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