Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * JFFS -- Journaling Flash File System, Linux implementation. | |
3 | * | |
4 | * Copyright (C) 1999, 2000 Axis Communications AB. | |
5 | * | |
6 | * Created by Finn Hakansson <finn@axis.com>. | |
7 | * | |
8 | * This is free software; you can redistribute it and/or modify it | |
9 | * under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * $Id: jffs_fm.c,v 1.27 2001/09/20 12:29:47 dwmw2 Exp $ | |
14 | * | |
15 | * Ported to Linux 2.3.x and MTD: | |
16 | * Copyright (C) 2000 Alexander Larsson (alex@cendio.se), Cendio Systems AB | |
17 | * | |
18 | */ | |
19 | #include <linux/slab.h> | |
20 | #include <linux/blkdev.h> | |
21 | #include <linux/jffs.h> | |
22 | #include "jffs_fm.h" | |
34c90b29 | 23 | #include "intrep.h" |
1da177e4 LT |
24 | |
25 | #if defined(JFFS_MARK_OBSOLETE) && JFFS_MARK_OBSOLETE | |
26 | static int jffs_mark_obsolete(struct jffs_fmcontrol *fmc, __u32 fm_offset); | |
27 | #endif | |
28 | ||
29 | static struct jffs_fm *jffs_alloc_fm(void); | |
30 | static void jffs_free_fm(struct jffs_fm *n); | |
31 | ||
32 | extern kmem_cache_t *fm_cache; | |
33 | extern kmem_cache_t *node_cache; | |
34 | ||
94c9eca2 AB |
35 | #if CONFIG_JFFS_FS_VERBOSE > 0 |
36 | void | |
37 | jffs_print_fmcontrol(struct jffs_fmcontrol *fmc) | |
38 | { | |
39 | D(printk("struct jffs_fmcontrol: 0x%p\n", fmc)); | |
40 | D(printk("{\n")); | |
41 | D(printk(" %u, /* flash_size */\n", fmc->flash_size)); | |
42 | D(printk(" %u, /* used_size */\n", fmc->used_size)); | |
43 | D(printk(" %u, /* dirty_size */\n", fmc->dirty_size)); | |
44 | D(printk(" %u, /* free_size */\n", fmc->free_size)); | |
45 | D(printk(" %u, /* sector_size */\n", fmc->sector_size)); | |
46 | D(printk(" %u, /* min_free_size */\n", fmc->min_free_size)); | |
47 | D(printk(" %u, /* max_chunk_size */\n", fmc->max_chunk_size)); | |
48 | D(printk(" 0x%p, /* mtd */\n", fmc->mtd)); | |
49 | D(printk(" 0x%p, /* head */ " | |
50 | "(head->offset = 0x%08x)\n", | |
51 | fmc->head, (fmc->head ? fmc->head->offset : 0))); | |
52 | D(printk(" 0x%p, /* tail */ " | |
53 | "(tail->offset + tail->size = 0x%08x)\n", | |
54 | fmc->tail, | |
55 | (fmc->tail ? fmc->tail->offset + fmc->tail->size : 0))); | |
56 | D(printk(" 0x%p, /* head_extra */\n", fmc->head_extra)); | |
57 | D(printk(" 0x%p, /* tail_extra */\n", fmc->tail_extra)); | |
58 | D(printk("}\n")); | |
59 | } | |
60 | #endif /* CONFIG_JFFS_FS_VERBOSE > 0 */ | |
61 | ||
62 | #if CONFIG_JFFS_FS_VERBOSE > 2 | |
63 | static void | |
64 | jffs_print_fm(struct jffs_fm *fm) | |
65 | { | |
66 | D(printk("struct jffs_fm: 0x%p\n", fm)); | |
67 | D(printk("{\n")); | |
68 | D(printk(" 0x%08x, /* offset */\n", fm->offset)); | |
69 | D(printk(" %u, /* size */\n", fm->size)); | |
70 | D(printk(" 0x%p, /* prev */\n", fm->prev)); | |
71 | D(printk(" 0x%p, /* next */\n", fm->next)); | |
72 | D(printk(" 0x%p, /* nodes */\n", fm->nodes)); | |
73 | D(printk("}\n")); | |
74 | } | |
75 | #endif /* CONFIG_JFFS_FS_VERBOSE > 2 */ | |
76 | ||
77 | #if 0 | |
78 | void | |
79 | jffs_print_node_ref(struct jffs_node_ref *ref) | |
80 | { | |
81 | D(printk("struct jffs_node_ref: 0x%p\n", ref)); | |
82 | D(printk("{\n")); | |
83 | D(printk(" 0x%p, /* node */\n", ref->node)); | |
84 | D(printk(" 0x%p, /* next */\n", ref->next)); | |
85 | D(printk("}\n")); | |
86 | } | |
87 | #endif /* 0 */ | |
88 | ||
1da177e4 LT |
89 | /* This function creates a new shiny flash memory control structure. */ |
90 | struct jffs_fmcontrol * | |
91 | jffs_build_begin(struct jffs_control *c, int unit) | |
92 | { | |
93 | struct jffs_fmcontrol *fmc; | |
94 | struct mtd_info *mtd; | |
95 | ||
96 | D3(printk("jffs_build_begin()\n")); | |
97 | fmc = (struct jffs_fmcontrol *)kmalloc(sizeof(struct jffs_fmcontrol), | |
98 | GFP_KERNEL); | |
99 | if (!fmc) { | |
100 | D(printk("jffs_build_begin(): Allocation of " | |
101 | "struct jffs_fmcontrol failed!\n")); | |
102 | return (struct jffs_fmcontrol *)0; | |
103 | } | |
104 | DJM(no_jffs_fmcontrol++); | |
105 | ||
106 | mtd = get_mtd_device(NULL, unit); | |
107 | ||
108 | if (!mtd) { | |
109 | kfree(fmc); | |
110 | DJM(no_jffs_fmcontrol--); | |
111 | return NULL; | |
112 | } | |
113 | ||
114 | /* Retrieve the size of the flash memory. */ | |
115 | fmc->flash_size = mtd->size; | |
116 | D3(printk(" fmc->flash_size = %d bytes\n", fmc->flash_size)); | |
117 | ||
118 | fmc->used_size = 0; | |
119 | fmc->dirty_size = 0; | |
120 | fmc->free_size = mtd->size; | |
121 | fmc->sector_size = mtd->erasesize; | |
122 | fmc->max_chunk_size = fmc->sector_size >> 1; | |
123 | /* min_free_size: | |
124 | 1 sector, obviously. | |
125 | + 1 x max_chunk_size, for when a nodes overlaps the end of a sector | |
126 | + 1 x max_chunk_size again, which ought to be enough to handle | |
127 | the case where a rename causes a name to grow, and GC has | |
128 | to write out larger nodes than the ones it's obsoleting. | |
129 | We should fix it so it doesn't have to write the name | |
130 | _every_ time. Later. | |
131 | + another 2 sectors because people keep getting GC stuck and | |
132 | we don't know why. This scares me - I want formal proof | |
133 | of correctness of whatever number we put here. dwmw2. | |
134 | */ | |
135 | fmc->min_free_size = fmc->sector_size << 2; | |
136 | fmc->mtd = mtd; | |
137 | fmc->c = c; | |
138 | fmc->head = NULL; | |
139 | fmc->tail = NULL; | |
140 | fmc->head_extra = NULL; | |
141 | fmc->tail_extra = NULL; | |
142 | init_MUTEX(&fmc->biglock); | |
143 | return fmc; | |
144 | } | |
145 | ||
146 | ||
147 | /* When the flash memory scan has completed, this function should be called | |
148 | before use of the control structure. */ | |
149 | void | |
150 | jffs_build_end(struct jffs_fmcontrol *fmc) | |
151 | { | |
152 | D3(printk("jffs_build_end()\n")); | |
153 | ||
154 | if (!fmc->head) { | |
155 | fmc->head = fmc->head_extra; | |
156 | fmc->tail = fmc->tail_extra; | |
157 | } | |
158 | else if (fmc->head_extra) { | |
159 | fmc->tail_extra->next = fmc->head; | |
160 | fmc->head->prev = fmc->tail_extra; | |
161 | fmc->head = fmc->head_extra; | |
162 | } | |
163 | fmc->head_extra = NULL; /* These two instructions should be omitted. */ | |
164 | fmc->tail_extra = NULL; | |
165 | D3(jffs_print_fmcontrol(fmc)); | |
166 | } | |
167 | ||
168 | ||
169 | /* Call this function when the file system is unmounted. This function | |
170 | frees all memory used by this module. */ | |
171 | void | |
172 | jffs_cleanup_fmcontrol(struct jffs_fmcontrol *fmc) | |
173 | { | |
174 | if (fmc) { | |
175 | struct jffs_fm *next = fmc->head; | |
176 | while (next) { | |
177 | struct jffs_fm *cur = next; | |
178 | next = next->next; | |
179 | jffs_free_fm(cur); | |
180 | } | |
181 | put_mtd_device(fmc->mtd); | |
182 | kfree(fmc); | |
183 | DJM(no_jffs_fmcontrol--); | |
184 | } | |
185 | } | |
186 | ||
187 | ||
188 | /* This function returns the size of the first chunk of free space on the | |
189 | flash memory. This function will return something nonzero if the flash | |
190 | memory contains any free space. */ | |
191 | __u32 | |
192 | jffs_free_size1(struct jffs_fmcontrol *fmc) | |
193 | { | |
194 | __u32 head; | |
195 | __u32 tail; | |
196 | __u32 end = fmc->flash_size; | |
197 | ||
198 | if (!fmc->head) { | |
199 | /* There is nothing on the flash. */ | |
200 | return fmc->flash_size; | |
201 | } | |
202 | ||
203 | /* Compute the beginning and ending of the contents of the flash. */ | |
204 | head = fmc->head->offset; | |
205 | tail = fmc->tail->offset + fmc->tail->size; | |
206 | if (tail == end) { | |
207 | tail = 0; | |
208 | } | |
209 | ASSERT(else if (tail > end) { | |
210 | printk(KERN_WARNING "jffs_free_size1(): tail > end\n"); | |
211 | tail = 0; | |
212 | }); | |
213 | ||
214 | if (head <= tail) { | |
215 | return end - tail; | |
216 | } | |
217 | else { | |
218 | return head - tail; | |
219 | } | |
220 | } | |
221 | ||
222 | /* This function will return something nonzero in case there are two free | |
223 | areas on the flash. Like this: | |
224 | ||
225 | +----------------+------------------+----------------+ | |
226 | | FREE 1 | USED / DIRTY | FREE 2 | | |
227 | +----------------+------------------+----------------+ | |
228 | fmc->head -----^ | |
229 | fmc->tail ------------------------^ | |
230 | ||
231 | The value returned, will be the size of the first empty area on the | |
232 | flash, in this case marked "FREE 1". */ | |
233 | __u32 | |
234 | jffs_free_size2(struct jffs_fmcontrol *fmc) | |
235 | { | |
236 | if (fmc->head) { | |
237 | __u32 head = fmc->head->offset; | |
238 | __u32 tail = fmc->tail->offset + fmc->tail->size; | |
239 | if (tail == fmc->flash_size) { | |
240 | tail = 0; | |
241 | } | |
242 | ||
243 | if (tail >= head) { | |
244 | return head; | |
245 | } | |
246 | } | |
247 | return 0; | |
248 | } | |
249 | ||
250 | ||
251 | /* Allocate a chunk of flash memory. If there is enough space on the | |
252 | device, a reference to the associated node is stored in the jffs_fm | |
253 | struct. */ | |
254 | int | |
255 | jffs_fmalloc(struct jffs_fmcontrol *fmc, __u32 size, struct jffs_node *node, | |
256 | struct jffs_fm **result) | |
257 | { | |
258 | struct jffs_fm *fm; | |
259 | __u32 free_chunk_size1; | |
260 | __u32 free_chunk_size2; | |
261 | ||
262 | D2(printk("jffs_fmalloc(): fmc = 0x%p, size = %d, " | |
263 | "node = 0x%p\n", fmc, size, node)); | |
264 | ||
265 | *result = NULL; | |
266 | ||
267 | if (!(fm = jffs_alloc_fm())) { | |
268 | D(printk("jffs_fmalloc(): kmalloc() failed! (fm)\n")); | |
269 | return -ENOMEM; | |
270 | } | |
271 | ||
272 | free_chunk_size1 = jffs_free_size1(fmc); | |
273 | free_chunk_size2 = jffs_free_size2(fmc); | |
274 | if (free_chunk_size1 + free_chunk_size2 != fmc->free_size) { | |
275 | printk(KERN_WARNING "Free size accounting screwed\n"); | |
276 | printk(KERN_WARNING "free_chunk_size1 == 0x%x, free_chunk_size2 == 0x%x, fmc->free_size == 0x%x\n", free_chunk_size1, free_chunk_size2, fmc->free_size); | |
277 | } | |
278 | ||
279 | D3(printk("jffs_fmalloc(): free_chunk_size1 = %u, " | |
280 | "free_chunk_size2 = %u\n", | |
281 | free_chunk_size1, free_chunk_size2)); | |
282 | ||
283 | if (size <= free_chunk_size1) { | |
284 | if (!(fm->nodes = (struct jffs_node_ref *) | |
285 | kmalloc(sizeof(struct jffs_node_ref), | |
286 | GFP_KERNEL))) { | |
287 | D(printk("jffs_fmalloc(): kmalloc() failed! " | |
288 | "(node_ref)\n")); | |
289 | jffs_free_fm(fm); | |
290 | return -ENOMEM; | |
291 | } | |
292 | DJM(no_jffs_node_ref++); | |
293 | fm->nodes->node = node; | |
294 | fm->nodes->next = NULL; | |
295 | if (fmc->tail) { | |
296 | fm->offset = fmc->tail->offset + fmc->tail->size; | |
297 | if (fm->offset == fmc->flash_size) { | |
298 | fm->offset = 0; | |
299 | } | |
300 | ASSERT(else if (fm->offset > fmc->flash_size) { | |
301 | printk(KERN_WARNING "jffs_fmalloc(): " | |
302 | "offset > flash_end\n"); | |
303 | fm->offset = 0; | |
304 | }); | |
305 | } | |
306 | else { | |
307 | /* There don't have to be files in the file | |
308 | system yet. */ | |
309 | fm->offset = 0; | |
310 | } | |
311 | fm->size = size; | |
312 | fmc->free_size -= size; | |
313 | fmc->used_size += size; | |
314 | } | |
315 | else if (size > free_chunk_size2) { | |
316 | printk(KERN_WARNING "JFFS: Tried to allocate a too " | |
317 | "large flash memory chunk. (size = %u)\n", size); | |
318 | jffs_free_fm(fm); | |
319 | return -ENOSPC; | |
320 | } | |
321 | else { | |
322 | fm->offset = fmc->tail->offset + fmc->tail->size; | |
323 | fm->size = free_chunk_size1; | |
324 | fm->nodes = NULL; | |
325 | fmc->free_size -= fm->size; | |
326 | fmc->dirty_size += fm->size; /* Changed by simonk. This seemingly fixes a | |
327 | bug that caused infinite garbage collection. | |
328 | It previously set fmc->dirty_size to size (which is the | |
329 | size of the requested chunk). | |
330 | */ | |
331 | } | |
332 | ||
333 | fm->next = NULL; | |
334 | if (!fmc->head) { | |
335 | fm->prev = NULL; | |
336 | fmc->head = fm; | |
337 | fmc->tail = fm; | |
338 | } | |
339 | else { | |
340 | fm->prev = fmc->tail; | |
341 | fmc->tail->next = fm; | |
342 | fmc->tail = fm; | |
343 | } | |
344 | ||
345 | D3(jffs_print_fmcontrol(fmc)); | |
346 | D3(jffs_print_fm(fm)); | |
347 | *result = fm; | |
348 | return 0; | |
349 | } | |
350 | ||
351 | ||
352 | /* The on-flash space is not needed anymore by the passed node. Remove | |
353 | the reference to the node from the node list. If the data chunk in | |
354 | the flash memory isn't used by any more nodes anymore (fm->nodes == 0), | |
355 | then mark that chunk as dirty. */ | |
356 | int | |
357 | jffs_fmfree(struct jffs_fmcontrol *fmc, struct jffs_fm *fm, struct jffs_node *node) | |
358 | { | |
359 | struct jffs_node_ref *ref; | |
360 | struct jffs_node_ref *prev; | |
361 | ASSERT(int del = 0); | |
362 | ||
363 | D2(printk("jffs_fmfree(): node->ino = %u, node->version = %u\n", | |
364 | node->ino, node->version)); | |
365 | ||
366 | ASSERT(if (!fmc || !fm || !fm->nodes) { | |
367 | printk(KERN_ERR "jffs_fmfree(): fmc: 0x%p, fm: 0x%p, " | |
368 | "fm->nodes: 0x%p\n", | |
369 | fmc, fm, (fm ? fm->nodes : NULL)); | |
370 | return -1; | |
371 | }); | |
372 | ||
373 | /* Find the reference to the node that is going to be removed | |
374 | and remove it. */ | |
375 | for (ref = fm->nodes, prev = NULL; ref; ref = ref->next) { | |
376 | if (ref->node == node) { | |
377 | if (prev) { | |
378 | prev->next = ref->next; | |
379 | } | |
380 | else { | |
381 | fm->nodes = ref->next; | |
382 | } | |
383 | kfree(ref); | |
384 | DJM(no_jffs_node_ref--); | |
385 | ASSERT(del = 1); | |
386 | break; | |
387 | } | |
388 | prev = ref; | |
389 | } | |
390 | ||
391 | /* If the data chunk in the flash memory isn't used anymore | |
392 | just mark it as obsolete. */ | |
393 | if (!fm->nodes) { | |
394 | /* No node uses this chunk so let's remove it. */ | |
395 | fmc->used_size -= fm->size; | |
396 | fmc->dirty_size += fm->size; | |
397 | #if defined(JFFS_MARK_OBSOLETE) && JFFS_MARK_OBSOLETE | |
398 | if (jffs_mark_obsolete(fmc, fm->offset) < 0) { | |
399 | D1(printk("jffs_fmfree(): Failed to mark an on-flash " | |
400 | "node obsolete!\n")); | |
401 | return -1; | |
402 | } | |
403 | #endif | |
404 | } | |
405 | ||
406 | ASSERT(if (!del) { | |
407 | printk(KERN_WARNING "***jffs_fmfree(): " | |
408 | "Didn't delete any node reference!\n"); | |
409 | }); | |
410 | ||
411 | return 0; | |
412 | } | |
413 | ||
414 | ||
415 | /* This allocation function is used during the initialization of | |
416 | the file system. */ | |
417 | struct jffs_fm * | |
418 | jffs_fmalloced(struct jffs_fmcontrol *fmc, __u32 offset, __u32 size, | |
419 | struct jffs_node *node) | |
420 | { | |
421 | struct jffs_fm *fm; | |
422 | ||
423 | D3(printk("jffs_fmalloced()\n")); | |
424 | ||
425 | if (!(fm = jffs_alloc_fm())) { | |
426 | D(printk("jffs_fmalloced(0x%p, %u, %u, 0x%p): failed!\n", | |
427 | fmc, offset, size, node)); | |
428 | return NULL; | |
429 | } | |
430 | fm->offset = offset; | |
431 | fm->size = size; | |
432 | fm->prev = NULL; | |
433 | fm->next = NULL; | |
434 | fm->nodes = NULL; | |
435 | if (node) { | |
436 | /* `node' exists and it should be associated with the | |
437 | jffs_fm structure `fm'. */ | |
438 | if (!(fm->nodes = (struct jffs_node_ref *) | |
439 | kmalloc(sizeof(struct jffs_node_ref), | |
440 | GFP_KERNEL))) { | |
441 | D(printk("jffs_fmalloced(): !fm->nodes\n")); | |
442 | jffs_free_fm(fm); | |
443 | return NULL; | |
444 | } | |
445 | DJM(no_jffs_node_ref++); | |
446 | fm->nodes->node = node; | |
447 | fm->nodes->next = NULL; | |
448 | fmc->used_size += size; | |
449 | fmc->free_size -= size; | |
450 | } | |
451 | else { | |
452 | /* If there is no node, then this is just a chunk of dirt. */ | |
453 | fmc->dirty_size += size; | |
454 | fmc->free_size -= size; | |
455 | } | |
456 | ||
457 | if (fmc->head_extra) { | |
458 | fm->prev = fmc->tail_extra; | |
459 | fmc->tail_extra->next = fm; | |
460 | fmc->tail_extra = fm; | |
461 | } | |
462 | else if (!fmc->head) { | |
463 | fmc->head = fm; | |
464 | fmc->tail = fm; | |
465 | } | |
466 | else if (fmc->tail->offset + fmc->tail->size < offset) { | |
467 | fmc->head_extra = fm; | |
468 | fmc->tail_extra = fm; | |
469 | } | |
470 | else { | |
471 | fm->prev = fmc->tail; | |
472 | fmc->tail->next = fm; | |
473 | fmc->tail = fm; | |
474 | } | |
475 | D3(jffs_print_fmcontrol(fmc)); | |
476 | D3(jffs_print_fm(fm)); | |
477 | return fm; | |
478 | } | |
479 | ||
480 | ||
481 | /* Add a new node to an already existing jffs_fm struct. */ | |
482 | int | |
483 | jffs_add_node(struct jffs_node *node) | |
484 | { | |
485 | struct jffs_node_ref *ref; | |
486 | ||
487 | D3(printk("jffs_add_node(): ino = %u\n", node->ino)); | |
488 | ||
489 | ref = (struct jffs_node_ref *)kmalloc(sizeof(struct jffs_node_ref), | |
490 | GFP_KERNEL); | |
491 | if (!ref) | |
492 | return -ENOMEM; | |
493 | ||
494 | DJM(no_jffs_node_ref++); | |
495 | ref->node = node; | |
496 | ref->next = node->fm->nodes; | |
497 | node->fm->nodes = ref; | |
498 | return 0; | |
499 | } | |
500 | ||
501 | ||
502 | /* Free a part of some allocated space. */ | |
503 | void | |
504 | jffs_fmfree_partly(struct jffs_fmcontrol *fmc, struct jffs_fm *fm, __u32 size) | |
505 | { | |
506 | D1(printk("***jffs_fmfree_partly(): fm = 0x%p, fm->nodes = 0x%p, " | |
507 | "fm->nodes->node->ino = %u, size = %u\n", | |
508 | fm, (fm ? fm->nodes : 0), | |
509 | (!fm ? 0 : (!fm->nodes ? 0 : fm->nodes->node->ino)), size)); | |
510 | ||
511 | if (fm->nodes) { | |
512 | kfree(fm->nodes); | |
513 | DJM(no_jffs_node_ref--); | |
514 | fm->nodes = NULL; | |
515 | } | |
516 | fmc->used_size -= fm->size; | |
517 | if (fm == fmc->tail) { | |
518 | fm->size -= size; | |
519 | fmc->free_size += size; | |
520 | } | |
521 | fmc->dirty_size += fm->size; | |
522 | } | |
523 | ||
524 | ||
525 | /* Find the jffs_fm struct that contains the end of the data chunk that | |
526 | begins at the logical beginning of the flash memory and spans `size' | |
527 | bytes. If we want to erase a sector of the flash memory, we use this | |
528 | function to find where the sector limit cuts a chunk of data. */ | |
529 | struct jffs_fm * | |
530 | jffs_cut_node(struct jffs_fmcontrol *fmc, __u32 size) | |
531 | { | |
532 | struct jffs_fm *fm; | |
533 | __u32 pos = 0; | |
534 | ||
535 | if (size == 0) { | |
536 | return NULL; | |
537 | } | |
538 | ||
539 | ASSERT(if (!fmc) { | |
540 | printk(KERN_ERR "jffs_cut_node(): fmc == NULL\n"); | |
541 | return NULL; | |
542 | }); | |
543 | ||
544 | fm = fmc->head; | |
545 | ||
546 | while (fm) { | |
547 | pos += fm->size; | |
548 | if (pos < size) { | |
549 | fm = fm->next; | |
550 | } | |
551 | else if (pos > size) { | |
552 | break; | |
553 | } | |
554 | else { | |
555 | fm = NULL; | |
556 | break; | |
557 | } | |
558 | } | |
559 | ||
560 | return fm; | |
561 | } | |
562 | ||
563 | ||
564 | /* Move the head of the fmc structures and delete the obsolete parts. */ | |
565 | void | |
566 | jffs_sync_erase(struct jffs_fmcontrol *fmc, int erased_size) | |
567 | { | |
568 | struct jffs_fm *fm; | |
569 | struct jffs_fm *del; | |
570 | ||
571 | ASSERT(if (!fmc) { | |
572 | printk(KERN_ERR "jffs_sync_erase(): fmc == NULL\n"); | |
573 | return; | |
574 | }); | |
575 | ||
576 | fmc->dirty_size -= erased_size; | |
577 | fmc->free_size += erased_size; | |
578 | ||
579 | for (fm = fmc->head; fm && (erased_size > 0);) { | |
580 | if (erased_size >= fm->size) { | |
581 | erased_size -= fm->size; | |
582 | del = fm; | |
583 | fm = fm->next; | |
584 | fm->prev = NULL; | |
585 | fmc->head = fm; | |
586 | jffs_free_fm(del); | |
587 | } | |
588 | else { | |
589 | fm->size -= erased_size; | |
590 | fm->offset += erased_size; | |
591 | break; | |
592 | } | |
593 | } | |
594 | } | |
595 | ||
596 | ||
597 | /* Return the oldest used node in the flash memory. */ | |
598 | struct jffs_node * | |
599 | jffs_get_oldest_node(struct jffs_fmcontrol *fmc) | |
600 | { | |
601 | struct jffs_fm *fm; | |
602 | struct jffs_node_ref *nref; | |
603 | struct jffs_node *node = NULL; | |
604 | ||
605 | ASSERT(if (!fmc) { | |
606 | printk(KERN_ERR "jffs_get_oldest_node(): fmc == NULL\n"); | |
607 | return NULL; | |
608 | }); | |
609 | ||
610 | for (fm = fmc->head; fm && !fm->nodes; fm = fm->next); | |
611 | ||
612 | if (!fm) { | |
613 | return NULL; | |
614 | } | |
615 | ||
616 | /* The oldest node is the last one in the reference list. This list | |
617 | shouldn't be too long; just one or perhaps two elements. */ | |
618 | for (nref = fm->nodes; nref; nref = nref->next) { | |
619 | node = nref->node; | |
620 | } | |
621 | ||
622 | D2(printk("jffs_get_oldest_node(): ino = %u, version = %u\n", | |
623 | (node ? node->ino : 0), (node ? node->version : 0))); | |
624 | ||
625 | return node; | |
626 | } | |
627 | ||
628 | ||
629 | #if defined(JFFS_MARK_OBSOLETE) && JFFS_MARK_OBSOLETE | |
630 | ||
631 | /* Mark an on-flash node as obsolete. | |
632 | ||
633 | Note that this is just an optimization that isn't necessary for the | |
634 | filesystem to work. */ | |
635 | ||
636 | static int | |
637 | jffs_mark_obsolete(struct jffs_fmcontrol *fmc, __u32 fm_offset) | |
638 | { | |
639 | /* The `accurate_pos' holds the position of the accurate byte | |
640 | in the jffs_raw_inode structure that we are going to mark | |
641 | as obsolete. */ | |
642 | __u32 accurate_pos = fm_offset + JFFS_RAW_INODE_ACCURATE_OFFSET; | |
643 | unsigned char zero = 0x00; | |
644 | size_t len; | |
645 | ||
646 | D3(printk("jffs_mark_obsolete(): accurate_pos = %u\n", accurate_pos)); | |
647 | ASSERT(if (!fmc) { | |
648 | printk(KERN_ERR "jffs_mark_obsolete(): fmc == NULL\n"); | |
649 | return -1; | |
650 | }); | |
651 | ||
652 | /* Write 0x00 to the raw inode's accurate member. Don't care | |
653 | about the return value. */ | |
654 | MTD_WRITE(fmc->mtd, accurate_pos, 1, &len, &zero); | |
655 | return 0; | |
656 | } | |
657 | ||
658 | #endif /* JFFS_MARK_OBSOLETE */ | |
659 | ||
660 | /* check if it's possible to erase the wanted range, and if not, return | |
661 | * the range that IS erasable, or a negative error code. | |
662 | */ | |
663 | static long | |
664 | jffs_flash_erasable_size(struct mtd_info *mtd, __u32 offset, __u32 size) | |
665 | { | |
666 | u_long ssize; | |
667 | ||
668 | /* assume that sector size for a partition is constant even | |
669 | * if it spans more than one chip (you usually put the same | |
670 | * type of chips in a system) | |
671 | */ | |
672 | ||
673 | ssize = mtd->erasesize; | |
674 | ||
675 | if (offset % ssize) { | |
676 | printk(KERN_WARNING "jffs_flash_erasable_size() given non-aligned offset %x (erasesize %lx)\n", offset, ssize); | |
677 | /* The offset is not sector size aligned. */ | |
678 | return -1; | |
679 | } | |
680 | else if (offset > mtd->size) { | |
681 | printk(KERN_WARNING "jffs_flash_erasable_size given offset off the end of device (%x > %x)\n", offset, mtd->size); | |
682 | return -2; | |
683 | } | |
684 | else if (offset + size > mtd->size) { | |
685 | printk(KERN_WARNING "jffs_flash_erasable_size() given length which runs off the end of device (ofs %x + len %x = %x, > %x)\n", offset,size, offset+size, mtd->size); | |
686 | return -3; | |
687 | } | |
688 | ||
689 | return (size / ssize) * ssize; | |
690 | } | |
691 | ||
692 | ||
693 | /* How much dirty flash memory is possible to erase at the moment? */ | |
694 | long | |
695 | jffs_erasable_size(struct jffs_fmcontrol *fmc) | |
696 | { | |
697 | struct jffs_fm *fm; | |
698 | __u32 size = 0; | |
699 | long ret; | |
700 | ||
701 | ASSERT(if (!fmc) { | |
702 | printk(KERN_ERR "jffs_erasable_size(): fmc = NULL\n"); | |
703 | return -1; | |
704 | }); | |
705 | ||
706 | if (!fmc->head) { | |
707 | /* The flash memory is totally empty. No nodes. No dirt. | |
708 | Just return. */ | |
709 | return 0; | |
710 | } | |
711 | ||
712 | /* Calculate how much space that is dirty. */ | |
713 | for (fm = fmc->head; fm && !fm->nodes; fm = fm->next) { | |
714 | if (size && fm->offset == 0) { | |
715 | /* We have reached the beginning of the flash. */ | |
716 | break; | |
717 | } | |
718 | size += fm->size; | |
719 | } | |
720 | ||
721 | /* Someone's signature contained this: | |
722 | There's a fine line between fishing and just standing on | |
723 | the shore like an idiot... */ | |
724 | ret = jffs_flash_erasable_size(fmc->mtd, fmc->head->offset, size); | |
725 | ||
726 | ASSERT(if (ret < 0) { | |
727 | printk("jffs_erasable_size: flash_erasable_size() " | |
728 | "returned something less than zero (%ld).\n", ret); | |
729 | printk("jffs_erasable_size: offset = 0x%08x\n", | |
730 | fmc->head->offset); | |
731 | }); | |
732 | ||
733 | /* If there is dirt on the flash (which is the reason to why | |
734 | this function was called in the first place) but no space is | |
735 | possible to erase right now, the initial part of the list of | |
736 | jffs_fm structs, that hold place for dirty space, could perhaps | |
737 | be shortened. The list's initial "dirty" elements are merged | |
738 | into just one large dirty jffs_fm struct. This operation must | |
739 | only be performed if nothing is possible to erase. Otherwise, | |
740 | jffs_clear_end_of_node() won't work as expected. */ | |
741 | if (ret == 0) { | |
742 | struct jffs_fm *head = fmc->head; | |
743 | struct jffs_fm *del; | |
744 | /* While there are two dirty nodes beside each other.*/ | |
745 | while (head->nodes == 0 | |
746 | && head->next | |
747 | && head->next->nodes == 0) { | |
748 | del = head->next; | |
749 | head->size += del->size; | |
750 | head->next = del->next; | |
751 | if (del->next) { | |
752 | del->next->prev = head; | |
753 | } | |
754 | jffs_free_fm(del); | |
755 | } | |
756 | } | |
757 | ||
758 | return (ret >= 0 ? ret : 0); | |
759 | } | |
760 | ||
761 | static struct jffs_fm *jffs_alloc_fm(void) | |
762 | { | |
763 | struct jffs_fm *fm; | |
764 | ||
765 | fm = kmem_cache_alloc(fm_cache,GFP_KERNEL); | |
766 | DJM(if (fm) no_jffs_fm++;); | |
767 | ||
768 | return fm; | |
769 | } | |
770 | ||
771 | static void jffs_free_fm(struct jffs_fm *n) | |
772 | { | |
773 | kmem_cache_free(fm_cache,n); | |
774 | DJM(no_jffs_fm--); | |
775 | } | |
776 | ||
777 | ||
778 | ||
779 | struct jffs_node *jffs_alloc_node(void) | |
780 | { | |
781 | struct jffs_node *n; | |
782 | ||
783 | n = (struct jffs_node *)kmem_cache_alloc(node_cache,GFP_KERNEL); | |
784 | if(n != NULL) | |
785 | no_jffs_node++; | |
786 | return n; | |
787 | } | |
788 | ||
789 | void jffs_free_node(struct jffs_node *n) | |
790 | { | |
791 | kmem_cache_free(node_cache,n); | |
792 | no_jffs_node--; | |
793 | } | |
794 | ||
795 | ||
796 | int jffs_get_node_inuse(void) | |
797 | { | |
798 | return no_jffs_node; | |
799 | } |