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