int (*o_fid_alloc)(struct obd_export *exp, struct lu_fid *fid,
struct lu_placement_hint *hint);
- int (*o_fid_delete)(struct obd_export *exp, struct lu_fid *fid);
+ int (*o_fid_delete)(struct obd_export *exp, const struct lu_fid *fid);
int (*o_statfs)(struct obd_device *obd, struct obd_statfs *osfs,
__u64 max_age);
int (*o_llog_finish)(struct obd_device *obd, int count);
/* metadata-only methods */
- int (*o_pin)(struct obd_export *, struct lu_fid *fid,
+ int (*o_pin)(struct obd_export *, const struct lu_fid *fid,
struct obd_client_handle *, int flag);
int (*o_unpin)(struct obd_export *, struct obd_client_handle *, int);
struct md_ops {
int (*m_getstatus)(struct obd_export *, struct lu_fid *);
- int (*m_change_cbdata)(struct obd_export *, struct lu_fid *,
+ int (*m_change_cbdata)(struct obd_export *, const struct lu_fid *,
ldlm_iterator_t, void *);
int (*m_close)(struct obd_export *, struct md_op_data *,
struct obd_client_handle *, struct ptlrpc_request **);
int, struct md_op_data *, struct lustre_handle *,
void *, int, ldlm_completion_callback,
ldlm_blocking_callback, void *, int);
- int (*m_getattr)(struct obd_export *, struct lu_fid *,
+ int (*m_getattr)(struct obd_export *, const struct lu_fid *,
obd_valid, int, struct ptlrpc_request **);
- int (*m_getattr_name)(struct obd_export *, struct lu_fid *,
+ int (*m_getattr_name)(struct obd_export *, const struct lu_fid *,
const char *, int, obd_valid,
int, struct ptlrpc_request **);
int (*m_intent_lock)(struct obd_export *, struct md_op_data *,
int (*m_setattr)(struct obd_export *, struct md_op_data *,
struct iattr *, void *, int , void *, int,
struct ptlrpc_request **);
- int (*m_sync)(struct obd_export *, struct lu_fid *,
+ int (*m_sync)(struct obd_export *, const struct lu_fid *,
struct ptlrpc_request **);
- int (*m_readpage)(struct obd_export *, struct lu_fid *,
+ int (*m_readpage)(struct obd_export *, const struct lu_fid *,
__u64, struct page *, struct ptlrpc_request **);
int (*m_unlink)(struct obd_export *, struct md_op_data *,
struct ptlrpc_request **);
- int (*m_setxattr)(struct obd_export *, struct lu_fid *,
+ int (*m_setxattr)(struct obd_export *, const struct lu_fid *,
obd_valid, const char *, const char *,
int, int, int, struct ptlrpc_request **);
- int (*m_getxattr)(struct obd_export *, struct lu_fid *,
+ int (*m_getxattr)(struct obd_export *, const struct lu_fid *,
obd_valid, const char *, const char *,
int, int, int, struct ptlrpc_request **);
struct obd_client_handle *);
int (*m_set_lock_data)(struct obd_export *, __u64 *, void *);
- int (*m_lock_match)(struct obd_export *, int, struct lu_fid *,
+ int (*m_lock_match)(struct obd_export *, int, const struct lu_fid *,
ldlm_type_t, ldlm_policy_data_t *, ldlm_mode_t,
struct lustre_handle *);
- int (*m_cancel_unused)(struct obd_export *, struct lu_fid *,
+ int (*m_cancel_unused)(struct obd_export *, const struct lu_fid *,
int flags, void *opaque);
/*
}
static inline int obd_fid_delete(struct obd_export *exp,
- struct lu_fid *fid)
+ const struct lu_fid *fid)
{
int rc;
ENTRY;
return(rc);
}
-static inline int obd_pin(struct obd_export *exp, struct lu_fid *fid,
+static inline int obd_pin(struct obd_export *exp, const struct lu_fid *fid,
struct obd_client_handle *handle, int flag)
{
int rc;
}
/* metadata helpers */
-static inline int md_getstatus(struct obd_export *exp, struct lu_fid *fid)
+static inline int md_getstatus(struct obd_export *exp,
+ struct lu_fid *fid)
{
int rc;
ENTRY;
RETURN(rc);
}
-static inline int md_getattr(struct obd_export *exp, struct lu_fid *fid,
+static inline int md_getattr(struct obd_export *exp,
+ const struct lu_fid *fid,
obd_valid valid, int ea_size,
struct ptlrpc_request **request)
{
RETURN(rc);
}
-static inline int md_change_cbdata(struct obd_export *exp, struct lu_fid *fid,
+static inline int md_change_cbdata(struct obd_export *exp,
+ const struct lu_fid *fid,
ldlm_iterator_t it, void *data)
{
int rc;
RETURN(rc);
}
-static inline int md_getattr_name(struct obd_export *exp, struct lu_fid *fid,
+static inline int md_getattr_name(struct obd_export *exp,
+ const struct lu_fid *fid,
const char *filename, int namelen,
obd_valid valid, int ea_size,
struct ptlrpc_request **request)
RETURN(rc);
}
-static inline int md_sync(struct obd_export *exp, struct lu_fid *fid,
+static inline int md_sync(struct obd_export *exp,
+ const struct lu_fid *fid,
struct ptlrpc_request **request)
{
int rc;
RETURN(rc);
}
-static inline int md_readpage(struct obd_export *exp, struct lu_fid *fid,
+static inline int md_readpage(struct obd_export *exp,
+ const struct lu_fid *fid,
__u64 offset, struct page *page,
struct ptlrpc_request **request)
{
RETURN(MDP(exp->exp_obd, free_lustre_md)(exp, md));
}
-static inline int md_setxattr(struct obd_export *exp, struct lu_fid *fid,
+static inline int md_setxattr(struct obd_export *exp,
+ const struct lu_fid *fid,
obd_valid valid, const char *name,
const char *input, int input_size,
int output_size, int flags,
request));
}
-static inline int md_getxattr(struct obd_export *exp, struct lu_fid *fid,
+static inline int md_getxattr(struct obd_export *exp,
+ const struct lu_fid *fid,
obd_valid valid, const char *name,
const char *input, int input_size,
int output_size, int flags,
}
static inline int md_cancel_unused(struct obd_export *exp,
- struct lu_fid *fid,
+ const struct lu_fid *fid,
int flags, void *opaque)
{
int rc;
}
static inline int md_lock_match(struct obd_export *exp, int flags,
- struct lu_fid *fid, ldlm_type_t type,
+ const struct lu_fid *fid, ldlm_type_t type,
ldlm_policy_data_t *policy, ldlm_mode_t mode,
struct lustre_handle *lockh)
{
struct lu_fid *ifid = &ll_i2info(inode)->lli_fid;
struct lu_fid *lfid = opaque;
- if (memcmp(ifid, lfid, sizeof(struct lu_fid)) == 0)
+ if (lu_fid_eq(ifid, lfid))
return 1;
return 0;
static void ll_fid_to_fh(struct lu_fid *fid, __u32 *mode, __u32 *datap)
{
+ __u64 *seq = (__u64 *)datap;
+
/* packing ->f_seq */
- *datap++ = (__u32)(fid_seq(fid) >> 32);
- *datap++ = (__u32)(fid_seq(fid) & 0x00000000ffffffff);
-
+ *seq = fid_seq(fid);
+ datap += 2;
+
/* packing ->f_num */
*datap++ = fid_ver(fid);
*datap++ = fid_oid(fid);
#include <lprocfs_status.h>
#include "lmv_internal.h"
-int lmv_fld_lookup(struct obd_device *obd, const struct lu_fid *fid)
+int lmv_fld_lookup(struct obd_device *obd,
+ const struct lu_fid *fid,
+ mdsno_t *mds)
{
struct lmv_obd *lmv = &obd->u.lmv;
- mdsno_t mds;
int rc;
ENTRY;
LASSERT(fid_is_sane(fid));
- rc = fld_client_lookup(&lmv->lmv_fld, fid_seq(fid), &mds);
+ rc = fld_client_lookup(&lmv->lmv_fld, fid_seq(fid), mds);
if (rc) {
- CERROR("can't find mds by seq "LPU64", rc %d\n",
- fid_seq(fid), rc);
+ CERROR("error while looking for mds number. Seq "LPU64
+ ", rc %d\n", fid_seq(fid), rc);
RETURN(rc);
}
- CDEBUG(D_INFO, "LMV: got MDS "LPU64" for sequence: "LPU64"\n",
- mds, fid_seq(fid));
- if (mds >= lmv->desc.ld_tgt_count) {
- CERROR("Got invalid mdsno: "LPU64" (max: %d)\n",
- mds, lmv->desc.ld_tgt_count);
- mds = (__u64)-EINVAL;
+
+ CDEBUG(D_INFO, "got mds "LPU64" for sequence: "LPU64"\n",
+ *mds, fid_seq(fid));
+
+ if (*mds >= lmv->desc.ld_tgt_count) {
+ CERROR("got invalid mds: "LPU64" (max: %d)\n",
+ *mds, lmv->desc.ld_tgt_count);
+ rc = -EINVAL;
}
- RETURN((int)mds);
+ RETURN(rc);
}
/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=8:tabstop=8:
*
- * Copyright (C) 2002, 2003 Cluster File Systems, Inc.
+ * Copyright (C) 2002, 2003, 2004, 2005, 2006 Cluster File Systems, Inc.
*
* This file is part of Lustre, http://www.lustre.org.
*
struct lustre_handle plock;
struct md_op_data *op_data;
struct lu_fid nid;
- int pmode, i, rc = 0;
+ int pmode, rc = 0;
+ mdsno_t mds;
ENTRY;
body = lustre_msg_buf((*reqp)->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body));
GOTO(out, rc = -ENOMEM);
op_data->fid1 = nid;
- i = lmv_fld_lookup(obd, &nid);
- if (i < 0)
- RETURN(i);
- rc = md_intent_lock(lmv->tgts[i].ltd_exp, op_data,
+ rc = lmv_fld_lookup(obd, &nid, &mds);
+ if (rc)
+ RETURN(rc);
+ rc = md_intent_lock(lmv->tgts[mds].ltd_exp, op_data,
lmm, lmmsize, it, flags, &req,
cb_blocking, extra_lock_flags);
return rc;
}
-int lmv_intent_open(struct obd_export *exp, struct lu_fid *pid,
+int lmv_intent_open(struct obd_export *exp, const struct lu_fid *pid,
const char *name, int len, void *lmm, int lmmsize,
- struct lu_fid *cid, struct lookup_intent *it,
+ const struct lu_fid *cid, struct lookup_intent *it,
int flags, struct ptlrpc_request **reqp,
ldlm_blocking_callback cb_blocking,
int extra_lock_flags)
struct md_op_data *op_data;
struct lmv_stripe_md *mea;
struct lu_fid rpid = *pid;
- int rc, mds, loop = 0;
struct lmv_obj *obj;
+ int rc, loop = 0;
+ mdsno_t mds;
ENTRY;
OBD_ALLOC_PTR(op_data);
if (op_data == NULL)
RETURN(-ENOMEM);
- /* IT_OPEN is intended to open (and create, possible) an object. Parent
- * (pid) may be splitted dir */
+ /*
+ * IT_OPEN is intended to open (and create, possible) an object. Parent
+ * (pid) may be split dir.
+ */
repeat:
LASSERT(++loop <= 2);
- mds = lmv_fld_lookup(obd, &rpid);
- if (mds < 0)
- GOTO(out_free_op_data, rc = mds);
+ rc = lmv_fld_lookup(obd, &rpid, &mds);
+ if (rc)
+ GOTO(out_free_op_data, rc);
obj = lmv_obj_grab(obd, &rpid);
if (obj) {
- /* directory is already splitted, so we have to forward
- * request to the right MDS */
+ /* directory is already split, so we have to forward request to
+ * the right MDS. */
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)name, len);
- CDEBUG(D_OTHER, "forward to MDS #%u ("DFID")\n",
+ CDEBUG(D_OTHER, "forward to MDS #"LPU64" ("DFID")\n",
mds, PFID(&rpid));
rpid = obj->lo_inodes[mds].li_fid;
lmv_obj_put(obj);
op_data->name = name;
op_data->namelen = len;
- //mds = lmv_fld_lookup(obd, &rpid);
rc = md_intent_lock(lmv->tgts[mds].ltd_exp, op_data,
lmm, lmmsize, it, flags, reqp,
cb_blocking, extra_lock_flags);
if (rc == -ERESTART) {
- /* directory got splitted. time to update local object and
+ /* directory got split. time to update local object and
* repeat the request with proper MDS */
LASSERT(lu_fid_eq(pid, &rpid));
rc = lmv_handle_split(exp, &rpid);
GOTO(out_free_op_data, rc = 0);
/* caller may use attrs MDS returns on IT_OPEN lock request so, we have
- * to update them for splitted dir */
+ * to update them for split dir */
body = lustre_msg_buf((*reqp)->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body));
LASSERT(body != NULL);
cid = &body->fid1;
obj = lmv_obj_grab(obd, cid);
if (!obj && (mea = lmv_get_mea(*reqp, DLM_REPLY_REC_OFF))) {
- /* wow! this is splitted dir, we'd like to handle it */
+ /* wow! this is split dir, we'd like to handle it */
obj = lmv_obj_create(exp, &body->fid1, mea);
if (IS_ERR(obj))
GOTO(out_free_op_data, rc = (int)PTR_ERR(obj));
}
if (obj) {
- /* this is splitted dir and we'd want to get attrs */
+ /* this is split dir and we'd want to get attrs */
CDEBUG(D_OTHER, "attrs from slaves for "DFID"\n",
PFID(cid));
return rc;
}
-int lmv_intent_getattr(struct obd_export *exp, struct lu_fid *pid,
+int lmv_intent_getattr(struct obd_export *exp, const struct lu_fid *pid,
const char *name, int len, void *lmm, int lmmsize,
- struct lu_fid *cid, struct lookup_intent *it,
+ const struct lu_fid *cid, struct lookup_intent *it,
int flags, struct ptlrpc_request **reqp,
ldlm_blocking_callback cb_blocking,
int extra_lock_flags)
struct md_op_data *op_data;
struct lu_fid rpid = *pid;
struct lmv_stripe_md *mea;
- int rc = 0, mds;
+ mdsno_t mds;
+ int rc = 0;
ENTRY;
OBD_ALLOC_PTR(op_data);
if (cid) {
/* caller wants to revalidate attrs of obj we have to revalidate
- * slaves if requested object is splitted directory */
+ * slaves if requested object is split directory */
CDEBUG(D_OTHER, "revalidate attrs for "DFID"\n", PFID(cid));
- mds = lmv_fld_lookup(obd, cid);
- if (mds < 0)
- GOTO(out_free_op_data, rc = mds);
+ rc = lmv_fld_lookup(obd, cid, &mds);
+ if (rc)
+ GOTO(out_free_op_data, rc);
#if 0
obj = lmv_obj_grab(obd, cid);
if (obj) {
- /* in fact, we need not this with current intent_lock(),
- * but it may change some day */
+ /* in fact, we do not need this with current
+ * intent_lock(), but it may change some day */
if (!lu_fid_eq(pid, cid)){
rpid = obj->lo_inodes[mds].li_fid;
- mds = lmv_fld_lookup(obd, &rpid);
- if (mds < 0)
- GOTO(out_free_op_data, rc = mds);
+ rc = lmv_fld_lookup(obd, &rpid, &mds);
+ if (rc)
+ GOTO(out_free_op_data, rc);
}
lmv_obj_put(obj);
}
} else {
CDEBUG(D_OTHER, "INTENT getattr for %*s on "DFID"\n",
len, name, PFID(pid));
- mds = lmv_fld_lookup(obd, pid);
- if (mds < 0)
- GOTO(out_free_op_data, rc = mds);
+ rc = lmv_fld_lookup(obd, pid, &mds);
+ if (rc)
+ GOTO(out_free_op_data, rc);
obj = lmv_obj_grab(obd, pid);
if (obj && len) {
- /* directory is already splitted. calculate mds */
+ /* directory is already split. calculate mds */
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)name, len);
rpid = obj->lo_inodes[mds].li_fid;
- mds = lmv_fld_lookup(obd, &rpid);
+ rc = lmv_fld_lookup(obd, &rpid, &mds);
+ if (rc)
+ GOTO(out_free_op_data, rc);
lmv_obj_put(obj);
- CDEBUG(D_OTHER, "forward to MDS #%u (slave "DFID")\n",
+ CDEBUG(D_OTHER, "forward to MDS #"LPU64" (slave "DFID")\n",
mds, PFID(&rpid));
}
}
if (obj && rc > 0) {
/*
- * this is splitted dir. In order to optimize things a bit, we
+ * this is split dir. In order to optimize things a bit, we
* consider obj valid updating missing parts.
* FIXME: do we need to return any lock here? It would be fine
obj2 = lmv_obj_grab(obd, cid);
if (!obj2 && (mea = lmv_get_mea(*reqp, DLM_REPLY_REC_OFF))) {
- /* wow! this is splitted dir, we'd like to handle it. */
+ /* wow! this is split dir, we'd like to handle it. */
body = lustre_msg_buf((*reqp)->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body));
LASSERT(body != NULL);
}
if (obj2) {
- /* this is splitted dir and we'd want to get attrs */
+ /* this is split dir and we'd want to get attrs */
CDEBUG(D_OTHER, "attrs from slaves for "DFID", rc %d\n",
PFID(cid), rc);
struct lu_fid fid = obj->lo_inodes[i].li_fid;
struct ptlrpc_request *req = NULL;
struct lookup_intent it;
- int mds;
+ mdsno_t mds;
if (lu_fid_eq(&fid, &obj->lo_fid))
/* skip master obj */
op_data->fid1 = fid;
op_data->fid2 = fid;
- mds = lmv_fld_lookup(obd, &fid);
- if (mds < 0)
- GOTO(cleanup, rc = mds);
+ rc = lmv_fld_lookup(obd, &fid, &mds);
+ if (rc)
+ GOTO(cleanup, rc);
rc = md_intent_lock(lmv->tgts[mds].ltd_exp, op_data,
NULL, 0, &it, 0, &req,
lmv_blocking_ast, 0);
return rc;
}
-int lmv_intent_lookup(struct obd_export *exp, struct lu_fid *pid,
+int lmv_intent_lookup(struct obd_export *exp, const struct lu_fid *pid,
const char *name, int len, void *lmm, int lmmsize,
- struct lu_fid *cid, struct lookup_intent *it,
+ const struct lu_fid *cid, struct lookup_intent *it,
int flags, struct ptlrpc_request **reqp,
ldlm_blocking_callback cb_blocking,
int extra_lock_flags)
struct lu_fid rpid = *pid;
struct md_op_data *op_data;
struct lmv_stripe_md *mea;
- int rc, mds, loop = 0;
struct lmv_obj *obj;
+ int rc, loop = 0;
+ mdsno_t mds;
ENTRY;
OBD_ALLOC_PTR(op_data);
rpid = obj->lo_inodes[mds].li_fid;
lmv_obj_put(obj);
}
- mds = lmv_fld_lookup(obd, &rpid);
- if (mds < 0)
- GOTO(out_free_op_data, rc = mds);
+ rc = lmv_fld_lookup(obd, &rpid, &mds);
+ if (rc)
+ GOTO(out_free_op_data, rc);
- CDEBUG(D_OTHER, "revalidate lookup for "DFID" to %d MDS\n",
+ CDEBUG(D_OTHER, "revalidate lookup for "DFID" to #"LPU64" MDS\n",
PFID(cid), mds);
op_data->fid2 = *cid;
} else {
- mds = lmv_fld_lookup(obd, pid);
- if (mds < 0)
- GOTO(out_free_op_data, rc = mds);
+ rc = lmv_fld_lookup(obd, pid, &mds);
+ if (rc)
+ GOTO(out_free_op_data, rc);
repeat:
LASSERT(++loop <= 2);
obj = lmv_obj_grab(obd, pid);
if (obj) {
if (len) {
- /* directory is already splitted. calculate mds */
+ /* directory is already split. calculate mds */
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)name, len);
rpid = obj->lo_inodes[mds].li_fid;
- mds = lmv_fld_lookup(obd, &rpid);
- if (mds < 0)
- GOTO(out_free_op_data, rc = mds);
+ rc = lmv_fld_lookup(obd, &rpid, &mds);
+ if (rc)
+ GOTO(out_free_op_data, rc);
}
lmv_obj_put(obj);
}
}
if (rc == -ERESTART) {
- /* directory got splitted since last update. this shouldn't be
+ /* directory got split since last update. this shouldn't be
* becasue splitting causes lock revocation, so revalidate had
* to fail and lookup on dir had to return mea */
CWARN("we haven't knew about directory splitting!\n");
cb_blocking, extra_lock_flags);
if (rc == 0 && (mea = lmv_get_mea(*reqp, DLM_REPLY_REC_OFF))) {
- /* wow! this is splitted dir, we'd like to handle it */
+ /* wow! this is split dir, we'd like to handle it */
body = lustre_msg_buf((*reqp)->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body));
LASSERT(body != NULL);
LASSERT((body->valid & OBD_MD_FLID) != 0);
const char *name = op_data->name;
int len = op_data->namelen;
struct lu_fid *pid, *cid;
- int rc, i = 0;
+ mdsno_t mds;
+ int rc;
ENTRY;
LASSERT(it);
pid = fid_is_sane(&op_data->fid1) ? &op_data->fid1 : NULL;
cid = fid_is_sane(&op_data->fid2) ? &op_data->fid2 : NULL;
- i = lmv_fld_lookup(obd, pid);
- if (i < 0)
- RETURN(i);
- CDEBUG(D_OTHER, "INTENT LOCK '%s' for '%*s' on "DFID" -> %d\n",
- LL_IT2STR(it), len, name, PFID(pid), i);
+ rc = lmv_fld_lookup(obd, pid, &mds);
+ if (rc)
+ RETURN(rc);
+ CDEBUG(D_OTHER, "INTENT LOCK '%s' for '%*s' on "DFID" -> #"LPU64"\n",
+ LL_IT2STR(it), len, name, PFID(pid), mds);
rc = lmv_check_connect(obd);
if (rc)
}
int lmv_revalidate_slaves(struct obd_export *exp, struct ptlrpc_request **reqp,
- struct lu_fid *mid, struct lookup_intent *oit,
+ const struct lu_fid *mid, struct lookup_intent *oit,
int master_valid, ldlm_blocking_callback cb_blocking,
int extra_lock_flags)
{
struct mdt_body *body;
struct lmv_obj *obj;
int master_lock_mode;
- int i, mds, rc = 0;
+ int i, rc = 0;
+ mdsno_t mds;
ENTRY;
OBD_ALLOC_PTR(op_data);
op_data->fid2 = fid;
/* is obj valid? */
- mds = lmv_fld_lookup(obd, &fid);
- if (mds < 0)
- GOTO(out_free_op_data, rc = mds);
+ rc = lmv_fld_lookup(obd, &fid, &mds);
+ if (rc)
+ GOTO(out_free_op_data, rc);
rc = md_intent_lock(lmv->tgts[mds].ltd_exp, op_data,
NULL, 0, &it, 0, &req, cb, extra_lock_flags);
lockh = (struct lustre_handle *) &it.d.lustre.it_lock_handle;
DLM_REPLY_REC_OFF, sizeof(*body));
LASSERT(body);
- /* FIXME: what about other attributes? */
body->size = size;
if (mreq == NULL) {
* no reply and the only attr we can return is size.
*/
body->valid = OBD_MD_FLSIZE;
-// body->mds = lmv_fld_lookup(obd, &obj->lo_fid);
+
+#if 0
+ rc = lmv_fld_lookup(obd, &obj->lo_fid, &body->mds);
+ if (rc)
+ GOTO(cleanup, rc);
+#endif
}
if (master_valid == 0) {
memcpy(&oit->d.lustre.it_lock_handle,
/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=8:tabstop=8:
*
- * Copyright (C) 2002, 2003, 2004 Cluster File Systems, Inc.
+ * Copyright (C) 2002, 2003, 2004, 2005, 2006 Cluster File Systems, Inc.
*
* This file is part of Lustre, http://www.lustre.org.
*
#define LL_IT2STR(it) \
((it) ? ldlm_it2str((it)->it_op) : "0")
-#define MEA_SIZE_LMV(lmv) \
- ((lmv)->desc.ld_tgt_count * \
- sizeof(struct lu_fid) + sizeof(struct lmv_stripe_md))
-
struct lmv_inode {
struct lu_fid li_fid; /* id of dirobj */
unsigned long li_size; /* slave size value */
struct lmv_obj *lmv_obj_get(struct lmv_obj *obj);
struct lmv_obj *lmv_obj_grab(struct obd_device *obd,
- struct lu_fid *fid);
+ const struct lu_fid *fid);
struct lmv_obj *lmv_obj_alloc(struct obd_device *obd,
- struct lu_fid *fid,
+ const struct lu_fid *fid,
struct lmv_stripe_md *mea);
struct lmv_obj *lmv_obj_create(struct obd_export *exp,
- struct lu_fid *fid,
+ const struct lu_fid *fid,
struct lmv_stripe_md *mea);
-int lmv_obj_delete(struct obd_export *exp, struct lu_fid *fid);
+int lmv_obj_delete(struct obd_export *exp,
+ const struct lu_fid *fid);
int lmv_check_connect(struct obd_device *obd);
ldlm_blocking_callback cb_blocking,
int extra_lock_flags);
-int lmv_intent_lookup(struct obd_export *, struct lu_fid *,
+int lmv_intent_lookup(struct obd_export *, const struct lu_fid *,
const char *, int, void *, int,
- struct lu_fid *, struct lookup_intent *, int,
+ const struct lu_fid *, struct lookup_intent *, int,
struct ptlrpc_request **, ldlm_blocking_callback,
int extra_lock_flags);
-int lmv_intent_getattr(struct obd_export *, struct lu_fid *, const char *,
- int, void *, int, struct lu_fid *, struct lookup_intent *,
+int lmv_intent_getattr(struct obd_export *, const struct lu_fid *, const char *,
+ int, void *, int, const struct lu_fid *, struct lookup_intent *,
int, struct ptlrpc_request **, ldlm_blocking_callback,
int extra_lock_flags);
-int lmv_intent_open(struct obd_export *, struct lu_fid *, const char *,
- int, void *, int, struct lu_fid *, struct lookup_intent *,
+int lmv_intent_open(struct obd_export *, const struct lu_fid *, const char *,
+ int, void *, int, const struct lu_fid *, struct lookup_intent *,
int, struct ptlrpc_request **, ldlm_blocking_callback,
int extra_lock_flags);
int lmv_revalidate_slaves(struct obd_export *, struct ptlrpc_request **,
- struct lu_fid *, struct lookup_intent *, int,
+ const struct lu_fid *, struct lookup_intent *, int,
ldlm_blocking_callback cb_blocking,
int extra_lock_flags);
-int lmv_handle_split(struct obd_export *, struct lu_fid *);
+int lmv_handle_split(struct obd_export *, const struct lu_fid *);
int lmv_blocking_ast(struct ldlm_lock *, struct ldlm_lock_desc *,
void *, int);
-int lmv_fld_lookup(struct obd_device *obd, const struct lu_fid *fid);
+int lmv_fld_lookup(struct obd_device *obd, const struct lu_fid *fid,
+ mdsno_t *mds);
static inline struct lmv_stripe_md *
lmv_get_mea(struct ptlrpc_request *req, int offset)
return mea;
}
+static inline int lmv_get_easize(struct lmv_obd *lmv)
+{
+ return sizeof(struct lmv_stripe_md) +
+ lmv->desc.ld_tgt_count *
+ sizeof(struct lu_fid);
+}
+
/* lproc_lmv.c */
extern struct file_operations lmv_proc_target_fops;
/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=8:tabstop=8:
*
- * Copyright (C) 2002, 2003 Cluster File Systems, Inc.
+ * Copyright (C) 2002, 2003, 2004, 2005, 2006 Cluster File Systems, Inc.
*
* This file is part of Lustre, http://www.lustre.org.
*
lmv->connected = 0;
lmv->cluuid = *cluuid;
- /* saving */
if (data)
- memcpy(&lmv->conn_data, data, sizeof(*data));
+ lmv->conn_data = *data;
#ifdef __KERNEL__
lmv_proc_dir = lprocfs_register("target_obds", obd->obd_proc_entry,
lmv_set_timeouts(obd);
class_export_put(lmv->exp);
lmv->connected = 1;
- easize = lmv->desc.ld_tgt_count * sizeof(struct lu_fid) +
- sizeof(struct lmv_stripe_md);
+ easize = lmv_get_easize(lmv);
lmv_init_ea_size(obd->obd_self_export, easize, 0, 0);
lmv_init_unlock(lmv);
RETURN(0);
RETURN(rc);
}
+/* assume all is balanced for now */
static int lmv_fids_balanced(struct obd_device *obd)
{
ENTRY;
- /* assume all is balansed for now */
RETURN(1);
}
return c;
}
-/* returns number of target where new fid should be allocated using passed @hint
- * as input data for making decision. */
static int lmv_placement_policy(struct obd_device *obd,
- struct lu_placement_hint *hint)
+ struct lu_placement_hint *hint,
+ mdsno_t *mds)
{
struct lmv_obd *lmv = &obd->u.lmv;
- int tgt;
+ int rc;
ENTRY;
+ LASSERT(mds != NULL);
+
/* here are some policies to allocate new fid */
if (lmv_fids_balanced(obd)) {
/* allocate new fid basing on its name in the case fids are
* balanced, that is all sequences have more or less equal
* number of objects created. */
- if (hint->ph_cname && (hint->ph_opc == LUSTRE_OPC_MKDIR))
- tgt = lmv_all_chars_policy(lmv->desc.ld_tgt_count,
- hint->ph_cname);
- else {
+ if (hint->ph_cname && (hint->ph_opc == LUSTRE_OPC_MKDIR)) {
+ *mds = lmv_all_chars_policy(lmv->desc.ld_tgt_count,
+ hint->ph_cname);
+ rc = 0;
+ } else {
/* default policy is to use parent MDS */
LASSERT(fid_is_sane(hint->ph_pfid));
- tgt = lmv_fld_lookup(obd, hint->ph_pfid);
+ rc = lmv_fld_lookup(obd, hint->ph_pfid, mds);
}
} else {
/* sequences among all tgts are not well balanced, allocate new
- * fid taking this into account to balance them. */
- tgt = -EINVAL;
+ * fid taking this into account to balance them. Not implemented
+ * yet! */
+ *mds = 0;
+ rc = -EINVAL;
}
- /* if cannot get proper MDS, use master one */
- if (tgt < 0) {
- CERROR("Cannot choose MDS, err = %i\n", tgt);
- tgt = 0;
+ if (rc) {
+ CERROR("cannot choose MDS, err = %d\n", rc);
+ } else {
+ LASSERT(*mds < lmv->desc.ld_tgt_count);
}
- RETURN(tgt);
+ RETURN(rc);
}
static int lmv_fid_init(struct obd_export *exp)
{
struct obd_device *obd = class_exp2obd(exp);
struct lmv_obd *lmv = &obd->u.lmv;
- int rc = 0, mds;
+ mdsno_t mds;
+ int rc;
ENTRY;
LASSERT(fid != NULL);
LASSERT(hint != NULL);
- mds = lmv_placement_policy(obd, hint);
- if (mds < 0 || mds >= lmv->desc.ld_tgt_count) {
- CERROR("can't get target for allocating fid\n");
- RETURN(-EINVAL);
+ rc = lmv_placement_policy(obd, hint, &mds);
+ if (rc) {
+ CERROR("can't get target for allocating fid, "
+ "rc %d\n", rc);
+ RETURN(rc);
}
/* asking underlaying tgt layer to allocate new fid */
if (rc > 0) {
LASSERT(fid_is_sane(fid));
- rc = fld_client_create(&lmv->lmv_fld,
- fid_seq(fid),
+ rc = fld_client_create(&lmv->lmv_fld, fid_seq(fid),
mds);
if (rc) {
- CERROR("can't create fld entry, "
- "rc %d\n", rc);
+ CERROR("can't create fld entry, rc %d\n", rc);
+ RETURN(rc);
}
}
RETURN(rc);
}
-static int lmv_fid_delete(struct obd_export *exp, struct lu_fid *fid)
+static int lmv_fid_delete(struct obd_export *exp, const struct lu_fid *fid)
{
ENTRY;
struct lmv_obd *lmv = &obd->u.lmv;
ENTRY;
+ fld_client_fini(&lmv->lmv_fld);
lprocfs_obd_cleanup(obd);
lmv_mgr_cleanup(obd);
- fld_client_fini(&lmv->lmv_fld);
OBD_FREE(lmv->datas, lmv->datas_size);
OBD_FREE(lmv->tgts, lmv->tgts_size);
GOTO(out_free_temp, rc);
}
if (i == 0) {
- memcpy(osfs, temp, sizeof(*temp));
+ *osfs = *temp;
} else {
osfs->os_bavail += temp->os_bavail;
osfs->os_blocks += temp->os_blocks;
return rc;
}
-static int lmv_getstatus(struct obd_export *exp, struct lu_fid *fid)
+static int lmv_getstatus(struct obd_export *exp,
+ struct lu_fid *fid)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
RETURN(rc);
}
-static int lmv_getxattr(struct obd_export *exp, struct lu_fid *fid,
+
+static int lmv_getxattr(struct obd_export *exp,
+ const struct lu_fid *fid,
obd_valid valid, const char *name,
const char *input, int input_size,
int output_size, int flags,
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
- int rc, i;
+ mdsno_t mds;
+ int rc;
ENTRY;
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
- i = lmv_fld_lookup(obd, fid);
- if (i < 0)
- RETURN(i);
-
- LASSERT(i < lmv->desc.ld_tgt_count);
+ rc = lmv_fld_lookup(obd, fid, &mds);
+ if (rc)
+ RETURN(rc);
- rc = md_getxattr(lmv->tgts[i].ltd_exp, fid, valid, name,
+ rc = md_getxattr(lmv->tgts[mds].ltd_exp, fid, valid, name,
input, input_size, output_size, flags, request);
RETURN(rc);
}
-static int lmv_setxattr(struct obd_export *exp, struct lu_fid *fid,
+static int lmv_setxattr(struct obd_export *exp,
+ const struct lu_fid *fid,
obd_valid valid, const char *name,
const char *input, int input_size,
int output_size, int flags,
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
- int rc, i;
+ mdsno_t mds;
+ int rc;
ENTRY;
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
- i = lmv_fld_lookup(obd, fid);
- if (i < 0)
- RETURN(i);
-
- LASSERT(i < lmv->desc.ld_tgt_count);
+ rc = lmv_fld_lookup(obd, fid, &mds);
+ if (rc)
+ RETURN(rc);
- rc = md_setxattr(lmv->tgts[i].ltd_exp, fid, valid, name,
+ rc = md_setxattr(lmv->tgts[mds].ltd_exp, fid, valid, name,
input, input_size, output_size, flags, request);
RETURN(rc);
}
-static int lmv_getattr(struct obd_export *exp, struct lu_fid *fid,
+static int lmv_getattr(struct obd_export *exp,
+ const struct lu_fid *fid,
obd_valid valid, int ea_size,
struct ptlrpc_request **request)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
struct lmv_obj *obj;
+ mdsno_t mds;
int rc, i;
ENTRY;
if (rc)
RETURN(rc);
- i = lmv_fld_lookup(obd, fid);
- if (i < 0)
- RETURN(i);
-
- LASSERT(i < lmv->desc.ld_tgt_count);
+ rc = lmv_fld_lookup(obd, fid, &mds);
+ if (rc)
+ RETURN(rc);
- rc = md_getattr(lmv->tgts[i].ltd_exp, fid, valid,
+ rc = md_getattr(lmv->tgts[mds].ltd_exp, fid, valid,
ea_size, request);
if (rc)
RETURN(rc);
obj = lmv_obj_grab(obd, fid);
CDEBUG(D_OTHER, "GETATTR for "DFID" %s\n",
- PFID(fid), obj ? "(splitted)" : "");
+ PFID(fid), obj ? "(split)" : "");
- /* if object is splitted, then we loop over all the slaves and gather
- * size attribute. In ideal world we would have to gather also mds field
- * from all slaves, as object is spread over the cluster and this is
+ /* if object is split, then we loop over all the slaves and gather size
+ * attribute. In ideal world we would have to gather also mds field from
+ * all slaves, as object is spread over the cluster and this is
* definitely interesting information and it is not good to loss it,
* but... */
if (obj) {
lmv_obj_lock(obj);
for (i = 0; i < obj->lo_objcount; i++) {
-
if (lmv->tgts[i].ltd_exp == NULL) {
CWARN("%s: NULL export for %d\n",
obd->obd_name, i);
}
static int lmv_change_cbdata(struct obd_export *exp,
- struct lu_fid *fid,
+ 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 rc, i;
+ mdsno_t mds;
+ int rc;
ENTRY;
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
- i = lmv_fld_lookup(obd, &op_data->fid1);
- if (i < 0)
- RETURN(i);
+ rc = lmv_fld_lookup(obd, &op_data->fid1, &mds);
+ if (rc)
+ RETURN(rc);
- LASSERT(i < lmv->desc.ld_tgt_count);
CDEBUG(D_OTHER, "CLOSE "DFID"\n", PFID(&op_data->fid1));
- rc = md_close(lmv->tgts[i].ltd_exp, op_data, och, request);
+ rc = md_close(lmv->tgts[mds].ltd_exp, op_data, och, request);
RETURN(rc);
}
/* called in the case MDS returns -ERESTART on create on open, what means that
- * directory is splitted and its LMV presentation object has to be updated. */
-int lmv_handle_split(struct obd_export *exp, struct lu_fid *fid)
+ * directory is split and its LMV presentation object has to be updated. */
+int lmv_handle_split(struct obd_export *exp, const struct lu_fid *fid)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
struct ptlrpc_request *req = NULL;
struct lmv_obj *obj;
struct lustre_md md;
- int mealen, rc, i;
+ int mealen, rc;
+ mdsno_t mds;
__u64 valid;
ENTRY;
md.mea = NULL;
- mealen = MEA_SIZE_LMV(lmv);
+ mealen = lmv_get_easize(lmv);
valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA | OBD_MD_MEA;
- i = lmv_fld_lookup(obd, fid);
- if (i < 0)
- RETURN(i);
-
- LASSERT(i < lmv->desc.ld_tgt_count);
+ rc = lmv_fld_lookup(obd, fid, &mds);
+ if (rc)
+ RETURN(rc);
/* time to update mea of parent fid */
- rc = md_getattr(lmv->tgts[i].ltd_exp, fid, valid,
+ rc = md_getattr(lmv->tgts[mds].ltd_exp, fid, valid,
mealen, &req);
if (rc) {
CERROR("md_getattr() failed, error %d\n", rc);
GOTO(cleanup, rc);
}
- rc = md_get_lustre_md(lmv->tgts[i].ltd_exp, req, 0,
+ rc = md_get_lustre_md(lmv->tgts[mds].ltd_exp, req, 0,
NULL, &md);
if (rc) {
CERROR("mdc_get_lustre_md() failed, error %d\n", rc);
struct lmv_obd *lmv = &obd->u.lmv;
struct mdt_body *body;
struct lmv_obj *obj;
- int rc, mds, loop = 0;
+ int rc, loop = 0;
+ mdsno_t mds;
ENTRY;
rc = lmv_check_connect(obd);
CDEBUG(D_OTHER, "CREATE '%*s' on "DFID"\n", op_data->namelen,
op_data->name, PFID(&op_data->fid1));
- mds = lmv_fld_lookup(obd, &op_data->fid1);
- if (mds < 0)
- RETURN(mds);
+ rc = lmv_fld_lookup(obd, &op_data->fid1, &mds);
+ if (rc)
+ RETURN(rc);
rc = md_create(lmv->tgts[mds].ltd_exp, op_data, data, datalen,
mode, uid, gid, cap_effective, rdev, request);
CDEBUG(D_OTHER, "created. "DFID"\n", PFID(&op_data->fid1));
} else if (rc == -ERESTART) {
- /* directory got splitted. time to update local object and
- * repeat the request with proper MDS. */
+ /* directory got split. time to update local object and repeat
+ * the request with proper MDS. */
rc = lmv_handle_split(exp, &op_data->fid1);
if (rc == 0) {
ptlrpc_req_finished(*request);
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
- int rc, mds;
+ mdsno_t mds;
+ int rc;
ENTRY;
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
- mds = lmv_fld_lookup(obd, &op_data->fid1);
- if (mds < 0)
- RETURN(mds);
+ rc = lmv_fld_lookup(obd, &op_data->fid1, &mds);
+ if (rc)
+ RETURN(rc);
rc = md_done_writing(lmv->tgts[mds].ltd_exp, op_data);
RETURN(rc);
}
struct lmv_obd *lmv = &obd->u.lmv;
struct lmv_stripe_md *mea = op_data->mea1;
struct md_op_data *op_data2;
- int i, rc = 0, mds;
+ int i, rc = 0;
+ mdsno_t mds;
ENTRY;
OBD_ALLOC_PTR(op_data2);
for (i = 0; i < mea->mea_count; i++) {
memset(op_data2, 0, sizeof(*op_data2));
op_data2->fid1 = mea->mea_ids[i];
- mds = lmv_fld_lookup(obd, &op_data2->fid1);
- if (mds < 0)
- GOTO(cleanup, rc = mds);
+ rc = lmv_fld_lookup(obd, &op_data2->fid1, &mds);
+ if (rc)
+ GOTO(cleanup, rc);
if (lmv->tgts[mds].ltd_exp == NULL)
continue;
struct mdt_body *body = NULL;
struct lustre_handle plock;
struct md_op_data *rdata;
- int i, rc = 0, pmode;
+ int rc = 0, pmode;
+ mdsno_t mds;
ENTRY;
body = lustre_msg_buf(req->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body));
it->d.lustre.it_disposition &= ~DISP_ENQ_COMPLETE;
ptlrpc_req_finished(req);
- i = lmv_fld_lookup(obd, &rdata->fid1);
- if (i < 0)
- GOTO(out_free_rdata, rc = i);
- rc = md_enqueue(lmv->tgts[i].ltd_exp,
+ rc = lmv_fld_lookup(obd, &rdata->fid1, &mds);
+ if (rc)
+ GOTO(out_free_rdata, rc);
+ rc = md_enqueue(lmv->tgts[mds].ltd_exp,
lock_type, it, lock_mode, rdata, lockh, lmm,
lmmsize, cb_compl, cb_blocking, cb_data,
extra_lock_flags);
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
struct lmv_obj *obj;
- int rc, mds;
+ mdsno_t mds;
+ int rc;
ENTRY;
rc = lmv_check_connect(obd);
if (op_data->namelen) {
obj = lmv_obj_grab(obd, &op_data->fid1);
if (obj) {
- /* directory is splitted. look for right mds for this
+ /* directory is split. look for right mds for this
* name */
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)op_data->name, op_data->namelen);
CDEBUG(D_OTHER, "ENQUEUE '%s' on "DFID"\n", LL_IT2STR(it),
PFID(&op_data->fid1));
- mds = lmv_fld_lookup(obd, &op_data->fid1);
- if (mds < 0)
- RETURN(mds);
+ rc = lmv_fld_lookup(obd, &op_data->fid1, &mds);
+ if (rc)
+ RETURN(rc);
rc = md_enqueue(lmv->tgts[mds].ltd_exp,
lock_type, it, lock_mode, op_data, lockh, lmm,
lmmsize, cb_compl, cb_blocking, cb_data,
}
static int
-lmv_getattr_name(struct obd_export *exp, struct lu_fid *fid,
+lmv_getattr_name(struct obd_export *exp, const struct lu_fid *fid,
const char *filename, int namelen, obd_valid valid,
int ea_size, struct ptlrpc_request **request)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
struct lu_fid rid = *fid;
- int rc, mds, loop = 0;
+ int rc, loop = 0;
struct mdt_body *body;
struct lmv_obj *obj;
+ mdsno_t mds;
ENTRY;
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
- mds = lmv_fld_lookup(obd, fid);
- if (mds < 0)
- RETURN(mds);
+ rc = lmv_fld_lookup(obd, fid, &mds);
+ if (rc)
+ RETURN(rc);
repeat:
LASSERT(++loop <= 2);
obj = lmv_obj_grab(obd, fid);
if (obj) {
- /* directory is splitted. look for right mds for this name */
+ /* directory is split. look for right mds for this name */
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
filename, namelen - 1);
rid = obj->lo_inodes[mds].li_fid;
CDEBUG(D_OTHER, "getattr_lock for %*s on "DFID" -> "DFID"\n",
namelen, filename, PFID(fid), PFID(&rid));
- mds = lmv_fld_lookup(obd, &rid);
- if (mds < 0)
- RETURN(mds);
+ rc = lmv_fld_lookup(obd, &rid, &mds);
+ if (rc)
+ RETURN(rc);
rc = md_getattr_name(lmv->tgts[mds].ltd_exp,
&rid, filename, namelen,
rid = body->fid1;
CDEBUG(D_OTHER, "request attrs for "DFID"\n", PFID(&rid));
- /*
- * XXX check for error.
- */
- mds = lmv_fld_lookup(obd, &rid);
+ rc = lmv_fld_lookup(obd, &rid, &mds);
+ if (rc) {
+ ptlrpc_req_finished(*request);
+ RETURN(rc);
+ }
+
rc = md_getattr_name(lmv->tgts[mds].ltd_exp,
&rid, NULL, 1, valid, ea_size, &req);
ptlrpc_req_finished(*request);
*request = req;
}
} else if (rc == -ERESTART) {
- /* directory got splitted. time to update local object and
- * repeat the request with proper MDS */
+ /* directory got split. time to update local object and repeat
+ * the request with proper MDS */
rc = lmv_handle_split(exp, &rid);
if (rc == 0) {
ptlrpc_req_finished(*request);
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
struct lmv_obj *obj;
- int rc, mds;
+ mdsno_t mds;
+ int rc;
ENTRY;
rc = lmv_check_connect(obd);
lmv_obj_put(obj);
}
- mds = lmv_fld_lookup(obd, &op_data->fid2);
- if (mds < 0)
- RETURN(mds);
+ rc = lmv_fld_lookup(obd, &op_data->fid2, &mds);
+ if (rc)
+ RETURN(rc);
CDEBUG(D_OTHER,"link "DFID":%*s to "DFID"\n",
PFID(&op_data->fid2), op_data->namelen,
op_data->name, PFID(&op_data->fid1));
} else {
- mds = lmv_fld_lookup(obd, &op_data->fid1);
- if (mds < 0)
- RETURN(mds);
+ rc = lmv_fld_lookup(obd, &op_data->fid1, &mds);
+ if (rc)
+ RETURN(rc);
/* request from MDS to acquire i_links for inode by fid1 */
CDEBUG(D_OTHER, "inc i_nlinks for "DFID"\n",
PFID(&op_data->fid1));
}
- CDEBUG(D_OTHER, "forward to MDS #%u ("DFID")\n",
+ CDEBUG(D_OTHER, "forward to MDS #"LPU64" ("DFID")\n",
mds, PFID(&op_data->fid1));
rc = md_link(lmv->tgts[mds].ltd_exp, op_data, request);
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
struct lmv_obj *obj;
- int rc, mds, mds2;
+ mdsno_t mds, mds2;
+ int rc;
ENTRY;
CDEBUG(D_OTHER, "rename %*s in "DFID" to %*s in "DFID"\n",
"to "DFID"\n", newlen, new, oldlen, newlen,
PFID(&op_data->fid2), PFID(&op_data->fid1));
- mds = lmv_fld_lookup(obd, &op_data->fid2);
- if (mds < 0)
- RETURN(mds);
+ rc = lmv_fld_lookup(obd, &op_data->fid2, &mds);
+ if (rc)
+ RETURN(rc);
/*
- * target directory can be splitted, sowe should forward request
- * to the right MDS.
+ * target directory can be split, sowe should forward request to
+ * the right MDS.
*/
obj = lmv_obj_grab(obd, &op_data->fid2);
if (obj) {
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)new, newlen);
op_data->fid2 = obj->lo_inodes[mds].li_fid;
- CDEBUG(D_OTHER, "forward to MDS #%u ("DFID")\n", mds,
+ CDEBUG(D_OTHER, "forward to MDS #"LPU64" ("DFID")\n", mds,
PFID(&op_data->fid2));
lmv_obj_put(obj);
}
obj = lmv_obj_grab(obd, &op_data->fid1);
if (obj) {
/*
- * directory is already splitted, so we have to forward request
- * to the right MDS.
+ * directory is already split, so we have to forward request to
+ * the right MDS.
*/
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)old, oldlen);
op_data->fid1 = obj->lo_inodes[mds].li_fid;
- CDEBUG(D_OTHER, "forward to MDS #%u ("DFID")\n", mds,
+ CDEBUG(D_OTHER, "forward to MDS #"LPU64" ("DFID")\n", mds,
PFID(&op_data->fid1));
lmv_obj_put(obj);
}
obj = lmv_obj_grab(obd, &op_data->fid2);
if (obj) {
/*
- * directory is already splitted, so we have to forward request
- * to the right MDS.
+ * directory is already split, so we have to forward request to
+ * the right MDS.
*/
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)new, newlen);
op_data->fid2 = obj->lo_inodes[mds].li_fid;
- CDEBUG(D_OTHER, "forward to MDS #%u ("DFID")\n", mds,
+ CDEBUG(D_OTHER, "forward to MDS #"LPU64" ("DFID")\n", mds,
PFID(&op_data->fid2));
lmv_obj_put(obj);
}
- mds = lmv_fld_lookup(obd, &op_data->fid1);
- if (mds < 0)
- RETURN(mds);
+ rc = lmv_fld_lookup(obd, &op_data->fid1, &mds);
+ if (rc)
+ RETURN(rc);
request:
- mds2 = lmv_fld_lookup(obd, &op_data->fid2);
- if (mds2 < 0)
- RETURN(mds2);
+ rc = lmv_fld_lookup(obd, &op_data->fid2, &mds2);
+ if (rc)
+ RETURN(rc);
if (mds != mds2) {
CDEBUG(D_OTHER,"cross-node rename "DFID"/%*s to "DFID"/%*s\n",
struct ptlrpc_request *req;
struct mdt_body *body;
struct lmv_obj *obj;
- int rc = 0, i, mds;
+ int rc = 0, i;
+ mdsno_t mds;
ENTRY;
rc = lmv_check_connect(obd);
obj = lmv_obj_grab(obd, &op_data->fid1);
CDEBUG(D_OTHER, "SETATTR for "DFID", valid 0x%x%s\n",
- PFID(&op_data->fid1), iattr->ia_valid, obj ? ", splitted" : "");
+ PFID(&op_data->fid1), iattr->ia_valid, obj ? ", split" : "");
if (obj) {
for (i = 0; i < obj->lo_objcount; i++) {
op_data->fid1 = obj->lo_inodes[i].li_fid;
- mds = lmv_fld_lookup(obd, &op_data->fid1);
- if (mds < 0) {
- rc = mds;
+ rc = lmv_fld_lookup(obd, &op_data->fid1, &mds);
+ if (rc)
break;
- }
rc = md_setattr(lmv->tgts[mds].ltd_exp,
op_data, iattr, ea, ealen, ea2,
}
lmv_obj_put(obj);
} else {
- mds = lmv_fld_lookup(obd, &op_data->fid1);
- if (mds < 0)
- RETURN(mds);
- LASSERT(mds < lmv->desc.ld_tgt_count);
+ rc = lmv_fld_lookup(obd, &op_data->fid1, &mds);
+ if (rc)
+ RETURN(rc);
+
rc = md_setattr(lmv->tgts[mds].ltd_exp, op_data, iattr, ea,
ealen, ea2, ea2len, request);
if (rc == 0) {
RETURN(rc);
}
-static int lmv_sync(struct obd_export *exp, struct lu_fid *fid,
+static int lmv_sync(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;
- int i, rc;
+ mdsno_t mds;
+ int rc;
ENTRY;
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
- i = lmv_fld_lookup(obd, fid);
- if (i < 0)
- RETURN(i);
- rc = md_sync(lmv->tgts[i].ltd_exp,
+ rc = lmv_fld_lookup(obd, fid, &mds);
+ if (rc)
+ RETURN(rc);
+ rc = md_sync(lmv->tgts[mds].ltd_exp,
fid, request);
RETURN(rc);
}
-/* main purpose of LMV blocking ast is to remove splitted directory
- * LMV presentation object (struct lmv_obj) attached to the lock
- * being revoked. */
+/* main purpose of LMV blocking ast is to remove split directory LMV
+ * presentation object (struct lmv_obj) attached to the lock being revoked. */
int lmv_blocking_ast(struct ldlm_lock *lock,
struct ldlm_lock_desc *desc,
void *data, int flag)
}
}
-static int lmv_readpage(struct obd_export *exp, struct lu_fid *fid,
+static int lmv_readpage(struct obd_export *exp,
+ const struct lu_fid *fid,
__u64 offset, struct page *page,
struct ptlrpc_request **request)
{
struct lmv_obd *lmv = &obd->u.lmv;
struct lu_fid rid = *fid;
struct lmv_obj *obj;
- int rc, i;
+ mdsno_t mds;
+ int i, rc;
ENTRY;
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
- i = lmv_fld_lookup(obd, fid);
- if (i < 0)
- RETURN(i);
- LASSERT(i < lmv->desc.ld_tgt_count);
CDEBUG(D_OTHER, "READPAGE at %llu from "DFID"\n",
offset, PFID(&rid));
CDEBUG(D_OTHER, "forward to "DFID" with offset %lu\n",
PFID(&rid), (unsigned long)offset);
}
- i = lmv_fld_lookup(obd, &rid);
- if (i < 0)
- RETURN(i);
- rc = md_readpage(lmv->tgts[i].ltd_exp, &rid,
+
+ rc = lmv_fld_lookup(obd, &rid, &mds);
+ if (rc)
+ RETURN(rc);
+
+ rc = md_readpage(lmv->tgts[mds].ltd_exp, &rid,
offset, page, request);
if (0 && rc == 0 && !lu_fid_eq(&rid, fid))
- /* this page isn't from master object. To avoid "." and ".."
+ /*
+ * This page isn't from master object. To avoid "." and ".."
* duplication in directory, we have to remove them from all
* slave objects
*
struct lmv_obd *lmv = &obd->u.lmv;
struct lmv_stripe_md *mea = op_data->mea1;
struct md_op_data *op_data2;
- int i, mds, rc = 0;
+ int i, rc = 0;
+ mdsno_t mds;
ENTRY;
OBD_ALLOC_PTR(op_data2);
op_data2->fid1 = mea->mea_ids[i];
op_data2->create_mode = MDS_MODE_DONT_LOCK | S_IFDIR;
- mds = lmv_fld_lookup(obd, &op_data2->fid1);
- if (mds < 0)
- GOTO(out_free_op_data2, rc = mds);
+ rc = lmv_fld_lookup(obd, &op_data2->fid1, &mds);
+ if (rc)
+ GOTO(out_free_op_data2, rc);
if (lmv->tgts[mds].ltd_exp == NULL)
continue;
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
- int rc, i = 0;
+ mdsno_t mds;
+ int rc, i;
ENTRY;
rc = lmv_check_connect(obd);
CDEBUG(D_OTHER, "drop i_nlink on "DFID"\n",
PFID(&op_data->fid1));
}
- i = lmv_fld_lookup(obd, &op_data->fid1);
- if (i < 0)
- RETURN(i);
- rc = md_unlink(lmv->tgts[i].ltd_exp, op_data, request);
+ rc = lmv_fld_lookup(obd, &op_data->fid1, &mds);
+ if (rc)
+ RETURN(rc);
+ rc = md_unlink(lmv->tgts[mds].ltd_exp, op_data, request);
RETURN(rc);
}
if (keylen == strlen("mdsize") && !strcmp(key, "mdsize")) {
__u32 *mdsize = val;
*vallen = sizeof(__u32);
- *mdsize = sizeof(struct lu_fid) * lmv->desc.ld_tgt_count
- + sizeof(struct lmv_stripe_md);
+ *mdsize = lmv_get_easize(lmv);
RETURN(0);
} else if (keylen == strlen("mdsnum") && !strcmp(key, "mdsnum")) {
struct obd_uuid *cluuid = &lmv->cluuid;
if (keylen == strlen("ids") && memcmp(key, "ids", keylen) == 0) {
struct lu_fid *fid = (struct lu_fid *)val;
- int i;
+ mdsno_t mds;
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
- i = lmv_fld_lookup(obd, fid);
- if (i < 0)
- RETURN(i);
- rc = obd_set_info_async(lmv->tgts[i].ltd_exp,
+ rc = lmv_fld_lookup(obd, fid, &mds);
+ if (rc)
+ RETURN(rc);
+ rc = obd_set_info_async(lmv->tgts[mds].ltd_exp,
keylen, key, vallen, val,
set);
RETURN(rc);
int mea_size, i;
ENTRY;
- mea_size = (sizeof(struct lu_fid) *
- lmv->desc.ld_tgt_count) + sizeof(struct lmv_stripe_md);
+ mea_size = lmv_get_easize(lmv);
if (!lmmp)
RETURN(mea_size);
__u32 magic;
ENTRY;
- mea_size = sizeof(struct lu_fid) *
- lmv->desc.ld_tgt_count + sizeof(struct lmv_stripe_md);
-
+ mea_size = lmv_get_easize(lmv);
if (lsmp == NULL)
return mea_size;
RETURN(-ENOMEM);
}
- /* here we should take care about splitted dir, so store cookie and fid
+ /* here we should take care about split dir, so store cookie and fid
* for "master" object should already be allocated and passed in @oa. */
LASSERT(oa->o_id != 0);
LASSERT(oa->o_fid != 0);
#endif
static int lmv_cancel_unused(struct obd_export *exp,
- struct lu_fid *fid,
+ const struct lu_fid *fid,
int flags, void *opaque)
{
struct obd_device *obd = exp->exp_obd;
}
int lmv_lock_match(struct obd_export *exp, int flags,
- struct lu_fid *fid, ldlm_type_t type,
+ const struct lu_fid *fid, ldlm_type_t type,
ldlm_policy_data_t *policy, ldlm_mode_t mode,
struct lustre_handle *lockh)
{
.m_link = lmv_link,
.m_rename = lmv_rename,
.m_setattr = lmv_setattr,
- .m_setxattr = lmv_setxattr,
+ .m_setxattr = lmv_setxattr,
.m_sync = lmv_sync,
.m_readpage = lmv_readpage,
.m_unlink = lmv_unlink,
/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=8:tabstop=8:
*
- * Copyright (C) 2002, 2003 Cluster File Systems, Inc.
+ * Copyright (C) 2002, 2003, 2004, 2005, 2006 Cluster File Systems, Inc.
*
* This file is part of Lustre, http://www.lustre.org.
*
/* creates new obj on passed @fid and @mea. */
struct lmv_obj *
lmv_obj_alloc(struct obd_device *obd,
- struct lu_fid *fid,
+ const struct lu_fid *fid,
struct lmv_stripe_md *mea)
{
int i;
}
static struct lmv_obj *
-__lmv_obj_grab(struct obd_device *obd, struct lu_fid *fid)
+__lmv_obj_grab(struct obd_device *obd, const struct lu_fid *fid)
{
struct lmv_obj *obj;
struct list_head *cur;
* passed obd. It is possible that, object manager will have two
* objects with the same fid belong to different obds, if client
* and mds runs on the same host. May be it is good idea to have
- * objects list assosiated with obd.
+ * objects list associated with obd.
*/
if (obj->lo_obd != obd)
continue;
}
struct lmv_obj *
-lmv_obj_grab(struct obd_device *obd, struct lu_fid *fid)
+lmv_obj_grab(struct obd_device *obd, const struct lu_fid *fid)
{
struct lmv_obj *obj;
ENTRY;
/* looks in objects list for an object that matches passed @fid. If it is not
* found -- creates it using passed @mea and puts onto list. */
static struct lmv_obj *
-__lmv_obj_create(struct obd_device *obd, struct lu_fid *fid,
+__lmv_obj_create(struct obd_device *obd, const struct lu_fid *fid,
struct lmv_stripe_md *mea)
{
struct lmv_obj *new, *obj;
obj = __lmv_obj_grab(obd, fid);
if (obj) {
/* someone created it already - put @obj and getting out. */
- lmv_obj_free(new);
spin_unlock(&obj_list_lock);
+ lmv_obj_free(new);
RETURN(obj);
}
/* creates object from passed @fid and @mea. If @mea is NULL, it will be
* obtained from correct MDT and used for constructing the object. */
struct lmv_obj *
-lmv_obj_create(struct obd_export *exp, struct lu_fid *fid,
+lmv_obj_create(struct obd_export *exp, const struct lu_fid *fid,
struct lmv_stripe_md *mea)
{
struct obd_device *obd = exp->exp_obd;
struct ptlrpc_request *req = NULL;
struct lmv_obj *obj;
struct lustre_md md;
- int mealen, rc, mds;
+ int mealen, rc;
+ mdsno_t mds;
ENTRY;
CDEBUG(D_OTHER, "get mea for "DFID" and create lmv obj\n",
__u64 valid;
CDEBUG(D_OTHER, "mea isn't passed in, get it now\n");
- mealen = MEA_SIZE_LMV(lmv);
+ mealen = lmv_get_easize(lmv);
/* time to update mea of parent fid */
md.mea = NULL;
valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA | OBD_MD_MEA;
- mds = lmv_fld_lookup(obd, fid);
- if (mds < 0)
- GOTO(cleanup, obj = ERR_PTR(mds));
+ rc = lmv_fld_lookup(obd, fid, &mds);
+ if (rc)
+ GOTO(cleanup, obj = ERR_PTR(rc));
rc = md_getattr(lmv->tgts[mds].ltd_exp, fid, valid, mealen, &req);
if (rc) {
* for subsequent callers of lmv_obj_grab().
*/
int
-lmv_obj_delete(struct obd_export *exp, struct lu_fid *fid)
+lmv_obj_delete(struct obd_export *exp, const struct lu_fid *fid)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obj *obj;
int rc;
ENTRY;
+#if __KERNEL__
if ((unsigned long)lump < USER_SPACE_TOP) {
rc = copy_from_user(&lum, lump, sizeof(lum));
if (rc)
RETURN(-EFAULT);
} else {
+#endif
memcpy(&lum, lump, sizeof(lum));
+#if __KERNEL__
}
+#endif
if (lum.lmm_magic != LOV_USER_MAGIC) {
if (lum.lmm_magic == __swab32(LOV_USER_MAGIC)) {
if (!lsm)
RETURN(-ENODATA);
+#if __KERNEL__
if ((unsigned long)lump < USER_SPACE_TOP) {
rc = copy_from_user(&lum, lump, sizeof(lum));
if (rc)
RETURN(-EFAULT);
} else {
+#endif
memcpy(&lum, lump, sizeof(lum));
+#if __KERNEL__
}
-
+#endif
+
if (lum.lmm_magic != LOV_USER_MAGIC)
RETURN(-EINVAL);
/* User wasn't expecting this many OST entries */
if (lum.lmm_stripe_count == 0) {
+#if __KERNEL__
if ((unsigned long)lump < USER_SPACE_TOP) {
if (copy_to_user(lump, lmmk, sizeof(lum)))
rc = -EFAULT;
} else {
+#endif
memcpy(lump, lmmk, sizeof(lum));
+#if __KERNEL__
}
+#endif
} else if (lum.lmm_stripe_count < lmmk->lmm_stripe_count) {
rc = -EOVERFLOW;
} else {
+#if __KERNEL__
if ((unsigned long)lump < USER_SPACE_TOP) {
if (copy_to_user(lump, lmmk, sizeof(lum)))
rc = -EFAULT;
} else {
+#endif
memcpy(lump, lmmk, sizeof(lum));
+#if __KERNEL__
}
+#endif
}
obd_free_diskmd(exp, &lmmk);
#include <lustre_mdc.h>
void mdc_pack_req_body(struct ptlrpc_request *req, int offset,
- __u64 valid, struct lu_fid *fid, int ea_size, int flags);
+ __u64 valid, const struct lu_fid *fid,
+ int ea_size, int flags);
void mdc_pack_rep_body(struct ptlrpc_request *);
void mdc_readdir_pack(struct ptlrpc_request *req, int pos, __u64 offset,
- __u32 size, struct lu_fid *fid);
+ __u32 size, const struct lu_fid *fid);
void mdc_getattr_pack(struct ptlrpc_request *req, int offset, int valid,
int flags, struct md_op_data *data);
void mdc_setattr_pack(struct ptlrpc_request *req, int offset,
int mdc_set_lock_data(struct obd_export *exp,
__u64 *lockh, void *data);
-int mdc_change_cbdata(struct obd_export *exp, struct lu_fid *fid,
+int mdc_change_cbdata(struct obd_export *exp, const struct lu_fid *fid,
ldlm_iterator_t it, void *data);
+
int mdc_intent_lock(struct obd_export *exp,
struct md_op_data *,
void *lmm, int lmmsize,
int cookiesize);
int mdc_getstatus(struct obd_export *exp, struct lu_fid *rootfid);
-int mdc_getattr(struct obd_export *exp, struct lu_fid *fid,
+int mdc_getattr(struct obd_export *exp, const struct lu_fid *fid,
obd_valid valid, int ea_size,
struct ptlrpc_request **request);
-int mdc_getattr_name(struct obd_export *exp, struct lu_fid *fid,
+int mdc_getattr_name(struct obd_export *exp, const struct lu_fid *fid,
const char *filename, int namelen, obd_valid valid,
int ea_size, struct ptlrpc_request **request);
int mdc_setattr(struct obd_export *exp, struct md_op_data *op_data,
struct iattr *iattr, void *ea, int ealen, void *ea2, int ea2len,
struct ptlrpc_request **request);
-int mdc_setxattr(struct obd_export *exp, struct lu_fid *fid,
+int mdc_setxattr(struct obd_export *exp, const struct lu_fid *fid,
obd_valid valid, const char *xattr_name,
const char *input, int input_size,
int output_size, int flags,
struct ptlrpc_request **request);
-int mdc_getxattr(struct obd_export *exp, struct lu_fid *fid,
+int mdc_getxattr(struct obd_export *exp, const struct lu_fid *fid,
obd_valid valid, const char *xattr_name,
const char *input, int input_size,
int output_size, int flags, struct ptlrpc_request **request);
int mdc_close(struct obd_export *, struct md_op_data *,
struct obd_client_handle *, struct ptlrpc_request **);
-int mdc_readpage(struct obd_export *exp, struct lu_fid *fid,
+int mdc_readpage(struct obd_export *exp, const struct lu_fid *fid,
__u64 offset, struct page *, struct ptlrpc_request **);
int mdc_create(struct obd_export *exp, struct md_op_data *op_data,
const char *old, int oldlen, const char *new, int newlen,
struct ptlrpc_request **request);
-int mdc_sync(struct obd_export *exp, struct lu_fid *fid,
+int mdc_sync(struct obd_export *exp, const struct lu_fid *fid,
struct ptlrpc_request **);
int mdc_lock_match(struct obd_export *exp, int flags,
- struct lu_fid *fid, ldlm_type_t type,
+ const struct lu_fid *fid, ldlm_type_t type,
ldlm_policy_data_t *policy, ldlm_mode_t mode,
struct lustre_handle *lockh);
-int mdc_cancel_unused(struct obd_export *exp, struct lu_fid *fid,
+int mdc_cancel_unused(struct obd_export *exp, const struct lu_fid *fid,
int flags, void *opaque);
int mdc_done_writing(struct obd_export *exp, struct md_op_data *op_data);
#endif
void mdc_readdir_pack(struct ptlrpc_request *req, int pos, __u64 offset,
- __u32 size, struct lu_fid *fid)
+ __u32 size, const struct lu_fid *fid)
{
struct mdt_body *b;
}
void mdc_pack_req_body(struct ptlrpc_request *req, int offset,
- __u64 valid, struct lu_fid *fid, int ea_size, int flags)
+ __u64 valid, const struct lu_fid *fid,
+ int ea_size, int flags)
{
struct mdt_body *b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b));
}
int mdc_lock_match(struct obd_export *exp, int flags,
- struct lu_fid *fid, ldlm_type_t type,
+ const struct lu_fid *fid, ldlm_type_t type,
ldlm_policy_data_t *policy, ldlm_mode_t mode,
struct lustre_handle *lockh)
{
}
int mdc_cancel_unused(struct obd_export *exp,
- struct lu_fid *fid,
+ const struct lu_fid *fid,
int flags, void *opaque)
{
struct ldlm_res_id res_id =
RETURN(rc);
}
-int mdc_change_cbdata(struct obd_export *exp, struct lu_fid *fid,
+int mdc_change_cbdata(struct obd_export *exp,
+ const struct lu_fid *fid,
ldlm_iterator_t it, void *data)
{
struct ldlm_res_id res_id = { .name = {0} };
/* This should be mdc_get_info("rootfid") */
int mdc_getstatus(struct obd_export *exp, struct lu_fid *rootfid)
{
- return send_getstatus(class_exp2cliimp(exp), rootfid, LUSTRE_IMP_FULL,
- 0);
+ return send_getstatus(class_exp2cliimp(exp), rootfid,
+ LUSTRE_IMP_FULL, 0);
}
static
RETURN (0);
}
-int mdc_getattr(struct obd_export *exp, struct lu_fid *fid,
- obd_valid valid, int ea_size,
- struct ptlrpc_request **request)
+int mdc_getattr(struct obd_export *exp, const struct lu_fid *fid,
+ obd_valid valid, int ea_size, struct ptlrpc_request **request)
{
struct ptlrpc_request *req;
int size[2] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) };
RETURN (rc);
}
-int mdc_getattr_name(struct obd_export *exp, struct lu_fid *fid,
+int mdc_getattr_name(struct obd_export *exp, const struct lu_fid *fid,
const char *filename, int namelen, obd_valid valid,
int ea_size, struct ptlrpc_request **request)
{
}
static
-int mdc_xattr_common(struct obd_export *exp, struct lu_fid *fid,
+int mdc_xattr_common(struct obd_export *exp, const struct lu_fid *fid,
int opcode, obd_valid valid, const char *xattr_name,
const char *input, int input_size, int output_size,
int flags, struct ptlrpc_request **request)
goto out;
}
-int mdc_setxattr(struct obd_export *exp, struct lu_fid *fid,
+int mdc_setxattr(struct obd_export *exp, const struct lu_fid *fid,
obd_valid valid, const char *xattr_name,
const char *input, int input_size,
int output_size, int flags,
input, input_size, output_size, flags, request);
}
-int mdc_getxattr(struct obd_export *exp, struct lu_fid *fid,
+int mdc_getxattr(struct obd_export *exp, const struct lu_fid *fid,
obd_valid valid, const char *xattr_name,
const char *input, int input_size,
int output_size, int flags, struct ptlrpc_request **request)
RETURN(rc);
}
-int mdc_readpage(struct obd_export *exp, struct lu_fid *fid, __u64 offset,
- struct page *page, struct ptlrpc_request **request)
+int mdc_readpage(struct obd_export *exp, const struct lu_fid *fid,
+ __u64 offset, struct page *page,
+ struct ptlrpc_request **request)
{
struct obd_import *imp = class_exp2cliimp(exp);
struct ptlrpc_request *req = NULL;
return rc;
}
-static int mdc_pin(struct obd_export *exp, struct lu_fid *fid,
+static int mdc_pin(struct obd_export *exp, const struct lu_fid *fid,
struct obd_client_handle *handle, int flag)
{
struct ptlrpc_request *req;
RETURN(rc);
}
-int mdc_sync(struct obd_export *exp, struct lu_fid *fid,
+int mdc_sync(struct obd_export *exp, const struct lu_fid *fid,
struct ptlrpc_request **request)
{
struct ptlrpc_request *req;
git://git.whamcloud.com / fs / lustre-release.git / commitdiff