*
* You should have received a copy of the GNU General Public License
* version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
*
* GPL HEADER END
*/
* Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2015, Intel Corporation.
+ * Copyright (c) 2011, 2017, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
*/
#define DEBUG_SUBSYSTEM S_LMV
-#include <linux/slab.h>
+
+#include <linux/file.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/user_namespace.h>
#include <linux/seq_file.h>
#include <linux/namei.h>
-#include <lustre/lustre_idl.h>
#include <obd_support.h>
#include <lustre_lib.h>
#include <lustre_net.h>
#include <lprocfs_status.h>
#include <cl_object.h>
#include <lustre_fid.h>
-#include <lustre_ioctl.h>
+#include <uapi/linux/lustre/lustre_ioctl.h>
#include <lustre_kernelcomm.h>
#include "lmv_internal.h"
-static void lmv_activate_target(struct lmv_obd *lmv,
- struct lmv_tgt_desc *tgt,
- int activate)
+static int lmv_check_connect(struct obd_device *obd);
+
+void lmv_activate_target(struct lmv_obd *lmv, struct lmv_tgt_desc *tgt,
+ int activate)
{
- if (tgt->ltd_active == activate)
- return;
+ if (tgt->ltd_active == activate)
+ return;
- tgt->ltd_active = activate;
- lmv->desc.ld_active_tgt_count += (activate ? 1 : -1);
+ tgt->ltd_active = activate;
+ lmv->lmv_mdt_descs.ltd_lmv_desc.ld_active_tgt_count +=
+ (activate ? 1 : -1);
tgt->ltd_exp->exp_obd->obd_inactive = !activate;
}
const struct obd_uuid *uuid,
int activate)
{
- struct lmv_tgt_desc *tgt = NULL;
- struct obd_device *obd;
- __u32 i;
- int rc = 0;
+ struct lu_tgt_desc *tgt = NULL;
+ struct obd_device *obd;
+ int rc = 0;
+
ENTRY;
CDEBUG(D_INFO, "Searching in lmv %p for uuid %s (activate=%d)\n",
lmv, uuid->uuid, activate);
spin_lock(&lmv->lmv_lock);
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- tgt = lmv->tgts[i];
- if (tgt == NULL || tgt->ltd_exp == NULL)
- continue;
-
- CDEBUG(D_INFO, "Target idx %d is %s conn "LPX64"\n", i,
- tgt->ltd_uuid.uuid, tgt->ltd_exp->exp_handle.h_cookie);
+ lmv_foreach_connected_tgt(lmv, tgt) {
+ CDEBUG(D_INFO, "Target idx %d is %s conn %#llx\n",
+ tgt->ltd_index, tgt->ltd_uuid.uuid,
+ tgt->ltd_exp->exp_handle.h_cookie);
if (obd_uuid_equals(uuid, &tgt->ltd_uuid))
break;
}
- if (i == lmv->desc.ld_tgt_count)
- GOTO(out_lmv_lock, rc = -EINVAL);
+ if (!tgt)
+ GOTO(out_lmv_lock, rc = -EINVAL);
- obd = class_exp2obd(tgt->ltd_exp);
- if (obd == NULL)
- GOTO(out_lmv_lock, rc = -ENOTCONN);
+ obd = class_exp2obd(tgt->ltd_exp);
+ if (obd == NULL)
+ GOTO(out_lmv_lock, rc = -ENOTCONN);
- CDEBUG(D_INFO, "Found OBD %s=%s device %d (%p) type %s at LMV idx %d\n",
- obd->obd_name, obd->obd_uuid.uuid, obd->obd_minor, obd,
- obd->obd_type->typ_name, i);
- LASSERT(strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) == 0);
+ CDEBUG(D_INFO, "Found OBD %s=%s device %d (%p) type %s at LMV idx %d\n",
+ obd->obd_name, obd->obd_uuid.uuid, obd->obd_minor, obd,
+ obd->obd_type->typ_name, tgt->ltd_index);
+ LASSERT(strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) == 0);
- if (tgt->ltd_active == activate) {
- CDEBUG(D_INFO, "OBD %p already %sactive!\n", obd,
- activate ? "" : "in");
- GOTO(out_lmv_lock, rc);
- }
+ if (tgt->ltd_active == activate) {
+ CDEBUG(D_INFO, "OBD %p already %sactive!\n", obd,
+ activate ? "" : "in");
+ GOTO(out_lmv_lock, rc);
+ }
- CDEBUG(D_INFO, "Marking OBD %p %sactive\n", obd,
- activate ? "" : "in");
- lmv_activate_target(lmv, tgt, activate);
- EXIT;
+ CDEBUG(D_INFO, "Marking OBD %p %sactive\n", obd,
+ activate ? "" : "in");
+ lmv_activate_target(lmv, tgt, activate);
+ EXIT;
out_lmv_lock:
spin_unlock(&lmv->lmv_lock);
struct obd_uuid *lmv_get_uuid(struct obd_export *exp)
{
- struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
- struct lmv_tgt_desc *tgt = lmv->tgts[0];
+ struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
+ struct lmv_tgt_desc *tgt = lmv_tgt(lmv, 0);
return (tgt == NULL) ? NULL : obd_get_uuid(tgt->ltd_exp);
}
static int lmv_notify(struct obd_device *obd, struct obd_device *watched,
- enum obd_notify_event ev, void *data)
+ enum obd_notify_event ev)
{
struct obd_connect_data *conn_data;
struct lmv_obd *lmv = &obd->u.lmv;
*/
obd->obd_self_export->exp_connect_data = *conn_data;
}
-#if 0
- else if (ev == OBD_NOTIFY_DISCON) {
- /*
- * For disconnect event, flush fld cache for failout MDS case.
- */
- fld_client_flush(&lmv->lmv_fld);
- }
-#endif
- /*
- * Pass the notification up the chain.
- */
- if (obd->obd_observer)
- rc = obd_notify(obd->obd_observer, watched, ev, data);
- RETURN(rc);
+ /*
+ * Pass the notification up the chain.
+ */
+ if (obd->obd_observer)
+ rc = obd_notify(obd->obd_observer, watched, ev);
+
+ RETURN(rc);
}
-/**
- * This is fake connect function. Its purpose is to initialize lmv and say
- * caller that everything is okay. Real connection will be performed later.
- */
static int lmv_connect(const struct lu_env *env,
- struct obd_export **exp, struct obd_device *obd,
- struct obd_uuid *cluuid, struct obd_connect_data *data,
- void *localdata)
+ struct obd_export **pexp, struct obd_device *obd,
+ struct obd_uuid *cluuid, struct obd_connect_data *data,
+ void *localdata)
{
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lustre_handle conn = { 0 };
- int rc = 0;
- ENTRY;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lustre_handle conn = { 0 };
+ struct obd_export *exp;
+ int rc;
+ ENTRY;
- /*
- * We don't want to actually do the underlying connections more than
- * once, so keep track.
- */
- lmv->refcount++;
- if (lmv->refcount > 1) {
- *exp = NULL;
- RETURN(0);
- }
+ rc = class_connect(&conn, obd, cluuid);
+ if (rc) {
+ CERROR("class_connection() returned %d\n", rc);
+ RETURN(rc);
+ }
- rc = class_connect(&conn, obd, cluuid);
- if (rc) {
- CERROR("class_connection() returned %d\n", rc);
- RETURN(rc);
- }
+ exp = class_conn2export(&conn);
- *exp = class_conn2export(&conn);
- class_export_get(*exp);
-
- lmv->exp = *exp;
- lmv->connected = 0;
- lmv->cluuid = *cluuid;
-
- if (data)
- lmv->conn_data = *data;
-
- if (lmv->targets_proc_entry == NULL) {
- lmv->targets_proc_entry = lprocfs_register("target_obds",
- obd->obd_proc_entry,
- NULL, NULL);
- if (IS_ERR(lmv->targets_proc_entry)) {
- CERROR("%s: cannot register "
- "/proc/fs/lustre/%s/%s/target_obds\n",
- obd->obd_name, obd->obd_type->typ_name,
- obd->obd_name);
- lmv->targets_proc_entry = NULL;
- }
+ lmv->connected = 0;
+ lmv->conn_data = *data;
+ lmv->lmv_cache = localdata;
+
+ lmv->lmv_tgts_kobj = kobject_create_and_add("target_obds",
+ &obd->obd_kset.kobj);
+ if (!lmv->lmv_tgts_kobj) {
+ CERROR("%s: cannot create /sys/fs/lustre/%s/%s/target_obds\n",
+ obd->obd_name, obd->obd_type->typ_name, obd->obd_name);
}
- /*
- * All real clients should perform actual connection right away, because
- * it is possible, that LMV will not have opportunity to connect targets
- * and MDC stuff will be called directly, for instance while reading
- * ../mdc/../kbytesfree procfs file, etc.
- */
- if (data != NULL && (data->ocd_connect_flags & OBD_CONNECT_REAL))
- rc = lmv_check_connect(obd);
+ rc = lmv_check_connect(obd);
+ if (rc != 0)
+ GOTO(out_sysfs, rc);
+
+ *pexp = exp;
- if (rc && lmv->targets_proc_entry != NULL)
- lprocfs_remove(&lmv->targets_proc_entry);
RETURN(rc);
+
+out_sysfs:
+ if (lmv->lmv_tgts_kobj)
+ kobject_put(lmv->lmv_tgts_kobj);
+
+ class_disconnect(exp);
+
+ return rc;
}
static int lmv_init_ea_size(struct obd_export *exp, __u32 easize,
__u32 def_easize)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- __u32 i;
- int rc = 0;
- int change = 0;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int change = 0;
+ int rc = 0;
+
ENTRY;
- if (lmv->max_easize < easize) {
- lmv->max_easize = easize;
- change = 1;
- }
- if (lmv->max_def_easize < def_easize) {
- lmv->max_def_easize = def_easize;
- change = 1;
- }
+ if (lmv->max_easize < easize) {
+ lmv->max_easize = easize;
+ change = 1;
+ }
+ if (lmv->max_def_easize < def_easize) {
+ lmv->max_def_easize = def_easize;
+ change = 1;
+ }
if (change == 0)
RETURN(0);
if (lmv->connected == 0)
RETURN(0);
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- struct lmv_tgt_desc *tgt = lmv->tgts[i];
-
- if (tgt == NULL || tgt->ltd_exp == NULL || !tgt->ltd_active) {
- CWARN("%s: NULL export for %d\n", obd->obd_name, i);
+ lmv_foreach_connected_tgt(lmv, tgt) {
+ if (!tgt->ltd_active)
continue;
- }
rc = md_init_ea_size(tgt->ltd_exp, easize, def_easize);
if (rc) {
CERROR("%s: obd_init_ea_size() failed on MDT target %d:"
- " rc = %d\n", obd->obd_name, i, rc);
+ " rc = %d\n", obd->obd_name, tgt->ltd_index, rc);
break;
}
}
int lmv_connect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt)
{
struct lmv_obd *lmv = &obd->u.lmv;
- struct obd_uuid *cluuid = &lmv->cluuid;
- struct obd_uuid lmv_mdc_uuid = { "LMV_MDC_UUID" };
struct obd_device *mdc_obd;
struct obd_export *mdc_exp;
struct lu_fld_target target;
int rc;
ENTRY;
- mdc_obd = class_find_client_obd(&tgt->ltd_uuid, LUSTRE_MDC_NAME,
- &obd->obd_uuid);
- if (!mdc_obd) {
- CERROR("target %s not attached\n", tgt->ltd_uuid.uuid);
- RETURN(-EINVAL);
- }
+ mdc_obd = class_find_client_obd(&tgt->ltd_uuid, LUSTRE_MDC_NAME,
+ &obd->obd_uuid);
+ if (!mdc_obd) {
+ CERROR("target %s not attached\n", tgt->ltd_uuid.uuid);
+ RETURN(-EINVAL);
+ }
- CDEBUG(D_CONFIG, "connect to %s(%s) - %s, %s FOR %s\n",
- mdc_obd->obd_name, mdc_obd->obd_uuid.uuid,
- tgt->ltd_uuid.uuid, obd->obd_uuid.uuid,
- cluuid->uuid);
+ CDEBUG(D_CONFIG, "connect to %s(%s) - %s, %s\n",
+ mdc_obd->obd_name, mdc_obd->obd_uuid.uuid,
+ tgt->ltd_uuid.uuid, obd->obd_uuid.uuid);
- if (!mdc_obd->obd_set_up) {
- CERROR("target %s is not set up\n", tgt->ltd_uuid.uuid);
- RETURN(-EINVAL);
- }
+ if (!mdc_obd->obd_set_up) {
+ CERROR("target %s is not set up\n", tgt->ltd_uuid.uuid);
+ RETURN(-EINVAL);
+ }
- rc = obd_connect(NULL, &mdc_exp, mdc_obd, &lmv_mdc_uuid,
- &lmv->conn_data, NULL);
+ rc = obd_connect(NULL, &mdc_exp, mdc_obd, &obd->obd_uuid,
+ &lmv->conn_data, lmv->lmv_cache);
if (rc) {
CERROR("target %s connect error %d\n", tgt->ltd_uuid.uuid, rc);
RETURN(rc);
if (rc)
RETURN(rc);
- target.ft_srv = NULL;
- target.ft_exp = mdc_exp;
- target.ft_idx = tgt->ltd_idx;
+ target.ft_srv = NULL;
+ target.ft_exp = mdc_exp;
+ target.ft_idx = tgt->ltd_index;
- fld_client_add_target(&lmv->lmv_fld, &target);
+ fld_client_add_target(&lmv->lmv_fld, &target);
- rc = obd_register_observer(mdc_obd, obd);
- if (rc) {
- obd_disconnect(mdc_exp);
- CERROR("target %s register_observer error %d\n",
- tgt->ltd_uuid.uuid, rc);
- RETURN(rc);
- }
+ rc = obd_register_observer(mdc_obd, obd);
+ if (rc) {
+ obd_disconnect(mdc_exp);
+ CERROR("target %s register_observer error %d\n",
+ tgt->ltd_uuid.uuid, rc);
+ RETURN(rc);
+ }
- if (obd->obd_observer) {
- /*
- * Tell the observer about the new target.
- */
+ if (obd->obd_observer) {
+ /*
+ * Tell the observer about the new target.
+ */
rc = obd_notify(obd->obd_observer, mdc_exp->exp_obd,
- OBD_NOTIFY_ACTIVE,
- (void *)(tgt - lmv->tgts[0]));
+ OBD_NOTIFY_ACTIVE);
if (rc) {
obd_disconnect(mdc_exp);
RETURN(rc);
}
- }
+ }
tgt->ltd_active = 1;
tgt->ltd_exp = mdc_exp;
- lmv->desc.ld_active_tgt_count++;
+ lmv->lmv_mdt_descs.ltd_lmv_desc.ld_active_tgt_count++;
md_init_ea_size(tgt->ltd_exp, lmv->max_easize, lmv->max_def_easize);
+ rc = lu_qos_add_tgt(&lmv->lmv_qos, tgt);
+ if (rc) {
+ obd_disconnect(mdc_exp);
+ RETURN(rc);
+ }
+
CDEBUG(D_CONFIG, "Connected to %s(%s) successfully (%d)\n",
mdc_obd->obd_name, mdc_obd->obd_uuid.uuid,
atomic_read(&obd->obd_refcount));
- if (lmv->targets_proc_entry != NULL) {
- struct proc_dir_entry *mdc_symlink;
-
- LASSERT(mdc_obd->obd_type != NULL);
- LASSERT(mdc_obd->obd_type->typ_name != NULL);
- mdc_symlink = lprocfs_add_symlink(mdc_obd->obd_name,
- lmv->targets_proc_entry,
- "../../../%s/%s",
- mdc_obd->obd_type->typ_name,
- mdc_obd->obd_name);
- if (mdc_symlink == NULL) {
- CERROR("cannot register LMV target "
- "/proc/fs/lustre/%s/%s/target_obds/%s\n",
- obd->obd_type->typ_name, obd->obd_name,
- mdc_obd->obd_name);
- }
- }
+ lmv_statfs_check_update(obd, tgt);
+
+ if (lmv->lmv_tgts_kobj)
+ /* Even if we failed to create the link, that's fine */
+ rc = sysfs_create_link(lmv->lmv_tgts_kobj,
+ &mdc_obd->obd_kset.kobj,
+ mdc_obd->obd_name);
RETURN(0);
}
-static void lmv_del_target(struct lmv_obd *lmv, int index)
+static void lmv_del_target(struct lmv_obd *lmv, struct lu_tgt_desc *tgt)
{
- if (lmv->tgts[index] == NULL)
- return;
-
- OBD_FREE_PTR(lmv->tgts[index]);
- lmv->tgts[index] = NULL;
- return;
+ LASSERT(tgt);
+ ltd_del_tgt(&lmv->lmv_mdt_descs, tgt);
+ OBD_FREE_PTR(tgt);
}
static int lmv_add_target(struct obd_device *obd, struct obd_uuid *uuidp,
__u32 index, int gen)
{
struct obd_device *mdc_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int orig_tgt_count = 0;
- int rc = 0;
- ENTRY;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ struct lu_tgt_descs *ltd = &lmv->lmv_mdt_descs;
+ int rc = 0;
+
+ ENTRY;
CDEBUG(D_CONFIG, "Target uuid: %s. index %d\n", uuidp->uuid, index);
mdc_obd = class_find_client_obd(uuidp, LUSTRE_MDC_NAME,
RETURN(-EINVAL);
}
- mutex_lock(&lmv->lmv_init_mutex);
- if ((index < lmv->tgts_size) && (lmv->tgts[index] != NULL)) {
- tgt = lmv->tgts[index];
- CERROR("%s: UUID %s already assigned at LOV target index %d:"
- " rc = %d\n", obd->obd_name,
- obd_uuid2str(&tgt->ltd_uuid), index, -EEXIST);
- mutex_unlock(&lmv->lmv_init_mutex);
- RETURN(-EEXIST);
- }
-
- if (index >= lmv->tgts_size) {
- /* We need to reallocate the lmv target array. */
- struct lmv_tgt_desc **newtgts, **old = NULL;
- __u32 newsize = 1;
- __u32 oldsize = 0;
-
- while (newsize < index + 1)
- newsize = newsize << 1;
- OBD_ALLOC(newtgts, sizeof(*newtgts) * newsize);
- if (newtgts == NULL) {
- mutex_unlock(&lmv->lmv_init_mutex);
- RETURN(-ENOMEM);
- }
-
- if (lmv->tgts_size) {
- memcpy(newtgts, lmv->tgts,
- sizeof(*newtgts) * lmv->tgts_size);
- old = lmv->tgts;
- oldsize = lmv->tgts_size;
- }
-
- lmv->tgts = newtgts;
- lmv->tgts_size = newsize;
- smp_rmb();
- if (old)
- OBD_FREE(old, sizeof(*old) * oldsize);
-
- CDEBUG(D_CONFIG, "tgts: %p size: %d\n", lmv->tgts,
- lmv->tgts_size);
- }
-
OBD_ALLOC_PTR(tgt);
- if (!tgt) {
- mutex_unlock(&lmv->lmv_init_mutex);
+ if (!tgt)
RETURN(-ENOMEM);
- }
mutex_init(&tgt->ltd_fid_mutex);
- tgt->ltd_idx = index;
+ tgt->ltd_index = index;
tgt->ltd_uuid = *uuidp;
tgt->ltd_active = 0;
- lmv->tgts[index] = tgt;
- if (index >= lmv->desc.ld_tgt_count) {
- orig_tgt_count = lmv->desc.ld_tgt_count;
- lmv->desc.ld_tgt_count = index + 1;
- }
- if (lmv->connected == 0) {
+ mutex_lock(<d->ltd_mutex);
+ rc = ltd_add_tgt(ltd, tgt);
+ mutex_unlock(<d->ltd_mutex);
+
+ if (rc)
+ GOTO(out_tgt, rc);
+
+ if (!lmv->connected)
/* lmv_check_connect() will connect this target. */
- mutex_unlock(&lmv->lmv_init_mutex);
RETURN(0);
- }
- /* Otherwise let's connect it ourselves */
- mutex_unlock(&lmv->lmv_init_mutex);
rc = lmv_connect_mdc(obd, tgt);
- if (rc != 0) {
- spin_lock(&lmv->lmv_lock);
- if (lmv->desc.ld_tgt_count == index + 1)
- lmv->desc.ld_tgt_count = orig_tgt_count;
- memset(tgt, 0, sizeof(*tgt));
- spin_unlock(&lmv->lmv_lock);
- } else {
+ if (!rc) {
int easize = sizeof(struct lmv_stripe_md) +
- lmv->desc.ld_tgt_count * sizeof(struct lu_fid);
+ lmv->lmv_mdt_count * sizeof(struct lu_fid);
+
lmv_init_ea_size(obd->obd_self_export, easize, 0);
}
RETURN(rc);
+
+out_tgt:
+ OBD_FREE_PTR(tgt);
+ return rc;
}
-int lmv_check_connect(struct obd_device *obd)
+static int lmv_check_connect(struct obd_device *obd)
{
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- __u32 i;
- int rc;
- int easize;
- ENTRY;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int easize;
+ int rc;
- if (lmv->connected)
- RETURN(0);
+ ENTRY;
- mutex_lock(&lmv->lmv_init_mutex);
- if (lmv->connected) {
- mutex_unlock(&lmv->lmv_init_mutex);
- RETURN(0);
- }
+ if (lmv->connected)
+ RETURN(0);
- if (lmv->desc.ld_tgt_count == 0) {
- mutex_unlock(&lmv->lmv_init_mutex);
- CERROR("%s: no targets configured.\n", obd->obd_name);
- RETURN(-EINVAL);
- }
+ mutex_lock(&lmv->lmv_mdt_descs.ltd_mutex);
+ if (lmv->connected)
+ GOTO(unlock, rc = 0);
- LASSERT(lmv->tgts != NULL);
+ if (!lmv->lmv_mdt_count) {
+ CERROR("%s: no targets configured: rc = -EINVAL\n",
+ obd->obd_name);
+ GOTO(unlock, rc = -EINVAL);
+ }
- if (lmv->tgts[0] == NULL) {
- mutex_unlock(&lmv->lmv_init_mutex);
- CERROR("%s: no target configured for index 0.\n",
+ if (!lmv_mdt0_inited(lmv)) {
+ CERROR("%s: no target configured for index 0: rc = -EINVAL.\n",
obd->obd_name);
- RETURN(-EINVAL);
+ GOTO(unlock, rc = -EINVAL);
}
CDEBUG(D_CONFIG, "Time to connect %s to %s\n",
- lmv->cluuid.uuid, obd->obd_name);
+ obd->obd_uuid.uuid, obd->obd_name);
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- tgt = lmv->tgts[i];
- if (tgt == NULL)
- continue;
+ lmv_foreach_tgt(lmv, tgt) {
rc = lmv_connect_mdc(obd, tgt);
if (rc)
GOTO(out_disc, rc);
}
- class_export_put(lmv->exp);
lmv->connected = 1;
- easize = lmv_mds_md_size(lmv->desc.ld_tgt_count, LMV_MAGIC);
+ easize = lmv_mds_md_size(lmv->lmv_mdt_count, LMV_MAGIC);
lmv_init_ea_size(obd->obd_self_export, easize, 0);
- mutex_unlock(&lmv->lmv_init_mutex);
- RETURN(0);
+ EXIT;
+unlock:
+ mutex_unlock(&lmv->lmv_mdt_descs.ltd_mutex);
+
+ return rc;
- out_disc:
- while (i-- > 0) {
- int rc2;
- tgt = lmv->tgts[i];
- if (tgt == NULL)
+out_disc:
+ lmv_foreach_tgt(lmv, tgt) {
+ tgt->ltd_active = 0;
+ if (!tgt->ltd_exp)
continue;
- tgt->ltd_active = 0;
- if (tgt->ltd_exp) {
- --lmv->desc.ld_active_tgt_count;
- rc2 = obd_disconnect(tgt->ltd_exp);
- if (rc2) {
- CERROR("LMV target %s disconnect on "
- "MDC idx %d: error %d\n",
- tgt->ltd_uuid.uuid, i, rc2);
- }
- }
- }
- class_disconnect(lmv->exp);
- mutex_unlock(&lmv->lmv_init_mutex);
- RETURN(rc);
+
+ --lmv->lmv_mdt_descs.ltd_lmv_desc.ld_active_tgt_count;
+ obd_disconnect(tgt->ltd_exp);
+ }
+
+ goto unlock;
}
static int lmv_disconnect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt)
mdc_obd->obd_fail = obd->obd_fail;
mdc_obd->obd_no_recov = obd->obd_no_recov;
- if (lmv->targets_proc_entry != NULL)
- lprocfs_remove_proc_entry(mdc_obd->obd_name,
- lmv->targets_proc_entry);
+ if (lmv->lmv_tgts_kobj)
+ sysfs_remove_link(lmv->lmv_tgts_kobj,
+ mdc_obd->obd_name);
}
rc = obd_fid_fini(tgt->ltd_exp->exp_obd);
static int lmv_disconnect(struct obd_export *exp)
{
- struct obd_device *obd = class_exp2obd(exp);
- struct lmv_obd *lmv = &obd->u.lmv;
- int rc;
- __u32 i;
+ struct obd_device *obd = class_exp2obd(exp);
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
+
ENTRY;
- if (!lmv->tgts)
- goto out_local;
+ lmv_foreach_connected_tgt(lmv, tgt)
+ lmv_disconnect_mdc(obd, tgt);
- /*
- * Only disconnect the underlying layers on the final disconnect.
- */
- lmv->refcount--;
- if (lmv->refcount != 0)
- goto out_local;
+ if (lmv->lmv_tgts_kobj)
+ kobject_put(lmv->lmv_tgts_kobj);
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- if (lmv->tgts[i] == NULL || lmv->tgts[i]->ltd_exp == NULL)
- continue;
+ if (!lmv->connected)
+ class_export_put(exp);
+ rc = class_disconnect(exp);
+ lmv->connected = 0;
- lmv_disconnect_mdc(obd, lmv->tgts[i]);
- }
+ RETURN(rc);
+}
- if (lmv->targets_proc_entry != NULL)
- lprocfs_remove(&lmv->targets_proc_entry);
- else
- CERROR("/proc/fs/lustre/%s/%s/target_obds missing\n",
- obd->obd_type->typ_name, obd->obd_name);
-
-out_local:
- /*
- * This is the case when no real connection is established by
- * lmv_check_connect().
- */
- if (!lmv->connected)
- class_export_put(exp);
- rc = class_disconnect(exp);
- if (lmv->refcount == 0)
- lmv->connected = 0;
- RETURN(rc);
-}
-
-static int lmv_fid2path(struct obd_export *exp, int len, void *karg, void *uarg)
-{
- struct obd_device *obddev = class_exp2obd(exp);
- struct lmv_obd *lmv = &obddev->u.lmv;
+static int lmv_fid2path(struct obd_export *exp, int len, void *karg,
+ void __user *uarg)
+{
+ struct obd_device *obddev = class_exp2obd(exp);
+ struct lmv_obd *lmv = &obddev->u.lmv;
struct getinfo_fid2path *gf;
- struct lmv_tgt_desc *tgt;
+ struct lmv_tgt_desc *tgt;
struct getinfo_fid2path *remote_gf = NULL;
- int remote_gf_size = 0;
- int rc;
+ struct lu_fid root_fid;
+ int remote_gf_size = 0;
+ int rc;
- gf = (struct getinfo_fid2path *)karg;
- tgt = lmv_find_target(lmv, &gf->gf_fid);
+ gf = karg;
+ tgt = lmv_fid2tgt(lmv, &gf->gf_fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
+ root_fid = *gf->gf_u.gf_root_fid;
+ LASSERT(fid_is_sane(&root_fid));
+
repeat_fid2path:
rc = obd_iocontrol(OBD_IOC_FID2PATH, tgt->ltd_exp, len, gf, uarg);
if (rc != 0 && rc != -EREMOTE)
if (remote_gf != NULL) {
struct getinfo_fid2path *ori_gf;
char *ptr;
+ int len;
ori_gf = (struct getinfo_fid2path *)karg;
- if (strlen(ori_gf->gf_path) +
- strlen(gf->gf_path) > ori_gf->gf_pathlen)
+ if (strlen(ori_gf->gf_u.gf_path) + 1 +
+ strlen(gf->gf_u.gf_path) + 1 > ori_gf->gf_pathlen)
GOTO(out_fid2path, rc = -EOVERFLOW);
- ptr = ori_gf->gf_path;
-
- memmove(ptr + strlen(gf->gf_path) + 1, ptr,
- strlen(ori_gf->gf_path));
+ ptr = ori_gf->gf_u.gf_path;
- strncpy(ptr, gf->gf_path, strlen(gf->gf_path));
- ptr += strlen(gf->gf_path);
- *ptr = '/';
+ len = strlen(gf->gf_u.gf_path);
+ /* move the current path to the right to release space
+ * for closer-to-root part */
+ memmove(ptr + len + 1, ptr, strlen(ori_gf->gf_u.gf_path));
+ memcpy(ptr, gf->gf_u.gf_path, len);
+ ptr[len] = '/';
}
- CDEBUG(D_INFO, "%s: get path %s "DFID" rec: "LPU64" ln: %u\n",
+ CDEBUG(D_INFO, "%s: get path %s "DFID" rec: %llu ln: %u\n",
tgt->ltd_exp->exp_obd->obd_name,
- gf->gf_path, PFID(&gf->gf_fid), gf->gf_recno,
+ gf->gf_u.gf_path, PFID(&gf->gf_fid), gf->gf_recno,
gf->gf_linkno);
if (rc == 0)
GOTO(out_fid2path, rc = -EINVAL);
}
- tgt = lmv_find_target(lmv, &gf->gf_fid);
+ tgt = lmv_fid2tgt(lmv, &gf->gf_fid);
if (IS_ERR(tgt))
GOTO(out_fid2path, rc = -EINVAL);
remote_gf->gf_fid = gf->gf_fid;
remote_gf->gf_recno = -1;
remote_gf->gf_linkno = -1;
- memset(remote_gf->gf_path, 0, remote_gf->gf_pathlen);
+ memset(remote_gf->gf_u.gf_path, 0, remote_gf->gf_pathlen);
+ *remote_gf->gf_u.gf_root_fid = root_fid;
gf = remote_gf;
goto repeat_fid2path;
const struct hsm_user_request *hur,
const struct lmv_tgt_desc *tgt_mds)
{
- __u32 i;
- int nr = 0;
- struct lmv_tgt_desc *curr_tgt;
+ struct lmv_tgt_desc *curr_tgt;
+ __u32 i;
+ int nr = 0;
/* count how many requests must be sent to the given target */
for (i = 0; i < hur->hur_request.hr_itemcount; i++) {
- curr_tgt = lmv_find_target(lmv, &hur->hur_user_item[i].hui_fid);
+ curr_tgt = lmv_fid2tgt(lmv, &hur->hur_user_item[i].hui_fid);
+ if (IS_ERR(curr_tgt))
+ RETURN(PTR_ERR(curr_tgt));
if (obd_uuid_equals(&curr_tgt->ltd_uuid, &tgt_mds->ltd_uuid))
nr++;
}
return nr;
}
-static void lmv_hsm_req_build(struct lmv_obd *lmv,
+static int lmv_hsm_req_build(struct lmv_obd *lmv,
struct hsm_user_request *hur_in,
const struct lmv_tgt_desc *tgt_mds,
struct hsm_user_request *hur_out)
{
- __u32 i, nr_out;
- struct lmv_tgt_desc *curr_tgt;
+ __u32 i, nr_out;
+ struct lmv_tgt_desc *curr_tgt;
/* build the hsm_user_request for the given target */
hur_out->hur_request = hur_in->hur_request;
nr_out = 0;
for (i = 0; i < hur_in->hur_request.hr_itemcount; i++) {
- curr_tgt = lmv_find_target(lmv,
- &hur_in->hur_user_item[i].hui_fid);
+ curr_tgt = lmv_fid2tgt(lmv, &hur_in->hur_user_item[i].hui_fid);
+ if (IS_ERR(curr_tgt))
+ RETURN(PTR_ERR(curr_tgt));
if (obd_uuid_equals(&curr_tgt->ltd_uuid, &tgt_mds->ltd_uuid)) {
hur_out->hur_user_item[nr_out] =
hur_in->hur_user_item[i];
hur_out->hur_request.hr_itemcount = nr_out;
memcpy(hur_data(hur_out), hur_data(hur_in),
hur_in->hur_request.hr_data_len);
+
+ RETURN(0);
}
-static int lmv_hsm_ct_unregister(struct lmv_obd *lmv, unsigned int cmd, int len,
- struct lustre_kernelcomm *lk, void *uarg)
+static int lmv_hsm_ct_unregister(struct obd_device *obd, unsigned int cmd,
+ int len, struct lustre_kernelcomm *lk,
+ void __user *uarg)
{
- __u32 i;
- int rc;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lu_tgt_desc *tgt;
+ int rc;
+
ENTRY;
/* unregister request (call from llapi_hsm_copytool_fini) */
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- struct lmv_tgt_desc *tgt = lmv->tgts[i];
-
- if (tgt == NULL || tgt->ltd_exp == NULL)
- continue;
+ lmv_foreach_connected_tgt(lmv, tgt)
/* best effort: try to clean as much as possible
* (continue on error) */
obd_iocontrol(cmd, tgt->ltd_exp, len, lk, uarg);
- }
/* Whatever the result, remove copytool from kuc groups.
* Unreached coordinators will get EPIPE on next requests
* and will unregister automatically.
*/
- rc = libcfs_kkuc_group_rem(lk->lk_uid, lk->lk_group);
+ rc = libcfs_kkuc_group_rem(&obd->obd_uuid, lk->lk_uid, lk->lk_group);
RETURN(rc);
}
-static int lmv_hsm_ct_register(struct lmv_obd *lmv, unsigned int cmd, int len,
- struct lustre_kernelcomm *lk, void *uarg)
+static int lmv_hsm_ct_register(struct obd_device *obd, unsigned int cmd,
+ int len, struct lustre_kernelcomm *lk,
+ void __user *uarg)
{
- struct file *filp;
- __u32 i, j;
- int err, rc;
- bool any_set = false;
- struct kkuc_ct_data kcd = { 0 };
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct file *filp;
+ bool any_set = false;
+ struct kkuc_ct_data *kcd;
+ size_t kcd_size;
+ struct lu_tgt_desc *tgt;
+ __u32 i;
+ int err;
+ int rc = 0;
+
ENTRY;
+ filp = fget(lk->lk_wfd);
+ if (!filp)
+ RETURN(-EBADF);
+
+ if (lk->lk_flags & LK_FLG_DATANR)
+ kcd_size = offsetof(struct kkuc_ct_data,
+ kcd_archives[lk->lk_data_count]);
+ else
+ kcd_size = sizeof(*kcd);
+
+ OBD_ALLOC(kcd, kcd_size);
+ if (kcd == NULL)
+ GOTO(err_fput, rc = -ENOMEM);
+
+ kcd->kcd_nr_archives = lk->lk_data_count;
+ if (lk->lk_flags & LK_FLG_DATANR) {
+ kcd->kcd_magic = KKUC_CT_DATA_ARRAY_MAGIC;
+ if (lk->lk_data_count > 0)
+ memcpy(kcd->kcd_archives, lk->lk_data,
+ sizeof(*kcd->kcd_archives) * lk->lk_data_count);
+ } else {
+ kcd->kcd_magic = KKUC_CT_DATA_BITMAP_MAGIC;
+ }
+
+ rc = libcfs_kkuc_group_add(filp, &obd->obd_uuid, lk->lk_uid,
+ lk->lk_group, kcd, kcd_size);
+ OBD_FREE(kcd, kcd_size);
+ if (rc)
+ GOTO(err_fput, rc);
+
/* All or nothing: try to register to all MDS.
* In case of failure, unregister from previous MDS,
* except if it because of inactive target. */
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- struct lmv_tgt_desc *tgt = lmv->tgts[i];
-
- if (tgt == NULL || tgt->ltd_exp == NULL)
- continue;
+ lmv_foreach_connected_tgt(lmv, tgt) {
err = obd_iocontrol(cmd, tgt->ltd_exp, len, lk, uarg);
if (err) {
if (tgt->ltd_active) {
/* permanent error */
CERROR("%s: iocontrol MDC %s on MDT"
" idx %d cmd %x: err = %d\n",
- class_exp2obd(lmv->exp)->obd_name,
- tgt->ltd_uuid.uuid, i, cmd, err);
+ lmv2obd_dev(lmv)->obd_name,
+ tgt->ltd_uuid.uuid, tgt->ltd_index, cmd,
+ err);
rc = err;
lk->lk_flags |= LK_FLG_STOP;
+ i = tgt->ltd_index;
/* unregister from previous MDS */
- for (j = 0; j < i; j++) {
- tgt = lmv->tgts[j];
- if (tgt == NULL || tgt->ltd_exp == NULL)
- continue;
+ lmv_foreach_connected_tgt(lmv, tgt) {
+ if (tgt->ltd_index >= i)
+ break;
+
obd_iocontrol(cmd, tgt->ltd_exp, len,
lk, uarg);
}
- RETURN(rc);
+ GOTO(err_kkuc_rem, rc);
}
/* else: transient error.
* kuc will register to the missing MDT
if (!any_set)
/* no registration done: return error */
- RETURN(-ENOTCONN);
-
- /* at least one registration done, with no failure */
- filp = fget(lk->lk_wfd);
- if (filp == NULL)
- RETURN(-EBADF);
+ GOTO(err_kkuc_rem, rc = -ENOTCONN);
- kcd.kcd_magic = KKUC_CT_DATA_MAGIC;
- kcd.kcd_uuid = lmv->cluuid;
- kcd.kcd_archive = lk->lk_data;
+ RETURN(0);
- rc = libcfs_kkuc_group_add(filp, lk->lk_uid, lk->lk_group,
- &kcd, sizeof(kcd));
- if (rc != 0)
- fput(filp);
+err_kkuc_rem:
+ libcfs_kkuc_group_rem(&obd->obd_uuid, lk->lk_uid, lk->lk_group);
- RETURN(rc);
+err_fput:
+ fput(filp);
+ return rc;
}
-
-
-
static int lmv_iocontrol(unsigned int cmd, struct obd_export *exp,
int len, void *karg, void __user *uarg)
{
- struct obd_device *obddev = class_exp2obd(exp);
- struct lmv_obd *lmv = &obddev->u.lmv;
- struct lmv_tgt_desc *tgt = NULL;
- __u32 i = 0;
- int rc = 0;
- int set = 0;
- __u32 count = lmv->desc.ld_tgt_count;
+ struct obd_device *obddev = class_exp2obd(exp);
+ struct lmv_obd *lmv = &obddev->u.lmv;
+ struct lu_tgt_desc *tgt = NULL;
+ int set = 0;
+ __u32 count = lmv->lmv_mdt_count;
+ int rc = 0;
+
ENTRY;
- if (count == 0)
- RETURN(-ENOTTY);
+ if (count == 0)
+ RETURN(-ENOTTY);
+
+ switch (cmd) {
+ case IOC_OBD_STATFS: {
+ struct obd_ioctl_data *data = karg;
+ struct obd_device *mdc_obd;
+ struct obd_statfs stat_buf = {0};
+ __u32 index;
- switch (cmd) {
- case IOC_OBD_STATFS: {
- struct obd_ioctl_data *data = karg;
- struct obd_device *mdc_obd;
- struct obd_statfs stat_buf = {0};
- __u32 index;
+ memcpy(&index, data->ioc_inlbuf2, sizeof(__u32));
- memcpy(&index, data->ioc_inlbuf2, sizeof(__u32));
- if ((index >= count))
- RETURN(-ENODEV);
+ if (index >= lmv->lmv_mdt_descs.ltd_tgts_size)
+ RETURN(-ENODEV);
- tgt = lmv->tgts[index];
- if (tgt == NULL || !tgt->ltd_active)
+ tgt = lmv_tgt(lmv, index);
+ if (!tgt || !tgt->ltd_active)
RETURN(-ENODATA);
mdc_obd = class_exp2obd(tgt->ltd_exp);
RETURN(-EFAULT);
rc = obd_statfs(NULL, tgt->ltd_exp, &stat_buf,
- cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
+ ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS,
0);
if (rc)
RETURN(rc);
(int) sizeof(stat_buf))))
RETURN(-EFAULT);
break;
- }
- case OBD_IOC_QUOTACTL: {
- struct if_quotactl *qctl = karg;
- struct obd_quotactl *oqctl;
+ }
+ case OBD_IOC_QUOTACTL: {
+ struct if_quotactl *qctl = karg;
+ struct obd_quotactl *oqctl;
if (qctl->qc_valid == QC_MDTIDX) {
- if (count <= qctl->qc_idx)
- RETURN(-EINVAL);
-
- tgt = lmv->tgts[qctl->qc_idx];
- if (tgt == NULL || tgt->ltd_exp == NULL)
- RETURN(-EINVAL);
+ tgt = lmv_tgt(lmv, qctl->qc_idx);
} else if (qctl->qc_valid == QC_UUID) {
- for (i = 0; i < count; i++) {
- tgt = lmv->tgts[i];
- if (tgt == NULL)
- continue;
+ lmv_foreach_tgt(lmv, tgt) {
if (!obd_uuid_equals(&tgt->ltd_uuid,
&qctl->obd_uuid))
continue;
- if (tgt->ltd_exp == NULL)
- RETURN(-EINVAL);
-
- break;
- }
- } else {
- RETURN(-EINVAL);
- }
-
- if (i >= count)
- RETURN(-EAGAIN);
+ if (!tgt->ltd_exp)
+ RETURN(-EINVAL);
- LASSERT(tgt != NULL && tgt->ltd_exp != NULL);
- OBD_ALLOC_PTR(oqctl);
- if (!oqctl)
- RETURN(-ENOMEM);
+ break;
+ }
+ } else {
+ RETURN(-EINVAL);
+ }
- QCTL_COPY(oqctl, qctl);
- rc = obd_quotactl(tgt->ltd_exp, oqctl);
- if (rc == 0) {
- QCTL_COPY(qctl, oqctl);
- qctl->qc_valid = QC_MDTIDX;
- qctl->obd_uuid = tgt->ltd_uuid;
- }
- OBD_FREE_PTR(oqctl);
- break;
- }
- case OBD_IOC_CHANGELOG_SEND:
- case OBD_IOC_CHANGELOG_CLEAR: {
- struct ioc_changelog *icc = karg;
+ if (!tgt || !tgt->ltd_exp)
+ RETURN(-EINVAL);
- if (icc->icc_mdtindex >= count)
- RETURN(-ENODEV);
+ OBD_ALLOC_PTR(oqctl);
+ if (!oqctl)
+ RETURN(-ENOMEM);
- tgt = lmv->tgts[icc->icc_mdtindex];
- if (tgt == NULL || tgt->ltd_exp == NULL || !tgt->ltd_active)
- RETURN(-ENODEV);
- rc = obd_iocontrol(cmd, tgt->ltd_exp, sizeof(*icc), icc, NULL);
+ QCTL_COPY(oqctl, qctl);
+ rc = obd_quotactl(tgt->ltd_exp, oqctl);
+ if (rc == 0) {
+ QCTL_COPY(qctl, oqctl);
+ qctl->qc_valid = QC_MDTIDX;
+ qctl->obd_uuid = tgt->ltd_uuid;
+ }
+ OBD_FREE_PTR(oqctl);
break;
}
case LL_IOC_GET_CONNECT_FLAGS: {
- tgt = lmv->tgts[0];
- if (tgt == NULL || tgt->ltd_exp == NULL)
- RETURN(-ENODATA);
- rc = obd_iocontrol(cmd, tgt->ltd_exp, len, karg, uarg);
+ tgt = lmv_tgt(lmv, 0);
+ rc = -ENODATA;
+ if (tgt && tgt->ltd_exp)
+ rc = obd_iocontrol(cmd, tgt->ltd_exp, len, karg, uarg);
break;
}
case LL_IOC_FID2MDTIDX: {
case LL_IOC_HSM_STATE_GET:
case LL_IOC_HSM_STATE_SET:
case LL_IOC_HSM_ACTION: {
- struct md_op_data *op_data = karg;
+ struct md_op_data *op_data = karg;
- tgt = lmv_find_target(lmv, &op_data->op_fid1);
+ tgt = lmv_fid2tgt(lmv, &op_data->op_fid1);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
case LL_IOC_HSM_PROGRESS: {
const struct hsm_progress_kernel *hpk = karg;
- tgt = lmv_find_target(lmv, &hpk->hpk_fid);
+ tgt = lmv_fid2tgt(lmv, &hpk->hpk_fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
rc = obd_iocontrol(cmd, tgt->ltd_exp, len, karg, uarg);
* or if there is a single MDS, no need to split
* the request. */
if (reqcount == 1 || count == 1) {
- tgt = lmv_find_target(lmv,
- &hur->hur_user_item[0].hui_fid);
+ tgt = lmv_fid2tgt(lmv, &hur->hur_user_item[0].hui_fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
rc = obd_iocontrol(cmd, tgt->ltd_exp, len, karg, uarg);
} else {
/* split fid list to their respective MDS */
- for (i = 0; i < count; i++) {
- unsigned int nr, reqlen;
- int rc1;
+ lmv_foreach_connected_tgt(lmv, tgt) {
+ int nr, rc1;
+ size_t reqlen;
struct hsm_user_request *req;
- tgt = lmv->tgts[i];
- if (tgt == NULL || tgt->ltd_exp == NULL)
- continue;
-
nr = lmv_hsm_req_count(lmv, hur, tgt);
+ if (nr < 0)
+ RETURN(nr);
if (nr == 0) /* nothing for this MDS */
continue;
OBD_ALLOC_LARGE(req, reqlen);
if (req == NULL)
RETURN(-ENOMEM);
-
- lmv_hsm_req_build(lmv, hur, tgt, req);
-
+ rc1 = lmv_hsm_req_build(lmv, hur, tgt, req);
+ if (rc1 < 0)
+ GOTO(hsm_req_err, rc1);
rc1 = obd_iocontrol(cmd, tgt->ltd_exp, reqlen,
req, uarg);
+hsm_req_err:
if (rc1 != 0 && rc == 0)
rc = rc1;
OBD_FREE_LARGE(req, reqlen);
break;
}
case LL_IOC_LOV_SWAP_LAYOUTS: {
- struct md_op_data *op_data = karg;
- struct lmv_tgt_desc *tgt1, *tgt2;
+ struct md_op_data *op_data = karg;
+ struct lmv_tgt_desc *tgt1, *tgt2;
- tgt1 = lmv_find_target(lmv, &op_data->op_fid1);
+ tgt1 = lmv_fid2tgt(lmv, &op_data->op_fid1);
if (IS_ERR(tgt1))
RETURN(PTR_ERR(tgt1));
- tgt2 = lmv_find_target(lmv, &op_data->op_fid2);
+ tgt2 = lmv_fid2tgt(lmv, &op_data->op_fid2);
if (IS_ERR(tgt2))
RETURN(PTR_ERR(tgt2));
RETURN(-EINVAL);
/* only files on same MDT can have their layouts swapped */
- if (tgt1->ltd_idx != tgt2->ltd_idx)
+ if (tgt1->ltd_index != tgt2->ltd_index)
RETURN(-EPERM);
rc = obd_iocontrol(cmd, tgt1->ltd_exp, len, karg, uarg);
case LL_IOC_HSM_CT_START: {
struct lustre_kernelcomm *lk = karg;
if (lk->lk_flags & LK_FLG_STOP)
- rc = lmv_hsm_ct_unregister(lmv, cmd, len, lk, uarg);
+ rc = lmv_hsm_ct_unregister(obddev, cmd, len, lk, uarg);
else
- rc = lmv_hsm_ct_register(lmv, cmd, len, lk, uarg);
+ rc = lmv_hsm_ct_register(obddev, cmd, len, lk, uarg);
break;
}
default:
- for (i = 0; i < count; i++) {
+ lmv_foreach_connected_tgt(lmv, tgt) {
struct obd_device *mdc_obd;
int err;
- tgt = lmv->tgts[i];
- if (tgt == NULL || tgt->ltd_exp == NULL)
- continue;
/* ll_umount_begin() sets force flag but for lmv, not
* mdc. Let's pass it through */
mdc_obd = class_exp2obd(tgt->ltd_exp);
if (tgt->ltd_active) {
CERROR("error: iocontrol MDC %s on MDT"
" idx %d cmd %x: err = %d\n",
- tgt->ltd_uuid.uuid, i, cmd, err);
+ tgt->ltd_uuid.uuid,
+ tgt->ltd_index, cmd, err);
if (!rc)
rc = err;
}
} else
set = 1;
- }
- if (!set && !rc)
- rc = -EIO;
- }
- RETURN(rc);
+ }
+ if (!set && !rc)
+ rc = -EIO;
+ }
+ RETURN(rc);
}
-#if 0
-static int lmv_all_chars_policy(int count, const char *name,
- int len)
+int lmv_fid_alloc(const struct lu_env *env, struct obd_export *exp,
+ struct lu_fid *fid, struct md_op_data *op_data)
{
- unsigned int c = 0;
+ struct obd_device *obd = class_exp2obd(exp);
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
- while (len > 0)
- c += name[--len];
- c = c % count;
- return c;
-}
+ ENTRY;
-static int lmv_nid_policy(struct lmv_obd *lmv)
-{
- struct obd_import *imp;
- __u32 id;
+ LASSERT(op_data);
+ LASSERT(fid);
- /*
- * XXX: To get nid we assume that underlying obd device is mdc.
- */
- imp = class_exp2cliimp(lmv->tgts[0].ltd_exp);
- id = imp->imp_connection->c_self ^ (imp->imp_connection->c_self >> 32);
- return id % lmv->desc.ld_tgt_count;
-}
+ tgt = lmv_tgt(lmv, op_data->op_mds);
+ if (!tgt)
+ RETURN(-ENODEV);
-static int lmv_choose_mds(struct lmv_obd *lmv, struct md_op_data *op_data,
- placement_policy_t placement)
-{
- switch (placement) {
- case PLACEMENT_CHAR_POLICY:
- return lmv_all_chars_policy(lmv->desc.ld_tgt_count,
- op_data->op_name,
- op_data->op_namelen);
- case PLACEMENT_NID_POLICY:
- return lmv_nid_policy(lmv);
+ if (!tgt->ltd_active || !tgt->ltd_exp)
+ RETURN(-ENODEV);
- default:
- break;
- }
+ /*
+ * New seq alloc and FLD setup should be atomic. Otherwise we may find
+ * on server that seq in new allocated fid is not yet known.
+ */
+ mutex_lock(&tgt->ltd_fid_mutex);
+ rc = obd_fid_alloc(NULL, tgt->ltd_exp, fid, NULL);
+ mutex_unlock(&tgt->ltd_fid_mutex);
+ if (rc > 0) {
+ LASSERT(fid_is_sane(fid));
+ rc = 0;
+ }
- CERROR("Unsupported placement policy %x\n", placement);
- return -EINVAL;
+ RETURN(rc);
}
-#endif
-/**
- * This is _inode_ placement policy function (not name).
- */
-static int lmv_placement_policy(struct obd_device *obd,
- struct md_op_data *op_data, u32 *mds)
+static int lmv_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
{
- struct lmv_obd *lmv = &obd->u.lmv;
- ENTRY;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_desc *desc;
+ struct lnet_process_id lnet_id;
+ int i = 0;
+ int rc;
- LASSERT(mds != NULL);
+ ENTRY;
- if (lmv->desc.ld_tgt_count == 1) {
- *mds = 0;
- RETURN(0);
+ if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1) {
+ CERROR("LMV setup requires a descriptor\n");
+ RETURN(-EINVAL);
}
- if (op_data->op_default_stripe_offset != -1) {
- *mds = op_data->op_default_stripe_offset;
- RETURN(0);
+ desc = (struct lmv_desc *)lustre_cfg_buf(lcfg, 1);
+ if (sizeof(*desc) > LUSTRE_CFG_BUFLEN(lcfg, 1)) {
+ CERROR("Lmv descriptor size wrong: %d > %d\n",
+ (int)sizeof(*desc), LUSTRE_CFG_BUFLEN(lcfg, 1));
+ RETURN(-EINVAL);
}
- /**
- * If stripe_offset is provided during setdirstripe
- * (setdirstripe -i xx), xx MDS will be choosen.
- */
- if (op_data->op_cli_flags & CLI_SET_MEA && op_data->op_data != NULL) {
- struct lmv_user_md *lum;
+ obd_str2uuid(&lmv->lmv_mdt_descs.ltd_lmv_desc.ld_uuid,
+ desc->ld_uuid.uuid);
+ lmv->lmv_mdt_descs.ltd_lmv_desc.ld_tgt_count = 0;
+ lmv->lmv_mdt_descs.ltd_lmv_desc.ld_active_tgt_count = 0;
+ lmv->lmv_mdt_descs.ltd_lmv_desc.ld_qos_maxage =
+ LMV_DESC_QOS_MAXAGE_DEFAULT;
+ lmv->max_def_easize = 0;
+ lmv->max_easize = 0;
- lum = op_data->op_data;
+ spin_lock_init(&lmv->lmv_lock);
- if (le32_to_cpu(lum->lum_stripe_offset) != (__u32)-1) {
- *mds = le32_to_cpu(lum->lum_stripe_offset);
- } else {
- /* -1 means default, which will be in the same MDT with
- * the stripe */
- *mds = op_data->op_mds;
- lum->lum_stripe_offset = cpu_to_le32(op_data->op_mds);
+ /*
+ * initialize rr_index to lower 32bit of netid, so that client
+ * can distribute subdirs evenly from the beginning.
+ */
+ while (LNetGetId(i++, &lnet_id) != -ENOENT) {
+ if (LNET_NETTYP(LNET_NIDNET(lnet_id.nid)) != LOLND) {
+ lmv->lmv_qos_rr_index = (u32)lnet_id.nid;
+ break;
}
- } else {
- /* Allocate new fid on target according to operation type and
- * parent home mds. */
- *mds = op_data->op_mds;
}
- RETURN(0);
-}
-
-int __lmv_fid_alloc(struct lmv_obd *lmv, struct lu_fid *fid, u32 mds)
-{
- struct lmv_tgt_desc *tgt;
- int rc;
- ENTRY;
-
- tgt = lmv_get_target(lmv, mds, NULL);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
-
- /*
- * New seq alloc and FLD setup should be atomic. Otherwise we may find
- * on server that seq in new allocated fid is not yet known.
- */
- mutex_lock(&tgt->ltd_fid_mutex);
-
- if (tgt->ltd_active == 0 || tgt->ltd_exp == NULL)
- GOTO(out, rc = -ENODEV);
-
- /*
- * Asking underlying tgt layer to allocate new fid.
- */
- rc = obd_fid_alloc(NULL, tgt->ltd_exp, fid, NULL);
- if (rc > 0) {
- LASSERT(fid_is_sane(fid));
- rc = 0;
- }
-
- EXIT;
-out:
- mutex_unlock(&tgt->ltd_fid_mutex);
- return rc;
-}
-
-int lmv_fid_alloc(const struct lu_env *env, struct obd_export *exp,
- struct lu_fid *fid, struct md_op_data *op_data)
-{
- struct obd_device *obd = class_exp2obd(exp);
- struct lmv_obd *lmv = &obd->u.lmv;
- u32 mds = 0;
- int rc;
- ENTRY;
-
- LASSERT(op_data != NULL);
- LASSERT(fid != NULL);
-
- rc = lmv_placement_policy(obd, op_data, &mds);
- if (rc) {
- CERROR("Can't get target for allocating fid, "
- "rc %d\n", rc);
- RETURN(rc);
- }
-
- rc = __lmv_fid_alloc(lmv, fid, mds);
- if (rc) {
- CERROR("Can't alloc new fid, rc %d\n", rc);
- RETURN(rc);
- }
-
- RETURN(rc);
-}
-
-static int lmv_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
-{
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_desc *desc;
- int rc;
- ENTRY;
-
- if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1) {
- CERROR("LMV setup requires a descriptor\n");
- RETURN(-EINVAL);
- }
-
- desc = (struct lmv_desc *)lustre_cfg_buf(lcfg, 1);
- if (sizeof(*desc) > LUSTRE_CFG_BUFLEN(lcfg, 1)) {
- CERROR("Lmv descriptor size wrong: %d > %d\n",
- (int)sizeof(*desc), LUSTRE_CFG_BUFLEN(lcfg, 1));
- RETURN(-EINVAL);
- }
-
- lmv->tgts_size = 32U;
- OBD_ALLOC(lmv->tgts, sizeof(*lmv->tgts) * lmv->tgts_size);
- if (lmv->tgts == NULL)
- RETURN(-ENOMEM);
-
- obd_str2uuid(&lmv->desc.ld_uuid, desc->ld_uuid.uuid);
- lmv->desc.ld_tgt_count = 0;
- lmv->desc.ld_active_tgt_count = 0;
- lmv->max_def_easize = 0;
- lmv->max_easize = 0;
- lmv->lmv_placement = PLACEMENT_CHAR_POLICY;
-
- spin_lock_init(&lmv->lmv_lock);
- mutex_init(&lmv->lmv_init_mutex);
-
-#ifdef CONFIG_PROC_FS
- obd->obd_vars = lprocfs_lmv_obd_vars;
- lprocfs_obd_setup(obd);
- lprocfs_alloc_md_stats(obd, 0);
- rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd",
- 0444, &lmv_proc_target_fops, obd);
+ rc = lmv_tunables_init(obd);
if (rc)
- CWARN("%s: error adding LMV target_obd file: rc = %d\n",
+ CWARN("%s: error adding LMV sysfs/debugfs files: rc = %d\n",
obd->obd_name, rc);
-#endif
+
rc = fld_client_init(&lmv->lmv_fld, obd->obd_name,
LUSTRE_CLI_FLD_HASH_DHT);
- if (rc) {
+ if (rc)
CERROR("Can't init FLD, err %d\n", rc);
- GOTO(out, rc);
- }
- RETURN(0);
+ rc = lu_tgt_descs_init(&lmv->lmv_mdt_descs, true);
+ if (rc)
+ CWARN("%s: error initialize target table: rc = %d\n",
+ obd->obd_name, rc);
-out:
- return rc;
+ RETURN(rc);
}
static int lmv_cleanup(struct obd_device *obd)
{
- struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lu_tgt_desc *tgt;
+ struct lu_tgt_desc *tmp;
+
ENTRY;
fld_client_fini(&lmv->lmv_fld);
- if (lmv->tgts != NULL) {
- int i;
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- if (lmv->tgts[i] == NULL)
- continue;
- lmv_del_target(lmv, i);
- }
- OBD_FREE(lmv->tgts, sizeof(*lmv->tgts) * lmv->tgts_size);
- lmv->tgts_size = 0;
- }
+ lmv_foreach_tgt_safe(lmv, tgt, tmp)
+ lmv_del_target(lmv, tgt);
+ lu_tgt_descs_fini(&lmv->lmv_mdt_descs);
+
RETURN(0);
}
RETURN(rc);
}
+static int lmv_select_statfs_mdt(struct lmv_obd *lmv, __u32 flags)
+{
+ int i;
+
+ if (flags & OBD_STATFS_FOR_MDT0)
+ return 0;
+
+ if (lmv->lmv_statfs_start || lmv->lmv_mdt_count == 1)
+ return lmv->lmv_statfs_start;
+
+ /* choose initial MDT for this client */
+ for (i = 0;; i++) {
+ struct lnet_process_id lnet_id;
+ if (LNetGetId(i, &lnet_id) == -ENOENT)
+ break;
+
+ if (LNET_NETTYP(LNET_NIDNET(lnet_id.nid)) != LOLND) {
+ /* We dont need a full 64-bit modulus, just enough
+ * to distribute the requests across MDTs evenly.
+ */
+ lmv->lmv_statfs_start = (u32)lnet_id.nid %
+ lmv->lmv_mdt_count;
+ break;
+ }
+ }
+
+ return lmv->lmv_statfs_start;
+}
+
static int lmv_statfs(const struct lu_env *env, struct obd_export *exp,
- struct obd_statfs *osfs, __u64 max_age, __u32 flags)
+ struct obd_statfs *osfs, time64_t max_age, __u32 flags)
{
- struct obd_device *obd = class_exp2obd(exp);
- struct lmv_obd *lmv = &obd->u.lmv;
- struct obd_statfs *temp;
- int rc = 0;
- __u32 i;
+ struct obd_device *obd = class_exp2obd(exp);
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct obd_statfs *temp;
+ struct lu_tgt_desc *tgt;
+ __u32 i;
+ __u32 idx;
+ int rc = 0;
+
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ OBD_ALLOC(temp, sizeof(*temp));
+ if (temp == NULL)
+ RETURN(-ENOMEM);
- OBD_ALLOC(temp, sizeof(*temp));
- if (temp == NULL)
- RETURN(-ENOMEM);
+ /* distribute statfs among MDTs */
+ idx = lmv_select_statfs_mdt(lmv, flags);
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- if (lmv->tgts[i] == NULL || lmv->tgts[i]->ltd_exp == NULL)
+ for (i = 0; i < lmv->lmv_mdt_descs.ltd_tgts_size; i++, idx++) {
+ idx = idx % lmv->lmv_mdt_descs.ltd_tgts_size;
+ tgt = lmv_tgt(lmv, idx);
+ if (!tgt || !tgt->ltd_exp)
continue;
- rc = obd_statfs(env, lmv->tgts[i]->ltd_exp, temp,
- max_age, flags);
+ rc = obd_statfs(env, tgt->ltd_exp, temp, max_age, flags);
if (rc) {
- CERROR("can't stat MDS #%d (%s), error %d\n", i,
- lmv->tgts[i]->ltd_exp->exp_obd->obd_name,
- rc);
+ CERROR("%s: can't stat MDS #%d: rc = %d\n",
+ tgt->ltd_exp->exp_obd->obd_name, i, rc);
GOTO(out_free_temp, rc);
}
+ if (temp->os_state & OS_STATE_SUM ||
+ flags == OBD_STATFS_FOR_MDT0) {
+ /* reset to the last aggregated values
+ * and don't sum with non-aggrated data */
+ /* If the statfs is from mount, it needs to retrieve
+ * necessary information from MDT0. i.e. mount does
+ * not need the merged osfs from all of MDT. Also
+ * clients can be mounted as long as MDT0 is in
+ * service */
+ *osfs = *temp;
+ break;
+ }
+
if (i == 0) {
*osfs = *temp;
- /* If the statfs is from mount, it will needs
- * retrieve necessary information from MDT0.
- * i.e. mount does not need the merged osfs
- * from all of MDT.
- * And also clients can be mounted as long as
- * MDT0 is in service*/
- if (flags & OBD_STATFS_FOR_MDT0)
- GOTO(out_free_temp, rc);
- } else {
- osfs->os_bavail += temp->os_bavail;
- osfs->os_blocks += temp->os_blocks;
- osfs->os_ffree += temp->os_ffree;
- osfs->os_files += temp->os_files;
- }
- }
+ } else {
+ osfs->os_bavail += temp->os_bavail;
+ osfs->os_blocks += temp->os_blocks;
+ osfs->os_ffree += temp->os_ffree;
+ osfs->os_files += temp->os_files;
+ osfs->os_granted += temp->os_granted;
+ }
+ }
- EXIT;
+ EXIT;
out_free_temp:
- OBD_FREE(temp, sizeof(*temp));
- return rc;
+ OBD_FREE(temp, sizeof(*temp));
+ return rc;
}
-static int lmv_getstatus(struct obd_export *exp, struct lu_fid *fid)
+static int lmv_statfs_update(void *cookie, int rc)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- int rc;
- ENTRY;
+ struct obd_info *oinfo = cookie;
+ struct obd_device *obd = oinfo->oi_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt = oinfo->oi_tgt;
+ struct obd_statfs *osfs = oinfo->oi_osfs;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ /*
+ * NB: don't deactivate TGT upon error, because we may not trigger async
+ * statfs any longer, then there is no chance to activate TGT.
+ */
+ if (!rc) {
+ spin_lock(&lmv->lmv_lock);
+ tgt->ltd_statfs = *osfs;
+ tgt->ltd_statfs_age = ktime_get_seconds();
+ spin_unlock(&lmv->lmv_lock);
+ lmv->lmv_qos.lq_dirty = 1;
+ }
+
+ return rc;
+}
+
+/* update tgt statfs async if it's ld_qos_maxage old */
+int lmv_statfs_check_update(struct obd_device *obd, struct lmv_tgt_desc *tgt)
+{
+ struct obd_info oinfo = {
+ .oi_obd = obd,
+ .oi_tgt = tgt,
+ .oi_cb_up = lmv_statfs_update,
+ };
+ int rc;
+
+ if (ktime_get_seconds() - tgt->ltd_statfs_age <
+ obd->u.lmv.lmv_mdt_descs.ltd_lmv_desc.ld_qos_maxage)
+ return 0;
- rc = md_getstatus(lmv->tgts[0]->ltd_exp, fid);
+ rc = obd_statfs_async(tgt->ltd_exp, &oinfo, 0, NULL);
+
+ return rc;
+}
+
+static int lmv_get_root(struct obd_export *exp, const char *fileset,
+ struct lu_fid *fid)
+{
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lu_tgt_desc *tgt = lmv_tgt(lmv, 0);
+ int rc;
+
+ ENTRY;
+
+ if (!tgt)
+ RETURN(-ENODEV);
+
+ rc = md_get_root(tgt->ltd_exp, fileset, fid);
RETURN(rc);
}
static int lmv_getxattr(struct obd_export *exp, const struct lu_fid *fid,
- u64 valid, const char *name,
- const char *input, int input_size, int output_size,
- int flags, struct ptlrpc_request **request)
+ u64 obd_md_valid, const char *name, size_t buf_size,
+ struct ptlrpc_request **req)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int rc;
- ENTRY;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- tgt = lmv_find_target(lmv, fid);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ tgt = lmv_fid2tgt(lmv, fid);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
- rc = md_getxattr(tgt->ltd_exp, fid, valid, name, input,
- input_size, output_size, flags, request);
+ rc = md_getxattr(tgt->ltd_exp, fid, obd_md_valid, name, buf_size, req);
RETURN(rc);
}
static int lmv_setxattr(struct obd_export *exp, const struct lu_fid *fid,
- u64 valid, const char *name,
- const char *input, int input_size, int output_size,
- int flags, __u32 suppgid,
- struct ptlrpc_request **request)
-{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int rc;
- ENTRY;
+ u64 obd_md_valid, const char *name,
+ const void *value, size_t value_size,
+ unsigned int xattr_flags, u32 suppgid,
+ struct ptlrpc_request **req)
+{
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- tgt = lmv_find_target(lmv, fid);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ tgt = lmv_fid2tgt(lmv, fid);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
- rc = md_setxattr(tgt->ltd_exp, fid, valid, name, input,
- input_size, output_size, flags, suppgid,
- request);
+ rc = md_setxattr(tgt->ltd_exp, fid, obd_md_valid, name,
+ value, value_size, xattr_flags, suppgid, req);
RETURN(rc);
}
static int lmv_getattr(struct obd_export *exp, struct md_op_data *op_data,
- struct ptlrpc_request **request)
+ struct ptlrpc_request **request)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int rc;
- ENTRY;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- tgt = lmv_find_target(lmv, &op_data->op_fid1);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ tgt = lmv_fid2tgt(lmv, &op_data->op_fid1);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
if (op_data->op_flags & MF_GET_MDT_IDX) {
- op_data->op_mds = tgt->ltd_idx;
+ op_data->op_mds = tgt->ltd_index;
RETURN(0);
}
- rc = md_getattr(tgt->ltd_exp, op_data, request);
+ rc = md_getattr(tgt->ltd_exp, op_data, request);
- RETURN(rc);
+ RETURN(rc);
}
static int lmv_null_inode(struct obd_export *exp, const struct lu_fid *fid)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- __u32 i;
- int rc;
- ENTRY;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lu_tgt_desc *tgt;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- CDEBUG(D_INODE, "CBDATA for "DFID"\n", PFID(fid));
+ CDEBUG(D_INODE, "CBDATA for "DFID"\n", PFID(fid));
/*
* With DNE every object can have two locks in different namespaces:
* lookup lock in space of MDT storing direntry and update/open lock in
* space of MDT storing inode.
*/
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- if (lmv->tgts[i] == NULL || lmv->tgts[i]->ltd_exp == NULL)
- continue;
- md_null_inode(lmv->tgts[i]->ltd_exp, fid);
- }
+ lmv_foreach_connected_tgt(lmv, tgt)
+ md_null_inode(tgt->ltd_exp, fid);
RETURN(0);
}
-static int lmv_find_cbdata(struct obd_export *exp, const struct lu_fid *fid,
- ldlm_iterator_t it, void *data)
+static int lmv_close(struct obd_export *exp, struct md_op_data *op_data,
+ struct md_open_data *mod, struct ptlrpc_request **request)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- int i;
- int tgt;
- int rc;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
+
ENTRY;
- rc = lmv_check_connect(obd);
+ tgt = lmv_fid2tgt(lmv, &op_data->op_fid1);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
+
+ CDEBUG(D_INODE, "CLOSE "DFID"\n", PFID(&op_data->op_fid1));
+ rc = md_close(tgt->ltd_exp, op_data, mod, request);
+ RETURN(rc);
+}
+
+static struct lu_tgt_desc *lmv_locate_tgt_qos(struct lmv_obd *lmv, __u32 *mdt)
+{
+ struct lu_tgt_desc *tgt;
+ __u64 total_weight = 0;
+ __u64 cur_weight = 0;
+ __u64 rand;
+ int rc;
+
+ ENTRY;
+
+ if (!ltd_qos_is_usable(&lmv->lmv_mdt_descs))
+ RETURN(ERR_PTR(-EAGAIN));
+
+ down_write(&lmv->lmv_qos.lq_rw_sem);
+
+ if (!ltd_qos_is_usable(&lmv->lmv_mdt_descs))
+ GOTO(unlock, tgt = ERR_PTR(-EAGAIN));
+
+ rc = ltd_qos_penalties_calc(&lmv->lmv_mdt_descs);
if (rc)
- RETURN(rc);
+ GOTO(unlock, tgt = ERR_PTR(rc));
- CDEBUG(D_INODE, "CBDATA for "DFID"\n", PFID(fid));
+ lmv_foreach_tgt(lmv, tgt) {
+ tgt->ltd_qos.ltq_usable = 0;
+ if (!tgt->ltd_exp || !tgt->ltd_active)
+ continue;
- /*
- * With DNE every object can have two locks in different namespaces:
- * lookup lock in space of MDT storing direntry and update/open lock in
- * space of MDT storing inode. Try the MDT that the FID maps to first,
- * since this can be easily found, and only try others if that fails.
- */
- for (i = 0, tgt = lmv_find_target_index(lmv, fid);
- i < lmv->desc.ld_tgt_count;
- i++, tgt = (tgt + 1) % lmv->desc.ld_tgt_count) {
- if (tgt < 0) {
- CDEBUG(D_HA, "%s: "DFID" is inaccessible: rc = %d\n",
- obd->obd_name, PFID(fid), tgt);
- tgt = 0;
- }
+ tgt->ltd_qos.ltq_usable = 1;
+ lu_tgt_qos_weight_calc(tgt);
+ total_weight += tgt->ltd_qos.ltq_weight;
+ }
+
+ rand = lu_prandom_u64_max(total_weight);
- if (lmv->tgts[tgt] == NULL ||
- lmv->tgts[tgt]->ltd_exp == NULL)
+ lmv_foreach_connected_tgt(lmv, tgt) {
+ if (!tgt->ltd_qos.ltq_usable)
continue;
- rc = md_find_cbdata(lmv->tgts[tgt]->ltd_exp, fid, it, data);
- if (rc)
- RETURN(rc);
+ cur_weight += tgt->ltd_qos.ltq_weight;
+ if (cur_weight < rand)
+ continue;
+
+ *mdt = tgt->ltd_index;
+ ltd_qos_update(&lmv->lmv_mdt_descs, tgt, &total_weight);
+ GOTO(unlock, rc = 0);
}
- RETURN(rc);
-}
+ /* no proper target found */
+ GOTO(unlock, tgt = ERR_PTR(-EAGAIN));
+unlock:
+ up_write(&lmv->lmv_qos.lq_rw_sem);
+ return tgt;
+}
-static int lmv_close(struct obd_export *exp, struct md_op_data *op_data,
- struct md_open_data *mod, struct ptlrpc_request **request)
+static struct lu_tgt_desc *lmv_locate_tgt_rr(struct lmv_obd *lmv, __u32 *mdt)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int rc;
- ENTRY;
+ struct lu_tgt_desc *tgt;
+ int i;
+ int index;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- tgt = lmv_find_target(lmv, &op_data->op_fid1);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ spin_lock(&lmv->lmv_qos.lq_rr.lqr_alloc);
+ for (i = 0; i < lmv->lmv_mdt_descs.ltd_tgts_size; i++) {
+ index = (i + lmv->lmv_qos_rr_index) %
+ lmv->lmv_mdt_descs.ltd_tgts_size;
+ tgt = lmv_tgt(lmv, index);
+ if (!tgt || !tgt->ltd_exp || !tgt->ltd_active)
+ continue;
+
+ *mdt = tgt->ltd_index;
+ lmv->lmv_qos_rr_index = (*mdt + 1) %
+ lmv->lmv_mdt_descs.ltd_tgts_size;
+ spin_unlock(&lmv->lmv_qos.lq_rr.lqr_alloc);
- CDEBUG(D_INODE, "CLOSE "DFID"\n", PFID(&op_data->op_fid1));
- rc = md_close(tgt->ltd_exp, op_data, mod, request);
- RETURN(rc);
+ RETURN(tgt);
+ }
+ spin_unlock(&lmv->lmv_qos.lq_rr.lqr_alloc);
+
+ RETURN(ERR_PTR(-ENODEV));
}
-/**
- * Choosing the MDT by name or FID in @op_data.
- * For non-striped directory, it will locate MDT by fid.
- * For striped-directory, it will locate MDT by name. And also
- * it will reset op_fid1 with the FID of the choosen stripe.
- **/
-struct lmv_tgt_desc *
-lmv_locate_target_for_name(struct lmv_obd *lmv, struct lmv_stripe_md *lsm,
- const char *name, int namelen, struct lu_fid *fid,
- u32 *mds)
+static struct lmv_tgt_desc *
+lmv_locate_tgt_by_name(struct lmv_obd *lmv, struct lmv_stripe_md *lsm,
+ const char *name, int namelen, struct lu_fid *fid,
+ __u32 *mds, bool post_migrate)
{
- struct lmv_tgt_desc *tgt;
- const struct lmv_oinfo *oinfo;
+ struct lmv_tgt_desc *tgt;
+ const struct lmv_oinfo *oinfo;
+
+ if (!lmv_dir_striped(lsm) || !namelen) {
+ tgt = lmv_fid2tgt(lmv, fid);
+ if (IS_ERR(tgt))
+ return tgt;
+
+ *mds = tgt->ltd_index;
+ return tgt;
+ }
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_NAME_HASH)) {
if (cfs_fail_val >= lsm->lsm_md_stripe_count)
- RETURN(ERR_PTR(-EBADF));
+ return ERR_PTR(-EBADF);
oinfo = &lsm->lsm_md_oinfo[cfs_fail_val];
} else {
- oinfo = lsm_name_to_stripe_info(lsm, name, namelen);
+ oinfo = lsm_name_to_stripe_info(lsm, name, namelen,
+ post_migrate);
if (IS_ERR(oinfo))
- RETURN(ERR_CAST(oinfo));
+ return ERR_CAST(oinfo);
}
- if (fid != NULL)
- *fid = oinfo->lmo_fid;
- if (mds != NULL)
- *mds = oinfo->lmo_mds;
+ *fid = oinfo->lmo_fid;
+ *mds = oinfo->lmo_mds;
+ tgt = lmv_tgt(lmv, oinfo->lmo_mds);
- tgt = lmv_get_target(lmv, oinfo->lmo_mds, NULL);
+ CDEBUG(D_INODE, "locate MDT %u parent "DFID"\n", *mds, PFID(fid));
- CDEBUG(D_INFO, "locate on mds %u "DFID"\n", oinfo->lmo_mds,
- PFID(&oinfo->lmo_fid));
- return tgt;
+ return tgt ? tgt : ERR_PTR(-ENODEV);
}
/**
- * Locate mds by fid or name
+ * Locate MDT of op_data->op_fid1
*
- * For striped directory (lsm != NULL), it will locate the stripe
- * by name hash (see lsm_name_to_stripe_info()). Note: if the hash_type
- * is unknown, it will return -EBADFD, and lmv_intent_lookup might need
- * walk through all of stripes to locate the entry.
+ * For striped directory, it will locate the stripe by name hash, if hash_type
+ * is unknown, it will return the stripe specified by 'op_data->op_stripe_index'
+ * which is set outside, and if dir is migrating, 'op_data->op_post_migrate'
+ * indicates whether old or new layout is used to locate.
+ *
+ * For plain direcotry, it just locate the MDT of op_data->op_fid1.
*
- * For normal direcotry, it will locate MDS by FID directly.
* \param[in] lmv LMV device
* \param[in] op_data client MD stack parameters, name, namelen
* mds_num etc.
- * \param[in] fid object FID used to locate MDS.
*
* retval pointer to the lmv_tgt_desc if succeed.
* ERR_PTR(errno) if failed.
*/
-struct lmv_tgt_desc*
-lmv_locate_mds(struct lmv_obd *lmv, struct md_op_data *op_data,
- struct lu_fid *fid)
+struct lmv_tgt_desc *
+lmv_locate_tgt(struct lmv_obd *lmv, struct md_op_data *op_data)
{
- struct lmv_stripe_md *lsm = op_data->op_mea1;
- struct lmv_tgt_desc *tgt;
+ struct lmv_stripe_md *lsm = op_data->op_mea1;
+ struct lmv_oinfo *oinfo;
+ struct lmv_tgt_desc *tgt;
+
+ if (lmv_dir_foreign(lsm))
+ return ERR_PTR(-ENODATA);
/* During creating VOLATILE file, it should honor the mdt
* index if the file under striped dir is being restored, see
* ct_restore(). */
if (op_data->op_bias & MDS_CREATE_VOLATILE &&
- (int)op_data->op_mds != -1) {
- int i;
- tgt = lmv_get_target(lmv, op_data->op_mds, NULL);
- if (IS_ERR(tgt))
- return tgt;
+ op_data->op_mds != LMV_OFFSET_DEFAULT) {
+ tgt = lmv_tgt(lmv, op_data->op_mds);
+ if (!tgt)
+ return ERR_PTR(-ENODEV);
+
+ if (lmv_dir_striped(lsm)) {
+ int i;
- if (lsm != NULL) {
/* refill the right parent fid */
for (i = 0; i < lsm->lsm_md_stripe_count; i++) {
- struct lmv_oinfo *oinfo;
-
oinfo = &lsm->lsm_md_oinfo[i];
if (oinfo->lmo_mds == op_data->op_mds) {
- *fid = oinfo->lmo_fid;
+ op_data->op_fid1 = oinfo->lmo_fid;
break;
}
}
if (i == lsm->lsm_md_stripe_count)
- *fid = lsm->lsm_md_oinfo[0].lmo_fid;
+ op_data->op_fid1 = lsm->lsm_md_oinfo[0].lmo_fid;
}
+ } else if (lmv_dir_bad_hash(lsm)) {
+ LASSERT(op_data->op_stripe_index < lsm->lsm_md_stripe_count);
+ oinfo = &lsm->lsm_md_oinfo[op_data->op_stripe_index];
- return tgt;
+ op_data->op_fid1 = oinfo->lmo_fid;
+ op_data->op_mds = oinfo->lmo_mds;
+ tgt = lmv_tgt(lmv, oinfo->lmo_mds);
+ if (!tgt)
+ return ERR_PTR(-ENODEV);
+ } else {
+ tgt = lmv_locate_tgt_by_name(lmv, op_data->op_mea1,
+ op_data->op_name, op_data->op_namelen,
+ &op_data->op_fid1, &op_data->op_mds,
+ op_data->op_post_migrate);
}
- if (lsm == NULL || op_data->op_namelen == 0) {
- tgt = lmv_find_target(lmv, fid);
+ return tgt;
+}
+
+/* Locate MDT of op_data->op_fid2 for link/rename */
+static struct lmv_tgt_desc *
+lmv_locate_tgt2(struct lmv_obd *lmv, struct md_op_data *op_data)
+{
+ struct lmv_tgt_desc *tgt;
+ int rc;
+
+ LASSERT(op_data->op_name);
+ if (lmv_dir_migrating(op_data->op_mea2)) {
+ struct lu_fid fid1 = op_data->op_fid1;
+ struct lmv_stripe_md *lsm1 = op_data->op_mea1;
+ struct ptlrpc_request *request = NULL;
+
+ /*
+ * avoid creating new file under old layout of migrating
+ * directory, check it here.
+ */
+ tgt = lmv_locate_tgt_by_name(lmv, op_data->op_mea2,
+ op_data->op_name, op_data->op_namelen,
+ &op_data->op_fid2, &op_data->op_mds, false);
if (IS_ERR(tgt))
- return tgt;
+ RETURN(tgt);
+
+ op_data->op_fid1 = op_data->op_fid2;
+ op_data->op_mea1 = op_data->op_mea2;
+ rc = md_getattr_name(tgt->ltd_exp, op_data, &request);
+ op_data->op_fid1 = fid1;
+ op_data->op_mea1 = lsm1;
+ if (!rc) {
+ ptlrpc_req_finished(request);
+ RETURN(ERR_PTR(-EEXIST));
+ }
- op_data->op_mds = tgt->ltd_idx;
- return tgt;
+ if (rc != -ENOENT)
+ RETURN(ERR_PTR(rc));
+ }
+
+ return lmv_locate_tgt_by_name(lmv, op_data->op_mea2, op_data->op_name,
+ op_data->op_namelen, &op_data->op_fid2,
+ &op_data->op_mds, true);
+}
+
+int lmv_migrate_existence_check(struct lmv_obd *lmv, struct md_op_data *op_data)
+{
+ struct lu_tgt_desc *tgt;
+ struct ptlrpc_request *request;
+ int rc;
+
+ LASSERT(lmv_dir_migrating(op_data->op_mea1));
+
+ tgt = lmv_locate_tgt(lmv, op_data);
+ if (IS_ERR(tgt))
+ return PTR_ERR(tgt);
+
+ rc = md_getattr_name(tgt->ltd_exp, op_data, &request);
+ if (!rc) {
+ ptlrpc_req_finished(request);
+ return -EEXIST;
}
- return lmv_locate_target_for_name(lmv, lsm, op_data->op_name,
- op_data->op_namelen, fid,
- &op_data->op_mds);
+ return rc;
+}
+
+/* mkdir by QoS in two cases:
+ * 1. 'lfs mkdir -i -1'
+ * 2. parent default LMV master_mdt_index is -1
+ *
+ * NB, mkdir by QoS only if parent is not striped, this is to avoid remote
+ * directories under striped directory.
+ */
+static inline bool lmv_op_qos_mkdir(const struct md_op_data *op_data)
+{
+ const struct lmv_stripe_md *lsm = op_data->op_default_mea1;
+ const struct lmv_user_md *lum = op_data->op_data;
+
+ if (op_data->op_code != LUSTRE_OPC_MKDIR)
+ return false;
+
+ if (lmv_dir_striped(op_data->op_mea1))
+ return false;
+
+ if (op_data->op_cli_flags & CLI_SET_MEA && lum &&
+ (le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC ||
+ le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC_SPECIFIC) &&
+ le32_to_cpu(lum->lum_stripe_offset) == LMV_OFFSET_DEFAULT)
+ return true;
+
+ if (lsm && lsm->lsm_md_master_mdt_index == LMV_OFFSET_DEFAULT)
+ return true;
+
+ return false;
}
+/* 'lfs mkdir -i <specific_MDT>' */
+static inline bool lmv_op_user_specific_mkdir(const struct md_op_data *op_data)
+{
+ const struct lmv_user_md *lum = op_data->op_data;
+
+ return op_data->op_code == LUSTRE_OPC_MKDIR &&
+ op_data->op_cli_flags & CLI_SET_MEA && lum &&
+ (le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC ||
+ le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC_SPECIFIC) &&
+ le32_to_cpu(lum->lum_stripe_offset) != LMV_OFFSET_DEFAULT;
+}
+
+/* parent default LMV master_mdt_index is not -1. */
+static inline bool
+lmv_op_default_specific_mkdir(const struct md_op_data *op_data)
+{
+ return op_data->op_code == LUSTRE_OPC_MKDIR &&
+ op_data->op_default_mea1 &&
+ op_data->op_default_mea1->lsm_md_master_mdt_index !=
+ LMV_OFFSET_DEFAULT;
+}
int lmv_create(struct obd_export *exp, struct md_op_data *op_data,
const void *data, size_t datalen, umode_t mode, uid_t uid,
gid_t gid, cfs_cap_t cap_effective, __u64 rdev,
struct ptlrpc_request **request)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int rc;
- ENTRY;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- if (!lmv->desc.ld_active_tgt_count)
+ if (!lmv->lmv_mdt_descs.ltd_lmv_desc.ld_active_tgt_count)
RETURN(-EIO);
- tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
+ if (lmv_dir_bad_hash(op_data->op_mea1))
+ RETURN(-EBADF);
+
+ if (lmv_dir_migrating(op_data->op_mea1)) {
+ /*
+ * if parent is migrating, create() needs to lookup existing
+ * name in both old and new layout, check old layout on client.
+ */
+ rc = lmv_migrate_existence_check(lmv, op_data);
+ if (rc != -ENOENT)
+ RETURN(rc);
+
+ op_data->op_post_migrate = true;
+ }
+
+ tgt = lmv_locate_tgt(lmv, op_data);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
- CDEBUG(D_INODE, "CREATE name '%.*s' on "DFID" -> mds #%x\n",
- (int)op_data->op_namelen, op_data->op_name,
- PFID(&op_data->op_fid1), op_data->op_mds);
+ if (lmv_op_qos_mkdir(op_data)) {
+ tgt = lmv_locate_tgt_qos(lmv, &op_data->op_mds);
+ if (tgt == ERR_PTR(-EAGAIN))
+ tgt = lmv_locate_tgt_rr(lmv, &op_data->op_mds);
+ /*
+ * only update statfs after QoS mkdir, this means the cached
+ * statfs may be stale, and current mkdir may not follow QoS
+ * accurately, but it's not serious, and avoids periodic statfs
+ * when client doesn't mkdir by QoS.
+ */
+ if (!IS_ERR(tgt))
+ lmv_statfs_check_update(obd, tgt);
+ } else if (lmv_op_user_specific_mkdir(op_data)) {
+ struct lmv_user_md *lum = op_data->op_data;
+
+ op_data->op_mds = le32_to_cpu(lum->lum_stripe_offset);
+ tgt = lmv_tgt(lmv, op_data->op_mds);
+ if (!tgt)
+ RETURN(-ENODEV);
+ } else if (lmv_op_default_specific_mkdir(op_data)) {
+ op_data->op_mds =
+ op_data->op_default_mea1->lsm_md_master_mdt_index;
+ tgt = lmv_tgt(lmv, op_data->op_mds);
+ if (!tgt)
+ RETURN(-ENODEV);
+ }
+
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
rc = lmv_fid_alloc(NULL, exp, &op_data->op_fid2, op_data);
if (rc)
RETURN(rc);
- if (exp_connect_flags(exp) & OBD_CONNECT_DIR_STRIPE) {
- /* Send the create request to the MDT where the object
- * will be located */
- tgt = lmv_find_target(lmv, &op_data->op_fid2);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
- op_data->op_mds = tgt->ltd_idx;
- } else {
- CDEBUG(D_CONFIG, "Server doesn't support striped dirs\n");
- }
-
- CDEBUG(D_INODE, "CREATE obj "DFID" -> mds #%x\n",
- PFID(&op_data->op_fid2), op_data->op_mds);
+ CDEBUG(D_INODE, "CREATE name '%.*s' "DFID" on "DFID" -> mds #%x\n",
+ (int)op_data->op_namelen, op_data->op_name,
+ PFID(&op_data->op_fid2), PFID(&op_data->op_fid1),
+ op_data->op_mds);
op_data->op_flags |= MF_MDC_CANCEL_FID1;
rc = md_create(tgt->ltd_exp, op_data, data, datalen, mode, uid, gid,
static int
lmv_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo,
- const union ldlm_policy_data *policy,
- struct lookup_intent *it, struct md_op_data *op_data,
+ const union ldlm_policy_data *policy, struct md_op_data *op_data,
struct lustre_handle *lockh, __u64 extra_lock_flags)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int rc;
- ENTRY;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- CDEBUG(D_INODE, "ENQUEUE '%s' on "DFID"\n",
- LL_IT2STR(it), PFID(&op_data->op_fid1));
+ CDEBUG(D_INODE, "ENQUEUE on "DFID"\n", PFID(&op_data->op_fid1));
- tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
+ tgt = lmv_fid2tgt(lmv, &op_data->op_fid1);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
- CDEBUG(D_INODE, "ENQUEUE '%s' on "DFID" -> mds #%u\n",
- LL_IT2STR(it), PFID(&op_data->op_fid1), tgt->ltd_idx);
+ CDEBUG(D_INODE, "ENQUEUE on "DFID" -> mds #%u\n",
+ PFID(&op_data->op_fid1), tgt->ltd_index);
- rc = md_enqueue(tgt->ltd_exp, einfo, policy, it, op_data, lockh,
+ rc = md_enqueue(tgt->ltd_exp, einfo, policy, op_data, lockh,
extra_lock_flags);
RETURN(rc);
}
-static int
-lmv_getattr_name(struct obd_export *exp,struct md_op_data *op_data,
- struct ptlrpc_request **preq)
-{
- struct ptlrpc_request *req = NULL;
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- struct mdt_body *body;
- int rc;
- ENTRY;
-
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+int
+lmv_getattr_name(struct obd_export *exp,struct md_op_data *op_data,
+ struct ptlrpc_request **preq)
+{
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ struct mdt_body *body;
+ int rc;
+
+ ENTRY;
- tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
+retry:
+ tgt = lmv_locate_tgt(lmv, op_data);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
CDEBUG(D_INODE, "GETATTR_NAME for %*s on "DFID" -> mds #%d\n",
(int)op_data->op_namelen, op_data->op_name,
- PFID(&op_data->op_fid1), tgt->ltd_idx);
+ PFID(&op_data->op_fid1), tgt->ltd_index);
rc = md_getattr_name(tgt->ltd_exp, op_data, preq);
- if (rc != 0)
+ if (rc == -ENOENT && lmv_dir_retry_check_update(op_data)) {
+ ptlrpc_req_finished(*preq);
+ *preq = NULL;
+ goto retry;
+ }
+
+ if (rc)
RETURN(rc);
body = req_capsule_server_get(&(*preq)->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
if (body->mbo_valid & OBD_MD_MDS) {
- struct lu_fid rid = body->mbo_fid1;
- CDEBUG(D_INODE, "Request attrs for "DFID"\n",
- PFID(&rid));
-
- tgt = lmv_find_target(lmv, &rid);
- if (IS_ERR(tgt)) {
- ptlrpc_req_finished(*preq);
- preq = NULL;
- RETURN(PTR_ERR(tgt));
- }
-
- op_data->op_fid1 = rid;
+ op_data->op_fid1 = body->mbo_fid1;
op_data->op_valid |= OBD_MD_FLCROSSREF;
op_data->op_namelen = 0;
op_data->op_name = NULL;
- rc = md_getattr_name(tgt->ltd_exp, op_data, &req);
+
ptlrpc_req_finished(*preq);
- *preq = req;
+ *preq = NULL;
+
+ goto retry;
}
RETURN(rc);
RETURN(0);
if (tgt == NULL) {
- tgt = lmv_find_target(lmv, fid);
+ tgt = lmv_fid2tgt(lmv, fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
}
- if (tgt->ltd_idx != op_tgt) {
+ if (tgt->ltd_index != op_tgt) {
CDEBUG(D_INODE, "EARLY_CANCEL on "DFID"\n", PFID(fid));
policy.l_inodebits.bits = bits;
rc = md_cancel_unused(tgt->ltd_exp, fid, &policy,
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
LASSERT(op_data->op_namelen != 0);
CDEBUG(D_INODE, "LINK "DFID":%*s to "DFID"\n",
op_data->op_fsuid = from_kuid(&init_user_ns, current_fsuid());
op_data->op_fsgid = from_kgid(&init_user_ns, current_fsgid());
op_data->op_cap = cfs_curproc_cap_pack();
- if (op_data->op_mea2 != NULL) {
- struct lmv_stripe_md *lsm = op_data->op_mea2;
- const struct lmv_oinfo *oinfo;
-
- oinfo = lsm_name_to_stripe_info(lsm, op_data->op_name,
- op_data->op_namelen);
- if (IS_ERR(oinfo))
- RETURN(PTR_ERR(oinfo));
-
- op_data->op_fid2 = oinfo->lmo_fid;
- }
- tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid2);
+ tgt = lmv_locate_tgt2(lmv, op_data);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
* Cancel UPDATE lock on child (fid1).
*/
op_data->op_flags |= MF_MDC_CANCEL_FID2;
- rc = lmv_early_cancel(exp, NULL, op_data, tgt->ltd_idx, LCK_EX,
+ rc = lmv_early_cancel(exp, NULL, op_data, tgt->ltd_index, LCK_EX,
MDS_INODELOCK_UPDATE, MF_MDC_CANCEL_FID1);
if (rc != 0)
RETURN(rc);
RETURN(rc);
}
-static int lmv_rename(struct obd_export *exp, struct md_op_data *op_data,
- const char *old, size_t oldlen,
- const char *new, size_t newlen,
- struct ptlrpc_request **request)
+static int lmv_migrate(struct obd_export *exp, struct md_op_data *op_data,
+ const char *name, size_t namelen,
+ struct ptlrpc_request **request)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *src_tgt;
- struct lmv_tgt_desc *tgt_tgt;
- struct obd_export *target_exp;
- struct mdt_body *body;
- int rc;
- ENTRY;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_stripe_md *lsm = op_data->op_mea1;
+ struct lmv_tgt_desc *parent_tgt;
+ struct lmv_tgt_desc *sp_tgt;
+ struct lmv_tgt_desc *tp_tgt = NULL;
+ struct lmv_tgt_desc *child_tgt;
+ struct lmv_tgt_desc *tgt;
+ struct lu_fid target_fid;
+ int rc;
- LASSERT(oldlen != 0);
+ ENTRY;
- CDEBUG(D_INODE, "RENAME %.*s in "DFID":%d to %.*s in "DFID":%d\n",
- (int)oldlen, old, PFID(&op_data->op_fid1),
- op_data->op_mea1 ? op_data->op_mea1->lsm_md_stripe_count : 0,
- (int)newlen, new, PFID(&op_data->op_fid2),
- op_data->op_mea2 ? op_data->op_mea2->lsm_md_stripe_count : 0);
+ LASSERT(op_data->op_cli_flags & CLI_MIGRATE);
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ CDEBUG(D_INODE, "MIGRATE "DFID"/%.*s\n",
+ PFID(&op_data->op_fid1), (int)namelen, name);
op_data->op_fsuid = from_kuid(&init_user_ns, current_fsuid());
op_data->op_fsgid = from_kgid(&init_user_ns, current_fsgid());
op_data->op_cap = cfs_curproc_cap_pack();
- if (op_data->op_cli_flags & CLI_MIGRATE) {
- LASSERTF(fid_is_sane(&op_data->op_fid3), "invalid FID "DFID"\n",
- PFID(&op_data->op_fid3));
-
- if (op_data->op_mea1 != NULL) {
- struct lmv_stripe_md *lsm = op_data->op_mea1;
- struct lmv_tgt_desc *tmp;
-
- /* Fix the parent fid for striped dir */
- tmp = lmv_locate_target_for_name(lmv, lsm, old,
- oldlen,
- &op_data->op_fid1,
- NULL);
- if (IS_ERR(tmp))
- RETURN(PTR_ERR(tmp));
- }
-
- rc = lmv_fid_alloc(NULL, exp, &op_data->op_fid2, op_data);
- if (rc != 0)
- RETURN(rc);
- src_tgt = lmv_find_target(lmv, &op_data->op_fid3);
- if (IS_ERR(src_tgt))
- RETURN(PTR_ERR(src_tgt));
+ parent_tgt = lmv_fid2tgt(lmv, &op_data->op_fid1);
+ if (IS_ERR(parent_tgt))
+ RETURN(PTR_ERR(parent_tgt));
- target_exp = src_tgt->ltd_exp;
- } else {
- if (op_data->op_mea1 != NULL) {
- struct lmv_stripe_md *lsm = op_data->op_mea1;
+ if (lmv_dir_striped(lsm)) {
+ __u32 hash_type = lsm->lsm_md_hash_type;
+ __u32 stripe_count = lsm->lsm_md_stripe_count;
- src_tgt = lmv_locate_target_for_name(lmv, lsm, old,
- oldlen,
- &op_data->op_fid1,
- &op_data->op_mds);
- } else {
- src_tgt = lmv_find_target(lmv, &op_data->op_fid1);
+ /*
+ * old stripes are appended after new stripes for migrating
+ * directory.
+ */
+ if (lmv_dir_migrating(lsm)) {
+ hash_type = lsm->lsm_md_migrate_hash;
+ stripe_count -= lsm->lsm_md_migrate_offset;
}
- if (IS_ERR(src_tgt))
- RETURN(PTR_ERR(src_tgt));
+ rc = lmv_name_to_stripe_index(hash_type, stripe_count, name,
+ namelen);
+ if (rc < 0)
+ RETURN(rc);
- if (op_data->op_mea2 != NULL) {
- struct lmv_stripe_md *lsm = op_data->op_mea2;
+ if (lmv_dir_migrating(lsm))
+ rc += lsm->lsm_md_migrate_offset;
- tgt_tgt = lmv_locate_target_for_name(lmv, lsm, new,
- newlen,
- &op_data->op_fid2,
- &op_data->op_mds);
- } else {
- tgt_tgt = lmv_find_target(lmv, &op_data->op_fid2);
+ /* save it in fid4 temporarily for early cancel */
+ op_data->op_fid4 = lsm->lsm_md_oinfo[rc].lmo_fid;
+ sp_tgt = lmv_tgt(lmv, lsm->lsm_md_oinfo[rc].lmo_mds);
+ if (!sp_tgt)
+ RETURN(-ENODEV);
- }
- if (IS_ERR(tgt_tgt))
- RETURN(PTR_ERR(tgt_tgt));
+ /*
+ * if parent is being migrated too, fill op_fid2 with target
+ * stripe fid, otherwise the target stripe is not created yet.
+ */
+ if (lmv_dir_migrating(lsm)) {
+ hash_type = lsm->lsm_md_hash_type &
+ ~LMV_HASH_FLAG_MIGRATION;
+ stripe_count = lsm->lsm_md_migrate_offset;
+
+ rc = lmv_name_to_stripe_index(hash_type, stripe_count,
+ name, namelen);
+ if (rc < 0)
+ RETURN(rc);
- target_exp = tgt_tgt->ltd_exp;
+ op_data->op_fid2 = lsm->lsm_md_oinfo[rc].lmo_fid;
+ tp_tgt = lmv_tgt(lmv, lsm->lsm_md_oinfo[rc].lmo_mds);
+ if (!tp_tgt)
+ RETURN(-ENODEV);
+ }
+ } else {
+ sp_tgt = parent_tgt;
}
- /*
- * LOOKUP lock on src child (fid3) should also be cancelled for
- * src_tgt in mdc_rename.
- */
- op_data->op_flags |= MF_MDC_CANCEL_FID1 | MF_MDC_CANCEL_FID3;
+ child_tgt = lmv_fid2tgt(lmv, &op_data->op_fid3);
+ if (IS_ERR(child_tgt))
+ RETURN(PTR_ERR(child_tgt));
- /*
- * Cancel UPDATE locks on tgt parent (fid2), tgt_tgt is its
- * own target.
+ /* for directory, migrate to MDT specified by lum_stripe_offset;
+ * otherwise migrate to the target stripe of parent, but parent
+ * directory may have finished migration (normally current file too),
+ * allocate FID on MDT lum_stripe_offset, and server will check
+ * whether file was migrated already.
*/
- rc = lmv_early_cancel(exp, NULL, op_data, src_tgt->ltd_idx,
- LCK_EX, MDS_INODELOCK_UPDATE,
- MF_MDC_CANCEL_FID2);
+ if (S_ISDIR(op_data->op_mode) || !tp_tgt) {
+ struct lmv_user_md *lum = op_data->op_data;
- if (rc != 0)
+ op_data->op_mds = le32_to_cpu(lum->lum_stripe_offset);
+ } else {
+ op_data->op_mds = tp_tgt->ltd_index;
+ }
+ rc = lmv_fid_alloc(NULL, exp, &target_fid, op_data);
+ if (rc)
RETURN(rc);
+
/*
- * Cancel LOOKUP locks on source child (fid3) for parent tgt_tgt.
+ * for directory, send migrate request to the MDT where the object will
+ * be migrated to, because we can't create a striped directory remotely.
+ *
+ * otherwise, send to the MDT where source is located because regular
+ * file may open lease.
+ *
+ * NB. if MDT doesn't support DIR_MIGRATE, send to source MDT too for
+ * backward compatibility.
*/
- if (fid_is_sane(&op_data->op_fid3)) {
- struct lmv_tgt_desc *tgt;
-
- tgt = lmv_find_target(lmv, &op_data->op_fid1);
+ if (S_ISDIR(op_data->op_mode) &&
+ (exp_connect_flags2(exp) & OBD_CONNECT2_DIR_MIGRATE)) {
+ tgt = lmv_fid2tgt(lmv, &target_fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
+ } else {
+ tgt = child_tgt;
+ }
- /* Cancel LOOKUP lock on its parent */
- rc = lmv_early_cancel(exp, tgt, op_data, src_tgt->ltd_idx,
- LCK_EX, MDS_INODELOCK_LOOKUP,
- MF_MDC_CANCEL_FID3);
- if (rc != 0)
+ /* cancel UPDATE lock of parent master object */
+ rc = lmv_early_cancel(exp, parent_tgt, op_data, tgt->ltd_index, LCK_EX,
+ MDS_INODELOCK_UPDATE, MF_MDC_CANCEL_FID1);
+ if (rc)
+ RETURN(rc);
+
+ /* cancel UPDATE lock of source parent */
+ if (sp_tgt != parent_tgt) {
+ /*
+ * migrate RPC packs master object FID, because we can only pack
+ * two FIDs in reint RPC, but MDS needs to know both source
+ * parent and target parent, and it will obtain them from master
+ * FID and LMV, the other FID in RPC is kept for target.
+ *
+ * since this FID is not passed to MDC, cancel it anyway.
+ */
+ rc = lmv_early_cancel(exp, sp_tgt, op_data, -1, LCK_EX,
+ MDS_INODELOCK_UPDATE, MF_MDC_CANCEL_FID4);
+ if (rc)
RETURN(rc);
- rc = lmv_early_cancel(exp, NULL, op_data, src_tgt->ltd_idx,
- LCK_EX, MDS_INODELOCK_FULL,
+ op_data->op_flags &= ~MF_MDC_CANCEL_FID4;
+ }
+ op_data->op_fid4 = target_fid;
+
+ /* cancel UPDATE locks of target parent */
+ rc = lmv_early_cancel(exp, tp_tgt, op_data, tgt->ltd_index, LCK_EX,
+ MDS_INODELOCK_UPDATE, MF_MDC_CANCEL_FID2);
+ if (rc)
+ RETURN(rc);
+
+ /* cancel LOOKUP lock of source if source is remote object */
+ if (child_tgt != sp_tgt) {
+ rc = lmv_early_cancel(exp, sp_tgt, op_data, tgt->ltd_index,
+ LCK_EX, MDS_INODELOCK_LOOKUP,
MF_MDC_CANCEL_FID3);
- if (rc != 0)
+ if (rc)
RETURN(rc);
}
-retry_rename:
- /*
- * Cancel all the locks on tgt child (fid4).
- */
+ /* cancel ELC locks of source */
+ rc = lmv_early_cancel(exp, child_tgt, op_data, tgt->ltd_index, LCK_EX,
+ MDS_INODELOCK_ELC, MF_MDC_CANCEL_FID3);
+ if (rc)
+ RETURN(rc);
+
+ rc = md_rename(tgt->ltd_exp, op_data, name, namelen, NULL, 0, request);
+
+ RETURN(rc);
+}
+
+static int lmv_rename(struct obd_export *exp, struct md_op_data *op_data,
+ const char *old, size_t oldlen,
+ const char *new, size_t newlen,
+ struct ptlrpc_request **request)
+{
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *sp_tgt;
+ struct lmv_tgt_desc *tp_tgt = NULL;
+ struct lmv_tgt_desc *src_tgt = NULL;
+ struct lmv_tgt_desc *tgt;
+ struct mdt_body *body;
+ int rc;
+
+ ENTRY;
+
+ LASSERT(oldlen != 0);
+
+ if (op_data->op_cli_flags & CLI_MIGRATE) {
+ rc = lmv_migrate(exp, op_data, old, oldlen, request);
+ RETURN(rc);
+ }
+
+ op_data->op_fsuid = from_kuid(&init_user_ns, current_fsuid());
+ op_data->op_fsgid = from_kgid(&init_user_ns, current_fsgid());
+ op_data->op_cap = cfs_curproc_cap_pack();
+
+ op_data->op_name = new;
+ op_data->op_namelen = newlen;
+
+ tp_tgt = lmv_locate_tgt2(lmv, op_data);
+ if (IS_ERR(tp_tgt))
+ RETURN(PTR_ERR(tp_tgt));
+
+ /* Since the target child might be destroyed, and it might become
+ * orphan, and we can only check orphan on the local MDT right now, so
+ * we send rename request to the MDT where target child is located. If
+ * target child does not exist, then it will send the request to the
+ * target parent */
+ if (fid_is_sane(&op_data->op_fid4)) {
+ tgt = lmv_fid2tgt(lmv, &op_data->op_fid4);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
+ } else {
+ tgt = tp_tgt;
+ }
+
+ op_data->op_flags |= MF_MDC_CANCEL_FID4;
+
+ /* cancel UPDATE locks of target parent */
+ rc = lmv_early_cancel(exp, tp_tgt, op_data, tgt->ltd_index, LCK_EX,
+ MDS_INODELOCK_UPDATE, MF_MDC_CANCEL_FID2);
+ if (rc != 0)
+ RETURN(rc);
+
if (fid_is_sane(&op_data->op_fid4)) {
- struct lmv_tgt_desc *tgt;
+ /* cancel LOOKUP lock of target on target parent */
+ if (tgt != tp_tgt) {
+ rc = lmv_early_cancel(exp, tp_tgt, op_data,
+ tgt->ltd_index, LCK_EX,
+ MDS_INODELOCK_LOOKUP,
+ MF_MDC_CANCEL_FID4);
+ if (rc != 0)
+ RETURN(rc);
+ }
+ }
+
+ if (fid_is_sane(&op_data->op_fid3)) {
+ src_tgt = lmv_fid2tgt(lmv, &op_data->op_fid3);
+ if (IS_ERR(src_tgt))
+ RETURN(PTR_ERR(src_tgt));
- rc = lmv_early_cancel(exp, NULL, op_data, src_tgt->ltd_idx,
- LCK_EX, MDS_INODELOCK_FULL,
- MF_MDC_CANCEL_FID4);
+ /* cancel ELC locks of source */
+ rc = lmv_early_cancel(exp, src_tgt, op_data, tgt->ltd_index,
+ LCK_EX, MDS_INODELOCK_ELC,
+ MF_MDC_CANCEL_FID3);
if (rc != 0)
RETURN(rc);
+ }
- tgt = lmv_find_target(lmv, &op_data->op_fid4);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ op_data->op_name = old;
+ op_data->op_namelen = oldlen;
+retry:
+ sp_tgt = lmv_locate_tgt(lmv, op_data);
+ if (IS_ERR(sp_tgt))
+ RETURN(PTR_ERR(sp_tgt));
+
+ /* cancel UPDATE locks of source parent */
+ rc = lmv_early_cancel(exp, sp_tgt, op_data, tgt->ltd_index, LCK_EX,
+ MDS_INODELOCK_UPDATE, MF_MDC_CANCEL_FID1);
+ if (rc != 0)
+ RETURN(rc);
- /* Since the target child might be destroyed, and it might
- * become orphan, and we can only check orphan on the local
- * MDT right now, so we send rename request to the MDT where
- * target child is located. If target child does not exist,
- * then it will send the request to the target parent */
- target_exp = tgt->ltd_exp;
+ if (fid_is_sane(&op_data->op_fid3)) {
+ /* cancel LOOKUP lock of source on source parent */
+ if (src_tgt != sp_tgt) {
+ rc = lmv_early_cancel(exp, sp_tgt, op_data,
+ tgt->ltd_index, LCK_EX,
+ MDS_INODELOCK_LOOKUP,
+ MF_MDC_CANCEL_FID3);
+ if (rc != 0)
+ RETURN(rc);
+ }
}
- rc = md_rename(target_exp, op_data, old, oldlen, new, newlen,
- request);
+rename:
+ CDEBUG(D_INODE, "RENAME "DFID"/%.*s to "DFID"/%.*s\n",
+ PFID(&op_data->op_fid1), (int)oldlen, old,
+ PFID(&op_data->op_fid2), (int)newlen, new);
+
+ rc = md_rename(tgt->ltd_exp, op_data, old, oldlen, new, newlen,
+ request);
+ if (rc == -ENOENT && lmv_dir_retry_check_update(op_data)) {
+ ptlrpc_req_finished(*request);
+ *request = NULL;
+ goto retry;
+ }
- if (rc != 0 && rc != -EXDEV)
+ if (rc && rc != -EXDEV)
RETURN(rc);
body = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_BODY);
if (likely(!(body->mbo_valid & OBD_MD_MDS)))
RETURN(rc);
- CDEBUG(D_INODE, "%s: try rename to another MDT for "DFID"\n",
- exp->exp_obd->obd_name, PFID(&body->mbo_fid1));
-
op_data->op_fid4 = body->mbo_fid1;
+
ptlrpc_req_finished(*request);
*request = NULL;
- goto retry_rename;
+
+ tgt = lmv_fid2tgt(lmv, &op_data->op_fid4);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
+
+ if (fid_is_sane(&op_data->op_fid4)) {
+ /* cancel LOOKUP lock of target on target parent */
+ if (tgt != tp_tgt) {
+ rc = lmv_early_cancel(exp, tp_tgt, op_data,
+ tgt->ltd_index, LCK_EX,
+ MDS_INODELOCK_LOOKUP,
+ MF_MDC_CANCEL_FID4);
+ if (rc != 0)
+ RETURN(rc);
+ }
+ }
+
+ goto rename;
}
static int lmv_setattr(struct obd_export *exp, struct md_op_data *op_data,
void *ea, size_t ealen, struct ptlrpc_request **request)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int rc = 0;
- ENTRY;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc = 0;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- CDEBUG(D_INODE, "SETATTR for "DFID", valid 0x%x\n",
- PFID(&op_data->op_fid1), op_data->op_attr.ia_valid);
+ CDEBUG(D_INODE, "SETATTR for "DFID", valid 0x%x/0x%x\n",
+ PFID(&op_data->op_fid1), op_data->op_attr.ia_valid,
+ op_data->op_xvalid);
op_data->op_flags |= MF_MDC_CANCEL_FID1;
- tgt = lmv_find_target(lmv, &op_data->op_fid1);
+ tgt = lmv_fid2tgt(lmv, &op_data->op_fid1);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
static int lmv_fsync(struct obd_export *exp, const struct lu_fid *fid,
struct ptlrpc_request **request)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int rc;
- ENTRY;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
- rc = lmv_check_connect(obd);
- if (rc != 0)
- RETURN(rc);
+ ENTRY;
- tgt = lmv_find_target(lmv, fid);
+ tgt = lmv_fid2tgt(lmv, fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
RETURN(rc);
}
-/**
- * Get current minimum entry from striped directory
- *
- * This function will search the dir entry, whose hash value is the
- * closest(>=) to @hash_offset, from all of sub-stripes, and it is
- * only being called for striped directory.
- *
- * \param[in] exp export of LMV
- * \param[in] op_data parameters transferred beween client MD stack
- * stripe_information will be included in this
- * parameter
- * \param[in] cb_op ldlm callback being used in enqueue in
- * mdc_read_page
- * \param[in] hash_offset the hash value, which is used to locate
- * minum(closet) dir entry
- * \param[in|out] stripe_offset the caller use this to indicate the stripe
- * index of last entry, so to avoid hash conflict
- * between stripes. It will also be used to
- * return the stripe index of current dir entry.
- * \param[in|out] entp the minum entry and it also is being used
- * to input the last dir entry to resolve the
- * hash conflict
- *
- * \param[out] ppage the page which holds the minum entry
- *
- * \retval = 0 get the entry successfully
- * negative errno (< 0) does not get the entry
- */
-static int lmv_get_min_striped_entry(struct obd_export *exp,
- struct md_op_data *op_data,
- struct md_callback *cb_op,
- __u64 hash_offset, int *stripe_offset,
- struct lu_dirent **entp,
- struct page **ppage)
-{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_stripe_md *lsm = op_data->op_mea1;
- struct lmv_tgt_desc *tgt;
- int stripe_count;
- struct lu_dirent *min_ent = NULL;
- struct page *min_page = NULL;
- int min_idx = 0;
- int i;
- int rc = 0;
+struct stripe_dirent {
+ struct page *sd_page;
+ struct lu_dirpage *sd_dp;
+ struct lu_dirent *sd_ent;
+ bool sd_eof;
+};
+
+struct lmv_dir_ctxt {
+ struct lmv_obd *ldc_lmv;
+ struct md_op_data *ldc_op_data;
+ struct md_callback *ldc_cb_op;
+ __u64 ldc_hash;
+ int ldc_count;
+ struct stripe_dirent ldc_stripes[0];
+};
+
+static inline void stripe_dirent_unload(struct stripe_dirent *stripe)
+{
+ if (stripe->sd_page) {
+ kunmap(stripe->sd_page);
+ put_page(stripe->sd_page);
+ stripe->sd_page = NULL;
+ stripe->sd_ent = NULL;
+ }
+}
+
+static inline void put_lmv_dir_ctxt(struct lmv_dir_ctxt *ctxt)
+{
+ int i;
+
+ for (i = 0; i < ctxt->ldc_count; i++)
+ stripe_dirent_unload(&ctxt->ldc_stripes[i]);
+}
+
+/* if @ent is dummy, or . .., get next */
+static struct lu_dirent *stripe_dirent_get(struct lmv_dir_ctxt *ctxt,
+ struct lu_dirent *ent,
+ int stripe_index)
+{
+ for (; ent; ent = lu_dirent_next(ent)) {
+ /* Skip dummy entry */
+ if (le16_to_cpu(ent->lde_namelen) == 0)
+ continue;
+
+ /* skip . and .. for other stripes */
+ if (stripe_index &&
+ (strncmp(ent->lde_name, ".",
+ le16_to_cpu(ent->lde_namelen)) == 0 ||
+ strncmp(ent->lde_name, "..",
+ le16_to_cpu(ent->lde_namelen)) == 0))
+ continue;
+
+ if (le64_to_cpu(ent->lde_hash) >= ctxt->ldc_hash)
+ break;
+ }
+
+ return ent;
+}
+
+static struct lu_dirent *stripe_dirent_load(struct lmv_dir_ctxt *ctxt,
+ struct stripe_dirent *stripe,
+ int stripe_index)
+{
+ struct md_op_data *op_data = ctxt->ldc_op_data;
+ struct lmv_oinfo *oinfo;
+ struct lu_fid fid = op_data->op_fid1;
+ struct inode *inode = op_data->op_data;
+ struct lmv_tgt_desc *tgt;
+ struct lu_dirent *ent = stripe->sd_ent;
+ __u64 hash = ctxt->ldc_hash;
+ int rc = 0;
+
ENTRY;
- stripe_count = lsm->lsm_md_stripe_count;
- for (i = 0; i < stripe_count; i++) {
- struct lu_dirent *ent = NULL;
- struct page *page = NULL;
- struct lu_dirpage *dp;
- __u64 stripe_hash = hash_offset;
+ LASSERT(stripe == &ctxt->ldc_stripes[stripe_index]);
+ LASSERT(!ent);
- tgt = lmv_get_target(lmv, lsm->lsm_md_oinfo[i].lmo_mds, NULL);
- if (IS_ERR(tgt))
- GOTO(out, rc = PTR_ERR(tgt));
-
- /* op_data will be shared by each stripe, so we need
- * reset these value for each stripe */
- op_data->op_fid1 = lsm->lsm_md_oinfo[i].lmo_fid;
- op_data->op_fid2 = lsm->lsm_md_oinfo[i].lmo_fid;
- op_data->op_data = lsm->lsm_md_oinfo[i].lmo_root;
-next:
- rc = md_read_page(tgt->ltd_exp, op_data, cb_op, stripe_hash,
- &page);
- if (rc != 0)
- GOTO(out, rc);
+ do {
+ if (stripe->sd_page) {
+ __u64 end = le64_to_cpu(stripe->sd_dp->ldp_hash_end);
+
+ /* @hash should be the last dirent hash */
+ LASSERTF(hash <= end,
+ "ctxt@%p stripe@%p hash %llx end %llx\n",
+ ctxt, stripe, hash, end);
+ /* unload last page */
+ stripe_dirent_unload(stripe);
+ /* eof */
+ if (end == MDS_DIR_END_OFF) {
+ stripe->sd_eof = true;
+ break;
+ }
+ hash = end;
+ }
- dp = page_address(page);
- for (ent = lu_dirent_start(dp); ent != NULL;
- ent = lu_dirent_next(ent)) {
- /* Skip dummy entry */
- if (le16_to_cpu(ent->lde_namelen) == 0)
- continue;
+ oinfo = &op_data->op_mea1->lsm_md_oinfo[stripe_index];
+ if (!oinfo->lmo_root) {
+ rc = -ENOENT;
+ break;
+ }
- if (le64_to_cpu(ent->lde_hash) < hash_offset)
- continue;
+ tgt = lmv_tgt(ctxt->ldc_lmv, oinfo->lmo_mds);
+ if (!tgt) {
+ rc = -ENODEV;
+ break;
+ }
+
+ /* op_data is shared by stripes, reset after use */
+ op_data->op_fid1 = oinfo->lmo_fid;
+ op_data->op_fid2 = oinfo->lmo_fid;
+ op_data->op_data = oinfo->lmo_root;
+
+ rc = md_read_page(tgt->ltd_exp, op_data, ctxt->ldc_cb_op, hash,
+ &stripe->sd_page);
+
+ op_data->op_fid1 = fid;
+ op_data->op_fid2 = fid;
+ op_data->op_data = inode;
+
+ if (rc)
+ break;
+
+ stripe->sd_dp = page_address(stripe->sd_page);
+ ent = stripe_dirent_get(ctxt, lu_dirent_start(stripe->sd_dp),
+ stripe_index);
+ /* in case a page filled with ., .. and dummy, read next */
+ } while (!ent);
+
+ stripe->sd_ent = ent;
+ if (rc) {
+ LASSERT(!ent);
+ /* treat error as eof, so dir can be partially accessed */
+ stripe->sd_eof = true;
+ LCONSOLE_WARN("dir "DFID" stripe %d readdir failed: %d, "
+ "directory is partially accessed!\n",
+ PFID(&ctxt->ldc_op_data->op_fid1), stripe_index,
+ rc);
+ }
+
+ RETURN(ent);
+}
+
+static int lmv_file_resync(struct obd_export *exp, struct md_op_data *data)
+{
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
+
+ ENTRY;
+
+ rc = lmv_check_connect(obd);
+ if (rc != 0)
+ RETURN(rc);
- if (le64_to_cpu(ent->lde_hash) == hash_offset &&
- (*entp == ent || i < *stripe_offset))
- continue;
+ tgt = lmv_fid2tgt(lmv, &data->op_fid1);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
- /* skip . and .. for other stripes */
- if (i != 0 &&
- (strncmp(ent->lde_name, ".",
- le16_to_cpu(ent->lde_namelen)) == 0 ||
- strncmp(ent->lde_name, "..",
- le16_to_cpu(ent->lde_namelen)) == 0))
- continue;
- break;
- }
+ data->op_flags |= MF_MDC_CANCEL_FID1;
+ rc = md_file_resync(tgt->ltd_exp, data);
+ RETURN(rc);
+}
- if (ent == NULL) {
- stripe_hash = le64_to_cpu(dp->ldp_hash_end);
+/**
+ * Get dirent with the closest hash for striped directory
+ *
+ * This function will search the dir entry, whose hash value is the
+ * closest(>=) to hash from all of sub-stripes, and it is only being called
+ * for striped directory.
+ *
+ * \param[in] ctxt dir read context
+ *
+ * \retval dirent get the entry successfully
+ * NULL does not get the entry, normally it means
+ * it reaches the end of the directory, while read
+ * stripe dirent error is ignored to allow partial
+ * access.
+ */
+static struct lu_dirent *lmv_dirent_next(struct lmv_dir_ctxt *ctxt)
+{
+ struct stripe_dirent *stripe;
+ struct lu_dirent *ent = NULL;
+ int i;
+ int min = -1;
- kunmap(page);
- page_cache_release(page);
- page = NULL;
+ /* TODO: optimize with k-way merge sort */
+ for (i = 0; i < ctxt->ldc_count; i++) {
+ stripe = &ctxt->ldc_stripes[i];
+ if (stripe->sd_eof)
+ continue;
- /* reach the end of current stripe, go to next stripe */
- if (stripe_hash == MDS_DIR_END_OFF)
+ if (!stripe->sd_ent) {
+ stripe_dirent_load(ctxt, stripe, i);
+ if (!stripe->sd_ent) {
+ LASSERT(stripe->sd_eof);
continue;
- else
- goto next;
+ }
}
- if (min_ent != NULL) {
- if (le64_to_cpu(min_ent->lde_hash) >
- le64_to_cpu(ent->lde_hash)) {
- min_ent = ent;
- kunmap(min_page);
- page_cache_release(min_page);
- min_idx = i;
- min_page = page;
- } else {
- kunmap(page);
- page_cache_release(page);
- page = NULL;
- }
- } else {
- min_ent = ent;
- min_page = page;
- min_idx = i;
+ if (min == -1 ||
+ le64_to_cpu(ctxt->ldc_stripes[min].sd_ent->lde_hash) >
+ le64_to_cpu(stripe->sd_ent->lde_hash)) {
+ min = i;
+ if (le64_to_cpu(stripe->sd_ent->lde_hash) ==
+ ctxt->ldc_hash)
+ break;
}
}
-out:
- if (*ppage != NULL) {
- kunmap(*ppage);
- page_cache_release(*ppage);
+ if (min != -1) {
+ stripe = &ctxt->ldc_stripes[min];
+ ent = stripe->sd_ent;
+ /* pop found dirent */
+ stripe->sd_ent = stripe_dirent_get(ctxt, lu_dirent_next(ent),
+ min);
}
- *stripe_offset = min_idx;
- *entp = min_ent;
- *ppage = min_page;
- RETURN(rc);
+
+ return ent;
}
/**
- * Build dir entry page from a striped directory
+ * Build dir entry page for striped directory
*
* This function gets one entry by @offset from a striped directory. It will
* read entries from all of stripes, and choose one closest to the required
* and .. in a directory.
* 2. op_data will be shared by all of stripes, instead of allocating new
* one, so need to restore before reusing.
- * 3. release the entry page if that is not being chosen.
*
* \param[in] exp obd export refer to LMV
* \param[in] op_data hold those MD parameters of read_entry
* \param[in] cb_op ldlm callback being used in enqueue in mdc_read_entry
- * \param[out] ldp the entry being read
+ * \param[in] offset starting hash offset
* \param[out] ppage the page holding the entry. Note: because the entry
* will be accessed in upper layer, so we need hold the
* page until the usages of entry is finished, see
* retval =0 if get entry successfully
* <0 cannot get entry
*/
-static int lmv_read_striped_page(struct obd_export *exp,
+static int lmv_striped_read_page(struct obd_export *exp,
struct md_op_data *op_data,
struct md_callback *cb_op,
__u64 offset, struct page **ppage)
{
- struct obd_device *obd = exp->exp_obd;
- struct lu_fid master_fid = op_data->op_fid1;
- struct inode *master_inode = op_data->op_data;
- __u64 hash_offset = offset;
- struct lu_dirpage *dp;
- struct page *min_ent_page = NULL;
- struct page *ent_page = NULL;
- struct lu_dirent *ent;
- void *area;
- int ent_idx = 0;
- struct lu_dirent *min_ent = NULL;
- struct lu_dirent *last_ent;
- size_t left_bytes;
- int rc;
+ struct page *page = NULL;
+ struct lu_dirpage *dp;
+ void *start;
+ struct lu_dirent *ent;
+ struct lu_dirent *last_ent;
+ int stripe_count;
+ struct lmv_dir_ctxt *ctxt;
+ struct lu_dirent *next = NULL;
+ __u16 ent_size;
+ size_t left_bytes;
+ int rc = 0;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
/* Allocate a page and read entries from all of stripes and fill
* the page by hash order */
- ent_page = alloc_page(GFP_KERNEL);
- if (ent_page == NULL)
+ page = alloc_page(GFP_KERNEL);
+ if (!page)
RETURN(-ENOMEM);
/* Initialize the entry page */
- dp = kmap(ent_page);
+ dp = kmap(page);
memset(dp, 0, sizeof(*dp));
dp->ldp_hash_start = cpu_to_le64(offset);
- dp->ldp_flags |= LDF_COLLIDE;
- area = dp + 1;
- left_bytes = PAGE_CACHE_SIZE - sizeof(*dp);
- ent = area;
+ start = dp + 1;
+ left_bytes = PAGE_SIZE - sizeof(*dp);
+ ent = start;
last_ent = ent;
- do {
- __u16 ent_size;
- /* Find the minum entry from all sub-stripes */
- rc = lmv_get_min_striped_entry(exp, op_data, cb_op, hash_offset,
- &ent_idx, &min_ent,
- &min_ent_page);
- if (rc != 0)
- GOTO(out, rc);
-
- /* If it can not get minum entry, it means it already reaches
- * the end of this directory */
- if (min_ent == NULL) {
- last_ent->lde_reclen = 0;
- hash_offset = MDS_DIR_END_OFF;
- GOTO(out, rc);
+ /* initalize dir read context */
+ stripe_count = op_data->op_mea1->lsm_md_stripe_count;
+ OBD_ALLOC(ctxt, offsetof(typeof(*ctxt), ldc_stripes[stripe_count]));
+ if (!ctxt)
+ GOTO(free_page, rc = -ENOMEM);
+ ctxt->ldc_lmv = &exp->exp_obd->u.lmv;
+ ctxt->ldc_op_data = op_data;
+ ctxt->ldc_cb_op = cb_op;
+ ctxt->ldc_hash = offset;
+ ctxt->ldc_count = stripe_count;
+
+ while (1) {
+ next = lmv_dirent_next(ctxt);
+
+ /* end of directory */
+ if (!next) {
+ ctxt->ldc_hash = MDS_DIR_END_OFF;
+ break;
}
+ ctxt->ldc_hash = le64_to_cpu(next->lde_hash);
- ent_size = le16_to_cpu(min_ent->lde_reclen);
+ ent_size = le16_to_cpu(next->lde_reclen);
- /* the last entry lde_reclen is 0, but it might not
- * the end of this entry of this temporay entry */
- if (ent_size == 0)
+ /* the last entry lde_reclen is 0, but it might not be the last
+ * one of this temporay dir page */
+ if (!ent_size)
ent_size = lu_dirent_calc_size(
- le16_to_cpu(min_ent->lde_namelen),
- le32_to_cpu(min_ent->lde_attrs));
- if (ent_size > left_bytes) {
- last_ent->lde_reclen = cpu_to_le16(0);
- hash_offset = le64_to_cpu(min_ent->lde_hash);
- GOTO(out, rc);
- }
+ le16_to_cpu(next->lde_namelen),
+ le32_to_cpu(next->lde_attrs));
+ /* page full */
+ if (ent_size > left_bytes)
+ break;
- memcpy(ent, min_ent, ent_size);
+ memcpy(ent, next, ent_size);
/* Replace . with master FID and Replace .. with the parent FID
* of master object */
if (strncmp(ent->lde_name, ".",
le16_to_cpu(ent->lde_namelen)) == 0 &&
le16_to_cpu(ent->lde_namelen) == 1)
- fid_cpu_to_le(&ent->lde_fid, &master_fid);
+ fid_cpu_to_le(&ent->lde_fid, &op_data->op_fid1);
else if (strncmp(ent->lde_name, "..",
le16_to_cpu(ent->lde_namelen)) == 0 &&
le16_to_cpu(ent->lde_namelen) == 2)
fid_cpu_to_le(&ent->lde_fid, &op_data->op_fid3);
+ CDEBUG(D_INODE, "entry %.*s hash %#llx\n",
+ le16_to_cpu(ent->lde_namelen), ent->lde_name,
+ le64_to_cpu(ent->lde_hash));
+
left_bytes -= ent_size;
ent->lde_reclen = cpu_to_le16(ent_size);
last_ent = ent;
ent = (void *)ent + ent_size;
- hash_offset = le64_to_cpu(min_ent->lde_hash);
- if (hash_offset == MDS_DIR_END_OFF) {
- last_ent->lde_reclen = 0;
- break;
- }
- } while (1);
-out:
- if (min_ent_page != NULL) {
- kunmap(min_ent_page);
- page_cache_release(min_ent_page);
- }
+ };
- if (unlikely(rc != 0)) {
- __free_page(ent_page);
- ent_page = NULL;
- } else {
- if (ent == area)
- dp->ldp_flags |= LDF_EMPTY;
- dp->ldp_flags = cpu_to_le32(dp->ldp_flags);
- dp->ldp_hash_end = cpu_to_le64(hash_offset);
- }
+ last_ent->lde_reclen = 0;
- /* We do not want to allocate md_op_data during each
- * dir entry reading, so op_data will be shared by every stripe,
- * then we need to restore it back to original value before
- * return to the upper layer */
- op_data->op_fid1 = master_fid;
- op_data->op_fid2 = master_fid;
- op_data->op_data = master_inode;
+ if (ent == start)
+ dp->ldp_flags |= LDF_EMPTY;
+ else if (ctxt->ldc_hash == le64_to_cpu(last_ent->lde_hash))
+ dp->ldp_flags |= LDF_COLLIDE;
+ dp->ldp_flags = cpu_to_le32(dp->ldp_flags);
+ dp->ldp_hash_end = cpu_to_le64(ctxt->ldc_hash);
- *ppage = ent_page;
+ put_lmv_dir_ctxt(ctxt);
+ OBD_FREE(ctxt, offsetof(typeof(*ctxt), ldc_stripes[stripe_count]));
- RETURN(rc);
+ *ppage = page;
+
+ RETURN(0);
+
+free_page:
+ kunmap(page);
+ __free_page(page);
+
+ return rc;
}
int lmv_read_page(struct obd_export *exp, struct md_op_data *op_data,
struct md_callback *cb_op, __u64 offset,
struct page **ppage)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_stripe_md *lsm = op_data->op_mea1;
- struct lmv_tgt_desc *tgt;
- int rc;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
+
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc != 0)
- RETURN(rc);
+ if (unlikely(lmv_dir_foreign(op_data->op_mea1)))
+ RETURN(-ENODATA);
- if (unlikely(lsm != NULL)) {
- rc = lmv_read_striped_page(exp, op_data, cb_op, offset, ppage);
+ if (unlikely(lmv_dir_striped(op_data->op_mea1))) {
+ rc = lmv_striped_read_page(exp, op_data, cb_op, offset, ppage);
RETURN(rc);
}
- tgt = lmv_find_target(lmv, &op_data->op_fid1);
+ tgt = lmv_fid2tgt(lmv, &op_data->op_fid1);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
* negative errno if failed.
*/
static int lmv_unlink(struct obd_export *exp, struct md_op_data *op_data,
- struct ptlrpc_request **request)
+ struct ptlrpc_request **request)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt = NULL;
- struct lmv_tgt_desc *parent_tgt = NULL;
- struct mdt_body *body;
- int rc;
- int stripe_index = 0;
- struct lmv_stripe_md *lsm = op_data->op_mea1;
- ENTRY;
-
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-retry_unlink:
- /* For striped dir, we need to locate the parent as well */
- if (lsm != NULL) {
- struct lmv_tgt_desc *tmp;
-
- LASSERT(op_data->op_name != NULL &&
- op_data->op_namelen != 0);
-
- tmp = lmv_locate_target_for_name(lmv, lsm,
- op_data->op_name,
- op_data->op_namelen,
- &op_data->op_fid1,
- &op_data->op_mds);
-
- /* return -EBADFD means unknown hash type, might
- * need try all sub-stripe here */
- if (IS_ERR(tmp) && PTR_ERR(tmp) != -EBADFD)
- RETURN(PTR_ERR(tmp));
-
- /* Note: both migrating dir and unknown hash dir need to
- * try all of sub-stripes, so we need start search the
- * name from stripe 0, but migrating dir is already handled
- * inside lmv_locate_target_for_name(), so we only check
- * unknown hash type directory here */
- if (!lmv_is_known_hash_type(lsm->lsm_md_hash_type)) {
- struct lmv_oinfo *oinfo;
-
- oinfo = &lsm->lsm_md_oinfo[stripe_index];
-
- op_data->op_fid1 = oinfo->lmo_fid;
- op_data->op_mds = oinfo->lmo_mds;
- }
- }
-
-try_next_stripe:
- /* Send unlink requests to the MDT where the child is located */
- if (likely(!fid_is_zero(&op_data->op_fid2)))
- tgt = lmv_find_target(lmv, &op_data->op_fid2);
- else if (lsm != NULL)
- tgt = lmv_get_target(lmv, op_data->op_mds, NULL);
- else
- tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ struct lmv_tgt_desc *parent_tgt;
+ struct mdt_body *body;
+ int rc;
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ ENTRY;
op_data->op_fsuid = from_kuid(&init_user_ns, current_fsuid());
op_data->op_fsgid = from_kgid(&init_user_ns, current_fsgid());
op_data->op_cap = cfs_curproc_cap_pack();
+retry:
+ parent_tgt = lmv_locate_tgt(lmv, op_data);
+ if (IS_ERR(parent_tgt))
+ RETURN(PTR_ERR(parent_tgt));
+
+ if (likely(!fid_is_zero(&op_data->op_fid2))) {
+ tgt = lmv_fid2tgt(lmv, &op_data->op_fid2);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
+ } else {
+ tgt = parent_tgt;
+ }
+
/*
* If child's fid is given, cancel unused locks for it if it is from
* another export than parent.
*/
op_data->op_flags |= MF_MDC_CANCEL_FID1 | MF_MDC_CANCEL_FID3;
- /*
- * Cancel FULL locks on child (fid3).
- */
- parent_tgt = lmv_find_target(lmv, &op_data->op_fid1);
- if (IS_ERR(parent_tgt))
- RETURN(PTR_ERR(parent_tgt));
-
- if (parent_tgt != tgt) {
- rc = lmv_early_cancel(exp, parent_tgt, op_data, tgt->ltd_idx,
+ if (parent_tgt != tgt)
+ rc = lmv_early_cancel(exp, parent_tgt, op_data, tgt->ltd_index,
LCK_EX, MDS_INODELOCK_LOOKUP,
MF_MDC_CANCEL_FID3);
- }
- rc = lmv_early_cancel(exp, NULL, op_data, tgt->ltd_idx, LCK_EX,
- MDS_INODELOCK_FULL, MF_MDC_CANCEL_FID3);
- if (rc != 0)
+ rc = lmv_early_cancel(exp, NULL, op_data, tgt->ltd_index, LCK_EX,
+ MDS_INODELOCK_ELC, MF_MDC_CANCEL_FID3);
+ if (rc)
RETURN(rc);
CDEBUG(D_INODE, "unlink with fid="DFID"/"DFID" -> mds #%u\n",
- PFID(&op_data->op_fid1), PFID(&op_data->op_fid2), tgt->ltd_idx);
+ PFID(&op_data->op_fid1), PFID(&op_data->op_fid2),
+ tgt->ltd_index);
rc = md_unlink(tgt->ltd_exp, op_data, request);
- if (rc != 0 && rc != -EREMOTE && rc != -ENOENT)
- RETURN(rc);
-
- /* Try next stripe if it is needed. */
- if (rc == -ENOENT && lsm != NULL && lmv_need_try_all_stripes(lsm)) {
- struct lmv_oinfo *oinfo;
-
- stripe_index++;
- if (stripe_index >= lsm->lsm_md_stripe_count)
- RETURN(rc);
-
- oinfo = &lsm->lsm_md_oinfo[stripe_index];
-
- op_data->op_fid1 = oinfo->lmo_fid;
- op_data->op_mds = oinfo->lmo_mds;
-
+ if (rc == -ENOENT && lmv_dir_retry_check_update(op_data)) {
ptlrpc_req_finished(*request);
*request = NULL;
-
- goto try_next_stripe;
+ goto retry;
}
+ if (rc != -EREMOTE)
+ RETURN(rc);
+
body = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_BODY);
if (body == NULL)
RETURN(-EPROTO);
if (likely(!(body->mbo_valid & OBD_MD_MDS)))
RETURN(rc);
- CDEBUG(D_INODE, "%s: try unlink to another MDT for "DFID"\n",
- exp->exp_obd->obd_name, PFID(&body->mbo_fid1));
-
- /* This is a remote object, try remote MDT, Note: it may
- * try more than 1 time here, Considering following case
- * /mnt/lustre is root on MDT0, remote1 is on MDT1
- * 1. Initially A does not know where remote1 is, it send
- * unlink RPC to MDT0, MDT0 return -EREMOTE, it will
- * resend unlink RPC to MDT1 (retry 1st time).
- *
- * 2. During the unlink RPC in flight,
- * client B mv /mnt/lustre/remote1 /mnt/lustre/remote2
- * and create new remote1, but on MDT0
- *
- * 3. MDT1 get unlink RPC(from A), then do remote lock on
- * /mnt/lustre, then lookup get fid of remote1, and find
- * it is remote dir again, and replay -EREMOTE again.
- *
- * 4. Then A will resend unlink RPC to MDT0. (retry 2nd times).
- *
- * In theory, it might try unlimited time here, but it should
- * be very rare case. */
+ /* This is a remote object, try remote MDT. */
op_data->op_fid2 = body->mbo_fid1;
ptlrpc_req_finished(*request);
*request = NULL;
- goto retry_unlink;
+ tgt = lmv_fid2tgt(lmv, &op_data->op_fid2);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
+
+ goto retry;
}
static int lmv_precleanup(struct obd_device *obd)
{
ENTRY;
- fld_client_proc_fini(&obd->u.lmv.lmv_fld);
+ libcfs_kkuc_group_rem(&obd->obd_uuid, 0, KUC_GRP_HSM);
+ fld_client_debugfs_fini(&obd->u.lmv.lmv_fld);
lprocfs_obd_cleanup(obd);
lprocfs_free_md_stats(obd);
RETURN(0);
static int lmv_get_info(const struct lu_env *env, struct obd_export *exp,
__u32 keylen, void *key, __u32 *vallen, void *val)
{
- struct obd_device *obd;
- struct lmv_obd *lmv;
- int rc = 0;
- ENTRY;
-
- obd = class_exp2obd(exp);
- if (obd == NULL) {
- CDEBUG(D_IOCTL, "Invalid client cookie "LPX64"\n",
- exp->exp_handle.h_cookie);
- RETURN(-EINVAL);
- }
-
- lmv = &obd->u.lmv;
- if (keylen >= strlen("remote_flag") && !strcmp(key, "remote_flag")) {
- int i;
+ struct obd_device *obd;
+ struct lmv_obd *lmv;
+ struct lu_tgt_desc *tgt;
+ int rc = 0;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- LASSERT(*vallen == sizeof(__u32));
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- struct lmv_tgt_desc *tgt = lmv->tgts[i];
- /*
- * All tgts should be connected when this gets called.
- */
- if (tgt == NULL || tgt->ltd_exp == NULL)
- continue;
+ obd = class_exp2obd(exp);
+ if (obd == NULL) {
+ CDEBUG(D_IOCTL, "Invalid client cookie %#llx\n",
+ exp->exp_handle.h_cookie);
+ RETURN(-EINVAL);
+ }
+ lmv = &obd->u.lmv;
+ if (keylen >= strlen("remote_flag") && !strcmp(key, "remote_flag")) {
+ LASSERT(*vallen == sizeof(__u32));
+ lmv_foreach_connected_tgt(lmv, tgt) {
if (!obd_get_info(env, tgt->ltd_exp, keylen, key,
vallen, val))
RETURN(0);
} else if (KEY_IS(KEY_MAX_EASIZE) ||
KEY_IS(KEY_DEFAULT_EASIZE) ||
KEY_IS(KEY_CONN_DATA)) {
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
/*
* Forwarding this request to first MDS, it should know LOV
* desc.
*/
- rc = obd_get_info(env, lmv->tgts[0]->ltd_exp, keylen, key,
- vallen, val);
+ tgt = lmv_tgt(lmv, 0);
+ if (!tgt)
+ RETURN(-ENODEV);
+
+ rc = obd_get_info(env, tgt->ltd_exp, keylen, key, vallen, val);
if (!rc && KEY_IS(KEY_CONN_DATA))
exp->exp_connect_data = *(struct obd_connect_data *)val;
- RETURN(rc);
- } else if (KEY_IS(KEY_TGT_COUNT)) {
- *((int *)val) = lmv->desc.ld_tgt_count;
- RETURN(0);
- }
+ RETURN(rc);
+ } else if (KEY_IS(KEY_TGT_COUNT)) {
+ *((int *)val) = lmv->lmv_mdt_descs.ltd_tgts_size;
+ RETURN(0);
+ }
+
+ CDEBUG(D_IOCTL, "Invalid key\n");
+ RETURN(-EINVAL);
+}
+
+static int lmv_rmfid(struct obd_export *exp, struct fid_array *fa,
+ int *__rcs, struct ptlrpc_request_set *_set)
+{
+ struct obd_device *obddev = class_exp2obd(exp);
+ struct ptlrpc_request_set *set = _set;
+ struct lmv_obd *lmv = &obddev->u.lmv;
+ int tgt_count = lmv->lmv_mdt_count;
+ struct lu_tgt_desc *tgt;
+ struct fid_array *fat, **fas = NULL;
+ int i, rc, **rcs = NULL;
+
+ if (!set) {
+ set = ptlrpc_prep_set();
+ if (!set)
+ RETURN(-ENOMEM);
+ }
+
+ /* split FIDs by targets */
+ OBD_ALLOC(fas, sizeof(fas) * tgt_count);
+ if (fas == NULL)
+ GOTO(out, rc = -ENOMEM);
+ OBD_ALLOC(rcs, sizeof(int *) * tgt_count);
+ if (rcs == NULL)
+ GOTO(out_fas, rc = -ENOMEM);
+
+ for (i = 0; i < fa->fa_nr; i++) {
+ unsigned int idx;
+
+ rc = lmv_fld_lookup(lmv, &fa->fa_fids[i], &idx);
+ if (rc) {
+ CDEBUG(D_OTHER, "can't lookup "DFID": rc = %d\n",
+ PFID(&fa->fa_fids[i]), rc);
+ continue;
+ }
+ LASSERT(idx < tgt_count);
+ if (!fas[idx])
+ OBD_ALLOC(fas[idx], offsetof(struct fid_array,
+ fa_fids[fa->fa_nr]));
+ if (!fas[idx])
+ GOTO(out, rc = -ENOMEM);
+ if (!rcs[idx])
+ OBD_ALLOC(rcs[idx], sizeof(int) * fa->fa_nr);
+ if (!rcs[idx])
+ GOTO(out, rc = -ENOMEM);
+
+ fat = fas[idx];
+ fat->fa_fids[fat->fa_nr++] = fa->fa_fids[i];
+ }
+
+ lmv_foreach_connected_tgt(lmv, tgt) {
+ fat = fas[tgt->ltd_index];
+ if (!fat || fat->fa_nr == 0)
+ continue;
+ rc = md_rmfid(tgt->ltd_exp, fat, rcs[tgt->ltd_index], set);
+ }
+
+ rc = ptlrpc_set_wait(NULL, set);
+ if (rc == 0) {
+ int j = 0;
+ for (i = 0; i < tgt_count; i++) {
+ fat = fas[i];
+ if (!fat || fat->fa_nr == 0)
+ continue;
+ /* copy FIDs back */
+ memcpy(fa->fa_fids + j, fat->fa_fids,
+ fat->fa_nr * sizeof(struct lu_fid));
+ /* copy rcs back */
+ memcpy(__rcs + j, rcs[i], fat->fa_nr * sizeof(**rcs));
+ j += fat->fa_nr;
+ }
+ }
+ if (set != _set)
+ ptlrpc_set_destroy(set);
+
+out:
+ for (i = 0; i < tgt_count; i++) {
+ if (fas && fas[i])
+ OBD_FREE(fas[i], offsetof(struct fid_array,
+ fa_fids[fa->fa_nr]));
+ if (rcs && rcs[i])
+ OBD_FREE(rcs[i], sizeof(int) * fa->fa_nr);
+ }
+ if (rcs)
+ OBD_FREE(rcs, sizeof(int *) * tgt_count);
+out_fas:
+ if (fas)
+ OBD_FREE(fas, sizeof(fas) * tgt_count);
- CDEBUG(D_IOCTL, "Invalid key\n");
- RETURN(-EINVAL);
+ RETURN(rc);
}
/**
obd = class_exp2obd(exp);
if (obd == NULL) {
- CDEBUG(D_IOCTL, "Invalid client cookie "LPX64"\n",
+ CDEBUG(D_IOCTL, "Invalid client cookie %#llx\n",
exp->exp_handle.h_cookie);
RETURN(-EINVAL);
}
if (KEY_IS(KEY_READ_ONLY) || KEY_IS(KEY_FLUSH_CTX) ||
KEY_IS(KEY_DEFAULT_EASIZE)) {
- int i, err = 0;
-
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- tgt = lmv->tgts[i];
-
- if (tgt == NULL || tgt->ltd_exp == NULL)
- continue;
+ int err = 0;
+ lmv_foreach_connected_tgt(lmv, tgt) {
err = obd_set_info_async(env, tgt->ltd_exp,
keylen, key, vallen, val, set);
if (err && rc == 0)
else
lsm->lsm_md_hash_type = le32_to_cpu(lmm1->lmv_hash_type);
lsm->lsm_md_layout_version = le32_to_cpu(lmm1->lmv_layout_version);
+ lsm->lsm_md_migrate_offset = le32_to_cpu(lmm1->lmv_migrate_offset);
+ lsm->lsm_md_migrate_hash = le32_to_cpu(lmm1->lmv_migrate_hash);
cplen = strlcpy(lsm->lsm_md_pool_name, lmm1->lmv_pool_name,
sizeof(lsm->lsm_md_pool_name));
if (cplen >= sizeof(lsm->lsm_md_pool_name))
RETURN(-E2BIG);
- CDEBUG(D_INFO, "unpack lsm count %d, master %d hash_type %d"
+ CDEBUG(D_INFO, "unpack lsm count %d, master %d hash_type %#x "
"layout_version %d\n", lsm->lsm_md_stripe_count,
lsm->lsm_md_master_mdt_index, lsm->lsm_md_hash_type,
lsm->lsm_md_layout_version);
for (i = 0; i < stripe_count; i++) {
fid_le_to_cpu(&lsm->lsm_md_oinfo[i].lmo_fid,
&lmm1->lmv_stripe_fids[i]);
+ /*
+ * set default value -1, so lmv_locate_tgt() knows this stripe
+ * target is not initialized.
+ */
+ lsm->lsm_md_oinfo[i].lmo_mds = LMV_OFFSET_DEFAULT;
+ if (!fid_is_sane(&lsm->lsm_md_oinfo[i].lmo_fid))
+ continue;
+
rc = lmv_fld_lookup(lmv, &lsm->lsm_md_oinfo[i].lmo_fid,
&lsm->lsm_md_oinfo[i].lmo_mds);
- if (rc != 0)
+ if (rc == -ENOENT)
+ continue;
+
+ if (rc)
RETURN(rc);
+
CDEBUG(D_INFO, "unpack fid #%d "DFID"\n", i,
PFID(&lsm->lsm_md_oinfo[i].lmo_fid));
}
RETURN(rc);
}
+static inline int lmv_unpack_user_md(struct obd_export *exp,
+ struct lmv_stripe_md *lsm,
+ const struct lmv_user_md *lmu)
+{
+ lsm->lsm_md_magic = le32_to_cpu(lmu->lum_magic);
+ lsm->lsm_md_stripe_count = le32_to_cpu(lmu->lum_stripe_count);
+ lsm->lsm_md_master_mdt_index = le32_to_cpu(lmu->lum_stripe_offset);
+ lsm->lsm_md_hash_type = le32_to_cpu(lmu->lum_hash_type);
+
+ return 0;
+}
+
static int lmv_unpackmd(struct obd_export *exp, struct lmv_stripe_md **lsmp,
const union lmv_mds_md *lmm, size_t lmm_size)
{
/* Free memmd */
if (lsm != NULL && lmm == NULL) {
int i;
- for (i = 0; i < lsm->lsm_md_stripe_count; i++) {
- /* For migrating inode, the master stripe and master
- * object will be the same, so do not need iput, see
- * ll_update_lsm_md */
- if (!(lsm->lsm_md_hash_type & LMV_HASH_FLAG_MIGRATION &&
- i == 0) && lsm->lsm_md_oinfo[i].lmo_root != NULL)
- iput(lsm->lsm_md_oinfo[i].lmo_root);
+ struct lmv_foreign_md *lfm = (struct lmv_foreign_md *)lsm;
+
+ if (lfm->lfm_magic == LMV_MAGIC_FOREIGN) {
+ size_t lfm_size;
+
+ lfm_size = lfm->lfm_length + offsetof(typeof(*lfm),
+ lfm_value[0]);
+ OBD_FREE_LARGE(lfm, lfm_size);
+ RETURN(0);
+ }
+
+ if (lmv_dir_striped(lsm)) {
+ for (i = 0; i < lsm->lsm_md_stripe_count; i++) {
+ if (lsm->lsm_md_oinfo[i].lmo_root)
+ iput(lsm->lsm_md_oinfo[i].lmo_root);
+ }
+ lsm_size = lmv_stripe_md_size(lsm->lsm_md_stripe_count);
+ } else {
+ lsm_size = lmv_stripe_md_size(0);
}
- lsm_size = lmv_stripe_md_size(lsm->lsm_md_stripe_count);
OBD_FREE(lsm, lsm_size);
*lsmp = NULL;
RETURN(0);
}
+ /* foreign lmv case */
+ if (le32_to_cpu(lmm->lmv_magic) == LMV_MAGIC_FOREIGN) {
+ struct lmv_foreign_md *lfm = (struct lmv_foreign_md *)lsm;
+
+ if (lfm == NULL) {
+ OBD_ALLOC_LARGE(lfm, lmm_size);
+ if (lfm == NULL)
+ RETURN(-ENOMEM);
+ *lsmp = (struct lmv_stripe_md *)lfm;
+ }
+ lfm->lfm_magic = le32_to_cpu(lmm->lmv_foreign_md.lfm_magic);
+ lfm->lfm_length = le32_to_cpu(lmm->lmv_foreign_md.lfm_length);
+ lfm->lfm_type = le32_to_cpu(lmm->lmv_foreign_md.lfm_type);
+ lfm->lfm_flags = le32_to_cpu(lmm->lmv_foreign_md.lfm_flags);
+ memcpy(&lfm->lfm_value, &lmm->lmv_foreign_md.lfm_value,
+ lfm->lfm_length);
+ RETURN(lmm_size);
+ }
+
if (le32_to_cpu(lmm->lmv_magic) == LMV_MAGIC_STRIPE)
RETURN(-EPERM);
*/
lsm_size = lmv_stripe_md_size(0);
- lsm_size = lmv_stripe_md_size(lmv_mds_md_stripe_count_get(lmm));
if (lsm == NULL) {
OBD_ALLOC(lsm, lsm_size);
if (lsm == NULL)
case LMV_MAGIC_V1:
rc = lmv_unpack_md_v1(exp, lsm, &lmm->lmv_md_v1);
break;
+ case LMV_USER_MAGIC:
+ rc = lmv_unpack_user_md(exp, lsm, &lmm->lmv_user_md);
+ break;
default:
CERROR("%s: unrecognized magic %x\n", exp->exp_obd->obd_name,
le32_to_cpu(lmm->lmv_magic));
void *opaque)
{
struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
+ struct lu_tgt_desc *tgt;
+ int err;
int rc = 0;
- __u32 i;
+
ENTRY;
LASSERT(fid != NULL);
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- struct lmv_tgt_desc *tgt = lmv->tgts[i];
- int err;
-
- if (tgt == NULL || tgt->ltd_exp == NULL || !tgt->ltd_active)
+ lmv_foreach_connected_tgt(lmv, tgt) {
+ if (!tgt->ltd_active)
continue;
err = md_cancel_unused(tgt->ltd_exp, fid, policy, mode, flags,
RETURN(rc);
}
-int lmv_set_lock_data(struct obd_export *exp, __u64 *lockh, void *data,
- __u64 *bits)
+static int lmv_set_lock_data(struct obd_export *exp,
+ const struct lustre_handle *lockh,
+ void *data, __u64 *bits)
{
- struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
- struct lmv_tgt_desc *tgt = lmv->tgts[0];
- int rc;
+ struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
+ struct lmv_tgt_desc *tgt = lmv_tgt(lmv, 0);
+ int rc;
+
ENTRY;
if (tgt == NULL || tgt->ltd_exp == NULL)
union ldlm_policy_data *policy,
enum ldlm_mode mode, struct lustre_handle *lockh)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- enum ldlm_mode rc;
- int tgt;
- int i;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ enum ldlm_mode rc;
+ struct lu_tgt_desc *tgt;
+ int i;
+ int index;
+
ENTRY;
CDEBUG(D_INODE, "Lock match for "DFID"\n", PFID(fid));
- /*
+ /*
* With DNE every object can have two locks in different namespaces:
* lookup lock in space of MDT storing direntry and update/open lock in
* space of MDT storing inode. Try the MDT that the FID maps to first,
* since this can be easily found, and only try others if that fails.
*/
- for (i = 0, tgt = lmv_find_target_index(lmv, fid);
- i < lmv->desc.ld_tgt_count;
- i++, tgt = (tgt + 1) % lmv->desc.ld_tgt_count) {
- if (tgt < 0) {
+ for (i = 0, index = lmv_fid2tgt_index(lmv, fid);
+ i < lmv->lmv_mdt_descs.ltd_tgts_size;
+ i++, index = (index + 1) % lmv->lmv_mdt_descs.ltd_tgts_size) {
+ if (index < 0) {
CDEBUG(D_HA, "%s: "DFID" is inaccessible: rc = %d\n",
- obd->obd_name, PFID(fid), tgt);
- tgt = 0;
+ obd->obd_name, PFID(fid), index);
+ index = 0;
}
- if (lmv->tgts[tgt] == NULL ||
- lmv->tgts[tgt]->ltd_exp == NULL ||
- lmv->tgts[tgt]->ltd_active == 0)
+ tgt = lmv_tgt(lmv, index);
+ if (!tgt || !tgt->ltd_exp || !tgt->ltd_active)
continue;
- rc = md_lock_match(lmv->tgts[tgt]->ltd_exp, flags, fid,
- type, policy, mode, lockh);
+ rc = md_lock_match(tgt->ltd_exp, flags, fid, type, policy, mode,
+ lockh);
if (rc)
RETURN(rc);
}
struct obd_export *dt_exp, struct obd_export *md_exp,
struct lustre_md *md)
{
- struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
- struct lmv_tgt_desc *tgt = lmv->tgts[0];
+ struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
+ struct lmv_tgt_desc *tgt = lmv_tgt(lmv, 0);
- if (tgt == NULL || tgt->ltd_exp == NULL)
- RETURN(-EINVAL);
+ if (!tgt || !tgt->ltd_exp)
+ return -EINVAL;
- return md_get_lustre_md(lmv->tgts[0]->ltd_exp, req, dt_exp, md_exp, md);
+ return md_get_lustre_md(tgt->ltd_exp, req, dt_exp, md_exp, md);
}
int lmv_free_lustre_md(struct obd_export *exp, struct lustre_md *md)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt = lmv->tgts[0];
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt = lmv_tgt(lmv, 0);
+
ENTRY;
+ if (md->default_lmv) {
+ lmv_free_memmd(md->default_lmv);
+ md->default_lmv = NULL;
+ }
if (md->lmv != NULL) {
lmv_free_memmd(md->lmv);
md->lmv = NULL;
}
- if (tgt == NULL || tgt->ltd_exp == NULL)
+ if (!tgt || !tgt->ltd_exp)
RETURN(-EINVAL);
- RETURN(md_free_lustre_md(lmv->tgts[0]->ltd_exp, md));
+ RETURN(md_free_lustre_md(tgt->ltd_exp, md));
}
int lmv_set_open_replay_data(struct obd_export *exp,
struct obd_client_handle *och,
struct lookup_intent *it)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+
ENTRY;
- tgt = lmv_find_target(lmv, &och->och_fid);
+ tgt = lmv_fid2tgt(lmv, &och->och_fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
}
int lmv_clear_open_replay_data(struct obd_export *exp,
- struct obd_client_handle *och)
-{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- ENTRY;
-
- tgt = lmv_find_target(lmv, &och->och_fid);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
-
- RETURN(md_clear_open_replay_data(tgt->ltd_exp, och));
-}
-
-static int lmv_get_remote_perm(struct obd_export *exp, const struct lu_fid *fid,
- u32 suppgid, struct ptlrpc_request **request)
+ struct obd_client_handle *och)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int rc;
- ENTRY;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- tgt = lmv_find_target(lmv, fid);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ tgt = lmv_fid2tgt(lmv, &och->och_fid);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
- rc = md_get_remote_perm(tgt->ltd_exp, fid, suppgid, request);
- RETURN(rc);
+ RETURN(md_clear_open_replay_data(tgt->ltd_exp, och));
}
int lmv_intent_getattr_async(struct obd_export *exp,
struct md_enqueue_info *minfo)
{
- struct md_op_data *op_data = &minfo->mi_data;
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *ptgt = NULL;
- struct lmv_tgt_desc *ctgt = NULL;
- int rc;
+ struct md_op_data *op_data = &minfo->mi_data;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *ptgt;
+ struct lmv_tgt_desc *ctgt;
+ int rc;
+
ENTRY;
if (!fid_is_sane(&op_data->op_fid2))
RETURN(-EINVAL);
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
- ptgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
+ ptgt = lmv_locate_tgt(lmv, op_data);
if (IS_ERR(ptgt))
RETURN(PTR_ERR(ptgt));
- ctgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid2);
+ ctgt = lmv_fid2tgt(lmv, &op_data->op_fid1);
if (IS_ERR(ctgt))
RETURN(PTR_ERR(ctgt));
/*
- * if child is on remote MDT, we need 2 async RPCs to fetch both LOOKUP
- * lock on parent, and UPDATE lock on child MDT, which makes all
- * complicated. Considering remote dir is rare case, and not supporting
- * it in statahead won't cause any issue, drop its support for now.
+ * remote object needs two RPCs to lookup and getattr, considering the
+ * complexity don't support statahead for now.
*/
- if (ptgt != ctgt)
- RETURN(-ENOTSUPP);
+ if (ctgt != ptgt)
+ RETURN(-EREMOTE);
rc = md_intent_getattr_async(ptgt->ltd_exp, minfo);
+
RETURN(rc);
}
int lmv_revalidate_lock(struct obd_export *exp, struct lookup_intent *it,
- struct lu_fid *fid, __u64 *bits)
+ struct lu_fid *fid, __u64 *bits)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- int rc;
- ENTRY;
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt;
+ int rc;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ ENTRY;
- tgt = lmv_find_target(lmv, fid);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ tgt = lmv_fid2tgt(lmv, fid);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
- rc = md_revalidate_lock(tgt->ltd_exp, it, fid, bits);
- RETURN(rc);
+ rc = md_revalidate_lock(tgt->ltd_exp, it, fid, bits);
+ RETURN(rc);
}
int lmv_get_fid_from_lsm(struct obd_export *exp,
{
const struct lmv_oinfo *oinfo;
- LASSERT(lsm != NULL);
- oinfo = lsm_name_to_stripe_info(lsm, name, namelen);
+ LASSERT(lmv_dir_striped(lsm));
+
+ oinfo = lsm_name_to_stripe_info(lsm, name, namelen, false);
if (IS_ERR(oinfo))
return PTR_ERR(oinfo);
int lmv_quotactl(struct obd_device *unused, struct obd_export *exp,
struct obd_quotactl *oqctl)
{
- struct obd_device *obd = class_exp2obd(exp);
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt = lmv->tgts[0];
- int rc = 0;
- __u32 i;
- __u64 curspace, curinodes;
+ struct obd_device *obd = class_exp2obd(exp);
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *tgt = lmv_tgt(lmv, 0);
+ __u64 curspace, curinodes;
+ int rc = 0;
+
ENTRY;
- if (tgt == NULL ||
- tgt->ltd_exp == NULL ||
- !tgt->ltd_active ||
- lmv->desc.ld_tgt_count == 0) {
+ if (!tgt || !tgt->ltd_exp || !tgt->ltd_active) {
CERROR("master lmv inactive\n");
RETURN(-EIO);
}
- if (oqctl->qc_cmd != Q_GETOQUOTA) {
- rc = obd_quotactl(tgt->ltd_exp, oqctl);
- RETURN(rc);
- }
+ if (oqctl->qc_cmd != Q_GETOQUOTA) {
+ rc = obd_quotactl(tgt->ltd_exp, oqctl);
+ RETURN(rc);
+ }
- curspace = curinodes = 0;
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
+ curspace = curinodes = 0;
+ lmv_foreach_connected_tgt(lmv, tgt) {
int err;
- tgt = lmv->tgts[i];
- if (tgt == NULL || tgt->ltd_exp == NULL || !tgt->ltd_active)
+ if (!tgt->ltd_active)
continue;
- err = obd_quotactl(tgt->ltd_exp, oqctl);
- if (err) {
- CERROR("getquota on mdt %d failed. %d\n", i, err);
- if (!rc)
- rc = err;
- } else {
- curspace += oqctl->qc_dqblk.dqb_curspace;
- curinodes += oqctl->qc_dqblk.dqb_curinodes;
- }
- }
- oqctl->qc_dqblk.dqb_curspace = curspace;
- oqctl->qc_dqblk.dqb_curinodes = curinodes;
+ err = obd_quotactl(tgt->ltd_exp, oqctl);
+ if (err) {
+ CERROR("getquota on mdt %d failed. %d\n",
+ tgt->ltd_index, err);
+ if (!rc)
+ rc = err;
+ } else {
+ curspace += oqctl->qc_dqblk.dqb_curspace;
+ curinodes += oqctl->qc_dqblk.dqb_curinodes;
+ }
+ }
+ oqctl->qc_dqblk.dqb_curspace = curspace;
+ oqctl->qc_dqblk.dqb_curinodes = curinodes;
- RETURN(rc);
+ RETURN(rc);
}
static int lmv_merge_attr(struct obd_export *exp,
int rc;
int i;
+ if (!lmv_dir_striped(lsm))
+ return 0;
+
rc = lmv_revalidate_slaves(exp, lsm, cb_blocking, 0);
if (rc < 0)
return rc;
for (i = 0; i < lsm->lsm_md_stripe_count; i++) {
struct inode *inode = lsm->lsm_md_oinfo[i].lmo_root;
- CDEBUG(D_INFO, ""DFID" size %llu, blocks %llu nlink %u,"
- " atime %lu ctime %lu, mtime %lu.\n",
+ if (!inode)
+ continue;
+
+ CDEBUG(D_INFO,
+ "" DFID " size %llu, blocks %llu nlink %u, atime %lld ctime %lld, mtime %lld.\n",
PFID(&lsm->lsm_md_oinfo[i].lmo_fid),
i_size_read(inode), (unsigned long long)inode->i_blocks,
- inode->i_nlink, LTIME_S(inode->i_atime),
- LTIME_S(inode->i_ctime), LTIME_S(inode->i_mtime));
+ inode->i_nlink, (s64)inode->i_atime.tv_sec,
+ (s64)inode->i_ctime.tv_sec, (s64)inode->i_mtime.tv_sec);
/* for slave stripe, it needs to subtract nlink for . and .. */
if (i != 0)
attr->cat_size += i_size_read(inode);
attr->cat_blocks += inode->i_blocks;
- if (attr->cat_atime < LTIME_S(inode->i_atime))
- attr->cat_atime = LTIME_S(inode->i_atime);
+ if (attr->cat_atime < inode->i_atime.tv_sec)
+ attr->cat_atime = inode->i_atime.tv_sec;
- if (attr->cat_ctime < LTIME_S(inode->i_ctime))
- attr->cat_ctime = LTIME_S(inode->i_ctime);
+ if (attr->cat_ctime < inode->i_ctime.tv_sec)
+ attr->cat_ctime = inode->i_ctime.tv_sec;
- if (attr->cat_mtime < LTIME_S(inode->i_mtime))
- attr->cat_mtime = LTIME_S(inode->i_mtime);
+ if (attr->cat_mtime < inode->i_mtime.tv_sec)
+ attr->cat_mtime = inode->i_mtime.tv_sec;
}
return 0;
}
.o_set_info_async = lmv_set_info_async,
.o_notify = lmv_notify,
.o_get_uuid = lmv_get_uuid,
+ .o_fid_alloc = lmv_fid_alloc,
.o_iocontrol = lmv_iocontrol,
.o_quotactl = lmv_quotactl
};
struct md_ops lmv_md_ops = {
- .m_getstatus = lmv_getstatus,
+ .m_get_root = lmv_get_root,
.m_null_inode = lmv_null_inode,
- .m_find_cbdata = lmv_find_cbdata,
.m_close = lmv_close,
.m_create = lmv_create,
.m_enqueue = lmv_enqueue,
.m_setattr = lmv_setattr,
.m_setxattr = lmv_setxattr,
.m_fsync = lmv_fsync,
+ .m_file_resync = lmv_file_resync,
.m_read_page = lmv_read_page,
.m_unlink = lmv_unlink,
.m_init_ea_size = lmv_init_ea_size,
.m_merge_attr = lmv_merge_attr,
.m_set_open_replay_data = lmv_set_open_replay_data,
.m_clear_open_replay_data = lmv_clear_open_replay_data,
- .m_get_remote_perm = lmv_get_remote_perm,
.m_intent_getattr_async = lmv_intent_getattr_async,
.m_revalidate_lock = lmv_revalidate_lock,
.m_get_fid_from_lsm = lmv_get_fid_from_lsm,
.m_unpackmd = lmv_unpackmd,
+ .m_rmfid = lmv_rmfid,
};
static int __init lmv_init(void)