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