Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README | |
3 | */ | |
4 | ||
1da177e4 | 5 | #include <linux/time.h> |
f466c6fd | 6 | #include "reiserfs.h" |
a3063ab8 | 7 | #include "acl.h" |
c45ac888 | 8 | #include "xattr.h" |
17093991 | 9 | #include <linux/uaccess.h> |
1da177e4 LT |
10 | #include <linux/pagemap.h> |
11 | #include <linux/swap.h> | |
12 | #include <linux/writeback.h> | |
13 | #include <linux/blkdev.h> | |
14 | #include <linux/buffer_head.h> | |
15 | #include <linux/quotaops.h> | |
16 | ||
17 | /* | |
098297b2 JM |
18 | * We pack the tails of files on file close, not at the time they are written. |
19 | * This implies an unnecessary copy of the tail and an unnecessary indirect item | |
20 | * insertion/balancing, for files that are written in one write. | |
21 | * It avoids unnecessary tail packings (balances) for files that are written in | |
22 | * multiple writes and are small enough to have tails. | |
23 | * | |
24 | * file_release is called by the VFS layer when the file is closed. If | |
25 | * this is the last open file descriptor, and the file | |
26 | * small enough to have a tail, and the tail is currently in an | |
27 | * unformatted node, the tail is converted back into a direct item. | |
28 | * | |
29 | * We use reiserfs_truncate_file to pack the tail, since it already has | |
30 | * all the conditions coded. | |
31 | */ | |
bd4c625c | 32 | static int reiserfs_file_release(struct inode *inode, struct file *filp) |
1da177e4 LT |
33 | { |
34 | ||
bd4c625c LT |
35 | struct reiserfs_transaction_handle th; |
36 | int err; | |
37 | int jbegin_failure = 0; | |
1da177e4 | 38 | |
14a61442 | 39 | BUG_ON(!S_ISREG(inode->i_mode)); |
1da177e4 | 40 | |
a9913d7e NA |
41 | if (!atomic_dec_and_mutex_lock(&REISERFS_I(inode)->openers, |
42 | &REISERFS_I(inode)->tailpack)) | |
0e4f6a79 AV |
43 | return 0; |
44 | ||
bd4c625c | 45 | /* fast out for when nothing needs to be done */ |
0e4f6a79 | 46 | if ((!(REISERFS_I(inode)->i_flags & i_pack_on_close_mask) || |
bd4c625c LT |
47 | !tail_has_to_be_packed(inode)) && |
48 | REISERFS_I(inode)->i_prealloc_count <= 0) { | |
a228bf8f | 49 | mutex_unlock(&REISERFS_I(inode)->tailpack); |
bd4c625c LT |
50 | return 0; |
51 | } | |
1da177e4 | 52 | |
b5f3953c | 53 | reiserfs_write_lock(inode->i_sb); |
098297b2 JM |
54 | /* |
55 | * freeing preallocation only involves relogging blocks that | |
bd4c625c LT |
56 | * are already in the current transaction. preallocation gets |
57 | * freed at the end of each transaction, so it is impossible for | |
58 | * us to log any additional blocks (including quota blocks) | |
59 | */ | |
60 | err = journal_begin(&th, inode->i_sb, 1); | |
1da177e4 | 61 | if (err) { |
098297b2 JM |
62 | /* |
63 | * uh oh, we can't allow the inode to go away while there | |
bd4c625c LT |
64 | * is still preallocation blocks pending. Try to join the |
65 | * aborted transaction | |
66 | */ | |
67 | jbegin_failure = err; | |
b491dd17 | 68 | err = journal_join_abort(&th, inode->i_sb); |
bd4c625c LT |
69 | |
70 | if (err) { | |
098297b2 JM |
71 | /* |
72 | * hmpf, our choices here aren't good. We can pin | |
73 | * the inode which will disallow unmount from ever | |
74 | * happening, we can do nothing, which will corrupt | |
75 | * random memory on unmount, or we can forcibly | |
76 | * remove the file from the preallocation list, which | |
77 | * will leak blocks on disk. Lets pin the inode | |
bd4c625c LT |
78 | * and let the admin know what is going on. |
79 | */ | |
80 | igrab(inode); | |
45b03d5e | 81 | reiserfs_warning(inode->i_sb, "clm-9001", |
bd4c625c | 82 | "pinning inode %lu because the " |
533221fb AD |
83 | "preallocation can't be freed", |
84 | inode->i_ino); | |
bd4c625c LT |
85 | goto out; |
86 | } | |
1da177e4 | 87 | } |
bd4c625c | 88 | reiserfs_update_inode_transaction(inode); |
1da177e4 LT |
89 | |
90 | #ifdef REISERFS_PREALLOCATE | |
bd4c625c | 91 | reiserfs_discard_prealloc(&th, inode); |
1da177e4 | 92 | #endif |
58d85426 | 93 | err = journal_end(&th); |
bd4c625c LT |
94 | |
95 | /* copy back the error code from journal_begin */ | |
96 | if (!err) | |
97 | err = jbegin_failure; | |
98 | ||
0e4f6a79 | 99 | if (!err && |
bd4c625c LT |
100 | (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) && |
101 | tail_has_to_be_packed(inode)) { | |
0e4f6a79 | 102 | |
098297b2 JM |
103 | /* |
104 | * if regular file is released by last holder and it has been | |
105 | * appended (we append by unformatted node only) or its direct | |
106 | * item(s) had to be converted, then it may have to be | |
107 | * indirect2direct converted | |
108 | */ | |
bd4c625c LT |
109 | err = reiserfs_truncate_file(inode, 0); |
110 | } | |
cf776a7a | 111 | out: |
bd4c625c | 112 | reiserfs_write_unlock(inode->i_sb); |
a228bf8f | 113 | mutex_unlock(&REISERFS_I(inode)->tailpack); |
bd4c625c | 114 | return err; |
1da177e4 LT |
115 | } |
116 | ||
0e4f6a79 | 117 | static int reiserfs_file_open(struct inode *inode, struct file *file) |
de14569f | 118 | { |
0e4f6a79 | 119 | int err = dquot_file_open(inode, file); |
098297b2 JM |
120 | |
121 | /* somebody might be tailpacking on final close; wait for it */ | |
0e4f6a79 | 122 | if (!atomic_inc_not_zero(&REISERFS_I(inode)->openers)) { |
a228bf8f | 123 | mutex_lock(&REISERFS_I(inode)->tailpack); |
0e4f6a79 | 124 | atomic_inc(&REISERFS_I(inode)->openers); |
a228bf8f | 125 | mutex_unlock(&REISERFS_I(inode)->tailpack); |
0e4f6a79 AV |
126 | } |
127 | return err; | |
de14569f VS |
128 | } |
129 | ||
cfac4b47 | 130 | void reiserfs_vfs_truncate_file(struct inode *inode) |
bd4c625c | 131 | { |
a228bf8f | 132 | mutex_lock(&REISERFS_I(inode)->tailpack); |
bd4c625c | 133 | reiserfs_truncate_file(inode, 1); |
a228bf8f | 134 | mutex_unlock(&REISERFS_I(inode)->tailpack); |
1da177e4 LT |
135 | } |
136 | ||
137 | /* Sync a reiserfs file. */ | |
138 | ||
139 | /* | |
140 | * FIXME: sync_mapping_buffers() never has anything to sync. Can | |
141 | * be removed... | |
142 | */ | |
143 | ||
02c24a82 JB |
144 | static int reiserfs_sync_file(struct file *filp, loff_t start, loff_t end, |
145 | int datasync) | |
bd4c625c | 146 | { |
7ea80859 | 147 | struct inode *inode = filp->f_mapping->host; |
ee93961b | 148 | int err; |
bd4c625c LT |
149 | int barrier_done; |
150 | ||
3b49c9a1 | 151 | err = file_write_and_wait_range(filp, start, end); |
02c24a82 JB |
152 | if (err) |
153 | return err; | |
154 | ||
5955102c | 155 | inode_lock(inode); |
995c762e | 156 | BUG_ON(!S_ISREG(inode->i_mode)); |
ee93961b | 157 | err = sync_mapping_buffers(inode->i_mapping); |
995c762e JM |
158 | reiserfs_write_lock(inode->i_sb); |
159 | barrier_done = reiserfs_commit_for_inode(inode); | |
160 | reiserfs_write_unlock(inode->i_sb); | |
161 | if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb)) | |
dd3932ed | 162 | blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); |
5955102c | 163 | inode_unlock(inode); |
bd4c625c LT |
164 | if (barrier_done < 0) |
165 | return barrier_done; | |
ee93961b | 166 | return (err < 0) ? -EIO : 0; |
1da177e4 LT |
167 | } |
168 | ||
1da177e4 LT |
169 | /* taken fs/buffer.c:__block_commit_write */ |
170 | int reiserfs_commit_page(struct inode *inode, struct page *page, | |
bd4c625c | 171 | unsigned from, unsigned to) |
1da177e4 | 172 | { |
bd4c625c LT |
173 | unsigned block_start, block_end; |
174 | int partial = 0; | |
175 | unsigned blocksize; | |
176 | struct buffer_head *bh, *head; | |
09cbfeaf | 177 | unsigned long i_size_index = inode->i_size >> PAGE_SHIFT; |
bd4c625c LT |
178 | int new; |
179 | int logit = reiserfs_file_data_log(inode); | |
180 | struct super_block *s = inode->i_sb; | |
09cbfeaf | 181 | int bh_per_page = PAGE_SIZE / s->s_blocksize; |
bd4c625c LT |
182 | struct reiserfs_transaction_handle th; |
183 | int ret = 0; | |
184 | ||
185 | th.t_trans_id = 0; | |
93407472 | 186 | blocksize = i_blocksize(inode); |
bd4c625c LT |
187 | |
188 | if (logit) { | |
189 | reiserfs_write_lock(s); | |
190 | ret = journal_begin(&th, s, bh_per_page + 1); | |
191 | if (ret) | |
192 | goto drop_write_lock; | |
193 | reiserfs_update_inode_transaction(inode); | |
194 | } | |
195 | for (bh = head = page_buffers(page), block_start = 0; | |
196 | bh != head || !block_start; | |
197 | block_start = block_end, bh = bh->b_this_page) { | |
198 | ||
199 | new = buffer_new(bh); | |
200 | clear_buffer_new(bh); | |
201 | block_end = block_start + blocksize; | |
202 | if (block_end <= from || block_start >= to) { | |
203 | if (!buffer_uptodate(bh)) | |
204 | partial = 1; | |
205 | } else { | |
206 | set_buffer_uptodate(bh); | |
207 | if (logit) { | |
208 | reiserfs_prepare_for_journal(s, bh, 1); | |
09f1b80b | 209 | journal_mark_dirty(&th, bh); |
bd4c625c LT |
210 | } else if (!buffer_dirty(bh)) { |
211 | mark_buffer_dirty(bh); | |
098297b2 JM |
212 | /* |
213 | * do data=ordered on any page past the end | |
bd4c625c LT |
214 | * of file and any buffer marked BH_New. |
215 | */ | |
216 | if (reiserfs_data_ordered(inode->i_sb) && | |
217 | (new || page->index >= i_size_index)) { | |
218 | reiserfs_add_ordered_list(inode, bh); | |
219 | } | |
220 | } | |
221 | } | |
1da177e4 | 222 | } |
bd4c625c | 223 | if (logit) { |
58d85426 | 224 | ret = journal_end(&th); |
cf776a7a | 225 | drop_write_lock: |
bd4c625c LT |
226 | reiserfs_write_unlock(s); |
227 | } | |
228 | /* | |
229 | * If this is a partial write which happened to make all buffers | |
230 | * uptodate then we can optimize away a bogus readpage() for | |
231 | * the next read(). Here we 'discover' whether the page went | |
232 | * uptodate as a result of this (potentially partial) write. | |
233 | */ | |
234 | if (!partial) | |
235 | SetPageUptodate(page); | |
236 | return ret; | |
1da177e4 LT |
237 | } |
238 | ||
4b6f5d20 | 239 | const struct file_operations reiserfs_file_operations = { |
205cb37b | 240 | .unlocked_ioctl = reiserfs_ioctl, |
52b499c4 DH |
241 | #ifdef CONFIG_COMPAT |
242 | .compat_ioctl = reiserfs_compat_ioctl, | |
243 | #endif | |
0e4f6a79 AV |
244 | .mmap = generic_file_mmap, |
245 | .open = reiserfs_file_open, | |
bd4c625c LT |
246 | .release = reiserfs_file_release, |
247 | .fsync = reiserfs_sync_file, | |
aad4f8bb | 248 | .read_iter = generic_file_read_iter, |
8174202b | 249 | .write_iter = generic_file_write_iter, |
5274f052 | 250 | .splice_read = generic_file_splice_read, |
8d020765 | 251 | .splice_write = iter_file_splice_write, |
91efc167 | 252 | .llseek = generic_file_llseek, |
1da177e4 LT |
253 | }; |
254 | ||
c5ef1c42 | 255 | const struct inode_operations reiserfs_file_inode_operations = { |
bd4c625c | 256 | .setattr = reiserfs_setattr, |
bd4c625c | 257 | .listxattr = reiserfs_listxattr, |
bd4c625c | 258 | .permission = reiserfs_permission, |
4e34e719 | 259 | .get_acl = reiserfs_get_acl, |
47f70d08 | 260 | .set_acl = reiserfs_set_acl, |
1da177e4 | 261 | }; |