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, 2017, Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
32 #define DEBUG_SUBSYSTEM S_CLASS
34 #include <linux/miscdevice.h>
35 #include <linux/user_namespace.h>
36 #include <linux/uidgid.h>
37 #include <linux/atomic.h>
38 #include <linux/list.h>
39 #include <linux/oom.h>
41 #include <obd_support.h>
42 #include <obd_class.h>
43 #include <uapi/linux/lnet/lnetctl.h>
44 #include <lustre_kernelcomm.h>
45 #include <lprocfs_status.h>
46 #include <cl_object.h>
47 #ifdef HAVE_SERVER_SUPPORT
48 # include <dt_object.h>
49 # include <md_object.h>
50 #endif /* HAVE_SERVER_SUPPORT */
51 #include <uapi/linux/lustre/lustre_ioctl.h>
52 #include "llog_internal.h"
53 #include <lustre_ioctl_old.h>
55 static __u64 obd_max_alloc;
57 static DEFINE_SPINLOCK(obd_updatemax_lock);
59 /* The following are visible and mutable through /proc/sys/lustre/. */
60 unsigned int obd_debug_peer_on_timeout;
61 EXPORT_SYMBOL(obd_debug_peer_on_timeout);
62 unsigned int obd_dump_on_timeout;
63 EXPORT_SYMBOL(obd_dump_on_timeout);
64 unsigned int obd_dump_on_eviction;
65 EXPORT_SYMBOL(obd_dump_on_eviction);
66 unsigned int obd_lbug_on_eviction;
67 EXPORT_SYMBOL(obd_lbug_on_eviction);
68 unsigned long obd_max_dirty_pages;
69 EXPORT_SYMBOL(obd_max_dirty_pages);
70 atomic_long_t obd_dirty_pages;
71 EXPORT_SYMBOL(obd_dirty_pages);
72 unsigned int obd_timeout = OBD_TIMEOUT_DEFAULT; /* seconds */
73 EXPORT_SYMBOL(obd_timeout);
74 unsigned int ldlm_timeout = LDLM_TIMEOUT_DEFAULT; /* seconds */
75 EXPORT_SYMBOL(ldlm_timeout);
76 unsigned int ping_interval = (OBD_TIMEOUT_DEFAULT > 4) ?
77 (OBD_TIMEOUT_DEFAULT / 4) : 1;
78 EXPORT_SYMBOL(ping_interval);
79 unsigned int ping_evict_timeout_multiplier = 6;
80 EXPORT_SYMBOL(ping_evict_timeout_multiplier);
81 unsigned int obd_timeout_set;
82 EXPORT_SYMBOL(obd_timeout_set);
83 unsigned int ldlm_timeout_set;
84 EXPORT_SYMBOL(ldlm_timeout_set);
85 /* bulk transfer timeout, give up after 100s by default */
86 unsigned int bulk_timeout = 100; /* seconds */
87 EXPORT_SYMBOL(bulk_timeout);
89 /* Adaptive timeout defs here instead of ptlrpc module for /proc/sys/ access */
90 unsigned int at_min = 5;
91 EXPORT_SYMBOL(at_min);
92 unsigned int at_max = 600;
93 EXPORT_SYMBOL(at_max);
94 unsigned int at_history = 600;
95 EXPORT_SYMBOL(at_history);
96 int at_early_margin = 5;
97 EXPORT_SYMBOL(at_early_margin);
99 EXPORT_SYMBOL(at_extra);
101 struct percpu_counter obd_memory;
102 EXPORT_SYMBOL(obd_memory);
104 static int obdclass_oom_handler(struct notifier_block *self,
105 unsigned long notused, void *nfreed)
108 pr_info("obd_memory max: %llu, obd_memory current: %llu\n",
109 obd_memory_max(), obd_memory_sum());
114 static struct notifier_block obdclass_oom = {
115 .notifier_call = obdclass_oom_handler
118 int obd_ioctl_msg(const char *file, const char *func, int line, int level,
119 const char *name, unsigned int cmd, const char *msg, int rc)
121 static struct cfs_debug_limit_state cdls;
124 [_IOC_READ] = "_IOR",
125 [_IOC_WRITE] = "_IOW",
126 [_IOC_READ|_IOC_WRITE] = "_IOWR",
130 type = _IOC_TYPE(cmd);
131 __CDEBUG_WITH_LOC(file, func, line, level, &cdls,
132 "%s: iocontrol from '%s' cmd=%x %s('%c', %u, %u) %s: rc = %d\n",
133 name, current->comm, cmd,
134 dirs[_IOC_DIR(cmd)] ?: "_IO?",
135 isprint(type) ? type : '?', _IOC_NR(cmd),
136 _IOC_SIZE(cmd), msg, rc);
139 EXPORT_SYMBOL(obd_ioctl_msg);
141 static int class_resolve_dev_name(__u32 len, const char *name)
148 CERROR("No name passed,!\n");
149 GOTO(out, rc = -EINVAL);
151 if (name[len - 1] != 0) {
152 CERROR("Name not nul terminated!\n");
153 GOTO(out, rc = -EINVAL);
156 CDEBUG(D_IOCTL, "device name %s\n", name);
157 dev = class_name2dev(name);
159 CDEBUG(D_IOCTL, "No device for name %s!\n", name);
160 GOTO(out, rc = -EINVAL);
163 CDEBUG(D_IOCTL, "device name %s, dev %d\n", name, dev);
170 #define OBD_MAX_IOCTL_BUFFER 8192
172 static int obd_ioctl_is_invalid(struct obd_ioctl_data *data)
174 const int maxlen = 1 << 30;
175 if (data->ioc_len > maxlen) {
176 CERROR("OBD ioctl: ioc_len larger than 1<<30\n");
180 if (data->ioc_inllen1 > maxlen) {
181 CERROR("OBD ioctl: ioc_inllen1 larger than 1<<30\n");
185 if (data->ioc_inllen2 > maxlen) {
186 CERROR("OBD ioctl: ioc_inllen2 larger than 1<<30\n");
190 if (data->ioc_inllen3 > maxlen) {
191 CERROR("OBD ioctl: ioc_inllen3 larger than 1<<30\n");
195 if (data->ioc_inllen4 > maxlen) {
196 CERROR("OBD ioctl: ioc_inllen4 larger than 1<<30\n");
200 if (data->ioc_inlbuf1 && data->ioc_inllen1 == 0) {
201 CERROR("OBD ioctl: inlbuf1 pointer but 0 length\n");
205 if (data->ioc_inlbuf2 && data->ioc_inllen2 == 0) {
206 CERROR("OBD ioctl: inlbuf2 pointer but 0 length\n");
210 if (data->ioc_inlbuf3 && data->ioc_inllen3 == 0) {
211 CERROR("OBD ioctl: inlbuf3 pointer but 0 length\n");
215 if (data->ioc_inlbuf4 && data->ioc_inllen4 == 0) {
216 CERROR("OBD ioctl: inlbuf4 pointer but 0 length\n");
220 if (data->ioc_pbuf1 && data->ioc_plen1 == 0) {
221 CERROR("OBD ioctl: pbuf1 pointer but 0 length\n");
225 if (data->ioc_pbuf2 && data->ioc_plen2 == 0) {
226 CERROR("OBD ioctl: pbuf2 pointer but 0 length\n");
230 if (!data->ioc_pbuf1 && data->ioc_plen1 != 0) {
231 CERROR("OBD ioctl: plen1 set but NULL pointer\n");
235 if (!data->ioc_pbuf2 && data->ioc_plen2 != 0) {
236 CERROR("OBD ioctl: plen2 set but NULL pointer\n");
240 if (obd_ioctl_packlen(data) > data->ioc_len) {
241 CERROR("OBD ioctl: packlen exceeds ioc_len (%d > %d)\n",
242 obd_ioctl_packlen(data), data->ioc_len);
249 /* buffer MUST be at least the size of obd_ioctl_hdr */
250 int obd_ioctl_getdata(struct obd_ioctl_data **datap, int *len, void __user *arg)
252 struct obd_ioctl_hdr hdr;
253 struct obd_ioctl_data *data;
258 if (copy_from_user(&hdr, arg, sizeof(hdr)))
261 if (hdr.ioc_version != OBD_IOCTL_VERSION) {
262 CERROR("%s: kernel/user version mismatch (%x != %x): rc = %d\n",
263 current->comm, OBD_IOCTL_VERSION, hdr.ioc_version, rc);
267 if (hdr.ioc_len > OBD_MAX_IOCTL_BUFFER) {
268 CERROR("%s: user buffer len %d exceeds %d max: rc = %d\n",
269 current->comm, hdr.ioc_len, OBD_MAX_IOCTL_BUFFER, rc);
273 if (hdr.ioc_len < sizeof(*data)) {
274 CERROR("%s: user buffer %d too small for ioctl %zu: rc = %d\n",
275 current->comm, hdr.ioc_len, sizeof(*data), rc);
279 /* When there are lots of processes calling vmalloc on multi-core
280 * system, the high lock contention will hurt performance badly,
281 * obdfilter-survey is an example, which relies on ioctl. So we'd
282 * better avoid vmalloc on ioctl path. LU-66
284 OBD_ALLOC_LARGE(data, hdr.ioc_len);
287 CERROR("%s: cannot allocate control buffer len %d: rc = %d\n",
288 current->comm, hdr.ioc_len, rc);
293 if (copy_from_user(data, arg, hdr.ioc_len))
294 GOTO(out_free, rc = -EFAULT);
296 if (obd_ioctl_is_invalid(data))
297 GOTO(out_free, rc = -EINVAL);
299 if (data->ioc_inllen1) {
300 data->ioc_inlbuf1 = &data->ioc_bulk[0];
301 offset += round_up(data->ioc_inllen1, 8);
304 if (data->ioc_inllen2) {
305 data->ioc_inlbuf2 = &data->ioc_bulk[0] + offset;
306 offset += round_up(data->ioc_inllen2, 8);
309 if (data->ioc_inllen3) {
310 data->ioc_inlbuf3 = &data->ioc_bulk[0] + offset;
311 offset += round_up(data->ioc_inllen3, 8);
314 if (data->ioc_inllen4)
315 data->ioc_inlbuf4 = &data->ioc_bulk[0] + offset;
322 OBD_FREE_LARGE(data, *len);
325 EXPORT_SYMBOL(obd_ioctl_getdata);
327 int class_handle_ioctl(unsigned int cmd, void __user *uarg)
329 struct obd_ioctl_data *data;
330 struct obd_device *obd = NULL;
334 CDEBUG(D_IOCTL, "obdclass: cmd=%x len=%u uarg=%pK\n", cmd, len, uarg);
335 if (unlikely(_IOC_TYPE(cmd) != 'f' && !OBD_IOC_BARRIER_ALLOW(cmd) &&
336 !IOC_OSC_SET_ACTIVE_ALLOW(cmd)))
337 RETURN(OBD_IOC_ERROR(obd->obd_name, cmd, "unknown", -ENOTTY));
339 rc = obd_ioctl_getdata(&data, &len, uarg);
341 CERROR("%s: ioctl data error: rc = %d\n", current->comm, rc);
346 case OBD_IOC_PROCESS_CFG: {
347 struct lustre_cfg *lcfg;
349 if (!data->ioc_plen1 || !data->ioc_pbuf1) {
350 rc = OBD_IOC_ERROR("obdclass", cmd, "no config buffer",
354 OBD_ALLOC(lcfg, data->ioc_plen1);
356 GOTO(out, rc = -ENOMEM);
357 rc = copy_from_user(lcfg, data->ioc_pbuf1, data->ioc_plen1);
359 rc = lustre_cfg_sanity_check(lcfg, data->ioc_plen1);
361 rc = class_process_config(lcfg);
363 OBD_FREE(lcfg, data->ioc_plen1);
367 #ifdef OBD_GET_VERSION
368 case_OBD_IOC_DEPRECATED(OBD_GET_VERSION, "obdclass", 2, 15) {
369 size_t vstr_size = sizeof(LUSTRE_VERSION_STRING);
371 if (!data->ioc_inlbuf1) {
372 rc = OBD_IOC_ERROR("obdclass", cmd, "no buffer passed",
377 if (vstr_size > data->ioc_inllen1) {
378 rc = OBD_IOC_ERROR("obdclass", cmd, "buffer too small",
383 strscpy(data->ioc_bulk, LUSTRE_VERSION_STRING, vstr_size);
385 if (copy_to_user(uarg, data, len))
390 case OBD_IOC_NAME2DEV: {
391 /* Resolve device name, does not change current selected dev */
394 dev = class_resolve_dev_name(data->ioc_inllen1,
398 GOTO(out, rc = -EINVAL);
400 if (copy_to_user(uarg, data, sizeof(*data)))
405 case OBD_IOC_UUID2DEV: {
406 /* Resolve device uuid, does not change current selected dev */
407 struct obd_uuid uuid;
410 if (!data->ioc_inllen1 || !data->ioc_inlbuf1) {
411 rc = OBD_IOC_ERROR("obdclass", cmd, "no UUID passed",
415 if (data->ioc_inlbuf1[data->ioc_inllen1 - 1] != 0) {
416 rc = OBD_IOC_ERROR("obdclass", cmd, "unterminated UUID",
421 CDEBUG(D_IOCTL, "device name %s\n", data->ioc_inlbuf1);
422 obd_str2uuid(&uuid, data->ioc_inlbuf1);
423 dev = class_uuid2dev(&uuid);
426 CDEBUG(D_IOCTL, "No device for UUID %s!\n",
428 GOTO(out, rc = -EINVAL);
431 CDEBUG(D_IOCTL, "device name %s, dev %d\n", data->ioc_inlbuf1,
433 if (copy_to_user(uarg, data, sizeof(*data)))
438 case OBD_IOC_GETDEVICE: {
439 int index = data->ioc_count;
442 if (!data->ioc_inlbuf1) {
443 rc = OBD_IOC_ERROR("obdclass", cmd, "no buffer passed",
447 if (data->ioc_inllen1 < 128) {
448 rc = OBD_IOC_ERROR("obdclass", cmd, "too small version",
453 obd = class_num2obd(index);
455 GOTO(out, rc = -ENOENT);
457 if (obd->obd_stopping)
459 else if (obd->obd_inactive)
461 else if (obd->obd_set_up)
463 else if (obd->obd_attached)
468 str = data->ioc_bulk;
469 snprintf(str, len - sizeof(*data), "%3d %s %s %s %s %d",
470 index, status, obd->obd_type->typ_name,
471 obd->obd_name, obd->obd_uuid.uuid,
472 kref_read(&obd->obd_refcount));
474 if (copy_to_user(uarg, data, len))
481 if (data->ioc_dev == OBD_DEV_BY_DEVNAME) {
482 if (data->ioc_inllen4 <= 0 || data->ioc_inlbuf4 == NULL)
483 GOTO(out, rc = -EINVAL);
484 if (strnlen(data->ioc_inlbuf4, MAX_OBD_NAME) >= MAX_OBD_NAME)
485 GOTO(out, rc = -EINVAL);
486 obd = class_name2obd(data->ioc_inlbuf4);
488 obd = class_num2obd(data->ioc_dev);
492 rc = OBD_IOC_ERROR(data->ioc_inlbuf4, cmd, "no device found",
496 LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
498 if (!obd->obd_set_up || obd->obd_stopping) {
500 CERROR("obdclass: device %d not set up: rc = %d\n",
505 rc = obd_iocontrol(cmd, obd->obd_self_export, len, data, NULL);
509 if (copy_to_user(uarg, data, len))
512 OBD_FREE_LARGE(data, len);
514 } /* class_handle_ioctl */
516 /* to control /dev/obd */
517 static long obd_class_ioctl(struct file *filp, unsigned int cmd,
523 /* Allow non-root access for some limited ioctls */
524 if (!capable(CAP_SYS_ADMIN))
527 if ((cmd & 0xffffff00) == ((int)'T') << 8) /* ignore all tty ioctls */
530 err = class_handle_ioctl(cmd, (void __user *)arg);
535 /* declare character device */
536 static const struct file_operations obd_psdev_fops = {
537 .owner = THIS_MODULE,
538 .unlocked_ioctl = obd_class_ioctl, /* unlocked_ioctl */
542 static struct miscdevice obd_psdev = {
543 .minor = MISC_DYNAMIC_MINOR,
544 .name = OBD_DEV_NAME,
545 .fops = &obd_psdev_fops,
548 #define test_string_to_size_err(value, expect, def_unit, __rc) \
553 BUILD_BUG_ON(sizeof(value) >= 23); \
554 __ret = sysfs_memparse(value, sizeof(value) - 1, &__size, def_unit); \
556 CERROR("string_helper: parsing '%s' expect rc %d != got %d\n", \
557 value, __rc, __ret); \
558 else if (!__ret && (u64)expect != __size) \
559 CERROR("string_helper: parsing '%s' expect %llu != got %llu\n",\
560 value, (u64)expect, __size); \
563 #define test_string_to_size_one(value, expect, def_unit) \
564 test_string_to_size_err(value, expect, def_unit, 0)
566 static int __init obd_init_checks(void)
568 __u64 u64val, div64val;
572 CDEBUG(D_INFO, "OBD_OBJECT_EOF = %#llx\n", (__u64)OBD_OBJECT_EOF);
574 u64val = OBD_OBJECT_EOF;
575 CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val);
576 if (u64val != OBD_OBJECT_EOF) {
577 CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
578 u64val, (int)sizeof(u64val));
581 len = snprintf(buf, sizeof(buf), "%#llx", u64val);
583 CERROR("u64 hex wrong length, strlen(%s)=%d != 18\n", buf, len);
587 div64val = OBD_OBJECT_EOF;
588 CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val);
589 if (u64val != OBD_OBJECT_EOF) {
590 CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
591 u64val, (int)sizeof(u64val));
594 if (u64val >> 8 != OBD_OBJECT_EOF >> 8) {
595 CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
596 u64val, (int)sizeof(u64val));
599 if (do_div(div64val, 256) != (u64val & 255)) {
600 CERROR("do_div(%#llx,256) != %llu\n", u64val, u64val & 255);
603 if (u64val >> 8 != div64val) {
604 CERROR("do_div(%#llx,256) %llu != %llu\n",
605 u64val, div64val, u64val >> 8);
608 len = snprintf(buf, sizeof(buf), "%#llx", u64val);
610 CERROR("u64 hex wrong length! strlen(%s)=%d != 18\n", buf, len);
613 len = snprintf(buf, sizeof(buf), "%llu", u64val);
615 CERROR("u64 wrong length! strlen(%s)=%d != 20\n", buf, len);
618 len = snprintf(buf, sizeof(buf), "%lld", u64val);
620 CERROR("s64 wrong length! strlen(%s)=%d != 2\n", buf, len);
623 if ((u64val & ~PAGE_MASK) >= PAGE_SIZE) {
624 CERROR("mask failed: u64val %llu >= %llu\n", u64val,
632 if (!test_string_to_size_err("256B34", 256, "B", -EINVAL)) {
633 CERROR("string_helpers: format should be number then units\n");
636 if (!test_string_to_size_err("132OpQ", 132, "B", -EINVAL)) {
637 CERROR("string_helpers: invalid units should be rejected\n");
640 if (!test_string_to_size_err("1.82B", 1, "B", -EINVAL)) {
641 CERROR("string_helpers: 'B' with '.' should be invalid\n");
644 if (test_string_to_size_one("343\n", 343, "B")) {
645 CERROR("string_helpers: should ignore newline\n");
651 /* memparse unit handling */
653 ret += test_string_to_size_one("0B", 0, "B");
654 ret += test_string_to_size_one("512B", 512, "B");
655 ret += test_string_to_size_one("1.067kB", 1067, "B");
656 ret += test_string_to_size_one("1.042KiB", 1067, "B");
657 ret += test_string_to_size_one("8", 8388608, "M");
658 ret += test_string_to_size_one("65536", 65536, "B");
659 ret += test_string_to_size_one("128", 131072, "K");
660 ret += test_string_to_size_one("1M", 1048576, "B");
661 ret += test_string_to_size_one("0.5T", 549755813888ULL, "T");
662 ret += test_string_to_size_one("256.5G", 275414777856ULL, "G");
666 /* string helper values */
667 ret += test_string_to_size_one("16", 16777216, "MiB");
668 ret += test_string_to_size_one("8.39MB", 8390000, "MiB");
669 ret += test_string_to_size_one("8.00MiB", 8388608, "MiB");
670 ret += test_string_to_size_one("256GB", 256000000000ULL, "GiB");
671 ret += test_string_to_size_one("238.731GiB", 256335459385ULL, "GiB");
676 ret += test_string_to_size_one("0.4TB", 400000000000ULL, "TiB");
677 ret += test_string_to_size_one("12.5TiB", 13743895347200ULL, "TiB");
678 ret += test_string_to_size_one("2PB", 2000000000000000ULL, "PiB");
679 ret += test_string_to_size_one("16PiB", 18014398509481984ULL, "PiB");
683 /* huge values should overflow */
684 if (!test_string_to_size_err("1000EiB", 0, "EiB", -EOVERFLOW)) {
685 CERROR("string_helpers: failed to detect binary overflow\n");
688 if (!test_string_to_size_err("1000EB", 0, "EiB", -EOVERFLOW)) {
689 CERROR("string_helpers: failed to detect decimal overflow\n");
696 static int __init obdclass_init(void)
700 LCONSOLE_INFO("Lustre: Build Version: "LUSTRE_VERSION_STRING"\n");
702 register_oom_notifier(&obdclass_oom);
704 err = libcfs_setup();
708 err = obd_init_checks();
712 err = percpu_counter_init(&obd_memory, 0, GFP_KERNEL);
714 CERROR("obdclass: initializing 'obd_memory' failed: rc = %d\n",
719 err = libcfs_kkuc_init();
721 goto cleanup_obd_memory;
723 err = obd_zombie_impexp_init();
727 err = class_handle_init();
729 goto cleanup_zombie_impexp;
731 err = misc_register(&obd_psdev);
733 CERROR("cannot register OBD miscdevice: rc = %d\n", err);
734 goto cleanup_class_handle;
737 /* Default the dirty page cache cap to 1/2 of system memory.
738 * For clients with less memory, a larger fraction is needed
739 * for other purposes (mostly for BGL). */
740 if (cfs_totalram_pages() <= 512 << (20 - PAGE_SHIFT))
741 obd_max_dirty_pages = cfs_totalram_pages() / 4;
743 obd_max_dirty_pages = cfs_totalram_pages() / 2;
745 err = obd_init_caches();
747 goto cleanup_deregister;
749 err = class_procfs_init();
753 err = lu_global_init();
755 goto cleanup_class_procfs;
757 err = cl_global_init();
759 goto cleanup_lu_global;
761 err = llog_info_init();
763 goto cleanup_cl_global;
765 err = obd_pool_init();
767 goto cleanup_llog_info;
769 #ifdef HAVE_SERVER_SUPPORT
770 err = dt_global_init();
772 goto cleanup_obd_pool;
774 err = lu_ucred_global_init();
776 goto cleanup_dt_global;
777 #endif /* HAVE_SERVER_SUPPORT */
779 /* simulate a late OOM situation now to require all
780 * alloc'ed/initialized resources to be freed
782 if (CFS_FAIL_CHECK(OBD_FAIL_OBDCLASS_MODULE_LOAD)) {
783 /* force error to ensure module will be unloaded/cleaned */
790 #ifdef HAVE_SERVER_SUPPORT
791 lu_ucred_global_fini();
797 #endif /* HAVE_SERVER_SUPPORT */
809 cleanup_class_procfs:
810 class_procfs_clean();
813 obd_cleanup_caches();
816 misc_deregister(&obd_psdev);
818 cleanup_class_handle:
819 class_handle_cleanup();
821 cleanup_zombie_impexp:
822 obd_zombie_impexp_stop();
828 percpu_counter_destroy(&obd_memory);
830 unregister_oom_notifier(&obdclass_oom);
834 void obd_update_maxusage(void)
838 max = obd_memory_sum();
840 spin_lock(&obd_updatemax_lock);
841 if (max > obd_max_alloc)
843 spin_unlock(&obd_updatemax_lock);
845 EXPORT_SYMBOL(obd_update_maxusage);
847 __u64 obd_memory_max(void)
851 obd_update_maxusage();
852 spin_lock(&obd_updatemax_lock);
854 spin_unlock(&obd_updatemax_lock);
858 EXPORT_SYMBOL(obd_memory_max);
860 static void __exit obdclass_exit(void)
866 misc_deregister(&obd_psdev);
867 #ifdef HAVE_SERVER_SUPPORT
868 lu_ucred_global_fini();
870 #endif /* HAVE_SERVER_SUPPORT */
876 obd_cleanup_caches();
878 class_procfs_clean();
880 class_handle_cleanup();
881 class_del_uuid(NULL); /* Delete all UUIDs. */
882 obd_zombie_impexp_stop();
885 memory_leaked = obd_memory_sum();
886 memory_max = obd_memory_max();
888 percpu_counter_destroy(&obd_memory);
889 /* the below message is checked in test-framework.sh check_mem_leak() */
890 CDEBUG((memory_leaked) ? D_ERROR : D_INFO,
891 "obd_memory max: %llu, leaked: %llu\n",
892 memory_max, memory_leaked);
894 unregister_oom_notifier(&obdclass_oom);
899 void obd_heat_clear(struct obd_heat_instance *instance, int count)
903 memset(instance, 0, sizeof(*instance) * count);
906 EXPORT_SYMBOL(obd_heat_clear);
909 * The file heat is calculated for every time interval period I. The access
910 * frequency during each period is counted. The file heat is only recalculated
911 * at the end of a time period. And a percentage of the former file heat is
912 * lost when recalculated. The recursion formula to calculate the heat of the
913 * file f is as follow:
915 * Hi+1(f) = (1-P)*Hi(f)+ P*Ci
917 * Where Hi is the heat value in the period between time points i*I and
918 * (i+1)*I; Ci is the access count in the period; the symbol P refers to the
919 * weight of Ci. The larger the value the value of P is, the more influence Ci
920 * has on the file heat.
922 void obd_heat_decay(struct obd_heat_instance *instance, __u64 time_second,
923 unsigned int weight, unsigned int period_second)
929 if (instance->ohi_time_second > time_second) {
930 obd_heat_clear(instance, 1);
934 if (instance->ohi_time_second == 0)
937 for (second = instance->ohi_time_second + period_second;
938 second < time_second;
939 second += period_second) {
940 instance->ohi_heat = instance->ohi_heat *
941 (256 - weight) / 256 +
942 instance->ohi_count * weight / 256;
943 instance->ohi_count = 0;
944 instance->ohi_time_second = second;
948 EXPORT_SYMBOL(obd_heat_decay);
950 __u64 obd_heat_get(struct obd_heat_instance *instance, unsigned int time_second,
951 unsigned int weight, unsigned int period_second)
955 obd_heat_decay(instance, time_second, weight, period_second);
957 if (instance->ohi_count == 0)
958 RETURN(instance->ohi_heat);
960 RETURN(instance->ohi_heat * (256 - weight) / 256 +
961 instance->ohi_count * weight / 256);
963 EXPORT_SYMBOL(obd_heat_get);
965 void obd_heat_add(struct obd_heat_instance *instance,
966 unsigned int time_second, __u64 count,
967 unsigned int weight, unsigned int period_second)
971 obd_heat_decay(instance, time_second, weight, period_second);
972 if (instance->ohi_time_second == 0) {
973 instance->ohi_time_second = time_second;
974 instance->ohi_heat = 0;
975 instance->ohi_count = count;
977 instance->ohi_count += count;
981 EXPORT_SYMBOL(obd_heat_add);
983 MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
984 MODULE_DESCRIPTION("Lustre Class Driver");
985 MODULE_VERSION(LUSTRE_VERSION_STRING);
986 MODULE_LICENSE("GPL");
988 module_init(obdclass_init);
989 module_exit(obdclass_exit);