开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
inode-v23.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：47k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

inode-v23.c：源码内容
  1. /*
  2.  * JFFS -- Journalling Flash File System, Linux implementation.
  3.  *
  4.  * Copyright (C) 1999, 2000  Axis Communications AB.
  5.  *
  6.  * Created by Finn Hakansson <finn@axis.com>.
  7.  *
  8.  * This is free software; you can redistribute it and/or modify it
  9.  * under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * $Id: inode-v23.c,v 1.72 2002/01/31 11:42:57 cdavies Exp $
  14.  *
  15.  * Ported to Linux 2.3.x and MTD:
  16.  * Copyright (C) 2000  Alexander Larsson (alex@cendio.se), Cendio Systems AB
  17.  *
  18.  * Copyright 2000, 2001  Red Hat, Inc.
  19.  */
  21. /* inode.c -- Contains the code that is called from the VFS.  */
  23. /* TODO-ALEX:
  24.  * uid and gid are just 16 bit.
  25.  * jffs_file_write reads from user-space pointers without xx_from_user
  26.  * maybe other stuff do to.
  27.  */
  29. /* Argh. Some architectures have kernel_thread in asm/processor.h
  30.    Some have it in unistd.h and you need to define __KERNEL_SYSCALLS__
  31.    Pass me a baseball bat and the person responsible.
  32.    dwmw2
  33. */
  34. #define __KERNEL_SYSCALLS__
  35. #include <linux/sched.h>
  36. #include <linux/unistd.h>
  38. #include <linux/module.h>
  39. #include <linux/init.h>
  40. #include <linux/types.h>
  41. #include <linux/errno.h>
  42. #include <linux/slab.h>
  43. #include <linux/jffs.h>
  44. #include <linux/fs.h>
  45. #include <linux/locks.h>
  46. #include <linux/smp_lock.h>
  47. #include <linux/ioctl.h>
  48. #include <linux/stat.h>
  49. #include <linux/blkdev.h>
  50. #include <linux/quotaops.h>
  51. #include <linux/compatmac.h>
  52. #include <asm/semaphore.h>
  53. #include <asm/byteorder.h>
  54. #include <asm/uaccess.h>
  56. #include "jffs_fm.h"
  57. #include "intrep.h"
  58. #if CONFIG_JFFS_PROC_FS
  59. #include "jffs_proc.h"
  60. #endif
  62. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,2)
  63. #define minor(x) MINOR(x)
  64. #define major(x) MAJOR(x)
  65. #endif
  67. static int jffs_remove(struct inode *dir, struct dentry *dentry, int type);
  69. static struct super_operations jffs_ops;
  70. static struct file_operations jffs_file_operations;
  71. static struct inode_operations jffs_file_inode_operations;
  72. static struct file_operations jffs_dir_operations;
  73. static struct inode_operations jffs_dir_inode_operations;
  74. static struct address_space_operations jffs_address_operations;
  76. kmem_cache_t     *node_cache = NULL;
  77. kmem_cache_t     *fm_cache = NULL;
  79. /* Called by the VFS at mount time to initialize the whole file system.  */
  80. static struct super_block *
  81. jffs_read_super(struct super_block *sb, void *data, int silent)
  82. {
  83. kdev_t dev = sb->s_dev;
  84. struct inode *root_inode;
  85. struct jffs_control *c;
  87. D1(printk(KERN_NOTICE "JFFS: Trying to mount device %s.n",
  88.   kdevname(dev)));
  90. if (major(dev) != MTD_BLOCK_MAJOR) {
  91. printk(KERN_WARNING "JFFS: Trying to mount a "
  92.        "non-mtd device.n");
  93. return 0;
  94. }
  96. sb->s_blocksize = PAGE_CACHE_SIZE;
  97. sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
  98. sb->u.generic_sbp = (void *) 0;
  99. sb->s_maxbytes = 0xFFFFFFFF;
  101. /* Build the file system.  */
  102. if (jffs_build_fs(sb) < 0) {
  103. goto jffs_sb_err1;
  104. }
  106. /*
  107.  * set up enough so that we can read an inode
  108.  */
  109. sb->s_magic = JFFS_MAGIC_SB_BITMASK;
  110. sb->s_op = &jffs_ops;
  112. root_inode = iget(sb, JFFS_MIN_INO);
  113. if (!root_inode)
  114.         goto jffs_sb_err2;
  116. /* Get the root directory of this file system.  */
  117. if (!(sb->s_root = d_alloc_root(root_inode))) {
  118. goto jffs_sb_err3;
  119. }
  121. c = (struct jffs_control *) sb->u.generic_sbp;
  123. #ifdef CONFIG_JFFS_PROC_FS
  124. /* Set up the jffs proc file system.  */
  125. if (jffs_register_jffs_proc_dir(dev, c) < 0) {
  126. printk(KERN_WARNING "JFFS: Failed to initialize the JFFS "
  127. "proc file system for device %s.n",
  128. kdevname(dev));
  129. }
  130. #endif
  132. /* Set the Garbage Collection thresholds */
  134. /* GC if free space goes below 5% of the total size */
  135. c->gc_minfree_threshold = c->fmc->flash_size / 20;
  137. if (c->gc_minfree_threshold < c->fmc->sector_size)
  138. c->gc_minfree_threshold = c->fmc->sector_size;
  140. /* GC if dirty space exceeds 33% of the total size. */
  141. c->gc_maxdirty_threshold = c->fmc->flash_size / 3;
  143. if (c->gc_maxdirty_threshold < c->fmc->sector_size)
  144. c->gc_maxdirty_threshold = c->fmc->sector_size;
  147. c->thread_pid = kernel_thread (jffs_garbage_collect_thread, 
  148.         (void *) c, 
  149.         CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
  150. D1(printk(KERN_NOTICE "JFFS: GC thread pid=%d.n", (int) c->thread_pid));
  152. D1(printk(KERN_NOTICE "JFFS: Successfully mounted device %s.n",
  153.        kdevname(dev)));
  154. return sb;
  156. jffs_sb_err3:
  157. iput(root_inode);
  158. jffs_sb_err2:
  159. jffs_cleanup_control((struct jffs_control *)sb->u.generic_sbp);
  160. jffs_sb_err1:
  161. printk(KERN_WARNING "JFFS: Failed to mount device %s.n",
  162.        kdevname(dev));
  163. return 0;
  164. }
  167. /* This function is called when the file system is umounted.  */
  168. static void
  169. jffs_put_super(struct super_block *sb)
  170. {
  171. struct jffs_control *c = (struct jffs_control *) sb->u.generic_sbp;
  172. D1(kdev_t dev = sb->s_dev);
  174. D2(printk("jffs_put_super()n"));
  176. #ifdef CONFIG_JFFS_PROC_FS
  177. jffs_unregister_jffs_proc_dir(c);
  178. #endif
  180. if (c->gc_task) {
  181. D1(printk (KERN_NOTICE "jffs_put_super(): Telling gc thread to die.n"));
  182. send_sig(SIGKILL, c->gc_task, 1);
  183. }
  184. wait_for_completion(&c->gc_thread_comp);
  186. D1(printk (KERN_NOTICE "jffs_put_super(): Successfully waited on thread.n"));
  188. jffs_cleanup_control((struct jffs_control *)sb->u.generic_sbp);
  189. D1(printk(KERN_NOTICE "JFFS: Successfully unmounted device %s.n",
  190.        kdevname(dev)));
  191. }
  194. /* This function is called when user commands like chmod, chgrp and
  195.    chown are executed. System calls like trunc() results in a call
  196.    to this function.  */
  197. static int
  198. jffs_setattr(struct dentry *dentry, struct iattr *iattr)
  199. {
  200. struct inode *inode = dentry->d_inode;
  201. struct jffs_raw_inode raw_inode;
  202. struct jffs_control *c;
  203. struct jffs_fmcontrol *fmc;
  204. struct jffs_file *f;
  205. struct jffs_node *new_node;
  206. int update_all;
  207. int res;
  208. int recoverable = 0;
  210. if ((res = inode_change_ok(inode, iattr)))
  211. return res;
  213. c = (struct jffs_control *)inode->i_sb->u.generic_sbp;
  214. fmc = c->fmc;
  216. D3(printk (KERN_NOTICE "notify_change(): down biglockn"));
  217. down(&fmc->biglock);
  219. f = jffs_find_file(c, inode->i_ino);
  221. ASSERT(if (!f) {
  222. printk("jffs_setattr(): Invalid inode number: %lun",
  223.        inode->i_ino);
  224. D3(printk (KERN_NOTICE "notify_change(): up biglockn"));
  225. up(&fmc->biglock);
  226. return -EINVAL;
  227. });
  229. D1(printk("***jffs_setattr(): file: "%s", ino: %un",
  230.   f->name, f->ino));
  232. update_all = iattr->ia_valid & ATTR_FORCE;
  234. if ( (update_all || iattr->ia_valid & ATTR_SIZE)
  235.      && (iattr->ia_size + 128 < f->size) ) {
  236. /* We're shrinking the file by more than 128 bytes.
  237.    We'll be able to GC and recover this space, so
  238.    allow it to go into the reserved space. */
  239. recoverable = 1;
  240.         }
  242. if (!(new_node = jffs_alloc_node())) {
  243. D(printk("jffs_setattr(): Allocation failed!n"));
  244. D3(printk (KERN_NOTICE "notify_change(): up biglockn"));
  245. up(&fmc->biglock);
  246. return -ENOMEM;
  247. }
  249. new_node->data_offset = 0;
  250. new_node->removed_size = 0;
  251. raw_inode.magic = JFFS_MAGIC_BITMASK;
  252. raw_inode.ino = f->ino;
  253. raw_inode.pino = f->pino;
  254. raw_inode.mode = f->mode;
  255. raw_inode.uid = f->uid;
  256. raw_inode.gid = f->gid;
  257. raw_inode.atime = f->atime;
  258. raw_inode.mtime = f->mtime;
  259. raw_inode.ctime = f->ctime;
  260. raw_inode.dsize = 0;
  261. raw_inode.offset = 0;
  262. raw_inode.rsize = 0;
  263. raw_inode.dsize = 0;
  264. raw_inode.nsize = f->nsize;
  265. raw_inode.nlink = f->nlink;
  266. raw_inode.spare = 0;
  267. raw_inode.rename = 0;
  268. raw_inode.deleted = 0;
  270. if (update_all || iattr->ia_valid & ATTR_MODE) {
  271. raw_inode.mode = iattr->ia_mode;
  272. inode->i_mode = iattr->ia_mode;
  273. }
  274. if (update_all || iattr->ia_valid & ATTR_UID) {
  275. raw_inode.uid = iattr->ia_uid;
  276. inode->i_uid = iattr->ia_uid;
  277. }
  278. if (update_all || iattr->ia_valid & ATTR_GID) {
  279. raw_inode.gid = iattr->ia_gid;
  280. inode->i_gid = iattr->ia_gid;
  281. }
  282. if (update_all || iattr->ia_valid & ATTR_SIZE) {
  283. int len;
  284. D1(printk("jffs_notify_change(): Changing size "
  285.   "to %lu bytes!n", (long)iattr->ia_size));
  286. raw_inode.offset = iattr->ia_size;
  288. /* Calculate how many bytes need to be removed from
  289.    the end.  */
  290. if (f->size < iattr->ia_size) {
  291. len = 0;
  292. }
  293. else {
  294. len = f->size - iattr->ia_size;
  295. }
  297. raw_inode.rsize = len;
  299. /* The updated node will be a removal node, with
  300.    base at the new size and size of the nbr of bytes
  301.    to be removed.  */
  302. new_node->data_offset = iattr->ia_size;
  303. new_node->removed_size = len;
  304. inode->i_size = iattr->ia_size;
  305. inode->i_blocks = (inode->i_size + 511) >> 9;
  307. if (len) {
  308. invalidate_inode_pages(inode);
  309. }
  310. inode->i_ctime = CURRENT_TIME;
  311. inode->i_mtime = inode->i_ctime;
  312. }
  313. if (update_all || iattr->ia_valid & ATTR_ATIME) {
  314. raw_inode.atime = iattr->ia_atime;
  315. inode->i_atime = iattr->ia_atime;
  316. }
  317. if (update_all || iattr->ia_valid & ATTR_MTIME) {
  318. raw_inode.mtime = iattr->ia_mtime;
  319. inode->i_mtime = iattr->ia_mtime;
  320. }
  321. if (update_all || iattr->ia_valid & ATTR_CTIME) {
  322. raw_inode.ctime = iattr->ia_ctime;
  323. inode->i_ctime = iattr->ia_ctime;
  324. }
  326. /* Write this node to the flash.  */
  327. if ((res = jffs_write_node(c, new_node, &raw_inode, f->name, 0, recoverable, f)) < 0) {
  328. D(printk("jffs_notify_change(): The write failed!n"));
  329. jffs_free_node(new_node);
  330. D3(printk (KERN_NOTICE "n_c(): up biglockn"));
  331. up(&c->fmc->biglock);
  332. return res;
  333. }
  335. jffs_insert_node(c, f, &raw_inode, 0, new_node);
  337. mark_inode_dirty(inode);
  338. D3(printk (KERN_NOTICE "n_c(): up biglockn"));
  339. up(&c->fmc->biglock);
  340. return 0;
  341. } /* jffs_notify_change()  */
  344. struct inode *
  345. jffs_new_inode(const struct inode * dir, struct jffs_raw_inode *raw_inode,
  346.        int * err)
  347. {
  348. struct super_block * sb;
  349. struct inode * inode;
  350. struct jffs_control *c;
  351. struct jffs_file *f;
  353. sb = dir->i_sb;
  354. inode = new_inode(sb);
  355. if (!inode) {
  356. *err = -ENOMEM;
  357. return NULL;
  358. }
  360. c = (struct jffs_control *)sb->u.generic_sbp;
  362. inode->i_ino = raw_inode->ino;
  363. inode->i_mode = raw_inode->mode;
  364. inode->i_nlink = raw_inode->nlink;
  365. inode->i_uid = raw_inode->uid;
  366. inode->i_gid = raw_inode->gid;
  367. inode->i_rdev = NODEV;
  368. inode->i_size = raw_inode->dsize;
  369. inode->i_atime = raw_inode->atime;
  370. inode->i_mtime = raw_inode->mtime;
  371. inode->i_ctime = raw_inode->ctime;
  372. inode->i_blksize = PAGE_SIZE;
  373. inode->i_blocks = (inode->i_size + 511) >> 9;
  374. inode->i_version = 0;
  376. f = jffs_find_file(c, raw_inode->ino);
  378. inode->u.generic_ip = (void *)f;
  379. insert_inode_hash(inode);
  381. return inode;
  382. }
  384. /* Get statistics of the file system.  */
  385. int
  386. jffs_statfs(struct super_block *sb, struct statfs *buf)
  387. {
  388. struct jffs_control *c = (struct jffs_control *) sb->u.generic_sbp;
  389. struct jffs_fmcontrol *fmc = c->fmc;
  391. D2(printk("jffs_statfs()n"));
  393. buf->f_type = JFFS_MAGIC_SB_BITMASK;
  394. buf->f_bsize = PAGE_CACHE_SIZE;
  395. buf->f_blocks = (fmc->flash_size / PAGE_CACHE_SIZE)
  396.        - (fmc->min_free_size / PAGE_CACHE_SIZE);
  397. buf->f_bfree = (jffs_free_size1(fmc) + jffs_free_size2(fmc) +
  398.        fmc->dirty_size - fmc->min_free_size)
  399.        >> PAGE_CACHE_SHIFT;
  400. buf->f_bavail = buf->f_bfree;
  402. /* Find out how many files there are in the filesystem.  */
  403. buf->f_files = jffs_foreach_file(c, jffs_file_count);
  404. buf->f_ffree = buf->f_bfree;
  405. /* buf->f_fsid = 0; */
  406. buf->f_namelen = JFFS_MAX_NAME_LEN;
  407. return 0;
  408. }
  411. /* Rename a file.  */
  412. int
  413. jffs_rename(struct inode *old_dir, struct dentry *old_dentry,
  414.     struct inode *new_dir, struct dentry *new_dentry)
  415. {
  416. struct jffs_raw_inode raw_inode;
  417. struct jffs_control *c;
  418. struct jffs_file *old_dir_f;
  419. struct jffs_file *new_dir_f;
  420. struct jffs_file *del_f;
  421. struct jffs_file *f;
  422. struct jffs_node *node;
  423. struct inode *inode;
  424. int result = 0;
  425. __u32 rename_data = 0;
  427. D2(printk("***jffs_rename()n"));
  429. D(printk("jffs_rename(): old_dir: 0x%p, old name: 0x%p, "
  430.  "new_dir: 0x%p, new name: 0x%pn",
  431.  old_dir, old_dentry->d_name.name,
  432.  new_dir, new_dentry->d_name.name));
  434. c = (struct jffs_control *)old_dir->i_sb->u.generic_sbp;
  435. ASSERT(if (!c) {
  436. printk(KERN_ERR "jffs_rename(): The old_dir inode "
  437.        "didn't have a reference to a jffs_file structn");
  438. return -EIO;
  439. });
  441. result = -ENOTDIR;
  442. if (!(old_dir_f = (struct jffs_file *)old_dir->u.generic_ip)) {
  443. D(printk("jffs_rename(): Old dir invalid.n"));
  444. goto jffs_rename_end;
  445. }
  447. /* Try to find the file to move.  */
  448. result = -ENOENT;
  449. if (!(f = jffs_find_child(old_dir_f, old_dentry->d_name.name,
  450.   old_dentry->d_name.len))) {
  451. goto jffs_rename_end;
  452. }
  454. /* Find the new directory.  */
  455. result = -ENOTDIR;
  456. if (!(new_dir_f = (struct jffs_file *)new_dir->u.generic_ip)) {
  457. D(printk("jffs_rename(): New dir invalid.n"));
  458. goto jffs_rename_end;
  459. }
  460. D3(printk (KERN_NOTICE "rename(): down biglockn"));
  461. down(&c->fmc->biglock);
  462. /* Create a node and initialize as much as needed.  */
  463. result = -ENOMEM;
  464. if (!(node = jffs_alloc_node())) {
  465. D(printk("jffs_rename(): Allocation failed: node == 0n"));
  466. goto jffs_rename_end;
  467. }
  468. node->data_offset = 0;
  469. node->removed_size = 0;
  471. /* Initialize the raw inode.  */
  472. raw_inode.magic = JFFS_MAGIC_BITMASK;
  473. raw_inode.ino = f->ino;
  474. raw_inode.pino = new_dir_f->ino;
  475. /*   raw_inode.version = f->highest_version + 1; */
  476. raw_inode.mode = f->mode;
  477. raw_inode.uid = current->fsuid;
  478. raw_inode.gid = current->fsgid;
  479. #if 0
  480. raw_inode.uid = f->uid;
  481. raw_inode.gid = f->gid;
  482. #endif
  483. raw_inode.atime = CURRENT_TIME;
  484. raw_inode.mtime = raw_inode.atime;
  485. raw_inode.ctime = f->ctime;
  486. raw_inode.offset = 0;
  487. raw_inode.dsize = 0;
  488. raw_inode.rsize = 0;
  489. raw_inode.nsize = new_dentry->d_name.len;
  490. raw_inode.nlink = f->nlink;
  491. raw_inode.spare = 0;
  492. raw_inode.rename = 0;
  493. raw_inode.deleted = 0;
  495. /* See if there already exists a file with the same name as
  496.    new_name.  */
  497. if ((del_f = jffs_find_child(new_dir_f, new_dentry->d_name.name,
  498.      new_dentry->d_name.len))) {
  499. raw_inode.rename = 1;
  500. raw_inode.dsize = sizeof(__u32);
  501. rename_data = del_f->ino;
  502. }
  504. /* Write the new node to the flash memory.  */
  505. if ((result = jffs_write_node(c, node, &raw_inode,
  506.       new_dentry->d_name.name,
  507.       (unsigned char*)&rename_data, 0, f)) < 0) {
  508. D(printk("jffs_rename(): Failed to write node to flash.n"));
  509. jffs_free_node(node);
  510. goto jffs_rename_end;
  511. }
  512. raw_inode.dsize = 0;
  514. if (raw_inode.rename) {
  515. /* The file with the same name must be deleted.  */
  516. //FIXME deadlock         down(&c->fmc->gclock);
  517. if ((result = jffs_remove(new_dir, new_dentry,
  518.   del_f->mode)) < 0) {
  519. /* This is really bad.  */
  520. printk(KERN_ERR "JFFS: An error occurred in "
  521.        "rename().n");
  522. }
  523. // up(&c->fmc->gclock);
  524. }
  526. if (old_dir_f != new_dir_f) {
  527. /* Remove the file from its old position in the
  528.    filesystem tree.  */
  529. jffs_unlink_file_from_tree(f);
  530. }
  532. /* Insert the new node into the file system.  */
  533. if ((result = jffs_insert_node(c, f, &raw_inode,
  534.        new_dentry->d_name.name, node)) < 0) {
  535. D(printk(KERN_ERR "jffs_rename(): jffs_insert_node() "
  536.  "failed!n"));
  537. }
  539. if (old_dir_f != new_dir_f) {
  540. /* Insert the file to its new position in the
  541.    file system.  */
  542. jffs_insert_file_into_tree(f);
  543. }
  545. /* This is a kind of update of the inode we're about to make
  546.    here.  This is what they do in ext2fs.  Kind of.  */
  547. if ((inode = iget(new_dir->i_sb, f->ino))) {
  548. inode->i_ctime = CURRENT_TIME;
  549. mark_inode_dirty(inode);
  550. iput(inode);
  551. }
  553. jffs_rename_end:
  554. D3(printk (KERN_NOTICE "rename(): up biglockn"));
  555. up(&c->fmc->biglock);
  556. return result;
  557. } /* jffs_rename()  */
  560. /* Read the contents of a directory.  Used by programs like `ls'
  561.    for instance.  */
  562. static int
  563. jffs_readdir(struct file *filp, void *dirent, filldir_t filldir)
  564. {
  565. struct jffs_file *f;
  566. struct dentry *dentry = filp->f_dentry;
  567. struct inode *inode = dentry->d_inode;
  568. struct jffs_control *c = (struct jffs_control *)inode->i_sb->u.generic_sbp;
  569. int j;
  570. int ddino;
  571. D3(printk (KERN_NOTICE "readdir(): down biglockn"));
  572. down(&c->fmc->biglock);
  574. D2(printk("jffs_readdir(): inode: 0x%p, filp: 0x%pn", inode, filp));
  575. if (filp->f_pos == 0) {
  576. D3(printk("jffs_readdir(): "." %lun", inode->i_ino));
  577. if (filldir(dirent, ".", 1, filp->f_pos, inode->i_ino, DT_DIR) < 0) {
  578. D3(printk (KERN_NOTICE "readdir(): up biglockn"));
  579. up(&c->fmc->biglock);
  580. return 0;
  581. }
  582. filp->f_pos = 1;
  583. }
  584. if (filp->f_pos == 1) {
  585. if (inode->i_ino == JFFS_MIN_INO) {
  586. ddino = JFFS_MIN_INO;
  587. }
  588. else {
  589. ddino = ((struct jffs_file *)
  590.  inode->u.generic_ip)->pino;
  591. }
  592. D3(printk("jffs_readdir(): ".." %un", ddino));
  593. if (filldir(dirent, "..", 2, filp->f_pos, ddino, DT_DIR) < 0) {
  594. D3(printk (KERN_NOTICE "readdir(): up biglockn"));
  595. up(&c->fmc->biglock);
  596. return 0;
  597. }
  598. filp->f_pos++;
  599. }
  600. f = ((struct jffs_file *)inode->u.generic_ip)->children;
  602. j = 2;
  603. while(f && (f->deleted || j++ < filp->f_pos )) {
  604. f = f->sibling_next;
  605. }
  607. while (f) {
  608. D3(printk("jffs_readdir(): "%s" ino: %un",
  609.   (f->name ? f->name : ""), f->ino));
  610. if (filldir(dirent, f->name, f->nsize,
  611.     filp->f_pos , f->ino, DT_UNKNOWN) < 0) {
  612.         D3(printk (KERN_NOTICE "readdir(): up biglockn"));
  613. up(&c->fmc->biglock);
  614. return 0;
  615. }
  616. filp->f_pos++;
  617. do {
  618. f = f->sibling_next;
  619. } while(f && f->deleted);
  620. }
  621. D3(printk (KERN_NOTICE "readdir(): up biglockn"));
  622. up(&c->fmc->biglock);
  623. return filp->f_pos;
  624. } /* jffs_readdir()  */
  627. /* Find a file in a directory. If the file exists, return its
  628.    corresponding dentry.  */
  629. static struct dentry *
  630. jffs_lookup(struct inode *dir, struct dentry *dentry)
  631. {
  632. struct jffs_file *d;
  633. struct jffs_file *f;
  634. struct jffs_control *c = (struct jffs_control *)dir->i_sb->u.generic_sbp;
  635. int len;
  636. int r = 0;
  637. const char *name;
  638. struct inode *inode = NULL;
  640. len = dentry->d_name.len;
  641. name = dentry->d_name.name;
  643. D3({
  644. char *s = (char *)kmalloc(len + 1, GFP_KERNEL);
  645. memcpy(s, name, len);
  646. s[len] = '';
  647. printk("jffs_lookup(): dir: 0x%p, name: "%s"n", dir, s);
  648. kfree(s);
  649. });
  651. D3(printk (KERN_NOTICE "lookup(): down biglockn"));
  652. down(&c->fmc->biglock);
  654. r = -ENAMETOOLONG;
  655. if (len > JFFS_MAX_NAME_LEN) {
  656. goto jffs_lookup_end;
  657. }
  659. r = -EACCES;
  660. if (!(d = (struct jffs_file *)dir->u.generic_ip)) {
  661. D(printk("jffs_lookup(): No such inode! (%lu)n",
  662.  dir->i_ino));
  663. goto jffs_lookup_end;
  664. }
  666. /* Get the corresponding inode to the file.  */
  668. /* iget calls jffs_read_inode, so we need to drop the biglock
  669.            before calling iget.  Unfortunately, the GC has a tendency
  670.            to sneak in here, because iget sometimes calls schedule ().
  671. */
  673. if ((len == 1) && (name[0] == '.')) {
  674. D3(printk (KERN_NOTICE "lookup(): up biglockn"));
  675. up(&c->fmc->biglock);
  676. if (!(inode = iget(dir->i_sb, d->ino))) {
  677. D(printk("jffs_lookup(): . iget() ==> NULLn"));
  678. goto jffs_lookup_end_no_biglock;
  679. }
  680. D3(printk (KERN_NOTICE "lookup(): down biglockn"));
  681. down(&c->fmc->biglock);
  682. } else if ((len == 2) && (name[0] == '.') && (name[1] == '.')) {
  683.         D3(printk (KERN_NOTICE "lookup(): up biglockn"));
  684. up(&c->fmc->biglock);
  685.   if (!(inode = iget(dir->i_sb, d->pino))) {
  686. D(printk("jffs_lookup(): .. iget() ==> NULLn"));
  687. goto jffs_lookup_end_no_biglock;
  688. }
  689. D3(printk (KERN_NOTICE "lookup(): down biglockn"));
  690. down(&c->fmc->biglock);
  691. } else if ((f = jffs_find_child(d, name, len))) {
  692.         D3(printk (KERN_NOTICE "lookup(): up biglockn"));
  693. up(&c->fmc->biglock);
  694. if (!(inode = iget(dir->i_sb, f->ino))) {
  695. D(printk("jffs_lookup(): iget() ==> NULLn"));
  696. goto jffs_lookup_end_no_biglock;
  697. }
  698. D3(printk (KERN_NOTICE "lookup(): down biglockn"));
  699. down(&c->fmc->biglock);
  700. } else {
  701. D3(printk("jffs_lookup(): Couldn't find the file. "
  702.   "f = 0x%p, name = "%s", d = 0x%p, d->ino = %un",
  703.   f, name, d, d->ino));
  704. inode = NULL;
  705. }
  707. d_add(dentry, inode);
  708. D3(printk (KERN_NOTICE "lookup(): up biglockn"));
  709. up(&c->fmc->biglock);
  710. return NULL;
  712. jffs_lookup_end:
  713. D3(printk (KERN_NOTICE "lookup(): up biglockn"));
  714. up(&c->fmc->biglock);
  716. jffs_lookup_end_no_biglock:
  717. return ERR_PTR(r);
  718. } /* jffs_lookup()  */
  721. /* Try to read a page of data from a file.  */
  722. static int
  723. jffs_do_readpage_nolock(struct file *file, struct page *page)
  724. {
  725. void *buf;
  726. unsigned long read_len;
  727. int result;
  728. struct inode *inode = (struct inode*)page->mapping->host;
  729. struct jffs_file *f = (struct jffs_file *)inode->u.generic_ip;
  730. struct jffs_control *c = (struct jffs_control *)inode->i_sb->u.generic_sbp;
  731. int r;
  732. loff_t offset;
  734. D2(printk("***jffs_readpage(): file = "%s", page->index = %lun",
  735.   (f->name ? f->name : ""), (long)page->index));
  737. get_page(page);
  738. /* Don't LockPage(page), should be locked already */
  739. buf = page_address(page);
  740. ClearPageUptodate(page);
  741. ClearPageError(page);
  743. D3(printk (KERN_NOTICE "readpage(): down biglockn"));
  744. down(&c->fmc->biglock);
  746. read_len = 0;
  747. result = 0;
  749. offset = page->index << PAGE_CACHE_SHIFT;
  750. if (offset < inode->i_size) {
  751. read_len = min_t(long, inode->i_size - offset, PAGE_SIZE);
  752. r = jffs_read_data(f, buf, offset, read_len);
  753. if (r != read_len) {
  754. result = -EIO;
  755. D(
  756.         printk("***jffs_readpage(): Read error! "
  757.        "Wanted to read %lu bytes but only "
  758.        "read %d bytes.n", read_len, r);
  759.   );
  760. }
  762. }
  764. /* This handles the case of partial or no read in above */
  765. if(read_len < PAGE_SIZE)
  766.         memset(buf + read_len, 0, PAGE_SIZE - read_len);
  768. D3(printk (KERN_NOTICE "readpage(): up biglockn"));
  769. up(&c->fmc->biglock);
  771. if (result) {
  772.         SetPageError(page);
  773. }else {
  774.         SetPageUptodate(page);         
  775. }
  776. flush_dcache_page(page);
  778. put_page(page);
  780. D3(printk("jffs_readpage(): Leaving...n"));
  782. return result;
  783. } /* jffs_do_readpage_nolock()  */
  785. static int jffs_readpage(struct file *file, struct page *page)
  786. {
  787. int ret = jffs_do_readpage_nolock(file, page);
  788. UnlockPage(page);
  789. return ret;
  790. }
  792. /* Create a new directory.  */
  793. static int
  794. jffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
  795. {
  796. struct jffs_raw_inode raw_inode;
  797. struct jffs_control *c;
  798. struct jffs_node *node;
  799. struct jffs_file *dir_f;
  800. struct inode *inode;
  801. int dir_mode;
  802. int result = 0;
  803. int err;
  805. D1({
  806.         int len = dentry->d_name.len;
  807. char *_name = (char *) kmalloc(len + 1, GFP_KERNEL);
  808. memcpy(_name, dentry->d_name.name, len);
  809. _name[len] = '';
  810. printk("***jffs_mkdir(): dir = 0x%p, name = "%s", "
  811.        "len = %d, mode = 0x%08xn", dir, _name, len, mode);
  812. kfree(_name);
  813. });
  815. dir_f = (struct jffs_file *)dir->u.generic_ip;
  817. ASSERT(if (!dir_f) {
  818. printk(KERN_ERR "jffs_mkdir(): No reference to a "
  819.        "jffs_file struct in inode.n");
  820. return -EIO;
  821. });
  823. c = dir_f->c;
  824. D3(printk (KERN_NOTICE "mkdir(): down biglockn"));
  825. down(&c->fmc->biglock);
  827. dir_mode = S_IFDIR | (mode & (S_IRWXUGO|S_ISVTX)
  828.       & ~current->fs->umask);
  829. if (dir->i_mode & S_ISGID) {
  830. dir_mode |= S_ISGID;
  831. }
  833. /* Create a node and initialize it as much as needed.  */
  834. if (!(node = jffs_alloc_node())) {
  835. D(printk("jffs_mkdir(): Allocation failed: node == 0n"));
  836. result = -ENOMEM;
  837. goto jffs_mkdir_end;
  838. }
  839. node->data_offset = 0;
  840. node->removed_size = 0;
  842. /* Initialize the raw inode.  */
  843. raw_inode.magic = JFFS_MAGIC_BITMASK;
  844. raw_inode.ino = c->next_ino++;
  845. raw_inode.pino = dir_f->ino;
  846. raw_inode.version = 1;
  847. raw_inode.mode = dir_mode;
  848. raw_inode.uid = current->fsuid;
  849. raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
  850. /* raw_inode.gid = current->fsgid; */
  851. raw_inode.atime = CURRENT_TIME;
  852. raw_inode.mtime = raw_inode.atime;
  853. raw_inode.ctime = raw_inode.atime;
  854. raw_inode.offset = 0;
  855. raw_inode.dsize = 0;
  856. raw_inode.rsize = 0;
  857. raw_inode.nsize = dentry->d_name.len;
  858. raw_inode.nlink = 1;
  859. raw_inode.spare = 0;
  860. raw_inode.rename = 0;
  861. raw_inode.deleted = 0;
  863. /* Write the new node to the flash.  */
  864. if ((result = jffs_write_node(c, node, &raw_inode,
  865.       dentry->d_name.name, 0, 0, NULL)) < 0) {
  866. D(printk("jffs_mkdir(): jffs_write_node() failed.n"));
  867. jffs_free_node(node);
  868. goto jffs_mkdir_end;
  869. }
  871. /* Insert the new node into the file system.  */
  872. if ((result = jffs_insert_node(c, 0, &raw_inode, dentry->d_name.name,
  873.        node)) < 0) {
  874. goto jffs_mkdir_end;
  875. }
  877. inode = jffs_new_inode(dir, &raw_inode, &err);
  878. if (inode == NULL) {
  879. result = err;
  880. goto jffs_mkdir_end;
  881. }
  883. inode->i_op = &jffs_dir_inode_operations;
  884. inode->i_fop = &jffs_dir_operations;
  886. mark_inode_dirty(dir);
  887. d_instantiate(dentry, inode);
  889. result = 0;
  890. jffs_mkdir_end:
  891. D3(printk (KERN_NOTICE "mkdir(): up biglockn"));
  892. up(&c->fmc->biglock);
  893. return result;
  894. } /* jffs_mkdir()  */
  897. /* Remove a directory.  */
  898. static int
  899. jffs_rmdir(struct inode *dir, struct dentry *dentry)
  900. {
  901. struct jffs_control *c = (struct jffs_control *)dir->i_sb->u.generic_sbp;
  902. int ret;
  903. D3(printk("***jffs_rmdir()n"));
  904. D3(printk (KERN_NOTICE "rmdir(): down biglockn"));
  905. down(&c->fmc->biglock);
  906. ret = jffs_remove(dir, dentry, S_IFDIR);
  907. D3(printk (KERN_NOTICE "rmdir(): up biglockn"));
  908. up(&c->fmc->biglock);
  909. return ret;
  910. }
  913. /* Remove any kind of file except for directories.  */
  914. static int
  915. jffs_unlink(struct inode *dir, struct dentry *dentry)
  916. {
  917. struct jffs_control *c = (struct jffs_control *)dir->i_sb->u.generic_sbp;
  918. int ret; 
  920. D3(printk("***jffs_unlink()n"));
  921. D3(printk (KERN_NOTICE "unlink(): down biglockn"));
  922. down(&c->fmc->biglock);
  923. ret = jffs_remove(dir, dentry, 0);
  924. D3(printk (KERN_NOTICE "unlink(): up biglockn"));
  925. up(&c->fmc->biglock);
  926. return ret;
  927. }
  930. /* Remove a JFFS entry, i.e. plain files, directories, etc.  Here we
  931.    shouldn't test for free space on the device.  */
  932. static int
  933. jffs_remove(struct inode *dir, struct dentry *dentry, int type)
  934. {
  935. struct jffs_raw_inode raw_inode;
  936. struct jffs_control *c;
  937. struct jffs_file *dir_f; /* The file-to-remove's parent.  */
  938. struct jffs_file *del_f; /* The file to remove.  */
  939. struct jffs_node *del_node;
  940. struct inode *inode = 0;
  941. int result = 0;
  943. D1({
  944. int len = dentry->d_name.len;
  945. const char *name = dentry->d_name.name;
  946. char *_name = (char *) kmalloc(len + 1, GFP_KERNEL);
  947. memcpy(_name, name, len);
  948. _name[len] = '';
  949. printk("***jffs_remove(): file = "%s", ino = %ldn", _name, dentry->d_inode->i_ino);
  950. kfree(_name);
  951. });
  953. dir_f = (struct jffs_file *) dir->u.generic_ip;
  954. c = dir_f->c;
  956. result = -ENOENT;
  957. if (!(del_f = jffs_find_child(dir_f, dentry->d_name.name,
  958.       dentry->d_name.len))) {
  959. D(printk("jffs_remove(): jffs_find_child() failed.n"));
  960. goto jffs_remove_end;
  961. }
  963. if (S_ISDIR(type)) {
  964. struct jffs_file *child = del_f->children;
  965. while(child) {
  966. if( !child->deleted ) {
  967. result = -ENOTEMPTY;
  968. goto jffs_remove_end;
  969. }
  970. child = child->sibling_next;
  971. }
  972. }            
  973. else if (S_ISDIR(del_f->mode)) {
  974. D(printk("jffs_remove(): node is a directory "
  975.  "but it shouldn't be.n"));
  976. result = -EPERM;
  977. goto jffs_remove_end;
  978. }
  980. inode = dentry->d_inode;
  982. result = -EIO;
  983. if (del_f->ino != inode->i_ino)
  984. goto jffs_remove_end;
  986. if (!inode->i_nlink) {
  987. printk("Deleting nonexistent file inode: %lu, nlink: %dn",
  988.        inode->i_ino, inode->i_nlink);
  989. inode->i_nlink=1;
  990. }
  992. /* Create a node for the deletion.  */
  993. result = -ENOMEM;
  994. if (!(del_node = jffs_alloc_node())) {
  995. D(printk("jffs_remove(): Allocation failed!n"));
  996. goto jffs_remove_end;
  997. }
  998. del_node->data_offset = 0;
  999. del_node->removed_size = 0;
  1001. /* Initialize the raw inode.  */
  1002. raw_inode.magic = JFFS_MAGIC_BITMASK;
  1003. raw_inode.ino = del_f->ino;
  1004. raw_inode.pino = del_f->pino;
  1005. /*   raw_inode.version = del_f->highest_version + 1; */
  1006. raw_inode.mode = del_f->mode;
  1007. raw_inode.uid = current->fsuid;
  1008. raw_inode.gid = current->fsgid;
  1009. raw_inode.atime = CURRENT_TIME;
  1010. raw_inode.mtime = del_f->mtime;
  1011. raw_inode.ctime = raw_inode.atime;
  1012. raw_inode.offset = 0;
  1013. raw_inode.dsize = 0;
  1014. raw_inode.rsize = 0;
  1015. raw_inode.nsize = 0;
  1016. raw_inode.nlink = del_f->nlink;
  1017. raw_inode.spare = 0;
  1018. raw_inode.rename = 0;
  1019. raw_inode.deleted = 1;
  1021. /* Write the new node to the flash memory.  */
  1022. if (jffs_write_node(c, del_node, &raw_inode, 0, 0, 1, del_f) < 0) {
  1023. jffs_free_node(del_node);
  1024. result = -EIO;
  1025. goto jffs_remove_end;
  1026. }
  1028. /* Update the file.  This operation will make the file disappear
  1029.    from the in-memory file system structures.  */
  1030. jffs_insert_node(c, del_f, &raw_inode, 0, del_node);
  1032. dir->i_version = ++event;
  1033. dir->i_ctime = dir->i_mtime = CURRENT_TIME;
  1034. mark_inode_dirty(dir);
  1035. inode->i_nlink--;
  1036. inode->i_ctime = dir->i_ctime;
  1037. mark_inode_dirty(inode);
  1039. d_delete(dentry); /* This also frees the inode */
  1041. result = 0;
  1042. jffs_remove_end:
  1043. return result;
  1044. } /* jffs_remove()  */
  1047. static int
  1048. jffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int rdev)
  1049. {
  1050. struct jffs_raw_inode raw_inode;
  1051. struct jffs_file *dir_f;
  1052. struct jffs_node *node = 0;
  1053. struct jffs_control *c;
  1054. struct inode *inode;
  1055. int result = 0;
  1056. kdev_t dev = to_kdev_t(rdev);
  1057. int err;
  1059. D1(printk("***jffs_mknod()n"));
  1061. dir_f = (struct jffs_file *)dir->u.generic_ip;
  1062. c = dir_f->c;
  1064. D3(printk (KERN_NOTICE "mknod(): down biglockn"));
  1065. down(&c->fmc->biglock);
  1067. /* Create and initialize a new node.  */
  1068. if (!(node = jffs_alloc_node())) {
  1069. D(printk("jffs_mknod(): Allocation failed!n"));
  1070. result = -ENOMEM;
  1071. goto jffs_mknod_err;
  1072. }
  1073. node->data_offset = 0;
  1074. node->removed_size = 0;
  1076. /* Initialize the raw inode.  */
  1077. raw_inode.magic = JFFS_MAGIC_BITMASK;
  1078. raw_inode.ino = c->next_ino++;
  1079. raw_inode.pino = dir_f->ino;
  1080. raw_inode.version = 1;
  1081. raw_inode.mode = mode;
  1082. raw_inode.uid = current->fsuid;
  1083. raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
  1084. /* raw_inode.gid = current->fsgid; */
  1085. raw_inode.atime = CURRENT_TIME;
  1086. raw_inode.mtime = raw_inode.atime;
  1087. raw_inode.ctime = raw_inode.atime;
  1088. raw_inode.offset = 0;
  1089. raw_inode.dsize = sizeof(kdev_t);
  1090. raw_inode.rsize = 0;
  1091. raw_inode.nsize = dentry->d_name.len;
  1092. raw_inode.nlink = 1;
  1093. raw_inode.spare = 0;
  1094. raw_inode.rename = 0;
  1095. raw_inode.deleted = 0;
  1097. /* Write the new node to the flash.  */
  1098. if ((err = jffs_write_node(c, node, &raw_inode, dentry->d_name.name,
  1099.    (unsigned char *)&dev, 0, NULL)) < 0) {
  1100. D(printk("jffs_mknod(): jffs_write_node() failed.n"));
  1101. result = err;
  1102. goto jffs_mknod_err;
  1103. }
  1105. /* Insert the new node into the file system.  */
  1106. if ((err = jffs_insert_node(c, 0, &raw_inode, dentry->d_name.name,
  1107.     node)) < 0) {
  1108. result = err;
  1109. goto jffs_mknod_end;
  1110. }
  1112. inode = jffs_new_inode(dir, &raw_inode, &err);
  1113. if (inode == NULL) {
  1114. result = err;
  1115. goto jffs_mknod_end;
  1116. }
  1118. init_special_inode(inode, mode, rdev);
  1120. d_instantiate(dentry, inode);
  1122. goto jffs_mknod_end;
  1124. jffs_mknod_err:
  1125. if (node) {
  1126. jffs_free_node(node);
  1127. }
  1129. jffs_mknod_end:
  1130. D3(printk (KERN_NOTICE "mknod(): up biglockn"));
  1131. up(&c->fmc->biglock);
  1132. return result;
  1133. } /* jffs_mknod()  */
  1136. static int
  1137. jffs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
  1138. {
  1139. struct jffs_raw_inode raw_inode;
  1140. struct jffs_control *c;
  1141. struct jffs_file *dir_f;
  1142. struct jffs_node *node;
  1143. struct inode *inode;
  1145. int symname_len = strlen(symname);
  1146. int err;
  1148. D1({
  1149. int len = dentry->d_name.len; 
  1150. char *_name = (char *)kmalloc(len + 1, GFP_KERNEL);
  1151. char *_symname = (char *)kmalloc(symname_len + 1, GFP_KERNEL);
  1152. memcpy(_name, dentry->d_name.name, len);
  1153. _name[len] = '';
  1154. memcpy(_symname, symname, symname_len);
  1155. _symname[symname_len] = '';
  1156. printk("***jffs_symlink(): dir = 0x%p, "
  1157.        "dentry->dname.name = "%s", "
  1158.        "symname = "%s"n", dir, _name, _symname);
  1159. kfree(_name);
  1160. kfree(_symname);
  1161. });
  1163. dir_f = (struct jffs_file *)dir->u.generic_ip;
  1164. ASSERT(if (!dir_f) {
  1165. printk(KERN_ERR "jffs_symlink(): No reference to a "
  1166.        "jffs_file struct in inode.n");
  1167. return -EIO;
  1168. });
  1170. c = dir_f->c;
  1172. /* Create a node and initialize it as much as needed.  */
  1173. if (!(node = jffs_alloc_node())) {
  1174. D(printk("jffs_symlink(): Allocation failed: node = NULLn"));
  1175. return -ENOMEM;
  1176. }
  1177. D3(printk (KERN_NOTICE "symlink(): down biglockn"));
  1178. down(&c->fmc->biglock);
  1180. node->data_offset = 0;
  1181. node->removed_size = 0;
  1183. /* Initialize the raw inode.  */
  1184. raw_inode.magic = JFFS_MAGIC_BITMASK;
  1185. raw_inode.ino = c->next_ino++;
  1186. raw_inode.pino = dir_f->ino;
  1187. raw_inode.version = 1;
  1188. raw_inode.mode = S_IFLNK | S_IRWXUGO;
  1189. raw_inode.uid = current->fsuid;
  1190. raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
  1191. raw_inode.atime = CURRENT_TIME;
  1192. raw_inode.mtime = raw_inode.atime;
  1193. raw_inode.ctime = raw_inode.atime;
  1194. raw_inode.offset = 0;
  1195. raw_inode.dsize = symname_len;
  1196. raw_inode.rsize = 0;
  1197. raw_inode.nsize = dentry->d_name.len;
  1198. raw_inode.nlink = 1;
  1199. raw_inode.spare = 0;
  1200. raw_inode.rename = 0;
  1201. raw_inode.deleted = 0;
  1203. /* Write the new node to the flash.  */
  1204. if ((err = jffs_write_node(c, node, &raw_inode, dentry->d_name.name,
  1205.    (const unsigned char *)symname, 0, NULL)) < 0) {
  1206. D(printk("jffs_symlink(): jffs_write_node() failed.n"));
  1207. jffs_free_node(node);
  1208. goto jffs_symlink_end;
  1209. }
  1211. /* Insert the new node into the file system.  */
  1212. if ((err = jffs_insert_node(c, 0, &raw_inode, dentry->d_name.name,
  1213.     node)) < 0) {
  1214. goto jffs_symlink_end;
  1215. }
  1217. inode = jffs_new_inode(dir, &raw_inode, &err);
  1218. if (inode == NULL) {
  1219. goto jffs_symlink_end;
  1220. }
  1221. err = 0;
  1222. inode->i_op = &page_symlink_inode_operations;
  1223. inode->i_mapping->a_ops = &jffs_address_operations;
  1225. d_instantiate(dentry, inode);
  1226.  jffs_symlink_end:
  1227. D3(printk (KERN_NOTICE "symlink(): up biglockn"));
  1228. up(&c->fmc->biglock);
  1229. return err;
  1230. } /* jffs_symlink()  */
  1233. /* Create an inode inside a JFFS directory (dir) and return it.
  1234.  *
  1235.  * By the time this is called, we already have created
  1236.  * the directory cache entry for the new file, but it
  1237.  * is so far negative - it has no inode.
  1238.  *
  1239.  * If the create succeeds, we fill in the inode information
  1240.  * with d_instantiate().
  1241.  */
  1242. static int
  1243. jffs_create(struct inode *dir, struct dentry *dentry, int mode)
  1244. {
  1245. struct jffs_raw_inode raw_inode;
  1246. struct jffs_control *c;
  1247. struct jffs_node *node;
  1248. struct jffs_file *dir_f; /* JFFS representation of the directory.  */
  1249. struct inode *inode;
  1250. int err;
  1252. D1({
  1253. int len = dentry->d_name.len;
  1254. char *s = (char *)kmalloc(len + 1, GFP_KERNEL);
  1255. memcpy(s, dentry->d_name.name, len);
  1256. s[len] = '';
  1257. printk("jffs_create(): dir: 0x%p, name: "%s"n", dir, s);
  1258. kfree(s);
  1259. });
  1261. dir_f = (struct jffs_file *)dir->u.generic_ip;
  1262. ASSERT(if (!dir_f) {
  1263. printk(KERN_ERR "jffs_create(): No reference to a "
  1264.        "jffs_file struct in inode.n");
  1265. return -EIO;
  1266. });
  1268. c = dir_f->c;
  1270. /* Create a node and initialize as much as needed.  */
  1271. if (!(node = jffs_alloc_node())) {
  1272. D(printk("jffs_create(): Allocation failed: node == 0n"));
  1273. return -ENOMEM;
  1274. }
  1275. D3(printk (KERN_NOTICE "create(): down biglockn"));
  1276. down(&c->fmc->biglock);
  1278. node->data_offset = 0;
  1279. node->removed_size = 0;
  1281. /* Initialize the raw inode.  */
  1282. raw_inode.magic = JFFS_MAGIC_BITMASK;
  1283. raw_inode.ino = c->next_ino++;
  1284. raw_inode.pino = dir_f->ino;
  1285. raw_inode.version = 1;
  1286. raw_inode.mode = mode;
  1287. raw_inode.uid = current->fsuid;
  1288. raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
  1289. raw_inode.atime = CURRENT_TIME;
  1290. raw_inode.mtime = raw_inode.atime;
  1291. raw_inode.ctime = raw_inode.atime;
  1292. raw_inode.offset = 0;
  1293. raw_inode.dsize = 0;
  1294. raw_inode.rsize = 0;
  1295. raw_inode.nsize = dentry->d_name.len;
  1296. raw_inode.nlink = 1;
  1297. raw_inode.spare = 0;
  1298. raw_inode.rename = 0;
  1299. raw_inode.deleted = 0;
  1301. /* Write the new node to the flash.  */
  1302. if ((err = jffs_write_node(c, node, &raw_inode,
  1303.    dentry->d_name.name, 0, 0, NULL)) < 0) {
  1304. D(printk("jffs_create(): jffs_write_node() failed.n"));
  1305. jffs_free_node(node);
  1306. goto jffs_create_end;
  1307. }
  1309. /* Insert the new node into the file system.  */
  1310. if ((err = jffs_insert_node(c, 0, &raw_inode, dentry->d_name.name,
  1311.     node)) < 0) {
  1312. goto jffs_create_end;
  1313. }
  1315. /* Initialize an inode.  */
  1316. inode = jffs_new_inode(dir, &raw_inode, &err);
  1317. if (inode == NULL) {
  1318. goto jffs_create_end;
  1319. }
  1320. err = 0;
  1321. inode->i_op = &jffs_file_inode_operations;
  1322. inode->i_fop = &jffs_file_operations;
  1323. inode->i_mapping->a_ops = &jffs_address_operations;
  1324. inode->i_mapping->nrpages = 0;
  1326. d_instantiate(dentry, inode);
  1327.  jffs_create_end:
  1328. D3(printk (KERN_NOTICE "create(): up biglockn"));
  1329. up(&c->fmc->biglock);
  1330. return err;
  1331. } /* jffs_create()  */
  1334. /* Write, append or rewrite data to an existing file.  */
  1335. static ssize_t
  1336. jffs_file_write(struct file *filp, const char *buf, size_t count,
  1337. loff_t *ppos)
  1338. {
  1339. struct jffs_raw_inode raw_inode;
  1340. struct jffs_control *c;
  1341. struct jffs_file *f;
  1342. struct jffs_node *node;
  1343. struct dentry *dentry = filp->f_dentry;
  1344. struct inode *inode = dentry->d_inode;
  1345. int recoverable = 0;
  1346. size_t written = 0;
  1347. __u32 thiscount = count;
  1348. loff_t pos = *ppos;
  1349. int err;
  1351. inode = filp->f_dentry->d_inode;
  1353. D2(printk("***jffs_file_write(): inode: 0x%p (ino: %lu), "
  1354.   "filp: 0x%p, buf: 0x%p, count: %dn",
  1355.   inode, inode->i_ino, filp, buf, count));
  1357. #if 0
  1358. if (inode->i_sb->s_flags & MS_RDONLY) {
  1359. D(printk("jffs_file_write(): MS_RDONLYn"));
  1360. err = -EROFS;
  1361. goto out_isem;
  1362. }
  1363. #endif
  1364. err = -EINVAL;
  1366. if (!S_ISREG(inode->i_mode)) {
  1367. D(printk("jffs_file_write(): inode->i_mode == 0x%08xn",
  1368. inode->i_mode));
  1369. goto out_isem;
  1370. }
  1372. if (!(f = (struct jffs_file *)inode->u.generic_ip)) {
  1373. D(printk("jffs_file_write(): inode->u.generic_ip = 0x%pn",
  1374. inode->u.generic_ip));
  1375. goto out_isem;
  1376. }
  1378. c = f->c;
  1380. /*
  1381.  * This will never trigger with sane page sizes.  leave it in
  1382.  * anyway, since I'm thinking about how to merge larger writes
  1383.  * (the current idea is to poke a thread that does the actual
  1384.  * I/O and starts by doing a down(&inode->i_sem).  then we
  1385.  * would need to get the page cache pages and have a list of
  1386.  * I/O requests and do write-merging here.
  1387.  * -- prumpf
  1388.  */
  1389. thiscount = min(c->fmc->max_chunk_size - sizeof(struct jffs_raw_inode), count);
  1391. D3(printk (KERN_NOTICE "file_write(): down biglockn"));
  1392. down(&c->fmc->biglock);
  1394. /* Urgh. POSIX says we can do short writes if we feel like it. 
  1395.  * In practice, we can't. Nothing will cope. So we loop until
  1396.  * we're done.
  1397.  *
  1398.  * <_Anarchy_> posix and reality are not interconnected on this issue
  1399.  */
  1400. while (count) {
  1401. /* Things are going to be written so we could allocate and
  1402.    initialize the necessary data structures now.  */
  1403. if (!(node = jffs_alloc_node())) {
  1404. D(printk("jffs_file_write(): node == 0n"));
  1405. err = -ENOMEM;
  1406. goto out;
  1407. }
  1409. node->data_offset = pos;
  1410. node->removed_size = 0;
  1412. /* Initialize the raw inode.  */
  1413. raw_inode.magic = JFFS_MAGIC_BITMASK;
  1414. raw_inode.ino = f->ino;
  1415. raw_inode.pino = f->pino;
  1417. raw_inode.mode = f->mode;
  1419. raw_inode.uid = f->uid;
  1420. raw_inode.gid = f->gid;
  1421. raw_inode.atime = CURRENT_TIME;
  1422. raw_inode.mtime = raw_inode.atime;
  1423. raw_inode.ctime = f->ctime;
  1424. raw_inode.offset = pos;
  1425. raw_inode.dsize = thiscount;
  1426. raw_inode.rsize = 0;
  1427. raw_inode.nsize = f->nsize;
  1428. raw_inode.nlink = f->nlink;
  1429. raw_inode.spare = 0;
  1430. raw_inode.rename = 0;
  1431. raw_inode.deleted = 0;
  1433. if (pos < f->size) {
  1434. node->removed_size = raw_inode.rsize = min(thiscount, (__u32)(f->size - pos));
  1436. /* If this node is going entirely over the top of old data,
  1437.    we can allow it to go into the reserved space, because
  1438.    we know that GC can reclaim the space later.
  1439. */
  1440. if (pos + thiscount < f->size) {
  1441. /* If all the data we're overwriting are _real_,
  1442.    not just holes, then:
  1443.    recoverable = 1;
  1444. */
  1445. }
  1446. }
  1448. /* Write the new node to the flash.  */
  1449. /* NOTE: We would be quite happy if jffs_write_node() wrote a
  1450.    smaller node than we were expecting. There's no need for it
  1451.    to waste the space at the end of the flash just because it's
  1452.    a little smaller than what we asked for. But that's a whole
  1453.    new can of worms which I'm not going to open this week. 
  1454.    -- dwmw2.
  1455. */
  1456. if ((err = jffs_write_node(c, node, &raw_inode, f->name,
  1457.    (const unsigned char *)buf,
  1458.    recoverable, f)) < 0) {
  1459. D(printk("jffs_file_write(): jffs_write_node() failed.n"));
  1460. jffs_free_node(node);
  1461. goto out;
  1462. }
  1464. written += err;
  1465. buf += err;
  1466. count -= err;
  1467. pos += err;
  1469. /* Insert the new node into the file system.  */
  1470. if ((err = jffs_insert_node(c, f, &raw_inode, 0, node)) < 0) {
  1471. goto out;
  1472. }
  1474. D3(printk("jffs_file_write(): new f_pos %ld.n", (long)pos));
  1476. thiscount = min(c->fmc->max_chunk_size - sizeof(struct jffs_raw_inode), count);
  1477. }
  1478.  out:
  1479. D3(printk (KERN_NOTICE "file_write(): up biglockn"));
  1480. up(&c->fmc->biglock);
  1482. /* Fix things in the real inode.  */
  1483. if (pos > inode->i_size) {
  1484. inode->i_size = pos;
  1485. inode->i_blocks = (inode->i_size + 511) >> 9;
  1486. }
  1487. inode->i_ctime = inode->i_mtime = CURRENT_TIME;
  1488. mark_inode_dirty(inode);
  1489. invalidate_inode_pages(inode);
  1491.  out_isem:
  1492. return err;
  1493. } /* jffs_file_write()  */
  1495. static ssize_t
  1496. jffs_prepare_write(struct file *filp, struct page *page,
  1497.                   unsigned from, unsigned to)
  1498. {
  1499. /* FIXME: we should detect some error conditions here */
  1501. /* Bugger that. We should make sure the page is uptodate */
  1502. if (!Page_Uptodate(page) && (from || to < PAGE_CACHE_SIZE))
  1503. return jffs_do_readpage_nolock(filp, page);
  1505. return 0;
  1506. } /* jffs_prepare_write() */
  1508. static ssize_t
  1509. jffs_commit_write(struct file *filp, struct page *page,
  1510.                  unsigned from, unsigned to)
  1511. {
  1512.        void *addr = page_address(page) + from;
  1513.        /* XXX: PAGE_CACHE_SHIFT or PAGE_SHIFT */
  1514.        loff_t pos = (page->index<<PAGE_CACHE_SHIFT) + from;
  1516.        return jffs_file_write(filp, addr, to-from, &pos);
  1517. } /* jffs_commit_write() */
  1519. /* This is our ioctl() routine.  */
  1520. static int
  1521. jffs_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
  1522.    unsigned long arg)
  1523. {
  1524. struct jffs_control *c;
  1525. int ret = 0;
  1527. D2(printk("***jffs_ioctl(): cmd = 0x%08x, arg = 0x%08lxn",
  1528.   cmd, arg));
  1530. if (!(c = (struct jffs_control *)inode->i_sb->u.generic_sbp)) {
  1531. printk(KERN_ERR "JFFS: Bad inode in ioctl() call. "
  1532.        "(cmd = 0x%08x)n", cmd);
  1533. return -EIO;
  1534. }
  1535. D3(printk (KERN_NOTICE "ioctl(): down biglockn"));
  1536. down(&c->fmc->biglock);
  1538. switch (cmd) {
  1539. case JFFS_PRINT_HASH:
  1540. jffs_print_hash_table(c);
  1541. break;
  1542. case JFFS_PRINT_TREE:
  1543. jffs_print_tree(c->root, 0);
  1544. break;
  1545. case JFFS_GET_STATUS:
  1546. {
  1547. struct jffs_flash_status fst;
  1548. struct jffs_fmcontrol *fmc = c->fmc;
  1549. printk("Flash status -- ");
  1550. if (!access_ok(VERIFY_WRITE,
  1551.        (struct jffs_flash_status *)arg,
  1552.        sizeof(struct jffs_flash_status))) {
  1553. D(printk("jffs_ioctl(): Bad arg in "
  1554.  "JFFS_GET_STATUS ioctl!n"));
  1555. ret = -EFAULT;
  1556. break;
  1557. }
  1558. fst.size = fmc->flash_size;
  1559. fst.used = fmc->used_size;
  1560. fst.dirty = fmc->dirty_size;
  1561. fst.begin = fmc->head->offset;
  1562. fst.end = fmc->tail->offset + fmc->tail->size;
  1563. printk("size: %d, used: %d, dirty: %d, "
  1564.        "begin: %d, end: %dn",
  1565.        fst.size, fst.used, fst.dirty,
  1566.        fst.begin, fst.end);
  1567. if (copy_to_user((struct jffs_flash_status *)arg,
  1568.  &fst,
  1569.  sizeof(struct jffs_flash_status))) {
  1570. ret = -EFAULT;
  1571. }
  1572. }
  1573. break;
  1574. default:
  1575. ret = -ENOTTY;
  1576. }
  1577. D3(printk (KERN_NOTICE "ioctl(): up biglockn"));
  1578. up(&c->fmc->biglock);
  1579. return ret;
  1580. } /* jffs_ioctl()  */
  1583. static struct address_space_operations jffs_address_operations = {
  1584. readpage: jffs_readpage,
  1585. prepare_write: jffs_prepare_write,
  1586. commit_write: jffs_commit_write,
  1587. };
  1589. static int jffs_fsync(struct file *f, struct dentry *d, int datasync)
  1590. {
  1591. /* We currently have O_SYNC operations at all times.
  1592.    Do nothing.
  1593. */
  1594. return 0;
  1595. }
  1598. extern int generic_file_open(struct inode *, struct file *) __attribute__((weak));
  1599. extern loff_t generic_file_llseek(struct file *, loff_t, int) __attribute__((weak));
  1601. static struct file_operations jffs_file_operations =
  1602. {
  1603. open: generic_file_open,
  1604. llseek: generic_file_llseek,
  1605. read: generic_file_read,
  1606. write: generic_file_write,
  1607. ioctl: jffs_ioctl,
  1608. mmap: generic_file_mmap,
  1609. fsync: jffs_fsync,
  1610. };
  1613. static struct inode_operations jffs_file_inode_operations =
  1614. {
  1615. lookup:  jffs_lookup,          /* lookup */
  1616. setattr: jffs_setattr,
  1617. };
  1620. static struct file_operations jffs_dir_operations =
  1621. {
  1622. readdir: jffs_readdir,
  1623. };
  1626. static struct inode_operations jffs_dir_inode_operations =
  1627. {
  1628. create:   jffs_create,
  1629. lookup:   jffs_lookup,
  1630. unlink:   jffs_unlink,
  1631. symlink:  jffs_symlink,
  1632. mkdir:    jffs_mkdir,
  1633. rmdir:    jffs_rmdir,
  1634. mknod:    jffs_mknod,
  1635. rename:   jffs_rename,
  1636. setattr:  jffs_setattr,
  1637. };
  1640. /* Initialize an inode for the VFS.  */
  1641. static void
  1642. jffs_read_inode(struct inode *inode)
  1643. {
  1644. struct jffs_file *f;
  1645. struct jffs_control *c;
  1647. D3(printk("jffs_read_inode(): inode->i_ino == %lun", inode->i_ino));
  1649. if (!inode->i_sb) {
  1650. D(printk("jffs_read_inode(): !inode->i_sb ==> "
  1651.  "No super block!n"));
  1652. return;
  1653. }
  1654. c = (struct jffs_control *)inode->i_sb->u.generic_sbp;
  1655. D3(printk (KERN_NOTICE "read_inode(): down biglockn"));
  1656. down(&c->fmc->biglock);
  1657. if (!(f = jffs_find_file(c, inode->i_ino))) {
  1658. D(printk("jffs_read_inode(): No such inode (%lu).n",
  1659.  inode->i_ino));
  1660. D3(printk (KERN_NOTICE "read_inode(): up biglockn"));
  1661. up(&c->fmc->biglock);
  1662. return;
  1663. }
  1664. inode->u.generic_ip = (void *)f;
  1665. inode->i_mode = f->mode;
  1666. inode->i_nlink = f->nlink;
  1667. inode->i_uid = f->uid;
  1668. inode->i_gid = f->gid;
  1669. inode->i_size = f->size;
  1670. inode->i_atime = f->atime;
  1671. inode->i_mtime = f->mtime;
  1672. inode->i_ctime = f->ctime;
  1673. inode->i_blksize = PAGE_SIZE;
  1674. inode->i_blocks = (inode->i_size + 511) >> 9;
  1675. if (S_ISREG(inode->i_mode)) {
  1676. inode->i_op = &jffs_file_inode_operations;
  1677. inode->i_fop = &jffs_file_operations;
  1678. inode->i_mapping->a_ops = &jffs_address_operations;
  1679. }
  1680. else if (S_ISDIR(inode->i_mode)) {
  1681. inode->i_op = &jffs_dir_inode_operations;
  1682. inode->i_fop = &jffs_dir_operations;
  1683. }
  1684. else if (S_ISLNK(inode->i_mode)) {
  1685. inode->i_op = &page_symlink_inode_operations;
  1686. inode->i_mapping->a_ops = &jffs_address_operations;
  1687. }
  1688. else {
  1689. /* If the node is a device of some sort, then the number of
  1690.    the device should be read from the flash memory and then
  1691.    added to the inode's i_rdev member.  */
  1692. kdev_t rdev;
  1693. jffs_read_data(f, (char *)&rdev, 0, sizeof(kdev_t));
  1694. init_special_inode(inode, inode->i_mode, kdev_t_to_nr(rdev));
  1695. }
  1697. D3(printk (KERN_NOTICE "read_inode(): up biglockn"));
  1698. up(&c->fmc->biglock);
  1699. }
  1702. void
  1703. jffs_delete_inode(struct inode *inode)
  1704. {
  1705. struct jffs_file *f;
  1706. struct jffs_control *c;
  1707. D3(printk("jffs_delete_inode(): inode->i_ino == %lun",
  1708.   inode->i_ino));
  1710. lock_kernel();
  1711. inode->i_size = 0;
  1712. inode->i_blocks = 0;
  1713. inode->u.generic_ip = 0;
  1714. clear_inode(inode);
  1715. if (inode->i_nlink == 0) {
  1716. c = (struct jffs_control *) inode->i_sb->u.generic_sbp;
  1717. f = (struct jffs_file *) jffs_find_file (c, inode->i_ino);
  1718. jffs_possibly_delete_file(f);
  1719. }
  1721. unlock_kernel();
  1722. }
  1725. void
  1726. jffs_write_super(struct super_block *sb)
  1727. {
  1728. struct jffs_control *c = (struct jffs_control *)sb->u.generic_sbp;
  1730. jffs_garbage_collect_trigger(c);
  1731. }
  1733. static struct super_operations jffs_ops =
  1734. {
  1735. read_inode:   jffs_read_inode,
  1736. delete_inode: jffs_delete_inode,
  1737. put_super:    jffs_put_super,
  1738. write_super:  jffs_write_super,
  1739. statfs:       jffs_statfs,
  1740. };
  1743. static DECLARE_FSTYPE_DEV(jffs_fs_type, "jffs", jffs_read_super);
  1745. static int __init
  1746. init_jffs_fs(void)
  1747. {
  1748. printk(KERN_INFO "JFFS version " JFFS_VERSION_STRING
  1749. ", (C) 1999, 2000  Axis Communications ABn");
  1751. #ifdef CONFIG_JFFS_PROC_FS
  1752. jffs_proc_root = proc_mkdir("jffs", proc_root_fs);
  1753. #endif
  1754. fm_cache = kmem_cache_create("jffs_fm", sizeof(struct jffs_fm),
  1755.      0, SLAB_HWCACHE_ALIGN, NULL, NULL);
  1756. node_cache = kmem_cache_create("jffs_node",sizeof(struct jffs_node),
  1757.        0, SLAB_HWCACHE_ALIGN, NULL, NULL);
  1758. return register_filesystem(&jffs_fs_type);
  1759. }
  1761. static void __exit
  1762. exit_jffs_fs(void)
  1763. {
  1764. unregister_filesystem(&jffs_fs_type);
  1765. kmem_cache_destroy(fm_cache);
  1766. kmem_cache_destroy(node_cache);
  1767. }
  1769. EXPORT_NO_SYMBOLS;
  1771. module_init(init_jffs_fs)
  1772. module_exit(exit_jffs_fs)
  1774. MODULE_DESCRIPTION("The Journalling Flash File System");
  1775. MODULE_AUTHOR("Axis Communications AB.");
  1776. MODULE_LICENSE("GPL");