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.59 2005/07/18 11:21:19 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 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_root_i; 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 jffs2_free_ino_caches(c); 539 jffs2_free_raw_node_refs(c); 540 if (c->mtd->flags & MTD_NO_VIRTBLOCKS) 541 vfree(c->blocks); 542 else 543 kfree(c->blocks); 544 out_inohash: 545 kfree(c->inocache_list); 546 out_wbuf: 547 jffs2_flash_cleanup(c); 548 549 return ret; 550 } 551 552 void jffs2_gc_release_inode(struct jffs2_sb_info *c, 553 struct jffs2_inode_info *f) 554 { 555 iput(OFNI_EDONI_2SFFJ(f)); 556 } 557 558 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c, 559 int inum, int nlink) 560 { 561 struct inode *inode; 562 struct jffs2_inode_cache *ic; 563 if (!nlink) { 564 /* The inode has zero nlink but its nodes weren't yet marked 565 obsolete. This has to be because we're still waiting for 566 the final (close() and) iput() to happen. 567 568 There's a possibility that the final iput() could have 569 happened while we were contemplating. In order to ensure 570 that we don't cause a new read_inode() (which would fail) 571 for the inode in question, we use ilookup() in this case 572 instead of iget(). 573 574 The nlink can't _become_ zero at this point because we're 575 holding the alloc_sem, and jffs2_do_unlink() would also 576 need that while decrementing nlink on any inode. 577 */ 578 inode = ilookup(OFNI_BS_2SFFJ(c), inum); 579 if (!inode) { 580 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n", 581 inum)); 582 583 spin_lock(&c->inocache_lock); 584 ic = jffs2_get_ino_cache(c, inum); 585 if (!ic) { 586 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum)); 587 spin_unlock(&c->inocache_lock); 588 return NULL; 589 } 590 if (ic->state != INO_STATE_CHECKEDABSENT) { 591 /* Wait for progress. Don't just loop */ 592 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n", 593 ic->ino, ic->state)); 594 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 595 } else { 596 spin_unlock(&c->inocache_lock); 597 } 598 599 return NULL; 600 } 601 } else { 602 /* Inode has links to it still; they're not going away because 603 jffs2_do_unlink() would need the alloc_sem and we have it. 604 Just iget() it, and if read_inode() is necessary that's OK. 605 */ 606 inode = iget(OFNI_BS_2SFFJ(c), inum); 607 if (!inode) 608 return ERR_PTR(-ENOMEM); 609 } 610 if (is_bad_inode(inode)) { 611 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n", 612 inum, nlink); 613 /* NB. This will happen again. We need to do something appropriate here. */ 614 iput(inode); 615 return ERR_PTR(-EIO); 616 } 617 618 return JFFS2_INODE_INFO(inode); 619 } 620 621 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c, 622 struct jffs2_inode_info *f, 623 unsigned long offset, 624 unsigned long *priv) 625 { 626 struct inode *inode = OFNI_EDONI_2SFFJ(f); 627 struct page *pg; 628 629 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT, 630 (void *)jffs2_do_readpage_unlock, inode); 631 if (IS_ERR(pg)) 632 return (void *)pg; 633 634 *priv = (unsigned long)pg; 635 return kmap(pg); 636 } 637 638 void jffs2_gc_release_page(struct jffs2_sb_info *c, 639 unsigned char *ptr, 640 unsigned long *priv) 641 { 642 struct page *pg = (void *)*priv; 643 644 kunmap(pg); 645 page_cache_release(pg); 646 } 647 648 static int jffs2_flash_setup(struct jffs2_sb_info *c) { 649 int ret = 0; 650 651 if (jffs2_cleanmarker_oob(c)) { 652 /* NAND flash... do setup accordingly */ 653 ret = jffs2_nand_flash_setup(c); 654 if (ret) 655 return ret; 656 } 657 658 /* add setups for other bizarre flashes here... */ 659 if (jffs2_nor_ecc(c)) { 660 ret = jffs2_nor_ecc_flash_setup(c); 661 if (ret) 662 return ret; 663 } 664 665 /* and Dataflash */ 666 if (jffs2_dataflash(c)) { 667 ret = jffs2_dataflash_setup(c); 668 if (ret) 669 return ret; 670 } 671 672 return ret; 673 } 674 675 void jffs2_flash_cleanup(struct jffs2_sb_info *c) { 676 677 if (jffs2_cleanmarker_oob(c)) { 678 jffs2_nand_flash_cleanup(c); 679 } 680 681 /* add cleanups for other bizarre flashes here... */ 682 if (jffs2_nor_ecc(c)) { 683 jffs2_nor_ecc_flash_cleanup(c); 684 } 685 686 /* and DataFlash */ 687 if (jffs2_dataflash(c)) { 688 jffs2_dataflash_cleanup(c); 689 } 690 } 691