Diff markup
1 /* 1 /*
2 * JFFS2 -- Journalling Flash File System, Ver 2 * JFFS2 -- Journalling Flash File System, Version 2.
3 * 3 *
4 * Copyright © 2001-2007 Red Hat, Inc. 4 * Copyright © 2001-2007 Red Hat, Inc.
5 * 5 *
6 * Created by David Woodhouse <dwmw2@infradead 6 * Created by David Woodhouse <dwmw2@infradead.org>
7 * 7 *
8 * For licensing information, see the file 'LI 8 * For licensing information, see the file 'LICENCE' in this directory.
9 * 9 *
10 */ 10 */
11 11
12 #ifndef __JFFS2_NODELIST_H__ 12 #ifndef __JFFS2_NODELIST_H__
13 #define __JFFS2_NODELIST_H__ 13 #define __JFFS2_NODELIST_H__
14 14
15 #include <linux/fs.h> 15 #include <linux/fs.h>
16 #include <linux/types.h> 16 #include <linux/types.h>
17 #include <linux/jffs2.h> 17 #include <linux/jffs2.h>
18 #include "jffs2_fs_sb.h" 18 #include "jffs2_fs_sb.h"
19 #include "jffs2_fs_i.h" 19 #include "jffs2_fs_i.h"
20 #include "xattr.h" 20 #include "xattr.h"
21 #include "acl.h" 21 #include "acl.h"
22 #include "summary.h" 22 #include "summary.h"
23 23
24 #ifdef __ECOS 24 #ifdef __ECOS
25 #include "os-ecos.h" 25 #include "os-ecos.h"
26 #else 26 #else
27 #include <linux/mtd/compatmac.h> /* For compat 27 #include <linux/mtd/compatmac.h> /* For compatibility with older kernels */
28 #include "os-linux.h" 28 #include "os-linux.h"
29 #endif 29 #endif
30 30
31 #define JFFS2_NATIVE_ENDIAN 31 #define JFFS2_NATIVE_ENDIAN
32 32
33 /* Note we handle mode bits conversion from JF 33 /* Note we handle mode bits conversion from JFFS2 (i.e. Linux) to/from
34 whatever OS we're actually running on here 34 whatever OS we're actually running on here too. */
35 35
36 #if defined(JFFS2_NATIVE_ENDIAN) 36 #if defined(JFFS2_NATIVE_ENDIAN)
37 #define cpu_to_je16(x) ((jint16_t){x}) 37 #define cpu_to_je16(x) ((jint16_t){x})
38 #define cpu_to_je32(x) ((jint32_t){x}) 38 #define cpu_to_je32(x) ((jint32_t){x})
39 #define cpu_to_jemode(x) ((jmode_t){os_to_jffs 39 #define cpu_to_jemode(x) ((jmode_t){os_to_jffs2_mode(x)})
40 40
41 #define constant_cpu_to_je16(x) ((jint16_t){x} 41 #define constant_cpu_to_je16(x) ((jint16_t){x})
42 #define constant_cpu_to_je32(x) ((jint32_t){x} 42 #define constant_cpu_to_je32(x) ((jint32_t){x})
43 43
44 #define je16_to_cpu(x) ((x).v16) 44 #define je16_to_cpu(x) ((x).v16)
45 #define je32_to_cpu(x) ((x).v32) 45 #define je32_to_cpu(x) ((x).v32)
46 #define jemode_to_cpu(x) (jffs2_to_os_mode((x) 46 #define jemode_to_cpu(x) (jffs2_to_os_mode((x).m))
47 #elif defined(JFFS2_BIG_ENDIAN) 47 #elif defined(JFFS2_BIG_ENDIAN)
48 #define cpu_to_je16(x) ((jint16_t){cpu_to_be16 48 #define cpu_to_je16(x) ((jint16_t){cpu_to_be16(x)})
49 #define cpu_to_je32(x) ((jint32_t){cpu_to_be32 49 #define cpu_to_je32(x) ((jint32_t){cpu_to_be32(x)})
50 #define cpu_to_jemode(x) ((jmode_t){cpu_to_be3 50 #define cpu_to_jemode(x) ((jmode_t){cpu_to_be32(os_to_jffs2_mode(x))})
51 51
52 #define constant_cpu_to_je16(x) ((jint16_t){__ 52 #define constant_cpu_to_je16(x) ((jint16_t){__constant_cpu_to_be16(x)})
53 #define constant_cpu_to_je32(x) ((jint32_t){__ 53 #define constant_cpu_to_je32(x) ((jint32_t){__constant_cpu_to_be32(x)})
54 54
55 #define je16_to_cpu(x) (be16_to_cpu(x.v16)) 55 #define je16_to_cpu(x) (be16_to_cpu(x.v16))
56 #define je32_to_cpu(x) (be32_to_cpu(x.v32)) 56 #define je32_to_cpu(x) (be32_to_cpu(x.v32))
57 #define jemode_to_cpu(x) (be32_to_cpu(jffs2_to 57 #define jemode_to_cpu(x) (be32_to_cpu(jffs2_to_os_mode((x).m)))
58 #elif defined(JFFS2_LITTLE_ENDIAN) 58 #elif defined(JFFS2_LITTLE_ENDIAN)
59 #define cpu_to_je16(x) ((jint16_t){cpu_to_le16 59 #define cpu_to_je16(x) ((jint16_t){cpu_to_le16(x)})
60 #define cpu_to_je32(x) ((jint32_t){cpu_to_le32 60 #define cpu_to_je32(x) ((jint32_t){cpu_to_le32(x)})
61 #define cpu_to_jemode(x) ((jmode_t){cpu_to_le3 61 #define cpu_to_jemode(x) ((jmode_t){cpu_to_le32(os_to_jffs2_mode(x))})
62 62
63 #define constant_cpu_to_je16(x) ((jint16_t){__ 63 #define constant_cpu_to_je16(x) ((jint16_t){__constant_cpu_to_le16(x)})
64 #define constant_cpu_to_je32(x) ((jint32_t){__ 64 #define constant_cpu_to_je32(x) ((jint32_t){__constant_cpu_to_le32(x)})
65 65
66 #define je16_to_cpu(x) (le16_to_cpu(x.v16)) 66 #define je16_to_cpu(x) (le16_to_cpu(x.v16))
67 #define je32_to_cpu(x) (le32_to_cpu(x.v32)) 67 #define je32_to_cpu(x) (le32_to_cpu(x.v32))
68 #define jemode_to_cpu(x) (le32_to_cpu(jffs2_to 68 #define jemode_to_cpu(x) (le32_to_cpu(jffs2_to_os_mode((x).m)))
69 #else 69 #else
70 #error wibble 70 #error wibble
71 #endif 71 #endif
72 72
73 /* The minimal node header size */ 73 /* The minimal node header size */
74 #define JFFS2_MIN_NODE_HEADER sizeof(struct jf 74 #define JFFS2_MIN_NODE_HEADER sizeof(struct jffs2_raw_dirent)
75 75
76 /* 76 /*
77 This is all we need to keep in-core for each 77 This is all we need to keep in-core for each raw node during normal
78 operation. As and when we do read_inode on a 78 operation. As and when we do read_inode on a particular inode, we can
79 scan the nodes which are listed for it and b 79 scan the nodes which are listed for it and build up a proper map of
80 which nodes are currently valid. JFFSv1 alwa 80 which nodes are currently valid. JFFSv1 always used to keep that whole
81 map in core for each inode. 81 map in core for each inode.
82 */ 82 */
83 struct jffs2_raw_node_ref 83 struct jffs2_raw_node_ref
84 { 84 {
85 struct jffs2_raw_node_ref *next_in_ino 85 struct jffs2_raw_node_ref *next_in_ino; /* Points to the next raw_node_ref
86 for this object. If this _is_ 86 for this object. If this _is_ the last, it points to the inode_cache,
87 xattr_ref or xattr_datum inste 87 xattr_ref or xattr_datum instead. The common part of those structures
88 has NULL in the first word. Se 88 has NULL in the first word. See jffs2_raw_ref_to_ic() below */
89 uint32_t flash_offset; 89 uint32_t flash_offset;
90 #define TEST_TOTLEN !! 90 #undef TEST_TOTLEN
91 #ifdef TEST_TOTLEN 91 #ifdef TEST_TOTLEN
92 uint32_t __totlen; /* This may die; us 92 uint32_t __totlen; /* This may die; use ref_totlen(c, jeb, ) below */
93 #endif 93 #endif
94 }; 94 };
95 95
96 #define REF_LINK_NODE ((int32_t)-1) 96 #define REF_LINK_NODE ((int32_t)-1)
97 #define REF_EMPTY_NODE ((int32_t)-2) 97 #define REF_EMPTY_NODE ((int32_t)-2)
98 98
99 /* Use blocks of about 256 bytes */ 99 /* Use blocks of about 256 bytes */
100 #define REFS_PER_BLOCK ((255/sizeof(struct jff 100 #define REFS_PER_BLOCK ((255/sizeof(struct jffs2_raw_node_ref))-1)
101 101
102 static inline struct jffs2_raw_node_ref *ref_n 102 static inline struct jffs2_raw_node_ref *ref_next(struct jffs2_raw_node_ref *ref)
103 { 103 {
104 ref++; 104 ref++;
105 105
106 /* Link to another block of refs */ 106 /* Link to another block of refs */
107 if (ref->flash_offset == REF_LINK_NODE 107 if (ref->flash_offset == REF_LINK_NODE) {
108 ref = ref->next_in_ino; 108 ref = ref->next_in_ino;
109 if (!ref) 109 if (!ref)
110 return ref; 110 return ref;
111 } 111 }
112 112
113 /* End of chain */ 113 /* End of chain */
114 if (ref->flash_offset == REF_EMPTY_NOD 114 if (ref->flash_offset == REF_EMPTY_NODE)
115 return NULL; 115 return NULL;
116 116
117 return ref; 117 return ref;
118 } 118 }
119 119
120 static inline struct jffs2_inode_cache *jffs2_ 120 static inline struct jffs2_inode_cache *jffs2_raw_ref_to_ic(struct jffs2_raw_node_ref *raw)
121 { 121 {
122 while(raw->next_in_ino) 122 while(raw->next_in_ino)
123 raw = raw->next_in_ino; 123 raw = raw->next_in_ino;
124 124
125 /* NB. This can be a jffs2_xattr_datum 125 /* NB. This can be a jffs2_xattr_datum or jffs2_xattr_ref and
126 not actually a jffs2_inode_cache. C 126 not actually a jffs2_inode_cache. Check ->class */
127 return ((struct jffs2_inode_cache *)ra 127 return ((struct jffs2_inode_cache *)raw);
128 } 128 }
129 129
130 /* flash_offset & 3 always has to be z 130 /* flash_offset & 3 always has to be zero, because nodes are
131 always aligned at 4 bytes. So we ha 131 always aligned at 4 bytes. So we have a couple of extra bits
132 to play with, which indicate the no 132 to play with, which indicate the node's status; see below: */
133 #define REF_UNCHECKED 0 /* We haven't 133 #define REF_UNCHECKED 0 /* We haven't yet checked the CRC or built its inode */
134 #define REF_OBSOLETE 1 /* Obsolete, c 134 #define REF_OBSOLETE 1 /* Obsolete, can be completely ignored */
135 #define REF_PRISTINE 2 /* Completely 135 #define REF_PRISTINE 2 /* Completely clean. GC without looking */
136 #define REF_NORMAL 3 /* Possibly ov 136 #define REF_NORMAL 3 /* Possibly overlapped. Read the page and write again on GC */
137 #define ref_flags(ref) ((ref)->flash_ 137 #define ref_flags(ref) ((ref)->flash_offset & 3)
138 #define ref_offset(ref) ((ref)->flash_ 138 #define ref_offset(ref) ((ref)->flash_offset & ~3)
139 #define ref_obsolete(ref) (((ref)->flash 139 #define ref_obsolete(ref) (((ref)->flash_offset & 3) == REF_OBSOLETE)
140 #define mark_ref_normal(ref) do { (ref)->fl 140 #define mark_ref_normal(ref) do { (ref)->flash_offset = ref_offset(ref) | REF_NORMAL; } while(0)
141 141
142 /* Dirent nodes should be REF_PRISTINE only if 142 /* Dirent nodes should be REF_PRISTINE only if they are not a deletion
143 dirent. Deletion dirents should be REF_NORM 143 dirent. Deletion dirents should be REF_NORMAL so that GC gets to
144 throw them away when appropriate */ 144 throw them away when appropriate */
145 #define dirent_node_state(rd) ( (je32_to_cpu 145 #define dirent_node_state(rd) ( (je32_to_cpu((rd)->ino)?REF_PRISTINE:REF_NORMAL) )
146 146
147 /* NB: REF_PRISTINE for an inode-less node (re 147 /* NB: REF_PRISTINE for an inode-less node (ref->next_in_ino == NULL) indicates
148 it is an unknown node of type JFFS2_NODETYP 148 it is an unknown node of type JFFS2_NODETYPE_RWCOMPAT_COPY, so it'll get
149 copied. If you need to do anything differen 149 copied. If you need to do anything different to GC inode-less nodes, then
150 you need to modify gc.c accordingly. */ 150 you need to modify gc.c accordingly. */
151 151
152 /* For each inode in the filesystem, we need t 152 /* For each inode in the filesystem, we need to keep a record of
153 nlink, because it would be a PITA to scan t 153 nlink, because it would be a PITA to scan the whole directory tree
154 at read_inode() time to calculate it, and t 154 at read_inode() time to calculate it, and to keep sufficient information
155 in the raw_node_ref (basically both parent 155 in the raw_node_ref (basically both parent and child inode number for
156 dirent nodes) would take more space than th 156 dirent nodes) would take more space than this does. We also keep
157 a pointer to the first physical node which 157 a pointer to the first physical node which is part of this inode, too.
158 */ 158 */
159 struct jffs2_inode_cache { 159 struct jffs2_inode_cache {
160 /* First part of structure is shared w 160 /* First part of structure is shared with other objects which
161 can terminate the raw node refs' ne 161 can terminate the raw node refs' next_in_ino list -- which
162 currently struct jffs2_xattr_datum 162 currently struct jffs2_xattr_datum and struct jffs2_xattr_ref. */
163 163
164 struct jffs2_full_dirent *scan_dents; 164 struct jffs2_full_dirent *scan_dents; /* Used during scan to hold
165 temporary lists of dirents, an 165 temporary lists of dirents, and later must be set to
166 NULL to mark the end of the ra 166 NULL to mark the end of the raw_node_ref->next_in_ino
167 chain. */ 167 chain. */
168 struct jffs2_raw_node_ref *nodes; 168 struct jffs2_raw_node_ref *nodes;
169 uint8_t class; /* It's used for ident 169 uint8_t class; /* It's used for identification */
170 170
171 /* end of shared structure */ 171 /* end of shared structure */
172 172
173 uint8_t flags; 173 uint8_t flags;
174 uint16_t state; 174 uint16_t state;
175 uint32_t ino; 175 uint32_t ino;
176 struct jffs2_inode_cache *next; 176 struct jffs2_inode_cache *next;
177 #ifdef CONFIG_JFFS2_FS_XATTR 177 #ifdef CONFIG_JFFS2_FS_XATTR
178 struct jffs2_xattr_ref *xref; 178 struct jffs2_xattr_ref *xref;
179 #endif 179 #endif
180 int nlink; !! 180 uint32_t pino_nlink; /* Directories store parent inode
>> 181 here; other inodes store nlink.
>> 182 Zero always means that it's
>> 183 completely unlinked. */
181 }; 184 };
182 185
183 /* Inode states for 'state' above. We need the 186 /* Inode states for 'state' above. We need the 'GC' state to prevent
184 someone from doing a read_inode() while we' 187 someone from doing a read_inode() while we're moving a 'REF_PRISTINE'
185 node without going through all the iget() n 188 node without going through all the iget() nonsense */
186 #define INO_STATE_UNCHECKED 0 /* CRC 189 #define INO_STATE_UNCHECKED 0 /* CRC checks not yet done */
187 #define INO_STATE_CHECKING 1 /* CRC 190 #define INO_STATE_CHECKING 1 /* CRC checks in progress */
188 #define INO_STATE_PRESENT 2 /* In 191 #define INO_STATE_PRESENT 2 /* In core */
189 #define INO_STATE_CHECKEDABSENT 3 /* Che 192 #define INO_STATE_CHECKEDABSENT 3 /* Checked, cleared again */
190 #define INO_STATE_GC 4 /* GCi 193 #define INO_STATE_GC 4 /* GCing a 'pristine' node */
191 #define INO_STATE_READING 5 /* In 194 #define INO_STATE_READING 5 /* In read_inode() */
192 #define INO_STATE_CLEARING 6 /* In 195 #define INO_STATE_CLEARING 6 /* In clear_inode() */
193 196
194 #define INO_FLAGS_XATTR_CHECKED 0x01 /* has 197 #define INO_FLAGS_XATTR_CHECKED 0x01 /* has no duplicate xattr_ref */
195 198
196 #define RAWNODE_CLASS_INODE_CACHE 0 199 #define RAWNODE_CLASS_INODE_CACHE 0
197 #define RAWNODE_CLASS_XATTR_DATUM 1 200 #define RAWNODE_CLASS_XATTR_DATUM 1
198 #define RAWNODE_CLASS_XATTR_REF 2 201 #define RAWNODE_CLASS_XATTR_REF 2
199 202
200 #define INOCACHE_HASHSIZE 128 203 #define INOCACHE_HASHSIZE 128
201 204
202 #define write_ofs(c) ((c)->nextblock->offset + 205 #define write_ofs(c) ((c)->nextblock->offset + (c)->sector_size - (c)->nextblock->free_size)
203 206
204 /* 207 /*
205 Larger representation of a raw node, kept in 208 Larger representation of a raw node, kept in-core only when the
206 struct inode for this particular ino is inst 209 struct inode for this particular ino is instantiated.
207 */ 210 */
208 211
209 struct jffs2_full_dnode 212 struct jffs2_full_dnode
210 { 213 {
211 struct jffs2_raw_node_ref *raw; 214 struct jffs2_raw_node_ref *raw;
212 uint32_t ofs; /* The offset to which t 215 uint32_t ofs; /* The offset to which the data of this node belongs */
213 uint32_t size; 216 uint32_t size;
214 uint32_t frags; /* Number of fragments 217 uint32_t frags; /* Number of fragments which currently refer
215 to this node. When thi 218 to this node. When this reaches zero,
216 the node is obsolete. 219 the node is obsolete. */
217 }; 220 };
218 221
219 /* 222 /*
220 Even larger representation of a raw node, k 223 Even larger representation of a raw node, kept in-core only while
221 we're actually building up the original map 224 we're actually building up the original map of which nodes go where,
222 in read_inode() 225 in read_inode()
223 */ 226 */
224 struct jffs2_tmp_dnode_info 227 struct jffs2_tmp_dnode_info
225 { 228 {
226 struct rb_node rb; 229 struct rb_node rb;
227 struct jffs2_full_dnode *fn; 230 struct jffs2_full_dnode *fn;
228 uint32_t version; 231 uint32_t version;
229 uint32_t data_crc; 232 uint32_t data_crc;
230 uint32_t partial_crc; 233 uint32_t partial_crc;
231 uint16_t csize; 234 uint16_t csize;
232 uint16_t overlapped; 235 uint16_t overlapped;
233 }; 236 };
234 237
235 /* Temporary data structure used during readin 238 /* Temporary data structure used during readinode. */
236 struct jffs2_readinode_info 239 struct jffs2_readinode_info
237 { 240 {
238 struct rb_root tn_root; 241 struct rb_root tn_root;
239 struct jffs2_tmp_dnode_info *mdata_tn; 242 struct jffs2_tmp_dnode_info *mdata_tn;
240 uint32_t highest_version; 243 uint32_t highest_version;
241 uint32_t latest_mctime; 244 uint32_t latest_mctime;
242 uint32_t mctime_ver; 245 uint32_t mctime_ver;
243 struct jffs2_full_dirent *fds; 246 struct jffs2_full_dirent *fds;
244 struct jffs2_raw_node_ref *latest_ref; 247 struct jffs2_raw_node_ref *latest_ref;
245 }; 248 };
246 249
247 struct jffs2_full_dirent 250 struct jffs2_full_dirent
248 { 251 {
249 struct jffs2_raw_node_ref *raw; 252 struct jffs2_raw_node_ref *raw;
250 struct jffs2_full_dirent *next; 253 struct jffs2_full_dirent *next;
251 uint32_t version; 254 uint32_t version;
252 uint32_t ino; /* == zero for unlink */ 255 uint32_t ino; /* == zero for unlink */
253 unsigned int nhash; 256 unsigned int nhash;
254 unsigned char type; 257 unsigned char type;
255 unsigned char name[0]; 258 unsigned char name[0];
256 }; 259 };
257 260
258 /* 261 /*
259 Fragments - used to build a map of which raw 262 Fragments - used to build a map of which raw node to obtain
260 data from for each part of the ino 263 data from for each part of the ino
261 */ 264 */
262 struct jffs2_node_frag 265 struct jffs2_node_frag
263 { 266 {
264 struct rb_node rb; 267 struct rb_node rb;
265 struct jffs2_full_dnode *node; /* NULL 268 struct jffs2_full_dnode *node; /* NULL for holes */
266 uint32_t size; 269 uint32_t size;
267 uint32_t ofs; /* The offset to which t 270 uint32_t ofs; /* The offset to which this fragment belongs */
268 }; 271 };
269 272
270 struct jffs2_eraseblock 273 struct jffs2_eraseblock
271 { 274 {
272 struct list_head list; 275 struct list_head list;
273 int bad_count; 276 int bad_count;
274 uint32_t offset; /* of 277 uint32_t offset; /* of this block in the MTD */
275 278
276 uint32_t unchecked_size; 279 uint32_t unchecked_size;
277 uint32_t used_size; 280 uint32_t used_size;
278 uint32_t dirty_size; 281 uint32_t dirty_size;
279 uint32_t wasted_size; 282 uint32_t wasted_size;
280 uint32_t free_size; /* Note that s 283 uint32_t free_size; /* Note that sector_size - free_size
281 is the addr 284 is the address of the first free space */
282 uint32_t allocated_refs; 285 uint32_t allocated_refs;
283 struct jffs2_raw_node_ref *first_node; 286 struct jffs2_raw_node_ref *first_node;
284 struct jffs2_raw_node_ref *last_node; 287 struct jffs2_raw_node_ref *last_node;
285 288
286 struct jffs2_raw_node_ref *gc_node; 289 struct jffs2_raw_node_ref *gc_node; /* Next node to be garbage collected */
287 }; 290 };
288 291
289 static inline int jffs2_blocks_use_vmalloc(str 292 static inline int jffs2_blocks_use_vmalloc(struct jffs2_sb_info *c)
290 { 293 {
291 return ((c->flash_size / c->sector_siz 294 return ((c->flash_size / c->sector_size) * sizeof (struct jffs2_eraseblock)) > (128 * 1024);
292 } 295 }
293 296
294 #define ref_totlen(a, b, c) __jffs2_ref_totlen 297 #define ref_totlen(a, b, c) __jffs2_ref_totlen((a), (b), (c))
295 298
296 #define ALLOC_NORMAL 0 /* Normal allo 299 #define ALLOC_NORMAL 0 /* Normal allocation */
297 #define ALLOC_DELETION 1 /* Deletion no 300 #define ALLOC_DELETION 1 /* Deletion node. Best to allow it */
298 #define ALLOC_GC 2 /* Space reque 301 #define ALLOC_GC 2 /* Space requested for GC. Give it or die */
299 #define ALLOC_NORETRY 3 /* For jffs2_w 302 #define ALLOC_NORETRY 3 /* For jffs2_write_dnode: On failure, return -EAGAIN instead of retrying */
300 303
301 /* How much dirty space before it goes on the 304 /* How much dirty space before it goes on the very_dirty_list */
302 #define VERYDIRTY(c, size) ((size) >= ((c)->se 305 #define VERYDIRTY(c, size) ((size) >= ((c)->sector_size / 2))
303 306
304 /* check if dirty space is more than 255 Byte 307 /* check if dirty space is more than 255 Byte */
305 #define ISDIRTY(size) ((size) > sizeof (struc 308 #define ISDIRTY(size) ((size) > sizeof (struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN)
306 309
307 #define PAD(x) (((x)+3)&~3) 310 #define PAD(x) (((x)+3)&~3)
308 311
309 static inline int jffs2_encode_dev(union jffs2 312 static inline int jffs2_encode_dev(union jffs2_device_node *jdev, dev_t rdev)
310 { 313 {
311 if (old_valid_dev(rdev)) { 314 if (old_valid_dev(rdev)) {
312 jdev->old = cpu_to_je16(old_en 315 jdev->old = cpu_to_je16(old_encode_dev(rdev));
313 return sizeof(jdev->old); 316 return sizeof(jdev->old);
314 } else { 317 } else {
315 jdev->new = cpu_to_je32(new_en 318 jdev->new = cpu_to_je32(new_encode_dev(rdev));
316 return sizeof(jdev->new); 319 return sizeof(jdev->new);
317 } 320 }
318 } 321 }
319 322
320 static inline struct jffs2_node_frag *frag_fir 323 static inline struct jffs2_node_frag *frag_first(struct rb_root *root)
321 { 324 {
322 struct rb_node *node = rb_first(root); 325 struct rb_node *node = rb_first(root);
323 326
324 if (!node) 327 if (!node)
325 return NULL; 328 return NULL;
326 329
327 return rb_entry(node, struct jffs2_nod 330 return rb_entry(node, struct jffs2_node_frag, rb);
328 } 331 }
329 332
330 static inline struct jffs2_node_frag *frag_las 333 static inline struct jffs2_node_frag *frag_last(struct rb_root *root)
331 { 334 {
332 struct rb_node *node = rb_last(root); 335 struct rb_node *node = rb_last(root);
333 336
334 if (!node) 337 if (!node)
335 return NULL; 338 return NULL;
336 339
337 return rb_entry(node, struct jffs2_nod 340 return rb_entry(node, struct jffs2_node_frag, rb);
338 } 341 }
339 342
340 #define frag_next(frag) rb_entry(rb_next(&(fra 343 #define frag_next(frag) rb_entry(rb_next(&(frag)->rb), struct jffs2_node_frag, rb)
341 #define frag_prev(frag) rb_entry(rb_prev(&(fra 344 #define frag_prev(frag) rb_entry(rb_prev(&(frag)->rb), struct jffs2_node_frag, rb)
342 #define frag_parent(frag) rb_entry(rb_parent(& 345 #define frag_parent(frag) rb_entry(rb_parent(&(frag)->rb), struct jffs2_node_frag, rb)
343 #define frag_left(frag) rb_entry((frag)->rb.rb 346 #define frag_left(frag) rb_entry((frag)->rb.rb_left, struct jffs2_node_frag, rb)
344 #define frag_right(frag) rb_entry((frag)->rb.r 347 #define frag_right(frag) rb_entry((frag)->rb.rb_right, struct jffs2_node_frag, rb)
345 #define frag_erase(frag, list) rb_erase(&frag- 348 #define frag_erase(frag, list) rb_erase(&frag->rb, list);
346 349
347 #define tn_next(tn) rb_entry(rb_next(&(tn)->rb 350 #define tn_next(tn) rb_entry(rb_next(&(tn)->rb), struct jffs2_tmp_dnode_info, rb)
348 #define tn_prev(tn) rb_entry(rb_prev(&(tn)->rb 351 #define tn_prev(tn) rb_entry(rb_prev(&(tn)->rb), struct jffs2_tmp_dnode_info, rb)
349 #define tn_parent(tn) rb_entry(rb_parent(&(tn) 352 #define tn_parent(tn) rb_entry(rb_parent(&(tn)->rb), struct jffs2_tmp_dnode_info, rb)
350 #define tn_left(tn) rb_entry((tn)->rb.rb_left, 353 #define tn_left(tn) rb_entry((tn)->rb.rb_left, struct jffs2_tmp_dnode_info, rb)
351 #define tn_right(tn) rb_entry((tn)->rb.rb_righ 354 #define tn_right(tn) rb_entry((tn)->rb.rb_right, struct jffs2_tmp_dnode_info, rb)
352 #define tn_erase(tn, list) rb_erase(&tn->rb, l 355 #define tn_erase(tn, list) rb_erase(&tn->rb, list);
353 #define tn_last(list) rb_entry(rb_last(list), 356 #define tn_last(list) rb_entry(rb_last(list), struct jffs2_tmp_dnode_info, rb)
354 #define tn_first(list) rb_entry(rb_first(list) 357 #define tn_first(list) rb_entry(rb_first(list), struct jffs2_tmp_dnode_info, rb)
355 358
356 /* nodelist.c */ 359 /* nodelist.c */
357 void jffs2_add_fd_to_list(struct jffs2_sb_info 360 void jffs2_add_fd_to_list(struct jffs2_sb_info *c, struct jffs2_full_dirent *new, struct jffs2_full_dirent **list);
358 void jffs2_set_inocache_state(struct jffs2_sb_ 361 void jffs2_set_inocache_state(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic, int state);
359 struct jffs2_inode_cache *jffs2_get_ino_cache( 362 struct jffs2_inode_cache *jffs2_get_ino_cache(struct jffs2_sb_info *c, uint32_t ino);
360 void jffs2_add_ino_cache (struct jffs2_sb_info 363 void jffs2_add_ino_cache (struct jffs2_sb_info *c, struct jffs2_inode_cache *new);
361 void jffs2_del_ino_cache(struct jffs2_sb_info 364 void jffs2_del_ino_cache(struct jffs2_sb_info *c, struct jffs2_inode_cache *old);
362 void jffs2_free_ino_caches(struct jffs2_sb_inf 365 void jffs2_free_ino_caches(struct jffs2_sb_info *c);
363 void jffs2_free_raw_node_refs(struct jffs2_sb_ 366 void jffs2_free_raw_node_refs(struct jffs2_sb_info *c);
364 struct jffs2_node_frag *jffs2_lookup_node_frag 367 struct jffs2_node_frag *jffs2_lookup_node_frag(struct rb_root *fragtree, uint32_t offset);
365 void jffs2_kill_fragtree(struct rb_root *root, 368 void jffs2_kill_fragtree(struct rb_root *root, struct jffs2_sb_info *c_delete);
366 struct rb_node *rb_next(struct rb_node *); <<
367 struct rb_node *rb_prev(struct rb_node *); <<
368 void rb_replace_node(struct rb_node *victim, s <<
369 int jffs2_add_full_dnode_to_inode(struct jffs2 369 int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_full_dnode *fn);
370 uint32_t jffs2_truncate_fragtree (struct jffs2 370 uint32_t jffs2_truncate_fragtree (struct jffs2_sb_info *c, struct rb_root *list, uint32_t size);
371 struct jffs2_raw_node_ref *jffs2_link_node_ref 371 struct jffs2_raw_node_ref *jffs2_link_node_ref(struct jffs2_sb_info *c,
372 372 struct jffs2_eraseblock *jeb,
373 373 uint32_t ofs, uint32_t len,
374 374 struct jffs2_inode_cache *ic);
375 extern uint32_t __jffs2_ref_totlen(struct jffs 375 extern uint32_t __jffs2_ref_totlen(struct jffs2_sb_info *c,
376 struct jffs 376 struct jffs2_eraseblock *jeb,
377 struct jffs 377 struct jffs2_raw_node_ref *ref);
378 378
379 /* nodemgmt.c */ 379 /* nodemgmt.c */
380 int jffs2_thread_should_wake(struct jffs2_sb_i 380 int jffs2_thread_should_wake(struct jffs2_sb_info *c);
381 int jffs2_reserve_space(struct jffs2_sb_info * 381 int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
382 uint32_t *len, int pri 382 uint32_t *len, int prio, uint32_t sumsize);
383 int jffs2_reserve_space_gc(struct jffs2_sb_inf 383 int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize,
384 uint32_t *len, uint32_ 384 uint32_t *len, uint32_t sumsize);
385 struct jffs2_raw_node_ref *jffs2_add_physical_ 385 struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c,
386 386 uint32_t ofs, uint32_t len,
387 387 struct jffs2_inode_cache *ic);
388 void jffs2_complete_reservation(struct jffs2_s 388 void jffs2_complete_reservation(struct jffs2_sb_info *c);
389 void jffs2_mark_node_obsolete(struct jffs2_sb_ 389 void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *raw);
390 390
391 /* write.c */ 391 /* write.c */
392 int jffs2_do_new_inode(struct jffs2_sb_info *c 392 int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri);
393 393
394 struct jffs2_full_dnode *jffs2_write_dnode(str 394 struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
395 str 395 struct jffs2_raw_inode *ri, const unsigned char *data,
396 uin 396 uint32_t datalen, int alloc_mode);
397 struct jffs2_full_dirent *jffs2_write_dirent(s 397 struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
398 s 398 struct jffs2_raw_dirent *rd, const unsigned char *name,
399 u 399 uint32_t namelen, int alloc_mode);
400 int jffs2_write_inode_range(struct jffs2_sb_in 400 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
401 struct jffs2_raw_i 401 struct jffs2_raw_inode *ri, unsigned char *buf,
402 uint32_t offset, u 402 uint32_t offset, uint32_t writelen, uint32_t *retlen);
403 int jffs2_do_create(struct jffs2_sb_info *c, s 403 int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, struct jffs2_inode_info *f,
404 struct jffs2_raw_inode *ri 404 struct jffs2_raw_inode *ri, const char *name, int namelen);
405 int jffs2_do_unlink(struct jffs2_sb_info *c, s 405 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, const char *name,
406 int namelen, struct jffs2_ 406 int namelen, struct jffs2_inode_info *dead_f, uint32_t time);
407 int jffs2_do_link(struct jffs2_sb_info *c, str 407 int jffs2_do_link(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, uint32_t ino,
408 uint8_t type, const char *n 408 uint8_t type, const char *name, int namelen, uint32_t time);
409 409
410 410
411 /* readinode.c */ 411 /* readinode.c */
412 int jffs2_do_read_inode(struct jffs2_sb_info * 412 int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
413 uint32_t ino, struct j 413 uint32_t ino, struct jffs2_raw_inode *latest_node);
414 int jffs2_do_crccheck_inode(struct jffs2_sb_in 414 int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic);
415 void jffs2_do_clear_inode(struct jffs2_sb_info 415 void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f);
416 416
417 /* malloc.c */ 417 /* malloc.c */
418 int jffs2_create_slab_caches(void); 418 int jffs2_create_slab_caches(void);
419 void jffs2_destroy_slab_caches(void); 419 void jffs2_destroy_slab_caches(void);
420 420
421 struct jffs2_full_dirent *jffs2_alloc_full_dir 421 struct jffs2_full_dirent *jffs2_alloc_full_dirent(int namesize);
422 void jffs2_free_full_dirent(struct jffs2_full_ 422 void jffs2_free_full_dirent(struct jffs2_full_dirent *);
423 struct jffs2_full_dnode *jffs2_alloc_full_dnod 423 struct jffs2_full_dnode *jffs2_alloc_full_dnode(void);
424 void jffs2_free_full_dnode(struct jffs2_full_d 424 void jffs2_free_full_dnode(struct jffs2_full_dnode *);
425 struct jffs2_raw_dirent *jffs2_alloc_raw_diren 425 struct jffs2_raw_dirent *jffs2_alloc_raw_dirent(void);
426 void jffs2_free_raw_dirent(struct jffs2_raw_di 426 void jffs2_free_raw_dirent(struct jffs2_raw_dirent *);
427 struct jffs2_raw_inode *jffs2_alloc_raw_inode( 427 struct jffs2_raw_inode *jffs2_alloc_raw_inode(void);
428 void jffs2_free_raw_inode(struct jffs2_raw_ino 428 void jffs2_free_raw_inode(struct jffs2_raw_inode *);
429 struct jffs2_tmp_dnode_info *jffs2_alloc_tmp_d 429 struct jffs2_tmp_dnode_info *jffs2_alloc_tmp_dnode_info(void);
430 void jffs2_free_tmp_dnode_info(struct jffs2_tm 430 void jffs2_free_tmp_dnode_info(struct jffs2_tmp_dnode_info *);
431 int jffs2_prealloc_raw_node_refs(struct jffs2_ 431 int jffs2_prealloc_raw_node_refs(struct jffs2_sb_info *c,
432 struct jffs2_ 432 struct jffs2_eraseblock *jeb, int nr);
433 void jffs2_free_refblock(struct jffs2_raw_node 433 void jffs2_free_refblock(struct jffs2_raw_node_ref *);
434 struct jffs2_node_frag *jffs2_alloc_node_frag( 434 struct jffs2_node_frag *jffs2_alloc_node_frag(void);
435 void jffs2_free_node_frag(struct jffs2_node_fr 435 void jffs2_free_node_frag(struct jffs2_node_frag *);
436 struct jffs2_inode_cache *jffs2_alloc_inode_ca 436 struct jffs2_inode_cache *jffs2_alloc_inode_cache(void);
437 void jffs2_free_inode_cache(struct jffs2_inode 437 void jffs2_free_inode_cache(struct jffs2_inode_cache *);
438 #ifdef CONFIG_JFFS2_FS_XATTR 438 #ifdef CONFIG_JFFS2_FS_XATTR
439 struct jffs2_xattr_datum *jffs2_alloc_xattr_da 439 struct jffs2_xattr_datum *jffs2_alloc_xattr_datum(void);
440 void jffs2_free_xattr_datum(struct jffs2_xattr 440 void jffs2_free_xattr_datum(struct jffs2_xattr_datum *);
441 struct jffs2_xattr_ref *jffs2_alloc_xattr_ref( 441 struct jffs2_xattr_ref *jffs2_alloc_xattr_ref(void);
442 void jffs2_free_xattr_ref(struct jffs2_xattr_r 442 void jffs2_free_xattr_ref(struct jffs2_xattr_ref *);
443 #endif 443 #endif
444 444
445 /* gc.c */ 445 /* gc.c */
446 int jffs2_garbage_collect_pass(struct jffs2_sb 446 int jffs2_garbage_collect_pass(struct jffs2_sb_info *c);
447 447
448 /* read.c */ 448 /* read.c */
449 int jffs2_read_dnode(struct jffs2_sb_info *c, 449 int jffs2_read_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
450 struct jffs2_full_dnode * 450 struct jffs2_full_dnode *fd, unsigned char *buf,
451 int ofs, int len); 451 int ofs, int len);
452 int jffs2_read_inode_range(struct jffs2_sb_inf 452 int jffs2_read_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
453 unsigned char *buf, 453 unsigned char *buf, uint32_t offset, uint32_t len);
454 char *jffs2_getlink(struct jffs2_sb_info *c, s 454 char *jffs2_getlink(struct jffs2_sb_info *c, struct jffs2_inode_info *f);
455 455
456 /* scan.c */ 456 /* scan.c */
457 int jffs2_scan_medium(struct jffs2_sb_info *c) 457 int jffs2_scan_medium(struct jffs2_sb_info *c);
458 void jffs2_rotate_lists(struct jffs2_sb_info * 458 void jffs2_rotate_lists(struct jffs2_sb_info *c);
459 struct jffs2_inode_cache *jffs2_scan_make_ino_ 459 struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino);
460 int jffs2_scan_classify_jeb(struct jffs2_sb_in 460 int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
461 int jffs2_scan_dirty_space(struct jffs2_sb_inf 461 int jffs2_scan_dirty_space(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t size);
462 462
463 /* build.c */ 463 /* build.c */
464 int jffs2_do_mount_fs(struct jffs2_sb_info *c) 464 int jffs2_do_mount_fs(struct jffs2_sb_info *c);
465 465
466 /* erase.c */ 466 /* erase.c */
467 void jffs2_erase_pending_blocks(struct jffs2_s 467 void jffs2_erase_pending_blocks(struct jffs2_sb_info *c, int count);
468 void jffs2_free_jeb_node_refs(struct jffs2_sb_ 468 void jffs2_free_jeb_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
469 469
470 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 470 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
471 /* wbuf.c */ 471 /* wbuf.c */
472 int jffs2_flush_wbuf_gc(struct jffs2_sb_info * 472 int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino);
473 int jffs2_flush_wbuf_pad(struct jffs2_sb_info 473 int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c);
474 int jffs2_check_nand_cleanmarker(struct jffs2_ 474 int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
475 int jffs2_write_nand_cleanmarker(struct jffs2_ 475 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
476 #endif 476 #endif
477 477
478 #include "debug.h" 478 #include "debug.h"
479 479
480 #endif /* __JFFS2_NODELIST_H__ */ 480 #endif /* __JFFS2_NODELIST_H__ */
481 481
|
This page was automatically generated by the
LXR engine.
|