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