fs/jffs2/fs.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright (C) 2001-2003 Red Hat, Inc.
   5  *
   6  * Created by David Woodhouse <dwmw2@redhat.com>
   7  *
   8  * For licensing information, see the file 'LICENCE' in this directory.
   9  *
  10  * $Id: fs.c,v 1.32 2003/10/11 11:47:23 dwmw2 Exp $
  11  *
  12  */
  13
  14 #include <linux/version.h>
  15 #include <linux/config.h>
  16 #include <linux/kernel.h>
  17 #include <linux/sched.h>
  18 #include <linux/fs.h>
  19 #include <linux/list.h>
  20 #include <linux/mtd/mtd.h>
  21 #include <linux/pagemap.h>
  22 #include <linux/slab.h>
  23 #include <linux/vfs.h>
  24 #include <linux/crc32.h>
  25 #include "nodelist.h"
  26
  27
  28 static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
  29 {
  30         struct jffs2_full_dnode *old_metadata, *new_metadata;
  31         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  32         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  33         struct jffs2_raw_inode *ri;
  34         unsigned short dev;
  35         unsigned char *mdata = NULL;
  36         int mdatalen = 0;
  37         unsigned int ivalid;
  38         uint32_t phys_ofs, alloclen;
  39         int ret;
  40         D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
  41         ret = inode_change_ok(inode, iattr);
  42         if (ret)
  43                 return ret;
  44
  45         /* Special cases - we don't want more than one data node
  46            for these types on the medium at any time. So setattr
  47            must read the original data associated with the node
  48            (i.e. the device numbers or the target name) and write
  49            it out again with the appropriate data attached */
  50         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
  51                 /* For these, we don't actually need to read the old node */
  52                 dev = old_encode_dev(inode->i_rdev);
  53                 mdata = (char *)&dev;
  54                 mdatalen = sizeof(dev);
  55                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
  56         } else if (S_ISLNK(inode->i_mode)) {
  57                 mdatalen = f->metadata->size;
  58                 mdata = kmalloc(f->metadata->size, GFP_USER);
  59                 if (!mdata)
  60                         return -ENOMEM;
  61                 ret = jffs2_read_dnode(c, f->metadata, mdata, 0, mdatalen);
  62                 if (ret) {
  63                         kfree(mdata);
  64                         return ret;
  65                 }
  66                 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
  67         }
  68
  69         ri = jffs2_alloc_raw_inode();
  70         if (!ri) {
  71                 if (S_ISLNK(inode->i_mode))
  72                         kfree(mdata);
  73                 return -ENOMEM;
  74         }
  75
  76         ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen, ALLOC_NORMAL);
  77         if (ret) {
  78                 jffs2_free_raw_inode(ri);
  79                 if (S_ISLNK(inode->i_mode & S_IFMT))
  80                          kfree(mdata);
  81                 return ret;
  82         }
  83         down(&f->sem);
  84         ivalid = iattr->ia_valid;
  85
  86         ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
  87         ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
  88         ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
  89         ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
  90
  91         ri->ino = cpu_to_je32(inode->i_ino);
  92         ri->version = cpu_to_je32(++f->highest_version);
  93
  94         ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
  95         ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
  96
  97         if (ivalid & ATTR_MODE)
  98                 if (iattr->ia_mode & S_ISGID &&
  99                     !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))
 100                         ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);
 101                 else
 102                         ri->mode = cpu_to_jemode(iattr->ia_mode);
 103         else
 104                 ri->mode = cpu_to_jemode(inode->i_mode);
 105
 106
 107         ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
 108         ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
 109         ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
 110         ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
 111
 112         ri->offset = cpu_to_je32(0);
 113         ri->csize = ri->dsize = cpu_to_je32(mdatalen);
 114         ri->compr = JFFS2_COMPR_NONE;
 115         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 116                 /* It's an extension. Make it a hole node */
 117                 ri->compr = JFFS2_COMPR_ZERO;
 118                 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
 119                 ri->offset = cpu_to_je32(inode->i_size);
 120         }
 121         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 122         if (mdatalen)
 123                 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
 124         else
 125                 ri->data_crc = cpu_to_je32(0);
 126
 127         new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, phys_ofs, ALLOC_NORMAL);
 128         if (S_ISLNK(inode->i_mode))
 129                 kfree(mdata);
 130
 131         if (IS_ERR(new_metadata)) {
 132                 jffs2_complete_reservation(c);
 133                 jffs2_free_raw_inode(ri);
 134                 up(&f->sem);
 135                 return PTR_ERR(new_metadata);
 136         }
 137         /* It worked. Update the inode */
 138         inode->i_atime = ITIME(je32_to_cpu(ri->atime));
 139         inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
 140         inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
 141         inode->i_mode = jemode_to_cpu(ri->mode);
 142         inode->i_uid = je16_to_cpu(ri->uid);
 143         inode->i_gid = je16_to_cpu(ri->gid);
 144
 145
 146         old_metadata = f->metadata;
 147
 148         if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
 149                 vmtruncate(inode, iattr->ia_size);
 150                 jffs2_truncate_fraglist (c, &f->fragtree, iattr->ia_size);
 151         }
 152
 153         if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 154                 jffs2_add_full_dnode_to_inode(c, f, new_metadata);
 155                 inode->i_size = iattr->ia_size;
 156                 f->metadata = NULL;
 157         } else {
 158                 f->metadata = new_metadata;
 159         }
 160         if (old_metadata) {
 161                 jffs2_mark_node_obsolete(c, old_metadata->raw);
 162                 jffs2_free_full_dnode(old_metadata);
 163         }
 164         jffs2_free_raw_inode(ri);
 165
 166         up(&f->sem);
 167         jffs2_complete_reservation(c);
 168
 169         return 0;
 170 }
 171
 172 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 173 {
 174         return jffs2_do_setattr(dentry->d_inode, iattr);
 175 }
 176
 177 int jffs2_statfs(struct super_block *sb, struct kstatfs *buf)
 178 {
 179         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 180         unsigned long avail;
 181
 182         buf->f_type = JFFS2_SUPER_MAGIC;
 183         buf->f_bsize = 1 << PAGE_SHIFT;
 184         buf->f_blocks = c->flash_size >> PAGE_SHIFT;
 185         buf->f_files = 0;
 186         buf->f_ffree = 0;
 187         buf->f_namelen = JFFS2_MAX_NAME_LEN;
 188
 189         spin_lock(&c->erase_completion_lock);
 190
 191         avail = c->dirty_size + c->free_size;
 192         if (avail > c->sector_size * c->resv_blocks_write)
 193                 avail -= c->sector_size * c->resv_blocks_write;
 194         else
 195                 avail = 0;
 196
 197         buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 198
 199         D1(jffs2_dump_block_lists(c));
 200
 201         spin_unlock(&c->erase_completion_lock);
 202
 203         return 0;
 204 }
 205
 206
 207 void jffs2_clear_inode (struct inode *inode)
 208 {
 209         /* We can forget about this inode for now - drop all
 210          *  the nodelists associated with it, etc.
 211          */
 212         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 213         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 214
 215         D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
 216
 217         jffs2_do_clear_inode(c, f);
 218 }
 219
 220 void jffs2_read_inode (struct inode *inode)
 221 {
 222         struct jffs2_inode_info *f;
 223         struct jffs2_sb_info *c;
 224         struct jffs2_raw_inode latest_node;
 225         int ret;
 226
 227         D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
 228
 229         f = JFFS2_INODE_INFO(inode);
 230         c = JFFS2_SB_INFO(inode->i_sb);
 231
 232         jffs2_init_inode_info(f);
 233
 234         ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 235
 236         if (ret) {
 237                 make_bad_inode(inode);
 238                 up(&f->sem);
 239                 return;
 240         }
 241         inode->i_mode = jemode_to_cpu(latest_node.mode);
 242         inode->i_uid = je16_to_cpu(latest_node.uid);
 243         inode->i_gid = je16_to_cpu(latest_node.gid);
 244         inode->i_size = je32_to_cpu(latest_node.isize);
 245         inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 246         inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 247         inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 248
 249         inode->i_nlink = f->inocache->nlink;
 250
 251         inode->i_blksize = PAGE_SIZE;
 252         inode->i_blocks = (inode->i_size + 511) >> 9;
 253
 254         switch (inode->i_mode & S_IFMT) {
 255                 jint16_t rdev;
 256
 257         case S_IFLNK:
 258                 inode->i_op = &jffs2_symlink_inode_operations;
 259                 break;
 260
 261         case S_IFDIR:
 262         {
 263                 struct jffs2_full_dirent *fd;
 264
 265                 for (fd=f->dents; fd; fd = fd->next) {
 266                         if (fd->type == DT_DIR && fd->ino)
 267                                 inode->i_nlink++;
 268                 }
 269                 /* and '..' */
 270                 inode->i_nlink++;
 271                 /* Root dir gets i_nlink 3 for some reason */
 272                 if (inode->i_ino == 1)
 273                         inode->i_nlink++;
 274
 275                 inode->i_op = &jffs2_dir_inode_operations;
 276                 inode->i_fop = &jffs2_dir_operations;
 277                 break;
 278         }
 279         case S_IFREG:
 280                 inode->i_op = &jffs2_file_inode_operations;
 281                 inode->i_fop = &jffs2_file_operations;
 282                 inode->i_mapping->a_ops = &jffs2_file_address_operations;
 283                 inode->i_mapping->nrpages = 0;
 284                 break;
 285
 286         case S_IFBLK:
 287         case S_IFCHR:
 288                 /* Read the device numbers from the media */
 289                 D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
 290                 if (jffs2_read_dnode(c, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) {
 291                         /* Eep */
 292                         printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
 293                         up(&f->sem);
 294                         jffs2_do_clear_inode(c, f);
 295                         make_bad_inode(inode);
 296                         return;
 297                 }
 298
 299         case S_IFSOCK:
 300         case S_IFIFO:
 301                 inode->i_op = &jffs2_file_inode_operations;
 302                 init_special_inode(inode, inode->i_mode,
 303                                    old_decode_dev((je16_to_cpu(rdev))));
 304                 break;
 305
 306         default:
 307                 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
 308         }
 309
 310         up(&f->sem);
 311
 312         D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
 313 }
 314
 315 void jffs2_dirty_inode(struct inode *inode)
 316 {
 317         struct iattr iattr;
 318
 319         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 320                 D1(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
 321                 return;
 322         }
 323
 324         D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
 325
 326         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
 327         iattr.ia_mode = inode->i_mode;
 328         iattr.ia_uid = inode->i_uid;
 329         iattr.ia_gid = inode->i_gid;
 330         iattr.ia_atime = inode->i_atime;
 331         iattr.ia_mtime = inode->i_mtime;
 332         iattr.ia_ctime = inode->i_ctime;
 333
 334         jffs2_do_setattr(inode, &iattr);
 335 }
 336
 337 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data)
 338 {
 339         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 340
 341         if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 342                 return -EROFS;
 343
 344         /* We stop if it was running, then restart if it needs to.
 345            This also catches the case where it was stopped and this
 346            is just a remount to restart it */
 347         if (!(sb->s_flags & MS_RDONLY))
 348                 jffs2_stop_garbage_collect_thread(c);
 349
 350         if (!(*flags & MS_RDONLY))
 351                 jffs2_start_garbage_collect_thread(c);
 352
 353         *flags |= MS_NOATIME;
 354
 355         return 0;
 356 }
 357
 358 void jffs2_write_super (struct super_block *sb)
 359 {
 360         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 361         sb->s_dirt = 0;
 362
 363         if (sb->s_flags & MS_RDONLY)
 364                 return;
 365
 366         D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
 367         jffs2_garbage_collect_trigger(c);
 368         jffs2_erase_pending_blocks(c);
 369         jffs2_flush_wbuf_gc(c, 0);
 370 }
 371
 372
 373 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 374    fill in the raw_inode while you're at it. */
 375 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri)
 376 {
 377         struct inode *inode;
 378         struct super_block *sb = dir_i->i_sb;
 379         struct jffs2_sb_info *c;
 380         struct jffs2_inode_info *f;
 381         int ret;
 382
 383         D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
 384
 385         c = JFFS2_SB_INFO(sb);
 386
 387         inode = new_inode(sb);
 388
 389         if (!inode)
 390                 return ERR_PTR(-ENOMEM);
 391
 392         f = JFFS2_INODE_INFO(inode);
 393         jffs2_init_inode_info(f);
 394
 395         memset(ri, 0, sizeof(*ri));
 396         /* Set OS-specific defaults for new inodes */
 397         ri->uid = cpu_to_je16(current->fsuid);
 398
 399         if (dir_i->i_mode & S_ISGID) {
 400                 ri->gid = cpu_to_je16(dir_i->i_gid);
 401                 if (S_ISDIR(mode))
 402                         mode |= S_ISGID;
 403         } else {
 404                 ri->gid = cpu_to_je16(current->fsgid);
 405         }
 406         ri->mode =  cpu_to_jemode(mode);
 407         ret = jffs2_do_new_inode (c, f, mode, ri);
 408         if (ret) {
 409                 make_bad_inode(inode);
 410                 iput(inode);
 411                 return ERR_PTR(ret);
 412         }
 413         inode->i_nlink = 1;
 414         inode->i_ino = je32_to_cpu(ri->ino);
 415         inode->i_mode = jemode_to_cpu(ri->mode);
 416         inode->i_gid = je16_to_cpu(ri->gid);
 417         inode->i_uid = je16_to_cpu(ri->uid);
 418         inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME;
 419         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 420
 421         inode->i_blksize = PAGE_SIZE;
 422         inode->i_blocks = 0;
 423         inode->i_size = 0;
 424
 425         insert_inode_hash(inode);
 426
 427         return inode;
 428 }
 429
 430
 431 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 432 {
 433         struct jffs2_sb_info *c;
 434         struct inode *root_i;
 435         int ret;
 436         size_t blocks;
 437
 438         c = JFFS2_SB_INFO(sb);
 439
 440         c->flash_size = c->mtd->size;
 441
 442         /*
 443          * Check, if we have to concatenate physical blocks to larger virtual blocks
 444          * to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation)
 445          */
 446         blocks = c->flash_size / c->mtd->erasesize;
 447         while ((blocks * sizeof (struct jffs2_eraseblock)) > (128 * 1024))
 448                 blocks >>= 1;
 449
 450         c->sector_size = c->flash_size / blocks;
 451         if (c->sector_size != c->mtd->erasesize)
 452                 printk(KERN_INFO "jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n",
 453                         c->mtd->erasesize / 1024, c->sector_size / 1024);
 454
 455         if (c->flash_size < 5*c->sector_size) {
 456                 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
 457                 return -EINVAL;
 458         }
 459
 460         c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 461         /* Joern -- stick alignment for weird 8-byte-page flash here */
 462
 463         if (jffs2_cleanmarker_oob(c)) {
 464                 /* NAND (or other bizarre) flash... do setup accordingly */
 465                 ret = jffs2_nand_flash_setup(c);
 466                 if (ret)
 467                         return ret;
 468         }
 469
 470         c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 471         if (!c->inocache_list) {
 472                 ret = -ENOMEM;
 473                 goto out_wbuf;
 474         }
 475         memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
 476
 477         if ((ret = jffs2_do_mount_fs(c)))
 478                 goto out_inohash;
 479
 480         ret = -EINVAL;
 481
 482         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
 483         root_i = iget(sb, 1);
 484         if (is_bad_inode(root_i)) {
 485                 D1(printk(KERN_WARNING "get root inode failed\n"));
 486                 goto out_nodes;
 487         }
 488
 489         D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
 490         sb->s_root = d_alloc_root(root_i);
 491         if (!sb->s_root)
 492                 goto out_root_i;
 493
 494 #if LINUX_VERSION_CODE >= 0x20403
 495         sb->s_maxbytes = 0xFFFFFFFF;
 496 #endif
 497         sb->s_blocksize = PAGE_CACHE_SIZE;
 498         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 499         sb->s_magic = JFFS2_SUPER_MAGIC;
 500         if (!(sb->s_flags & MS_RDONLY))
 501                 jffs2_start_garbage_collect_thread(c);
 502         return 0;
 503
 504  out_root_i:
 505         iput(root_i);
 506  out_nodes:
 507         jffs2_free_ino_caches(c);
 508         jffs2_free_raw_node_refs(c);
 509         kfree(c->blocks);
 510  out_inohash:
 511         kfree(c->inocache_list);
 512  out_wbuf:
 513         jffs2_nand_flash_cleanup(c);
 514
 515         return ret;
 516 }