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