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