fs/Makefile | 3 fs/file_table.c | 11 ++ fs/inode.c | 23 ++++- fs/namei.c | 12 ++ fs/nfsd/export.c | 5 + fs/nfsd/nfsfh.c | 65 +++++++++++++- fs/nfsd/vfs.c | 235 ++++++++++++++++++++++++++++++++++++++++++++++++----- include/linux/fs.h | 11 ++ kernel/ksyms.c | 2 9 files changed, 333 insertions(+), 34 deletions(-) Index: linux-2.4.21-chaos/fs/file_table.c =================================================================== --- linux-2.4.21-chaos.orig/fs/file_table.c 2003-07-15 04:41:00.000000000 +0400 +++ linux-2.4.21-chaos/fs/file_table.c 2003-12-12 16:19:25.000000000 +0300 @@ -82,7 +82,8 @@ * 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 @@ 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) { Index: linux-2.4.21-chaos/fs/inode.c =================================================================== --- linux-2.4.21-chaos.orig/fs/inode.c 2003-12-12 16:18:15.000000000 +0300 +++ linux-2.4.21-chaos/fs/inode.c 2003-12-12 16:19:25.000000000 +0300 @@ -1054,9 +1054,10 @@ return inode; } -struct inode *iget4_locked(struct super_block *sb, unsigned long ino, find_inode_t find_actor, void *opaque) +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); @@ -1069,6 +1070,24 @@ } 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_locked(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. Index: linux-2.4.21-chaos/fs/Makefile =================================================================== --- linux-2.4.21-chaos.orig/fs/Makefile 2003-12-12 16:18:36.000000000 +0300 +++ linux-2.4.21-chaos/fs/Makefile 2003-12-12 16:19:25.000000000 +0300 @@ -9,7 +9,8 @@ O_TARGET := fs.o -export-objs := filesystems.o open.o dcache.o buffer.o dquot.o inode.o +export-objs := filesystems.o open.o dcache.o buffer.o dquot.o inode.o \ + namei.o file_table.o mod-subdirs := nls xfs obj-y := open.o read_write.o devices.o file_table.o buffer.o \ Index: linux-2.4.21-chaos/fs/namei.c =================================================================== --- linux-2.4.21-chaos.orig/fs/namei.c 2003-12-12 16:18:06.000000000 +0300 +++ linux-2.4.21-chaos/fs/namei.c 2003-12-12 16:19:25.000000000 +0300 @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -100,6 +101,7 @@ it->it_op_release(it); } +EXPORT_SYMBOL(intent_release); /* In order to reduce some races, while at the same time doing additional * checking and hopefully speeding things up, we copy filenames to the @@ -910,7 +912,8 @@ /* 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; @@ -930,11 +933,16 @@ } 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() * Index: linux-2.4.21-chaos/fs/nfsd/export.c =================================================================== --- linux-2.4.21-chaos.orig/fs/nfsd/export.c 2003-09-19 03:49:54.000000000 +0400 +++ linux-2.4.21-chaos/fs/nfsd/export.c 2003-12-12 16:19:25.000000000 +0300 @@ -223,6 +223,11 @@ inode = nd.dentry->d_inode; dev = inode->i_dev; ino = inode->i_ino; + if ((inode->i_sb->s_type->fs_flags & FS_NFSEXP_FSID) && + !(nxp->ex_flags & NFSEXP_FSID)) { + nxp->ex_dev = inode->i_sb->s_dev; + nxp->ex_flags |= NFSEXP_FSID; + } err = -EINVAL; exp = exp_get(clp, dev, ino); Index: linux-2.4.21-chaos/fs/nfsd/nfsfh.c =================================================================== --- linux-2.4.21-chaos.orig/fs/nfsd/nfsfh.c 2003-09-19 03:49:54.000000000 +0400 +++ linux-2.4.21-chaos/fs/nfsd/nfsfh.c 2003-12-12 16:19:25.000000000 +0300 @@ -36,6 +36,13 @@ 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); + return inode->i_op->lookup(inode, dentry); +} + /* * A rather strange filldir function to capture * the name matching the specified inode number. @@ -75,6 +84,8 @@ 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)) @@ -85,9 +96,37 @@ /* * 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: Simulate init_private_file without + * f_op->open for disconnected dentry as 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, FMODE_READ); + 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; @@ -113,9 +152,12 @@ } 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; } @@ -274,7 +317,7 @@ * 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 @@ pdentry->d_flags |= DCACHE_NFSD_DISCONNECTED; pdentry->d_op = child->d_op; } + if (child->d_op && child->d_op->d_revalidate_it) + pdentry->d_op = child->d_op; } if (pdentry == NULL) pdentry = ERR_PTR(-ENOMEM); @@ -464,6 +509,8 @@ 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)) @@ -672,6 +719,10 @@ 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 @@ 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; } Index: linux-2.4.21-chaos/fs/nfsd/vfs.c =================================================================== --- linux-2.4.21-chaos.orig/fs/nfsd/vfs.c 2003-09-19 03:49:54.000000000 +0400 +++ linux-2.4.21-chaos/fs/nfsd/vfs.c 2003-12-12 16:19:25.000000000 +0300 @@ -78,6 +78,127 @@ 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); + igrab(dold->d_inode); + 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)) { + err = -EINVAL; + return err; + } + } + + return err; +} + /* * Look up one component of a pathname. * N.B. After this call _both_ fhp and resfh need an fh_put @@ -303,7 +425,10 @@ } 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) { @@ -430,6 +555,7 @@ { 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) @@ -476,6 +602,18 @@ filp->f_mode = FMODE_READ; } +#ifndef O_OWNER_OVERRIDE +#define O_OWNER_OVERRIDE 0200000000 +#endif + intent_init(&it, IT_OPEN, (filp->f_flags & ~O_ACCMODE) | filp->f_mode | + O_OWNER_OVERRIDE); + + 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); @@ -490,6 +624,9 @@ } } out_nfserr: + if (it.it_op_release) + intent_release(&it); + if (err) err = nfserrno(err); out: @@ -821,7 +959,7 @@ { struct dentry *dentry, *dchild; struct inode *dirp; - int err; + int err, error = -EOPNOTSUPP; err = nfserr_perm; if (!flen) @@ -837,20 +975,47 @@ 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); + } + if (error && error != -EOPNOTSUPP) { + err = error; + goto out_nfserr; + } + 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; @@ -871,10 +1033,12 @@ * 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)) @@ -887,16 +1051,19 @@ 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); @@ -965,7 +1132,13 @@ /* 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_nfserr; + } + + if (!dirp->i_op || !(dirp->i_op->lookup || dirp->i_op->lookup_it)) goto out; fh_lock(fhp); @@ -1016,6 +1189,8 @@ case NFS3_CREATE_GUARDED: err = nfserr_exist; } + if (dirp->i_op->mknod_raw) + err = 0; goto out; } @@ -1122,7 +1297,7 @@ struct iattr *iap) { struct dentry *dentry, *dnew; - int err, cerr; + int err, cerr, error = -EOPNOTSUPP; err = nfserr_noent; if (!flen || !plen) @@ -1136,12 +1311,18 @@ 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); @@ -1148,7 +1329,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) err = nfserrno(err); else if (EX_ISSYNC(fhp->fh_export)) @@ -1211,7 +1392,10 @@ 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); @@ -1296,7 +1480,10 @@ 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); if (!err && EX_ISSYNC(tfhp->fh_export)) { nfsd_sync_dir(tdentry); nfsd_sync_dir(fdentry); @@ -1317,7 +1504,7 @@ fill_post_wcc(tfhp); double_up(&tdir->i_sem, &fdir->i_sem); ffhp->fh_locked = tfhp->fh_locked = 0; - + out: return err; } @@ -1363,9 +1550,15 @@ 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); Index: linux-2.4.21-chaos/include/linux/fs.h =================================================================== --- linux-2.4.21-chaos.orig/include/linux/fs.h 2003-12-12 16:19:23.000000000 +0300 +++ linux-2.4.21-chaos/include/linux/fs.h 2003-12-12 16:19:25.000000000 +0300 @@ -93,6 +93,8 @@ #define FS_SINGLE 8 /* Filesystem that can have only one superblock */ #define FS_NOMOUNT 16 /* Never mount from userland */ #define FS_LITTER 32 /* Keeps the tree in dcache */ +#define FS_NFSEXP_FSID 64 /* Use file system specific fsid for + * exporting non device filesystems. */ #define FS_ODD_RENAME 32768 /* Temporary stuff; will go away as soon * as nfs_rename() will be cleaned up */ @@ -1159,6 +1162,9 @@ struct nameidata *nd, struct lookup_intent *it); 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 *, struct dentry *dentry, int mode, + struct lookup_intent *it); extern int filp_close(struct file *, fl_owner_t id); extern char * getname(const char *); @@ -1458,6 +1464,8 @@ 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 *); extern struct dentry * lookup_hash(struct qstr *, struct dentry *); #define user_path_walk(name,nd) __user_walk(name, LOOKUP_FOLLOW|LOOKUP_POSITIVE, nd) @@ -1477,6 +1485,8 @@ extern struct inode * iget4_locked(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 *iget4(struct super_block *sb, unsigned long ino, find_inode_t find_actor, void *opaque) Index: linux-2.4.21-chaos/kernel/ksyms.c =================================================================== --- linux-2.4.21-chaos.orig/kernel/ksyms.c 2003-12-12 16:18:36.000000000 +0300 +++ linux-2.4.21-chaos/kernel/ksyms.c 2003-12-12 16:19:25.000000000 +0300 @@ -178,6 +178,7 @@ EXPORT_SYMBOL(igrab); EXPORT_SYMBOL(iunique); EXPORT_SYMBOL(iget4_locked); +EXPORT_SYMBOL(ilookup4); EXPORT_SYMBOL(unlock_new_inode); EXPORT_SYMBOL(iput); EXPORT_SYMBOL(inode_init_once); @@ -191,6 +192,7 @@ 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);