-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
+ *
+ * Copyright (c) 2011, Whamcloud, Inc.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
* Author: Nathan Rutman <nathan@clusterfs.com>
*/
-#ifndef EXPORT_SYMTAB
-#define EXPORT_SYMTAB
-#endif
#define DEBUG_SUBSYSTEM S_MGS
-#define D_MGS D_CONFIG /*|D_WARNING*/
+#define D_MGS D_CONFIG
#ifdef __KERNEL__
#include <linux/module.h>
#include <lustre_disk.h>
#include <lustre_param.h>
#include <lustre_sec.h>
+#include <lquota.h>
#include "mgs_internal.h"
/********************** Class functions ********************/
/* Caller must list_del and OBD_FREE each dentry from the list */
int class_dentry_readdir(struct obd_device *obd, struct dentry *dir,
struct vfsmount *inmnt,
- struct list_head *dentry_list){
+ cfs_list_t *dentry_list){
/* see mds_cleanup_pending */
struct lvfs_run_ctxt saved;
struct file *file;
GOTO(out_pop, rc = PTR_ERR(mnt));
}
- file = dentry_open(dentry, mnt, O_RDONLY);
+ file = ll_dentry_open(dentry, mnt, O_RDONLY, current_cred());
if (IS_ERR(file))
/* dentry_open_it() drops the dentry, mnt refs */
GOTO(out_pop, rc = PTR_ERR(file));
*/
/* It might be better to have a separate db file, instead of parsing the info
out of the client log. This is slow and potentially error-prone. */
-static int mgs_fsdb_handler(struct llog_handle *llh, struct llog_rec_hdr *rec,
- void *data)
+static int mgs_fsdb_handler(const struct lu_env *env, struct llog_handle *llh,
+ struct llog_rec_hdr *rec, void *data)
{
- struct mgs_fsdb_handler_data *d = (struct mgs_fsdb_handler_data *) data;
+ struct mgs_fsdb_handler_data *d = data;
struct fs_db *fsdb = d->fsdb;
int cfg_len = rec->lrh_len;
char *cfg_buf = (char*) (rec + 1);
CDEBUG(D_MGS, "OST index for %s is %u (%s)\n",
lustre_cfg_string(lcfg, 1), index,
lustre_cfg_string(lcfg, 2));
- set_bit(index, fsdb->fsdb_ost_index_map);
+ cfs_set_bit(index, fsdb->fsdb_ost_index_map);
}
/* Figure out mdt indicies */
}
rc = 0;
CDEBUG(D_MGS, "MDT index is %u\n", index);
- set_bit(index, fsdb->fsdb_mdt_index_map);
+ cfs_set_bit(index, fsdb->fsdb_mdt_index_map);
+ fsdb->fsdb_mdt_count ++;
}
/* COMPAT_146 */
/* #01 L attach 0:lov_mdsA 1:lov 2:cdbe9_lov_mdsA_dc8cf7f3bb */
if ((fsdb->fsdb_gen == 0) && (lcfg->lcfg_command == LCFG_ATTACH) &&
(strcmp(lustre_cfg_string(lcfg, 1), LUSTRE_LOV_NAME) == 0)) {
- fsdb->fsdb_flags |= FSDB_OLDLOG14;
+ cfs_set_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags);
name_destroy(&fsdb->fsdb_clilov);
rc = name_create(&fsdb->fsdb_clilov,
lustre_cfg_string(lcfg, 0), "");
if ((fsdb->fsdb_gen == 0) && (lcfg->lcfg_command == LCFG_SETUP) &&
(strncmp(lustre_cfg_string(lcfg, 0), "MDC_", 4) == 0)) {
char *ptr;
- fsdb->fsdb_flags |= FSDB_OLDLOG14;
+ cfs_set_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags);
ptr = strstr(lustre_cfg_string(lcfg, 1), "_UUID");
if (!ptr) {
CERROR("Can't parse MDT uuid %s\n",
/*
* compat to 1.8, check osc name used by MDT0 to OSTs, bz18548.
*/
- if (fsdb->fsdb_fl_oscname_18 == 0 &&
+ if (!cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags) &&
lcfg->lcfg_command == LCFG_ATTACH &&
strcmp(lustre_cfg_string(lcfg, 1), LUSTRE_OSC_NAME) == 0) {
if (OBD_OCD_VERSION_MAJOR(d->ver) == 1 &&
OBD_OCD_VERSION_MINOR(d->ver) <= 8) {
CWARN("MDT using 1.8 OSC name scheme\n");
- fsdb->fsdb_fl_oscname_18 = 1;
+ cfs_set_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags);
}
}
RETURN(rc);
}
-/* fsdb->fsdb_sem is already held in mgs_find_or_make_fsdb*/
+/* fsdb->fsdb_mutex is already held in mgs_find_or_make_fsdb*/
static int mgs_get_fsdb_from_llog(struct obd_device *obd, struct fs_db *fsdb)
{
char *logname;
ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
LASSERT(ctxt != NULL);
name_create(&logname, fsdb->fsdb_name, "-client");
- down(&fsdb->fsdb_sem);
+ cfs_mutex_lock(&fsdb->fsdb_mutex);
push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
- rc = llog_create(ctxt, &loghandle, NULL, logname);
- if (rc)
- GOTO(out_pop, rc);
+ rc = llog_create(NULL, ctxt, &loghandle, NULL, logname);
+ if (rc)
+ GOTO(out_pop, rc);
- rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(NULL, loghandle, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
if (llog_get_size(loghandle) <= 1)
- fsdb->fsdb_flags |= FSDB_LOG_EMPTY;
+ cfs_set_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags);
- rc = llog_process(loghandle, mgs_fsdb_handler, (void *) &d, NULL);
- CDEBUG(D_INFO, "get_db = %d\n", rc);
+ rc = llog_process(NULL, loghandle, mgs_fsdb_handler, (void *) &d,
+ NULL);
+ CDEBUG(D_INFO, "get_db = %d\n", rc);
out_close:
- rc2 = llog_close(loghandle);
+ rc2 = llog_close(NULL, loghandle);
if (!rc)
rc = rc2;
out_pop:
pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
- up(&fsdb->fsdb_sem);
+ cfs_mutex_unlock(&fsdb->fsdb_mutex);
name_destroy(&logname);
llog_ctxt_put(ctxt);
sptlrpc_rule_set_free(&fsdb->fsdb_srpc_gen);
}
-static struct fs_db *mgs_find_fsdb(struct obd_device *obd, char *fsname)
+struct fs_db *mgs_find_fsdb(struct obd_device *obd, char *fsname)
{
struct mgs_obd *mgs = &obd->u.mgs;
struct fs_db *fsdb;
- struct list_head *tmp;
+ cfs_list_t *tmp;
- list_for_each(tmp, &mgs->mgs_fs_db_list) {
- fsdb = list_entry(tmp, struct fs_db, fsdb_list);
+ cfs_list_for_each(tmp, &mgs->mgs_fs_db_list) {
+ fsdb = cfs_list_entry(tmp, struct fs_db, fsdb_list);
if (strcmp(fsdb->fsdb_name, fsname) == 0)
return fsdb;
}
RETURN(NULL);
strcpy(fsdb->fsdb_name, fsname);
- sema_init(&fsdb->fsdb_sem, 1);
- fsdb->fsdb_fl_udesc = 1;
+ cfs_mutex_init(&fsdb->fsdb_mutex);
+ cfs_set_bit(FSDB_UDESC, &fsdb->fsdb_flags);
if (strcmp(fsname, MGSSELF_NAME) == 0) {
- fsdb->fsdb_fl_mgsself = 1;
+ cfs_set_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags);
} else {
OBD_ALLOC(fsdb->fsdb_ost_index_map, INDEX_MAP_SIZE);
OBD_ALLOC(fsdb->fsdb_mdt_index_map, INDEX_MAP_SIZE);
if (rc)
GOTO(err, rc);
+ /* initialise data for NID table */
+ mgs_ir_init_fs(obd, fsdb);
+
lproc_mgs_add_live(obd, fsdb);
}
- list_add(&fsdb->fsdb_list, &mgs->mgs_fs_db_list);
+ cfs_list_add(&fsdb->fsdb_list, &mgs->mgs_fs_db_list);
RETURN(fsdb);
err:
static void mgs_free_fsdb(struct obd_device *obd, struct fs_db *fsdb)
{
/* wait for anyone with the sem */
- down(&fsdb->fsdb_sem);
+ cfs_mutex_lock(&fsdb->fsdb_mutex);
lproc_mgs_del_live(obd, fsdb);
- list_del(&fsdb->fsdb_list);
+ cfs_list_del(&fsdb->fsdb_list);
+
+ /* deinitialize fsr */
+ mgs_ir_fini_fs(obd, fsdb);
+
if (fsdb->fsdb_ost_index_map)
OBD_FREE(fsdb->fsdb_ost_index_map, INDEX_MAP_SIZE);
if (fsdb->fsdb_mdt_index_map)
name_destroy(&fsdb->fsdb_mdtlmv);
name_destroy(&fsdb->fsdb_mdc);
mgs_free_fsdb_srpc(fsdb);
+ cfs_mutex_unlock(&fsdb->fsdb_mutex);
OBD_FREE_PTR(fsdb);
}
{
struct mgs_obd *mgs = &obd->u.mgs;
struct fs_db *fsdb;
- struct list_head *tmp, *tmp2;
- down(&mgs->mgs_sem);
- list_for_each_safe(tmp, tmp2, &mgs->mgs_fs_db_list) {
- fsdb = list_entry(tmp, struct fs_db, fsdb_list);
+ cfs_list_t *tmp, *tmp2;
+ cfs_mutex_lock(&mgs->mgs_mutex);
+ cfs_list_for_each_safe(tmp, tmp2, &mgs->mgs_fs_db_list) {
+ fsdb = cfs_list_entry(tmp, struct fs_db, fsdb_list);
mgs_free_fsdb(obd, fsdb);
}
- up(&mgs->mgs_sem);
+ cfs_mutex_unlock(&mgs->mgs_mutex);
return 0;
}
struct fs_db *fsdb;
int rc = 0;
- down(&mgs->mgs_sem);
+ cfs_mutex_lock(&mgs->mgs_mutex);
fsdb = mgs_find_fsdb(obd, name);
if (fsdb) {
- up(&mgs->mgs_sem);
+ cfs_mutex_unlock(&mgs->mgs_mutex);
*dbh = fsdb;
return 0;
}
CDEBUG(D_MGS, "Creating new db\n");
fsdb = mgs_new_fsdb(obd, name);
- up(&mgs->mgs_sem);
+ cfs_mutex_unlock(&mgs->mgs_mutex);
if (!fsdb)
return -ENOMEM;
- if (!fsdb->fsdb_fl_mgsself) {
+ if (!cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
/* populate the db from the client llog */
rc = mgs_get_fsdb_from_llog(obd, fsdb);
if (rc) {
RETURN(rc);
}
- if (fsdb->fsdb_flags & FSDB_LOG_EMPTY)
+ if (cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags))
RETURN(-1);
if (mti->mti_flags & LDD_F_SV_TYPE_OST)
else
RETURN(-EINVAL);
- if (test_bit(mti->mti_stripe_index, imap))
+ if (cfs_test_bit(mti->mti_stripe_index, imap))
RETURN(1);
RETURN(0);
}
{
int i;
for (i = 0; i < map_len * 8; i++)
- if (!test_bit(i, index_map)) {
+ if (!cfs_test_bit(i, index_map)) {
return i;
}
CERROR("max index %d exceeded.\n", i);
0 newly marked as in use
<0 err
+EALREADY for update of an old index */
-int mgs_set_index(struct obd_device *obd, struct mgs_target_info *mti)
+static int mgs_set_index(struct obd_device *obd, struct mgs_target_info *mti)
{
struct fs_db *fsdb;
void *imap;
RETURN(rc);
}
- if (mti->mti_flags & LDD_F_SV_TYPE_OST)
+ if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
imap = fsdb->fsdb_ost_index_map;
- else if (mti->mti_flags & LDD_F_SV_TYPE_MDT)
+ } else if (mti->mti_flags & LDD_F_SV_TYPE_MDT) {
imap = fsdb->fsdb_mdt_index_map;
- else
+ if (fsdb->fsdb_mdt_count >= MAX_MDT_COUNT) {
+ LCONSOLE_ERROR_MSG(0x13f, "The max mdt count"
+ "is %d\n", (int)MAX_MDT_COUNT);
+ RETURN(-ERANGE);
+ }
+ } else {
RETURN(-EINVAL);
+ }
if (mti->mti_flags & LDD_F_NEED_INDEX) {
rc = next_index(imap, INDEX_MAP_SIZE);
if (rc == -1)
RETURN(-ERANGE);
mti->mti_stripe_index = rc;
+ if (mti->mti_flags & LDD_F_SV_TYPE_MDT)
+ fsdb->fsdb_mdt_count ++;
}
if (mti->mti_stripe_index >= INDEX_MAP_SIZE * 8) {
RETURN(-ERANGE);
}
- if (test_bit(mti->mti_stripe_index, imap)) {
+ if (cfs_test_bit(mti->mti_stripe_index, imap)) {
if ((mti->mti_flags & LDD_F_VIRGIN) &&
!(mti->mti_flags & LDD_F_WRITECONF)) {
LCONSOLE_ERROR_MSG(0x140, "Server %s requested index "
}
}
- set_bit(mti->mti_stripe_index, imap);
- fsdb->fsdb_flags &= ~FSDB_LOG_EMPTY;
- server_make_name(mti->mti_flags, mti->mti_stripe_index,
- mti->mti_fsname, mti->mti_svname);
+ cfs_set_bit(mti->mti_stripe_index, imap);
+ cfs_clear_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags);
+ server_make_name(mti->mti_flags & ~(LDD_F_VIRGIN | LDD_F_WRITECONF),
+ mti->mti_stripe_index, mti->mti_fsname, mti->mti_svname);
CDEBUG(D_MGS, "Set index for %s to %d\n", mti->mti_svname,
mti->mti_stripe_index);
int mml_modified;
};
-static int mgs_modify_handler(struct llog_handle *llh, struct llog_rec_hdr *rec,
- void *data)
+static int mgs_modify_handler(const struct lu_env *env,
+ struct llog_handle *llh,
+ struct llog_rec_hdr *rec, void *data)
{
- struct mgs_modify_lookup *mml = (struct mgs_modify_lookup *)data;
+ struct mgs_modify_lookup *mml = data;
struct cfg_marker *marker;
struct lustre_cfg *lcfg = (struct lustre_cfg *)(rec + 1);
int cfg_len = rec->lrh_len - sizeof(struct llog_rec_hdr) -
/* Header and tail are added back to lrh_len in
llog_lvfs_write_rec */
rec->lrh_len = cfg_len;
- rc = llog_write_rec(llh, rec, NULL, 0, (void *)lcfg,
- rec->lrh_index);
+ rc = llog_write_rec(NULL, llh, rec, NULL, 0, (void *)lcfg,
+ rec->lrh_index);
if (!rc)
mml->mml_modified++;
}
int rc, rc2;
ENTRY;
- CDEBUG(D_MGS, "modify %s/%s/%s\n", logname, devname, comment);
+ CDEBUG(D_MGS, "modify %s/%s/%s fl=%x\n", logname, devname, comment,
+ flags);
push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
LASSERT(ctxt != NULL);
- rc = llog_create(ctxt, &loghandle, NULL, logname);
+ rc = llog_create(NULL, ctxt, &loghandle, NULL, logname);
if (rc)
GOTO(out_pop, rc);
- rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(NULL, loghandle, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
mml->mml_marker.cm_flags = flags;
mml->mml_marker.cm_canceltime = flags ? cfs_time_current_sec() : 0;
mml->mml_modified = 0;
- rc = llog_process(loghandle, mgs_modify_handler, (void *)mml, NULL);
+ rc = llog_process(NULL, loghandle, mgs_modify_handler, (void *)mml,
+ NULL);
if (!rc && !mml->mml_modified)
rc = -ENODEV;
OBD_FREE_PTR(mml);
out_close:
- rc2 = llog_close(loghandle);
+ rc2 = llog_close(NULL, loghandle);
if (!rc)
rc = rc2;
out_pop:
push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
/* idx = -1 means append */
- rc = llog_write_rec(llh, &rec, NULL, 0, (void *)lcfg, -1);
+ rc = llog_write_rec(NULL, llh, &rec, NULL, 0, (void *)lcfg, -1);
pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
if (rc)
CERROR("failed %d\n", rc);
GOTO(out, rc = -ENODEV);
push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
- rc = llog_create(ctxt, llh, NULL, name);
- if (rc == 0)
- llog_init_handle(*llh, LLOG_F_IS_PLAIN, &cfg_uuid);
- else
- *llh = NULL;
+ rc = llog_create(NULL, ctxt, llh, NULL, name);
+ if (rc == 0)
+ llog_init_handle(NULL, *llh, LLOG_F_IS_PLAIN, &cfg_uuid);
+ else
+ *llh = NULL;
pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
- rc = llog_close(*llh);
+ rc = llog_close(NULL, *llh);
*llh = NULL;
pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
LASSERT(ctxt != NULL);
push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
- rc = llog_create(ctxt, &llh, NULL, name);
+ rc = llog_create(NULL, ctxt, &llh, NULL, name);
if (rc == 0) {
- llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
- rc = llog_get_size(llh);
- llog_close(llh);
+ llog_init_handle(NULL, llh, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_get_size(llh);
+ llog_close(NULL, llh);
}
pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
/* write the lcfg in all logs for the given fs */
int mgs_write_log_direct_all(struct obd_device *obd, struct fs_db *fsdb,
- struct mgs_target_info *mti,
- struct lustre_cfg *lcfg,
- char *devname, char *comment)
+ struct mgs_target_info *mti,
+ struct lustre_cfg *lcfg,
+ char *devname, char *comment,
+ int server_only)
{
struct mgs_obd *mgs = &obd->u.mgs;
- struct list_head dentry_list;
+ cfs_list_t dentry_list;
struct l_linux_dirent *dirent, *n;
char *fsname = mti->mti_fsname;
char *logname;
}
/* Could use fsdb index maps instead of directory listing */
- list_for_each_entry_safe(dirent, n, &dentry_list, lld_list) {
- list_del(&dirent->lld_list);
+ cfs_list_for_each_entry_safe(dirent, n, &dentry_list, lld_list) {
+ cfs_list_del(&dirent->lld_list);
/* don't write to sptlrpc rule log */
- if (strncmp(fsname, dirent->lld_name, len) == 0 &&
- strstr(dirent->lld_name, "-sptlrpc") == NULL) {
+ if (strstr(dirent->lld_name, "-sptlrpc") != NULL)
+ goto next;
+
+ /* caller wants write server logs only */
+ if (server_only && strstr(dirent->lld_name, "-client") != NULL)
+ goto next;
+
+ if (strncmp(fsname, dirent->lld_name, len) == 0) {
CDEBUG(D_MGS, "Changing log %s\n", dirent->lld_name);
/* Erase any old settings of this same parameter */
mgs_modify(obd, fsdb, mti, dirent->lld_name, devname,
comment, CM_SKIP);
/* Write the new one */
- rc = mgs_write_log_direct(obd, fsdb, dirent->lld_name,
- lcfg, devname, comment);
- if (rc)
- CERROR("err %d writing log %s\n", rc,
- dirent->lld_name);
+ if (lcfg) {
+ rc = mgs_write_log_direct(obd, fsdb,
+ dirent->lld_name,
+ lcfg, devname,
+ comment);
+ if (rc)
+ CERROR("err %d writing log %s\n", rc,
+ dirent->lld_name);
+ }
}
+next:
OBD_FREE(dirent, sizeof(*dirent));
}
static int mgs_write_log_mdc_to_mdt(struct obd_device *, struct fs_db *,
struct mgs_target_info *, char *);
+static int mgs_write_log_osc_to_lov(struct obd_device *obd, struct fs_db *fsdb,
+ struct mgs_target_info *mti,
+ char *logname, char *suffix, char *lovname,
+ enum lustre_sec_part sec_part, int flags);
+static void name_create_mdt_and_lov(char **logname, char **lovname,
+ struct fs_db *fsdb, int i);
-static int mgs_steal_llog_handler(struct llog_handle *llh,
- struct llog_rec_hdr *rec,
- void *data)
+static int mgs_steal_llog_handler(const struct lu_env *env,
+ struct llog_handle *llh,
+ struct llog_rec_hdr *rec, void *data)
{
struct obd_device * obd;
struct mgs_target_info *mti, *tmti;
if (!strncmp(marker->cm_comment,"add osc",7) &&
(marker->cm_flags & CM_START)){
got_an_osc_or_mdc = 1;
+ strncpy(tmti->mti_svname, marker->cm_tgtname,
+ sizeof(tmti->mti_svname));
rc = record_start_log(obd, &mdt_llh, mti->mti_svname);
rc = record_marker(obd, mdt_llh, fsdb, CM_START,
mti->mti_svname,"add osc(copied)");
memset(tmti, 0, sizeof(*tmti));
RETURN(rc);
}
+
+ if (lcfg->lcfg_command == LCFG_LOV_ADD_OBD) {
+ int index;
+ char mdt_index[9];
+ char *logname, *lovname;
+
+ name_create_mdt_and_lov(&logname, &lovname, fsdb,
+ mti->mti_stripe_index);
+ sprintf(mdt_index, "-MDT%04x", mti->mti_stripe_index);
+
+ if (sscanf(lustre_cfg_buf(lcfg, 2), "%d", &index) != 1) {
+ name_destroy(&logname);
+ name_destroy(&lovname);
+ RETURN(-EINVAL);
+ }
+
+ tmti->mti_stripe_index = index;
+ mgs_write_log_osc_to_lov(obd, fsdb, tmti, logname,
+ mdt_index, lovname,
+ LUSTRE_SP_MDT, 0);
+ name_destroy(&logname);
+ name_destroy(&lovname);
+ RETURN(rc);
+ }
RETURN(rc);
}
-/* fsdb->fsdb_sem is already held in mgs_write_log_target*/
+/* fsdb->fsdb_mutex is already held in mgs_write_log_target*/
/* stealed from mgs_get_fsdb_from_llog*/
static int mgs_steal_llog_for_mdt_from_client(struct obd_device *obd,
char *client_name,
push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
- rc = llog_create(ctxt, &loghandle, NULL, client_name);
+ rc = llog_create(NULL, ctxt, &loghandle, NULL, client_name);
if (rc)
GOTO(out_pop, rc);
- rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(NULL, loghandle, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
- rc = llog_process(loghandle, mgs_steal_llog_handler, (void *)comp, NULL);
+ rc = llog_process(NULL, loghandle, mgs_steal_llog_handler,
+ (void *)comp, NULL);
CDEBUG(D_MGS, "steal llog re = %d\n", rc);
out_close:
- rc2 = llog_close(loghandle);
+ rc2 = llog_close(NULL, loghandle);
if (!rc)
rc = rc2;
out_pop:
lovdesc->ld_default_stripe_count = 1;
lovdesc->ld_pattern = LOV_PATTERN_RAID0;
lovdesc->ld_default_stripe_size = 1024 * 1024;
- lovdesc->ld_default_stripe_offset = 0;
+ lovdesc->ld_default_stripe_offset = -1;
lovdesc->ld_qos_maxage = QOS_DEFAULT_MAXAGE;
sprintf((char*)lovdesc->ld_uuid.uuid, "%s_UUID", lovname);
/* can these be the same? */
{
struct llog_handle *llh = NULL;
char *mdcname, *nodeuuid, *mdcuuid, *lmvuuid;
- char index[5];
+ char index[6];
int i, rc;
ENTRY;
int i, rc;
ENTRY;
- if (mgs_log_is_empty(obd, mti->mti_svname)) {
+ if (mgs_log_is_empty(obd, logname)) {
CERROR("log is empty! Logical error\n");
RETURN (-EINVAL);
}
{
name_create_mdt(logname, fsdb->fsdb_name, i);
/* COMPAT_180 */
- if (i == 0 && fsdb->fsdb_fl_oscname_18)
+ if (i == 0 && cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
name_create(lovname, fsdb->fsdb_name, "-mdtlov");
else
name_create(lovname, *logname, "-mdtlov");
{
char suffix[16];
- if (i == 0 && fsdb->fsdb_fl_oscname_18)
+ if (i == 0 && cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
sprintf(suffix, "-osc");
else
sprintf(suffix, "-osc-MDT%04x", i);
for (i = 0; i < INDEX_MAP_SIZE * 8; i++){
char *mdtname;
if (i != mti->mti_stripe_index &&
- test_bit(i, fsdb->fsdb_mdt_index_map)) {
+ cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
name_create_mdt(&mdtname, mti->mti_fsname, i);
rc = mgs_write_log_mdc_to_mdt(obd, fsdb, mti, mdtname);
name_destroy(&mdtname);
{
struct llog_handle *llh = NULL;
char *nodeuuid, *oscname, *oscuuid, *lovuuid, *svname;
- char index[5];
+ char index[6];
int i, rc;
ENTRY;
mti->mti_svname, logname);
if (mgs_log_is_empty(obd, logname)) {
- /* The first item in the log must be the lov, so we have
- somewhere to add our osc. */
- rc = mgs_write_log_lov(obd, fsdb, mti, logname, lovname);
+ CERROR("log is empty! Logical error\n");
+ RETURN (-EINVAL);
}
name_create(&nodeuuid, libcfs_nid2str(mti->mti_nids[0]), "");
/* We also have to update the other logs where this osc is part of
the lov */
- if (fsdb->fsdb_flags & FSDB_OLDLOG14) {
+ if (cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags)) {
/* If we're upgrading, the old mdt log already has our
entry. Let's do a fake one for fun. */
/* Note that we can't add any new failnids, since we don't
/* Add ost to all MDT lov defs */
for (i = 0; i < INDEX_MAP_SIZE * 8; i++){
- if (test_bit(i, fsdb->fsdb_mdt_index_map)) {
+ if (cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
char mdt_index[9];
name_create_mdt_and_lov(&logname, &lovname, fsdb, i);
/* Append ost info to the client log */
name_create(&logname, mti->mti_fsname, "-client");
+ if (mgs_log_is_empty(obd, logname)) {
+ /* Start client log */
+ rc = mgs_write_log_lov(obd, fsdb, mti, logname,
+ fsdb->fsdb_clilov);
+ rc = mgs_write_log_lmv(obd, fsdb, mti, logname,
+ fsdb->fsdb_clilmv);
+ }
mgs_write_log_osc_to_lov(obd, fsdb, mti, logname, "",
- fsdb->fsdb_clilov, LUSTRE_SP_CLI, 0);
+ fsdb->fsdb_clilov, LUSTRE_SP_CLI, flags);
name_destroy(&logname);
RETURN(rc);
}
+static __inline__ int mgs_param_empty(char *ptr)
+{
+ char *tmp;
+
+ if ((tmp = strchr(ptr, '=')) && (*(++tmp) == '\0'))
+ return 1;
+ return 0;
+}
+
+static int mgs_write_log_failnid_internal(struct obd_device *obd,
+ struct fs_db *fsdb,
+ struct mgs_target_info *mti,
+ char *logname, char *cliname)
+{
+ int rc;
+ struct llog_handle *llh = NULL;
+
+ if (mgs_param_empty(mti->mti_params)) {
+ /* Remove _all_ failnids */
+ rc = mgs_modify(obd, fsdb, mti, logname,
+ mti->mti_svname, "add failnid", CM_SKIP);
+ return rc;
+ }
+
+ /* Otherwise failover nids are additive */
+ rc = record_start_log(obd, &llh, logname);
+ if (!rc) {
+ /* FIXME this should be a single journal transaction */
+ rc = record_marker(obd, llh, fsdb, CM_START,
+ mti->mti_svname, "add failnid");
+ rc = mgs_write_log_failnids(obd, mti, llh, cliname);
+ rc = record_marker(obd, llh, fsdb, CM_END,
+ mti->mti_svname, "add failnid");
+ rc = record_end_log(obd, &llh);
+ }
+
+ return rc;
+}
+
+
/* Add additional failnids to an existing log.
The mdc/osc must have been added to logs first */
/* tcp nids must be in dotted-quad ascii -
struct mgs_target_info *mti)
{
char *logname, *cliname;
- struct llog_handle *llh = NULL;
int rc;
ENTRY;
- /* FIXME how do we delete a failnid? Currently --writeconf is the
- only way. Maybe make --erase-params pass a flag to really
- erase all params from logs - except it can't erase the failnids
- given when a target first registers, since they aren't processed
- as params... */
+ /* FIXME we currently can't erase the failnids
+ * given when a target first registers, since they aren't part of
+ * an "add uuid" stanza */
/* Verify that we know about this target */
if (mgs_log_is_empty(obd, mti->mti_svname)) {
RETURN(-EINVAL);
}
- /* Add failover nids to client log */
+ /* Add failover nids to the client log */
name_create(&logname, mti->mti_fsname, "-client");
- rc = record_start_log(obd, &llh, logname);
- if (!rc) {
- /* FIXME this fn should be a single journal transaction */
- rc = record_marker(obd, llh, fsdb, CM_START, mti->mti_svname,
- "add failnid");
- rc = mgs_write_log_failnids(obd, mti, llh, cliname);
- rc = record_marker(obd, llh, fsdb, CM_END, mti->mti_svname,
- "add failnid");
- rc = record_end_log(obd, &llh);
- }
+ rc = mgs_write_log_failnid_internal(obd, fsdb, mti, logname, cliname);
name_destroy(&logname);
name_destroy(&cliname);
int i;
for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
- if (!test_bit(i, fsdb->fsdb_mdt_index_map))
+ if (!cfs_test_bit(i, fsdb->fsdb_mdt_index_map))
continue;
name_create_mdt(&logname, mti->mti_fsname, i);
name_create_mdt_osc(&cliname, mti->mti_svname, fsdb, i);
-
- rc = record_start_log(obd, &llh, logname);
- if (!rc) {
- rc = record_marker(obd, llh, fsdb, CM_START,
- mti->mti_svname,
- "add failnid");
- rc = mgs_write_log_failnids(obd, mti, llh,
- cliname);
- rc = record_marker(obd, llh, fsdb, CM_END,
- mti->mti_svname,
- "add failnid");
- rc = record_end_log(obd, &llh);
- }
+ rc = mgs_write_log_failnid_internal(obd, fsdb, mti,
+ logname, cliname);
name_destroy(&cliname);
name_destroy(&logname);
}
char comment[MTI_NAME_MAXLEN];
char *tmp;
struct lustre_cfg *lcfg;
- int rc;
+ int rc, del;
/* Erase any old settings of this same parameter */
memcpy(comment, ptr, MTI_NAME_MAXLEN);
*tmp = 0;
/* FIXME we should skip settings that are the same as old values */
rc = mgs_modify(obd, fsdb, mti, logname, tgtname, comment, CM_SKIP);
- LCONSOLE_INFO("%sing parameter %s.%s in log %s\n", rc ?
+ del = mgs_param_empty(ptr);
+
+ LCONSOLE_INFO("%sing parameter %s.%s in log %s\n", del ? "Disabl" : rc ?
"Sett" : "Modify", tgtname, comment, logname);
+ if (del)
+ return rc;
lustre_cfg_bufs_reset(bufs, tgtname);
lustre_cfg_bufs_set_string(bufs, 1, ptr);
/* write global variable settings into log */
static int mgs_write_log_sys(struct obd_device *obd, struct fs_db *fsdb,
- struct mgs_target_info *mti, char *sys, char *ptr)
-{
- struct lustre_cfg_bufs bufs;
- struct lustre_cfg *lcfg;
- char *tmp;
- int cmd, val;
- int rc;
-
- if (class_match_param(ptr, PARAM_TIMEOUT, &tmp) == 0)
- cmd = LCFG_SET_TIMEOUT;
- else if (class_match_param(ptr, PARAM_LDLM_TIMEOUT, &tmp) == 0)
- cmd = LCFG_SET_LDLM_TIMEOUT;
- /* Check for known params here so we can return error to lctl */
- else if ((class_match_param(ptr, PARAM_AT_MIN, &tmp) == 0)
- || (class_match_param(ptr, PARAM_AT_MAX, &tmp) == 0)
- || (class_match_param(ptr, PARAM_AT_EXTRA, &tmp) == 0)
- || (class_match_param(ptr, PARAM_AT_EARLY_MARGIN, &tmp) == 0)
- || (class_match_param(ptr, PARAM_AT_HISTORY, &tmp) == 0))
- cmd = LCFG_PARAM;
- else
- return -EINVAL;
-
- val = simple_strtoul(tmp, NULL, 0);
- CDEBUG(D_MGS, "global %s = %d\n", ptr, val);
-
- lustre_cfg_bufs_reset(&bufs, NULL);
- lustre_cfg_bufs_set_string(&bufs, 1, sys);
- lcfg = lustre_cfg_new(cmd, &bufs);
- lcfg->lcfg_num = val;
- /* modify all servers and clients */
- rc = mgs_write_log_direct_all(obd, fsdb, mti, lcfg, mti->mti_fsname,
- ptr);
- lustre_cfg_free(lcfg);
- return rc;
+ struct mgs_target_info *mti, char *sys, char *ptr)
+{
+ struct lustre_cfg_bufs bufs;
+ struct lustre_cfg *lcfg;
+ char *tmp, sep;
+ int rc, cmd, convert = 1;
+
+ if (class_match_param(ptr, PARAM_TIMEOUT, &tmp) == 0) {
+ cmd = LCFG_SET_TIMEOUT;
+ } else if (class_match_param(ptr, PARAM_LDLM_TIMEOUT, &tmp) == 0) {
+ cmd = LCFG_SET_LDLM_TIMEOUT;
+ /* Check for known params here so we can return error to lctl */
+ } else if ((class_match_param(ptr, PARAM_AT_MIN, &tmp) == 0) ||
+ (class_match_param(ptr, PARAM_AT_MAX, &tmp) == 0) ||
+ (class_match_param(ptr, PARAM_AT_EXTRA, &tmp) == 0) ||
+ (class_match_param(ptr, PARAM_AT_EARLY_MARGIN, &tmp) == 0) ||
+ (class_match_param(ptr, PARAM_AT_HISTORY, &tmp) == 0)) {
+ cmd = LCFG_PARAM;
+ } else if (class_match_param(ptr, PARAM_JOBID_VAR, &tmp) == 0) {
+ convert = 0; /* Don't convert string value to integer */
+ cmd = LCFG_PARAM;
+ } else {
+ return -EINVAL;
+ }
+
+ if (mgs_param_empty(ptr))
+ CDEBUG(D_MGS, "global '%s' removed\n", sys);
+ else
+ CDEBUG(D_MGS, "global '%s' val=%s\n", sys, tmp);
+
+ lustre_cfg_bufs_reset(&bufs, NULL);
+ lustre_cfg_bufs_set_string(&bufs, 1, sys);
+ if (!convert && *tmp != '\0')
+ lustre_cfg_bufs_set_string(&bufs, 2, tmp);
+ lcfg = lustre_cfg_new(cmd, &bufs);
+ lcfg->lcfg_num = convert ? simple_strtoul(tmp, NULL, 0) : 0;
+ /* truncate the comment to the parameter name */
+ ptr = tmp - 1;
+ sep = *ptr;
+ *ptr = '\0';
+ /* modify all servers and clients */
+ rc = mgs_write_log_direct_all(obd, fsdb, mti,
+ *tmp == '\0' ? NULL : lcfg,
+ mti->mti_fsname, sys, 0);
+ if (rc == 0 && *tmp != '\0') {
+ switch (cmd) {
+ case LCFG_SET_TIMEOUT:
+ if (!obd_timeout_set || lcfg->lcfg_num > obd_timeout)
+ class_process_config(lcfg);
+ break;
+ case LCFG_SET_LDLM_TIMEOUT:
+ if (!ldlm_timeout_set || lcfg->lcfg_num > ldlm_timeout)
+ class_process_config(lcfg);
+ break;
+ default:
+ break;
+ }
+ }
+ *ptr = sep;
+ lustre_cfg_free(lcfg);
+ return rc;
+}
+
+/* write quota settings into log */
+static int mgs_write_log_quota(struct obd_device *obd, struct fs_db *fsdb,
+ struct mgs_target_info *mti, char *quota,
+ char *ptr)
+{
+ struct lustre_cfg_bufs bufs;
+ struct lustre_cfg *lcfg;
+ char *tmp;
+ char sep;
+ int cmd = LCFG_PARAM;
+ int rc;
+
+ /* support only 'meta' and 'data' pools so far */
+ if (class_match_param(ptr, QUOTA_METAPOOL_NAME, &tmp) != 0 &&
+ class_match_param(ptr, QUOTA_DATAPOOL_NAME, &tmp) != 0) {
+ CERROR("parameter quota.%s isn't supported (only quota.mdt "
+ "& quota.ost are)\n", ptr);
+ return -EINVAL;
+ }
+
+ if (*tmp == '\0') {
+ CDEBUG(D_MGS, "global '%s' removed\n", quota);
+ } else {
+ CDEBUG(D_MGS, "global '%s'\n", quota);
+
+ if (strchr(tmp, 'u') == NULL && strchr(tmp, 'g') == NULL &&
+ strcmp(tmp, "none") != 0) {
+ CERROR("enable option(%s) isn't supported\n", tmp);
+ return -EINVAL;
+ }
+ }
+
+ lustre_cfg_bufs_reset(&bufs, NULL);
+ lustre_cfg_bufs_set_string(&bufs, 1, quota);
+ lcfg = lustre_cfg_new(cmd, &bufs);
+ /* truncate the comment to the parameter name */
+ ptr = tmp - 1;
+ sep = *ptr;
+ *ptr = '\0';
+
+ /* XXX we duplicated quota enable information in all server
+ * config logs, it should be moved to a separate config
+ * log once we cleanup the config log for global param. */
+ /* modify all servers */
+ rc = mgs_write_log_direct_all(obd, fsdb, mti,
+ *tmp == '\0' ? NULL : lcfg,
+ mti->mti_fsname, quota, 1);
+ *ptr = sep;
+ lustre_cfg_free(lcfg);
+ return rc;
}
static int mgs_srpc_set_param_disk(struct obd_device *obd,
goto error_out;
if (strcmp(ptr, "yes") == 0) {
- fsdb->fsdb_fl_udesc = 1;
+ cfs_set_bit(FSDB_UDESC, &fsdb->fsdb_flags);
CWARN("Enable user descriptor shipping from client to MDT\n");
} else if (strcmp(ptr, "no") == 0) {
- fsdb->fsdb_fl_udesc = 0;
+ cfs_clear_bit(FSDB_UDESC, &fsdb->fsdb_flags);
CWARN("Disable user descriptor shipping from client to MDT\n");
} else {
*(ptr - 1) = '=';
RETURN(rc);
/* mgs rules implies must be mgc->mgs */
- if (fsdb->fsdb_fl_mgsself) {
+ if (cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
if ((rule.sr_from != LUSTRE_SP_MGC &&
rule.sr_from != LUSTRE_SP_ANY) ||
(rule.sr_to != LUSTRE_SP_MGS &&
if (rc)
goto out_free;
- if (fsdb->fsdb_fl_mgsself) {
+ if (cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
/*
* for mgs rules, make them effective immediately.
*/
int msrd_skip;
};
-static int mgs_srpc_read_handler(struct llog_handle *llh,
- struct llog_rec_hdr *rec,
- void *data)
+static int mgs_srpc_read_handler(const struct lu_env *env,
+ struct llog_handle *llh,
+ struct llog_rec_hdr *rec, void *data)
{
- struct mgs_srpc_read_data *msrd = (struct mgs_srpc_read_data *) data;
+ struct mgs_srpc_read_data *msrd = data;
struct cfg_marker *marker;
struct lustre_cfg *lcfg = (struct lustre_cfg *)(rec + 1);
char *svname, *param;
push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
- rc = llog_create(ctxt, &llh, NULL, logname);
+ rc = llog_create(NULL, ctxt, &llh, NULL, logname);
if (rc)
GOTO(out_pop, rc);
- rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(NULL, llh, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
msrd.msrd_fsdb = fsdb;
msrd.msrd_skip = 0;
- rc = llog_process(llh, mgs_srpc_read_handler, (void *) &msrd, NULL);
+ rc = llog_process(NULL, llh, mgs_srpc_read_handler, (void *) &msrd,
+ NULL);
out_close:
- llog_close(llh);
+ llog_close(NULL, llh);
out_pop:
pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
out:
RETURN(rc);
}
+/* Permanent settings of all parameters by writing into the appropriate
+ * configuration logs.
+ * A parameter with null value ("<param>='\0'") means to erase it out of
+ * the logs.
+ */
static int mgs_write_log_param(struct obd_device *obd, struct fs_db *fsdb,
struct mgs_target_info *mti, char *ptr)
{
struct lustre_cfg_bufs bufs;
char *logname;
char *tmp;
- int rc = 0;
+ int rc = 0, rc2 = 0;
ENTRY;
/* For various parameter settings, we have to figure out which logs
if (class_match_param(ptr, PARAM_MGSNODE, NULL) == 0)
GOTO(end, rc);
+ /* Processed in ost/mdt */
+ if (class_match_param(ptr, PARAM_NETWORK, NULL) == 0)
+ GOTO(end, rc);
+
/* Processed in mgs_write_log_ost */
if (class_match_param(ptr, PARAM_FAILMODE, NULL) == 0) {
if (mti->mti_flags & LDD_F_PARAM) {
GOTO(end, rc);
}
+ if (class_match_param(ptr, PARAM_QUOTA, &tmp) == 0) {
+ rc = mgs_write_log_quota(obd, fsdb, mti, ptr, tmp);
+ GOTO(end, rc);
+ }
+
if (class_match_param(ptr, PARAM_OSC""PARAM_ACTIVE, &tmp) == 0) {
/* active=0 means off, anything else means on */
int flag = (*tmp == '0') ? CM_EXCLUDE : 0;
/* Modify mdtlov */
/* Add to all MDT logs for CMD */
for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
- if (!test_bit(i, fsdb->fsdb_mdt_index_map))
+ if (!cfs_test_bit(i, fsdb->fsdb_mdt_index_map))
continue;
name_create_mdt(&logname, mti->mti_fsname, i);
rc = mgs_modify(obd, fsdb, mti, logname,
"changes were made to the "
"config log.\n",
mti->mti_svname, rc);
- if (fsdb->fsdb_flags & FSDB_OLDLOG14)
+ if (cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags))
LCONSOLE_ERROR_MSG(0x146, "This may be"
" because the log"
"is in the old 1.4"
"-mdc");
} else if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
/* COMPAT_146 */
- if (fsdb->fsdb_flags & FSDB_OLDLOG14) {
+ if (cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags)) {
LCONSOLE_ERROR_MSG(0x148, "Upgraded "
"client logs for %s"
" cannot be "
int i;
for (i = 0; i < INDEX_MAP_SIZE * 8; i++){
- if (!test_bit(i, fsdb->fsdb_mdt_index_map))
+ if (!cfs_test_bit(i, fsdb->fsdb_mdt_index_map))
continue;
name_destroy(&cname);
name_create_mdt_osc(&cname, mti->mti_svname,
goto active_err;
if (rc & LDD_F_SV_ALL) {
for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
- if (!test_bit(i,
- fsdb->fsdb_mdt_index_map))
+ if (!cfs_test_bit(i,
+ fsdb->fsdb_mdt_index_map))
continue;
name_create_mdt(&logname, mti->mti_fsname, i);
rc = mgs_wlp_lcfg(obd, fsdb, mti,
}
LCONSOLE_WARN("Ignoring unrecognized param '%s'\n", ptr);
+ rc2 = -ENOSYS;
end:
if (rc)
CERROR("err %d on param '%s'\n", rc, ptr);
- RETURN(rc);
+ RETURN(rc ?: rc2);
}
/* Not implementing automatic failover nid addition at this time. */
the failover list. Modify mti->params for rewriting back at
server_register_target(). */
- down(&fsdb->fsdb_sem);
+ cfs_mutex_lock(&fsdb->fsdb_mutex);
rc = mgs_write_log_add_failnid(obd, fsdb, mti);
- up(&fsdb->fsdb_sem);
+ cfs_mutex_unlock(&fsdb->fsdb_mutex);
RETURN(rc);
#endif
}
int mgs_write_log_target(struct obd_device *obd,
- struct mgs_target_info *mti)
+ struct mgs_target_info *mti,
+ struct fs_db *fsdb)
{
- struct fs_db *fsdb;
int rc = -EINVAL;
char *buf, *params;
ENTRY;
}
}
- rc = mgs_find_or_make_fsdb(obd, mti->mti_fsname, &fsdb);
- if (rc) {
- CERROR("Can't get db for %s\n", mti->mti_fsname);
- RETURN(rc);
- }
-
- down(&fsdb->fsdb_sem);
+ cfs_mutex_lock(&fsdb->fsdb_mutex);
if (mti->mti_flags &
(LDD_F_VIRGIN | LDD_F_UPGRADE14 | LDD_F_WRITECONF)) {
OBD_FREE(buf, strlen(mti->mti_params) + 1);
out_up:
- up(&fsdb->fsdb_sem);
+ cfs_mutex_unlock(&fsdb->fsdb_mutex);
RETURN(rc);
}
/* COMPAT_146 */
/* verify that we can handle the old config logs */
-int mgs_upgrade_sv_14(struct obd_device *obd, struct mgs_target_info *mti)
+int mgs_upgrade_sv_14(struct obd_device *obd, struct mgs_target_info *mti,
+ struct fs_db *fsdb)
{
- struct fs_db *fsdb;
int rc = 0;
ENTRY;
LCONSOLE_INFO("upgrading server %s from pre-1.6\n", mti->mti_svname);
server_mti_print("upgrade", mti);
- rc = mgs_find_or_make_fsdb(obd, mti->mti_fsname, &fsdb);
- if (rc)
- RETURN(rc);
-
- if (fsdb->fsdb_flags & FSDB_LOG_EMPTY) {
+ if (cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags)) {
LCONSOLE_ERROR_MSG(0x14a, "The old client log %s-client is "
"missing. Was tunefs.lustre successful?\n",
mti->mti_fsname);
}
}
- if (!(fsdb->fsdb_flags & FSDB_OLDLOG14)) {
+ if (!cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags)) {
LCONSOLE_ERROR_MSG(0x14c, "%s-client is supposedly an old "
"log, but no old LOV or MDT was found. "
"Consider updating the configuration with"
LASSERT(ctxt != NULL);
push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
- rc = llog_create(ctxt, &llh, NULL, name);
- if (rc == 0) {
- llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
- rc = llog_destroy(llh);
+ rc = llog_create(NULL, ctxt, &llh, NULL, name);
+ if (rc == 0) {
+ llog_init_handle(NULL, llh, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_destroy(NULL, llh);
llog_free_handle(llh);
}
pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
int mgs_erase_logs(struct obd_device *obd, char *fsname)
{
struct mgs_obd *mgs = &obd->u.mgs;
- static struct fs_db *fsdb;
- struct list_head dentry_list;
+ struct fs_db *fsdb;
+ cfs_list_t dentry_list;
struct l_linux_dirent *dirent, *n;
int rc, len = strlen(fsname);
+ char *suffix;
ENTRY;
/* Find all the logs in the CONFIGS directory */
RETURN(rc);
}
- down(&mgs->mgs_sem);
+ cfs_mutex_lock(&mgs->mgs_mutex);
/* Delete the fs db */
fsdb = mgs_find_fsdb(obd, fsname);
if (fsdb)
mgs_free_fsdb(obd, fsdb);
- list_for_each_entry_safe(dirent, n, &dentry_list, lld_list) {
- list_del(&dirent->lld_list);
- if (strncmp(fsname, dirent->lld_name, len) == 0) {
- CDEBUG(D_MGS, "Removing log %s\n", dirent->lld_name);
- mgs_erase_log(obd, dirent->lld_name);
+ cfs_list_for_each_entry_safe(dirent, n, &dentry_list, lld_list) {
+ cfs_list_del(&dirent->lld_list);
+ suffix = strrchr(dirent->lld_name, '-');
+ if (suffix != NULL) {
+ if ((len == suffix - dirent->lld_name) &&
+ (strncmp(fsname, dirent->lld_name, len) == 0)) {
+ CDEBUG(D_MGS, "Removing log %s\n",
+ dirent->lld_name);
+ mgs_erase_log(obd, dirent->lld_name);
+ }
}
OBD_FREE(dirent, sizeof(*dirent));
}
- up(&mgs->mgs_sem);
+ cfs_mutex_unlock(&mgs->mgs_mutex);
RETURN(rc);
}
EXIT;
}
-/* Set a permanent (config log) param for a target or fs */
+/* Set a permanent (config log) param for a target or fs
+ * \param lcfg buf0 may contain the device (testfs-MDT0000) name
+ * buf1 contains the single parameter
+ */
int mgs_setparam(struct obd_device *obd, struct lustre_cfg *lcfg, char *fsname)
{
struct fs_db *fsdb;
strncpy(fsname, devname, MTI_NAME_MAXLEN);
}
fsname[MTI_NAME_MAXLEN - 1] = 0;
- CDEBUG(D_MGS, "setparam on fs %s device %s\n", fsname, devname);
+ CDEBUG(D_MGS, "setparam fs='%s' device='%s'\n", fsname, devname);
rc = mgs_find_or_make_fsdb(obd, fsname, &fsdb);
if (rc)
RETURN(rc);
- if (!fsdb->fsdb_fl_mgsself && fsdb->fsdb_flags & FSDB_LOG_EMPTY) {
+ if (!cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags) &&
+ cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags)) {
CERROR("No filesystem targets for %s. cfg_device from lctl "
"is '%s'\n", fsname, devname);
mgs_free_fsdb(obd, fsdb);
mti->mti_flags = rc | LDD_F_PARAM;
- down(&fsdb->fsdb_sem);
- /* this is lctl conf_param's single param path, there is not
- need to loop through parameters */
+ cfs_mutex_lock(&fsdb->fsdb_mutex);
rc = mgs_write_log_param(obd, fsdb, mti, mti->mti_params);
- up(&fsdb->fsdb_sem);
+ cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ /*
+ * Revoke lock so everyone updates. Should be alright if
+ * someone was already reading while we were updating the logs,
+ * so we don't really need to hold the lock while we're
+ * writing (above).
+ */
+ mgs_revoke_lock(obd, fsdb, CONFIG_T_CONFIG);
out:
OBD_FREE_PTR(mti);
RETURN(rc);
CERROR("Can't get db for %s\n", fsname);
RETURN(rc);
}
- if (fsdb->fsdb_flags & FSDB_LOG_EMPTY) {
+ if (cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags)) {
CERROR("%s is not defined\n", fsname);
mgs_free_fsdb(obd, fsdb);
RETURN(-EINVAL);
}
}
- down(&fsdb->fsdb_sem);
+ cfs_mutex_lock(&fsdb->fsdb_mutex);
if (canceled_label != NULL) {
OBD_ALLOC_PTR(mti);
/* write pool def to all MDT logs */
for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
- if (test_bit(i, fsdb->fsdb_mdt_index_map)) {
+ if (cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
name_create_mdt_and_lov(&logname, &lovname, fsdb, i);
if (canceled_label != NULL) {
cmd, fsname, poolname, ostname, label);
name_destroy(&logname);
- up(&fsdb->fsdb_sem);
+ cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ /* request for update */
+ mgs_revoke_lock(obd, fsdb, CONFIG_T_CONFIG);
EXIT;
out:
git://git.whamcloud.com / fs / lustre-release.git / blobdiff