#include <lustre_lib.h>
#include <lustre_net.h>
#include <obd_class.h>
+#include <lustre_lmv.h>
#include <lprocfs_status.h>
+#include <cl_object.h>
+#include <lclient.h>
#include <lustre_lite.h>
#include <lustre_fid.h>
#include "lmv_internal.h"
+/* This hash is only for testing purpose */
+static inline unsigned int
+lmv_hash_all_chars(unsigned int count, const char *name, int namelen)
+{
+ unsigned int c = 0;
+ const unsigned char *p = (const unsigned char *)name;
+
+ while (--namelen >= 0)
+ c += p[namelen];
+
+ c = c % count;
+
+ return c;
+}
+
+static inline unsigned int
+lmv_hash_fnv1a(unsigned int count, const char *name, int namelen)
+{
+ __u64 hash;
+
+ hash = lustre_hash_fnv_1a_64(name, namelen);
+
+ hash = hash % count;
+
+ return hash;
+}
+
+int lmv_name_to_stripe_index(enum lmv_hash_type hashtype,
+ unsigned int max_mdt_index,
+ const char *name, int namelen)
+{
+ int idx;
+
+ LASSERT(namelen > 0);
+ if (max_mdt_index <= 1)
+ return 0;
+
+ switch (hashtype) {
+ case LMV_HASH_TYPE_ALL_CHARS:
+ idx = lmv_hash_all_chars(max_mdt_index, name, namelen);
+ break;
+ case LMV_HASH_TYPE_FNV_1A_64:
+ idx = lmv_hash_fnv1a(max_mdt_index, name, namelen);
+ break;
+ /* LMV_HASH_TYPE_MIGRATION means the file is being migrated,
+ * and the file should be accessed by client, except for
+ * lookup(see lmv_intent_lookup), return -EACCES here */
+ case LMV_HASH_TYPE_MIGRATION:
+ CERROR("%.*s is being migrated: rc = %d\n", namelen,
+ name, -EACCES);
+ return -EACCES;
+ default:
+ CERROR("Unknown hash type 0x%x\n", hashtype);
+ return -EINVAL;
+ }
+
+ CDEBUG(D_INFO, "name %.*s hash_type %d idx %d\n", namelen, name,
+ hashtype, idx);
+
+ LASSERT(idx < max_mdt_index);
+ return idx;
+}
+
static void lmv_activate_target(struct lmv_obd *lmv,
struct lmv_tgt_desc *tgt,
int activate)
lmv->conn_data = *data;
#ifdef __KERNEL__
- lmv_proc_dir = lprocfs_register("target_obds", obd->obd_proc_entry,
- NULL, NULL);
- if (IS_ERR(lmv_proc_dir)) {
- CERROR("could not register /proc/fs/lustre/%s/%s/target_obds.",
- obd->obd_type->typ_name, obd->obd_name);
- lmv_proc_dir = NULL;
- }
+ if (obd->obd_proc_private != NULL) {
+ lmv_proc_dir = obd->obd_proc_private;
+ } else {
+ lmv_proc_dir = lprocfs_seq_register("target_obds",
+ obd->obd_proc_entry,
+ NULL, NULL);
+ if (IS_ERR(lmv_proc_dir)) {
+ CERROR("could not register /proc/fs/lustre/%s/%s/target_obds.",
+ obd->obd_type->typ_name, obd->obd_name);
+ lmv_proc_dir = NULL;
+ }
+ obd->obd_proc_private = lmv_proc_dir;
+ }
#endif
/*
rc = lmv_check_connect(obd);
#ifdef __KERNEL__
- if (rc) {
- if (lmv_proc_dir)
- lprocfs_remove(&lmv_proc_dir);
- }
+ if (rc && lmv_proc_dir) {
+ lprocfs_remove(&lmv_proc_dir);
+ obd->obd_proc_private = NULL;
+ }
#endif
-
RETURN(rc);
}
cfs_atomic_read(&obd->obd_refcount));
#ifdef __KERNEL__
- lmv_proc_dir = lprocfs_srch(obd->obd_proc_entry, "target_obds");
- if (lmv_proc_dir) {
- 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_proc_dir,
- "../../../%s/%s",
- mdc_obd->obd_type->typ_name,
- mdc_obd->obd_name);
- if (mdc_symlink == NULL) {
- CERROR("Could not register LMV target "
- "/proc/fs/lustre/%s/%s/target_obds/%s.",
- obd->obd_type->typ_name, obd->obd_name,
- mdc_obd->obd_name);
- lprocfs_remove(&lmv_proc_dir);
- lmv_proc_dir = NULL;
- }
- }
+ lmv_proc_dir = obd->obd_proc_private;
+ if (lmv_proc_dir) {
+ 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_proc_dir,
+ "../../../%s/%s",
+ mdc_obd->obd_type->typ_name,
+ mdc_obd->obd_name);
+ if (mdc_symlink == NULL) {
+ CERROR("Could not register LMV target "
+ "/proc/fs/lustre/%s/%s/target_obds/%s.",
+ obd->obd_type->typ_name, obd->obd_name,
+ mdc_obd->obd_name);
+ lprocfs_remove(&lmv_proc_dir);
+ obd->obd_proc_private = NULL;
+ }
+ }
#endif
- RETURN(0);
+ RETURN(0);
}
static void lmv_del_target(struct lmv_obd *lmv, int index)
GOTO(out_disc, rc);
}
- lmv_set_timeouts(obd);
- class_export_put(lmv->exp);
- lmv->connected = 1;
- easize = lmv_get_easize(lmv);
- lmv_init_ea_size(obd->obd_self_export, easize, 0, 0);
- lmv_init_unlock(lmv);
- RETURN(0);
+ lmv_set_timeouts(obd);
+ class_export_put(lmv->exp);
+ lmv->connected = 1;
+ easize = lmv_mds_md_size(lmv->desc.ld_tgt_count, LMV_MAGIC);
+ lmv_init_ea_size(obd->obd_self_export, easize, 0, 0);
+ lmv_init_unlock(lmv);
+ RETURN(0);
out_disc:
while (i-- > 0) {
}
#ifdef __KERNEL__
- lmv_proc_dir = lprocfs_srch(obd->obd_proc_entry, "target_obds");
- if (lmv_proc_dir) {
- struct proc_dir_entry *mdc_symlink;
-
- mdc_symlink = lprocfs_srch(lmv_proc_dir, mdc_obd->obd_name);
- if (mdc_symlink) {
- lprocfs_remove(&mdc_symlink);
- } else {
- CERROR("/proc/fs/lustre/%s/%s/target_obds/%s missing\n",
- obd->obd_type->typ_name, obd->obd_name,
- mdc_obd->obd_name);
- }
- }
+ lmv_proc_dir = obd->obd_proc_private;
+ if (lmv_proc_dir)
+ lprocfs_remove_proc_entry(mdc_obd->obd_name, lmv_proc_dir);
#endif
rc = obd_fid_fini(tgt->ltd_exp->exp_obd);
if (rc)
static int lmv_disconnect(struct obd_export *exp)
{
struct obd_device *obd = class_exp2obd(exp);
-#ifdef __KERNEL__
- struct proc_dir_entry *lmv_proc_dir;
-#endif
struct lmv_obd *lmv = &obd->u.lmv;
int rc;
__u32 i;
}
#ifdef __KERNEL__
- lmv_proc_dir = lprocfs_srch(obd->obd_proc_entry, "target_obds");
- if (lmv_proc_dir) {
- lprocfs_remove(&lmv_proc_dir);
- } else {
- CERROR("/proc/fs/lustre/%s/%s/target_obds missing\n",
- obd->obd_type->typ_name, obd->obd_name);
- }
+ if (obd->obd_proc_private)
+ lprocfs_remove((struct proc_dir_entry **)&obd->obd_proc_private);
+ else
+ CERROR("/proc/fs/lustre/%s/%s/target_obds missing\n",
+ obd->obd_type->typ_name, obd->obd_name);
#endif
out_local:
* If stripe_offset is provided during setdirstripe
* (setdirstripe -i xx), xx MDS will be choosen.
*/
- if (op_data->op_cli_flags & CLI_SET_MEA) {
+ if (op_data->op_cli_flags & CLI_SET_MEA && op_data->op_data != NULL) {
struct lmv_user_md *lum;
- lum = (struct lmv_user_md *)op_data->op_data;
- if (lum->lum_type == LMV_STRIPE_TYPE &&
- lum->lum_stripe_offset != -1) {
- if (lum->lum_stripe_offset >= lmv->desc.ld_tgt_count) {
- CERROR("%s: Stripe_offset %d > MDT count %d:"
- " rc = %d\n", obd->obd_name,
- lum->lum_stripe_offset,
- lmv->desc.ld_tgt_count, -ERANGE);
- RETURN(-ERANGE);
- }
+ lum = op_data->op_data;
+
+ if (lum->lum_stripe_offset != (__u32)-1) {
*mds = lum->lum_stripe_offset;
- RETURN(0);
+ } else {
+ /* -1 means default, which will be in the same MDT with
+ * the stripe */
+ *mds = op_data->op_mds;
+ lum->lum_stripe_offset = op_data->op_mds;
}
+ } else {
+ /* Allocate new fid on target according to operation type and
+ * parent home mds. */
+ *mds = op_data->op_mds;
}
- /* Allocate new fid on target according to operation type and parent
- * home mds. */
- *mds = op_data->op_mds;
RETURN(0);
}
static int lmv_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
{
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lprocfs_static_vars lvars;
- struct lmv_desc *desc;
- int rc;
- ENTRY;
+ 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");
spin_lock_init(&lmv->lmv_lock);
mutex_init(&lmv->init_mutex);
- lprocfs_lmv_init_vars(&lvars);
-
- lprocfs_obd_setup(obd, lvars.obd_vars);
- lprocfs_alloc_md_stats(obd, 0);
#ifdef LPROCFS
- {
- rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd",
- 0444, &lmv_proc_target_fops, obd);
- if (rc)
- CWARN("%s: error adding LMV target_obd file: rc = %d\n",
- obd->obd_name, rc);
- }
+ obd->obd_vars = lprocfs_lmv_obd_vars;
+ lprocfs_seq_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);
+ if (rc)
+ CWARN("%s: error adding LMV target_obd file: rc = %d\n",
+ obd->obd_name, rc);
#endif
rc = fld_client_init(&lmv->lmv_fld, obd->obd_name,
LUSTRE_CLI_FLD_HASH_DHT);
obd_str2uuid(&obd_uuid, lustre_cfg_buf(lcfg, 1));
- if (sscanf(lustre_cfg_buf(lcfg, 2), "%d", &index) != 1)
+ if (sscanf(lustre_cfg_buf(lcfg, 2), "%u", &index) != 1)
GOTO(out, rc = -EINVAL);
if (sscanf(lustre_cfg_buf(lcfg, 3), "%d", &gen) != 1)
GOTO(out, rc = -EINVAL);
RETURN(rc);
}
+/**
+ * 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,
+ mdsno_t *mds)
+{
+ struct lmv_tgt_desc *tgt;
+ const struct lmv_oinfo *oinfo;
+
+ oinfo = lsm_name_to_stripe_info(lsm, name, namelen);
+ if (IS_ERR(oinfo))
+ RETURN((void *)oinfo);
+ *fid = oinfo->lmo_fid;
+ *mds = oinfo->lmo_mds;
+ tgt = lmv_get_target(lmv, *mds);
+
+ CDEBUG(D_INFO, "locate on mds %u "DFID"\n", *mds, PFID(fid));
+ return tgt;
+}
+
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 *tgt;
+ struct lmv_stripe_md *lsm = op_data->op_mea1;
+ struct lmv_tgt_desc *tgt;
- tgt = lmv_find_target(lmv, fid);
- if (IS_ERR(tgt))
- return tgt;
+ if (lsm == NULL || lsm->lsm_md_stripe_count <= 1 ||
+ op_data->op_namelen == 0 ||
+ lsm->lsm_md_magic == LMV_MAGIC_MIGRATE) {
+ tgt = lmv_find_target(lmv, fid);
+ if (IS_ERR(tgt))
+ return tgt;
- op_data->op_mds = tgt->ltd_idx;
+ op_data->op_mds = tgt->ltd_idx;
+ return tgt;
+ }
- return tgt;
+ return lmv_locate_target_for_name(lmv, lsm, op_data->op_name,
+ op_data->op_namelen, fid,
+ &op_data->op_mds);
}
int lmv_create(struct obd_export *exp, struct md_op_data *op_data,
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
+ CDEBUG(D_INODE, "CREATE name '%.*s' on "DFID" -> mds #%x\n",
+ op_data->op_namelen, op_data->op_name, PFID(&op_data->op_fid1),
+ op_data->op_mds);
+
rc = lmv_fid_alloc(exp, &op_data->op_fid2, op_data);
if (rc)
RETURN(rc);
- CDEBUG(D_INODE, "CREATE '%*s' on "DFID" -> mds #%x\n",
- op_data->op_namelen, op_data->op_name, PFID(&op_data->op_fid1),
- op_data->op_mds);
+ /* 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;
+
+ CDEBUG(D_INODE, "CREATE obj "DFID" -> mds #%x\n",
+ PFID(&op_data->op_fid2), 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,
cap_effective, rdev, request);
-
if (rc == 0) {
if (*request == NULL)
RETURN(rc);
fl == MF_MDC_CANCEL_FID4 ? &op_data->op_fid4 : \
NULL)
-static int lmv_early_cancel(struct obd_export *exp, struct md_op_data *op_data,
- int op_tgt, ldlm_mode_t mode, int bits, int flag)
+static int lmv_early_cancel(struct obd_export *exp, struct lmv_tgt_desc *tgt,
+ struct md_op_data *op_data,
+ int op_tgt, ldlm_mode_t mode, int bits, int flag)
{
- struct lu_fid *fid = md_op_data_fid(op_data, flag);
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_tgt_desc *tgt;
- ldlm_policy_data_t policy = {{0}};
- int rc = 0;
- ENTRY;
+ struct lu_fid *fid = md_op_data_fid(op_data, flag);
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ ldlm_policy_data_t policy = {{ 0 }};
+ int rc = 0;
+ ENTRY;
- if (!fid_is_sane(fid))
- RETURN(0);
+ if (!fid_is_sane(fid))
+ RETURN(0);
- tgt = lmv_find_target(lmv, fid);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ if (tgt == NULL) {
+ tgt = lmv_find_target(lmv, fid);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
+ }
if (tgt->ltd_idx != op_tgt) {
CDEBUG(D_INODE, "EARLY_CANCEL on "DFID"\n", PFID(fid));
op_data->op_fsuid = current_fsuid();
op_data->op_fsgid = 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);
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, op_data, tgt->ltd_idx, LCK_EX,
+ rc = lmv_early_cancel(exp, NULL, op_data, tgt->ltd_idx, LCK_EX,
MDS_INODELOCK_UPDATE, MF_MDC_CANCEL_FID1);
if (rc != 0)
RETURN(rc);
const char *old, int oldlen, const char *new, int newlen,
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_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_tgt_desc *src_tgt;
int rc;
ENTRY;
- LASSERT(oldlen != 0);
+ LASSERT(oldlen != 0);
- CDEBUG(D_INODE, "RENAME %*s in "DFID" to %*s in "DFID"\n",
- oldlen, old, PFID(&op_data->op_fid1),
- newlen, new, PFID(&op_data->op_fid2));
+ CDEBUG(D_INODE, "RENAME %.*s in "DFID":%d to %.*s in "DFID":%d\n",
+ oldlen, old, PFID(&op_data->op_fid1),
+ op_data->op_mea1 ? op_data->op_mea1->lsm_md_stripe_count : 0,
+ newlen, new, PFID(&op_data->op_fid2),
+ op_data->op_mea2 ? op_data->op_mea2->lsm_md_stripe_count : 0);
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ rc = lmv_check_connect(obd);
+ if (rc)
+ RETURN(rc);
op_data->op_fsuid = current_fsuid();
op_data->op_fsgid = current_fsgid();
op_data->op_cap = cfs_curproc_cap_pack();
- src_tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
+ 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));
+ rc = lmv_fid_alloc(exp, &op_data->op_fid2, op_data);
+ if (rc)
+ RETURN(rc);
+ src_tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid3);
+ } else {
+ if (op_data->op_mea1 != NULL) {
+ struct lmv_stripe_md *lsm = op_data->op_mea1;
+
+ src_tgt = lmv_locate_target_for_name(lmv, lsm, old,
+ oldlen,
+ &op_data->op_fid1,
+ &op_data->op_mds);
+ if (IS_ERR(src_tgt))
+ RETURN(PTR_ERR(src_tgt));
+ } else {
+ src_tgt = lmv_find_target(lmv, &op_data->op_fid1);
+ if (IS_ERR(src_tgt))
+ RETURN(PTR_ERR(src_tgt));
+
+ op_data->op_mds = src_tgt->ltd_idx;
+ }
+
+ if (op_data->op_mea2) {
+ struct lmv_stripe_md *lsm = op_data->op_mea2;
+ const struct lmv_oinfo *oinfo;
+
+ oinfo = lsm_name_to_stripe_info(lsm, new, newlen);
+ if (IS_ERR(oinfo))
+ RETURN(PTR_ERR(oinfo));
+
+ op_data->op_fid2 = oinfo->lmo_fid;
+ }
+ }
if (IS_ERR(src_tgt))
RETURN(PTR_ERR(src_tgt));
- tgt_tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid2);
- if (IS_ERR(tgt_tgt))
- RETURN(PTR_ERR(tgt_tgt));
/*
* LOOKUP lock on src child (fid3) should also be cancelled for
* src_tgt in mdc_rename.
* Cancel UPDATE locks on tgt parent (fid2), tgt_tgt is its
* own target.
*/
- rc = lmv_early_cancel(exp, op_data, src_tgt->ltd_idx,
+ rc = lmv_early_cancel(exp, NULL, op_data, src_tgt->ltd_idx,
LCK_EX, MDS_INODELOCK_UPDATE,
MF_MDC_CANCEL_FID2);
+ if (rc != 0)
+ RETURN(rc);
/*
- * Cancel LOOKUP locks on tgt child (fid4) for parent tgt_tgt.
+ * Cancel LOOKUP locks on source child (fid3) for parent tgt_tgt.
*/
- if (rc == 0) {
- rc = lmv_early_cancel(exp, op_data, src_tgt->ltd_idx,
+ if (fid_is_sane(&op_data->op_fid3)) {
+ struct lmv_tgt_desc *tgt;
+
+ tgt = lmv_find_target(lmv, &op_data->op_fid1);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(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_FID4);
+ MF_MDC_CANCEL_FID3);
+ if (rc != 0)
+ RETURN(rc);
+
+ rc = lmv_early_cancel(exp, NULL, op_data, src_tgt->ltd_idx,
+ LCK_EX, MDS_INODELOCK_FULL,
+ MF_MDC_CANCEL_FID3);
+ if (rc != 0)
+ RETURN(rc);
}
/*
* Cancel all the locks on tgt child (fid4).
*/
- if (rc == 0)
- rc = lmv_early_cancel(exp, op_data, src_tgt->ltd_idx,
+ if (fid_is_sane(&op_data->op_fid4))
+ rc = lmv_early_cancel(exp, NULL, op_data, src_tgt->ltd_idx,
LCK_EX, MDS_INODELOCK_FULL,
MF_MDC_CANCEL_FID4);
- if (rc == 0)
- rc = md_rename(src_tgt->ltd_exp, op_data, old, oldlen,
- new, newlen, request);
+ CDEBUG(D_INODE, DFID":m%d to "DFID"\n", PFID(&op_data->op_fid1),
+ op_data->op_mds, PFID(&op_data->op_fid2));
+
+ rc = md_rename(src_tgt->ltd_exp, op_data, old, oldlen, new, newlen,
+ request);
+
RETURN(rc);
}
#define lmv_adjust_dirpages(pages, ncfspgs, nlupgs) do {} while (0)
#endif /* PAGE_CACHE_SIZE > LU_PAGE_SIZE */
-static int lmv_readpage(struct obd_export *exp, struct md_op_data *op_data,
- struct page **pages, struct ptlrpc_request **request)
+#define NORMAL_MAX_STRIPES 4
+int lmv_read_entry(struct obd_export *exp, struct md_op_data *op_data,
+ struct md_callback *cb_op, struct lu_dirent **ldp,
+ struct page **ppage)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
- __u64 offset = op_data->op_offset;
+ struct lmv_stripe_md *lsm = op_data->op_mea1;
+ struct lu_dirent *tmp_ents[NORMAL_MAX_STRIPES];
+ struct lu_dirent **ents = NULL;
+ int stripe_count;
+ __u64 min_hash;
+ int min_idx = 0;
+ struct page *min_page = NULL;
+ int i;
int rc;
- int ncfspgs; /* pages read in PAGE_CACHE_SIZE */
- int nlupgs; /* pages read in LU_PAGE_SIZE */
- struct lmv_tgt_desc *tgt;
ENTRY;
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
- CDEBUG(D_INODE, "READPAGE at "LPX64" from "DFID"\n",
- offset, PFID(&op_data->op_fid1));
+ if (lsm == NULL)
+ stripe_count = 1;
+ else
+ stripe_count = lsm->lsm_md_stripe_count;
+
+ if (stripe_count > NORMAL_MAX_STRIPES) {
+ OBD_ALLOC(ents, sizeof(ents[0]) * stripe_count);
+ if (ents == NULL)
+ GOTO(out, rc = -ENOMEM);
+ } else {
+ ents = tmp_ents;
+ memset(ents, 0, sizeof(ents[0]) * stripe_count);
+ }
- tgt = lmv_find_target(lmv, &op_data->op_fid1);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ min_hash = MDS_DIR_END_OFF;
+ for (i = 0; i < stripe_count; i++) {
+ struct lmv_tgt_desc *tgt;
+ struct page *page = NULL;
- rc = md_readpage(tgt->ltd_exp, op_data, pages, request);
- if (rc != 0)
- RETURN(rc);
+ if (likely(lsm == NULL)) {
+ tgt = lmv_find_target(lmv, &op_data->op_fid1);
+ if (IS_ERR(tgt))
+ GOTO(out, rc = PTR_ERR(tgt));
+ LASSERT(op_data->op_data != NULL);
+ } else {
+ tgt = lmv_get_target(lmv, lsm->lsm_md_oinfo[i].lmo_mds);
+ if (IS_ERR(tgt))
+ GOTO(out, rc = PTR_ERR(tgt));
+ 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_stripe_offset = i;
+ }
- ncfspgs = ((*request)->rq_bulk->bd_nob_transferred +
- PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
- nlupgs = (*request)->rq_bulk->bd_nob_transferred >> LU_PAGE_SHIFT;
- LASSERT(!((*request)->rq_bulk->bd_nob_transferred & ~LU_PAGE_MASK));
- LASSERT(ncfspgs > 0 && ncfspgs <= op_data->op_npages);
+ rc = md_read_entry(tgt->ltd_exp, op_data, cb_op, &ents[i],
+ &page);
+ if (rc != 0)
+ GOTO(out, rc);
+
+ if (ents[i] != NULL &&
+ le64_to_cpu(ents[i]->lde_hash) <= min_hash) {
+ if (min_page != NULL)
+ page_cache_release(min_page);
+ min_page = page;
+ min_hash = le64_to_cpu(ents[i]->lde_hash);
+ min_idx = i;
+ }
+ }
- CDEBUG(D_INODE, "read %d(%d)/%d pages\n", ncfspgs, nlupgs,
- op_data->op_npages);
+ if (min_hash != MDS_DIR_END_OFF)
+ *ldp = ents[min_idx];
+ else
+ *ldp = NULL;
+out:
+ if (stripe_count > NORMAL_MAX_STRIPES && ents != NULL)
+ OBD_FREE(ents, sizeof(ents[0]) * stripe_count);
- lmv_adjust_dirpages(pages, ncfspgs, nlupgs);
+ if (rc != 0 && min_page != NULL) {
+ kunmap(min_page);
+ page_cache_release(min_page);
+ } else {
+ *ppage = min_page;
+ }
RETURN(rc);
}
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;
ENTRY;
RETURN(rc);
retry:
/* Send unlink requests to the MDT where the child is located */
- if (likely(!fid_is_zero(&op_data->op_fid2)))
- tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid2);
- else
+ if (likely(!fid_is_zero(&op_data->op_fid2))) {
+ tgt = lmv_find_target(lmv, &op_data->op_fid2);
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
+
+ /* For striped dir, we need to locate the parent as well */
+ if (op_data->op_mea1 != NULL &&
+ op_data->op_mea1->lsm_md_stripe_count > 1) {
+ struct lmv_tgt_desc *tmp;
+
+ LASSERT(op_data->op_name != NULL &&
+ op_data->op_namelen != 0);
+ tmp = lmv_locate_target_for_name(lmv,
+ op_data->op_mea1,
+ op_data->op_name,
+ op_data->op_namelen,
+ &op_data->op_fid1,
+ &op_data->op_mds);
+ if (IS_ERR(tmp))
+ RETURN(PTR_ERR(tmp));
+ }
+ } else {
tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ if (IS_ERR(tgt))
+ RETURN(PTR_ERR(tgt));
+ }
op_data->op_fsuid = current_fsuid();
op_data->op_fsgid = current_fsgid();
/*
* Cancel FULL locks on child (fid3).
*/
- rc = lmv_early_cancel(exp, op_data, tgt->ltd_idx, LCK_EX,
- MDS_INODELOCK_FULL, MF_MDC_CANCEL_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,
+ 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)
RETURN(rc);
obd_count keylen, void *key, obd_count vallen,
void *val, struct ptlrpc_request_set *set)
{
- struct lmv_tgt_desc *tgt;
+ struct lmv_tgt_desc *tgt = NULL;
struct obd_device *obd;
struct lmv_obd *lmv;
int rc = 0;
RETURN(-EINVAL);
}
-int lmv_packmd(struct obd_export *exp, struct lov_mds_md **lmmp,
- struct lov_stripe_md *lsm)
+static int lmv_pack_md_v1(const struct lmv_stripe_md *lsm,
+ struct lmv_mds_md_v1 *lmm1)
{
- struct obd_device *obd = class_exp2obd(exp);
- struct lmv_obd *lmv = &obd->u.lmv;
- struct lmv_stripe_md *meap;
- struct lmv_stripe_md *lsmp;
- int mea_size;
- __u32 i;
- ENTRY;
+ int cplen;
+ int i;
- mea_size = lmv_get_easize(lmv);
- if (!lmmp)
- RETURN(mea_size);
+ lmm1->lmv_magic = cpu_to_le32(lsm->lsm_md_magic);
+ lmm1->lmv_stripe_count = cpu_to_le32(lsm->lsm_md_stripe_count);
+ lmm1->lmv_master_mdt_index = cpu_to_le32(lsm->lsm_md_master_mdt_index);
+ lmm1->lmv_hash_type = cpu_to_le32(lsm->lsm_md_hash_type);
+ cplen = strlcpy(lmm1->lmv_pool_name, lsm->lsm_md_pool_name,
+ sizeof(lmm1->lmv_pool_name));
+ if (cplen >= sizeof(lmm1->lmv_pool_name))
+ return -E2BIG;
- if (*lmmp && !lsm) {
- OBD_FREE_LARGE(*lmmp, mea_size);
- *lmmp = NULL;
- RETURN(0);
- }
+ for (i = 0; i < lsm->lsm_md_stripe_count; i++)
+ fid_cpu_to_le(&lmm1->lmv_stripe_fids[i],
+ &lsm->lsm_md_oinfo[i].lmo_fid);
+ return 0;
+}
- if (*lmmp == NULL) {
- OBD_ALLOC_LARGE(*lmmp, mea_size);
- if (*lmmp == NULL)
- RETURN(-ENOMEM);
- }
+int lmv_pack_md(union lmv_mds_md **lmmp, const struct lmv_stripe_md *lsm,
+ int stripe_count)
+{
+ int lmm_size = 0;
+ bool allocated = false;
+ int rc = 0;
+ ENTRY;
- if (!lsm)
- RETURN(mea_size);
+ LASSERT(lmmp != NULL);
+ /* Free lmm */
+ if (*lmmp != NULL && lsm == NULL) {
+ int stripe_count;
- lsmp = (struct lmv_stripe_md *)lsm;
- meap = (struct lmv_stripe_md *)*lmmp;
+ stripe_count = lmv_mds_md_stripe_count_get(*lmmp);
+ lmm_size = lmv_mds_md_size(stripe_count,
+ le32_to_cpu((*lmmp)->lmv_magic));
+ if (lmm_size == 0)
+ RETURN(-EINVAL);
+ OBD_FREE(*lmmp, lmm_size);
+ *lmmp = NULL;
+ RETURN(0);
+ }
- if (lsmp->mea_magic != MEA_MAGIC_LAST_CHAR &&
- lsmp->mea_magic != MEA_MAGIC_ALL_CHARS)
- RETURN(-EINVAL);
+ /* Alloc lmm */
+ if (*lmmp == NULL && lsm == NULL) {
+ lmm_size = lmv_mds_md_size(stripe_count, LMV_MAGIC);
+ LASSERT(lmm_size > 0);
+ OBD_ALLOC(*lmmp, lmm_size);
+ if (*lmmp == NULL)
+ RETURN(-ENOMEM);
+ lmv_mds_md_stripe_count_set(*lmmp, stripe_count);
+ (*lmmp)->lmv_magic = cpu_to_le32(LMV_MAGIC);
+ RETURN(lmm_size);
+ }
- meap->mea_magic = cpu_to_le32(lsmp->mea_magic);
- meap->mea_count = cpu_to_le32(lsmp->mea_count);
- meap->mea_master = cpu_to_le32(lsmp->mea_master);
+ /* pack lmm */
+ LASSERT(lsm != NULL);
+ lmm_size = lmv_mds_md_size(lsm->lsm_md_stripe_count, lsm->lsm_md_magic);
+ if (*lmmp == NULL) {
+ OBD_ALLOC(*lmmp, lmm_size);
+ if (*lmmp == NULL)
+ RETURN(-ENOMEM);
+ allocated = true;
+ }
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- meap->mea_ids[i] = lsmp->mea_ids[i];
- fid_cpu_to_le(&meap->mea_ids[i], &lsmp->mea_ids[i]);
+ switch (lsm->lsm_md_magic) {
+ case LMV_MAGIC_V1:
+ rc = lmv_pack_md_v1(lsm, &(*lmmp)->lmv_md_v1);
+ break;
+ default:
+ rc = -EINVAL;
+ break;
+ }
+
+ if (rc != 0 && allocated) {
+ OBD_FREE(*lmmp, lmm_size);
+ *lmmp = NULL;
}
- RETURN(mea_size);
+ RETURN(lmm_size);
}
+EXPORT_SYMBOL(lmv_pack_md);
-int lmv_unpackmd(struct obd_export *exp, struct lov_stripe_md **lsmp,
- struct lov_mds_md *lmm, int lmm_size)
+static int lmv_unpack_md_v1(struct obd_export *exp, struct lmv_stripe_md *lsm,
+ const struct lmv_mds_md_v1 *lmm1)
{
- struct obd_device *obd = class_exp2obd(exp);
- struct lmv_stripe_md **tmea = (struct lmv_stripe_md **)lsmp;
- struct lmv_stripe_md *mea = (struct lmv_stripe_md *)lmm;
- struct lmv_obd *lmv = &obd->u.lmv;
- int mea_size;
- __u32 i;
- __u32 magic;
- ENTRY;
+ struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
+ int stripe_count;
+ int cplen;
+ int i;
+ int rc = 0;
+ ENTRY;
+
+ lsm->lsm_md_magic = le32_to_cpu(lmm1->lmv_magic);
+ lsm->lsm_md_stripe_count = le32_to_cpu(lmm1->lmv_stripe_count);
+ lsm->lsm_md_master_mdt_index = le32_to_cpu(lmm1->lmv_master_mdt_index);
+ lsm->lsm_md_hash_type = le32_to_cpu(lmm1->lmv_hash_type);
+ lsm->lsm_md_layout_version = le32_to_cpu(lmm1->lmv_layout_version);
+ 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"
+ "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);
+
+ stripe_count = le32_to_cpu(lmm1->lmv_stripe_count);
+ for (i = 0; i < le32_to_cpu(stripe_count); i++) {
+ fid_le_to_cpu(&lsm->lsm_md_oinfo[i].lmo_fid,
+ &lmm1->lmv_stripe_fids[i]);
+ rc = lmv_fld_lookup(lmv, &lsm->lsm_md_oinfo[i].lmo_fid,
+ &lsm->lsm_md_oinfo[i].lmo_mds);
+ if (rc != 0)
+ RETURN(rc);
+ CDEBUG(D_INFO, "unpack fid #%d "DFID"\n", i,
+ PFID(&lsm->lsm_md_oinfo[i].lmo_fid));
+ }
- mea_size = lmv_get_easize(lmv);
- if (lsmp == NULL)
- return mea_size;
+ RETURN(rc);
+}
- if (*lsmp != NULL && lmm == NULL) {
- OBD_FREE_LARGE(*tmea, mea_size);
- *lsmp = NULL;
- RETURN(0);
- }
+int lmv_unpack_md(struct obd_export *exp, struct lmv_stripe_md **lsmp,
+ const union lmv_mds_md *lmm, int stripe_count)
+{
+ struct lmv_stripe_md *lsm;
+ int lsm_size;
+ int rc;
+ bool allocated = false;
+ ENTRY;
- LASSERT(mea_size == lmm_size);
+ LASSERT(lsmp != NULL);
- OBD_ALLOC_LARGE(*tmea, mea_size);
- if (*tmea == NULL)
- RETURN(-ENOMEM);
+ lsm = *lsmp;
+ /* Free memmd */
+ if (lsm != NULL && lmm == NULL) {
+#ifdef __KERNEL__
+ int i;
+ for (i = 1; i < lsm->lsm_md_stripe_count; i++) {
+ if (lsm->lsm_md_oinfo[i].lmo_root != NULL)
+ iput(lsm->lsm_md_oinfo[i].lmo_root);
+ }
+#endif
+ lsm_size = lmv_stripe_md_size(lsm->lsm_md_stripe_count);
+ OBD_FREE(lsm, lsm_size);
+ *lsmp = NULL;
+ RETURN(0);
+ }
- if (!lmm)
- RETURN(mea_size);
+ /* Alloc memmd */
+ if (lsm == NULL && lmm == NULL) {
+ lsm_size = lmv_stripe_md_size(stripe_count);
+ OBD_ALLOC(lsm, lsm_size);
+ if (lsm == NULL)
+ RETURN(-ENOMEM);
+ lsm->lsm_md_stripe_count = stripe_count;
+ *lsmp = lsm;
+ RETURN(0);
+ }
- if (mea->mea_magic == MEA_MAGIC_LAST_CHAR ||
- mea->mea_magic == MEA_MAGIC_ALL_CHARS ||
- mea->mea_magic == MEA_MAGIC_HASH_SEGMENT)
- {
- magic = le32_to_cpu(mea->mea_magic);
- } else {
- /*
- * Old mea is not handled here.
- */
- CERROR("Old not supportable EA is found\n");
- LBUG();
- }
+ /* Unpack memmd */
+ if (le32_to_cpu(lmm->lmv_magic) != LMV_MAGIC_V1 &&
+ le32_to_cpu(lmm->lmv_magic) != LMV_MAGIC_MIGRATE &&
+ le32_to_cpu(lmm->lmv_magic) != LMV_USER_MAGIC) {
+ CERROR("%s: invalid lmv magic %x: rc = %d\n",
+ exp->exp_obd->obd_name, le32_to_cpu(lmm->lmv_magic),
+ -EIO);
+ RETURN(-EIO);
+ }
- (*tmea)->mea_magic = magic;
- (*tmea)->mea_count = le32_to_cpu(mea->mea_count);
- (*tmea)->mea_master = le32_to_cpu(mea->mea_master);
+ if (le32_to_cpu(lmm->lmv_magic) == LMV_MAGIC_V1 ||
+ le32_to_cpu(lmm->lmv_magic) == LMV_MAGIC_MIGRATE)
+ lsm_size = lmv_stripe_md_size(lmv_mds_md_stripe_count_get(lmm));
+ else
+ /**
+ * Unpack default dirstripe(lmv_user_md) to lmv_stripe_md,
+ * stripecount should be 0 then.
+ */
+ lsm_size = lmv_stripe_md_size(0);
- for (i = 0; i < (*tmea)->mea_count; i++) {
- (*tmea)->mea_ids[i] = mea->mea_ids[i];
- fid_le_to_cpu(&(*tmea)->mea_ids[i], &(*tmea)->mea_ids[i]);
- }
- RETURN(mea_size);
+ lsm_size = lmv_stripe_md_size(lmv_mds_md_stripe_count_get(lmm));
+ if (lsm == NULL) {
+ OBD_ALLOC(lsm, lsm_size);
+ if (lsm == NULL)
+ RETURN(-ENOMEM);
+ allocated = true;
+ *lsmp = lsm;
+ }
+
+ switch (le32_to_cpu(lmm->lmv_magic)) {
+ case LMV_MAGIC_V1:
+ case LMV_MAGIC_MIGRATE:
+ rc = lmv_unpack_md_v1(exp, lsm, &lmm->lmv_md_v1);
+ break;
+ default:
+ CERROR("%s: unrecognized magic %x\n", exp->exp_obd->obd_name,
+ le32_to_cpu(lmm->lmv_magic));
+ rc = -EINVAL;
+ break;
+ }
+
+ if (rc != 0 && allocated) {
+ OBD_FREE(lsm, lsm_size);
+ *lsmp = NULL;
+ lsm_size = rc;
+ }
+ RETURN(lsm_size);
+}
+
+int lmv_alloc_memmd(struct lmv_stripe_md **lsmp, int stripes)
+{
+ return lmv_unpack_md(NULL, lsmp, NULL, stripes);
+}
+EXPORT_SYMBOL(lmv_alloc_memmd);
+
+void lmv_free_memmd(struct lmv_stripe_md *lsm)
+{
+ lmv_unpack_md(NULL, &lsm, NULL, 0);
+}
+EXPORT_SYMBOL(lmv_free_memmd);
+
+int lmv_unpackmd(struct obd_export *exp, struct lov_stripe_md **lsmp,
+ struct lov_mds_md *lmm, int disk_len)
+{
+ return lmv_unpack_md(exp, (struct lmv_stripe_md **)lsmp,
+ (union lmv_mds_md *)lmm, disk_len);
+}
+
+int lmv_packmd(struct obd_export *exp, struct lov_mds_md **lmmp,
+ struct lov_stripe_md *lsm)
+{
+ struct obd_device *obd = exp->exp_obd;
+ struct lmv_obd *lmv_obd = &obd->u.lmv;
+ const struct lmv_stripe_md *lmv = (struct lmv_stripe_md *)lsm;
+ int stripe_count;
+
+ if (lmmp == NULL) {
+ if (lsm != NULL)
+ stripe_count = lmv->lsm_md_stripe_count;
+ else
+ stripe_count = lmv_obd->desc.ld_tgt_count;
+
+ return lmv_mds_md_size(stripe_count, LMV_MAGIC_V1);
+ }
+
+ return lmv_pack_md((union lmv_mds_md **)lmmp, lmv, 0);
}
static int lmv_cancel_unused(struct obd_export *exp, const struct lu_fid *fid,
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_obd *lmv = &exp->exp_obd->u.lmv;
struct lmv_tgt_desc *tgt = lmv->tgts[0];
if (tgt == NULL || tgt->ltd_exp == NULL)
RETURN(-EINVAL);
- return md_get_lustre_md(tgt->ltd_exp, req, dt_exp, md_exp, md);
+
+ return md_get_lustre_md(lmv->tgts[0]->ltd_exp, req, dt_exp, md_exp, md);
}
int lmv_free_lustre_md(struct obd_export *exp, struct lustre_md *md)
struct lmv_tgt_desc *tgt = lmv->tgts[0];
ENTRY;
- if (md->mea)
- obd_free_memmd(exp, (void *)&md->mea);
+ if (md->lmv != NULL) {
+ lmv_free_memmd(md->lmv);
+ md->lmv = NULL;
+ }
if (tgt == NULL || tgt->ltd_exp == NULL)
RETURN(-EINVAL);
- RETURN(md_free_lustre_md(tgt->ltd_exp, md));
+ RETURN(md_free_lustre_md(lmv->tgts[0]->ltd_exp, md));
}
int lmv_set_open_replay_data(struct obd_export *exp,
if (rc)
RETURN(rc);
- tgt = lmv_find_target(lmv, &op_data->op_fid1);
+ tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
RETURN(rc);
}
+int lmv_update_lsm_md(struct obd_export *exp, struct lmv_stripe_md *lsm,
+ struct mdt_body *body, ldlm_blocking_callback cb_blocking)
+{
+ if (lsm->lsm_md_stripe_count <= 1)
+ return 0;
+
+ return lmv_revalidate_slaves(exp, body, lsm, cb_blocking, 0);
+}
+
+int lmv_merge_attr(struct obd_export *exp, const struct lmv_stripe_md *lsm,
+ struct cl_attr *attr)
+{
+#ifdef __KERNEL__
+ int i;
+
+ 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, nlink %u, atime %lu ctime"
+ "%lu, mtime %lu.\n", PFID(&lsm->lsm_md_oinfo[i].lmo_fid),
+ i_size_read(inode), inode->i_nlink,
+ LTIME_S(inode->i_atime), LTIME_S(inode->i_ctime),
+ LTIME_S(inode->i_mtime));
+
+ /* for slave stripe, it needs to subtract nlink for . and .. */
+ if (i != 0)
+ attr->cat_nlink += inode->i_nlink - 2;
+ else
+ attr->cat_nlink = inode->i_nlink;
+
+ attr->cat_size += i_size_read(inode);
+
+ if (attr->cat_atime < LTIME_S(inode->i_atime))
+ attr->cat_atime = LTIME_S(inode->i_atime);
+
+ if (attr->cat_ctime < LTIME_S(inode->i_ctime))
+ attr->cat_ctime = LTIME_S(inode->i_ctime);
+
+ if (attr->cat_mtime < LTIME_S(inode->i_mtime))
+ attr->cat_mtime = LTIME_S(inode->i_mtime);
+ }
+#endif
+ return 0;
+}
+
struct obd_ops lmv_obd_ops = {
.o_owner = THIS_MODULE,
.o_setup = lmv_setup,
.m_setattr = lmv_setattr,
.m_setxattr = lmv_setxattr,
.m_fsync = lmv_fsync,
- .m_readpage = lmv_readpage,
+ .m_read_entry = lmv_read_entry,
.m_unlink = lmv_unlink,
.m_init_ea_size = lmv_init_ea_size,
.m_cancel_unused = lmv_cancel_unused,
.m_set_lock_data = lmv_set_lock_data,
.m_lock_match = lmv_lock_match,
- .m_get_lustre_md = lmv_get_lustre_md,
- .m_free_lustre_md = lmv_free_lustre_md,
+ .m_get_lustre_md = lmv_get_lustre_md,
+ .m_free_lustre_md = lmv_free_lustre_md,
+ .m_update_lsm_md = lmv_update_lsm_md,
+ .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_renew_capa = lmv_renew_capa,
int __init lmv_init(void)
{
- struct lprocfs_static_vars lvars;
- int rc;
-
- lprocfs_lmv_init_vars(&lvars);
-
- rc = class_register_type(&lmv_obd_ops, &lmv_md_ops,
- lvars.module_vars, LUSTRE_LMV_NAME, NULL);
- return rc;
+ return class_register_type(&lmv_obd_ops, &lmv_md_ops, NULL,
+#ifndef HAVE_ONLY_PROCFS_SEQ
+ NULL,
+#endif
+ LUSTRE_LMV_NAME, NULL);
}
#ifdef __KERNEL__
git://git.whamcloud.com / fs / lustre-release.git / blobdiff