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: fs.c,v 1.66 2005/09/27 13:17:29 dedekind Exp $ 11 * 12 */ 13 14 #include <linux/capability.h> 15 #include <linux/kernel.h> 16 #include <linux/sched.h> 17 #include <linux/fs.h> 18 #include <linux/list.h> 19 #include <linux/mtd/mtd.h> 20 #include <linux/pagemap.h> 21 #include <linux/slab.h> 22 #include <linux/vmalloc.h> 23 #include <linux/vfs.h> 24 #include <linux/crc32.h> 25 #include "nodelist.h" 26 27 static int jffs2_flash_setup(struct jffs2_sb_info *c); 28 29 static 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 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino)); 42 ret = inode_change_ok(inode, iattr); 43 if (ret) 44 return ret; 45 46 /* Special cases - we don't want more than one data node 47 for these types on the medium at any time. So setattr 48 must read the original data associated with the node 49 (i.e. the device numbers or the target name) and write 50 it out again with the appropriate data attached */ 51 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) { 52 /* For these, we don't actually need to read the old node */ 53 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev); 54 mdata = (char *)&dev; 55 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen)); 56 } else if (S_ISLNK(inode->i_mode)) { 57 down(&f->sem); 58 mdatalen = f->metadata->size; 59 mdata = kmalloc(f->metadata->size, GFP_USER); 60 if (!mdata) { 61 up(&f->sem); 62 return -ENOMEM; 63 } 64 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen); 65 if (ret) { 66 up(&f->sem); 67 kfree(mdata); 68 return ret; 69 } 70 up(&f->sem); 71 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen)); 72 } 73 74 ri = jffs2_alloc_raw_inode(); 75 if (!ri) { 76 if (S_ISLNK(inode->i_mode)) 77 kfree(mdata); 78 return -ENOMEM; 79 } 80 81 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen, 82 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 83 if (ret) { 84 jffs2_free_raw_inode(ri); 85 if (S_ISLNK(inode->i_mode & S_IFMT)) 86 kfree(mdata); 87 return ret; 88 } 89 down(&f->sem); 90 ivalid = iattr->ia_valid; 91 92 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 93 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 94 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen); 95 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 96 97 ri->ino = cpu_to_je32(inode->i_ino); 98 ri->version = cpu_to_je32(++f->highest_version); 99 100 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid); 101 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid); 102 103 if (ivalid & ATTR_MODE) 104 if (iattr->ia_mode & S_ISGID && 105 !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID)) 106 ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID); 107 else 108 ri->mode = cpu_to_jemode(iattr->ia_mode); 109 else 110 ri->mode = cpu_to_jemode(inode->i_mode); 111 112 113 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size); 114 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime)); 115 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime)); 116 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime)); 117 118 ri->offset = cpu_to_je32(0); 119 ri->csize = ri->dsize = cpu_to_je32(mdatalen); 120 ri->compr = JFFS2_COMPR_NONE; 121 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) { 122 /* It's an extension. Make it a hole node */ 123 ri->compr = JFFS2_COMPR_ZERO; 124 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size); 125 ri->offset = cpu_to_je32(inode->i_size); 126 } 127 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 128 if (mdatalen) 129 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen)); 130 else 131 ri->data_crc = cpu_to_je32(0); 132 133 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, ALLOC_NORMAL); 134 if (S_ISLNK(inode->i_mode)) 135 kfree(mdata); 136 137 if (IS_ERR(new_metadata)) { 138 jffs2_complete_reservation(c); 139 jffs2_free_raw_inode(ri); 140 up(&f->sem); 141 return PTR_ERR(new_metadata); 142 } 143 /* It worked. Update the inode */ 144 inode->i_atime = ITIME(je32_to_cpu(ri->atime)); 145 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime)); 146 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime)); 147 inode->i_mode = jemode_to_cpu(ri->mode); 148 inode->i_uid = je16_to_cpu(ri->uid); 149 inode->i_gid = je16_to_cpu(ri->gid); 150 151 152 old_metadata = f->metadata; 153 154 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) 155 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size); 156 157 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) { 158 jffs2_add_full_dnode_to_inode(c, f, new_metadata); 159 inode->i_size = iattr->ia_size; 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 up(&f->sem); 171 jffs2_complete_reservation(c); 172 173 /* We have to do the vmtruncate() 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 vmtruncate(inode, iattr->ia_size); 180 181 return 0; 182 } 183 184 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr) 185 { 186 int 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 return rc; 192 } 193 194 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf) 195 { 196 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb); 197 unsigned long avail; 198 199 buf->f_type = JFFS2_SUPER_MAGIC; 200 buf->f_bsize = 1 << PAGE_SHIFT; 201 buf->f_blocks = c->flash_size >> PAGE_SHIFT; 202 buf->f_files = 0; 203 buf->f_ffree = 0; 204 buf->f_namelen = JFFS2_MAX_NAME_LEN; 205 206 spin_lock(&c->erase_completion_lock); 207 avail = c->dirty_size + c->free_size; 208 if (avail > c->sector_size * c->resv_blocks_write) 209 avail -= c->sector_size * c->resv_blocks_write; 210 else 211 avail = 0; 212 spin_unlock(&c->erase_completion_lock); 213 214 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT; 215 216 return 0; 217 } 218 219 220 void jffs2_clear_inode (struct inode *inode) 221 { 222 /* We can forget about this inode for now - drop all 223 * the nodelists associated with it, etc. 224 */ 225 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); 226 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 227 228 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode)); 229 jffs2_do_clear_inode(c, f); 230 } 231 232 void jffs2_read_inode (struct inode *inode) 233 { 234 struct jffs2_inode_info *f; 235 struct jffs2_sb_info *c; 236 struct jffs2_raw_inode latest_node; 237 union jffs2_device_node jdev; 238 dev_t rdev = 0; 239 int ret; 240 241 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino)); 242 243 f = JFFS2_INODE_INFO(inode); 244 c = JFFS2_SB_INFO(inode->i_sb); 245 246 jffs2_init_inode_info(f); 247 down(&f->sem); 248 249 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node); 250 251 if (ret) { 252 make_bad_inode(inode); 253 up(&f->sem); 254 return; 255 } 256 inode->i_mode = jemode_to_cpu(latest_node.mode); 257 inode->i_uid = je16_to_cpu(latest_node.uid); 258 inode->i_gid = je16_to_cpu(latest_node.gid); 259 inode->i_size = je32_to_cpu(latest_node.isize); 260 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime)); 261 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime)); 262 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime)); 263 264 inode->i_nlink = f->inocache->nlink; 265 266 inode->i_blksize = PAGE_SIZE; 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 inode->i_nlink++; 282 } 283 /* and '..' */ 284 inode->i_nlink++; 285 /* Root dir gets i_nlink 3 for some reason */ 286 if (inode->i_ino == 1) 287 inode->i_nlink++; 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 ri->mode = cpu_to_jemode(mode); 438 ret = jffs2_do_new_inode (c, f, mode, ri); 439 if (ret) { 440 make_bad_inode(inode); 441 iput(inode); 442 return ERR_PTR(ret); 443 } 444 inode->i_nlink = 1; 445 inode->i_ino = je32_to_cpu(ri->ino); 446 inode->i_mode = jemode_to_cpu(ri->mode); 447 inode->i_gid = je16_to_cpu(ri->gid); 448 inode->i_uid = je16_to_cpu(ri->uid); 449 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 450 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime)); 451 452 inode->i_blksize = PAGE_SIZE; 453 inode->i_blocks = 0; 454 inode->i_size = 0; 455 456 insert_inode_hash(inode); 457 458 return inode; 459 } 460 461 462 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent) 463 { 464 struct jffs2_sb_info *c; 465 struct inode *root_i; 466 int ret; 467 size_t blocks; 468 469 c = JFFS2_SB_INFO(sb); 470 471 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER 472 if (c->mtd->type == MTD_NANDFLASH) { 473 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n"); 474 return -EINVAL; 475 } 476 if (c->mtd->type == MTD_DATAFLASH) { 477 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n"); 478 return -EINVAL; 479 } 480 #endif 481 482 c->flash_size = c->mtd->size; 483 c->sector_size = c->mtd->erasesize; 484 blocks = c->flash_size / c->sector_size; 485 486 /* 487 * Size alignment check 488 */ 489 if ((c->sector_size * blocks) != c->flash_size) { 490 c->flash_size = c->sector_size * blocks; 491 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n", 492 c->flash_size / 1024); 493 } 494 495 if (c->flash_size < 5*c->sector_size) { 496 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size); 497 return -EINVAL; 498 } 499 500 c->cleanmarker_size = sizeof(struct jffs2_unknown_node); 501 502 /* NAND (or other bizarre) flash... do setup accordingly */ 503 ret = jffs2_flash_setup(c); 504 if (ret) 505 return ret; 506 507 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL); 508 if (!c->inocache_list) { 509 ret = -ENOMEM; 510 goto out_wbuf; 511 } 512 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *)); 513 514 jffs2_init_xattr_subsystem(c); 515 516 if ((ret = jffs2_do_mount_fs(c))) 517 goto out_inohash; 518 519 ret = -EINVAL; 520 521 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n")); 522 root_i = iget(sb, 1); 523 if (is_bad_inode(root_i)) { 524 D1(printk(KERN_WARNING "get root inode failed\n")); 525 goto out_root_i; 526 } 527 528 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n")); 529 sb->s_root = d_alloc_root(root_i); 530 if (!sb->s_root) 531 goto out_root_i; 532 533 sb->s_maxbytes = 0xFFFFFFFF; 534 sb->s_blocksize = PAGE_CACHE_SIZE; 535 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 536 sb->s_magic = JFFS2_SUPER_MAGIC; 537 if (!(sb->s_flags & MS_RDONLY)) 538 jffs2_start_garbage_collect_thread(c); 539 return 0; 540 541 out_root_i: 542 iput(root_i); 543 jffs2_free_ino_caches(c); 544 jffs2_free_raw_node_refs(c); 545 if (jffs2_blocks_use_vmalloc(c)) 546 vfree(c->blocks); 547 else 548 kfree(c->blocks); 549 out_inohash: 550 jffs2_clear_xattr_subsystem(c); 551 kfree(c->inocache_list); 552 out_wbuf: 553 jffs2_flash_cleanup(c); 554 555 return ret; 556 } 557 558 void jffs2_gc_release_inode(struct jffs2_sb_info *c, 559 struct jffs2_inode_info *f) 560 { 561 iput(OFNI_EDONI_2SFFJ(f)); 562 } 563 564 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c, 565 int inum, int nlink) 566 { 567 struct inode *inode; 568 struct jffs2_inode_cache *ic; 569 if (!nlink) { 570 /* The inode has zero nlink but its nodes weren't yet marked 571 obsolete. This has to be because we're still waiting for 572 the final (close() and) iput() to happen. 573 574 There's a possibility that the final iput() could have 575 happened while we were contemplating. In order to ensure 576 that we don't cause a new read_inode() (which would fail) 577 for the inode in question, we use ilookup() in this case 578 instead of iget(). 579 580 The nlink can't _become_ zero at this point because we're 581 holding the alloc_sem, and jffs2_do_unlink() would also 582 need that while decrementing nlink on any inode. 583 */ 584 inode = ilookup(OFNI_BS_2SFFJ(c), inum); 585 if (!inode) { 586 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n", 587 inum)); 588 589 spin_lock(&c->inocache_lock); 590 ic = jffs2_get_ino_cache(c, inum); 591 if (!ic) { 592 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum)); 593 spin_unlock(&c->inocache_lock); 594 return NULL; 595 } 596 if (ic->state != INO_STATE_CHECKEDABSENT) { 597 /* Wait for progress. Don't just loop */ 598 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n", 599 ic->ino, ic->state)); 600 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 601 } else { 602 spin_unlock(&c->inocache_lock); 603 } 604 605 return NULL; 606 } 607 } else { 608 /* Inode has links to it still; they're not going away because 609 jffs2_do_unlink() would need the alloc_sem and we have it. 610 Just iget() it, and if read_inode() is necessary that's OK. 611 */ 612 inode = iget(OFNI_BS_2SFFJ(c), inum); 613 if (!inode) 614 return ERR_PTR(-ENOMEM); 615 } 616 if (is_bad_inode(inode)) { 617 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n", 618 inum, nlink); 619 /* NB. This will happen again. We need to do something appropriate here. */ 620 iput(inode); 621 return ERR_PTR(-EIO); 622 } 623 624 return JFFS2_INODE_INFO(inode); 625 } 626 627 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c, 628 struct jffs2_inode_info *f, 629 unsigned long offset, 630 unsigned long *priv) 631 { 632 struct inode *inode = OFNI_EDONI_2SFFJ(f); 633 struct page *pg; 634 635 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT, 636 (void *)jffs2_do_readpage_unlock, inode); 637 if (IS_ERR(pg)) 638 return (void *)pg; 639 640 *priv = (unsigned long)pg; 641 return kmap(pg); 642 } 643 644 void jffs2_gc_release_page(struct jffs2_sb_info *c, 645 unsigned char *ptr, 646 unsigned long *priv) 647 { 648 struct page *pg = (void *)*priv; 649 650 kunmap(pg); 651 page_cache_release(pg); 652 } 653 654 static int jffs2_flash_setup(struct jffs2_sb_info *c) { 655 int ret = 0; 656 657 if (jffs2_cleanmarker_oob(c)) { 658 /* NAND flash... do setup accordingly */ 659 ret = jffs2_nand_flash_setup(c); 660 if (ret) 661 return ret; 662 } 663 664 /* and Dataflash */ 665 if (jffs2_dataflash(c)) { 666 ret = jffs2_dataflash_setup(c); 667 if (ret) 668 return ret; 669 } 670 671 /* and Intel "Sibley" flash */ 672 if (jffs2_nor_wbuf_flash(c)) { 673 ret = jffs2_nor_wbuf_flash_setup(c); 674 if (ret) 675 return ret; 676 } 677 678 return ret; 679 } 680 681 void jffs2_flash_cleanup(struct jffs2_sb_info *c) { 682 683 if (jffs2_cleanmarker_oob(c)) { 684 jffs2_nand_flash_cleanup(c); 685 } 686 687 /* and DataFlash */ 688 if (jffs2_dataflash(c)) { 689 jffs2_dataflash_cleanup(c); 690 } 691 692 /* and Intel "Sibley" flash */ 693 if (jffs2_nor_wbuf_flash(c)) { 694 jffs2_nor_wbuf_flash_cleanup(c); 695 } 696 } 697