1 /*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright © 2001-2007 Red Hat, Inc.
5 *
6 * Created by David Woodhouse <dwmw2@infradead.org>
7 *
8 * For licensing information, see the file 'LICENCE' in this directory.
9 *
10 */
11
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14 #include <linux/kernel.h>
15 #include <linux/mtd/mtd.h>
16 #include <linux/compiler.h>
17 #include <linux/sched/signal.h>
18 #include "nodelist.h"
19 #include "debug.h"
20
21 /*
22 * Check whether the user is allowed to write.
23 */
24 static int jffs2_rp_can_write(struct jffs2_sb_info *c)
25 {
26 uint32_t avail;
27 struct jffs2_mount_opts *opts = &c->mount_opts;
28
29 avail = c->dirty_size + c->free_size + c->unchecked_size +
30 c->erasing_size - c->resv_blocks_write * c->sector_size
31 - c->nospc_dirty_size;
32
33 if (avail < 2 * opts->rp_size)
34 jffs2_dbg(1, "rpsize %u, dirty_size %u, free_size %u, "
35 "erasing_size %u, unchecked_size %u, "
36 "nr_erasing_blocks %u, avail %u, resrv %u\n",
37 opts->rp_size, c->dirty_size, c->free_size,
38 c->erasing_size, c->unchecked_size,
39 c->nr_erasing_blocks, avail, c->nospc_dirty_size);
40
41 if (avail > opts->rp_size)
42 return 1;
43
44 /* Always allow root */
45 if (capable(CAP_SYS_RESOURCE))
46 return 1;
47
48 jffs2_dbg(1, "forbid writing\n");
49 return 0;
50 }
51
52 static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
53 uint32_t *len, uint32_t sumsize);
54
55 /**
56 * jffs2_reserve_space - request physical space to write nodes to flash
57 * @c: superblock info
58 * @minsize: Minimum acceptable size of allocation
59 * @len: Returned value of allocation length
60 * @prio: Allocation type - ALLOC_{NORMAL,DELETION}
61 * @sumsize: summary size requested or JFFS2_SUMMARY_NOSUM_SIZE for no summary
62 *
63 * Requests a block of physical space on the flash.
64 *
65 * Returns: %0 for success and puts 'len' into the appropriate place,
66 * or returns -ENOSPC or other error if appropriate.
67 * Doesn't return len since that's already returned in @len.
68 *
69 * If it returns %0, jffs2_reserve_space() also downs the per-filesystem
70 * allocation semaphore, to prevent more than one allocation from being
71 * active at any time. The semaphore is later released by jffs2_commit_allocation().
72 *
73 * jffs2_reserve_space() may trigger garbage collection in order to make room
74 * for the requested allocation.
75 */
76
77 int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
78 uint32_t *len, int prio, uint32_t sumsize)
79 {
80 int ret = -EAGAIN;
81 int blocksneeded = c->resv_blocks_write;
82 /* align it */
83 minsize = PAD(minsize);
84
85 jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize);
86 mutex_lock(&c->alloc_sem);
87
88 jffs2_dbg(1, "%s(): alloc sem got\n", __func__);
89
90 spin_lock(&c->erase_completion_lock);
91
92 /*
93 * Check if the free space is greater then size of the reserved pool.
94 * If not, only allow root to proceed with writing.
95 */
96 if (prio != ALLOC_DELETION && !jffs2_rp_can_write(c)) {
97 ret = -ENOSPC;
98 goto out;
99 }
100
101 /* this needs a little more thought (true <tglx> :)) */
102 while(ret == -EAGAIN) {
103 while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) {
104 uint32_t dirty, avail;
105
106 /* calculate real dirty size
107 * dirty_size contains blocks on erase_pending_list
108 * those blocks are counted in c->nr_erasing_blocks.
109 * If one block is actually erased, it is not longer counted as dirty_space
110 * but it is counted in c->nr_erasing_blocks, so we add it and subtract it
111 * with c->nr_erasing_blocks * c->sector_size again.
112 * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks
113 * This helps us to force gc and pick eventually a clean block to spread the load.
114 * We add unchecked_size here, as we hopefully will find some space to use.
115 * This will affect the sum only once, as gc first finishes checking
116 * of nodes.
117 */
118 dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size;
119 if (dirty < c->nospc_dirty_size) {
120 if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) {
121 jffs2_dbg(1, "%s(): Low on dirty space to GC, but it's a deletion. Allowing...\n",
122 __func__);
123 break;
124 }
125 jffs2_dbg(1, "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n",
126 dirty, c->unchecked_size,
127 c->sector_size);
128
129 spin_unlock(&c->erase_completion_lock);
130 mutex_unlock(&c->alloc_sem);
131 return -ENOSPC;
132 }
133
134 /* Calc possibly available space. Possibly available means that we
135 * don't know, if unchecked size contains obsoleted nodes, which could give us some
136 * more usable space. This will affect the sum only once, as gc first finishes checking
137 * of nodes.
138 + Return -ENOSPC, if the maximum possibly available space is less or equal than
139 * blocksneeded * sector_size.
140 * This blocks endless gc looping on a filesystem, which is nearly full, even if
141 * the check above passes.
142 */
143 avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size;
144 if ( (avail / c->sector_size) <= blocksneeded) {
145 if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) {
146 jffs2_dbg(1, "%s(): Low on possibly available space, but it's a deletion. Allowing...\n",
147 __func__);
148 break;
149 }
150
151 jffs2_dbg(1, "max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n",
152 avail, blocksneeded * c->sector_size);
153 spin_unlock(&c->erase_completion_lock);
154 mutex_unlock(&c->alloc_sem);
155 return -ENOSPC;
156 }
157
158 mutex_unlock(&c->alloc_sem);
159
160 jffs2_dbg(1, "Triggering GC pass. nr_free_blocks %d, nr_erasing_blocks %d, free_size 0x%08x, dirty_size 0x%08x, wasted_size 0x%08x, used_size 0x%08x, erasing_size 0x%08x, bad_size 0x%08x (total 0x%08x of 0x%08x)\n",
161 c->nr_free_blocks, c->nr_erasing_blocks,
162 c->free_size, c->dirty_size, c->wasted_size,
163 c->used_size, c->erasing_size, c->bad_size,
164 c->free_size + c->dirty_size +
165 c->wasted_size + c->used_size +
166 c->erasing_size + c->bad_size,
167 c->flash_size);
168 spin_unlock(&c->erase_completion_lock);
169
170 ret = jffs2_garbage_collect_pass(c);
171
172 if (ret == -EAGAIN) {
173 spin_lock(&c->erase_completion_lock);
174 if (c->nr_erasing_blocks &&
175 list_empty(&c->erase_pending_list) &&
176 list_empty(&c->erase_complete_list)) {
177 DECLARE_WAITQUEUE(wait, current);
178 set_current_state(TASK_UNINTERRUPTIBLE);
179 add_wait_queue(&c->erase_wait, &wait);
180 jffs2_dbg(1, "%s waiting for erase to complete\n",
181 __func__);
182 spin_unlock(&c->erase_completion_lock);
183
184 schedule();
185 remove_wait_queue(&c->erase_wait, &wait);
186 } else
187 spin_unlock(&c->erase_completion_lock);
188 } else if (ret)
189 return ret;
190
191 cond_resched();
192
193 if (signal_pending(current))
194 return -EINTR;
195
196 mutex_lock(&c->alloc_sem);
197 spin_lock(&c->erase_completion_lock);
198 }
199
200 ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
201 if (ret) {
202 jffs2_dbg(1, "%s(): ret is %d\n", __func__, ret);
203 }
204 }
205
206 out:
207 spin_unlock(&c->erase_completion_lock);
208 if (!ret)
209 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
210 if (ret)
211 mutex_unlock(&c->alloc_sem);
212 return ret;
213 }
214
215 int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize,
216 uint32_t *len, uint32_t sumsize)
217 {
218 int ret;
219 minsize = PAD(minsize);
220
221 jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize);
222
223 while (true) {
224 spin_lock(&c->erase_completion_lock);
225 ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
226 if (ret) {
227 jffs2_dbg(1, "%s(): looping, ret is %d\n",
228 __func__, ret);
229 }
230 spin_unlock(&c->erase_completion_lock);
231
232 if (ret == -EAGAIN)
233 cond_resched();
234 else
235 break;
236 }
237 if (!ret)
238 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
239
240 return ret;
241 }
242
243
244 /* Classify nextblock (clean, dirty of verydirty) and force to select an other one */
245
246 static void jffs2_close_nextblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
247 {
248
249 if (c->nextblock == NULL) {
250 jffs2_dbg(1, "%s(): Erase block at 0x%08x has already been placed in a list\n",
251 __func__, jeb->offset);
252 return;
253 }
254 /* Check, if we have a dirty block now, or if it was dirty already */
255 if (ISDIRTY (jeb->wasted_size + jeb->dirty_size)) {
256 c->dirty_size += jeb->wasted_size;
257 c->wasted_size -= jeb->wasted_size;
258 jeb->dirty_size += jeb->wasted_size;
259 jeb->wasted_size = 0;
260 if (VERYDIRTY(c, jeb->dirty_size)) {
261 jffs2_dbg(1, "Adding full erase block at 0x%08x to very_dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
262 jeb->offset, jeb->free_size, jeb->dirty_size,
263 jeb->used_size);
264 list_add_tail(&jeb->list, &c->very_dirty_list);
265 } else {
266 jffs2_dbg(1, "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
267 jeb->offset, jeb->free_size, jeb->dirty_size,
268 jeb->used_size);
269 list_add_tail(&jeb->list, &c->dirty_list);
270 }
271 } else {
272 jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
273 jeb->offset, jeb->free_size, jeb->dirty_size,
274 jeb->used_size);
275 list_add_tail(&jeb->list, &c->clean_list);
276 }
277 c->nextblock = NULL;
278
279 }
280
281 /* Select a new jeb for nextblock */
282
283 static int jffs2_find_nextblock(struct jffs2_sb_info *c)
284 {
285 struct list_head *next;
286
287 /* Take the next block off the 'free' list */
288
289 if (list_empty(&c->free_list)) {
290
291 if (!c->nr_erasing_blocks &&
292 !list_empty(&c->erasable_list)) {
293 struct jffs2_eraseblock *ejeb;
294
295 ejeb = list_entry(c->erasable_list.next, struct jffs2_eraseblock, list);
296 list_move_tail(&ejeb->list, &c->erase_pending_list);
297 c->nr_erasing_blocks++;
298 jffs2_garbage_collect_trigger(c);
299 jffs2_dbg(1, "%s(): Triggering erase of erasable block at 0x%08x\n",
300 __func__, ejeb->offset);
301 }
302
303 if (!c->nr_erasing_blocks &&
304 !list_empty(&c->erasable_pending_wbuf_list)) {
305 jffs2_dbg(1, "%s(): Flushing write buffer\n",
306 __func__);
307 /* c->nextblock is NULL, no update to c->nextblock allowed */
308 spin_unlock(&c->erase_completion_lock);
309 jffs2_flush_wbuf_pad(c);
310 spin_lock(&c->erase_completion_lock);
311 /* Have another go. It'll be on the erasable_list now */
312 return -EAGAIN;
313 }
314
315 if (!c->nr_erasing_blocks) {
316 /* Ouch. We're in GC, or we wouldn't have got here.
317 And there's no space left. At all. */
318 pr_crit("Argh. No free space left for GC. nr_erasing_blocks is %d. nr_free_blocks is %d. (erasableempty: %s, erasingempty: %s, erasependingempty: %s)\n",
319 c->nr_erasing_blocks, c->nr_free_blocks,
320 list_empty(&c->erasable_list) ? "yes" : "no",
321 list_empty(&c->erasing_list) ? "yes" : "no",
322 list_empty(&c->erase_pending_list) ? "yes" : "no");
323 return -ENOSPC;
324 }
325
326 spin_unlock(&c->erase_completion_lock);
327 /* Don't wait for it; just erase one right now */
328 jffs2_erase_pending_blocks(c, 1);
329 spin_lock(&c->erase_completion_lock);
330
331 /* An erase may have failed, decreasing the
332 amount of free space available. So we must
333 restart from the beginning */
334 return -EAGAIN;
335 }
336
337 next = c->free_list.next;
338 list_del(next);
339 c->nextblock = list_entry(next, struct jffs2_eraseblock, list);
340 c->nr_free_blocks--;
341
342 jffs2_sum_reset_collected(c->summary); /* reset collected summary */
343
344 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
345 /* adjust write buffer offset, else we get a non contiguous write bug */
346 if (!(c->wbuf_ofs % c->sector_size) && !c->wbuf_len)
347 c->wbuf_ofs = 0xffffffff;
348 #endif
349
350 jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n",
351 __func__, c->nextblock->offset);
352
353 return 0;
354 }
355
356 /* Called with alloc sem _and_ erase_completion_lock */
357 static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
358 uint32_t *len, uint32_t sumsize)
359 {
360 struct jffs2_eraseblock *jeb = c->nextblock;
361 uint32_t reserved_size; /* for summary information at the end of the jeb */
362 int ret;
363
364 restart:
365 reserved_size = 0;
366
367 if (jffs2_sum_active() && (sumsize != JFFS2_SUMMARY_NOSUM_SIZE)) {
368 /* NOSUM_SIZE means not to generate summary */
369
370 if (jeb) {
371 reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE);
372 dbg_summary("minsize=%d , jeb->free=%d ,"
373 "summary->size=%d , sumsize=%d\n",
374 minsize, jeb->free_size,
375 c->summary->sum_size, sumsize);
376 }
377
378 /* Is there enough space for writing out the current node, or we have to
379 write out summary information now, close this jeb and select new nextblock? */
380 if (jeb && (PAD(minsize) + PAD(c->summary->sum_size + sumsize +
381 JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size)) {
382
383 /* Has summary been disabled for this jeb? */
384 if (jffs2_sum_is_disabled(c->summary)) {
385 sumsize = JFFS2_SUMMARY_NOSUM_SIZE;
386 goto restart;
387 }
388
389 /* Writing out the collected summary information */
390 dbg_summary("generating summary for 0x%08x.\n", jeb->offset);
391 ret = jffs2_sum_write_sumnode(c);
392
393 if (ret)
394 return ret;
395
396 if (jffs2_sum_is_disabled(c->summary)) {
397 /* jffs2_write_sumnode() couldn't write out the summary information
398 diabling summary for this jeb and free the collected information
399 */
400 sumsize = JFFS2_SUMMARY_NOSUM_SIZE;
401 goto restart;
402 }
403
404 jffs2_close_nextblock(c, jeb);
405 jeb = NULL;
406 /* keep always valid value in reserved_size */
407 reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE);
408 }
409 } else {
410 if (jeb && minsize > jeb->free_size) {
411 uint32_t waste;
412
413 /* Skip the end of this block and file it as having some dirty space */
414 /* If there's a pending write to it, flush now */
415
416 if (jffs2_wbuf_dirty(c)) {
417 spin_unlock(&c->erase_completion_lock);
418 jffs2_dbg(1, "%s(): Flushing write buffer\n",
419 __func__);
420 jffs2_flush_wbuf_pad(c);
421 spin_lock(&c->erase_completion_lock);
422 jeb = c->nextblock;
423 goto restart;
424 }
425
426 spin_unlock(&c->erase_completion_lock);
427
428 ret = jffs2_prealloc_raw_node_refs(c, jeb, 1);
429
430 /* Just lock it again and continue. Nothing much can change because
431 we hold c->alloc_sem anyway. In fact, it's not entirely clear why
432 we hold c->erase_completion_lock in the majority of this function...
433 but that's a question for another (more caffeine-rich) day. */
434 spin_lock(&c->erase_completion_lock);
435
436 if (ret)
437 return ret;
438
439 waste = jeb->free_size;
440 jffs2_link_node_ref(c, jeb,
441 (jeb->offset + c->sector_size - waste) | REF_OBSOLETE,
442 waste, NULL);
443 /* FIXME: that made it count as dirty. Convert to wasted */
444 jeb->dirty_size -= waste;
445 c->dirty_size -= waste;
446 jeb->wasted_size += waste;
447 c->wasted_size += waste;
448
449 jffs2_close_nextblock(c, jeb);
450 jeb = NULL;
451 }
452 }
453
454 if (!jeb) {
455
456 ret = jffs2_find_nextblock(c);
457 if (ret)
458 return ret;
459
460 jeb = c->nextblock;
461
462 if (jeb->free_size != c->sector_size - c->cleanmarker_size) {
463 pr_warn("Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n",
464 jeb->offset, jeb->free_size);
465 goto restart;
466 }
467 }
468 /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has
469 enough space */
470 *len = jeb->free_size - reserved_size;
471
472 if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size &&
473 !jeb->first_node->next_in_ino) {
474 /* Only node in it beforehand was a CLEANMARKER node (we think).
475 So mark it obsolete now that there's going to be another node
476 in the block. This will reduce used_size to zero but We've
477 already set c->nextblock so that jffs2_mark_node_obsolete()
478 won't try to refile it to the dirty_list.
479 */
480 spin_unlock(&c->erase_completion_lock);
481 jffs2_mark_node_obsolete(c, jeb->first_node);
482 spin_lock(&c->erase_completion_lock);
483 }
484
485 jffs2_dbg(1, "%s(): Giving 0x%x bytes at 0x%x\n",
486 __func__,
487 *len, jeb->offset + (c->sector_size - jeb->free_size));
488 return 0;
489 }
490
491 /**
492 * jffs2_add_physical_node_ref - add a physical node reference to the list
493 * @c: superblock info
494 * @ofs: offset in the block
495 * @len: length of this physical node
496 * @ic: inode cache pointer
497 *
498 * Should only be used to report nodes for which space has been allocated
499 * by jffs2_reserve_space.
500 *
501 * Must be called with the alloc_sem held.
502 *
503 * Returns: pointer to new node on success or -errno code on error
504 */
505
506 struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c,
507 uint32_t ofs, uint32_t len,
508 struct jffs2_inode_cache *ic)
509 {
510 struct jffs2_eraseblock *jeb;
511 struct jffs2_raw_node_ref *new;
512
513 jeb = &c->blocks[ofs / c->sector_size];
514
515 jffs2_dbg(1, "%s(): Node at 0x%x(%d), size 0x%x\n",
516 __func__, ofs & ~3, ofs & 3, len);
517 #if 1
518 /* Allow non-obsolete nodes only to be added at the end of c->nextblock,
519 if c->nextblock is set. Note that wbuf.c will file obsolete nodes
520 even after refiling c->nextblock */
521 if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE))
522 && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) {
523 pr_warn("argh. node added in wrong place at 0x%08x(%d)\n",
524 ofs & ~3, ofs & 3);
525 if (c->nextblock)
526 pr_warn("nextblock 0x%08x", c->nextblock->offset);
527 else
528 pr_warn("No nextblock");
529 pr_cont(", expected at %08x\n",
530 jeb->offset + (c->sector_size - jeb->free_size));
531 return ERR_PTR(-EINVAL);
532 }
533 #endif
534 spin_lock(&c->erase_completion_lock);
535
536 new = jffs2_link_node_ref(c, jeb, ofs, len, ic);
537
538 if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) {
539 /* If it lives on the dirty_list, jffs2_reserve_space will put it there */
540 jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
541 jeb->offset, jeb->free_size, jeb->dirty_size,
542 jeb->used_size);
543 if (jffs2_wbuf_dirty(c)) {
544 /* Flush the last write in the block if it's outstanding */
545 spin_unlock(&c->erase_completion_lock);
546 jffs2_flush_wbuf_pad(c);
547 spin_lock(&c->erase_completion_lock);
548 }
549
550 list_add_tail(&jeb->list, &c->clean_list);
551 c->nextblock = NULL;
552 }
553 jffs2_dbg_acct_sanity_check_nolock(c,jeb);
554 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
555
556 spin_unlock(&c->erase_completion_lock);
557
558 return new;
559 }
560
561
562 void jffs2_complete_reservation(struct jffs2_sb_info *c)
563 {
564 jffs2_dbg(1, "jffs2_complete_reservation()\n");
565 spin_lock(&c->erase_completion_lock);
566 jffs2_garbage_collect_trigger(c);
567 spin_unlock(&c->erase_completion_lock);
568 mutex_unlock(&c->alloc_sem);
569 }
570
571 static inline int on_list(struct list_head *obj, struct list_head *head)
572 {
573 struct list_head *this;
574
575 list_for_each(this, head) {
576 if (this == obj) {
577 jffs2_dbg(1, "%p is on list at %p\n", obj, head);
578 return 1;
579
580 }
581 }
582 return 0;
583 }
584
585 void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref)
586 {
587 struct jffs2_eraseblock *jeb;
588 int blocknr;
589 struct jffs2_unknown_node n;
590 int ret, addedsize;
591 size_t retlen;
592 uint32_t freed_len;
593
594 if(unlikely(!ref)) {
595 pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
596 return;
597 }
598 if (ref_obsolete(ref)) {
599 jffs2_dbg(1, "%s(): called with already obsolete node at 0x%08x\n",
600 __func__, ref_offset(ref));
601 return;
602 }
603 blocknr = ref->flash_offset / c->sector_size;
604 if (blocknr >= c->nr_blocks) {
605 pr_notice("raw node at 0x%08x is off the end of device!\n",
606 ref->flash_offset);
607 BUG();
608 }
609 jeb = &c->blocks[blocknr];
610
611 if (jffs2_can_mark_obsolete(c) && !jffs2_is_readonly(c) &&
612 !(c->flags & (JFFS2_SB_FLAG_SCANNING | JFFS2_SB_FLAG_BUILDING))) {
613 /* Hm. This may confuse static lock analysis. If any of the above
614 three conditions is false, we're going to return from this
615 function without actually obliterating any nodes or freeing
616 any jffs2_raw_node_refs. So we don't need to stop erases from
617 happening, or protect against people holding an obsolete
618 jffs2_raw_node_ref without the erase_completion_lock. */
619 mutex_lock(&c->erase_free_sem);
620 }
621
622 spin_lock(&c->erase_completion_lock);
623
624 freed_len = ref_totlen(c, jeb, ref);
625
626 if (ref_flags(ref) == REF_UNCHECKED) {
627 D1(if (unlikely(jeb->unchecked_size < freed_len)) {
628 pr_notice("raw unchecked node of size 0x%08x freed from erase block %d at 0x%08x, but unchecked_size was already 0x%08x\n",
629 freed_len, blocknr,
630 ref->flash_offset, jeb->used_size);
631 BUG();
632 })
633 jffs2_dbg(1, "Obsoleting previously unchecked node at 0x%08x of len %x\n",
634 ref_offset(ref), freed_len);
635 jeb->unchecked_size -= freed_len;
636 c->unchecked_size -= freed_len;
637 } else {
638 D1(if (unlikely(jeb->used_size < freed_len)) {
639 pr_notice("raw node of size 0x%08x freed from erase block %d at 0x%08x, but used_size was already 0x%08x\n",
640 freed_len, blocknr,
641 ref->flash_offset, jeb->used_size);
642 BUG();
643 })
644 jffs2_dbg(1, "Obsoleting node at 0x%08x of len %#x: ",
645 ref_offset(ref), freed_len);
646 jeb->used_size -= freed_len;
647 c->used_size -= freed_len;
648 }
649
650 // Take care, that wasted size is taken into concern
651 if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
652 jffs2_dbg(1, "Dirtying\n");
653 addedsize = freed_len;
654 jeb->dirty_size += freed_len;
655 c->dirty_size += freed_len;
656
657 /* Convert wasted space to dirty, if not a bad block */
658 if (jeb->wasted_size) {
659 if (on_list(&jeb->list, &c->bad_used_list)) {
660 jffs2_dbg(1, "Leaving block at %08x on the bad_used_list\n",
661 jeb->offset);
662 addedsize = 0; /* To fool the refiling code later */
663 } else {
664 jffs2_dbg(1, "Converting %d bytes of wasted space to dirty in block at %08x\n",
665 jeb->wasted_size, jeb->offset);
666 addedsize += jeb->wasted_size;
667 jeb->dirty_size += jeb->wasted_size;
668 c->dirty_size += jeb->wasted_size;
669 c->wasted_size -= jeb->wasted_size;
670 jeb->wasted_size = 0;
671 }
672 }
673 } else {
674 jffs2_dbg(1, "Wasting\n");
675 addedsize = 0;
676 jeb->wasted_size += freed_len;
677 c->wasted_size += freed_len;
678 }
679 ref->flash_offset = ref_offset(ref) | REF_OBSOLETE;
680
681 jffs2_dbg_acct_sanity_check_nolock(c, jeb);
682 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
683
684 if (c->flags & JFFS2_SB_FLAG_SCANNING) {
685 /* Flash scanning is in progress. Don't muck about with the block
686 lists because they're not ready yet, and don't actually
687 obliterate nodes that look obsolete. If they weren't
688 marked obsolete on the flash at the time they _became_
689 obsolete, there was probably a reason for that. */
690 spin_unlock(&c->erase_completion_lock);
691 /* We didn't lock the erase_free_sem */
692 return;
693 }
694
695 if (jeb == c->nextblock) {
696 jffs2_dbg(2, "Not moving nextblock 0x%08x to dirty/erase_pending list\n",
697 jeb->offset);
698 } else if (!jeb->used_size && !jeb->unchecked_size) {
699 if (jeb == c->gcblock) {
700 jffs2_dbg(1, "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n",
701 jeb->offset);
702 c->gcblock = NULL;
703 } else {
704 jffs2_dbg(1, "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n",
705 jeb->offset);
706 list_del(&jeb->list);
707 }
708 if (jffs2_wbuf_dirty(c)) {
709 jffs2_dbg(1, "...and adding to erasable_pending_wbuf_list\n");
710 list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list);
711 } else {
712 if (jiffies & 127) {
713 /* Most of the time, we just erase it immediately. Otherwise we
714 spend ages scanning it on mount, etc. */
715 jffs2_dbg(1, "...and adding to erase_pending_list\n");
716 list_add_tail(&jeb->list, &c->erase_pending_list);
717 c->nr_erasing_blocks++;
718 jffs2_garbage_collect_trigger(c);
719 } else {
720 /* Sometimes, however, we leave it elsewhere so it doesn't get
721 immediately reused, and we spread the load a bit. */
722 jffs2_dbg(1, "...and adding to erasable_list\n");
723 list_add_tail(&jeb->list, &c->erasable_list);
724 }
725 }
726 jffs2_dbg(1, "Done OK\n");
727 } else if (jeb == c->gcblock) {
728 jffs2_dbg(2, "Not moving gcblock 0x%08x to dirty_list\n",
729 jeb->offset);
730 } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) {
731 jffs2_dbg(1, "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n",
732 jeb->offset);
733 list_del(&jeb->list);
734 jffs2_dbg(1, "...and adding to dirty_list\n");
735 list_add_tail(&jeb->list, &c->dirty_list);
736 } else if (VERYDIRTY(c, jeb->dirty_size) &&
737 !VERYDIRTY(c, jeb->dirty_size - addedsize)) {
738 jffs2_dbg(1, "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n",
739 jeb->offset);
740 list_del(&jeb->list);
741 jffs2_dbg(1, "...and adding to very_dirty_list\n");
742 list_add_tail(&jeb->list, &c->very_dirty_list);
743 } else {
744 jffs2_dbg(1, "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n",
745 jeb->offset, jeb->free_size, jeb->dirty_size,
746 jeb->used_size);
747 }
748
749 spin_unlock(&c->erase_completion_lock);
750
751 if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) ||
752 (c->flags & JFFS2_SB_FLAG_BUILDING)) {
753 /* We didn't lock the erase_free_sem */
754 return;
755 }
756
757 /* The erase_free_sem is locked, and has been since before we marked the node obsolete
758 and potentially put its eraseblock onto the erase_pending_list. Thus, we know that
759 the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet
760 by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */
761
762 jffs2_dbg(1, "obliterating obsoleted node at 0x%08x\n",
763 ref_offset(ref));
764 ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
765 if (ret) {
766 pr_warn("Read error reading from obsoleted node at 0x%08x: %d\n",
767 ref_offset(ref), ret);
768 goto out_erase_sem;
769 }
770 if (retlen != sizeof(n)) {
771 pr_warn("Short read from obsoleted node at 0x%08x: %zd\n",
772 ref_offset(ref), retlen);
773 goto out_erase_sem;
774 }
775 if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) {
776 pr_warn("Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n",
777 je32_to_cpu(n.totlen), freed_len);
778 goto out_erase_sem;
779 }
780 if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) {
781 jffs2_dbg(1, "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n",
782 ref_offset(ref), je16_to_cpu(n.nodetype));
783 goto out_erase_sem;
784 }
785 /* XXX FIXME: This is ugly now */
786 n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE);
787 ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
788 if (ret) {
789 pr_warn("Write error in obliterating obsoleted node at 0x%08x: %d\n",
790 ref_offset(ref), ret);
791 goto out_erase_sem;
792 }
793 if (retlen != sizeof(n)) {
794 pr_warn("Short write in obliterating obsoleted node at 0x%08x: %zd\n",
795 ref_offset(ref), retlen);
796 goto out_erase_sem;
797 }
798
799 /* Nodes which have been marked obsolete no longer need to be
800 associated with any inode. Remove them from the per-inode list.
801
802 Note we can't do this for NAND at the moment because we need
803 obsolete dirent nodes to stay on the lists, because of the
804 horridness in jffs2_garbage_collect_deletion_dirent(). Also
805 because we delete the inocache, and on NAND we need that to
806 stay around until all the nodes are actually erased, in order
807 to stop us from giving the same inode number to another newly
808 created inode. */
809 if (ref->next_in_ino) {
810 struct jffs2_inode_cache *ic;
811 struct jffs2_raw_node_ref **p;
812
813 spin_lock(&c->erase_completion_lock);
814
815 ic = jffs2_raw_ref_to_ic(ref);
816 for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino))
817 ;
818
819 *p = ref->next_in_ino;
820 ref->next_in_ino = NULL;
821
822 switch (ic->class) {
823 #ifdef CONFIG_JFFS2_FS_XATTR
824 case RAWNODE_CLASS_XATTR_DATUM:
825 jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic);
826 break;
827 case RAWNODE_CLASS_XATTR_REF:
828 jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic);
829 break;
830 #endif
831 default:
832 if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
833 jffs2_del_ino_cache(c, ic);
834 break;
835 }
836 spin_unlock(&c->erase_completion_lock);
837 }
838
839 out_erase_sem:
840 mutex_unlock(&c->erase_free_sem);
841 }
842
843 int jffs2_thread_should_wake(struct jffs2_sb_info *c)
844 {
845 int ret = 0;
846 uint32_t dirty;
847 int nr_very_dirty = 0;
848 struct jffs2_eraseblock *jeb;
849
850 if (!list_empty(&c->erase_complete_list) ||
851 !list_empty(&c->erase_pending_list))
852 return 1;
853
854 if (c->unchecked_size) {
855 jffs2_dbg(1, "jffs2_thread_should_wake(): unchecked_size %d, check_ino #%d\n",
856 c->unchecked_size, c->check_ino);
857 return 1;
858 }
859
860 /* dirty_size contains blocks on erase_pending_list
861 * those blocks are counted in c->nr_erasing_blocks.
862 * If one block is actually erased, it is not longer counted as dirty_space
863 * but it is counted in c->nr_erasing_blocks, so we add it and subtract it
864 * with c->nr_erasing_blocks * c->sector_size again.
865 * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks
866 * This helps us to force gc and pick eventually a clean block to spread the load.
867 */
868 dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
869
870 if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
871 (dirty > c->nospc_dirty_size))
872 ret = 1;
873
874 list_for_each_entry(jeb, &c->very_dirty_list, list) {
875 nr_very_dirty++;
876 if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
877 ret = 1;
878 /* In debug mode, actually go through and count them all */
879 D1(continue);
880 break;
881 }
882 }
883
884 jffs2_dbg(1, "%s(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x, vdirty_blocks %d: %s\n",
885 __func__, c->nr_free_blocks, c->nr_erasing_blocks,
886 c->dirty_size, nr_very_dirty, ret ? "yes" : "no");
887
888 return ret;
889 }
890
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.