X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Fclass_obd.c;h=da38c9a248e9ba791610e06d0b7783968f5b8ea5;hp=8d4b47f70f7249835359c504996c1bf2d30bf7c4;hb=8701e7e4b5ec1b34700c95b9b6588f4745730b72;hpb=75a11fe9f6af21d75c75480c2838b00a122fdaca diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c index 8d4b47f..da38c9a 100644 --- a/lustre/obdclass/class_obd.c +++ b/lustre/obdclass/class_obd.c @@ -27,7 +27,7 @@ * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, Whamcloud, Inc. + * Copyright (c) 2011, 2012, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -48,26 +48,35 @@ #include #include #include +#include +#ifdef HAVE_SERVER_SUPPORT +# include +# include +#endif /* HAVE_SERVER_SUPPORT */ +#include #include "llog_internal.h" #ifndef __KERNEL__ /* liblustre workaround */ -cfs_atomic_t libcfs_kmemory = {0}; +atomic_t libcfs_kmemory = {0}; #endif struct obd_device *obd_devs[MAX_OBD_DEVICES]; EXPORT_SYMBOL(obd_devs); -cfs_list_t obd_types; +struct list_head obd_types; DEFINE_RWLOCK(obd_dev_lock); -#ifndef __KERNEL__ __u64 obd_max_pages = 0; __u64 obd_max_alloc = 0; +#ifndef __KERNEL__ __u64 obd_alloc; __u64 obd_pages; #endif +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; @@ -76,7 +85,7 @@ unsigned int obd_dump_on_eviction; EXPORT_SYMBOL(obd_dump_on_eviction); unsigned int obd_max_dirty_pages = 256; EXPORT_SYMBOL(obd_max_dirty_pages); -cfs_atomic_t obd_dirty_pages; +atomic_t obd_dirty_pages; EXPORT_SYMBOL(obd_dirty_pages); unsigned int obd_timeout = OBD_TIMEOUT_DEFAULT; /* seconds */ EXPORT_SYMBOL(obd_timeout); @@ -98,12 +107,17 @@ EXPORT_SYMBOL(at_early_margin); int at_extra = 30; EXPORT_SYMBOL(at_extra); -cfs_atomic_t obd_dirty_transit_pages; +atomic_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 +struct lprocfs_stats *obd_memory = NULL; +EXPORT_SYMBOL(obd_memory); +#endif + /* Get jobid of current process by reading the environment variable * stored in between the "env_start" & "env_end" of task struct. * @@ -130,7 +144,8 @@ int lustre_get_jobid(char *jobid) /* Use process name + fsuid as jobid */ if (strcmp(obd_jobid_var, JOBSTATS_PROCNAME_UID) == 0) { snprintf(jobid, JOBSTATS_JOBID_SIZE, "%s.%u", - cfs_curproc_comm(), cfs_curproc_fsuid()); + current_comm(), + from_kuid(&init_user_ns, current_fsuid())); RETURN(0); } @@ -162,18 +177,26 @@ int lustre_get_jobid(char *jobid) } EXPORT_SYMBOL(lustre_get_jobid); -static inline void obd_data2conn(struct lustre_handle *conn, - struct obd_ioctl_data *data) +int obd_alloc_fail(const void *ptr, const char *name, const char *type, + size_t size, const char *file, int line) { - memset(conn, 0, sizeof *conn); - conn->cookie = data->ioc_cookie; -} - -static inline void obd_conn2data(struct obd_ioctl_data *data, - struct lustre_handle *conn) -{ - data->ioc_cookie = conn->cookie; + 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; } +EXPORT_SYMBOL(obd_alloc_fail); int class_resolve_dev_name(__u32 len, const char *name) { @@ -239,7 +262,7 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) OBD_ALLOC(lcfg, data->ioc_plen1); if (lcfg == NULL) GOTO(out, err = -ENOMEM); - err = cfs_copy_from_user(lcfg, data->ioc_pbuf1, + err = copy_from_user(lcfg, data->ioc_pbuf1, data->ioc_plen1); if (!err) err = lustre_cfg_sanity_check(lcfg, data->ioc_plen1); @@ -321,12 +344,6 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) GOTO(out, err); } - case OBD_IOC_CLOSE_UUID: { - CDEBUG(D_IOCTL, "closing all connections to uuid %s (NOOP)\n", - data->ioc_inlbuf1); - GOTO(out, err = 0); - } - case OBD_IOC_GETDEVICE: { int index = data->ioc_count; char *status, *str; @@ -356,7 +373,7 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) snprintf(str, len - sizeof(*data), "%3d %s %s %s %s %d", (int)index, status, obd->obd_type->typ_name, obd->obd_name, obd->obd_uuid.uuid, - cfs_atomic_read(&obd->obd_refcount)); + atomic_read(&obd->obd_refcount)); err = obd_ioctl_popdata((void *)arg, data, len); GOTO(out, err = 0); @@ -419,9 +436,9 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) } /* class_handle_ioctl */ #ifdef __KERNEL__ -extern cfs_psdev_t obd_psdev; +extern struct miscdevice obd_psdev; #else -void *obd_psdev = NULL; +struct miscdevice obd_psdev; #endif #define OBD_INIT_CHECK @@ -485,9 +502,9 @@ int obd_init_checks(void) CWARN("LPD64 wrong length! strlen(%s)=%d != 2\n", buf, len); ret = -EINVAL; } - if ((u64val & ~CFS_PAGE_MASK) >= CFS_PAGE_SIZE) { + if ((u64val & ~CFS_PAGE_MASK) >= PAGE_CACHE_SIZE) { CWARN("mask failed: u64val "LPU64" >= "LPU64"\n", u64val, - (__u64)CFS_PAGE_SIZE); + (__u64)PAGE_CACHE_SIZE); ret = -EINVAL; } @@ -497,7 +514,6 @@ int obd_init_checks(void) #define obd_init_checks() do {} while(0) #endif -extern cfs_spinlock_t obd_types_lock; extern int class_procfs_init(void); extern int class_procfs_clean(void); @@ -512,12 +528,12 @@ int init_obdclass(void) int lustre_register_fs(void); for (i = CAPA_SITE_CLIENT; i < CAPA_SITE_MAX; i++) - CFS_INIT_LIST_HEAD(&capa_list[i]); + INIT_LIST_HEAD(&capa_list[i]); #endif LCONSOLE_INFO("Lustre: Build Version: "BUILD_VERSION"\n"); - cfs_spin_lock_init(&obd_types_lock); + spin_lock_init(&obd_types_lock); obd_zombie_impexp_init(); #ifdef LPROCFS obd_memory = lprocfs_alloc_stats(OBD_STATS_NUM, @@ -544,13 +560,13 @@ int init_obdclass(void) if (err) return err; - CFS_INIT_LIST_HEAD(&obd_types); + INIT_LIST_HEAD(&obd_types); - err = cfs_psdev_register(&obd_psdev); - if (err) { - CERROR("cannot register %d err %d\n", OBD_DEV_MINOR, err); - return err; - } + err = misc_register(&obd_psdev); + if (err) { + CERROR("cannot register %d err %d\n", OBD_DEV_MINOR, err); + return err; + } /* This struct is already zeroed for us (static global) */ for (i = 0; i < class_devno_max(); i++) @@ -559,10 +575,10 @@ int init_obdclass(void) /* 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 (cfs_num_physpages <= 512 << (20 - CFS_PAGE_SHIFT)) - obd_max_dirty_pages = cfs_num_physpages / 4; - else - obd_max_dirty_pages = cfs_num_physpages / 2; + if (totalram_pages <= 512 << (20 - PAGE_CACHE_SHIFT)) + obd_max_dirty_pages = totalram_pages / 4; + else + obd_max_dirty_pages = totalram_pages / 2; err = obd_init_caches(); if (err) @@ -573,9 +589,27 @@ int init_obdclass(void) return err; #endif - err = lu_global_init(); - if (err) - return err; + err = lu_global_init(); + if (err) + return err; + + err = lu_capainfo_init(); + if (err) + return err; + + err = cl_global_init(); + if (err != 0) + return err; + +#if defined(__KERNEL__) && defined(HAVE_SERVER_SUPPORT) + err = dt_global_init(); + if (err != 0) + return err; + + err = lu_ucred_global_init(); + if (err != 0) + return err; +#endif err = llog_info_init(); if (err) @@ -588,12 +622,53 @@ int init_obdclass(void) return err; } +void obd_update_maxusage(void) +{ + __u64 max1, max2; + + max1 = obd_pages_sum(); + max2 = 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; + spin_unlock(&obd_updatemax_lock); +} +EXPORT_SYMBOL(obd_update_maxusage); + +#ifdef LPROCFS +__u64 obd_memory_max(void) +{ + __u64 ret; + + spin_lock(&obd_updatemax_lock); + ret = obd_max_alloc; + spin_unlock(&obd_updatemax_lock); + + return ret; +} +EXPORT_SYMBOL(obd_memory_max); + +__u64 obd_pages_max(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 i; int lustre_unregister_fs(void); __u64 memory_leaked, pages_leaked; __u64 memory_max, pages_max; @@ -601,18 +676,15 @@ static void cleanup_obdclass(void) lustre_unregister_fs(); - cfs_psdev_deregister(&obd_psdev); - for (i = 0; i < class_devno_max(); i++) { - struct obd_device *obd = class_num2obd(i); - if (obd && obd->obd_set_up && - OBT(obd) && OBP(obd, detach)) { - /* XXX should this call generic detach otherwise? */ - LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC); - OBP(obd, detach)(obd); - } - } + misc_deregister(&obd_psdev); llog_info_fini(); - lu_global_fini(); +#ifdef HAVE_SERVER_SUPPORT + lu_ucred_global_fini(); + dt_global_fini(); +#endif + cl_global_fini(); + lu_capainfo_fini(); + lu_global_fini(); obd_cleanup_caches(); obd_sysctl_clean();