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