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