1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/time.h>
22#include <linux/fs.h>
23#include <linux/jbd2.h>
24#include <linux/mount.h>
25#include <linux/path.h>
26#include <linux/quotaops.h>
27#include "ext4.h"
28#include "ext4_jbd2.h"
29#include "xattr.h"
30#include "acl.h"
31
32
33
34
35
36
37static int ext4_release_file(struct inode *inode, struct file *filp)
38{
39 if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) {
40 ext4_alloc_da_blocks(inode);
41 ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
42 }
43
44 if ((filp->f_mode & FMODE_WRITE) &&
45 (atomic_read(&inode->i_writecount) == 1) &&
46 !EXT4_I(inode)->i_reserved_data_blocks)
47 {
48 down_write(&EXT4_I(inode)->i_data_sem);
49 ext4_discard_preallocations(inode);
50 up_write(&EXT4_I(inode)->i_data_sem);
51 }
52 if (is_dx(inode) && filp->private_data)
53 ext4_htree_free_dir_info(filp->private_data);
54
55 return 0;
56}
57
58static void ext4_aiodio_wait(struct inode *inode)
59{
60 wait_queue_head_t *wq = ext4_ioend_wq(inode);
61
62 wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_aiodio_unwritten) == 0));
63}
64
65
66
67
68
69
70
71
72
73
74static int
75ext4_unaligned_aio(struct inode *inode, const struct iovec *iov,
76 unsigned long nr_segs, loff_t pos)
77{
78 struct super_block *sb = inode->i_sb;
79 int blockmask = sb->s_blocksize - 1;
80 size_t count = iov_length(iov, nr_segs);
81 loff_t final_size = pos + count;
82
83 if (pos >= inode->i_size)
84 return 0;
85
86 if ((pos & blockmask) || (final_size & blockmask))
87 return 1;
88
89 return 0;
90}
91
92static ssize_t
93ext4_file_dio_write(struct kiocb *iocb, const struct iovec *iov,
94 unsigned long nr_segs, loff_t pos)
95{
96 struct file *file = iocb->ki_filp;
97 struct inode *inode = file->f_mapping->host;
98 struct blk_plug plug;
99 int unaligned_aio = 0;
100 ssize_t ret;
101 int overwrite = 0;
102 size_t length = iov_length(iov, nr_segs);
103
104 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
105 !is_sync_kiocb(iocb))
106 unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
107
108
109 if (unaligned_aio) {
110 static unsigned long unaligned_warn_time;
111
112
113 if (printk_timed_ratelimit(&unaligned_warn_time, 60*60*24*HZ))
114 ext4_msg(inode->i_sb, KERN_WARNING,
115 "Unaligned AIO/DIO on inode %ld by %s; "
116 "performance will be poor.",
117 inode->i_ino, current->comm);
118 mutex_lock(ext4_aio_mutex(inode));
119 ext4_aiodio_wait(inode);
120 }
121
122 BUG_ON(iocb->ki_pos != pos);
123
124 mutex_lock(&inode->i_mutex);
125 blk_start_plug(&plug);
126
127 iocb->private = &overwrite;
128
129
130 if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&
131 !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
132 struct ext4_map_blocks map;
133 unsigned int blkbits = inode->i_blkbits;
134 int err, len;
135
136 map.m_lblk = pos >> blkbits;
137 map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits)
138 - map.m_lblk;
139 len = map.m_len;
140
141 err = ext4_map_blocks(NULL, inode, &map, 0);
142
143
144
145
146
147
148
149
150
151 if (err == len && (map.m_flags & EXT4_MAP_MAPPED))
152 overwrite = 1;
153 }
154
155 ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
156 mutex_unlock(&inode->i_mutex);
157
158 if (ret > 0 || ret == -EIOCBQUEUED) {
159 ssize_t err;
160
161 err = generic_write_sync(file, pos, ret);
162 if (err < 0 && ret > 0)
163 ret = err;
164 }
165 blk_finish_plug(&plug);
166
167 if (unaligned_aio)
168 mutex_unlock(ext4_aio_mutex(inode));
169
170 return ret;
171}
172
173static ssize_t
174ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
175 unsigned long nr_segs, loff_t pos)
176{
177 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
178 ssize_t ret;
179
180
181
182
183
184
185 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
186 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
187 size_t length = iov_length(iov, nr_segs);
188
189 if ((pos > sbi->s_bitmap_maxbytes ||
190 (pos == sbi->s_bitmap_maxbytes && length > 0)))
191 return -EFBIG;
192
193 if (pos + length > sbi->s_bitmap_maxbytes) {
194 nr_segs = iov_shorten((struct iovec *)iov, nr_segs,
195 sbi->s_bitmap_maxbytes - pos);
196 }
197 }
198
199 if (unlikely(iocb->ki_filp->f_flags & O_DIRECT))
200 ret = ext4_file_dio_write(iocb, iov, nr_segs, pos);
201 else
202 ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
203
204 return ret;
205}
206
207static const struct vm_operations_struct ext4_file_vm_ops = {
208 .fault = filemap_fault,
209 .page_mkwrite = ext4_page_mkwrite,
210};
211
212static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
213{
214 struct address_space *mapping = file->f_mapping;
215
216 if (!mapping->a_ops->readpage)
217 return -ENOEXEC;
218 file_accessed(file);
219 vma->vm_ops = &ext4_file_vm_ops;
220 vma->vm_flags |= VM_CAN_NONLINEAR;
221 return 0;
222}
223
224static int ext4_file_open(struct inode * inode, struct file * filp)
225{
226 struct super_block *sb = inode->i_sb;
227 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
228 struct ext4_inode_info *ei = EXT4_I(inode);
229 struct vfsmount *mnt = filp->f_path.mnt;
230 struct path path;
231 char buf[64], *cp;
232
233 if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) &&
234 !(sb->s_flags & MS_RDONLY))) {
235 sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED;
236
237
238
239
240
241
242 memset(buf, 0, sizeof(buf));
243 path.mnt = mnt;
244 path.dentry = mnt->mnt_root;
245 cp = d_path(&path, buf, sizeof(buf));
246 if (!IS_ERR(cp)) {
247 handle_t *handle;
248 int err;
249
250 handle = ext4_journal_start_sb(sb, 1);
251 if (IS_ERR(handle))
252 return PTR_ERR(handle);
253 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
254 if (err) {
255 ext4_journal_stop(handle);
256 return err;
257 }
258 strlcpy(sbi->s_es->s_last_mounted, cp,
259 sizeof(sbi->s_es->s_last_mounted));
260 ext4_handle_dirty_super(handle, sb);
261 ext4_journal_stop(handle);
262 }
263 }
264
265
266
267
268 if (sbi->s_journal && !ei->jinode && (filp->f_mode & FMODE_WRITE)) {
269 struct jbd2_inode *jinode = jbd2_alloc_inode(GFP_KERNEL);
270
271 spin_lock(&inode->i_lock);
272 if (!ei->jinode) {
273 if (!jinode) {
274 spin_unlock(&inode->i_lock);
275 return -ENOMEM;
276 }
277 ei->jinode = jinode;
278 jbd2_journal_init_jbd_inode(ei->jinode, inode);
279 jinode = NULL;
280 }
281 spin_unlock(&inode->i_lock);
282 if (unlikely(jinode != NULL))
283 jbd2_free_inode(jinode);
284 }
285 return dquot_file_open(inode, filp);
286}
287
288
289
290
291
292
293loff_t ext4_llseek(struct file *file, loff_t offset, int origin)
294{
295 struct inode *inode = file->f_mapping->host;
296 loff_t maxbytes;
297
298 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
299 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes;
300 else
301 maxbytes = inode->i_sb->s_maxbytes;
302
303 return generic_file_llseek_size(file, offset, origin,
304 maxbytes, i_size_read(inode));
305}
306
307const struct file_operations ext4_file_operations = {
308 .llseek = ext4_llseek,
309 .read = do_sync_read,
310 .write = do_sync_write,
311 .aio_read = generic_file_aio_read,
312 .aio_write = ext4_file_write,
313 .unlocked_ioctl = ext4_ioctl,
314#ifdef CONFIG_COMPAT
315 .compat_ioctl = ext4_compat_ioctl,
316#endif
317 .mmap = ext4_file_mmap,
318 .open = ext4_file_open,
319 .release = ext4_release_file,
320 .fsync = ext4_sync_file,
321 .splice_read = generic_file_splice_read,
322 .splice_write = generic_file_splice_write,
323 .fallocate = ext4_fallocate,
324};
325
326const struct inode_operations ext4_file_inode_operations = {
327 .setattr = ext4_setattr,
328 .getattr = ext4_getattr,
329#ifdef CONFIG_EXT4_FS_XATTR
330 .setxattr = generic_setxattr,
331 .getxattr = generic_getxattr,
332 .listxattr = ext4_listxattr,
333 .removexattr = generic_removexattr,
334#endif
335 .get_acl = ext4_get_acl,
336 .fiemap = ext4_fiemap,
337};
338
339