1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
4 */
5
6 #include <linux/init.h>
7 #include <linux/buffer_head.h>
8 #include <linux/mpage.h>
9 #include <linux/bio.h>
10 #include <linux/blkdev.h>
11 #include <linux/time.h>
12 #include <linux/writeback.h>
13 #include <linux/uio.h>
14 #include <linux/random.h>
15 #include <linux/iversion.h>
16
17 #include "exfat_raw.h"
18 #include "exfat_fs.h"
19
20 int __exfat_write_inode(struct inode *inode, int sync)
21 {
22 unsigned long long on_disk_size;
23 struct exfat_dentry *ep, *ep2;
24 struct exfat_entry_set_cache es;
25 struct super_block *sb = inode->i_sb;
26 struct exfat_sb_info *sbi = EXFAT_SB(sb);
27 struct exfat_inode_info *ei = EXFAT_I(inode);
28 bool is_dir = (ei->type == TYPE_DIR) ? true : false;
29 struct timespec64 ts;
30
31 if (inode->i_ino == EXFAT_ROOT_INO)
32 return 0;
33
34 /*
35 * If the inode is already unlinked, there is no need for updating it.
36 */
37 if (ei->dir.dir == DIR_DELETED)
38 return 0;
39
40 if (is_dir && ei->dir.dir == sbi->root_dir && ei->entry == -1)
41 return 0;
42
43 exfat_set_volume_dirty(sb);
44
45 /* get the directory entry of given file or directory */
46 if (exfat_get_dentry_set(&es, sb, &(ei->dir), ei->entry, ES_ALL_ENTRIES))
47 return -EIO;
48 ep = exfat_get_dentry_cached(&es, ES_IDX_FILE);
49 ep2 = exfat_get_dentry_cached(&es, ES_IDX_STREAM);
50
51 ep->dentry.file.attr = cpu_to_le16(exfat_make_attr(inode));
52
53 /* set FILE_INFO structure using the acquired struct exfat_dentry */
54 exfat_set_entry_time(sbi, &ei->i_crtime,
55 &ep->dentry.file.create_tz,
56 &ep->dentry.file.create_time,
57 &ep->dentry.file.create_date,
58 &ep->dentry.file.create_time_cs);
59 ts = inode_get_mtime(inode);
60 exfat_set_entry_time(sbi, &ts,
61 &ep->dentry.file.modify_tz,
62 &ep->dentry.file.modify_time,
63 &ep->dentry.file.modify_date,
64 &ep->dentry.file.modify_time_cs);
65 ts = inode_get_atime(inode);
66 exfat_set_entry_time(sbi, &ts,
67 &ep->dentry.file.access_tz,
68 &ep->dentry.file.access_time,
69 &ep->dentry.file.access_date,
70 NULL);
71
72 /* File size should be zero if there is no cluster allocated */
73 on_disk_size = i_size_read(inode);
74
75 if (ei->start_clu == EXFAT_EOF_CLUSTER)
76 on_disk_size = 0;
77
78 ep2->dentry.stream.size = cpu_to_le64(on_disk_size);
79 /*
80 * mmap write does not use exfat_write_end(), valid_size may be
81 * extended to the sector-aligned length in exfat_get_block().
82 * So we need to fixup valid_size to the writren length.
83 */
84 if (on_disk_size < ei->valid_size)
85 ep2->dentry.stream.valid_size = ep2->dentry.stream.size;
86 else
87 ep2->dentry.stream.valid_size = cpu_to_le64(ei->valid_size);
88
89 if (on_disk_size) {
90 ep2->dentry.stream.flags = ei->flags;
91 ep2->dentry.stream.start_clu = cpu_to_le32(ei->start_clu);
92 } else {
93 ep2->dentry.stream.flags = ALLOC_FAT_CHAIN;
94 ep2->dentry.stream.start_clu = EXFAT_FREE_CLUSTER;
95 }
96
97 exfat_update_dir_chksum(&es);
98 return exfat_put_dentry_set(&es, sync);
99 }
100
101 int exfat_write_inode(struct inode *inode, struct writeback_control *wbc)
102 {
103 int ret;
104
105 mutex_lock(&EXFAT_SB(inode->i_sb)->s_lock);
106 ret = __exfat_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
107 mutex_unlock(&EXFAT_SB(inode->i_sb)->s_lock);
108
109 return ret;
110 }
111
112 void exfat_sync_inode(struct inode *inode)
113 {
114 lockdep_assert_held(&EXFAT_SB(inode->i_sb)->s_lock);
115 __exfat_write_inode(inode, 1);
116 }
117
118 /*
119 * Input: inode, (logical) clu_offset, target allocation area
120 * Output: errcode, cluster number
121 * *clu = (~0), if it's unable to allocate a new cluster
122 */
123 static int exfat_map_cluster(struct inode *inode, unsigned int clu_offset,
124 unsigned int *clu, int create)
125 {
126 int ret;
127 unsigned int last_clu;
128 struct exfat_chain new_clu;
129 struct super_block *sb = inode->i_sb;
130 struct exfat_sb_info *sbi = EXFAT_SB(sb);
131 struct exfat_inode_info *ei = EXFAT_I(inode);
132 unsigned int local_clu_offset = clu_offset;
133 unsigned int num_to_be_allocated = 0, num_clusters = 0;
134
135 if (ei->i_size_ondisk > 0)
136 num_clusters =
137 EXFAT_B_TO_CLU_ROUND_UP(ei->i_size_ondisk, sbi);
138
139 if (clu_offset >= num_clusters)
140 num_to_be_allocated = clu_offset - num_clusters + 1;
141
142 if (!create && (num_to_be_allocated > 0)) {
143 *clu = EXFAT_EOF_CLUSTER;
144 return 0;
145 }
146
147 *clu = last_clu = ei->start_clu;
148
149 if (ei->flags == ALLOC_NO_FAT_CHAIN) {
150 if (clu_offset > 0 && *clu != EXFAT_EOF_CLUSTER) {
151 last_clu += clu_offset - 1;
152
153 if (clu_offset == num_clusters)
154 *clu = EXFAT_EOF_CLUSTER;
155 else
156 *clu += clu_offset;
157 }
158 } else if (ei->type == TYPE_FILE) {
159 unsigned int fclus = 0;
160 int err = exfat_get_cluster(inode, clu_offset,
161 &fclus, clu, &last_clu, 1);
162 if (err)
163 return -EIO;
164
165 clu_offset -= fclus;
166 } else {
167 /* hint information */
168 if (clu_offset > 0 && ei->hint_bmap.off != EXFAT_EOF_CLUSTER &&
169 ei->hint_bmap.off > 0 && clu_offset >= ei->hint_bmap.off) {
170 clu_offset -= ei->hint_bmap.off;
171 /* hint_bmap.clu should be valid */
172 WARN_ON(ei->hint_bmap.clu < 2);
173 *clu = ei->hint_bmap.clu;
174 }
175
176 while (clu_offset > 0 && *clu != EXFAT_EOF_CLUSTER) {
177 last_clu = *clu;
178 if (exfat_get_next_cluster(sb, clu))
179 return -EIO;
180 clu_offset--;
181 }
182 }
183
184 if (*clu == EXFAT_EOF_CLUSTER) {
185 exfat_set_volume_dirty(sb);
186
187 new_clu.dir = (last_clu == EXFAT_EOF_CLUSTER) ?
188 EXFAT_EOF_CLUSTER : last_clu + 1;
189 new_clu.size = 0;
190 new_clu.flags = ei->flags;
191
192 /* allocate a cluster */
193 if (num_to_be_allocated < 1) {
194 /* Broken FAT (i_sze > allocated FAT) */
195 exfat_fs_error(sb, "broken FAT chain.");
196 return -EIO;
197 }
198
199 ret = exfat_alloc_cluster(inode, num_to_be_allocated, &new_clu,
200 inode_needs_sync(inode));
201 if (ret)
202 return ret;
203
204 if (new_clu.dir == EXFAT_EOF_CLUSTER ||
205 new_clu.dir == EXFAT_FREE_CLUSTER) {
206 exfat_fs_error(sb,
207 "bogus cluster new allocated (last_clu : %u, new_clu : %u)",
208 last_clu, new_clu.dir);
209 return -EIO;
210 }
211
212 /* append to the FAT chain */
213 if (last_clu == EXFAT_EOF_CLUSTER) {
214 if (new_clu.flags == ALLOC_FAT_CHAIN)
215 ei->flags = ALLOC_FAT_CHAIN;
216 ei->start_clu = new_clu.dir;
217 } else {
218 if (new_clu.flags != ei->flags) {
219 /* no-fat-chain bit is disabled,
220 * so fat-chain should be synced with
221 * alloc-bitmap
222 */
223 exfat_chain_cont_cluster(sb, ei->start_clu,
224 num_clusters);
225 ei->flags = ALLOC_FAT_CHAIN;
226 }
227 if (new_clu.flags == ALLOC_FAT_CHAIN)
228 if (exfat_ent_set(sb, last_clu, new_clu.dir))
229 return -EIO;
230 }
231
232 num_clusters += num_to_be_allocated;
233 *clu = new_clu.dir;
234
235 inode->i_blocks += EXFAT_CLU_TO_B(num_to_be_allocated, sbi) >> 9;
236
237 /*
238 * Move *clu pointer along FAT chains (hole care) because the
239 * caller of this function expect *clu to be the last cluster.
240 * This only works when num_to_be_allocated >= 2,
241 * *clu = (the first cluster of the allocated chain) =>
242 * (the last cluster of ...)
243 */
244 if (ei->flags == ALLOC_NO_FAT_CHAIN) {
245 *clu += num_to_be_allocated - 1;
246 } else {
247 while (num_to_be_allocated > 1) {
248 if (exfat_get_next_cluster(sb, clu))
249 return -EIO;
250 num_to_be_allocated--;
251 }
252 }
253
254 }
255
256 /* hint information */
257 ei->hint_bmap.off = local_clu_offset;
258 ei->hint_bmap.clu = *clu;
259
260 return 0;
261 }
262
263 static int exfat_map_new_buffer(struct exfat_inode_info *ei,
264 struct buffer_head *bh, loff_t pos)
265 {
266 if (buffer_delay(bh) && pos > ei->i_size_aligned)
267 return -EIO;
268 set_buffer_new(bh);
269
270 /*
271 * Adjust i_size_aligned if i_size_ondisk is bigger than it.
272 */
273 if (ei->i_size_ondisk > ei->i_size_aligned)
274 ei->i_size_aligned = ei->i_size_ondisk;
275 return 0;
276 }
277
278 static int exfat_get_block(struct inode *inode, sector_t iblock,
279 struct buffer_head *bh_result, int create)
280 {
281 struct exfat_inode_info *ei = EXFAT_I(inode);
282 struct super_block *sb = inode->i_sb;
283 struct exfat_sb_info *sbi = EXFAT_SB(sb);
284 unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
285 int err = 0;
286 unsigned long mapped_blocks = 0;
287 unsigned int cluster, sec_offset;
288 sector_t last_block;
289 sector_t phys = 0;
290 sector_t valid_blks;
291 loff_t pos;
292
293 mutex_lock(&sbi->s_lock);
294 last_block = EXFAT_B_TO_BLK_ROUND_UP(i_size_read(inode), sb);
295 if (iblock >= last_block && !create)
296 goto done;
297
298 /* Is this block already allocated? */
299 err = exfat_map_cluster(inode, iblock >> sbi->sect_per_clus_bits,
300 &cluster, create);
301 if (err) {
302 if (err != -ENOSPC)
303 exfat_fs_error_ratelimit(sb,
304 "failed to bmap (inode : %p iblock : %llu, err : %d)",
305 inode, (unsigned long long)iblock, err);
306 goto unlock_ret;
307 }
308
309 if (cluster == EXFAT_EOF_CLUSTER)
310 goto done;
311
312 /* sector offset in cluster */
313 sec_offset = iblock & (sbi->sect_per_clus - 1);
314
315 phys = exfat_cluster_to_sector(sbi, cluster) + sec_offset;
316 mapped_blocks = sbi->sect_per_clus - sec_offset;
317 max_blocks = min(mapped_blocks, max_blocks);
318
319 pos = EXFAT_BLK_TO_B((iblock + 1), sb);
320 if ((create && iblock >= last_block) || buffer_delay(bh_result)) {
321 if (ei->i_size_ondisk < pos)
322 ei->i_size_ondisk = pos;
323 }
324
325 map_bh(bh_result, sb, phys);
326 if (buffer_delay(bh_result))
327 clear_buffer_delay(bh_result);
328
329 if (create) {
330 valid_blks = EXFAT_B_TO_BLK_ROUND_UP(ei->valid_size, sb);
331
332 if (iblock + max_blocks < valid_blks) {
333 /* The range has been written, map it */
334 goto done;
335 } else if (iblock < valid_blks) {
336 /*
337 * The range has been partially written,
338 * map the written part.
339 */
340 max_blocks = valid_blks - iblock;
341 goto done;
342 }
343
344 /* The area has not been written, map and mark as new. */
345 err = exfat_map_new_buffer(ei, bh_result, pos);
346 if (err) {
347 exfat_fs_error(sb,
348 "requested for bmap out of range(pos : (%llu) > i_size_aligned(%llu)\n",
349 pos, ei->i_size_aligned);
350 goto unlock_ret;
351 }
352
353 ei->valid_size = EXFAT_BLK_TO_B(iblock + max_blocks, sb);
354 mark_inode_dirty(inode);
355 } else {
356 valid_blks = EXFAT_B_TO_BLK(ei->valid_size, sb);
357
358 if (iblock + max_blocks < valid_blks) {
359 /* The range has been written, map it */
360 goto done;
361 } else if (iblock < valid_blks) {
362 /*
363 * The area has been partially written,
364 * map the written part.
365 */
366 max_blocks = valid_blks - iblock;
367 goto done;
368 } else if (iblock == valid_blks &&
369 (ei->valid_size & (sb->s_blocksize - 1))) {
370 /*
371 * The block has been partially written,
372 * zero the unwritten part and map the block.
373 */
374 loff_t size, off;
375
376 max_blocks = 1;
377
378 /*
379 * For direct read, the unwritten part will be zeroed in
380 * exfat_direct_IO()
381 */
382 if (!bh_result->b_folio)
383 goto done;
384
385 pos -= sb->s_blocksize;
386 size = ei->valid_size - pos;
387 off = pos & (PAGE_SIZE - 1);
388
389 folio_set_bh(bh_result, bh_result->b_folio, off);
390 err = bh_read(bh_result, 0);
391 if (err < 0)
392 goto unlock_ret;
393
394 folio_zero_segment(bh_result->b_folio, off + size,
395 off + sb->s_blocksize);
396 } else {
397 /*
398 * The range has not been written, clear the mapped flag
399 * to only zero the cache and do not read from disk.
400 */
401 clear_buffer_mapped(bh_result);
402 }
403 }
404 done:
405 bh_result->b_size = EXFAT_BLK_TO_B(max_blocks, sb);
406 unlock_ret:
407 mutex_unlock(&sbi->s_lock);
408 return err;
409 }
410
411 static int exfat_read_folio(struct file *file, struct folio *folio)
412 {
413 return mpage_read_folio(folio, exfat_get_block);
414 }
415
416 static void exfat_readahead(struct readahead_control *rac)
417 {
418 struct address_space *mapping = rac->mapping;
419 struct inode *inode = mapping->host;
420 struct exfat_inode_info *ei = EXFAT_I(inode);
421 loff_t pos = readahead_pos(rac);
422
423 /* Range cross valid_size, read it page by page. */
424 if (ei->valid_size < i_size_read(inode) &&
425 pos <= ei->valid_size &&
426 ei->valid_size < pos + readahead_length(rac))
427 return;
428
429 mpage_readahead(rac, exfat_get_block);
430 }
431
432 static int exfat_writepages(struct address_space *mapping,
433 struct writeback_control *wbc)
434 {
435 return mpage_writepages(mapping, wbc, exfat_get_block);
436 }
437
438 static void exfat_write_failed(struct address_space *mapping, loff_t to)
439 {
440 struct inode *inode = mapping->host;
441
442 if (to > i_size_read(inode)) {
443 truncate_pagecache(inode, i_size_read(inode));
444 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
445 exfat_truncate(inode);
446 }
447 }
448
449 static int exfat_write_begin(struct file *file, struct address_space *mapping,
450 loff_t pos, unsigned int len,
451 struct page **pagep, void **fsdata)
452 {
453 int ret;
454
455 *pagep = NULL;
456 ret = block_write_begin(mapping, pos, len, pagep, exfat_get_block);
457
458 if (ret < 0)
459 exfat_write_failed(mapping, pos+len);
460
461 return ret;
462 }
463
464 static int exfat_write_end(struct file *file, struct address_space *mapping,
465 loff_t pos, unsigned int len, unsigned int copied,
466 struct page *pagep, void *fsdata)
467 {
468 struct inode *inode = mapping->host;
469 struct exfat_inode_info *ei = EXFAT_I(inode);
470 int err;
471
472 err = generic_write_end(file, mapping, pos, len, copied, pagep, fsdata);
473
474 if (ei->i_size_aligned < i_size_read(inode)) {
475 exfat_fs_error(inode->i_sb,
476 "invalid size(size(%llu) > aligned(%llu)\n",
477 i_size_read(inode), ei->i_size_aligned);
478 return -EIO;
479 }
480
481 if (err < len)
482 exfat_write_failed(mapping, pos+len);
483
484 if (!(err < 0) && pos + err > ei->valid_size) {
485 ei->valid_size = pos + err;
486 mark_inode_dirty(inode);
487 }
488
489 if (!(err < 0) && !(ei->attr & EXFAT_ATTR_ARCHIVE)) {
490 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
491 ei->attr |= EXFAT_ATTR_ARCHIVE;
492 mark_inode_dirty(inode);
493 }
494
495 return err;
496 }
497
498 static ssize_t exfat_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
499 {
500 struct address_space *mapping = iocb->ki_filp->f_mapping;
501 struct inode *inode = mapping->host;
502 struct exfat_inode_info *ei = EXFAT_I(inode);
503 loff_t pos = iocb->ki_pos;
504 loff_t size = pos + iov_iter_count(iter);
505 int rw = iov_iter_rw(iter);
506 ssize_t ret;
507
508 if (rw == WRITE) {
509 /*
510 * FIXME: blockdev_direct_IO() doesn't use ->write_begin(),
511 * so we need to update the ->i_size_aligned to block boundary.
512 *
513 * But we must fill the remaining area or hole by nul for
514 * updating ->i_size_aligned
515 *
516 * Return 0, and fallback to normal buffered write.
517 */
518 if (EXFAT_I(inode)->i_size_aligned < size)
519 return 0;
520 }
521
522 /*
523 * Need to use the DIO_LOCKING for avoiding the race
524 * condition of exfat_get_block() and ->truncate().
525 */
526 ret = blockdev_direct_IO(iocb, inode, iter, exfat_get_block);
527 if (ret < 0) {
528 if (rw == WRITE && ret != -EIOCBQUEUED)
529 exfat_write_failed(mapping, size);
530
531 return ret;
532 } else
533 size = pos + ret;
534
535 /* zero the unwritten part in the partially written block */
536 if (rw == READ && pos < ei->valid_size && ei->valid_size < size) {
537 iov_iter_revert(iter, size - ei->valid_size);
538 iov_iter_zero(size - ei->valid_size, iter);
539 }
540
541 return ret;
542 }
543
544 static sector_t exfat_aop_bmap(struct address_space *mapping, sector_t block)
545 {
546 sector_t blocknr;
547
548 /* exfat_get_cluster() assumes the requested blocknr isn't truncated. */
549 down_read(&EXFAT_I(mapping->host)->truncate_lock);
550 blocknr = generic_block_bmap(mapping, block, exfat_get_block);
551 up_read(&EXFAT_I(mapping->host)->truncate_lock);
552 return blocknr;
553 }
554
555 /*
556 * exfat_block_truncate_page() zeroes out a mapping from file offset `from'
557 * up to the end of the block which corresponds to `from'.
558 * This is required during truncate to physically zeroout the tail end
559 * of that block so it doesn't yield old data if the file is later grown.
560 * Also, avoid causing failure from fsx for cases of "data past EOF"
561 */
562 int exfat_block_truncate_page(struct inode *inode, loff_t from)
563 {
564 return block_truncate_page(inode->i_mapping, from, exfat_get_block);
565 }
566
567 static const struct address_space_operations exfat_aops = {
568 .dirty_folio = block_dirty_folio,
569 .invalidate_folio = block_invalidate_folio,
570 .read_folio = exfat_read_folio,
571 .readahead = exfat_readahead,
572 .writepages = exfat_writepages,
573 .write_begin = exfat_write_begin,
574 .write_end = exfat_write_end,
575 .direct_IO = exfat_direct_IO,
576 .bmap = exfat_aop_bmap,
577 .migrate_folio = buffer_migrate_folio,
578 };
579
580 static inline unsigned long exfat_hash(loff_t i_pos)
581 {
582 return hash_32(i_pos, EXFAT_HASH_BITS);
583 }
584
585 void exfat_hash_inode(struct inode *inode, loff_t i_pos)
586 {
587 struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
588 struct hlist_head *head = sbi->inode_hashtable + exfat_hash(i_pos);
589
590 spin_lock(&sbi->inode_hash_lock);
591 EXFAT_I(inode)->i_pos = i_pos;
592 hlist_add_head(&EXFAT_I(inode)->i_hash_fat, head);
593 spin_unlock(&sbi->inode_hash_lock);
594 }
595
596 void exfat_unhash_inode(struct inode *inode)
597 {
598 struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
599
600 spin_lock(&sbi->inode_hash_lock);
601 hlist_del_init(&EXFAT_I(inode)->i_hash_fat);
602 EXFAT_I(inode)->i_pos = 0;
603 spin_unlock(&sbi->inode_hash_lock);
604 }
605
606 struct inode *exfat_iget(struct super_block *sb, loff_t i_pos)
607 {
608 struct exfat_sb_info *sbi = EXFAT_SB(sb);
609 struct exfat_inode_info *info;
610 struct hlist_head *head = sbi->inode_hashtable + exfat_hash(i_pos);
611 struct inode *inode = NULL;
612
613 spin_lock(&sbi->inode_hash_lock);
614 hlist_for_each_entry(info, head, i_hash_fat) {
615 WARN_ON(info->vfs_inode.i_sb != sb);
616
617 if (i_pos != info->i_pos)
618 continue;
619 inode = igrab(&info->vfs_inode);
620 if (inode)
621 break;
622 }
623 spin_unlock(&sbi->inode_hash_lock);
624 return inode;
625 }
626
627 /* doesn't deal with root inode */
628 static int exfat_fill_inode(struct inode *inode, struct exfat_dir_entry *info)
629 {
630 struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
631 struct exfat_inode_info *ei = EXFAT_I(inode);
632 loff_t size = info->size;
633
634 ei->dir = info->dir;
635 ei->entry = info->entry;
636 ei->attr = info->attr;
637 ei->start_clu = info->start_clu;
638 ei->flags = info->flags;
639 ei->type = info->type;
640 ei->valid_size = info->valid_size;
641
642 ei->version = 0;
643 ei->hint_stat.eidx = 0;
644 ei->hint_stat.clu = info->start_clu;
645 ei->hint_femp.eidx = EXFAT_HINT_NONE;
646 ei->hint_bmap.off = EXFAT_EOF_CLUSTER;
647 ei->i_pos = 0;
648
649 inode->i_uid = sbi->options.fs_uid;
650 inode->i_gid = sbi->options.fs_gid;
651 inode_inc_iversion(inode);
652 inode->i_generation = get_random_u32();
653
654 if (info->attr & EXFAT_ATTR_SUBDIR) { /* directory */
655 inode->i_generation &= ~1;
656 inode->i_mode = exfat_make_mode(sbi, info->attr, 0777);
657 inode->i_op = &exfat_dir_inode_operations;
658 inode->i_fop = &exfat_dir_operations;
659 set_nlink(inode, info->num_subdirs);
660 } else { /* regular file */
661 inode->i_generation |= 1;
662 inode->i_mode = exfat_make_mode(sbi, info->attr, 0777);
663 inode->i_op = &exfat_file_inode_operations;
664 inode->i_fop = &exfat_file_operations;
665 inode->i_mapping->a_ops = &exfat_aops;
666 inode->i_mapping->nrpages = 0;
667 }
668
669 i_size_write(inode, size);
670
671 /* ondisk and aligned size should be aligned with block size */
672 if (size & (inode->i_sb->s_blocksize - 1)) {
673 size |= (inode->i_sb->s_blocksize - 1);
674 size++;
675 }
676
677 ei->i_size_aligned = size;
678 ei->i_size_ondisk = size;
679
680 exfat_save_attr(inode, info->attr);
681
682 inode->i_blocks = round_up(i_size_read(inode), sbi->cluster_size) >> 9;
683 inode_set_mtime_to_ts(inode, info->mtime);
684 inode_set_ctime_to_ts(inode, info->mtime);
685 ei->i_crtime = info->crtime;
686 inode_set_atime_to_ts(inode, info->atime);
687
688 return 0;
689 }
690
691 struct inode *exfat_build_inode(struct super_block *sb,
692 struct exfat_dir_entry *info, loff_t i_pos)
693 {
694 struct inode *inode;
695 int err;
696
697 inode = exfat_iget(sb, i_pos);
698 if (inode)
699 goto out;
700 inode = new_inode(sb);
701 if (!inode) {
702 inode = ERR_PTR(-ENOMEM);
703 goto out;
704 }
705 inode->i_ino = iunique(sb, EXFAT_ROOT_INO);
706 inode_set_iversion(inode, 1);
707 err = exfat_fill_inode(inode, info);
708 if (err) {
709 iput(inode);
710 inode = ERR_PTR(err);
711 goto out;
712 }
713 exfat_hash_inode(inode, i_pos);
714 insert_inode_hash(inode);
715 out:
716 return inode;
717 }
718
719 void exfat_evict_inode(struct inode *inode)
720 {
721 truncate_inode_pages(&inode->i_data, 0);
722
723 if (!inode->i_nlink) {
724 i_size_write(inode, 0);
725 mutex_lock(&EXFAT_SB(inode->i_sb)->s_lock);
726 __exfat_truncate(inode);
727 mutex_unlock(&EXFAT_SB(inode->i_sb)->s_lock);
728 }
729
730 invalidate_inode_buffers(inode);
731 clear_inode(inode);
732 exfat_cache_inval_inode(inode);
733 exfat_unhash_inode(inode);
734 }
735
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.