]>
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> | |
7 | #include <linux/cred.h> | |
8 | #include <linux/buffer_head.h> | |
5267456e | 9 | #include <linux/blkdev.h> |
98d91704 NJ |
10 | |
11 | #include "exfat_raw.h" | |
12 | #include "exfat_fs.h" | |
13 | ||
14 | static int exfat_cont_expand(struct inode *inode, loff_t size) | |
15 | { | |
16 | struct address_space *mapping = inode->i_mapping; | |
17 | loff_t start = i_size_read(inode), count = size - i_size_read(inode); | |
18 | int err, err2; | |
19 | ||
20 | err = generic_cont_expand_simple(inode, size); | |
21 | if (err) | |
22 | return err; | |
23 | ||
24 | inode->i_ctime = inode->i_mtime = current_time(inode); | |
25 | mark_inode_dirty(inode); | |
26 | ||
27 | if (!IS_SYNC(inode)) | |
28 | return 0; | |
29 | ||
30 | err = filemap_fdatawrite_range(mapping, start, start + count - 1); | |
31 | err2 = sync_mapping_buffers(mapping); | |
32 | if (!err) | |
33 | err = err2; | |
34 | err2 = write_inode_now(inode, 1); | |
35 | if (!err) | |
36 | err = err2; | |
37 | if (err) | |
38 | return err; | |
39 | ||
40 | return filemap_fdatawait_range(mapping, start, start + count - 1); | |
41 | } | |
42 | ||
43 | static bool exfat_allow_set_time(struct exfat_sb_info *sbi, struct inode *inode) | |
44 | { | |
45 | mode_t allow_utime = sbi->options.allow_utime; | |
46 | ||
47 | if (!uid_eq(current_fsuid(), inode->i_uid)) { | |
48 | if (in_group_p(inode->i_gid)) | |
49 | allow_utime >>= 3; | |
50 | if (allow_utime & MAY_WRITE) | |
51 | return true; | |
52 | } | |
53 | ||
54 | /* use a default check */ | |
55 | return false; | |
56 | } | |
57 | ||
58 | static int exfat_sanitize_mode(const struct exfat_sb_info *sbi, | |
59 | struct inode *inode, umode_t *mode_ptr) | |
60 | { | |
61 | mode_t i_mode, mask, perm; | |
62 | ||
63 | i_mode = inode->i_mode; | |
64 | ||
65 | mask = (S_ISREG(i_mode) || S_ISLNK(i_mode)) ? | |
66 | sbi->options.fs_fmask : sbi->options.fs_dmask; | |
67 | perm = *mode_ptr & ~(S_IFMT | mask); | |
68 | ||
69 | /* Of the r and x bits, all (subject to umask) must be present.*/ | |
70 | if ((perm & 0555) != (i_mode & 0555)) | |
71 | return -EPERM; | |
72 | ||
73 | if (exfat_mode_can_hold_ro(inode)) { | |
74 | /* | |
75 | * Of the w bits, either all (subject to umask) or none must | |
76 | * be present. | |
77 | */ | |
78 | if ((perm & 0222) && ((perm & 0222) != (0222 & ~mask))) | |
79 | return -EPERM; | |
80 | } else { | |
81 | /* | |
82 | * If exfat_mode_can_hold_ro(inode) is false, can't change | |
83 | * w bits. | |
84 | */ | |
85 | if ((perm & 0222) != (0222 & ~mask)) | |
86 | return -EPERM; | |
87 | } | |
88 | ||
89 | *mode_ptr &= S_IFMT | perm; | |
90 | ||
91 | return 0; | |
92 | } | |
93 | ||
94 | /* resize the file length */ | |
95 | int __exfat_truncate(struct inode *inode, loff_t new_size) | |
96 | { | |
97 | unsigned int num_clusters_new, num_clusters_phys; | |
98 | unsigned int last_clu = EXFAT_FREE_CLUSTER; | |
99 | struct exfat_chain clu; | |
98d91704 NJ |
100 | struct super_block *sb = inode->i_sb; |
101 | struct exfat_sb_info *sbi = EXFAT_SB(sb); | |
102 | struct exfat_inode_info *ei = EXFAT_I(inode); | |
98d91704 NJ |
103 | int evict = (ei->dir.dir == DIR_DELETED) ? 1 : 0; |
104 | ||
105 | /* check if the given file ID is opened */ | |
106 | if (ei->type != TYPE_FILE && ei->type != TYPE_DIR) | |
107 | return -EPERM; | |
108 | ||
109 | exfat_set_vol_flags(sb, VOL_DIRTY); | |
110 | ||
111 | num_clusters_new = EXFAT_B_TO_CLU_ROUND_UP(i_size_read(inode), sbi); | |
112 | num_clusters_phys = | |
113 | EXFAT_B_TO_CLU_ROUND_UP(EXFAT_I(inode)->i_size_ondisk, sbi); | |
114 | ||
115 | exfat_chain_set(&clu, ei->start_clu, num_clusters_phys, ei->flags); | |
116 | ||
117 | if (new_size > 0) { | |
118 | /* | |
119 | * Truncate FAT chain num_clusters after the first cluster | |
120 | * num_clusters = min(new, phys); | |
121 | */ | |
122 | unsigned int num_clusters = | |
123 | min(num_clusters_new, num_clusters_phys); | |
124 | ||
125 | /* | |
126 | * Follow FAT chain | |
127 | * (defensive coding - works fine even with corrupted FAT table | |
128 | */ | |
129 | if (clu.flags == ALLOC_NO_FAT_CHAIN) { | |
130 | clu.dir += num_clusters; | |
131 | clu.size -= num_clusters; | |
132 | } else { | |
133 | while (num_clusters > 0) { | |
134 | last_clu = clu.dir; | |
135 | if (exfat_get_next_cluster(sb, &(clu.dir))) | |
136 | return -EIO; | |
137 | ||
138 | num_clusters--; | |
139 | clu.size--; | |
140 | } | |
141 | } | |
142 | } else { | |
143 | ei->flags = ALLOC_NO_FAT_CHAIN; | |
144 | ei->start_clu = EXFAT_EOF_CLUSTER; | |
145 | } | |
146 | ||
147 | i_size_write(inode, new_size); | |
148 | ||
149 | if (ei->type == TYPE_FILE) | |
150 | ei->attr |= ATTR_ARCHIVE; | |
151 | ||
152 | /* update the directory entry */ | |
153 | if (!evict) { | |
154 | struct timespec64 ts; | |
943af1fd TK |
155 | struct exfat_dentry *ep, *ep2; |
156 | struct exfat_entry_set_cache *es; | |
98d91704 NJ |
157 | |
158 | es = exfat_get_dentry_set(sb, &(ei->dir), ei->entry, | |
943af1fd | 159 | ES_ALL_ENTRIES); |
98d91704 NJ |
160 | if (!es) |
161 | return -EIO; | |
943af1fd TK |
162 | ep = exfat_get_dentry_cached(es, 0); |
163 | ep2 = exfat_get_dentry_cached(es, 1); | |
98d91704 NJ |
164 | |
165 | ts = current_time(inode); | |
166 | exfat_set_entry_time(sbi, &ts, | |
167 | &ep->dentry.file.modify_tz, | |
168 | &ep->dentry.file.modify_time, | |
169 | &ep->dentry.file.modify_date, | |
ed0f84d3 | 170 | &ep->dentry.file.modify_time_cs); |
98d91704 NJ |
171 | ep->dentry.file.attr = cpu_to_le16(ei->attr); |
172 | ||
173 | /* File size should be zero if there is no cluster allocated */ | |
174 | if (ei->start_clu == EXFAT_EOF_CLUSTER) { | |
29bbb14b NJ |
175 | ep2->dentry.stream.valid_size = 0; |
176 | ep2->dentry.stream.size = 0; | |
98d91704 | 177 | } else { |
29bbb14b NJ |
178 | ep2->dentry.stream.valid_size = cpu_to_le64(new_size); |
179 | ep2->dentry.stream.size = ep->dentry.stream.valid_size; | |
98d91704 NJ |
180 | } |
181 | ||
182 | if (new_size == 0) { | |
183 | /* Any directory can not be truncated to zero */ | |
184 | WARN_ON(ei->type != TYPE_FILE); | |
185 | ||
186 | ep2->dentry.stream.flags = ALLOC_FAT_CHAIN; | |
187 | ep2->dentry.stream.start_clu = EXFAT_FREE_CLUSTER; | |
188 | } | |
189 | ||
943af1fd TK |
190 | exfat_update_dir_chksum_with_entry_set(es); |
191 | exfat_free_dentry_set(es, inode_needs_sync(inode)); | |
98d91704 NJ |
192 | } |
193 | ||
194 | /* cut off from the FAT chain */ | |
195 | if (ei->flags == ALLOC_FAT_CHAIN && last_clu != EXFAT_FREE_CLUSTER && | |
196 | last_clu != EXFAT_EOF_CLUSTER) { | |
197 | if (exfat_ent_set(sb, last_clu, EXFAT_EOF_CLUSTER)) | |
198 | return -EIO; | |
199 | } | |
200 | ||
201 | /* invalidate cache and free the clusters */ | |
202 | /* clear exfat cache */ | |
203 | exfat_cache_inval_inode(inode); | |
204 | ||
205 | /* hint information */ | |
206 | ei->hint_bmap.off = EXFAT_EOF_CLUSTER; | |
207 | ei->hint_bmap.clu = EXFAT_EOF_CLUSTER; | |
208 | if (ei->rwoffset > new_size) | |
209 | ei->rwoffset = new_size; | |
210 | ||
211 | /* hint_stat will be used if this is directory. */ | |
212 | ei->hint_stat.eidx = 0; | |
213 | ei->hint_stat.clu = ei->start_clu; | |
214 | ei->hint_femp.eidx = EXFAT_HINT_NONE; | |
215 | ||
216 | /* free the clusters */ | |
217 | if (exfat_free_cluster(inode, &clu)) | |
218 | return -EIO; | |
219 | ||
220 | exfat_set_vol_flags(sb, VOL_CLEAN); | |
221 | ||
222 | return 0; | |
223 | } | |
224 | ||
225 | void exfat_truncate(struct inode *inode, loff_t size) | |
226 | { | |
227 | struct super_block *sb = inode->i_sb; | |
228 | struct exfat_sb_info *sbi = EXFAT_SB(sb); | |
229 | unsigned int blocksize = 1 << inode->i_blkbits; | |
230 | loff_t aligned_size; | |
231 | int err; | |
232 | ||
233 | mutex_lock(&sbi->s_lock); | |
234 | if (EXFAT_I(inode)->start_clu == 0) { | |
235 | /* | |
236 | * Empty start_clu != ~0 (not allocated) | |
237 | */ | |
238 | exfat_fs_error(sb, "tried to truncate zeroed cluster."); | |
239 | goto write_size; | |
240 | } | |
241 | ||
242 | err = __exfat_truncate(inode, i_size_read(inode)); | |
243 | if (err) | |
244 | goto write_size; | |
245 | ||
246 | inode->i_ctime = inode->i_mtime = current_time(inode); | |
247 | if (IS_DIRSYNC(inode)) | |
248 | exfat_sync_inode(inode); | |
249 | else | |
250 | mark_inode_dirty(inode); | |
251 | ||
252 | inode->i_blocks = ((i_size_read(inode) + (sbi->cluster_size - 1)) & | |
253 | ~(sbi->cluster_size - 1)) >> inode->i_blkbits; | |
254 | write_size: | |
255 | aligned_size = i_size_read(inode); | |
256 | if (aligned_size & (blocksize - 1)) { | |
257 | aligned_size |= (blocksize - 1); | |
258 | aligned_size++; | |
259 | } | |
260 | ||
261 | if (EXFAT_I(inode)->i_size_ondisk > i_size_read(inode)) | |
262 | EXFAT_I(inode)->i_size_ondisk = aligned_size; | |
263 | ||
264 | if (EXFAT_I(inode)->i_size_aligned > i_size_read(inode)) | |
265 | EXFAT_I(inode)->i_size_aligned = aligned_size; | |
266 | mutex_unlock(&sbi->s_lock); | |
267 | } | |
268 | ||
269 | int exfat_getattr(const struct path *path, struct kstat *stat, | |
270 | unsigned int request_mask, unsigned int query_flags) | |
271 | { | |
272 | struct inode *inode = d_backing_inode(path->dentry); | |
273 | struct exfat_inode_info *ei = EXFAT_I(inode); | |
274 | ||
275 | generic_fillattr(inode, stat); | |
81df1ad4 | 276 | exfat_truncate_atime(&stat->atime); |
98d91704 NJ |
277 | stat->result_mask |= STATX_BTIME; |
278 | stat->btime.tv_sec = ei->i_crtime.tv_sec; | |
279 | stat->btime.tv_nsec = ei->i_crtime.tv_nsec; | |
280 | stat->blksize = EXFAT_SB(inode->i_sb)->cluster_size; | |
281 | return 0; | |
282 | } | |
283 | ||
284 | int exfat_setattr(struct dentry *dentry, struct iattr *attr) | |
285 | { | |
286 | struct exfat_sb_info *sbi = EXFAT_SB(dentry->d_sb); | |
287 | struct inode *inode = dentry->d_inode; | |
288 | unsigned int ia_valid; | |
289 | int error; | |
290 | ||
291 | if ((attr->ia_valid & ATTR_SIZE) && | |
292 | attr->ia_size > i_size_read(inode)) { | |
293 | error = exfat_cont_expand(inode, attr->ia_size); | |
294 | if (error || attr->ia_valid == ATTR_SIZE) | |
295 | return error; | |
296 | attr->ia_valid &= ~ATTR_SIZE; | |
297 | } | |
298 | ||
299 | /* Check for setting the inode time. */ | |
300 | ia_valid = attr->ia_valid; | |
301 | if ((ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET | ATTR_TIMES_SET)) && | |
302 | exfat_allow_set_time(sbi, inode)) { | |
303 | attr->ia_valid &= ~(ATTR_MTIME_SET | ATTR_ATIME_SET | | |
304 | ATTR_TIMES_SET); | |
305 | } | |
306 | ||
307 | error = setattr_prepare(dentry, attr); | |
308 | attr->ia_valid = ia_valid; | |
309 | if (error) | |
310 | goto out; | |
311 | ||
312 | if (((attr->ia_valid & ATTR_UID) && | |
313 | !uid_eq(attr->ia_uid, sbi->options.fs_uid)) || | |
314 | ((attr->ia_valid & ATTR_GID) && | |
315 | !gid_eq(attr->ia_gid, sbi->options.fs_gid)) || | |
316 | ((attr->ia_valid & ATTR_MODE) && | |
317 | (attr->ia_mode & ~(S_IFREG | S_IFLNK | S_IFDIR | 0777)))) { | |
318 | error = -EPERM; | |
319 | goto out; | |
320 | } | |
321 | ||
322 | /* | |
323 | * We don't return -EPERM here. Yes, strange, but this is too | |
324 | * old behavior. | |
325 | */ | |
326 | if (attr->ia_valid & ATTR_MODE) { | |
327 | if (exfat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0) | |
328 | attr->ia_valid &= ~ATTR_MODE; | |
329 | } | |
330 | ||
331 | if (attr->ia_valid & ATTR_SIZE) { | |
332 | error = exfat_block_truncate_page(inode, attr->ia_size); | |
333 | if (error) | |
334 | goto out; | |
335 | ||
336 | down_write(&EXFAT_I(inode)->truncate_lock); | |
337 | truncate_setsize(inode, attr->ia_size); | |
338 | exfat_truncate(inode, attr->ia_size); | |
339 | up_write(&EXFAT_I(inode)->truncate_lock); | |
340 | } | |
341 | ||
342 | setattr_copy(inode, attr); | |
81df1ad4 | 343 | exfat_truncate_atime(&inode->i_atime); |
98d91704 NJ |
344 | mark_inode_dirty(inode); |
345 | ||
346 | out: | |
347 | return error; | |
348 | } | |
349 | ||
5267456e SS |
350 | int exfat_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync) |
351 | { | |
352 | struct inode *inode = filp->f_mapping->host; | |
353 | int err; | |
354 | ||
355 | err = __generic_file_fsync(filp, start, end, datasync); | |
356 | if (err) | |
357 | return err; | |
358 | ||
359 | err = sync_blockdev(inode->i_sb->s_bdev); | |
360 | if (err) | |
361 | return err; | |
362 | ||
363 | return blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL); | |
364 | } | |
365 | ||
98d91704 | 366 | const struct file_operations exfat_file_operations = { |
03577948 ES |
367 | .llseek = generic_file_llseek, |
368 | .read_iter = generic_file_read_iter, | |
369 | .write_iter = generic_file_write_iter, | |
370 | .mmap = generic_file_mmap, | |
5267456e | 371 | .fsync = exfat_file_fsync, |
03577948 ES |
372 | .splice_read = generic_file_splice_read, |
373 | .splice_write = iter_file_splice_write, | |
98d91704 NJ |
374 | }; |
375 | ||
376 | const struct inode_operations exfat_file_inode_operations = { | |
377 | .setattr = exfat_setattr, | |
378 | .getattr = exfat_getattr, | |
379 | }; |