Commit | Line | Data |
---|---|---|
98d91704 NJ |
1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* | |
3 | * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd. | |
4 | */ | |
5 | ||
6 | #include <linux/slab.h> | |
654762df | 7 | #include <linux/compat.h> |
98d91704 NJ |
8 | #include <linux/cred.h> |
9 | #include <linux/buffer_head.h> | |
5267456e | 10 | #include <linux/blkdev.h> |
98d91704 NJ |
11 | |
12 | #include "exfat_raw.h" | |
13 | #include "exfat_fs.h" | |
14 | ||
15 | static int exfat_cont_expand(struct inode *inode, loff_t size) | |
16 | { | |
17 | struct address_space *mapping = inode->i_mapping; | |
18 | loff_t start = i_size_read(inode), count = size - i_size_read(inode); | |
19 | int err, err2; | |
20 | ||
21 | err = generic_cont_expand_simple(inode, size); | |
22 | if (err) | |
23 | return err; | |
24 | ||
25 | inode->i_ctime = inode->i_mtime = current_time(inode); | |
26 | mark_inode_dirty(inode); | |
27 | ||
28 | if (!IS_SYNC(inode)) | |
29 | return 0; | |
30 | ||
31 | err = filemap_fdatawrite_range(mapping, start, start + count - 1); | |
32 | err2 = sync_mapping_buffers(mapping); | |
33 | if (!err) | |
34 | err = err2; | |
35 | err2 = write_inode_now(inode, 1); | |
36 | if (!err) | |
37 | err = err2; | |
38 | if (err) | |
39 | return err; | |
40 | ||
41 | return filemap_fdatawait_range(mapping, start, start + count - 1); | |
42 | } | |
43 | ||
44 | static bool exfat_allow_set_time(struct exfat_sb_info *sbi, struct inode *inode) | |
45 | { | |
46 | mode_t allow_utime = sbi->options.allow_utime; | |
47 | ||
48 | if (!uid_eq(current_fsuid(), inode->i_uid)) { | |
49 | if (in_group_p(inode->i_gid)) | |
50 | allow_utime >>= 3; | |
51 | if (allow_utime & MAY_WRITE) | |
52 | return true; | |
53 | } | |
54 | ||
55 | /* use a default check */ | |
56 | return false; | |
57 | } | |
58 | ||
59 | static int exfat_sanitize_mode(const struct exfat_sb_info *sbi, | |
60 | struct inode *inode, umode_t *mode_ptr) | |
61 | { | |
62 | mode_t i_mode, mask, perm; | |
63 | ||
64 | i_mode = inode->i_mode; | |
65 | ||
66 | mask = (S_ISREG(i_mode) || S_ISLNK(i_mode)) ? | |
67 | sbi->options.fs_fmask : sbi->options.fs_dmask; | |
68 | perm = *mode_ptr & ~(S_IFMT | mask); | |
69 | ||
70 | /* Of the r and x bits, all (subject to umask) must be present.*/ | |
71 | if ((perm & 0555) != (i_mode & 0555)) | |
72 | return -EPERM; | |
73 | ||
74 | if (exfat_mode_can_hold_ro(inode)) { | |
75 | /* | |
76 | * Of the w bits, either all (subject to umask) or none must | |
77 | * be present. | |
78 | */ | |
79 | if ((perm & 0222) && ((perm & 0222) != (0222 & ~mask))) | |
80 | return -EPERM; | |
81 | } else { | |
82 | /* | |
83 | * If exfat_mode_can_hold_ro(inode) is false, can't change | |
84 | * w bits. | |
85 | */ | |
86 | if ((perm & 0222) != (0222 & ~mask)) | |
87 | return -EPERM; | |
88 | } | |
89 | ||
90 | *mode_ptr &= S_IFMT | perm; | |
91 | ||
92 | return 0; | |
93 | } | |
94 | ||
95 | /* resize the file length */ | |
f7cde967 | 96 | int __exfat_truncate(struct inode *inode) |
98d91704 NJ |
97 | { |
98 | unsigned int num_clusters_new, num_clusters_phys; | |
99 | unsigned int last_clu = EXFAT_FREE_CLUSTER; | |
100 | struct exfat_chain clu; | |
98d91704 NJ |
101 | struct super_block *sb = inode->i_sb; |
102 | struct exfat_sb_info *sbi = EXFAT_SB(sb); | |
103 | struct exfat_inode_info *ei = EXFAT_I(inode); | |
98d91704 NJ |
104 | |
105 | /* check if the given file ID is opened */ | |
106 | if (ei->type != TYPE_FILE && ei->type != TYPE_DIR) | |
107 | return -EPERM; | |
108 | ||
7018ec68 | 109 | exfat_set_volume_dirty(sb); |
98d91704 NJ |
110 | |
111 | num_clusters_new = EXFAT_B_TO_CLU_ROUND_UP(i_size_read(inode), sbi); | |
7dee6f57 | 112 | num_clusters_phys = EXFAT_B_TO_CLU_ROUND_UP(ei->i_size_ondisk, sbi); |
98d91704 NJ |
113 | |
114 | exfat_chain_set(&clu, ei->start_clu, num_clusters_phys, ei->flags); | |
115 | ||
f7cde967 | 116 | if (i_size_read(inode) > 0) { |
98d91704 NJ |
117 | /* |
118 | * Truncate FAT chain num_clusters after the first cluster | |
119 | * num_clusters = min(new, phys); | |
120 | */ | |
121 | unsigned int num_clusters = | |
122 | min(num_clusters_new, num_clusters_phys); | |
123 | ||
124 | /* | |
125 | * Follow FAT chain | |
126 | * (defensive coding - works fine even with corrupted FAT table | |
127 | */ | |
128 | if (clu.flags == ALLOC_NO_FAT_CHAIN) { | |
129 | clu.dir += num_clusters; | |
130 | clu.size -= num_clusters; | |
131 | } else { | |
132 | while (num_clusters > 0) { | |
133 | last_clu = clu.dir; | |
134 | if (exfat_get_next_cluster(sb, &(clu.dir))) | |
135 | return -EIO; | |
136 | ||
137 | num_clusters--; | |
138 | clu.size--; | |
139 | } | |
140 | } | |
141 | } else { | |
142 | ei->flags = ALLOC_NO_FAT_CHAIN; | |
143 | ei->start_clu = EXFAT_EOF_CLUSTER; | |
144 | } | |
145 | ||
98d91704 NJ |
146 | if (ei->type == TYPE_FILE) |
147 | ei->attr |= ATTR_ARCHIVE; | |
148 | ||
4493895b YM |
149 | /* |
150 | * update the directory entry | |
151 | * | |
152 | * If the directory entry is updated by mark_inode_dirty(), the | |
153 | * directory entry will be written after a writeback cycle of | |
154 | * updating the bitmap/FAT, which may result in clusters being | |
155 | * freed but referenced by the directory entry in the event of a | |
156 | * sudden power failure. | |
157 | * __exfat_write_inode() is called for directory entry, bitmap | |
158 | * and FAT to be written in a same writeback. | |
159 | */ | |
23e6e1c9 YM |
160 | if (__exfat_write_inode(inode, inode_needs_sync(inode))) |
161 | return -EIO; | |
98d91704 NJ |
162 | |
163 | /* cut off from the FAT chain */ | |
164 | if (ei->flags == ALLOC_FAT_CHAIN && last_clu != EXFAT_FREE_CLUSTER && | |
165 | last_clu != EXFAT_EOF_CLUSTER) { | |
166 | if (exfat_ent_set(sb, last_clu, EXFAT_EOF_CLUSTER)) | |
167 | return -EIO; | |
168 | } | |
169 | ||
170 | /* invalidate cache and free the clusters */ | |
171 | /* clear exfat cache */ | |
172 | exfat_cache_inval_inode(inode); | |
173 | ||
174 | /* hint information */ | |
175 | ei->hint_bmap.off = EXFAT_EOF_CLUSTER; | |
176 | ei->hint_bmap.clu = EXFAT_EOF_CLUSTER; | |
98d91704 NJ |
177 | |
178 | /* hint_stat will be used if this is directory. */ | |
179 | ei->hint_stat.eidx = 0; | |
180 | ei->hint_stat.clu = ei->start_clu; | |
181 | ei->hint_femp.eidx = EXFAT_HINT_NONE; | |
182 | ||
183 | /* free the clusters */ | |
184 | if (exfat_free_cluster(inode, &clu)) | |
185 | return -EIO; | |
186 | ||
98d91704 NJ |
187 | return 0; |
188 | } | |
189 | ||
e981917b | 190 | void exfat_truncate(struct inode *inode) |
98d91704 NJ |
191 | { |
192 | struct super_block *sb = inode->i_sb; | |
193 | struct exfat_sb_info *sbi = EXFAT_SB(sb); | |
7dee6f57 | 194 | struct exfat_inode_info *ei = EXFAT_I(inode); |
45882a6a | 195 | unsigned int blocksize = i_blocksize(inode); |
98d91704 NJ |
196 | loff_t aligned_size; |
197 | int err; | |
198 | ||
199 | mutex_lock(&sbi->s_lock); | |
7dee6f57 | 200 | if (ei->start_clu == 0) { |
98d91704 NJ |
201 | /* |
202 | * Empty start_clu != ~0 (not allocated) | |
203 | */ | |
204 | exfat_fs_error(sb, "tried to truncate zeroed cluster."); | |
205 | goto write_size; | |
206 | } | |
207 | ||
f7cde967 | 208 | err = __exfat_truncate(inode); |
98d91704 NJ |
209 | if (err) |
210 | goto write_size; | |
211 | ||
39c1ce8e | 212 | inode->i_blocks = round_up(i_size_read(inode), sbi->cluster_size) >> 9; |
98d91704 NJ |
213 | write_size: |
214 | aligned_size = i_size_read(inode); | |
215 | if (aligned_size & (blocksize - 1)) { | |
216 | aligned_size |= (blocksize - 1); | |
217 | aligned_size++; | |
218 | } | |
219 | ||
7dee6f57 CVB |
220 | if (ei->i_size_ondisk > i_size_read(inode)) |
221 | ei->i_size_ondisk = aligned_size; | |
98d91704 | 222 | |
7dee6f57 CVB |
223 | if (ei->i_size_aligned > i_size_read(inode)) |
224 | ei->i_size_aligned = aligned_size; | |
98d91704 NJ |
225 | mutex_unlock(&sbi->s_lock); |
226 | } | |
227 | ||
b74d24f7 | 228 | int exfat_getattr(struct mnt_idmap *idmap, const struct path *path, |
549c7297 CB |
229 | struct kstat *stat, unsigned int request_mask, |
230 | unsigned int query_flags) | |
98d91704 NJ |
231 | { |
232 | struct inode *inode = d_backing_inode(path->dentry); | |
233 | struct exfat_inode_info *ei = EXFAT_I(inode); | |
234 | ||
b74d24f7 | 235 | generic_fillattr(&nop_mnt_idmap, inode, stat); |
81df1ad4 | 236 | exfat_truncate_atime(&stat->atime); |
98d91704 NJ |
237 | stat->result_mask |= STATX_BTIME; |
238 | stat->btime.tv_sec = ei->i_crtime.tv_sec; | |
239 | stat->btime.tv_nsec = ei->i_crtime.tv_nsec; | |
240 | stat->blksize = EXFAT_SB(inode->i_sb)->cluster_size; | |
241 | return 0; | |
242 | } | |
243 | ||
c1632a0f | 244 | int exfat_setattr(struct mnt_idmap *idmap, struct dentry *dentry, |
549c7297 | 245 | struct iattr *attr) |
98d91704 NJ |
246 | { |
247 | struct exfat_sb_info *sbi = EXFAT_SB(dentry->d_sb); | |
248 | struct inode *inode = dentry->d_inode; | |
249 | unsigned int ia_valid; | |
250 | int error; | |
251 | ||
252 | if ((attr->ia_valid & ATTR_SIZE) && | |
253 | attr->ia_size > i_size_read(inode)) { | |
254 | error = exfat_cont_expand(inode, attr->ia_size); | |
255 | if (error || attr->ia_valid == ATTR_SIZE) | |
256 | return error; | |
257 | attr->ia_valid &= ~ATTR_SIZE; | |
258 | } | |
259 | ||
260 | /* Check for setting the inode time. */ | |
261 | ia_valid = attr->ia_valid; | |
262 | if ((ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET | ATTR_TIMES_SET)) && | |
263 | exfat_allow_set_time(sbi, inode)) { | |
264 | attr->ia_valid &= ~(ATTR_MTIME_SET | ATTR_ATIME_SET | | |
265 | ATTR_TIMES_SET); | |
266 | } | |
267 | ||
c1632a0f | 268 | error = setattr_prepare(&nop_mnt_idmap, dentry, attr); |
98d91704 NJ |
269 | attr->ia_valid = ia_valid; |
270 | if (error) | |
271 | goto out; | |
272 | ||
273 | if (((attr->ia_valid & ATTR_UID) && | |
274 | !uid_eq(attr->ia_uid, sbi->options.fs_uid)) || | |
275 | ((attr->ia_valid & ATTR_GID) && | |
276 | !gid_eq(attr->ia_gid, sbi->options.fs_gid)) || | |
277 | ((attr->ia_valid & ATTR_MODE) && | |
278 | (attr->ia_mode & ~(S_IFREG | S_IFLNK | S_IFDIR | 0777)))) { | |
279 | error = -EPERM; | |
280 | goto out; | |
281 | } | |
282 | ||
283 | /* | |
284 | * We don't return -EPERM here. Yes, strange, but this is too | |
285 | * old behavior. | |
286 | */ | |
287 | if (attr->ia_valid & ATTR_MODE) { | |
288 | if (exfat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0) | |
289 | attr->ia_valid &= ~ATTR_MODE; | |
290 | } | |
291 | ||
4493895b YM |
292 | if (attr->ia_valid & ATTR_SIZE) |
293 | inode->i_mtime = inode->i_ctime = current_time(inode); | |
294 | ||
c1632a0f | 295 | setattr_copy(&nop_mnt_idmap, inode, attr); |
4493895b YM |
296 | exfat_truncate_atime(&inode->i_atime); |
297 | ||
98d91704 NJ |
298 | if (attr->ia_valid & ATTR_SIZE) { |
299 | error = exfat_block_truncate_page(inode, attr->ia_size); | |
300 | if (error) | |
301 | goto out; | |
302 | ||
303 | down_write(&EXFAT_I(inode)->truncate_lock); | |
304 | truncate_setsize(inode, attr->ia_size); | |
4493895b YM |
305 | |
306 | /* | |
307 | * __exfat_write_inode() is called from exfat_truncate(), inode | |
308 | * is already written by it, so mark_inode_dirty() is unneeded. | |
309 | */ | |
e981917b | 310 | exfat_truncate(inode); |
98d91704 | 311 | up_write(&EXFAT_I(inode)->truncate_lock); |
4493895b YM |
312 | } else |
313 | mark_inode_dirty(inode); | |
98d91704 NJ |
314 | |
315 | out: | |
316 | return error; | |
317 | } | |
318 | ||
654762df HK |
319 | static int exfat_ioctl_fitrim(struct inode *inode, unsigned long arg) |
320 | { | |
654762df HK |
321 | struct fstrim_range range; |
322 | int ret = 0; | |
323 | ||
324 | if (!capable(CAP_SYS_ADMIN)) | |
325 | return -EPERM; | |
326 | ||
70200574 | 327 | if (!bdev_max_discard_sectors(inode->i_sb->s_bdev)) |
654762df HK |
328 | return -EOPNOTSUPP; |
329 | ||
330 | if (copy_from_user(&range, (struct fstrim_range __user *)arg, sizeof(range))) | |
331 | return -EFAULT; | |
332 | ||
333 | range.minlen = max_t(unsigned int, range.minlen, | |
7b47ef52 | 334 | bdev_discard_granularity(inode->i_sb->s_bdev)); |
654762df HK |
335 | |
336 | ret = exfat_trim_fs(inode, &range); | |
337 | if (ret < 0) | |
338 | return ret; | |
339 | ||
340 | if (copy_to_user((struct fstrim_range __user *)arg, &range, sizeof(range))) | |
341 | return -EFAULT; | |
342 | ||
343 | return 0; | |
344 | } | |
345 | ||
346 | long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) | |
347 | { | |
348 | struct inode *inode = file_inode(filp); | |
349 | ||
350 | switch (cmd) { | |
351 | case FITRIM: | |
352 | return exfat_ioctl_fitrim(inode, arg); | |
353 | default: | |
354 | return -ENOTTY; | |
355 | } | |
356 | } | |
357 | ||
358 | #ifdef CONFIG_COMPAT | |
359 | long exfat_compat_ioctl(struct file *filp, unsigned int cmd, | |
360 | unsigned long arg) | |
361 | { | |
362 | return exfat_ioctl(filp, cmd, (unsigned long)compat_ptr(arg)); | |
363 | } | |
364 | #endif | |
365 | ||
5267456e SS |
366 | int exfat_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync) |
367 | { | |
368 | struct inode *inode = filp->f_mapping->host; | |
369 | int err; | |
370 | ||
371 | err = __generic_file_fsync(filp, start, end, datasync); | |
372 | if (err) | |
373 | return err; | |
374 | ||
375 | err = sync_blockdev(inode->i_sb->s_bdev); | |
376 | if (err) | |
377 | return err; | |
378 | ||
c6bf3f0e | 379 | return blkdev_issue_flush(inode->i_sb->s_bdev); |
5267456e SS |
380 | } |
381 | ||
98d91704 | 382 | const struct file_operations exfat_file_operations = { |
03577948 ES |
383 | .llseek = generic_file_llseek, |
384 | .read_iter = generic_file_read_iter, | |
385 | .write_iter = generic_file_write_iter, | |
654762df HK |
386 | .unlocked_ioctl = exfat_ioctl, |
387 | #ifdef CONFIG_COMPAT | |
388 | .compat_ioctl = exfat_compat_ioctl, | |
389 | #endif | |
03577948 | 390 | .mmap = generic_file_mmap, |
5267456e | 391 | .fsync = exfat_file_fsync, |
03577948 ES |
392 | .splice_read = generic_file_splice_read, |
393 | .splice_write = iter_file_splice_write, | |
98d91704 NJ |
394 | }; |
395 | ||
396 | const struct inode_operations exfat_file_inode_operations = { | |
397 | .setattr = exfat_setattr, | |
398 | .getattr = exfat_getattr, | |
399 | }; |