Whamcloud - gitweb
LU-5587 lustre: require HAVE_SERVER_SUPPORT in md_object.h
[fs/lustre-release.git] / lustre / obdclass / class_obd.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) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2012, 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
37 #define DEBUG_SUBSYSTEM S_CLASS
38 #include <asm/atomic.h>
39
40 #include <obd_support.h>
41 #include <obd_class.h>
42 #include <lnet/lnetctl.h>
43 #include <lustre_debug.h>
44 #include <lprocfs_status.h>
45 #include <lustre/lustre_build_version.h>
46 #include <libcfs/list.h>
47 #include <cl_object.h>
48 #ifdef HAVE_SERVER_SUPPORT
49 # include <dt_object.h>
50 # include <md_object.h>
51 #endif /* HAVE_SERVER_SUPPORT */
52 #include <lustre_ioctl.h>
53 #include "llog_internal.h"
54
55
56 struct obd_device *obd_devs[MAX_OBD_DEVICES];
57 EXPORT_SYMBOL(obd_devs);
58 struct list_head obd_types;
59 DEFINE_RWLOCK(obd_dev_lock);
60
61 __u64 obd_max_pages = 0;
62 __u64 obd_max_alloc = 0;
63
64 static DEFINE_SPINLOCK(obd_updatemax_lock);
65
66 /* The following are visible and mutable through /proc/sys/lustre/. */
67 unsigned int obd_alloc_fail_rate = 0;
68 EXPORT_SYMBOL(obd_alloc_fail_rate);
69 unsigned int obd_debug_peer_on_timeout;
70 EXPORT_SYMBOL(obd_debug_peer_on_timeout);
71 unsigned int obd_dump_on_timeout;
72 EXPORT_SYMBOL(obd_dump_on_timeout);
73 unsigned int obd_dump_on_eviction;
74 EXPORT_SYMBOL(obd_dump_on_eviction);
75 unsigned long obd_max_dirty_pages;
76 EXPORT_SYMBOL(obd_max_dirty_pages);
77 atomic_long_t obd_dirty_pages;
78 EXPORT_SYMBOL(obd_dirty_pages);
79 unsigned int obd_timeout = OBD_TIMEOUT_DEFAULT;   /* seconds */
80 EXPORT_SYMBOL(obd_timeout);
81 unsigned int ldlm_timeout = LDLM_TIMEOUT_DEFAULT; /* seconds */
82 EXPORT_SYMBOL(ldlm_timeout);
83 unsigned int obd_timeout_set;
84 EXPORT_SYMBOL(obd_timeout_set);
85 unsigned int ldlm_timeout_set;
86 EXPORT_SYMBOL(ldlm_timeout_set);
87 /* bulk transfer timeout, give up after 100s by default */
88 unsigned int bulk_timeout = 100; /* seconds */
89 EXPORT_SYMBOL(bulk_timeout);
90 /* Adaptive timeout defs here instead of ptlrpc module for /proc/sys/ access */
91 unsigned int at_min = 0;
92 EXPORT_SYMBOL(at_min);
93 unsigned int at_max = 600;
94 EXPORT_SYMBOL(at_max);
95 unsigned int at_history = 600;
96 EXPORT_SYMBOL(at_history);
97 int at_early_margin = 5;
98 EXPORT_SYMBOL(at_early_margin);
99 int at_extra = 30;
100 EXPORT_SYMBOL(at_extra);
101
102 atomic_long_t obd_dirty_transit_pages;
103 EXPORT_SYMBOL(obd_dirty_transit_pages);
104
105 char obd_jobid_var[JOBSTATS_JOBID_VAR_MAX_LEN + 1] = JOBSTATS_DISABLE;
106 EXPORT_SYMBOL(obd_jobid_var);
107
108 #ifdef LPROCFS
109 struct lprocfs_stats *obd_memory = NULL;
110 EXPORT_SYMBOL(obd_memory);
111 #endif
112
113 /* Get jobid of current process by reading the environment variable
114  * stored in between the "env_start" & "env_end" of task struct.
115  *
116  * TODO:
117  * It's better to cache the jobid for later use if there is any
118  * efficient way, the cl_env code probably could be reused for this
119  * purpose.
120  *
121  * If some job scheduler doesn't store jobid in the "env_start/end",
122  * then an upcall could be issued here to get the jobid by utilizing
123  * the userspace tools/api. Then, the jobid must be cached.
124  */
125 int lustre_get_jobid(char *jobid)
126 {
127         int jobid_len = JOBSTATS_JOBID_SIZE;
128         int rc = 0;
129         ENTRY;
130
131         memset(jobid, 0, JOBSTATS_JOBID_SIZE);
132         /* Jobstats isn't enabled */
133         if (strcmp(obd_jobid_var, JOBSTATS_DISABLE) == 0)
134                 RETURN(0);
135
136         /* Use process name + fsuid as jobid */
137         if (strcmp(obd_jobid_var, JOBSTATS_PROCNAME_UID) == 0) {
138                 snprintf(jobid, JOBSTATS_JOBID_SIZE, "%s.%u",
139                          current_comm(),
140                          from_kuid(&init_user_ns, current_fsuid()));
141                 RETURN(0);
142         }
143
144         rc = cfs_get_environ(obd_jobid_var, jobid, &jobid_len);
145         if (rc) {
146                 if (rc == -EOVERFLOW) {
147                         /* For the PBS_JOBID and LOADL_STEP_ID keys (which are
148                          * variable length strings instead of just numbers), it
149                          * might make sense to keep the unique parts for JobID,
150                          * instead of just returning an error.  That means a
151                          * larger temp buffer for cfs_get_environ(), then
152                          * truncating the string at some separator to fit into
153                          * the specified jobid_len.  Fix later if needed. */
154                         static bool printed;
155                         if (unlikely(!printed)) {
156                                 LCONSOLE_ERROR_MSG(0x16b, "%s value too large "
157                                                    "for JobID buffer (%d)\n",
158                                                    obd_jobid_var, jobid_len);
159                                 printed = true;
160                         }
161                 } else {
162                         CDEBUG((rc == -ENOENT || rc == -EINVAL ||
163                                 rc == -EDEADLK) ? D_INFO : D_ERROR,
164                                "Get jobid for (%s) failed: rc = %d\n",
165                                obd_jobid_var, rc);
166                 }
167         }
168         RETURN(rc);
169 }
170 EXPORT_SYMBOL(lustre_get_jobid);
171
172 int obd_alloc_fail(const void *ptr, const char *name, const char *type,
173                    size_t size, const char *file, int line)
174 {
175         if (ptr == NULL ||
176             (cfs_rand() & OBD_ALLOC_FAIL_MASK) < obd_alloc_fail_rate) {
177                 CERROR("%s%salloc of %s ("LPU64" bytes) failed at %s:%d\n",
178                        ptr ? "force " :"", type, name, (__u64)size, file,
179                        line);
180                 CERROR(LPU64" total bytes and "LPU64" total pages "
181                        "("LPU64" bytes) allocated by Lustre, "
182                        "%d total bytes by LNET\n",
183                        obd_memory_sum(),
184                        obd_pages_sum() << PAGE_CACHE_SHIFT,
185                        obd_pages_sum(),
186                         atomic_read(&libcfs_kmemory));
187                 return 1;
188         }
189         return 0;
190 }
191 EXPORT_SYMBOL(obd_alloc_fail);
192
193 static int class_resolve_dev_name(__u32 len, const char *name)
194 {
195         int rc;
196         int dev;
197
198         ENTRY;
199         if (!len || !name) {
200                 CERROR("No name passed,!\n");
201                 GOTO(out, rc = -EINVAL);
202         }
203         if (name[len - 1] != 0) {
204                 CERROR("Name not nul terminated!\n");
205                 GOTO(out, rc = -EINVAL);
206         }
207
208         CDEBUG(D_IOCTL, "device name %s\n", name);
209         dev = class_name2dev(name);
210         if (dev == -1) {
211                 CDEBUG(D_IOCTL, "No device for name %s!\n", name);
212                 GOTO(out, rc = -EINVAL);
213         }
214
215         CDEBUG(D_IOCTL, "device name %s, dev %d\n", name, dev);
216         rc = dev;
217
218 out:
219         RETURN(rc);
220 }
221
222 int class_handle_ioctl(unsigned int cmd, unsigned long arg)
223 {
224         char *buf = NULL;
225         struct obd_ioctl_data *data;
226         struct libcfs_debug_ioctl_data *debug_data;
227         struct obd_device *obd = NULL;
228         int err = 0, len = 0;
229         ENTRY;
230
231         /* only for debugging */
232         if (cmd == LIBCFS_IOC_DEBUG_MASK) {
233                 debug_data = (struct libcfs_debug_ioctl_data*)arg;
234                 libcfs_subsystem_debug = debug_data->subs;
235                 libcfs_debug = debug_data->debug;
236                 return 0;
237         }
238
239         CDEBUG(D_IOCTL, "cmd = %x\n", cmd);
240         if (obd_ioctl_getdata(&buf, &len, (void __user *)arg)) {
241                 CERROR("OBD ioctl: data error\n");
242                 RETURN(-EINVAL);
243         }
244         data = (struct obd_ioctl_data *)buf;
245
246         switch (cmd) {
247         case OBD_IOC_PROCESS_CFG: {
248                 struct lustre_cfg *lcfg;
249
250                 if (!data->ioc_plen1 || !data->ioc_pbuf1) {
251                         CERROR("No config buffer passed!\n");
252                         GOTO(out, err = -EINVAL);
253                 }
254                 OBD_ALLOC(lcfg, data->ioc_plen1);
255                 if (lcfg == NULL)
256                         GOTO(out, err = -ENOMEM);
257                 err = copy_from_user(lcfg, data->ioc_pbuf1,
258                                          data->ioc_plen1);
259                 if (!err)
260                         err = lustre_cfg_sanity_check(lcfg, data->ioc_plen1);
261                 if (!err)
262                         err = class_process_config(lcfg);
263
264                 OBD_FREE(lcfg, data->ioc_plen1);
265                 GOTO(out, err);
266         }
267
268         case OBD_GET_VERSION:
269                 if (!data->ioc_inlbuf1) {
270                         CERROR("No buffer passed in ioctl\n");
271                         GOTO(out, err = -EINVAL);
272                 }
273
274                 if (strlen(BUILD_VERSION) + 1 > data->ioc_inllen1) {
275                         CERROR("ioctl buffer too small to hold version\n");
276                         GOTO(out, err = -EINVAL);
277                 }
278
279                 memcpy(data->ioc_bulk, BUILD_VERSION,
280                        strlen(BUILD_VERSION) + 1);
281
282                 err = obd_ioctl_popdata((void __user *)arg, data, len);
283                 if (err)
284                         err = -EFAULT;
285                 GOTO(out, err);
286
287         case OBD_IOC_NAME2DEV: {
288                 /* Resolve a device name.  This does not change the
289                  * currently selected device.
290                  */
291                 int dev;
292
293                 dev = class_resolve_dev_name(data->ioc_inllen1,
294                                              data->ioc_inlbuf1);
295                 data->ioc_dev = dev;
296                 if (dev < 0)
297                         GOTO(out, err = -EINVAL);
298
299                 err = obd_ioctl_popdata((void __user *)arg, data,
300                                         sizeof(*data));
301                 if (err)
302                         err = -EFAULT;
303                 GOTO(out, err);
304         }
305
306         case OBD_IOC_UUID2DEV: {
307                 /* Resolve a device uuid.  This does not change the
308                  * currently selected device.
309                  */
310                 int dev;
311                 struct obd_uuid uuid;
312
313                 if (!data->ioc_inllen1 || !data->ioc_inlbuf1) {
314                         CERROR("No UUID passed!\n");
315                         GOTO(out, err = -EINVAL);
316                 }
317                 if (data->ioc_inlbuf1[data->ioc_inllen1 - 1] != 0) {
318                         CERROR("UUID not NUL terminated!\n");
319                         GOTO(out, err = -EINVAL);
320                 }
321
322                 CDEBUG(D_IOCTL, "device name %s\n", data->ioc_inlbuf1);
323                 obd_str2uuid(&uuid, data->ioc_inlbuf1);
324                 dev = class_uuid2dev(&uuid);
325                 data->ioc_dev = dev;
326                 if (dev == -1) {
327                         CDEBUG(D_IOCTL, "No device for UUID %s!\n",
328                                data->ioc_inlbuf1);
329                         GOTO(out, err = -EINVAL);
330                 }
331
332                 CDEBUG(D_IOCTL, "device name %s, dev %d\n", data->ioc_inlbuf1,
333                        dev);
334                 err = obd_ioctl_popdata((void __user *)arg, data,
335                                         sizeof(*data));
336                 if (err)
337                         err = -EFAULT;
338                 GOTO(out, err);
339         }
340
341         case OBD_IOC_GETDEVICE: {
342                 int     index = data->ioc_count;
343                 char    *status, *str;
344
345                 if (!data->ioc_inlbuf1) {
346                         CERROR("No buffer passed in ioctl\n");
347                         GOTO(out, err = -EINVAL);
348                 }
349                 if (data->ioc_inllen1 < 128) {
350                         CERROR("ioctl buffer too small to hold version\n");
351                         GOTO(out, err = -EINVAL);
352                 }
353
354                 obd = class_num2obd(index);
355                 if (!obd)
356                         GOTO(out, err = -ENOENT);
357
358                 if (obd->obd_stopping)
359                         status = "ST";
360                 else if (obd->obd_set_up)
361                         status = "UP";
362                 else if (obd->obd_attached)
363                         status = "AT";
364                 else
365                         status = "--";
366                 str = (char *)data->ioc_bulk;
367                 snprintf(str, len - sizeof(*data), "%3d %s %s %s %s %d",
368                          (int)index, status, obd->obd_type->typ_name,
369                          obd->obd_name, obd->obd_uuid.uuid,
370                          atomic_read(&obd->obd_refcount));
371                 err = obd_ioctl_popdata((void __user *)arg, data, len);
372
373                 GOTO(out, err = 0);
374         }
375
376         }
377
378         if (data->ioc_dev == OBD_DEV_BY_DEVNAME) {
379                 if (data->ioc_inllen4 <= 0 || data->ioc_inlbuf4 == NULL)
380                         GOTO(out, err = -EINVAL);
381                 if (strnlen(data->ioc_inlbuf4, MAX_OBD_NAME) >= MAX_OBD_NAME)
382                         GOTO(out, err = -EINVAL);
383                 obd = class_name2obd(data->ioc_inlbuf4);
384         } else if (data->ioc_dev < class_devno_max()) {
385                 obd = class_num2obd(data->ioc_dev);
386         } else {
387                 CERROR("OBD ioctl: No device\n");
388                 GOTO(out, err = -EINVAL);
389         }
390
391         if (obd == NULL) {
392                 CERROR("OBD ioctl : No Device %d\n", data->ioc_dev);
393                 GOTO(out, err = -EINVAL);
394         }
395         LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
396
397         if (!obd->obd_set_up || obd->obd_stopping) {
398                 CERROR("OBD ioctl: device not setup %d \n", data->ioc_dev);
399                 GOTO(out, err = -EINVAL);
400         }
401
402         switch(cmd) {
403         case OBD_IOC_NO_TRANSNO: {
404                 if (!obd->obd_attached) {
405                         CERROR("Device %d not attached\n", obd->obd_minor);
406                         GOTO(out, err = -ENODEV);
407                 }
408                 CDEBUG(D_HA, "%s: disabling committed-transno notification\n",
409                        obd->obd_name);
410                 obd->obd_no_transno = 1;
411                 GOTO(out, err = 0);
412         }
413
414         default: {
415                 err = obd_iocontrol(cmd, obd->obd_self_export, len, data, NULL);
416                 if (err)
417                         GOTO(out, err);
418
419                 err = obd_ioctl_popdata((void __user *)arg, data, len);
420                 if (err)
421                         err = -EFAULT;
422                 GOTO(out, err);
423         }
424         }
425
426  out:
427         if (buf)
428                 obd_ioctl_freedata(buf, len);
429         RETURN(err);
430 } /* class_handle_ioctl */
431
432 extern struct miscdevice obd_psdev;
433
434 #define OBD_INIT_CHECK
435 #ifdef OBD_INIT_CHECK
436 static int obd_init_checks(void)
437 {
438         __u64 u64val, div64val;
439         char buf[64];
440         int len, ret = 0;
441
442         CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s\n", LPU64, LPD64, LPX64);
443
444         CDEBUG(D_INFO, "OBD_OBJECT_EOF = "LPX64"\n", (__u64)OBD_OBJECT_EOF);
445
446         u64val = OBD_OBJECT_EOF;
447         CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val);
448         if (u64val != OBD_OBJECT_EOF) {
449                 CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
450                        u64val, (int)sizeof(u64val));
451                 ret = -EINVAL;
452         }
453         len = snprintf(buf, sizeof(buf), LPX64, u64val);
454         if (len != 18) {
455                 CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
456                 ret = -EINVAL;
457         }
458
459         div64val = OBD_OBJECT_EOF;
460         CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val);
461         if (u64val != OBD_OBJECT_EOF) {
462                 CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
463                        u64val, (int)sizeof(u64val));
464                 ret = -EOVERFLOW;
465         }
466         if (u64val >> 8 != OBD_OBJECT_EOF >> 8) {
467                 CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
468                        u64val, (int)sizeof(u64val));
469                 return -EOVERFLOW;
470         }
471         if (do_div(div64val, 256) != (u64val & 255)) {
472                 CERROR("do_div("LPX64",256) != "LPU64"\n", u64val, u64val &255);
473                 return -EOVERFLOW;
474         }
475         if (u64val >> 8 != div64val) {
476                 CERROR("do_div("LPX64",256) "LPU64" != "LPU64"\n",
477                        u64val, div64val, u64val >> 8);
478                 return -EOVERFLOW;
479         }
480         len = snprintf(buf, sizeof(buf), LPX64, u64val);
481         if (len != 18) {
482                 CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
483                 ret = -EINVAL;
484         }
485         len = snprintf(buf, sizeof(buf), LPU64, u64val);
486         if (len != 20) {
487                 CWARN("LPU64 wrong length! strlen(%s)=%d != 20\n", buf, len);
488                 ret = -EINVAL;
489         }
490         len = snprintf(buf, sizeof(buf), LPD64, u64val);
491         if (len != 2) {
492                 CWARN("LPD64 wrong length! strlen(%s)=%d != 2\n", buf, len);
493                 ret = -EINVAL;
494         }
495         if ((u64val & ~CFS_PAGE_MASK) >= PAGE_CACHE_SIZE) {
496                 CWARN("mask failed: u64val "LPU64" >= "LPU64"\n", u64val,
497                       (__u64)PAGE_CACHE_SIZE);
498                 ret = -EINVAL;
499         }
500
501         return ret;
502 }
503 #else
504 #define obd_init_checks() do {} while(0)
505 #endif
506
507 extern int class_procfs_init(void);
508 extern int class_procfs_clean(void);
509
510 static int __init init_obdclass(void)
511 {
512         int i, err;
513         int lustre_register_fs(void);
514
515         for (i = CAPA_SITE_CLIENT; i < CAPA_SITE_MAX; i++)
516                 INIT_LIST_HEAD(&capa_list[i]);
517
518         LCONSOLE_INFO("Lustre: Build Version: "BUILD_VERSION"\n");
519
520         spin_lock_init(&obd_types_lock);
521         obd_zombie_impexp_init();
522 #ifdef LPROCFS
523         obd_memory = lprocfs_alloc_stats(OBD_STATS_NUM,
524                                          LPROCFS_STATS_FLAG_NONE |
525                                          LPROCFS_STATS_FLAG_IRQ_SAFE);
526         if (obd_memory == NULL) {
527                 CERROR("kmalloc of 'obd_memory' failed\n");
528                 RETURN(-ENOMEM);
529         }
530
531         lprocfs_counter_init(obd_memory, OBD_MEMORY_STAT,
532                              LPROCFS_CNTR_AVGMINMAX,
533                              "memused", "bytes");
534         lprocfs_counter_init(obd_memory, OBD_MEMORY_PAGES_STAT,
535                              LPROCFS_CNTR_AVGMINMAX,
536                              "pagesused", "pages");
537 #endif
538         err = obd_init_checks();
539         if (err == -EOVERFLOW)
540                 return err;
541
542         class_init_uuidlist();
543         err = class_handle_init();
544         if (err)
545                 return err;
546
547         INIT_LIST_HEAD(&obd_types);
548
549         err = misc_register(&obd_psdev);
550         if (err) {
551                 CERROR("cannot register %d err %d\n", OBD_DEV_MINOR, err);
552                 return err;
553         }
554
555         /* This struct is already zeroed for us (static global) */
556         for (i = 0; i < class_devno_max(); i++)
557                 obd_devs[i] = NULL;
558
559         /* Default the dirty page cache cap to 1/2 of system memory.
560          * For clients with less memory, a larger fraction is needed
561          * for other purposes (mostly for BGL). */
562         if (totalram_pages <= 512 << (20 - PAGE_CACHE_SHIFT))
563                 obd_max_dirty_pages = totalram_pages / 4;
564         else
565                 obd_max_dirty_pages = totalram_pages / 2;
566
567         err = obd_init_caches();
568         if (err)
569                 return err;
570         err = class_procfs_init();
571         if (err)
572                 return err;
573
574         err = lu_global_init();
575         if (err)
576                 return err;
577
578         err = lu_capainfo_init();
579         if (err)
580                 return err;
581
582         err = cl_global_init();
583         if (err != 0)
584                 return err;
585
586 #ifdef HAVE_SERVER_SUPPORT
587         err = dt_global_init();
588         if (err != 0)
589                 return err;
590
591         err = lu_ucred_global_init();
592         if (err != 0)
593                 return err;
594 #endif /* HAVE_SERVER_SUPPORT */
595
596         err = llog_info_init();
597         if (err)
598                 return err;
599
600         err = lustre_register_fs();
601
602         return err;
603 }
604
605 void obd_update_maxusage(void)
606 {
607         __u64 max1, max2;
608
609         max1 = obd_pages_sum();
610         max2 = obd_memory_sum();
611
612         spin_lock(&obd_updatemax_lock);
613         if (max1 > obd_max_pages)
614                 obd_max_pages = max1;
615         if (max2 > obd_max_alloc)
616                 obd_max_alloc = max2;
617         spin_unlock(&obd_updatemax_lock);
618 }
619 EXPORT_SYMBOL(obd_update_maxusage);
620
621 #ifdef LPROCFS
622 __u64 obd_memory_max(void)
623 {
624         __u64 ret;
625
626         spin_lock(&obd_updatemax_lock);
627         ret = obd_max_alloc;
628         spin_unlock(&obd_updatemax_lock);
629
630         return ret;
631 }
632 EXPORT_SYMBOL(obd_memory_max);
633
634 __u64 obd_pages_max(void)
635 {
636         __u64 ret;
637
638         spin_lock(&obd_updatemax_lock);
639         ret = obd_max_pages;
640         spin_unlock(&obd_updatemax_lock);
641
642         return ret;
643 }
644 EXPORT_SYMBOL(obd_pages_max);
645 #endif /* LPROCFS */
646
647 /* liblustre doesn't call cleanup_obdclass, apparently.  we carry on in this
648  * ifdef to the end of the file to cover module and versioning goo.*/
649 static void cleanup_obdclass(void)
650 {
651         int lustre_unregister_fs(void);
652         __u64 memory_leaked, pages_leaked;
653         __u64 memory_max, pages_max;
654         ENTRY;
655
656         lustre_unregister_fs();
657
658         misc_deregister(&obd_psdev);
659         llog_info_fini();
660 #ifdef HAVE_SERVER_SUPPORT
661         lu_ucred_global_fini();
662         dt_global_fini();
663 #endif /* HAVE_SERVER_SUPPORT */
664         cl_global_fini();
665         lu_capainfo_fini();
666         lu_global_fini();
667
668         obd_cleanup_caches();
669         obd_sysctl_clean();
670
671         class_procfs_clean();
672
673         class_handle_cleanup();
674         class_exit_uuidlist();
675         obd_zombie_impexp_stop();
676
677         memory_leaked = obd_memory_sum();
678         pages_leaked = obd_pages_sum();
679
680         memory_max = obd_memory_max();
681         pages_max = obd_pages_max();
682
683         lprocfs_free_stats(&obd_memory);
684         CDEBUG((memory_leaked) ? D_ERROR : D_INFO,
685                "obd_memory max: "LPU64", leaked: "LPU64"\n",
686                memory_max, memory_leaked);
687         CDEBUG((pages_leaked) ? D_ERROR : D_INFO,
688                "obd_memory_pages max: "LPU64", leaked: "LPU64"\n",
689                pages_max, pages_leaked);
690
691         EXIT;
692 }
693
694 MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
695 MODULE_DESCRIPTION("Lustre Class Driver Build Version: " BUILD_VERSION);
696 MODULE_LICENSE("GPL");
697
698 cfs_module(obdclass, LUSTRE_VERSION_STRING, init_obdclass, cleanup_obdclass);