Root/fs/jffs2/fs.c

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

Archive Download this file



interactive