#include <asm/types.h>
#include <linux/types.h>
-#else
+#else
#define __KERNEL__
#include <linux/list.h>
#undef __KERNEL__
#include <stdint.h>
#endif
-/*
+/*
* this file contains all data structures used in Lustre interfaces:
* - obdo and obd_request records
* - mds_request records
* - ldlm data
* - ioctl's
- */
-
-struct lustre_msg {
- __u32 opc;
- __u32 xid;
- __u32 status;
- __u32 type;
- __u32 connid;
- __u32 bufcount;
- __u32 buflens[0];
-};
-
-struct ptlreq_hdr {
- __u32 opc;
- __u32 xid;
- __u32 status;
- __u32 type;
- __u32 connid;
- __u32 bufcount;
- __u32 buflens[0];
-};
+ */
-struct ptlrep_hdr {
+struct lustre_msg {
__u32 opc;
__u32 xid;
__u32 status;
__u32 buflens[0];
};
-/*
+/*
* OST requests: OBDO & OBD request records
*/
typedef uint32_t obd_flag;
typedef uint32_t obd_count;
-#define OBD_FL_INLINEDATA (0x00000001UL)
+#define OBD_FL_INLINEDATA (0x00000001UL)
#define OBD_FL_OBDMDEXISTS (0x00000002UL)
#define OBD_INLINESZ 60
#define OST_REQ_HAS_OA1 0x1
-struct ost_req {
+struct ost_body {
__u32 connid;
- __u32 cmd;
+ __u32 data;
struct obdo oa;
- __u32 buflen1;
- __u32 buflen2;
};
-struct ost_rep {
- __u32 result;
- __u32 connid;
- struct obdo oa;
- __u32 buflen1;
- __u32 buflen2;
-};
-
-struct obd_ioobj {
+struct obd_ioobj {
obd_id ioo_id;
obd_gr ioo_gr;
__u32 ioo_type;
__u32 ioo_bufcnt;
};
-
-/*
+/*
* MDS REQ RECORDS
*/
#define MDS_REINT 4
#define MDS_READPAGE 5
-#define REINT_SETATTR 0
-#define REINT_CREATE 1
-#define REINT_LINK 2
-#define REINT_UNLINK 3
-#define REINT_RENAME 4
-#define REINT_MAX 4
+#define REINT_SETATTR 1
+#define REINT_CREATE 2
+#define REINT_LINK 3
+#define REINT_UNLINK 4
+#define REINT_RENAME 5
+#define REINT_MAX 5
-struct ll_fid {
+struct ll_fid {
__u64 id;
__u32 generation;
__u32 f_type;
};
-struct niobuf {
+struct niobuf {
__u64 addr;
- __u64 offset;
+ __u64 offset;
__u32 len;
__u32 flags;
__u32 xid;
void *page;
};
-struct mds_req {
- struct ll_fid fid1;
- struct ll_fid fid2;
- __u32 namelen;
- __u32 tgtlen;
- __u32 opcode;
- __u32 valid;
- __u32 mode;
- __u32 uid;
- __u32 gid;
- __u64 objid;
- __u64 size;
- __u32 mtime;
- __u32 ctime;
- __u32 atime;
- __u32 flags;
- __u32 major;
- __u32 minor;
- __u32 ino;
- __u32 nlink;
- __u32 generation;
+struct mds_body {
+ struct ll_fid fid1;
+ struct ll_fid fid2;
+ __u64 objid;
+ __u64 size;
+ __u32 valid;
+ __u32 mode;
+ __u32 uid;
+ __u32 gid;
+ __u32 mtime;
+ __u32 ctime;
+ __u32 atime;
+ __u32 flags;
+ __u32 major;
+ __u32 minor;
+ __u32 ino;
+ __u32 nlink;
+ __u32 generation;
};
-struct mds_rep {
- struct ll_fid fid1;
- struct ll_fid fid2;
- __u32 namelen;
- __u32 tgtlen;
- __u32 valid;
- __u32 mode;
- __u32 uid;
- __u32 gid;
- __u64 objid;
- __u64 size;
- __u32 mtime;
- __u32 ctime;
- __u32 atime;
- __u32 flags;
- __u32 major;
- __u32 minor;
- __u32 ino;
- __u32 nlink;
- __u32 generation;
-};
-
-/* MDS update records */
-struct mds_update_record_hdr {
- __u32 ur_reclen;
+/* MDS update records */
+struct mds_update_record_hdr {
__u32 ur_opcode;
};
-struct mds_rec_setattr {
- __u32 sa_reclen;
+struct mds_rec_setattr {
__u32 sa_opcode;
struct ll_fid sa_fid;
__u32 sa_valid;
__u32 sa_attr_flags;
};
-struct mds_rec_create {
- __u32 cr_reclen;
+struct mds_rec_create {
__u32 cr_opcode;
struct ll_fid cr_fid;
__u32 cr_uid;
__u32 cr_gid;
__u64 cr_time;
__u32 cr_mode;
- /* overloaded: id for create, tgtlen for symlink, rdev for mknod */
- __u64 cr_id;
- __u32 cr_namelen;
- __u32 cr_tgtlen;
- /* name here */
- /* symlink target here */
+ /* overloaded: id for create, tgtlen for symlink, rdev for mknod */
+ __u64 cr_id;
};
-struct mds_rec_link {
- __u32 lk_reclen;
+struct mds_rec_link {
__u32 lk_opcode;
struct ll_fid lk_fid1;
struct ll_fid lk_fid2;
- __u32 lk_namelen;
};
-struct mds_rec_unlink {
- __u32 ul_reclen;
+struct mds_rec_unlink {
__u32 ul_opcode;
struct ll_fid ul_fid1;
struct ll_fid ul_fid2;
- __u32 ul_namelen;
};
-struct mds_rec_rename {
- __u32 rn_reclen;
+struct mds_rec_rename {
__u32 rn_opcode;
struct ll_fid rn_fid1;
struct ll_fid rn_fid2;
- __u32 rn_namelen;
- __u32 rn_tgtlen;
};
-#ifdef __KERNEL__
+#ifdef __KERNEL__
static inline void ll_ino2fid(struct ll_fid *fid, ino_t ino, __u32 generation,
int type)
inode->i_mode & S_IFMT);
}
-#endif
+#endif
-/*
+/*
* LDLM requests:
*/
struct ldlm_handle lock_handle;
};
-/*
+/*
* OBD IOCTLS
*/
#define OBD_IOCTL_VERSION 0x00010001
-struct obd_ioctl_data {
+struct obd_ioctl_data {
uint32_t ioc_len;
uint32_t ioc_version;
uint32_t ioc_conn1;
char ioc_bulk[0];
};
-struct obd_ioctl_hdr {
+struct obd_ioctl_hdr {
uint32_t ioc_len;
uint32_t ioc_version;
};
static inline int obd_ioctl_is_invalid(struct obd_ioctl_data *data)
{
- if (data->ioc_len > (1<<30)) {
+ if (data->ioc_len > (1<<30)) {
printk("OBD ioctl: ioc_len larger than 1<<30\n");
return 1;
}
- if (data->ioc_inllen1 > (1<<30)) {
+ if (data->ioc_inllen1 > (1<<30)) {
printk("OBD ioctl: ioc_inllen1 larger than 1<<30\n");
return 1;
}
- if (data->ioc_inllen2 > (1<<30)) {
+ if (data->ioc_inllen2 > (1<<30)) {
printk("OBD ioctl: ioc_inllen2 larger than 1<<30\n");
return 1;
}
printk("OBD ioctl: packlen exceeds ioc_len\n");
return 1;
}
- if (data->ioc_inllen1 &&
- data->ioc_bulk[data->ioc_inllen1 - 1] != '\0') {
+ if (data->ioc_inllen1 &&
+ data->ioc_bulk[data->ioc_inllen1 - 1] != '\0') {
printk("OBD ioctl: inlbuf1 not 0 terminated\n");
return 1;
}
- if (data->ioc_inllen2 &&
- data->ioc_bulk[size_round(data->ioc_inllen1) + data->ioc_inllen2 - 1] != '\0') {
+ if (data->ioc_inllen2 &&
+ data->ioc_bulk[size_round(data->ioc_inllen1) + data->ioc_inllen2 - 1] != '\0') {
printk("OBD ioctl: inlbuf2 not 0 terminated\n");
return 1;
}
data->ioc_len = obd_ioctl_packlen(data);
data->ioc_version = OBD_IOCTL_VERSION;
- if (*pbuf && obd_ioctl_packlen(data) > max)
+ if (*pbuf && obd_ioctl_packlen(data) > max)
return 1;
- if (*pbuf == NULL) {
+ if (*pbuf == NULL) {
*pbuf = malloc(data->ioc_len);
}
if (!*pbuf)
return err;
}
- if (hdr->ioc_version != OBD_IOCTL_VERSION) {
+ if (hdr->ioc_version != OBD_IOCTL_VERSION) {
printk("OBD: version mismatch kernel vs application\n");
return -EINVAL;
}
- if (hdr->ioc_len + buf >= end) {
+ if (hdr->ioc_len + buf >= end) {
printk("OBD: user buffer exceeds kernel buffer\n");
return -EINVAL;
}
- if (hdr->ioc_len < sizeof(struct obd_ioctl_data)) {
+ if (hdr->ioc_len < sizeof(struct obd_ioctl_data)) {
printk("OBD: user buffer too small for ioctl\n");
return -EINVAL;
}
return err;
}
- if (obd_ioctl_is_invalid(data)) {
+ if (obd_ioctl_is_invalid(data)) {
printk("OBD: ioctl not correctly formatted\n");
return -EINVAL;
}
- if (data->ioc_inllen1) {
+ if (data->ioc_inllen1) {
data->ioc_inlbuf1 = &data->ioc_bulk[0];
}
- if (data->ioc_inllen2) {
+ if (data->ioc_inllen2) {
data->ioc_inlbuf2 = &data->ioc_bulk[0] + size_round(data->ioc_inllen1);
}
#define OBD_IOC_DEC_FS_USE_COUNT _IO ('f', 32 )
-
-/* GENERAL THINGS */
-union ptl_rep {
- struct mds_rep *mds;
- struct ost_rep *ost;
- struct lustre_msg *lustre;
-};
-
-union ptl_req {
- struct mds_req *mds;
- struct ost_req *ost;
- struct lustre_msg *lustre;
-};
-
#endif
#define LUSTRE_MDS_NAME "mds"
struct mds_update_record {
- __u32 ur_reclen;
__u32 ur_opcode;
struct ll_fid *ur_fid1;
struct ll_fid *ur_fid2;
__u64 ur_time;
};
-/* mds/mds_pack.c */
-void *mds_req_tgt(struct mds_req *req);
-int mds_pack_req(char *name, int namelen, char *tgt, int tgtlen, struct ptlreq_hdr **hdr, union ptl_req *req, int *len, char **buf);
-int mds_unpack_req(char *buf, int len, struct ptlreq_hdr **hdr, union ptl_req *);
-int mds_pack_rep(char *name, int namelen, char *tgt, int tgtlen, struct ptlrep_hdr **hdr, union ptl_rep *rep, int *len, char **buf);
-int mds_unpack_rep(char *buf, int len, struct ptlrep_hdr **hdr, union ptl_rep *rep);
-
/* mds/mds_reint.c */
int mds_reint_rec(struct mds_update_record *r, struct ptlrpc_request *req);
/* lib/mds_updates.c */
-int mds_update_unpack(char *buf, int len, struct mds_update_record *r);
-
-void mds_setattr_pack(struct mds_rec_setattr *rec, struct inode *inode, struct iattr *iattr);
-void mds_create_pack(struct mds_rec_create *rec, struct inode *inode, const char *name, int namelen, __u32 mode, __u64 id, __u32 uid, __u32 gid, __u64 time, const char *tgt, int tgtlen);
-void mds_unlink_pack(struct mds_rec_unlink *rec, struct inode *inode, struct inode *child, const char *name, int namelen);
-void mds_link_pack(struct mds_rec_link *rec, struct inode *inode, struct inode *dir, const char *name, int namelen);
-void mds_rename_pack(struct mds_rec_rename *rec, struct inode *srcdir, struct inode *tgtdir, const char *name, int namelen, const char *tgt, int tgtlen);
+void mds_pack_body(struct ptlrpc_request *);
+void mds_unpack_body(struct ptlrpc_request *);
+int mds_update_unpack(struct ptlrpc_request *, struct mds_update_record *);
+
+void mds_setattr_pack(struct mds_rec_setattr *, struct inode *, struct iattr *);
+void mds_create_pack(struct mds_rec_create *, struct inode *, __u32 mode,
+ __u64 id, __u32 uid, __u32 gid, __u64 time);
+void mds_unlink_pack(struct mds_rec_unlink *, struct inode *inode,
+ struct inode *child);
+void mds_link_pack(struct mds_rec_link *, struct inode *ino, struct inode *dir);
+void mds_rename_pack(struct mds_rec_rename *, struct inode *srcdir,
+ struct inode *tgtdir);
/* mds/handler.c */
struct dentry *mds_fid2dentry(struct mds_obd *mds, struct ll_fid *fid, struct vfsmount **mnt);
#define SVC_LIST 32
#define SVC_SIGNAL 64
-typedef int (*rep_unpack_t)(char *, int, struct ptlrep_hdr **, union ptl_rep *);
-typedef int (*req_pack_t)(char *, int, char *, int, struct ptlreq_hdr **,
- union ptl_req*, int *, char **);
-
-typedef int (*req_unpack_t)(char *buf, int len, struct ptlreq_hdr **,
- union ptl_req *);
-typedef int (*rep_pack_t)(char *buf1, int len1, char *buf2, int len2,
- struct ptlrep_hdr **, union ptl_rep*,
- int *replen, char **repbuf);
-
struct ptlrpc_client {
struct lustre_peer cli_server;
struct obd_device *cli_obd;
__u32 cli_request_portal;
__u32 cli_reply_portal;
- rep_unpack_t cli_rep_unpack;
- req_pack_t cli_req_pack;
spinlock_t cli_lock;
__u32 cli_xid;
__u32 rq_connid;
__u32 rq_xid;
- char *rq_reqbuf;
int rq_reqlen;
- struct ptlreq_hdr *rq_reqhdr;
- union ptl_req rq_req;
+ char *rq_reqbuf;
+ struct lustre_msg *rq_reqmsg;
- char *rq_repbuf;
int rq_replen;
- struct ptlrep_hdr *rq_rephdr;
- union ptl_rep rq_rep;
+ char *rq_repbuf;
+ struct lustre_msg *rq_repmsg;
char *rq_bulkbuf;
int rq_bulklen;
spinlock_t srv_lock;
struct list_head srv_reqs;
ptl_event_t srv_ev;
- req_unpack_t srv_req_unpack;
- rep_pack_t srv_rep_pack;
int (*srv_handler)(struct obd_device *obddev,
struct ptlrpc_service *svc,
struct ptlrpc_request *req);
void ptlrpc_link_svc_me(struct ptlrpc_service *service, int i);
/* rpc/client.c */
-int ptlrpc_connect_client(int dev, char *uuid, int req_portal, int rep_portal,
- req_pack_t req_pack, rep_unpack_t rep_unpack,
+int ptlrpc_connect_client(int dev, char *uuid, int req_portal, int rep_portal,
struct ptlrpc_client *cl);
int ptlrpc_queue_wait(struct ptlrpc_client *cl, struct ptlrpc_request *req);
int ptlrpc_queue_req(struct ptlrpc_client *peer, struct ptlrpc_request *req);
-struct ptlrpc_request *ptlrpc_prep_req(struct ptlrpc_client *cl,
- int opcode, int namelen, char *name,
- int tgtlen, char *tgt);
+struct ptlrpc_request *ptlrpc_prep_req(struct ptlrpc_client *cl, int opcode,
+ int count, int *lengths, char **bufs);
void ptlrpc_free_req(struct ptlrpc_request *request);
struct ptlrpc_bulk_desc *ptlrpc_prep_bulk(struct lustre_peer *);
int ptlrpc_check_status(struct ptlrpc_request *req, int err);
struct obd_device *dev;
};
+/* rpc/pack_generic.c */
+int lustre_pack_msg(int count, int *lens, char **bufs, int *len, char **buf);
+int lustre_msg_size(int count, int *lengths);
+int lustre_unpack_msg(char *buf, int len);
+void *lustre_msg_buf(struct lustre_msg *m, int n);
+
#endif
/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=8:tabstop=8:
*
- *
* Copyright (C) 2001 Cluster File Systems, Inc.
*
* This code is issued under the GNU General Public License.
int typ_refcnt;
};
-struct obd_run_ctxt {
- struct vfsmount *pwdmnt;
- struct dentry *pwd;
- mm_segment_t fs;
+struct obd_run_ctxt {
+ struct vfsmount *pwdmnt;
+ struct dentry *pwd;
+ mm_segment_t fs;
};
struct obd_conn {
};
struct obd_devicename {
- uint32_t len;
- char * name;
+ uint32_t len;
+ char *name;
struct dentry *dentry; /* file system obd device names */
- __u8 _uuid[16]; /* uuid obd device names */
+ __u8 _uuid[16]; /* uuid obd device names */
};
/* Individual type definitions */
struct ext2_obd {
- struct super_block * e2_sb;
- struct vfsmount *e2_vfsmnt;
+ struct super_block *e2_sb;
+ struct vfsmount *e2_vfsmnt;
};
struct filter_obd {
- char *fo_fstype;
- struct super_block * fo_sb;
- struct vfsmount *fo_vfsmnt;
- struct obd_run_ctxt fo_ctxt;
- spinlock_t fo_lock;
- __u64 fo_lastino;
- struct file_operations *fo_fop;
- struct inode_operations *fo_iop;
- struct address_space_operations *fo_aops;
+ char *fo_fstype;
+ struct super_block *fo_sb;
+ struct vfsmount *fo_vfsmnt;
+ struct obd_run_ctxt fo_ctxt;
+ spinlock_t fo_lock;
+ __u64 fo_lastino;
+ struct file_operations *fo_fop;
+ struct inode_operations *fo_iop;
+ struct address_space_operations *fo_aops;
};
struct mds_obd {
struct ptlrpc_service *mds_service;
- char *mds_fstype;
- struct super_block * mds_sb;
- struct vfsmount *mds_vfsmnt;
- struct obd_run_ctxt mds_ctxt;
- struct file_operations *mds_fop;
- struct inode_operations *mds_iop;
- struct address_space_operations *mds_aops;
+ char *mds_fstype;
+ struct super_block *mds_sb;
+ struct vfsmount *mds_vfsmnt;
+ struct obd_run_ctxt mds_ctxt;
+ struct file_operations *mds_fop;
+ struct inode_operations *mds_iop;
+ struct address_space_operations *mds_aops;
struct mds_fs_operations *mds_fsops;
};
};
struct echo_obd {
- char *eo_fstype;
+ char *eo_fstype;
struct super_block *eo_sb;
- struct vfsmount *eo_vfsmnt;
- struct obd_run_ctxt eo_ctxt;
- spinlock_t eo_lock;
- __u64 eo_lastino;
- struct file_operations *eo_fop;
- struct inode_operations *eo_iop;
- struct address_space_operations *eo_aops;
+ struct vfsmount *eo_vfsmnt;
+ struct obd_run_ctxt eo_ctxt;
+ spinlock_t eo_lock;
+ __u64 eo_lastino;
+ struct file_operations *eo_fop;
+ struct inode_operations *eo_iop;
+ struct address_space_operations *eo_aops;
};
struct trace_obd {
#if 0
struct snap_obd {
- unsigned int snap_index; /* which snapshot index are we accessing */
- int snap_tableno;
+ unsigned int snap_index; /* which snapshot index are we accessing */
+ int snap_tableno;
};
struct raid1_obd {
struct ost_obd {
struct ptlrpc_service *ost_service;
- struct obd_device *ost_tgt;
- struct obd_conn ost_conn;
+ struct obd_device *ost_tgt;
+ struct obd_conn ost_conn;
};
struct osc_obd {
- struct obd_device *osc_tgt;
- struct ptlrpc_client *osc_peer;
+ struct obd_device *osc_tgt;
+ struct ptlrpc_client *osc_client;
};
/* corresponds to one of the obd's */
struct obd_type *obd_type;
int obd_minor;
int obd_flags;
- int obd_refcnt;
- struct obd_devicename obd_fsname;
- struct proc_dir_entry *obd_proc_entry;
+ int obd_refcnt;
+ struct obd_devicename obd_fsname;
+ struct proc_dir_entry *obd_proc_entry;
int obd_multi_count;
struct obd_conn obd_multi_conn[MAX_MULTI];
unsigned int obd_gen_last_id;
struct osc_obd osc;
struct ldlm_obd ldlm;
struct echo_obd echo;
- struct trace_obd trace;
+ struct trace_obd trace;
#if 0
struct raid1_obd raid1;
struct snap_obd snap;
obd_size count, obd_off offset);
int (*o_iterate)(struct obd_conn *conn, int (*)(obd_id, obd_gr, void *),
obd_id *startid, obd_gr group, void *data);
- int (*o_preprw)(int cmd, struct obd_conn *conn,
- int objcount, struct obd_ioobj *obj,
- int niocount, struct niobuf *nb,
- struct niobuf *res);
- int (*o_commitrw)(int cmd, struct obd_conn *conn,
- int objcount, struct obd_ioobj *obj,
- int niocount, struct niobuf *res);
+ int (*o_preprw)(int cmd, struct obd_conn *conn,
+ int objcount, struct obd_ioobj *obj,
+ int niocount, struct niobuf *nb,
+ struct niobuf *res);
+ int (*o_commitrw)(int cmd, struct obd_conn *conn,
+ int objcount, struct obd_ioobj *obj,
+ int niocount, struct niobuf *res);
};
#endif
return 0;
}
-#define OBT(dev) dev->obd_type
-#define OBP(dev,op) dev->obd_type->typ_ops->o_ ## op
+#define OBT(dev) (dev)->obd_type
+#define OBP(dev,op) (dev)->obd_type->typ_ops->o_ ## op
#define OBD_CHECK_SETUP(conn) \
do { \
extern void obd_sysctl_init (void);
extern void obd_sysctl_clean (void);
-/* pack_generic.c */
-int lustre_pack_msg(int count, int *lens, char **bufs, int *len, char **buf);
-int lustre_unpack_msg(char *buf, int len);
-void *lustre_msg_buf(int n, struct lustre_msg *m);
-
#endif /* __LINUX_CLASS_OBD_H */
#define LUSTRE_OSC_NAME "osc"
/* ost/ost_pack.c */
-int ost_pack_req(char *buf1, int buflen1, char *buf2, int buflen2, struct ptlreq_hdr **hdr, union ptl_req *req, int *len, char **buf);
-int ost_unpack_req(char *buf, int len, struct ptlreq_hdr **hdr, union ptl_req *req);
-int ost_pack_rep(char *buf1, int buflen1, char *buf2, int buflen2,
- struct ptlrep_hdr **hdr, union ptl_rep *r,
- int *len, char **buf);
-int ost_unpack_rep(char *buf, int len, struct ptlrep_hdr **hdr, union ptl_rep *rep);
-
void ost_pack_niobuf(void **tmp, void *addr, __u64 offset, __u32 len,
__u32 flags, __u32 xid);
void ost_unpack_niobuf(void **tmp, struct niobuf **nbp);
void ost_pack_ioo(void **tmp, struct obdo *oa, int bufcnt);
void ost_unpack_ioo(void **tmp, struct obd_ioobj **ioop);
-void *ost_req_buf2(struct ost_req *req);
-void *ost_req_buf1(struct ost_req *req);
-void *ost_rep_buf2(struct ost_rep *rep);
-void *ost_rep_buf1(struct ost_rep *rep);
#endif
modulefs_DATA = ldlm.o
EXTRA_PROGRAMS = ldlm
-pack_generic.c:
- ln -s ../lib/pack_generic.c
ldlm_SOURCES = ldlm_lock.c ldlm_resource.c ldlm_test.c ldlm_lockd.c \
-ldlm_extent.c pack_generic.c
+ldlm_extent.c
include $(top_srcdir)/Rules
{
struct ldlm_reply *dlm_rep;
struct ldlm_request *dlm_req;
- struct lustre_msg *msg, *req_msg;
ldlm_error_t err;
- int rc;
- int bufsize = sizeof(*dlm_rep);
+ int rc, bufsize = sizeof(*dlm_rep);
rc = lustre_pack_msg(1, &bufsize, NULL, &req->rq_replen,
&req->rq_repbuf);
req->rq_status = -ENOMEM;
RETURN(0);
}
- msg = (struct lustre_msg *)req->rq_repbuf;
- req_msg = req->rq_req.lustre;
- dlm_rep = lustre_msg_buf(0, msg);
- dlm_req = lustre_msg_buf(0, req_msg);
-
- msg->xid = req_msg->xid;
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ dlm_rep = lustre_msg_buf(req->rq_repmsg, 0);
+ dlm_req = lustre_msg_buf(req->rq_reqmsg, 0);
err = ldlm_local_lock_enqueue(req->rq_obd,
dlm_req->ns_id,
&dlm_req->flags,
ldlm_client_callback,
ldlm_client_callback,
- lustre_msg_buf(1, req_msg),
- req_msg->buflens[1],
+ lustre_msg_buf(req->rq_reqmsg, 1),
+ req->rq_reqmsg->buflens[1],
&dlm_rep->lock_handle);
- msg->status = HTON__u32(err);
+ req->rq_status = err;
- /* XXX unfinished */
- return 0;
+ CERROR("local_lock_enqueue: %d\n", err);
+
+ RETURN(0);
}
static int ldlm_handle(struct obd_device *dev, struct ptlrpc_service *svc,
struct ptlrpc_request *req)
{
int rc;
- struct ptlreq_hdr *hdr;
-
ENTRY;
- hdr = (struct ptlreq_hdr *)req->rq_reqbuf;
-
- if (NTOH__u32(hdr->type) != PTL_RPC_REQUEST) {
- CERROR("lustre_ldlm: wrong packet type sent %d\n",
- NTOH__u32(hdr->type));
- rc = -EINVAL;
- GOTO(out, rc);
- }
-
rc = lustre_unpack_msg(req->rq_reqbuf, req->rq_reqlen);
- req->rq_reqhdr = (void *)req->rq_reqbuf;
+ req->rq_reqmsg = (struct lustre_msg *)req->rq_reqbuf;
if (rc) {
CERROR("lustre_ldlm: Invalid request\n");
GOTO(out, rc);
}
- switch (req->rq_reqhdr->opc) {
+ if (req->rq_reqmsg->type != PTL_RPC_REQUEST) {
+ CERROR("lustre_ldlm: wrong packet type sent %d\n",
+ req->rq_reqmsg->type);
+ GOTO(out, rc = -EINVAL);
+ }
+
+ switch (req->rq_reqmsg->opc) {
case LDLM_ENQUEUE:
CDEBUG(D_INODE, "enqueue\n");
OBD_FAIL_RETURN(OBD_FAIL_LDLM_ENQUEUE, 0);
return 0;
}
-
-
static int ldlm_iocontrol(int cmd, struct obd_conn *conn, int len, void *karg,
void *uarg)
{
struct obd_device *obddev = conn->oc_dev;
+ struct ptlrpc_client cl;
int err;
ENTRY;
return -EINVAL;
}
+ err = ptlrpc_connect_client(-1, "ldlm",
+ LDLM_REQUEST_PORTAL, LDLM_REPLY_PORTAL,
+ &cl);
+ if (err) {
+ CERROR("cannot create client\n");
+ RETURN(-EINVAL);
+ }
+
switch (cmd) {
case IOC_LDLM_TEST: {
err = ldlm_test(obddev);
-EXTRA_DIST = mds_pack.c mds_updates.c obd_pack.c page.c pack_generic.c
+EXTRA_DIST = mds_updates.c obd_pack.c page.c
include $(top_srcdir)/Rules
+++ /dev/null
-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
- * Copyright (C) 2001 Cluster File Systems, Inc. <braam@clusterfs.com>
- *
- * This file is part of Lustre, http://www.lustre.org.
- *
- * Lustre is free 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.
- *
- * 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
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Lustre; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * (Un)packing of MDS and OST request records
- *
- */
-
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/major.h>
-#include <linux/sched.h>
-#include <linux/lp.h>
-#include <linux/slab.h>
-#include <linux/ioport.h>
-#include <linux/fcntl.h>
-#include <linux/delay.h>
-#include <linux/skbuff.h>
-#include <linux/proc_fs.h>
-#include <linux/fs.h>
-#include <linux/poll.h>
-#include <linux/init.h>
-#include <linux/list.h>
-#include <asm/io.h>
-#include <asm/segment.h>
-#include <asm/system.h>
-#include <asm/poll.h>
-#include <asm/uaccess.h>
-
-#define DEBUG_SUBSYSTEM S_MDS
-
-#include <linux/lustre_mds.h>
-#include <linux/lustre_lib.h>
-
-int mds_pack_req(char *name, int namelen, char *tgt, int tgtlen,
- struct ptlreq_hdr **hdr, union ptl_req *r,
- int *len, char **buf)
-{
- struct mds_req *req;
- char *ptr;
-
- *len = sizeof(**hdr) + size_round(namelen) + size_round(tgtlen) +
- sizeof(*req);
-
- OBD_ALLOC(*buf, *len);
- if (!*buf) {
- RETURN(-ENOMEM);
- }
-
- memset(*buf, 0, *len);
- *hdr = (struct ptlreq_hdr *)(*buf);
- req = (struct mds_req *)(*buf + sizeof(**hdr));
- r->mds = req;
-
- ptr = *buf + sizeof(**hdr) + sizeof(*req);
-
- (*hdr)->type = PTL_RPC_REQUEST;
-
- req->namelen = NTOH__u32(namelen);
- LOGL(name, namelen, ptr);
-
- req->tgtlen = NTOH__u32(tgtlen);
- LOGL(tgt, tgtlen, ptr);
-
- RETURN(0);
-}
-
-
-int mds_unpack_req(char *buf, int len,
- struct ptlreq_hdr **hdr, union ptl_req *r)
-{
- struct mds_req *req;
- char *name, *tgt;
-
- if (len < sizeof(**hdr) + sizeof(*req)) {
- RETURN(-EINVAL);
- }
-
- *hdr = (struct ptlreq_hdr *) (buf);
- req = (struct mds_req *) (buf + sizeof(**hdr));
- r->mds = req;
-
- req->namelen = NTOH__u32(req->namelen);
- req->tgtlen = NTOH__u32(req->tgtlen);
-
- if (len < sizeof(**hdr) + sizeof(*req) +
- size_round(req->namelen) + size_round(req->tgtlen) ) {
- RETURN(-EINVAL);
- }
-
- if (req->namelen) {
- name = buf + sizeof(**hdr) + sizeof(*req);
- } else {
- name = NULL;
- }
-
- if (req->tgtlen) {
- tgt = buf + sizeof(**hdr) + sizeof(*req) +
- size_round(req->namelen);
- } else {
- tgt = NULL;
- }
-
- RETURN(0);
-}
-
-void *mds_req_tgt(struct mds_req *req)
-{
- if (!req->tgtlen)
- return NULL;
- return (void *)((char *)req + sizeof(*req) +
- size_round(req->namelen));
-}
-
-void *mds_req_name(struct mds_req *req)
-{
- if (!req->namelen)
- return NULL;
- return (void *)((char *)req + sizeof(*req));
-}
-
-int mds_pack_rep(char *name, int namelen, char *tgt, int tgtlen,
- struct ptlrep_hdr **hdr, union ptl_rep *r,
- int *len, char **buf)
-{
- struct mds_rep *rep;
- char *ptr;
-
- *len = sizeof(**hdr) + size_round(namelen) + size_round(tgtlen) +
- sizeof(*rep);
-
- OBD_ALLOC(*buf, *len);
- if (!*buf) {
- EXIT;
- return -ENOMEM;
- }
-
- memset(*buf, 0, *len);
- *hdr = (struct ptlrep_hdr *)(*buf);
- rep = (struct mds_rep *)(*buf + sizeof(**hdr));
- r->mds = rep;
-
- ptr = *buf + sizeof(**hdr) + sizeof(*rep);
-
- (*hdr)->type = PTL_RPC_REPLY;
-
- rep->namelen = NTOH__u32(namelen);
- if (name) {
- LOGL(name, namelen, ptr);
- }
-
- rep->tgtlen = NTOH__u32(tgtlen);
- if (tgt) {
- LOGL(tgt, tgtlen, ptr);
- }
- return 0;
-}
-
-int mds_unpack_rep(char *buf, int len,
- struct ptlrep_hdr **hdr, union ptl_rep *r)
-{
- struct mds_rep *rep;
- if (len < sizeof(**hdr)) {
- EXIT;
- return -EINVAL;
- }
- *hdr = (struct ptlrep_hdr *) (buf);
-
- if (len < sizeof(**hdr) + sizeof(*rep)) {
- EXIT;
- return -EINVAL;
- }
-
- rep = (struct mds_rep *) (buf + sizeof(**hdr));
- r->mds = rep;
- rep->namelen = NTOH__u32(rep->namelen);
- rep->tgtlen = NTOH__u32(rep->namelen);
-
- if (len < sizeof(**hdr) + sizeof(*rep)
- + size_round(rep->namelen) + size_round(rep->tgtlen) ) {
- EXIT;
- return -EINVAL;
- }
-
- EXIT;
- return 0;
-}
-
-void *mds_rep_name(struct mds_rep *rep)
-{
- if (!rep->namelen)
- return NULL;
- return (void *)((char *)rep + sizeof(*rep));
-}
-
-void *mds_rep_tgt(struct mds_rep *rep)
-{
- if (!rep->tgtlen)
- return NULL;
- return (void *)((char *)rep + sizeof(*rep) + size_round(rep->namelen));
-}
-
-/*
+/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
+ * vim:expandtab:shiftwidth=8:tabstop=8:
+ *
* Lustre Light Update Records
*
* This code is issued under the GNU General Public License.
#include <linux/lustre_lib.h>
#include <linux/lustre_mds.h>
+void mds_pack_body(struct ptlrpc_request *req)
+{
+ struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
+ if (b == NULL)
+ LBUG();
+
+ /* fid1/fid2 are already packed by another function */
+ b->objid = HTON__u64(b->objid);
+ b->size = HTON__u64(b->size);
+ b->valid = HTON__u32(b->valid);
+ b->mode = HTON__u32(b->mode);
+ b->uid = HTON__u32(b->uid);
+ b->gid = HTON__u32(b->gid);
+ b->mtime = HTON__u32(b->mtime);
+ b->ctime = HTON__u32(b->ctime);
+ b->atime = HTON__u32(b->atime);
+ b->flags = HTON__u32(b->flags);
+ b->major = HTON__u32(b->major);
+ b->minor = HTON__u32(b->minor);
+ b->ino = HTON__u32(b->ino);
+ b->nlink = HTON__u32(b->nlink);
+ b->generation = HTON__u32(b->generation);
+}
+
/* packing of MDS records */
void mds_create_pack(struct mds_rec_create *rec, struct inode *inode,
- const char *name, int namelen, __u32 mode, __u64 id,
- __u32 uid, __u32 gid, __u64 time, const char *tgt,
- int tgtlen)
+ __u32 mode, __u64 id, __u32 uid, __u32 gid, __u64 time)
{
- char *tmp = (char *)rec + sizeof(*rec);
/* XXX do something about time, uid, gid */
- rec->cr_reclen =
- HTON__u32(sizeof(*rec) + size_round0(namelen) +
- size_round0(tgtlen));
rec->cr_opcode = HTON__u32(REINT_CREATE);
-
- ll_inode2fid(&rec->cr_fid, inode);
+ ll_inode2fid(&rec->cr_fid, inode);
rec->cr_mode = HTON__u32(mode);
rec->cr_id = HTON__u64(id);
rec->cr_uid = HTON__u32(uid);
rec->cr_gid = HTON__u32(gid);
rec->cr_time = HTON__u64(time);
- rec->cr_namelen = HTON__u32(namelen + 1); /* for terminating \0 */
- LOGL0(name, namelen, tmp);
- if (tgt) {
- rec->cr_tgtlen = HTON__u32(tgtlen + 1);
- LOGL0(tgt, tgtlen, tmp);
- }
}
void mds_setattr_pack(struct mds_rec_setattr *rec, struct inode *inode,
struct iattr *iattr)
{
- rec->sa_reclen = HTON__u32(sizeof(*rec));
rec->sa_opcode = HTON__u32(REINT_SETATTR);
-
- ll_inode2fid(&rec->sa_fid, inode);
+ ll_inode2fid(&rec->sa_fid, inode);
rec->sa_valid = HTON__u32(iattr->ia_valid);
rec->sa_mode = HTON__u32(iattr->ia_mode);
rec->sa_uid = HTON__u32(iattr->ia_uid);
}
void mds_unlink_pack(struct mds_rec_unlink *rec, struct inode *inode,
- struct inode *child, const char *name, int namelen)
+ struct inode *child)
{
- char *tmp = (char *)rec + sizeof(*rec);
-
- rec->ul_reclen = HTON__u32(sizeof(*rec)) + size_round0(namelen);
rec->ul_opcode = HTON__u32(REINT_UNLINK);
-
ll_inode2fid(&rec->ul_fid1, inode);
ll_inode2fid(&rec->ul_fid2, child);
- rec->ul_namelen = HTON__u32(namelen + 1); /* for terminating \0 */
- LOGL0(name, namelen, tmp);
}
-void mds_link_pack(struct mds_rec_link *rec,
- struct inode *inode, struct inode *dir,
- const char *name, int namelen)
+void mds_link_pack(struct mds_rec_link *rec,
+ struct inode *inode, struct inode *dir)
{
- char *tmp = (char *)rec + sizeof(*rec);
- rec->lk_reclen = HTON__u32(sizeof(*rec)) + size_round0(namelen);
rec->lk_opcode = HTON__u32(REINT_LINK);
-
- ll_inode2fid(&rec->lk_fid1, inode);
- ll_inode2fid(&rec->lk_fid2, dir);
- rec->lk_namelen = HTON__u32(namelen + 1); /* for terminating \0 */
- LOGL0(name, namelen, tmp);
+ ll_inode2fid(&rec->lk_fid1, inode);
+ ll_inode2fid(&rec->lk_fid2, dir);
}
-void mds_rename_pack(struct mds_rec_rename *rec, struct inode *srcdir, struct inode *tgtdir, const char *name, int namelen, const char *tgt, int tgtlen)
+void mds_rename_pack(struct mds_rec_rename *rec, struct inode *srcdir,
+ struct inode *tgtdir)
{
- char *tmp = (char *)rec + sizeof(*rec);
/* XXX do something about time, uid, gid */
- rec->rn_reclen =
- HTON__u32(sizeof(*rec) + size_round0(namelen) +
- size_round0(tgtlen));
rec->rn_opcode = HTON__u32(REINT_RENAME);
-
- ll_inode2fid(&rec->rn_fid1, srcdir);
- ll_inode2fid(&rec->rn_fid2, tgtdir);
- rec->rn_namelen = HTON__u32(namelen + 1); /* for terminating \0 */
- LOGL0(name, namelen, tmp);
- if (tgt) {
- rec->rn_tgtlen = HTON__u32(tgtlen + 1);
- LOGL0(tgt, tgtlen, tmp);
- }
+ ll_inode2fid(&rec->rn_fid1, srcdir);
+ ll_inode2fid(&rec->rn_fid2, tgtdir);
}
/* unpacking */
-
-static int mds_update_hdr_unpack(char *buf, int len,
- struct mds_update_record *r)
+void mds_unpack_body(struct ptlrpc_request *req)
{
- struct mds_update_record_hdr *hdr = (struct mds_update_record_hdr *)buf;
-
- r->ur_reclen = NTOH__u32(hdr->ur_reclen);
- if (len < sizeof(*hdr) || len != r->ur_reclen) {
- CERROR("invalid buffer length\n");
- return -EFAULT;
- }
- r->ur_opcode = NTOH__u32(hdr->ur_opcode);
- return 0;
+ struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
+ if (b == NULL)
+ LBUG();
+
+ b->objid = NTOH__u64(b->objid);
+ b->size = NTOH__u64(b->size);
+ b->valid = NTOH__u32(b->valid);
+ b->mode = NTOH__u32(b->mode);
+ b->uid = NTOH__u32(b->uid);
+ b->gid = NTOH__u32(b->gid);
+ b->mtime = NTOH__u32(b->mtime);
+ b->ctime = NTOH__u32(b->ctime);
+ b->atime = NTOH__u32(b->atime);
+ b->flags = NTOH__u32(b->flags);
+ b->major = NTOH__u32(b->major);
+ b->minor = NTOH__u32(b->minor);
+ b->ino = NTOH__u32(b->ino);
+ b->nlink = NTOH__u32(b->nlink);
+ b->generation = NTOH__u32(b->generation);
}
-static int mds_setattr_unpack(char *buf, int len, struct mds_update_record *r)
+static int mds_setattr_unpack(struct ptlrpc_request *req,
+ struct mds_update_record *r)
{
-
struct iattr *attr = &r->ur_iattr;
- struct mds_rec_setattr *rec = (struct mds_rec_setattr *)buf;
+ struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, 0);
+ ENTRY;
- if (len < sizeof(*rec)) {
- CERROR("invalid buffer length\n");
- return -EFAULT;
- }
+ if (req->rq_reqmsg->bufcount != 1 ||
+ req->rq_reqmsg->buflens[0] != sizeof(*rec))
+ RETURN(-EFAULT);
- r->ur_fid1 = &rec->sa_fid;
+ r->ur_fid1 = &rec->sa_fid;
attr->ia_valid = NTOH__u32(rec->sa_valid);
attr->ia_mode = NTOH__u32(rec->sa_mode);
attr->ia_uid = NTOH__u32(rec->sa_uid);
attr->ia_mtime = NTOH__u64(rec->sa_mtime);
attr->ia_ctime = NTOH__u64(rec->sa_ctime);
attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
- return 0;
+ RETURN(0);
}
-static int mds_create_unpack(char *buf, int len, struct mds_update_record *r)
+static int mds_create_unpack(struct ptlrpc_request *req,
+ struct mds_update_record *r)
{
- struct mds_rec_create *rec = (struct mds_rec_create *)buf;
- char *ptr, *end;
-
- if (len < sizeof(*rec)) {
- CERROR("invalid buffer length\n");
- return -EFAULT;
- }
-
- ptr = (char *)rec + sizeof(*rec);
- end = ptr + len - sizeof(*rec);
-
+ struct mds_rec_create *rec = lustre_msg_buf(req->rq_reqmsg, 0);
+ ENTRY;
+
+ if (req->rq_reqmsg->bufcount != 3 ||
+ req->rq_reqmsg->buflens[0] != sizeof(*rec))
+ RETURN(-EFAULT);
+
r->ur_fid1 = &rec->cr_fid;
r->ur_mode = NTOH__u32(rec->cr_mode);
r->ur_id = NTOH__u64(rec->cr_id);
r->ur_uid = NTOH__u32(rec->cr_uid);
r->ur_gid = NTOH__u32(rec->cr_gid);
r->ur_time = NTOH__u64(rec->cr_time);
- r->ur_namelen = NTOH__u32(rec->cr_namelen);
- r->ur_tgtlen = NTOH__u32(rec->cr_tgtlen);
- UNLOGL0(r->ur_name, char, r->ur_namelen, ptr, end);
- UNLOGL0(r->ur_tgt, char, r->ur_tgtlen, ptr, end);
- return 0;
+ r->ur_name = lustre_msg_buf(req->rq_reqmsg, 1);
+ r->ur_namelen = req->rq_reqmsg->buflens[1];
+
+ r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, 2);
+ r->ur_tgtlen = req->rq_reqmsg->buflens[2];
+ RETURN(0);
}
-static int mds_link_unpack(char *buf, int len, struct mds_update_record *r)
+static int mds_link_unpack(struct ptlrpc_request *req,
+ struct mds_update_record *r)
{
- struct mds_rec_link *rec = (struct mds_rec_link *)buf;
- char *ptr, *end;
-
- if (len < sizeof(*rec)) {
- CERROR("invalid buffer length\n");
- return -EFAULT;
- }
-
- ptr = (char *)rec + sizeof(*rec);
- end = ptr + len - sizeof(*rec);
-
+ struct mds_rec_link *rec = lustre_msg_buf(req->rq_reqmsg, 0);
+ ENTRY;
+
+ if (req->rq_reqmsg->bufcount != 2 ||
+ req->rq_reqmsg->buflens[0] != sizeof(*rec))
+ RETURN(-EFAULT);
+
r->ur_fid1 = &rec->lk_fid1;
r->ur_fid2 = &rec->lk_fid2;
- r->ur_namelen = NTOH__u32(rec->lk_namelen);
- UNLOGL0(r->ur_name, char, r->ur_namelen, ptr, end);
- return 0;
+
+ r->ur_name = lustre_msg_buf(req->rq_reqmsg, 1);
+ r->ur_namelen = req->rq_reqmsg->buflens[1];
+ RETURN(0);
}
-static int mds_unlink_unpack(char *buf, int len, struct mds_update_record *r)
+static int mds_unlink_unpack(struct ptlrpc_request *req,
+ struct mds_update_record *r)
{
- struct mds_rec_unlink *rec = (struct mds_rec_unlink *)buf;
- char *ptr, *end;
+ struct mds_rec_unlink *rec = lustre_msg_buf(req->rq_reqmsg, 0);
ENTRY;
- if (len < sizeof(*rec)) {
- CERROR("invalid buffer length\n");
- return -EFAULT;
- }
-
- ptr = (char *)rec + sizeof(*rec);
- end = ptr + len - sizeof(*rec);
-
+ if (req->rq_reqmsg->bufcount != 2 ||
+ req->rq_reqmsg->buflens[0] != sizeof(*rec))
+ RETURN(-EFAULT);
+
r->ur_fid1 = &rec->ul_fid1;
r->ur_fid2 = &rec->ul_fid2;
- r->ur_namelen = NTOH__u32(rec->ul_namelen);
- UNLOGL0(r->ur_name, char, r->ur_namelen, ptr, end);
- EXIT;
- return 0;
+
+ r->ur_name = lustre_msg_buf(req->rq_reqmsg, 1);
+ r->ur_namelen = req->rq_reqmsg->buflens[1];
+ RETURN(0);
}
-static int mds_rename_unpack(char *buf, int len, struct mds_update_record *r)
+static int mds_rename_unpack(struct ptlrpc_request *req,
+ struct mds_update_record *r)
{
- struct mds_rec_rename *rec = (struct mds_rec_rename *)buf;
- char *ptr, *end;
-
- if (len < sizeof(*rec)) {
- CERROR("invalid buffer length\n");
- return -EFAULT;
- }
-
- ptr = (char *)rec + sizeof(*rec);
- end = ptr + len - sizeof(*rec);
-
+ struct mds_rec_rename *rec = lustre_msg_buf(req->rq_reqmsg, 0);
+ ENTRY;
+
+ if (req->rq_reqmsg->bufcount != 3 ||
+ req->rq_reqmsg->buflens[0] != sizeof(*rec))
+ RETURN(-EFAULT);
+
r->ur_fid1 = &rec->rn_fid1;
r->ur_fid2 = &rec->rn_fid2;
- r->ur_namelen = NTOH__u32(rec->rn_namelen);
- r->ur_tgtlen = NTOH__u32(rec->rn_tgtlen);
- UNLOGL0(r->ur_name, char, r->ur_namelen, ptr, end);
- UNLOGL0(r->ur_tgt, char, r->ur_tgtlen, ptr, end);
- return 0;
+ r->ur_name = lustre_msg_buf(req->rq_reqmsg, 1);
+ r->ur_namelen = req->rq_reqmsg->buflens[1];
+
+ r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, 2);
+ r->ur_tgtlen = req->rq_reqmsg->buflens[2];
+ RETURN(0);
}
-typedef int (*update_unpacker)(char *, int , struct mds_update_record *);
+typedef int (*update_unpacker)(struct ptlrpc_request *req,
+ struct mds_update_record *r);
static update_unpacker mds_unpackers[REINT_MAX + 1] = {
- [REINT_SETATTR] mds_setattr_unpack,
+ [REINT_SETATTR] mds_setattr_unpack,
[REINT_CREATE] mds_create_unpack,
[REINT_LINK] mds_link_unpack,
[REINT_UNLINK] mds_unlink_unpack,
[REINT_RENAME] mds_rename_unpack,
};
-int mds_update_unpack(char *buf, int len, struct mds_update_record *r)
+int mds_update_unpack(struct ptlrpc_request *req, struct mds_update_record *rec)
{
- int rc;
+ struct mds_update_record_hdr *hdr = lustre_msg_buf(req->rq_reqmsg, 0);
+ int rc;
ENTRY;
- rc = mds_update_hdr_unpack(buf, len, r);
-
- if (rc) {
- EXIT;
- return -EFAULT;
- }
-
- if ( r->ur_opcode<0 || r->ur_opcode > REINT_MAX) {
- EXIT;
- return EFAULT;
- }
-
- rc = mds_unpackers[r->ur_opcode](buf, len, r);
- EXIT;
- return rc;
+ if (!hdr || req->rq_reqmsg->buflens[0] < sizeof(__u32))
+ RETURN(-EFAULT);
+
+ rec->ur_opcode = NTOH__u32(hdr->ur_opcode);
+
+ if (rec->ur_opcode < 0 || rec->ur_opcode > REINT_MAX)
+ RETURN(-EFAULT);
+
+ rc = mds_unpackers[rec->ur_opcode](req, rec);
+ RETURN(rc);
}
*
*/
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/major.h>
-#include <linux/sched.h>
-#include <linux/lp.h>
-#include <linux/slab.h>
-#include <linux/ioport.h>
-#include <linux/fcntl.h>
-#include <linux/delay.h>
-#include <linux/skbuff.h>
-#include <linux/proc_fs.h>
-#include <linux/fs.h>
-#include <linux/poll.h>
-#include <linux/init.h>
-#include <linux/list.h>
-#include <asm/io.h>
-#include <asm/segment.h>
-#include <asm/system.h>
-#include <asm/poll.h>
-#include <asm/uaccess.h>
-
#define DEBUG_SUBSYSTEM S_OST
-#include <linux/obd_class.h>
#include <linux/obd_ost.h>
#include <linux/lustre_net.h>
-int ost_pack_req(char *buf1, int buflen1, char *buf2, int buflen2,
- struct ptlreq_hdr **hdr, union ptl_req *r,
- int *len, char **buf)
-{
- struct ost_req *req;
- char *ptr;
-
- *len = sizeof(**hdr) + size_round(buflen1) + size_round(buflen2) +
- sizeof(*req);
-
- OBD_ALLOC(*buf, *len);
- if (!*buf) {
- RETURN(-ENOMEM);
- }
-
- memset(*buf, 0, *len);
- *hdr = (struct ptlreq_hdr *)(*buf);
- req = (struct ost_req *)((*buf) + sizeof(**hdr));
- r->ost = req;
-
- ptr = *buf + sizeof(**hdr) + sizeof(*req);
-
- (*hdr)->type = PTL_RPC_REQUEST;
-
- req->buflen1 = HTON__u32(buflen1);
- LOGL(buf1, buflen1, ptr);
-
- req->buflen2 = HTON__u32(buflen2);
- LOGL(buf2, buflen2, ptr);
-
- RETURN(0);
-}
-
-int ost_unpack_req(char *buf, int len,
- struct ptlreq_hdr **hdr, union ptl_req *r)
-{
- struct ost_req *req;
-
- if (len < sizeof(**hdr) + sizeof(*req)) {
- RETURN(-EINVAL);
- }
-
- *hdr = (struct ptlreq_hdr *) (buf);
- req = (struct ost_req *) (buf + sizeof(**hdr));
- r->ost = req;
-
- req->buflen1 = NTOH__u32(req->buflen1);
- req->buflen2 = NTOH__u32(req->buflen2);
-
- if (len < sizeof(**hdr) + sizeof(*req) +
- size_round(req->buflen1) + size_round(req->buflen2) ) {
- RETURN(-EINVAL);
- }
-
- RETURN(0);
-}
-
-
-void *ost_req_buf1(struct ost_req *req)
-{
- if (!req->buflen1)
- return NULL;
- return (void *)((char *)req + sizeof(*req));
-}
-
-void *ost_req_buf2(struct ost_req *req)
-{
- if (!req->buflen2)
- return NULL;
- return (void *)((char *)req + sizeof(*req) +
- size_round(req->buflen1));
-}
-
-int ost_pack_rep(char *buf1, int buflen1, char *buf2, int buflen2,
- struct ptlrep_hdr **hdr, union ptl_rep *r,
- int *len, char **buf)
-{
- char *ptr;
- struct ost_rep *rep;
-
- *len = sizeof(**hdr) + size_round(buflen1) + size_round(buflen2) +
- sizeof(*rep);
-
- OBD_ALLOC(*buf, *len);
- if (!*buf) {
- EXIT;
- return -ENOMEM;
- }
-
- memset(*buf, 0, *len);
- *hdr = (struct ptlrep_hdr *)(*buf);
- rep = (struct ost_rep *)(*buf + sizeof(**hdr));
- r->ost = rep;
-
- ptr = *buf + sizeof(**hdr) + sizeof(*rep);
-
- rep->buflen1 = HTON__u32(buflen1);
- if (buf1) {
- LOGL(buf1, buflen1, ptr);
- } else {
- ptr += size_round(buflen1);
- }
-
- rep->buflen2 = HTON__u32(buflen2);
- if (buf2) {
- LOGL(buf2, buflen2, ptr);
- }
- return 0;
-}
-
-
-int ost_unpack_rep(char *buf, int len,
- struct ptlrep_hdr **hdr, union ptl_rep *r)
-{
- struct ost_rep *rep;
-
- if (len < sizeof(**hdr) + sizeof(*rep)) {
- EXIT;
- return -EINVAL;
- }
-
- *hdr = (struct ptlrep_hdr *) (buf);
- rep = (struct ost_rep *) (buf + sizeof(**hdr));
- r->ost = rep;
-
- rep->buflen1 = NTOH__u32(rep->buflen1);
- rep->buflen2 = NTOH__u32(rep->buflen2);
-
- if (len < sizeof(**hdr) + sizeof(*rep) +
- size_round(rep->buflen1) + size_round(rep->buflen2) ) {
- EXIT;
- return -EINVAL;
- }
-
- EXIT;
- return 0;
-}
-
-void *ost_rep_buf1(struct ost_rep *rep)
-{
- if (!rep->buflen1)
- return NULL;
- return (void *)((char *)rep + sizeof(*rep));
-}
-
-void *ost_rep_buf2(struct ost_rep *rep)
-{
- if (!rep->buflen2)
- return NULL;
- return (void *)((char *)rep + sizeof(*rep) +
- size_round(rep->buflen1));
-}
-
void ost_pack_ioo(void **tmp, struct obdo *oa, int bufcnt)
{
struct obd_ioobj *ioo = *tmp;
/* methods */
static int ll_find_inode(struct inode *inode, unsigned long ino, void *opaque)
{
- struct mds_rep *rep = (struct mds_rep *)opaque;
+ struct mds_body *body = (struct mds_body *)opaque;
- if (inode->i_generation != rep->generation)
+ if (inode->i_generation != body->generation)
return 0;
return 1;
err = mdc_getattr(&sbi->ll_mds_client, ino, type,
OBD_MD_FLNOTOBD|OBD_MD_FLBLOCKS, &request);
- if ( err ) {
+ if (err) {
CERROR("failure %d inode %ld\n", err, ino);
ptlrpc_free_req(request);
EXIT;
return ERR_PTR(-abs(err));
}
- inode = iget4(dir->i_sb, ino, ll_find_inode, request->rq_rep.mds);
+ inode = iget4(dir->i_sb, ino, ll_find_inode,
+ lustre_msg_buf(request->rq_repmsg, 0));
ptlrpc_free_req(request);
if (!inode)
{
struct inode *inode;
struct ptlrpc_request *request;
- struct mds_rep *rep;
+ struct mds_body *body;
int err;
time_t time = CURRENT_TIME;
struct ll_sb_info *sbi = ll_i2sbi(dir);
mode, id, current->uid, current->gid, time, &request);
if (err) {
inode = ERR_PTR(err);
- EXIT;
- goto out;
+ GOTO(out, err);
}
- rep = request->rq_rep.mds;
- rep->valid = OBD_MD_FLNOTOBD;
+ body = lustre_msg_buf(request->rq_repmsg, 0);
+ body->valid = OBD_MD_FLNOTOBD;
- rep->objid = id;
- rep->nlink = 1;
- rep->atime = rep->ctime = rep->mtime = time;
- rep->mode = mode;
+ body->objid = id;
+ body->nlink = 1;
+ body->atime = body->ctime = body->mtime = time;
+ body->mode = mode;
CDEBUG(D_INODE, "-- new_inode: objid %lld, ino %d, mode %o\n",
- rep->objid, rep->ino, rep->mode);
+ body->objid, body->ino, body->mode);
- inode = iget4(dir->i_sb, rep->ino, ll_find_inode, rep);
+ inode = iget4(dir->i_sb, body->ino, ll_find_inode, body);
if (IS_ERR(inode)) {
CERROR("new_inode -fatal: %ld\n", PTR_ERR(inode));
inode = ERR_PTR(-EIO);
LBUG();
- EXIT;
- goto out;
+ GOTO(out, -EIO);
}
if (!list_empty(&inode->i_dentry)) {
CERROR("new_inode -fatal: inode %d, ct %d lnk %d\n",
- rep->ino, atomic_read(&inode->i_count),
+ body->ino, atomic_read(&inode->i_count),
inode->i_nlink);
iput(inode);
LBUG();
inode = ERR_PTR(-EIO);
- EXIT;
- goto out;
+ GOTO(out, -EIO);
}
EXIT;
RETURN(NULL);
}
- memset(sbi, 0, sizeof(*sbi));
sb->u.generic_sbp = sbi;
ll_options(data, &device, &version);
/* the first parameter should become an mds device no */
err = ptlrpc_connect_client(-1, "mds",
- MDS_REQUEST_PORTAL,
- MDC_REPLY_PORTAL,
- mds_pack_req,
- mds_unpack_rep,
+ MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL,
&sbi->ll_mds_client);
if (err) {
GOTO(out_req, sb = NULL);
}
- root = iget4(sb, sbi->ll_rootino, NULL, request->rq_rep.mds);
+ root = iget4(sb, sbi->ll_rootino, NULL,
+ lustre_msg_buf(request->rq_repmsg, 0));
if (root) {
sb->s_root = d_alloc_root(root);
} else {
return err;
}
-static void inline ll_to_inode(struct inode *dst, struct mds_rep *rep)
+static void inline ll_to_inode(struct inode *dst, struct mds_body *body)
{
struct ll_inode_info *ii =
(struct ll_inode_info *) &dst->u.generic_ip;
/* core attributes first */
- if ( rep->valid & OBD_MD_FLID )
- dst->i_ino = rep->ino;
- if ( rep->valid & OBD_MD_FLATIME )
- dst->i_atime = rep->atime;
- if ( rep->valid & OBD_MD_FLMTIME )
- dst->i_mtime = rep->mtime;
- if ( rep->valid & OBD_MD_FLCTIME )
- dst->i_ctime = rep->ctime;
- if ( rep->valid & OBD_MD_FLSIZE )
- dst->i_size = rep->size;
- if ( rep->valid & OBD_MD_FLMODE )
- dst->i_mode = rep->mode;
- if ( rep->valid & OBD_MD_FLUID )
- dst->i_uid = rep->uid;
- if ( rep->valid & OBD_MD_FLGID )
- dst->i_gid = rep->gid;
- if ( rep->valid & OBD_MD_FLFLAGS )
- dst->i_flags = rep->flags;
- if ( rep->valid & OBD_MD_FLNLINK )
- dst->i_nlink = rep->nlink;
- if ( rep->valid & OBD_MD_FLGENER )
- dst->i_generation = rep->generation;
+ if ( body->valid & OBD_MD_FLID )
+ dst->i_ino = body->ino;
+ if ( body->valid & OBD_MD_FLATIME )
+ dst->i_atime = body->atime;
+ if ( body->valid & OBD_MD_FLMTIME )
+ dst->i_mtime = body->mtime;
+ if ( body->valid & OBD_MD_FLCTIME )
+ dst->i_ctime = body->ctime;
+ if ( body->valid & OBD_MD_FLSIZE )
+ dst->i_size = body->size;
+ if ( body->valid & OBD_MD_FLMODE )
+ dst->i_mode = body->mode;
+ if ( body->valid & OBD_MD_FLUID )
+ dst->i_uid = body->uid;
+ if ( body->valid & OBD_MD_FLGID )
+ dst->i_gid = body->gid;
+ if ( body->valid & OBD_MD_FLFLAGS )
+ dst->i_flags = body->flags;
+ if ( body->valid & OBD_MD_FLNLINK )
+ dst->i_nlink = body->nlink;
+ if ( body->valid & OBD_MD_FLGENER )
+ dst->i_generation = body->generation;
/* this will become more elaborate for striping etc */
- if (rep->valid & OBD_MD_FLOBJID)
- ii->lli_objid = rep->objid;
+ if (body->valid & OBD_MD_FLOBJID)
+ ii->lli_objid = body->objid;
#if 0
if (obdo_has_inline(oa)) {
static inline void ll_read_inode2(struct inode *inode, void *opaque)
{
- struct mds_rep *rep = opaque;
+ struct mds_body *body = opaque;
ENTRY;
- ll_to_inode(inode, rep);
+ ll_to_inode(inode, body);
/* OIDEBUG(inode); */
modulefs_DATA = mdc.o
EXTRA_PROGRAMS = mdc
-
-LINX=mds_pack.c mds_updates.c
+LINX=mds_updates.c
mdc_SOURCES = mdc_request.c mdc_reint.c $(LINX)
-mds_pack.c:
- ln -s ../lib/mds_pack.c .
mds_updates.c:
ln -s ../lib/mds_updates.c .
static int mdc_reint(struct ptlrpc_client *cl, struct ptlrpc_request *request)
{
- int rc;
+ int rc;
rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_check_status(request, rc);
if (rc)
- CERROR("error in handling %d\n", rc);
+ CERROR("error in handling %d\n", rc);
return rc;
}
-int mdc_setattr(struct ptlrpc_client *peer,
- struct inode *inode, struct iattr *iattr,
- struct ptlrpc_request **request)
+int mdc_setattr(struct ptlrpc_client *cl, struct inode *inode,
+ struct iattr *iattr, struct ptlrpc_request **request)
{
- int rc;
struct mds_rec_setattr *rec;
+ struct ptlrpc_request *req;
+ int rc, size = sizeof(*rec);
ENTRY;
- *request = ptlrpc_prep_req(peer, MDS_REINT, 0, NULL,
- sizeof(*rec), NULL);
- if (!(*request)) {
- CERROR("cannot pack\n");
- EXIT;
- return -ENOMEM;
- }
+ req = ptlrpc_prep_req(cl, MDS_REINT, 1, &size, NULL);
+ if (!req)
+ RETURN(-ENOMEM);
- rec = mds_req_tgt((*request)->rq_req.mds);
- mds_setattr_pack(rec, inode, iattr);
- (*request)->rq_req.mds->opcode = HTON__u32(REINT_SETATTR);
- (*request)->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+ rec = lustre_msg_buf(req->rq_reqmsg, 0);
+ mds_setattr_pack(rec, inode, iattr);
- rc = mdc_reint(peer, *request);
+ size = sizeof(struct mds_body);
+ req->rq_replen = lustre_msg_size(1, &size);
- EXIT;
- return rc;
+ rc = mdc_reint(cl, req);
+ *request = req;
+
+ RETURN(rc);
}
-int mdc_create(struct ptlrpc_client *peer,
- struct inode *dir, const char *name, int namelen,
- const char *tgt, int tgtlen,
- int mode, __u64 id, __u32 uid, __u32 gid, __u64 time,
+int mdc_create(struct ptlrpc_client *cl, struct inode *dir, const char *name,
+ int namelen, const char *tgt, int tgtlen, int mode, __u64 id,
+ __u32 uid, __u32 gid, __u64 time,
struct ptlrpc_request **request)
{
- int rc;
struct mds_rec_create *rec;
+ struct ptlrpc_request *req;
+ int rc, size[3] = {sizeof(*rec), namelen + 1, tgtlen + 1};
+ char *tmp;
ENTRY;
- (*request) = ptlrpc_prep_req(peer, MDS_REINT, 0, NULL,
- sizeof(*rec) + size_round0(namelen) +
- size_round0(tgtlen), NULL);
- if (!(*request)) {
- CERROR("cannot pack\n");
- return -ENOMEM;
- }
+ req = ptlrpc_prep_req(cl, MDS_REINT, 3, size, NULL);
+ if (!req)
+ RETURN(-ENOMEM);
- (*request)->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+ rec = lustre_msg_buf(req->rq_reqmsg, 0);
+ mds_create_pack(rec, dir, mode, id, uid, gid, time);
- rec = mds_req_tgt((*request)->rq_req.mds);
- mds_create_pack(rec, dir, name, namelen, mode, id, uid, gid, time,
- tgt, tgtlen);
+ tmp = lustre_msg_buf(req->rq_reqmsg, 1);
+ LOGL0(name, namelen, tmp);
- rc = mdc_reint(peer, (*request));
+ if (tgt) {
+ tmp = lustre_msg_buf(req->rq_reqmsg, 2);
+ LOGL0(tgt, tgtlen, tmp);
+ }
- EXIT;
- return rc;
+ size[0] = sizeof(struct mds_body);
+ req->rq_replen = lustre_msg_size(1, size);
+
+ rc = mdc_reint(cl, req);
+ *request = req;
+
+ RETURN(rc);
}
-int mdc_unlink(struct ptlrpc_client *peer, struct inode *dir,
- struct inode *child, const char *name, int namelen,
+int mdc_unlink(struct ptlrpc_client *cl, struct inode *dir,
+ struct inode *child, const char *name, int namelen,
struct ptlrpc_request **request)
{
- int rc;
struct mds_rec_unlink *rec;
+ struct ptlrpc_request *req;
+ int rc, size[2] = {sizeof(*rec), namelen + 1};
+ char *tmp;
+ ENTRY;
- (*request) = ptlrpc_prep_req(peer, MDS_REINT, 0, NULL,
- sizeof(*rec) + size_round0(namelen), NULL);
- if (!(*request)) {
- CERROR("cannot pack\n");
- return -ENOMEM;
- }
+ req = ptlrpc_prep_req(cl, MDS_REINT, 2, size, NULL);
+ if (!req)
+ RETURN(-ENOMEM);
- (*request)->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+ rec = lustre_msg_buf(req->rq_reqmsg, 0);
+ mds_unlink_pack(rec, dir, child);
- rec = mds_req_tgt((*request)->rq_req.mds);
- mds_unlink_pack(rec, dir, child, name, namelen);
+ tmp = lustre_msg_buf(req->rq_reqmsg, 1);
+ LOGL0(name, namelen, tmp);
- rc = mdc_reint(peer, (*request));
+ size[0] = sizeof(struct mds_body);
+ req->rq_replen = lustre_msg_size(1, size);
- EXIT;
- return rc;
+ rc = mdc_reint(cl, req);
+ *request = req;
+
+ RETURN(rc);
}
-int mdc_link(struct ptlrpc_client *peer, struct dentry *src,
- struct inode *dir, const char *name, int namelen,
- struct ptlrpc_request **request)
+int mdc_link(struct ptlrpc_client *cl, struct dentry *src, struct inode *dir,
+ const char *name, int namelen, struct ptlrpc_request **request)
{
- int rc;
struct mds_rec_link *rec;
+ struct ptlrpc_request *req;
+ int rc, size[2] = {sizeof(*rec), namelen + 1};
+ char *tmp;
ENTRY;
- (*request) = ptlrpc_prep_req(peer, MDS_REINT, 0, NULL,
- sizeof(*rec) + size_round0(namelen), NULL);
- if (!(*request)) {
- CERROR("cannot pack\n");
- return -ENOMEM;
- }
+ req = ptlrpc_prep_req(cl, MDS_REINT, 2, size, NULL);
+ if (!req)
+ RETURN(-ENOMEM);
- (*request)->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+ rec = lustre_msg_buf(req->rq_reqmsg, 0);
+ mds_link_pack(rec, src->d_inode, dir);
- rec = mds_req_tgt((*request)->rq_req.mds);
- mds_link_pack(rec, src->d_inode, dir, name, namelen);
+ tmp = lustre_msg_buf(req->rq_reqmsg, 1);
+ LOGL0(name, namelen, tmp);
- rc = mdc_reint(peer, (*request));
- EXIT;
- return rc;
+ size[0] = sizeof(struct mds_body);
+ req->rq_replen = lustre_msg_size(1, size);
+
+ rc = mdc_reint(cl, req);
+ *request = req;
+
+ RETURN(rc);
}
-int mdc_rename(struct ptlrpc_client *peer, struct inode *src,
- struct inode *tgt, const char *old, int oldlen,
- const char *new, int newlen,
+int mdc_rename(struct ptlrpc_client *cl, struct inode *src, struct inode *tgt,
+ const char *old, int oldlen, const char *new, int newlen,
struct ptlrpc_request **request)
{
- int rc;
struct mds_rec_rename *rec;
+ struct ptlrpc_request *req;
+ int rc, size[3] = {sizeof(*rec), oldlen + 1, newlen + 1};
+ char *tmp;
ENTRY;
- (*request) = ptlrpc_prep_req(peer, MDS_REINT, 0, NULL,
- sizeof(*rec) + size_round0(oldlen)
- + size_round0(newlen), NULL);
- if (!(*request)) {
- CERROR("cannot pack\n");
- return -ENOMEM;
- }
+ req = ptlrpc_prep_req(cl, MDS_REINT, 3, size, NULL);
+ if (!req)
+ RETURN(-ENOMEM);
- (*request)->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+ rec = lustre_msg_buf(req->rq_reqmsg, 0);
+ mds_rename_pack(rec, src, tgt);
- rec = mds_req_tgt((*request)->rq_req.mds);
- mds_rename_pack(rec, src, tgt, old, oldlen, new, newlen);
+ tmp = lustre_msg_buf(req->rq_reqmsg, 1);
+ LOGL0(old, oldlen, tmp);
- rc = mdc_reint(peer, (*request));
+ if (tgt) {
+ tmp = lustre_msg_buf(req->rq_reqmsg, 2);
+ LOGL0(new, newlen, tmp);
+ }
- EXIT;
- return rc;
+ size[0] = sizeof(struct mds_body);
+ req->rq_replen = lustre_msg_size(1, size);
+
+ rc = mdc_reint(cl, req);
+ *request = req;
+
+ RETURN(rc);
}
extern int mds_queue_req(struct ptlrpc_request *);
-
int mdc_getattr(struct ptlrpc_client *cl, ino_t ino, int type, int valid,
- struct ptlrpc_request **req)
+ struct ptlrpc_request **request)
{
- int rc;
- struct ptlrpc_request *request;
-
+ struct ptlrpc_request *req;
+ struct mds_body *body;
+ int rc, size = sizeof(*body);
ENTRY;
- request = ptlrpc_prep_req(cl, MDS_GETATTR, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("llight request: cannot pack\n");
+ req = ptlrpc_prep_req(cl, MDS_GETATTR, 1, &size, NULL);
+ if (!req)
GOTO(out, rc = -ENOMEM);
- }
- ll_ino2fid(&request->rq_req.mds->fid1, ino, 0, type);
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ ll_ino2fid(&body->fid1, ino, 0, type);
+ body->valid = valid;
- request->rq_req.mds->valid = valid;
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+ req->rq_replen = lustre_msg_size(1, &size);
- rc = ptlrpc_queue_wait(cl, request);
- rc = ptlrpc_check_status(request, rc);
+ rc = ptlrpc_queue_wait(cl, req);
+ rc = ptlrpc_check_status(req, rc);
- if (!rc)
- CDEBUG(D_NET, "mode: %o\n", request->rq_rep.mds->mode);
+ if (!rc) {
+ mds_unpack_body(req);
+ body = lustre_msg_buf(req->rq_repmsg, 0);
+ CDEBUG(D_NET, "mode: %o\n", body->mode);
+ }
- GOTO(out, rc);
+ EXIT;
out:
- *req = request;
+ *request = req;
return rc;
}
int mdc_open(struct ptlrpc_client *cl, ino_t ino, int type, int flags,
- __u64 *fh, struct ptlrpc_request **req)
+ __u64 *fh, struct ptlrpc_request **request)
{
- struct ptlrpc_request *request;
- int rc;
+ struct mds_body *body;
+ int rc, size = sizeof(*body);
+ struct ptlrpc_request *req;
- request = ptlrpc_prep_req(cl, MDS_OPEN, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("llight request: cannot pack\n");
- rc = -ENOMEM;
- goto out;
- }
+ req = ptlrpc_prep_req(cl, MDS_OPEN, 1, &size, NULL);
+ if (!req)
+ GOTO(out, rc = -ENOMEM);
- ll_ino2fid(&request->rq_req.mds->fid1, ino, 0, type);
- request->rq_req.mds->flags = HTON__u32(flags);
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ ll_ino2fid(&body->fid1, ino, 0, type);
+ body->flags = HTON__u32(flags);
- rc = ptlrpc_queue_wait(cl, request);
- rc = ptlrpc_check_status(request, rc);
+ req->rq_replen = lustre_msg_size(1, &size);
- if (rc) {
- CERROR("llight request: error in handling %d\n", rc);
- goto out;
+ rc = ptlrpc_queue_wait(cl, req);
+ rc = ptlrpc_check_status(req, rc);
+
+ if (!rc) {
+ mds_unpack_body(req);
+ body = lustre_msg_buf(req->rq_repmsg, 0);
+ *fh = body->objid;
}
- *fh = request->rq_rep.mds->objid;
+ EXIT;
out:
- *req = request;
+ *request = req;
return rc;
}
-
int mdc_close(struct ptlrpc_client *cl, ino_t ino, int type, __u64 fh,
- struct ptlrpc_request **req)
+ struct ptlrpc_request **request)
{
- struct ptlrpc_request *request;
- int rc;
+ struct mds_body *body;
+ int rc, size = sizeof(*body);
+ struct ptlrpc_request *req;
- request = ptlrpc_prep_req(cl, MDS_CLOSE, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("llight request: cannot pack\n");
- rc = -ENOMEM;
- goto out;
- }
+ req = ptlrpc_prep_req(cl, MDS_CLOSE, 1, &size, NULL);
+ if (!req)
+ GOTO(out, rc = -ENOMEM);
- ll_ino2fid(&request->rq_req.mds->fid1, ino, 0, type);
- request->rq_req.mds->objid = fh;
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ ll_ino2fid(&body->fid1, ino, 0, type);
+ body->objid = fh;
- rc = ptlrpc_queue_wait(cl, request);
- rc = ptlrpc_check_status(request, rc);
+ req->rq_replen = lustre_msg_size(1, &size);
- if (rc) {
- CERROR("llight request: error in handling %d\n", rc);
- goto out;
- }
+ rc = ptlrpc_queue_wait(cl, req);
+ rc = ptlrpc_check_status(req, rc);
+ EXIT;
out:
- *req = request;
+ *request = req;
return rc;
}
int mdc_readpage(struct ptlrpc_client *cl, ino_t ino, int type, __u64 offset,
- char *addr, struct ptlrpc_request **req)
+ char *addr, struct ptlrpc_request **request)
{
- struct ptlrpc_request *request = NULL;
+ struct ptlrpc_request *req = NULL;
struct ptlrpc_bulk_desc *bulk = NULL;
struct niobuf niobuf;
- int rc;
+ struct mds_body *body;
+ int rc, size[2] = {sizeof(*body), sizeof(struct niobuf)};
+ char *bufs[2] = {NULL, (char *)&niobuf};
niobuf.addr = (__u64) (long) addr;
goto out;
}
- request = ptlrpc_prep_req(cl, MDS_READPAGE, 0, NULL,
- sizeof(struct niobuf), (char *)&niobuf);
- if (!request) {
- CERROR("%s: cannot pack\n", __FUNCTION__);
- rc = -ENOMEM;
- goto out;
- }
+ req = ptlrpc_prep_req(cl, MDS_READPAGE, 2, size, bufs);
+ if (!req)
+ GOTO(out, rc = -ENOMEM);
bulk->b_buflen = PAGE_SIZE;
bulk->b_buf = (void *)(long)niobuf.addr;
bulk->b_portal = MDS_BULK_PORTAL;
- bulk->b_xid = request->rq_xid;
+ bulk->b_xid = req->rq_xid;
rc = ptlrpc_register_bulk(bulk);
if (rc) {
- CERROR("%s: couldn't setup bulk sink: error %d.\n",
- __FUNCTION__, rc);
- goto out;
+ CERROR("couldn't setup bulk sink: error %d.\n", rc);
+ GOTO(out, rc);
}
- request->rq_req.mds->fid1.id = ino;
- request->rq_req.mds->fid1.f_type = type;
- request->rq_req.mds->size = offset;
- request->rq_req.mds->tgtlen = sizeof(niobuf);
- request->rq_replen = sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ body->fid1.id = ino;
+ body->fid1.f_type = type;
+ body->size = offset;
+
+ req->rq_replen = lustre_msg_size(1, size);
- rc = ptlrpc_queue_wait(cl, request);
+ rc = ptlrpc_queue_wait(cl, req);
if (rc) {
- CERROR("mdc request: error in handling %d\n", rc);
+ CERROR("error in handling %d\n", rc);
ptlrpc_abort_bulk(bulk);
- goto out;
+ GOTO(out, rc);
}
- CDEBUG(D_INODE, "mode: %o\n", request->rq_rep.mds->mode);
+ mds_unpack_body(req);
+ EXIT;
out:
- *req = request;
+ *request = req;
if (bulk != NULL)
OBD_FREE(bulk, sizeof(*bulk));
return rc;
}
err = ptlrpc_connect_client(-1, "mds",
- MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL,
- mds_pack_req, mds_unpack_rep, &cl);
+ MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL, &cl);
if (err) {
CERROR("cannot create client\n");
RETURN(-EINVAL);
modulefs_DATA = mds.o
EXTRA_PROGRAMS = mds
-LINX=mds_pack.c mds_updates.c simple.c
-mds_pack.c:
- ln -s ../lib/mds_pack.c .
+LINX=mds_updates.c simple.c
mds_updates.c:
ln -s ../lib/mds_updates.c .
simple.c:
{
struct dentry *de;
struct inode *inode;
- struct mds_rep *rep;
+ struct mds_body *body;
struct mds_obd *mds = &req->rq_obd->u.mds;
- int rc;
+ int rc, size = sizeof(*body);
+ ENTRY;
- rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_GETATTR_PACK)) {
CERROR("mds: out of memory\n");
req->rq_status = -ENOMEM;
RETURN(0);
}
- req->rq_rephdr->xid = req->rq_reqhdr->xid;
- rep = req->rq_rep.mds;
-
- de = mds_fid2dentry(mds, &req->rq_req.mds->fid1, NULL);
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ de = mds_fid2dentry(mds, &body->fid1, NULL);
if (IS_ERR(de)) {
- req->rq_rephdr->status = -ENOENT;
+ req->rq_status = -ENOENT;
RETURN(0);
}
+ body = lustre_msg_buf(req->rq_repmsg, 0);
inode = de->d_inode;
- rep->ino = inode->i_ino;
- rep->generation = inode->i_generation;
- rep->atime = inode->i_atime;
- rep->ctime = inode->i_ctime;
- rep->mtime = inode->i_mtime;
- rep->uid = inode->i_uid;
- rep->gid = inode->i_gid;
- rep->size = inode->i_size;
- rep->mode = inode->i_mode;
- rep->nlink = inode->i_nlink;
- rep->valid = ~0;
- mds_fs_get_objid(mds, inode, &rep->objid);
+ body->ino = inode->i_ino;
+ body->generation = inode->i_generation;
+ body->atime = inode->i_atime;
+ body->ctime = inode->i_ctime;
+ body->mtime = inode->i_mtime;
+ body->uid = inode->i_uid;
+ body->gid = inode->i_gid;
+ body->size = inode->i_size;
+ body->mode = inode->i_mode;
+ body->nlink = inode->i_nlink;
+ body->valid = ~0;
+ mds_fs_get_objid(mds, inode, &body->objid);
l_dput(de);
- return 0;
+ RETURN(0);
}
int mds_open(struct ptlrpc_request *req)
{
struct dentry *de;
- struct mds_rep *rep;
+ struct mds_body *body;
struct file *file;
struct vfsmount *mnt;
__u32 flags;
- int rc;
+ int rc, size = sizeof(*body);
+ ENTRY;
- rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_OPEN_PACK)) {
CERROR("mds: out of memory\n");
req->rq_status = -ENOMEM;
RETURN(0);
}
- req->rq_rephdr->xid = req->rq_reqhdr->xid;
- rep = req->rq_rep.mds;
-
- de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, &mnt);
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ de = mds_fid2dentry(&req->rq_obd->u.mds, &body->fid1, &mnt);
if (IS_ERR(de)) {
- req->rq_rephdr->status = -ENOENT;
+ req->rq_status = -ENOENT;
RETURN(0);
}
- flags = req->rq_req.mds->flags;
+ flags = body->flags;
file = dentry_open(de, mnt, flags);
if (!file || IS_ERR(file)) {
- req->rq_rephdr->status = -EINVAL;
+ req->rq_status = -EINVAL;
RETURN(0);
}
- rep->objid = (__u64) (unsigned long)file;
- return 0;
+ body = lustre_msg_buf(req->rq_repmsg, 0);
+ body->objid = (__u64) (unsigned long)file;
+ RETURN(0);
}
int mds_close(struct ptlrpc_request *req)
{
struct dentry *de;
- struct mds_rep *rep;
+ struct mds_body *body;
struct file *file;
struct vfsmount *mnt;
int rc;
+ ENTRY;
- rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
+ rc = lustre_pack_msg(0, NULL, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_CLOSE_PACK)) {
CERROR("mds: out of memory\n");
req->rq_status = -ENOMEM;
RETURN(0);
}
- req->rq_rephdr->xid = req->rq_reqhdr->xid;
- rep = req->rq_rep.mds;
-
- de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, &mnt);
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ de = mds_fid2dentry(&req->rq_obd->u.mds, &body->fid1, &mnt);
if (IS_ERR(de)) {
- req->rq_rephdr->status = -ENOENT;
+ req->rq_status = -ENOENT;
RETURN(0);
}
- file = (struct file *)(unsigned long) req->rq_req.mds->objid;
-
- req->rq_rephdr->status = filp_close(file, 0);
+ file = (struct file *)(unsigned long)body->objid;
+ req->rq_status = filp_close(file, 0);
l_dput(de);
mntput(mnt);
- return 0;
+
+ RETURN(0);
}
int mds_readpage(struct ptlrpc_request *req)
struct dentry *de;
struct file *file;
struct niobuf *niobuf;
- struct mds_rep *rep;
- int rc;
-
+ struct mds_body *body;
+ int rc, size = sizeof(*body);
ENTRY;
- rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_READPAGE_PACK)) {
CERROR("mds: out of memory\n");
req->rq_status = -ENOMEM;
RETURN(0);
}
- req->rq_rephdr->xid = req->rq_reqhdr->xid;
- rep = req->rq_rep.mds;
-
- de = mds_fid2dentry(&req->rq_obd->u.mds, &req->rq_req.mds->fid1, &mnt);
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ de = mds_fid2dentry(&req->rq_obd->u.mds, &body->fid1, &mnt);
if (IS_ERR(de)) {
- req->rq_rephdr->status = PTR_ERR(de);
+ req->rq_status = PTR_ERR(de);
RETURN(0);
}
file = dentry_open(de, mnt, O_RDONLY | O_LARGEFILE);
/* note: in case of an error, dentry_open puts dentry */
if (IS_ERR(file)) {
- req->rq_rephdr->status = PTR_ERR(file);
+ req->rq_status = PTR_ERR(file);
RETURN(0);
}
- niobuf = mds_req_tgt(req->rq_req.mds);
+ niobuf = lustre_msg_buf(req->rq_reqmsg, 1);
+ if (!niobuf) {
+ req->rq_status = -EINVAL;
+ LBUG();
+ RETURN(0);
+ }
/* to make this asynchronous make sure that the handling function
doesn't send a reply when this function completes. Instead a
callback function would send the reply */
- rc = mds_sendpage(req, file, req->rq_req.mds->size, niobuf);
+ rc = mds_sendpage(req, file, body->size, niobuf);
filp_close(file, 0);
- req->rq_rephdr->status = rc;
+ req->rq_status = rc;
RETURN(0);
}
int mds_reint(struct ptlrpc_request *req)
{
- char *buf;
- int rc, len;
+ int rc;
struct mds_update_record rec;
- buf = mds_req_tgt(req->rq_req.mds);
- len = req->rq_req.mds->tgtlen;
-
- rc = mds_update_unpack(buf, len, &rec);
+ rc = mds_update_unpack(req, &rec);
if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNPACK)) {
CERROR("invalid record\n");
req->rq_status = -EINVAL;
struct ptlrpc_request *req)
{
int rc;
- struct ptlreq_hdr *hdr;
-
ENTRY;
- hdr = (struct ptlreq_hdr *)req->rq_reqbuf;
-
- if (NTOH__u32(hdr->type) != PTL_RPC_REQUEST) {
- CERROR("lustre_mds: wrong packet type sent %d\n",
- NTOH__u32(hdr->type));
- rc = -EINVAL;
- GOTO(out, rc);
- }
-
- rc = mds_unpack_req(req->rq_reqbuf, req->rq_reqlen,
- &req->rq_reqhdr, &req->rq_req);
+ rc = lustre_unpack_msg(req->rq_reqbuf, req->rq_reqlen);
+ req->rq_reqmsg = (struct lustre_msg *)req->rq_reqbuf;
if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_HANDLE_UNPACK)) {
CERROR("lustre_mds: Invalid request\n");
GOTO(out, rc);
}
- switch (req->rq_reqhdr->opc) {
+ if (req->rq_reqmsg->type != PTL_RPC_REQUEST) {
+ CERROR("lustre_mds: wrong packet type sent %d\n",
+ req->rq_reqmsg->type);
+ GOTO(out, rc = -EINVAL);
+ }
+ switch (req->rq_reqmsg->opc) {
case MDS_GETATTR:
CDEBUG(D_INODE, "getattr\n");
OBD_FAIL_RETURN(OBD_FAIL_MDS_GETATTR_NET, 0);
EXIT;
out:
if (rc) {
- CERROR("no header\n");
- LBUG();
- return 0;
- }
-
- if( req->rq_status) {
ptlrpc_error(dev, svc, req);
} else {
CDEBUG(D_NET, "sending reply\n");
#include <linux/lustre_mds.h>
#include <linux/obd_class.h>
-extern struct ptlrpc_request *mds_prep_req(int size, int opcode, int namelen, char *name, int tgtlen, char *tgt);
-
-static int mds_reint_setattr(struct mds_update_record *rec, struct ptlrpc_request *req)
+static int mds_reint_setattr(struct mds_update_record *rec,
+ struct ptlrpc_request *req)
{
struct mds_obd *mds = &req->rq_obd->u.mds;
struct dentry *de;
de = mds_fid2dentry(mds, rec->ur_fid1, NULL);
if (IS_ERR(de) || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_SETATTR)) {
- req->rq_rephdr->status = -ESTALE;
+ req->rq_status = -ESTALE;
RETURN(0);
}
OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_SETATTR_WRITE,
de->d_inode->i_sb->s_dev);
- req->rq_rephdr->status = mds_fs_setattr(mds, de, NULL, &rec->ur_iattr);
+ req->rq_status = mds_fs_setattr(mds, de, NULL, &rec->ur_iattr);
l_dput(de);
RETURN(0);
static int mds_reint_create(struct mds_update_record *rec,
struct ptlrpc_request *req)
{
- int type = rec->ur_mode & S_IFMT;
struct dentry *de = NULL;
- struct mds_rep *rep = req->rq_rep.mds;
struct mds_obd *mds = &req->rq_obd->u.mds;
struct dentry *dchild = NULL;
struct inode *dir;
void *handle;
- int rc = 0;
+ int rc = 0, type = rec->ur_mode & S_IFMT;
ENTRY;
de = mds_fid2dentry(mds, rec->ur_fid1, NULL);
} else {
struct iattr iattr;
struct inode *inode = dchild->d_inode;
+ struct mds_body *body;
if (type == S_IFREG) {
rc = mds_fs_set_objid(mds, inode, handle, rec->ur_id);
iattr.ia_uid = rec->ur_uid;
iattr.ia_gid = rec->ur_gid;
iattr.ia_valid = ATTR_UID | ATTR_GID | ATTR_ATIME |
- ATTR_MTIME | ATTR_CTIME;
+ ATTR_MTIME | ATTR_CTIME;
rc = mds_fs_setattr(mds, dchild, handle, &iattr);
- rep->ino = inode->i_ino;
- rep->generation = inode->i_generation;
+ body = lustre_msg_buf(req->rq_repmsg, 0);
+ body->ino = inode->i_ino;
+ body->generation = inode->i_generation;
}
out_reint_commit:
rc = mds_fs_commit(mds, dir, handle);
out_reint_create:
- req->rq_rephdr->status = rc;
+ req->rq_status = rc;
l_dput(dchild);
l_dput(de);
RETURN(0);
}
out_unlink:
- req->rq_rephdr->status = rc;
+ req->rq_status = rc;
l_dput(dchild);
l_dput(de);
RETURN(0);
EXIT;
out_link:
- req->rq_rephdr->status = rc;
+ req->rq_status = rc;
l_dput(dchild);
l_dput(de_tgt_dir);
l_dput(de_src);
return 0;
}
-
static int mds_reint_rename(struct mds_update_record *rec,
struct ptlrpc_request *req)
{
EXIT;
out_rename:
- req->rq_rephdr->status = rc;
+ req->rq_status = rc;
l_dput(de_new);
l_dput(de_old);
l_dput(de_tgtdir);
typedef int (*mds_reinter)(struct mds_update_record *, struct ptlrpc_request*);
-static mds_reinter reinters[REINT_MAX+1] = {
+static mds_reinter reinters[REINT_MAX+1] = {
[REINT_SETATTR] mds_reint_setattr,
[REINT_CREATE] mds_reint_create,
[REINT_UNLINK] mds_reint_unlink,
int mds_reint_rec(struct mds_update_record *rec, struct ptlrpc_request *req)
{
- int rc;
+ int rc, size = sizeof(struct mds_body);
- if (rec->ur_opcode < 0 || rec->ur_opcode > REINT_MAX) {
+ if (rec->ur_opcode < 1 || rec->ur_opcode > REINT_MAX) {
CERROR("opcode %d not valid\n", rec->ur_opcode);
rc = req->rq_status = -EINVAL;
RETURN(rc);
}
- rc = mds_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
if (rc) {
CERROR("mds: out of memory\n");
rc = req->rq_status = -ENOMEM;
RETURN(rc);
}
- req->rq_rephdr->xid = req->rq_reqhdr->xid;
rc = reinters[rec->ur_opcode](rec, req);
return rc;
OBD_ALLOC(type, sizeof(*type));
if (!type)
RETURN(-ENOMEM);
- memset(type, 0, sizeof(*type));
INIT_LIST_HEAD(&type->typ_chain);
MOD_INC_USE_COUNT;
list_add(&type->typ_chain, obd_types.next);
* See the file COPYING in this distribution
*
* Author Peter Braam <braam@clusterfs.com>
- *
+ *
* This server is single threaded at present (but can easily be multi
* threaded). For testing and management it is treated as an
* obd_device, although it does not export a full OBD method table
* (the requests are coming in over the wire, so object target
* modules do not have a full method table.)
- *
+ *
*/
#define EXPORT_SYMTAB
struct ptlrpc_client *osc_con2cl(struct obd_conn *conn)
{
struct osc_obd *osc = &conn->oc_dev->u.osc;
- return osc->osc_peer;
+ return osc->osc_client;
}
static int osc_connect(struct obd_conn *conn)
{
struct ptlrpc_request *request;
- struct ptlrpc_client *peer = osc_con2cl(conn);
- int rc;
+ struct ptlrpc_client *cl = osc_con2cl(conn);
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
ENTRY;
-
- request = ptlrpc_prep_req(peer, OST_CONNECT, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
- }
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct ost_rep);
+ request = ptlrpc_prep_req(cl, OST_CONNECT, 0, NULL, NULL);
+ if (!request)
+ RETURN(-ENOMEM);
- rc = ptlrpc_queue_wait(peer, request);
- if (rc) {
- EXIT;
- goto out;
- }
-
- CDEBUG(D_INODE, "received connid %d\n", request->rq_rep.ost->connid);
+ request->rq_replen = lustre_msg_size(1, &size);
+
+ rc = ptlrpc_queue_wait(cl, request);
+ if (rc)
+ GOTO(out, rc);
- conn->oc_id = request->rq_rep.ost->connid;
+ body = lustre_msg_buf(request->rq_repmsg, 0);
+ CDEBUG(D_INODE, "received connid %d\n", body->connid);
+
+ conn->oc_id = body->connid;
+ EXIT;
out:
ptlrpc_free_req(request);
- EXIT;
return rc;
}
static int osc_disconnect(struct obd_conn *conn)
{
struct ptlrpc_request *request;
- struct ptlrpc_client *peer = osc_con2cl(conn);
- int rc;
+ struct ptlrpc_client *cl = osc_con2cl(conn);
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
ENTRY;
-
- request = ptlrpc_prep_req(peer, OST_DISCONNECT, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
- }
- request->rq_req.ost->connid = conn->oc_id;
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct ost_rep);
-
- rc = ptlrpc_queue_wait(peer, request);
- if (rc) {
- EXIT;
- goto out;
- }
+
+ request = ptlrpc_prep_req(cl, OST_DISCONNECT, 1, &size, NULL);
+ if (!request)
+ RETURN(-ENOMEM);
+
+ body = lustre_msg_buf(request->rq_reqmsg, 0);
+ body->connid = conn->oc_id;
+
+ request->rq_replen = lustre_msg_size(1, &size);
+
+ rc = ptlrpc_queue_wait(cl, request);
+ GOTO(out, rc);
out:
ptlrpc_free_req(request);
- EXIT;
return rc;
}
-
static int osc_getattr(struct obd_conn *conn, struct obdo *oa)
{
struct ptlrpc_request *request;
- struct ptlrpc_client *peer = osc_con2cl(conn);
- int rc;
+ struct ptlrpc_client *cl = osc_con2cl(conn);
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
+ ENTRY;
- request = ptlrpc_prep_req(peer, OST_GETATTR, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
- }
-
- memcpy(&request->rq_req.ost->oa, oa, sizeof(*oa));
- request->rq_req.ost->connid = conn->oc_id;
- request->rq_req.ost->oa.o_valid = ~0;
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct ost_rep);
-
- rc = ptlrpc_queue_wait(peer, request);
- if (rc) {
- EXIT;
- goto out;
- }
+ request = ptlrpc_prep_req(cl, OST_GETATTR, 1, &size, NULL);
+ if (!request)
+ RETURN(-ENOMEM);
- CDEBUG(D_INODE, "mode: %o\n", request->rq_rep.ost->oa.o_mode);
- if (oa) {
- memcpy(oa, &request->rq_rep.ost->oa, sizeof(*oa));
- }
+ body = lustre_msg_buf(request->rq_reqmsg, 0);
+ memcpy(&body->oa, oa, sizeof(*oa));
+ body->connid = conn->oc_id;
+ body->oa.o_valid = ~0;
+
+ request->rq_replen = lustre_msg_size(1, &size);
+
+ rc = ptlrpc_queue_wait(cl, request);
+ if (rc)
+ GOTO(out, rc);
+ body = lustre_msg_buf(request->rq_repmsg, 0);
+ CDEBUG(D_INODE, "mode: %o\n", body->oa.o_mode);
+ if (oa)
+ memcpy(oa, &body->oa, sizeof(*oa));
+
+ EXIT;
out:
ptlrpc_free_req(request);
return 0;
static int osc_open(struct obd_conn *conn, struct obdo *oa)
{
struct ptlrpc_request *request;
- struct ptlrpc_client *peer = osc_con2cl(conn);
- int rc;
+ struct ptlrpc_client *cl = osc_con2cl(conn);
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
+ ENTRY;
- request = ptlrpc_prep_req(peer, OST_OPEN, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
- }
-
- memcpy(&request->rq_req.ost->oa, oa, sizeof(*oa));
- request->rq_req.ost->connid = conn->oc_id;
- if (request->rq_req.ost->oa.o_valid != (OBD_MD_FLMODE | OBD_MD_FLID))
+ request = ptlrpc_prep_req(cl, OST_OPEN, 1, &size, NULL);
+ if (!request)
+ RETURN(-ENOMEM);
+
+ body = lustre_msg_buf(request->rq_reqmsg, 0);
+ memcpy(&body->oa, oa, sizeof(*oa));
+ body->connid = conn->oc_id;
+ if (body->oa.o_valid != (OBD_MD_FLMODE | OBD_MD_FLID))
LBUG();
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct ost_rep);
-
- rc = ptlrpc_queue_wait(peer, request);
- if (rc) {
- EXIT;
- goto out;
- }
- CDEBUG(D_INODE, "mode: %o\n", request->rq_rep.ost->oa.o_mode);
- if (oa) {
- memcpy(oa, &request->rq_rep.ost->oa, sizeof(*oa));
- }
+ request->rq_replen = lustre_msg_size(1, &size);
+
+ rc = ptlrpc_queue_wait(cl, request);
+ if (rc)
+ GOTO(out, rc);
+
+ body = lustre_msg_buf(request->rq_repmsg, 0);
+ CDEBUG(D_INODE, "mode: %o\n", body->oa.o_mode);
+ if (oa)
+ memcpy(oa, &body->oa, sizeof(*oa));
+ EXIT;
out:
ptlrpc_free_req(request);
return 0;
static int osc_close(struct obd_conn *conn, struct obdo *oa)
{
struct ptlrpc_request *request;
- struct ptlrpc_client *peer = osc_con2cl(conn);
- int rc;
+ struct ptlrpc_client *cl = osc_con2cl(conn);
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
+ ENTRY;
- request = ptlrpc_prep_req(peer, OST_CLOSE, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
- }
-
- memcpy(&request->rq_req.ost->oa, oa, sizeof(*oa));
- request->rq_req.ost->connid = conn->oc_id;
-
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct ost_rep);
-
- rc = ptlrpc_queue_wait(peer, request);
- if (rc) {
- EXIT;
- goto out;
- }
+ request = ptlrpc_prep_req(cl, OST_CLOSE, 1, &size, NULL);
+ if (!request)
+ RETURN(-ENOMEM);
- CDEBUG(D_INODE, "mode: %o\n", request->rq_rep.ost->oa.o_mode);
- if (oa) {
- memcpy(oa, &request->rq_rep.ost->oa, sizeof(*oa));
- }
+ body = lustre_msg_buf(request->rq_reqmsg, 0);
+ memcpy(&body->oa, oa, sizeof(*oa));
+ body->connid = conn->oc_id;
+
+ request->rq_replen = lustre_msg_size(1, &size);
+
+ rc = ptlrpc_queue_wait(cl, request);
+ if (rc)
+ GOTO(out, rc);
+
+ body = lustre_msg_buf(request->rq_repmsg, 0);
+ CDEBUG(D_INODE, "mode: %o\n", body->oa.o_mode);
+ if (oa)
+ memcpy(oa, &body->oa, sizeof(*oa));
+ EXIT;
out:
ptlrpc_free_req(request);
return 0;
static int osc_setattr(struct obd_conn *conn, struct obdo *oa)
{
struct ptlrpc_request *request;
- struct ptlrpc_client *peer = osc_con2cl(conn);
- int rc;
+ struct ptlrpc_client *cl = osc_con2cl(conn);
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
+ ENTRY;
- request = ptlrpc_prep_req(peer, OST_SETATTR, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
- }
-
- memcpy(&request->rq_req.ost->oa, oa, sizeof(*oa));
- request->rq_req.ost->connid = conn->oc_id;
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct ost_rep);
-
- rc = ptlrpc_queue_wait(peer, request);
- if (rc) {
- EXIT;
- goto out;
- }
+ request = ptlrpc_prep_req(cl, OST_SETATTR, 1, &size, NULL);
+ if (!request)
+ RETURN(-ENOMEM);
+
+ body = lustre_msg_buf(request->rq_reqmsg, 0);
+ memcpy(&body->oa, oa, sizeof(*oa));
+ body->connid = conn->oc_id;
+
+ request->rq_replen = lustre_msg_size(1, &size);
+
+ rc = ptlrpc_queue_wait(cl, request);
+ GOTO(out, rc);
out:
ptlrpc_free_req(request);
static int osc_create(struct obd_conn *conn, struct obdo *oa)
{
struct ptlrpc_request *request;
- struct ptlrpc_client *peer = osc_con2cl(conn);
- int rc;
+ struct ptlrpc_client *cl = osc_con2cl(conn);
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
+ ENTRY;
- if (!oa) {
- CERROR("oa NULL\n");
- }
- request = ptlrpc_prep_req(peer, OST_CREATE, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
+ if (!oa) {
+ CERROR("oa NULL\n");
+ RETURN(-EINVAL);
}
-
- memcpy(&request->rq_req.ost->oa, oa, sizeof(*oa));
- request->rq_req.ost->connid = conn->oc_id;
- request->rq_req.ost->oa.o_valid = ~0;
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct ost_rep);
-
- rc = ptlrpc_queue_wait(peer, request);
- if (rc) {
- EXIT;
- goto out;
- }
- memcpy(oa, &request->rq_rep.ost->oa, sizeof(*oa));
+ request = ptlrpc_prep_req(cl, OST_CREATE, 1, &size, NULL);
+ if (!request)
+ RETURN(-ENOMEM);
+ body = lustre_msg_buf(request->rq_reqmsg, 0);
+ memcpy(&body->oa, oa, sizeof(*oa));
+ body->oa.o_valid = ~0;
+ body->connid = conn->oc_id;
+
+ request->rq_replen = lustre_msg_size(1, &size);
+
+ rc = ptlrpc_queue_wait(cl, request);
+ if (rc)
+ GOTO(out, rc);
+
+ body = lustre_msg_buf(request->rq_repmsg, 0);
+ memcpy(oa, &body->oa, sizeof(*oa));
+
+ EXIT;
out:
ptlrpc_free_req(request);
return 0;
obd_off offset)
{
struct ptlrpc_request *request;
- struct ptlrpc_client *peer = osc_con2cl(conn);
- int rc;
+ struct ptlrpc_client *cl = osc_con2cl(conn);
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
+ ENTRY;
- if (!oa) {
- CERROR("oa NULL\n");
- }
- request = ptlrpc_prep_req(peer, OST_PUNCH, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
+ if (!oa) {
+ CERROR("oa NULL\n");
+ RETURN(-EINVAL);
}
-
- memcpy(&request->rq_req.ost->oa, oa, sizeof(*oa));
- request->rq_req.ost->connid = conn->oc_id;
- request->rq_req.ost->oa.o_valid = ~0;
- request->rq_req.ost->oa.o_size = offset;
- request->rq_req.ost->oa.o_blocks = count;
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct ost_rep);
-
- rc = ptlrpc_queue_wait(peer, request);
- if (rc) {
- EXIT;
- goto out;
- }
- memcpy(oa, &request->rq_rep.ost->oa, sizeof(*oa));
+ request = ptlrpc_prep_req(cl, OST_PUNCH, 1, &size, NULL);
+ if (!request)
+ RETURN(-ENOMEM);
+
+ body = lustre_msg_buf(request->rq_reqmsg, 0);
+ memcpy(&body->oa, oa, sizeof(*oa));
+ body->connid = conn->oc_id;
+ body->oa.o_valid = ~0;
+ body->oa.o_size = offset;
+ body->oa.o_blocks = count;
+
+ request->rq_replen = lustre_msg_size(1, &size);
+
+ rc = ptlrpc_queue_wait(cl, request);
+ if (rc)
+ GOTO(out, rc);
+ body = lustre_msg_buf(request->rq_repmsg, 0);
+ memcpy(oa, &body->oa, sizeof(*oa));
+
+ EXIT;
out:
ptlrpc_free_req(request);
return 0;
static int osc_destroy(struct obd_conn *conn, struct obdo *oa)
{
struct ptlrpc_request *request;
- struct ptlrpc_client *peer = osc_con2cl(conn);
- int rc;
+ struct ptlrpc_client *cl = osc_con2cl(conn);
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
+ ENTRY;
- if (!oa) {
- CERROR("oa NULL\n");
+ if (!oa) {
+ CERROR("oa NULL\n");
+ RETURN(-EINVAL);
}
- request = ptlrpc_prep_req(peer, OST_DESTROY, 0, NULL, 0, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
- }
-
- memcpy(&request->rq_req.ost->oa, oa, sizeof(*oa));
- request->rq_req.ost->connid = conn->oc_id;
- request->rq_req.ost->oa.o_valid = ~0;
- request->rq_replen =
- sizeof(struct ptlrep_hdr) + sizeof(struct ost_rep);
-
- rc = ptlrpc_queue_wait(peer, request);
- if (rc) {
- EXIT;
- goto out;
- }
- memcpy(oa, &request->rq_rep.ost->oa, sizeof(*oa));
+ request = ptlrpc_prep_req(cl, OST_DESTROY, 1, &size, NULL);
+ if (!request)
+ RETURN(-ENOMEM);
+ body = lustre_msg_buf(request->rq_reqmsg, 0);
+ memcpy(&body->oa, oa, sizeof(*oa));
+ body->connid = conn->oc_id;
+ body->oa.o_valid = ~0;
+
+ request->rq_replen = lustre_msg_size(1, &size);
+
+ rc = ptlrpc_queue_wait(cl, request);
+ if (rc)
+ GOTO(out, rc);
+
+ body = lustre_msg_buf(request->rq_repmsg, 0);
+ memcpy(oa, &body->oa, sizeof(*oa));
+
+ EXIT;
out:
ptlrpc_free_req(request);
return 0;
{
struct ptlrpc_client *cl = osc_con2cl(conn);
struct ptlrpc_request *request;
- int pages;
- int rc;
+ struct ost_body *body;
struct obd_ioobj ioo;
struct niobuf src;
- int size1, size2 = 0;
+ int pages, rc, i, j, size[3] = {sizeof(*body)};
void *ptr1, *ptr2;
- int i, j, n;
struct ptlrpc_bulk_desc **bulk;
+ ENTRY;
- size1 = num_oa * sizeof(ioo);
+ size[1] = num_oa * sizeof(ioo);
pages = 0;
for (i = 0; i < num_oa; i++)
pages += oa_bufs[i];
- size2 = pages * sizeof(src);
-
- request = ptlrpc_prep_req(cl, OST_BRW, size1, NULL, size2, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
- }
- request->rq_req.ost->cmd = OBD_BRW_READ;
+ size[2] = pages * sizeof(src);
OBD_ALLOC(bulk, pages * sizeof(*bulk));
- if (bulk == NULL) {
- CERROR("cannot alloc bulk desc vector\n");
- return -ENOMEM;
- }
- memset(bulk, 0, pages * sizeof(*bulk));
-
- n = 0;
- ptr1 = ost_req_buf1(request->rq_req.ost);
- ptr2 = ost_req_buf2(request->rq_req.ost);
- for (i = 0; i < num_oa; i++) {
- ost_pack_ioo(&ptr1, oa[i], oa_bufs[i]);
- for (j = 0; j < oa_bufs[i]; j++) {
- bulk[n] = ptlrpc_prep_bulk(&cl->cli_server);
- if (bulk[n] == NULL) {
- CERROR("cannot alloc bulk desc\n");
- rc = -ENOMEM;
- goto out;
- }
+ if (bulk == NULL)
+ RETURN(-ENOMEM);
+
+ request = ptlrpc_prep_req(cl, OST_BRW, 3, size, NULL);
+ if (!request)
+ GOTO(out, rc = -ENOMEM);
+
+ body = lustre_msg_buf(request->rq_reqmsg, 0);
+ body->data = OBD_BRW_READ;
+
+ ptr1 = lustre_msg_buf(request->rq_reqmsg, 1);
+ ptr2 = lustre_msg_buf(request->rq_reqmsg, 2);
+ for (pages = 0, i = 0; i < num_oa; i++) {
+ ost_pack_ioo(&ptr1, oa[i], oa_bufs[i]);
+ for (j = 0; j < oa_bufs[i]; j++, pages++) {
+ bulk[pages] = ptlrpc_prep_bulk(&cl->cli_server);
+ if (bulk[pages] == NULL)
+ GOTO(out, rc = -ENOMEM);
spin_lock(&cl->cli_lock);
- bulk[n]->b_xid = cl->cli_xid++;
+ bulk[pages]->b_xid = cl->cli_xid++;
spin_unlock(&cl->cli_lock);
- bulk[n]->b_buf = kmap(buf[n]);
- bulk[n]->b_buflen = PAGE_SIZE;
- bulk[n]->b_portal = OST_BULK_PORTAL;
- ost_pack_niobuf(&ptr2, bulk[n]->b_buf, offset[n],
- count[n], flags[n], bulk[n]->b_xid);
- rc = ptlrpc_register_bulk(bulk[n]);
+ bulk[pages]->b_buf = kmap(buf[pages]);
+ bulk[pages]->b_buflen = PAGE_SIZE;
+ bulk[pages]->b_portal = OST_BULK_PORTAL;
+ ost_pack_niobuf(&ptr2, bulk[pages]->b_buf,
+ offset[pages], count[pages],
+ flags[pages], bulk[pages]->b_xid);
+
+ rc = ptlrpc_register_bulk(bulk[pages]);
if (rc)
- goto out;
- n++;
+ GOTO(out, rc);
}
}
- request->rq_replen = sizeof(struct ptlrep_hdr) + sizeof(struct ost_rep);
+ request->rq_replen = lustre_msg_size(1, size);
rc = ptlrpc_queue_wait(cl, request);
+ GOTO(out, rc);
out:
/* FIXME: if we've called ptlrpc_wait_bulk but rc != 0, we need to
* abort those bulk listeners. */
- n = 0;
- for (i = 0; i < num_oa; i++) {
- for (j = 0; j < oa_bufs[i]; j++) {
- if (bulk[n] == NULL)
+ for (pages = 0, i = 0; i < num_oa; i++) {
+ for (j = 0; j < oa_bufs[i]; j++, pages++) {
+ if (bulk[pages] == NULL)
continue;
- kunmap(buf[n]);
- OBD_FREE(bulk[n], sizeof(**bulk));
- n++;
+ kunmap(buf[pages]);
+ OBD_FREE(bulk[pages], sizeof(**bulk));
}
}
struct ptlrpc_client *cl = osc_con2cl(conn);
struct ptlrpc_request *request;
struct obd_ioobj ioo;
+ struct ost_body *body;
struct niobuf *src;
- int pages, rc, i, j, n, size1, size2 = 0;
+ int pages, rc, i, j, size[3] = {sizeof(*body)};
void *ptr1, *ptr2;
+ ENTRY;
- size1 = num_oa * sizeof(ioo);
+ size[1] = num_oa * sizeof(ioo);
pages = 0;
for (i = 0; i < num_oa; i++)
pages += oa_bufs[i];
- size2 = pages * sizeof(*src);
+ size[2] = pages * sizeof(*src);
- OBD_ALLOC(src, size2);
- if (!src) {
- CERROR("no src memory\n");
- return -ENOMEM;
- }
- memset((char *)src, 0, size2);
+ OBD_ALLOC(src, size[2]);
+ if (!src)
+ RETURN(-ENOMEM);
- request = ptlrpc_prep_req(cl, OST_BRW, size1, NULL, size2, NULL);
- if (!request) {
- CERROR("cannot pack req!\n");
- return -ENOMEM;
- }
- request->rq_req.ost->cmd = OBD_BRW_WRITE;
-
- n = 0;
- ptr1 = ost_req_buf1(request->rq_req.ost);
- ptr2 = ost_req_buf2(request->rq_req.ost);
- for (i = 0; i < num_oa; i++) {
- ost_pack_ioo(&ptr1, oa[i], oa_bufs[i]);
- for (j = 0; j < oa_bufs[i]; j++) {
- ost_pack_niobuf(&ptr2, kmap(buf[n]), offset[n],
- count[n], flags[n], 0);
- n++;
+ request = ptlrpc_prep_req(cl, OST_BRW, 3, size, NULL);
+ if (!request)
+ RETURN(-ENOMEM);
+ body = lustre_msg_buf(request->rq_reqmsg, 0);
+ body->data = OBD_BRW_WRITE;
+
+ ptr1 = lustre_msg_buf(request->rq_reqmsg, 1);
+ ptr2 = lustre_msg_buf(request->rq_reqmsg, 2);
+ for (pages = 0, i = 0; i < num_oa; i++) {
+ ost_pack_ioo(&ptr1, oa[i], oa_bufs[i]);
+ for (j = 0; j < oa_bufs[i]; j++, pages++) {
+ ost_pack_niobuf(&ptr2, kmap(buf[pages]), offset[pages],
+ count[pages], flags[pages], 0);
}
}
- memcpy((char *)src, (char *)ost_req_buf2(request->rq_req.ost), size2);
+ memcpy(src, lustre_msg_buf(request->rq_reqmsg, 2), size[2]);
+
+ size[1] = pages * sizeof(struct niobuf);
+ request->rq_replen = lustre_msg_size(2, size);
- request->rq_replen = sizeof(struct ptlrep_hdr) +
- sizeof(struct ost_rep) + pages * sizeof(struct niobuf);
rc = ptlrpc_queue_wait(cl, request);
- if (rc) {
- EXIT;
- goto out;
- }
+ if (rc)
+ GOTO(out, rc);
- ptr2 = ost_rep_buf2(request->rq_rep.ost);
- if (request->rq_rep.ost->buflen2 != n * sizeof(struct niobuf)) {
+ ptr2 = lustre_msg_buf(request->rq_repmsg, 1);
+ if (ptr2 == NULL)
+ GOTO(out, rc = -EINVAL);
+
+ if (request->rq_repmsg->buflens[1] != pages * sizeof(struct niobuf)) {
CERROR("buffer length wrong (%d vs. %d)\n",
- request->rq_rep.ost->buflen2, n * sizeof(struct niobuf));
- EXIT;
- goto out;
+ request->rq_repmsg->buflens[1],
+ pages * sizeof(struct niobuf));
+ GOTO(out, rc = -EINVAL);
}
- n = 0;
- for (i = 0; i < num_oa; i++) {
- for (j = 0; j < oa_bufs[i]; j++) {
+ for (pages = 0, i = 0; i < num_oa; i++) {
+ for (j = 0; j < oa_bufs[i]; j++, pages++) {
struct niobuf *dst;
ost_unpack_niobuf(&ptr2, &dst);
- osc_sendpage(conn, request, dst, &src[n]);
- n++;
+ osc_sendpage(conn, request, dst, &src[pages]);
}
}
- OBD_FREE(src, size2);
+ OBD_FREE(src, size[2]);
out:
- n = 0;
- for (i = 0; i < num_oa; i++) {
- for (j = 0; j < oa_bufs[i]; j++) {
+ for (pages = 0, i = 0; i < num_oa; i++)
+ for (j = 0; j < oa_bufs[i]; j++, pages++)
kunmap(buf[n]);
- n++;
- }
- }
ptlrpc_free_req(request);
return 0;
struct obdo **oa, obd_count *oa_bufs, struct page **buf,
obd_size *count, obd_off *offset, obd_flag *flags)
{
- if (rw == OBD_BRW_READ) {
+ if (rw == OBD_BRW_READ)
return osc_brw_read(conn, num_oa, oa, oa_bufs, buf, count,
offset, flags);
- } else {
+ else
return osc_brw_write(conn, num_oa, oa, oa_bufs, buf, count,
offset, flags);
- }
}
/* mount the file system (secretly) */
static int osc_setup(struct obd_device *obddev, obd_count len,
void *buf)
-
+
{
struct osc_obd *osc = &obddev->u.osc;
struct obd_ioctl_data *data = (struct obd_ioctl_data *)buf;
int dev = data->ioc_dev;
ENTRY;
- OBD_ALLOC(osc->osc_peer, sizeof(*osc->osc_peer));
- if (osc->osc_peer == NULL)
+ OBD_ALLOC(osc->osc_client, sizeof(*osc->osc_client));
+ if (osc->osc_client == NULL)
RETURN(-ENOMEM);
rc = ptlrpc_connect_client(dev, "ost",
- OST_REQUEST_PORTAL,
- OSC_REPLY_PORTAL,
- ost_pack_req,
- ost_unpack_rep,
- osc->osc_peer);
+ OST_REQUEST_PORTAL, OSC_REPLY_PORTAL,
+ osc->osc_client);
if (rc == 0)
MOD_INC_USE_COUNT;
RETURN(rc);
-}
+}
static int osc_cleanup(struct obd_device * obddev)
{
struct osc_obd *osc = &obddev->u.osc;
- if (osc->osc_peer != NULL)
- OBD_FREE(osc->osc_peer, sizeof(*osc->osc_peer));
+ if (osc->osc_client != NULL)
+ OBD_FREE(osc->osc_client, sizeof(*osc->osc_client));
MOD_DEC_USE_COUNT;
return 0;
}
-struct obd_ops osc_obd_ops = {
+struct obd_ops osc_obd_ops = {
o_setup: osc_setup,
- o_cleanup: osc_cleanup,
+ o_cleanup: osc_cleanup,
o_create: osc_create,
o_destroy: osc_destroy,
o_getattr: osc_getattr,
MODULE_AUTHOR("Peter J. Braam <braam@clusterfs.com>");
MODULE_DESCRIPTION("Lustre Object Storage Client (OSC) v1.0");
-MODULE_LICENSE("GPL");
+MODULE_LICENSE("GPL");
module_init(osc_init);
module_exit(osc_exit);
static int ost_destroy(struct ost_obd *ost, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
-
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
ENTRY;
- conn.oc_id = req->rq_req.ost->connid;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ conn.oc_id = body->connid;
conn.oc_dev = ost->ost_tgt;
- rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
-
- req->rq_rep.ost->result = obd_destroy(&conn, &req->rq_req.ost->oa);
+ req->rq_status = obd_destroy(&conn, &body->oa);
RETURN(0);
}
static int ost_getattr(struct ost_obd *ost, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
-
+ struct ost_body *body, *repbody;
+ int rc, size = sizeof(*body);
ENTRY;
- conn.oc_id = req->rq_req.ost->connid;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ conn.oc_id = body->connid;
conn.oc_dev = ost->ost_tgt;
- rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
- req->rq_rep.ost->oa.o_id = req->rq_req.ost->oa.o_id;
- req->rq_rep.ost->oa.o_valid = req->rq_req.ost->oa.o_valid;
-
- req->rq_rep.ost->result = obd_getattr(&conn, &req->rq_rep.ost->oa);
+ repbody = lustre_msg_buf(req->rq_repmsg, 0);
+ memcpy(&repbody->oa, &body->oa, sizeof(body->oa));
+ req->rq_status = obd_getattr(&conn, &repbody->oa);
RETURN(0);
}
static int ost_open(struct ost_obd *ost, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
-
+ struct ost_body *body, *repbody;
+ int rc, size = sizeof(*body);
ENTRY;
- conn.oc_id = req->rq_req.ost->connid;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ conn.oc_id = body->connid;
conn.oc_dev = ost->ost_tgt;
- rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
- req->rq_rep.ost->oa.o_id = req->rq_req.ost->oa.o_id;
- req->rq_rep.ost->oa.o_valid = req->rq_req.ost->oa.o_valid;
-
- req->rq_rep.ost->result = obd_open(&conn, &req->rq_rep.ost->oa);
+ repbody = lustre_msg_buf(req->rq_repmsg, 0);
+ memcpy(&repbody->oa, &body->oa, sizeof(body->oa));
+ req->rq_status = obd_open(&conn, &repbody->oa);
RETURN(0);
}
static int ost_close(struct ost_obd *ost, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
-
+ struct ost_body *body, *repbody;
+ int rc, size = sizeof(*body);
ENTRY;
- conn.oc_id = req->rq_req.ost->connid;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ conn.oc_id = body->connid;
conn.oc_dev = ost->ost_tgt;
- rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
- req->rq_rep.ost->oa.o_id = req->rq_req.ost->oa.o_id;
- req->rq_rep.ost->oa.o_valid = req->rq_req.ost->oa.o_valid;
-
- req->rq_rep.ost->result = obd_close(&conn, &req->rq_rep.ost->oa);
+ repbody = lustre_msg_buf(req->rq_repmsg, 0);
+ memcpy(&repbody->oa, &body->oa, sizeof(body->oa));
+ req->rq_status = obd_close(&conn, &repbody->oa);
RETURN(0);
}
-
static int ost_create(struct ost_obd *ost, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
-
+ struct ost_body *body, *repbody;
+ int rc, size = sizeof(*body);
ENTRY;
- conn.oc_id = req->rq_req.ost->connid;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ conn.oc_id = body->connid;
conn.oc_dev = ost->ost_tgt;
- rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
-
- memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa,
- sizeof(req->rq_req.ost->oa));
-
- req->rq_rep.ost->result =obd_create(&conn, &req->rq_rep.ost->oa);
+ repbody = lustre_msg_buf(req->rq_repmsg, 0);
+ memcpy(&repbody->oa, &body->oa, sizeof(body->oa));
+ req->rq_status = obd_create(&conn, &repbody->oa);
RETURN(0);
}
static int ost_punch(struct ost_obd *ost, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
-
+ struct ost_body *body, *repbody;
+ int rc, size = sizeof(*body);
ENTRY;
- conn.oc_id = req->rq_req.ost->connid;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ conn.oc_id = body->connid;
conn.oc_dev = ost->ost_tgt;
- rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
-
- memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa,
- sizeof(req->rq_req.ost->oa));
-
- req->rq_rep.ost->result = obd_punch(&conn, &req->rq_rep.ost->oa,
- req->rq_rep.ost->oa.o_size,
- req->rq_rep.ost->oa.o_blocks);
+ repbody = lustre_msg_buf(req->rq_repmsg, 0);
+ memcpy(&repbody->oa, &body->oa, sizeof(body->oa));
+ req->rq_status = obd_punch(&conn, &repbody->oa,
+ repbody->oa.o_size, repbody->oa.o_blocks);
RETURN(0);
}
-
static int ost_setattr(struct ost_obd *ost, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
-
+ struct ost_body *body, *repbody;
+ int rc, size = sizeof(*body);
ENTRY;
- conn.oc_id = req->rq_req.ost->connid;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ conn.oc_id = body->connid;
conn.oc_dev = ost->ost_tgt;
- rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
-
- memcpy(&req->rq_rep.ost->oa, &req->rq_req.ost->oa,
- sizeof(req->rq_req.ost->oa));
-
- req->rq_rep.ost->result = obd_setattr(&conn, &req->rq_rep.ost->oa);
+ repbody = lustre_msg_buf(req->rq_repmsg, 0);
+ memcpy(&repbody->oa, &body->oa, sizeof(body->oa));
+ req->rq_status = obd_setattr(&conn, &repbody->oa);
RETURN(0);
}
static int ost_connect(struct ost_obd *ost, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
-
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
ENTRY;
conn.oc_dev = ost->ost_tgt;
- rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
- req->rq_rep.ost->result = obd_connect(&conn);
+ req->rq_status = obd_connect(&conn);
CDEBUG(D_IOCTL, "rep buffer %p, id %d\n", req->rq_repbuf, conn.oc_id);
- req->rq_rep.ost->connid = conn.oc_id;
+ body = lustre_msg_buf(req->rq_repmsg, 0);
+ body->connid = conn.oc_id;
RETURN(0);
}
static int ost_disconnect(struct ost_obd *ost, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
-
+ struct ost_body *body;
+ int rc, size = sizeof(*body);
ENTRY;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ conn.oc_id = body->connid;
conn.oc_dev = ost->ost_tgt;
- conn.oc_id = req->rq_req.ost->connid;
- rc = ost_pack_rep(NULL, 0, NULL, 0, &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
- CDEBUG(D_IOCTL, "Disconnecting %d\n", conn.oc_id);
- req->rq_rep.ost->result = obd_disconnect(&conn);
+ CDEBUG(D_IOCTL, "Disconnecting %d\n", conn.oc_id);
+ req->rq_status = obd_disconnect(&conn);
RETURN(0);
}
static int ost_get_info(struct ost_obd *ost, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
- int vallen;
- void *val;
- char *ptr;
-
+ struct ost_body *body;
+ int rc, size[2] = {sizeof(*body)};
+ char *bufs[2] = {NULL, NULL}, *ptr;
ENTRY;
- conn.oc_id = req->rq_req.ost->connid;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ conn.oc_id = body->connid;
conn.oc_dev = ost->ost_tgt;
- ptr = ost_req_buf1(req->rq_req.ost);
- req->rq_rep.ost->result = obd_get_info(&conn, req->rq_req.ost->buflen1,
- ptr, &vallen, &val);
+ ptr = lustre_msg_buf(req->rq_reqmsg, 1);
+ if (!ptr)
+ RETURN(-EINVAL);
+
+ req->rq_status = obd_get_info(&conn, req->rq_reqmsg->buflens[1], ptr,
+ &(size[1]), (void **)&(bufs[1]));
- rc = ost_pack_rep(val, vallen, NULL, 0, &req->rq_rephdr,
- &req->rq_rep, &req->rq_replen, &req->rq_repbuf);
+ rc = lustre_pack_msg(2, size, bufs, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
if (rc)
CERROR("cannot pack reply\n");
static int ost_brw_read(struct ost_obd *obddev, struct ptlrpc_request *req)
{
- struct ptlrpc_bulk_desc **bulk_vec = NULL;
- struct ptlrpc_bulk_desc *bulk = NULL;
+ struct ptlrpc_bulk_desc **bulk_vec = NULL, *bulk = NULL;
struct obd_conn conn;
- int rc;
- int i, j;
- int objcount, niocount;
- char *tmp1, *tmp2, *end2;
- int cmd;
+ void *tmp1, *tmp2, *end2;
struct niobuf *nb, *dst, *res = NULL;
struct obd_ioobj *ioo;
- struct ost_req *r = req->rq_req.ost;
-
+ struct ost_body *body;
+ int rc, cmd, i, j, objcount, niocount, size = sizeof(*body);
ENTRY;
- tmp1 = ost_req_buf1(r);
- tmp2 = ost_req_buf2(r);
- end2 = tmp2 + req->rq_req.ost->buflen2;
- objcount = r->buflen1 / sizeof(*ioo);
- niocount = r->buflen2 / sizeof(*nb);
- cmd = r->cmd;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ tmp1 = lustre_msg_buf(req->rq_reqmsg, 1);
+ tmp2 = lustre_msg_buf(req->rq_reqmsg, 2);
+ end2 = (char *)tmp2 + req->rq_reqmsg->buflens[2];
+ objcount = req->rq_reqmsg->buflens[1] / sizeof(*ioo);
+ niocount = req->rq_reqmsg->buflens[2] / sizeof(*nb);
+ cmd = body->data;
- conn.oc_id = req->rq_req.ost->connid;
+ conn.oc_id = body->connid;
conn.oc_dev = req->rq_obd->u.ost.ost_tgt;
for (i = 0; i < objcount; i++) {
- ost_unpack_ioo((void *)&tmp1, &ioo);
+ ost_unpack_ioo(&tmp1, &ioo);
if (tmp2 + ioo->ioo_bufcnt > end2) {
LBUG();
rc = -EFAULT;
break;
}
for (j = 0; j < ioo->ioo_bufcnt; j++)
- ost_unpack_niobuf((void *)&tmp2, &nb);
+ ost_unpack_niobuf(&tmp2, &nb);
}
- rc = ost_pack_rep(NULL, 0, NULL, 0,
- &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
OBD_ALLOC(res, sizeof(*res) * niocount);
if (res == NULL)
RETURN(-ENOMEM);
/* The unpackers move tmp1 and tmp2, so reset them before using */
- tmp1 = ost_req_buf1(r);
- tmp2 = ost_req_buf2(r);
- req->rq_rep.ost->result = obd_preprw
- (cmd, &conn, objcount, (struct obd_ioobj *)tmp1,
- niocount, (struct niobuf *)tmp2, res);
+ tmp1 = lustre_msg_buf(req->rq_reqmsg, 1);
+ tmp2 = lustre_msg_buf(req->rq_reqmsg, 2);
+ req->rq_status = obd_preprw(cmd, &conn, objcount,
+ tmp1, niocount, tmp2, res);
- if (req->rq_rep.ost->result)
+ if (req->rq_status)
GOTO(out, 0);
for (i = 0; i < niocount; i++) {
bulk = ptlrpc_prep_bulk(&req->rq_peer);
if (bulk == NULL) {
CERROR("cannot alloc bulk desc\n");
- rc = -ENOMEM;
- GOTO(out, rc);
+ GOTO(out, rc = -ENOMEM);
}
- dst = &((struct niobuf *)tmp2)[i];
+ dst = &(((struct niobuf *)tmp2)[i]);
bulk->b_xid = dst->xid;
bulk->b_buf = (void *)(unsigned long)res[i].addr;
bulk->b_buflen = PAGE_SIZE;
bulk = NULL;
}
-#if 0
- /* Local delivery */
- dst = &((struct niobuf *)tmp2)[i];
- memcpy((void *)(unsigned long)dst->addr,
- (void *)(unsigned long)src->addr, PAGE_SIZE);
-#endif
- barrier();
-
/* The unpackers move tmp1 and tmp2, so reset them before using */
- tmp1 = ost_req_buf1(r);
- tmp2 = ost_req_buf2(r);
- req->rq_rep.ost->result = obd_commitrw
- (cmd, &conn, objcount, (struct obd_ioobj *)tmp1,
- niocount, res);
+ tmp1 = lustre_msg_buf(req->rq_reqmsg, 1);
+ tmp2 = lustre_msg_buf(req->rq_reqmsg, 2);
+ req->rq_status = obd_commitrw(cmd, &conn, objcount,
+ tmp1, niocount, res);
EXIT;
out:
if (bulk != NULL)
OBD_FREE(bulk, sizeof(*bulk));
if (bulk_vec != NULL) {
- for (i = 0; i < niocount; i++) {
+ for (i = 0; i < niocount; i++)
if (bulk_vec[i] != NULL)
OBD_FREE(bulk_vec[i], sizeof(*bulk));
- }
OBD_FREE(bulk_vec, niocount * sizeof(*bulk_vec));
}
static int ost_brw_write(struct ost_obd *obddev, struct ptlrpc_request *req)
{
struct obd_conn conn;
- int rc;
- int i, j;
- int objcount, niocount;
- char *tmp1, *tmp2, *end2;
- char *res;
- int cmd;
struct niobuf *nb, *dst;
struct obd_ioobj *ioo;
- struct ost_req *r = req->rq_req.ost;
-
+ struct ost_body *body;
+ int cmd, rc, i, j, objcount, niocount, size[2] = {sizeof(*body)};
+ void *tmp1, *tmp2, *end2, *res;
ENTRY;
- tmp1 = ost_req_buf1(r);
- tmp2 = ost_req_buf2(r);
- end2 = tmp2 + req->rq_req.ost->buflen2;
- objcount = r->buflen1 / sizeof(*ioo);
- niocount = r->buflen2 / sizeof(*nb);
- cmd = r->cmd;
+ body = lustre_msg_buf(req->rq_reqmsg, 0);
+ tmp1 = lustre_msg_buf(req->rq_reqmsg, 1);
+ tmp2 = lustre_msg_buf(req->rq_reqmsg, 2);
+ end2 = (char *)tmp2 + req->rq_reqmsg->buflens[2];
+ objcount = req->rq_reqmsg->buflens[1] / sizeof(*ioo);
+ niocount = req->rq_reqmsg->buflens[2] / sizeof(*nb);
+ cmd = body->data;
- conn.oc_id = req->rq_req.ost->connid;
+ conn.oc_id = body->connid;
conn.oc_dev = req->rq_obd->u.ost.ost_tgt;
for (i = 0; i < objcount; i++) {
ost_unpack_niobuf((void *)&tmp2, &nb);
}
- rc = ost_pack_rep(NULL, 0, NULL, niocount * sizeof(*nb),
- &req->rq_rephdr, &req->rq_rep,
- &req->rq_replen, &req->rq_repbuf);
- if (rc) {
- CERROR("cannot pack reply\n");
+ size[1] = niocount * sizeof(*nb);
+ rc = lustre_pack_msg(2, size, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
RETURN(rc);
- }
- res = ost_rep_buf2(req->rq_rep.ost);
+
+ res = lustre_msg_buf(req->rq_repmsg, 1);
/* The unpackers move tmp1 and tmp2, so reset them before using */
- tmp1 = ost_req_buf1(r);
- tmp2 = ost_req_buf2(r);
- req->rq_rep.ost->result = obd_preprw
- (cmd, &conn, objcount, (struct obd_ioobj *)tmp1,
- niocount, (struct niobuf *)tmp2, (struct niobuf *)res);
+ tmp1 = lustre_msg_buf(req->rq_reqmsg, 1);
+ tmp2 = lustre_msg_buf(req->rq_reqmsg, 2);
+ req->rq_status = obd_preprw(cmd, &conn, objcount,
+ tmp1, niocount, tmp2, res);
- if (req->rq_rep.ost->result)
+ if (req->rq_status)
GOTO(out, 0);
for (i = 0; i < niocount; i++) {
struct ptlrpc_service *srv = req->rq_obd->u.ost.ost_service;
bulk = ptlrpc_prep_bulk(&req->rq_peer);
- if (bulk == NULL) {
- CERROR("cannot alloc bulk desc\n");
- rc = -ENOMEM;
- GOTO(out, rc);
- }
+ if (bulk == NULL)
+ GOTO(out, rc = -ENOMEM);
spin_lock(&srv->srv_lock);
bulk->b_xid = srv->srv_xid++;
spin_unlock(&srv->srv_lock);
- dst = &((struct niobuf *)res)[i];
+ dst = &(((struct niobuf *)res)[i]);
dst->xid = HTON__u32(bulk->b_xid);
bulk->b_buf = (void *)(unsigned long)dst->addr;
rc = ptlrpc_register_bulk(bulk);
if (rc)
GOTO(out, rc);
-
-#if 0
- /* Local delivery */
- src = &((struct niobuf *)tmp2)[i];
- memcpy((void *)(unsigned long)dst->addr,
- (void *)(unsigned long)src->addr, src->len);
-#endif
}
- barrier();
EXIT;
out:
static int ost_brw(struct ost_obd *obddev, struct ptlrpc_request *req)
{
- struct ost_req *r = req->rq_req.ost;
- int cmd = r->cmd;
+ struct ost_body *body = lustre_msg_buf(req->rq_reqmsg, 0);
- if (cmd == OBD_BRW_READ)
+ if (body->data == OBD_BRW_READ)
return ost_brw_read(obddev, req);
else
return ost_brw_write(obddev, req);
{
int rc;
struct ost_obd *ost = &obddev->u.ost;
- struct ptlreq_hdr *hdr;
-
ENTRY;
- hdr = (struct ptlreq_hdr *)req->rq_reqbuf;
- if (NTOH__u32(hdr->type) != PTL_RPC_REQUEST) {
- CERROR("lustre_ost: wrong packet type sent %d\n",
- NTOH__u32(hdr->type));
- LBUG();
- rc = -EINVAL;
+ rc = lustre_unpack_msg(req->rq_reqbuf, req->rq_reqlen);
+ req->rq_reqmsg = (struct lustre_msg *)req->rq_reqbuf;
+ if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_HANDLE_UNPACK)) {
+ CERROR("lustre_mds: Invalid request\n");
GOTO(out, rc);
}
- rc = ost_unpack_req(req->rq_reqbuf, req->rq_reqlen,
- &req->rq_reqhdr, &req->rq_req);
- if (rc) {
- CERROR("lustre_ost: Invalid request\n");
- GOTO(out, rc);
+ if (req->rq_reqmsg->type != PTL_RPC_REQUEST) {
+ CERROR("lustre_mds: wrong packet type sent %d\n",
+ req->rq_reqmsg->type);
+ GOTO(out, rc = -EINVAL);
}
- switch (req->rq_reqhdr->opc) {
-
+ switch (req->rq_reqmsg->opc) {
case OST_CONNECT:
CDEBUG(D_INODE, "connect\n");
OBD_FAIL_RETURN(OBD_FAIL_OST_CONNECT_NET, 0);
EXIT;
out:
- req->rq_status = rc;
+ //req->rq_status = rc;
if (rc) {
CERROR("ost: processing error %d\n", rc);
ptlrpc_error(obddev, svc, req);
modulefs_DATA = ptlrpc.o
EXTRA_PROGRAMS = ptlrpc
-ptlrpc_SOURCES = rpc.c events.c service.c client.c niobuf.c
+ptlrpc_SOURCES = rpc.c events.c service.c client.c niobuf.c pack_generic.c
include $(top_srcdir)/Rules
int ptlrpc_enqueue(struct ptlrpc_client *peer, struct ptlrpc_request *req)
{
struct ptlrpc_request *srv_req;
-
- if (!peer->cli_obd) {
- EXIT;
- return -1;
- }
+
+ if (!peer->cli_obd)
+ RETURN(-1);
OBD_ALLOC(srv_req, sizeof(*srv_req));
- if (!srv_req) {
- EXIT;
- return -ENOMEM;
- }
+ if (!srv_req)
+ RETURN(-ENOMEM);
CDEBUG(0, "peer obd minor %d, incoming req %p, srv_req %p\n",
peer->cli_obd->obd_minor, req, srv_req);
- memset(srv_req, 0, sizeof(*req));
-
/* move the request buffer */
srv_req->rq_reqbuf = req->rq_reqbuf;
srv_req->rq_reqlen = req->rq_reqlen;
srv_req->rq_reply_handle = req;
spin_lock(&peer->cli_lock);
- list_add(&srv_req->rq_list, &peer->cli_obd->obd_req_list);
+ list_add(&srv_req->rq_list, &peer->cli_obd->obd_req_list);
spin_unlock(&peer->cli_lock);
wake_up(&peer->cli_obd->obd_req_waitq);
return 0;
}
-int ptlrpc_connect_client(int dev, char *uuid, int req_portal, int rep_portal,
- req_pack_t req_pack, rep_unpack_t rep_unpack,
+int ptlrpc_connect_client(int dev, char *uuid, int req_portal, int rep_portal,
struct ptlrpc_client *cl)
{
- int err;
+ int err;
memset(cl, 0, sizeof(*cl));
spin_lock_init(&cl->cli_lock);
cl->cli_xid = 1;
- cl->cli_obd = NULL;
+ cl->cli_obd = NULL;
cl->cli_request_portal = req_portal;
cl->cli_reply_portal = rep_portal;
- cl->cli_rep_unpack = rep_unpack;
- cl->cli_req_pack = req_pack;
sema_init(&cl->cli_rpc_sem, 32);
/* non networked client */
if (dev >= 0 && dev < MAX_OBD_DEVICES) {
struct obd_device *obd = &obd_dev[dev];
-
+
if ((!obd->obd_flags & OBD_ATTACHED) ||
- (!obd->obd_flags & OBD_SET_UP)) {
+ (!obd->obd_flags & OBD_SET_UP)) {
CERROR("target device %d not att or setup\n", dev);
return -EINVAL;
}
- if (strcmp(obd->obd_type->typ_name, "ost") &&
- strcmp(obd->obd_type->typ_name, "mds")) {
+ if (strcmp(obd->obd_type->typ_name, "ost") &&
+ strcmp(obd->obd_type->typ_name, "mds"))
return -EINVAL;
- }
cl->cli_obd = &obd_dev[dev];
return 0;
OBD_ALLOC(bulk, sizeof(*bulk));
if (bulk != NULL) {
- memset(bulk, 0, sizeof(*bulk));
memcpy(&bulk->b_peer, peer, sizeof(*peer));
init_waitqueue_head(&bulk->b_waitq);
}
return bulk;
}
-struct ptlrpc_request *ptlrpc_prep_req(struct ptlrpc_client *cl,
- int opcode, int namelen, char *name,
- int tgtlen, char *tgt)
+struct ptlrpc_request *ptlrpc_prep_req(struct ptlrpc_client *cl, int opcode,
+ int count, int *lengths, char **bufs)
{
struct ptlrpc_request *request;
int rc;
- ENTRY;
+ ENTRY;
OBD_ALLOC(request, sizeof(*request));
- if (!request) {
+ if (!request) {
CERROR("request allocation out of memory\n");
- return NULL;
+ RETURN(NULL);
}
- memset(request, 0, sizeof(*request));
-
spin_lock(&cl->cli_lock);
request->rq_xid = cl->cli_xid++;
spin_unlock(&cl->cli_lock);
- rc = cl->cli_req_pack(name, namelen, tgt, tgtlen,
- &request->rq_reqhdr, &request->rq_req,
- &request->rq_reqlen, &request->rq_reqbuf);
- if (rc) {
- CERROR("cannot pack request %d\n", rc);
- return NULL;
+ rc = lustre_pack_msg(count, lengths, bufs,
+ &request->rq_reqlen, &request->rq_reqbuf);
+ if (rc) {
+ CERROR("cannot pack request %d\n", rc);
+ RETURN(NULL);
}
- request->rq_reqhdr->opc = opcode;
- request->rq_reqhdr->xid = request->rq_xid;
+ request->rq_type = PTL_RPC_REQUEST;
+ request->rq_reqmsg = (struct lustre_msg *)request->rq_reqbuf;
+ request->rq_reqmsg->opc = HTON__u32(opcode);
+ request->rq_reqmsg->xid = HTON__u32(request->rq_xid);
+ request->rq_reqmsg->type = HTON__u32(request->rq_type);
- EXIT;
- return request;
+ RETURN(request);
}
void ptlrpc_free_req(struct ptlrpc_request *request)
if (sigismember(&(current->pending.signal), SIGKILL) ||
sigismember(&(current->pending.signal), SIGTERM) ||
- sigismember(&(current->pending.signal), SIGINT)) {
+ sigismember(&(current->pending.signal), SIGINT)) {
req->rq_flags = PTL_RPC_INTR;
GOTO(out, rc = 1);
}
if (err != 0) {
CERROR("err is %d\n", err);
- EXIT;
- return err;
+ RETURN(err);
}
if (req == NULL) {
CERROR("req == NULL\n");
- EXIT;
- return -ENOMEM;
+ RETURN(-ENOMEM);
}
- if (req->rq_rephdr == NULL) {
- CERROR("req->rq_rephdr == NULL\n");
- EXIT;
- return -ENOMEM;
+ if (req->rq_repmsg == NULL) {
+ CERROR("req->rq_repmsg == NULL\n");
+ RETURN(-ENOMEM);
}
- if (req->rq_rephdr->status != 0) {
- CERROR("req->rq_rephdr->status is %d\n",
- req->rq_rephdr->status);
- EXIT;
+ if (req->rq_repmsg->status != 0) {
+ CERROR("req->rq_repmsg->status is %d\n",
+ req->rq_repmsg->status);
/* XXX: translate this error from net to host */
- return req->rq_rephdr->status;
+ RETURN(req->rq_repmsg->status);
}
- EXIT;
- return 0;
+ RETURN(0);
}
/* Abort this request and cleanup any resources associated with it. */
if (cl->cli_obd) {
/* Local delivery */
down(&cl->cli_rpc_sem);
- rc = ptlrpc_enqueue(cl, req);
+ rc = ptlrpc_enqueue(cl, req);
} else {
/* Remote delivery via portals. */
req->rq_req_portal = cl->cli_request_portal;
req->rq_reply_portal = cl->cli_reply_portal;
rc = ptl_send_rpc(req, cl);
}
- if (rc) {
- CERROR("error %d, opcode %d\n", rc, req->rq_reqhdr->opc);
+ if (rc) {
+ CERROR("error %d, opcode %d\n", rc, req->rq_reqmsg->opc);
up(&cl->cli_rpc_sem);
RETURN(-rc);
}
wait_event_interruptible(req->rq_wait_for_rep, ptlrpc_check_reply(req));
CDEBUG(D_OTHER, "-- done\n");
up(&cl->cli_rpc_sem);
- if (req->rq_flags == PTL_RPC_INTR) {
+ if (req->rq_flags == PTL_RPC_INTR) {
/* Clean up the dangling reply buffers */
ptlrpc_abort(req);
GOTO(out, rc = -EINTR);
}
- if (req->rq_flags != PTL_RPC_REPLY) {
+ if (req->rq_flags != PTL_RPC_REPLY) {
CERROR("Unknown reason for wakeup\n");
/* XXX Phil - I end up here when I kill obdctl */
- ptlrpc_abort(req);
+ ptlrpc_abort(req);
GOTO(out, rc = -EINTR);
}
- rc = cl->cli_rep_unpack(req->rq_repbuf, req->rq_replen,
- &req->rq_rephdr, &req->rq_rep);
+ rc = lustre_unpack_msg(req->rq_repbuf, req->rq_replen);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
if (rc) {
CERROR("unpack_rep failed: %d\n", rc);
GOTO(out, rc);
}
- CDEBUG(D_NET, "got rep %d\n", req->rq_rephdr->xid);
+ CDEBUG(D_NET, "got rep %d\n", req->rq_repmsg->xid);
- if ( req->rq_rephdr->status == 0 )
+ if (req->rq_repmsg->status == 0)
CDEBUG(D_NET, "--> buf %p len %d status %d\n", req->rq_repbuf,
- req->rq_replen, req->rq_rephdr->status);
+ req->rq_replen, req->rq_repmsg->status);
EXIT;
out:
/* FIXME: we need to increment the count of handled events */
req->rq_type = PTL_RPC_REPLY;
- req->rq_reqhdr->xid = req->rq_reqhdr->xid;
+ req->rq_repmsg->xid = HTON__u32(req->rq_reqmsg->xid);
+ req->rq_repmsg->status = HTON__u32(req->rq_status);
+ req->rq_reqmsg->type = HTON__u32(req->rq_type);
ptl_send_buf(req, &req->rq_peer, svc->srv_rep_portal);
} else {
/* This is a local request that came from another thread. */
wake_up_interruptible(&clnt_req->rq_wait_for_rep);
}
- EXIT;
- return 0;
+ RETURN(0);
}
int ptlrpc_error(struct obd_device *obddev, struct ptlrpc_service *svc,
struct ptlrpc_request *req)
{
- struct ptlrep_hdr *hdr;
-
+ int rc;
ENTRY;
- OBD_ALLOC(hdr, sizeof(*hdr));
- if (!hdr) {
- EXIT;
- return -ENOMEM;
- }
-
- memset(hdr, 0, sizeof(*hdr));
-
- hdr->xid = req->rq_reqhdr->xid;
- hdr->status = req->rq_status;
- hdr->type = PTL_RPC_ERR;
-
- if (req->rq_repbuf) {
+ if (req->rq_repbuf) {
CERROR("req has repbuf\n");
LBUG();
}
- req->rq_repbuf = (char *)hdr;
- req->rq_replen = sizeof(*hdr);
+ rc = lustre_pack_msg(0, NULL, NULL, &req->rq_replen, &req->rq_repbuf);
+ req->rq_repmsg = (struct lustre_msg *)req->rq_repbuf;
+ if (rc)
+ RETURN(rc);
- EXIT;
- return ptlrpc_reply(obddev, svc, req);
+ req->rq_repmsg->type = HTON__u32(PTL_RPC_ERR);
+
+ rc = ptlrpc_reply(obddev, svc, req);
+ RETURN(rc);
}
int ptl_send_rpc(struct ptlrpc_request *request, struct ptlrpc_client *cl)
{
ptl_process_id_t local_id;
- struct ptlreq_hdr *hdr;
int rc;
char *repbuf;
ENTRY;
- hdr = (struct ptlreq_hdr *)request->rq_reqbuf;
- if (NTOH__u32(hdr->type) != PTL_RPC_REQUEST) {
- CERROR("wrong packet type sent %d\n", NTOH__u32(hdr->type));
+ if (NTOH__u32(request->rq_reqmsg->type) != PTL_RPC_REQUEST) {
+ CERROR("wrong packet type sent %d\n",
+ NTOH__u32(request->rq_reqmsg->type));
LBUG();
RETURN(-EINVAL);
}
*
*/
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/major.h>
-#include <linux/sched.h>
-#include <linux/lp.h>
-#include <linux/slab.h>
-#include <linux/ioport.h>
-#include <linux/fcntl.h>
-#include <linux/delay.h>
-#include <linux/skbuff.h>
-#include <linux/proc_fs.h>
-#include <linux/fs.h>
-#include <linux/poll.h>
-#include <linux/init.h>
-#include <linux/list.h>
-#include <asm/io.h>
-#include <asm/segment.h>
-#include <asm/system.h>
-#include <asm/poll.h>
-#include <asm/uaccess.h>
+#define EXPORT_SYMTAB
#define DEBUG_SUBSYSTEM S_CLASS
{
char *ptr;
struct lustre_msg *m;
- int size = 0;
- int i;
+ int size = 0, i;
- for (i=0 ; i<count; i++) {
+ for (i = 0; i < count; i++)
size += size_round(lens[i]);
- }
- *len = sizeof(*m) + size;
+
+ *len = sizeof(*m) + count * sizeof(__u32) + size;
OBD_ALLOC(*buf, *len);
- if (!*buf) {
- EXIT;
- return -ENOMEM;
- }
+ if (!*buf)
+ RETURN(-ENOMEM);
- memset(*buf, 0, *len);
m = (struct lustre_msg *)(*buf);
- m->type = PTL_RPC_REQUEST;
-
m->bufcount = HTON__u32(count);
- for (i=0 ; i<count; i++) {
+ for (i = 0; i < count; i++)
m->buflens[i] = HTON__u32(lens[i]);
- }
-
+
ptr = *buf + sizeof(*m) + sizeof(__u32) * count;
- for (i=0 ; i<count ; i++) {
- LOGL(buf[i], lens[i], ptr);
+ for (i = 0; i < count; i++) {
+ char *tmp = NULL;
+ if (bufs)
+ tmp = bufs[i];
+ LOGL(tmp, lens[i], ptr);
}
return 0;
}
+/* This returns the size of the buffer that is required to hold a lustre_msg
+ * with the given sub-buffer lengths. */
+int lustre_msg_size(int count, int *lengths)
+{
+ int size = sizeof(struct lustre_msg), i;
+
+ for (i = 0; i < count; i++)
+ size += size_round(lengths[i]);
+
+ size += count * sizeof(__u32);
+
+ return size;
+}
+
int lustre_unpack_msg(char *buf, int len)
{
struct lustre_msg *m = (struct lustre_msg *)buf;
int required_len, i;
required_len = sizeof(*m);
- if (len < required_len) {
+ if (len < required_len)
RETURN(-EINVAL);
- }
- m->bufcount = NTOH__u32(m->bufcount);
+ m->opc = NTOH__u32(m->opc);
+ m->xid = NTOH__u32(m->xid);
+ m->status = NTOH__u32(m->status);
+ m->type = NTOH__u32(m->type);
+ m->connid = NTOH__u32(m->connid);
+ m->bufcount = NTOH__u32(m->bufcount);
- required_len += m->bufcount * sizeof(__u32);
- if (len < required_len) {
+ required_len += m->bufcount * sizeof(__u32);
+ if (len < required_len)
RETURN(-EINVAL);
- }
- for (i=0; i<m->bufcount; i++) {
+ for (i = 0; i < m->bufcount; i++) {
m->buflens[i] = NTOH__u32(m->buflens[i]);
required_len += size_round(m->buflens[i]);
}
- if (len < required_len) {
+ if (len < required_len) {
+ CERROR("len: %d, required_len %d\n", len, required_len);
RETURN(-EINVAL);
}
- EXIT;
- return 0;
+ RETURN(0);
}
-void *lustre_msg_buf(int n, struct lustre_msg *m)
+void *lustre_msg_buf(struct lustre_msg *m, int n)
{
- int i;
- int offset;
+ int i, offset;
- if (n >= m->bufcount || n < 0) {
- CERROR("referencing bad sub buffer!\n");
+ if (n < 0 || n >= m->bufcount) {
+ CERROR("referencing bad sub buffer!\n");
+ LBUG();
return NULL;
}
offset = sizeof(*m) + m->bufcount * sizeof(__u32);
- for (i=0; i < n; i++ )
- offset += size_round(m->buflens[i]);
+ for (i = 0; i < n; i++)
+ offset += size_round(m->buflens[i]);
return (char *)m + offset;
}
{
int rc = 0;
- spin_lock(&svc->srv_lock);
+ spin_lock(&svc->srv_lock);
if (sigismember(&(current->pending.signal), SIGKILL) ||
sigismember(&(current->pending.signal), SIGTERM) ||
- sigismember(&(current->pending.signal), SIGINT)) {
+ sigismember(&(current->pending.signal), SIGINT)) {
svc->srv_flags |= SVC_KILLED;
GOTO(out, rc = 1);
}
int err;
err = PtlEQGet(svc->srv_eq_h, &svc->srv_ev);
- if (err == PTL_OK) {
+ if (err == PTL_OK) {
svc->srv_flags |= SVC_EVENT;
GOTO(out, rc = 1);
}
EXIT;
out:
- spin_unlock(&svc->srv_lock);
+ spin_unlock(&svc->srv_lock);
return rc;
}
int rc, i;
struct ptlrpc_service *service;
- OBD_ALLOC(service, sizeof(*service));
- if ( !service ) {
+ OBD_ALLOC(service, sizeof(*service));
+ if (!service) {
LBUG();
RETURN(NULL);
}
- memset(service, 0, sizeof(*service));
-
spin_lock_init(&service->srv_lock);
INIT_LIST_HEAD(&service->srv_reqs);
- init_waitqueue_head(&service->srv_ctl_waitq);
- init_waitqueue_head(&service->srv_waitq);
+ init_waitqueue_head(&service->srv_ctl_waitq);
+ init_waitqueue_head(&service->srv_waitq);
service->srv_thread = NULL;
service->srv_flags = 0;
service->srv_handler = handler;
err = kportal_uuid_to_peer(uuid, &service->srv_self);
- if (err) {
- CERROR("cannot get peer for uuid %s", uuid);
- GOTO(err_free, NULL);
+ if (err) {
+ CERROR("cannot get peer for uuid %s", uuid);
+ GOTO(err_free, NULL);
}
service->srv_ring_length = RPC_RING_LENGTH;
service->srv_id.nid = PTL_ID_ANY;
service->srv_id.pid = PTL_ID_ANY;
- rc = PtlEQAlloc(service->srv_self.peer_ni, 128,
+ rc = PtlEQAlloc(service->srv_self.peer_ni, 128,
server_request_callback,
service, &(service->srv_eq_h));
LBUG();
GOTO(err_ring, NULL);
}
- service->srv_ref_count[i] = 0;
- ptlrpc_link_svc_me(service, i);
+ service->srv_ref_count[i] = 0;
+ ptlrpc_link_svc_me(service, i);
}
CDEBUG(D_NET, "Starting service listening on portal %d\n",
/* Record that the thread is running */
svc->srv_thread = current;
svc->srv_flags = SVC_RUNNING;
- wake_up(&svc->srv_ctl_waitq);
+ wake_up(&svc->srv_ctl_waitq);
/* XXX maintain a list of all managed devices: insert here */
/* And now, loop forever on requests */
while (1) {
wait_event(svc->srv_waitq, ptlrpc_check_event(svc));
-
+
spin_lock(&svc->srv_lock);
if (svc->srv_flags & SVC_SIGNAL) {
spin_unlock(&svc->srv_lock);
break;
}
- if (svc->srv_flags & SVC_EVENT) {
+ if (svc->srv_flags & SVC_EVENT) {
struct ptlrpc_request request;
void *start;
- svc->srv_flags = SVC_RUNNING;
+ svc->srv_flags = SVC_RUNNING;
/* FIXME: If we move to an event-driven model,
* we should put the request on the stack of
continue;
}
- if (svc->srv_flags & SVC_LIST) {
+ if (svc->srv_flags & SVC_LIST) {
struct ptlrpc_request *request;
- svc->srv_flags = SVC_RUNNING;
+ svc->srv_flags = SVC_RUNNING;
request = list_entry(svc->srv_reqs.next,
struct ptlrpc_request,
rc = svc->srv_handler(obddev, svc, request);
continue;
}
- CERROR("unknown break in service");
+ CERROR("unknown break in service");
spin_unlock(&svc->srv_lock);
EXIT;
- break;
+ break;
}
svc->srv_thread = NULL;
svc->srv_flags = SVC_STOPPING;
wake_up(&svc->srv_waitq);
- wait_event_interruptible(svc->srv_ctl_waitq,
+ wait_event_interruptible(svc->srv_ctl_waitq,
(svc->srv_flags & SVC_STOPPED));
}
init_waitqueue_head(&svc->srv_waitq);
init_waitqueue_head(&svc->srv_ctl_waitq);
- rc = kernel_thread(ptlrpc_main, (void *) &d,
+ rc = kernel_thread(ptlrpc_main, (void *) &d,
CLONE_VM | CLONE_FS | CLONE_FILES);
if (rc < 0) {
- CERROR("cannot start thread\n");
+ CERROR("cannot start thread\n");
RETURN(-EINVAL);
}
wait_event(svc->srv_ctl_waitq, svc->srv_flags & SVC_RUNNING);
setup
setup_portals
-new_fs ext2 /tmp/ost 25000
+new_fs ext2 /tmp/ost 10000
OST=$LOOPDEV
MDSFS=ext2
new_fs ${MDSFS} /tmp/mds 10000
umount /mnt/obd
+killall acceptor
rmmod llight
rmmod mdc
rmmod kqswnal
rmmod ksocknal
-killall acceptor
rmmod portals
losetup -d ${LOOP}0
git://git.whamcloud.com / fs / lustre-release.git / commitdiff