* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, Whamcloud, Inc.
+ * Copyright (c) 2011, 2012, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#include <obd_lov.h>
#include <lustre_param.h>
#include <lustre_sec.h>
-#include <lquota.h>
-#include <lustre_log.h>
+#include <lustre_quota.h>
#include "mgs_internal.h"
/********************** Class functions ********************/
-/* Caller must list_del and mgs_dirent_free() each dentry from the list */
int class_dentry_readdir(const struct lu_env *env,
struct mgs_device *mgs, cfs_list_t *list)
{
CDEBUG(D_MGS, "OST index for %s is %u (%s)\n",
lustre_cfg_string(lcfg, 1), index,
lustre_cfg_string(lcfg, 2));
- cfs_set_bit(index, fsdb->fsdb_ost_index_map);
+ set_bit(index, fsdb->fsdb_ost_index_map);
}
/* Figure out mdt indicies */
}
rc = 0;
CDEBUG(D_MGS, "MDT index is %u\n", index);
- cfs_set_bit(index, fsdb->fsdb_mdt_index_map);
+ set_bit(index, fsdb->fsdb_mdt_index_map);
fsdb->fsdb_mdt_count ++;
}
/*
* compat to 1.8, check osc name used by MDT0 to OSTs, bz18548.
*/
- if (!cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags) &&
+ if (!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");
- cfs_set_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags);
+ set_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags);
}
}
struct mgs_device *mgs,
struct fs_db *fsdb)
{
- char *logname;
- struct llog_handle *loghandle;
- struct lvfs_run_ctxt saved;
- struct llog_ctxt *ctxt;
- struct mgs_fsdb_handler_data d = { fsdb, 0 };
- int rc, rc2;
- ENTRY;
+ char *logname;
+ struct llog_handle *loghandle;
+ struct llog_ctxt *ctxt;
+ struct mgs_fsdb_handler_data d = { fsdb, 0 };
+ int rc;
+
+ ENTRY;
ctxt = llog_get_context(mgs->mgs_obd, LLOG_CONFIG_ORIG_CTXT);
LASSERT(ctxt != NULL);
rc = name_create(&logname, fsdb->fsdb_name, "-client");
if (rc)
GOTO(out_put, rc);
- cfs_mutex_lock(&fsdb->fsdb_mutex);
- push_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
- rc = llog_open_create(NULL, ctxt, &loghandle, NULL, logname);
+ rc = llog_open_create(env, ctxt, &loghandle, NULL, logname);
if (rc)
GOTO(out_pop, rc);
- rc = llog_init_handle(NULL, loghandle, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(env, loghandle, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
if (llog_get_size(loghandle) <= 1)
- cfs_set_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags);
+ set_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags);
- rc = llog_process_or_fork(env, loghandle, mgs_fsdb_handler, (void *)&d,
- NULL, false);
+ rc = llog_process(env, loghandle, mgs_fsdb_handler, (void *)&d, NULL);
CDEBUG(D_INFO, "get_db = %d\n", rc);
out_close:
- rc2 = llog_close(NULL, loghandle);
- if (!rc)
- rc = rc2;
+ llog_close(env, loghandle);
out_pop:
- pop_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
- cfs_mutex_unlock(&fsdb->fsdb_mutex);
name_destroy(&logname);
out_put:
llog_ctxt_put(ctxt);
RETURN(NULL);
strcpy(fsdb->fsdb_name, fsname);
- cfs_mutex_init(&fsdb->fsdb_mutex);
- cfs_set_bit(FSDB_UDESC, &fsdb->fsdb_flags);
+ mutex_init(&fsdb->fsdb_mutex);
+ set_bit(FSDB_UDESC, &fsdb->fsdb_flags);
fsdb->fsdb_gen = 1;
if (strcmp(fsname, MGSSELF_NAME) == 0) {
- cfs_set_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags);
+ 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);
static void mgs_free_fsdb(struct mgs_device *mgs, struct fs_db *fsdb)
{
/* wait for anyone with the sem */
- cfs_mutex_lock(&fsdb->fsdb_mutex);
+ mutex_lock(&fsdb->fsdb_mutex);
lproc_mgs_del_live(mgs, fsdb);
cfs_list_del(&fsdb->fsdb_list);
name_destroy(&fsdb->fsdb_clilov);
name_destroy(&fsdb->fsdb_clilmv);
mgs_free_fsdb_srpc(fsdb);
- cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ mutex_unlock(&fsdb->fsdb_mutex);
OBD_FREE_PTR(fsdb);
}
{
struct fs_db *fsdb;
cfs_list_t *tmp, *tmp2;
- cfs_mutex_lock(&mgs->mgs_mutex);
+ 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(mgs, fsdb);
}
- cfs_mutex_unlock(&mgs->mgs_mutex);
+ mutex_unlock(&mgs->mgs_mutex);
return 0;
}
struct fs_db *fsdb;
int rc = 0;
- cfs_mutex_lock(&mgs->mgs_mutex);
+ ENTRY;
+ mutex_lock(&mgs->mgs_mutex);
fsdb = mgs_find_fsdb(mgs, name);
if (fsdb) {
- cfs_mutex_unlock(&mgs->mgs_mutex);
+ mutex_unlock(&mgs->mgs_mutex);
*dbh = fsdb;
- return 0;
+ RETURN(0);
}
CDEBUG(D_MGS, "Creating new db\n");
fsdb = mgs_new_fsdb(env, mgs, name);
- cfs_mutex_unlock(&mgs->mgs_mutex);
+ /* lock fsdb_mutex until the db is loaded from llogs */
+ if (fsdb)
+ mutex_lock(&fsdb->fsdb_mutex);
+ mutex_unlock(&mgs->mgs_mutex);
if (!fsdb)
- return -ENOMEM;
+ RETURN(-ENOMEM);
- if (!cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
+ if (!test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
/* populate the db from the client llog */
rc = mgs_get_fsdb_from_llog(env, mgs, fsdb);
if (rc) {
CERROR("Can't get db from client log %d\n", rc);
- mgs_free_fsdb(mgs, fsdb);
- return rc;
+ GOTO(out_free, rc);
}
}
rc = mgs_get_fsdb_srpc_from_llog(env, mgs, fsdb);
if (rc) {
CERROR("Can't get db from params log %d\n", rc);
- mgs_free_fsdb(mgs, fsdb);
- return rc;
+ GOTO(out_free, rc);
}
+ mutex_unlock(&fsdb->fsdb_mutex);
*dbh = fsdb;
- return 0;
+ RETURN(0);
+
+out_free:
+ mutex_unlock(&fsdb->fsdb_mutex);
+ mgs_free_fsdb(mgs, fsdb);
+ return rc;
}
/* 1 = index in use
RETURN(rc);
}
- if (cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags))
+ if (test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags))
RETURN(-1);
if (mti->mti_flags & LDD_F_SV_TYPE_OST)
else
RETURN(-EINVAL);
- if (cfs_test_bit(mti->mti_stripe_index, imap))
+ if (test_bit(mti->mti_stripe_index, imap))
RETURN(1);
RETURN(0);
}
{
int i;
for (i = 0; i < map_len * 8; i++)
- if (!cfs_test_bit(i, index_map)) {
+ if (!test_bit(i, index_map)) {
return i;
}
CERROR("max index %d exceeded.\n", i);
RETURN(rc);
}
+ mutex_lock(&fsdb->fsdb_mutex);
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) {
imap = fsdb->fsdb_mdt_index_map;
- 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);
+ GOTO(out_up, rc = -EINVAL);
}
if (mti->mti_flags & LDD_F_NEED_INDEX) {
rc = next_index(imap, INDEX_MAP_SIZE);
if (rc == -1)
- RETURN(-ERANGE);
+ GOTO(out_up, rc = -ERANGE);
mti->mti_stripe_index = rc;
if (mti->mti_flags & LDD_F_SV_TYPE_MDT)
fsdb->fsdb_mdt_count ++;
"but the max index is %d.\n",
mti->mti_svname, mti->mti_stripe_index,
INDEX_MAP_SIZE * 8);
- RETURN(-ERANGE);
+ GOTO(out_up, rc = -ERANGE);
}
- if (cfs_test_bit(mti->mti_stripe_index, imap)) {
+ if (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 "
"use. Use --writeconf to force\n",
mti->mti_svname,
mti->mti_stripe_index);
- RETURN(-EADDRINUSE);
+ GOTO(out_up, rc = -EADDRINUSE);
} else {
CDEBUG(D_MGS, "Server %s updating index %d\n",
mti->mti_svname, mti->mti_stripe_index);
- RETURN(EALREADY);
+ GOTO(out_up, rc = EALREADY);
}
}
- cfs_set_bit(mti->mti_stripe_index, imap);
- cfs_clear_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags);
+ set_bit(mti->mti_stripe_index, imap);
+ clear_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags);
+ mutex_unlock(&fsdb->fsdb_mutex);
server_make_name(mti->mti_flags & ~(LDD_F_VIRGIN | LDD_F_WRITECONF),
mti->mti_stripe_index, mti->mti_fsname, mti->mti_svname);
mti->mti_stripe_index);
RETURN(0);
+out_up:
+ mutex_unlock(&fsdb->fsdb_mutex);
+ return rc;
}
struct mgs_modify_lookup {
{
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) -
- sizeof(struct llog_rec_tail);
+ struct lustre_cfg *lcfg = REC_DATA(rec);
+ int cfg_len = REC_DATA_LEN(rec);
int rc;
ENTRY;
/* Header and tail are added back to lrh_len in
llog_lvfs_write_rec */
rec->lrh_len = cfg_len;
- rc = llog_write(NULL, llh, rec, NULL, 0, (void *)lcfg,
+ rc = llog_write(env, llh, rec, NULL, 0, (void *)lcfg,
rec->lrh_index);
if (!rc)
mml->mml_modified++;
RETURN(rc);
}
-/* Modify an existing config log record (for CM_SKIP or CM_EXCLUDE) */
+/**
+ * Modify an existing config log record (for CM_SKIP or CM_EXCLUDE)
+ * Return code:
+ * 0 - modified successfully,
+ * 1 - no modification was done
+ * negative - error
+ */
static int mgs_modify(const struct lu_env *env, struct mgs_device *mgs,
struct fs_db *fsdb, struct mgs_target_info *mti,
char *logname, char *devname, char *comment, int flags)
{
struct llog_handle *loghandle;
- struct lvfs_run_ctxt saved;
struct llog_ctxt *ctxt;
struct mgs_modify_lookup *mml;
- int rc, rc2;
+ int rc;
+
ENTRY;
- CDEBUG(D_MGS, "modify %s/%s/%s fl=%x\n", logname, devname, comment,
- flags);
+ LASSERT(mutex_is_locked(&fsdb->fsdb_mutex));
+ CDEBUG(D_MGS, "modify %s/%s/%s fl=%x\n", logname, devname, comment,
+ flags);
ctxt = llog_get_context(mgs->mgs_obd, LLOG_CONFIG_ORIG_CTXT);
LASSERT(ctxt != NULL);
- push_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
- rc = llog_open(NULL, ctxt, &loghandle, NULL, logname,
- LLOG_OPEN_EXISTS);
+ rc = llog_open(env, ctxt, &loghandle, NULL, logname, LLOG_OPEN_EXISTS);
if (rc < 0) {
if (rc == -ENOENT)
rc = 0;
GOTO(out_pop, rc);
}
- rc = llog_init_handle(NULL, loghandle, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(env, 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_or_fork(env, loghandle, mgs_modify_handler,
- (void *)mml, NULL, false);
- if (!rc && !mml->mml_modified)
+ rc = llog_process(env, loghandle, mgs_modify_handler, (void *)mml,
+ NULL);
+ if (!rc && !mml->mml_modified)
rc = 1;
OBD_FREE_PTR(mml);
out_close:
- rc2 = llog_close(NULL, loghandle);
- if (!rc)
- rc = rc2;
+ llog_close(env, loghandle);
out_pop:
- pop_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
if (rc < 0)
- CERROR("modify %s/%s failed %d\n",
- mti->mti_svname, comment, rc);
+ CERROR("%s: modify %s/%s failed: rc = %d\n",
+ mgs->mgs_obd->obd_name, mti->mti_svname, comment, rc);
llog_ctxt_put(ctxt);
RETURN(rc);
}
-/******************** config log recording functions *********************/
+/** This structure is passed to mgs_replace_handler */
+struct mgs_replace_uuid_lookup {
+ /* Nids are replaced for this target device */
+ struct mgs_target_info target;
+ /* Temporary modified llog */
+ struct llog_handle *temp_llh;
+ /* Flag is set if in target block*/
+ int in_target_device;
+ /* Nids already added. Just skip (multiple nids) */
+ int device_nids_added;
+ /* Flag is set if this block should not be copied */
+ int skip_it;
+};
+
+/**
+ * Check: a) if block should be skipped
+ * b) is it target block
+ *
+ * \param[in] lcfg
+ * \param[in] mrul
+ *
+ * \retval 0 should not to be skipped
+ * \retval 1 should to be skipped
+ */
+static int check_markers(struct lustre_cfg *lcfg,
+ struct mgs_replace_uuid_lookup *mrul)
+{
+ struct cfg_marker *marker;
+
+ /* Track markers. Find given device */
+ if (lcfg->lcfg_command == LCFG_MARKER) {
+ marker = lustre_cfg_buf(lcfg, 1);
+ /* Clean llog from records marked as CM_EXCLUDE.
+ CM_SKIP records are used for "active" command
+ and can be restored if needed */
+ if ((marker->cm_flags & (CM_EXCLUDE | CM_START)) ==
+ (CM_EXCLUDE | CM_START)) {
+ mrul->skip_it = 1;
+ return 1;
+ }
+
+ if ((marker->cm_flags & (CM_EXCLUDE | CM_END)) ==
+ (CM_EXCLUDE | CM_END)) {
+ mrul->skip_it = 0;
+ return 1;
+ }
+
+ if (strcmp(mrul->target.mti_svname, marker->cm_tgtname) == 0) {
+ LASSERT(!(marker->cm_flags & CM_START) ||
+ !(marker->cm_flags & CM_END));
+ if (marker->cm_flags & CM_START) {
+ mrul->in_target_device = 1;
+ mrul->device_nids_added = 0;
+ } else if (marker->cm_flags & CM_END)
+ mrul->in_target_device = 0;
+ }
+ }
+
+ return 0;
+}
static int record_lcfg(const struct lu_env *env, struct llog_handle *llh,
- struct lustre_cfg *lcfg)
+ struct lustre_cfg *lcfg)
{
- struct lvfs_run_ctxt saved;
- struct llog_rec_hdr rec;
- int buflen, rc;
- struct obd_device *obd = llh->lgh_ctxt->loc_obd;
+ struct llog_rec_hdr rec;
+ int buflen, rc;
if (!lcfg || !llh)
return -ENOMEM;
rec.lrh_len = llog_data_len(buflen);
rec.lrh_type = OBD_CFG_REC;
- push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
/* idx = -1 means append */
- rc = llog_write(NULL, llh, &rec, NULL, 0, (void *)lcfg, -1);
- pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
+ rc = llog_write(env, llh, &rec, NULL, 0, (void *)lcfg, -1);
if (rc)
CERROR("failed %d\n", rc);
return rc;
return rc;
}
-
static inline int record_add_uuid(const struct lu_env *env,
struct llog_handle *llh,
uint64_t nid, char *uuid)
{
return record_base(env, llh, NULL, nid, LCFG_ADD_UUID, uuid, 0, 0, 0);
-
}
static inline int record_add_conn(const struct lu_env *env,
return record_base(env, llh, devname, 0, LCFG_SETUP, s1, s2, s3, s4);
}
+/**
+ * \retval <0 record processing error
+ * \retval n record is processed. No need copy original one.
+ * \retval 0 record is not processed.
+ */
+static int process_command(const struct lu_env *env, struct lustre_cfg *lcfg,
+ struct mgs_replace_uuid_lookup *mrul)
+{
+ int nids_added = 0;
+ lnet_nid_t nid;
+ char *ptr;
+ int rc;
+
+ if (lcfg->lcfg_command == LCFG_ADD_UUID) {
+ /* LCFG_ADD_UUID command found. Let's skip original command
+ and add passed nids */
+ ptr = mrul->target.mti_params;
+ while (class_parse_nid(ptr, &nid, &ptr) == 0) {
+ CDEBUG(D_MGS, "add nid %s with uuid %s, "
+ "device %s\n", libcfs_nid2str(nid),
+ mrul->target.mti_params,
+ mrul->target.mti_svname);
+ rc = record_add_uuid(env,
+ mrul->temp_llh, nid,
+ mrul->target.mti_params);
+ if (!rc)
+ nids_added++;
+ }
+
+ if (nids_added == 0) {
+ CERROR("No new nids were added, nid %s with uuid %s, "
+ "device %s\n", libcfs_nid2str(nid),
+ mrul->target.mti_params,
+ mrul->target.mti_svname);
+ RETURN(-ENXIO);
+ } else {
+ mrul->device_nids_added = 1;
+ }
+
+ return nids_added;
+ }
+
+ if (mrul->device_nids_added && lcfg->lcfg_command == LCFG_SETUP) {
+ /* LCFG_SETUP command found. UUID should be changed */
+ rc = record_setup(env,
+ mrul->temp_llh,
+ /* devname the same */
+ lustre_cfg_string(lcfg, 0),
+ /* s1 is not changed */
+ lustre_cfg_string(lcfg, 1),
+ /* new uuid should be
+ the full nidlist */
+ mrul->target.mti_params,
+ /* s3 is not changed */
+ lustre_cfg_string(lcfg, 3),
+ /* s4 is not changed */
+ lustre_cfg_string(lcfg, 4));
+ return rc ? rc : 1;
+ }
+
+ /* Another commands in target device block */
+ return 0;
+}
+
+/**
+ * Handler that called for every record in llog.
+ * Records are processed in order they placed in llog.
+ *
+ * \param[in] llh log to be processed
+ * \param[in] rec current record
+ * \param[in] data mgs_replace_uuid_lookup structure
+ *
+ * \retval 0 success
+ */
+static int mgs_replace_handler(const struct lu_env *env,
+ struct llog_handle *llh,
+ struct llog_rec_hdr *rec,
+ void *data)
+{
+ struct llog_rec_hdr local_rec = *rec;
+ struct mgs_replace_uuid_lookup *mrul;
+ struct lustre_cfg *lcfg = REC_DATA(rec);
+ int cfg_len = REC_DATA_LEN(rec);
+ int rc;
+ ENTRY;
+
+ mrul = (struct mgs_replace_uuid_lookup *)data;
+
+ if (rec->lrh_type != OBD_CFG_REC) {
+ CERROR("unhandled lrh_type: %#x, cmd %x %s %s\n",
+ rec->lrh_type, lcfg->lcfg_command,
+ lustre_cfg_string(lcfg, 0),
+ lustre_cfg_string(lcfg, 1));
+ RETURN(-EINVAL);
+ }
+
+ rc = lustre_cfg_sanity_check(lcfg, cfg_len);
+ if (rc) {
+ /* Do not copy any invalidated records */
+ GOTO(skip_out, rc = 0);
+ }
+
+ rc = check_markers(lcfg, mrul);
+ if (rc || mrul->skip_it)
+ GOTO(skip_out, rc = 0);
+
+ /* Write to new log all commands outside target device block */
+ if (!mrul->in_target_device)
+ GOTO(copy_out, rc = 0);
+
+ /* Skip all other LCFG_ADD_UUID and LCFG_ADD_CONN records
+ (failover nids) for this target, assuming that if then
+ primary is changing then so is the failover */
+ if (mrul->device_nids_added &&
+ (lcfg->lcfg_command == LCFG_ADD_UUID ||
+ lcfg->lcfg_command == LCFG_ADD_CONN))
+ GOTO(skip_out, rc = 0);
+
+ rc = process_command(env, lcfg, mrul);
+ if (rc < 0)
+ RETURN(rc);
+
+ if (rc)
+ RETURN(0);
+copy_out:
+ /* Record is placed in temporary llog as is */
+ local_rec.lrh_len -= sizeof(*rec) + sizeof(struct llog_rec_tail);
+ rc = llog_write(env, mrul->temp_llh, &local_rec, NULL, 0,
+ (void *)lcfg, -1);
+
+ CDEBUG(D_MGS, "Copied idx=%d, rc=%d, len=%d, cmd %x %s %s\n",
+ rec->lrh_index, rc, rec->lrh_len, lcfg->lcfg_command,
+ lustre_cfg_string(lcfg, 0), lustre_cfg_string(lcfg, 1));
+ RETURN(rc);
+
+skip_out:
+ CDEBUG(D_MGS, "Skipped idx=%d, rc=%d, len=%d, cmd %x %s %s\n",
+ rec->lrh_index, rc, rec->lrh_len, lcfg->lcfg_command,
+ lustre_cfg_string(lcfg, 0), lustre_cfg_string(lcfg, 1));
+ RETURN(rc);
+}
+
+static int mgs_backup_llog(const struct lu_env *env,
+ struct obd_device *mgs,
+ char *fsname, char *backup)
+{
+ struct obd_uuid *uuid;
+ struct llog_handle *orig_llh, *bak_llh;
+ struct llog_ctxt *lctxt;
+ int rc, rc2;
+ ENTRY;
+
+ lctxt = llog_get_context(mgs, LLOG_CONFIG_ORIG_CTXT);
+ if (!lctxt) {
+ CERROR("%s: missing llog context\n", mgs->obd_name);
+ GOTO(out, rc = -EINVAL);
+ }
+
+ /* Make sure there's no old backup log */
+ rc = llog_erase(env, lctxt, NULL, backup);
+ if (rc < 0 && rc != -ENOENT)
+ GOTO(out_put, rc);
+
+ /* open backup log */
+ rc = llog_open_create(env, lctxt, &bak_llh, NULL, backup);
+ if (rc) {
+ CERROR("%s: backup logfile open %s: rc = %d\n",
+ mgs->obd_name, backup, rc);
+ GOTO(out_put, rc);
+ }
+
+ /* set the log header uuid */
+ OBD_ALLOC_PTR(uuid);
+ if (uuid == NULL)
+ GOTO(out_put, rc = -ENOMEM);
+ obd_str2uuid(uuid, backup);
+ rc = llog_init_handle(env, bak_llh, LLOG_F_IS_PLAIN, uuid);
+ OBD_FREE_PTR(uuid);
+ if (rc)
+ GOTO(out_close1, rc);
+
+ /* open original log */
+ rc = llog_open(env, lctxt, &orig_llh, NULL, fsname,
+ LLOG_OPEN_EXISTS);
+ if (rc < 0) {
+ if (rc == -ENOENT)
+ rc = 0;
+ GOTO(out_close1, rc);
+ }
+
+ rc = llog_init_handle(env, orig_llh, LLOG_F_IS_PLAIN, NULL);
+ if (rc)
+ GOTO(out_close2, rc);
+
+ /* Copy remote log */
+ rc = llog_process(env, orig_llh, llog_copy_handler,
+ (void *)bak_llh, NULL);
+
+out_close2:
+ rc2 = llog_close(env, orig_llh);
+ if (!rc)
+ rc = rc2;
+out_close1:
+ rc2 = llog_close(env, bak_llh);
+ if (!rc)
+ rc = rc2;
+out_put:
+ if (lctxt)
+ llog_ctxt_put(lctxt);
+out:
+ if (rc)
+ CERROR("%s: Failed to backup log %s: rc = %d\n",
+ mgs->obd_name, fsname, rc);
+ RETURN(rc);
+}
+
+static int mgs_log_is_empty(const struct lu_env *env, struct mgs_device *mgs,
+ char *name);
+
+static int mgs_replace_nids_log(const struct lu_env *env,
+ struct obd_device *mgs, struct fs_db *fsdb,
+ char *logname, char *devname, char *nids)
+{
+ struct llog_handle *orig_llh, *backup_llh;
+ struct llog_ctxt *ctxt;
+ struct mgs_replace_uuid_lookup *mrul;
+ struct mgs_device *mgs_dev = lu2mgs_dev(mgs->obd_lu_dev);
+ char *backup;
+ int rc, rc2;
+ ENTRY;
+
+ CDEBUG(D_MGS, "Replace nids for %s in %s\n", devname, logname);
+
+ ctxt = llog_get_context(mgs, LLOG_CONFIG_ORIG_CTXT);
+ LASSERT(ctxt != NULL);
+
+ if (mgs_log_is_empty(env, mgs_dev, logname)) {
+ /* Log is empty. Nothing to replace */
+ GOTO(out_put, rc = 0);
+ }
+
+ OBD_ALLOC(backup, strlen(logname) + 5);
+ if (backup == NULL)
+ GOTO(out_put, rc = -ENOMEM);
+
+ sprintf(backup, "%s.bak", logname);
+
+ rc = mgs_backup_llog(env, mgs, logname, backup);
+ if (rc < 0) {
+ CERROR("%s: can't make backup for %s: rc = %d\n",
+ mgs->obd_name, logname, rc);
+ GOTO(out_free,rc);
+ }
+
+ /* Now erase original log file. Connections are not allowed.
+ Backup is already saved */
+ rc = llog_erase(env, ctxt, NULL, logname);
+ if (rc < 0 && rc != -ENOENT)
+ GOTO(out_free, rc);
+
+ /* open local log */
+ rc = llog_open_create(env, ctxt, &orig_llh, NULL, logname);
+ if (rc)
+ GOTO(out_restore, rc);
+
+ rc = llog_init_handle(env, orig_llh, LLOG_F_IS_PLAIN, NULL);
+ if (rc)
+ GOTO(out_closel, rc);
+
+ /* open backup llog */
+ rc = llog_open(env, ctxt, &backup_llh, NULL, backup,
+ LLOG_OPEN_EXISTS);
+ if (rc)
+ GOTO(out_closel, rc);
+
+ rc = llog_init_handle(env, backup_llh, LLOG_F_IS_PLAIN, NULL);
+ if (rc)
+ GOTO(out_close, rc);
+
+ if (llog_get_size(backup_llh) <= 1)
+ GOTO(out_close, rc = 0);
+
+ OBD_ALLOC_PTR(mrul);
+ if (!mrul)
+ GOTO(out_close, rc = -ENOMEM);
+ /* devname is only needed information to replace UUID records */
+ strncpy(mrul->target.mti_svname, devname, MTI_NAME_MAXLEN);
+ /* parse nids later */
+ strncpy(mrul->target.mti_params, nids, MTI_PARAM_MAXLEN);
+ /* Copy records to this temporary llog */
+ mrul->temp_llh = orig_llh;
+
+ rc = llog_process(env, backup_llh, mgs_replace_handler,
+ (void *)mrul, NULL);
+ OBD_FREE_PTR(mrul);
+out_close:
+ rc2 = llog_close(NULL, backup_llh);
+ if (!rc)
+ rc = rc2;
+out_closel:
+ rc2 = llog_close(NULL, orig_llh);
+ if (!rc)
+ rc = rc2;
+
+out_restore:
+ if (rc) {
+ CERROR("%s: llog should be restored: rc = %d\n",
+ mgs->obd_name, rc);
+ rc2 = mgs_backup_llog(env, mgs, backup, logname);
+ if (rc2 < 0)
+ CERROR("%s: can't restore backup %s: rc = %d\n",
+ mgs->obd_name, logname, rc2);
+ }
+
+out_free:
+ OBD_FREE(backup, strlen(backup) + 5);
+
+out_put:
+ llog_ctxt_put(ctxt);
+
+ if (rc)
+ CERROR("%s: failed to replace nids in log %s: rc = %d\n",
+ mgs->obd_name, logname, rc);
+
+ RETURN(rc);
+}
+
+/**
+ * Parse device name and get file system name and/or device index
+ *
+ * \param[in] devname device name (ex. lustre-MDT0000)
+ * \param[out] fsname file system name(optional)
+ * \param[out] index device index(optional)
+ *
+ * \retval 0 success
+ */
+static int mgs_parse_devname(char *devname, char *fsname, __u32 *index)
+{
+ char *ptr;
+ ENTRY;
+
+ /* Extract fsname */
+ ptr = strrchr(devname, '-');
+
+ if (fsname) {
+ if (!ptr) {
+ CDEBUG(D_MGS, "Device name %s without fsname\n",
+ devname);
+ RETURN(-EINVAL);
+ }
+ memset(fsname, 0, MTI_NAME_MAXLEN);
+ strncpy(fsname, devname, ptr - devname);
+ fsname[MTI_NAME_MAXLEN - 1] = 0;
+ }
+
+ if (index) {
+ if (server_name2index(ptr, index, NULL) < 0) {
+ CDEBUG(D_MGS, "Device name with wrong index\n");
+ RETURN(-EINVAL);
+ }
+ }
+
+ RETURN(0);
+}
+
+static int only_mgs_is_running(struct obd_device *mgs_obd)
+{
+ /* TDB: Is global variable with devices count exists? */
+ int num_devices = get_devices_count();
+ /* osd, MGS and MGC + self_export
+ (wc -l /proc/fs/lustre/devices <= 2) && (num_exports <= 2) */
+ return (num_devices <= 3) && (mgs_obd->obd_num_exports <= 2);
+}
+
+static int name_create_mdt(char **logname, char *fsname, int i)
+{
+ char mdt_index[9];
+
+ sprintf(mdt_index, "-MDT%04x", i);
+ return name_create(logname, fsname, mdt_index);
+}
+
+/**
+ * Replace nids for \a device to \a nids values
+ *
+ * \param obd MGS obd device
+ * \param devname nids need to be replaced for this device
+ * (ex. lustre-OST0000)
+ * \param nids nids list (ex. nid1,nid2,nid3)
+ *
+ * \retval 0 success
+ */
+int mgs_replace_nids(const struct lu_env *env,
+ struct mgs_device *mgs,
+ char *devname, char *nids)
+{
+ /* Assume fsname is part of device name */
+ char fsname[MTI_NAME_MAXLEN];
+ int rc;
+ __u32 index;
+ char *logname;
+ struct fs_db *fsdb;
+ unsigned int i;
+ int conn_state;
+ struct obd_device *mgs_obd = mgs->mgs_obd;
+ ENTRY;
+
+ /* We can only change NIDs if no other nodes are connected */
+ spin_lock(&mgs_obd->obd_dev_lock);
+ conn_state = mgs_obd->obd_no_conn;
+ mgs_obd->obd_no_conn = 1;
+ spin_unlock(&mgs_obd->obd_dev_lock);
+
+ /* We can not change nids if not only MGS is started */
+ if (!only_mgs_is_running(mgs_obd)) {
+ CERROR("Only MGS is allowed to be started\n");
+ GOTO(out, rc = -EINPROGRESS);
+ }
+
+ /* Get fsname and index*/
+ rc = mgs_parse_devname(devname, fsname, &index);
+ if (rc)
+ GOTO(out, rc);
+
+ rc = mgs_find_or_make_fsdb(env, mgs, fsname, &fsdb);
+ if (rc) {
+ CERROR("%s: can't find fsdb: rc = %d\n", fsname, rc);
+ GOTO(out, rc);
+ }
+
+ /* Process client llogs */
+ name_create(&logname, fsname, "-client");
+ rc = mgs_replace_nids_log(env, mgs_obd, fsdb, logname, devname, nids);
+ name_destroy(&logname);
+ if (rc) {
+ CERROR("%s: error while replacing NIDs for %s: rc = %d\n",
+ fsname, devname, rc);
+ GOTO(out, rc);
+ }
+
+ /* Process MDT llogs */
+ for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
+ if (!test_bit(i, fsdb->fsdb_mdt_index_map))
+ continue;
+ name_create_mdt(&logname, fsname, i);
+ rc = mgs_replace_nids_log(env, mgs_obd, fsdb, logname, devname, nids);
+ name_destroy(&logname);
+ if (rc)
+ GOTO(out, rc);
+ }
+
+out:
+ spin_lock(&mgs_obd->obd_dev_lock);
+ mgs_obd->obd_no_conn = conn_state;
+ spin_unlock(&mgs_obd->obd_dev_lock);
+
+ RETURN(rc);
+}
+
static int record_lov_setup(const struct lu_env *env, struct llog_handle *llh,
char *devname, struct lov_desc *desc)
{
char *index, char *gen)
{
return record_base(env,llh,lov_name,0,LCFG_LOV_ADD_OBD,
- ost_uuid,index,gen,0);
+ ost_uuid, index, gen, 0);
}
static inline int record_mount_opt(const struct lu_env *env,
return rc;
}
-static int record_start_log(const struct lu_env *env,
- struct mgs_device *mgs,
- struct llog_handle **llh, char *name)
+static int record_start_log(const struct lu_env *env, struct mgs_device *mgs,
+ struct llog_handle **llh, char *name)
{
- static struct obd_uuid cfg_uuid = { .uuid = "config_uuid" };
- struct lvfs_run_ctxt saved;
- struct llog_ctxt *ctxt;
- int rc = 0;
+ static struct obd_uuid cfg_uuid = { .uuid = "config_uuid" };
+ struct llog_ctxt *ctxt;
+ int rc = 0;
- if (*llh)
- GOTO(out, rc = -EBUSY);
+ if (*llh)
+ GOTO(out, rc = -EBUSY);
ctxt = llog_get_context(mgs->mgs_obd, LLOG_CONFIG_ORIG_CTXT);
if (!ctxt)
GOTO(out, rc = -ENODEV);
LASSERT(ctxt->loc_obd == mgs->mgs_obd);
- push_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
- rc = llog_open_create(NULL, ctxt, llh, NULL, name);
+ rc = llog_open_create(env, ctxt, llh, NULL, name);
if (rc)
GOTO(out_ctxt, rc);
- rc = llog_init_handle(NULL, *llh, LLOG_F_IS_PLAIN, &cfg_uuid);
- if (rc) {
- llog_close(NULL, *llh);
- *llh = NULL;
- }
+ rc = llog_init_handle(env, *llh, LLOG_F_IS_PLAIN, &cfg_uuid);
+ if (rc)
+ llog_close(env, *llh);
out_ctxt:
- pop_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
out:
- if (rc)
- CERROR("Can't start log %s: %d\n", name, rc);
+ if (rc) {
+ CERROR("%s: can't start log %s: rc = %d\n",
+ mgs->mgs_obd->obd_name, name, rc);
+ *llh = NULL;
+ }
RETURN(rc);
}
static int record_end_log(const struct lu_env *env, struct llog_handle **llh)
{
- struct lvfs_run_ctxt saved;
- struct obd_device *obd = (*llh)->lgh_ctxt->loc_obd;
- int rc = 0;
-
- push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
+ int rc;
- rc = llog_close(NULL, *llh);
- *llh = NULL;
+ rc = llog_close(env, *llh);
+ *llh = NULL;
- pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
- RETURN(rc);
+ return rc;
}
static int mgs_log_is_empty(const struct lu_env *env,
struct mgs_device *mgs, char *name)
{
- struct lvfs_run_ctxt saved;
struct llog_handle *llh;
struct llog_ctxt *ctxt;
int rc = 0;
ctxt = llog_get_context(mgs->mgs_obd, LLOG_CONFIG_ORIG_CTXT);
LASSERT(ctxt != NULL);
- push_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
- rc = llog_open(NULL, ctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
+ rc = llog_open(env, ctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
if (rc < 0) {
if (rc == -ENOENT)
rc = 0;
GOTO(out_ctxt, rc);
}
- llog_init_handle(NULL, llh, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
rc = llog_get_size(llh);
out_close:
- llog_close(NULL, llh);
+ llog_close(env, llh);
out_ctxt:
- pop_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
/* header is record 1 */
return (rc <= 1);
RETURN(rc);
}
-static int mgs_write_log_mdc_to_mdt(const struct lu_env *env,
+static int mgs_write_log_osp_to_mdt(const struct lu_env *env,
struct mgs_device *mgs,
struct fs_db *fsdb,
struct mgs_target_info *mti,
- char *logname);
+ int index, char *logname);
static int mgs_write_log_osc_to_lov(const struct lu_env *env,
struct mgs_device *mgs,
struct fs_db *fsdb,
struct mgs_target_info *mti,
- char *logname, char *suffix, char *lovname,
+ char *logname, char *suffix, char *lovname,
enum lustre_sec_part sec_part, int flags);
static int name_create_mdt_and_lov(char **logname, char **lovname,
struct fs_db *fsdb, int i);
+static int add_param(char *params, char *key, char *val)
+{
+ char *start = params + strlen(params);
+ char *end = params + sizeof(((struct mgs_target_info *)0)->mti_params);
+ int keylen = 0;
+
+ if (key != NULL)
+ keylen = strlen(key);
+ if (start + 1 + keylen + strlen(val) >= end) {
+ CERROR("params are too long: %s %s%s\n",
+ params, key != NULL ? key : "", val);
+ return -EINVAL;
+ }
+
+ sprintf(start, " %s%s", key != NULL ? key : "", val);
+ return 0;
+}
+
static int mgs_steal_llog_handler(const struct lu_env *env,
struct llog_handle *llh,
struct llog_rec_hdr *rec, void *data)
{
struct mgs_device *mgs;
+ struct obd_device *obd;
struct mgs_target_info *mti, *tmti;
struct fs_db *fsdb;
int cfg_len = rec->lrh_len;
mti = ((struct temp_comp*)data)->comp_mti;
tmti = ((struct temp_comp*)data)->comp_tmti;
fsdb = ((struct temp_comp*)data)->comp_fsdb;
- mgs = ((struct temp_comp*)data)->comp_mgs;
+ obd = ((struct temp_comp *)data)->comp_obd;
+ mgs = lu2mgs_dev(obd->obd_lu_dev);
+ LASSERT(mgs);
if (rec->lrh_type != OBD_CFG_REC) {
CERROR("unhandled lrh_type: %#x\n", rec->lrh_type);
struct cfg_marker *marker;
marker = lustre_cfg_buf(lcfg, 1);
if (!strncmp(marker->cm_comment,"add osc",7) &&
- (marker->cm_flags & CM_START)){
+ (marker->cm_flags & CM_START) &&
+ !(marker->cm_flags & CM_SKIP)) {
got_an_osc_or_mdc = 1;
strncpy(tmti->mti_svname, marker->cm_tgtname,
sizeof(tmti->mti_svname));
RETURN(rc);
}
if (!strncmp(marker->cm_comment,"add osc",7) &&
- (marker->cm_flags & CM_END)){
+ (marker->cm_flags & CM_END) &&
+ !(marker->cm_flags & CM_SKIP)) {
LASSERT(last_step == marker->cm_step);
last_step = -1;
got_an_osc_or_mdc = 0;
RETURN(rc);
}
if (!strncmp(marker->cm_comment,"add mdc",7) &&
- (marker->cm_flags & CM_START)){
+ (marker->cm_flags & CM_START) &&
+ !(marker->cm_flags & CM_SKIP)) {
got_an_osc_or_mdc = 2;
last_step = marker->cm_step;
memcpy(tmti->mti_svname, marker->cm_tgtname,
RETURN(rc);
}
if (!strncmp(marker->cm_comment,"add mdc",7) &&
- (marker->cm_flags & CM_END)){
+ (marker->cm_flags & CM_END) &&
+ !(marker->cm_flags & CM_SKIP)) {
LASSERT(last_step == marker->cm_step);
last_step = -1;
got_an_osc_or_mdc = 0;
if (got_an_osc_or_mdc == 0 || last_step < 0)
RETURN(rc);
- if (lcfg->lcfg_command == LCFG_ADD_UUID) {
- uint64_t nodenid;
- nodenid = lcfg->lcfg_nid;
+ if (lcfg->lcfg_command == LCFG_ADD_UUID) {
+ uint64_t nodenid = lcfg->lcfg_nid;
- tmti->mti_nids[tmti->mti_nid_count] = nodenid;
- tmti->mti_nid_count++;
+ if (strlen(tmti->mti_uuid) == 0) {
+ /* target uuid not set, this config record is before
+ * LCFG_SETUP, this nid is one of target node nid.
+ */
+ tmti->mti_nids[tmti->mti_nid_count] = nodenid;
+ tmti->mti_nid_count++;
+ } else {
+ /* failover node nid */
+ rc = add_param(tmti->mti_params, PARAM_FAILNODE,
+ libcfs_nid2str(nodenid));
+ }
- RETURN(rc);
- }
+ RETURN(rc);
+ }
if (lcfg->lcfg_command == LCFG_SETUP) {
char *target;
strlen(mti->mti_fsname));
tmti->mti_stripe_index = index;
- rc = mgs_write_log_mdc_to_mdt(env, mgs, fsdb, tmti,
+ rc = mgs_write_log_osp_to_mdt(env, mgs, fsdb, tmti,
+ mti->mti_stripe_index,
mti->mti_svname);
memset(tmti, 0, sizeof(*tmti));
RETURN(rc);
struct temp_comp* comp)
{
struct llog_handle *loghandle;
- struct lvfs_run_ctxt saved;
struct mgs_target_info *tmti;
struct llog_ctxt *ctxt;
int rc;
GOTO(out_ctxt, rc = -ENOMEM);
comp->comp_tmti = tmti;
- comp->comp_mgs = mgs;
-
- push_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
+ comp->comp_obd = mgs->mgs_obd;
- rc = llog_open(NULL, ctxt, &loghandle, NULL, client_name,
+ rc = llog_open(env, ctxt, &loghandle, NULL, client_name,
LLOG_OPEN_EXISTS);
if (rc < 0) {
if (rc == -ENOENT)
GOTO(out_pop, rc);
}
- rc = llog_init_handle(NULL, loghandle, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(env, loghandle, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
(void *)comp, NULL, false);
CDEBUG(D_MGS, "steal llog re = %d\n", rc);
out_close:
- llog_close(NULL, loghandle);
+ llog_close(env, loghandle);
out_pop:
- pop_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
OBD_FREE_PTR(tmti);
out_ctxt:
llog_ctxt_put(ctxt);
RETURN(rc);
}
+static inline int name_create_lov(char **lovname, char *mdtname,
+ struct fs_db *fsdb, int index)
+{
+ /* COMPAT_180 */
+ if (index == 0 && test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
+ return name_create(lovname, fsdb->fsdb_name, "-mdtlov");
+ else
+ return name_create(lovname, mdtname, "-mdtlov");
+}
+
+static int name_create_mdt_and_lov(char **logname, char **lovname,
+ struct fs_db *fsdb, int i)
+{
+ int rc;
+
+ rc = name_create_mdt(logname, fsdb->fsdb_name, i);
+ if (rc)
+ return rc;
+ /* COMPAT_180 */
+ if (i == 0 && test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
+ rc = name_create(lovname, fsdb->fsdb_name, "-mdtlov");
+ else
+ rc = name_create(lovname, *logname, "-mdtlov");
+ if (rc) {
+ name_destroy(logname);
+ *logname = NULL;
+ }
+ return rc;
+}
+
+static inline int name_create_mdt_osc(char **oscname, char *ostname,
+ struct fs_db *fsdb, int i)
+{
+ char suffix[16];
+
+ if (i == 0 && test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
+ sprintf(suffix, "-osc");
+ else
+ sprintf(suffix, "-osc-MDT%04x", i);
+ return name_create(oscname, ostname, suffix);
+}
+
/* add new mdc to already existent MDS */
-static int mgs_write_log_mdc_to_mdt(const struct lu_env *env,
+static int mgs_write_log_osp_to_mdt(const struct lu_env *env,
struct mgs_device *mgs,
struct fs_db *fsdb,
struct mgs_target_info *mti,
- char *logname)
-{
- struct llog_handle *llh = NULL;
- char *nodeuuid = NULL;
- char *mdcname = NULL;
- char *mdcuuid = NULL;
- char *mdtuuid = NULL;
- int idx = mti->mti_stripe_index;
- char index[9];
- int i, rc;
+ int mdt_index, char *logname)
+{
+ struct llog_handle *llh = NULL;
+ char *nodeuuid = NULL;
+ char *ospname = NULL;
+ char *lovuuid = NULL;
+ char *mdtuuid = NULL;
+ char *svname = NULL;
+ char *mdtname = NULL;
+ char *lovname = NULL;
+ char index_str[16];
+ int i, rc;
- ENTRY;
- if (mgs_log_is_empty(env, mgs, logname)) {
+ ENTRY;
+ if (mgs_log_is_empty(env, mgs, mti->mti_svname)) {
CERROR("log is empty! Logical error\n");
RETURN (-EINVAL);
}
- CDEBUG(D_MGS, "adding mdc index %d to %s\n", idx, logname);
+ CDEBUG(D_MGS, "adding osp index %d to %s\n", mti->mti_stripe_index,
+ logname);
- rc = name_create(&nodeuuid, libcfs_nid2str(mti->mti_nids[0]), "");
+ rc = name_create_mdt(&mdtname, fsdb->fsdb_name, mti->mti_stripe_index);
if (rc)
RETURN(rc);
- snprintf(index, sizeof(index), "-mdc%04x", idx);
- rc = name_create(&mdcname, logname, index);
+
+ rc = name_create(&nodeuuid, libcfs_nid2str(mti->mti_nids[0]), "");
if (rc)
- GOTO(out_free, rc);
- rc = name_create(&mdcuuid, mdcname, "_UUID");
+ GOTO(out_destory, rc);
+
+ rc = name_create(&svname, mdtname, "-osp");
if (rc)
- GOTO(out_free, rc);
- rc = name_create(&mdtuuid, logname, "_UUID");
+ GOTO(out_destory, rc);
+
+ sprintf(index_str, "-MDT%04x", mdt_index);
+ rc = name_create(&ospname, svname, index_str);
if (rc)
- GOTO(out_free, rc);
+ GOTO(out_destory, rc);
+
+ rc = name_create_lov(&lovname, logname, fsdb, mdt_index);
+ if (rc)
+ GOTO(out_destory, rc);
+
+ rc = name_create(&lovuuid, lovname, "_UUID");
+ if (rc)
+ GOTO(out_destory, rc);
+
+ rc = name_create(&mdtuuid, mdtname, "_UUID");
+ if (rc)
+ GOTO(out_destory, rc);
rc = record_start_log(env, mgs, &llh, logname);
if (rc)
- GOTO(out_free, rc);
- rc = record_marker(env, llh, fsdb, CM_START, mti->mti_svname, "add mdc");
+ GOTO(out_destory, rc);
+
+ rc = record_marker(env, llh, fsdb, CM_START, mti->mti_svname,
+ "add osp");
if (rc)
- GOTO(out_end, rc);
- for (i = 0; i < mti->mti_nid_count; i++) {
- CDEBUG(D_MGS, "add nid %s for mdt\n",
- libcfs_nid2str(mti->mti_nids[i]));
+ GOTO(out_destory, rc);
+
+ for (i = 0; i < mti->mti_nid_count; i++) {
+ CDEBUG(D_MGS, "add nid %s for mdt\n",
+ libcfs_nid2str(mti->mti_nids[i]));
rc = record_add_uuid(env, llh, mti->mti_nids[i], nodeuuid);
if (rc)
GOTO(out_end, rc);
}
- rc = record_attach(env, llh, mdcname, LUSTRE_MDC_NAME, mdcuuid);
+
+ rc = record_attach(env, llh, ospname, LUSTRE_OSP_NAME, lovuuid);
if (rc)
GOTO(out_end, rc);
- rc = record_setup(env, llh, mdcname, mti->mti_uuid, nodeuuid, 0, 0);
+
+ rc = record_setup(env, llh, ospname, mti->mti_uuid, nodeuuid,
+ NULL, NULL);
if (rc)
GOTO(out_end, rc);
- rc = mgs_write_log_failnids(env, mti, llh, mdcname);
+
+ rc = mgs_write_log_failnids(env, mti, llh, ospname);
if (rc)
GOTO(out_end, rc);
- snprintf(index, sizeof(index), "%d", idx);
- rc = record_mdc_add(env, llh, logname, mdcuuid, mti->mti_uuid,
- index, "1");
+ /* Add mdc(osp) to lod */
+ snprintf(index_str, sizeof(mti->mti_stripe_index), "%d",
+ mti->mti_stripe_index);
+ rc = record_base(env, llh, lovname, 0, LCFG_ADD_MDC, mti->mti_uuid,
+ index_str, "1", NULL);
if (rc)
GOTO(out_end, rc);
- rc = record_marker(env, llh, fsdb, CM_END, mti->mti_svname, "add mdc");
+
+ rc = record_marker(env, llh, fsdb, CM_END, mti->mti_svname, "add osp");
if (rc)
GOTO(out_end, rc);
+
out_end:
record_end_log(env, &llh);
-out_free:
+
+out_destory:
name_destroy(&mdtuuid);
- name_destroy(&mdcuuid);
- name_destroy(&mdcname);
+ name_destroy(&lovuuid);
+ name_destroy(&lovname);
+ name_destroy(&ospname);
+ name_destroy(&svname);
name_destroy(&nodeuuid);
- RETURN(rc);
+ name_destroy(&mdtname);
+ RETURN(rc);
}
static int mgs_write_log_mdt0(const struct lu_env *env,
RETURN(rc);
}
-static inline int name_create_mdt(char **logname, char *fsname, int i)
-{
- char mdt_index[9];
-
- sprintf(mdt_index, "-MDT%04x", i);
- return name_create(logname, fsname, mdt_index);
-}
-
-static int name_create_mdt_and_lov(char **logname, char **lovname,
- struct fs_db *fsdb, int i)
-{
- int rc;
-
- rc = name_create_mdt(logname, fsdb->fsdb_name, i);
- if (rc)
- return rc;
- /* COMPAT_180 */
- if (i == 0 && cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
- rc = name_create(lovname, fsdb->fsdb_name, "-mdtlov");
- else
- rc = name_create(lovname, *logname, "-mdtlov");
- if (rc) {
- name_destroy(logname);
- *logname = NULL;
- }
- return rc;
-}
-
-static inline int name_create_mdt_osc(char **oscname, char *ostname,
- struct fs_db *fsdb, int i)
-{
- char suffix[16];
-
- if (i == 0 && cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
- sprintf(suffix, "-osc");
- else
- sprintf(suffix, "-osc-MDT%04x", i);
- return name_create(oscname, ostname, suffix);
-}
-
/* envelope method for all layers log */
static int mgs_write_log_mdt(const struct lu_env *env,
struct mgs_device *mgs,
if (rc)
GOTO(out_end, rc);
+
/* for_all_existing_mdt except current one */
- for (i = 0; i < INDEX_MAP_SIZE * 8; i++){
- char *mdtname;
- if (i != mti->mti_stripe_index &&
- cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
- rc = name_create_mdt(&mdtname, mti->mti_fsname, i);
+ for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
+ if (i != mti->mti_stripe_index &&
+ test_bit(i, fsdb->fsdb_mdt_index_map)) {
+ char *logname;
+
+ rc = name_create_mdt(&logname, fsdb->fsdb_name, i);
if (rc)
GOTO(out_end, rc);
- rc = mgs_write_log_mdc_to_mdt(env, mgs, fsdb, mti, mdtname);
- name_destroy(&mdtname);
+
+ rc = mgs_write_log_osp_to_mdt(env, mgs, fsdb, mti,
+ i, logname);
+ name_destroy(&logname);
if (rc)
GOTO(out_end, rc);
- }
- }
+ }
+ }
out_end:
record_end_log(env, &llh);
out_free:
rc = name_create(&svname, mti->mti_svname, "-osc");
if (rc)
GOTO(out_free, rc);
- rc = name_create(&oscname, svname, suffix);
+
+ /* for the system upgraded from old 1.8, keep using the old osc naming
+ * style for mdt, see name_create_mdt_osc(). LU-1257 */
+ if (test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
+ rc = name_create(&oscname, svname, "");
+ else
+ rc = name_create(&oscname, svname, suffix);
if (rc)
GOTO(out_free, rc);
+
rc = name_create(&oscuuid, oscname, "_UUID");
if (rc)
GOTO(out_free, rc);
if (rc)
GOTO(out_free, rc);
+
/*
#03 L add_uuid nid=uml1@tcp(0x20000c0a80201) 0: 1:uml1_UUID
multihomed (#4)
rc = record_start_log(env, mgs, &llh, logname);
if (rc)
GOTO(out_free, rc);
+
/* FIXME these should be a single journal transaction */
rc = record_marker(env, llh, fsdb, CM_START | flags, mti->mti_svname,
"add osc");
if (rc)
GOTO(out_end, rc);
+
+ /* NB: don't change record order, because upon MDT steal OSC config
+ * from client, it treats all nids before LCFG_SETUP as target nids
+ * (multiple interfaces), while nids after as failover node nids.
+ * See mgs_steal_llog_handler() LCFG_ADD_UUID.
+ */
for (i = 0; i < mti->mti_nid_count; i++) {
CDEBUG(D_MGS, "add nid %s\n", libcfs_nid2str(mti->mti_nids[i]));
rc = record_add_uuid(env, llh, mti->mti_nids[i], nodeuuid);
rc = mgs_write_log_failnids(env, mti, llh, oscname);
if (rc)
GOTO(out_end, rc);
- snprintf(index, sizeof(index), "%d", mti->mti_stripe_index);
+
+ snprintf(index, sizeof(index), "%d", mti->mti_stripe_index);
+
rc = record_lov_add(env, llh, lovname, mti->mti_uuid, index, "1");
if (rc)
GOTO(out_end, rc);
/* We also have to update the other logs where this osc is part of
the lov */
- if (cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags)) {
+ if (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 (cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
+ if (test_bit(i, fsdb->fsdb_mdt_index_map)) {
char mdt_index[9];
rc = name_create_mdt_and_lov(&logname, &lovname, fsdb,
int i;
for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
- if (!cfs_test_bit(i, fsdb->fsdb_mdt_index_map))
+ if (!test_bit(i, fsdb->fsdb_mdt_index_map))
continue;
rc = name_create_mdt(&logname, mti->mti_fsname, i);
if (rc)
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;
+ struct mgs_thread_info *mgi = mgs_env_info(env);
+ struct lustre_cfg *lcfg;
+ char *tmp;
+ char sep;
+ int rc, cmd = LCFG_PARAM;
/* support only 'meta' and 'data' pools so far */
if (class_match_param(ptr, QUOTA_METAPOOL_NAME, &tmp) != 0 &&
}
}
- lustre_cfg_bufs_reset(&bufs, NULL);
- lustre_cfg_bufs_set_string(&bufs, 1, quota);
- lcfg = lustre_cfg_new(cmd, &bufs);
+ lustre_cfg_bufs_reset(&mgi->mgi_bufs, mti->mti_fsname);
+ lustre_cfg_bufs_set_string(&mgi->mgi_bufs, 1, quota);
+ lcfg = lustre_cfg_new(cmd, &mgi->mgi_bufs);
/* truncate the comment to the parameter name */
ptr = tmp - 1;
sep = *ptr;
mti->mti_fsname, quota, 1);
*ptr = sep;
lustre_cfg_free(lcfg);
- return rc;
+ return rc < 0 ? rc : 0;
}
static int mgs_srpc_set_param_disk(const struct lu_env *env,
goto error_out;
if (strcmp(ptr, "yes") == 0) {
- cfs_set_bit(FSDB_UDESC, &fsdb->fsdb_flags);
+ set_bit(FSDB_UDESC, &fsdb->fsdb_flags);
CWARN("Enable user descriptor shipping from client to MDT\n");
} else if (strcmp(ptr, "no") == 0) {
- cfs_clear_bit(FSDB_UDESC, &fsdb->fsdb_flags);
+ 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 (cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
+ if (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 (cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
+ if (test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
/*
* for mgs rules, make them effective immediately.
*/
{
struct mgs_srpc_read_data *msrd = data;
struct cfg_marker *marker;
- struct lustre_cfg *lcfg = (struct lustre_cfg *)(rec + 1);
+ struct lustre_cfg *lcfg = REC_DATA(rec);
char *svname, *param;
int cfg_len, rc;
ENTRY;
struct fs_db *fsdb)
{
struct llog_handle *llh = NULL;
- struct lvfs_run_ctxt saved;
struct llog_ctxt *ctxt;
char *logname;
struct mgs_srpc_read_data msrd;
if (mgs_log_is_empty(env, mgs, logname))
GOTO(out, rc = 0);
- push_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
-
- rc = llog_open(NULL, ctxt, &llh, NULL, logname,
+ rc = llog_open(env, ctxt, &llh, NULL, logname,
LLOG_OPEN_EXISTS);
if (rc < 0) {
if (rc == -ENOENT)
rc = 0;
- GOTO(out_pop, rc);
+ GOTO(out, rc);
}
- rc = llog_init_handle(NULL, llh, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(out_close, rc);
msrd.msrd_fsdb = fsdb;
msrd.msrd_skip = 0;
- rc = llog_process_or_fork(env, llh, mgs_srpc_read_handler,
- (void *)&msrd, NULL, false);
+ rc = llog_process(env, llh, mgs_srpc_read_handler, (void *)&msrd,
+ NULL);
out_close:
- llog_close(NULL, llh);
-out_pop:
- pop_ctxt(&saved, &mgs->mgs_obd->obd_lvfs_ctxt, NULL);
+ llog_close(env, llh);
out:
llog_ctxt_put(ctxt);
name_destroy(&logname);
/* Modify mdtlov */
/* Add to all MDT logs for CMD */
for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
- if (!cfs_test_bit(i, fsdb->fsdb_mdt_index_map))
+ if (!test_bit(i, fsdb->fsdb_mdt_index_map))
continue;
rc = name_create_mdt(&logname, mti->mti_fsname, i);
if (rc)
"changes were made to the "
"config log.\n",
mti->mti_svname, rc);
- if (cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags))
+ if (test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags))
LCONSOLE_ERROR_MSG(0x146, "This may be"
" because the log"
"is in the old 1.4"
(class_match_param(ptr, PARAM_LLITE, NULL) == 0)) {
char *cname;
- if (cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags)) {
+ if (test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags)) {
LCONSOLE_ERROR_MSG(0x148, "Upgraded client logs for %s"
" cannot be modified. Consider"
" updating the configuration with"
int i;
for (i = 0; i < INDEX_MAP_SIZE * 8; i++){
- if (!cfs_test_bit(i, fsdb->fsdb_mdt_index_map))
+ if (!test_bit(i, fsdb->fsdb_mdt_index_map))
continue;
name_destroy(&cname);
rc = 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 (!cfs_test_bit(i,
+ if (!test_bit(i,
fsdb->fsdb_mdt_index_map))
continue;
rc = name_create_mdt(&logname,
the failover list. Modify mti->params for rewriting back at
server_register_target(). */
- cfs_mutex_lock(&fsdb->fsdb_mutex);
+ mutex_lock(&fsdb->fsdb_mutex);
rc = mgs_write_log_add_failnid(obd, fsdb, mti);
- cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ mutex_unlock(&fsdb->fsdb_mutex);
RETURN(rc);
#endif
mti->mti_flags &= ~LDD_F_UPDATE;
}
- cfs_mutex_lock(&fsdb->fsdb_mutex);
+ 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:
- cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ mutex_unlock(&fsdb->fsdb_mutex);
RETURN(rc);
}
int mgs_erase_log(const struct lu_env *env, struct mgs_device *mgs, char *name)
{
- struct lvfs_run_ctxt saved;
struct llog_ctxt *ctxt;
int rc = 0;
- struct obd_device *obd = mgs->mgs_obd;
- ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
+ ctxt = llog_get_context(mgs->mgs_obd, LLOG_CONFIG_ORIG_CTXT);
if (ctxt == NULL) {
CERROR("%s: MGS config context doesn't exist\n",
- obd->obd_name);
+ mgs->mgs_obd->obd_name);
rc = -ENODEV;
} else {
- push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
- rc = llog_erase(NULL, ctxt, NULL, name);
+ rc = llog_erase(env, ctxt, NULL, name);
/* llog may not exist */
if (rc == -ENOENT)
rc = 0;
- pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
llog_ctxt_put(ctxt);
}
if (rc)
- CERROR("%s: failed to clear log %s: %d\n", obd->obd_name,
- name, rc);
+ CERROR("%s: failed to clear log %s: %d\n",
+ mgs->mgs_obd->obd_name, name, rc);
return rc;
}
if (rc)
RETURN(rc);
- cfs_mutex_lock(&mgs->mgs_mutex);
+ mutex_lock(&mgs->mgs_mutex);
/* Delete the fs db */
fsdb = mgs_find_fsdb(mgs, fsname);
if (fsdb)
mgs_free_fsdb(mgs, fsdb);
- cfs_mutex_unlock(&mgs->mgs_mutex);
+ mutex_unlock(&mgs->mgs_mutex);
cfs_list_for_each_entry_safe(dirent, n, &list, list) {
cfs_list_del(&dirent->list);
RETURN(-ENOSYS);
}
- /* Extract fsname */
- ptr = strrchr(devname, '-');
- memset(fsname, 0, MTI_NAME_MAXLEN);
- if (ptr && (server_name2index(ptr, &index, NULL) >= 0)) {
+ rc = mgs_parse_devname(devname, fsname, NULL);
+ if (rc == 0 && !mgs_parse_devname(devname, NULL, &index)) {
/* param related to llite isn't allowed to set by OST or MDT */
- if (strncmp(param, PARAM_LLITE, sizeof(PARAM_LLITE)) == 0)
+ if (rc == 0 && strncmp(param, PARAM_LLITE,
+ sizeof(PARAM_LLITE)) == 0)
RETURN(-EINVAL);
-
- strncpy(fsname, devname, ptr - devname);
} else {
/* assume devname is the fsname */
+ memset(fsname, 0, MTI_NAME_MAXLEN);
strncpy(fsname, devname, MTI_NAME_MAXLEN);
+ fsname[MTI_NAME_MAXLEN - 1] = 0;
}
- fsname[MTI_NAME_MAXLEN - 1] = 0;
CDEBUG(D_MGS, "setparam fs='%s' device='%s'\n", fsname, devname);
rc = mgs_find_or_make_fsdb(env, mgs, fsname, &fsdb);
if (rc)
RETURN(rc);
- if (!cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags) &&
- cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags)) {
+ if (!test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags) &&
+ 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(mgs, fsdb);
mti->mti_flags = rc | LDD_F_PARAM;
- cfs_mutex_lock(&fsdb->fsdb_mutex);
+ mutex_lock(&fsdb->fsdb_mutex);
rc = mgs_write_log_param(env, mgs, fsdb, mti, mti->mti_params);
- cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ mutex_unlock(&fsdb->fsdb_mutex);
/*
* Revoke lock so everyone updates. Should be alright if
CERROR("Can't get db for %s\n", fsname);
RETURN(rc);
}
- if (cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags)) {
+ if (test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags)) {
CERROR("%s is not defined\n", fsname);
mgs_free_fsdb(mgs, fsdb);
RETURN(-EINVAL);
break;
}
- cfs_mutex_lock(&fsdb->fsdb_mutex);
+ 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 (cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
+ if (test_bit(i, fsdb->fsdb_mdt_index_map)) {
rc = name_create_mdt_and_lov(&logname, &lovname,
fsdb, i);
if (rc) {
- cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ mutex_unlock(&fsdb->fsdb_mutex);
GOTO(out_mti, rc);
}
if (canceled_label != NULL) {
name_destroy(&logname);
name_destroy(&lovname);
if (rc) {
- cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ mutex_unlock(&fsdb->fsdb_mutex);
GOTO(out_mti, rc);
}
}
rc = name_create(&logname, fsname, "-client");
if (rc) {
- cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ mutex_unlock(&fsdb->fsdb_mutex);
GOTO(out_mti, rc);
}
if (canceled_label != NULL) {
rc = mgs_modify(env, mgs, fsdb, mti, logname,
fsdb->fsdb_clilov, canceled_label, CM_SKIP);
if (rc < 0) {
- cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ mutex_unlock(&fsdb->fsdb_mutex);
name_destroy(&logname);
GOTO(out_mti, rc);
}
rc = mgs_write_log_pool(env, mgs, logname, fsdb, fsdb->fsdb_clilov,
cmd, fsname, poolname, ostname, label);
- cfs_mutex_unlock(&fsdb->fsdb_mutex);
+ mutex_unlock(&fsdb->fsdb_mutex);
name_destroy(&logname);
/* request for update */
mgs_revoke_lock(mgs, fsdb, CONFIG_T_CONFIG);
return rc;
}
-#if 0
-/******************** unused *********************/
-static int mgs_backup_llog(struct obd_device *obd, char* fsname)
-{
- struct file *filp, *bak_filp;
- struct lvfs_run_ctxt saved;
- char *logname, *buf;
- loff_t soff = 0 , doff = 0;
- int count = 4096, len;
- int rc = 0;
-
- OBD_ALLOC(logname, PATH_MAX);
- if (logname == NULL)
- return -ENOMEM;
-
- OBD_ALLOC(buf, count);
- if (!buf)
- GOTO(out , rc = -ENOMEM);
-
- len = snprintf(logname, PATH_MAX, "%s/%s.bak",
- MOUNT_CONFIGS_DIR, fsname);
-
- if (len >= PATH_MAX - 1) {
- GOTO(out, -ENAMETOOLONG);
- }
- push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
-
- bak_filp = l_filp_open(logname, O_RDWR|O_CREAT|O_TRUNC, 0660);
- if (IS_ERR(bak_filp)) {
- rc = PTR_ERR(bak_filp);
- CERROR("backup logfile open %s: %d\n", logname, rc);
- GOTO(pop, rc);
- }
- sprintf(logname, "%s/%s", MOUNT_CONFIGS_DIR, fsname);
- filp = l_filp_open(logname, O_RDONLY, 0);
- if (IS_ERR(filp)) {
- rc = PTR_ERR(filp);
- CERROR("logfile open %s: %d\n", logname, rc);
- GOTO(close1f, rc);
- }
-
- while ((rc = lustre_fread(filp, buf, count, &soff)) > 0) {
- rc = lustre_fwrite(bak_filp, buf, count, &doff);
- break;
- }
-
- filp_close(filp, 0);
-close1f:
- filp_close(bak_filp, 0);
-pop:
- pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
-out:
- if (buf)
- OBD_FREE(buf, count);
- OBD_FREE(logname, PATH_MAX);
- return rc;
-}
-
-#endif
git://git.whamcloud.com / fs / lustre-release.git / blobdiff