[JFFS2] Use f->target instead of f->dents for symlink target

JFFS2 uses f->dents to store the pointer to the symlink target string (in case
the inode is symlink). This is somewhat ugly to use the same field for
different reasons. Introduce distinct field f->target for this purpose.
Note, f->fragtree, f->dents, f->target may probably be put in a union.

Signed-off-by: Artem B. Bityutskiy <dedekind@infradead.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index 3ca0d25eef1d529f82da3ec83d1644c331d629f6..5738df22377539af543e971dc5cd55f96787f304 100644 (file)
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: dir.c,v 1.86 2005/07/06 12:13:09 dwmw2 Exp $
+ * $Id: dir.c,v 1.87 2005/07/17 11:13:46 dedekind Exp $
  *
  */
 
@@ -344,9 +344,9 @@ static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char
                return PTR_ERR(fn);
        }
 
-       /* We use f->dents field to store the target path. */
-       f->dents = kmalloc(targetlen + 1, GFP_KERNEL);
-       if (!f->dents) {
+       /* We use f->target field to store the target path. */
+       f->target = kmalloc(targetlen + 1, GFP_KERNEL);
+       if (!f->target) {
                printk(KERN_WARNING "Can't allocate %d bytes of memory\n", targetlen + 1);
                up(&f->sem);
                jffs2_complete_reservation(c);
@@ -354,8 +354,8 @@ static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char
                return -ENOMEM;
        }
 
-       memcpy(f->dents, target, targetlen + 1);
-       D1(printk(KERN_DEBUG "jffs2_symlink: symlink's target '%s' cached\n", (char *)f->dents));
+       memcpy(f->target, target, targetlen + 1);
+       D1(printk(KERN_DEBUG "jffs2_symlink: symlink's target '%s' cached\n", (char *)f->target));
 
        /* No data here. Only a metadata node, which will be 
           obsoleted by the first data write

diff --git a/fs/jffs2/os-linux.h b/fs/jffs2/os-linux.h
index d900c8929b09983cca227d2deeb1658ac0913b0b..0fc952eaf8c8d439c1d6ab44b08b6991c8a1612c 100644 (file)
--- a/fs/jffs2/os-linux.h
+++ b/fs/jffs2/os-linux.h
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: os-linux.h,v 1.58 2005/07/12 02:34:35 tpoynor Exp $
+ * $Id: os-linux.h,v 1.59 2005/07/17 11:13:46 dedekind Exp $
  *
  */
 
@@ -57,6 +57,7 @@ static inline void jffs2_init_inode_info(struct jffs2_inode_info *f)
        f->fragtree = RB_ROOT;
        f->metadata = NULL;
        f->dents = NULL;
+       f->target = NULL;
        f->flags = 0;
        f->usercompr = 0;
 }

diff --git a/fs/jffs2/readinode.c b/fs/jffs2/readinode.c
index cf39bcf3e3cf6634bf091b499836749f2deeeaf1..49da1a6cfc81d69a892bf94165d45ee12e68bf91 100644 (file)
--- a/fs/jffs2/readinode.c
+++ b/fs/jffs2/readinode.c
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: readinode.c,v 1.126 2005/07/17 06:56:21 dedekind Exp $
+ * $Id: readinode.c,v 1.127 2005/07/17 11:13:46 dedekind Exp $
  *
  */
 
@@ -547,11 +547,10 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
 
                if (f->inocache->state != INO_STATE_CHECKING) {
                        /* Symlink's inode data is the target path. Read it and
-                        * keep in RAM to facilitate quick follow symlink operation.
-                        * We use f->dents field to store the target path, which
-                        * is somewhat ugly. */
-                       f->dents = kmalloc(je32_to_cpu(latest_node->csize) + 1, GFP_KERNEL);
-                       if (!f->dents) {
+                        * keep in RAM to facilitate quick follow symlink
+                        * operation. */
+                       f->target = kmalloc(je32_to_cpu(latest_node->csize) + 1, GFP_KERNEL);
+                       if (!f->target) {
                                printk(KERN_WARNING "Can't allocate %d bytes of memory "
                                                "for the symlink target path cache\n",
                                                je32_to_cpu(latest_node->csize));
@@ -561,21 +560,21 @@ static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c,
                        }
                        
                        ret = jffs2_flash_read(c, ref_offset(fn->raw) + sizeof(*latest_node),
-                                               je32_to_cpu(latest_node->csize), &retlen, (char *)f->dents);
+                                               je32_to_cpu(latest_node->csize), &retlen, (char *)f->target);
                        
                        if (ret  || retlen != je32_to_cpu(latest_node->csize)) {
                                if (retlen != je32_to_cpu(latest_node->csize))
                                        ret = -EIO;
-                               kfree(f->dents);
-                               f->dents = NULL;
+                               kfree(f->target);
+                               f->target = NULL;
                                up(&f->sem);
                                jffs2_do_clear_inode(c, f);
                                return -ret;
                        }
 
-                       ((char *)f->dents)[je32_to_cpu(latest_node->csize)] = '\0';
+                       f->target[je32_to_cpu(latest_node->csize)] = '\0';
                        D1(printk(KERN_DEBUG "jffs2_do_read_inode(): symlink's target '%s' cached\n",
-                                               (char *)f->dents));
+                                               f->target));
                }
                
                /* fall through... */
