4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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).
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
23 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2011, 2015, Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
30 * Lustre is a trademark of Sun Microsystems, Inc.
33 #define DEBUG_SUBSYSTEM S_CLASS
35 #include <linux/user_namespace.h>
36 #ifdef HAVE_UIDGID_HEADER
37 # include <linux/uidgid.h>
39 #include <linux/atomic.h>
40 #include <linux/list.h>
42 #include <obd_support.h>
43 #include <obd_class.h>
44 #include <uapi/linux/lnet/lnetctl.h>
45 #include <lustre_debug.h>
46 #include <lustre_kernelcomm.h>
47 #include <lprocfs_status.h>
48 #include <cl_object.h>
49 #ifdef HAVE_SERVER_SUPPORT
50 # include <dt_object.h>
51 # include <md_object.h>
52 #endif /* HAVE_SERVER_SUPPORT */
53 #include <uapi/linux/lustre/lustre_ioctl.h>
54 #include "llog_internal.h"
57 static __u64 obd_max_alloc;
62 static DEFINE_SPINLOCK(obd_updatemax_lock);
64 /* The following are visible and mutable through /proc/sys/lustre/. */
65 unsigned int obd_debug_peer_on_timeout;
66 EXPORT_SYMBOL(obd_debug_peer_on_timeout);
67 unsigned int obd_dump_on_timeout;
68 EXPORT_SYMBOL(obd_dump_on_timeout);
69 unsigned int obd_dump_on_eviction;
70 EXPORT_SYMBOL(obd_dump_on_eviction);
71 unsigned long obd_max_dirty_pages;
72 EXPORT_SYMBOL(obd_max_dirty_pages);
73 atomic_long_t obd_dirty_pages;
74 EXPORT_SYMBOL(obd_dirty_pages);
75 unsigned int obd_timeout = OBD_TIMEOUT_DEFAULT; /* seconds */
76 EXPORT_SYMBOL(obd_timeout);
77 unsigned int ldlm_timeout = LDLM_TIMEOUT_DEFAULT; /* seconds */
78 EXPORT_SYMBOL(ldlm_timeout);
79 unsigned int obd_timeout_set;
80 EXPORT_SYMBOL(obd_timeout_set);
81 unsigned int ldlm_timeout_set;
82 EXPORT_SYMBOL(ldlm_timeout_set);
83 /* bulk transfer timeout, give up after 100s by default */
84 unsigned int bulk_timeout = 100; /* seconds */
85 EXPORT_SYMBOL(bulk_timeout);
86 /* Adaptive timeout defs here instead of ptlrpc module for /proc/sys/ access */
87 unsigned int at_min = 0;
88 EXPORT_SYMBOL(at_min);
89 unsigned int at_max = 600;
90 EXPORT_SYMBOL(at_max);
91 unsigned int at_history = 600;
92 EXPORT_SYMBOL(at_history);
93 int at_early_margin = 5;
94 EXPORT_SYMBOL(at_early_margin);
96 EXPORT_SYMBOL(at_extra);
98 atomic_long_t obd_dirty_transit_pages;
99 EXPORT_SYMBOL(obd_dirty_transit_pages);
101 #ifdef CONFIG_PROC_FS
102 struct lprocfs_stats *obd_memory = NULL;
103 EXPORT_SYMBOL(obd_memory);
106 static int class_resolve_dev_name(__u32 len, const char *name)
113 CERROR("No name passed,!\n");
114 GOTO(out, rc = -EINVAL);
116 if (name[len - 1] != 0) {
117 CERROR("Name not nul terminated!\n");
118 GOTO(out, rc = -EINVAL);
121 CDEBUG(D_IOCTL, "device name %s\n", name);
122 dev = class_name2dev(name);
124 CDEBUG(D_IOCTL, "No device for name %s!\n", name);
125 GOTO(out, rc = -EINVAL);
128 CDEBUG(D_IOCTL, "device name %s, dev %d\n", name, dev);
135 int class_handle_ioctl(unsigned int cmd, unsigned long arg)
138 struct obd_ioctl_data *data;
139 struct libcfs_debug_ioctl_data *debug_data;
140 struct obd_device *obd = NULL;
141 int err = 0, len = 0;
144 /* only for debugging */
145 if (cmd == LIBCFS_IOC_DEBUG_MASK) {
146 debug_data = (struct libcfs_debug_ioctl_data*)arg;
147 libcfs_subsystem_debug = debug_data->subs;
148 libcfs_debug = debug_data->debug;
152 CDEBUG(D_IOCTL, "cmd = %x\n", cmd);
153 if (obd_ioctl_getdata(&buf, &len, (void __user *)arg)) {
154 CERROR("OBD ioctl: data error\n");
157 data = (struct obd_ioctl_data *)buf;
160 case OBD_IOC_PROCESS_CFG: {
161 struct lustre_cfg *lcfg;
163 if (!data->ioc_plen1 || !data->ioc_pbuf1) {
164 CERROR("No config buffer passed!\n");
165 GOTO(out, err = -EINVAL);
167 OBD_ALLOC(lcfg, data->ioc_plen1);
169 GOTO(out, err = -ENOMEM);
170 err = copy_from_user(lcfg, data->ioc_pbuf1,
173 err = lustre_cfg_sanity_check(lcfg, data->ioc_plen1);
175 err = class_process_config(lcfg);
177 OBD_FREE(lcfg, data->ioc_plen1);
181 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 53, 0)
182 case OBD_GET_VERSION: {
185 if (!data->ioc_inlbuf1) {
186 CERROR("No buffer passed in ioctl\n");
187 GOTO(out, err = -EINVAL);
190 if (strlen(LUSTRE_VERSION_STRING) + 1 > data->ioc_inllen1) {
191 CERROR("ioctl buffer too small to hold version\n");
192 GOTO(out, err = -EINVAL);
197 CWARN("%s: ioctl(OBD_GET_VERSION) is deprecated, "
198 "use llapi_get_version_string() and/or relink\n",
201 memcpy(data->ioc_bulk, LUSTRE_VERSION_STRING,
202 strlen(LUSTRE_VERSION_STRING) + 1);
204 if (copy_to_user((void __user *)arg, data, len))
209 case OBD_IOC_NAME2DEV: {
210 /* Resolve a device name. This does not change the
211 * currently selected device.
215 dev = class_resolve_dev_name(data->ioc_inllen1,
219 GOTO(out, err = -EINVAL);
221 if (copy_to_user((void __user *)arg, data, sizeof(*data)))
226 case OBD_IOC_UUID2DEV: {
227 /* Resolve a device uuid. This does not change the
228 * currently selected device.
231 struct obd_uuid uuid;
233 if (!data->ioc_inllen1 || !data->ioc_inlbuf1) {
234 CERROR("No UUID passed!\n");
235 GOTO(out, err = -EINVAL);
237 if (data->ioc_inlbuf1[data->ioc_inllen1 - 1] != 0) {
238 CERROR("UUID not NUL terminated!\n");
239 GOTO(out, err = -EINVAL);
242 CDEBUG(D_IOCTL, "device name %s\n", data->ioc_inlbuf1);
243 obd_str2uuid(&uuid, data->ioc_inlbuf1);
244 dev = class_uuid2dev(&uuid);
247 CDEBUG(D_IOCTL, "No device for UUID %s!\n",
249 GOTO(out, err = -EINVAL);
252 CDEBUG(D_IOCTL, "device name %s, dev %d\n", data->ioc_inlbuf1,
254 if (copy_to_user((void __user *)arg, data, sizeof(*data)))
259 case OBD_IOC_GETDEVICE: {
260 int index = data->ioc_count;
263 if (!data->ioc_inlbuf1) {
264 CERROR("No buffer passed in ioctl\n");
265 GOTO(out, err = -EINVAL);
267 if (data->ioc_inllen1 < 128) {
268 CERROR("ioctl buffer too small to hold version\n");
269 GOTO(out, err = -EINVAL);
272 obd = class_num2obd(index);
274 GOTO(out, err = -ENOENT);
276 if (obd->obd_stopping)
278 else if (obd->obd_set_up)
280 else if (obd->obd_attached)
284 str = (char *)data->ioc_bulk;
285 snprintf(str, len - sizeof(*data), "%3d %s %s %s %s %d",
286 (int)index, status, obd->obd_type->typ_name,
287 obd->obd_name, obd->obd_uuid.uuid,
288 atomic_read(&obd->obd_refcount));
290 if (copy_to_user((void __user *)arg, data, len))
298 if (data->ioc_dev == OBD_DEV_BY_DEVNAME) {
299 if (data->ioc_inllen4 <= 0 || data->ioc_inlbuf4 == NULL)
300 GOTO(out, err = -EINVAL);
301 if (strnlen(data->ioc_inlbuf4, MAX_OBD_NAME) >= MAX_OBD_NAME)
302 GOTO(out, err = -EINVAL);
303 obd = class_name2obd(data->ioc_inlbuf4);
304 } else if (data->ioc_dev < class_devno_max()) {
305 obd = class_num2obd(data->ioc_dev);
307 CERROR("OBD ioctl: No device\n");
308 GOTO(out, err = -EINVAL);
312 CERROR("OBD ioctl : No Device %d\n", data->ioc_dev);
313 GOTO(out, err = -EINVAL);
315 LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
317 if (!obd->obd_set_up || obd->obd_stopping) {
318 CERROR("OBD ioctl: device not setup %d \n", data->ioc_dev);
319 GOTO(out, err = -EINVAL);
323 case OBD_IOC_NO_TRANSNO: {
324 if (!obd->obd_attached) {
325 CERROR("Device %d not attached\n", obd->obd_minor);
326 GOTO(out, err = -ENODEV);
328 CDEBUG(D_HA, "%s: disabling committed-transno notification\n",
330 obd->obd_no_transno = 1;
335 err = obd_iocontrol(cmd, obd->obd_self_export, len, data, NULL);
339 if (copy_to_user((void __user *)arg, data, len))
346 OBD_FREE_LARGE(buf, len);
348 } /* class_handle_ioctl */
350 #define OBD_INIT_CHECK
351 #ifdef OBD_INIT_CHECK
352 static int obd_init_checks(void)
354 __u64 u64val, div64val;
358 CDEBUG(D_INFO, "OBD_OBJECT_EOF = %#llx\n", (__u64)OBD_OBJECT_EOF);
360 u64val = OBD_OBJECT_EOF;
361 CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val);
362 if (u64val != OBD_OBJECT_EOF) {
363 CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
364 u64val, (int)sizeof(u64val));
367 len = snprintf(buf, sizeof(buf), "%#llx", u64val);
369 CWARN("u64 hex wrong length! strlen(%s)=%d != 18\n", buf, len);
373 div64val = OBD_OBJECT_EOF;
374 CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val);
375 if (u64val != OBD_OBJECT_EOF) {
376 CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
377 u64val, (int)sizeof(u64val));
380 if (u64val >> 8 != OBD_OBJECT_EOF >> 8) {
381 CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
382 u64val, (int)sizeof(u64val));
385 if (do_div(div64val, 256) != (u64val & 255)) {
386 CERROR("do_div(%#llx,256) != %llu\n", u64val, u64val & 255);
389 if (u64val >> 8 != div64val) {
390 CERROR("do_div(%#llx,256) %llu != %llu\n",
391 u64val, div64val, u64val >> 8);
394 len = snprintf(buf, sizeof(buf), "%#llx", u64val);
396 CWARN("u64 hex wrong length! strlen(%s)=%d != 18\n", buf, len);
399 len = snprintf(buf, sizeof(buf), "%llu", u64val);
401 CWARN("u64 wrong length! strlen(%s)=%d != 20\n", buf, len);
404 len = snprintf(buf, sizeof(buf), "%lld", u64val);
406 CWARN("s64 wrong length! strlen(%s)=%d != 2\n", buf, len);
409 if ((u64val & ~PAGE_MASK) >= PAGE_SIZE) {
410 CWARN("mask failed: u64val %llu >= %llu\n", u64val,
418 #define obd_init_checks() do {} while(0)
421 static int __init obdclass_init(void)
425 LCONSOLE_INFO("Lustre: Build Version: "LUSTRE_VERSION_STRING"\n");
429 err = obd_init_checks();
430 if (err == -EOVERFLOW)
433 #ifdef CONFIG_PROC_FS
434 obd_memory = lprocfs_alloc_stats(OBD_STATS_NUM,
435 LPROCFS_STATS_FLAG_NONE |
436 LPROCFS_STATS_FLAG_IRQ_SAFE);
437 if (obd_memory == NULL) {
438 CERROR("kmalloc of 'obd_memory' failed\n");
442 lprocfs_counter_init(obd_memory, OBD_MEMORY_STAT,
443 LPROCFS_CNTR_AVGMINMAX,
446 err = obd_zombie_impexp_init();
448 goto cleanup_obd_memory;
450 err = class_handle_init();
452 goto cleanup_zombie_impexp;
454 err = misc_register(&obd_psdev);
456 CERROR("cannot register %d err %d\n", OBD_DEV_MINOR, err);
457 goto cleanup_class_handle;
460 /* Default the dirty page cache cap to 1/2 of system memory.
461 * For clients with less memory, a larger fraction is needed
462 * for other purposes (mostly for BGL). */
463 if (totalram_pages <= 512 << (20 - PAGE_SHIFT))
464 obd_max_dirty_pages = totalram_pages / 4;
466 obd_max_dirty_pages = totalram_pages / 2;
468 err = obd_init_caches();
470 goto cleanup_deregister;
472 err = class_procfs_init();
476 err = lu_global_init();
478 goto cleanup_class_procfs;
480 err = cl_global_init();
482 goto cleanup_lu_global;
484 #ifdef HAVE_SERVER_SUPPORT
485 err = dt_global_init();
487 goto cleanup_cl_global;
489 err = lu_ucred_global_init();
491 goto cleanup_dt_global;
492 #endif /* HAVE_SERVER_SUPPORT */
494 err = llog_info_init();
496 #ifdef HAVE_SERVER_SUPPORT
497 goto cleanup_lu_ucred_global;
498 #else /* !HAVE_SERVER_SUPPORT */
499 goto cleanup_cl_global;
500 #endif /* HAVE_SERVER_SUPPORT */
502 err = lustre_register_fs();
504 /* simulate a late OOM situation now to require all
505 * alloc'ed/initialized resources to be freed */
506 if (OBD_FAIL_CHECK(OBD_FAIL_OBDCLASS_MODULE_LOAD)) {
507 /* fake error but filesystem has been registered */
508 lustre_unregister_fs();
509 /* force error to ensure module will be unloaded/cleaned */
514 goto cleanup_llog_info;
521 #ifdef HAVE_SERVER_SUPPORT
522 cleanup_lu_ucred_global:
523 lu_ucred_global_fini();
527 #endif /* HAVE_SERVER_SUPPORT */
535 cleanup_class_procfs:
537 class_procfs_clean();
540 obd_cleanup_caches();
543 misc_deregister(&obd_psdev);
545 cleanup_class_handle:
546 class_handle_cleanup();
548 cleanup_zombie_impexp:
549 obd_zombie_impexp_stop();
552 #ifdef CONFIG_PROC_FS
553 lprocfs_free_stats(&obd_memory);
559 void obd_update_maxusage(void)
563 max = obd_memory_sum();
565 spin_lock(&obd_updatemax_lock);
566 if (max > obd_max_alloc)
568 spin_unlock(&obd_updatemax_lock);
570 EXPORT_SYMBOL(obd_update_maxusage);
572 #ifdef CONFIG_PROC_FS
573 __u64 obd_memory_max(void)
577 obd_update_maxusage();
578 spin_lock(&obd_updatemax_lock);
580 spin_unlock(&obd_updatemax_lock);
584 #endif /* CONFIG_PROC_FS */
586 static void __exit obdclass_exit(void)
588 #ifdef CONFIG_PROC_FS
591 #endif /* CONFIG_PROC_FS */
594 lustre_unregister_fs();
596 misc_deregister(&obd_psdev);
598 #ifdef HAVE_SERVER_SUPPORT
599 lu_ucred_global_fini();
601 #endif /* HAVE_SERVER_SUPPORT */
605 obd_cleanup_caches();
608 class_procfs_clean();
610 class_handle_cleanup();
611 class_del_uuid(NULL); /* Delete all UUIDs. */
612 obd_zombie_impexp_stop();
614 #ifdef CONFIG_PROC_FS
615 memory_leaked = obd_memory_sum();
616 memory_max = obd_memory_max();
618 lprocfs_free_stats(&obd_memory);
619 CDEBUG((memory_leaked) ? D_ERROR : D_INFO,
620 "obd_memory max: %llu, leaked: %llu\n",
621 memory_max, memory_leaked);
622 #endif /* CONFIG_PROC_FS */
627 MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
628 MODULE_DESCRIPTION("Lustre Class Driver");
629 MODULE_VERSION(LUSTRE_VERSION_STRING);
630 MODULE_LICENSE("GPL");
632 module_init(obdclass_init);
633 module_exit(obdclass_exit);