From abc7c1748d03ad3027c7779a25a791a2d5b2087a Mon Sep 17 00:00:00 2001 From: mfrey Date: Wed, 8 Oct 2003 19:16:10 +0000 Subject: [PATCH] updated from parent (b_llp_hp) --- lustre/include/linux/lvfs.h | 20 +- .../patches/ext3-raw-lookup-pdirops.patch | 63 ++ .../patches/nfs_export_kernel-2.4.18.patch | 752 +++++++++++++++++++++ .../kernel_patches/pc/ext3-raw-lookup-pdirops.pc | 2 + .../kernel_patches/pc/nfs_export_kernel-2.4.18.pc | 9 + lustre/lvfs/fsfilt_ext3.c | 32 +- lustre/lvfs/fsfilt_extN.c | 4 + lustre/lvfs/fsfilt_reiserfs.c | 14 +- 8 files changed, 885 insertions(+), 11 deletions(-) create mode 100644 lustre/kernel_patches/patches/ext3-raw-lookup-pdirops.patch create mode 100644 lustre/kernel_patches/patches/nfs_export_kernel-2.4.18.patch create mode 100644 lustre/kernel_patches/pc/ext3-raw-lookup-pdirops.pc create mode 100644 lustre/kernel_patches/pc/nfs_export_kernel-2.4.18.pc diff --git a/lustre/include/linux/lvfs.h b/lustre/include/linux/lvfs.h index 8ea973f..7a8525c 100644 --- a/lustre/include/linux/lvfs.h +++ b/lustre/include/linux/lvfs.h @@ -78,10 +78,26 @@ static inline struct dentry *ll_lookup_one_len(char *fid_name, int fid_namelen) { struct dentry *dchild; +#ifdef S_PDIROPS + unsigned long hash; + void *lock = NULL; + + if (IS_PDIROPS(dparent->d_inode)) { + hash = full_name_hash(fid_name, fid_namelen); + lock = dynlock_lock(&dparent->d_inode->i_dcache_lock, + hash, 1, GFP_ATOMIC); + } else +#endif + down(&dparent->d_inode->i_sem); - down(&dparent->d_inode->i_sem); dchild = lookup_one_len(fid_name, dparent, fid_namelen); - up(&dparent->d_inode->i_sem); + +#ifdef S_PDIROPS + if (IS_PDIROPS(dparent->d_inode)) + dynlock_unlock(&dparent->d_inode->i_dcache_lock, lock); + else +#endif + up(&dparent->d_inode->i_sem); return dchild; } diff --git a/lustre/kernel_patches/patches/ext3-raw-lookup-pdirops.patch b/lustre/kernel_patches/patches/ext3-raw-lookup-pdirops.patch new file mode 100644 index 0000000..72a5156 --- /dev/null +++ b/lustre/kernel_patches/patches/ext3-raw-lookup-pdirops.patch @@ -0,0 +1,63 @@ + fs/ext3/namei.c | 31 +++++++++++++++++++++++++++++++ + include/linux/fs.h | 1 + + 2 files changed, 32 insertions(+) + +--- linux-2.4.18-p4smp1Guser/include/linux/fs.h~ext3-raw-lookup Thu Sep 25 15:59:59 2003 ++++ linux-2.4.18-p4smp1Guser-pschwan/include/linux/fs.h Thu Sep 25 15:59:59 2003 +@@ -911,6 +911,7 @@ struct inode_operations { + int (*create) (struct inode *,struct dentry *,int); + int (*create_it) (struct inode *,struct dentry *,int, struct lookup_intent *); + struct dentry * (*lookup) (struct inode *,struct dentry *); ++ int (*lookup_raw) (struct inode *, const char *, int, ino_t *); + struct dentry * (*lookup_it) (struct inode *,struct dentry *, struct lookup_intent *, int flags); + int (*link) (struct dentry *,struct inode *,struct dentry *); + int (*link_raw) (struct nameidata *,struct nameidata *); +--- linux-2.4.18-p4smp1Guser/fs/ext3/namei.c~ext3-raw-lookup Thu Sep 25 15:59:59 2003 ++++ linux-2.4.18-p4smp1Guser-pschwan/fs/ext3/namei.c Thu Sep 25 16:16:48 2003 +@@ -1121,6 +1121,36 @@ static struct dentry *ext3_lookup(struct + return NULL; + } + ++static int ext3_lookup_raw(struct inode *dir, const char *name, ++ int len, ino_t *data) ++{ ++ struct ext3_dir_entry_2 *de; ++ struct buffer_head *bh; ++ struct dentry parent; ++ struct dentry dentry; ++ void *lock = NULL; ++ ++ if (len > EXT3_NAME_LEN) ++ return -ENAMETOOLONG; ++ ++ parent.d_inode = dir; ++ dentry.d_parent = &parent; ++ dentry.d_name.name = name; ++ dentry.d_name.len = len; ++ ++ bh = ext3_find_entry(&dentry, &de, 0, &lock); ++ if (bh) { ++ unsigned long ino = le32_to_cpu(de->inode); ++ ext3_unlock_htree(dir, lock); ++ brelse (bh); ++ if (data) ++ *data = ino; ++ return 0; /* found name */ ++ } ++ ++ return -ENOENT; ++} ++ + #define S_SHIFT 12 + static unsigned char ext3_type_by_mode[S_IFMT >> S_SHIFT] = { + [S_IFREG >> S_SHIFT] EXT3_FT_REG_FILE, +@@ -2623,6 +2653,7 @@ static inline void ext3_unlock_htree(str + struct inode_operations ext3_dir_inode_operations = { + create: ext3_create, /* BKL held */ + lookup: ext3_lookup, /* BKL held */ ++ lookup_raw: ext3_lookup_raw, /* BKL held */ + link: ext3_link, /* BKL held */ + unlink: ext3_unlink, /* BKL held */ + symlink: ext3_symlink, /* BKL held */ + +_ diff --git a/lustre/kernel_patches/patches/nfs_export_kernel-2.4.18.patch b/lustre/kernel_patches/patches/nfs_export_kernel-2.4.18.patch new file mode 100644 index 0000000..413a814 --- /dev/null +++ b/lustre/kernel_patches/patches/nfs_export_kernel-2.4.18.patch @@ -0,0 +1,752 @@ + fs/Makefile | 3 + fs/file_table.c | 11 ++ + fs/inode.c | 23 ++++- + fs/namei.c | 12 ++ + fs/nfsd/nfsfh.c | 65 +++++++++++++- + fs/nfsd/vfs.c | 240 ++++++++++++++++++++++++++++++++++++++++++++++++----- + fs/super.c | 3 + include/linux/fs.h | 8 + + kernel/ksyms.c | 3 + 9 files changed, 333 insertions(+), 35 deletions(-) + +--- linux-2.4.18-p4smp1Guser/fs/Makefile~nfs_export_kernel-2.4.18 Thu Sep 25 00:45:26 2003 ++++ linux-2.4.18-p4smp1Guser-pschwan/fs/Makefile Thu Sep 25 00:45:56 2003 +@@ -9,7 +9,8 @@ + + O_TARGET := fs.o + +-export-objs := filesystems.o open.o dcache.o buffer.o inode.o ++export-objs := filesystems.o open.o dcache.o buffer.o inode.o namei.o \ ++ file_table.o + mod-subdirs := nls + + obj-y := open.o read_write.o devices.o file_table.o buffer.o \ +--- linux-2.4.18-p4smp1Guser/fs/file_table.c~nfs_export_kernel-2.4.18 Tue May 7 15:05:16 2002 ++++ linux-2.4.18-p4smp1Guser-pschwan/fs/file_table.c Thu Sep 25 00:22:15 2003 +@@ -82,7 +82,8 @@ struct file * get_empty_filp(void) + * and call the open function (if any). The caller must verify that + * inode->i_fop is not NULL. + */ +-int init_private_file(struct file *filp, struct dentry *dentry, int mode) ++int init_private_file_it(struct file *filp, struct dentry *dentry, int mode, ++ struct lookup_intent *it) + { + memset(filp, 0, sizeof(*filp)); + filp->f_mode = mode; +@@ -90,12 +91,20 @@ int init_private_file(struct file *filp, + filp->f_dentry = dentry; + filp->f_uid = current->fsuid; + filp->f_gid = current->fsgid; ++ if (it) ++ filp->f_it = it; + filp->f_op = dentry->d_inode->i_fop; + if (filp->f_op->open) + return filp->f_op->open(dentry->d_inode, filp); + else + return 0; + } ++EXPORT_SYMBOL(init_private_file_it); ++ ++int init_private_file(struct file *filp, struct dentry *dentry, int mode) ++{ ++ return init_private_file_it(filp, dentry, mode, NULL); ++} + + void fput(struct file * file) + { +--- linux-2.4.18-p4smp1Guser/fs/inode.c~nfs_export_kernel-2.4.18 Wed Sep 24 23:35:07 2003 ++++ linux-2.4.18-p4smp1Guser-pschwan/fs/inode.c Wed Sep 24 23:35:08 2003 +@@ -988,9 +988,10 @@ struct inode *igrab(struct inode *inode) + } + + +-struct inode *iget4(struct super_block *sb, unsigned long ino, find_inode_t find_actor, void *opaque) ++static inline struct inode *ifind(struct super_block *sb, unsigned long ino, ++ struct list_head *head, ++ find_inode_t find_actor, void *opaque) + { +- struct list_head * head = inode_hashtable + hash(sb,ino); + struct inode * inode; + + spin_lock(&inode_lock); +@@ -1003,6 +1004,24 @@ struct inode *iget4(struct super_block * + } + spin_unlock(&inode_lock); + ++ return NULL; ++} ++ ++struct inode *ilookup4(struct super_block *sb, unsigned long ino, ++ find_inode_t find_actor, void *opaque) ++{ ++ struct list_head * head = inode_hashtable + hash(sb,ino); ++ return ifind(sb, ino, head, find_actor, opaque); ++} ++ ++struct inode *iget4(struct super_block *sb, unsigned long ino, ++ find_inode_t find_actor, void *opaque) ++{ ++ struct list_head * head = inode_hashtable + hash(sb,ino); ++ struct inode *inode = ifind(sb, ino, head, find_actor, opaque); ++ if (inode) ++ return inode; ++ + /* + * get_new_inode() will do the right thing, re-trying the search + * in case it had to block at any point. +--- linux-2.4.18-p4smp1Guser/fs/namei.c~nfs_export_kernel-2.4.18 Wed Sep 24 23:35:07 2003 ++++ linux-2.4.18-p4smp1Guser-pschwan/fs/namei.c Thu Sep 25 00:49:00 2003 +@@ -22,6 +22,7 @@ + #include + #include + #include ++#include + + #include + #include +@@ -100,6 +101,7 @@ void intent_release(struct lookup_intent + it->it_op_release(it); + + } ++EXPORT_SYMBOL(intent_release); + + static void *lock_dir(struct inode *dir, struct qstr *name) + { +@@ -945,7 +947,8 @@ struct dentry * lookup_hash(struct qstr + + + /* SMP-safe */ +-struct dentry * lookup_one_len(const char * name, struct dentry * base, int len) ++struct dentry * lookup_one_len_it(const char * name, struct dentry * base, ++ int len, struct lookup_intent *it) + { + unsigned long hash; + struct qstr this; +@@ -965,11 +968,16 @@ struct dentry * lookup_one_len(const cha + } + this.hash = end_name_hash(hash); + +- return lookup_hash_it(&this, base, NULL); ++ return lookup_hash_it(&this, base, it); + access: + return ERR_PTR(-EACCES); + } + ++struct dentry * lookup_one_len(const char * name, struct dentry * base, int len) ++{ ++ return lookup_one_len_it(name, base, len, NULL); ++} ++ + /* + * namei() + * +--- linux-2.4.18-p4smp1Guser/fs/nfsd/nfsfh.c~nfs_export_kernel-2.4.18 Tue Jun 25 21:16:24 2002 ++++ linux-2.4.18-p4smp1Guser-pschwan/fs/nfsd/nfsfh.c Wed Sep 24 23:35:08 2003 +@@ -37,6 +37,15 @@ struct nfsd_getdents_callback { + int sequence; /* sequence counter */ + }; + ++static struct dentry *lookup_it(struct inode *inode, struct dentry * dentry) ++{ ++ if (inode->i_op->lookup_it) ++ return inode->i_op->lookup_it(inode, dentry, NULL, 0); ++ else ++ return inode->i_op->lookup(inode, dentry); ++ ++} ++ + /* + * A rather strange filldir function to capture + * the name matching the specified inode number. +@@ -76,6 +85,8 @@ static int nfsd_get_name(struct dentry * + int error; + struct file file; + struct nfsd_getdents_callback buffer; ++ struct lookup_intent it; ++ struct file *filp = NULL; + + error = -ENOTDIR; + if (!dir || !S_ISDIR(dir->i_mode)) +@@ -86,9 +97,37 @@ static int nfsd_get_name(struct dentry * + /* + * Open the directory ... + */ +- error = init_private_file(&file, dentry, FMODE_READ); +- if (error) ++ if (dentry->d_op && dentry->d_op->d_revalidate_it) { ++ if ((dentry->d_flags & DCACHE_NFSD_DISCONNECTED) && ++ (dentry->d_parent == dentry) ) { ++ it.it_op_release = NULL; ++ /* ++ * XXX Temporary Hack: Simulating init_private_file without ++ * f_op->open for disconnected dentry Since we don't have actual ++ * dentry->d_name to revalidate in revalidate_it() ++ */ ++ filp = &file; ++ memset(filp, 0, sizeof(*filp)); ++ filp->f_mode = FMODE_READ; ++ atomic_set(&filp->f_count, 1); ++ filp->f_dentry = dentry; ++ filp->f_uid = current->fsuid; ++ filp->f_gid = current->fsgid; ++ filp->f_op = dentry->d_inode->i_fop; ++ error = 0; ++ } else { ++ intent_init(&it, IT_OPEN, 0); ++ error = revalidate_it(dentry, &it); ++ if (error) ++ goto out; ++ error = init_private_file_it(&file, dentry, FMODE_READ, &it); ++ } ++ } else { ++ error = init_private_file_it(&file, dentry, FMODE_READ, NULL); ++ } ++ if (error) + goto out; ++ + error = -EINVAL; + if (!file.f_op->readdir) + goto out_close; +@@ -114,9 +153,13 @@ static int nfsd_get_name(struct dentry * + } + + out_close: +- if (file.f_op->release) ++ if (file.f_op->release && !filp) + file.f_op->release(dir, &file); + out: ++ if (dentry->d_op && ++ dentry->d_op->d_revalidate_it && ++ it.it_op_release && !filp) ++ intent_release(&it); + return error; + } + +@@ -275,7 +318,7 @@ struct dentry *nfsd_findparent(struct de + * it is well connected. But nobody returns different dentrys do they? + */ + down(&child->d_inode->i_sem); +- pdentry = child->d_inode->i_op->lookup(child->d_inode, tdentry); ++ pdentry = lookup_it(child->d_inode, tdentry); + up(&child->d_inode->i_sem); + d_drop(tdentry); /* we never want ".." hashed */ + if (!pdentry && tdentry->d_inode == NULL) { +@@ -307,6 +350,8 @@ struct dentry *nfsd_findparent(struct de + igrab(tdentry->d_inode); + pdentry->d_flags |= DCACHE_NFSD_DISCONNECTED; + } ++ if (child->d_op && child->d_op->d_revalidate_it) ++ pdentry->d_op = child->d_op; + } + if (pdentry == NULL) + pdentry = ERR_PTR(-ENOMEM); +@@ -465,6 +510,8 @@ find_fh_dentry(struct super_block *sb, _ + struct dentry *pdentry; + struct inode *parent; + ++ if (result->d_op && result->d_op->d_revalidate_it) ++ dentry->d_op = result->d_op; + pdentry = nfsd_findparent(dentry); + err = PTR_ERR(pdentry); + if (IS_ERR(pdentry)) +@@ -667,6 +714,11 @@ fh_verify(struct svc_rqst *rqstp, struct + + inode = dentry->d_inode; + ++ /* cache coherency for non-device filesystems */ ++ if (inode->i_op && inode->i_op->revalidate_it) { ++ inode->i_op->revalidate_it(dentry, NULL); ++ } ++ + /* Type check. The correct error return for type mismatches + * does not seem to be generally agreed upon. SunOS seems to + * use EISDIR if file isn't S_IFREG; a comment in the NFSv3 +@@ -905,8 +957,9 @@ out_negative: + dentry->d_parent->d_name.name, dentry->d_name.name); + goto out; + out_uptodate: +- printk(KERN_ERR "fh_update: %s/%s already up-to-date!\n", +- dentry->d_parent->d_name.name, dentry->d_name.name); ++ if(!dentry->d_parent->d_inode->i_op->mkdir_raw) ++ printk(KERN_ERR "fh_update: %s/%s already up-to-date!\n", ++ dentry->d_parent->d_name.name, dentry->d_name.name); + goto out; + } + +--- linux-2.4.18-p4smp1Guser/fs/nfsd/vfs.c~nfs_export_kernel-2.4.18 Tue Jul 22 21:06:36 2003 ++++ linux-2.4.18-p4smp1Guser-pschwan/fs/nfsd/vfs.c Thu Sep 25 00:07:41 2003 +@@ -77,6 +77,128 @@ struct raparms { + static struct raparms * raparml; + static struct raparms * raparm_cache; + ++static int link_raw(struct dentry *dold, struct dentry *ddir, ++ struct dentry *dnew) ++{ ++ int err; ++ ++ struct nameidata old_nd = { .dentry = dold }; ++ struct nameidata nd = { .dentry = ddir, .last = dnew->d_name }; ++ struct inode_operations *op = nd.dentry->d_inode->i_op; ++ err = op->link_raw(&old_nd, &nd); ++ d_instantiate(dnew, dold->d_inode); ++ if(dold->d_inode->i_op && dold->d_inode->i_op->revalidate_it) ++ dold->d_inode->i_op->revalidate_it(dnew, NULL); ++ ++ return err; ++} ++ ++static int unlink_raw(struct dentry *dentry, char *fname, int flen, ++ struct dentry *rdentry) ++{ ++ int err; ++ struct qstr last = { .name = fname, .len = flen }; ++ struct nameidata nd = { .dentry = dentry, .last = last }; ++ struct inode_operations *op = nd.dentry->d_inode->i_op; ++ err = op->unlink_raw(&nd); ++ if (!err) ++ d_delete(rdentry); ++ ++ return err; ++} ++ ++static int rmdir_raw(struct dentry *dentry, char *fname, int flen, ++ struct dentry *rdentry) ++{ ++ int err; ++ struct qstr last = { .name = fname, .len = flen }; ++ struct nameidata nd = { .dentry = dentry, .last = last }; ++ struct inode_operations *op = nd.dentry->d_inode->i_op; ++ err = op->rmdir_raw(&nd); ++ if(!err) { ++ rdentry->d_inode->i_flags |= S_DEAD; ++ d_delete(rdentry); ++ } ++ ++ return err; ++} ++ ++static int symlink_raw(struct dentry *dentry, char *fname, int flen, ++ char *path) ++{ ++ int err; ++ struct qstr last = { .name = fname, .len = flen }; ++ struct nameidata nd = { .dentry = dentry, .last = last }; ++ struct inode_operations *op = nd.dentry->d_inode->i_op; ++ err = op->symlink_raw(&nd, path); ++ ++ return err; ++} ++ ++static int mkdir_raw(struct dentry *dentry, char *fname, int flen, int mode) ++{ ++ int err; ++ struct qstr last = { .name = fname, .len = flen }; ++ struct nameidata nd = { .dentry = dentry, .last = last }; ++ struct inode_operations *op = nd.dentry->d_inode->i_op; ++ err = op->mkdir_raw(&nd, mode); ++ ++ return err; ++} ++ ++static int mknod_raw(struct dentry *dentry, char *fname, int flen, int mode, ++ dev_t dev) ++{ ++ int err; ++ struct qstr last = { .name = fname, .len = flen }; ++ struct nameidata nd = { .dentry = dentry, .last = last }; ++ struct inode_operations *op = nd.dentry->d_inode->i_op; ++ err = op->mknod_raw(&nd, mode, dev); ++ ++ return err; ++} ++ ++static int rename_raw(struct dentry *fdentry, struct dentry *tdentry, ++ struct dentry *odentry, struct dentry *ndentry) ++{ ++ int err; ++ ++ struct nameidata old_nd = { .dentry = fdentry, .last = odentry->d_name}; ++ struct nameidata new_nd = { .dentry = tdentry, .last = ndentry->d_name}; ++ struct inode_operations *op = old_nd.dentry->d_inode->i_op; ++ err = op->rename_raw(&old_nd, &new_nd); ++ d_move(odentry, ndentry); ++ ++ return err; ++} ++ ++static int setattr_raw(struct inode *inode, struct iattr *iap) ++{ ++ int err; ++ ++ iap->ia_valid |= ATTR_RAW; ++ err = inode->i_op->setattr_raw(inode, iap); ++ ++ return err; ++} ++ ++int revalidate_it(struct dentry *dentry, struct lookup_intent *it) ++{ ++ int err = 0; ++ ++ if (dentry && dentry->d_op && dentry->d_op->d_revalidate_it) { ++ if (!dentry->d_op->d_revalidate_it(dentry, 0, it) && ++ !d_invalidate(dentry)) { ++ dput(dentry); ++ err = -EINVAL; ++ dentry = NULL; ++ return err; ++ } ++ } ++ ++ return err; ++} ++ + /* + * Look up one component of a pathname. + * N.B. After this call _both_ fhp and resfh need an fh_put +@@ -300,7 +422,10 @@ nfsd_setattr(struct svc_rqst *rqstp, str + } + err = nfserr_notsync; + if (!check_guard || guardtime == inode->i_ctime) { +- err = notify_change(dentry, iap); ++ if ( dentry->d_inode->i_op && dentry->d_inode->i_op->setattr_raw) ++ err = setattr_raw(dentry->d_inode, iap); ++ else ++ err = notify_change(dentry, iap); + err = nfserrno(err); + } + if (size_change) { +@@ -427,6 +552,7 @@ nfsd_open(struct svc_rqst *rqstp, struct + { + struct dentry *dentry; + struct inode *inode; ++ struct lookup_intent it; + int err; + + /* If we get here, then the client has already done an "open", and (hopefully) +@@ -473,6 +599,14 @@ nfsd_open(struct svc_rqst *rqstp, struct + filp->f_mode = FMODE_READ; + } + ++ intent_init(&it, IT_OPEN, (filp->f_flags & ~O_ACCMODE) | filp->f_mode); ++ ++ err = revalidate_it(dentry, &it); ++ if (err) ++ goto out_nfserr; ++ ++ filp->f_it = ⁢ ++ + err = 0; + if (filp->f_op && filp->f_op->open) { + err = filp->f_op->open(inode, filp); +@@ -487,7 +621,11 @@ nfsd_open(struct svc_rqst *rqstp, struct + atomic_dec(&filp->f_count); + } + } ++ + out_nfserr: ++ if (it.it_op_release) ++ intent_release(&it); ++ + if (err) + err = nfserrno(err); + out: +@@ -824,7 +962,7 @@ nfsd_create(struct svc_rqst *rqstp, stru + { + struct dentry *dentry, *dchild; + struct inode *dirp; +- int err; ++ int err, error = -EOPNOTSUPP; + + err = nfserr_perm; + if (!flen) +@@ -840,20 +978,44 @@ nfsd_create(struct svc_rqst *rqstp, stru + dentry = fhp->fh_dentry; + dirp = dentry->d_inode; + ++ switch (type) { ++ case S_IFDIR: ++ if (dirp->i_op->mkdir_raw) ++ error = mkdir_raw(dentry, fname, flen, iap->ia_mode); ++ break; ++ case S_IFCHR: ++ case S_IFBLK: ++ case S_IFIFO: ++ case S_IFSOCK: ++ case S_IFREG: ++ if (dirp->i_op->mknod_raw) { ++ if (type == S_IFREG) ++ rdev = 0; ++ error = mknod_raw(dentry, fname, flen, iap->ia_mode, rdev); ++ } ++ break; ++ default: ++ printk("nfsd: bad file type %o in nfsd_create\n", type); ++ } ++ + err = nfserr_notdir; +- if(!dirp->i_op || !dirp->i_op->lookup) ++ if(!dirp->i_op || !(dirp->i_op->lookup || dirp->i_op->lookup_it)) + goto out; + /* + * Check whether the response file handle has been verified yet. + * If it has, the parent directory should already be locked. + */ +- if (!resfhp->fh_dentry) { +- /* called from nfsd_proc_mkdir, or possibly nfsd3_proc_create */ +- fh_lock(fhp); ++ if (!resfhp->fh_dentry || dirp->i_op->lookup_it) { ++ /* called from nfsd_proc_mkdir, or possibly nfsd3_proc_create ++ and nfsd_proc_create in case of lustre ++ */ ++ if (!resfhp->fh_dentry) ++ fh_lock(fhp); + dchild = lookup_one_len(fname, dentry, flen); + err = PTR_ERR(dchild); + if (IS_ERR(dchild)) + goto out_nfserr; ++ resfhp->fh_dentry = NULL; + err = fh_compose(resfhp, fhp->fh_export, dchild, fhp); + if (err) + goto out; +@@ -874,10 +1036,12 @@ nfsd_create(struct svc_rqst *rqstp, stru + * Make sure the child dentry is still negative ... + */ + err = nfserr_exist; +- if (dchild->d_inode) { +- dprintk("nfsd_create: dentry %s/%s not negative!\n", +- dentry->d_name.name, dchild->d_name.name); +- goto out; ++ if ( error == -EOPNOTSUPP) { ++ if (dchild->d_inode) { ++ dprintk("nfsd_create: dentry %s/%s not negative!\n", ++ dentry->d_name.name, dchild->d_name.name); ++ goto out; ++ } + } + + if (!(iap->ia_valid & ATTR_MODE)) +@@ -890,16 +1054,19 @@ nfsd_create(struct svc_rqst *rqstp, stru + err = nfserr_perm; + switch (type) { + case S_IFREG: +- err = vfs_create(dirp, dchild, iap->ia_mode); ++ if (error == -EOPNOTSUPP) ++ err = vfs_create(dirp, dchild, iap->ia_mode); + break; + case S_IFDIR: +- err = vfs_mkdir(dirp, dchild, iap->ia_mode); ++ if (error == -EOPNOTSUPP) ++ err = vfs_mkdir(dirp, dchild, iap->ia_mode); + break; + case S_IFCHR: + case S_IFBLK: + case S_IFIFO: + case S_IFSOCK: +- err = vfs_mknod(dirp, dchild, iap->ia_mode, rdev); ++ if (error == -EOPNOTSUPP) ++ err = vfs_mknod(dirp, dchild, iap->ia_mode, rdev); + break; + default: + printk("nfsd: bad file type %o in nfsd_create\n", type); +@@ -968,7 +1135,13 @@ nfsd_create_v3(struct svc_rqst *rqstp, s + /* Get all the sanity checks out of the way before + * we lock the parent. */ + err = nfserr_notdir; +- if(!dirp->i_op || !dirp->i_op->lookup) ++ if (dirp->i_op->mknod_raw) { ++ err = mknod_raw(dentry, fname, flen, iap->ia_mode, 0); ++ if (err && err != -EOPNOTSUPP) ++ goto out; ++ } ++ ++ if(!dirp->i_op || !(dirp->i_op->lookup || dirp->i_op->lookup_it)) + goto out; + fh_lock(fhp); + +@@ -1019,6 +1192,8 @@ nfsd_create_v3(struct svc_rqst *rqstp, s + case NFS3_CREATE_GUARDED: + err = nfserr_exist; + } ++ if(dirp->i_op->mknod_raw) ++ err = 0; + goto out; + } + +@@ -1125,7 +1300,7 @@ nfsd_symlink(struct svc_rqst *rqstp, str + struct iattr *iap) + { + struct dentry *dentry, *dnew; +- int err, cerr; ++ int err, cerr, error = -EOPNOTSUPP; + + err = nfserr_noent; + if (!flen || !plen) +@@ -1139,12 +1314,18 @@ nfsd_symlink(struct svc_rqst *rqstp, str + goto out; + fh_lock(fhp); + dentry = fhp->fh_dentry; ++ ++ if (dentry->d_inode->i_op->symlink_raw) ++ error = symlink_raw(dentry, fname, flen, path); ++ + dnew = lookup_one_len(fname, dentry, flen); + err = PTR_ERR(dnew); + if (IS_ERR(dnew)) + goto out_nfserr; + +- err = vfs_symlink(dentry->d_inode, dnew, path); ++ err = error; ++ if (err == -EOPNOTSUPP || !dentry->d_inode->i_op->symlink_raw) ++ err = vfs_symlink(dentry->d_inode, dnew, path); + if (!err) { + if (EX_ISSYNC(fhp->fh_export)) + nfsd_sync_dir(dentry); +@@ -1154,7 +1335,10 @@ nfsd_symlink(struct svc_rqst *rqstp, str + iap->ia_valid |= ATTR_CTIME; + iap->ia_mode = (iap->ia_mode&S_IALLUGO) + | S_IFLNK; +- err = notify_change(dnew, iap); ++ if (dnew->d_inode->i_op && dnew->d_inode->i_op->setattr_raw) ++ err = setattr_raw(dnew->d_inode, iap); ++ else ++ err = notify_change(dnew, iap); + if (!err && EX_ISSYNC(fhp->fh_export)) + write_inode_now(dentry->d_inode, 1); + } +@@ -1212,7 +1396,10 @@ nfsd_link(struct svc_rqst *rqstp, struct + dold = tfhp->fh_dentry; + dest = dold->d_inode; + +- err = vfs_link(dold, dirp, dnew); ++ if (dirp->i_op->link_raw) ++ err = link_raw(dold, ddir, dnew); ++ else ++ err = vfs_link(dold, dirp, dnew); + if (!err) { + if (EX_ISSYNC(ffhp->fh_export)) { + nfsd_sync_dir(ddir); +@@ -1298,7 +1485,10 @@ nfsd_rename(struct svc_rqst *rqstp, stru + err = nfserr_perm; + } else + #endif +- err = vfs_rename(fdir, odentry, tdir, ndentry); ++ if(fdir->i_op->rename_raw) ++ err = rename_raw(fdentry, tdentry, odentry, ndentry); ++ else ++ err = vfs_rename(fdir, odentry, tdir, ndentry); + unlock_kernel(); + if (!err && EX_ISSYNC(tfhp->fh_export)) { + nfsd_sync_dir(tdentry); +@@ -1320,7 +1510,7 @@ nfsd_rename(struct svc_rqst *rqstp, stru + fill_post_wcc(tfhp); + double_up(&tdir->i_sem, &fdir->i_sem); + ffhp->fh_locked = tfhp->fh_locked = 0; +- ++ + out: + return err; + } +@@ -1366,9 +1556,15 @@ nfsd_unlink(struct svc_rqst *rqstp, stru + err = nfserr_perm; + } else + #endif +- err = vfs_unlink(dirp, rdentry); ++ if (dirp->i_op->unlink_raw) ++ err = unlink_raw(dentry, fname, flen, rdentry); ++ else ++ err = vfs_unlink(dirp, rdentry); + } else { /* It's RMDIR */ +- err = vfs_rmdir(dirp, rdentry); ++ if (dirp->i_op->rmdir_raw) ++ err = rmdir_raw(dentry, fname, flen, rdentry); ++ else ++ err = vfs_rmdir(dirp, rdentry); + } + + dput(rdentry); +--- linux-2.4.18-p4smp1Guser/fs/super.c~nfs_export_kernel-2.4.18 Wed Sep 24 23:35:00 2003 ++++ linux-2.4.18-p4smp1Guser-pschwan/fs/super.c Wed Sep 24 23:35:08 2003 +@@ -27,6 +27,7 @@ + #include + #include + #include ++#include + + #include + +@@ -58,7 +59,7 @@ static DECLARE_MUTEX(lockfs_sem); + */ + + static struct file_system_type *file_systems; +-static rwlock_t file_systems_lock = RW_LOCK_UNLOCKED; ++rwlock_t file_systems_lock = RW_LOCK_UNLOCKED; + + /* WARNING: This can be used only if we _already_ own a reference */ + static void get_filesystem(struct file_system_type *fs) +--- linux-2.4.18-p4smp1Guser/include/linux/fs.h~nfs_export_kernel-2.4.18 Wed Sep 24 23:35:07 2003 ++++ linux-2.4.18-p4smp1Guser-pschwan/include/linux/fs.h Thu Sep 25 00:23:27 2003 +@@ -1147,6 +1147,9 @@ extern struct file *filp_open(const char + extern struct file * dentry_open(struct dentry *, struct vfsmount *, int); + extern struct file *dentry_open_it(struct dentry *dentry, struct vfsmount *mnt, + int flags, struct lookup_intent *it); ++extern int revalidate_it(struct dentry *dentry, struct lookup_intent *it); ++extern int init_private_file_it(struct file *filp, struct dentry *dentry, int mode, ++ struct lookup_intent *it); + extern int filp_close(struct file *, fl_owner_t id); + extern char * getname(const char *); + +@@ -1423,6 +1426,8 @@ extern void path_release(struct nameidat + extern int follow_down(struct vfsmount **, struct dentry **); + extern int follow_up(struct vfsmount **, struct dentry **); + extern struct dentry * lookup_one_len(const char *, struct dentry *, int); ++extern struct dentry * lookup_one_len_it(const char *, struct dentry *, int, ++ struct lookup_intent *); + extern struct dentry * lookup_hash(struct qstr *, struct dentry *); + #define user_path_walk(name,nd) __user_walk(name, LOOKUP_FOLLOW|LOOKUP_POSITIVE, nd) + #define user_path_walk_link(name,nd) __user_walk(name, LOOKUP_POSITIVE, nd) +@@ -1437,6 +1442,8 @@ extern ino_t iunique(struct super_block + + typedef int (*find_inode_t)(struct inode *, unsigned long, void *); + extern struct inode * iget4(struct super_block *, unsigned long, find_inode_t, void *); ++extern struct inode * ilookup4(struct super_block *, unsigned long, ++ find_inode_t, void *); + static inline struct inode *iget(struct super_block *sb, unsigned long ino) + { + return iget4(sb, ino, NULL, NULL); +@@ -1541,6 +1548,7 @@ extern int vfs_stat(char *, struct kstat + extern int vfs_lstat(char *, struct kstat *); + extern int vfs_fstat(unsigned int, struct kstat *); + ++extern rwlock_t file_systems_lock; + extern struct file_system_type *get_fs_type(const char *name); + extern struct super_block *get_super(kdev_t); + extern void drop_super(struct super_block *sb); +--- linux-2.4.18-p4smp1Guser/kernel/ksyms.c~nfs_export_kernel-2.4.18 Wed Sep 24 23:35:00 2003 ++++ linux-2.4.18-p4smp1Guser-pschwan/kernel/ksyms.c Wed Sep 24 23:35:08 2003 +@@ -156,6 +156,7 @@ EXPORT_SYMBOL(fget); + EXPORT_SYMBOL(igrab); + EXPORT_SYMBOL(iunique); + EXPORT_SYMBOL(iget4); ++EXPORT_SYMBOL(ilookup4); + EXPORT_SYMBOL(iput); + EXPORT_SYMBOL(inode_init_once); + EXPORT_SYMBOL(force_delete); +@@ -167,6 +168,7 @@ EXPORT_SYMBOL(path_walk); + EXPORT_SYMBOL(path_release); + EXPORT_SYMBOL(__user_walk); + EXPORT_SYMBOL(lookup_one_len); ++EXPORT_SYMBOL(lookup_one_len_it); + EXPORT_SYMBOL(lookup_hash); + EXPORT_SYMBOL(sys_close); + EXPORT_SYMBOL(sys_read); +@@ -630,6 +632,7 @@ EXPORT_SYMBOL(init_task_union); + + EXPORT_SYMBOL(tasklist_lock); + EXPORT_SYMBOL(pidhash); ++EXPORT_SYMBOL(file_systems_lock); + + /* for Linux-ABI */ + EXPORT_SYMBOL(do_fork); + +_ diff --git a/lustre/kernel_patches/pc/ext3-raw-lookup-pdirops.pc b/lustre/kernel_patches/pc/ext3-raw-lookup-pdirops.pc new file mode 100644 index 0000000..32892d6 --- /dev/null +++ b/lustre/kernel_patches/pc/ext3-raw-lookup-pdirops.pc @@ -0,0 +1,2 @@ +include/linux/fs.h +fs/ext3/namei.c diff --git a/lustre/kernel_patches/pc/nfs_export_kernel-2.4.18.pc b/lustre/kernel_patches/pc/nfs_export_kernel-2.4.18.pc new file mode 100644 index 0000000..622704f --- /dev/null +++ b/lustre/kernel_patches/pc/nfs_export_kernel-2.4.18.pc @@ -0,0 +1,9 @@ +fs/Makefile +fs/file_table.c +fs/inode.c +fs/namei.c +fs/nfsd/nfsfh.c +fs/nfsd/vfs.c +fs/super.c +include/linux/fs.h +kernel/ksyms.c diff --git a/lustre/lvfs/fsfilt_ext3.c b/lustre/lvfs/fsfilt_ext3.c index 501e43f..5fd532d 100644 --- a/lustre/lvfs/fsfilt_ext3.c +++ b/lustre/lvfs/fsfilt_ext3.c @@ -41,6 +41,7 @@ #endif #include #include +#include #include #include #include @@ -294,6 +295,10 @@ static int fsfilt_ext3_setattr(struct dentry *dentry, void *handle, /* Don't allow setattr to change file type */ iattr->ia_mode = (inode->i_mode & S_IFMT)|(iattr->ia_mode & ~S_IFMT); + /* We set these flags on the client, but have already checked perms + * so don't confuse inode_change_ok. */ + iattr->ia_valid &= ~(ATTR_MTIME_SET | ATTR_ATIME_SET); + if (inode->i_op->setattr) { rc = inode->i_op->setattr(dentry, iattr); } else { @@ -627,6 +632,20 @@ out: return err; } +static int fsfilt_ext3_setup(struct super_block *sb) +{ +#if 0 + EXT3_SB(sb)->dx_lock = fsfilt_ext3_dx_lock; + EXT3_SB(sb)->dx_unlock = fsfilt_ext3_dx_unlock; +#endif +#ifdef S_PDIROPS + CERROR("Enabling PDIROPS\n"); + set_opt(EXT3_SB(sb)->s_mount_opt, PDIROPS); + sb->s_flags |= S_PDIROPS; +#endif + return 0; +} + static struct fsfilt_operations fsfilt_ext3_ops = { fs_type: "ext3", fs_owner: THIS_MODULE, @@ -644,12 +663,11 @@ static struct fsfilt_operations fsfilt_ext3_ops = { fs_prep_san_write: fsfilt_ext3_prep_san_write, fs_write_record: fsfilt_ext3_write_record, fs_read_record: fsfilt_ext3_read_record, + fs_setup: fsfilt_ext3_setup, }; #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) -#warning "fsfilt_ext3_init() and fsfilt_ext3_exit() aren't called on 2.6. MUST be fixed" - static int __init fsfilt_ext3_init(void) { int rc; @@ -686,12 +704,14 @@ static void __exit fsfilt_ext3_exit(void) //rc = ext3_xattr_unregister(); } -MODULE_AUTHOR("Cluster File Systems, Inc. "); -MODULE_DESCRIPTION("Lustre ext3 Filesystem Helper v0.1"); -MODULE_LICENSE("GPL"); - module_init(fsfilt_ext3_init); module_exit(fsfilt_ext3_exit); +#else +#warning "FIXME: fsfilt_ext3_init() and fsfilt_ext3_exit() aren't called on 2.6" #endif +MODULE_AUTHOR("Cluster File Systems, Inc. "); +MODULE_DESCRIPTION("Lustre ext3 Filesystem Helper v0.1"); +MODULE_LICENSE("GPL"); + diff --git a/lustre/lvfs/fsfilt_extN.c b/lustre/lvfs/fsfilt_extN.c index 7141e45..bcc0bea 100644 --- a/lustre/lvfs/fsfilt_extN.c +++ b/lustre/lvfs/fsfilt_extN.c @@ -288,6 +288,10 @@ static int fsfilt_extN_setattr(struct dentry *dentry, void *handle, /* Don't allow setattr to change file type */ iattr->ia_mode = (inode->i_mode & S_IFMT)|(iattr->ia_mode & ~S_IFMT); + /* We set these flags on the client, but have already checked perms + * so don't confuse inode_change_ok. */ + iattr->ia_valid &= ~(ATTR_MTIME_SET | ATTR_ATIME_SET); + if (inode->i_op->setattr) { rc = inode->i_op->setattr(dentry, iattr); } else { diff --git a/lustre/lvfs/fsfilt_reiserfs.c b/lustre/lvfs/fsfilt_reiserfs.c index 3d118fc..00a670d 100644 --- a/lustre/lvfs/fsfilt_reiserfs.c +++ b/lustre/lvfs/fsfilt_reiserfs.c @@ -98,10 +98,18 @@ static int fsfilt_reiserfs_setattr(struct dentry *dentry, void *handle, iattr->ia_mode = inode->i_mode; } } - if (inode->i_op->setattr) + + /* We set these flags on the client, but have already checked perms + * so don't confuse inode_change_ok. */ + iattr->ia_valid &= ~(ATTR_MTIME_SET | ATTR_ATIME_SET); + + if (inode->i_op->setattr) { rc = inode->i_op->setattr(dentry, iattr); - else - rc = inode_setattr(inode, iattr); + } else { + rc = inode_change_ok(inode, iattr); + if (!rc) + rc = inode_setattr(inode, iattr); + } unlock_kernel(); -- 1.8.3.1