Root/
1 | /* |
2 | * fs/logfs/file.c - prepare_write, commit_write and friends |
3 | * |
4 | * As should be obvious for Linux kernel code, license is GPLv2 |
5 | * |
6 | * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org> |
7 | */ |
8 | #include "logfs.h" |
9 | #include <linux/sched.h> |
10 | #include <linux/writeback.h> |
11 | |
12 | static int logfs_write_begin(struct file *file, struct address_space *mapping, |
13 | loff_t pos, unsigned len, unsigned flags, |
14 | struct page **pagep, void **fsdata) |
15 | { |
16 | struct inode *inode = mapping->host; |
17 | struct page *page; |
18 | pgoff_t index = pos >> PAGE_CACHE_SHIFT; |
19 | |
20 | page = grab_cache_page_write_begin(mapping, index, flags); |
21 | if (!page) |
22 | return -ENOMEM; |
23 | *pagep = page; |
24 | |
25 | if ((len == PAGE_CACHE_SIZE) || PageUptodate(page)) |
26 | return 0; |
27 | if ((pos & PAGE_CACHE_MASK) >= i_size_read(inode)) { |
28 | unsigned start = pos & (PAGE_CACHE_SIZE - 1); |
29 | unsigned end = start + len; |
30 | |
31 | /* Reading beyond i_size is simple: memset to zero */ |
32 | zero_user_segments(page, 0, start, end, PAGE_CACHE_SIZE); |
33 | return 0; |
34 | } |
35 | return logfs_readpage_nolock(page); |
36 | } |
37 | |
38 | static int logfs_write_end(struct file *file, struct address_space *mapping, |
39 | loff_t pos, unsigned len, unsigned copied, struct page *page, |
40 | void *fsdata) |
41 | { |
42 | struct inode *inode = mapping->host; |
43 | pgoff_t index = page->index; |
44 | unsigned start = pos & (PAGE_CACHE_SIZE - 1); |
45 | unsigned end = start + copied; |
46 | int ret = 0; |
47 | |
48 | BUG_ON(PAGE_CACHE_SIZE != inode->i_sb->s_blocksize); |
49 | BUG_ON(page->index > I3_BLOCKS); |
50 | |
51 | if (copied < len) { |
52 | /* |
53 | * Short write of a non-initialized paged. Just tell userspace |
54 | * to retry the entire page. |
55 | */ |
56 | if (!PageUptodate(page)) { |
57 | copied = 0; |
58 | goto out; |
59 | } |
60 | } |
61 | if (copied == 0) |
62 | goto out; /* FIXME: do we need to update inode? */ |
63 | |
64 | if (i_size_read(inode) < (index << PAGE_CACHE_SHIFT) + end) { |
65 | i_size_write(inode, (index << PAGE_CACHE_SHIFT) + end); |
66 | mark_inode_dirty_sync(inode); |
67 | } |
68 | |
69 | SetPageUptodate(page); |
70 | if (!PageDirty(page)) { |
71 | if (!get_page_reserve(inode, page)) |
72 | __set_page_dirty_nobuffers(page); |
73 | else |
74 | ret = logfs_write_buf(inode, page, WF_LOCK); |
75 | } |
76 | out: |
77 | unlock_page(page); |
78 | page_cache_release(page); |
79 | return ret ? ret : copied; |
80 | } |
81 | |
82 | int logfs_readpage(struct file *file, struct page *page) |
83 | { |
84 | int ret; |
85 | |
86 | ret = logfs_readpage_nolock(page); |
87 | unlock_page(page); |
88 | return ret; |
89 | } |
90 | |
91 | /* Clear the page's dirty flag in the radix tree. */ |
92 | /* TODO: mucking with PageWriteback is silly. Add a generic function to clear |
93 | * the dirty bit from the radix tree for filesystems that don't have to wait |
94 | * for page writeback to finish (i.e. any compressing filesystem). |
95 | */ |
96 | static void clear_radix_tree_dirty(struct page *page) |
97 | { |
98 | BUG_ON(PagePrivate(page) || page->private); |
99 | set_page_writeback(page); |
100 | end_page_writeback(page); |
101 | } |
102 | |
103 | static int __logfs_writepage(struct page *page) |
104 | { |
105 | struct inode *inode = page->mapping->host; |
106 | int err; |
107 | |
108 | err = logfs_write_buf(inode, page, WF_LOCK); |
109 | if (err) |
110 | set_page_dirty(page); |
111 | else |
112 | clear_radix_tree_dirty(page); |
113 | unlock_page(page); |
114 | return err; |
115 | } |
116 | |
117 | static int logfs_writepage(struct page *page, struct writeback_control *wbc) |
118 | { |
119 | struct inode *inode = page->mapping->host; |
120 | loff_t i_size = i_size_read(inode); |
121 | pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT; |
122 | unsigned offset; |
123 | u64 bix; |
124 | level_t level; |
125 | |
126 | log_file("logfs_writepage(%lx, %lx, %p)\n", inode->i_ino, page->index, |
127 | page); |
128 | |
129 | logfs_unpack_index(page->index, &bix, &level); |
130 | |
131 | /* Indirect blocks are never truncated */ |
132 | if (level != 0) |
133 | return __logfs_writepage(page); |
134 | |
135 | /* |
136 | * TODO: everything below is a near-verbatim copy of nobh_writepage(). |
137 | * The relevant bits should be factored out after logfs is merged. |
138 | */ |
139 | |
140 | /* Is the page fully inside i_size? */ |
141 | if (bix < end_index) |
142 | return __logfs_writepage(page); |
143 | |
144 | /* Is the page fully outside i_size? (truncate in progress) */ |
145 | offset = i_size & (PAGE_CACHE_SIZE-1); |
146 | if (bix > end_index || offset == 0) { |
147 | unlock_page(page); |
148 | return 0; /* don't care */ |
149 | } |
150 | |
151 | /* |
152 | * The page straddles i_size. It must be zeroed out on each and every |
153 | * writepage invokation because it may be mmapped. "A file is mapped |
154 | * in multiples of the page size. For a file that is not a multiple of |
155 | * the page size, the remaining memory is zeroed when mapped, and |
156 | * writes to that region are not written out to the file." |
157 | */ |
158 | zero_user_segment(page, offset, PAGE_CACHE_SIZE); |
159 | return __logfs_writepage(page); |
160 | } |
161 | |
162 | static void logfs_invalidatepage(struct page *page, unsigned long offset) |
163 | { |
164 | move_page_to_btree(page); |
165 | BUG_ON(PagePrivate(page) || page->private); |
166 | } |
167 | |
168 | static int logfs_releasepage(struct page *page, gfp_t only_xfs_uses_this) |
169 | { |
170 | return 0; /* None of these are easy to release */ |
171 | } |
172 | |
173 | |
174 | int logfs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, |
175 | unsigned long arg) |
176 | { |
177 | struct logfs_inode *li = logfs_inode(inode); |
178 | unsigned int oldflags, flags; |
179 | int err; |
180 | |
181 | switch (cmd) { |
182 | case FS_IOC_GETFLAGS: |
183 | flags = li->li_flags & LOGFS_FL_USER_VISIBLE; |
184 | return put_user(flags, (int __user *)arg); |
185 | case FS_IOC_SETFLAGS: |
186 | if (IS_RDONLY(inode)) |
187 | return -EROFS; |
188 | |
189 | if (!is_owner_or_cap(inode)) |
190 | return -EACCES; |
191 | |
192 | err = get_user(flags, (int __user *)arg); |
193 | if (err) |
194 | return err; |
195 | |
196 | mutex_lock(&inode->i_mutex); |
197 | oldflags = li->li_flags; |
198 | flags &= LOGFS_FL_USER_MODIFIABLE; |
199 | flags |= oldflags & ~LOGFS_FL_USER_MODIFIABLE; |
200 | li->li_flags = flags; |
201 | mutex_unlock(&inode->i_mutex); |
202 | |
203 | inode->i_ctime = CURRENT_TIME; |
204 | mark_inode_dirty_sync(inode); |
205 | return 0; |
206 | |
207 | default: |
208 | return -ENOTTY; |
209 | } |
210 | } |
211 | |
212 | int logfs_fsync(struct file *file, struct dentry *dentry, int datasync) |
213 | { |
214 | struct super_block *sb = dentry->d_inode->i_sb; |
215 | struct logfs_super *super = logfs_super(sb); |
216 | |
217 | /* FIXME: write anchor */ |
218 | super->s_devops->sync(sb); |
219 | return 0; |
220 | } |
221 | |
222 | static int logfs_setattr(struct dentry *dentry, struct iattr *attr) |
223 | { |
224 | struct inode *inode = dentry->d_inode; |
225 | int err = 0; |
226 | |
227 | if (attr->ia_valid & ATTR_SIZE) |
228 | err = logfs_truncate(inode, attr->ia_size); |
229 | attr->ia_valid &= ~ATTR_SIZE; |
230 | |
231 | if (!err) |
232 | err = inode_change_ok(inode, attr); |
233 | if (!err) |
234 | err = inode_setattr(inode, attr); |
235 | return err; |
236 | } |
237 | |
238 | const struct inode_operations logfs_reg_iops = { |
239 | .setattr = logfs_setattr, |
240 | }; |
241 | |
242 | const struct file_operations logfs_reg_fops = { |
243 | .aio_read = generic_file_aio_read, |
244 | .aio_write = generic_file_aio_write, |
245 | .fsync = logfs_fsync, |
246 | .ioctl = logfs_ioctl, |
247 | .llseek = generic_file_llseek, |
248 | .mmap = generic_file_readonly_mmap, |
249 | .open = generic_file_open, |
250 | .read = do_sync_read, |
251 | .write = do_sync_write, |
252 | }; |
253 | |
254 | const struct address_space_operations logfs_reg_aops = { |
255 | .invalidatepage = logfs_invalidatepage, |
256 | .readpage = logfs_readpage, |
257 | .releasepage = logfs_releasepage, |
258 | .set_page_dirty = __set_page_dirty_nobuffers, |
259 | .writepage = logfs_writepage, |
260 | .writepages = generic_writepages, |
261 | .write_begin = logfs_write_begin, |
262 | .write_end = logfs_write_end, |
263 | }; |
264 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9