MDS_QUOTACTL = 48,
MDS_GETXATTR = 49,
MDS_SETXATTR = 50,
+ MDS_WRITEPAGE = 51,
+ MDS_IS_SUBDIR = 52,
+ MDS_GET_INFO = 53,
MDS_LAST_OPC
} mds_cmd_t;
MDS_SETXATTR = 50, /* obsolete, now it's MDS_REINT op */
MDS_WRITEPAGE = 51,
MDS_IS_SUBDIR = 52,
+ MDS_GET_INFO = 53,
MDS_LAST_OPC
} mds_cmd_t;
__u32 cs_id;
} __attribute__((packed));
+/** fid2path request/reply structure */
+struct getinfo_fid2path {
+ struct lu_fid gf_fid;
+ __u64 gf_recno;
+ __u32 gf_linkno;
+ __u32 gf_pathlen;
+ char gf_path[0];
+};
+
+void lustre_swab_fid2path (struct getinfo_fid2path *gf);
+
/** changelog record */
struct llog_changelog_rec {
struct llog_rec_hdr cr_hdr;
extern const struct req_format RQF_MDS_CONNECT;
extern const struct req_format RQF_MDS_DISCONNECT;
extern const struct req_format RQF_MDS_SET_INFO;
+extern const struct req_format RQF_MDS_GET_INFO;
extern const struct req_format RQF_MDS_READPAGE;
extern const struct req_format RQF_MDS_WRITEPAGE;
extern const struct req_format RQF_MDS_IS_SUBDIR;
extern const struct req_msg_field RMF_CLUUID;
extern const struct req_msg_field RMF_SETINFO_VAL;
extern const struct req_msg_field RMF_SETINFO_KEY;
+extern const struct req_msg_field RMF_GETINFO_VAL;
+extern const struct req_msg_field RMF_GETINFO_VALLEN;
+extern const struct req_msg_field RMF_GETINFO_KEY;
/*
* connection handle received in MDS_CONNECT request.
#define KEY_BLOCKSIZE "blocksize"
#define KEY_CAPA_KEY "capa_key"
#define KEY_CHANGELOG_CLEAR "changelog_clear"
+#define KEY_FID2PATH "fid2path"
#define KEY_CHECKSUM "checksum"
#define KEY_CLEAR_FS "clear_fs"
#define KEY_CONN_DATA "conn_data"
#define OBD_FAIL_MDS_WRITEPAGE_NET 0x183
#define OBD_FAIL_MDS_WRITEPAGE_PACK 0x184
#define OBD_FAIL_MDS_RECOVERY_ACCEPTS_GAPS 0x185
+#define OBD_FAIL_MDS_GET_INFO_NET 0x186
#define OBD_FAIL_OST 0x200
#define OBD_FAIL_OST_CONNECT_NET 0x201
#include <lprocfs_status.h>
#include <lustre_param.h>
#include "mdc_internal.h"
+#include <lustre/lustre_idl.h>
#define REQUEST_MINOR 244
RETURN(0);
}
+/* This routine is quite similar to mdt_ioc_fid2path() */
+int mdc_ioc_fid2path(struct obd_export *exp, struct obd_ioctl_data *data)
+{
+ struct getinfo_fid2path *fp = NULL;
+ int keylen = size_round(sizeof(KEY_FID2PATH)) + sizeof(*fp);
+ int pathlen = data->ioc_plen1;
+ __u32 vallen = pathlen + sizeof(*fp);
+ int alloclen = keylen + vallen;
+ void *buf;
+ int rc;
+
+ if (pathlen > PATH_MAX)
+ RETURN(-EINVAL);
+ if (pathlen < 2)
+ RETURN(-EINVAL);
+
+ OBD_ALLOC(buf, alloclen);
+ if (buf == NULL)
+ RETURN(-ENOMEM);
+ fp = buf + size_round(sizeof(KEY_FID2PATH));
+ memcpy(buf, KEY_FID2PATH, sizeof(KEY_FID2PATH));
+ memcpy(&fp->gf_fid, data->ioc_inlbuf1, sizeof(struct lu_fid));
+ memcpy(&fp->gf_recno, data->ioc_inlbuf2, sizeof(fp->gf_recno));
+ memcpy(&fp->gf_linkno, data->ioc_inlbuf3,
+ sizeof(fp->gf_linkno));
+ fp->gf_pathlen = pathlen;
+
+ CDEBUG(D_IOCTL, "path get "DFID" from "LPU64" #%d\n",
+ PFID(&fp->gf_fid), fp->gf_recno, fp->gf_linkno);
+
+ if (!fid_is_sane(&fp->gf_fid))
+ GOTO(out, rc = -EINVAL);
+
+ rc = obd_get_info(exp, keylen, buf, &vallen, fp, NULL);
+ if (rc)
+ GOTO(out, rc);
+
+ if (vallen < sizeof(*fp) + 1)
+ GOTO(out, rc = -EPROTO);
+ else if (vallen - sizeof(*fp) > pathlen)
+ GOTO(out, rc = -EOVERFLOW);
+ if (copy_to_user(data->ioc_pbuf1, fp->gf_path,
+ pathlen))
+ GOTO(out, rc = -EFAULT);
+ memcpy(data->ioc_inlbuf2, &fp->gf_recno, sizeof(fp->gf_recno));
+ memcpy(data->ioc_inlbuf3, &fp->gf_linkno,
+ sizeof(fp->gf_linkno));
+
+out:
+ OBD_FREE(buf, alloclen);
+
+ return rc;
+}
+
static int mdc_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
void *karg, void *uarg)
{
NULL);
GOTO(out, rc);
}
+ case OBD_IOC_FID2PATH: {
+ rc = mdc_ioc_fid2path(exp, data);
+ GOTO(out, rc);
+ }
case OBD_IOC_CLIENT_RECOVER:
rc = ptlrpc_recover_import(imp, data->ioc_inlbuf1);
if (rc < 0)
RETURN(rc);
}
+int mdc_get_info_rpc(struct obd_export *exp,
+ obd_count keylen, void *key,
+ int vallen, void *val)
+{
+ struct obd_import *imp = class_exp2cliimp(exp);
+ struct ptlrpc_request *req;
+ char *tmp;
+ int rc = -EINVAL;
+ ENTRY;
+
+ req = ptlrpc_request_alloc(imp, &RQF_MDS_GET_INFO);
+ if (req == NULL)
+ RETURN(-ENOMEM);
+
+ req_capsule_set_size(&req->rq_pill, &RMF_GETINFO_KEY,
+ RCL_CLIENT, keylen);
+ req_capsule_set_size(&req->rq_pill, &RMF_GETINFO_VALLEN,
+ RCL_CLIENT, sizeof(__u32));
+
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_GET_INFO);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_GETINFO_KEY);
+ memcpy(tmp, key, keylen);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_GETINFO_VALLEN);
+ memcpy(tmp, &vallen, sizeof(__u32));
+
+ req_capsule_set_size(&req->rq_pill, &RMF_GETINFO_VAL,
+ RCL_SERVER, vallen);
+ ptlrpc_request_set_replen(req);
+
+ rc = ptlrpc_queue_wait(req);
+ if (!rc) {
+ tmp = req_capsule_server_get(&req->rq_pill, &RMF_GETINFO_VAL);
+ memcpy(val, tmp, vallen);
+ if (lustre_msg_swabbed(req->rq_repmsg)) {
+ if (KEY_IS(KEY_FID2PATH)) {
+ lustre_swab_fid2path(val);
+ }
+ }
+ }
+ ptlrpc_req_finished(req);
+
+ RETURN(rc);
+}
+
int mdc_set_info_async(struct obd_export *exp,
obd_count keylen, void *key,
obd_count vallen, void *val,
RETURN(0);
}
+ rc = mdc_get_info_rpc(exp, keylen, key, *vallen, val);
+
RETURN(rc);
}
static struct mdt_device *mdt_dev(struct lu_device *d);
static int mdt_regular_handle(struct ptlrpc_request *req);
static int mdt_unpack_req_pack_rep(struct mdt_thread_info *info, __u32 flags);
+static int mdt_fid2path(struct lu_env *env, struct mdt_device *mdt,
+ struct getinfo_fid2path *fp);
static const struct lu_object_operations mdt_obj_ops;
case MDS_GETXATTR:
case MDS_SETXATTR:
case MDS_SET_INFO:
+ case MDS_GET_INFO:
case MDS_QUOTACHECK:
case MDS_QUOTACTL:
case QUOTA_DQACQ:
RETURN(0);
}
+/* This routine is quite similar to mdc_ioc_fid2path() */
static int mdt_ioc_fid2path(struct lu_env *env, struct mdt_device *mdt,
struct obd_ioctl_data *data)
{
+ struct getinfo_fid2path *fp = NULL;
+ int pathlen;
+ int alloclen;
+ int rc;
+
+ ENTRY;
+
+ pathlen = data->ioc_plen1;
+ if (pathlen > PATH_MAX)
+ GOTO(out, rc = -EINVAL);
+ if (pathlen < 2)
+ GOTO(out, rc = -EINVAL);
+
+ alloclen = sizeof(*fp) + pathlen;
+ OBD_ALLOC(fp, alloclen);
+ if (fp == NULL)
+ GOTO(out, rc = -ENOMEM);
+
+ memcpy(&fp->gf_fid, data->ioc_inlbuf1, sizeof(struct lu_fid));
+ memcpy(&fp->gf_recno, data->ioc_inlbuf2, sizeof(fp->gf_recno));
+ memcpy(&fp->gf_linkno, data->ioc_inlbuf3,
+ sizeof(fp->gf_linkno));
+ fp->gf_pathlen = pathlen;
+
+ if (!fid_is_sane(&fp->gf_fid))
+ GOTO(out, rc = -EINVAL);
+
+ rc = mdt_fid2path(env, mdt, fp);
+
+ if (!rc && copy_to_user(data->ioc_pbuf1, fp->gf_path, pathlen))
+ GOTO(out, rc = -EFAULT);
+ memcpy(data->ioc_inlbuf2, &fp->gf_recno, sizeof(fp->gf_recno));
+ memcpy(data->ioc_inlbuf3, &fp->gf_linkno, sizeof(fp->gf_linkno));
+out:
+ if (fp)
+ OBD_FREE(fp, alloclen);
+ RETURN(rc);
+}
+
+static int mdt_rpc_fid2path(struct mdt_thread_info *info, void *key,
+ int keylen, void *val, int vallen)
+{
+ struct lu_env env;
+ struct mdt_device *mdt = mdt_dev(info->mti_exp->exp_obd->obd_lu_dev);
+ struct ptlrpc_request *req = mdt_info_req(info);
+ struct getinfo_fid2path *fpout, *fpin;
+ int rc = 0;
+
+ fpin = key + size_round(sizeof(KEY_FID2PATH));
+ fpout = val;
+
+ if (lustre_msg_swabbed(req->rq_reqmsg))
+ lustre_swab_fid2path(fpin);
+
+ memcpy(fpout, fpin, sizeof(*fpin));
+ if (fpout->gf_pathlen != vallen - sizeof(*fpin))
+ RETURN(-EINVAL);
+
+ rc = lu_env_init(&env, LCT_MD_THREAD);
+ if (rc)
+ RETURN(rc);
+ rc = mdt_fid2path(&env, mdt, fpout);
+ lu_env_fini(&env);
+
+ RETURN(rc);
+}
+
+static int mdt_fid2path(struct lu_env *env, struct mdt_device *mdt,
+ struct getinfo_fid2path *fp)
+{
struct lu_context ioctl_session;
struct mdt_object *obj;
- struct lu_fid *fid;
- char *path = NULL;
- __u64 recno;
- int pathlen = data->ioc_plen1;
- int linkno;
int rc;
ENTRY;
-
- fid = (struct lu_fid *)data->ioc_inlbuf1;
- memcpy(&recno, data->ioc_inlbuf2, sizeof(recno));
- memcpy(&linkno, data->ioc_inlbuf3, sizeof(linkno));
CDEBUG(D_IOCTL, "path get "DFID" from "LPU64" #%d\n",
- PFID(fid), recno, linkno);
+ PFID(&fp->gf_fid), fp->gf_recno, fp->gf_linkno);
- if (!fid_is_sane(fid))
+ if (!fid_is_sane(&fp->gf_fid))
RETURN(-EINVAL);
- if (pathlen < 3)
- RETURN(-EOVERFLOW);
-
rc = lu_context_init(&ioctl_session, LCT_SESSION);
if (rc)
RETURN(rc);
lu_context_enter(&ioctl_session);
env->le_ses = &ioctl_session;
- OBD_ALLOC(path, pathlen);
- if (path == NULL)
- GOTO(out_context, rc = -ENOMEM);
-
- obj = mdt_object_find(env, mdt, fid);
+ obj = mdt_object_find(env, mdt, &fp->gf_fid);
if (obj == NULL || IS_ERR(obj)) {
- CDEBUG(D_IOCTL, "no object "DFID": %ld\n", PFID(fid),
+ CDEBUG(D_IOCTL, "no object "DFID": %ld\n",PFID(&fp->gf_fid),
PTR_ERR(obj));
- GOTO(out_free, rc = -EINVAL);
+ GOTO(out, rc = -EINVAL);
}
rc = lu_object_exists(&obj->mot_obj.mo_lu);
else
rc = -ENOENT;
mdt_object_put(env, obj);
- CDEBUG(D_IOCTL, "nonlocal object "DFID": %d\n", PFID(fid),
- rc);
- GOTO(out_free, rc);
+ CDEBUG(D_IOCTL, "nonlocal object "DFID": %d\n",
+ PFID(&fp->gf_fid), rc);
+ GOTO(out, rc);
}
- rc = mo_path(env, md_object_next(&obj->mot_obj), path, pathlen, &recno,
- &linkno);
+ rc = mo_path(env, md_object_next(&obj->mot_obj), fp->gf_path,
+ fp->gf_pathlen, &fp->gf_recno, &fp->gf_linkno);
mdt_object_put(env, obj);
- if (rc)
- GOTO(out_free, rc);
-
- if (copy_to_user(data->ioc_pbuf1, path, pathlen))
- rc = -EFAULT;
-
- memcpy(data->ioc_inlbuf2, &recno, sizeof(recno));
- memcpy(data->ioc_inlbuf3, &linkno, sizeof(linkno));
EXIT;
-out_free:
- OBD_FREE(path, pathlen);
-out_context:
+
+out:
lu_context_exit(&ioctl_session);
lu_context_fini(&ioctl_session);
return rc;
}
+static int mdt_get_info(struct mdt_thread_info *info)
+{
+ char *key;
+ int keysize;
+ int keylen;
+ __u32 *valin;
+ __u32 vallen;
+ int valsize;
+ void *valout;
+ int rc;
+ struct ptlrpc_request *req = mdt_info_req(info);
+
+ ENTRY;
+
+ key = req_capsule_client_get(info->mti_pill, &RMF_GETINFO_KEY);
+ if (key == NULL) {
+ CDEBUG(D_IOCTL, "No GETINFO key");
+ RETURN(-EFAULT);
+ }
+ keysize = req_capsule_get_size(info->mti_pill, &RMF_GETINFO_KEY,
+ RCL_CLIENT);
+ keylen = strnlen(key, keysize);
+
+ valin = req_capsule_client_get(info->mti_pill, &RMF_GETINFO_VALLEN);
+ if (valin == NULL) {
+ CDEBUG(D_IOCTL, "Unable to get RMF_GETINFO_VALLEN buffer");
+ RETURN(-EFAULT);
+ }
+ valsize = req_capsule_get_size(info->mti_pill, &RMF_GETINFO_VALLEN,
+ RCL_CLIENT);
+ if (valsize != sizeof(vallen)) {
+ CDEBUG(D_IOCTL, "RMF_GETINFO_VALLEN has invalid size");
+ RETURN(-EINVAL);
+ }
+ vallen = *valin;
+
+ req_capsule_set_size(info->mti_pill, &RMF_GETINFO_VAL, RCL_SERVER,
+ vallen);
+ rc = req_capsule_server_pack(info->mti_pill);
+ valout = req_capsule_server_get(info->mti_pill, &RMF_GETINFO_VAL);
+ if (valout == NULL) {
+ CDEBUG(D_IOCTL, "Unable to get get-info RPC out buffer");
+ RETURN(-EFAULT);
+ }
+
+ if (KEY_IS(KEY_FID2PATH))
+ rc = mdt_rpc_fid2path(info, key, keysize, valout, vallen);
+ else
+ rc = -EINVAL;
+
+ lustre_msg_set_status(req->rq_repmsg, rc);
+
+ RETURN(rc);
+}
+
/* Pass the ioc down */
static int mdt_ioc_child(struct lu_env *env, struct mdt_device *mdt,
unsigned int cmd, int len, void *data)
DEF_MDT_HNDL_F(0, CONNECT, mdt_connect),
DEF_MDT_HNDL_F(0, DISCONNECT, mdt_disconnect),
DEF_MDT_HNDL_F(0, SET_INFO, mdt_set_info),
+DEF_MDT_HNDL_F(0, GET_INFO, mdt_get_info),
DEF_MDT_HNDL_F(0 |HABEO_REFERO, GETSTATUS, mdt_getstatus),
DEF_MDT_HNDL_F(HABEO_CORPUS, GETATTR, mdt_getattr),
DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, GETATTR_NAME, mdt_getattr_name),
&RMF_SETINFO_VAL
};
+static const struct req_msg_field *mds_getinfo_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_GETINFO_KEY,
+ &RMF_GETINFO_VALLEN
+};
+
+static const struct req_msg_field *mds_getinfo_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_GETINFO_VAL,
+};
+
static const struct req_msg_field *ldlm_enqueue_client[] = {
&RMF_PTLRPC_BODY,
&RMF_DLM_REQ
&RQF_MDS_CONNECT,
&RQF_MDS_DISCONNECT,
&RQF_MDS_SET_INFO,
+ &RQF_MDS_GET_INFO,
&RQF_MDS_GETSTATUS,
&RQF_MDS_STATFS,
&RQF_MDS_GETATTR,
DEFINE_MSGF("setinfo_val", 0, -1, NULL);
EXPORT_SYMBOL(RMF_SETINFO_VAL);
+const struct req_msg_field RMF_GETINFO_KEY =
+ DEFINE_MSGF("getinfo_key", 0, -1, NULL);
+EXPORT_SYMBOL(RMF_GETINFO_KEY);
+
+const struct req_msg_field RMF_GETINFO_VALLEN =
+ DEFINE_MSGF("getinfo_vallen", 0,
+ sizeof(__u32), lustre_swab_generic_32s);
+EXPORT_SYMBOL(RMF_GETINFO_VALLEN);
+
+const struct req_msg_field RMF_GETINFO_VAL =
+ DEFINE_MSGF("getinfo_val", 0, -1, NULL);
+EXPORT_SYMBOL(RMF_GETINFO_VAL);
+
const struct req_msg_field RMF_SEQ_OPC =
DEFINE_MSGF("seq_query_opc", 0,
sizeof(__u32), lustre_swab_generic_32s);
DEFINE_REQ_FMT0("MDS_SET_INFO", mds_set_info_client, empty);
EXPORT_SYMBOL(RQF_MDS_SET_INFO);
+const struct req_format RQF_MDS_GET_INFO =
+ DEFINE_REQ_FMT0("MDS_GET_INFO", mds_getinfo_client,
+ mds_getinfo_server);
+EXPORT_SYMBOL(RQF_MDS_GET_INFO);
+
const struct req_format RQF_LDLM_ENQUEUE =
DEFINE_REQ_FMT0("LDLM_ENQUEUE",
ldlm_enqueue_client, ldlm_enqueue_lvb_server);
{ MDS_SETXATTR, "mds_setxattr" },
{ MDS_WRITEPAGE, "mds_writepage" },
{ MDS_IS_SUBDIR, "mds_is_subdir" },
+ { MDS_GET_INFO, "mds_get_info" },
{ LDLM_ENQUEUE, "ldlm_enqueue" },
{ LDLM_CONVERT, "ldlm_convert" },
{ LDLM_CANCEL, "ldlm_cancel" },
CLASSERT(offsetof(typeof(*sa), sa_padding) != 0);
}
+void lustre_swab_fid2path(struct getinfo_fid2path *gf)
+{
+ lustre_swab_lu_fid(&gf->gf_fid);
+ __swab64s(&gf->gf_recno);
+ __swab32s(&gf->gf_linkno);
+ __swab32s(&gf->gf_pathlen);
+}
+EXPORT_SYMBOL(lustre_swab_fid2path);
+
void lustre_swab_mds_rec_join (struct mds_rec_join *jr)
{
__swab64s(&jr->jr_headsize);
{
/* Wire protocol assertions generated by 'wirecheck'
* (make -C lustre/utils newwiretest)
- * running on Linux cfs21 2.6.18-92.el5xen #1 SMP Tue Jun 10 19:55:54 EDT 2008 i686 i686 i386
+ * running on Linux lin3 2.6.18-128.1.1-prep #1 SMP Wed Mar 4 23:08:37 MST 2009 i686 i686 i38
* with gcc version 4.1.2 20071124 (Red Hat 4.1.2-42) */
(long long)MDS_WRITEPAGE);
LASSERTF(MDS_IS_SUBDIR == 52, " found %lld\n",
(long long)MDS_IS_SUBDIR);
- LASSERTF(MDS_LAST_OPC == 53, " found %lld\n",
+ LASSERTF(MDS_GET_INFO == 53, " found %lld\n",
+ (long long)MDS_GET_INFO);
+ LASSERTF(MDS_LAST_OPC == 54, " found %lld\n",
(long long)MDS_LAST_OPC);
LASSERTF(REINT_SETATTR == 1, " found %lld\n",
(long long)REINT_SETATTR);
CLASSERT(OBD_CONNECT_REQPORTAL == 0x40ULL);
CLASSERT(OBD_CONNECT_ACL == 0x80ULL);
CLASSERT(OBD_CONNECT_XATTR == 0x100ULL);
- CLASSERT(OBD_CONNECT_REAL == 0x08000000ULL);
+ CLASSERT(OBD_CONNECT_REAL == 0x8000000ULL);
CLASSERT(OBD_CONNECT_CKSUM == 0x20000000ULL);
CLASSERT(OBD_CONNECT_TRUNCLOCK == 0x400ULL);
CLASSERT(OBD_CONNECT_IBITS == 0x1000ULL);
CLASSERT(OBD_CONNECT_JOIN == 0x2000ULL);
CLASSERT(OBD_CONNECT_ATTRFID == 0x4000ULL);
CLASSERT(OBD_CONNECT_NODEVOH == 0x8000ULL);
- CLASSERT(OBD_CONNECT_RMT_CLIENT == 0x00010000ULL);
- CLASSERT(OBD_CONNECT_RMT_CLIENT_FORCE == 0x00020000ULL);
+ CLASSERT(OBD_CONNECT_RMT_CLIENT == 0x10000ULL);
+ CLASSERT(OBD_CONNECT_RMT_CLIENT_FORCE == 0x20000ULL);
CLASSERT(OBD_CONNECT_BRW_SIZE == 0x40000ULL);
CLASSERT(OBD_CONNECT_QUOTA64 == 0x80000ULL);
CLASSERT(OBD_CONNECT_MDS_CAPA == 0x100000ULL);
CLASSERT(OBD_CONNECT_OSS_CAPA == 0x200000ULL);
- CLASSERT(OBD_CONNECT_MDS_MDS == 0x04000000ULL);
- CLASSERT(OBD_CONNECT_SOM == 0x00800000ULL);
- CLASSERT(OBD_CONNECT_AT == 0x01000000ULL);
+ CLASSERT(OBD_CONNECT_MDS_MDS == 0x4000000ULL);
+ CLASSERT(OBD_CONNECT_SOM == 0x800000ULL);
+ CLASSERT(OBD_CONNECT_AT == 0x1000000ULL);
CLASSERT(OBD_CONNECT_CANCELSET == 0x400000ULL);
- CLASSERT(OBD_CONNECT_LRU_RESIZE == 0x02000000ULL);
+ CLASSERT(OBD_CONNECT_LRU_RESIZE == 0x2000000ULL);
CLASSERT(OBD_CONNECT_VBR == 0x80000000ULL);
CLASSERT(OBD_CONNECT_SKIP_ORPHAN == 0x400000000ULL);
run_test 160 "changelog sanity"
test_161() {
- # need local MDT for fid2path
- remote_mds && skip "remote MDS" && return
-
mkdir -p $DIR/$tdir
cp /etc/hosts $DIR/$tdir/$tfile
mkdir $DIR/$tdir/foo1
}
test_162() {
- # need local MDT for fid2path
- remote_mds && skip "remote MDS" && return
-
# Make changes to filesystem
mkdir -p $DIR/$tdir/d2
touch $DIR/$tdir/d2/$tfile
data.ioc_inlbuf1 = name;
rc = dev_ioctl(&data, -1, OBD_IOC_NAME2DEV);
+ if (rc < 0)
+ return rc;
+
+ return data.ioc_dev;
+}
+
+
+static void do_get_mdcname(char *obd_type_name, char *obd_name,
+ char *obd_uuid, void *name)
+{
+ if (strncmp(obd_name, (char *)name, strlen((char *)name)) == 0)
+ strcpy((char *)name, obd_name);
+}
+
+static int get_mdcdev(const char *mdtname)
+{
+ char name[MAX_OBD_NAME];
+ char *type[] = { "mdc" };
+ int rc;
+
+ strcpy(name, mdtname);
+ rc = llapi_target_iterate(1, type, (void *)name, do_get_mdcname);
+ rc = rc < 0 ? : -rc;
if (rc < 0) {
llapi_err(LLAPI_MSG_ERROR, "Device %s not found %d\n", name,rc);
return rc;
}
- return data.ioc_dev;
+ rc = dev_name2dev(name);
+ if (rc < 0)
+ llapi_err(LLAPI_MSG_ERROR, "Device %s not found %d\n", name,rc);
+ return rc;
}
int llapi_fid2path(char *device, char *fidstr, char *buf, int buflen,
{
struct lu_fid fid;
struct obd_ioctl_data data;
- char buffer[256];
+ char mdtname[256];
int dev, rc;
while (*fidstr == '[')
return -EINVAL;
}
- rc = get_mdtname(device, "%s%s", buffer);
+ /* If the node is an MDS, issue the ioctl to the MDT . If not,
+ issue it to the MDC. */
+ rc = get_mdtname(device, "%s%s", mdtname);
if (rc < 0)
return rc;
-
- dev = dev_name2dev(buffer);
- if (dev < 0)
- return dev;
+ dev = dev_name2dev(mdtname);
+ if (dev < 0) {
+ dev = get_mdcdev(mdtname);
+ if (dev < 0) {
+ llapi_err(LLAPI_MSG_ERROR | LLAPI_MSG_NO_ERRNO,
+ "can't find mdc for '%s'\n", mdtname);
+ return dev;
+ }
+ }
memset(&data, 0, sizeof(data));
data.ioc_inlbuf1 = (char *)&fid;
return rc;
}
-
CHECK_VALUE(MDS_SETXATTR);
CHECK_VALUE(MDS_WRITEPAGE);
CHECK_VALUE(MDS_IS_SUBDIR);
+ CHECK_VALUE(MDS_GET_INFO);
CHECK_VALUE(MDS_LAST_OPC);
CHECK_VALUE(REINT_SETATTR);
{
/* Wire protocol assertions generated by 'wirecheck'
* (make -C lustre/utils newwiretest)
- * running on Linux cfs21 2.6.18-92.el5xen #1 SMP Tue Jun 10 19:55:54 EDT 2008 i686 i686 i386
+ * running on Linux lin3 2.6.18-128.1.1-prep #1 SMP Wed Mar 4 23:08:37 MST 2009 i686 i686 i38
* with gcc version 4.1.2 20071124 (Red Hat 4.1.2-42) */
(long long)MDS_WRITEPAGE);
LASSERTF(MDS_IS_SUBDIR == 52, " found %lld\n",
(long long)MDS_IS_SUBDIR);
- LASSERTF(MDS_LAST_OPC == 53, " found %lld\n",
+ LASSERTF(MDS_GET_INFO == 53, " found %lld\n",
+ (long long)MDS_GET_INFO);
+ LASSERTF(MDS_LAST_OPC == 54, " found %lld\n",
(long long)MDS_LAST_OPC);
LASSERTF(REINT_SETATTR == 1, " found %lld\n",
(long long)REINT_SETATTR);
CLASSERT(OBD_CONNECT_REQPORTAL == 0x40ULL);
CLASSERT(OBD_CONNECT_ACL == 0x80ULL);
CLASSERT(OBD_CONNECT_XATTR == 0x100ULL);
- CLASSERT(OBD_CONNECT_REAL == 0x08000000ULL);
+ CLASSERT(OBD_CONNECT_REAL == 0x8000000ULL);
CLASSERT(OBD_CONNECT_CKSUM == 0x20000000ULL);
CLASSERT(OBD_CONNECT_TRUNCLOCK == 0x400ULL);
CLASSERT(OBD_CONNECT_IBITS == 0x1000ULL);
CLASSERT(OBD_CONNECT_JOIN == 0x2000ULL);
CLASSERT(OBD_CONNECT_ATTRFID == 0x4000ULL);
CLASSERT(OBD_CONNECT_NODEVOH == 0x8000ULL);
- CLASSERT(OBD_CONNECT_RMT_CLIENT == 0x00010000ULL);
- CLASSERT(OBD_CONNECT_RMT_CLIENT_FORCE == 0x00020000ULL);
+ CLASSERT(OBD_CONNECT_RMT_CLIENT == 0x10000ULL);
+ CLASSERT(OBD_CONNECT_RMT_CLIENT_FORCE == 0x20000ULL);
CLASSERT(OBD_CONNECT_BRW_SIZE == 0x40000ULL);
CLASSERT(OBD_CONNECT_QUOTA64 == 0x80000ULL);
CLASSERT(OBD_CONNECT_MDS_CAPA == 0x100000ULL);
CLASSERT(OBD_CONNECT_OSS_CAPA == 0x200000ULL);
- CLASSERT(OBD_CONNECT_MDS_MDS == 0x04000000ULL);
- CLASSERT(OBD_CONNECT_SOM == 0x00800000ULL);
- CLASSERT(OBD_CONNECT_AT == 0x01000000ULL);
+ CLASSERT(OBD_CONNECT_MDS_MDS == 0x4000000ULL);
+ CLASSERT(OBD_CONNECT_SOM == 0x800000ULL);
+ CLASSERT(OBD_CONNECT_AT == 0x1000000ULL);
CLASSERT(OBD_CONNECT_CANCELSET == 0x400000ULL);
- CLASSERT(OBD_CONNECT_LRU_RESIZE == 0x02000000ULL);
+ CLASSERT(OBD_CONNECT_LRU_RESIZE == 0x2000000ULL);
CLASSERT(OBD_CONNECT_VBR == 0x80000000ULL);
CLASSERT(OBD_CONNECT_SKIP_ORPHAN == 0x400000000ULL);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff