file.c 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299
  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: file.c,v 1.1.1.1 2007/06/12 07:27:13 eyryu Exp $
  11. *
  12. */
  13. #include <linux/kernel.h>
  14. #include <linux/slab.h>
  15. #include <linux/fs.h>
  16. #include <linux/time.h>
  17. #include <linux/pagemap.h>
  18. #include <linux/highmem.h>
  19. #include <linux/crc32.h>
  20. #include <linux/jffs2.h>
  21. #include "nodelist.h"
  22. static int jffs2_commit_write (struct file *filp, struct page *pg,
  23. unsigned start, unsigned end);
  24. static int jffs2_prepare_write (struct file *filp, struct page *pg,
  25. unsigned start, unsigned end);
  26. static int jffs2_readpage (struct file *filp, struct page *pg);
  27. int jffs2_fsync(struct file *filp, struct dentry *dentry, int datasync)
  28. {
  29. struct inode *inode = dentry->d_inode;
  30. struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  31. /* Trigger GC to flush any pending writes for this inode */
  32. jffs2_flush_wbuf_gc(c, inode->i_ino);
  33. return 0;
  34. }
  35. const struct file_operations jffs2_file_operations =
  36. {
  37. .llseek = generic_file_llseek,
  38. .open = generic_file_open,
  39. .read = do_sync_read,
  40. .aio_read = generic_file_aio_read,
  41. .write = do_sync_write,
  42. .aio_write = generic_file_aio_write,
  43. .ioctl = jffs2_ioctl,
  44. .mmap = generic_file_readonly_mmap,
  45. .fsync = jffs2_fsync,
  46. .sendfile = generic_file_sendfile
  47. };
  48. /* jffs2_file_inode_operations */
  49. const struct inode_operations jffs2_file_inode_operations =
  50. {
  51. .permission = jffs2_permission,
  52. .setattr = jffs2_setattr,
  53. .setxattr = jffs2_setxattr,
  54. .getxattr = jffs2_getxattr,
  55. .listxattr = jffs2_listxattr,
  56. .removexattr = jffs2_removexattr
  57. };
  58. const struct address_space_operations jffs2_file_address_operations =
  59. {
  60. .readpage = jffs2_readpage,
  61. .prepare_write =jffs2_prepare_write,
  62. .commit_write = jffs2_commit_write
  63. };
  64. static int jffs2_do_readpage_nolock (struct inode *inode, struct page *pg)
  65. {
  66. struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  67. struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  68. unsigned char *pg_buf;
  69. int ret;
  70. D2(printk(KERN_DEBUG "jffs2_do_readpage_nolock(): ino #%lu, page at offset 0x%lx\n", inode->i_ino, pg->index << PAGE_CACHE_SHIFT));
  71. BUG_ON(!PageLocked(pg));
  72. pg_buf = kmap(pg);
  73. /* FIXME: Can kmap fail? */
  74. ret = jffs2_read_inode_range(c, f, pg_buf, pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE);
  75. if (ret) {
  76. ClearPageUptodate(pg);
  77. SetPageError(pg);
  78. } else {
  79. SetPageUptodate(pg);
  80. ClearPageError(pg);
  81. }
  82. flush_dcache_page(pg);
  83. kunmap(pg);
  84. D2(printk(KERN_DEBUG "readpage finished\n"));
  85. return 0;
  86. }
  87. int jffs2_do_readpage_unlock(struct inode *inode, struct page *pg)
  88. {
  89. int ret = jffs2_do_readpage_nolock(inode, pg);
  90. unlock_page(pg);
  91. return ret;
  92. }
  93. static int jffs2_readpage (struct file *filp, struct page *pg)
  94. {
  95. struct jffs2_inode_info *f = JFFS2_INODE_INFO(pg->mapping->host);
  96. int ret;
  97. down(&f->sem);
  98. ret = jffs2_do_readpage_unlock(pg->mapping->host, pg);
  99. up(&f->sem);
  100. return ret;
  101. }
  102. static int jffs2_prepare_write (struct file *filp, struct page *pg,
  103. unsigned start, unsigned end)
  104. {
  105. struct inode *inode = pg->mapping->host;
  106. struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  107. uint32_t pageofs = pg->index << PAGE_CACHE_SHIFT;
  108. int ret = 0;
  109. D1(printk(KERN_DEBUG "jffs2_prepare_write()\n"));
  110. if (pageofs > inode->i_size) {
  111. /* Make new hole frag from old EOF to new page */
  112. struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  113. struct jffs2_raw_inode ri;
  114. struct jffs2_full_dnode *fn;
  115. uint32_t alloc_len;
  116. D1(printk(KERN_DEBUG "Writing new hole frag 0x%x-0x%x between current EOF and new page\n",
  117. (unsigned int)inode->i_size, pageofs));
  118. ret = jffs2_reserve_space(c, sizeof(ri), &alloc_len,
  119. ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
  120. if (ret)
  121. return ret;
  122. down(&f->sem);
  123. memset(&ri, 0, sizeof(ri));
  124. ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
  125. ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
  126. ri.totlen = cpu_to_je32(sizeof(ri));
  127. ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
  128. ri.ino = cpu_to_je32(f->inocache->ino);
  129. ri.version = cpu_to_je32(++f->highest_version);
  130. ri.mode = cpu_to_jemode(inode->i_mode);
  131. ri.uid = cpu_to_je16(inode->i_uid);
  132. ri.gid = cpu_to_je16(inode->i_gid);
  133. ri.isize = cpu_to_je32(max((uint32_t)inode->i_size, pageofs));
  134. ri.atime = ri.ctime = ri.mtime = cpu_to_je32(get_seconds());
  135. ri.offset = cpu_to_je32(inode->i_size);
  136. ri.dsize = cpu_to_je32(pageofs - inode->i_size);
  137. ri.csize = cpu_to_je32(0);
  138. ri.compr = JFFS2_COMPR_ZERO;
  139. ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
  140. ri.data_crc = cpu_to_je32(0);
  141. fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_NORMAL);
  142. if (IS_ERR(fn)) {
  143. ret = PTR_ERR(fn);
  144. jffs2_complete_reservation(c);
  145. up(&f->sem);
  146. return ret;
  147. }
  148. ret = jffs2_add_full_dnode_to_inode(c, f, fn);
  149. if (f->metadata) {
  150. jffs2_mark_node_obsolete(c, f->metadata->raw);
  151. jffs2_free_full_dnode(f->metadata);
  152. f->metadata = NULL;
  153. }
  154. if (ret) {
  155. D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in prepare_write, returned %d\n", ret));
  156. jffs2_mark_node_obsolete(c, fn->raw);
  157. jffs2_free_full_dnode(fn);
  158. jffs2_complete_reservation(c);
  159. up(&f->sem);
  160. return ret;
  161. }
  162. jffs2_complete_reservation(c);
  163. inode->i_size = pageofs;
  164. up(&f->sem);
  165. }
  166. /* Read in the page if it wasn't already present, unless it's a whole page */
  167. if (!PageUptodate(pg) && (start || end < PAGE_CACHE_SIZE)) {
  168. down(&f->sem);
  169. ret = jffs2_do_readpage_nolock(inode, pg);
  170. up(&f->sem);
  171. }
  172. D1(printk(KERN_DEBUG "end prepare_write(). pg->flags %lx\n", pg->flags));
  173. return ret;
  174. }
  175. static int jffs2_commit_write (struct file *filp, struct page *pg,
  176. unsigned start, unsigned end)
  177. {
  178. /* Actually commit the write from the page cache page we're looking at.
  179. * For now, we write the full page out each time. It sucks, but it's simple
  180. */
  181. struct inode *inode = pg->mapping->host;
  182. struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  183. struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
  184. struct jffs2_raw_inode *ri;
  185. unsigned aligned_start = start & ~3;
  186. int ret = 0;
  187. uint32_t writtenlen = 0;
  188. D1(printk(KERN_DEBUG "jffs2_commit_write(): ino #%lu, page at 0x%lx, range %d-%d, flags %lx\n",
  189. inode->i_ino, pg->index << PAGE_CACHE_SHIFT, start, end, pg->flags));
  190. if (end == PAGE_CACHE_SIZE) {
  191. if (!start) {
  192. /* We need to avoid deadlock with page_cache_read() in
  193. jffs2_garbage_collect_pass(). So we have to mark the
  194. page up to date, to prevent page_cache_read() from
  195. trying to re-lock it. */
  196. SetPageUptodate(pg);
  197. } else {
  198. /* When writing out the end of a page, write out the
  199. _whole_ page. This helps to reduce the number of
  200. nodes in files which have many short writes, like
  201. syslog files. */
  202. start = aligned_start = 0;
  203. }
  204. }
  205. ri = jffs2_alloc_raw_inode();
  206. if (!ri) {
  207. D1(printk(KERN_DEBUG "jffs2_commit_write(): Allocation of raw inode failed\n"));
  208. return -ENOMEM;
  209. }
  210. /* Set the fields that the generic jffs2_write_inode_range() code can't find */
  211. ri->ino = cpu_to_je32(inode->i_ino);
  212. ri->mode = cpu_to_jemode(inode->i_mode);
  213. ri->uid = cpu_to_je16(inode->i_uid);
  214. ri->gid = cpu_to_je16(inode->i_gid);
  215. ri->isize = cpu_to_je32((uint32_t)inode->i_size);
  216. ri->atime = ri->ctime = ri->mtime = cpu_to_je32(get_seconds());
  217. /* In 2.4, it was already kmapped by generic_file_write(). Doesn't
  218. hurt to do it again. The alternative is ifdefs, which are ugly. */
  219. kmap(pg);
  220. ret = jffs2_write_inode_range(c, f, ri, page_address(pg) + aligned_start,
  221. (pg->index << PAGE_CACHE_SHIFT) + aligned_start,
  222. end - aligned_start, &writtenlen);
  223. kunmap(pg);
  224. if (ret) {
  225. /* There was an error writing. */
  226. SetPageError(pg);
  227. }
  228. /* Adjust writtenlen for the padding we did, so we don't confuse our caller */
  229. if (writtenlen < (start&3))
  230. writtenlen = 0;
  231. else
  232. writtenlen -= (start&3);
  233. if (writtenlen) {
  234. if (inode->i_size < (pg->index << PAGE_CACHE_SHIFT) + start + writtenlen) {
  235. inode->i_size = (pg->index << PAGE_CACHE_SHIFT) + start + writtenlen;
  236. inode->i_blocks = (inode->i_size + 511) >> 9;
  237. inode->i_ctime = inode->i_mtime = ITIME(je32_to_cpu(ri->ctime));
  238. }
  239. }
  240. jffs2_free_raw_inode(ri);
  241. if (start+writtenlen < end) {
  242. /* generic_file_write has written more to the page cache than we've
  243. actually written to the medium. Mark the page !Uptodate so that
  244. it gets reread */
  245. D1(printk(KERN_DEBUG "jffs2_commit_write(): Not all bytes written. Marking page !uptodate\n"));
  246. SetPageError(pg);
  247. ClearPageUptodate(pg);
  248. }
  249. D1(printk(KERN_DEBUG "jffs2_commit_write() returning %d\n",start+writtenlen==end?0:ret));
  250. return start+writtenlen==end?0:ret;
  251. }