From 8a6e1551ccd24d53d1002731620670351d8734c8 Mon Sep 17 00:00:00 2001 From: braam Date: Tue, 19 Feb 2002 16:43:53 +0000 Subject: [PATCH] This adds most of the metadata infrastructure: I think that all commands (mkdir, link, symlink, rm, rmdir, mknod, mv etc) now work. Probably the server code is not multithread safe (particularly for renames, the others might be OK). I expect other fragilities and perhaps some errors with setting {a,m,c}times, owners etc. - add the beginning of an obd command that prints the information for UML gdb (class/class_obd.c) - try to ignore errors on creating symbolic links in Makefiles - the patch is 2.4.17 again for ext2obd, ghees, let's fix that. - to avoid confusion, null out the buffer of result nio's in prepw - add other reintegration functions. --- lustre/include/linux/lustre_idl.h | 34 ++++++- lustre/include/linux/lustre_lib.h | 27 +++++ lustre/include/linux/lustre_light.h | 3 +- lustre/include/linux/lustre_mds.h | 29 +++++- lustre/lib/mds_updates.c | 136 +++++++++++++++++++++++-- lustre/llite/dir.c | 2 + lustre/llite/namei.c | 141 +++++++++++++++++++++----- lustre/llite/rw.c | 15 +-- lustre/llite/super.c | 7 +- lustre/mdc/mdc_reint.c | 112 ++++++++++++++++++++- lustre/mdc/mdc_request.c | 8 +- lustre/mds/mds_reint.c | 195 +++++++++++++++++++++++++++++++++--- lustre/obdclass/class_obd.c | 24 +++++ lustre/patches/patch-2.4.17 | 1 + 14 files changed, 667 insertions(+), 67 deletions(-) diff --git a/lustre/include/linux/lustre_idl.h b/lustre/include/linux/lustre_idl.h index 14c7f55..dba1809 100644 --- a/lustre/include/linux/lustre_idl.h +++ b/lustre/include/linux/lustre_idl.h @@ -182,7 +182,10 @@ struct obd_ioobj { #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; @@ -243,9 +246,7 @@ struct mds_rep { __u64 objid; }; - /* MDS update records */ - struct mds_update_record_hdr { __u32 ur_reclen; __u32 ur_opcode; @@ -277,7 +278,33 @@ struct mds_rec_create { /* 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__ @@ -503,6 +530,7 @@ static inline int obd_ioctl_getdata(char *buf, char *end, void *arg) #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 ) diff --git a/lustre/include/linux/lustre_lib.h b/lustre/include/linux/lustre_lib.h index a4dc7d7..9a9e928 100644 --- a/lustre/include/linux/lustre_lib.h +++ b/lustre/include/linux/lustre_lib.h @@ -52,6 +52,13 @@ static inline int size_round (int val) 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); @@ -142,17 +149,37 @@ do { \ */ #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 */ diff --git a/lustre/include/linux/lustre_light.h b/lustre/include/linux/lustre_light.h index e40877d..ba95417 100644 --- a/lustre/include/linux/lustre_light.h +++ b/lustre/include/linux/lustre_light.h @@ -18,10 +18,11 @@ #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 { diff --git a/lustre/include/linux/lustre_mds.h b/lustre/include/linux/lustre_mds.h index bd65d92..02222be 100644 --- a/lustre/include/linux/lustre_mds.h +++ b/lustre/include/linux/lustre_mds.h @@ -31,6 +31,13 @@ #include #include +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; @@ -94,7 +101,10 @@ int mds_reint_rec(struct mds_update_record *r, struct ptlrpc_request *req); 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); @@ -107,10 +117,21 @@ int mdc_setattr(struct lustre_peer *peer, struct inode *inode, 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' diff --git a/lustre/lib/mds_updates.c b/lustre/lib/mds_updates.c index ad48e5c3..45317b5 100644 --- a/lustre/lib/mds_updates.c +++ b/lustre/lib/mds_updates.c @@ -35,12 +35,13 @@ /* 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); @@ -49,9 +50,12 @@ void mds_create_pack(struct mds_rec_create *rec, struct inode *inode, const char 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); + } } @@ -72,6 +76,52 @@ void mds_setattr_pack(struct mds_rec_setattr *rec, struct inode *inode, struct i 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) @@ -130,9 +180,76 @@ static int mds_create_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; } @@ -140,7 +257,10 @@ typedef int (*update_unpacker)(char *, int , struct mds_update_record *); 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) diff --git a/lustre/llite/dir.c b/lustre/llite/dir.c index 9265dac..92d2f1a 100644 --- a/lustre/llite/dir.c +++ b/lustre/llite/dir.c @@ -78,7 +78,9 @@ static int ext2_commit_chunk(struct page *page, unsigned from, unsigned to) { 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); diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c index 01df8cb..3dbb54c 100644 --- a/lustre/llite/namei.c +++ b/lustre/llite/namei.c @@ -134,20 +134,22 @@ static inline int ext2_match (int len, const char * const name, } 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); @@ -160,6 +162,7 @@ static struct inode *ll_create_node(struct inode *dir, const char *name, 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); @@ -185,6 +188,85 @@ static struct inode *ll_create_node(struct inode *dir, const char *name, 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 @@ -208,8 +290,8 @@ static int ll_create (struct inode * dir, struct dentry * dentry, int mode) 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)) { @@ -227,7 +309,8 @@ static int ll_create (struct inode * dir, struct dentry * dentry, int mode) 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); @@ -241,7 +324,7 @@ static int ll_symlink (struct inode * dir, struct dentry * dentry, { 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; @@ -249,26 +332,17 @@ static int ll_symlink (struct inode * dir, struct dentry * dentry, 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: @@ -280,11 +354,10 @@ out_fail: 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)) @@ -293,6 +366,13 @@ static int ll_link (struct dentry * old_dentry, struct inode * dir, 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); @@ -313,7 +393,7 @@ static int ll_mkdir(struct inode * dir, struct dentry * dentry, int mode) 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)) @@ -322,7 +402,7 @@ static int ll_mkdir(struct inode * dir, struct dentry * dentry, int mode) 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); @@ -359,6 +439,11 @@ static int ll_unlink(struct inode * dir, struct dentry *dentry) 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) @@ -399,6 +484,10 @@ static int ll_rename (struct inode * old_dir, struct dentry * old_dentry, 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; diff --git a/lustre/llite/rw.c b/lustre/llite/rw.c index 62f6cc2..7b6a167 100644 --- a/lustre/llite/rw.c +++ b/lustre/llite/rw.c @@ -190,11 +190,10 @@ static int ll_commit_page(struct page *page, int create, int from, int to) 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(); @@ -215,9 +214,9 @@ static int ll_commit_page(struct page *page, int create, int from, int to) 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"); @@ -271,7 +270,10 @@ int ll_readpage(struct file *file, struct page *page) } /* 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) { @@ -577,5 +579,6 @@ struct address_space_operations ll_aops = { struct address_space_operations ll_dir_aops = { - readpage: ll_dir_readpage + readpage: ll_dir_readpage, + prepare_write: ll_dir_prepare_write }; diff --git a/lustre/llite/super.c b/lustre/llite/super.c index 3afacea..8d62258 100644 --- a/lustre/llite/super.c +++ b/lustre/llite/super.c @@ -235,11 +235,14 @@ static int ll_attr2inode(struct inode * inode, struct iattr * attr) 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) diff --git a/lustre/mdc/mdc_reint.c b/lustre/mdc/mdc_reint.c index 3c9b939..15b490c 100644 --- a/lustre/mdc/mdc_reint.c +++ b/lustre/mdc/mdc_reint.c @@ -70,6 +70,7 @@ int mdc_setattr(struct lustre_peer *peer, 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) { @@ -78,8 +79,8 @@ int mdc_create(struct lustre_peer *peer, 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; @@ -89,7 +90,112 @@ int mdc_create(struct lustre_peer *peer, 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); diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c index ea996b6..8a438ff 100644 --- a/lustre/mdc/mdc_request.c +++ b/lustre/mdc/mdc_request.c @@ -303,8 +303,9 @@ static int request_ioctl(struct inode *inode, struct file *file, 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) { @@ -354,6 +355,9 @@ MODULE_DESCRIPTION("Lustre MDS Request Tester v1.0"); 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); diff --git a/lustre/mds/mds_reint.c b/lustre/mds/mds_reint.c index 1d44baa..0ae75bb 100644 --- a/lustre/mds/mds_reint.c +++ b/lustre/mds/mds_reint.c @@ -53,7 +53,7 @@ static int mds_reint_setattr(struct mds_update_record *rec, struct ptlrpc_reques inode_setattr(de->d_inode, &rec->ur_iattr); } - dput(de); + l_dput(de); EXIT; return 0; } @@ -77,20 +77,23 @@ static int mds_reint_create(struct mds_update_record *rec, 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; } @@ -99,6 +102,7 @@ static int mds_reint_create(struct mds_update_record *rec, de->d_inode->i_ino, rec->ur_name); dput(de); req->rq_rephdr->status = -ESTALE; + EXIT; return 0; } @@ -106,19 +110,17 @@ static int mds_reint_create(struct mds_update_record *rec, 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: @@ -127,10 +129,22 @@ static int mds_reint_create(struct mds_update_record *rec, 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); @@ -138,11 +152,168 @@ static int mds_reint_create(struct mds_update_record *rec, 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) diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c index cdd4be0..893162c 100644 --- a/lustre/obdclass/class_obd.c +++ b/lustre/obdclass/class_obd.c @@ -377,6 +377,30 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, } #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; diff --git a/lustre/patches/patch-2.4.17 b/lustre/patches/patch-2.4.17 index 411f6ed..2f249f0 100644 --- a/lustre/patches/patch-2.4.17 +++ b/lustre/patches/patch-2.4.17 @@ -33,6 +33,7 @@ +/* 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); -- 1.8.3.1