diff options
| -rw-r--r-- | target/linux/generic-2.6/patches-2.6.25/209-mini_fo.patch | 652 | ||||
| -rw-r--r-- | target/linux/generic-2.6/patches-2.6.25/210-mini_fo_2.6.25_fixes.patch | 151 |
2 files changed, 477 insertions, 326 deletions
diff --git a/target/linux/generic-2.6/patches-2.6.25/209-mini_fo.patch b/target/linux/generic-2.6/patches-2.6.25/209-mini_fo.patch index b76cf69..54c2c8d 100644 --- a/target/linux/generic-2.6/patches-2.6.25/209-mini_fo.patch +++ b/target/linux/generic-2.6/patches-2.6.25/209-mini_fo.patch @@ -5,7 +5,7 @@ Index: linux-2.6.23/fs/Kconfig @@ -458,6 +458,9 @@ This option will enlarge your kernel, but it allows debugging of ocfs2 filesystem issues. - + +config MINI_FO + tristate "Mini fanout overlay filesystem" + @@ -64,11 +64,11 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + check_mini_fo_dentry(dentry); + if(dtost(dentry) == MODIFIED || dtost(dentry) == CREATED || dtost(dentry) == DEL_REWRITTEN) + return 1; -+ return 0; ++ return 0; +} + +/* check if dentry is in an existing state */ -+int is_mini_fo_existant(dentry_t *dentry) ++int is_mini_fo_existant(dentry_t *dentry) +{ + check_mini_fo_dentry(dentry); + @@ -78,12 +78,12 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + return 1; +} + -+/* -+ * This function will create a negative storage dentry for ++/* ++ * This function will create a negative storage dentry for + * dentry, what is required for many create like options. + * It will create the storage structure if necessary. + */ -+int get_neg_sto_dentry(dentry_t *dentry) ++int get_neg_sto_dentry(dentry_t *dentry) +{ + int err = 0; + unsigned int len; @@ -106,18 +106,18 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + if(dtost(dentry->d_parent) == UNMODIFIED) { + /* build sto struct */ + err = build_sto_structure(dentry->d_parent->d_parent, dentry->d_parent); -+ if(err || ++ if(err || + dtost(dentry->d_parent) != MODIFIED) { + printk(KERN_CRIT "mini_fo: get_neg_sto_dentry: ERROR building sto structure.\n"); + err = -1; + goto out; -+ } ++ } + } + + len = dentry->d_name.len; + name = dentry->d_name.name; -+ -+ dtohd2(dentry) = ++ ++ dtohd2(dentry) = + lookup_one_len(name, dtohd2(dentry->d_parent), len); + + out: @@ -129,7 +129,7 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + ASSERT(dentry != NULL); + ASSERT(dtopd(dentry) != NULL); + ASSERT((dtohd(dentry) != NULL) || (dtohd2(dentry) != NULL)); -+ ++ +/* if(dtost(dentry) == MODIFIED) { */ +/* ASSERT(dentry->d_inode != NULL); */ +/* ASSERT(dtohd(dentry) != NULL); */ @@ -141,7 +141,7 @@ Index: linux-2.6.23/fs/mini_fo/aux.c +/* ASSERT(dentry->d_inode != NULL); */ +/* ASSERT( */ +/* } */ -+ return 0; ++ return 0; +} + +int check_mini_fo_file(file_t *file) @@ -149,8 +149,8 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + ASSERT(file != NULL); + ASSERT(ftopd(file) != NULL); + ASSERT(file->f_dentry != NULL); -+ -+ /* violent checking, check depending of state and type ++ ++ /* violent checking, check depending of state and type + * if(S_ISDIR(file->f_dentry->d_inode->i_mode)) {} + */ + ASSERT((ftohf(file) != NULL) || (ftohf2(file) != NULL)); @@ -165,13 +165,13 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + return 0; +} + -+/* ++/* + * will walk a base path as provided by get_mini_fo_bpath and return + * the (hopefully ;-) ) positive dentry of the renamed base dir. + * + * This does some work of path_init. + */ -+dentry_t *bpath_walk(super_block_t *sb, char *bpath) ++dentry_t *bpath_walk(super_block_t *sb, char *bpath) +{ + int err; + struct vfsmount *mnt; @@ -186,20 +186,20 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + printk(KERN_CRIT "mini_fo: bpath_walk: Invalid sb.\n"); + return NULL; + } -+ -+ /* fix this: how do I reach this lock? ++ ++ /* fix this: how do I reach this lock? + * read_lock(¤t->fs->lock); */ + mnt = mntget(stopd(sb)->hidden_mnt); + /* read_unlock(¤t->fs->lock); */ -+ ++ + err = vfs_path_lookup(mnt->mnt_root, mnt, bpath+1, 0, &nd); + + /* validate */ -+ if (err || !nd.path.dentry || !nd.path.dentry->d_inode) { ++ if (err || !nd.dentry || !nd.dentry->d_inode) { + printk(KERN_CRIT "mini_fo: bpath_walk: path_walk failed.\n"); + return NULL; + } -+ return nd.path.dentry; ++ return nd.dentry; +} + + @@ -209,7 +209,7 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + char *buf_walker; + int len = 0; + dentry_t *sky_walker; -+ ++ + if(!dentry || !dtohd(dentry)) { + printk(KERN_CRIT "mini_fo: get_mini_fo_bpath: invalid dentry passed.\n"); + return -1; @@ -230,11 +230,11 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + buf_walker = *bpath+len; /* put it on last char */ + *buf_walker = '\n'; + sky_walker = dtohd(dentry); -+ ++ + do { + buf_walker -= sky_walker->d_name.len; -+ strncpy(buf_walker, -+ sky_walker->d_name.name, ++ strncpy(buf_walker, ++ sky_walker->d_name.name, + sky_walker->d_name.len); + *(--buf_walker) = '/'; + sky_walker = sky_walker->d_parent; @@ -311,9 +311,9 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + */ + bytes = len = PAGE_SIZE; + while(bytes == len) { -+ bytes = src_file->f_op->read(src_file, buf, len, ++ bytes = src_file->f_op->read(src_file, buf, len, + &src_file->f_pos); -+ tmp = tgt_file->f_op->write(tgt_file, buf, bytes, ++ tmp = tgt_file->f_op->write(tgt_file, buf, bytes, + &tgt_file->f_pos); + if(tmp != bytes) { + printk(KERN_CRIT "mini_fo_cp_cont: ERROR writing.\n"); @@ -361,7 +361,7 @@ Index: linux-2.6.23/fs/mini_fo/aux.c +{ + struct ndl_entry *tmp_entry; + -+ tmp_entry = (struct ndl_entry *) ++ tmp_entry = (struct ndl_entry *) + kmalloc(sizeof(struct ndl_entry), GFP_KERNEL); + if(!tmp_entry) { + printk(KERN_CRIT "mini_fo: ndl_add_entry: out of mem.\n"); @@ -446,9 +446,9 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + + if(!hidden_sto_dentry) { + /* -+ * This is the case after creating the first ++ * This is the case after creating the first + * hidden_sto_dentry. -+ * After one negative storage_dentry, all pointers to ++ * After one negative storage_dentry, all pointers to + * hidden_storage dentries are set to NULL. We need to + * create the negative dentry before we create the storage + * file. @@ -496,7 +496,7 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + dput(dir); + return err; + } -+ ++ + /* everything ok! */ + if(!dtohd2(dentry)->d_inode) { + printk(KERN_CRIT "mini_fo: build_sto_structure: failed to create storage dir [2].\n"); @@ -518,9 +518,9 @@ Index: linux-2.6.23/fs/mini_fo/aux.c + itopd(dentry->d_inode)->deleted_list_size = -1; + itopd(dentry->d_inode)->renamed_list_size = -1; + meta_build_lists(dentry); -+ ++ + fist_copy_attr_all(dentry->d_inode, itohi2(dentry->d_inode)); -+ fist_copy_attr_timesizes(dir->d_inode, ++ fist_copy_attr_timesizes(dir->d_inode, + hidden_sto_dir_dentry->d_inode); + dir->d_inode->i_nlink++; + /* was: unlock_dir(hidden_sto_dir_dentry); */ @@ -615,7 +615,7 @@ Index: linux-2.6.23/fs/mini_fo/ChangeLog + + * Add tons of ugly ifdefs to Ed L. Cashin's mutex patch to + retain backwards compatibility. -+ ++ +2006-01-24 Ed L. Cashin <ecashin@coraid.com> + + * Support for the new mutex infrastructure @@ -665,7 +665,7 @@ Index: linux-2.6.23/fs/mini_fo/ChangeLog + + * Makefile: clean it up and added make install and make + uninstall. -+ ++ +2005-05-06 <mk@mary> + + * merged devel branch back to main. [v0-6-0-pre3] @@ -701,7 +701,7 @@ Index: linux-2.6.23/fs/mini_fo/ChangeLog + + * inode.c: rename_reg_file renamed to rename_nondir, as it + doesn't matter as long it't not a dir. Removed all -+ rename_dev_file etc. ++ rename_dev_file etc. + + * tagged as devel-0-0-15 + @@ -733,7 +733,7 @@ Index: linux-2.6.23/fs/mini_fo/ChangeLog +2005-04-23 <mk@mary> + + * state.c, aux.c: more cleaning up and -+ simplifications. [devel-0-0-13] ++ simplifications. [devel-0-0-13] + + * inode.c: implemented mini_fo_getattr, that was required for + 2.6 because inode_revalidate has been remove there, and the @@ -815,11 +815,11 @@ Index: linux-2.6.23/fs/mini_fo/ChangeLog + * Rewrote mini_fo rename and split it into several + subfunctions, that handle the different types + seperately. Rewrote the regular file function aswell, as it -+ was implemented somewhat inefficient. ++ was implemented somewhat inefficient. + +2005-03-16 Markus Klotzbuecher <mk@chasey> + -+ * Implemented new META subsystem, removed old WOL stuff in favor ++ * Implemented new META subsystem, removed old WOL stuff in favor + if it. + + * After some basic testing everything seems ok... @@ -831,7 +831,7 @@ Index: linux-2.6.23/fs/mini_fo/ChangeLog + files. mini_fo_rename still isn't implemented properly, renaming + of device files, symlinks etc. results in a empty regular file + instead of the proper type. -+ ++ + * Directory renaming suddenly works! What a surprise! I guess + this is because renaming is implemented as making a copy and + removing the original. Still this might not work @@ -848,7 +848,7 @@ Index: linux-2.6.23/fs/mini_fo/ChangeLog + the state numbers. + +2005-03-08 Markus Klotzbuecher <mk@chasey> -+ ++ + * Makefile fix, fist_ioctl was built against wrong sources if ARCH=um + + * Fixed a bug in dentry.c, mini_fo_d_hash. In state 4 = @@ -874,24 +874,24 @@ Index: linux-2.6.23/fs/mini_fo/ChangeLog +2004-10-24 Gleb Natapov <gleb@nbase.co.il> + + * Fix: owner and group where not correctly copied from base to -+ storage. ++ storage. + + +2004-10-05 Gleb Natapov <gleb@nbase.co.il> + + * Implementation of fsync, fasync and lock mini_fo functions. -+ ++ + +2004-09-29 Bob Lee <bob@pantasys.com> + + * Fix of a serious pointer bug -+ ++ + +2004-09-28 Gleb Natapov <gleb@nbase.co.il> + + * Implementation of mini_fo_mknod and mini_fo_rename, support + for device files. -+ ++ Index: linux-2.6.23/fs/mini_fo/dentry.c =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 @@ -961,10 +961,10 @@ Index: linux-2.6.23/fs/mini_fo/dentry.c + hidden_sto_dentry->d_op && + hidden_sto_dentry->d_op->d_revalidate) { +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) -+ err2 = hidden_sto_dentry->d_op->d_revalidate(hidden_sto_dentry, ++ err2 = hidden_sto_dentry->d_op->d_revalidate(hidden_sto_dentry, + nd); +#else -+ err2 = hidden_sto_dentry->d_op->d_revalidate(hidden_sto_dentry, ++ err2 = hidden_sto_dentry->d_op->d_revalidate(hidden_sto_dentry, + flags); +#endif + } @@ -1204,8 +1204,8 @@ Index: linux-2.6.23/fs/mini_fo/file.c + hidden_file->f_pos = file->f_pos; + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) -+ memcpy(&(hidden_file->f_ra), -+ &(file->f_ra), ++ memcpy(&(hidden_file->f_ra), ++ &(file->f_ra), + sizeof(struct file_ra_state)); +#else + if (file->f_reada) { /* update readahead information if needed */ @@ -1347,7 +1347,7 @@ Index: linux-2.6.23/fs/mini_fo/file.c + */ + if (err >= 0) + fist_copy_attr_times(inode, hidden_inode); -+ ++ + *ppos = pos; +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) + /* @@ -1376,7 +1376,7 @@ Index: linux-2.6.23/fs/mini_fo/file.c + * - be able to call wol functions in order to avoid listing deleted + * base files. + * - if we're reading a directory which is in state 1, we need to -+ * maintain a list (in mini_fo_filldir) of which files allready ++ * maintain a list (in mini_fo_filldir) of which files allready + * have been copied to userspace,to detect files existing in base + * and storage and not list them twice. + */ @@ -1422,7 +1422,7 @@ Index: linux-2.6.23/fs/mini_fo/file.c + /* check if file has been deleted */ + if(meta_check_d_entry(file->f_dentry, name, namlen)) + return 0; -+ ++ + /* do duplicate checking */ + if(ndl_check_entry(&ftopd(file)->rd, name, namlen)) + return 0; @@ -1456,7 +1456,7 @@ Index: linux-2.6.23/fs/mini_fo/file.c + ftopd(file)->rd.sto_done = 0; + do { + if (ftopd(file) != NULL) { -+ if(ftohf2(file)) { ++ if(ftohf2(file)) { + hidden_sto_file = ftohf2(file); + err = vfs_readdir(hidden_sto_file, mini_fo_filldir, dirent); + file->f_pos = hidden_sto_file->f_pos; @@ -1469,7 +1469,7 @@ Index: linux-2.6.23/fs/mini_fo/file.c + + ftopd(file)->rd.sto_done = 1; + -+ if(ftohf(file)) { ++ if(ftohf(file)) { + hidden_file = ftohf(file); + err = vfs_readdir(hidden_file, mini_fo_filldir, dirent); + file->f_pos = hidden_file->f_pos; @@ -1551,7 +1551,7 @@ Index: linux-2.6.23/fs/mini_fo/file.c +mini_fo_open(inode_t *inode, file_t *file) +{ + int err = 0; -+ int hidden_flags; ++ int hidden_flags; + file_t *hidden_file = NULL; + dentry_t *hidden_dentry = NULL; + @@ -1559,7 +1559,7 @@ Index: linux-2.6.23/fs/mini_fo/file.c + file_t *hidden_sto_file = NULL; + dentry_t *hidden_sto_dentry = NULL; + -+ __ftopd(file) = ++ __ftopd(file) = + kmalloc(sizeof(struct mini_fo_file_info), GFP_KERNEL); + if (!ftopd(file)) { + err = -ENOMEM; @@ -1678,7 +1678,7 @@ Index: linux-2.6.23/fs/mini_fo/file.c + goto out; + } + ftohf2(file) = hidden_sto_file; /* link storage file */ -+ ++ + out: + if (err < 0 && ftopd(file)) { + kfree(ftopd(file)); @@ -1696,7 +1696,7 @@ Index: linux-2.6.23/fs/mini_fo/file.c + int err1 = 0; /* assume ok (see open.c:close_fp) */ + int err2 = 0; + file_t *hidden_file = NULL; -+ ++ + check_mini_fo_file(file); + + /* mk: we don't do any state checking here, as its not worth the time. @@ -1813,7 +1813,7 @@ Index: linux-2.6.23/fs/mini_fo/file.c + if((hidden_file = ftohf2(file)) != NULL) { + err2 = hidden_file->f_op->fasync(fd, hidden_file, flag); + } -+ ++ + return (err1 || err2); +} + @@ -2146,7 +2146,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + +#ifdef HAVE_CONFIG_H +# include <config.h> -+#endif ++#endif + +#include "fist.h" +#include "mini_fo.h" @@ -2187,7 +2187,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + dentry_t *hidden_sto_dentry = NULL; + + /* whiteout flag */ -+ int del_flag = 0; ++ int del_flag = 0; + char *bpath = NULL; + + const char *name; @@ -2230,27 +2230,27 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + err= -EINVAL; + goto out; + } -+ ++ + /* this can be set up safely without fear of spaghetti + * interposing as it is only used for copying times */ + hidden_dir_dentry = hidden_dentry->d_parent; + kfree(bpath); + } + else if(hidden_dir_dentry && hidden_dir_dentry->d_inode) -+ hidden_dentry = ++ hidden_dentry = + lookup_one_len(name, hidden_dir_dentry, namelen); + else + hidden_dentry = NULL; + + if(hidden_sto_dir_dentry && hidden_sto_dir_dentry->d_inode) -+ hidden_sto_dentry = ++ hidden_sto_dentry = + lookup_one_len(name, hidden_sto_dir_dentry, namelen); + else + hidden_sto_dentry = NULL; + + /* catch error in lookup */ + if (IS_ERR(hidden_dentry) || IS_ERR(hidden_sto_dentry)) { -+ /* mk: we need to call dput on the dentry, whose ++ /* mk: we need to call dput on the dentry, whose + * lookup_one_len operation failed, in order to avoid + * unmount trouble. + */ @@ -2272,14 +2272,14 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + /* allocate dentry private data */ + __dtopd(dentry) = (struct mini_fo_dentry_info *) + kmalloc(sizeof(struct mini_fo_dentry_info), GFP_KERNEL); -+ ++ + if (!dtopd(dentry)) { + err = -ENOMEM; + goto out_dput; + } + + /* check for different states of the mini_fo file to be looked up. */ -+ ++ + /* state 1, file has been modified */ + if(hidden_dentry && hidden_sto_dentry && + hidden_dentry->d_inode && hidden_sto_dentry->d_inode && !del_flag) { @@ -2338,7 +2338,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + + /* state 4, file has deleted and created again. */ + if(hidden_dentry && hidden_sto_dentry && -+ hidden_dentry->d_inode && ++ hidden_dentry->d_inode && + hidden_sto_dentry->d_inode && del_flag) { + + fist_copy_attr_atime(dir, hidden_sto_dir_dentry->d_inode); @@ -2360,15 +2360,15 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + } + /* state 5, file has been deleted in base */ + if(hidden_dentry && hidden_sto_dentry && -+ hidden_dentry->d_inode && ++ hidden_dentry->d_inode && + !hidden_sto_dentry->d_inode && del_flag) { + + /* check which parents atime we need for updating */ + if(hidden_sto_dir_dentry->d_inode) -+ fist_copy_attr_atime(dir, ++ fist_copy_attr_atime(dir, + hidden_sto_dir_dentry->d_inode); + else -+ fist_copy_attr_atime(dir, ++ fist_copy_attr_atime(dir, + hidden_dir_dentry->d_inode); + + dtopd(dentry)->state = DELETED; @@ -2463,7 +2463,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + dtohd(old_dentry) = NULL; + dtost(old_dentry) = DEL_REWRITTEN; + } -+ ++ + err = get_neg_sto_dentry(new_dentry); + if(err) { + err = -EINVAL; @@ -2567,7 +2567,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c +#endif + + /* Fail if the symlink file exists */ -+ if(!(dtost(dentry) == DELETED || ++ if(!(dtost(dentry) == DELETED || + dtost(dentry) == NON_EXISTANT)) { + err = -EEXIST; + goto out; @@ -2613,7 +2613,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + goto out_lock; + } + fist_copy_attr_timesizes(dir, hidden_sto_dir_dentry->d_inode); -+ ++ + out_lock: + /* was: unlock_dir(hidden_sto_dir_dentry); */ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16) @@ -2647,7 +2647,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c +mini_fo_rmdir(inode_t *dir, dentry_t *dentry) +{ + int err = 0; -+ ++ + dentry_t *hidden_sto_dentry; + dentry_t *hidden_sto_dir_dentry; + dentry_t *meta_dentry; @@ -2676,8 +2676,8 @@ Index: linux-2.6.23/fs/mini_fo/inode.c +#endif + + /* Delete an old WOL file contained in the storage dir */ -+ meta_dentry = lookup_one_len(META_FILENAME, -+ hidden_sto_dentry, ++ meta_dentry = lookup_one_len(META_FILENAME, ++ hidden_sto_dentry, + strlen(META_FILENAME)); + if(meta_dentry->d_inode) { + err = vfs_unlink(hidden_sto_dentry->d_inode, meta_dentry); @@ -2695,15 +2695,15 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + dentry->d_inode->i_nlink = itohi2(dentry->d_inode)->i_nlink; + + dput(dtohd(dentry)); -+ ++ + dtohd(dentry) = NULL; + dtopd(dentry)->state = DELETED; + + /* carefull with R files */ -+ if( __meta_is_r_entry(dir, -+ dentry->d_name.name, ++ if( __meta_is_r_entry(dir, ++ dentry->d_name.name, + dentry->d_name.len) == 1) { -+ err = meta_remove_r_entry(dentry->d_parent, ++ err = meta_remove_r_entry(dentry->d_parent, + dentry->d_name.name, + dentry->d_name.len); + if(err) { @@ -2712,9 +2712,9 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + } + } + else { -+ /* ok, add deleted file to META */ -+ meta_add_d_entry(dentry->d_parent, -+ dentry->d_name.name, ++ /* ok, add deleted file to META */ ++ meta_add_d_entry(dentry->d_parent, ++ dentry->d_name.name, + dentry->d_name.len); + } + /* was: unlock_dir(hidden_sto_dir_dentry); */ @@ -2728,7 +2728,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + } + else if(dtopd(dentry)->state == UNMODIFIED) { + /* XXX: simply adding it to the delete list here is fscking dangerous! -+ * as a temporary hack, i will disable rmdir on unmodified directories ++ * as a temporary hack, i will disable rmdir on unmodified directories + * for now. + */ + err = -EINVAL; @@ -2739,7 +2739,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + err = -EINVAL; + goto out; + } -+ ++ + /* dput base dentry, this will relase the inode and free the + * dentry, as we will never need it again. */ + dput(dtohd(dentry)); @@ -2747,8 +2747,8 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + dtopd(dentry)->state = DELETED; + + /* add deleted file to META-file */ -+ meta_add_d_entry(dentry->d_parent, -+ dentry->d_name.name, ++ meta_add_d_entry(dentry->d_parent, ++ dentry->d_name.name, + dentry->d_name.len); + goto out; + } @@ -2766,12 +2766,12 @@ Index: linux-2.6.23/fs/mini_fo/inode.c +#endif + + /* Delete an old WOL file contained in the storage dir */ -+ meta_dentry = lookup_one_len(META_FILENAME, -+ hidden_sto_dentry, ++ meta_dentry = lookup_one_len(META_FILENAME, ++ hidden_sto_dentry, + strlen(META_FILENAME)); + if(meta_dentry->d_inode) { + /* is this necessary? dget(meta_dentry); */ -+ err = vfs_unlink(hidden_sto_dentry->d_inode, ++ err = vfs_unlink(hidden_sto_dentry->d_inode, + meta_dentry); + dput(meta_dentry); + if(!err) @@ -2811,8 +2811,8 @@ Index: linux-2.6.23/fs/mini_fo/inode.c +#endif + + /* Delete an old WOL file contained in the storage dir */ -+ meta_dentry = lookup_one_len(META_FILENAME, -+ hidden_sto_dentry, ++ meta_dentry = lookup_one_len(META_FILENAME, ++ hidden_sto_dentry, + strlen(META_FILENAME)); + if(meta_dentry->d_inode) { + /* is this necessary? dget(meta_dentry); */ @@ -2848,7 +2848,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + if(!err) { + d_drop(dentry); + } -+ ++ + fist_copy_attr_times(dir, itohi2(dentry->d_parent->d_inode)); + dput(dentry); + @@ -2872,7 +2872,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + printk(KERN_CRIT "mini_fo_mknod: creating sto nod failed.\n"); + err = -EINVAL; + } -+ ++ + check_mini_fo_dentry(dentry); + return err; +} @@ -2886,7 +2886,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + if(S_ISDIR(old_dentry->d_inode->i_mode)) + return rename_directory(old_dir, old_dentry, new_dir, new_dentry); + return rename_nondir(old_dir, old_dentry, new_dir, new_dentry); -+ ++ +} + +int rename_directory(inode_t *old_dir, dentry_t *old_dentry, @@ -2911,17 +2911,17 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + uh, ah, new_dentry not negative.\n"); + /* return -1; */ + } -+ ++ + /* state = UNMODIFIED */ + if(dtopd(old_dentry)->state == UNMODIFIED) { + err = dir_unmod_to_mod(old_dentry); -+ if (err) ++ if (err) + goto out; + } + + /* state = MODIFIED */ + if(dtopd(old_dentry)->state == MODIFIED) { -+ bpath = meta_check_r_entry(old_dentry->d_parent, ++ bpath = meta_check_r_entry(old_dentry->d_parent, + old_dentry->d_name.name, + old_dentry->d_name.len); + if(bpath) { @@ -2942,22 +2942,22 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + kfree(bpath); + } + else {/* wol it */ -+ err = meta_add_d_entry(old_dentry->d_parent, ++ err = meta_add_d_entry(old_dentry->d_parent, + old_dentry->d_name.name, + old_dentry->d_name.len); -+ if (err) ++ if (err) + goto out; + /* put it on rename list */ + err = get_mini_fo_bpath(old_dentry, -+ &bpath, ++ &bpath, + &bpath_len); -+ if (err) ++ if (err) + goto out; + err = meta_add_r_entry(new_dentry->d_parent, + bpath, bpath_len, + new_dentry->d_name.name, + new_dentry->d_name.len); -+ if (err) ++ if (err) + goto out; + } + /* no state change, MODIFIED stays MODIFIED */ @@ -2967,53 +2967,53 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + dtopd(old_dentry)->state == DEL_REWRITTEN) { + if(dtohd(old_dentry)) + dput(dtohd(old_dentry)); -+ ++ + if(dtopd(new_dentry)->state == DELETED) { + dtopd(old_dentry)->state = DEL_REWRITTEN; + dtohd(old_dentry) = NULL; -+ } ++ } + else if(dtopd(new_dentry)->state == NON_EXISTANT) { + dtopd(old_dentry)->state = CREATED; + /* steal new dentry's neg. base dentry */ + dtohd(old_dentry) = dtohd(new_dentry); + dtohd(new_dentry) = NULL; + } -+ } ++ } + if(dtopd(new_dentry)->state == UNMODIFIED || + dtopd(new_dentry)->state == NON_EXISTANT) { + err = get_neg_sto_dentry(new_dentry); + if(err) + goto out; + } -+ ++ + /* now move sto file */ + hidden_old_dentry = dtohd2(old_dentry); + hidden_new_dentry = dtohd2(new_dentry); -+ ++ + dget(hidden_old_dentry); + dget(hidden_new_dentry); -+ ++ + hidden_old_dir_dentry = dget(hidden_old_dentry->d_parent); + hidden_new_dir_dentry = dget(hidden_new_dentry->d_parent); + double_lock(hidden_old_dir_dentry, hidden_new_dir_dentry); -+ ++ + err = vfs_rename(hidden_old_dir_dentry->d_inode, hidden_old_dentry, + hidden_new_dir_dentry->d_inode, hidden_new_dentry); + if(err) + goto out_lock; -+ ++ + fist_copy_attr_all(new_dir, hidden_new_dir_dentry->d_inode); + if (new_dir != old_dir) -+ fist_copy_attr_all(old_dir, ++ fist_copy_attr_all(old_dir, + hidden_old_dir_dentry->d_inode); -+ ++ + out_lock: + /* double_unlock will dput the new/old parent dentries + * whose refcnts were incremented via get_parent above. */ + double_unlock(hidden_old_dir_dentry, hidden_new_dir_dentry); + dput(hidden_new_dentry); + dput(hidden_old_dentry); -+ ++ + out: + return err; +} @@ -3039,7 +3039,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + + /* the easy states */ + if(exists_in_storage(old_dentry)) { -+ ++ + dentry_t *hidden_old_dentry; + dentry_t *hidden_new_dentry; + dentry_t *hidden_old_dir_dentry; @@ -3103,7 +3103,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + + /* we keep the neg. base dentry (if exists) */ + dtohd(old_dentry) = dtohd(new_dentry); -+ /* ...and set it to Null, or we'll get ++ /* ...and set it to Null, or we'll get + * Dr. dcache.c:345 if it gets dput twice... */ + dtohd(new_dentry) = NULL; + dtopd(old_dentry)->state = CREATED; @@ -3115,41 +3115,41 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + dtopd(old_dentry)->state = DEL_REWRITTEN; + } + else { /* not possible, uhh, ahh */ -+ printk(KERN_CRIT ++ printk(KERN_CRIT + "mini_fo: rename_reg_file: invalid state detected [1].\n"); + return -1; + } -+ ++ + /* now we definitely have a sto file */ + hidden_old_dentry = dtohd2(old_dentry); + hidden_new_dentry = dtohd2(new_dentry); + + dget(hidden_old_dentry); + dget(hidden_new_dentry); -+ ++ + hidden_old_dir_dentry = dget(hidden_old_dentry->d_parent); + hidden_new_dir_dentry = dget(hidden_new_dentry->d_parent); + double_lock(hidden_old_dir_dentry, hidden_new_dir_dentry); + -+ err = vfs_rename(hidden_old_dir_dentry->d_inode, ++ err = vfs_rename(hidden_old_dir_dentry->d_inode, + hidden_old_dentry, -+ hidden_new_dir_dentry->d_inode, ++ hidden_new_dir_dentry->d_inode, + hidden_new_dentry); -+ if(err) ++ if(err) + goto out_lock; + + fist_copy_attr_all(new_dir, hidden_new_dir_dentry->d_inode); + if (new_dir != old_dir) + fist_copy_attr_all(old_dir, hidden_old_dir_dentry->d_inode); -+ ++ + out_lock: -+ /* double_unlock will dput the new/old parent dentries ++ /* double_unlock will dput the new/old parent dentries + * whose refcnts were incremented via get_parent above. + */ + double_unlock(hidden_old_dir_dentry, hidden_new_dir_dentry); + dput(hidden_new_dentry); + dput(hidden_old_dentry); -+ out: ++ out: + return err; + } + else { /* invalid state */ @@ -3273,13 +3273,13 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + * if (err) + * goto out; + */ -+ ++ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) + err = permission(hidden_inode, mask, nd); +#else + err = permission(hidden_inode, mask); +#endif -+ ++ + /* out: */ + return err; +} @@ -3323,7 +3323,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + int err = 0; + + check_mini_fo_dentry(dentry); -+ ++ + if(!is_mini_fo_existant(dentry)) { + printk(KERN_CRIT "mini_fo_setattr: ERROR, invalid state detected [1].\n"); + goto out; @@ -3337,7 +3337,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + err = dir_unmod_to_mod(dentry); + } else { + /* we copy contents if file is not beeing truncated */ -+ if(S_ISREG(dentry->d_inode->i_mode) && ++ if(S_ISREG(dentry->d_inode->i_mode) && + !(ia->ia_size == 0 && (ia->ia_valid & ATTR_SIZE))) { + err = nondir_unmod_to_mod(dentry, 1); + } else @@ -3358,7 +3358,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + ASSERT(dtohd2(dentry)); + ASSERT(itopd(dentry->d_inode)); + ASSERT(itohi2(dentry->d_inode)); -+ ++ + err = notify_change(dtohd2(dentry), ia); + fist_copy_attr_all(dentry->d_inode, itohi2(dentry->d_inode)); + out: @@ -3454,7 +3454,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + hidden_dentry = dtohd2(dentry); + else + hidden_dentry = dtohd(dentry); -+ ++ + ASSERT(hidden_dentry); + ASSERT(hidden_dentry->d_inode); + ASSERT(hidden_dentry->d_inode->i_op); @@ -3487,10 +3487,10 @@ Index: linux-2.6.23/fs/mini_fo/inode.c +#if ((LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,21) \ + && LINUX_VERSION_CODE <= KERNEL_VERSION(2,4,23)) \ + || LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)) -+mini_fo_setxattr(struct dentry *dentry, const char *name, ++mini_fo_setxattr(struct dentry *dentry, const char *name, + const void *value, size_t size, int flags) +#else -+mini_fo_setxattr(struct dentry *dentry, const char *name, ++mini_fo_setxattr(struct dentry *dentry, const char *name, + void *value, size_t size, int flags) +#endif + @@ -3508,7 +3508,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + hidden_dentry = dtohd2(dentry); + else + hidden_dentry = dtohd(dentry); -+ ++ + ASSERT(hidden_dentry); + ASSERT(hidden_dentry->d_inode); + ASSERT(hidden_dentry->d_inode->i_op); @@ -3549,7 +3549,7 @@ Index: linux-2.6.23/fs/mini_fo/inode.c + hidden_dentry = dtohd2(dentry); + else + hidden_dentry = dtohd(dentry); -+ ++ + ASSERT(hidden_dentry); + ASSERT(hidden_dentry->d_inode); + ASSERT(hidden_dentry->d_inode->i_op); @@ -3774,7 +3774,7 @@ Index: linux-2.6.23/fs/mini_fo/main.c + /* + * original: inode = iget(sb, hidden_inode->i_ino); + */ -+ inode = iget_locked(sb, iunique(sb, 25)); ++ inode = iget(sb, iunique(sb, 25)); + if (!inode) { + err = -EACCES; /* should be impossible??? */ + goto out; @@ -3849,7 +3849,7 @@ Index: linux-2.6.23/fs/mini_fo/main.c +{ + dentry_t *hidden_root = ERR_PTR(-EINVAL); + dentry_t *hidden_root2 = ERR_PTR(-EINVAL); -+ struct nameidata nd, nd2; ++ struct nameidata nd, nd2; + char *name, *tmp, *end; + int err = 0; + @@ -3876,9 +3876,9 @@ Index: linux-2.6.23/fs/mini_fo/main.c + hidden_root = ERR_PTR(err); + goto out; + } -+ hidden_root = nd.path.dentry; -+ stopd(sb)->base_dir_dentry = nd.path.dentry; -+ stopd(sb)->hidden_mnt = nd.path.mnt; ++ hidden_root = nd.dentry; ++ stopd(sb)->base_dir_dentry = nd.dentry; ++ stopd(sb)->hidden_mnt = nd.mnt; + + } else if(!strncmp("sto=", options, 4)) { + /* parse the storage dir */ @@ -3896,12 +3896,12 @@ Index: linux-2.6.23/fs/mini_fo/main.c + hidden_root2 = ERR_PTR(err); + goto out; + } -+ hidden_root2 = nd2.path.dentry; -+ stopd(sb)->storage_dir_dentry = nd2.path.dentry; -+ stopd(sb)->hidden_mnt2 = nd2.path.mnt; ++ hidden_root2 = nd2.dentry; ++ stopd(sb)->storage_dir_dentry = nd2.dentry; ++ stopd(sb)->hidden_mnt2 = nd2.mnt; + stohs2(sb) = hidden_root2->d_sb; + -+ /* validate storage dir, this is done in ++ /* validate storage dir, this is done in + * mini_fo_read_super for the base directory. + */ + if (IS_ERR(hidden_root2)) { @@ -4000,7 +4000,7 @@ Index: linux-2.6.23/fs/mini_fo/main.c + sb->s_root->d_parent = sb->s_root; + + /* link the upper and lower dentries */ -+ __dtopd(sb->s_root) = (struct mini_fo_dentry_info *) ++ __dtopd(sb->s_root) = (struct mini_fo_dentry_info *) + kmalloc(sizeof(struct mini_fo_dentry_info), GFP_KERNEL); + if (!dtopd(sb->s_root)) { + err = -ENOMEM; @@ -4050,14 +4050,14 @@ Index: linux-2.6.23/fs/mini_fo/main.c +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18) +static int mini_fo_get_sb(struct file_system_type *fs_type, + int flags, const char *dev_name, -+ void *raw_data, struct vfsmount *mnt) ++ void *raw_data, struct vfsmount *mnt) +{ + return get_sb_nodev(fs_type, flags, raw_data, mini_fo_read_super, mnt); +} +#else +static struct super_block *mini_fo_get_sb(struct file_system_type *fs_type, + int flags, const char *dev_name, -+ void *raw_data) ++ void *raw_data) +{ + return get_sb_nodev(fs_type, flags, raw_data, mini_fo_read_super); +} @@ -4155,7 +4155,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c +#include "fist.h" +#include "mini_fo.h" + -+int meta_build_lists(dentry_t *dentry) ++int meta_build_lists(dentry_t *dentry) +{ + struct mini_fo_inode_info *inode_info; + @@ -4186,7 +4186,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + /* might there be a META-file? */ + if(dtohd2(dentry) && dtohd2(dentry)->d_inode) { + meta_dentry = lookup_one_len(META_FILENAME, -+ dtohd2(dentry), ++ dtohd2(dentry), + strlen(META_FILENAME)); + if(!meta_dentry->d_inode) { + dput(meta_dentry); @@ -4195,7 +4195,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + /* $%& err, is this correct? */ + meta_mnt = stopd(dentry->d_inode->i_sb)->hidden_mnt2; + mntget(meta_mnt); -+ ++ + + /* open META-file for reading */ + meta_file = dentry_open(meta_dentry, meta_mnt, 0x0); @@ -4243,8 +4243,8 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + switch (*entry) { + case 'D': + /* format: "D filename" */ -+ meta_list_add_d_entry(dentry, -+ entry+2, ++ meta_list_add_d_entry(dentry, ++ entry+2, + len-2); + break; + case 'R': @@ -4253,10 +4253,10 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + dir_name = strchr(old_path, ' ') + 1; + old_len = dir_name - old_path - 1; + new_len = ((int) entry) + len - ((int ) dir_name); -+ meta_list_add_r_entry(dentry, -+ old_path, ++ meta_list_add_r_entry(dentry, ++ old_path, + old_len, -+ dir_name, ++ dir_name, + new_len); + break; + default: @@ -4281,11 +4281,11 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + dput(meta_dentry); + return -1; + out_ok: -+ return 1; /* check this!!! inode_info->wol_size; */ ++ return 1; /* check this!!! inode_info->wol_size; */ +} + +/* cleanups up all lists and free's the mem by dentry */ -+int meta_put_lists(dentry_t *dentry) ++int meta_put_lists(dentry_t *dentry) +{ + if(!dentry || !dentry->d_inode) { + printk("mini_fo: meta_put_lists: invalid dentry passed.\n"); @@ -4295,7 +4295,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c +} + +/* cleanups up all lists and free's the mem by inode */ -+int __meta_put_lists(inode_t *inode) ++int __meta_put_lists(inode_t *inode) +{ + int err = 0; + if(!inode || !itopd(inode)) { @@ -4322,19 +4322,19 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + + +/* remove all D entries from the renamed list and free the mem */ -+int __meta_put_d_list(inode_t *inode) ++int __meta_put_d_list(inode_t *inode) +{ + struct list_head *tmp; + struct deleted_entry *del_entry; + struct mini_fo_inode_info *inode_info; -+ ++ + if(!inode || !itopd(inode)) { + printk(KERN_CRIT "mini_fo: __meta_put_d_list: \ + invalid inode passed.\n"); + return -1; + } + inode_info = itopd(inode); -+ ++ + /* nuke the DELETED-list */ + if(inode_info->deleted_list_size <= 0) + return 0; @@ -4347,25 +4347,25 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + kfree(del_entry); + } + inode_info->deleted_list_size = 0; -+ ++ + return 0; +} + +/* remove all R entries from the renamed list and free the mem */ -+int __meta_put_r_list(inode_t *inode) ++int __meta_put_r_list(inode_t *inode) +{ + struct list_head *tmp; + struct renamed_entry *ren_entry; + struct mini_fo_inode_info *inode_info; -+ ++ + if(!inode || !itopd(inode)) { + printk(KERN_CRIT "mini_fo: meta_put_r_list: invalid inode.\n"); + return -1; + } + inode_info = itopd(inode); -+ ++ + /* nuke the RENAMED-list */ -+ if(inode_info->renamed_list_size <= 0) ++ if(inode_info->renamed_list_size <= 0) + return 0; + + while(!list_empty(&inode_info->renamed_list)) { @@ -4377,7 +4377,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + kfree(ren_entry); + } + inode_info->renamed_list_size = 0; -+ ++ + return 0; +} + @@ -4386,11 +4386,11 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + int err = 0; + err = meta_list_add_d_entry(dentry, name, len); + err |= meta_write_d_entry(dentry,name,len); -+ return err; ++ return err; +} + +/* add a D entry to the deleted list */ -+int meta_list_add_d_entry(dentry_t *dentry, const char *name, int len) ++int meta_list_add_d_entry(dentry_t *dentry, const char *name, int len) +{ + struct deleted_entry *del_entry; + struct mini_fo_inode_info *inode_info; @@ -4405,7 +4405,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + if(inode_info->deleted_list_size < 0) + return -1; + -+ del_entry = (struct deleted_entry *) ++ del_entry = (struct deleted_entry *) + kmalloc(sizeof(struct deleted_entry), GFP_KERNEL); + del_entry->name = (char*) kmalloc(len, GFP_KERNEL); + if(!del_entry || !del_entry->name) { @@ -4424,12 +4424,12 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + return 0; +} + -+int meta_add_r_entry(dentry_t *dentry, -+ const char *old_name, int old_len, ++int meta_add_r_entry(dentry_t *dentry, ++ const char *old_name, int old_len, + const char *new_name, int new_len) +{ + int err = 0; -+ err = meta_list_add_r_entry(dentry, ++ err = meta_list_add_r_entry(dentry, + old_name, old_len, + new_name, new_len); + err |= meta_write_r_entry(dentry, @@ -4439,8 +4439,8 @@ Index: linux-2.6.23/fs/mini_fo/meta.c +} + +/* add a R entry to the renamed list */ -+int meta_list_add_r_entry(dentry_t *dentry, -+ const char *old_name, int old_len, ++int meta_list_add_r_entry(dentry_t *dentry, ++ const char *old_name, int old_len, + const char *new_name, int new_len) +{ + struct renamed_entry *ren_entry; @@ -4456,7 +4456,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + if(inode_info->renamed_list_size < 0) + return -1; + -+ ren_entry = (struct renamed_entry *) ++ ren_entry = (struct renamed_entry *) + kmalloc(sizeof(struct renamed_entry), GFP_KERNEL); + ren_entry->old_name = (char*) kmalloc(old_len, GFP_KERNEL); + ren_entry->new_name = (char*) kmalloc(new_len, GFP_KERNEL); @@ -4485,7 +4485,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c +{ + int err = 0; + if(!dentry || !dentry->d_inode) { -+ printk(KERN_CRIT ++ printk(KERN_CRIT + "mini_fo: meta_remove_r_entry: \ + invalid dentry passed.\n"); + return -1; @@ -4499,7 +4499,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c +int meta_list_remove_r_entry(dentry_t *dentry, const char *name, int len) +{ + if(!dentry || !dentry->d_inode) { -+ printk(KERN_CRIT ++ printk(KERN_CRIT + "mini_fo: meta_list_remove_r_entry: \ + invalid dentry passed.\n"); + return -1; @@ -4514,7 +4514,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + struct mini_fo_inode_info *inode_info; + + if(!inode || !itopd(inode)) -+ printk(KERN_CRIT ++ printk(KERN_CRIT + "mini_fo: __meta_list_remove_r_entry: \ + invalid inode passed.\n"); + inode_info = itopd(inode); @@ -4523,12 +4523,12 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + return -1; + if(inode_info->renamed_list_size == 0) + return 1; -+ ++ + list_for_each(tmp, &inode_info->renamed_list) { + ren_entry = list_entry(tmp, struct renamed_entry, list); + if(ren_entry->new_len != len) + continue; -+ ++ + if(!strncmp(ren_entry->new_name, name, len)) { + list_del(tmp); + kfree(ren_entry->new_name); @@ -4543,7 +4543,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + + +/* append a single D entry to the meta file */ -+int meta_write_d_entry(dentry_t *dentry, const char *name, int len) ++int meta_write_d_entry(dentry_t *dentry, const char *name, int len) +{ + dentry_t *meta_dentry = 0; + file_t *meta_file = 0; @@ -4568,19 +4568,19 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + goto out; + } + } -+ meta_dentry = lookup_one_len(META_FILENAME, ++ meta_dentry = lookup_one_len(META_FILENAME, + dtohd2(dentry), strlen (META_FILENAME)); + + /* We need to create a META-file */ + if(!meta_dentry->d_inode) { +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) + vfs_create(dtohd2(dentry)->d_inode, -+ meta_dentry, ++ meta_dentry, + S_IRUSR | S_IWUSR, + NULL); +#else + vfs_create(dtohd2(dentry)->d_inode, -+ meta_dentry, ++ meta_dentry, + S_IRUSR | S_IWUSR); +#endif + } @@ -4613,12 +4613,12 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + out of mem.\n"); + return -ENOMEM; + } -+ ++ + buf[0] = 'D'; + buf[1] = ' '; + strncpy(buf+2, name, len); + buf[len+2] = '\n'; -+ bytes = meta_file->f_op->write(meta_file, buf, len+3, ++ bytes = meta_file->f_op->write(meta_file, buf, len+3, + &meta_file->f_pos); + if(bytes != len+3) { + printk(KERN_CRIT "mini_fo: meta_write_d_entry: \ @@ -4635,9 +4635,9 @@ Index: linux-2.6.23/fs/mini_fo/meta.c +} + +/* append a single R entry to the meta file */ -+int meta_write_r_entry(dentry_t *dentry, -+ const char *old_name, int old_len, -+ const char *new_name, int new_len) ++int meta_write_r_entry(dentry_t *dentry, ++ const char *old_name, int old_len, ++ const char *new_name, int new_len) +{ + dentry_t *meta_dentry = 0; + file_t *meta_file = 0; @@ -4664,16 +4664,16 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + goto out; + } + } -+ meta_dentry = lookup_one_len(META_FILENAME, -+ dtohd2(dentry), ++ meta_dentry = lookup_one_len(META_FILENAME, ++ dtohd2(dentry), + strlen (META_FILENAME)); + if(!meta_dentry->d_inode) { + /* We need to create a META-file */ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) -+ vfs_create(dtohd2(dentry)->d_inode, ++ vfs_create(dtohd2(dentry)->d_inode, + meta_dentry, S_IRUSR | S_IWUSR, NULL); +#else -+ vfs_create(dtohd2(dentry)->d_inode, ++ vfs_create(dtohd2(dentry)->d_inode, + meta_dentry, S_IRUSR | S_IWUSR); +#endif + } @@ -4706,7 +4706,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + printk(KERN_CRIT "mini_fo: meta_write_r_entry: out of mem.\n"); + return -ENOMEM; + } -+ ++ + buf[0] = 'R'; + buf[1] = ' '; + strncpy(buf + 2, old_name, old_len); @@ -4718,7 +4718,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + printk(KERN_CRIT "mini_fo: meta_write_r_entry: ERROR writing.\n"); + err = -1; + } -+ ++ + kfree(buf); + set_fs(old_fs); + @@ -4736,7 +4736,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + dentry_t *meta_dentry; + file_t *meta_file; + mm_segment_t old_fs; -+ ++ + int bytes, err; + struct vfsmount *meta_mnt; + char *buf; @@ -4748,7 +4748,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + err = 0; + meta_file=0; + meta_mnt=0; -+ ++ + if(!dentry || !dentry->d_inode) { + printk(KERN_CRIT "mini_fo: meta_sync_d_list: \ + invalid inode passed.\n"); @@ -4756,12 +4756,12 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + goto out; + } + inode_info = itopd(dentry->d_inode); -+ ++ + if(inode_info->deleted_list_size < 0) { + err = -1; + goto out; + } -+ ++ + /* ok, there is something to sync */ + + /* build the storage structure? */ @@ -4773,16 +4773,16 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + goto out; + } + } -+ meta_dentry = lookup_one_len(META_FILENAME, -+ dtohd2(dentry), ++ meta_dentry = lookup_one_len(META_FILENAME, ++ dtohd2(dentry), + strlen(META_FILENAME)); + if(!meta_dentry->d_inode) { + /* We need to create a META-file */ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) -+ vfs_create(dtohd2(dentry)->d_inode, ++ vfs_create(dtohd2(dentry)->d_inode, + meta_dentry, S_IRUSR | S_IWUSR, NULL); +#else -+ vfs_create(dtohd2(dentry)->d_inode, ++ vfs_create(dtohd2(dentry)->d_inode, + meta_dentry, S_IRUSR | S_IWUSR); +#endif + app_flag = 0; @@ -4819,7 +4819,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + printk(KERN_CRIT "mini_fo: meta_sync_d_list: \ + ERROR opening meta file.\n"); + /* we don't mntget so we dont't mntput (for now) -+ * mntput(meta_mnt); ++ * mntput(meta_mnt); + */ + dput(meta_dentry); + err = -1; @@ -4832,7 +4832,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + ERROR, fs does not support writing.\n"); + goto out_err_close; + } -+ ++ + meta_file->f_pos = meta_dentry->d_inode->i_size; /* append */ + old_fs = get_fs(); + set_fs(KERNEL_DS); @@ -4840,7 +4840,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + /* here we go... */ + list_for_each(tmp, &inode_info->deleted_list) { + del_entry = list_entry(tmp, struct deleted_entry, list); -+ ++ + /* size: len for name, 1 for \n and 2 for "D " */ + buf = (char *) kmalloc(del_entry->len+3, GFP_KERNEL); + if (!buf) { @@ -4848,13 +4848,13 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + out of mem.\n"); + return -ENOMEM; + } -+ ++ + buf[0] = 'D'; + buf[1] = ' '; + strncpy(buf+2, del_entry->name, del_entry->len); + buf[del_entry->len+2] = '\n'; -+ bytes = meta_file->f_op->write(meta_file, buf, -+ del_entry->len+3, ++ bytes = meta_file->f_op->write(meta_file, buf, ++ del_entry->len+3, + &meta_file->f_pos); + if(bytes != del_entry->len+3) { + printk(KERN_CRIT "mini_fo: meta_sync_d_list: \ @@ -4864,7 +4864,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + kfree(buf); + } + set_fs(old_fs); -+ ++ + out_err_close: + fput(meta_file); + out: @@ -4877,19 +4877,19 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + dentry_t *meta_dentry; + file_t *meta_file; + mm_segment_t old_fs; -+ ++ + int bytes, err, buf_len; + struct vfsmount *meta_mnt; + char *buf; -+ ++ + struct list_head *tmp; + struct renamed_entry *ren_entry; + struct mini_fo_inode_info *inode_info; -+ ++ + err = 0; + meta_file=0; + meta_mnt=0; -+ ++ + if(!dentry || !dentry->d_inode) { + printk(KERN_CRIT "mini_fo: meta_sync_r_list: \ + invalid dentry passed.\n"); @@ -4897,12 +4897,12 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + goto out; + } + inode_info = itopd(dentry->d_inode); -+ ++ + if(inode_info->deleted_list_size < 0) { + err = -1; + goto out; + } -+ ++ + /* ok, there is something to sync */ + + /* build the storage structure? */ @@ -4914,16 +4914,16 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + goto out; + } + } -+ meta_dentry = lookup_one_len(META_FILENAME, -+ dtohd2(dentry), ++ meta_dentry = lookup_one_len(META_FILENAME, ++ dtohd2(dentry), + strlen(META_FILENAME)); + if(!meta_dentry->d_inode) { + /* We need to create a META-file */ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) -+ vfs_create(dtohd2(dentry)->d_inode, ++ vfs_create(dtohd2(dentry)->d_inode, + meta_dentry, S_IRUSR | S_IWUSR, NULL); +#else -+ vfs_create(dtohd2(dentry)->d_inode, ++ vfs_create(dtohd2(dentry)->d_inode, + meta_dentry, S_IRUSR | S_IWUSR); +#endif + app_flag = 0; @@ -4959,7 +4959,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + printk(KERN_CRIT "mini_fo: meta_sync_r_list: \ + ERROR opening meta file.\n"); + /* we don't mntget so we dont't mntput (for now) -+ * mntput(meta_mnt); ++ * mntput(meta_mnt); + */ + dput(meta_dentry); + err = -1; @@ -4972,7 +4972,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + ERROR, fs does not support writing.\n"); + goto out_err_close; + } -+ ++ + meta_file->f_pos = meta_dentry->d_inode->i_size; /* append */ + old_fs = get_fs(); + set_fs(KERNEL_DS); @@ -4980,7 +4980,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + /* here we go... */ + list_for_each(tmp, &inode_info->renamed_list) { + ren_entry = list_entry(tmp, struct renamed_entry, list); -+ /* size: ++ /* size: + * 2 for "R ", old_len+new_len for names, 1 blank+1 \n */ + buf_len = ren_entry->old_len + ren_entry->new_len + 4; + buf = (char *) kmalloc(buf_len, GFP_KERNEL); @@ -4993,35 +4993,35 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + buf[1] = ' '; + strncpy(buf + 2, ren_entry->old_name, ren_entry->old_len); + buf[ren_entry->old_len + 2] = ' '; -+ strncpy(buf + ren_entry->old_len + 3, ++ strncpy(buf + ren_entry->old_len + 3, + ren_entry->new_name, ren_entry->new_len); + buf[buf_len - 1] = '\n'; -+ bytes = meta_file->f_op->write(meta_file, buf, ++ bytes = meta_file->f_op->write(meta_file, buf, + buf_len, &meta_file->f_pos); + if(bytes != buf_len) { + printk(KERN_CRIT "mini_fo: meta_sync_r_list: \ + ERROR writing.\n"); + err |= -1; -+ } ++ } + kfree(buf); + } + set_fs(old_fs); -+ ++ + out_err_close: + fput(meta_file); + out: + return err; +} + -+int meta_check_d_entry(dentry_t *dentry, const char *name, int len) ++int meta_check_d_entry(dentry_t *dentry, const char *name, int len) +{ + if(!dentry || !dentry->d_inode) + printk(KERN_CRIT "mini_fo: meta_check_d_dentry: \ + invalid dentry passed.\n"); -+ return __meta_check_d_entry(dentry->d_inode, name, len); ++ return __meta_check_d_entry(dentry->d_inode, name, len); +} + -+int __meta_check_d_entry(inode_t *inode, const char *name, int len) ++int __meta_check_d_entry(inode_t *inode, const char *name, int len) +{ + struct list_head *tmp; + struct deleted_entry *del_entry; @@ -5032,7 +5032,7 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + invalid inode passed.\n"); + + inode_info = itopd(inode); -+ ++ + if(inode_info->deleted_list_size <= 0) + return 0; + @@ -5040,26 +5040,26 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + del_entry = list_entry(tmp, struct deleted_entry, list); + if(del_entry->len != len) + continue; -+ ++ + if(!strncmp(del_entry->name, name, len)) + return 1; + } + return 0; +} + -+/* ++/* + * check if file has been renamed and return path to orig. base dir. + * Implements no error return values so far, what of course sucks. + * String is null terminated.' + */ -+char* meta_check_r_entry(dentry_t *dentry, const char *name, int len) ++char* meta_check_r_entry(dentry_t *dentry, const char *name, int len) +{ + if(!dentry || !dentry->d_inode) { + printk(KERN_CRIT "mini_fo: meta_check_r_dentry: \ + invalid dentry passed.\n"); + return NULL; + } -+ return __meta_check_r_entry(dentry->d_inode, name, len); ++ return __meta_check_r_entry(dentry->d_inode, name, len); +} + +char* __meta_check_r_entry(inode_t *inode, const char *name, int len) @@ -5068,27 +5068,27 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + struct renamed_entry *ren_entry; + struct mini_fo_inode_info *inode_info; + char *old_path; -+ ++ + if(!inode || !itopd(inode)) { + printk(KERN_CRIT "mini_fo: meta_check_r_dentry: \ + invalid inode passed.\n"); + return NULL; + } + inode_info = itopd(inode); -+ ++ + if(inode_info->renamed_list_size <= 0) + return NULL; -+ ++ + list_for_each(tmp, &inode_info->renamed_list) { + ren_entry = list_entry(tmp, struct renamed_entry, list); + if(ren_entry->new_len != len) + continue; -+ ++ + if(!strncmp(ren_entry->new_name, name, len)) { -+ old_path = (char *) ++ old_path = (char *) + kmalloc(ren_entry->old_len+1, GFP_KERNEL); -+ strncpy(old_path, -+ ren_entry->old_name, ++ strncpy(old_path, ++ ren_entry->old_name, + ren_entry->old_len); + old_path[ren_entry->old_len]='\0'; + return old_path; @@ -5103,14 +5103,14 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + * 0 if not, + * -1 if error. + */ -+int meta_is_r_entry(dentry_t *dentry, const char *name, int len) ++int meta_is_r_entry(dentry_t *dentry, const char *name, int len) +{ + if(!dentry || !dentry->d_inode) { + printk(KERN_CRIT "mini_fo: meta_check_r_dentry [2]: \ + invalid dentry passed.\n"); + return -1; + } -+ return __meta_is_r_entry(dentry->d_inode, name, len); ++ return __meta_is_r_entry(dentry->d_inode, name, len); +} + +int __meta_is_r_entry(inode_t *inode, const char *name, int len) @@ -5118,23 +5118,23 @@ Index: linux-2.6.23/fs/mini_fo/meta.c + struct list_head *tmp; + struct renamed_entry *ren_entry; + struct mini_fo_inode_info *inode_info; -+ ++ + if(!inode || !itopd(inode)) { + printk(KERN_CRIT "mini_fo: meta_check_r_dentry [2]: \ + invalid inode passed.\n"); + return -1; + } + inode_info = itopd(inode); -+ ++ + if(inode_info->renamed_list_size <= 0) + return -1; -+ ++ + list_for_each(tmp, &inode_info->renamed_list) { + ren_entry = list_entry(tmp, struct renamed_entry, list); + if(ren_entry->new_len != len) + continue; -+ -+ if(!strncmp(ren_entry->new_name, name, len)) ++ ++ if(!strncmp(ren_entry->new_name, name, len)) + return 1; + } + return 0; @@ -5341,7 +5341,7 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo.h +# define __ftopd(file) ((file)->private_data) +/* file TO hidden_file */ +# define ftohf(file) ((ftopd(file))->wfi_file) -+# define ftohf2(file) ((ftopd(file))->wfi_file2) ++# define ftohf2(file) ((ftopd(file))->wfi_file2) + +/* inode TO private_data */ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18) @@ -5443,7 +5443,7 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo.h +/* misc stuff */ +extern int mini_fo_tri_interpose(dentry_t *hidden_dentry, + dentry_t *hidden_sto_dentry, -+ dentry_t *dentry, ++ dentry_t *dentry, + super_block_t *sb, int flag); + +extern int mini_fo_cp_cont(dentry_t *tgt_dentry, struct vfsmount *tgt_mnt, @@ -5482,8 +5482,8 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo.h +extern int __meta_put_lists(inode_t *inode); + +extern int meta_add_d_entry(dentry_t *dentry, const char *name, int len); -+extern int meta_add_r_entry(dentry_t *dentry, -+ const char *old_name, int old_len, ++extern int meta_add_r_entry(dentry_t *dentry, ++ const char *old_name, int old_len, + const char *new_name, int new_len); + +extern int meta_remove_r_entry(dentry_t *dentry, const char *name, int len); @@ -5500,21 +5500,21 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo.h +extern int __meta_put_d_list(inode_t *inode); +extern int __meta_put_r_list(inode_t *inode); + -+extern int meta_list_add_d_entry(dentry_t *dentry, ++extern int meta_list_add_d_entry(dentry_t *dentry, + const char *name, int len); -+extern int meta_list_add_r_entry(dentry_t *dentry, -+ const char *old_name, int old_len, ++extern int meta_list_add_r_entry(dentry_t *dentry, ++ const char *old_name, int old_len, + const char *new_name, int new_len); + -+extern int meta_list_remove_r_entry(dentry_t *dentry, ++extern int meta_list_remove_r_entry(dentry_t *dentry, + const char *name, int len); + -+extern int __meta_list_remove_r_entry(inode_t *inode, ++extern int __meta_list_remove_r_entry(inode_t *inode, + const char *name, int len); + +extern int meta_write_d_entry(dentry_t *dentry, const char *name, int len); -+extern int meta_write_r_entry(dentry_t *dentry, -+ const char *old_name, int old_len, ++extern int meta_write_r_entry(dentry_t *dentry, ++ const char *old_name, int old_len, + const char *new_name, int new_len); + +extern int meta_sync_lists(dentry_t *dentry); @@ -5524,7 +5524,7 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo.h +/* ndl stuff */ +extern int ndl_add_entry(struct readdir_data *rd, const char *name, int len); +extern void ndl_put_list(struct readdir_data *rd); -+extern int ndl_check_entry(struct readdir_data *rd, ++extern int ndl_check_entry(struct readdir_data *rd, + const char *name, int len); + + @@ -5762,7 +5762,7 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo-merge +# storage dir: $STO +# meta filename: $META_NAME +# dry run: $DRYRUN -+# verbose: $VERBOSE ++# verbose: $VERBOSE +# tmp files: $TMP +############################################################################### + @@ -5773,7 +5773,7 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo-merge +# first process all renamed dirs +echo "Merging renamed directories..." +pushd $STO &> /dev/null -+find . -name $META_NAME -type f -print0 | xargs -0 -e grep -e '^R ' | tr -s ':R' ' ' | while read ENTRY; do ++find . -name $META_NAME -type f -print0 | xargs -0 -e grep -e '^R ' | tr -s ':R' ' ' | while read ENTRY; do + echo "entry: $ENTRY" + META_FILE=`echo $ENTRY | cut -d ' ' -f 1` + OLD_B_DIR=`echo $ENTRY | cut -d ' ' -f 2 | sed -e 's/\///'` @@ -5797,7 +5797,7 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo-merge + +# delete all whiteouted files from base +echo -e "\nDeleting whiteout'ed files from base file system..." -+find . -name $META_NAME -type f -print0 | xargs -0 -e grep -e '^D ' | sed -e 's/:D//' | while read ENTRY; do ++find . -name $META_NAME -type f -print0 | xargs -0 -e grep -e '^D ' | sed -e 's/:D//' | while read ENTRY; do + META_FILE=`echo $ENTRY | cut -d ' ' -f 1` + DEL_NAME=`echo $ENTRY | cut -d ' ' -f 2` + DEL_FILE=`echo $META_FILE | sed -e "s/$META_NAME/$DEL_NAME/" | sed -e 's/^\.\///'` @@ -5833,11 +5833,11 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo-merge + pushd $BASE #&> /dev/null + COMMAND="cp -df $STO/$FILE $BASE/$FILE"; exec_command + popd &> /dev/null -+ done ++ done +done +popd &> /dev/null + -+#rm $TMP/$SKIP_DEL_LIST ++#rm $TMP/$SKIP_DEL_LIST + +echo "Done!" Index: linux-2.6.23/fs/mini_fo/mini_fo-overlay @@ -5862,7 +5862,7 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo-overlay +STO_DIR="/tmp" +BASE= + -+usage() ++usage() +{ +cat <<EOF + @@ -5870,7 +5870,7 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo-overlay +Version 0.1 + +This script overlays the given base directory using the mini_fo file -+system. If only the base directory base_dir is given, $0 ++system. If only the base directory base_dir is given, $0 +will use a storage directory called "sto-<base_dir_name>" in $STO_DIR, +and mount point "mini_fo-<base_dir_dir>" in $MNT_DIR. + @@ -5915,7 +5915,7 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo-overlay + exit -1 +fi + -+# fix suffix ++# fix suffix +if [ "x$SUFF" != "x" ]; then + SUFF="-$SUFF" +fi @@ -5969,7 +5969,7 @@ Index: linux-2.6.23/fs/mini_fo/mini_fo-overlay + exit -1 +fi + -+# mount ++# mount +mount -t mini_fo -o base=$BASE,sto=$STO $BASE $MNTP + +if [ $? -ne 0 ]; then @@ -6688,9 +6688,9 @@ Index: linux-2.6.23/fs/mini_fo/README +on it: + +load the module (as root) -+ ++ + # insmod mini_fo.o for a 2.4 kernel or -+ ++ + # insmod mini_fo.ko for a 2.6 kernel + + @@ -6854,7 +6854,7 @@ Index: linux-2.6.23/fs/mini_fo/RELEASE_NOTES + +v0-5-10-pre5: + -+- implemented directory deleting ++- implemented directory deleting +- made parsing of mount options more stable +- New format of mount options! (See README) +- I can't reproduce the unknown panic with 2.4.25 anymore, so I'll @@ -6864,10 +6864,10 @@ Index: linux-2.6.23/fs/mini_fo/RELEASE_NOTES +Implemented features: +--------------------- + -+- creating hard links (see BUGS on already existing hard links) ++- creating hard links (see BUGS on already existing hard links) +- lightweight directory renaming -+- renaming device files, pipes, sockets, etc. -+- creating, renaming, deleting of special files ++- renaming device files, pipes, sockets, etc. ++- creating, renaming, deleting of special files +- deleting directorys +- general directory reading (simple "ls" ) +- creating files in existing directorys @@ -6946,7 +6946,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c + printk(KERN_CRIT "mini_fo: create_sto_file: ERROR getting neg. sto dentry.\n"); + goto out; + } -+ ++ + dir = dentry->d_parent->d_inode; + hidden_sto_dentry = dtohd2(dentry); + @@ -7006,7 +7006,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c + } + itohi2(dentry->d_inode) = igrab(dtohd2(dentry)->d_inode); + } -+ fist_copy_attr_timesizes(dentry->d_parent->d_inode, ++ fist_copy_attr_timesizes(dentry->d_parent->d_inode, + hidden_sto_dir_dentry->d_inode); + + out_lock: @@ -7035,7 +7035,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c + err = -EINVAL; + goto out; + } -+ ++ + err = get_neg_sto_dentry(dentry); + if(err) { + err = -EINVAL; @@ -7057,7 +7057,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c + err = PTR_ERR(hidden_sto_dir_dentry); + if (IS_ERR(hidden_sto_dir_dentry)) + goto out; -+ ++ + err = vfs_mkdir(hidden_sto_dir_dentry->d_inode, + hidden_sto_dentry, + mode); @@ -7117,9 +7117,9 @@ Index: linux-2.6.23/fs/mini_fo/state.c +} + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) -+int create_sto_nod(dentry_t *dentry, int mode, dev_t dev) ++int create_sto_nod(dentry_t *dentry, int mode, dev_t dev) +#else -+int create_sto_nod(dentry_t *dentry, int mode, int dev) ++int create_sto_nod(dentry_t *dentry, int mode, int dev) +#endif +{ + int err = 0; @@ -7136,11 +7136,11 @@ Index: linux-2.6.23/fs/mini_fo/state.c + if (err) { + printk(KERN_CRIT "mini_fo: create_sto_nod: ERROR getting neg. sto dentry.\n"); + goto out; -+ } ++ } + + dir = dentry->d_parent->d_inode; + hidden_sto_dentry = dtohd2(dentry); -+ ++ + /* lock parent */ + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent); + @@ -7149,7 +7149,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c +#else + down(&hidden_sto_dir_dentry->d_inode->i_sem); +#endif -+ ++ + err = PTR_ERR(hidden_sto_dir_dentry); + if (IS_ERR(hidden_sto_dir_dentry)) + goto out; @@ -7202,7 +7202,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c +} + + -+/* unimplemented (and possibly not usefull): ++/* unimplemented (and possibly not usefull): + + nondir-del_to_del_rew + nondir-non_exist_to_creat @@ -7217,7 +7217,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c + + +/* bring a file of any type from state UNMODIFIED to MODIFIED */ -+int nondir_unmod_to_mod(dentry_t *dentry, int cp_flag) ++int nondir_unmod_to_mod(dentry_t *dentry, int cp_flag) +{ + int err = 0; + struct vfsmount *tgt_mnt; @@ -7243,7 +7243,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c + ERROR getting neg. sto dentry.\n"); + goto out; + } -+ ++ + /* create sto file */ + hidden_sto_dentry = dtohd2(dentry); + @@ -7268,7 +7268,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c + dtohd(dentry)->d_inode->i_mode, + dtohd(dentry)->d_inode->i_rdev); + } -+ ++ + else if(S_ISREG(dentry->d_inode->i_mode)) { + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) @@ -7296,8 +7296,8 @@ Index: linux-2.6.23/fs/mini_fo/state.c + } + + itohi2(dentry->d_inode) = igrab(dtohd2(dentry)->d_inode); -+ -+ fist_copy_attr_timesizes(dentry->d_parent->d_inode, ++ ++ fist_copy_attr_timesizes(dentry->d_parent->d_inode, + hidden_sto_dir_dentry->d_inode); + dtost(dentry) = MODIFIED; + @@ -7317,14 +7317,14 @@ Index: linux-2.6.23/fs/mini_fo/state.c + tgt_mnt = stopd(dentry->d_inode->i_sb)->hidden_mnt2; + src_dentry = dtohd(dentry); + src_mnt = stopd(dentry->d_inode->i_sb)->hidden_mnt; -+ -+ err = mini_fo_cp_cont(tgt_dentry, tgt_mnt, ++ ++ err = mini_fo_cp_cont(tgt_dentry, tgt_mnt, + src_dentry, src_mnt); + if(err) { + printk(KERN_CRIT "mini_fo: nondir_unmod_to_mod: \ + ERROR copying contents.\n"); + } -+ goto out; ++ goto out; + } + + out_lock: @@ -7344,17 +7344,17 @@ Index: linux-2.6.23/fs/mini_fo/state.c + return nondir_creat_to_del(dentry); +} + -+int nondir_creat_to_del(dentry_t *dentry) ++int nondir_creat_to_del(dentry_t *dentry) +{ + int err = 0; + + inode_t *hidden_sto_dir_inode; + dentry_t *hidden_sto_dir_dentry; + dentry_t *hidden_sto_dentry; -+ ++ + check_mini_fo_dentry(dentry); + -+ /* for now this function serves for both state DEL_REWRITTEN and ++ /* for now this function serves for both state DEL_REWRITTEN and + * CREATED */ + if(!(dtost(dentry) == CREATED || (dtost(dentry) == DEL_REWRITTEN)) || + S_ISDIR(dentry->d_inode->i_mode)) { @@ -7363,10 +7363,10 @@ Index: linux-2.6.23/fs/mini_fo/state.c + err = -1; + goto out; + } -+ ++ + hidden_sto_dir_inode = itohi2(dentry->d_parent->d_inode); + hidden_sto_dentry = dtohd2(dentry); -+ ++ + /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry);*/ + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent); + @@ -7375,19 +7375,19 @@ Index: linux-2.6.23/fs/mini_fo/state.c +#else + down(&hidden_sto_dir_dentry->d_inode->i_sem); +#endif -+ ++ + /* avoid destroying the hidden inode if the file is in use */ + dget(hidden_sto_dentry); + err = vfs_unlink(hidden_sto_dir_inode, hidden_sto_dentry); + dput(hidden_sto_dentry); + if(!err) + d_delete(hidden_sto_dentry); -+ ++ + /* propagate number of hard-links */ + dentry->d_inode->i_nlink = itohi2(dentry->d_inode)->i_nlink; -+ ++ + dtost(dentry) = NON_EXISTANT; -+ ++ + /* was: unlock_dir(hidden_sto_dir_dentry); */ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16) + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex); @@ -7395,7 +7395,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c + up(&hidden_sto_dir_dentry->d_inode->i_sem); +#endif + dput(hidden_sto_dir_dentry); -+ ++ + out: + return err; +} @@ -7406,7 +7406,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c + dentry_t *hidden_sto_dentry; + inode_t *hidden_sto_dir_inode; + dentry_t *hidden_sto_dir_dentry; -+ ++ + check_mini_fo_dentry(dentry); + + if(dtost(dentry) != MODIFIED || @@ -7419,7 +7419,7 @@ Index: linux-2.6.23/fs/mini_fo/state.c + + hidden_sto_dir_inode = itohi2(dentry->d_parent->d_inode); + hidden_sto_dentry = dtohd2(dentry); -+ ++ + /* was hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */ + hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent); + @@ -7428,17 +7428,17 @@ Index: linux-2.6.23/fs/mini_fo/state.c +#else + down(&hidden_sto_dir_dentry->d_inode->i_sem); +#endif -+ ++ + /* avoid destroying the hidden inode if the file is in use */ + dget(hidden_sto_dentry); + err = vfs_unlink(hidden_sto_dir_inode, hidden_sto_dentry); + dput(hidden_sto_dentry); + if(!err) + d_delete(hidden_sto_dentry); -+ ++ + /* propagate number of hard-links */ + dentry->d_inode->i_nlink = itohi2(dentry->d_inode)->i_nlink; -+ ++ + /* dput base dentry, this will relase the inode and free the + * dentry, as we will never need it again. */ + dput(dtohd(dentry)); @@ -7446,10 +7446,10 @@ Index: linux-2.6.23/fs/mini_fo/state.c + dtost(dentry) = DELETED; + + /* add deleted file to META-file */ -+ meta_add_d_entry(dentry->d_parent, -+ dentry->d_name.name, ++ meta_add_d_entry(dentry->d_parent, ++ dentry->d_name.name, + dentry->d_name.len); -+ ++ + /* was: unlock_dir(hidden_sto_dir_dentry); */ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16) + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex); @@ -7475,33 +7475,33 @@ Index: linux-2.6.23/fs/mini_fo/state.c + err = -1; + goto out; + } -+ ++ + /* next we have to get a negative dentry for the storage file */ + err = get_neg_sto_dentry(dentry); + + if(err) -+ goto out; ++ goto out; + + /* add deleted file to META lists */ -+ err = meta_add_d_entry(dentry->d_parent, -+ dentry->d_name.name, ++ err = meta_add_d_entry(dentry->d_parent, ++ dentry->d_name.name, + dentry->d_name.len); + + if(err) + goto out; -+ ++ + /* dput base dentry, this will relase the inode and free the + * dentry, as we will never need it again. */ + dput(dtohd(dentry)); + dtohd(dentry) = NULL; + dtost(dentry) = DELETED; -+ ++ + out: + return err; +} + +/* bring a dir from state UNMODIFIED to MODIFIED */ -+int dir_unmod_to_mod(dentry_t *dentry) ++int dir_unmod_to_mod(dentry_t *dentry) +{ + int err; + @@ -7556,12 +7556,12 @@ Index: linux-2.6.23/fs/mini_fo/super.c + +#ifdef HAVE_CONFIG_H +# include <config.h> -+#endif ++#endif + +#include "fist.h" +#include "mini_fo.h" + -+#if 0 ++ +STATIC void +mini_fo_read_inode(inode_t *inode) +{ @@ -7600,7 +7600,7 @@ Index: linux-2.6.23/fs/mini_fo/super.c + /* I don't think ->a_ops is ever allowed to be NULL */ + inode->i_mapping->a_ops = &mini_fo_empty_aops; +} -+#endif ++ + +#if defined(FIST_DEBUG) || defined(FIST_FILTER_SCA) +/* @@ -7664,7 +7664,7 @@ Index: linux-2.6.23/fs/mini_fo/super.c + mntput(stopd(sb)->hidden_mnt); + mntput(stopd(sb)->hidden_mnt2); + -+ /* mk: no! dput(stopd(sb)->base_dir_dentry); ++ /* mk: no! dput(stopd(sb)->base_dir_dentry); + dput(stopd(sb)->storage_dir_dentry); */ + + kfree(stopd(sb)); @@ -7798,7 +7798,7 @@ Index: linux-2.6.23/fs/mini_fo/super.c + +struct super_operations mini_fo_sops = +{ -+// read_inode: mini_fo_read_inode, ++ read_inode: mini_fo_read_inode, +#if defined(FIST_DEBUG) || defined(FIST_FILTER_SCA) + write_inode: mini_fo_write_inode, +#endif /* defined(FIST_DEBUG) || defined(FIST_FILTER_SCA) */ diff --git a/target/linux/generic-2.6/patches-2.6.25/210-mini_fo_2.6.25_fixes.patch b/target/linux/generic-2.6/patches-2.6.25/210-mini_fo_2.6.25_fixes.patch new file mode 100644 index 0000000..77c2ff3 --- /dev/null +++ b/target/linux/generic-2.6/patches-2.6.25/210-mini_fo_2.6.25_fixes.patch @@ -0,0 +1,151 @@ +Index: linux-2.6.25/fs/mini_fo/main.c +=================================================================== +--- linux-2.6.25.orig/fs/mini_fo/main.c ++++ linux-2.6.25/fs/mini_fo/main.c +@@ -79,6 +79,7 @@ mini_fo_tri_interpose(dentry_t *hidden_d + * of the new inode's fields + */ + ++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25) + /* + * original: inode = iget(sb, hidden_inode->i_ino); + */ +@@ -87,6 +88,13 @@ mini_fo_tri_interpose(dentry_t *hidden_d + err = -EACCES; /* should be impossible??? */ + goto out; + } ++#else ++ inode = mini_fo_iget(sb, iunique(sb, 25)); ++ if (IS_ERR(inode)) { ++ err = PTR_ERR(inode); ++ goto out; ++ } ++#endif + + /* + * interpose the inode if not already interposed +@@ -184,9 +192,9 @@ mini_fo_parse_options(super_block_t *sb, + hidden_root = ERR_PTR(err); + goto out; + } +- hidden_root = nd.dentry; +- stopd(sb)->base_dir_dentry = nd.dentry; +- stopd(sb)->hidden_mnt = nd.mnt; ++ hidden_root = nd_get_dentry(&nd); ++ stopd(sb)->base_dir_dentry = nd_get_dentry(&nd); ++ stopd(sb)->hidden_mnt = nd_get_mnt(&nd); + + } else if(!strncmp("sto=", options, 4)) { + /* parse the storage dir */ +@@ -204,9 +212,9 @@ mini_fo_parse_options(super_block_t *sb, + hidden_root2 = ERR_PTR(err); + goto out; + } +- hidden_root2 = nd2.dentry; +- stopd(sb)->storage_dir_dentry = nd2.dentry; +- stopd(sb)->hidden_mnt2 = nd2.mnt; ++ hidden_root2 = nd_get_dentry(&nd2); ++ stopd(sb)->storage_dir_dentry = nd_get_dentry(&nd2); ++ stopd(sb)->hidden_mnt2 = nd_get_mnt(&nd2); + stohs2(sb) = hidden_root2->d_sb; + + /* validate storage dir, this is done in +Index: linux-2.6.25/fs/mini_fo/mini_fo.h +=================================================================== +--- linux-2.6.25.orig/fs/mini_fo/mini_fo.h ++++ linux-2.6.25/fs/mini_fo/mini_fo.h +@@ -302,6 +302,10 @@ extern int mini_fo_tri_interpose(dentry_ + extern int mini_fo_cp_cont(dentry_t *tgt_dentry, struct vfsmount *tgt_mnt, + dentry_t *src_dentry, struct vfsmount *src_mnt); + ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25) ++extern struct inode *mini_fo_iget(struct super_block *sb, unsigned long ino); ++#endif ++ + #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) + extern int mini_fo_create(inode_t *dir, dentry_t *dentry, int mode, struct nameidata *nd); + +@@ -501,6 +505,29 @@ static inline void double_unlock(struct + #endif /* if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) */ + #endif /* __KERNEL__ */ + ++ ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25) ++static inline dentry_t *nd_get_dentry(struct nameidata *nd) ++{ ++ return (nd->path.dentry); ++} ++ ++static inline struct vfsmount *nd_get_mnt(struct nameidata *nd) ++{ ++ return (nd->path.mnt); ++} ++#else ++static inline dentry_t *nd_get_dentry(struct nameidata *nd) ++{ ++ return (nd->dentry); ++} ++ ++static inline struct vfsmount *nd_get_mnt(struct nameidata *nd) ++{ ++ return (nd->mnt); ++} ++#endif ++ + /* + * Definitions for user and kernel code + */ +Index: linux-2.6.25/fs/mini_fo/super.c +=================================================================== +--- linux-2.6.25.orig/fs/mini_fo/super.c ++++ linux-2.6.25/fs/mini_fo/super.c +@@ -262,10 +262,31 @@ mini_fo_umount_begin(super_block_t *sb) + } + #endif + ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25) ++struct inode * ++mini_fo_iget(struct super_block *sb, unsigned long ino) ++{ ++ struct inode *inode; ++ ++ inode = iget_locked(sb, ino); ++ if (!inode) ++ return ERR_PTR(-ENOMEM); ++ ++ if (!(inode->i_state & I_NEW)) ++ return inode; ++ ++ mini_fo_read_inode(inode); ++ ++ unlock_new_inode(inode); ++ return inode; ++} ++#endif /* if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25) */ + + struct super_operations mini_fo_sops = + { ++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25) + read_inode: mini_fo_read_inode, ++#endif + #if defined(FIST_DEBUG) || defined(FIST_FILTER_SCA) + write_inode: mini_fo_write_inode, + #endif /* defined(FIST_DEBUG) || defined(FIST_FILTER_SCA) */ +Index: linux-2.6.25/fs/mini_fo/aux.c +=================================================================== +--- linux-2.6.25.orig/fs/mini_fo/aux.c ++++ linux-2.6.25/fs/mini_fo/aux.c +@@ -164,11 +164,11 @@ dentry_t *bpath_walk(super_block_t *sb, + err = vfs_path_lookup(mnt->mnt_root, mnt, bpath+1, 0, &nd); + + /* validate */ +- if (err || !nd.dentry || !nd.dentry->d_inode) { ++ if (err || !nd_get_dentry(&nd) || !nd_get_dentry(&nd)->d_inode) { + printk(KERN_CRIT "mini_fo: bpath_walk: path_walk failed.\n"); + return NULL; + } +- return nd.dentry; ++ return nd_get_dentry(&nd); + } + + |