blob: 6da13b309bd19b533f05b6a74b456f7e0e20c738 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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"
Adrian Bunk34c90b22005-11-08 16:48:36 +010023#include "intrep.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25#if defined(JFFS_MARK_OBSOLETE) && JFFS_MARK_OBSOLETE
26static int jffs_mark_obsolete(struct jffs_fmcontrol *fmc, __u32 fm_offset);
27#endif
28
29static struct jffs_fm *jffs_alloc_fm(void);
30static void jffs_free_fm(struct jffs_fm *n);
31
32extern kmem_cache_t *fm_cache;
33extern kmem_cache_t *node_cache;
34
Adrian Bunk94c9eca2005-06-25 14:59:06 -070035#if CONFIG_JFFS_FS_VERBOSE > 0
36void
37jffs_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
63static void
64jffs_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
78void
79jffs_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
Linus Torvalds1da177e2005-04-16 15:20:36 -070089/* This function creates a new shiny flash memory control structure. */
90struct jffs_fmcontrol *
91jffs_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. */
149void
150jffs_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. */
171void
172jffs_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
192jffs_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
234jffs_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. */
254int
255jffs_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. */
356int
357jffs_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. */
417struct jffs_fm *
418jffs_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. */
482int
483jffs_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. */
503void
504jffs_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. */
529struct jffs_fm *
530jffs_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. */
565void
566jffs_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. */
598struct jffs_node *
599jffs_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
636static int
637jffs_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 */
663static long
664jffs_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? */
694long
695jffs_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
761static 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
771static 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
779struct 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
789void jffs_free_node(struct jffs_node *n)
790{
791 kmem_cache_free(node_cache,n);
792 no_jffs_node--;
793}
794
795
796int jffs_get_node_inuse(void)
797{
798 return no_jffs_node;
799}