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 static int obd_init_checks(void)
352 __u64 u64val, div64val;
356 CDEBUG(D_INFO, "OBD_OBJECT_EOF = %#llx\n", (__u64)OBD_OBJECT_EOF);
358 u64val = OBD_OBJECT_EOF;
359 CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val);
360 if (u64val != OBD_OBJECT_EOF) {
361 CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
362 u64val, (int)sizeof(u64val));
365 len = snprintf(buf, sizeof(buf), "%#llx", u64val);
367 CWARN("u64 hex wrong length! strlen(%s)=%d != 18\n", buf, len);
371 div64val = OBD_OBJECT_EOF;
372 CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val);
373 if (u64val != OBD_OBJECT_EOF) {
374 CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
375 u64val, (int)sizeof(u64val));
378 if (u64val >> 8 != OBD_OBJECT_EOF >> 8) {
379 CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
380 u64val, (int)sizeof(u64val));
383 if (do_div(div64val, 256) != (u64val & 255)) {
384 CERROR("do_div(%#llx,256) != %llu\n", u64val, u64val & 255);
387 if (u64val >> 8 != div64val) {
388 CERROR("do_div(%#llx,256) %llu != %llu\n",
389 u64val, div64val, u64val >> 8);
392 len = snprintf(buf, sizeof(buf), "%#llx", u64val);
394 CWARN("u64 hex wrong length! strlen(%s)=%d != 18\n", buf, len);
397 len = snprintf(buf, sizeof(buf), "%llu", u64val);
399 CWARN("u64 wrong length! strlen(%s)=%d != 20\n", buf, len);
402 len = snprintf(buf, sizeof(buf), "%lld", u64val);
404 CWARN("s64 wrong length! strlen(%s)=%d != 2\n", buf, len);
407 if ((u64val & ~PAGE_MASK) >= PAGE_SIZE) {
408 CWARN("mask failed: u64val %llu >= %llu\n", u64val,
416 static int __init obdclass_init(void)
420 LCONSOLE_INFO("Lustre: Build Version: "LUSTRE_VERSION_STRING"\n");
424 err = obd_init_checks();
425 if (err == -EOVERFLOW)
428 #ifdef CONFIG_PROC_FS
429 obd_memory = lprocfs_alloc_stats(OBD_STATS_NUM,
430 LPROCFS_STATS_FLAG_NONE |
431 LPROCFS_STATS_FLAG_IRQ_SAFE);
432 if (obd_memory == NULL) {
433 CERROR("kmalloc of 'obd_memory' failed\n");
437 lprocfs_counter_init(obd_memory, OBD_MEMORY_STAT,
438 LPROCFS_CNTR_AVGMINMAX,
441 err = obd_zombie_impexp_init();
443 goto cleanup_obd_memory;
445 err = class_handle_init();
447 goto cleanup_zombie_impexp;
449 err = misc_register(&obd_psdev);
451 CERROR("cannot register %d err %d\n", OBD_DEV_MINOR, err);
452 goto cleanup_class_handle;
455 /* Default the dirty page cache cap to 1/2 of system memory.
456 * For clients with less memory, a larger fraction is needed
457 * for other purposes (mostly for BGL). */
458 if (totalram_pages <= 512 << (20 - PAGE_SHIFT))
459 obd_max_dirty_pages = totalram_pages / 4;
461 obd_max_dirty_pages = totalram_pages / 2;
463 err = obd_init_caches();
465 goto cleanup_deregister;
467 err = class_procfs_init();
471 err = lu_global_init();
473 goto cleanup_class_procfs;
475 err = cl_global_init();
477 goto cleanup_lu_global;
479 #ifdef HAVE_SERVER_SUPPORT
480 err = dt_global_init();
482 goto cleanup_cl_global;
484 err = lu_ucred_global_init();
486 goto cleanup_dt_global;
487 #endif /* HAVE_SERVER_SUPPORT */
489 err = llog_info_init();
491 #ifdef HAVE_SERVER_SUPPORT
492 goto cleanup_lu_ucred_global;
493 #else /* !HAVE_SERVER_SUPPORT */
494 goto cleanup_cl_global;
495 #endif /* HAVE_SERVER_SUPPORT */
497 err = lustre_register_fs();
499 /* simulate a late OOM situation now to require all
500 * alloc'ed/initialized resources to be freed */
501 if (OBD_FAIL_CHECK(OBD_FAIL_OBDCLASS_MODULE_LOAD)) {
502 /* fake error but filesystem has been registered */
503 lustre_unregister_fs();
504 /* force error to ensure module will be unloaded/cleaned */
509 goto cleanup_llog_info;
516 #ifdef HAVE_SERVER_SUPPORT
517 cleanup_lu_ucred_global:
518 lu_ucred_global_fini();
522 #endif /* HAVE_SERVER_SUPPORT */
530 cleanup_class_procfs:
532 class_procfs_clean();
535 obd_cleanup_caches();
538 misc_deregister(&obd_psdev);
540 cleanup_class_handle:
541 class_handle_cleanup();
543 cleanup_zombie_impexp:
544 obd_zombie_impexp_stop();
547 #ifdef CONFIG_PROC_FS
548 lprocfs_free_stats(&obd_memory);
554 void obd_update_maxusage(void)
558 max = obd_memory_sum();
560 spin_lock(&obd_updatemax_lock);
561 if (max > obd_max_alloc)
563 spin_unlock(&obd_updatemax_lock);
565 EXPORT_SYMBOL(obd_update_maxusage);
567 #ifdef CONFIG_PROC_FS
568 __u64 obd_memory_max(void)
572 obd_update_maxusage();
573 spin_lock(&obd_updatemax_lock);
575 spin_unlock(&obd_updatemax_lock);
579 #endif /* CONFIG_PROC_FS */
581 static void __exit obdclass_exit(void)
583 #ifdef CONFIG_PROC_FS
586 #endif /* CONFIG_PROC_FS */
589 lustre_unregister_fs();
591 misc_deregister(&obd_psdev);
593 #ifdef HAVE_SERVER_SUPPORT
594 lu_ucred_global_fini();
596 #endif /* HAVE_SERVER_SUPPORT */
600 obd_cleanup_caches();
603 class_procfs_clean();
605 class_handle_cleanup();
606 class_del_uuid(NULL); /* Delete all UUIDs. */
607 obd_zombie_impexp_stop();
609 #ifdef CONFIG_PROC_FS
610 memory_leaked = obd_memory_sum();
611 memory_max = obd_memory_max();
613 lprocfs_free_stats(&obd_memory);
614 CDEBUG((memory_leaked) ? D_ERROR : D_INFO,
615 "obd_memory max: %llu, leaked: %llu\n",
616 memory_max, memory_leaked);
617 #endif /* CONFIG_PROC_FS */
622 MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
623 MODULE_DESCRIPTION("Lustre Class Driver");
624 MODULE_VERSION(LUSTRE_VERSION_STRING);
625 MODULE_LICENSE("GPL");
627 module_init(obdclass_init);
628 module_exit(obdclass_exit);