* Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2011, 2015, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#include <lustre_kernelcomm.h>
#include "lmv_internal.h"
+static int lmv_check_connect(struct obd_device *obd);
+
static void lmv_activate_target(struct lmv_obd *lmv,
struct lmv_tgt_desc *tgt,
int activate)
tgt->ltd_active = activate;
lmv->desc.ld_active_tgt_count += (activate ? 1 : -1);
+
+ tgt->ltd_exp->exp_obd->obd_inactive = !activate;
}
/**
*/
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.
*/
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;
-
- /*
- * 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);
- }
+ struct lmv_obd *lmv = &obd->u.lmv;
+ struct lustre_handle conn = { 0 };
+ struct obd_export *exp;
+ int rc;
+ ENTRY;
- *exp = class_conn2export(&conn);
- class_export_get(*exp);
+ rc = class_connect(&conn, obd, cluuid);
+ if (rc) {
+ CERROR("class_connection() returned %d\n", rc);
+ RETURN(rc);
+ }
- lmv->exp = *exp;
- lmv->connected = 0;
- lmv->cluuid = *cluuid;
+ exp = class_conn2export(&conn);
- if (data)
- lmv->conn_data = *data;
+ lmv->connected = 0;
+ lmv->cluuid = *cluuid;
+ lmv->conn_data = *data;
if (lmv->targets_proc_entry == NULL) {
lmv->targets_proc_entry = lprocfs_register("target_obds",
}
}
- /*
- * 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_proc, rc);
+
+ *pexp = exp;
- if (rc && lmv->targets_proc_entry != NULL)
- lprocfs_remove(&lmv->targets_proc_entry);
RETURN(rc);
+
+out_proc:
+ if (lmv->targets_proc_entry != NULL)
+ lprocfs_remove(&lmv->targets_proc_entry);
+
+ class_disconnect(exp);
+
+ return rc;
}
static int lmv_init_ea_size(struct obd_export *exp, __u32 easize,
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;
GOTO(out_disc, rc);
}
- 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);
}
}
}
- class_disconnect(lmv->exp);
+
mutex_unlock(&lmv->lmv_init_mutex);
- RETURN(rc);
+
+ RETURN(rc);
}
static int lmv_disconnect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt)
if (!lmv->tgts)
goto out_local;
- /*
- * Only disconnect the underlying layers on the final disconnect.
- */
- lmv->refcount--;
- if (lmv->refcount != 0)
- goto out_local;
-
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);
- if (lmv->refcount == 0)
- lmv->connected = 0;
- RETURN(rc);
+ lmv->connected = 0;
+
+ RETURN(rc);
}
-static int lmv_fid2path(struct obd_export *exp, int len, void *karg, void *uarg)
+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 getinfo_fid2path *remote_gf = NULL;
+ struct lu_fid root_fid;
int remote_gf_size = 0;
int rc;
- gf = (struct getinfo_fid2path *)karg;
+ gf = karg;
tgt = lmv_find_target(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)
char *ptr;
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) +
+ strlen(gf->gf_u.gf_path) > ori_gf->gf_pathlen)
GOTO(out_fid2path, rc = -EOVERFLOW);
- ptr = ori_gf->gf_path;
+ ptr = ori_gf->gf_u.gf_path;
- memmove(ptr + strlen(gf->gf_path) + 1, ptr,
- strlen(ori_gf->gf_path));
+ memmove(ptr + strlen(gf->gf_u.gf_path) + 1, ptr,
+ strlen(ori_gf->gf_u.gf_path));
- strncpy(ptr, gf->gf_path, strlen(gf->gf_path));
- ptr += strlen(gf->gf_path);
+ strncpy(ptr, gf->gf_u.gf_path,
+ strlen(gf->gf_u.gf_path));
+ ptr += strlen(gf->gf_u.gf_path);
*ptr = '/';
}
CDEBUG(D_INFO, "%s: get path %s "DFID" rec: "LPU64" 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)
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;
/* 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);
+ 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)
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);
+ 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)
+ struct lustre_kernelcomm *lk,
+ void __user *uarg)
{
- __u32 i;
- int rc;
- struct kkuc_ct_data *kcd = NULL;
+ __u32 i;
+ int rc;
ENTRY;
/* unregister request (call from llapi_hsm_copytool_fini) */
* Unreached coordinators will get EPIPE on next requests
* and will unregister automatically.
*/
- rc = libcfs_kkuc_group_rem(lk->lk_uid, lk->lk_group, (void **)&kcd);
- if (kcd != NULL)
- OBD_FREE_PTR(kcd);
+ rc = libcfs_kkuc_group_rem(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)
+ struct lustre_kernelcomm *lk, __user void *uarg)
{
struct file *filp;
__u32 i, j;
int err, rc;
bool any_set = false;
- struct kkuc_ct_data *kcd;
+ struct kkuc_ct_data kcd = { 0 };
ENTRY;
/* All or nothing: try to register to all MDS.
/* permanent error */
CERROR("%s: iocontrol MDC %s on MDT"
" idx %d cmd %x: err = %d\n",
- class_exp2obd(lmv->exp)->obd_name,
+ lmv2obd_dev(lmv)->obd_name,
tgt->ltd_uuid.uuid, i, cmd, err);
rc = err;
lk->lk_flags |= LK_FLG_STOP;
if (filp == NULL)
RETURN(-EBADF);
- OBD_ALLOC_PTR(kcd);
- if (kcd == NULL) {
- fput(filp);
- RETURN(-ENOMEM);
- }
- kcd->kcd_magic = KKUC_CT_DATA_MAGIC;
- kcd->kcd_uuid = lmv->cluuid;
- kcd->kcd_archive = lk->lk_data;
+ kcd.kcd_magic = KKUC_CT_DATA_MAGIC;
+ kcd.kcd_uuid = lmv->cluuid;
+ kcd.kcd_archive = lk->lk_data;
- rc = libcfs_kkuc_group_add(filp, lk->lk_uid, lk->lk_group, kcd);
- if (rc != 0) {
- if (filp != NULL)
- fput(filp);
- OBD_FREE_PTR(kcd);
- }
+ rc = libcfs_kkuc_group_add(filp, lk->lk_uid, lk->lk_group,
+ &kcd, sizeof(kcd));
+ if (rc != 0)
+ fput(filp);
RETURN(rc);
}
static int lmv_iocontrol(unsigned int cmd, struct obd_export *exp,
- int len, void *karg, void *uarg)
+ int len, void *karg, void __user *uarg)
{
struct obd_device *obddev = class_exp2obd(exp);
struct lmv_obd *lmv = &obddev->u.lmv;
} else {
/* split fid list to their respective MDS */
for (i = 0; i < count; i++) {
- unsigned int nr, reqlen;
- int rc1;
+ int nr, rc1;
+ size_t reqlen;
struct hsm_user_request *req;
tgt = lmv->tgts[i];
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);
RETURN(rc);
}
-#if 0
-static int lmv_all_chars_policy(int count, const char *name,
- int len)
-{
- unsigned int c = 0;
-
- while (len > 0)
- c += name[--len];
- c = c % count;
- return c;
-}
-
-static int lmv_nid_policy(struct lmv_obd *lmv)
-{
- struct obd_import *imp;
- __u32 id;
-
- /*
- * 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;
-}
-
-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);
-
- default:
- break;
- }
-
- CERROR("Unsupported placement policy %x\n", placement);
- return -EINVAL;
-}
-#endif
-
/**
* This is _inode_ placement policy function (not name).
*/
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);
__u32 i;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
OBD_ALLOC(temp, sizeof(*temp));
if (temp == NULL)
RETURN(-ENOMEM);
return rc;
}
-static int lmv_getstatus(struct obd_export *exp, struct lu_fid *fid)
+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;
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
- rc = md_getstatus(lmv->tgts[0]->ltd_exp, fid);
+ rc = md_get_root(lmv->tgts[0]->ltd_exp, fileset, fid);
RETURN(rc);
}
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
tgt = lmv_find_target(lmv, fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
tgt = lmv_find_target(lmv, fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
tgt = lmv_find_target(lmv, &op_data->op_fid1);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
__u32 i;
- int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
CDEBUG(D_INODE, "CBDATA for "DFID"\n", PFID(fid));
/*
RETURN(0);
}
-static int lmv_find_cbdata(struct obd_export *exp, const struct lu_fid *fid,
- ldlm_iterator_t it, void *data)
-{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- int i;
- int tgt;
- int rc;
- ENTRY;
-
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
- 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. 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;
- }
-
- if (lmv->tgts[tgt] == NULL ||
- lmv->tgts[tgt]->ltd_exp == NULL)
- continue;
-
- rc = md_find_cbdata(lmv->tgts[tgt]->ltd_exp, fid, it, data);
- if (rc)
- RETURN(rc);
- }
-
- RETURN(rc);
-}
-
-
static int lmv_close(struct obd_export *exp, struct md_op_data *op_data,
struct md_open_data *mod, struct ptlrpc_request **request)
{
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
tgt = lmv_find_target(lmv, &op_data->op_fid1);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
* 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 && lsm != NULL) {
+ (int)op_data->op_mds != -1) {
int i;
tgt = lmv_get_target(lmv, op_data->op_mds, NULL);
if (IS_ERR(tgt))
return tgt;
- /* refill the right parent fid */
- for (i = 0; i < lsm->lsm_md_stripe_count; i++) {
- struct lmv_oinfo *oinfo;
+ 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;
- break;
+ oinfo = &lsm->lsm_md_oinfo[i];
+ if (oinfo->lmo_mds == op_data->op_mds) {
+ *fid = oinfo->lmo_fid;
+ break;
+ }
}
- }
- /* Hmm, can not find the stripe by mdt_index(op_mds) */
- if (i == lsm->lsm_md_stripe_count)
- tgt = ERR_PTR(-EINVAL);
+ if (i == lsm->lsm_md_stripe_count)
+ *fid = lsm->lsm_md_oinfo[0].lmo_fid;
+ }
return tgt;
}
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
if (!lmv->desc.ld_active_tgt_count)
RETURN(-EIO);
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
CDEBUG(D_INODE, "ENQUEUE '%s' on "DFID"\n",
LL_IT2STR(it), PFID(&op_data->op_fid1));
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
NULL)
static int lmv_early_cancel(struct obd_export *exp, struct lmv_tgt_desc *tgt,
- struct md_op_data *op_data,
- __u32 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;
- ldlm_policy_data_t policy = {{ 0 }};
- int rc = 0;
+ struct md_op_data *op_data, __u32 op_tgt,
+ enum ldlm_mode mode, int bits, int flag)
+{
+ struct lu_fid *fid = md_op_data_fid(op_data, flag);
+ struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
+ union ldlm_policy_data policy = { { 0 } };
+ int rc = 0;
ENTRY;
if (!fid_is_sane(fid))
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",
(int)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);
-
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();
int rc = 0;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
CDEBUG(D_INODE, "SETATTR for "DFID", valid 0x%x\n",
PFID(&op_data->op_fid1), op_data->op_attr.ia_valid);
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc != 0)
- RETURN(rc);
-
tgt = lmv_find_target(lmv, fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
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;
int rc;
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);
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc != 0)
- RETURN(rc);
-
if (unlikely(lsm != NULL)) {
rc = lmv_read_striped_page(exp, op_data, cb_op, offset, ppage);
RETURN(rc);
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) {
goto retry_unlink;
}
-static int lmv_precleanup(struct obd_device *obd, enum obd_cleanup_stage stage)
+static int lmv_precleanup(struct obd_device *obd)
{
- struct lmv_obd *lmv = &obd->u.lmv;
- int rc = 0;
-
- switch (stage) {
- case OBD_CLEANUP_EARLY:
- /* XXX: here should be calling obd_precleanup() down to
- * stack. */
- break;
- case OBD_CLEANUP_EXPORTS:
- fld_client_proc_fini(&lmv->lmv_fld);
- lprocfs_obd_cleanup(obd);
- lprocfs_free_md_stats(obd);
- break;
- default:
- break;
- }
- RETURN(rc);
+ ENTRY;
+ fld_client_proc_fini(&obd->u.lmv.lmv_fld);
+ lprocfs_obd_cleanup(obd);
+ lprocfs_free_md_stats(obd);
+ RETURN(0);
}
/**
if (keylen >= strlen("remote_flag") && !strcmp(key, "remote_flag")) {
int i;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
LASSERT(*vallen == sizeof(__u32));
for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
struct lmv_tgt_desc *tgt = lmv->tgts[i];
} 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.
EXPORT_SYMBOL(lmv_free_memmd);
static int lmv_cancel_unused(struct obd_export *exp, const struct lu_fid *fid,
- ldlm_policy_data_t *policy, ldlm_mode_t mode,
- ldlm_cancel_flags_t flags, void *opaque)
+ union ldlm_policy_data *policy,
+ enum ldlm_mode mode, enum ldlm_cancel_flags flags,
+ void *opaque)
{
- struct obd_device *obd = exp->exp_obd;
- struct lmv_obd *lmv = &obd->u.lmv;
- int rc = 0;
- int err;
- __u32 i;
- ENTRY;
+ struct lmv_obd *lmv = &exp->exp_obd->u.lmv;
+ int rc = 0;
+ __u32 i;
+ ENTRY;
- LASSERT(fid != NULL);
+ 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)
continue;
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];
RETURN(rc);
}
-ldlm_mode_t lmv_lock_match(struct obd_export *exp, __u64 flags,
- const struct lu_fid *fid, ldlm_type_t type,
- ldlm_policy_data_t *policy, ldlm_mode_t mode,
- struct lustre_handle *lockh)
+enum ldlm_mode lmv_lock_match(struct obd_export *exp, __u64 flags,
+ const struct lu_fid *fid, enum ldlm_type type,
+ 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;
- ldlm_mode_t rc;
+ enum ldlm_mode rc;
int tgt;
int i;
ENTRY;
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_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)
- RETURN(rc);
-
- tgt = lmv_find_target(lmv, fid);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
-
- rc = md_get_remote_perm(tgt->ltd_exp, fid, suppgid, request);
- RETURN(rc);
-}
-
int lmv_intent_getattr_async(struct obd_export *exp,
- struct md_enqueue_info *minfo,
- struct ldlm_enqueue_info *einfo)
+ 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 *tgt = NULL;
+ struct lmv_tgt_desc *ptgt = NULL;
+ struct lmv_tgt_desc *ctgt = NULL;
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
+ if (!fid_is_sane(&op_data->op_fid2))
+ RETURN(-EINVAL);
- tgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
- if (IS_ERR(tgt))
- RETURN(PTR_ERR(tgt));
+ ptgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid1);
+ if (IS_ERR(ptgt))
+ RETURN(PTR_ERR(ptgt));
+
+ ctgt = lmv_locate_mds(lmv, op_data, &op_data->op_fid2);
+ if (IS_ERR(ctgt))
+ RETURN(PTR_ERR(ctgt));
- rc = md_intent_getattr_async(tgt->ltd_exp, minfo, einfo);
+ /*
+ * 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.
+ */
+ if (ptgt != ctgt)
+ RETURN(-ENOTSUPP);
+
+ rc = md_intent_getattr_async(ptgt->ltd_exp, minfo);
RETURN(rc);
}
int rc;
ENTRY;
- rc = lmv_check_connect(obd);
- if (rc)
- RETURN(rc);
-
tgt = lmv_find_target(lmv, fid);
if (IS_ERR(tgt))
RETURN(PTR_ERR(tgt));
};
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_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,
};
-int __init lmv_init(void)
+static int __init lmv_init(void)
{
return class_register_type(&lmv_obd_ops, &lmv_md_ops, true, NULL,
LUSTRE_LMV_NAME, NULL);
}
-static void lmv_exit(void)
+static void __exit lmv_exit(void)
{
- class_unregister_type(LUSTRE_LMV_NAME);
+ class_unregister_type(LUSTRE_LMV_NAME);
}
-MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
-MODULE_DESCRIPTION("Lustre Logical Metadata Volume OBD driver");
+MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
+MODULE_DESCRIPTION("Lustre Logical Metadata Volume");
+MODULE_VERSION(LUSTRE_VERSION_STRING);
MODULE_LICENSE("GPL");
module_init(lmv_init);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff