X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Fclass_obd.c;h=498ae5a2eb0ef78cb954f8068a3d55b8da97641b;hb=f123480738a0eba0372053e069089190a5e13bca;hp=01cf385481c9e6d5131a5ba276828948ddb6adb8;hpb=efc75006b820c9b8e186c7650fc24edd5d0509af;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c index 01cf385..498ae5a 100644 --- a/lustre/obdclass/class_obd.c +++ b/lustre/obdclass/class_obd.c @@ -1,89 +1,95 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Object Devices Class Driver + * GPL HEADER START * - * Copyright (C) 2001-2003 Cluster File Systems, Inc. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * This file is part of Lustre, http://www.lustre.org. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. * - * Lustre is free software; you can redistribute it and/or - * modify it under the terms of version 2 of the GNU General Public - * License as published by the Free Software Foundation. + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * Lustre is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * 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 * - * You should have received a copy of the GNU General Public License - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * 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. * - * These are the only exported functions, they provide some generic - * infrastructure for managing object devices + * GPL HEADER END + */ +/* + * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Use is subject to license terms. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. */ #define DEBUG_SUBSYSTEM S_CLASS #ifndef EXPORT_SYMTAB # define EXPORT_SYMTAB #endif -#ifdef __KERNEL__ -#include /* for CONFIG_PROC_FS */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#else +#ifndef __KERNEL__ # include +#else +# include #endif -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include #include "llog_internal.h" -struct semaphore obd_conf_sem; /* serialize configuration commands */ -struct obd_device obd_dev[MAX_OBD_DEVICES]; +#ifndef __KERNEL__ +/* liblustre workaround */ +atomic_t libcfs_kmemory = {0}; +#endif + +struct obd_device *obd_devs[MAX_OBD_DEVICES]; struct list_head obd_types; -atomic_t obd_memory; -int obd_memmax; +spinlock_t obd_dev_lock = SPIN_LOCK_UNLOCKED; -int proc_version; +#ifndef __KERNEL__ +__u64 obd_max_pages = 0; +__u64 obd_max_alloc = 0; +__u64 obd_alloc; +__u64 obd_pages; +#endif /* The following are visible and mutable through /proc/sys/lustre/. */ -unsigned int obd_fail_loc; -unsigned int obd_timeout = 100; -char obd_lustre_upcall[128] = "/usr/lib/lustre/lustre_upcall"; -unsigned int obd_sync_filter; /* = 0, don't sync by default */ +unsigned int obd_debug_peer_on_timeout; +unsigned int obd_dump_on_timeout; +unsigned int obd_dump_on_eviction; +unsigned int obd_timeout = OBD_TIMEOUT_DEFAULT; /* seconds */ +unsigned int ldlm_timeout = LDLM_TIMEOUT_DEFAULT; /* seconds */ +unsigned int obd_max_dirty_pages = 256; +atomic_t obd_dirty_pages; +atomic_t obd_dirty_transit_pages; + +cfs_waitq_t obd_race_waitq; +int obd_race_state; #ifdef __KERNEL__ +unsigned long obd_print_fail_loc(void) +{ + CWARN("obd_fail_loc = %lx\n", obd_fail_loc); + return obd_fail_loc; +} + /* opening /dev/obd */ -static int obd_class_open(struct inode * inode, struct file * file) +static int obd_class_open(unsigned long flags, void *args) { ENTRY; @@ -92,7 +98,7 @@ static int obd_class_open(struct inode * inode, struct file * file) } /* closing /dev/obd */ -static int obd_class_release(struct inode * inode, struct file * file) +static int obd_class_release(unsigned long flags, void *args) { ENTRY; @@ -114,11 +120,12 @@ static inline void obd_conn2data(struct obd_ioctl_data *data, data->ioc_cookie = conn->cookie; } -int class_resolve_dev_name(uint32_t len, char *name) +int class_resolve_dev_name(__u32 len, const char *name) { int rc; int dev; + ENTRY; if (!len || !name) { CERROR("No name passed,!\n"); GOTO(out, rc = -EINVAL); @@ -146,46 +153,20 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) { char *buf = NULL; struct obd_ioctl_data *data; - struct portals_debug_ioctl_data *debug_data; + struct libcfs_debug_ioctl_data *debug_data; struct obd_device *obd = NULL; - int err = 0, len = 0, serialised = 0; + int err = 0, len = 0; ENTRY; - if (current->fsuid != 0) - RETURN(err = -EACCES); - - if ((cmd & 0xffffff00) == ((int)'T') << 8) /* ignore all tty ioctls */ - RETURN(err = -ENOTTY); - /* only for debugging */ - if (cmd == PTL_IOC_DEBUG_MASK) { - debug_data = (struct portals_debug_ioctl_data*)arg; - portal_subsystem_debug = debug_data->subs; - portal_debug = debug_data->debug; + if (cmd == LIBCFS_IOC_DEBUG_MASK) { + debug_data = (struct libcfs_debug_ioctl_data*)arg; + libcfs_subsystem_debug = debug_data->subs; + libcfs_debug = debug_data->debug; return 0; } - switch (cmd) { - case OBD_IOC_BRW_WRITE: - case OBD_IOC_BRW_READ: - case OBD_IOC_GETATTR: - case ECHO_IOC_ENQUEUE: - case ECHO_IOC_CANCEL: - case OBD_IOC_CLIENT_RECOVER: - case OBD_IOC_CATLOGLIST: - case OBD_IOC_LLOG_INFO: - case OBD_IOC_LLOG_PRINT: - case OBD_IOC_LLOG_CANCEL: - case OBD_IOC_LLOG_CHECK: - case OBD_IOC_LLOG_REMOVE: - break; - default: - down(&obd_conf_sem); - serialised = 1; - break; - } - - CDEBUG(D_IOCTL, "cmd = %x, obd = %p\n", cmd, obd); + CDEBUG(D_IOCTL, "cmd = %x\n", cmd); if (obd_ioctl_getdata(&buf, &len, (void *)arg)) { CERROR("OBD ioctl: data error\n"); GOTO(out, err = -EINVAL); @@ -194,71 +175,22 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) switch (cmd) { case OBD_IOC_PROCESS_CFG: { - char *buf; struct lustre_cfg *lcfg; - /* FIXME hack to liblustre dump, remove when switch - to zeroconf */ -#ifndef __KERNEL__ - data->ioc_pbuf1 = data->ioc_inlbuf1; - data->ioc_plen1 = data->ioc_inllen1; -#endif if (!data->ioc_plen1 || !data->ioc_pbuf1) { CERROR("No config buffer passed!\n"); GOTO(out, err = -EINVAL); } - err = lustre_cfg_getdata(&buf, data->ioc_plen1, - data->ioc_pbuf1, 0); - if (err) - GOTO(out, err); - lcfg = (struct lustre_cfg* ) buf; - - err = class_process_config(lcfg); - lustre_cfg_freedata(buf, data->ioc_plen1); - GOTO(out, err); - } - - case OBD_IOC_LIST: { - int i; - char *buf2 = data->ioc_bulk; - int remains = data->ioc_inllen1; - - if (!data->ioc_inlbuf1) { - CERROR("No buffer passed!\n"); - GOTO(out, err = -EINVAL); - } - - - for (i = 0 ; i < MAX_OBD_DEVICES ; i++) { - int l; - char *status; - struct obd_device *obd = &obd_dev[i]; - - if (!obd->obd_type) - continue; - if (obd->obd_stopping) - status = "ST"; - else if (obd->obd_set_up) - status = "UP"; - else if (obd->obd_attached) - status = "AT"; - else - status = "-"; - l = snprintf(buf2, remains, "%2d %s %s %s %s %d\n", - i, status, obd->obd_type->typ_name, - obd->obd_name, obd->obd_uuid.uuid, - obd->obd_type->typ_refcnt); - buf2 +=l; - remains -=l; - if (remains <= 0) { - CERROR("not enough space for device listing\n"); - break; - } - } - - err = copy_to_user((void *)arg, data, len); - if (err) - err = -EFAULT; + OBD_ALLOC(lcfg, data->ioc_plen1); + if (lcfg == NULL) + GOTO(out, err = -ENOMEM); + err = copy_from_user(lcfg, data->ioc_pbuf1, data->ioc_plen1); + if (!err) + err = lustre_cfg_sanity_check(lcfg, data->ioc_plen1); + if (!err) + err = class_process_config(lcfg); + + OBD_FREE(lcfg, data->ioc_plen1); GOTO(out, err); } @@ -276,7 +208,7 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) memcpy(data->ioc_bulk, BUILD_VERSION, strlen(BUILD_VERSION) + 1); - err = copy_to_user((void *)arg, data, len); + err = obd_ioctl_popdata((void *)arg, data, len); if (err) err = -EFAULT; GOTO(out, err); @@ -293,7 +225,7 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) if (dev < 0) GOTO(out, err = -EINVAL); - err = copy_to_user((void *)arg, data, sizeof(*data)); + err = obd_ioctl_popdata((void *)arg, data, sizeof(*data)); if (err) err = -EFAULT; GOTO(out, err); @@ -327,29 +259,75 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) CDEBUG(D_IOCTL, "device name %s, dev %d\n", data->ioc_inlbuf1, dev); - err = copy_to_user((void *)arg, data, sizeof(*data)); + err = obd_ioctl_popdata((void *)arg, data, sizeof(*data)); if (err) err = -EFAULT; GOTO(out, err); } - case OBD_IOC_CLOSE_UUID: { - struct lustre_peer peer; - CDEBUG(D_IOCTL, "closing all connections to uuid %s\n", + CDEBUG(D_IOCTL, "closing all connections to uuid %s (NOOP)\n", data->ioc_inlbuf1); - lustre_uuid_to_peer(data->ioc_inlbuf1, &peer); + GOTO(out, err = 0); + } + + case OBD_IOC_GETDEVICE: { + int index = data->ioc_count; + char *status, *str; + + if (!data->ioc_inlbuf1) { + CERROR("No buffer passed in ioctl\n"); + GOTO(out, err = -EINVAL); + } + if (data->ioc_inllen1 < 128) { + CERROR("ioctl buffer too small to hold version\n"); + GOTO(out, err = -EINVAL); + } + + obd = class_num2obd(index); + if (!obd) + GOTO(out, err = -ENOENT); + + if (obd->obd_stopping) + status = "ST"; + else if (obd->obd_set_up) + status = "UP"; + else if (obd->obd_attached) + status = "AT"; + else + status = "--"; + str = (char *)data->ioc_bulk; + 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, + atomic_read(&obd->obd_refcount)); + err = obd_ioctl_popdata((void *)arg, data, len); + GOTO(out, err = 0); } } - if (data->ioc_dev >= MAX_OBD_DEVICES) { + if (data->ioc_dev == OBD_DEV_BY_DEVNAME) { + if (data->ioc_inllen4 <= 0 || data->ioc_inlbuf4 == NULL) + GOTO(out, err = -EINVAL); + if (strnlen(data->ioc_inlbuf4, MAX_OBD_NAME) >= MAX_OBD_NAME) + GOTO(out, err = -EINVAL); + obd = class_name2obd(data->ioc_inlbuf4); + } else if (data->ioc_dev < class_devno_max()) { + obd = class_num2obd(data->ioc_dev); + } else { CERROR("OBD ioctl: No device\n"); GOTO(out, err = -EINVAL); - } - obd = &obd_dev[data->ioc_dev]; - if (!(obd && obd->obd_set_up) || obd->obd_stopping) { + } + + if (obd == NULL) { + CERROR("OBD ioctl : No Device %d\n", data->ioc_dev); + GOTO(out, err = -EINVAL); + } + LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC); + + if (!obd->obd_set_up || obd->obd_stopping) { CERROR("OBD ioctl: device not setup %d \n", data->ioc_dev); GOTO(out, err = -EINVAL); } @@ -360,9 +338,8 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) CERROR("Device %d not attached\n", obd->obd_minor); GOTO(out, err = -ENODEV); } - CDEBUG(D_IOCTL, - "disabling committed-transno notifications on %d\n", - obd->obd_minor); + CDEBUG(D_HA, "%s: disabling committed-transno notification\n", + obd->obd_name); obd->obd_no_transno = 1; GOTO(out, err = 0); } @@ -372,7 +349,7 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) if (err) GOTO(out, err); - err = copy_to_user((void *)arg, data, len); + err = obd_ioctl_popdata((void *)arg, data, len); if (err) err = -EFAULT; GOTO(out, err); @@ -382,8 +359,6 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) out: if (buf) obd_ioctl_freedata(buf, len); - if (serialised) - up(&obd_conf_sem); RETURN(err); } /* class_handle_ioctl */ @@ -392,39 +367,40 @@ int class_handle_ioctl(unsigned int cmd, unsigned long arg) #define OBD_MINOR 241 #ifdef __KERNEL__ /* to control /dev/obd */ -static int obd_class_ioctl(struct inode *inode, struct file *filp, - unsigned int cmd, unsigned long arg) +static int obd_class_ioctl (struct cfs_psdev_file *pfile, unsigned long cmd, + void *arg) { - return class_handle_ioctl(cmd, arg); + return class_handle_ioctl(cmd, (unsigned long)arg); } /* declare character device */ -static struct file_operations obd_psdev_fops = { - ioctl: obd_class_ioctl, /* ioctl */ - open: obd_class_open, /* open */ - release: obd_class_release, /* release */ +struct cfs_psdev_ops obd_psdev_ops = { + /* .p_open = */ obd_class_open, /* open */ + /* .p_close = */ obd_class_release, /* release */ + /* .p_read = */ NULL, + /* .p_write = */ NULL, + /* .p_ioctl = */ obd_class_ioctl /* ioctl */ }; -/* modules setup */ -static struct miscdevice obd_psdev = { - OBD_MINOR, - "obd_psdev", - &obd_psdev_fops -}; +extern cfs_psdev_t obd_psdev; #else void *obd_psdev = NULL; #endif -EXPORT_SYMBOL(obd_dev); -EXPORT_SYMBOL(obdo_cachep); -EXPORT_SYMBOL(obd_memory); -EXPORT_SYMBOL(obd_memmax); -EXPORT_SYMBOL(obd_fail_loc); +EXPORT_SYMBOL(obd_devs); +EXPORT_SYMBOL(obd_print_fail_loc); +EXPORT_SYMBOL(obd_race_waitq); +EXPORT_SYMBOL(obd_race_state); +EXPORT_SYMBOL(obd_debug_peer_on_timeout); +EXPORT_SYMBOL(obd_dump_on_timeout); +EXPORT_SYMBOL(obd_dump_on_eviction); EXPORT_SYMBOL(obd_timeout); -EXPORT_SYMBOL(obd_lustre_upcall); -EXPORT_SYMBOL(obd_sync_filter); +EXPORT_SYMBOL(ldlm_timeout); +EXPORT_SYMBOL(obd_max_dirty_pages); +EXPORT_SYMBOL(obd_dirty_pages); +EXPORT_SYMBOL(obd_dirty_transit_pages); EXPORT_SYMBOL(ptlrpc_put_connection_superhack); -EXPORT_SYMBOL(ptlrpc_abort_inflight_superhack); + EXPORT_SYMBOL(proc_lustre_root); EXPORT_SYMBOL(class_register_type); @@ -436,27 +412,14 @@ EXPORT_SYMBOL(class_name2obd); EXPORT_SYMBOL(class_uuid2dev); EXPORT_SYMBOL(class_uuid2obd); EXPORT_SYMBOL(class_find_client_obd); -EXPORT_SYMBOL(__class_export_put); -EXPORT_SYMBOL(class_new_export); -EXPORT_SYMBOL(class_unlink_export); -EXPORT_SYMBOL(class_import_get); -EXPORT_SYMBOL(class_import_put); -EXPORT_SYMBOL(class_new_import); -EXPORT_SYMBOL(class_destroy_import); -EXPORT_SYMBOL(class_connect); +EXPORT_SYMBOL(class_devices_in_group); EXPORT_SYMBOL(class_conn2export); EXPORT_SYMBOL(class_exp2obd); EXPORT_SYMBOL(class_conn2obd); EXPORT_SYMBOL(class_exp2cliimp); EXPORT_SYMBOL(class_conn2cliimp); EXPORT_SYMBOL(class_disconnect); -EXPORT_SYMBOL(class_disconnect_exports); - -EXPORT_SYMBOL(osic_init); -EXPORT_SYMBOL(osic_release); -EXPORT_SYMBOL(osic_add_one); -EXPORT_SYMBOL(osic_wait); -EXPORT_SYMBOL(osic_complete_one); +EXPORT_SYMBOL(class_num2obd); /* uuid.c */ EXPORT_SYMBOL(class_uuid_unparse); @@ -464,241 +427,248 @@ EXPORT_SYMBOL(lustre_uuid_to_peer); EXPORT_SYMBOL(class_handle_hash); EXPORT_SYMBOL(class_handle_unhash); +EXPORT_SYMBOL(class_handle_hash_back); EXPORT_SYMBOL(class_handle2object); +EXPORT_SYMBOL(class_handle_free_cb); -/* config.c */ +/* obd_config.c */ +EXPORT_SYMBOL(class_incref); +EXPORT_SYMBOL(class_decref); EXPORT_SYMBOL(class_get_profile); +EXPORT_SYMBOL(class_del_profile); +EXPORT_SYMBOL(class_del_profiles); EXPORT_SYMBOL(class_process_config); +EXPORT_SYMBOL(class_process_proc_param); EXPORT_SYMBOL(class_config_parse_llog); EXPORT_SYMBOL(class_config_dump_llog); EXPORT_SYMBOL(class_attach); EXPORT_SYMBOL(class_setup); EXPORT_SYMBOL(class_cleanup); EXPORT_SYMBOL(class_detach); +EXPORT_SYMBOL(class_manual_cleanup); -#ifdef LPROCFS -int obd_proc_read_version(char *page, char **start, off_t off, int count, - int *eof, void *data) -{ - *eof = 1; - return snprintf(page, count, "%s\n", BUILD_VERSION); -} +/* mea.c */ +EXPORT_SYMBOL(mea_name2idx); +EXPORT_SYMBOL(raw_name2idx); -int obd_proc_read_pinger(char *page, char **start, off_t off, int count, - int *eof, void *data) +#define OBD_INIT_CHECK +#ifdef OBD_INIT_CHECK +int obd_init_checks(void) { - *eof = 1; - return snprintf(page, count, "%s\n", -#ifdef ENABLE_PINGER - "on" -#else - "off" -#endif - ); -} + __u64 u64val, div64val; + char buf[64]; + int len, ret = 0; -/* Root for /proc/fs/lustre */ -struct proc_dir_entry *proc_lustre_root = NULL; -struct lprocfs_vars lprocfs_base[] = { - { "version", obd_proc_read_version, NULL, NULL }, - { "pinger", obd_proc_read_pinger, NULL, NULL }, - { 0 } -}; + CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s, LPSZ=%s, LPSSZ=%s\n", + LPU64, LPD64, LPX64, LPSZ, LPSSZ); -static void *obd_device_list_seq_start(struct seq_file *p, loff_t*pos) -{ - if (*pos >= MAX_OBD_DEVICES) - return NULL; - return &obd_dev[*pos]; -} + CDEBUG(D_INFO, "OBD_OBJECT_EOF = "LPX64"\n", (__u64)OBD_OBJECT_EOF); -static void obd_device_list_seq_stop(struct seq_file *p, void *v) -{ -} - -static void *obd_device_list_seq_next(struct seq_file *p, void *v, loff_t *pos) -{ - ++*pos; - if (*pos >= MAX_OBD_DEVICES) - return NULL; - return &obd_dev[*pos]; -} - -static int obd_device_list_seq_show(struct seq_file *p, void *v) -{ - struct obd_device *obd = (struct obd_device *)v; - int index = obd - &obd_dev[0]; - char *status; - - if (!obd->obd_type) - return 0; - if (obd->obd_stopping) - status = "ST"; - else if (obd->obd_set_up) - status = "UP"; - else if (obd->obd_attached) - status = "AT"; - else - status = "--"; - - return seq_printf(p, "%3d %s %s %s %s %d\n", - (int)index, status, obd->obd_type->typ_name, - obd->obd_name, obd->obd_uuid.uuid, - atomic_read(&obd->obd_refcount)); -} - -struct seq_operations obd_device_list_sops = { - .start = obd_device_list_seq_start, - .stop = obd_device_list_seq_stop, - .next = obd_device_list_seq_next, - .show = obd_device_list_seq_show, -}; - -static int obd_device_list_open(struct inode *inode, struct file *file) -{ - struct proc_dir_entry *dp = PDE(inode); - struct seq_file *seq; - int rc = seq_open(file, &obd_device_list_sops); - - if (rc) - return rc; + u64val = OBD_OBJECT_EOF; + CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val); + if (u64val != OBD_OBJECT_EOF) { + CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n", + u64val, (int)sizeof(u64val)); + ret = -EINVAL; + } + len = snprintf(buf, sizeof(buf), LPX64, u64val); + if (len != 18) { + CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len); + ret = -EINVAL; + } - seq = file->private_data; - seq->private = dp->data; + div64val = OBD_OBJECT_EOF; + CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val); + if (u64val != OBD_OBJECT_EOF) { + CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n", + u64val, (int)sizeof(u64val)); + ret = -EOVERFLOW; + } + if (u64val >> 8 != OBD_OBJECT_EOF >> 8) { + CERROR("__u64 "LPX64"(%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); + return -EOVERFLOW; + } + if (u64val >> 8 != div64val) { + CERROR("do_div("LPX64",256) "LPU64" != "LPU64"\n", + u64val, div64val, u64val >> 8); + return -EOVERFLOW; + } + len = snprintf(buf, sizeof(buf), LPX64, u64val); + if (len != 18) { + CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len); + ret = -EINVAL; + } + len = snprintf(buf, sizeof(buf), LPU64, u64val); + if (len != 20) { + CWARN("LPU64 wrong length! strlen(%s)=%d != 20\n", buf, len); + ret = -EINVAL; + } + len = snprintf(buf, sizeof(buf), LPD64, u64val); + if (len != 2) { + CWARN("LPD64 wrong length! strlen(%s)=%d != 2\n", buf, len); + ret = -EINVAL; + } + if ((u64val & ~CFS_PAGE_MASK) >= CFS_PAGE_SIZE) { + CWARN("mask failed: u64val "LPU64" >= "LPU64"\n", u64val, + (__u64)CFS_PAGE_SIZE); + ret = -EINVAL; + } - return 0; + return ret; } - -struct file_operations obd_device_list_fops = { - .open = obd_device_list_open, - .read = seq_read, - .llseek = seq_lseek, - .release = seq_release, -}; +#else +#define obd_init_checks() do {} while(0) #endif +extern spinlock_t obd_types_lock; +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 { - struct obd_device *obd; -#ifdef LPROCFS - struct proc_dir_entry *entry; + int i, err; +#ifdef __KERNEL__ + int lustre_register_fs(void); + + for (i = CAPA_SITE_CLIENT; i < CAPA_SITE_MAX; i++) + CFS_INIT_LIST_HEAD(&capa_list[i]); #endif - int err; - int i; - printk(KERN_INFO "Lustre: OBD class driver Build Version: " - BUILD_VERSION", info@clusterfs.com\n"); + LCONSOLE_INFO("OBD class driver, http://www.lustre.org/\n"); + LCONSOLE_INFO(" Lustre Version: "LUSTRE_VERSION_STRING"\n"); + LCONSOLE_INFO(" Build Version: "BUILD_VERSION"\n"); + + spin_lock_init(&obd_types_lock); + cfs_waitq_init(&obd_race_waitq); + obd_zombie_impexp_init(); +#ifdef LPROCFS + obd_memory = lprocfs_alloc_stats(OBD_STATS_NUM, + LPROCFS_STATS_FLAG_NONE); + 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"); +#endif + err = obd_init_checks(); + if (err == -EOVERFLOW) + return err; class_init_uuidlist(); err = class_handle_init(); if (err) return err; - sema_init(&obd_conf_sem, 1); - INIT_LIST_HEAD(&obd_types); + spin_lock_init(&obd_dev_lock); + CFS_INIT_LIST_HEAD(&obd_types); - err = misc_register(&obd_psdev); + err = cfs_psdev_register(&obd_psdev); if (err) { CERROR("cannot register %d err %d\n", OBD_MINOR, err); return err; } - /* This struct is already zerod for us (static global) */ - for (i = 0, obd = obd_dev; i < MAX_OBD_DEVICES; i++, obd++) - obd->obd_minor = i; + /* 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 (num_physpages <= 512 << (20 - CFS_PAGE_SHIFT)) + obd_max_dirty_pages = num_physpages / 4; + else + obd_max_dirty_pages = num_physpages / 2; err = obd_init_caches(); if (err) return err; - #ifdef __KERNEL__ - obd_sysctl_init(); + err = class_procfs_init(); + if (err) + return err; #endif -#ifdef LPROCFS - proc_lustre_root = proc_mkdir("lustre", proc_root_fs); - if (!proc_lustre_root) { - printk(KERN_ERR - "LustreError: error registering /proc/fs/lustre\n"); - RETURN(-ENOMEM); - } - proc_version = lprocfs_add_vars(proc_lustre_root, lprocfs_base, NULL); - entry = create_proc_entry("devices", 0444, proc_lustre_root); - if (entry == NULL) { - printk(KERN_ERR "LustreError: error registering " - "/proc/fs/lustre/devices\n"); - lprocfs_remove(proc_lustre_root); - RETURN(-ENOMEM); - } - entry->proc_fops = &obd_device_list_fops; + err = lu_global_init(); + if (err) + return err; + +#ifdef __KERNEL__ + err = lustre_register_fs(); #endif - return 0; + + return err; } +/* 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 /*__exit*/ cleanup_obdclass(void) -#else static void cleanup_obdclass(void) -#endif { - int i, leaked; + int i; + int lustre_unregister_fs(void); + __u64 memory_leaked, pages_leaked; + __u64 memory_max, pages_max; ENTRY; - misc_deregister(&obd_psdev); - for (i = 0; i < MAX_OBD_DEVICES; i++) { - struct obd_device *obd = &obd_dev[i]; - if (obd->obd_type && obd->obd_set_up && + 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); } } + lu_global_fini(); obd_cleanup_caches(); -#ifdef __KERNEL__ obd_sysctl_clean(); -#endif -#ifdef LPROCFS - if (proc_lustre_root) { - lprocfs_remove(proc_lustre_root); - proc_lustre_root = NULL; - } -#endif + + class_procfs_clean(); class_handle_cleanup(); class_exit_uuidlist(); + obd_zombie_impexp_stop(); + + memory_leaked = obd_memory_sum(); + pages_leaked = obd_pages_sum(); - leaked = atomic_read(&obd_memory); - CDEBUG(leaked ? D_ERROR : D_INFO, - "obd mem max: %d leaked: %d\n", obd_memmax, leaked); + 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", + memory_max, memory_leaked); + CDEBUG((pages_leaked) ? D_ERROR : D_INFO, + "obd_memory_pages max: "LPU64", leaked: "LPU64"\n", + pages_max, pages_leaked); EXIT; } -/* Check that we're building against the appropriate version of the Lustre - * kernel patch */ -#ifdef __KERNEL__ -#include -#define LUSTRE_MIN_VERSION 28 -#define LUSTRE_MAX_VERSION 32 -#if (LUSTRE_KERNEL_VERSION < LUSTRE_MIN_VERSION) -# error Cannot continue: Your Lustre kernel patch is older than the sources -#elif (LUSTRE_KERNEL_VERSION > LUSTRE_MAX_VERSION) -# error Cannot continue: Your Lustre sources are older than the kernel patch -#endif - #else -# warning "Lib Lustre - no versioning information" -#endif - -#ifdef __KERNEL__ -MODULE_AUTHOR("Cluster File Systems, Inc. "); +MODULE_AUTHOR("Sun Microsystems, Inc. "); MODULE_DESCRIPTION("Lustre Class Driver Build Version: " BUILD_VERSION); MODULE_LICENSE("GPL"); -module_init(init_obdclass); -module_exit(cleanup_obdclass); +cfs_module(obdclass, LUSTRE_VERSION_STRING, init_obdclass, cleanup_obdclass); #endif