1 /* 2 * JFFS2 -- Journalling Flash File System, Version 2. 3 * 4 * Copyright © 2001-2007 Red Hat, Inc. 5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org> 6 * 7 * Created by David Woodhouse <dwmw2@infradead.org> 8 * 9 * For licensing information, see the file 'LICENCE' in this directory. 10 * 11 */ 12 13 #include <linux/capability.h> 14 #include <linux/kernel.h> 15 #include <linux/sched.h> 16 #include <linux/fs.h> 17 #include <linux/list.h> 18 #include <linux/mtd/mtd.h> 19 #include <linux/pagemap.h> 20 #include <linux/slab.h> 21 #include <linux/vmalloc.h> 22 #include <linux/vfs.h> 23 #include <linux/crc32.h> 24 #include <linux/smp_lock.h> 25 #include "nodelist.h" 26 27 static int jffs2_flash_setup(struct jffs2_sb_info *c); 28 29 int jffs2_do_setattr (struct inode *inode, struct iattr *iattr) 30 { 31 struct jffs2_full_dnode *old_metadata, *new_metadata; 32 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 33 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); 34 struct jffs2_raw_inode *ri; 35 union jffs2_device_node dev; 36 unsigned char *mdata = NULL; 37 int mdatalen = 0; 38 unsigned int ivalid; 39 uint32_t alloclen; 40 int ret; 41 int alloc_type = ALLOC_NORMAL; 42 43 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino)); 44 45 /* Special cases - we don't want more than one data node 46 for these types on the medium at any time. So setattr 47 must read the original data associated with the node 48 (i.e. the device numbers or the target name) and write 49 it out again with the appropriate data attached */ 50 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) { 51 /* For these, we don't actually need to read the old node */ 52 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev); 53 mdata = (char *)&dev; 54 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen)); 55 } else if (S_ISLNK(inode->i_mode)) { 56 mutex_lock(&f->sem); 57 mdatalen = f->metadata->size; 58 mdata = kmalloc(f->metadata->size, GFP_USER); 59 if (!mdata) { 60 mutex_unlock(&f->sem); 61 return -ENOMEM; 62 } 63 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen); 64 if (ret) { 65 mutex_unlock(&f->sem); 66 kfree(mdata); 67 return ret; 68 } 69 mutex_unlock(&f->sem); 70 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen)); 71 } 72 73 ri = jffs2_alloc_raw_inode(); 74 if (!ri) { 75 if (S_ISLNK(inode->i_mode)) 76 kfree(mdata); 77 return -ENOMEM; 78 } 79 80 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen, 81 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 82 if (ret) { 83 jffs2_free_raw_inode(ri); 84 if (S_ISLNK(inode->i_mode & S_IFMT)) 85 kfree(mdata); 86 return ret; 87 } 88 mutex_lock(&f->sem); 89 ivalid = iattr->ia_valid; 90 91 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 92 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 93 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen); 94 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 95 96 ri->ino = cpu_to_je32(inode->i_ino); 97 ri->version = cpu_to_je32(++f->highest_version); 98 99 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid); 100 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid); 101 102 if (ivalid & ATTR_MODE) 103 ri->mode = cpu_to_jemode(iattr->ia_mode); 104 else 105 ri->mode = cpu_to_jemode(inode->i_mode); 106 107 108 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size); 109 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime)); 110 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime)); 111 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime)); 112 113 ri->offset = cpu_to_je32(0); 114 ri->csize = ri->dsize = cpu_to_je32(mdatalen); 115 ri->compr = JFFS2_COMPR_NONE; 116 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) { 117 /* It's an extension. Make it a hole node */ 118 ri->compr = JFFS2_COMPR_ZERO; 119 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size); 120 ri->offset = cpu_to_je32(inode->i_size); 121 } else if (ivalid & ATTR_SIZE && !iattr->ia_size) { 122 /* For truncate-to-zero, treat it as deletion because 123 it'll always be obsoleting all previous nodes */ 124 alloc_type = ALLOC_DELETION; 125 } 126 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 127 if (mdatalen) 128 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen)); 129 else 130 ri->data_crc = cpu_to_je32(0); 131 132 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type); 133 if (S_ISLNK(inode->i_mode)) 134 kfree(mdata); 135 136 if (IS_ERR(new_metadata)) { 137 jffs2_complete_reservation(c); 138 jffs2_free_raw_inode(ri); 139 mutex_unlock(&f->sem); 140 return PTR_ERR(new_metadata); 141 } 142 /* It worked. Update the inode */ 143 inode->i_atime = ITIME(je32_to_cpu(ri->atime)); 144 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime)); 145 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime)); 146 inode->i_mode = jemode_to_cpu(ri->mode); 147 inode->i_uid = je16_to_cpu(ri->uid); 148 inode->i_gid = je16_to_cpu(ri->gid); 149 150 151 old_metadata = f->metadata; 152 153 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) 154 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size); 155 156 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) { 157 jffs2_add_full_dnode_to_inode(c, f, new_metadata); 158 inode->i_size = iattr->ia_size; 159 inode->i_blocks = (inode->i_size + 511) >> 9; 160 f->metadata = NULL; 161 } else { 162 f->metadata = new_metadata; 163 } 164 if (old_metadata) { 165 jffs2_mark_node_obsolete(c, old_metadata->raw); 166 jffs2_free_full_dnode(old_metadata); 167 } 168 jffs2_free_raw_inode(ri); 169 170 mutex_unlock(&f->sem); 171 jffs2_complete_reservation(c); 172 173 /* We have to do the truncate_setsize() without f->sem held, since 174 some pages may be locked and waiting for it in readpage(). 175 We are protected from a simultaneous write() extending i_size 176 back past iattr->ia_size, because do_truncate() holds the 177 generic inode semaphore. */ 178 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) { 179 truncate_setsize(inode, iattr->ia_size); 180 inode->i_blocks = (inode->i_size + 511) >> 9; 181 } 182 183 return 0; 184 } 185 186 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr) 187 { 188 int rc; 189 190 rc = inode_change_ok(dentry->d_inode, iattr); 191 if (rc) 192 return rc; 193 194 rc = jffs2_do_setattr(dentry->d_inode, iattr); 195 if (!rc && (iattr->ia_valid & ATTR_MODE)) 196 rc = jffs2_acl_chmod(dentry->d_inode); 197 198 return rc; 199 } 200 201 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf) 202 { 203 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb); 204 unsigned long avail; 205 206 buf->f_type = JFFS2_SUPER_MAGIC; 207 buf->f_bsize = 1 << PAGE_SHIFT; 208 buf->f_blocks = c->flash_size >> PAGE_SHIFT; 209 buf->f_files = 0; 210 buf->f_ffree = 0; 211 buf->f_namelen = JFFS2_MAX_NAME_LEN; 212 buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC; 213 buf->f_fsid.val[1] = c->mtd->index; 214 215 spin_lock(&c->erase_completion_lock); 216 avail = c->dirty_size + c->free_size; 217 if (avail > c->sector_size * c->resv_blocks_write) 218 avail -= c->sector_size * c->resv_blocks_write; 219 else 220 avail = 0; 221 spin_unlock(&c->erase_completion_lock); 222 223 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT; 224 225 return 0; 226 } 227 228 229 void jffs2_evict_inode (struct inode *inode) 230 { 231 /* We can forget about this inode for now - drop all 232 * the nodelists associated with it, etc. 233 */ 234 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); 235 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 236 237 D1(printk(KERN_DEBUG "jffs2_evict_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode)); 238 truncate_inode_pages(&inode->i_data, 0); 239 end_writeback(inode); 240 jffs2_do_clear_inode(c, f); 241 } 242 243 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino) 244 { 245 struct jffs2_inode_info *f; 246 struct jffs2_sb_info *c; 247 struct jffs2_raw_inode latest_node; 248 union jffs2_device_node jdev; 249 struct inode *inode; 250 dev_t rdev = 0; 251 int ret; 252 253 D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino)); 254 255 inode = iget_locked(sb, ino); 256 if (!inode) 257 return ERR_PTR(-ENOMEM); 258 if (!(inode->i_state & I_NEW)) 259 return inode; 260 261 f = JFFS2_INODE_INFO(inode); 262 c = JFFS2_SB_INFO(inode->i_sb); 263 264 jffs2_init_inode_info(f); 265 mutex_lock(&f->sem); 266 267 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node); 268 269 if (ret) { 270 mutex_unlock(&f->sem); 271 iget_failed(inode); 272 return ERR_PTR(ret); 273 } 274 inode->i_mode = jemode_to_cpu(latest_node.mode); 275 inode->i_uid = je16_to_cpu(latest_node.uid); 276 inode->i_gid = je16_to_cpu(latest_node.gid); 277 inode->i_size = je32_to_cpu(latest_node.isize); 278 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime)); 279 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime)); 280 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime)); 281 282 inode->i_nlink = f->inocache->pino_nlink; 283 284 inode->i_blocks = (inode->i_size + 511) >> 9; 285 286 switch (inode->i_mode & S_IFMT) { 287 288 case S_IFLNK: 289 inode->i_op = &jffs2_symlink_inode_operations; 290 break; 291 292 case S_IFDIR: 293 { 294 struct jffs2_full_dirent *fd; 295 inode->i_nlink = 2; /* parent and '.' */ 296 297 for (fd=f->dents; fd; fd = fd->next) { 298 if (fd->type == DT_DIR && fd->ino) 299 inc_nlink(inode); 300 } 301 /* Root dir gets i_nlink 3 for some reason */ 302 if (inode->i_ino == 1) 303 inc_nlink(inode); 304 305 inode->i_op = &jffs2_dir_inode_operations; 306 inode->i_fop = &jffs2_dir_operations; 307 break; 308 } 309 case S_IFREG: 310 inode->i_op = &jffs2_file_inode_operations; 311 inode->i_fop = &jffs2_file_operations; 312 inode->i_mapping->a_ops = &jffs2_file_address_operations; 313 inode->i_mapping->nrpages = 0; 314 break; 315 316 case S_IFBLK: 317 case S_IFCHR: 318 /* Read the device numbers from the media */ 319 if (f->metadata->size != sizeof(jdev.old_id) && 320 f->metadata->size != sizeof(jdev.new_id)) { 321 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size); 322 goto error_io; 323 } 324 D1(printk(KERN_DEBUG "Reading device numbers from flash\n")); 325 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size); 326 if (ret < 0) { 327 /* Eep */ 328 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino); 329 goto error; 330 } 331 if (f->metadata->size == sizeof(jdev.old_id)) 332 rdev = old_decode_dev(je16_to_cpu(jdev.old_id)); 333 else 334 rdev = new_decode_dev(je32_to_cpu(jdev.new_id)); 335 336 case S_IFSOCK: 337 case S_IFIFO: 338 inode->i_op = &jffs2_file_inode_operations; 339 init_special_inode(inode, inode->i_mode, rdev); 340 break; 341 342 default: 343 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino); 344 } 345 346 mutex_unlock(&f->sem); 347 348 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n")); 349 unlock_new_inode(inode); 350 return inode; 351 352 error_io: 353 ret = -EIO; 354 error: 355 mutex_unlock(&f->sem); 356 jffs2_do_clear_inode(c, f); 357 iget_failed(inode); 358 return ERR_PTR(ret); 359 } 360 361 void jffs2_dirty_inode(struct inode *inode) 362 { 363 struct iattr iattr; 364 365 if (!(inode->i_state & I_DIRTY_DATASYNC)) { 366 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino)); 367 return; 368 } 369 370 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino)); 371 372 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME; 373 iattr.ia_mode = inode->i_mode; 374 iattr.ia_uid = inode->i_uid; 375 iattr.ia_gid = inode->i_gid; 376 iattr.ia_atime = inode->i_atime; 377 iattr.ia_mtime = inode->i_mtime; 378 iattr.ia_ctime = inode->i_ctime; 379 380 jffs2_do_setattr(inode, &iattr); 381 } 382 383 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data) 384 { 385 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 386 387 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY)) 388 return -EROFS; 389 390 /* We stop if it was running, then restart if it needs to. 391 This also catches the case where it was stopped and this 392 is just a remount to restart it. 393 Flush the writebuffer, if neccecary, else we loose it */ 394 lock_kernel(); 395 if (!(sb->s_flags & MS_RDONLY)) { 396 jffs2_stop_garbage_collect_thread(c); 397 mutex_lock(&c->alloc_sem); 398 jffs2_flush_wbuf_pad(c); 399 mutex_unlock(&c->alloc_sem); 400 } 401 402 if (!(*flags & MS_RDONLY)) 403 jffs2_start_garbage_collect_thread(c); 404 405 *flags |= MS_NOATIME; 406 407 unlock_kernel(); 408 return 0; 409 } 410 411 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash, 412 fill in the raw_inode while you're at it. */ 413 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri) 414 { 415 struct inode *inode; 416 struct super_block *sb = dir_i->i_sb; 417 struct jffs2_sb_info *c; 418 struct jffs2_inode_info *f; 419 int ret; 420 421 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode)); 422 423 c = JFFS2_SB_INFO(sb); 424 425 inode = new_inode(sb); 426 427 if (!inode) 428 return ERR_PTR(-ENOMEM); 429 430 f = JFFS2_INODE_INFO(inode); 431 jffs2_init_inode_info(f); 432 mutex_lock(&f->sem); 433 434 memset(ri, 0, sizeof(*ri)); 435 /* Set OS-specific defaults for new inodes */ 436 ri->uid = cpu_to_je16(current_fsuid()); 437 438 if (dir_i->i_mode & S_ISGID) { 439 ri->gid = cpu_to_je16(dir_i->i_gid); 440 if (S_ISDIR(mode)) 441 mode |= S_ISGID; 442 } else { 443 ri->gid = cpu_to_je16(current_fsgid()); 444 } 445 446 /* POSIX ACLs have to be processed now, at least partly. 447 The umask is only applied if there's no default ACL */ 448 ret = jffs2_init_acl_pre(dir_i, inode, &mode); 449 if (ret) { 450 make_bad_inode(inode); 451 iput(inode); 452 return ERR_PTR(ret); 453 } 454 ret = jffs2_do_new_inode (c, f, mode, ri); 455 if (ret) { 456 make_bad_inode(inode); 457 iput(inode); 458 return ERR_PTR(ret); 459 } 460 inode->i_nlink = 1; 461 inode->i_ino = je32_to_cpu(ri->ino); 462 inode->i_mode = jemode_to_cpu(ri->mode); 463 inode->i_gid = je16_to_cpu(ri->gid); 464 inode->i_uid = je16_to_cpu(ri->uid); 465 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 466 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime)); 467 468 inode->i_blocks = 0; 469 inode->i_size = 0; 470 471 if (insert_inode_locked(inode) < 0) { 472 make_bad_inode(inode); 473 unlock_new_inode(inode); 474 iput(inode); 475 return ERR_PTR(-EINVAL); 476 } 477 478 return inode; 479 } 480 481 static int calculate_inocache_hashsize(uint32_t flash_size) 482 { 483 /* 484 * Pick a inocache hash size based on the size of the medium. 485 * Count how many megabytes we're dealing with, apply a hashsize twice 486 * that size, but rounding down to the usual big powers of 2. And keep 487 * to sensible bounds. 488 */ 489 490 int size_mb = flash_size / 1024 / 1024; 491 int hashsize = (size_mb * 2) & ~0x3f; 492 493 if (hashsize < INOCACHE_HASHSIZE_MIN) 494 return INOCACHE_HASHSIZE_MIN; 495 if (hashsize > INOCACHE_HASHSIZE_MAX) 496 return INOCACHE_HASHSIZE_MAX; 497 498 return hashsize; 499 } 500 501 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent) 502 { 503 struct jffs2_sb_info *c; 504 struct inode *root_i; 505 int ret; 506 size_t blocks; 507 508 c = JFFS2_SB_INFO(sb); 509 510 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER 511 if (c->mtd->type == MTD_NANDFLASH) { 512 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n"); 513 return -EINVAL; 514 } 515 if (c->mtd->type == MTD_DATAFLASH) { 516 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n"); 517 return -EINVAL; 518 } 519 #endif 520 521 c->flash_size = c->mtd->size; 522 c->sector_size = c->mtd->erasesize; 523 blocks = c->flash_size / c->sector_size; 524 525 /* 526 * Size alignment check 527 */ 528 if ((c->sector_size * blocks) != c->flash_size) { 529 c->flash_size = c->sector_size * blocks; 530 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n", 531 c->flash_size / 1024); 532 } 533 534 if (c->flash_size < 5*c->sector_size) { 535 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size); 536 return -EINVAL; 537 } 538 539 c->cleanmarker_size = sizeof(struct jffs2_unknown_node); 540 541 /* NAND (or other bizarre) flash... do setup accordingly */ 542 ret = jffs2_flash_setup(c); 543 if (ret) 544 return ret; 545 546 c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size); 547 c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL); 548 if (!c->inocache_list) { 549 ret = -ENOMEM; 550 goto out_wbuf; 551 } 552 553 jffs2_init_xattr_subsystem(c); 554 555 if ((ret = jffs2_do_mount_fs(c))) 556 goto out_inohash; 557 558 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n")); 559 root_i = jffs2_iget(sb, 1); 560 if (IS_ERR(root_i)) { 561 D1(printk(KERN_WARNING "get root inode failed\n")); 562 ret = PTR_ERR(root_i); 563 goto out_root; 564 } 565 566 ret = -ENOMEM; 567 568 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n")); 569 sb->s_root = d_alloc_root(root_i); 570 if (!sb->s_root) 571 goto out_root_i; 572 573 sb->s_maxbytes = 0xFFFFFFFF; 574 sb->s_blocksize = PAGE_CACHE_SIZE; 575 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 576 sb->s_magic = JFFS2_SUPER_MAGIC; 577 if (!(sb->s_flags & MS_RDONLY)) 578 jffs2_start_garbage_collect_thread(c); 579 return 0; 580 581 out_root_i: 582 iput(root_i); 583 out_root: 584 jffs2_free_ino_caches(c); 585 jffs2_free_raw_node_refs(c); 586 if (jffs2_blocks_use_vmalloc(c)) 587 vfree(c->blocks); 588 else 589 kfree(c->blocks); 590 out_inohash: 591 jffs2_clear_xattr_subsystem(c); 592 kfree(c->inocache_list); 593 out_wbuf: 594 jffs2_flash_cleanup(c); 595 596 return ret; 597 } 598 599 void jffs2_gc_release_inode(struct jffs2_sb_info *c, 600 struct jffs2_inode_info *f) 601 { 602 iput(OFNI_EDONI_2SFFJ(f)); 603 } 604 605 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c, 606 int inum, int unlinked) 607 { 608 struct inode *inode; 609 struct jffs2_inode_cache *ic; 610 611 if (unlinked) { 612 /* The inode has zero nlink but its nodes weren't yet marked 613 obsolete. This has to be because we're still waiting for 614 the final (close() and) iput() to happen. 615 616 There's a possibility that the final iput() could have 617 happened while we were contemplating. In order to ensure 618 that we don't cause a new read_inode() (which would fail) 619 for the inode in question, we use ilookup() in this case 620 instead of iget(). 621 622 The nlink can't _become_ zero at this point because we're 623 holding the alloc_sem, and jffs2_do_unlink() would also 624 need that while decrementing nlink on any inode. 625 */ 626 inode = ilookup(OFNI_BS_2SFFJ(c), inum); 627 if (!inode) { 628 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n", 629 inum)); 630 631 spin_lock(&c->inocache_lock); 632 ic = jffs2_get_ino_cache(c, inum); 633 if (!ic) { 634 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum)); 635 spin_unlock(&c->inocache_lock); 636 return NULL; 637 } 638 if (ic->state != INO_STATE_CHECKEDABSENT) { 639 /* Wait for progress. Don't just loop */ 640 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n", 641 ic->ino, ic->state)); 642 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 643 } else { 644 spin_unlock(&c->inocache_lock); 645 } 646 647 return NULL; 648 } 649 } else { 650 /* Inode has links to it still; they're not going away because 651 jffs2_do_unlink() would need the alloc_sem and we have it. 652 Just iget() it, and if read_inode() is necessary that's OK. 653 */ 654 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum); 655 if (IS_ERR(inode)) 656 return ERR_CAST(inode); 657 } 658 if (is_bad_inode(inode)) { 659 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. unlinked %d\n", 660 inum, unlinked); 661 /* NB. This will happen again. We need to do something appropriate here. */ 662 iput(inode); 663 return ERR_PTR(-EIO); 664 } 665 666 return JFFS2_INODE_INFO(inode); 667 } 668 669 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c, 670 struct jffs2_inode_info *f, 671 unsigned long offset, 672 unsigned long *priv) 673 { 674 struct inode *inode = OFNI_EDONI_2SFFJ(f); 675 struct page *pg; 676 677 pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT, 678 (void *)jffs2_do_readpage_unlock, inode); 679 if (IS_ERR(pg)) 680 return (void *)pg; 681 682 *priv = (unsigned long)pg; 683 return kmap(pg); 684 } 685 686 void jffs2_gc_release_page(struct jffs2_sb_info *c, 687 unsigned char *ptr, 688 unsigned long *priv) 689 { 690 struct page *pg = (void *)*priv; 691 692 kunmap(pg); 693 page_cache_release(pg); 694 } 695 696 static int jffs2_flash_setup(struct jffs2_sb_info *c) { 697 int ret = 0; 698 699 if (jffs2_cleanmarker_oob(c)) { 700 /* NAND flash... do setup accordingly */ 701 ret = jffs2_nand_flash_setup(c); 702 if (ret) 703 return ret; 704 } 705 706 /* and Dataflash */ 707 if (jffs2_dataflash(c)) { 708 ret = jffs2_dataflash_setup(c); 709 if (ret) 710 return ret; 711 } 712 713 /* and Intel "Sibley" flash */ 714 if (jffs2_nor_wbuf_flash(c)) { 715 ret = jffs2_nor_wbuf_flash_setup(c); 716 if (ret) 717 return ret; 718 } 719 720 /* and an UBI volume */ 721 if (jffs2_ubivol(c)) { 722 ret = jffs2_ubivol_setup(c); 723 if (ret) 724 return ret; 725 } 726 727 return ret; 728 } 729 730 void jffs2_flash_cleanup(struct jffs2_sb_info *c) { 731 732 if (jffs2_cleanmarker_oob(c)) { 733 jffs2_nand_flash_cleanup(c); 734 } 735 736 /* and DataFlash */ 737 if (jffs2_dataflash(c)) { 738 jffs2_dataflash_cleanup(c); 739 } 740 741 /* and Intel "Sibley" flash */ 742 if (jffs2_nor_wbuf_flash(c)) { 743 jffs2_nor_wbuf_flash_cleanup(c); 744 } 745 746 /* and an UBI volume */ 747 if (jffs2_ubivol(c)) { 748 jffs2_ubivol_cleanup(c); 749 } 750 } 751