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