subdir-m += mgc
@SERVER_TRUE@subdir-m += mds obdfilter ost mgs mdt cmm mdd osd
-@CLIENT_TRUE@subdir-m += mdc llite
+@CLIENT_TRUE@subdir-m += mdc llite fld
@QUOTA_TRUE@subdir-m += quota
@INCLUDE_RULES@
SERVER_SUBDIRS := ldiskfs obdfilter ost mds mgs mdt cmm mdd osd
-CLIENT_SUBDIRS := mdc llite
+CLIENT_SUBDIRS := mdc llite fld
QUOTA_SUBDIRS := quota
lustre/cmm/autoMakefile
lustre/mdd/Makefile
lustre/mdd/autoMakefile
+lustre/fld/Makefile
+lustre/fld/autoMakefile
lustre/obdclass/Makefile
lustre/obdclass/autoMakefile
lustre/obdecho/Makefile
--- /dev/null
+MODULES := fld
+fld-objs := fld_seq.o
+
+@INCLUDE_RULES@
--- /dev/null
+# Copyright (C) 2001 Cluster File Systems, Inc.
+#
+# This code is issued under the GNU General Public License.
+# See the file COPYING in this distribution
+
+if MODULES
+modulefs_DATA = fld$(KMODEXT)
+endif
+
+MOSTLYCLEANFILES := @MOSTLYCLEANFILES@
+DIST_SOURCES := $(fld-objs:%.o=%.c)
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* license text for more details.
*/
-#ifndef _MDD_INTERNAL_H
-#define _MDD_INTERNAL_H
+#ifndef _FLD_INTERNAL_H
+#define _FLD_INTERNAL_H
struct fld_cache {
- struct hlist_node fld_hash;
+ struct hlist_node fld_list;
__u64 fld_mds;
__u64 fld_seq;
-}
+};
struct fld_cache_info {
- struct hlist_head *fld_list;
+ struct hlist_head *fld_hash;
spinlock_t fld_lock;
int fld_hash_mask;
-}
-#define FLD_CREATE 0
-#define FLD_DELETE 1
-#define FLD_GET 3
+};
#endif
--- /dev/null
+/* -*- MODE: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
+ * vim:expandtab:shiftwidth=8:tabstop=8:
+ *
+ * fld/fld.c
+ *
+ * Copyright (C) 2006 Cluster File Systems, Inc.
+ *
+ * This file is part of the Lustre file system, http://www.lustre.org
+ * Lustre is a trademark of Cluster File Systems, Inc.
+ *
+ * You may have signed or agreed to another license before downloading
+ * this software. If so, you are bound by the terms and conditions
+ * of that agreement, and the following does not apply to you. See the
+ * LICENSE file included with this distribution for more information.
+ *
+ * If you did not agree to a different license, then this copy of Lustre
+ * is open source software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * In either case, Lustre is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * license text for more details.
+ */
+#ifndef EXPORT_SYMTAB
+# define EXPORT_SYMTAB
+#endif
+#define DEBUG_SUBSYSTEM S_LLITE
+
+#include <linux/module.h>
+
+#include <linux/obd.h>
+#include <linux/obd_class.h>
+#include <linux/lustre_ver.h>
+#include <linux/obd_support.h>
+#include <linux/lprocfs_status.h>
+
+#include <linux/md_object.h>
+#include "fld_internal.h"
+
+/*XXX maybe these 2 items should go to sbi*/
+struct fld_cache_info *fld_cache = NULL;
+
+static int dht_mdt_hash(__u64 seq)
+{
+ return 0;
+}
+struct obd_export* get_fld_exp(struct obd_export *exp, __u64 seq)
+{
+ int seq_mds;
+
+ seq_mds = dht_mdt_hash(seq);
+ CDEBUG(D_INFO, "mds number %d\n", seq_mds);
+
+ /*get exp according to lu_seq*/
+ return exp;
+}
+
+enum {
+ FLD_HTABLE_BITS = 8,
+ FLD_HTABLE_SIZE = (1 << FLD_HTABLE_BITS),
+ FLD_HTABLE_MASK = FLD_HTABLE_SIZE - 1
+};
+
+static __u32 fld_hash(__u64 lu_seq)
+{
+ return lu_seq;
+}
+
+
+static int fld_cache_insert(struct fld_cache_info *fld_cache, __u64 lu_seq,
+ __u64 mds_num)
+{
+ struct fld_cache *fld;
+ struct hlist_head *bucket;
+ struct hlist_node *scan;
+ int rc = 0;
+ ENTRY;
+
+ bucket = fld_cache->fld_hash + (fld_hash(lu_seq) &
+ fld_cache->fld_hash_mask);
+
+ OBD_ALLOC_PTR(fld);
+ if (!fld)
+ RETURN(-ENOMEM);
+
+ INIT_HLIST_NODE(&fld->fld_list);
+ fld->fld_mds = mds_num;
+ fld->fld_seq = lu_seq;
+
+ spin_lock(&fld_cache->fld_lock);
+ hlist_for_each_entry(fld, scan, bucket, fld_list) {
+ if (fld->fld_seq == lu_seq) {
+ spin_unlock(&fld_cache->fld_lock);
+ GOTO(exit, rc = -EEXIST);
+ }
+ }
+ hlist_add_head(&fld->fld_list, bucket);
+ spin_unlock(&fld_cache->fld_lock);
+exit:
+ if (rc != 0)
+ OBD_FREE(fld, sizeof(*fld));
+ RETURN(rc);
+}
+
+static struct fld_cache*
+fld_cache_lookup(struct fld_cache_info *fld_cache, __u64 lu_seq)
+{
+ struct hlist_head *bucket;
+ struct hlist_node *scan;
+ struct fld_cache *fld;
+ ENTRY;
+
+ bucket = fld_cache->fld_hash + (fld_hash(lu_seq) &
+ fld_cache->fld_hash_mask);
+
+ spin_lock(&fld_cache->fld_lock);
+ hlist_for_each_entry(fld, scan, bucket, fld_list) {
+ if (fld->fld_seq == lu_seq) {
+ spin_unlock(&fld_cache->fld_lock);
+ RETURN(fld);
+ }
+ }
+ spin_unlock(&fld_cache->fld_lock);
+
+ RETURN(NULL);
+}
+
+static void fld_cache_delete(struct fld_cache_info *fld_cache, __u64 lu_seq)
+{
+ struct hlist_head *bucket;
+ struct hlist_node *scan;
+ struct fld_cache *fld;
+ ENTRY;
+
+ bucket = fld_cache->fld_hash + (fld_hash(lu_seq) &
+ fld_cache->fld_hash_mask);
+
+ spin_lock(&fld_cache->fld_lock);
+ hlist_for_each_entry(fld, scan, bucket, fld_list) {
+ if (fld->fld_seq == lu_seq) {
+ hlist_del_init(&fld->fld_list);
+ spin_unlock(&fld_cache->fld_lock);
+ EXIT;
+ return;
+ }
+ }
+ spin_unlock(&fld_cache->fld_lock);
+ return;
+}
+
+int fld_create(struct obd_export *exp, __u64 seq, __u64 mds_num)
+{
+ struct obd_export *fld_exp;
+ struct md_fld md_fld;
+ __u32 rc;
+ ENTRY;
+
+ fld_exp = get_fld_exp(exp, seq);
+ if (!fld_exp)
+ RETURN(-EINVAL);
+
+ md_fld.mf_seq = seq;
+ md_fld.mf_mds = mds_num;
+
+ rc = obd_set_info(fld_exp, strlen("fld_create"), "fld_create",
+ sizeof(struct md_fld), &md_fld);
+ fld_cache_insert(fld_cache, seq, mds_num);
+
+ RETURN(rc);
+}
+
+int fld_delete(struct obd_export *exp, __u64 seq, __u64 mds_num)
+{
+ struct obd_export *fld_exp;
+ struct md_fld md_fld;
+ __u32 rc;
+
+ fld_cache_delete(fld_cache, seq);
+
+ fld_exp = get_fld_exp(exp, seq);
+ if (!fld_exp)
+ RETURN(-EINVAL);
+
+ md_fld.mf_seq = seq;
+ md_fld.mf_mds = mds_num;
+
+ rc = obd_set_info(fld_exp, strlen("fld_delete"), "fld_delete",
+ sizeof(struct md_fld), &md_fld);
+
+ RETURN(rc);
+}
+
+int fld_get(struct obd_export *exp, __u64 lu_seq, __u64 *mds_num)
+{
+ struct obd_export *fld_exp;
+ struct md_fld md_fld;
+ int vallen, rc;
+
+ fld_exp = get_fld_exp(exp, lu_seq);
+ if (!fld_exp);
+ RETURN(-EINVAL);
+
+ md_fld.mf_seq = lu_seq;
+
+ vallen = sizeof(struct md_fld);
+
+ rc = obd_get_info(fld_exp, strlen("fld_delete"), "fld_delete",
+ &vallen, &md_fld);
+
+ *mds_num = md_fld.mf_mds;
+
+ RETURN(rc);
+}
+
+/*lookup fid in the namespace of pfid according to the name*/
+int fld_lookup(struct obd_export *exp, __u64 lu_seq, __u64 *mds_num)
+{
+ struct fld_cache *fld;
+ int rc;
+ ENTRY;
+
+ /*lookup it in the cache*/
+ fld = fld_cache_lookup(fld_cache, lu_seq);
+ if (fld != NULL) {
+ *mds_num = fld->fld_mds;
+ RETURN(0);
+ }
+ /*can not find it in the cache*/
+ rc = fld_get(exp, lu_seq, mds_num);
+ if (rc)
+ RETURN(rc);
+
+ rc = fld_cache_insert(fld_cache, lu_seq, *mds_num);
+
+ RETURN(rc);
+}
+
+static int fld_init(void)
+{
+ ENTRY;
+
+ OBD_ALLOC_PTR(fld_cache);
+ if (fld_cache == NULL)
+ RETURN(-ENOMEM);
+
+ /*init fld cache info*/
+ fld_cache->fld_hash_mask = FLD_HTABLE_MASK;
+ OBD_ALLOC(fld_cache->fld_hash, FLD_HTABLE_SIZE *
+ sizeof fld_cache->fld_hash[0]);
+ spin_lock_init(&fld_cache->fld_lock);
+
+ RETURN(0);
+}
+
+static int fld_fini(void)
+{
+ if (fld_cache != NULL) {
+ OBD_FREE(fld_cache->fld_hash, FLD_HTABLE_SIZE *
+ sizeof fld_cache->fld_hash[0]);
+ OBD_FREE_PTR(fld_cache);
+ }
+ return 0;
+}
+
+static int __init fld_mod_init(void)
+{
+ fld_init();
+ return 0;
+}
+
+static void __exit fld_mod_exit(void)
+{
+ fld_fini();
+ return;
+}
+
+MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
+MODULE_DESCRIPTION("Lustre fld Prototype");
+MODULE_LICENSE("GPL");
+
+cfs_module(mdd, "0.0.2", fld_mod_init, fld_mod_exit);
MDS_QUOTACTL = 48,
MDS_GETXATTR = 49,
MDS_SETXATTR = 50,
+ MDS_GET_INFO = 51,
MDS_LAST_OPC
} mds_cmd_t;
extern void lustre_swab_cmm_desc (struct cmm_desc *ld);
/*end adding MDT by huanghua@clusterfs.com*/
+struct md_fld {
+ __u64 mf_seq;
+ __u64 mf_mds;
+};
+extern void lustre_swab_md_fld (struct md_fld *mf);
extern void lustre_swab_lov_desc (struct lov_desc *ld);
/*
struct md_device *m, struct lu_fid *f);
int (*mdo_statfs)(struct lu_context *ctx,
struct md_device *m, struct kstatfs *sfs);
+
+ int (*mdo_get_info)(struct lu_context *ctx, struct md_device *m,
+ __u32 keylen, void *key, __u32 *vallen, void *val);
+
+ int (*mdo_set_info)(struct lu_context *ctx, struct md_device *m,
+ __u32 keylen, void *key, __u32 vallen, void *val);
};
struct md_device {
{
lu_device_fini(&md->md_lu_dev);
}
+
#endif /* _LINUX_MD_OBJECT_H */
#define OBD_FAIL_MDS_SETXATTR_WRITE 0x134
#define OBD_FAIL_MDS_SET_INFO_NET 0x135
#define OBD_FAIL_MDS_SET_INFO_PACK 0x136
+#define OBD_FAIL_MDS_GET_INFO_NET 0x137
+#define OBD_FAIL_MDS_GET_INFO_PACK 0x138
#define OBD_FAIL_OST 0x200
#define OBD_FAIL_OST_CONNECT_NET 0x201
b->eadatasize = ea_size;
mdc_pack_body(b);
}
-
-#ifdef FLD_PROTO_TYPE
-void mdc_fld_pack(struct ptlrpc_request *req, int offset, __u64 mds_num,
- __u64 seq_num, int op)
-{
- struct mdt_body *b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b));
-
- b->size = seq_num;
- b->valid = mds_num;
- b->fsuid = op;
-}
-#endif
/* packing of MDS records */
void mdc_create_pack(struct ptlrpc_request *req, int offset,
struct mdc_op_data *op_data, const void *data, int datalen,
RETURN(rc);
}
-#ifdef FLD_PROTO_TYPE
-int mdc_fld_req(struct obd_export *exp, __u64 mds_num, __u64 seq_num, int op)
-{
- struct obd_device *obd = exp->exp_obd;
- struct ptlrpc_request *req;
- int size[] = { sizeof(struct mdt_body)};
- int rc, level, bufcount = 1;
- ENTRY;
-
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_FLD_OP, bufcount, size, NULL);
- if (req == NULL)
- RETURN(-ENOMEM);
-
- /* mdc_create_pack fills msg->bufs[1] with name
- * and msg->bufs[2] with tgt, for symlinks or lov MD data */
- mdc_fld_pack(req, MDS_REQ_REC_OFF, mds_num, seq_num, op);
-
- size[0] = sizeof(struct mdt_body);
- req->rq_replen = lustre_msg_size(1, size);
-
- level = LUSTRE_IMP_FULL;
- rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, level);
-
- ptlrpc_req_finished(req);
- RETURN(rc);
-}
-#endif
-
int mdc_unlink(struct obd_export *exp, struct mdc_op_data *data,
struct ptlrpc_request **request)
{
#include <linux/obd_class.h>
#include <linux/lustre_mdc.h>
+#include <linux/md_object.h>
#include <linux/lustre_acl.h>
#include <linux/lustre_dlm.h>
#include <linux/lprocfs_status.h>
ptlrpc_req_finished(req);
RETURN(rc);
}
+ if (KEY_IS("fld_create") || KEY_IS("fld_delete")) {
+ struct ptlrpc_request *req;
+ int size[2] = {keylen, vallen};
+ char *bufs[2] = {key, val};
+ ENTRY;
+ req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION,
+ MDS_SET_INFO, 2, size, bufs);
+ if (req == NULL)
+ RETURN(-ENOMEM);
+
+ req->rq_replen = lustre_msg_size(0, NULL);
+ rc = ptlrpc_queue_wait(req);
+ if (rc)
+ GOTO(out_req, rc);
+out_req:
+ ptlrpc_req_finished(req);
+ RETURN(rc);
+
+ }
RETURN(rc);
}
*max_easize = exp->exp_obd->u.cli.cl_max_mds_easize;
RETURN(0);
}
+ if (KEY_IS("fld_get")) {
+ struct ptlrpc_request *req;
+ int size[2] = {keylen, *vallen};
+ char *bufs[2] = {key, val};
+ struct md_fld *reply;
+ ENTRY;
+
+ req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
+ MDS_GET_INFO, 2, size, bufs);
+ if (req == NULL)
+ RETURN(-ENOMEM);
+
+ req->rq_replen = lustre_msg_size(1, (int *)vallen);
+ rc = ptlrpc_queue_wait(req);
+ if (rc)
+ GOTO(out_req, rc);
+
+ reply = lustre_swab_repbuf(req, 0, sizeof(*reply),
+ lustre_swab_md_fld);
+ if (reply == NULL) {
+ CERROR("Can't unpack %s\n", (char *)key);
+ GOTO(out_req, rc = -EPROTO);
+ }
+ *((struct md_fld *)val) = *reply;
+out_req:
+ ptlrpc_req_finished(req);
+ RETURN(rc);
+ }
RETURN(rc);
}
static void mdd_object_release(struct lu_context *ctxt, struct lu_object *o)
{
struct mdd_object *obj = mdd_obj(o);
-
int rc;
int nlink;
RETURN(rc);
}
-static struct md_device_operations mdd_ops = {
+/*XXX use linked list temp for fld in this prototype*/
+struct fld_list {
+ struct list_head fld_list;
+ spinlock_t fld_lock;
+};
+struct fld_item{
+ struct list_head fld_list;
+ __u64 fld_seq;
+ __u64 fld_mds;
+};
+
+struct fld_list fld_list_head;
+
+static void mdd_fld_init(struct mdd_device *mdd)
+{
+ INIT_LIST_HEAD(&fld_list_head.fld_list);
+ spin_lock_init(&fld_list_head.fld_lock);
+}
+
+static void mdd_fld_fini(struct mdd_device *mdd)
+{
+ struct list_head *pos, *n;
+
+ spin_lock(&fld_list_head.fld_lock);
+ list_for_each_safe(pos, n, &fld_list_head.fld_list) {
+ struct fld_item *fld = list_entry(pos, struct fld_item,
+ fld_list);
+ list_del_init(&fld->fld_list);
+ OBD_FREE_PTR(fld);
+ }
+ spin_unlock(&fld_list_head.fld_lock);
+}
+
+static int mdd_fld_create(struct mdd_device *mdd, __u64 seq_num, __u64 mds_num)
+{
+ struct fld_item *fld;
+
+ OBD_ALLOC_PTR(fld);
+ fld->fld_seq = seq_num;
+ fld->fld_mds = mds_num;
+ INIT_LIST_HEAD(&fld->fld_list);
+ spin_lock(&fld_list_head.fld_lock);
+ list_add_tail(&fld_list_head.fld_list, &fld->fld_list);
+ spin_unlock(&fld_list_head.fld_lock);
+ return 0;
+}
+
+static int mdd_fld_delete(struct mdd_device *mdd, __u64 seq_num, __u64 mds_num)
+{
+ struct list_head *pos, *n;
+ spin_lock(&fld_list_head.fld_lock);
+ list_for_each_safe(pos, n, &fld_list_head.fld_list) {
+ struct fld_item *fld = list_entry(pos, struct fld_item,
+ fld_list);
+ if (fld->fld_seq == seq_num) {
+ LASSERT(fld->fld_mds == mds_num);
+ list_del_init(&fld->fld_list);
+ OBD_FREE_PTR(fld);
+ spin_unlock(&fld_list_head.fld_lock);
+ RETURN(0);
+ }
+ }
+ spin_unlock(&fld_list_head.fld_lock);
+ RETURN(0);
+}
+
+static int mdd_fld_get(struct mdd_device *mdd, __u64 seq_num, __u64 *mds_num)
+{
+ struct list_head *pos, *n;
+
+ spin_lock(&fld_list_head.fld_lock);
+ list_for_each_safe(pos, n, &fld_list_head.fld_list) {
+ struct fld_item *fld = list_entry(pos, struct fld_item,
+ fld_list);
+ if (fld->fld_seq == seq_num) {
+ *mds_num = fld->fld_mds;
+ spin_unlock(&fld_list_head.fld_lock);
+ RETURN(0);
+ }
+ }
+ spin_unlock(&fld_list_head.fld_lock);
+ return -ENOENT;
+}
+
+static int mdd_get_info(struct lu_context *ctx, struct md_device *m,
+ __u32 keylen, void *key, __u32 *vallen, void *val)
+{
+ struct mdd_device *mdd = lu2mdd_dev(&m->md_lu_dev);
+ int rc;
+
+ ENTRY;
+ if (keylen >= strlen("fld_get") &&
+ memcmp(key, "fld_get", 7) == 0) {
+ struct md_fld *mf = val;
+ rc = mdd_fld_get(mdd, mf->mf_seq, &mf->mf_mds);
+ RETURN(rc);
+ }
+ RETURN(-EINVAL);
+}
+
+static int mdd_set_info(struct lu_context *ctx, struct md_device *m,
+ __u32 keylen, void *key, __u32 vallen, void *val)
+{
+ struct mdd_device *mdd = lu2mdd_dev(&m->md_lu_dev);
+ int rc;
+ ENTRY;
+
+ if (keylen >= strlen("fld_create") &&
+ memcmp(key, "fld_create", 10) == 0) {
+ struct md_fld *mf = val;
+ rc = mdd_fld_create(mdd, mf->mf_seq, mf->mf_mds);
+ RETURN(rc);
+ }
+
+ if (keylen >= strlen("fld_delete") &&
+ memcmp(key, "fld_delete", 10) == 0) {
+ struct md_fld *mf = val;
+ rc = mdd_fld_delete(mdd, mf->mf_seq, mf->mf_mds);
+ RETURN(rc);
+ }
+
+ RETURN(-EINVAL);
+}
+
+struct md_device_operations mdd_ops = {
.mdo_root_get = mdd_root_get,
+ .mdo_get_info = mdd_get_info,
+ .mdo_set_info = mdd_set_info,
.mdo_config = mdd_config,
.mdo_statfs = mdd_statfs
};
l = mdd2lu_dev(m);
l->ld_ops = &mdd_lu_ops;
m->mdd_md_dev.md_ops = &mdd_ops;
-
+ mdd_fld_init(m);
/* get next layer */
obd = class_name2obd(child);
if (obd && obd->obd_lu_dev) {
struct mdd_device *m = lu2mdd_dev(lu);
LASSERT(atomic_read(&lu->ld_ref) == 0);
- md_device_fini(&m->mdd_md_dev);
+ mdd_fld_fini(m);
+ md_device_fini(&m->mdd_md_dev);
OBD_FREE_PTR(m);
}
RETURN(result);
}
+static int mdt_set_info(struct mdt_thread_info *info,
+ struct ptlrpc_request *req, int offset)
+{
+ struct md_device *next = info->mti_mdt->mdt_child;
+ char *key;
+ int keylen, rc = 0;
+ ENTRY;
+
+ key = lustre_msg_buf(req->rq_reqmsg, 0, 1);
+ if (key == NULL) {
+ DEBUG_REQ(D_HA, req, "no set_info key");
+ RETURN(-EFAULT);
+ }
+ keylen = req->rq_reqmsg->buflens[0];
+
+ if (((keylen >= strlen("fld_create") &&
+ memcmp(key, "fld_create", keylen) == 0)) ||
+ ((keylen >= strlen("fld_delete") &&
+ memcmp(key, "fld_delete", keylen) == 0))) {
+ struct md_fld mf, *p;
+ __u32 size = sizeof(struct md_fld);
+
+ rc = lustre_pack_reply(req, 0, NULL, NULL);
+ if (rc)
+ RETURN(rc);
+
+ p = lustre_swab_reqbuf(req, 1, sizeof(mf), lustre_swab_md_fld);
+ mf = *p;
+ rc = next->md_ops->mdo_get_info(&info->mti_ctxt, next, keylen,
+ key, &size, &mf);
+ RETURN(rc);
+ }
+
+ CDEBUG(D_IOCTL, "invalid key\n");
+ RETURN(-EINVAL);
+
+}
+
+static int mdt_get_info(struct mdt_thread_info *info,
+ struct ptlrpc_request *req, int offset)
+{
+ struct md_device *next = info->mti_mdt->mdt_child;
+ char *key;
+ int keylen, rc = 0;
+ ENTRY;
+
+ key = lustre_msg_buf(req->rq_reqmsg, 0, 1);
+ if (key == NULL) {
+ DEBUG_REQ(D_HA, req, "no set_info key");
+ RETURN(-EFAULT);
+ }
+ keylen = req->rq_reqmsg->buflens[0];
+
+ if (((keylen >= strlen("fld_get") &&
+ memcmp(key, "fld_get", keylen) == 0))) {
+ struct md_fld mf, *p, *reply;
+ int size = sizeof(*reply);
+
+ rc = lustre_pack_reply(req, 1, &size, NULL);
+ if (rc)
+ RETURN(rc);
+ p = lustre_swab_reqbuf(req, 1, sizeof(mf), lustre_swab_md_fld);
+ mf = *p;
+ rc = next->md_ops->mdo_get_info(&info->mti_ctxt, next, keylen,
+ key, &size, &mf);
+ reply = lustre_msg_buf(req->rq_repmsg, 0, size);
+ *reply = mf;
+ RETURN(rc);
+ }
+
+ CDEBUG(D_IOCTL, "invalid key\n");
+ RETURN(-EINVAL);
+}
+
static struct lu_device_operations mdt_lu_ops;
static int lu_device_is_mdt(struct lu_device *d)
return -EOPNOTSUPP;
}
-static int mdt_set_info(struct mdt_thread_info *info,
- struct ptlrpc_request *req, int offset)
-{
- return -EOPNOTSUPP;
-}
-
static int mdt_handle_quotacheck(struct mdt_thread_info *info,
struct ptlrpc_request *req, int offset)
{
DEF_MDT_HNDL(0, PIN, mdt_pin),
DEF_MDT_HNDL(HABEO_CORPUS, SYNC, mdt_sync),
DEF_MDT_HNDL(0, SET_INFO, mdt_set_info),
+ DEF_MDT_HNDL(0, GET_INFO, mdt_get_info),
DEF_MDT_HNDL(0, QUOTACHECK, mdt_handle_quotacheck),
DEF_MDT_HNDL(0, QUOTACTL, mdt_handle_quotactl)
};
/* uuid endian insensitive */
}
/*end adding MDT by huanghua@clusterfs.com*/
-
+void lustre_swab_md_fld (struct md_fld *mf)
+{
+ __swab64s(&mf->mf_seq);
+ __swab64s(&mf->mf_mds);
+}
static void print_lum (struct lov_user_md *lum)
{
EXPORT_SYMBOL(lustre_swab_ldlm_reply);
EXPORT_SYMBOL(lustre_swab_qdata);
EXPORT_SYMBOL(lustre_swab_mgs_target_info);
+EXPORT_SYMBOL(lustre_swab_md_fld);
/* recover.c */
EXPORT_SYMBOL(ptlrpc_run_recovery_over_upcall);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff