fs/jffs2/fs.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright (C) 2001, 2002 Red Hat, Inc.
   5  *
   6  * Created by David Woodhouse <dwmw2@cambridge.redhat.com>
   7  *
   8  * For licensing information, see the file 'LICENCE' in this directory.
   9  *
  10  * $Id: fs.c,v 1.24 2003/04/29 09:52:58 dwmw2 Exp $
  11  *
  12  */
  13
  14 #include <linux/config.h>
  15 #include <linux/kernel.h>
  16 #include <linux/sched.h>
  17 #include <linux/fs.h>
  18 #include <linux/list.h>
  19 #include <linux/mtd/mtd.h>
  20 #include <linux/pagemap.h>
  21 #include <linux/slab.h>
  22 #include <linux/vfs.h>
  23 #include "nodelist.h"
  24
  25 int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
  26 {
  27         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
  28         unsigned long avail;
  29
  30         buf->f_type = JFFS2_SUPER_MAGIC;
  31         buf->f_bsize = 1 << PAGE_SHIFT;
  32         buf->f_blocks = c->flash_size >> PAGE_SHIFT;
  33         buf->f_files = 0;
  34         buf->f_ffree = 0;
  35         buf->f_namelen = JFFS2_MAX_NAME_LEN;
  36
  37         spin_lock(&c->erase_completion_lock);
  38
  39         avail = c->dirty_size + c->free_size;
  40         if (avail > c->sector_size * JFFS2_RESERVED_BLOCKS_WRITE)
  41                 avail -= c->sector_size * JFFS2_RESERVED_BLOCKS_WRITE;
  42         else
  43                 avail = 0;
  44
  45         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
  46
  47         D1(jffs2_dump_block_lists(c));
  48
  49         spin_unlock(&c->erase_completion_lock);
  50
  51         return 0;
  52 }
  53
  54
  55 void jffs2_clear_inode (struct inode *inode)
  56 {
  57         /* We can forget about this inode for now - drop all
  58          *  the nodelists associated with it, etc.
  59          */
  60         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  61         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  62
  63         D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
  64
  65         jffs2_do_clear_inode(c, f);
  66 }
  67
  68 void jffs2_read_inode (struct inode *inode)
  69 {
  70         struct jffs2_inode_info *f;
  71         struct jffs2_sb_info *c;
  72         struct jffs2_raw_inode latest_node;
  73         int ret;
  74
  75         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
  76
  77         f = JFFS2_INODE_INFO(inode);
  78         c = JFFS2_SB_INFO(inode->i_sb);
  79
  80         jffs2_init_inode_info(f);
  81
  82         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
  83
  84         if (ret) {
  85                 make_bad_inode(inode);
  86                 up(&f->sem);
  87                 return;
  88         }
  89         inode->i_mode = jemode_to_cpu(latest_node.mode);
  90         inode->i_uid = je16_to_cpu(latest_node.uid);
  91         inode->i_gid = je16_to_cpu(latest_node.gid);
  92         inode->i_size = je32_to_cpu(latest_node.isize);
  93         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
  94         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
  95         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
  96
  97         inode->i_nlink = f->inocache->nlink;
  98
  99         inode->i_blksize = PAGE_SIZE;
 100         inode->i_blocks = (inode->i_size + 511) >> 9;
 101
 102         switch (inode->i_mode & S_IFMT) {
 103                 jint16_t rdev;
 104
 105         case S_IFLNK:
 106                 inode->i_op = &jffs2_symlink_inode_operations;
 107                 break;
 108
 109         case S_IFDIR:
 110         {
 111                 struct jffs2_full_dirent *fd;
 112
 113                 for (fd=f->dents; fd; fd = fd->next) {
 114                         if (fd->type == DT_DIR && fd->ino)
 115                                 inode->i_nlink++;
 116                 }
 117                 /* and '..' */
 118                 inode->i_nlink++;
 119                 /* Root dir gets i_nlink 3 for some reason */
 120                 if (inode->i_ino == 1)
 121                         inode->i_nlink++;
 122
 123                 inode->i_op = &jffs2_dir_inode_operations;
 124                 inode->i_fop = &jffs2_dir_operations;
 125                 break;
 126         }
 127         case S_IFREG:
 128                 inode->i_op = &jffs2_file_inode_operations;
 129                 inode->i_fop = &jffs2_file_operations;
 130                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
 131                 inode->i_mapping->nrpages = 0;
 132                 break;
 133
 134         case S_IFBLK:
 135         case S_IFCHR:
 136                 /* Read the device numbers from the media */
 137                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
 138                 if (jffs2_read_dnode(c, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
 139                         /* Eep */
 140                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
 141                         up(&f->sem);
 142                         jffs2_do_clear_inode(c, f);
 143                         make_bad_inode(inode);
 144                         return;
 145                 }
 146
 147         case S_IFSOCK:
 148         case S_IFIFO:
 149                 inode->i_op = &jffs2_file_inode_operations;
 150                 init_special_inode(inode, inode->i_mode, kdev_t_to_nr(mk_kdev(je16_to_cpu(rdev)>>8, je16_to_cpu(rdev)&0xff)));
 151                 break;
 152
 153         default:
 154                 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
 155         }
 156
 157         up(&f->sem);
 158
 159         D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
 160 }
 161
 162
 163 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
 164 {
 165         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 166
 167         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 168                 return -EROFS;
 169
 170         /* We stop if it was running, then restart if it needs to.
 171            This also catches the case where it was stopped and this
 172            is just a remount to restart it */
 173         if (!(sb->s_flags & MS_RDONLY))
 174                 jffs2_stop_garbage_collect_thread(c);
 175
 176         if (!(*flags & MS_RDONLY))
 177                 jffs2_start_garbage_collect_thread(c);
 178
 179         sb->s_flags = (sb->s_flags & ~MS_RDONLY)|(*flags & MS_RDONLY);
 180
 181         return 0;
 182 }
 183
 184 void jffs2_write_super (struct super_block *sb)
 185 {
 186         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 187         sb->s_dirt = 0;
 188
 189         if (sb->s_flags & MS_RDONLY)
 190                 return;
 191
 192         D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
 193         jffs2_garbage_collect_trigger(c);
 194         jffs2_erase_pending_blocks(c);
 195 }
 196
 197
 198 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 199    fill in the raw_inode while you're at it. */
 200 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
 201 {
 202         struct inode *inode;
 203         struct super_block *sb = dir_i->i_sb;
 204         struct jffs2_sb_info *c;
 205         struct jffs2_inode_info *f;
 206         int ret;
 207
 208         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
 209
 210         c = JFFS2_SB_INFO(sb);
 211
 212         inode = new_inode(sb);
 213
 214         if (!inode)
 215                 return ERR_PTR(-ENOMEM);
 216
 217         f = JFFS2_INODE_INFO(inode);
 218         jffs2_init_inode_info(f);
 219
 220         memset(ri, 0, sizeof(*ri));
 221         /* Set OS-specific defaults for new inodes */
 222         ri->uid = cpu_to_je16(current->fsuid);
 223
 224         if (dir_i->i_mode & S_ISGID) {
 225                 ri->gid = cpu_to_je16(dir_i->i_gid);
 226                 if (S_ISDIR(mode))
 227                         mode |= S_ISGID;
 228         } else {
 229                 ri->gid = cpu_to_je16(current->fsgid);
 230         }
 231         ri->mode =  cpu_to_jemode(mode);
 232         ret = jffs2_do_new_inode (c, f, mode, ri);
 233         if (ret) {
 234                 make_bad_inode(inode);
 235                 iput(inode);
 236                 return ERR_PTR(ret);
 237         }
 238         inode->i_nlink = 1;
 239         inode->i_ino = je32_to_cpu(ri->ino);
 240         inode->i_mode = jemode_to_cpu(ri->mode);
 241         inode->i_gid = je16_to_cpu(ri->gid);
 242         inode->i_uid = je16_to_cpu(ri->uid);
 243         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME;
 244         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 245
 246         inode->i_blksize = PAGE_SIZE;
 247         inode->i_blocks = 0;
 248         inode->i_size = 0;
 249
 250         insert_inode_hash(inode);
 251
 252         return inode;
 253 }
 254
 255
 256 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 257 {
 258         struct jffs2_sb_info *c;
 259         struct inode *root_i;
 260         int ret;
 261         size_t blocks;
 262
 263         c = JFFS2_SB_INFO(sb);
 264
 265         c->flash_size = c->mtd->size;
 266
 267         /*
 268          * Check, if we have to concatenate physical blocks to larger virtual blocks
 269          * to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation)
 270          */
 271         blocks = c->flash_size / c->mtd->erasesize;
 272         while ((blocks * sizeof (struct jffs2_eraseblock)) > (128 * 1024))
 273                 blocks >>= 1;
 274
 275         c->sector_size = c->flash_size / blocks;
 276         if (c->sector_size != c->mtd->erasesize)
 277                 printk(KERN_INFO "jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n",
 278                         c->mtd->erasesize / 1024, c->sector_size / 1024);
 279
 280         if (c->flash_size < 5*c->sector_size) {
 281                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 282                 return -EINVAL;
 283         }
 284
 285         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 286         /* Joern -- stick alignment for weird 8-byte-page flash here */
 287
 288         if (jffs2_cleanmarker_oob(c)) {
 289                 /* Cleanmarker is out-of-band, so inline size zero */
 290                 c->cleanmarker_size = 0;
 291         }
 292
 293         if (c->mtd->type == MTD_NANDFLASH) {
 294                 /* Initialise write buffer */
 295                 c->wbuf_pagesize = c->mtd->oobblock;
 296                 c->wbuf_ofs = 0xFFFFFFFF;
 297                 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
 298                 if (!c->wbuf)
 299                         return -ENOMEM;
 300
 301                 /* Initialise process for timed wbuf flush */
 302                 INIT_WORK(&c->wbuf_task,(void*) jffs2_wbuf_process, (void *)c);
 303
 304                 /* Initialise timer for timed wbuf flush */
 305                 init_timer(&c->wbuf_timer);
 306                 c->wbuf_timer.function = jffs2_wbuf_timeout;
 307                 c->wbuf_timer.data = (unsigned long) c;
 308         }
 309
 310         c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 311         if (!c->inocache_list) {
 312                 ret = -ENOMEM;
 313                 goto out_wbuf;
 314         }
 315         memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
 316
 317         if ((ret = jffs2_do_mount_fs(c)))
 318                 goto out_inohash;
 319
 320         ret = -EINVAL;
 321
 322         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 323         root_i = iget(sb, 1);
 324         if (is_bad_inode(root_i)) {
 325                 D1(printk(KERN_WARNING "get root inode failed\n"));
 326                 goto out_nodes;
 327         }
 328
 329         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 330         sb->s_root = d_alloc_root(root_i);
 331         if (!sb->s_root)
 332                 goto out_root_i;
 333
 334 #if LINUX_VERSION_CODE >= 0x20403
 335         sb->s_maxbytes = 0xFFFFFFFF;
 336 #endif
 337         sb->s_blocksize = PAGE_CACHE_SIZE;
 338         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 339         sb->s_magic = JFFS2_SUPER_MAGIC;
 340         if (!(sb->s_flags & MS_RDONLY))
 341                 jffs2_start_garbage_collect_thread(c);
 342         return 0;
 343
 344  out_root_i:
 345         iput(root_i);
 346  out_nodes:
 347         jffs2_free_ino_caches(c);
 348         jffs2_free_raw_node_refs(c);
 349         kfree(c->blocks);
 350  out_inohash:
 351         kfree(c->inocache_list);
 352  out_wbuf:
 353         if (c->wbuf)
 354                 kfree(c->wbuf);
 355         return ret;
 356 }