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