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