linux/fs/jffs2/fs.c
<<
>>
Prefs
   1/*
   2 * JFFS2 -- Journalling Flash File System, Version 2.
   3 *
   4 * Copyright © 2001-2007 Red Hat, Inc.
   5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
   6 *
   7 * Created by David Woodhouse <dwmw2@infradead.org>
   8 *
   9 * For licensing information, see the file 'LICENCE' in this directory.
  10 *
  11 */
  12
  13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15#include <linux/capability.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/vmalloc.h>
  24#include <linux/vfs.h>
  25#include <linux/crc32.h>
  26#include "nodelist.h"
  27
  28static int jffs2_flash_setup(struct jffs2_sb_info *c);
  29
  30int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
  31{
  32        struct jffs2_full_dnode *old_metadata, *new_metadata;
  33        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  34        struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  35        struct jffs2_raw_inode *ri;
  36        union jffs2_device_node dev;
  37        unsigned char *mdata = NULL;
  38        int mdatalen = 0;
  39        unsigned int ivalid;
  40        uint32_t alloclen;
  41        int ret;
  42        int alloc_type = ALLOC_NORMAL;
  43
  44        jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino);
  45
  46        /* Special cases - we don't want more than one data node
  47           for these types on the medium at any time. So setattr
  48           must read the original data associated with the node
  49           (i.e. the device numbers or the target name) and write
  50           it out again with the appropriate data attached */
  51        if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
  52                /* For these, we don't actually need to read the old node */
  53                mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
  54                mdata = (char *)&dev;
  55                jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n",
  56                          __func__, mdatalen);
  57        } else if (S_ISLNK(inode->i_mode)) {
  58                mutex_lock(&f->sem);
  59                mdatalen = f->metadata->size;
  60                mdata = kmalloc(f->metadata->size, GFP_USER);
  61                if (!mdata) {
  62                        mutex_unlock(&f->sem);
  63                        return -ENOMEM;
  64                }
  65                ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen);
  66                if (ret) {
  67                        mutex_unlock(&f->sem);
  68                        kfree(mdata);
  69                        return ret;
  70                }
  71                mutex_unlock(&f->sem);
  72                jffs2_dbg(1, "%s(): Writing %d bytes of symlink target\n",
  73                          __func__, mdatalen);
  74        }
  75
  76        ri = jffs2_alloc_raw_inode();
  77        if (!ri) {
  78                if (S_ISLNK(inode->i_mode))
  79                        kfree(mdata);
  80                return -ENOMEM;
  81        }
  82
  83        ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen,
  84                                  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
  85        if (ret) {
  86                jffs2_free_raw_inode(ri);
  87                if (S_ISLNK(inode->i_mode))
  88                         kfree(mdata);
  89                return ret;
  90        }
  91        mutex_lock(&f->sem);
  92        ivalid = iattr->ia_valid;
  93
  94        ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
  95        ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
  96        ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);
  97        ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
  98
  99        ri->ino = cpu_to_je32(inode->i_ino);
 100        ri->version = cpu_to_je32(++f->highest_version);
 101
 102        ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);
 103        ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);
 104
 105        if (ivalid & ATTR_MODE)
 106                ri->mode = cpu_to_jemode(iattr->ia_mode);
 107        else
 108                ri->mode = cpu_to_jemode(inode->i_mode);
 109
 110
 111        ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);
 112        ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));
 113        ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));
 114        ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));
 115
 116        ri->offset = cpu_to_je32(0);
 117        ri->csize = ri->dsize = cpu_to_je32(mdatalen);
 118        ri->compr = JFFS2_COMPR_NONE;
 119        if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 120                /* It's an extension. Make it a hole node */
 121                ri->compr = JFFS2_COMPR_ZERO;
 122                ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);
 123                ri->offset = cpu_to_je32(inode->i_size);
 124        } else if (ivalid & ATTR_SIZE && !iattr->ia_size) {
 125                /* For truncate-to-zero, treat it as deletion because
 126                   it'll always be obsoleting all previous nodes */
 127                alloc_type = ALLOC_DELETION;
 128        }
 129        ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 130        if (mdatalen)
 131                ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
 132        else
 133                ri->data_crc = cpu_to_je32(0);
 134
 135        new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type);
 136        if (S_ISLNK(inode->i_mode))
 137                kfree(mdata);
 138
 139        if (IS_ERR(new_metadata)) {
 140                jffs2_complete_reservation(c);
 141                jffs2_free_raw_inode(ri);
 142                mutex_unlock(&f->sem);
 143                return PTR_ERR(new_metadata);
 144        }
 145        /* It worked. Update the inode */
 146        inode->i_atime = ITIME(je32_to_cpu(ri->atime));
 147        inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));
 148        inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));
 149        inode->i_mode = jemode_to_cpu(ri->mode);
 150        inode->i_uid = je16_to_cpu(ri->uid);
 151        inode->i_gid = je16_to_cpu(ri->gid);
 152
 153
 154        old_metadata = f->metadata;
 155
 156        if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)
 157                jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);
 158
 159        if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {
 160                jffs2_add_full_dnode_to_inode(c, f, new_metadata);
 161                inode->i_size = iattr->ia_size;
 162                inode->i_blocks = (inode->i_size + 511) >> 9;
 163                f->metadata = NULL;
 164        } else {
 165                f->metadata = new_metadata;
 166        }
 167        if (old_metadata) {
 168                jffs2_mark_node_obsolete(c, old_metadata->raw);
 169                jffs2_free_full_dnode(old_metadata);
 170        }
 171        jffs2_free_raw_inode(ri);
 172
 173        mutex_unlock(&f->sem);
 174        jffs2_complete_reservation(c);
 175
 176        /* We have to do the truncate_setsize() without f->sem held, since
 177           some pages may be locked and waiting for it in readpage().
 178           We are protected from a simultaneous write() extending i_size
 179           back past iattr->ia_size, because do_truncate() holds the
 180           generic inode semaphore. */
 181        if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) {
 182                truncate_setsize(inode, iattr->ia_size);
 183                inode->i_blocks = (inode->i_size + 511) >> 9;
 184        }       
 185
 186        return 0;
 187}
 188
 189int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 190{
 191        int rc;
 192
 193        rc = inode_change_ok(dentry->d_inode, iattr);
 194        if (rc)
 195                return rc;
 196
 197        rc = jffs2_do_setattr(dentry->d_inode, iattr);
 198        if (!rc && (iattr->ia_valid & ATTR_MODE))
 199                rc = jffs2_acl_chmod(dentry->d_inode);
 200
 201        return rc;
 202}
 203
 204int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 205{
 206        struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb);
 207        unsigned long avail;
 208
 209        buf->f_type = JFFS2_SUPER_MAGIC;
 210        buf->f_bsize = 1 << PAGE_SHIFT;
 211        buf->f_blocks = c->flash_size >> PAGE_SHIFT;
 212        buf->f_files = 0;
 213        buf->f_ffree = 0;
 214        buf->f_namelen = JFFS2_MAX_NAME_LEN;
 215        buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC;
 216        buf->f_fsid.val[1] = c->mtd->index;
 217
 218        spin_lock(&c->erase_completion_lock);
 219        avail = c->dirty_size + c->free_size;
 220        if (avail > c->sector_size * c->resv_blocks_write)
 221                avail -= c->sector_size * c->resv_blocks_write;
 222        else
 223                avail = 0;
 224        spin_unlock(&c->erase_completion_lock);
 225
 226        buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT;
 227
 228        return 0;
 229}
 230
 231
 232void jffs2_evict_inode (struct inode *inode)
 233{
 234        /* We can forget about this inode for now - drop all
 235         *  the nodelists associated with it, etc.
 236         */
 237        struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
 238        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 239
 240        jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
 241                  __func__, inode->i_ino, inode->i_mode);
 242        truncate_inode_pages(&inode->i_data, 0);
 243        clear_inode(inode);
 244        jffs2_do_clear_inode(c, f);
 245}
 246
 247struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
 248{
 249        struct jffs2_inode_info *f;
 250        struct jffs2_sb_info *c;
 251        struct jffs2_raw_inode latest_node;
 252        union jffs2_device_node jdev;
 253        struct inode *inode;
 254        dev_t rdev = 0;
 255        int ret;
 256
 257        jffs2_dbg(1, "%s(): ino == %lu\n", __func__, ino);
 258
 259        inode = iget_locked(sb, ino);
 260        if (!inode)
 261                return ERR_PTR(-ENOMEM);
 262        if (!(inode->i_state & I_NEW))
 263                return inode;
 264
 265        f = JFFS2_INODE_INFO(inode);
 266        c = JFFS2_SB_INFO(inode->i_sb);
 267
 268        jffs2_init_inode_info(f);
 269        mutex_lock(&f->sem);
 270
 271        ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
 272
 273        if (ret) {
 274                mutex_unlock(&f->sem);
 275                iget_failed(inode);
 276                return ERR_PTR(ret);
 277        }
 278        inode->i_mode = jemode_to_cpu(latest_node.mode);
 279        inode->i_uid = je16_to_cpu(latest_node.uid);
 280        inode->i_gid = je16_to_cpu(latest_node.gid);
 281        inode->i_size = je32_to_cpu(latest_node.isize);
 282        inode->i_atime = ITIME(je32_to_cpu(latest_node.atime));
 283        inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime));
 284        inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime));
 285
 286        set_nlink(inode, f->inocache->pino_nlink);
 287
 288        inode->i_blocks = (inode->i_size + 511) >> 9;
 289
 290        switch (inode->i_mode & S_IFMT) {
 291
 292        case S_IFLNK:
 293                inode->i_op = &jffs2_symlink_inode_operations;
 294                break;
 295
 296        case S_IFDIR:
 297        {
 298                struct jffs2_full_dirent *fd;
 299                set_nlink(inode, 2); /* parent and '.' */
 300
 301                for (fd=f->dents; fd; fd = fd->next) {
 302                        if (fd->type == DT_DIR && fd->ino)
 303                                inc_nlink(inode);
 304                }
 305                /* Root dir gets i_nlink 3 for some reason */
 306                if (inode->i_ino == 1)
 307                        inc_nlink(inode);
 308
 309                inode->i_op = &jffs2_dir_inode_operations;
 310                inode->i_fop = &jffs2_dir_operations;
 311                break;
 312        }
 313        case S_IFREG:
 314                inode->i_op = &jffs2_file_inode_operations;
 315                inode->i_fop = &jffs2_file_operations;
 316                inode->i_mapping->a_ops = &jffs2_file_address_operations;
 317                inode->i_mapping->nrpages = 0;
 318                break;
 319
 320        case S_IFBLK:
 321        case S_IFCHR:
 322                /* Read the device numbers from the media */
 323                if (f->metadata->size != sizeof(jdev.old_id) &&
 324                    f->metadata->size != sizeof(jdev.new_id)) {
 325                        pr_notice("Device node has strange size %d\n",
 326                                  f->metadata->size);
 327                        goto error_io;
 328                }
 329                jffs2_dbg(1, "Reading device numbers from flash\n");
 330                ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
 331                if (ret < 0) {
 332                        /* Eep */
 333                        pr_notice("Read device numbers for inode %lu failed\n",
 334                                  (unsigned long)inode->i_ino);
 335                        goto error;
 336                }
 337                if (f->metadata->size == sizeof(jdev.old_id))
 338                        rdev = old_decode_dev(je16_to_cpu(jdev.old_id));
 339                else
 340                        rdev = new_decode_dev(je32_to_cpu(jdev.new_id));
 341
 342        case S_IFSOCK:
 343        case S_IFIFO:
 344                inode->i_op = &jffs2_file_inode_operations;
 345                init_special_inode(inode, inode->i_mode, rdev);
 346                break;
 347
 348        default:
 349                pr_warn("%s(): Bogus i_mode %o for ino %lu\n",
 350                        __func__, inode->i_mode, (unsigned long)inode->i_ino);
 351        }
 352
 353        mutex_unlock(&f->sem);
 354
 355        jffs2_dbg(1, "jffs2_read_inode() returning\n");
 356        unlock_new_inode(inode);
 357        return inode;
 358
 359error_io:
 360        ret = -EIO;
 361error:
 362        mutex_unlock(&f->sem);
 363        jffs2_do_clear_inode(c, f);
 364        iget_failed(inode);
 365        return ERR_PTR(ret);
 366}
 367
 368void jffs2_dirty_inode(struct inode *inode, int flags)
 369{
 370        struct iattr iattr;
 371
 372        if (!(inode->i_state & I_DIRTY_DATASYNC)) {
 373                jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
 374                          __func__, inode->i_ino);
 375                return;
 376        }
 377
 378        jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n",
 379                  __func__, inode->i_ino);
 380
 381        iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
 382        iattr.ia_mode = inode->i_mode;
 383        iattr.ia_uid = inode->i_uid;
 384        iattr.ia_gid = inode->i_gid;
 385        iattr.ia_atime = inode->i_atime;
 386        iattr.ia_mtime = inode->i_mtime;
 387        iattr.ia_ctime = inode->i_ctime;
 388
 389        jffs2_do_setattr(inode, &iattr);
 390}
 391
 392int jffs2_do_remount_fs(struct super_block *sb, int *flags, char *data)
 393{
 394        struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
 395
 396        if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY))
 397                return -EROFS;
 398
 399        /* We stop if it was running, then restart if it needs to.
 400           This also catches the case where it was stopped and this
 401           is just a remount to restart it.
 402           Flush the writebuffer, if neccecary, else we loose it */
 403        if (!(sb->s_flags & MS_RDONLY)) {
 404                jffs2_stop_garbage_collect_thread(c);
 405                mutex_lock(&c->alloc_sem);
 406                jffs2_flush_wbuf_pad(c);
 407                mutex_unlock(&c->alloc_sem);
 408        }
 409
 410        if (!(*flags & MS_RDONLY))
 411                jffs2_start_garbage_collect_thread(c);
 412
 413        *flags |= MS_NOATIME;
 414        return 0;
 415}
 416
 417/* jffs2_new_inode: allocate a new inode and inocache, add it to the hash,
 418   fill in the raw_inode while you're at it. */
 419struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_raw_inode *ri)
 420{
 421        struct inode *inode;
 422        struct super_block *sb = dir_i->i_sb;
 423        struct jffs2_sb_info *c;
 424        struct jffs2_inode_info *f;
 425        int ret;
 426
 427        jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n",
 428                  __func__, dir_i->i_ino, mode);
 429
 430        c = JFFS2_SB_INFO(sb);
 431
 432        inode = new_inode(sb);
 433
 434        if (!inode)
 435                return ERR_PTR(-ENOMEM);
 436
 437        f = JFFS2_INODE_INFO(inode);
 438        jffs2_init_inode_info(f);
 439        mutex_lock(&f->sem);
 440
 441        memset(ri, 0, sizeof(*ri));
 442        /* Set OS-specific defaults for new inodes */
 443        ri->uid = cpu_to_je16(current_fsuid());
 444
 445        if (dir_i->i_mode & S_ISGID) {
 446                ri->gid = cpu_to_je16(dir_i->i_gid);
 447                if (S_ISDIR(mode))
 448                        mode |= S_ISGID;
 449        } else {
 450                ri->gid = cpu_to_je16(current_fsgid());
 451        }
 452
 453        /* POSIX ACLs have to be processed now, at least partly.
 454           The umask is only applied if there's no default ACL */
 455        ret = jffs2_init_acl_pre(dir_i, inode, &mode);
 456        if (ret) {
 457            make_bad_inode(inode);
 458            iput(inode);
 459            return ERR_PTR(ret);
 460        }
 461        ret = jffs2_do_new_inode (c, f, mode, ri);
 462        if (ret) {
 463                make_bad_inode(inode);
 464                iput(inode);
 465                return ERR_PTR(ret);
 466        }
 467        set_nlink(inode, 1);
 468        inode->i_ino = je32_to_cpu(ri->ino);
 469        inode->i_mode = jemode_to_cpu(ri->mode);
 470        inode->i_gid = je16_to_cpu(ri->gid);
 471        inode->i_uid = je16_to_cpu(ri->uid);
 472        inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 473        ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 474
 475        inode->i_blocks = 0;
 476        inode->i_size = 0;
 477
 478        if (insert_inode_locked(inode) < 0) {
 479                make_bad_inode(inode);
 480                iput(inode);
 481                return ERR_PTR(-EINVAL);
 482        }
 483
 484        return inode;
 485}
 486
 487static int calculate_inocache_hashsize(uint32_t flash_size)
 488{
 489        /*
 490         * Pick a inocache hash size based on the size of the medium.
 491         * Count how many megabytes we're dealing with, apply a hashsize twice
 492         * that size, but rounding down to the usual big powers of 2. And keep
 493         * to sensible bounds.
 494         */
 495
 496        int size_mb = flash_size / 1024 / 1024;
 497        int hashsize = (size_mb * 2) & ~0x3f;
 498
 499        if (hashsize < INOCACHE_HASHSIZE_MIN)
 500                return INOCACHE_HASHSIZE_MIN;
 501        if (hashsize > INOCACHE_HASHSIZE_MAX)
 502                return INOCACHE_HASHSIZE_MAX;
 503
 504        return hashsize;
 505}
 506
 507int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 508{
 509        struct jffs2_sb_info *c;
 510        struct inode *root_i;
 511        int ret;
 512        size_t blocks;
 513
 514        c = JFFS2_SB_INFO(sb);
 515
 516#ifndef CONFIG_JFFS2_FS_WRITEBUFFER
 517        if (c->mtd->type == MTD_NANDFLASH) {
 518                pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n");
 519                return -EINVAL;
 520        }
 521        if (c->mtd->type == MTD_DATAFLASH) {
 522                pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n");
 523                return -EINVAL;
 524        }
 525#endif
 526
 527        c->flash_size = c->mtd->size;
 528        c->sector_size = c->mtd->erasesize;
 529        blocks = c->flash_size / c->sector_size;
 530
 531        /*
 532         * Size alignment check
 533         */
 534        if ((c->sector_size * blocks) != c->flash_size) {
 535                c->flash_size = c->sector_size * blocks;
 536                pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
 537                        c->flash_size / 1024);
 538        }
 539
 540        if (c->flash_size < 5*c->sector_size) {
 541                pr_err("Too few erase blocks (%d)\n",
 542                       c->flash_size / c->sector_size);
 543                return -EINVAL;
 544        }
 545
 546        c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
 547
 548        /* NAND (or other bizarre) flash... do setup accordingly */
 549        ret = jffs2_flash_setup(c);
 550        if (ret)
 551                return ret;
 552
 553        c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size);
 554        c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
 555        if (!c->inocache_list) {
 556                ret = -ENOMEM;
 557                goto out_wbuf;
 558        }
 559
 560        jffs2_init_xattr_subsystem(c);
 561
 562        if ((ret = jffs2_do_mount_fs(c)))
 563                goto out_inohash;
 564
 565        jffs2_dbg(1, "%s(): Getting root inode\n", __func__);
 566        root_i = jffs2_iget(sb, 1);
 567        if (IS_ERR(root_i)) {
 568                jffs2_dbg(1, "get root inode failed\n");
 569                ret = PTR_ERR(root_i);
 570                goto out_root;
 571        }
 572
 573        ret = -ENOMEM;
 574
 575        jffs2_dbg(1, "%s(): d_make_root()\n", __func__);
 576        sb->s_root = d_make_root(root_i);
 577        if (!sb->s_root)
 578                goto out_root;
 579
 580        sb->s_maxbytes = 0xFFFFFFFF;
 581        sb->s_blocksize = PAGE_CACHE_SIZE;
 582        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 583        sb->s_magic = JFFS2_SUPER_MAGIC;
 584        if (!(sb->s_flags & MS_RDONLY))
 585                jffs2_start_garbage_collect_thread(c);
 586        return 0;
 587
 588out_root:
 589        jffs2_free_ino_caches(c);
 590        jffs2_free_raw_node_refs(c);
 591        if (jffs2_blocks_use_vmalloc(c))
 592                vfree(c->blocks);
 593        else
 594                kfree(c->blocks);
 595 out_inohash:
 596        jffs2_clear_xattr_subsystem(c);
 597        kfree(c->inocache_list);
 598 out_wbuf:
 599        jffs2_flash_cleanup(c);
 600
 601        return ret;
 602}
 603
 604void jffs2_gc_release_inode(struct jffs2_sb_info *c,
 605                                   struct jffs2_inode_info *f)
 606{
 607        iput(OFNI_EDONI_2SFFJ(f));
 608}
 609
 610struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
 611                                              int inum, int unlinked)
 612{
 613        struct inode *inode;
 614        struct jffs2_inode_cache *ic;
 615
 616        if (unlinked) {
 617                /* The inode has zero nlink but its nodes weren't yet marked
 618                   obsolete. This has to be because we're still waiting for
 619                   the final (close() and) iput() to happen.
 620
 621                   There's a possibility that the final iput() could have
 622                   happened while we were contemplating. In order to ensure
 623                   that we don't cause a new read_inode() (which would fail)
 624                   for the inode in question, we use ilookup() in this case
 625                   instead of iget().
 626
 627                   The nlink can't _become_ zero at this point because we're
 628                   holding the alloc_sem, and jffs2_do_unlink() would also
 629                   need that while decrementing nlink on any inode.
 630                */
 631                inode = ilookup(OFNI_BS_2SFFJ(c), inum);
 632                if (!inode) {
 633                        jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n",
 634                                  inum);
 635
 636                        spin_lock(&c->inocache_lock);
 637                        ic = jffs2_get_ino_cache(c, inum);
 638                        if (!ic) {
 639                                jffs2_dbg(1, "Inode cache for ino #%u is gone\n",
 640                                          inum);
 641                                spin_unlock(&c->inocache_lock);
 642                                return NULL;
 643                        }
 644                        if (ic->state != INO_STATE_CHECKEDABSENT) {
 645                                /* Wait for progress. Don't just loop */
 646                                jffs2_dbg(1, "Waiting for ino #%u in state %d\n",
 647                                          ic->ino, ic->state);
 648                                sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
 649                        } else {
 650                                spin_unlock(&c->inocache_lock);
 651                        }
 652
 653                        return NULL;
 654                }
 655        } else {
 656                /* Inode has links to it still; they're not going away because
 657                   jffs2_do_unlink() would need the alloc_sem and we have it.
 658                   Just iget() it, and if read_inode() is necessary that's OK.
 659                */
 660                inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
 661                if (IS_ERR(inode))
 662                        return ERR_CAST(inode);
 663        }
 664        if (is_bad_inode(inode)) {
 665                pr_notice("Eep. read_inode() failed for ino #%u. unlinked %d\n",
 666                          inum, unlinked);
 667                /* NB. This will happen again. We need to do something appropriate here. */
 668                iput(inode);
 669                return ERR_PTR(-EIO);
 670        }
 671
 672        return JFFS2_INODE_INFO(inode);
 673}
 674
 675unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c,
 676                                   struct jffs2_inode_info *f,
 677                                   unsigned long offset,
 678                                   unsigned long *priv)
 679{
 680        struct inode *inode = OFNI_EDONI_2SFFJ(f);
 681        struct page *pg;
 682
 683        pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT,
 684                             (void *)jffs2_do_readpage_unlock, inode);
 685        if (IS_ERR(pg))
 686                return (void *)pg;
 687
 688        *priv = (unsigned long)pg;
 689        return kmap(pg);
 690}
 691
 692void jffs2_gc_release_page(struct jffs2_sb_info *c,
 693                           unsigned char *ptr,
 694                           unsigned long *priv)
 695{
 696        struct page *pg = (void *)*priv;
 697
 698        kunmap(pg);
 699        page_cache_release(pg);
 700}
 701
 702static int jffs2_flash_setup(struct jffs2_sb_info *c) {
 703        int ret = 0;
 704
 705        if (jffs2_cleanmarker_oob(c)) {
 706                /* NAND flash... do setup accordingly */
 707                ret = jffs2_nand_flash_setup(c);
 708                if (ret)
 709                        return ret;
 710        }
 711
 712        /* and Dataflash */
 713        if (jffs2_dataflash(c)) {
 714                ret = jffs2_dataflash_setup(c);
 715                if (ret)
 716                        return ret;
 717        }
 718
 719        /* and Intel "Sibley" flash */
 720        if (jffs2_nor_wbuf_flash(c)) {
 721                ret = jffs2_nor_wbuf_flash_setup(c);
 722                if (ret)
 723                        return ret;
 724        }
 725
 726        /* and an UBI volume */
 727        if (jffs2_ubivol(c)) {
 728                ret = jffs2_ubivol_setup(c);
 729                if (ret)
 730                        return ret;
 731        }
 732
 733        return ret;
 734}
 735
 736void jffs2_flash_cleanup(struct jffs2_sb_info *c) {
 737
 738        if (jffs2_cleanmarker_oob(c)) {
 739                jffs2_nand_flash_cleanup(c);
 740        }
 741
 742        /* and DataFlash */
 743        if (jffs2_dataflash(c)) {
 744                jffs2_dataflash_cleanup(c);
 745        }
 746
 747        /* and Intel "Sibley" flash */
 748        if (jffs2_nor_wbuf_flash(c)) {
 749                jffs2_nor_wbuf_flash_cleanup(c);
 750        }
 751
 752        /* and an UBI volume */
 753        if (jffs2_ubivol(c)) {
 754                jffs2_ubivol_cleanup(c);
 755        }
 756}
 757
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.