lustre/obdclass/lu_ref.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * GPL HEADER START
   4  *
   5  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 only,
   9  * as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License version 2 for more details (a copy is included
  15  * in the LICENSE file that accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * version 2 along with this program; If not, see
  19  * http://www.gnu.org/licenses/gpl-2.0.html
  20  *
  21  * GPL HEADER END
  22  */
  23 /*
  24  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  25  * Use is subject to license terms.
  26  *
  27  * Copyright (c) 2012, 2017, Intel Corporation.
  28  */
  29 /*
  30  * This file is part of Lustre, http://www.lustre.org/
  31  *
  32  * lustre/obdclass/lu_ref.c
  33  *
  34  * Lustre reference.
  35  *
  36  *   Author: Nikita Danilov <nikita.danilov@sun.com>
  37  */
  38
  39 #define DEBUG_SUBSYSTEM S_CLASS
  40
  41 #include <obd.h>
  42 #include <obd_class.h>
  43 #include <obd_support.h>
  44 #include <lu_ref.h>
  45
  46 #ifdef CONFIG_LUSTRE_DEBUG_LU_REF
  47 /**
  48  * Asserts a condition for a given lu_ref. Must be called with
  49  * lu_ref::lf_guard held.
  50  */
  51 #define REFASSERT(ref, expr) do {                                       \
  52         struct lu_ref *__tmp = (ref);                                   \
  53                                                                         \
  54         if (unlikely(!(expr))) {                                        \
  55                 lu_ref_print(__tmp);                                    \
  56                 spin_unlock(&__tmp->lf_guard);                          \
  57                 lu_ref_print_all();                                     \
  58                 LASSERT(0);                                             \
  59                 spin_lock(&__tmp->lf_guard);                            \
  60         }                                                               \
  61 } while (0)
  62
  63 static struct kmem_cache *lu_ref_link_kmem;
  64
  65 static struct lu_kmem_descr lu_ref_caches[] = {
  66         {
  67                 .ckd_cache = &lu_ref_link_kmem,
  68                 .ckd_name  = "lu_ref_link_kmem",
  69                 .ckd_size  = sizeof(struct lu_ref_link)
  70         },
  71         {
  72                 .ckd_cache = NULL
  73         }
  74 };
  75
  76 /**
  77  * Global list of active (initialized, but not finalized) lu_ref's.
  78  *
  79  * Protected by lu_ref_refs_guard.
  80  */
  81 static LIST_HEAD(lu_ref_refs);
  82 static DEFINE_SPINLOCK(lu_ref_refs_guard);
  83 static struct lu_ref lu_ref_marker = {
  84         .lf_guard       = __SPIN_LOCK_UNLOCKED(lu_ref_marker.lf_guard),
  85         .lf_list        = LIST_HEAD_INIT(lu_ref_marker.lf_list),
  86         .lf_linkage     = LIST_HEAD_INIT(lu_ref_marker.lf_linkage)
  87 };
  88
  89 void lu_ref_print(const struct lu_ref *ref)
  90 {
  91         struct lu_ref_link *link;
  92
  93         CERROR("lu_ref: %p %d %d %s:%d\n",
  94                ref, ref->lf_refs, ref->lf_failed, ref->lf_func, ref->lf_line);
  95         list_for_each_entry(link, &ref->lf_list, ll_linkage) {
  96                 CERROR("     link: %s %p\n", link->ll_scope, link->ll_source);
  97         }
  98 }
  99
 100 static int lu_ref_is_marker(const struct lu_ref *ref)
 101 {
 102         return ref == &lu_ref_marker;
 103 }
 104
 105 void lu_ref_print_all(void)
 106 {
 107         struct lu_ref *ref;
 108
 109         spin_lock(&lu_ref_refs_guard);
 110         list_for_each_entry(ref, &lu_ref_refs, lf_linkage) {
 111                 if (lu_ref_is_marker(ref))
 112                         continue;
 113
 114                 spin_lock(&ref->lf_guard);
 115                 lu_ref_print(ref);
 116                 spin_unlock(&ref->lf_guard);
 117         }
 118         spin_unlock(&lu_ref_refs_guard);
 119 }
 120
 121 void lu_ref_init_loc(struct lu_ref *ref, const char *func, const int line)
 122 {
 123         ref->lf_refs = 0;
 124         ref->lf_func = func;
 125         ref->lf_line = line;
 126         spin_lock_init(&ref->lf_guard);
 127         INIT_LIST_HEAD(&ref->lf_list);
 128         spin_lock(&lu_ref_refs_guard);
 129         list_add(&ref->lf_linkage, &lu_ref_refs);
 130         spin_unlock(&lu_ref_refs_guard);
 131 }
 132 EXPORT_SYMBOL(lu_ref_init_loc);
 133
 134 void lu_ref_fini(struct lu_ref *ref)
 135 {
 136         spin_lock(&ref->lf_guard);
 137         REFASSERT(ref, list_empty(&ref->lf_list));
 138         REFASSERT(ref, ref->lf_refs == 0);
 139         spin_unlock(&ref->lf_guard);
 140         spin_lock(&lu_ref_refs_guard);
 141         list_del_init(&ref->lf_linkage);
 142         spin_unlock(&lu_ref_refs_guard);
 143 }
 144 EXPORT_SYMBOL(lu_ref_fini);
 145
 146 static struct lu_ref_link *lu_ref_add_context(struct lu_ref *ref,
 147                                               int flags,
 148                                               const char *scope,
 149                                               const void *source)
 150 {
 151         struct lu_ref_link *link;
 152
 153         link = NULL;
 154         if (lu_ref_link_kmem) {
 155                 OBD_SLAB_ALLOC_PTR_GFP(link, lu_ref_link_kmem, flags);
 156                 if (link) {
 157                         link->ll_ref = ref;
 158                         link->ll_scope = scope;
 159                         link->ll_source = source;
 160                         spin_lock(&ref->lf_guard);
 161                         list_add_tail(&link->ll_linkage, &ref->lf_list);
 162                         ref->lf_refs++;
 163                         spin_unlock(&ref->lf_guard);
 164                 }
 165         }
 166
 167         if (!link) {
 168                 spin_lock(&ref->lf_guard);
 169                 ref->lf_failed++;
 170                 spin_unlock(&ref->lf_guard);
 171                 link = ERR_PTR(-ENOMEM);
 172         }
 173
 174         return link;
 175 }
 176
 177 void lu_ref_add(struct lu_ref *ref, const char *scope, const void *source)
 178 {
 179         might_sleep();
 180         lu_ref_add_context(ref, GFP_NOFS, scope, source);
 181 }
 182 EXPORT_SYMBOL(lu_ref_add);
 183
 184 void lu_ref_add_at(struct lu_ref *ref, struct lu_ref_link *link,
 185                    const char *scope, const void *source)
 186 {
 187         link->ll_ref = ref;
 188         link->ll_scope = scope;
 189         link->ll_source = source;
 190         spin_lock(&ref->lf_guard);
 191         list_add_tail(&link->ll_linkage, &ref->lf_list);
 192         ref->lf_refs++;
 193         spin_unlock(&ref->lf_guard);
 194 }
 195 EXPORT_SYMBOL(lu_ref_add_at);
 196
 197 /**
 198  * Version of lu_ref_add() to be used in non-blockable contexts.
 199  */
 200 void lu_ref_add_atomic(struct lu_ref *ref, const char *scope,
 201                        const void *source)
 202 {
 203         lu_ref_add_context(ref, GFP_ATOMIC, scope, source);
 204 }
 205 EXPORT_SYMBOL(lu_ref_add_atomic);
 206
 207 static inline int lu_ref_link_eq(const struct lu_ref_link *link,
 208                                  const char *scope,
 209                                  const void *source)
 210 {
 211         return link->ll_source == source && !strcmp(link->ll_scope, scope);
 212 }
 213
 214 /**
 215  * Maximal chain length seen so far.
 216  */
 217 static unsigned int lu_ref_chain_max_length = 127;
 218
 219 /**
 220  * Searches for a lu_ref_link with given [scope, source] within given lu_ref.
 221  */
 222 static struct lu_ref_link *lu_ref_find(struct lu_ref *ref, const char *scope,
 223                                        const void *source)
 224 {
 225         struct lu_ref_link *link;
 226         unsigned int iterations;
 227
 228         iterations = 0;
 229         list_for_each_entry(link, &ref->lf_list, ll_linkage) {
 230                 ++iterations;
 231                 if (lu_ref_link_eq(link, scope, source)) {
 232                         if (iterations > lu_ref_chain_max_length) {
 233                                 CWARN("Long lu_ref chain %d \"%s\":%p\n",
 234                                       iterations, scope, source);
 235                                 lu_ref_chain_max_length = iterations * 3 / 2;
 236                         }
 237                         return link;
 238                 }
 239         }
 240         return NULL;
 241 }
 242
 243 void lu_ref_del(struct lu_ref *ref, const char *scope, const void *source)
 244 {
 245         struct lu_ref_link *link;
 246
 247         spin_lock(&ref->lf_guard);
 248         link = lu_ref_find(ref, scope, source);
 249         if (link) {
 250                 list_del(&link->ll_linkage);
 251                 ref->lf_refs--;
 252                 spin_unlock(&ref->lf_guard);
 253                 OBD_SLAB_FREE(link, lu_ref_link_kmem, sizeof(*link));
 254         } else {
 255                 REFASSERT(ref, ref->lf_failed > 0);
 256                 ref->lf_failed--;
 257                 spin_unlock(&ref->lf_guard);
 258         }
 259 }
 260 EXPORT_SYMBOL(lu_ref_del);
 261
 262 void lu_ref_set_at(struct lu_ref *ref, struct lu_ref_link *link,
 263                    const char *scope,
 264                    const void *source0, const void *source1)
 265 {
 266         spin_lock(&ref->lf_guard);
 267         REFASSERT(ref, !IS_ERR_OR_NULL(link));
 268         REFASSERT(ref, link->ll_ref == ref);
 269         REFASSERT(ref, lu_ref_link_eq(link, scope, source0));
 270         link->ll_source = source1;
 271         spin_unlock(&ref->lf_guard);
 272 }
 273 EXPORT_SYMBOL(lu_ref_set_at);
 274
 275 void lu_ref_del_at(struct lu_ref *ref, struct lu_ref_link *link,
 276                    const char *scope, const void *source)
 277 {
 278         spin_lock(&ref->lf_guard);
 279         REFASSERT(ref, !IS_ERR_OR_NULL(link));
 280         REFASSERT(ref, link->ll_ref == ref);
 281         REFASSERT(ref, lu_ref_link_eq(link, scope, source));
 282         list_del(&link->ll_linkage);
 283         ref->lf_refs--;
 284         spin_unlock(&ref->lf_guard);
 285 }
 286 EXPORT_SYMBOL(lu_ref_del_at);
 287
 288 #ifdef CONFIG_PROC_FS
 289
 290 static void *lu_ref_seq_start(struct seq_file *seq, loff_t *pos)
 291 {
 292         struct lu_ref *ref = seq->private;
 293
 294         spin_lock(&lu_ref_refs_guard);
 295         if (list_empty(&ref->lf_linkage))
 296                 ref = NULL;
 297         spin_unlock(&lu_ref_refs_guard);
 298
 299         return ref;
 300 }
 301
 302 static void *lu_ref_seq_next(struct seq_file *seq, void *p, loff_t *pos)
 303 {
 304         struct lu_ref *ref = p;
 305         struct lu_ref *next;
 306
 307         LASSERT(seq->private == p);
 308         LASSERT(!list_empty(&ref->lf_linkage));
 309
 310         (*pos)++;
 311         spin_lock(&lu_ref_refs_guard);
 312         next = list_entry(ref->lf_linkage.next, struct lu_ref, lf_linkage);
 313         if (&next->lf_linkage == &lu_ref_refs)
 314                 p = NULL;
 315         else
 316                 list_move(&ref->lf_linkage, &next->lf_linkage);
 317         spin_unlock(&lu_ref_refs_guard);
 318
 319         return p;
 320 }
 321
 322 static void lu_ref_seq_stop(struct seq_file *seq, void *p)
 323 {
 324         /* Nothing to do */
 325 }
 326
 327
 328 static int lu_ref_seq_show(struct seq_file *seq, void *p)
 329 {
 330         struct lu_ref *ref  = p;
 331         struct lu_ref *next;
 332
 333         spin_lock(&lu_ref_refs_guard);
 334         next = list_entry(ref->lf_linkage.next, struct lu_ref, lf_linkage);
 335         if ((&next->lf_linkage == &lu_ref_refs) || lu_ref_is_marker(next)) {
 336                 spin_unlock(&lu_ref_refs_guard);
 337                 return 0;
 338         }
 339
 340         /* print the entry */
 341         spin_lock(&next->lf_guard);
 342         seq_printf(seq, "lu_ref: %p %d %d %s:%d\n",
 343                    next, next->lf_refs, next->lf_failed,
 344                    next->lf_func, next->lf_line);
 345         if (next->lf_refs > 64) {
 346                 seq_puts(seq, "  too many references, skip\n");
 347         } else {
 348                 struct lu_ref_link *link;
 349                 int i = 0;
 350
 351                 list_for_each_entry(link, &next->lf_list, ll_linkage)
 352                         seq_printf(seq, "  #%d link: %s %p\n",
 353                                    i++, link->ll_scope, link->ll_source);
 354         }
 355         spin_unlock(&next->lf_guard);
 356         spin_unlock(&lu_ref_refs_guard);
 357
 358         return 0;
 359 }
 360
 361 static const struct seq_operations lu_ref_seq_ops = {
 362         .start  = lu_ref_seq_start,
 363         .stop   = lu_ref_seq_stop,
 364         .next   = lu_ref_seq_next,
 365         .show   = lu_ref_seq_show
 366 };
 367
 368 static int lu_ref_seq_open(struct inode *inode, struct file *file)
 369 {
 370         struct lu_ref *marker = &lu_ref_marker;
 371         int result = 0;
 372
 373         result = seq_open(file, &lu_ref_seq_ops);
 374         if (result == 0) {
 375                 spin_lock(&lu_ref_refs_guard);
 376                 if (!list_empty(&marker->lf_linkage))
 377                         result = -EAGAIN;
 378                 else
 379                         list_add(&marker->lf_linkage, &lu_ref_refs);
 380                 spin_unlock(&lu_ref_refs_guard);
 381
 382                 if (result == 0) {
 383                         struct seq_file *f = file->private_data;
 384
 385                         f->private = marker;
 386                 } else {
 387                         seq_release(inode, file);
 388                 }
 389         }
 390
 391         return result;
 392 }
 393
 394 static int lu_ref_seq_release(struct inode *inode, struct file *file)
 395 {
 396         struct seq_file *m = file->private_data;
 397         struct lu_ref *ref = m->private;
 398
 399         spin_lock(&lu_ref_refs_guard);
 400         list_del_init(&ref->lf_linkage);
 401         spin_unlock(&lu_ref_refs_guard);
 402
 403         return seq_release(inode, file);
 404 }
 405
 406 static const struct file_operations lu_ref_dump_fops = {
 407         .owner          = THIS_MODULE,
 408         .open           = lu_ref_seq_open,
 409         .read           = seq_read,
 410         .llseek         = seq_lseek,
 411         .release        = lu_ref_seq_release
 412 };
 413
 414 #endif /* CONFIG_PROC_FS */
 415
 416 int lu_ref_global_init(void)
 417 {
 418         int result;
 419
 420         CDEBUG(D_CONSOLE,
 421                "lu_ref tracking is enabled. Performance isn't.\n");
 422
 423         result = lu_kmem_init(lu_ref_caches);
 424
 425 #ifdef CONFIG_PROC_FS
 426         if (result == 0) {
 427                 result = lprocfs_seq_create(proc_lustre_root, "lu_refs",
 428                                             0444, &lu_ref_dump_fops, NULL);
 429                 if (result)
 430                         lu_kmem_fini(lu_ref_caches);
 431         }
 432 #endif /* CONFIG_PROC_FS */
 433
 434         return result;
 435 }
 436
 437 void lu_ref_global_fini(void)
 438 {
 439 #ifdef CONFIG_PROC_FS
 440         lprocfs_remove_proc_entry("lu_refs", proc_lustre_root);
 441 #endif /* CONFIG_PROC_FS */
 442         lu_kmem_fini(lu_ref_caches);
 443 }
 444
 445 #endif /* CONFIG_LUSTRE_DEBUG_LU_REF */