X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Fclass_obd.c;h=7d2d3c911bce6500c24219ef8c61fa48ef9a3c8c;hb=56cc9aeb7151f908ab9cac034ceaf11098bac6a4;hp=420a3fb1d2d07bb1ea8c335c14def1ab52728239;hpb=b191d0b1a44458bb3ecebb0096fb3d373c500e21;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c index 420a3fb..7d2d3c9 100644 --- a/lustre/obdclass/class_obd.c +++ b/lustre/obdclass/class_obd.c @@ -1,157 +1,162 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Copyright (C) 2001, 2002 Cluster File Systems, Inc. + * GPL HEADER START * - * This code is issued under the GNU General Public License. - * See the file COPYING in this distribution + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * These are the only exported functions, they provide some generic - * infrastructure for managing object devices + * 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. * - * Object Devices Class Driver + * 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). + * + * 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. + * + * 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 EXPORT_SYMTAB -#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 #define DEBUG_SUBSYSTEM S_CLASS +#ifndef EXPORT_SYMTAB +# define EXPORT_SYMTAB +#endif +#ifndef __KERNEL__ +# include +#else +# include +#endif -#include -#include -#include -#include -#include -#include /* for PTL_MD_MAX_IOV */ -#include - -struct semaphore obd_conf_sem; /* serialize configuration commands */ -struct obd_device obd_dev[MAX_OBD_DEVICES]; -struct list_head obd_types; -unsigned long obd_memory; - -/* The following are visible and mutable through /proc/sys/lustre/. */ -unsigned long obd_fail_loc; -unsigned long obd_timeout = 100; -char obd_recovery_upcall[128] = "/usr/lib/lustre/ha_assist"; - -extern struct obd_type *class_nm_to_type(char *nm); +#include +#include +#include +#include +#include +#include +#include +#include "llog_internal.h" + +#ifndef __KERNEL__ +/* liblustre workaround */ +cfs_atomic_t libcfs_kmemory = {0}; +#endif -/* opening /dev/obd */ -static int obd_class_open(struct inode * inode, struct file * file) -{ - ENTRY; +struct obd_device *obd_devs[MAX_OBD_DEVICES]; +cfs_list_t obd_types; +cfs_spinlock_t obd_dev_lock = CFS_SPIN_LOCK_UNLOCKED; - file->private_data = NULL; - CDEBUG(D_IOCTL, "MOD_INC_USE for open: count = %d\n", - atomic_read(&(THIS_MODULE)->uc.usecount)); - MOD_INC_USE_COUNT; - RETURN(0); -} +#ifndef __KERNEL__ +__u64 obd_max_pages = 0; +__u64 obd_max_alloc = 0; +__u64 obd_alloc; +__u64 obd_pages; +#endif -/* closing /dev/obd */ -static int obd_class_release(struct inode * inode, struct file * file) +/* The following are visible and mutable through /proc/sys/lustre/. */ +unsigned int obd_debug_peer_on_timeout; +unsigned int obd_dump_on_timeout; +unsigned int obd_dump_on_eviction; +unsigned int obd_max_dirty_pages = 256; +unsigned int obd_timeout = OBD_TIMEOUT_DEFAULT; /* seconds */ +unsigned int ldlm_timeout = LDLM_TIMEOUT_DEFAULT; /* seconds */ +/* Adaptive timeout defs here instead of ptlrpc module for /proc/sys/ access */ +unsigned int at_min = 0; +unsigned int at_max = 600; +unsigned int at_history = 600; +int at_early_margin = 5; +int at_extra = 30; + +cfs_atomic_t obd_dirty_pages; +cfs_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) { - ENTRY; - - // XXX drop lsm, connections here - if (file->private_data) - file->private_data = NULL; - - CDEBUG(D_IOCTL, "MOD_DEC_USE for close: count = %d\n", - atomic_read(&(THIS_MODULE)->uc.usecount) - 1); - MOD_DEC_USE_COUNT; - RETURN(0); + CWARN("obd_fail_loc = %lx\n", obd_fail_loc); + return obd_fail_loc; } +#endif static inline void obd_data2conn(struct lustre_handle *conn, struct obd_ioctl_data *data) { - conn->addr = data->ioc_addr; + 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_addr = conn->addr; data->ioc_cookie = conn->cookie; } -static void forcibly_detach_exports(struct obd_device *obd) +int class_resolve_dev_name(__u32 len, const char *name) { int rc; - struct list_head *tmp, *n; - struct lustre_handle fake_conn; - - CDEBUG(D_IOCTL, "OBD device %d (%p) has exports, " - "disconnecting them", obd->obd_minor, obd); - list_for_each_safe(tmp, n, &obd->obd_exports) { - struct obd_export *exp = list_entry(tmp, struct obd_export, - exp_obd_chain); - fake_conn.addr = (__u64)(unsigned long)exp; - fake_conn.cookie = exp->exp_cookie; - rc = obd_disconnect(&fake_conn); - if (rc) { - CDEBUG(D_IOCTL, "disconnecting export %p failed: %d\n", - exp, rc); - } else { - CDEBUG(D_IOCTL, "export %p disconnected\n", exp); - } + int dev; + + ENTRY; + if (!len || !name) { + CERROR("No name passed,!\n"); + GOTO(out, rc = -EINVAL); + } + if (name[len - 1] != 0) { + CERROR("Name not nul terminated!\n"); + GOTO(out, rc = -EINVAL); + } + + CDEBUG(D_IOCTL, "device name %s\n", name); + dev = class_name2dev(name); + if (dev == -1) { + CDEBUG(D_IOCTL, "No device for name %s!\n", name); + GOTO(out, rc = -EINVAL); } + + CDEBUG(D_IOCTL, "device name %s, dev %d\n", name, dev); + rc = dev; + +out: + RETURN(rc); } -/* to control /dev/obd */ -static int obd_class_ioctl (struct inode * inode, struct file * filp, - unsigned int cmd, unsigned long arg) +int class_handle_ioctl(unsigned int cmd, unsigned long arg) { char *buf = NULL; struct obd_ioctl_data *data; - struct obd_device *obd = filp->private_data; - struct lustre_handle conn; - int err = 0, len = 0, serialised = 0; + struct libcfs_debug_ioctl_data *debug_data; + struct obd_device *obd = NULL; + int err = 0, len = 0; ENTRY; - switch (cmd) { - case OBD_IOC_BRW_WRITE: - case OBD_IOC_BRW_READ: - case OBD_IOC_GETATTR: - break; - default: - down(&obd_conf_sem); - serialised = 1; - break; + /* only for debugging */ + 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; } - if (!obd && cmd != OBD_IOC_DEVICE && cmd != TCGETS && - cmd != OBD_IOC_LIST && cmd != OBD_GET_VERSION && - cmd != OBD_IOC_NAME2DEV && cmd != OBD_IOC_NEWDEV) { - CERROR("OBD ioctl: No device\n"); - GOTO(out, err = -EINVAL); - } + 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); @@ -159,57 +164,24 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, data = (struct obd_ioctl_data *)buf; switch (cmd) { - case TCGETS: - GOTO(out, err=-EINVAL); - case OBD_IOC_DEVICE: { - CDEBUG(D_IOCTL, "\n"); - if (data->ioc_dev >= MAX_OBD_DEVICES || data->ioc_dev < 0) { - CERROR("OBD ioctl: DEVICE insufficient devices\n"); - GOTO(out, err=-EINVAL); - } - CDEBUG(D_IOCTL, "device %d\n", data->ioc_dev); + case OBD_IOC_PROCESS_CFG: { + struct lustre_cfg *lcfg; - filp->private_data = &obd_dev[data->ioc_dev]; - GOTO(out, err=0); - } - - 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_flags & OBD_SET_UP) - status = "UP"; - else if (obd->obd_flags & 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, obd->obd_type->typ_refcnt); - buf2 +=l; - remains -=l; - if (remains <= 0) { - CERROR("not enough space for device listing\n"); - break; - } + if (!data->ioc_plen1 || !data->ioc_pbuf1) { + CERROR("No config buffer passed!\n"); + GOTO(out, err = -EINVAL); } - - 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 = cfs_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); } @@ -227,7 +199,7 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, 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); @@ -238,27 +210,13 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, */ int dev; - if (!data->ioc_inllen1 || !data->ioc_inlbuf1 ) { - CERROR("No name passed,!\n"); - GOTO(out, err=-EINVAL); - } - if (data->ioc_inlbuf1[data->ioc_inllen1-1] !=0) { - CERROR("Name not nul terminated!\n"); - GOTO(out, err=-EINVAL); - } - - CDEBUG(D_IOCTL, "device name %s\n", data->ioc_inlbuf1); - dev = class_name2dev(data->ioc_inlbuf1); + dev = class_resolve_dev_name(data->ioc_inllen1, + data->ioc_inlbuf1); data->ioc_dev = dev; - if (dev == -1) { - CDEBUG(D_IOCTL, "No device for name %s!\n", - data->ioc_inlbuf1); - GOTO(out, err=-EINVAL); - } + if (dev < 0) + GOTO(out, err = -EINVAL); - 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); @@ -269,447 +227,426 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, * currently selected device. */ int dev; + struct obd_uuid uuid; if (!data->ioc_inllen1 || !data->ioc_inlbuf1) { CERROR("No UUID passed!\n"); - GOTO(out, err=-EINVAL); + GOTO(out, err = -EINVAL); } - if (data->ioc_inlbuf1[data->ioc_inllen1-1] !=0) { - CERROR("Name not nul terminated!\n"); - GOTO(out, err=-EINVAL); + if (data->ioc_inlbuf1[data->ioc_inllen1 - 1] != 0) { + CERROR("UUID not NUL terminated!\n"); + GOTO(out, err = -EINVAL); } CDEBUG(D_IOCTL, "device name %s\n", data->ioc_inlbuf1); - dev = class_uuid2dev(data->ioc_inlbuf1); + obd_str2uuid(&uuid, data->ioc_inlbuf1); + dev = class_uuid2dev(&uuid); data->ioc_dev = dev; if (dev == -1) { - CDEBUG(D_IOCTL, "No device for name %s!\n", + CDEBUG(D_IOCTL, "No device for UUID %s!\n", data->ioc_inlbuf1); - GOTO(out, err=-EINVAL); + GOTO(out, err = -EINVAL); } 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_NEWDEV: { - int dev = -1; - int i; - - filp->private_data = NULL; - for (i = 0 ; i < MAX_OBD_DEVICES ; i++) { - struct obd_device *obd = &obd_dev[i]; - if (!obd->obd_type) { - filp->private_data = obd; - dev = i; - break; - } - } - - - data->ioc_dev = dev; - if (dev == -1) - GOTO(out, err=-EINVAL); - - err = copy_to_user((void *)arg, data, sizeof(*data)); - if (err) - err = -EFAULT; - 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_ATTACH: { - struct obd_type *type; - int minor; - - /* have we attached a type to this device */ - if (obd->obd_flags & OBD_ATTACHED || obd->obd_type) { - CERROR("OBD: Device %d already typed as %s.\n", - obd->obd_minor, MKSTR(obd->obd_type->typ_name)); - GOTO(out, err=-EBUSY); - } - - if (!data->ioc_inllen1 || !data->ioc_inlbuf1) { - CERROR("No type passed!\n"); - GOTO(out, err=-EINVAL); - } - if (data->ioc_inlbuf1[data->ioc_inllen1-1] !=0) { - CERROR("Type not nul terminated!\n"); - GOTO(out, err=-EINVAL); - } - - CDEBUG(D_IOCTL, "attach type %s name: %s uuid: %s\n", - MKSTR(data->ioc_inlbuf1), - MKSTR(data->ioc_inlbuf2), MKSTR(data->ioc_inlbuf3)); - - /* find the type */ - type = class_nm_to_type(data->ioc_inlbuf1); - if (!type) { - CERROR("OBD: unknown type dev %d\n", obd->obd_minor); - GOTO(out, err=-EINVAL); - } - - minor = obd->obd_minor; - memset(obd, 0, sizeof(*obd)); - obd->obd_minor = minor; - obd->obd_type = type; - INIT_LIST_HEAD(&obd->obd_exports); - INIT_LIST_HEAD(&obd->obd_imports); - spin_lock_init(&obd->obd_dev_lock); - - if (data->ioc_inlbuf2) { - int len = strlen(data->ioc_inlbuf2) + 1; - OBD_ALLOC(obd->obd_name, len); - if (!obd->obd_name) { - CERROR("no memory\n"); - LBUG(); - } - memcpy(obd->obd_name, data->ioc_inlbuf2, len); - } else { - CERROR("WARNING: unnamed obd device\n"); - } - if (data->ioc_inlbuf3) { - int len = strlen(data->ioc_inlbuf3); - if (len >= sizeof(obd->obd_uuid)) { - CERROR("uuid must be < %d bytes long\n", - sizeof(obd->obd_uuid)); - if (obd->obd_name) - OBD_FREE(obd->obd_name, - strlen(obd->obd_name) + 1); - GOTO(out, err=-EINVAL); - } - memcpy(obd->obd_uuid, data->ioc_inlbuf3, len); - } - /* do the attach */ - if (OBP(obd, attach)) - err = OBP(obd,attach)(obd, sizeof(*data), data); - if (err) { - if(data->ioc_inlbuf2) - OBD_FREE(obd->obd_name, strlen(obd->obd_name)+1); - obd->obd_type = NULL; - } else { - obd->obd_flags |= OBD_ATTACHED; - - type->typ_refcnt++; - CDEBUG(D_IOCTL, "OBD: dev %d attached type %s\n", - obd->obd_minor, data->ioc_inlbuf1); - - CDEBUG(D_IOCTL, "MOD_INC_USE for attach: count = %d\n", - atomic_read(&(THIS_MODULE)->uc.usecount)); - MOD_INC_USE_COUNT; - } + case OBD_IOC_GETDEVICE: { + int index = data->ioc_count; + char *status, *str; - GOTO(out, err); - } - - case OBD_IOC_DETACH: { - ENTRY; - if (obd->obd_flags & OBD_SET_UP) { - CERROR("OBD device %d still set up\n", obd->obd_minor); - GOTO(out, err=-EBUSY); - } - if (!(obd->obd_flags & OBD_ATTACHED) ) { - CERROR("OBD device %d not attached\n", obd->obd_minor); - GOTO(out, err=-ENODEV); + if (!data->ioc_inlbuf1) { + CERROR("No buffer passed in ioctl\n"); + GOTO(out, err = -EINVAL); } - if (!list_empty(&obd->obd_exports)) { - if (!data->ioc_inlbuf1 || data->ioc_inlbuf1[0] != 'F') { - CERROR("OBD device %d (%p) has exports\n", - obd->obd_minor, obd); - GOTO(out, err=-EBUSY); - } - forcibly_detach_exports(obd); + if (data->ioc_inllen1 < 128) { + CERROR("ioctl buffer too small to hold version\n"); + GOTO(out, err = -EINVAL); } - if (OBP(obd, detach)) - err=OBP(obd,detach)(obd); - if (obd->obd_name) { - OBD_FREE(obd->obd_name, strlen(obd->obd_name)+1); - obd->obd_name = NULL; - } + 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, + cfs_atomic_read(&obd->obd_refcount)); + err = obd_ioctl_popdata((void *)arg, data, len); - obd->obd_flags &= ~OBD_ATTACHED; - obd->obd_type->typ_refcnt--; - obd->obd_type = NULL; - CDEBUG(D_IOCTL, "MOD_DEC_USE for detach: count = %d\n", - atomic_read(&(THIS_MODULE)->uc.usecount) - 1); - MOD_DEC_USE_COUNT; GOTO(out, err = 0); } - case OBD_IOC_SETUP: { - /* have we attached a type to this device? */ - if (!(obd->obd_flags & OBD_ATTACHED)) { - CERROR("Device %d not attached\n", obd->obd_minor); - GOTO(out, err=-ENODEV); - } - - /* has this been done already? */ - if ( obd->obd_flags & OBD_SET_UP ) { - CERROR("Device %d already setup (type %s)\n", - obd->obd_minor, obd->obd_type->typ_name); - GOTO(out, err=-EBUSY); - } - - if ( OBT(obd) && OBP(obd, setup) ) - err = obd_setup(obd, sizeof(*data), data); - - if (!err) { - obd->obd_type->typ_refcnt++; - obd->obd_flags |= OBD_SET_UP; - } - - GOTO(out, err); } - case OBD_IOC_CLEANUP: { - /* have we attached a type to this device? */ - if (!(obd->obd_flags & OBD_ATTACHED)) { - CERROR("Device %d not attached\n", obd->obd_minor); - GOTO(out, err=-ENODEV); - } - if ( OBT(obd) && OBP(obd, cleanup) ) - err = obd_cleanup(obd); - - if (!err) { - obd->obd_flags &= ~OBD_SET_UP; - obd->obd_type->typ_refcnt--; - } - GOTO(out, err); + 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); } - case OBD_IOC_CONNECT: { - char * cluuid = "OBD_CLASS_UUID"; - obd_data2conn(&conn, data); - - err = obd_connect(&conn, obd, cluuid, NULL, NULL); - - CDEBUG(D_IOCTL, "assigned export "LPX64"\n", conn.addr); - obd_conn2data(data, &conn); - if (err) - GOTO(out, err); - - err = copy_to_user((void *)arg, data, sizeof(*data)); - if (err) - err = -EFAULT; - // XXX save connection data into file handle - GOTO(out, err); + if (obd == NULL) { + CERROR("OBD ioctl : No Device %d\n", data->ioc_dev); + GOTO(out, err = -EINVAL); } + LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC); - case OBD_IOC_DISCONNECT: { - obd_data2conn(&conn, data); - err = obd_disconnect(&conn); - GOTO(out, err); + if (!obd->obd_set_up || obd->obd_stopping) { + CERROR("OBD ioctl: device not setup %d \n", data->ioc_dev); + GOTO(out, err = -EINVAL); } - case OBD_IOC_DEC_USE_COUNT: { - CDEBUG(D_IOCTL, "MOD_DEC_USE for force dec: count = %d\n", - atomic_read(&(THIS_MODULE)->uc.usecount) - 1); - MOD_DEC_USE_COUNT; - GOTO(out, err=0); + switch(cmd) { + case OBD_IOC_NO_TRANSNO: { + if (!obd->obd_attached) { + CERROR("Device %d not attached\n", obd->obd_minor); + GOTO(out, err = -ENODEV); + } + CDEBUG(D_HA, "%s: disabling committed-transno notification\n", + obd->obd_name); + obd->obd_no_transno = 1; + GOTO(out, err = 0); } - default: - obd_data2conn(&conn, data); - - err = obd_iocontrol(cmd, &conn, len, data, NULL); + default: { + err = obd_iocontrol(cmd, obd->obd_self_export, len, data, NULL); 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); } + } out: if (buf) - OBD_FREE(buf, len); - if (serialised) - up(&obd_conf_sem); + obd_ioctl_freedata(buf, len); RETURN(err); -} /* obd_class_ioctl */ - - +} /* class_handle_ioctl */ -/* 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 */ -}; -/* modules setup */ -#define OBD_MINOR 241 -static struct miscdevice obd_psdev = { - OBD_MINOR, - "obd_psdev", - &obd_psdev_fops -}; -void (*class_signal_connection_failure)(struct ptlrpc_connection *); - -#ifdef CONFIG_HIGHMEM -/* Allow at most 3/4 of the kmap mappings to be consumed by vector I/O - * requests. This avoids deadlocks on servers which have a lot of clients - * doing vector I/O. We don't need to do this for non-vector I/O requests - * because singleton requests will just block on the kmap itself and never - * deadlock waiting for additional kmaps to complete. - * - * If we are a "server" task, we can have at most a single reservation - * in excess of the maximum. This avoids a deadlock when multiple client - * threads are on the same machine as the server threads, and the clients - * have consumed all of the available mappings. As long as a single server - * thread is can make progress, we are guaranteed to avoid deadlock. - */ -#define OBD_KMAP_MAX (LAST_PKMAP * 3 / 4) -static atomic_t obd_kmap_count = ATOMIC_INIT(OBD_KMAP_MAX); -static DECLARE_WAIT_QUEUE_HEAD(obd_kmap_waitq); - -void obd_kmap_get(int count, int server) -{ - //CERROR("getting %d kmap counts (%d/%d)\n", count, - // atomic_read(&obd_kmap_count), OBD_KMAP_MAX); - if (count == 1) - atomic_dec(&obd_kmap_count); - else while (atomic_add_negative(-count, &obd_kmap_count)) { - static long next_show = 0; - static int skipped = 0; - - if (server && atomic_read(&obd_kmap_count) >= -PTL_MD_MAX_IOV) - break; - - CDEBUG(D_OTHER, "negative kmap reserved count: %d\n", - atomic_read(&obd_kmap_count)); - atomic_add(count, &obd_kmap_count); - - if (time_after(jiffies, next_show)) { - CERROR("blocking %s (and %d others) for kmaps\n", - current->comm, skipped); - next_show = jiffies + 5*HZ; - skipped = 0; - } else - skipped++; - wait_event(obd_kmap_waitq, - atomic_read(&obd_kmap_count) >= count); - } -} - -void obd_kmap_put(int count) -{ - atomic_add(count, &obd_kmap_count); - /* Wake up sleepers. Sadly, this wakes up all of the tasks at once. - * We could have something smarter here like: - while (atomic_read(&obd_kmap_count) > 0) - wake_up_nr(obd_kmap_waitq, 1); - although we would need to set somewhere (probably obd_class_init): - obd_kmap_waitq.flags |= WQ_FLAG_EXCLUSIVE; - For now the wait_event() condition will handle this OK I believe. - */ - if (atomic_read(&obd_kmap_count) > 0) - wake_up(&obd_kmap_waitq); -} - -EXPORT_SYMBOL(obd_kmap_get); -EXPORT_SYMBOL(obd_kmap_put); +#ifdef __KERNEL__ +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_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_recovery_upcall); +EXPORT_SYMBOL(ldlm_timeout); +EXPORT_SYMBOL(obd_max_dirty_pages); +EXPORT_SYMBOL(obd_dirty_pages); +EXPORT_SYMBOL(obd_dirty_transit_pages); +EXPORT_SYMBOL(at_min); +EXPORT_SYMBOL(at_max); +EXPORT_SYMBOL(at_extra); +EXPORT_SYMBOL(at_early_margin); +EXPORT_SYMBOL(at_history); EXPORT_SYMBOL(ptlrpc_put_connection_superhack); +EXPORT_SYMBOL(proc_lustre_root); + EXPORT_SYMBOL(class_register_type); EXPORT_SYMBOL(class_unregister_type); +EXPORT_SYMBOL(class_get_type); +EXPORT_SYMBOL(class_put_type); EXPORT_SYMBOL(class_name2dev); +EXPORT_SYMBOL(class_name2obd); EXPORT_SYMBOL(class_uuid2dev); EXPORT_SYMBOL(class_uuid2obd); -EXPORT_SYMBOL(class_new_export); -EXPORT_SYMBOL(class_destroy_export); -EXPORT_SYMBOL(class_connect); +EXPORT_SYMBOL(class_find_client_obd); +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_conn2ldlmimp); EXPORT_SYMBOL(class_disconnect); -EXPORT_SYMBOL(class_disconnect_all); +EXPORT_SYMBOL(class_num2obd); + +/* uuid.c */ EXPORT_SYMBOL(class_uuid_unparse); +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); + +/* 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); + +/* mea.c */ +EXPORT_SYMBOL(mea_name2idx); +EXPORT_SYMBOL(raw_name2idx); + +#define OBD_INIT_CHECK +#ifdef OBD_INIT_CHECK +int obd_init_checks(void) +{ + __u64 u64val, div64val; + char buf[64]; + int len, ret = 0; -EXPORT_SYMBOL(class_signal_connection_failure); -EXPORT_SYMBOL(class_nm_to_type); + 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); + + 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; + } + + 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 ret; +} +#else +#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); + +#ifdef __KERNEL__ static int __init init_obdclass(void) +#else +int init_obdclass(void) +#endif { - struct obd_device *obd; - int err; - int i; + 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 + + 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"); + + cfs_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; - printk(KERN_INFO "OBD class driver Build Version: " BUILD_VERSION - ", info@clusterfs.com\n"); + class_init_uuidlist(); + err = class_handle_init(); + if (err) + return err; - sema_init(&obd_conf_sem, 1); - INIT_LIST_HEAD(&obd_types); + cfs_spin_lock_init(&obd_dev_lock); + CFS_INIT_LIST_HEAD(&obd_types); - if ((err = misc_register(&obd_psdev))) { - CERROR("cannot register %d err %d\n", OBD_MINOR, err); + err = cfs_psdev_register(&obd_psdev); + if (err) { + CERROR("cannot register %d err %d\n", OBD_DEV_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 (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; err = obd_init_caches(); + if (err) + return err; +#ifdef __KERNEL__ + err = class_procfs_init(); + if (err) + return err; +#endif + err = lu_global_init(); if (err) return err; - obd_sysctl_init(); - err = lprocfs_reg_main(); +#ifdef __KERNEL__ + err = lustre_register_fs(); +#endif - return 0; + return err; } -static void __exit cleanup_obdclass(void) +/* 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, err; + 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_flags & 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(); obd_sysctl_clean(); - err = lprocfs_dereg_main(); + class_procfs_clean(); + + class_handle_cleanup(); + class_exit_uuidlist(); + obd_zombie_impexp_stop(); + + 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", + memory_max, memory_leaked); + CDEBUG((pages_leaked) ? D_ERROR : D_INFO, + "obd_memory_pages max: "LPU64", leaked: "LPU64"\n", + pages_max, pages_leaked); - CERROR("obd memory leaked: %ld bytes\n", obd_memory); EXIT; } -/* Check that we're building against the appropriate version of the Lustre - * kernel patch */ -#include -#if (LUSTRE_KERNEL_VERSION != 4) -# error Cannot continue: Your Lustre kernel patch is out of date -#endif - -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