@@ -638,20 +637,16 @@ void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
 
        jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
 
-       /* For symlink inodes we us f->dents to store the target path name */
-       if (S_ISLNK(OFNI_EDONI_2SFFJ(f)->i_mode)) {
-               if (f->dents) {
-                       kfree(f->dents);
-                       f->dents = NULL;
-               }
-       } else {
-               fds = f->dents;
-
-               while(fds) {
-                       fd = fds;
-                       fds = fd->next;
-                       jffs2_free_full_dirent(fd);
-               }
+       if (f->target) {
+               kfree(f->target);
+               f->target = NULL;
+       }
+       
+       fds = f->dents;
+       while(fds) {
+               fd = fds;
+               fds = fd->next;
+               jffs2_free_full_dirent(fd);
        }
 
        if (f->inocache && f->inocache->state != INO_STATE_CHECKING) {

diff --git a/fs/jffs2/symlink.c b/fs/jffs2/symlink.c
index 82ef484f5e12337ba1cc190e30275e0ebe7a9e16..6fd5ee4f90b737af87395ad8ba9ee4fc03f03832 100644 (file)
--- a/fs/jffs2/symlink.c
+++ b/fs/jffs2/symlink.c
@@ -7,7 +7,7 @@
  *
  * For licensing information, see the file 'LICENCE' in this directory.
  *
- * $Id: symlink.c,v 1.16 2005/03/01 10:50:48 dedekind Exp $
+ * $Id: symlink.c,v 1.18 2005/11/06 11:03:27 gleixner Exp $
  *
  */
 
@@ -30,35 +30,33 @@ struct inode_operations jffs2_symlink_inode_operations =
 static void *jffs2_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
        struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode);
-       char *p = (char *)f->dents;
-       
+       char *p = (char *)f->target;
+
        /*
         * We don't acquire the f->sem mutex here since the only data we
-        * use is f->dents which in case of the symlink inode points to the
-        * symlink's target path.
+        * use is f->target.
         *
-        * 1. If we are here the inode has already built and f->dents has
+        * 1. If we are here the inode has already built and f->target has
         * to point to the target path.
-        * 2. Nobody uses f->dents (if the inode is symlink's inode). The
-        * exception is inode freeing function which frees f->dents. But
+        * 2. Nobody uses f->target (if the inode is symlink's inode). The
+        * exception is inode freeing function which frees f->target. But
         * it can't be called while we are here and before VFS has
-        * stopped using our f->dents string which we provide by means of
+        * stopped using our f->target string which we provide by means of
         * nd_set_link() call.
         */
        
        if (!p) {
                printk(KERN_ERR "jffs2_follow_link(): can't find symlink taerget\n");
                p = ERR_PTR(-EIO);
-       } else {
-               D1(printk(KERN_DEBUG "jffs2_follow_link(): target path is '%s'\n", (char *) f->dents));
        }
+       D1(printk(KERN_DEBUG "jffs2_follow_link(): target path is '%s'\n", (char *) f->target));
 
        nd_set_link(nd, p);
        
        /*
-        * We unlock the f->sem mutex but VFS will use the f->dents string. This is safe
-        * since the only way that may cause f->dents to be changed is iput() operation.
-        * But VFS will not use f->dents after iput() has been called.
+        * We will unlock the f->sem mutex but VFS will use the f->target string. This is safe
+        * since the only way that may cause f->target to be changed is iput() operation.
+        * But VFS will not use f->target after iput() has been called.
         */
        return NULL;
 }

diff --git a/include/linux/jffs2_fs_i.h b/include/linux/jffs2_fs_i.h
index 6dbb1cce66460504deeb0bd15245eadfe3ed64ec..a5db884ec607a2626982a6d791ec9e72c5dfa23d 100644 (file)
--- a/include/linux/jffs2_fs_i.h
+++ b/include/linux/jffs2_fs_i.h
@@ -1,4 +1,4 @@
-/* $Id: jffs2_fs_i.h,v 1.17 2004/11/11 23:51:27 dwmw2 Exp $ */
+/* $Id: jffs2_fs_i.h,v 1.18 2005/07/17 11:13:48 dedekind Exp $ */
 
 #ifndef _JFFS2_FS_I
 #define _JFFS2_FS_I
@@ -32,6 +32,9 @@ struct jffs2_inode_info {
        /* Directory entries */
        struct jffs2_full_dirent *dents;
 
+       /* The target path if this is the inode of a symlink */
+       unsigned char *target;
+
        /* Some stuff we just have to keep in-core at all times, for each inode. */
        struct jffs2_inode_cache *inocache;