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