X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=sidebyside;f=lustre%2Fobdclass%2Fclass_obd.c;h=cf38cde7b1656b66fc2df0939e174bcec8832160;hb=8eca92b365fd3efd1541a48b1bb239926838d947;hp=da38c9a248e9ba791610e06d0b7783968f5b8ea5;hpb=8701e7e4b5ec1b34700c95b9b6588f4745730b72;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c index da38c9a..cf38cde 100644 --- a/lustre/obdclass/class_obd.c +++ b/lustre/obdclass/class_obd.c @@ -15,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -27,7 +23,7 @@ * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Intel Corporation. + * Copyright (c) 2011, 2015, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -35,19 +31,20 @@ */ #define DEBUG_SUBSYSTEM S_CLASS -#ifndef __KERNEL__ -# include -#else -# include + +#include +#ifdef HAVE_UIDGID_HEADER +# include #endif +#include +#include #include #include #include #include #include -#include -#include +#include #include #ifdef HAVE_SERVER_SUPPORT # include @@ -56,36 +53,28 @@ #include #include "llog_internal.h" -#ifndef __KERNEL__ -/* liblustre workaround */ -atomic_t libcfs_kmemory = {0}; -#endif - struct obd_device *obd_devs[MAX_OBD_DEVICES]; -EXPORT_SYMBOL(obd_devs); struct list_head obd_types; DEFINE_RWLOCK(obd_dev_lock); -__u64 obd_max_pages = 0; -__u64 obd_max_alloc = 0; -#ifndef __KERNEL__ -__u64 obd_alloc; -__u64 obd_pages; +#ifdef CONFIG_PROC_FS +static __u64 obd_max_alloc; +#else +__u64 obd_max_alloc; #endif -DEFINE_SPINLOCK(obd_updatemax_lock); + +static DEFINE_SPINLOCK(obd_updatemax_lock); /* The following are visible and mutable through /proc/sys/lustre/. */ -unsigned int obd_alloc_fail_rate = 0; -EXPORT_SYMBOL(obd_alloc_fail_rate); unsigned int obd_debug_peer_on_timeout; EXPORT_SYMBOL(obd_debug_peer_on_timeout); unsigned int obd_dump_on_timeout; EXPORT_SYMBOL(obd_dump_on_timeout); unsigned int obd_dump_on_eviction; EXPORT_SYMBOL(obd_dump_on_eviction); -unsigned int obd_max_dirty_pages = 256; +unsigned long obd_max_dirty_pages; EXPORT_SYMBOL(obd_max_dirty_pages); -atomic_t obd_dirty_pages; +atomic_long_t obd_dirty_pages; EXPORT_SYMBOL(obd_dirty_pages); unsigned int obd_timeout = OBD_TIMEOUT_DEFAULT; /* seconds */ EXPORT_SYMBOL(obd_timeout); @@ -95,6 +84,9 @@ unsigned int obd_timeout_set; EXPORT_SYMBOL(obd_timeout_set); unsigned int ldlm_timeout_set; EXPORT_SYMBOL(ldlm_timeout_set); +/* bulk transfer timeout, give up after 100s by default */ +unsigned int bulk_timeout = 100; /* seconds */ +EXPORT_SYMBOL(bulk_timeout); /* Adaptive timeout defs here instead of ptlrpc module for /proc/sys/ access */ unsigned int at_min = 0; EXPORT_SYMBOL(at_min); @@ -107,17 +99,18 @@ EXPORT_SYMBOL(at_early_margin); int at_extra = 30; EXPORT_SYMBOL(at_extra); -atomic_t obd_dirty_transit_pages; +atomic_long_t obd_dirty_transit_pages; EXPORT_SYMBOL(obd_dirty_transit_pages); char obd_jobid_var[JOBSTATS_JOBID_VAR_MAX_LEN + 1] = JOBSTATS_DISABLE; -EXPORT_SYMBOL(obd_jobid_var); -#ifdef LPROCFS +#ifdef CONFIG_PROC_FS struct lprocfs_stats *obd_memory = NULL; EXPORT_SYMBOL(obd_memory); #endif +char obd_jobid_node[LUSTRE_JOBID_SIZE + 1]; + /* Get jobid of current process by reading the environment variable * stored in between the "env_start" & "env_end" of task struct. * @@ -132,24 +125,30 @@ EXPORT_SYMBOL(obd_memory); */ int lustre_get_jobid(char *jobid) { - int jobid_len = JOBSTATS_JOBID_SIZE; + int jobid_len = LUSTRE_JOBID_SIZE; + char tmp_jobid[LUSTRE_JOBID_SIZE] = { 0 }; int rc = 0; ENTRY; - memset(jobid, 0, JOBSTATS_JOBID_SIZE); /* Jobstats isn't enabled */ if (strcmp(obd_jobid_var, JOBSTATS_DISABLE) == 0) - RETURN(0); + GOTO(out, rc = 0); + + /* Whole node dedicated to single job */ + if (strcmp(obd_jobid_var, JOBSTATS_NODELOCAL) == 0) { + memcpy(tmp_jobid, obd_jobid_node, LUSTRE_JOBID_SIZE); + GOTO(out, rc = 0); + } /* Use process name + fsuid as jobid */ if (strcmp(obd_jobid_var, JOBSTATS_PROCNAME_UID) == 0) { - snprintf(jobid, JOBSTATS_JOBID_SIZE, "%s.%u", + snprintf(tmp_jobid, LUSTRE_JOBID_SIZE, "%s.%u", current_comm(), from_kuid(&init_user_ns, current_fsuid())); - RETURN(0); + GOTO(out, rc = 0); } - rc = cfs_get_environ(obd_jobid_var, jobid, &jobid_len); + rc = cfs_get_environ(obd_jobid_var, tmp_jobid, &jobid_len); if (rc) { if (rc == -EOVERFLOW) { /* For the PBS_JOBID and LOADL_STEP_ID keys (which are @@ -173,32 +172,20 @@ int lustre_get_jobid(char *jobid) obd_jobid_var, rc); } } - RETURN(rc); -} -EXPORT_SYMBOL(lustre_get_jobid); -int obd_alloc_fail(const void *ptr, const char *name, const char *type, - size_t size, const char *file, int line) -{ - if (ptr == NULL || - (cfs_rand() & OBD_ALLOC_FAIL_MASK) < obd_alloc_fail_rate) { - CERROR("%s%salloc of %s ("LPU64" bytes) failed at %s:%d\n", - ptr ? "force " :"", type, name, (__u64)size, file, - line); - CERROR(LPU64" total bytes and "LPU64" total pages " - "("LPU64" bytes) allocated by Lustre, " - "%d total bytes by LNET\n", - obd_memory_sum(), - obd_pages_sum() << PAGE_CACHE_SHIFT, - obd_pages_sum(), - atomic_read(&libcfs_kmemory)); - return 1; - } - return 0; +out: + if (rc != 0) + RETURN(rc); + + /* Only replace the job ID if it changed. */ + if (strcmp(jobid, tmp_jobid) != 0) + memcpy(jobid, tmp_jobid, jobid_len); + + RETURN(0); } -EXPORT_SYMBOL(obd_alloc_fail); +EXPORT_SYMBOL(lustre_get_jobid); -int class_resolve_dev_name(__u32 len, const char *name) +static int class_resolve_dev_name(__u32 len, const char *name) { int rc; int dev; @@ -245,7 +232,7 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) } CDEBUG(D_IOCTL, "cmd = %x\n", cmd); - if (obd_ioctl_getdata(&buf, &len, (void *)arg)) { + if (obd_ioctl_getdata(&buf, &len, (void __user *)arg)) { CERROR("OBD ioctl: data error\n"); RETURN(-EINVAL); } @@ -273,24 +260,24 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) GOTO(out, err); } - case OBD_GET_VERSION: - if (!data->ioc_inlbuf1) { - CERROR("No buffer passed in ioctl\n"); - GOTO(out, err = -EINVAL); - } + case OBD_GET_VERSION: + if (!data->ioc_inlbuf1) { + CERROR("No buffer passed in ioctl\n"); + GOTO(out, err = -EINVAL); + } - if (strlen(BUILD_VERSION) + 1 > data->ioc_inllen1) { - CERROR("ioctl buffer too small to hold version\n"); - GOTO(out, err = -EINVAL); - } + if (strlen(LUSTRE_VERSION_STRING) + 1 > data->ioc_inllen1) { + CERROR("ioctl buffer too small to hold version\n"); + GOTO(out, err = -EINVAL); + } - memcpy(data->ioc_bulk, BUILD_VERSION, - strlen(BUILD_VERSION) + 1); + memcpy(data->ioc_bulk, LUSTRE_VERSION_STRING, + strlen(LUSTRE_VERSION_STRING) + 1); - err = obd_ioctl_popdata((void *)arg, data, len); - if (err) - err = -EFAULT; - GOTO(out, err); + err = obd_ioctl_popdata((void __user *)arg, data, len); + if (err) + err = -EFAULT; + GOTO(out, err); case OBD_IOC_NAME2DEV: { /* Resolve a device name. This does not change the @@ -304,7 +291,8 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) if (dev < 0) GOTO(out, err = -EINVAL); - err = obd_ioctl_popdata((void *)arg, data, sizeof(*data)); + err = obd_ioctl_popdata((void __user *)arg, data, + sizeof(*data)); if (err) err = -EFAULT; GOTO(out, err); @@ -338,7 +326,8 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) CDEBUG(D_IOCTL, "device name %s, dev %d\n", data->ioc_inlbuf1, dev); - err = obd_ioctl_popdata((void *)arg, data, sizeof(*data)); + err = obd_ioctl_popdata((void __user *)arg, data, + sizeof(*data)); if (err) err = -EFAULT; GOTO(out, err); @@ -374,7 +363,7 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) (int)index, status, obd->obd_type->typ_name, obd->obd_name, obd->obd_uuid.uuid, atomic_read(&obd->obd_refcount)); - err = obd_ioctl_popdata((void *)arg, data, len); + err = obd_ioctl_popdata((void __user *)arg, data, len); GOTO(out, err = 0); } @@ -422,7 +411,7 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) if (err) GOTO(out, err); - err = obd_ioctl_popdata((void *)arg, data, len); + err = obd_ioctl_popdata((void __user *)arg, data, len); if (err) err = -EFAULT; GOTO(out, err); @@ -435,76 +424,68 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) RETURN(err); } /* class_handle_ioctl */ -#ifdef __KERNEL__ -extern struct miscdevice obd_psdev; -#else -struct miscdevice obd_psdev; -#endif - #define OBD_INIT_CHECK #ifdef OBD_INIT_CHECK -int obd_init_checks(void) +static int obd_init_checks(void) { __u64 u64val, div64val; char buf[64]; int len, ret = 0; - CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s\n", LPU64, LPD64, LPX64); - - CDEBUG(D_INFO, "OBD_OBJECT_EOF = "LPX64"\n", (__u64)OBD_OBJECT_EOF); + CDEBUG(D_INFO, "OBD_OBJECT_EOF = %#llx\n", (__u64)OBD_OBJECT_EOF); u64val = OBD_OBJECT_EOF; - CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val); + CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val); if (u64val != OBD_OBJECT_EOF) { - CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n", + CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n", u64val, (int)sizeof(u64val)); ret = -EINVAL; } - len = snprintf(buf, sizeof(buf), LPX64, u64val); + len = snprintf(buf, sizeof(buf), "%#llx", u64val); if (len != 18) { - CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len); + CWARN("u64 hex wrong length! strlen(%s)=%d != 18\n", buf, len); ret = -EINVAL; } div64val = OBD_OBJECT_EOF; - CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val); + CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val); if (u64val != OBD_OBJECT_EOF) { - CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n", + CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n", u64val, (int)sizeof(u64val)); ret = -EOVERFLOW; } if (u64val >> 8 != OBD_OBJECT_EOF >> 8) { - CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n", + CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n", u64val, (int)sizeof(u64val)); return -EOVERFLOW; } if (do_div(div64val, 256) != (u64val & 255)) { - CERROR("do_div("LPX64",256) != "LPU64"\n", u64val, u64val &255); + CERROR("do_div(%#llx,256) != %llu\n", u64val, u64val & 255); return -EOVERFLOW; } if (u64val >> 8 != div64val) { - CERROR("do_div("LPX64",256) "LPU64" != "LPU64"\n", + CERROR("do_div(%#llx,256) %llu != %llu\n", u64val, div64val, u64val >> 8); return -EOVERFLOW; } - len = snprintf(buf, sizeof(buf), LPX64, u64val); + len = snprintf(buf, sizeof(buf), "%#llx", u64val); if (len != 18) { - CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len); + CWARN("u64 hex wrong length! strlen(%s)=%d != 18\n", buf, len); ret = -EINVAL; } - len = snprintf(buf, sizeof(buf), LPU64, u64val); + len = snprintf(buf, sizeof(buf), "%llu", u64val); if (len != 20) { - CWARN("LPU64 wrong length! strlen(%s)=%d != 20\n", buf, len); + CWARN("u64 wrong length! strlen(%s)=%d != 20\n", buf, len); ret = -EINVAL; } - len = snprintf(buf, sizeof(buf), LPD64, u64val); + len = snprintf(buf, sizeof(buf), "%lld", u64val); if (len != 2) { - CWARN("LPD64 wrong length! strlen(%s)=%d != 2\n", buf, len); + CWARN("s64 wrong length! strlen(%s)=%d != 2\n", buf, len); ret = -EINVAL; } - if ((u64val & ~CFS_PAGE_MASK) >= PAGE_CACHE_SIZE) { - CWARN("mask failed: u64val "LPU64" >= "LPU64"\n", u64val, - (__u64)PAGE_CACHE_SIZE); + if ((u64val & ~PAGE_MASK) >= PAGE_SIZE) { + CWARN("mask failed: u64val %llu >= %llu\n", u64val, + (__u64)PAGE_SIZE); ret = -EINVAL; } @@ -514,51 +495,39 @@ int obd_init_checks(void) #define obd_init_checks() do {} while(0) #endif -extern int class_procfs_init(void); -extern int class_procfs_clean(void); - -#ifdef __KERNEL__ -static int __init init_obdclass(void) -#else -int init_obdclass(void) -#endif +static int __init obdclass_init(void) { - int i, err; -#ifdef __KERNEL__ - int lustre_register_fs(void); + int i, err; - for (i = CAPA_SITE_CLIENT; i < CAPA_SITE_MAX; i++) - INIT_LIST_HEAD(&capa_list[i]); -#endif + spin_lock_init(&obd_stale_export_lock); + INIT_LIST_HEAD(&obd_stale_exports); + atomic_set(&obd_stale_export_num, 0); - LCONSOLE_INFO("Lustre: Build Version: "BUILD_VERSION"\n"); + LCONSOLE_INFO("Lustre: Build Version: "LUSTRE_VERSION_STRING"\n"); spin_lock_init(&obd_types_lock); - obd_zombie_impexp_init(); -#ifdef LPROCFS - obd_memory = lprocfs_alloc_stats(OBD_STATS_NUM, + obd_zombie_impexp_init(); +#ifdef CONFIG_PROC_FS + obd_memory = lprocfs_alloc_stats(OBD_STATS_NUM, LPROCFS_STATS_FLAG_NONE | LPROCFS_STATS_FLAG_IRQ_SAFE); - if (obd_memory == NULL) { - CERROR("kmalloc of 'obd_memory' failed\n"); - RETURN(-ENOMEM); - } + if (obd_memory == NULL) { + CERROR("kmalloc of 'obd_memory' failed\n"); + RETURN(-ENOMEM); + } - lprocfs_counter_init(obd_memory, OBD_MEMORY_STAT, - LPROCFS_CNTR_AVGMINMAX, - "memused", "bytes"); - lprocfs_counter_init(obd_memory, OBD_MEMORY_PAGES_STAT, - LPROCFS_CNTR_AVGMINMAX, - "pagesused", "pages"); + lprocfs_counter_init(obd_memory, OBD_MEMORY_STAT, + LPROCFS_CNTR_AVGMINMAX, + "memused", "bytes"); #endif - err = obd_init_checks(); - if (err == -EOVERFLOW) - return err; + err = obd_init_checks(); + if (err == -EOVERFLOW) + return err; - class_init_uuidlist(); - err = class_handle_init(); - if (err) - return err; + class_init_uuidlist(); + err = class_handle_init(); + if (err) + return err; INIT_LIST_HEAD(&obd_types); @@ -568,32 +537,26 @@ int init_obdclass(void) return err; } - /* This struct is already zeroed for us (static global) */ - for (i = 0; i < class_devno_max(); i++) - obd_devs[i] = NULL; + /* This struct is already zeroed for us (static global) */ + for (i = 0; i < class_devno_max(); i++) + obd_devs[i] = NULL; - /* Default the dirty page cache cap to 1/2 of system memory. - * For clients with less memory, a larger fraction is needed - * for other purposes (mostly for BGL). */ - if (totalram_pages <= 512 << (20 - PAGE_CACHE_SHIFT)) + /* Default the dirty page cache cap to 1/2 of system memory. + * For clients with less memory, a larger fraction is needed + * for other purposes (mostly for BGL). */ + if (totalram_pages <= 512 << (20 - PAGE_SHIFT)) obd_max_dirty_pages = totalram_pages / 4; else obd_max_dirty_pages = totalram_pages / 2; - err = obd_init_caches(); - if (err) - return err; -#ifdef __KERNEL__ - err = class_procfs_init(); - if (err) - return err; -#endif - - err = lu_global_init(); + err = obd_init_caches(); + if (err) + return err; + err = class_procfs_init(); if (err) return err; - err = lu_capainfo_init(); + err = lu_global_init(); if (err) return err; @@ -601,7 +564,7 @@ int init_obdclass(void) if (err != 0) return err; -#if defined(__KERNEL__) && defined(HAVE_SERVER_SUPPORT) +#ifdef HAVE_SERVER_SUPPORT err = dt_global_init(); if (err != 0) return err; @@ -609,81 +572,59 @@ int init_obdclass(void) err = lu_ucred_global_init(); if (err != 0) return err; -#endif +#endif /* HAVE_SERVER_SUPPORT */ err = llog_info_init(); if (err) return err; -#ifdef __KERNEL__ - err = lustre_register_fs(); -#endif + err = lustre_register_fs(); - return err; + return err; } void obd_update_maxusage(void) { - __u64 max1, max2; + __u64 max; - max1 = obd_pages_sum(); - max2 = obd_memory_sum(); + max = obd_memory_sum(); spin_lock(&obd_updatemax_lock); - if (max1 > obd_max_pages) - obd_max_pages = max1; - if (max2 > obd_max_alloc) - obd_max_alloc = max2; + if (max > obd_max_alloc) + obd_max_alloc = max; spin_unlock(&obd_updatemax_lock); } EXPORT_SYMBOL(obd_update_maxusage); -#ifdef LPROCFS +#ifdef CONFIG_PROC_FS __u64 obd_memory_max(void) { __u64 ret; + obd_update_maxusage(); spin_lock(&obd_updatemax_lock); ret = obd_max_alloc; spin_unlock(&obd_updatemax_lock); return ret; } -EXPORT_SYMBOL(obd_memory_max); +#endif /* CONFIG_PROC_FS */ -__u64 obd_pages_max(void) +static void __exit obdclass_exit(void) { - __u64 ret; - - spin_lock(&obd_updatemax_lock); - ret = obd_max_pages; - spin_unlock(&obd_updatemax_lock); - - return ret; -} -EXPORT_SYMBOL(obd_pages_max); -#endif - -/* liblustre doesn't call cleanup_obdclass, apparently. we carry on in this - * ifdef to the end of the file to cover module and versioning goo.*/ -#ifdef __KERNEL__ -static void cleanup_obdclass(void) -{ - int lustre_unregister_fs(void); - __u64 memory_leaked, pages_leaked; - __u64 memory_max, pages_max; - ENTRY; + __u64 memory_leaked; + __u64 memory_max; + ENTRY; - lustre_unregister_fs(); + lustre_unregister_fs(); misc_deregister(&obd_psdev); llog_info_fini(); #ifdef HAVE_SERVER_SUPPORT lu_ucred_global_fini(); dt_global_fini(); -#endif +#endif /* HAVE_SERVER_SUPPORT */ cl_global_fini(); - lu_capainfo_fini(); lu_global_fini(); obd_cleanup_caches(); @@ -694,27 +635,24 @@ static void cleanup_obdclass(void) class_handle_cleanup(); class_exit_uuidlist(); obd_zombie_impexp_stop(); + LASSERT(list_empty(&obd_stale_exports)); memory_leaked = obd_memory_sum(); - pages_leaked = obd_pages_sum(); memory_max = obd_memory_max(); - pages_max = obd_pages_max(); lprocfs_free_stats(&obd_memory); CDEBUG((memory_leaked) ? D_ERROR : D_INFO, - "obd_memory max: "LPU64", leaked: "LPU64"\n", + "obd_memory max: %llu, leaked: %llu\n", memory_max, memory_leaked); - CDEBUG((pages_leaked) ? D_ERROR : D_INFO, - "obd_memory_pages max: "LPU64", leaked: "LPU64"\n", - pages_max, pages_leaked); EXIT; } -MODULE_AUTHOR("Sun Microsystems, Inc. "); -MODULE_DESCRIPTION("Lustre Class Driver Build Version: " BUILD_VERSION); +MODULE_AUTHOR("OpenSFS, Inc. "); +MODULE_DESCRIPTION("Lustre Class Driver"); +MODULE_VERSION(LUSTRE_VERSION_STRING); MODULE_LICENSE("GPL"); -cfs_module(obdclass, LUSTRE_VERSION_STRING, init_obdclass, cleanup_obdclass); -#endif +module_init(obdclass_init); +module_exit(obdclass_exit);