11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2.
31da177e4SLinus Torvalds *
4c00c310eSDavid Woodhouse * Copyright © 2001-2007 Red Hat, Inc.
51da177e4SLinus Torvalds *
61da177e4SLinus Torvalds * Created by David Woodhouse <dwmw2@infradead.org>
71da177e4SLinus Torvalds *
81da177e4SLinus Torvalds * For licensing information, see the file 'LICENCE' in this directory.
91da177e4SLinus Torvalds *
101da177e4SLinus Torvalds */
111da177e4SLinus Torvalds
121da177e4SLinus Torvalds #ifndef __JFFS2_NODELIST_H__
131da177e4SLinus Torvalds #define __JFFS2_NODELIST_H__
141da177e4SLinus Torvalds
151da177e4SLinus Torvalds #include <linux/fs.h>
161da177e4SLinus Torvalds #include <linux/types.h>
171da177e4SLinus Torvalds #include <linux/jffs2.h>
18cbb9a561SDavid Woodhouse #include "jffs2_fs_sb.h"
19cbb9a561SDavid Woodhouse #include "jffs2_fs_i.h"
20aa98d7cfSKaiGai Kohei #include "xattr.h"
21aa98d7cfSKaiGai Kohei #include "acl.h"
22e631ddbaSFerenc Havasi #include "summary.h"
231da177e4SLinus Torvalds
241da177e4SLinus Torvalds #ifdef __ECOS
251da177e4SLinus Torvalds #include "os-ecos.h"
261da177e4SLinus Torvalds #else
271da177e4SLinus Torvalds #include "os-linux.h"
281da177e4SLinus Torvalds #endif
291da177e4SLinus Torvalds
301da177e4SLinus Torvalds #define JFFS2_NATIVE_ENDIAN
311da177e4SLinus Torvalds
321da177e4SLinus Torvalds /* Note we handle mode bits conversion from JFFS2 (i.e. Linux) to/from
331da177e4SLinus Torvalds whatever OS we're actually running on here too. */
341da177e4SLinus Torvalds
351da177e4SLinus Torvalds #if defined(JFFS2_NATIVE_ENDIAN)
361da177e4SLinus Torvalds #define cpu_to_je16(x) ((jint16_t){x})
371da177e4SLinus Torvalds #define cpu_to_je32(x) ((jint32_t){x})
381da177e4SLinus Torvalds #define cpu_to_jemode(x) ((jmode_t){os_to_jffs2_mode(x)})
391da177e4SLinus Torvalds
40566865a2SDavid Woodhouse #define constant_cpu_to_je16(x) ((jint16_t){x})
41566865a2SDavid Woodhouse #define constant_cpu_to_je32(x) ((jint32_t){x})
42566865a2SDavid Woodhouse
431da177e4SLinus Torvalds #define je16_to_cpu(x) ((x).v16)
441da177e4SLinus Torvalds #define je32_to_cpu(x) ((x).v32)
451da177e4SLinus Torvalds #define jemode_to_cpu(x) (jffs2_to_os_mode((x).m))
461da177e4SLinus Torvalds #elif defined(JFFS2_BIG_ENDIAN)
471da177e4SLinus Torvalds #define cpu_to_je16(x) ((jint16_t){cpu_to_be16(x)})
481da177e4SLinus Torvalds #define cpu_to_je32(x) ((jint32_t){cpu_to_be32(x)})
491da177e4SLinus Torvalds #define cpu_to_jemode(x) ((jmode_t){cpu_to_be32(os_to_jffs2_mode(x))})
501da177e4SLinus Torvalds
51566865a2SDavid Woodhouse #define constant_cpu_to_je16(x) ((jint16_t){__constant_cpu_to_be16(x)})
52566865a2SDavid Woodhouse #define constant_cpu_to_je32(x) ((jint32_t){__constant_cpu_to_be32(x)})
53566865a2SDavid Woodhouse
541da177e4SLinus Torvalds #define je16_to_cpu(x) (be16_to_cpu(x.v16))
551da177e4SLinus Torvalds #define je32_to_cpu(x) (be32_to_cpu(x.v32))
561da177e4SLinus Torvalds #define jemode_to_cpu(x) (be32_to_cpu(jffs2_to_os_mode((x).m)))
571da177e4SLinus Torvalds #elif defined(JFFS2_LITTLE_ENDIAN)
581da177e4SLinus Torvalds #define cpu_to_je16(x) ((jint16_t){cpu_to_le16(x)})
591da177e4SLinus Torvalds #define cpu_to_je32(x) ((jint32_t){cpu_to_le32(x)})
601da177e4SLinus Torvalds #define cpu_to_jemode(x) ((jmode_t){cpu_to_le32(os_to_jffs2_mode(x))})
611da177e4SLinus Torvalds
62566865a2SDavid Woodhouse #define constant_cpu_to_je16(x) ((jint16_t){__constant_cpu_to_le16(x)})
63566865a2SDavid Woodhouse #define constant_cpu_to_je32(x) ((jint32_t){__constant_cpu_to_le32(x)})
64566865a2SDavid Woodhouse
651da177e4SLinus Torvalds #define je16_to_cpu(x) (le16_to_cpu(x.v16))
661da177e4SLinus Torvalds #define je32_to_cpu(x) (le32_to_cpu(x.v32))
671da177e4SLinus Torvalds #define jemode_to_cpu(x) (le32_to_cpu(jffs2_to_os_mode((x).m)))
681da177e4SLinus Torvalds #else
691da177e4SLinus Torvalds #error wibble
701da177e4SLinus Torvalds #endif
711da177e4SLinus Torvalds
721e0da3cbSArtem B. Bityutskiy /* The minimal node header size */
731e0da3cbSArtem B. Bityutskiy #define JFFS2_MIN_NODE_HEADER sizeof(struct jffs2_raw_dirent)
741e0da3cbSArtem B. Bityutskiy
751da177e4SLinus Torvalds /*
761da177e4SLinus Torvalds This is all we need to keep in-core for each raw node during normal
771da177e4SLinus Torvalds operation. As and when we do read_inode on a particular inode, we can
781da177e4SLinus Torvalds scan the nodes which are listed for it and build up a proper map of
791da177e4SLinus Torvalds which nodes are currently valid. JFFSv1 always used to keep that whole
801da177e4SLinus Torvalds map in core for each inode.
811da177e4SLinus Torvalds */
821da177e4SLinus Torvalds struct jffs2_raw_node_ref
831da177e4SLinus Torvalds {
841da177e4SLinus Torvalds struct jffs2_raw_node_ref *next_in_ino; /* Points to the next raw_node_ref
85987d47b7SDavid Woodhouse for this object. If this _is_ the last, it points to the inode_cache,
86987d47b7SDavid Woodhouse xattr_ref or xattr_datum instead. The common part of those structures
87987d47b7SDavid Woodhouse has NULL in the first word. See jffs2_raw_ref_to_ic() below */
881da177e4SLinus Torvalds uint32_t flash_offset;
8919e56ceaSDavid Woodhouse #undef TEST_TOTLEN
90ca89a517SDavid Woodhouse #ifdef TEST_TOTLEN
911da177e4SLinus Torvalds uint32_t __totlen; /* This may die; use ref_totlen(c, jeb, ) below */
92ca89a517SDavid Woodhouse #endif
931da177e4SLinus Torvalds };
941da177e4SLinus Torvalds
959bfeb691SDavid Woodhouse #define REF_LINK_NODE ((int32_t)-1)
969bfeb691SDavid Woodhouse #define REF_EMPTY_NODE ((int32_t)-2)
979bfeb691SDavid Woodhouse
989bfeb691SDavid Woodhouse /* Use blocks of about 256 bytes */
999bfeb691SDavid Woodhouse #define REFS_PER_BLOCK ((255/sizeof(struct jffs2_raw_node_ref))-1)
1009bfeb691SDavid Woodhouse
ref_next(struct jffs2_raw_node_ref * ref)1019bfeb691SDavid Woodhouse static inline struct jffs2_raw_node_ref *ref_next(struct jffs2_raw_node_ref *ref)
1029bfeb691SDavid Woodhouse {
1039bfeb691SDavid Woodhouse ref++;
1049bfeb691SDavid Woodhouse
1059bfeb691SDavid Woodhouse /* Link to another block of refs */
1069bfeb691SDavid Woodhouse if (ref->flash_offset == REF_LINK_NODE) {
1079bfeb691SDavid Woodhouse ref = ref->next_in_ino;
1089bfeb691SDavid Woodhouse if (!ref)
1099bfeb691SDavid Woodhouse return ref;
1109bfeb691SDavid Woodhouse }
1119bfeb691SDavid Woodhouse
1129bfeb691SDavid Woodhouse /* End of chain */
1139bfeb691SDavid Woodhouse if (ref->flash_offset == REF_EMPTY_NODE)
1149bfeb691SDavid Woodhouse return NULL;
1159bfeb691SDavid Woodhouse
1169bfeb691SDavid Woodhouse return ref;
1179bfeb691SDavid Woodhouse }
11899988f7bSDavid Woodhouse
jffs2_raw_ref_to_ic(struct jffs2_raw_node_ref * raw)119987d47b7SDavid Woodhouse static inline struct jffs2_inode_cache *jffs2_raw_ref_to_ic(struct jffs2_raw_node_ref *raw)
120987d47b7SDavid Woodhouse {
12199988f7bSDavid Woodhouse while(raw->next_in_ino)
122987d47b7SDavid Woodhouse raw = raw->next_in_ino;
123987d47b7SDavid Woodhouse
124987d47b7SDavid Woodhouse /* NB. This can be a jffs2_xattr_datum or jffs2_xattr_ref and
125987d47b7SDavid Woodhouse not actually a jffs2_inode_cache. Check ->class */
126987d47b7SDavid Woodhouse return ((struct jffs2_inode_cache *)raw);
127987d47b7SDavid Woodhouse }
128987d47b7SDavid Woodhouse
1291da177e4SLinus Torvalds /* flash_offset & 3 always has to be zero, because nodes are
1301da177e4SLinus Torvalds always aligned at 4 bytes. So we have a couple of extra bits
1311da177e4SLinus Torvalds to play with, which indicate the node's status; see below: */
1321da177e4SLinus Torvalds #define REF_UNCHECKED 0 /* We haven't yet checked the CRC or built its inode */
1331da177e4SLinus Torvalds #define REF_OBSOLETE 1 /* Obsolete, can be completely ignored */
1341da177e4SLinus Torvalds #define REF_PRISTINE 2 /* Completely clean. GC without looking */
1351da177e4SLinus Torvalds #define REF_NORMAL 3 /* Possibly overlapped. Read the page and write again on GC */
1361da177e4SLinus Torvalds #define ref_flags(ref) ((ref)->flash_offset & 3)
1371da177e4SLinus Torvalds #define ref_offset(ref) ((ref)->flash_offset & ~3)
1381da177e4SLinus Torvalds #define ref_obsolete(ref) (((ref)->flash_offset & 3) == REF_OBSOLETE)
1391da177e4SLinus Torvalds #define mark_ref_normal(ref) do { (ref)->flash_offset = ref_offset(ref) | REF_NORMAL; } while(0)
1401da177e4SLinus Torvalds
14143dfa07fSDavid Woodhouse /* Dirent nodes should be REF_PRISTINE only if they are not a deletion
14243dfa07fSDavid Woodhouse dirent. Deletion dirents should be REF_NORMAL so that GC gets to
14343dfa07fSDavid Woodhouse throw them away when appropriate */
14443dfa07fSDavid Woodhouse #define dirent_node_state(rd) ( (je32_to_cpu((rd)->ino)?REF_PRISTINE:REF_NORMAL) )
14543dfa07fSDavid Woodhouse
1466171586aSDavid Woodhouse /* NB: REF_PRISTINE for an inode-less node (ref->next_in_ino == NULL) indicates
1476171586aSDavid Woodhouse it is an unknown node of type JFFS2_NODETYPE_RWCOMPAT_COPY, so it'll get
1486171586aSDavid Woodhouse copied. If you need to do anything different to GC inode-less nodes, then
1496171586aSDavid Woodhouse you need to modify gc.c accordingly. */
1506171586aSDavid Woodhouse
1511da177e4SLinus Torvalds /* For each inode in the filesystem, we need to keep a record of
1521da177e4SLinus Torvalds nlink, because it would be a PITA to scan the whole directory tree
1531da177e4SLinus Torvalds at read_inode() time to calculate it, and to keep sufficient information
1541da177e4SLinus Torvalds in the raw_node_ref (basically both parent and child inode number for
1551da177e4SLinus Torvalds dirent nodes) would take more space than this does. We also keep
1561da177e4SLinus Torvalds a pointer to the first physical node which is part of this inode, too.
1571da177e4SLinus Torvalds */
1581da177e4SLinus Torvalds struct jffs2_inode_cache {
159987d47b7SDavid Woodhouse /* First part of structure is shared with other objects which
160987d47b7SDavid Woodhouse can terminate the raw node refs' next_in_ino list -- which
161987d47b7SDavid Woodhouse currently struct jffs2_xattr_datum and struct jffs2_xattr_ref. */
162987d47b7SDavid Woodhouse
1631da177e4SLinus Torvalds struct jffs2_full_dirent *scan_dents; /* Used during scan to hold
1641da177e4SLinus Torvalds temporary lists of dirents, and later must be set to
1651da177e4SLinus Torvalds NULL to mark the end of the raw_node_ref->next_in_ino
1661da177e4SLinus Torvalds chain. */
1671da177e4SLinus Torvalds struct jffs2_raw_node_ref *nodes;
168987d47b7SDavid Woodhouse uint8_t class; /* It's used for identification */
169987d47b7SDavid Woodhouse
170987d47b7SDavid Woodhouse /* end of shared structure */
171987d47b7SDavid Woodhouse
172987d47b7SDavid Woodhouse uint8_t flags;
173987d47b7SDavid Woodhouse uint16_t state;
1741da177e4SLinus Torvalds uint32_t ino;
175987d47b7SDavid Woodhouse struct jffs2_inode_cache *next;
176aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR
1778f2b6f49SKaiGai Kohei struct jffs2_xattr_ref *xref;
178aa98d7cfSKaiGai Kohei #endif
17927c72b04SDavid Woodhouse uint32_t pino_nlink; /* Directories store parent inode
18027c72b04SDavid Woodhouse here; other inodes store nlink.
18127c72b04SDavid Woodhouse Zero always means that it's
18227c72b04SDavid Woodhouse completely unlinked. */
1831da177e4SLinus Torvalds };
1841da177e4SLinus Torvalds
1851da177e4SLinus Torvalds /* Inode states for 'state' above. We need the 'GC' state to prevent
1861da177e4SLinus Torvalds someone from doing a read_inode() while we're moving a 'REF_PRISTINE'
1871da177e4SLinus Torvalds node without going through all the iget() nonsense */
1881da177e4SLinus Torvalds #define INO_STATE_UNCHECKED 0 /* CRC checks not yet done */
1891da177e4SLinus Torvalds #define INO_STATE_CHECKING 1 /* CRC checks in progress */
1901da177e4SLinus Torvalds #define INO_STATE_PRESENT 2 /* In core */
1911da177e4SLinus Torvalds #define INO_STATE_CHECKEDABSENT 3 /* Checked, cleared again */
1921da177e4SLinus Torvalds #define INO_STATE_GC 4 /* GCing a 'pristine' node */
1931da177e4SLinus Torvalds #define INO_STATE_READING 5 /* In read_inode() */
19467e345d1SDavid Woodhouse #define INO_STATE_CLEARING 6 /* In clear_inode() */
1951da177e4SLinus Torvalds
196aa98d7cfSKaiGai Kohei #define INO_FLAGS_XATTR_CHECKED 0x01 /* has no duplicate xattr_ref */
197be629c62SDavid Woodhouse #define INO_FLAGS_IS_DIR 0x02 /* is a directory */
198aa98d7cfSKaiGai Kohei
199aa98d7cfSKaiGai Kohei #define RAWNODE_CLASS_INODE_CACHE 0
200aa98d7cfSKaiGai Kohei #define RAWNODE_CLASS_XATTR_DATUM 1
201aa98d7cfSKaiGai Kohei #define RAWNODE_CLASS_XATTR_REF 2
202aa98d7cfSKaiGai Kohei
20365e5a0e1SDaniel Drake #define INOCACHE_HASHSIZE_MIN 128
20465e5a0e1SDaniel Drake #define INOCACHE_HASHSIZE_MAX 1024
2051da177e4SLinus Torvalds
2069fe4854cSDavid Woodhouse #define write_ofs(c) ((c)->nextblock->offset + (c)->sector_size - (c)->nextblock->free_size)
2079fe4854cSDavid Woodhouse
2081da177e4SLinus Torvalds /*
2091da177e4SLinus Torvalds Larger representation of a raw node, kept in-core only when the
2101da177e4SLinus Torvalds struct inode for this particular ino is instantiated.
2111da177e4SLinus Torvalds */
2121da177e4SLinus Torvalds
2131da177e4SLinus Torvalds struct jffs2_full_dnode
2141da177e4SLinus Torvalds {
2151da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw;
2161da177e4SLinus Torvalds uint32_t ofs; /* The offset to which the data of this node belongs */
2171da177e4SLinus Torvalds uint32_t size;
2181da177e4SLinus Torvalds uint32_t frags; /* Number of fragments which currently refer
2191da177e4SLinus Torvalds to this node. When this reaches zero,
2201da177e4SLinus Torvalds the node is obsolete. */
2211da177e4SLinus Torvalds };
2221da177e4SLinus Torvalds
2231da177e4SLinus Torvalds /*
2241da177e4SLinus Torvalds Even larger representation of a raw node, kept in-core only while
2251da177e4SLinus Torvalds we're actually building up the original map of which nodes go where,
2261da177e4SLinus Torvalds in read_inode()
2271da177e4SLinus Torvalds */
2281da177e4SLinus Torvalds struct jffs2_tmp_dnode_info
2291da177e4SLinus Torvalds {
2309dee7503SDavid Woodhouse struct rb_node rb;
2311da177e4SLinus Torvalds struct jffs2_full_dnode *fn;
2321da177e4SLinus Torvalds uint32_t version;
2331e0da3cbSArtem B. Bityutskiy uint32_t data_crc;
2341e0da3cbSArtem B. Bityutskiy uint32_t partial_crc;
23541bf1a24SAjesh Kunhipurayil Vijayan uint32_t csize;
236df8e96f3SDavid Woodhouse uint16_t overlapped;
237df8e96f3SDavid Woodhouse };
238df8e96f3SDavid Woodhouse
239df8e96f3SDavid Woodhouse /* Temporary data structure used during readinode. */
240df8e96f3SDavid Woodhouse struct jffs2_readinode_info
241df8e96f3SDavid Woodhouse {
242df8e96f3SDavid Woodhouse struct rb_root tn_root;
243df8e96f3SDavid Woodhouse struct jffs2_tmp_dnode_info *mdata_tn;
244df8e96f3SDavid Woodhouse uint32_t highest_version;
245df8e96f3SDavid Woodhouse uint32_t latest_mctime;
246df8e96f3SDavid Woodhouse uint32_t mctime_ver;
247df8e96f3SDavid Woodhouse struct jffs2_full_dirent *fds;
248df8e96f3SDavid Woodhouse struct jffs2_raw_node_ref *latest_ref;
2491da177e4SLinus Torvalds };
2501da177e4SLinus Torvalds
2511da177e4SLinus Torvalds struct jffs2_full_dirent
2521da177e4SLinus Torvalds {
253be629c62SDavid Woodhouse union {
2541da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw;
255be629c62SDavid Woodhouse struct jffs2_inode_cache *ic; /* Just during part of build */
256be629c62SDavid Woodhouse };
2571da177e4SLinus Torvalds struct jffs2_full_dirent *next;
2581da177e4SLinus Torvalds uint32_t version;
2591da177e4SLinus Torvalds uint32_t ino; /* == zero for unlink */
2601da177e4SLinus Torvalds unsigned int nhash;
2611da177e4SLinus Torvalds unsigned char type;
2626112bad7SGustavo A. R. Silva unsigned char name[];
2631da177e4SLinus Torvalds };
2641da177e4SLinus Torvalds
2651da177e4SLinus Torvalds /*
2661da177e4SLinus Torvalds Fragments - used to build a map of which raw node to obtain
2671da177e4SLinus Torvalds data from for each part of the ino
2681da177e4SLinus Torvalds */
2691da177e4SLinus Torvalds struct jffs2_node_frag
2701da177e4SLinus Torvalds {
2711da177e4SLinus Torvalds struct rb_node rb;
2721da177e4SLinus Torvalds struct jffs2_full_dnode *node; /* NULL for holes */
2731da177e4SLinus Torvalds uint32_t size;
2741da177e4SLinus Torvalds uint32_t ofs; /* The offset to which this fragment belongs */
2751da177e4SLinus Torvalds };
2761da177e4SLinus Torvalds
2771da177e4SLinus Torvalds struct jffs2_eraseblock
2781da177e4SLinus Torvalds {
2791da177e4SLinus Torvalds struct list_head list;
2801da177e4SLinus Torvalds int bad_count;
2811da177e4SLinus Torvalds uint32_t offset; /* of this block in the MTD */
2821da177e4SLinus Torvalds
2831da177e4SLinus Torvalds uint32_t unchecked_size;
2841da177e4SLinus Torvalds uint32_t used_size;
2851da177e4SLinus Torvalds uint32_t dirty_size;
2861da177e4SLinus Torvalds uint32_t wasted_size;
2871da177e4SLinus Torvalds uint32_t free_size; /* Note that sector_size - free_size
2881da177e4SLinus Torvalds is the address of the first free space */
2899bfeb691SDavid Woodhouse uint32_t allocated_refs;
2901da177e4SLinus Torvalds struct jffs2_raw_node_ref *first_node;
2911da177e4SLinus Torvalds struct jffs2_raw_node_ref *last_node;
2921da177e4SLinus Torvalds
2931da177e4SLinus Torvalds struct jffs2_raw_node_ref *gc_node; /* Next node to be garbage collected */
2941da177e4SLinus Torvalds };
2951da177e4SLinus Torvalds
jffs2_blocks_use_vmalloc(struct jffs2_sb_info * c)2964ce1f562SFerenc Havasi static inline int jffs2_blocks_use_vmalloc(struct jffs2_sb_info *c)
2974ce1f562SFerenc Havasi {
2984ce1f562SFerenc Havasi return ((c->flash_size / c->sector_size) * sizeof (struct jffs2_eraseblock)) > (128 * 1024);
2994ce1f562SFerenc Havasi }
3004ce1f562SFerenc Havasi
301ca89a517SDavid Woodhouse #define ref_totlen(a, b, c) __jffs2_ref_totlen((a), (b), (c))
3021da177e4SLinus Torvalds
3031da177e4SLinus Torvalds #define ALLOC_NORMAL 0 /* Normal allocation */
3041da177e4SLinus Torvalds #define ALLOC_DELETION 1 /* Deletion node. Best to allow it */
3051da177e4SLinus Torvalds #define ALLOC_GC 2 /* Space requested for GC. Give it or die */
3061da177e4SLinus Torvalds #define ALLOC_NORETRY 3 /* For jffs2_write_dnode: On failure, return -EAGAIN instead of retrying */
3071da177e4SLinus Torvalds
3081da177e4SLinus Torvalds /* How much dirty space before it goes on the very_dirty_list */
3091da177e4SLinus Torvalds #define VERYDIRTY(c, size) ((size) >= ((c)->sector_size / 2))
3101da177e4SLinus Torvalds
3111da177e4SLinus Torvalds /* check if dirty space is more than 255 Byte */
3121da177e4SLinus Torvalds #define ISDIRTY(size) ((size) > sizeof (struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN)
3131da177e4SLinus Torvalds
3141da177e4SLinus Torvalds #define PAD(x) (((x)+3)&~3)
3151da177e4SLinus Torvalds
jffs2_encode_dev(union jffs2_device_node * jdev,dev_t rdev)316aef9ab47SDavid Woodhouse static inline int jffs2_encode_dev(union jffs2_device_node *jdev, dev_t rdev)
317aef9ab47SDavid Woodhouse {
318aef9ab47SDavid Woodhouse if (old_valid_dev(rdev)) {
31991f80266SAndrew Morton jdev->old_id = cpu_to_je16(old_encode_dev(rdev));
32091f80266SAndrew Morton return sizeof(jdev->old_id);
321aef9ab47SDavid Woodhouse } else {
32291f80266SAndrew Morton jdev->new_id = cpu_to_je32(new_encode_dev(rdev));
32391f80266SAndrew Morton return sizeof(jdev->new_id);
324aef9ab47SDavid Woodhouse }
325aef9ab47SDavid Woodhouse }
326aef9ab47SDavid Woodhouse
frag_first(struct rb_root * root)3271da177e4SLinus Torvalds static inline struct jffs2_node_frag *frag_first(struct rb_root *root)
3281da177e4SLinus Torvalds {
329ea7415ccSAkinobu Mita struct rb_node *node = rb_first(root);
3301da177e4SLinus Torvalds
3311da177e4SLinus Torvalds if (!node)
3321da177e4SLinus Torvalds return NULL;
333ea7415ccSAkinobu Mita
3341da177e4SLinus Torvalds return rb_entry(node, struct jffs2_node_frag, rb);
3351da177e4SLinus Torvalds }
3368557fd51SArtem B. Bityuckiy
frag_last(struct rb_root * root)3378557fd51SArtem B. Bityuckiy static inline struct jffs2_node_frag *frag_last(struct rb_root *root)
3388557fd51SArtem B. Bityuckiy {
339ea7415ccSAkinobu Mita struct rb_node *node = rb_last(root);
3408557fd51SArtem B. Bityuckiy
3418557fd51SArtem B. Bityuckiy if (!node)
3428557fd51SArtem B. Bityuckiy return NULL;
343ea7415ccSAkinobu Mita
3448557fd51SArtem B. Bityuckiy return rb_entry(node, struct jffs2_node_frag, rb);
3458557fd51SArtem B. Bityuckiy }
3468557fd51SArtem B. Bityuckiy
3471da177e4SLinus Torvalds #define frag_next(frag) rb_entry(rb_next(&(frag)->rb), struct jffs2_node_frag, rb)
3481da177e4SLinus Torvalds #define frag_prev(frag) rb_entry(rb_prev(&(frag)->rb), struct jffs2_node_frag, rb)
3491da177e4SLinus Torvalds #define frag_parent(frag) rb_entry(rb_parent(&(frag)->rb), struct jffs2_node_frag, rb)
3501da177e4SLinus Torvalds #define frag_left(frag) rb_entry((frag)->rb.rb_left, struct jffs2_node_frag, rb)
3511da177e4SLinus Torvalds #define frag_right(frag) rb_entry((frag)->rb.rb_right, struct jffs2_node_frag, rb)
352*22bdb8b6STom Rix #define frag_erase(frag, list) rb_erase(&frag->rb, list)
3531da177e4SLinus Torvalds
354df8e96f3SDavid Woodhouse #define tn_next(tn) rb_entry(rb_next(&(tn)->rb), struct jffs2_tmp_dnode_info, rb)
355df8e96f3SDavid Woodhouse #define tn_prev(tn) rb_entry(rb_prev(&(tn)->rb), struct jffs2_tmp_dnode_info, rb)
356df8e96f3SDavid Woodhouse #define tn_parent(tn) rb_entry(rb_parent(&(tn)->rb), struct jffs2_tmp_dnode_info, rb)
357df8e96f3SDavid Woodhouse #define tn_left(tn) rb_entry((tn)->rb.rb_left, struct jffs2_tmp_dnode_info, rb)
358df8e96f3SDavid Woodhouse #define tn_right(tn) rb_entry((tn)->rb.rb_right, struct jffs2_tmp_dnode_info, rb)
359*22bdb8b6STom Rix #define tn_erase(tn, list) rb_erase(&tn->rb, list)
360df8e96f3SDavid Woodhouse #define tn_last(list) rb_entry(rb_last(list), struct jffs2_tmp_dnode_info, rb)
361df8e96f3SDavid Woodhouse #define tn_first(list) rb_entry(rb_first(list), struct jffs2_tmp_dnode_info, rb)
362df8e96f3SDavid Woodhouse
3631da177e4SLinus Torvalds /* nodelist.c */
3641da177e4SLinus Torvalds void jffs2_add_fd_to_list(struct jffs2_sb_info *c, struct jffs2_full_dirent *new, struct jffs2_full_dirent **list);
3651da177e4SLinus Torvalds void jffs2_set_inocache_state(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic, int state);
3661da177e4SLinus Torvalds struct jffs2_inode_cache *jffs2_get_ino_cache(struct jffs2_sb_info *c, uint32_t ino);
3671da177e4SLinus Torvalds void jffs2_add_ino_cache (struct jffs2_sb_info *c, struct jffs2_inode_cache *new);
3681da177e4SLinus Torvalds void jffs2_del_ino_cache(struct jffs2_sb_info *c, struct jffs2_inode_cache *old);
3691da177e4SLinus Torvalds void jffs2_free_ino_caches(struct jffs2_sb_info *c);
3701da177e4SLinus Torvalds void jffs2_free_raw_node_refs(struct jffs2_sb_info *c);
3711da177e4SLinus Torvalds struct jffs2_node_frag *jffs2_lookup_node_frag(struct rb_root *fragtree, uint32_t offset);
3721da177e4SLinus Torvalds void jffs2_kill_fragtree(struct rb_root *root, struct jffs2_sb_info *c_delete);
373f97117d1SArtem B. Bityutskiy int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_full_dnode *fn);
37461c4b237SDavid Woodhouse uint32_t jffs2_truncate_fragtree (struct jffs2_sb_info *c, struct rb_root *list, uint32_t size);
3752f785402SDavid Woodhouse struct jffs2_raw_node_ref *jffs2_link_node_ref(struct jffs2_sb_info *c,
3762f785402SDavid Woodhouse struct jffs2_eraseblock *jeb,
3772f785402SDavid Woodhouse uint32_t ofs, uint32_t len,
378fcb75787SDavid Woodhouse struct jffs2_inode_cache *ic);
379ca89a517SDavid Woodhouse extern uint32_t __jffs2_ref_totlen(struct jffs2_sb_info *c,
380ca89a517SDavid Woodhouse struct jffs2_eraseblock *jeb,
381ca89a517SDavid Woodhouse struct jffs2_raw_node_ref *ref);
3821da177e4SLinus Torvalds
3831da177e4SLinus Torvalds /* nodemgmt.c */
3841da177e4SLinus Torvalds int jffs2_thread_should_wake(struct jffs2_sb_info *c);
3859fe4854cSDavid Woodhouse int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
386e631ddbaSFerenc Havasi uint32_t *len, int prio, uint32_t sumsize);
3879fe4854cSDavid Woodhouse int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize,
388e631ddbaSFerenc Havasi uint32_t *len, uint32_t sumsize);
3892f785402SDavid Woodhouse struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c,
3902f785402SDavid Woodhouse uint32_t ofs, uint32_t len,
391fcb75787SDavid Woodhouse struct jffs2_inode_cache *ic);
3921da177e4SLinus Torvalds void jffs2_complete_reservation(struct jffs2_sb_info *c);
3931da177e4SLinus Torvalds void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *raw);
3941da177e4SLinus Torvalds
3951da177e4SLinus Torvalds /* write.c */
3961da177e4SLinus Torvalds int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri);
3971da177e4SLinus Torvalds
3989fe4854cSDavid Woodhouse struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
3999fe4854cSDavid Woodhouse struct jffs2_raw_inode *ri, const unsigned char *data,
4009fe4854cSDavid Woodhouse uint32_t datalen, int alloc_mode);
4019fe4854cSDavid Woodhouse struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
4029fe4854cSDavid Woodhouse struct jffs2_raw_dirent *rd, const unsigned char *name,
4039fe4854cSDavid Woodhouse uint32_t namelen, int alloc_mode);
4041da177e4SLinus Torvalds int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
4051da177e4SLinus Torvalds struct jffs2_raw_inode *ri, unsigned char *buf,
4061da177e4SLinus Torvalds uint32_t offset, uint32_t writelen, uint32_t *retlen);
4079fe4854cSDavid Woodhouse int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, struct jffs2_inode_info *f,
4082a7dba39SEric Paris struct jffs2_raw_inode *ri, const struct qstr *qstr);
4099fe4854cSDavid Woodhouse int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, const char *name,
4109fe4854cSDavid Woodhouse int namelen, struct jffs2_inode_info *dead_f, uint32_t time);
4119fe4854cSDavid Woodhouse int jffs2_do_link(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, uint32_t ino,
4129fe4854cSDavid Woodhouse uint8_t type, const char *name, int namelen, uint32_t time);
4131da177e4SLinus Torvalds
4141da177e4SLinus Torvalds
4151da177e4SLinus Torvalds /* readinode.c */
4161da177e4SLinus Torvalds int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
4171da177e4SLinus Torvalds uint32_t ino, struct jffs2_raw_inode *latest_node);
4181da177e4SLinus Torvalds int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic);
4191da177e4SLinus Torvalds void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f);
4201da177e4SLinus Torvalds
4211da177e4SLinus Torvalds /* malloc.c */
4221da177e4SLinus Torvalds int jffs2_create_slab_caches(void);
4231da177e4SLinus Torvalds void jffs2_destroy_slab_caches(void);
4241da177e4SLinus Torvalds
4251da177e4SLinus Torvalds struct jffs2_full_dirent *jffs2_alloc_full_dirent(int namesize);
4261da177e4SLinus Torvalds void jffs2_free_full_dirent(struct jffs2_full_dirent *);
4271da177e4SLinus Torvalds struct jffs2_full_dnode *jffs2_alloc_full_dnode(void);
4281da177e4SLinus Torvalds void jffs2_free_full_dnode(struct jffs2_full_dnode *);
4291da177e4SLinus Torvalds struct jffs2_raw_dirent *jffs2_alloc_raw_dirent(void);
4301da177e4SLinus Torvalds void jffs2_free_raw_dirent(struct jffs2_raw_dirent *);
4311da177e4SLinus Torvalds struct jffs2_raw_inode *jffs2_alloc_raw_inode(void);
4321da177e4SLinus Torvalds void jffs2_free_raw_inode(struct jffs2_raw_inode *);
4331da177e4SLinus Torvalds struct jffs2_tmp_dnode_info *jffs2_alloc_tmp_dnode_info(void);
4341da177e4SLinus Torvalds void jffs2_free_tmp_dnode_info(struct jffs2_tmp_dnode_info *);
435046b8b98SDavid Woodhouse int jffs2_prealloc_raw_node_refs(struct jffs2_sb_info *c,
436046b8b98SDavid Woodhouse struct jffs2_eraseblock *jeb, int nr);
4379bfeb691SDavid Woodhouse void jffs2_free_refblock(struct jffs2_raw_node_ref *);
4381da177e4SLinus Torvalds struct jffs2_node_frag *jffs2_alloc_node_frag(void);
4391da177e4SLinus Torvalds void jffs2_free_node_frag(struct jffs2_node_frag *);
4401da177e4SLinus Torvalds struct jffs2_inode_cache *jffs2_alloc_inode_cache(void);
4411da177e4SLinus Torvalds void jffs2_free_inode_cache(struct jffs2_inode_cache *);
442aa98d7cfSKaiGai Kohei #ifdef CONFIG_JFFS2_FS_XATTR
443aa98d7cfSKaiGai Kohei struct jffs2_xattr_datum *jffs2_alloc_xattr_datum(void);
444aa98d7cfSKaiGai Kohei void jffs2_free_xattr_datum(struct jffs2_xattr_datum *);
445aa98d7cfSKaiGai Kohei struct jffs2_xattr_ref *jffs2_alloc_xattr_ref(void);
446aa98d7cfSKaiGai Kohei void jffs2_free_xattr_ref(struct jffs2_xattr_ref *);
447aa98d7cfSKaiGai Kohei #endif
4481da177e4SLinus Torvalds
4491da177e4SLinus Torvalds /* gc.c */
4501da177e4SLinus Torvalds int jffs2_garbage_collect_pass(struct jffs2_sb_info *c);
4511da177e4SLinus Torvalds
4521da177e4SLinus Torvalds /* read.c */
4531da177e4SLinus Torvalds int jffs2_read_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
4541da177e4SLinus Torvalds struct jffs2_full_dnode *fd, unsigned char *buf,
4551da177e4SLinus Torvalds int ofs, int len);
4561da177e4SLinus Torvalds int jffs2_read_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
4571da177e4SLinus Torvalds unsigned char *buf, uint32_t offset, uint32_t len);
4581da177e4SLinus Torvalds char *jffs2_getlink(struct jffs2_sb_info *c, struct jffs2_inode_info *f);
4591da177e4SLinus Torvalds
4601da177e4SLinus Torvalds /* scan.c */
4611da177e4SLinus Torvalds int jffs2_scan_medium(struct jffs2_sb_info *c);
4621da177e4SLinus Torvalds void jffs2_rotate_lists(struct jffs2_sb_info *c);
463e631ddbaSFerenc Havasi struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino);
464e631ddbaSFerenc Havasi int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
46568270995SDavid Woodhouse int jffs2_scan_dirty_space(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t size);
4661da177e4SLinus Torvalds
4671da177e4SLinus Torvalds /* build.c */
4681da177e4SLinus Torvalds int jffs2_do_mount_fs(struct jffs2_sb_info *c);
4691da177e4SLinus Torvalds
4701da177e4SLinus Torvalds /* erase.c */
4719957abeaSJoakim Tjernlund int jffs2_erase_pending_blocks(struct jffs2_sb_info *c, int count);
472c38c1b61SDavid Woodhouse void jffs2_free_jeb_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
4731da177e4SLinus Torvalds
4742f82ce1eSAndrew Victor #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
4751da177e4SLinus Torvalds /* wbuf.c */
4761da177e4SLinus Torvalds int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino);
4771da177e4SLinus Torvalds int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c);
4781da177e4SLinus Torvalds int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
4791da177e4SLinus Torvalds int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
4801da177e4SLinus Torvalds #endif
4811da177e4SLinus Torvalds
482730554d9SArtem B. Bityutskiy #include "debug.h"
483730554d9SArtem B. Bityutskiy
4841da177e4SLinus Torvalds #endif /* __JFFS2_NODELIST_H__ */
485