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