X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Fobd_config.c;h=a6917f109d234f80865cc6f2170489dbbafae260;hb=41ab260642f4923106da3567d7c75e1ca3c61ea4;hp=0d825c7b33ccbbd467de03cf34ea9c77c10cc96a;hpb=350abc09880fc4cc1085f462258bf6e0f7b933f2;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/obd_config.c b/lustre/obdclass/obd_config.c index 0d825c7..a6917f1 100644 --- a/lustre/obdclass/obd_config.c +++ b/lustre/obdclass/obd_config.c @@ -1,54 +1,216 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Copyright (c) 2001-2003 Cluster File Systems, Inc. + * GPL HEADER START * - * This file is part of Lustre, http://www.lustre.org. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * 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 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 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. + * 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 - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * 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 * - * Config API + * 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. + * + * lustre/obdclass/obd_config.c * + * Config API */ #define DEBUG_SUBSYSTEM S_CLASS #ifdef __KERNEL__ -#include /* for request_module() */ -#include -#include -#include -#include -#include +#include +#include #else #include -#include -#include +#include +#include #endif -#include -#include +#include +#include #include +#include +#include + +static lustre_hash_ops_t uuid_hash_ops; +static lustre_hash_ops_t nid_hash_ops; +static lustre_hash_ops_t nid_stat_hash_ops; + +/*********** string parsing utils *********/ + +/* returns 0 if we find this key in the buffer, else 1 */ +int class_find_param(char *buf, char *key, char **valp) +{ + char *ptr; + + if (!buf) + return 1; + + if ((ptr = strstr(buf, key)) == NULL) + return 1; + if (valp) + *valp = ptr + strlen(key); -/* Create a new device and set the type, name and uuid. If - * successful, the new device can be accessed by either name or uuid. + return 0; +} + +/** + * Finds a parameter in \a params and copies it to \a copy. + * + * Leading spaces are skipped. Next space or end of string is the + * parameter terminator with the exception that spaces inside single or double + * quotes get included into a parameter. The parameter is copied into \a copy + * which has to be allocated big enough by a caller, quotes are stripped in + * the copy and the copy is terminated by 0. + * + * On return \a params is set to next parameter or to NULL if last + * parameter is returned. + * + * \retval 0 if parameter is returned in \a copy + * \retval 1 otherwise + * \retval -EINVAL if unbalanced quota is found */ -static int class_attach(struct lustre_cfg *lcfg) +int class_get_next_param(char **params, char *copy) { - struct obd_type *type; - struct obd_device *obd; + char *q1, *q2, *str; + int len; + + str = *params; + while (*str == ' ') + str++; + + if (*str == '\0') { + *params = NULL; + return 1; + } + + while (1) { + q1 = strpbrk(str, " '\""); + if (q1 == NULL) { + len = strlen(str); + memcpy(copy, str, len); + copy[len] = '\0'; + *params = NULL; + return 0; + } + len = q1 - str; + if (*q1 == ' ') { + memcpy(copy, str, len); + copy[len] = '\0'; + *params = str + len; + return 0; + } + + memcpy(copy, str, len); + copy += len; + + /* search for the matching closing quote */ + str = q1 + 1; + q2 = strchr(str, *q1); + if (q2 == NULL) { + CERROR("Unbalanced quota in parameters: \"%s\"\n", + *params); + return -EINVAL; + } + len = q2 - str; + memcpy(copy, str, len); + copy += len; + str = q2 + 1; + } + return 1; +} + +/* returns 0 if this is the first key in the buffer, else 1. + valp points to first char after key. */ +int class_match_param(char *buf, char *key, char **valp) +{ + if (!buf) + return 1; + + if (memcmp(buf, key, strlen(key)) != 0) + return 1; + + if (valp) + *valp = buf + strlen(key); + + return 0; +} + +/* 0 is good nid, + 1 not found + < 0 error + endh is set to next separator */ +int class_parse_nid(char *buf, lnet_nid_t *nid, char **endh) +{ + char tmp, *endp; + + if (!buf) + return 1; + while (*buf == ',' || *buf == ':') + buf++; + if (*buf == ' ' || *buf == '/' || *buf == '\0') + return 1; + + /* nid separators or end of nids */ + endp = strpbrk(buf, ",: /"); + if (endp == NULL) + endp = buf + strlen(buf); + + tmp = *endp; + *endp = '\0'; + *nid = libcfs_str2nid(buf); + if (*nid == LNET_NID_ANY) { + LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", buf); + *endp = tmp; + return -EINVAL; + } + *endp = tmp; + + if (endh) + *endh = endp; + CDEBUG(D_INFO, "Nid %s\n", libcfs_nid2str(*nid)); + return 0; +} + +EXPORT_SYMBOL(class_find_param); +EXPORT_SYMBOL(class_get_next_param); +EXPORT_SYMBOL(class_match_param); +EXPORT_SYMBOL(class_parse_nid); + +/********************** class fns **********************/ + +/** + * Create a new device and set the type, name and uuid. If successful, the new + * device can be accessed by either name or uuid. + */ +int class_attach(struct lustre_cfg *lcfg) +{ + struct obd_device *obd = NULL; char *typename, *name, *uuid; - int rc, len, cleanup_phase = 0; + int rc, len; + ENTRY; if (!LUSTRE_CFG_BUFLEN(lcfg, 1)) { CERROR("No type passed!\n"); @@ -71,57 +233,55 @@ static int class_attach(struct lustre_cfg *lcfg) CDEBUG(D_IOCTL, "attach type %s name: %s uuid: %s\n", MKSTR(typename), MKSTR(name), MKSTR(uuid)); - /* find the type */ - type = class_get_type(typename); - if (!type) { - CERROR("OBD: unknown type: %s\n", typename); - RETURN(-EINVAL); - } - cleanup_phase = 1; /* class_put_type */ - - obd = class_name2obd(name); - if (obd != NULL) { - CERROR("obd %s already attached\n", name); - GOTO(out, rc = -EEXIST); + obd = class_newdev(typename, name); + if (IS_ERR(obd)) { + /* Already exists or out of obds */ + rc = PTR_ERR(obd); + obd = NULL; + CERROR("Cannot create device %s of type %s : %d\n", + name, typename, rc); + GOTO(out, rc); } - - obd = class_newdev(type); - if (obd == NULL) - GOTO(out, rc = -EINVAL); - - cleanup_phase = 2; /* class_release_dev */ - - INIT_LIST_HEAD(&obd->obd_exports); - obd->obd_num_exports = 0; + LASSERTF(obd != NULL, "Cannot get obd device %s of type %s\n", + name, typename); + LASSERTF(obd->obd_magic == OBD_DEVICE_MAGIC, + "obd %p obd_magic %08X != %08X\n", + obd, obd->obd_magic, OBD_DEVICE_MAGIC); + LASSERTF(strncmp(obd->obd_name, name, strlen(name)) == 0, + "%p obd_name %s != %s\n", obd, obd->obd_name, name); + + rwlock_init(&obd->obd_pool_lock); + obd->obd_pool_limit = 0; + obd->obd_pool_slv = 0; + + CFS_INIT_LIST_HEAD(&obd->obd_exports); + CFS_INIT_LIST_HEAD(&obd->obd_delayed_exports); + CFS_INIT_LIST_HEAD(&obd->obd_exports_timed); + CFS_INIT_LIST_HEAD(&obd->obd_nid_stats); + spin_lock_init(&obd->obd_nid_lock); spin_lock_init(&obd->obd_dev_lock); + sema_init(&obd->obd_dev_sem, 1); spin_lock_init(&obd->obd_osfs_lock); - obd->obd_osfs_age = jiffies - 1000 * HZ; - init_waitqueue_head(&obd->obd_refcount_waitq); + /* obd->obd_osfs_age must be set to a value in the distant + * past to guarantee a fresh statfs is fetched on mount. */ + obd->obd_osfs_age = cfs_time_shift_64(-1000); /* XXX belongs in setup not attach */ /* recovery data */ - init_timer(&obd->obd_recovery_timer); + cfs_init_timer(&obd->obd_recovery_timer); spin_lock_init(&obd->obd_processing_task_lock); - init_waitqueue_head(&obd->obd_next_transno_waitq); - INIT_LIST_HEAD(&obd->obd_req_replay_queue); - INIT_LIST_HEAD(&obd->obd_lock_replay_queue); - INIT_LIST_HEAD(&obd->obd_final_req_queue); - - spin_lock_init(&obd->obd_uncommitted_replies_lock); - INIT_LIST_HEAD(&obd->obd_uncommitted_replies); - - len = strlen(name) + 1; - OBD_ALLOC(obd->obd_name, len); - if (!obd->obd_name) - GOTO(out, rc = -ENOMEM); - memcpy(obd->obd_name, name, len); - - cleanup_phase = 3; /* free obd_name */ + cfs_waitq_init(&obd->obd_next_transno_waitq); + cfs_waitq_init(&obd->obd_evict_inprogress_waitq); + CFS_INIT_LIST_HEAD(&obd->obd_req_replay_queue); + CFS_INIT_LIST_HEAD(&obd->obd_lock_replay_queue); + CFS_INIT_LIST_HEAD(&obd->obd_final_req_queue); + + llog_group_init(&obd->obd_olg, FILTER_GROUP_LLOG); len = strlen(uuid); if (len >= sizeof(obd->obd_uuid)) { - CERROR("uuid must be < "LPSZ" bytes long\n", - sizeof(obd->obd_uuid)); + CERROR("uuid must be < %d bytes long\n", + (int)sizeof(obd->obd_uuid)); GOTO(out, rc = -EINVAL); } memcpy(obd->obd_uuid.uuid, uuid, len); @@ -133,30 +293,37 @@ static int class_attach(struct lustre_cfg *lcfg) GOTO(out, rc = -EINVAL); } + /* Detach drops this */ + spin_lock(&obd->obd_dev_lock); + atomic_set(&obd->obd_refcount, 1); + spin_unlock(&obd->obd_dev_lock); + lu_ref_init(&obd->obd_reference); + lu_ref_add(&obd->obd_reference, "attach", obd); + obd->obd_attached = 1; - type->typ_refcnt++; - CDEBUG(D_IOCTL, "OBD: dev %d attached type %s\n", - obd->obd_minor, typename); + CDEBUG(D_IOCTL, "OBD: dev %d attached type %s with refcount %d\n", + obd->obd_minor, typename, atomic_read(&obd->obd_refcount)); RETURN(0); out: - switch (cleanup_phase) { - case 3: - OBD_FREE(obd->obd_name, strlen(obd->obd_name) + 1); - case 2: + if (obd != NULL) { class_release_dev(obd); - case 1: - class_put_type(type); } return rc; } -static int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg) +int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg) { int err = 0; struct obd_export *exp; ENTRY; - LASSERT(obd == (obd_dev + obd->obd_minor)); + LASSERT(obd != NULL); + LASSERTF(obd == class_num2obd(obd->obd_minor), + "obd %p != obd_devs[%d] %p\n", + obd, obd->obd_minor, class_num2obd(obd->obd_minor)); + LASSERTF(obd->obd_magic == OBD_DEVICE_MAGIC, + "obd %p obd_magic %08x != %08x\n", + obd, obd->obd_magic, OBD_DEVICE_MAGIC); /* have we attached a type to this device? */ if (!obd->obd_attached) { @@ -164,182 +331,304 @@ static int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg) RETURN(-ENODEV); } - /* has this been done already? */ if (obd->obd_set_up) { CERROR("Device %d already setup (type %s)\n", obd->obd_minor, obd->obd_type->typ_name); - RETURN(-EBUSY); + RETURN(-EEXIST); } - atomic_set(&obd->obd_refcount, 0); + /* is someone else setting us up right now? (attach inits spinlock) */ + spin_lock(&obd->obd_dev_lock); + if (obd->obd_starting) { + spin_unlock(&obd->obd_dev_lock); + CERROR("Device %d setup in progress (type %s)\n", + obd->obd_minor, obd->obd_type->typ_name); + RETURN(-EEXIST); + } + /* just leave this on forever. I can't use obd_set_up here because + other fns check that status, and we're not actually set up yet. */ + obd->obd_starting = 1; + obd->obd_uuid_hash = NULL; + obd->obd_nid_hash = NULL; + obd->obd_nid_stats_hash = NULL; + spin_unlock(&obd->obd_dev_lock); + + /* create an uuid-export lustre hash */ + obd->obd_uuid_hash = lustre_hash_init("UUID_HASH", + HASH_UUID_CUR_BITS, + HASH_UUID_MAX_BITS, + &uuid_hash_ops, 0); + if (!obd->obd_uuid_hash) + GOTO(err_hash, err = -ENOMEM); + + /* create a nid-export lustre hash */ + obd->obd_nid_hash = lustre_hash_init("NID_HASH", + HASH_NID_CUR_BITS, + HASH_NID_MAX_BITS, + &nid_hash_ops, 0); + if (!obd->obd_nid_hash) + GOTO(err_hash, err = -ENOMEM); + + /* create a nid-stats lustre hash */ + obd->obd_nid_stats_hash = lustre_hash_init("NID_STATS", + HASH_NID_STATS_CUR_BITS, + HASH_NID_STATS_MAX_BITS, + &nid_stat_hash_ops, 0); + if (!obd->obd_nid_stats_hash) + GOTO(err_hash, err = -ENOMEM); + + exp = class_new_export(obd, &obd->obd_uuid); + if (IS_ERR(exp)) + GOTO(err_hash, err = PTR_ERR(exp)); - exp = class_new_export(obd); - if (exp == NULL) - RETURN(err); - memcpy(&exp->exp_client_uuid, &obd->obd_uuid, - sizeof(exp->exp_client_uuid)); obd->obd_self_export = exp; + list_del_init(&exp->exp_obd_chain_timed); class_export_put(exp); - err = obd_setup(obd, sizeof(*lcfg), lcfg); + err = obd_setup(obd, lcfg); if (err) GOTO(err_exp, err); - obd->obd_type->typ_refcnt++; obd->obd_set_up = 1; - RETURN(err); + spin_lock(&obd->obd_dev_lock); + /* cleanup drops this */ + class_incref(obd, "setup", obd); + spin_unlock(&obd->obd_dev_lock); + + CDEBUG(D_IOCTL, "finished setup of obd %s (uuid %s)\n", + obd->obd_name, obd->obd_uuid.uuid); + RETURN(0); err_exp: - class_unlink_export(obd->obd_self_export); - obd->obd_self_export = NULL; - RETURN(err); + if (obd->obd_self_export) { + class_unlink_export(obd->obd_self_export); + obd->obd_self_export = NULL; + } +err_hash: + if (obd->obd_uuid_hash) { + lustre_hash_exit(obd->obd_uuid_hash); + obd->obd_uuid_hash = NULL; + } + if (obd->obd_nid_hash) { + lustre_hash_exit(obd->obd_nid_hash); + obd->obd_nid_hash = NULL; + } + if (obd->obd_nid_stats_hash) { + lustre_hash_exit(obd->obd_nid_stats_hash); + obd->obd_nid_stats_hash = NULL; + } + obd->obd_starting = 0; + CERROR("setup %s failed (%d)\n", obd->obd_name, err); + return err; } -static int class_detach(struct obd_device *obd, struct lustre_cfg *lcfg) +int class_detach(struct obd_device *obd, struct lustre_cfg *lcfg) { - int err = 0; - ENTRY; + if (obd->obd_set_up) { CERROR("OBD device %d still set up\n", obd->obd_minor); RETURN(-EBUSY); } + + spin_lock(&obd->obd_dev_lock); if (!obd->obd_attached) { + spin_unlock(&obd->obd_dev_lock); CERROR("OBD device %d not attached\n", obd->obd_minor); RETURN(-ENODEV); } - if (OBP(obd, detach)) - err = OBP(obd,detach)(obd); + obd->obd_attached = 0; + spin_unlock(&obd->obd_dev_lock); - if (obd->obd_name) { - OBD_FREE(obd->obd_name, strlen(obd->obd_name)+1); - obd->obd_name = NULL; - } else { - CERROR("device %d: no name at detach\n", obd->obd_minor); - } + CDEBUG(D_IOCTL, "detach on obd %s (uuid %s)\n", + obd->obd_name, obd->obd_uuid.uuid); - obd->obd_attached = 0; - obd->obd_type->typ_refcnt--; - class_put_type(obd->obd_type); - class_release_dev(obd); - RETURN(err); + class_decref(obd, "attach", obd); + + /* not strictly necessary, but cleans up eagerly */ + obd_zombie_impexp_cull(); + + RETURN(0); } static void dump_exports(struct obd_device *obd) { - struct obd_export *exp, *n; + struct obd_export *exp; - list_for_each_entry_safe(exp, n, &obd->obd_exports, exp_obd_chain) { + spin_lock(&obd->obd_dev_lock); + list_for_each_entry(exp, &obd->obd_exports, exp_obd_chain) { struct ptlrpc_reply_state *rs; struct ptlrpc_reply_state *first_reply = NULL; int nreplies = 0; + spin_lock(&exp->exp_lock); list_for_each_entry (rs, &exp->exp_outstanding_replies, rs_exp_list) { if (nreplies == 0) first_reply = rs; nreplies++; } + spin_unlock(&exp->exp_lock); - CERROR("%s: %p %s %d %d %d: %p %s\n", + CDEBUG(D_IOCTL, "%s: %p %s %s %d %d %d: %p %s\n", obd->obd_name, exp, exp->exp_client_uuid.uuid, + obd_export_nid2str(exp), atomic_read(&exp->exp_refcount), exp->exp_failed, nreplies, first_reply, nreplies > 3 ? "..." : ""); } + spin_unlock(&obd->obd_dev_lock); } -static int class_cleanup(struct obd_device *obd, struct lustre_cfg *lcfg) +int class_cleanup(struct obd_device *obd, struct lustre_cfg *lcfg) { - int flags = 0; int err = 0; char *flag; - ENTRY; + + OBD_RACE(OBD_FAIL_LDLM_RECOV_CLIENTS); + if (!obd->obd_set_up) { CERROR("Device %d not setup\n", obd->obd_minor); RETURN(-ENODEV); } - if (LUSTRE_CFG_BUFLEN(lcfg, 1) > 0) { - for (flag = lustre_cfg_string(lcfg, 1); *flag != 0; flag++) + + spin_lock(&obd->obd_dev_lock); + if (obd->obd_stopping) { + spin_unlock(&obd->obd_dev_lock); + CERROR("OBD %d already stopping\n", obd->obd_minor); + RETURN(-ENODEV); + } + /* Leave this on forever */ + obd->obd_stopping = 1; + spin_unlock(&obd->obd_dev_lock); + + if (lcfg->lcfg_bufcount >= 2 && LUSTRE_CFG_BUFLEN(lcfg, 1) > 0) { + for (flag = lustre_cfg_string(lcfg, 1); *flag != 0; flag++) switch (*flag) { case 'F': - flags |= OBD_OPT_FORCE; + obd->obd_force = 1; break; case 'A': - flags |= OBD_OPT_FAILOVER; + LCONSOLE_WARN("Failing over %s\n", + obd->obd_name); + obd->obd_fail = 1; + obd->obd_no_transno = 1; + obd->obd_no_recov = 1; + if (OBP(obd, iocontrol)) { + obd_iocontrol(OBD_IOC_SYNC, + obd->obd_self_export, + 0, NULL, NULL); + /* Set the obd readonly if we can */ + obd_iocontrol(OBD_IOC_SET_READONLY, + obd->obd_self_export, + 0, NULL, NULL); + } break; default: - CERROR("unrecognised flag '%c'\n", - *flag); + CERROR("Unrecognised flag '%c'\n", *flag); } } - /* The one reference that should be remaining is the - * obd_self_export */ - if (atomic_read(&obd->obd_refcount) <= 1 || - flags & OBD_OPT_FORCE) { - /* this will stop new connections, and need to - do it before class_disconnect_exports() */ - obd->obd_stopping = 1; + LASSERT(obd->obd_self_export); + + /* The three references that should be remaining are the + * obd_self_export and the attach and setup references. */ + if (atomic_read(&obd->obd_refcount) > 3) { + /* refcounf - 3 might be the number of real exports + (excluding self export). But class_incref is called + by other things as well, so don't count on it. */ + CDEBUG(D_IOCTL, "%s: forcing exports to disconnect: %d\n", + obd->obd_name, atomic_read(&obd->obd_refcount) - 3); + dump_exports(obd); + class_disconnect_exports(obd); } - if (atomic_read(&obd->obd_refcount) > 1) { - struct l_wait_info lwi = LWI_TIMEOUT_INTR(1 * HZ, NULL, - NULL, NULL); - int rc; + /* destroy an uuid-export hash body */ + if (obd->obd_uuid_hash) { + lustre_hash_exit(obd->obd_uuid_hash); + obd->obd_uuid_hash = NULL; + } - if (!(flags & OBD_OPT_FORCE)) { - CERROR("OBD device %d (%p,%s) has refcount %d\n", - obd->obd_minor, obd, obd->obd_name, - atomic_read(&obd->obd_refcount)); - portals_debug_dumplog(); - dump_exports(obd); - GOTO(out, err = -EBUSY); - } - class_disconnect_exports(obd, flags); - CDEBUG(D_IOCTL, - "%s: waiting for obd refs to go away: %d\n", - obd->obd_name, atomic_read(&obd->obd_refcount)); - - rc = l_wait_event(obd->obd_refcount_waitq, - atomic_read(&obd->obd_refcount) < 2, &lwi); - if (rc == 0) { - LASSERT(atomic_read(&obd->obd_refcount) == 1); - } else { - CERROR("wait cancelled cleaning anyway. " - "refcount: %d\n", - atomic_read(&obd->obd_refcount)); - dump_exports(obd); - } - CDEBUG(D_IOCTL, "%s: awake, now finishing cleanup\n", - obd->obd_name); + /* destroy a nid-export hash body */ + if (obd->obd_nid_hash) { + lustre_hash_exit(obd->obd_nid_hash); + obd->obd_nid_hash = NULL; } - if (obd->obd_self_export) { - err = obd_precleanup(obd, flags); - if (err) - GOTO(out, err); + /* destroy a nid-stats hash body */ + if (obd->obd_nid_stats_hash) { + lustre_hash_exit(obd->obd_nid_stats_hash); + obd->obd_nid_stats_hash = NULL; + } + + /* Precleanup, we must make sure all exports get destroyed. */ + err = obd_precleanup(obd, OBD_CLEANUP_EXPORTS); + if (err) + CERROR("Precleanup %s returned %d\n", + obd->obd_name, err); + class_decref(obd, "setup", obd); + obd->obd_set_up = 0; + RETURN(0); +} + +struct obd_device *class_incref(struct obd_device *obd, + const char *scope, const void *source) +{ + LASSERT(!obd->obd_stopping); + lu_ref_add_atomic(&obd->obd_reference, scope, source); + atomic_inc(&obd->obd_refcount); + CDEBUG(D_INFO, "incref %s (%p) now %d\n", obd->obd_name, obd, + atomic_read(&obd->obd_refcount)); + + return obd; +} + +void class_decref(struct obd_device *obd, const char *scope, const void *source) +{ + int err; + int refs; + + spin_lock(&obd->obd_dev_lock); + atomic_dec(&obd->obd_refcount); + refs = atomic_read(&obd->obd_refcount); + spin_unlock(&obd->obd_dev_lock); + lu_ref_del(&obd->obd_reference, scope, source); + + CDEBUG(D_INFO, "Decref %s (%p) now %d\n", obd->obd_name, obd, refs); + + if ((refs == 1) && obd->obd_stopping) { + /* All exports have been destroyed; there should + be no more in-progress ops by this point.*/ + + spin_lock(&obd->obd_self_export->exp_lock); + obd->obd_self_export->exp_flags |= exp_flags_from_obd(obd); + spin_unlock(&obd->obd_self_export->exp_lock); + + /* note that we'll recurse into class_decref again */ class_unlink_export(obd->obd_self_export); - obd->obd_self_export = NULL; + return; } - err = obd_cleanup(obd, flags); -out: - if (!err) { - obd->obd_set_up = obd->obd_stopping = 0; - obd->obd_type->typ_refcnt--; - /* XXX this should be an LASSERT */ - if (atomic_read(&obd->obd_refcount) > 0) { - CERROR("%s (%p) still has refcount %d after " - "cleanup.\n", obd->obd_name, obd, - atomic_read(&obd->obd_refcount)); - dump_exports(obd); + if (refs == 0) { + CDEBUG(D_CONFIG, "finishing cleanup of obd %s (%s)\n", + obd->obd_name, obd->obd_uuid.uuid); + LASSERT(!obd->obd_attached); + if (obd->obd_stopping) { + /* If we're not stopping, we were never set up */ + err = obd_cleanup(obd); + if (err) + CERROR("Cleanup %s returned %d\n", + obd->obd_name, err); + } + if (OBP(obd, detach)) { + err = OBP(obd, detach)(obd); + if (err) + CERROR("Detach returned %d\n", err); } + class_release_dev(obd); } - - RETURN(err); } int class_add_conn(struct obd_device *obd, struct lustre_cfg *lcfg) @@ -354,13 +643,9 @@ int class_add_conn(struct obd_device *obd, struct lustre_cfg *lcfg) CERROR("invalid conn_uuid\n"); RETURN(-EINVAL); } - - if (LUSTRE_CFG_BUFLEN(lcfg, 2) != sizeof(int)) { - CERROR("invalid priority\n"); - RETURN(-EINVAL); - } - if (strcmp(obd->obd_type->typ_name, "mdc") && - strcmp(obd->obd_type->typ_name, "osc")) { + if (strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) && + strcmp(obd->obd_type->typ_name, LUSTRE_OSC_NAME) && + strcmp(obd->obd_type->typ_name, LUSTRE_MGC_NAME)) { CERROR("can't add connection on non-client dev\n"); RETURN(-EINVAL); } @@ -376,6 +661,7 @@ int class_add_conn(struct obd_device *obd, struct lustre_cfg *lcfg) RETURN(rc); } + int class_del_conn(struct obd_device *obd, struct lustre_cfg *lcfg) { struct obd_import *imp; @@ -388,10 +674,9 @@ int class_del_conn(struct obd_device *obd, struct lustre_cfg *lcfg) CERROR("invalid conn_uuid\n"); RETURN(-EINVAL); } - - if (strcmp(obd->obd_type->typ_name, "mdc") && - strcmp(obd->obd_type->typ_name, "osc")) { - CERROR("can't add connection on non-client dev\n"); + if (strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) && + strcmp(obd->obd_type->typ_name, LUSTRE_OSC_NAME)) { + CERROR("can't del connection on non-client dev\n"); RETURN(-EINVAL); } @@ -407,12 +692,13 @@ int class_del_conn(struct obd_device *obd, struct lustre_cfg *lcfg) RETURN(rc); } -LIST_HEAD(lustre_profile_list); +CFS_LIST_HEAD(lustre_profile_list); -struct lustre_profile *class_get_profile(char * prof) +struct lustre_profile *class_get_profile(const char * prof) { struct lustre_profile *lprof; + ENTRY; list_for_each_entry(lprof, &lustre_profile_list, lp_list) { if (!strcmp(lprof->lp_profile, prof)) { RETURN(lprof); @@ -421,18 +707,19 @@ struct lustre_profile *class_get_profile(char * prof) RETURN(NULL); } -int class_add_profile(int proflen, char *prof, - int lovlen, char *lov, - int lmvlen, char *lmv, - int gkclen, char *gkc) +int class_add_profile(int proflen, char *prof, int osclen, char *osc, + int mdclen, char *mdc) { struct lustre_profile *lprof; int err = 0; + ENTRY; + + CDEBUG(D_CONFIG, "Add profile %s\n", prof); OBD_ALLOC(lprof, sizeof(*lprof)); if (lprof == NULL) - GOTO(out, err = -ENOMEM); - INIT_LIST_HEAD(&lprof->lp_list); + RETURN(-ENOMEM); + CFS_INIT_LIST_HEAD(&lprof->lp_list); LASSERT(proflen == (strlen(prof) + 1)); OBD_ALLOC(lprof->lp_profile, proflen); @@ -440,56 +727,108 @@ int class_add_profile(int proflen, char *prof, GOTO(out, err = -ENOMEM); memcpy(lprof->lp_profile, prof, proflen); - LASSERT(lovlen == (strlen(lov) + 1)); - OBD_ALLOC(lprof->lp_lov, lovlen); - if (lprof->lp_profile == NULL) + LASSERT(osclen == (strlen(osc) + 1)); + OBD_ALLOC(lprof->lp_dt, osclen); + if (lprof->lp_dt == NULL) GOTO(out, err = -ENOMEM); - memcpy(lprof->lp_lov, lov, lovlen); + memcpy(lprof->lp_dt, osc, osclen); - if (lmvlen > 0) { - LASSERT(lmvlen == (strlen(lmv) + 1)); - OBD_ALLOC(lprof->lp_lmv, lmvlen); - if (lprof->lp_lmv == NULL) + if (mdclen > 0) { + LASSERT(mdclen == (strlen(mdc) + 1)); + OBD_ALLOC(lprof->lp_md, mdclen); + if (lprof->lp_md == NULL) GOTO(out, err = -ENOMEM); - memcpy(lprof->lp_lmv, lmv, lmvlen); + memcpy(lprof->lp_md, mdc, mdclen); } - if (gkclen > 0 ) { - LASSERT(gkclen == (strlen(gkc) + 1)); - OBD_ALLOC(lprof->lp_gkc, gkclen); - if (lprof->lp_gkc == NULL) - GOTO(out, err = -ENOMEM); - memcpy(lprof->lp_gkc, gkc, gkclen); - } - + list_add(&lprof->lp_list, &lustre_profile_list); + RETURN(err); + out: + if (lprof->lp_md) + OBD_FREE(lprof->lp_md, mdclen); + if (lprof->lp_dt) + OBD_FREE(lprof->lp_dt, osclen); + if (lprof->lp_profile) + OBD_FREE(lprof->lp_profile, proflen); + OBD_FREE(lprof, sizeof(*lprof)); RETURN(err); } -void class_del_profile(char *prof) +void class_del_profile(const char *prof) { struct lustre_profile *lprof; + ENTRY; + + CDEBUG(D_CONFIG, "Del profile %s\n", prof); lprof = class_get_profile(prof); if (lprof) { list_del(&lprof->lp_list); OBD_FREE(lprof->lp_profile, strlen(lprof->lp_profile) + 1); - OBD_FREE(lprof->lp_lov, strlen(lprof->lp_lov) + 1); - if (lprof->lp_lmv) - OBD_FREE(lprof->lp_lmv, strlen(lprof->lp_lmv) + 1); + OBD_FREE(lprof->lp_dt, strlen(lprof->lp_dt) + 1); + if (lprof->lp_md) + OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1); + OBD_FREE(lprof, sizeof *lprof); + } + EXIT; +} + +/* COMPAT_146 */ +void class_del_profiles(void) +{ + struct lustre_profile *lprof, *n; + ENTRY; + + list_for_each_entry_safe(lprof, n, &lustre_profile_list, lp_list) { + list_del(&lprof->lp_list); + OBD_FREE(lprof->lp_profile, strlen(lprof->lp_profile) + 1); + OBD_FREE(lprof->lp_dt, strlen(lprof->lp_dt) + 1); + if (lprof->lp_md) + OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1); OBD_FREE(lprof, sizeof *lprof); } + EXIT; +} + +static int class_set_global(char *ptr, int val) { + ENTRY; + + if (class_match_param(ptr, PARAM_AT_MIN, NULL) == 0) + at_min = val; + else if (class_match_param(ptr, PARAM_AT_MAX, NULL) == 0) + at_max = val; + else if (class_match_param(ptr, PARAM_AT_EXTRA, NULL) == 0) + at_extra = val; + else if (class_match_param(ptr, PARAM_AT_EARLY_MARGIN, NULL) == 0) + at_early_margin = val; + else if (class_match_param(ptr, PARAM_AT_HISTORY, NULL) == 0) + at_history = val; + else + RETURN(-EINVAL); + + CDEBUG(D_IOCTL, "global %s = %d\n", ptr, val); + + RETURN(0); +} + + +/* We can't call ll_process_config directly because it lives in a module that + must be loaded after this one. */ +static int (*client_process_config)(struct lustre_cfg *lcfg) = NULL; + +void lustre_register_client_process_config(int (*cpc)(struct lustre_cfg *lcfg)) +{ + client_process_config = cpc; } +EXPORT_SYMBOL(lustre_register_client_process_config); int class_process_config(struct lustre_cfg *lcfg) { struct obd_device *obd; - char str[PTL_NALFMT_SIZE]; int err; - ENTRY; LASSERT(lcfg && !IS_ERR(lcfg)); - CDEBUG(D_IOCTL, "processing cmd: %x\n", lcfg->lcfg_command); /* Commands that don't need a device */ @@ -500,13 +839,11 @@ int class_process_config(struct lustre_cfg *lcfg) } case LCFG_ADD_UUID: { CDEBUG(D_IOCTL, "adding mapping from uuid %s to nid "LPX64 - " (%s), nal %x\n", lustre_cfg_string(lcfg, 1), lcfg->lcfg_nid, - portals_nid2str(lcfg->lcfg_nal, lcfg->lcfg_nid, str), - lcfg->lcfg_nal); + " (%s)\n", lustre_cfg_string(lcfg, 1), + lcfg->lcfg_nid, libcfs_nid2str(lcfg->lcfg_nid)); - err = class_add_uuid(lustre_cfg_string(lcfg, 1), lcfg->lcfg_nid, - lcfg->lcfg_nal); - GOTO(out, err); + err = class_add_uuid(lustre_cfg_string(lcfg, 1), lcfg->lcfg_nid); + GOTO(out, err); } case LCFG_DEL_UUID: { CDEBUG(D_IOCTL, "removing mappings for uuid %s\n", @@ -517,11 +854,10 @@ int class_process_config(struct lustre_cfg *lcfg) GOTO(out, err); } case LCFG_MOUNTOPT: { - CDEBUG(D_IOCTL, "mountopt: profile %s osc %s mdc %s gkc %s \n", + CDEBUG(D_IOCTL, "mountopt: profile %s osc %s mdc %s\n", lustre_cfg_string(lcfg, 1), lustre_cfg_string(lcfg, 2), - lustre_cfg_string(lcfg, 3), - lustre_cfg_string(lcfg, 4)); + lustre_cfg_string(lcfg, 3)); /* set these mount options somewhere, so ll_fill_super * can find them. */ err = class_add_profile(LUSTRE_CFG_BUFLEN(lcfg, 1), @@ -529,43 +865,71 @@ int class_process_config(struct lustre_cfg *lcfg) LUSTRE_CFG_BUFLEN(lcfg, 2), lustre_cfg_string(lcfg, 2), LUSTRE_CFG_BUFLEN(lcfg, 3), - lustre_cfg_string(lcfg, 3), - LUSTRE_CFG_BUFLEN(lcfg, 4), - lustre_cfg_string(lcfg, 4)); + lustre_cfg_string(lcfg, 3)); GOTO(out, err); } case LCFG_DEL_MOUNTOPT: { CDEBUG(D_IOCTL, "mountopt: profile %s\n", lustre_cfg_string(lcfg, 1)); - /* set these mount options somewhere, so ll_fill_super - * can find them. */ class_del_profile(lustre_cfg_string(lcfg, 1)); GOTO(out, err = 0); } case LCFG_SET_TIMEOUT: { CDEBUG(D_IOCTL, "changing lustre timeout from %d to %d\n", - obd_timeout, - lcfg->lcfg_num); - obd_timeout = lcfg->lcfg_num; + obd_timeout, lcfg->lcfg_num); + obd_timeout = max(lcfg->lcfg_num, 1U); + GOTO(out, err = 0); + } + case LCFG_SET_LDLM_TIMEOUT: { + CDEBUG(D_IOCTL, "changing lustre ldlm_timeout from %d to %d\n", + ldlm_timeout, lcfg->lcfg_num); + ldlm_timeout = max(lcfg->lcfg_num, 1U); + if (ldlm_timeout >= obd_timeout) + ldlm_timeout = max(obd_timeout / 3, 1U); + GOTO(out, err = 0); } case LCFG_SET_UPCALL: { - CDEBUG(D_IOCTL, "setting lustre ucpall to: %s\n", - lustre_cfg_string(lcfg, 1)); - if (LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof obd_lustre_upcall) - GOTO(out, err = -EINVAL); - strncpy(obd_lustre_upcall, lustre_cfg_string(lcfg, 1), - sizeof (obd_lustre_upcall)); + LCONSOLE_ERROR_MSG(0x15a, "recovery upcall is deprecated\n"); + /* COMPAT_146 Don't fail on old configs */ + GOTO(out, err = 0); + } + case LCFG_MARKER: { + struct cfg_marker *marker; + marker = lustre_cfg_buf(lcfg, 1); + CDEBUG(D_IOCTL, "marker %d (%#x) %.16s %s\n", marker->cm_step, + marker->cm_flags, marker->cm_tgtname, marker->cm_comment); GOTO(out, err = 0); } + case LCFG_PARAM: { + char *tmp; + /* llite has no obd */ + if ((class_match_param(lustre_cfg_string(lcfg, 1), + PARAM_LLITE, 0) == 0) && + client_process_config) { + err = (*client_process_config)(lcfg); + GOTO(out, err); + } else if ((class_match_param(lustre_cfg_string(lcfg, 1), + PARAM_SYS, &tmp) == 0)) { + /* Global param settings */ + err = class_set_global(tmp, lcfg->lcfg_num); + /* Note that since LCFG_PARAM is LCFG_REQUIRED, new + unknown globals would cause config to fail */ + if (err) + CWARN("Ignoring unknown param %s\n", tmp); + GOTO(out, 0); + } + + /* Fall through */ + break; } - + } + /* Commands that require a device */ obd = class_name2obd(lustre_cfg_string(lcfg, 0)); if (obd == NULL) { if (!LUSTRE_CFG_BUFLEN(lcfg, 0)) - CERROR("this lcfg command %d requires a device name\n", - lcfg->lcfg_command); + CERROR("this lcfg command requires a device name\n"); else CERROR("no device for: %s\n", lustre_cfg_string(lcfg, 0)); @@ -594,6 +958,28 @@ int class_process_config(struct lustre_cfg *lcfg) err = class_del_conn(obd, lcfg); GOTO(out, err = 0); } + case LCFG_POOL_NEW: { + err = obd_pool_new(obd, lustre_cfg_string(lcfg, 2)); + GOTO(out, err = 0); + break; + } + case LCFG_POOL_ADD: { + err = obd_pool_add(obd, lustre_cfg_string(lcfg, 2), + lustre_cfg_string(lcfg, 3)); + GOTO(out, err = 0); + break; + } + case LCFG_POOL_REM: { + err = obd_pool_rem(obd, lustre_cfg_string(lcfg, 2), + lustre_cfg_string(lcfg, 3)); + GOTO(out, err = 0); + break; + } + case LCFG_POOL_DEL: { + err = obd_pool_del(obd, lustre_cfg_string(lcfg, 2)); + GOTO(out, err = 0); + break; + } default: { err = obd_process_config(obd, sizeof(*lcfg), lcfg); GOTO(out, err); @@ -601,100 +987,327 @@ int class_process_config(struct lustre_cfg *lcfg) } } out: + if ((err < 0) && !(lcfg->lcfg_command & LCFG_REQUIRED)) { + CWARN("Ignoring error %d on optional command %#x\n", err, + lcfg->lcfg_command); + err = 0; + } return err; } -static int class_config_parse_handler(struct llog_handle * handle, - struct llog_rec_hdr *rec, void *data) +int class_process_proc_param(char *prefix, struct lprocfs_vars *lvars, + struct lustre_cfg *lcfg, void *data) +{ +#ifdef __KERNEL__ + struct lprocfs_vars *var; + char *key, *sval; + int i, keylen, vallen; + int matched = 0, j = 0; + int rc = 0; + int skip = 0; + ENTRY; + + if (lcfg->lcfg_command != LCFG_PARAM) { + CERROR("Unknown command: %d\n", lcfg->lcfg_command); + RETURN(-EINVAL); + } + + /* e.g. tunefs.lustre --param mdt.group_upcall=foo /r/tmp/lustre-mdt + or lctl conf_param lustre-MDT0000.mdt.group_upcall=bar + or lctl conf_param lustre-OST0000.osc.max_dirty_mb=36 */ + for (i = 1; i < lcfg->lcfg_bufcount; i++) { + key = lustre_cfg_buf(lcfg, i); + /* Strip off prefix */ + class_match_param(key, prefix, &key); + sval = strchr(key, '='); + if (!sval || (*(sval + 1) == 0)) { + CERROR("Can't parse param %s (missing '=')\n", key); + /* rc = -EINVAL; continue parsing other params */ + continue; + } + keylen = sval - key; + sval++; + vallen = strlen(sval); + matched = 0; + j = 0; + /* Search proc entries */ + while (lvars[j].name) { + var = &lvars[j]; + if (class_match_param(key, (char *)var->name, 0) == 0 && + keylen == strlen(var->name)) { + matched++; + rc = -EROFS; + if (var->write_fptr) { + mm_segment_t oldfs; + oldfs = get_fs(); + set_fs(KERNEL_DS); + rc = (var->write_fptr)(NULL, sval, + vallen, data); + set_fs(oldfs); + } + break; + } + j++; + } + if (!matched) { + /* If the prefix doesn't match, return error so we + can pass it down the stack */ + if (strnchr(key, keylen, '.')) + RETURN(-ENOSYS); + CERROR("%s: unknown param %s\n", + (char *)lustre_cfg_string(lcfg, 0), key); + /* rc = -EINVAL; continue parsing other params */ + skip++; + } else if (rc < 0) { + CERROR("writing proc entry %s err %d\n", + var->name, rc); + rc = 0; + } else { + LCONSOLE_INFO("%s.%.*s: set parameter %.*s=%s\n", + lustre_cfg_string(lcfg, 0), + (int)strlen(prefix) - 1, prefix, + (int)(sval - key - 1), key, sval); + } + } + + if (rc > 0) + rc = 0; + if (!rc && skip) + rc = skip; + RETURN(rc); +#else + CDEBUG(D_CONFIG, "liblustre can't process params.\n"); + /* Don't throw config error */ + RETURN(0); +#endif +} + +int class_config_dump_handler(struct llog_handle * handle, + struct llog_rec_hdr *rec, void *data); + +#ifdef __KERNEL__ +extern int lustre_check_exclusion(struct super_block *sb, char *svname); +#else +#define lustre_check_exclusion(a,b) 0 +#endif + +static int class_config_llog_handler(struct llog_handle * handle, + struct llog_rec_hdr *rec, void *data) { - struct config_llog_instance *cfg = data; + struct config_llog_instance *clli = data; int cfg_len = rec->lrh_len; char *cfg_buf = (char*) (rec + 1); int rc = 0; ENTRY; - if (rec->lrh_type == OBD_CFG_REC) { + //class_config_dump_handler(handle, rec, data); + + switch (rec->lrh_type) { + case OBD_CFG_REC: { struct lustre_cfg *lcfg, *lcfg_new; struct lustre_cfg_bufs bufs; - char *inst_name = NULL; int inst_len = 0; - int inst = 0; + int inst = 0, swab = 0; lcfg = (struct lustre_cfg *)cfg_buf; - if (lcfg->lcfg_version == __swab32(LUSTRE_CFG_VERSION)) + if (lcfg->lcfg_version == __swab32(LUSTRE_CFG_VERSION)) { lustre_swab_lustre_cfg(lcfg); + swab = 1; + } rc = lustre_cfg_sanity_check(cfg_buf, cfg_len); if (rc) GOTO(out, rc); + /* Figure out config state info */ + if (lcfg->lcfg_command == LCFG_MARKER) { + struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1); + lustre_swab_cfg_marker(marker, swab, + LUSTRE_CFG_BUFLEN(lcfg, 1)); + CDEBUG(D_CONFIG, "Marker, inst_flg=%#x mark_flg=%#x\n", + clli->cfg_flags, marker->cm_flags); + if (marker->cm_flags & CM_START) { + /* all previous flags off */ + clli->cfg_flags = CFG_F_MARKER; + if (marker->cm_flags & CM_SKIP) { + clli->cfg_flags |= CFG_F_SKIP; + CDEBUG(D_CONFIG, "SKIP #%d\n", + marker->cm_step); + } else if ((marker->cm_flags & CM_EXCLUDE) || + (clli->cfg_sb && + lustre_check_exclusion(clli->cfg_sb, + marker->cm_tgtname))) { + clli->cfg_flags |= CFG_F_EXCLUDE; + CDEBUG(D_CONFIG, "EXCLUDE %d\n", + marker->cm_step); + } + } else if (marker->cm_flags & CM_END) { + clli->cfg_flags = 0; + } + } + /* A config command without a start marker before it is + illegal (post 146) */ + if (!(clli->cfg_flags & CFG_F_COMPAT146) && + !(clli->cfg_flags & CFG_F_MARKER) && + (lcfg->lcfg_command != LCFG_MARKER)) { + CWARN("Config not inside markers, ignoring! " + "(inst: %s, uuid: %s, flags: %#x)\n", + clli->cfg_instance ? clli->cfg_instance : "", + clli->cfg_uuid.uuid, clli->cfg_flags); + clli->cfg_flags |= CFG_F_SKIP; + } + if (clli->cfg_flags & CFG_F_SKIP) { + CDEBUG(D_CONFIG, "skipping %#x\n", + clli->cfg_flags); + rc = 0; + /* No processing! */ + break; + } + + /* + * For interoperability between 1.8 and 2.0, + * rename "mds" obd device type to "mdt". + */ + { + char *typename = lustre_cfg_string(lcfg, 1); + char *index = lustre_cfg_string(lcfg, 2); + + if ((lcfg->lcfg_command == LCFG_ATTACH && typename && + strcmp(typename, "mds") == 0)) { + CWARN("For 1.8 interoperability, rename obd " + "type from mds to mdt\n"); + typename[2] = 't'; + } + if ((lcfg->lcfg_command == LCFG_SETUP && index && + strcmp(index, "type") == 0)) { + CDEBUG(D_INFO, "For 1.8 interoperability, " + "set this index to '0'\n"); + index[0] = '0'; + index[1] = 0; + } + } + + if ((clli->cfg_flags & CFG_F_EXCLUDE) && + (lcfg->lcfg_command == LCFG_LOV_ADD_OBD)) + /* Add inactive instead */ + lcfg->lcfg_command = LCFG_LOV_ADD_INA; + lustre_cfg_bufs_init(&bufs, lcfg); - if (cfg && cfg->cfg_instance && LUSTRE_CFG_BUFLEN(lcfg, 0) > 0) { + + if (clli && clli->cfg_instance && + LUSTRE_CFG_BUFLEN(lcfg, 0) > 0){ inst = 1; inst_len = LUSTRE_CFG_BUFLEN(lcfg, 0) + - strlen(cfg->cfg_instance) + 1; + strlen(clli->cfg_instance) + 1; OBD_ALLOC(inst_name, inst_len); if (inst_name == NULL) GOTO(out, rc = -ENOMEM); sprintf(inst_name, "%s-%s", lustre_cfg_string(lcfg, 0), - cfg->cfg_instance); + clli->cfg_instance); lustre_cfg_bufs_set_string(&bufs, 0, inst_name); - + CDEBUG(D_CONFIG, "cmd %x, instance name: %s\n", + lcfg->lcfg_command, inst_name); } - if (cfg && lcfg->lcfg_command == LCFG_ATTACH) - lustre_cfg_bufs_set_string(&bufs, 2, - (char *)cfg->cfg_uuid.uuid); - if (cfg && cfg->cfg_instance && - lcfg->lcfg_command == LCFG_SETUP) { - /*add cfg_instance to the end of lcfg buffers*/ - lustre_cfg_bufs_set_string(&bufs, bufs.lcfg_bufcount, - cfg->cfg_instance); + /* we override the llog's uuid for clients, to insure they + are unique */ + if (clli && clli->cfg_instance && + lcfg->lcfg_command == LCFG_ATTACH) { + lustre_cfg_bufs_set_string(&bufs, 2, + clli->cfg_uuid.uuid); } + /* + * sptlrpc config record, we expect 2 data segments: + * [0]: fs_name/target_name, + * [1]: rule string + * moving them to index [1] and [2], and insert MGC's + * obdname at index [0]. + */ + if (clli && clli->cfg_instance == NULL && + lcfg->lcfg_command == LCFG_SPTLRPC_CONF) { + lustre_cfg_bufs_set(&bufs, 2, bufs.lcfg_buf[1], + bufs.lcfg_buflen[1]); + lustre_cfg_bufs_set(&bufs, 1, bufs.lcfg_buf[0], + bufs.lcfg_buflen[0]); + lustre_cfg_bufs_set_string(&bufs, 0, + clli->cfg_obdname); + } + lcfg_new = lustre_cfg_new(lcfg->lcfg_command, &bufs); lcfg_new->lcfg_num = lcfg->lcfg_num; lcfg_new->lcfg_flags = lcfg->lcfg_flags; - lcfg_new->lcfg_nid = lcfg->lcfg_nid; - lcfg_new->lcfg_nal = lcfg->lcfg_nal; + + /* XXX Hack to try to remain binary compatible with + * pre-newconfig logs */ + if (lcfg->lcfg_nal != 0 && /* pre-newconfig log? */ + (lcfg->lcfg_nid >> 32) == 0) { + __u32 addr = (__u32)(lcfg->lcfg_nid & 0xffffffff); + + lcfg_new->lcfg_nid = + LNET_MKNID(LNET_MKNET(lcfg->lcfg_nal, 0), addr); + CWARN("Converted pre-newconfig NAL %d NID %x to %s\n", + lcfg->lcfg_nal, addr, + libcfs_nid2str(lcfg_new->lcfg_nid)); + } else { + lcfg_new->lcfg_nid = lcfg->lcfg_nid; + } + + lcfg_new->lcfg_nal = 0; /* illegal value for obsolete field */ rc = class_process_config(lcfg_new); lustre_cfg_free(lcfg_new); if (inst) OBD_FREE(inst_name, inst_len); - } else if (rec->lrh_type == PTL_CFG_REC) { - struct portals_cfg *pcfg = (struct portals_cfg *)cfg_buf; - if (pcfg->pcfg_command == NAL_CMD_REGISTER_MYNID && - cfg->cfg_local_nid != PTL_NID_ANY) { - pcfg->pcfg_nid = cfg->cfg_local_nid; - } - - rc = libcfs_nal_cmd(pcfg); - } else { - CERROR("unrecognized record type: 0x%x\n", rec->lrh_type); + break; + } + default: + CERROR("Unknown llog record type %#x encountered\n", + rec->lrh_type); + break; } out: + if (rc) { + CERROR("Err %d on cfg command:\n", rc); + class_config_dump_handler(handle, rec, data); + } RETURN(rc); } -int class_config_process_llog(struct llog_ctxt *ctxt, char *name, - struct config_llog_instance *cfg) +int class_config_parse_llog(struct llog_ctxt *ctxt, char *name, + struct config_llog_instance *cfg) { + struct llog_process_cat_data cd = {0, 0}; struct llog_handle *llh; int rc, rc2; ENTRY; - rc = llog_open(ctxt, &llh, NULL, name, 0); + CDEBUG(D_INFO, "looking up llog %s\n", name); + rc = llog_create(ctxt, &llh, NULL, name); if (rc) RETURN(rc); rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL); - if (rc == 0) - rc = llog_process(llh, class_config_parse_handler, cfg, NULL); + if (rc) + GOTO(parse_out, rc); + + /* continue processing from where we last stopped to end-of-log */ + if (cfg) + cd.lpcd_first_idx = cfg->cfg_last_idx; + cd.lpcd_last_idx = 0; + + rc = llog_process(llh, class_config_llog_handler, cfg, &cd); + CDEBUG(D_CONFIG, "Processed log %s gen %d-%d (rc=%d)\n", name, + cd.lpcd_first_idx + 1, cd.lpcd_last_idx, rc); + + if (cfg) + cfg->cfg_last_idx = cd.lpcd_last_idx; + +parse_out: rc2 = llog_close(llh); if (rc == 0) rc = rc2; @@ -707,8 +1320,16 @@ int class_config_dump_handler(struct llog_handle * handle, { int cfg_len = rec->lrh_len; char *cfg_buf = (char*) (rec + 1); + char *outstr, *ptr, *end; int rc = 0; ENTRY; + + OBD_ALLOC(outstr, 256); + end = outstr + 256; + ptr = outstr; + if (!outstr) { + RETURN(-ENOMEM); + } if (rec->lrh_type == OBD_CFG_REC) { struct lustre_cfg *lcfg; int i; @@ -718,55 +1339,39 @@ int class_config_dump_handler(struct llog_handle * handle, GOTO(out, rc); lcfg = (struct lustre_cfg *)cfg_buf; - CDEBUG(D_INFO, "lcfg command: %x\n", lcfg->lcfg_command); - if (LUSTRE_CFG_BUFLEN(lcfg, 0) > 0) - CDEBUG(D_INFO, " devname: %s\n", - lustre_cfg_string(lcfg, 0)); - if (lcfg->lcfg_flags) - CDEBUG(D_INFO, " flags: %x\n", lcfg->lcfg_flags); - if (lcfg->lcfg_nid) - CDEBUG(D_INFO, " nid: "LPX64"\n", - lcfg->lcfg_nid); - if (lcfg->lcfg_nal) - CDEBUG(D_INFO, " nal: %x\n", lcfg->lcfg_nal); - if (lcfg->lcfg_num) - CDEBUG(D_INFO, " nal: %x\n", lcfg->lcfg_num); - for (i = 1; i < lcfg->lcfg_bufcount; i++) - if (LUSTRE_CFG_BUFLEN(lcfg, i) > 0) - CDEBUG(D_INFO, " inlbuf%d: %s\n", i, - lustre_cfg_string(lcfg, i)); - } else if (rec->lrh_type == PTL_CFG_REC) { - struct portals_cfg *pcfg = (struct portals_cfg *)cfg_buf; - CDEBUG(D_INFO, "pcfg command: %d\n", pcfg->pcfg_command); - if (pcfg->pcfg_nal) - CDEBUG(D_INFO, " nal: %x\n", - pcfg->pcfg_nal); - if (pcfg->pcfg_gw_nal) - CDEBUG(D_INFO, " gw_nal: %x\n", - pcfg->pcfg_gw_nal); - if (pcfg->pcfg_nid) - CDEBUG(D_INFO, " nid: "LPX64"\n", - pcfg->pcfg_nid); - if (pcfg->pcfg_nid2) - CDEBUG(D_INFO, " nid: "LPX64"\n", - pcfg->pcfg_nid2); - if (pcfg->pcfg_nid3) - CDEBUG(D_INFO, " nid: "LPX64"\n", - pcfg->pcfg_nid3); - if (pcfg->pcfg_misc) - CDEBUG(D_INFO, " nid: %d\n", - pcfg->pcfg_misc); - if (pcfg->pcfg_id) - CDEBUG(D_INFO, " id: %x\n", - pcfg->pcfg_id); - if (pcfg->pcfg_flags) - CDEBUG(D_INFO, " flags: %x\n", - pcfg->pcfg_flags); + ptr += snprintf(ptr, end-ptr, "cmd=%05x ", + lcfg->lcfg_command); + if (lcfg->lcfg_flags) { + ptr += snprintf(ptr, end-ptr, "flags=%#08x ", + lcfg->lcfg_flags); + } + if (lcfg->lcfg_num) { + ptr += snprintf(ptr, end-ptr, "num=%#08x ", + lcfg->lcfg_num); + } + if (lcfg->lcfg_nid) { + ptr += snprintf(ptr, end-ptr, "nid=%s("LPX64")\n ", + libcfs_nid2str(lcfg->lcfg_nid), + lcfg->lcfg_nid); + } + if (lcfg->lcfg_command == LCFG_MARKER) { + struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1); + ptr += snprintf(ptr, end-ptr, "marker=%d(%#x)%s '%s'", + marker->cm_step, marker->cm_flags, + marker->cm_tgtname, marker->cm_comment); + } else { + for (i = 0; i < lcfg->lcfg_bufcount; i++) { + ptr += snprintf(ptr, end-ptr, "%d:%s ", i, + lustre_cfg_string(lcfg, i)); + } + } + LCONSOLE(D_WARNING, " %s\n", outstr); } else { - CERROR("unhandled lrh_type: %#x\n", rec->lrh_type); + LCONSOLE(D_WARNING, "unhandled lrh_type: %#x\n", rec->lrh_type); rc = -EINVAL; } out: + OBD_FREE(outstr, 256); RETURN(rc); } @@ -777,17 +1382,252 @@ int class_config_dump_llog(struct llog_ctxt *ctxt, char *name, int rc, rc2; ENTRY; - rc = llog_open(ctxt, &llh, NULL, name, 0); + LCONSOLE_INFO("Dumping config log %s\n", name); + + rc = llog_create(ctxt, &llh, NULL, name); if (rc) RETURN(rc); rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL); - if (rc == 0) - rc = llog_process(llh, class_config_dump_handler, cfg, NULL); + if (rc) + GOTO(parse_out, rc); + rc = llog_process(llh, class_config_dump_handler, cfg, NULL); +parse_out: rc2 = llog_close(llh); if (rc == 0) rc = rc2; + LCONSOLE_INFO("End config log %s\n", name); RETURN(rc); + } + +/* Cleanup and detach */ +int class_manual_cleanup(struct obd_device *obd) +{ + char flags[3] = ""; + struct lustre_cfg *lcfg; + struct lustre_cfg_bufs bufs; + int rc; + ENTRY; + + if (!obd) { + CERROR("empty cleanup\n"); + RETURN(-EALREADY); + } + + if (obd->obd_force) + strcat(flags, "F"); + if (obd->obd_fail) + strcat(flags, "A"); + + CDEBUG(D_CONFIG, "Manual cleanup of %s (flags='%s')\n", + obd->obd_name, flags); + + lustre_cfg_bufs_reset(&bufs, obd->obd_name); + lustre_cfg_bufs_set_string(&bufs, 1, flags); + lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs); + if (!lcfg) + RETURN(-ENOMEM); + + rc = class_process_config(lcfg); + if (rc) { + CERROR("cleanup failed %d: %s\n", rc, obd->obd_name); + GOTO(out, rc); + } + + /* the lcfg is almost the same for both ops */ + lcfg->lcfg_command = LCFG_DETACH; + rc = class_process_config(lcfg); + if (rc) + CERROR("detach failed %d: %s\n", rc, obd->obd_name); +out: + lustre_cfg_free(lcfg); + RETURN(rc); +} + +/* + * uuid<->export lustre hash operations + */ + +static unsigned +uuid_hash(lustre_hash_t *lh, void *key, unsigned mask) +{ + return lh_djb2_hash(((struct obd_uuid *)key)->uuid, + sizeof(((struct obd_uuid *)key)->uuid), mask); +} + +static void * +uuid_key(struct hlist_node *hnode) +{ + struct obd_export *exp; + + exp = hlist_entry(hnode, struct obd_export, exp_uuid_hash); + + RETURN(&exp->exp_client_uuid); +} + +/* + * NOTE: It is impossible to find an export that is in failed + * state with this function + */ +static int +uuid_compare(void *key, struct hlist_node *hnode) +{ + struct obd_export *exp; + + LASSERT(key); + exp = hlist_entry(hnode, struct obd_export, exp_uuid_hash); + + RETURN(obd_uuid_equals((struct obd_uuid *)key,&exp->exp_client_uuid) && + !exp->exp_failed); +} + +static void * +uuid_export_get(struct hlist_node *hnode) +{ + struct obd_export *exp; + + exp = hlist_entry(hnode, struct obd_export, exp_uuid_hash); + class_export_get(exp); + + RETURN(exp); +} + +static void * +uuid_export_put(struct hlist_node *hnode) +{ + struct obd_export *exp; + + exp = hlist_entry(hnode, struct obd_export, exp_uuid_hash); + class_export_put(exp); + + RETURN(exp); +} + +static lustre_hash_ops_t uuid_hash_ops = { + .lh_hash = uuid_hash, + .lh_key = uuid_key, + .lh_compare = uuid_compare, + .lh_get = uuid_export_get, + .lh_put = uuid_export_put, +}; + + +/* + * nid<->export hash operations + */ + +static unsigned +nid_hash(lustre_hash_t *lh, void *key, unsigned mask) +{ + return lh_djb2_hash(key, sizeof(lnet_nid_t), mask); +} + +static void * +nid_key(struct hlist_node *hnode) +{ + struct obd_export *exp; + + exp = hlist_entry(hnode, struct obd_export, exp_nid_hash); + + RETURN(&exp->exp_connection->c_peer.nid); +} + +/* + * NOTE: It is impossible to find an export that is in failed + * state with this function + */ +static int +nid_compare(void *key, struct hlist_node *hnode) +{ + struct obd_export *exp; + + LASSERT(key); + exp = hlist_entry(hnode, struct obd_export, exp_nid_hash); + + RETURN(exp->exp_connection->c_peer.nid == *(lnet_nid_t *)key && + !exp->exp_failed); +} + +static void * +nid_export_get(struct hlist_node *hnode) +{ + struct obd_export *exp; + + exp = hlist_entry(hnode, struct obd_export, exp_nid_hash); + class_export_get(exp); + + RETURN(exp); +} + +static void * +nid_export_put(struct hlist_node *hnode) +{ + struct obd_export *exp; + + exp = hlist_entry(hnode, struct obd_export, exp_nid_hash); + class_export_put(exp); + + RETURN(exp); +} + +static lustre_hash_ops_t nid_hash_ops = { + .lh_hash = nid_hash, + .lh_key = nid_key, + .lh_compare = nid_compare, + .lh_get = nid_export_get, + .lh_put = nid_export_put, +}; + + +/* + * nid<->nidstats hash operations + */ + +static void * +nidstats_key(struct hlist_node *hnode) +{ + struct nid_stat *ns; + + ns = hlist_entry(hnode, struct nid_stat, nid_hash); + + RETURN(&ns->nid); +} + +static int +nidstats_compare(void *key, struct hlist_node *hnode) +{ + RETURN(*(lnet_nid_t *)nidstats_key(hnode) == *(lnet_nid_t *)key); +} + +static void * +nidstats_get(struct hlist_node *hnode) +{ + struct nid_stat *ns; + + ns = hlist_entry(hnode, struct nid_stat, nid_hash); + nidstat_getref(ns); + + RETURN(ns); +} + +static void * +nidstats_put(struct hlist_node *hnode) +{ + struct nid_stat *ns; + + ns = hlist_entry(hnode, struct nid_stat, nid_hash); + nidstat_putref(ns); + + RETURN(ns); +} + +static lustre_hash_ops_t nid_stat_hash_ops = { + .lh_hash = nid_hash, + .lh_key = nidstats_key, + .lh_compare = nidstats_compare, + .lh_get = nidstats_get, + .lh_put = nidstats_put, +};