2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: file.c,v 1.104 2005/10/18 23:29:35 tpoynor Exp $
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
17 #include <linux/time.h>
18 #include <linux/pagemap.h>
19 #include <linux/highmem.h>
20 #include <linux/crc32.h>
21 #include <linux/jffs2.h>
24 static int jffs2_commit_write (struct file
*filp
, struct page
*pg
,
25 unsigned start
, unsigned end
);
26 static int jffs2_prepare_write (struct file
*filp
, struct page
*pg
,
27 unsigned start
, unsigned end
);
28 static int jffs2_readpage (struct file
*filp
, struct page
*pg
);
30 int jffs2_fsync(struct file
*filp
, struct dentry
*dentry
, int datasync
)
32 struct inode
*inode
= dentry
->d_inode
;
33 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(inode
->i_sb
);
35 /* Trigger GC to flush any pending writes for this inode */
36 jffs2_flush_wbuf_gc(c
, inode
->i_ino
);
41 const struct file_operations jffs2_file_operations
=
43 .llseek
= generic_file_llseek
,
44 .open
= generic_file_open
,
46 .aio_read
= generic_file_aio_read
,
47 .write
= do_sync_write
,
48 .aio_write
= generic_file_aio_write
,
50 .mmap
= generic_file_readonly_mmap
,
52 .sendfile
= generic_file_sendfile
55 /* jffs2_file_inode_operations */
57 struct inode_operations jffs2_file_inode_operations
=
59 .permission
= jffs2_permission
,
60 .setattr
= jffs2_setattr
,
61 .setxattr
= jffs2_setxattr
,
62 .getxattr
= jffs2_getxattr
,
63 .listxattr
= jffs2_listxattr
,
64 .removexattr
= jffs2_removexattr
67 const struct address_space_operations jffs2_file_address_operations
=
69 .readpage
= jffs2_readpage
,
70 .prepare_write
=jffs2_prepare_write
,
71 .commit_write
= jffs2_commit_write
74 static int jffs2_do_readpage_nolock (struct inode
*inode
, struct page
*pg
)
76 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(inode
);
77 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(inode
->i_sb
);
78 unsigned char *pg_buf
;
81 D2(printk(KERN_DEBUG
"jffs2_do_readpage_nolock(): ino #%lu, page at offset 0x%lx\n", inode
->i_ino
, pg
->index
<< PAGE_CACHE_SHIFT
));
83 BUG_ON(!PageLocked(pg
));
86 /* FIXME: Can kmap fail? */
88 ret
= jffs2_read_inode_range(c
, f
, pg_buf
, pg
->index
<< PAGE_CACHE_SHIFT
, PAGE_CACHE_SIZE
);
91 ClearPageUptodate(pg
);
98 flush_dcache_page(pg
);
101 D2(printk(KERN_DEBUG
"readpage finished\n"));
105 int jffs2_do_readpage_unlock(struct inode
*inode
, struct page
*pg
)
107 int ret
= jffs2_do_readpage_nolock(inode
, pg
);
113 static int jffs2_readpage (struct file
*filp
, struct page
*pg
)
115 #if 0 // mask by Victor Yu. 02-12-2007
116 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(pg
->mapping
->host
);
118 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(pg
->u
.xx
.mapping
->host
);
123 #if 0 // mask by Victor Yu. 02-12-2007
124 ret
= jffs2_do_readpage_unlock(pg
->mapping
->host
, pg
);
126 ret
= jffs2_do_readpage_unlock(pg
->u
.xx
.mapping
->host
, pg
);
132 static int jffs2_prepare_write (struct file
*filp
, struct page
*pg
,
133 unsigned start
, unsigned end
)
135 #if 0 // mask by Victor Yu. 02-12-2007
136 struct inode
*inode
= pg
->mapping
->host
;
138 struct inode
*inode
= pg
->u
.xx
.mapping
->host
;
140 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(inode
);
141 uint32_t pageofs
= pg
->index
<< PAGE_CACHE_SHIFT
;
144 D1(printk(KERN_DEBUG
"jffs2_prepare_write()\n"));
146 if (pageofs
> inode
->i_size
) {
147 /* Make new hole frag from old EOF to new page */
148 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(inode
->i_sb
);
149 struct jffs2_raw_inode ri
;
150 struct jffs2_full_dnode
*fn
;
153 D1(printk(KERN_DEBUG
"Writing new hole frag 0x%x-0x%x between current EOF and new page\n",
154 (unsigned int)inode
->i_size
, pageofs
));
156 ret
= jffs2_reserve_space(c
, sizeof(ri
), &alloc_len
,
157 ALLOC_NORMAL
, JFFS2_SUMMARY_INODE_SIZE
);
162 memset(&ri
, 0, sizeof(ri
));
164 ri
.magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
165 ri
.nodetype
= cpu_to_je16(JFFS2_NODETYPE_INODE
);
166 ri
.totlen
= cpu_to_je32(sizeof(ri
));
167 ri
.hdr_crc
= cpu_to_je32(crc32(0, &ri
, sizeof(struct jffs2_unknown_node
)-4));
169 ri
.ino
= cpu_to_je32(f
->inocache
->ino
);
170 ri
.version
= cpu_to_je32(++f
->highest_version
);
171 ri
.mode
= cpu_to_jemode(inode
->i_mode
);
172 ri
.uid
= cpu_to_je16(inode
->i_uid
);
173 ri
.gid
= cpu_to_je16(inode
->i_gid
);
174 ri
.isize
= cpu_to_je32(max((uint32_t)inode
->i_size
, pageofs
));
175 ri
.atime
= ri
.ctime
= ri
.mtime
= cpu_to_je32(get_seconds());
176 ri
.offset
= cpu_to_je32(inode
->i_size
);
177 ri
.dsize
= cpu_to_je32(pageofs
- inode
->i_size
);
178 ri
.csize
= cpu_to_je32(0);
179 ri
.compr
= JFFS2_COMPR_ZERO
;
180 ri
.node_crc
= cpu_to_je32(crc32(0, &ri
, sizeof(ri
)-8));
181 ri
.data_crc
= cpu_to_je32(0);
183 fn
= jffs2_write_dnode(c
, f
, &ri
, NULL
, 0, ALLOC_NORMAL
);
187 jffs2_complete_reservation(c
);
191 ret
= jffs2_add_full_dnode_to_inode(c
, f
, fn
);
193 jffs2_mark_node_obsolete(c
, f
->metadata
->raw
);
194 jffs2_free_full_dnode(f
->metadata
);
198 D1(printk(KERN_DEBUG
"Eep. add_full_dnode_to_inode() failed in prepare_write, returned %d\n", ret
));
199 jffs2_mark_node_obsolete(c
, fn
->raw
);
200 jffs2_free_full_dnode(fn
);
201 jffs2_complete_reservation(c
);
205 jffs2_complete_reservation(c
);
206 inode
->i_size
= pageofs
;
210 /* Read in the page if it wasn't already present, unless it's a whole page */
211 if (!PageUptodate(pg
) && (start
|| end
< PAGE_CACHE_SIZE
)) {
213 ret
= jffs2_do_readpage_nolock(inode
, pg
);
216 D1(printk(KERN_DEBUG
"end prepare_write(). pg->flags %lx\n", pg
->flags
));
220 static int jffs2_commit_write (struct file
*filp
, struct page
*pg
,
221 unsigned start
, unsigned end
)
223 /* Actually commit the write from the page cache page we're looking at.
224 * For now, we write the full page out each time. It sucks, but it's simple
226 #if 0 // mask by Victor Yu. 02-12-2007
227 struct inode
*inode
= pg
->mapping
->host
;
229 struct inode
*inode
= pg
->u
.xx
.mapping
->host
;
231 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(inode
);
232 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(inode
->i_sb
);
233 struct jffs2_raw_inode
*ri
;
234 unsigned aligned_start
= start
& ~3;
236 uint32_t writtenlen
= 0;
238 D1(printk(KERN_DEBUG
"jffs2_commit_write(): ino #%lu, page at 0x%lx, range %d-%d, flags %lx\n",
239 inode
->i_ino
, pg
->index
<< PAGE_CACHE_SHIFT
, start
, end
, pg
->flags
));
241 if (end
== PAGE_CACHE_SIZE
) {
243 /* We need to avoid deadlock with page_cache_read() in
244 jffs2_garbage_collect_pass(). So we have to mark the
245 page up to date, to prevent page_cache_read() from
246 trying to re-lock it. */
249 /* When writing out the end of a page, write out the
250 _whole_ page. This helps to reduce the number of
251 nodes in files which have many short writes, like
253 start
= aligned_start
= 0;
257 ri
= jffs2_alloc_raw_inode();
260 D1(printk(KERN_DEBUG
"jffs2_commit_write(): Allocation of raw inode failed\n"));
264 /* Set the fields that the generic jffs2_write_inode_range() code can't find */
265 ri
->ino
= cpu_to_je32(inode
->i_ino
);
266 ri
->mode
= cpu_to_jemode(inode
->i_mode
);
267 ri
->uid
= cpu_to_je16(inode
->i_uid
);
268 ri
->gid
= cpu_to_je16(inode
->i_gid
);
269 ri
->isize
= cpu_to_je32((uint32_t)inode
->i_size
);
270 ri
->atime
= ri
->ctime
= ri
->mtime
= cpu_to_je32(get_seconds());
272 /* In 2.4, it was already kmapped by generic_file_write(). Doesn't
273 hurt to do it again. The alternative is ifdefs, which are ugly. */
276 ret
= jffs2_write_inode_range(c
, f
, ri
, page_address(pg
) + aligned_start
,
277 (pg
->index
<< PAGE_CACHE_SHIFT
) + aligned_start
,
278 end
- aligned_start
, &writtenlen
);
283 /* There was an error writing. */
287 /* Adjust writtenlen for the padding we did, so we don't confuse our caller */
288 if (writtenlen
< (start
&3))
291 writtenlen
-= (start
&3);
294 if (inode
->i_size
< (pg
->index
<< PAGE_CACHE_SHIFT
) + start
+ writtenlen
) {
295 inode
->i_size
= (pg
->index
<< PAGE_CACHE_SHIFT
) + start
+ writtenlen
;
296 inode
->i_blocks
= (inode
->i_size
+ 511) >> 9;
298 inode
->i_ctime
= inode
->i_mtime
= ITIME(je32_to_cpu(ri
->ctime
));
302 jffs2_free_raw_inode(ri
);
304 if (start
+writtenlen
< end
) {
305 /* generic_file_write has written more to the page cache than we've
306 actually written to the medium. Mark the page !Uptodate so that
308 D1(printk(KERN_DEBUG
"jffs2_commit_write(): Not all bytes written. Marking page !uptodate\n"));
310 ClearPageUptodate(pg
);
313 D1(printk(KERN_DEBUG
"jffs2_commit_write() returning %d\n",start
+writtenlen
==end
?0:ret
));
314 return start
+writtenlen
==end
?0:ret
;