#define REINT_SETATTR 0
#define REINT_CREATE 1
-#define REINT_MAX 1
+#define REINT_LINK 2
+#define REINT_UNLINK 3
+#define REINT_RENAME 4
+#define REINT_MAX 4
struct ll_fid {
__u64 id;
__u64 objid;
};
-
/* MDS update records */
-
struct mds_update_record_hdr {
__u32 ur_reclen;
__u32 ur_opcode;
/* overloaded: id for create, tgtlen for symlink, rdev for mknod */
__u64 cr_id;
__u32 cr_namelen;
+ __u32 cr_tgtlen;
/* name here */
+ /* symlink target here */
+};
+
+struct mds_rec_link {
+ __u32 lk_reclen;
+ __u32 lk_opcode;
+ struct ll_fid lk_fid1;
+ struct ll_fid lk_fid2;
+ __u32 lk_namelen;
+};
+
+struct mds_rec_unlink {
+ __u32 ul_reclen;
+ __u32 ul_opcode;
+ struct ll_fid ul_fid1;
+ __u32 ul_namelen;
+};
+
+struct mds_rec_rename {
+ __u32 rn_reclen;
+ __u32 rn_opcode;
+ struct ll_fid rn_fid1;
+ struct ll_fid rn_fid2;
+ __u32 rn_namelen;
+ __u32 rn_tgtlen;
};
#ifdef __KERNEL__
#define OBD_IOC_MIGR _IOWR('f', 23, long)
#define OBD_IOC_PUNCH _IOWR('f', 24, long)
#define OBD_IOC_DEVICE _IOWR('f', 25, long)
+#define OBD_IOC_MODULE_DEBUG _IOWR('f', 26, long)
#define OBD_IOC_DEC_FS_USE_COUNT _IO ('f', 32 )
return (val + 3) & (~0x3);
}
+static inline int size_round0(int val)
+{
+ if (!val)
+ return 0;
+ return (val + 1 + 3) & (~0x3);
+}
+
static inline size_t round_strlen(char *fset)
{
return size_round(strlen(fset) + 1);
*/
#define UNLOGL(var,type,len,ptr,end) \
do { \
+ if (!len) { \
+ var = NULL; \
+ break; \
+ } \
var = (type *)ptr; \
ptr += size_round(len * sizeof(type)); \
if (ptr > end ) \
return -EFAULT; \
} while (0)
+#define UNLOGL0(var,type,len,ptr,end) \
+do { \
+ UNLOGL(var,type,len,ptr,end); \
+ if ( *((char *)ptr - size_round(len) + len - 1) != '\0')\
+ return -EFAULT; \
+} while (0)
+
#define LOGL(var,len,ptr) \
do { \
+ if (!len) break; \
memcpy((char *)ptr, (const char *)var, len); \
ptr += size_round(len); \
} while (0)
+#define LOGL0(var,len,ptr) \
+do { \
+ if (!len) break; \
+ memcpy((char *)ptr, (const char *)var, len); \
+ *((char *)(ptr) + len) = 0; \
+ ptr += size_round(len + 1); \
+} while (0)
+
#endif /* _LUSTRE_LIB_H */
#define LL_SUPER_MAGIC 0x0BD00BD0;
+#define LL_INLINESZ 60
struct ll_inode_info {
int lli_flags;
__u64 lli_objid;
- char lli_inline[OBD_INLINESZ];
+ char lli_inline[LL_INLINESZ];
};
struct ll_sb_info {
#include <linux/lustre_idl.h>
#include <linux/lustre_net.h>
+static inline void l_dput(struct dentry *de)
+{
+ if (!de || IS_ERR(de))
+ return;
+ dput(de);
+}
+
struct mds_run_ctxt {
struct vfsmount *pwdmnt;
struct dentry *pwd;
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);
+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, 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);
/* mds/handler.c */
struct dentry *mds_fid2dentry(struct mds_obd *mds, struct ll_fid *fid, struct vfsmount **mnt);
struct ptlrep_hdr **hdr);
int mdc_readpage(struct lustre_peer *peer, ino_t ino, int type, __u64 offset,
char *addr, struct mds_rep **rep, struct ptlrep_hdr **hdr);
-int mdc_create(struct lustre_peer *peer, struct inode *dir, const char *name,
- int namelen, int mode, __u64 id, __u32 uid,
- __u32 gid, __u64 time,
+int mdc_create(struct lustre_peer *peer,
+ struct inode *dir, const char *name, int namelen,
+ const char *tgt, int tgtlen,
+ int mode, __u64 id, __u32 uid, __u32 gid, __u64 time,
+ struct mds_rep **rep, struct ptlrep_hdr **hdr);
+int mdc_unlink(struct lustre_peer *peer,
+ struct inode *dir, const char *name, int namelen,
+ struct mds_rep **rep, struct ptlrep_hdr **hdr);
+int mdc_link(struct lustre_peer *peer, struct dentry *src,
+ struct inode *dir, const char *name, int namelen,
struct mds_rep **rep, struct ptlrep_hdr **hdr);
+int mdc_rename(struct lustre_peer *peer, struct inode *src,
+ struct inode *tgt, const char *old, int oldlen,
+ const char *new, int newlen,
+ struct mds_rep **rep, struct ptlrep_hdr **hdr);
/* ioctls for trying requests */
#define IOC_REQUEST_TYPE 'f'
/* 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)
+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)
{
char *tmp = (char *)rec + sizeof(*rec);
/* XXX do something about time, uid, gid */
rec->cr_reclen =
- HTON__u32(sizeof(*rec) + size_round(namelen + 1));
+ HTON__u32(sizeof(*rec) + size_round0(namelen) +
+ size_round0(tgtlen));
rec->cr_opcode = HTON__u32(REINT_CREATE);
ll_inode2fid(&rec->cr_fid, inode);
rec->cr_uid = HTON__u32(uid);
rec->cr_gid = HTON__u32(gid);
rec->cr_time = HTON__u64(time);
- rec->cr_namelen = namelen;
- LOGL(name, namelen, tmp);
- *tmp = '\0';
+ 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);
+ }
}
rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
}
+void mds_unlink_pack(struct mds_rec_unlink *rec,
+ struct inode *inode, const char *name, int namelen)
+{
+ 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);
+ 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)
+{
+ 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);
+}
+
+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)
+{
+ 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);
+ }
+}
+
/* unpacking */
static int mds_update_hdr_unpack(char *buf, int len, struct mds_update_record *r)
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__u64(rec->cr_namelen);
+ 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;
+}
+
+static int mds_link_unpack(char *buf, int len, struct mds_update_record *r)
+{
+ struct mds_rec_link *rec = (struct mds_rec_link *)buf;
+ char *ptr, *end;
+
+ if (len < sizeof(*rec)) {
+ printk(__FUNCTION__ "invalid buffer length\n");
+ return -EFAULT;
+ }
+
+ ptr = (char *)rec + sizeof(*rec);
+ end = ptr + len - sizeof(*rec);
+
+ 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;
+}
+
+
+static int mds_unlink_unpack(char *buf, int len, struct mds_update_record *r)
+{
+ struct mds_rec_unlink *rec = (struct mds_rec_unlink *)buf;
+ char *ptr, *end;
+ ENTRY;
+
+ if (len < sizeof(*rec)) {
+ printk(__FUNCTION__ "invalid buffer length\n");
+ return -EFAULT;
+ }
+
+ ptr = (char *)rec + sizeof(*rec);
+ end = ptr + len - sizeof(*rec);
+
+ r->ur_fid1 = &rec->ul_fid1;
+ r->ur_namelen = NTOH__u32(rec->ul_namelen);
+ UNLOGL0(r->ur_name, char, r->ur_namelen, ptr, end);
+ EXIT;
+ return 0;
+}
+
+static int mds_rename_unpack(char *buf, int len, struct mds_update_record *r)
+{
+ struct mds_rec_rename *rec = (struct mds_rec_rename *)buf;
+ char *ptr, *end;
+
+ if (len < sizeof(*rec)) {
+ printk(__FUNCTION__ "invalid buffer length\n");
+ return -EFAULT;
+ }
+
+ ptr = (char *)rec + sizeof(*rec);
+ end = ptr + len - sizeof(*rec);
+
+ 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);
- UNLOGL(r->ur_name, char, r->ur_namelen, ptr, end);
+ UNLOGL0(r->ur_name, char, r->ur_namelen, ptr, end);
+ UNLOGL0(r->ur_tgt, char, r->ur_tgtlen, ptr, end);
return 0;
}
static update_unpacker mds_unpackers[REINT_MAX + 1] = {
[REINT_SETATTR] mds_setattr_unpack,
- [REINT_CREATE] mds_create_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)
{
struct inode *dir = page->mapping->host;
int err = 0;
+
dir->i_version = ++event;
+ dir->i_size = (page->index << PAGE_CACHE_SHIFT) + to;
SetPageUptodate(page);
set_page_clean(page);
}
static struct inode *ll_create_node(struct inode *dir, const char *name,
- int namelen, int mode, __u64 id)
+ int namelen, const char *tgt, int tgtlen,
+ int mode, __u64 id)
{
struct inode *inode;
struct mds_rep *rep;
struct ptlrep_hdr *hdr;
int err;
+ time_t time = CURRENT_TIME;
struct ll_sb_info *sbi =
(struct ll_sb_info *)(&dir->i_sb->u.generic_sbp);
ENTRY;
- err = mdc_create(sbi->ll_peer_ptr, dir, name, namelen, mode, id,
- current->uid, current->gid, CURRENT_TIME,
- &rep, &hdr);
+ err = mdc_create(sbi->ll_peer_ptr, dir, name, namelen, tgt, tgtlen,
+ mode, id,
+ current->uid, current->gid, time, &rep, &hdr);
if (err) {
EXIT;
return ERR_PTR(err);
rep->objid = id;
rep->nlink = 1;
+ rep->atime = rep->ctime = rep->mtime = time;
rep->mode = mode;
printk("-- new_inode: objid %lld, ino %d, mode %o\n",
rep->objid, rep->ino, rep->mode);
return inode;
} /* ll_new_inode */
+int ll_mdc_unlink(struct inode *dir, const char *name, int len)
+{
+ struct mds_rep *rep;
+ struct ptlrep_hdr *hdr;
+ int err;
+ struct ll_sb_info *sbi =
+ (struct ll_sb_info *)(&dir->i_sb->u.generic_sbp);
+
+ ENTRY;
+
+ err = mdc_unlink(sbi->ll_peer_ptr, dir, name, len, &rep, &hdr);
+
+ if (err) {
+ EXIT;
+ return err;
+ }
+ if ( hdr->status) {
+ EXIT;
+ return hdr->status;
+ }
+
+ EXIT;
+ return 0;
+}
+
+int ll_mdc_link(struct dentry *src, struct inode *dir,
+ const char *name, int len)
+{
+ struct mds_rep *rep;
+ struct ptlrep_hdr *hdr;
+ int err;
+ struct ll_sb_info *sbi =
+ (struct ll_sb_info *)(&dir->i_sb->u.generic_sbp);
+
+ ENTRY;
+
+ err = mdc_link(sbi->ll_peer_ptr, src, dir, name, len, &rep, &hdr);
+
+ if (err) {
+ EXIT;
+ return err;
+ }
+ if ( hdr->status) {
+ EXIT;
+ return hdr->status;
+ }
+
+ EXIT;
+ return 0;
+}
+
+int ll_mdc_rename(struct inode *src, struct inode *tgt,
+ struct dentry *old, struct dentry *new)
+{
+ struct mds_rep *rep;
+ struct ptlrep_hdr *hdr;
+ int err;
+ struct ll_sb_info *sbi =
+ (struct ll_sb_info *)(&src->i_sb->u.generic_sbp);
+
+ ENTRY;
+
+ err = mdc_rename(sbi->ll_peer_ptr, src, tgt,
+ old->d_name.name, old->d_name.len,
+ new->d_name.name, new->d_name.len,
+ &rep, &hdr);
+
+ if (err) {
+ EXIT;
+ return err;
+ }
+ if ( hdr->status) {
+ EXIT;
+ return hdr->status;
+ }
+
+ EXIT;
+ return 0;
+}
/*
* By the time this is called, we already have created
mode = mode | S_IFREG;
printk("ll_create: name %s mode %o\n", dentry->d_name.name, mode);
- inode = ll_create_node(dir, dentry->d_name.name,
- dentry->d_name.len,
+ inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
+ NULL, 0,
mode, oa.o_id);
err = PTR_ERR(inode);
if (!IS_ERR(inode)) {
static int ll_mknod (struct inode * dir, struct dentry *dentry, int mode, int rdev)
{
struct inode * inode = ll_create_node(dir, dentry->d_name.name,
- dentry->d_name.len, mode, 0);
+ dentry->d_name.len, NULL, 0,
+ mode, 0);
int err = PTR_ERR(inode);
if (!IS_ERR(inode)) {
init_special_inode(inode, mode, rdev);
{
struct super_block * sb = dir->i_sb;
int err = -ENAMETOOLONG;
- unsigned l = strlen(symname)+1;
+ unsigned l = strlen(symname);
struct inode * inode;
struct ll_inode_info *oinfo;
goto out;
inode = ll_create_node(dir, dentry->d_name.name,
- dentry->d_name.len,
+ dentry->d_name.len, symname, l,
S_IFLNK | S_IRWXUGO, 0);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out;
oinfo = ll_i2info(inode);
- if (l >= sizeof(oinfo->lli_inline)) {
- /* slow symlink */
- inode->i_op = &page_symlink_inode_operations;
- inode->i_mapping->a_ops = &ll_aops;
- err = block_symlink(inode, symname, l);
- if (err)
- goto out_fail;
- } else {
- /* fast symlink */
- inode->i_op = &ll_fast_symlink_inode_operations;
- memcpy(oinfo->lli_inline, symname, l);
- inode->i_size = l-1;
- }
+
+ inode->i_op = &ll_fast_symlink_inode_operations;
+ memcpy(oinfo->lli_inline, symname, l);
+ inode->i_size = l-1;
err = ext2_add_nondir(dentry, inode);
out:
goto out;
}
-
-
static int ll_link (struct dentry * old_dentry, struct inode * dir,
struct dentry *dentry)
{
+ int err;
struct inode *inode = old_dentry->d_inode;
if (S_ISDIR(inode->i_mode))
if (inode->i_nlink >= EXT2_LINK_MAX)
return -EMLINK;
+ err = ll_mdc_link(old_dentry, dir,
+ dentry->d_name.name, dentry->d_name.len);
+ if (err) {
+ EXIT;
+ return err;
+ }
+
inode->i_ctime = CURRENT_TIME;
ext2_inc_count(inode);
atomic_inc(&inode->i_count);
ext2_inc_count(dir);
inode = ll_create_node (dir, dentry->d_name.name,
- dentry->d_name.len,
+ dentry->d_name.len, NULL, 0,
S_IFDIR | mode, 0);
err = PTR_ERR(inode);
if (IS_ERR(inode))
inode->i_op = &ll_dir_inode_operations;
inode->i_fop = &ll_dir_operations;
inode->i_mapping->a_ops = &ll_aops;
-
+ inode->i_nlink = 1;
ext2_inc_count(inode);
err = ext2_make_empty(inode, dir);
de = ext2_find_entry (dir, dentry, &page);
if (!de)
goto out;
+
+ err = ll_mdc_unlink(dir, dentry->d_name.name, dentry->d_name.len);
+ if (err)
+ goto out;
+
err = ext2_delete_entry (de, page);
if (err)
struct ext2_dir_entry_2 * old_de;
int err = -ENOENT;
+ err = ll_mdc_rename(old_dir, new_dir, old_dentry, new_dentry);
+ if (err)
+ goto out;
+
old_de = ext2_find_entry (old_dir, old_dentry, &old_page);
if (!old_de)
goto out;
obd_count bufs_per_obdo = 1;
struct obdo *oa;
obd_size count = to;
- obd_off offset = (((obd_off)page->index) << PAGE_SHIFT);
+ obd_off offset = (((obd_off)page->index) << PAGE_SHIFT) + to;
obd_flag flags = create ? OBD_BRW_CREATE : 0;
int err;
struct iattr iattr;
- loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
ENTRY;
oa = obdo_alloc();
set_page_clean(page);
}
- if (pos > inode->i_size) {
+ if (offset > inode->i_size) {
iattr.ia_valid = ATTR_SIZE;
- iattr.ia_size = inode->i_size;
+ iattr.ia_size = offset;
err = ll_inode_setattr(inode, &iattr);
if (err) {
printk("mds_inode_setattr failed; do something dramatic.\n");
} /* ll_readpage */
-
+int ll_dir_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
+{
+ return 0;
+}
/* returns the page unlocked, but with a reference */
int ll_dir_readpage(struct file *file, struct page *page)
{
struct address_space_operations ll_dir_aops = {
- readpage: ll_dir_readpage
+ readpage: ll_dir_readpage,
+ prepare_write: ll_dir_prepare_write
};
unsigned int ia_valid = attr->ia_valid;
int error = 0;
- if (ia_valid & ATTR_SIZE) {
+ if ((ia_valid & ATTR_SIZE) && attr->ia_size < inode->i_size ) {
error = vmtruncate(inode, attr->ia_size);
if (error)
goto out;
- }
+ } else if (ia_valid & ATTR_SIZE) {
+ inode->i_size = attr->ia_size;
+ }
+
if (ia_valid & ATTR_UID)
inode->i_uid = attr->ia_uid;
if (ia_valid & ATTR_GID)
int mdc_create(struct lustre_peer *peer,
struct inode *dir, const char *name, int namelen,
+ const char *tgt, int tgtlen,
int mode, __u64 id, __u32 uid, __u32 gid, __u64 time,
struct mds_rep **rep, struct ptlrep_hdr **hdr)
{
struct mds_rec_create *rec;
request = mds_prep_req(MDS_REINT, 0, NULL,
- sizeof(*rec) + size_round(namelen + 1),
- NULL);
+ sizeof(*rec) + size_round0(namelen) +
+ size_round0(tgtlen), NULL);
if (!request) {
printk("mdc_create: cannot pack\n");
return -ENOMEM;
sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
rec = mds_req_tgt(request->rq_req.mds);
- mds_create_pack(rec, dir, name, namelen, mode, id, uid, gid, time);
+ mds_create_pack(rec, dir, name, namelen, mode, id, uid, gid, time,
+ tgt, tgtlen);
+
+ rc = mdc_reint(peer, request);
+
+ if (rep) {
+ *rep = request->rq_rep.mds;
+ }
+ if (hdr) {
+ *hdr = request->rq_rephdr;
+ }
+
+ kfree(request);
+ return rc;
+}
+
+int mdc_unlink(struct lustre_peer *peer,
+ struct inode *dir, const char *name, int namelen,
+ struct mds_rep **rep, struct ptlrep_hdr **hdr)
+{
+ int rc;
+ struct ptlrpc_request *request;
+ struct mds_rec_unlink *rec;
+
+ request = mds_prep_req(MDS_REINT, 0, NULL,
+ sizeof(*rec) + size_round0(namelen), NULL);
+ if (!request) {
+ printk("mdc_unlink: cannot pack\n");
+ return -ENOMEM;
+ }
+
+ request->rq_replen =
+ sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+
+ rec = mds_req_tgt(request->rq_req.mds);
+ mds_unlink_pack(rec, dir, name, namelen);
+
+ rc = mdc_reint(peer, request);
+
+ if (rep) {
+ *rep = request->rq_rep.mds;
+ }
+ if (hdr) {
+ *hdr = request->rq_rephdr;
+ }
+
+ kfree(request);
+ return rc;
+}
+
+int mdc_link(struct lustre_peer *peer, struct dentry *src,
+ struct inode *dir, const char *name, int namelen,
+ struct mds_rep **rep, struct ptlrep_hdr **hdr)
+{
+ int rc;
+ struct ptlrpc_request *request;
+ struct mds_rec_link *rec;
+
+ request = mds_prep_req(MDS_REINT, 0, NULL,
+ sizeof(*rec) + size_round0(namelen), NULL);
+ if (!request) {
+ printk("mdc_link: cannot pack\n");
+ return -ENOMEM;
+ }
+
+ request->rq_replen =
+ sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+
+ rec = mds_req_tgt(request->rq_req.mds);
+ mds_link_pack(rec, src->d_inode, dir, name, namelen);
+
+ rc = mdc_reint(peer, request);
+
+ if (rep) {
+ *rep = request->rq_rep.mds;
+ }
+ if (hdr) {
+ *hdr = request->rq_rephdr;
+ }
+
+ kfree(request);
+ return rc;
+}
+
+int mdc_rename(struct lustre_peer *peer, struct inode *src,
+ struct inode *tgt, const char *old, int oldlen,
+ const char *new, int newlen,
+ struct mds_rep **rep, struct ptlrep_hdr **hdr)
+{
+ int rc;
+ struct ptlrpc_request *request;
+ struct mds_rec_rename *rec;
+
+ request = mds_prep_req(MDS_REINT, 0, NULL,
+ sizeof(*rec) + size_round0(oldlen)
+ + size_round0(newlen), NULL);
+ if (!request) {
+ printk("mdc_link: cannot pack\n");
+ return -ENOMEM;
+ }
+
+ request->rq_replen =
+ sizeof(struct ptlrep_hdr) + sizeof(struct mds_rep);
+
+ rec = mds_req_tgt(request->rq_req.mds);
+ mds_rename_pack(rec, src, tgt, old, oldlen, new, newlen);
rc = mdc_reint(peer, request);
iattr.ia_atime = 0;
iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
- err = mdc_create(peer_ptr, &inode, "foofile",
- strlen("foofile"), 0100707, 47114711,
+ err = mdc_create(peer_ptr, &inode,
+ "foofile", strlen("foofile"),
+ NULL, 0, 0100707, 47114711,
11, 47, 0, NULL, &hdr);
printk("-- done err %d\n", err);
if (!err) {
MODULE_LICENSE("GPL");
EXPORT_SYMBOL(mdc_create);
+EXPORT_SYMBOL(mdc_unlink);
+EXPORT_SYMBOL(mdc_rename);
+EXPORT_SYMBOL(mdc_link);
EXPORT_SYMBOL(mdc_getattr);
EXPORT_SYMBOL(mdc_readpage);
EXPORT_SYMBOL(mdc_setattr);
inode_setattr(de->d_inode, &rec->ur_iattr);
}
- dput(de);
+ l_dput(de);
EXIT;
return 0;
}
struct mds_rep *rep = req->rq_rep.mds;
struct dentry *dchild;
int rc;
+ ENTRY;
de = mds_fid2dentry(req->rq_obd, rec->ur_fid1, &mnt);
if (IS_ERR(de)) {
req->rq_rephdr->status = -ESTALE;
+ EXIT;
return 0;
}
printk("mds_reint_create: ino %ld\n", de->d_inode->i_ino);
- dchild = lookup_one_len(rec->ur_name, de, rec->ur_namelen);
+ dchild = lookup_one_len(rec->ur_name, de, rec->ur_namelen - 1);
rc = PTR_ERR(dchild);
if (IS_ERR(dchild)) {
printk(__FUNCTION__ "child lookup error %d\n", rc);
dput(de);
req->rq_rephdr->status = -ESTALE;
+ EXIT;
return 0;
}
de->d_inode->i_ino, rec->ur_name);
dput(de);
req->rq_rephdr->status = -ESTALE;
+ EXIT;
return 0;
}
case S_IFREG: {
rc = vfs_create(de->d_inode, dchild, rec->ur_mode);
- if (!rc) {
- mds_store_objid(dchild->d_inode, &rec->ur_id);
- dchild->d_inode->i_atime = rec->ur_time;
- dchild->d_inode->i_ctime = rec->ur_time;
- dchild->d_inode->i_mtime = rec->ur_time;
- dchild->d_inode->i_uid = rec->ur_uid;
- dchild->d_inode->i_gid = rec->ur_gid;
- rep->ino = dchild->d_inode->i_ino;
- }
+ EXIT;
break;
}
case S_IFDIR: {
rc = vfs_mkdir(de->d_inode, dchild, rec->ur_mode);
+ EXIT;
+ break;
+ }
+ case S_IFLNK: {
+ rc = vfs_symlink(de->d_inode, dchild, rec->ur_tgt);
+ EXIT;
break;
}
case S_IFCHR:
case S_IFSOCK: {
int rdev = rec->ur_id;
rc = vfs_mknod(de->d_inode, dchild, rec->ur_mode, rdev);
+ EXIT;
break;
}
}
+
req->rq_rephdr->status = rc;
+ if (!rc) {
+ if (type == S_IFREG)
+ mds_store_objid(dchild->d_inode, &rec->ur_id);
+ dchild->d_inode->i_atime = rec->ur_time;
+ dchild->d_inode->i_ctime = rec->ur_time;
+ dchild->d_inode->i_mtime = rec->ur_time;
+ dchild->d_inode->i_uid = rec->ur_uid;
+ dchild->d_inode->i_gid = rec->ur_gid;
+ rep->ino = dchild->d_inode->i_ino;
+ }
dput(de);
dput(dchild);
return 0;
}
+static int mds_reint_unlink(struct mds_update_record *rec,
+ struct ptlrpc_request *req)
+{
+ struct vfsmount *mnt;
+ struct dentry *de;
+ struct dentry *dchild;
+ int rc;
+ ENTRY;
+
+ de = mds_fid2dentry(req->rq_obd, rec->ur_fid1, &mnt);
+ if (IS_ERR(de)) {
+ req->rq_rephdr->status = -ESTALE;
+ EXIT;
+ return 0;
+ }
+ printk("mds_reint_create: ino %ld\n", de->d_inode->i_ino);
+
+ dchild = lookup_one_len(rec->ur_name, de, rec->ur_namelen - 1);
+ rc = PTR_ERR(dchild);
+ if (IS_ERR(dchild)) {
+ printk(__FUNCTION__ ": child lookup error %d\n", rc);
+ dput(de);
+ req->rq_rephdr->status = -ESTALE;
+ EXIT;
+ return 0;
+ }
+
+ if (!dchild->d_inode) {
+ printk(__FUNCTION__ ": child doesn't exist (dir %ld, name %s\n",
+ de->d_inode->i_ino, rec->ur_name);
+ dput(de);
+ req->rq_rephdr->status = -ESTALE;
+ EXIT;
+ return 0;
+ }
+
+ switch (de->d_inode->i_mode & S_IFMT) {
+ case S_IFDIR:
+ rc = vfs_rmdir(de->d_inode, dchild);
+ EXIT;
+ break;
+ default:
+ rc = vfs_unlink(de->d_inode, dchild);
+
+ EXIT;
+ break;
+ }
+
+ req->rq_rephdr->status = rc;
+ dput(de);
+ dput(dchild);
+ EXIT;
+ return 0;
+}
+
+static int mds_reint_link(struct mds_update_record *rec,
+ struct ptlrpc_request *req)
+{
+ struct vfsmount *mnt;
+ struct dentry *de_src = NULL;
+ struct dentry *de_tgt_dir = NULL;
+ struct dentry *dchild = NULL;
+ int rc;
+ ENTRY;
+
+ rc = -ESTALE;
+ de_src = mds_fid2dentry(req->rq_obd, rec->ur_fid1, &mnt);
+ if (IS_ERR(de_src)) {
+ EXIT;
+ goto out_link;
+ }
+
+ de_tgt_dir = mds_fid2dentry(req->rq_obd, rec->ur_fid2, &mnt);
+ if (IS_ERR(de_tgt_dir)) {
+ rc = -ESTALE;
+ EXIT;
+ goto out_link;
+ }
+
+ dchild = lookup_one_len(rec->ur_name, de_tgt_dir, rec->ur_namelen - 1);
+ if (IS_ERR(dchild)) {
+ printk(__FUNCTION__ ": child lookup error %d\n", rc);
+ req->rq_rephdr->status = -ESTALE;
+ goto out_link;
+ }
+
+ if (dchild->d_inode) {
+ printk(__FUNCTION__ ": child exists (dir %ld, name %s\n",
+ de_tgt_dir->d_inode->i_ino, rec->ur_name);
+ EXIT;
+ goto out_link;
+ }
+
+ rc = vfs_link(de_src, de_tgt_dir->d_inode, dchild);
+
+ out_link:
+ req->rq_rephdr->status = rc;
+ l_dput(de_src);
+ l_dput(de_tgt_dir);
+ l_dput(dchild);
+ EXIT;
+ return 0;
+}
+
+
+static int mds_reint_rename(struct mds_update_record *rec,
+ struct ptlrpc_request *req)
+{
+ struct vfsmount *mnt;
+ struct dentry *de_srcdir = NULL;
+ struct dentry *de_tgtdir = NULL;
+ struct dentry *de_old = NULL;
+ struct dentry *de_new = NULL;
+ int rc;
+ ENTRY;
+
+ rc = -ESTALE;
+ de_srcdir = mds_fid2dentry(req->rq_obd, rec->ur_fid1, &mnt);
+ if (IS_ERR(de_srcdir)) {
+ EXIT;
+ goto out_rename;
+ }
+
+ de_tgtdir = mds_fid2dentry(req->rq_obd, rec->ur_fid2, &mnt);
+ if (IS_ERR(de_tgtdir)) {
+ rc = -ESTALE;
+ EXIT;
+ goto out_rename;
+ }
+
+ de_old = lookup_one_len(rec->ur_name, de_srcdir, rec->ur_namelen - 1);
+ if (IS_ERR(de_old)) {
+ printk(__FUNCTION__ "child lookup error %d\n", rc);
+ goto out_rename;
+ }
+
+ de_new = lookup_one_len(rec->ur_tgt, de_tgtdir, rec->ur_tgtlen - 1);
+ if (IS_ERR(de_new)) {
+ printk(__FUNCTION__ "child lookup error %d\n", rc);
+ goto out_rename;
+ }
+
+ rc = vfs_rename(de_srcdir->d_inode, de_old, de_tgtdir->d_inode, de_new);
+
+ out_rename:
+ req->rq_rephdr->status = rc;
+ l_dput(de_new);
+ l_dput(de_old);
+ l_dput(de_tgtdir);
+ l_dput(de_srcdir);
+ EXIT;
+ return 0;
+}
+
typedef int (*mds_reinter)(struct mds_update_record *, struct ptlrpc_request*);
static mds_reinter reinters[REINT_MAX+1] = {
[REINT_SETATTR] mds_reint_setattr,
- [REINT_CREATE] mds_reint_create
+ [REINT_CREATE] mds_reint_create,
+ [REINT_UNLINK] mds_reint_unlink,
+ [REINT_LINK] mds_reint_link,
+ [REINT_RENAME] mds_reint_rename
};
int mds_reint_rec(struct mds_update_record *rec, struct ptlrpc_request *req)
}
#if 0
+ case OBD_IOC_MODULE_DEBUG:
+ {
+ struct module *mod = module_list;
+ char *tmp = data->ioc_inlbuf1;
+ char line[128];
+
+ snprintf(line, 128, "symbol-file\n"
+ "symbol-file /usr/src/lum/linux\n"
+ "b panic\n"
+ "b stop\n");
+ tmp += strlen(line);
+
+ do {
+ sprintf(line,
+ "add-symbol-file /usr/src/obd/%s/%s.o %p\n",
+ mod->name, mod->name, mod);
+ memcpy(tmp, line, strlen(line));
+ tmp += strlen(line);
+ } while ( mod->next != NULL)
+
+ return copy_to_user((int *)arg, data, sizeof(*data) +
+ data->ioc_inllen1);
+ }
+
case OBD_IOC_SYNC: {
struct oic_range_s *range = tmp_buf;
+/* Lustre symbols */
+EXPORT_SYMBOL(pagecache_lock);
+EXPORT_SYMBOL(do_kern_mount);
++EXPORT_SYMBOL(module_list);
+EXPORT_SYMBOL(sys_mkdir);
+EXPORT_SYMBOL(sys_rmdir);
+EXPORT_SYMBOL(sys_unlink);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff