Whamcloud - gitweb
LU-6142 obdclass: resolve lu_ref checkpatch issues
[fs/lustre-release.git] / 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 */