| 1 | |
| 2 | |
| 3 | * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
|
| 4 |
|
| 5 |
|
| 6 | #include <linux/slab.h>
|
| 7 | #include <linux/compat.h>
|
| 8 | #include <linux/cred.h>
|
| 9 | #include <linux/buffer_head.h>
|
| 10 | #include <linux/blkdev.h>
|
| 11 | #include <linux/fsnotify.h>
|
| 12 | #include <linux/security.h>
|
| 13 | #include <linux/msdos_fs.h>
|
| 14 | #include <linux/writeback.h>
|
| 15 | #include <linux/filelock.h>
|
| 16 | #include <linux/falloc.h>
|
| 17 | #include <linux/fileattr.h>
|
| 18 | #include <linux/iomap.h>
|
| 19 | #include <linux/pagemap.h>
|
| 20 |
|
| 21 | #include "exfat_raw.h"
|
| 22 | #include "exfat_fs.h"
|
| 23 | #include "iomap.h"
|
| 24 |
|
| 25 | static int exfat_cont_expand(struct inode *inode, loff_t size)
|
| 26 | {
|
| 27 | int ret;
|
| 28 | unsigned int num_clusters, new_num_clusters, last_clu;
|
| 29 | struct exfat_inode_info *ei = EXFAT_I(inode);
|
| 30 | struct super_block *sb = inode->i_sb;
|
| 31 | struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
| 32 | struct exfat_chain clu;
|
| 33 | loff_t oldsize = i_size_read(inode);
|
| 34 |
|
| 35 | truncate_pagecache(inode, oldsize);
|
| 36 |
|
| 37 | ret = inode_newsize_ok(inode, size);
|
| 38 | if (ret)
|
| 39 | return ret;
|
| 40 |
|
| 41 | num_clusters = exfat_bytes_to_cluster(sbi, exfat_ondisk_size(inode));
|
| 42 |
|
| 43 | new_num_clusters = exfat_bytes_to_cluster_round_up(sbi, size);
|
| 44 |
|
| 45 | if (new_num_clusters == num_clusters)
|
| 46 | goto out;
|
| 47 |
|
| 48 | if (num_clusters) {
|
| 49 | exfat_chain_set(&clu, ei->start_clu, num_clusters, ei->flags);
|
| 50 | ret = exfat_find_last_cluster(sb, &clu, &last_clu);
|
| 51 | if (ret)
|
| 52 | return ret;
|
| 53 |
|
| 54 | clu.dir = last_clu + 1;
|
| 55 | } else {
|
| 56 | last_clu = EXFAT_EOF_CLUSTER;
|
| 57 | clu.dir = EXFAT_EOF_CLUSTER;
|
| 58 | }
|
| 59 |
|
| 60 | clu.size = 0;
|
| 61 | clu.flags = ei->flags;
|
| 62 |
|
| 63 | ret = exfat_alloc_cluster(inode, new_num_clusters - num_clusters,
|
| 64 | &clu, inode_needs_sync(inode), false);
|
| 65 | if (ret)
|
| 66 | return ret;
|
| 67 |
|
| 68 |
|
| 69 | if (num_clusters) {
|
| 70 | if (clu.flags != ei->flags)
|
| 71 | if (exfat_chain_cont_cluster(sb, ei->start_clu, num_clusters))
|
| 72 | goto free_clu;
|
| 73 |
|
| 74 | if (clu.flags == ALLOC_FAT_CHAIN)
|
| 75 | if (exfat_ent_set(sb, last_clu, clu.dir))
|
| 76 | goto free_clu;
|
| 77 | } else
|
| 78 | ei->start_clu = clu.dir;
|
| 79 |
|
| 80 | ei->flags = clu.flags;
|
| 81 |
|
| 82 | out:
|
| 83 | inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
|
| 84 |
|
| 85 | i_size_write(inode, size);
|
| 86 | |
| 87 | * When extending file size, call truncate_pagecache() first,
|
| 88 | * then update i_size, and call pagecache_isize_extended()
|
| 89 | * to ensures the straddling folio is properly marked RO so
|
| 90 | * page_mkwrite() is called and post-EOF area is zeroed.
|
| 91 |
|
| 92 | pagecache_isize_extended(inode, oldsize, inode->i_size);
|
| 93 |
|
| 94 | inode->i_blocks = round_up(size, sbi->cluster_size) >> 9;
|
| 95 | mark_inode_dirty(inode);
|
| 96 |
|
| 97 | if (IS_SYNC(inode))
|
| 98 | return write_inode_now(inode, 1);
|
| 99 |
|
| 100 | return 0;
|
| 101 |
|
| 102 | free_clu:
|
| 103 | exfat_free_cluster(inode, &clu);
|
| 104 | return -EIO;
|
| 105 | }
|
| 106 |
|
| 107 | |
| 108 | * Preallocate space for a file. This implements exfat's fallocate file
|
| 109 | * operation, which gets called from sys_fallocate system call. User space
|
| 110 | * requests len bytes at offset. In contrary to fat, we only support
|
| 111 | * FALLOC_FL_ALLOCATE_RANGE because by leaving the valid data length(VDL)
|
| 112 | * field, it is unnecessary to zero out the newly allocated clusters.
|
| 113 |
|
| 114 | static long exfat_fallocate(struct file *file, int mode,
|
| 115 | loff_t offset, loff_t len)
|
| 116 | {
|
| 117 | struct inode *inode = file->f_mapping->host;
|
| 118 | loff_t newsize = offset + len;
|
| 119 | int err = 0;
|
| 120 |
|
| 121 |
|
| 122 | if (mode != FALLOC_FL_ALLOCATE_RANGE)
|
| 123 | return -EOPNOTSUPP;
|
| 124 |
|
| 125 |
|
| 126 | if (!S_ISREG(inode->i_mode))
|
| 127 | return -EOPNOTSUPP;
|
| 128 |
|
| 129 | if (unlikely(exfat_forced_shutdown(inode->i_sb)))
|
| 130 | return -EIO;
|
| 131 |
|
| 132 | inode_lock(inode);
|
| 133 |
|
| 134 | if (newsize <= i_size_read(inode))
|
| 135 | goto error;
|
| 136 |
|
| 137 |
|
| 138 | err = exfat_cont_expand(inode, newsize);
|
| 139 |
|
| 140 | error:
|
| 141 | inode_unlock(inode);
|
| 142 |
|
| 143 | return err;
|
| 144 | }
|
| 145 |
|
| 146 | static bool exfat_allow_set_time(const struct mnt_idmap *idmap,
|
| 147 | struct exfat_sb_info *sbi, struct inode *inode)
|
| 148 | {
|
| 149 | mode_t allow_utime = sbi->options.allow_utime;
|
| 150 |
|
| 151 | if (!vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode),
|
| 152 | current_fsuid())) {
|
| 153 | if (vfsgid_in_group_p(i_gid_into_vfsgid(idmap, inode)))
|
| 154 | allow_utime >>= 3;
|
| 155 | if (allow_utime & MAY_WRITE)
|
| 156 | return true;
|
| 157 | }
|
| 158 |
|
| 159 |
|
| 160 | return false;
|
| 161 | }
|
| 162 |
|
| 163 | static int exfat_sanitize_mode(const struct exfat_sb_info *sbi,
|
| 164 | struct inode *inode, umode_t *mode_ptr)
|
| 165 | {
|
| 166 | mode_t i_mode, mask, perm;
|
| 167 |
|
| 168 | i_mode = inode->i_mode;
|
| 169 |
|
| 170 | mask = (S_ISREG(i_mode) || S_ISLNK(i_mode)) ?
|
| 171 | sbi->options.fs_fmask : sbi->options.fs_dmask;
|
| 172 | perm = *mode_ptr & ~(S_IFMT | mask);
|
| 173 |
|
| 174 |
|
| 175 | if ((perm & 0555) != (i_mode & 0555))
|
| 176 | return -EPERM;
|
| 177 |
|
| 178 | if (exfat_mode_can_hold_ro(inode)) {
|
| 179 | |
| 180 | * Of the w bits, either all (subject to umask) or none must
|
| 181 | * be present.
|
| 182 |
|
| 183 | if ((perm & 0222) && ((perm & 0222) != (0222 & ~mask)))
|
| 184 | return -EPERM;
|
| 185 | } else {
|
| 186 | |
| 187 | * If exfat_mode_can_hold_ro(inode) is false, can't change
|
| 188 | * w bits.
|
| 189 |
|
| 190 | if ((perm & 0222) != (0222 & ~mask))
|
| 191 | return -EPERM;
|
| 192 | }
|
| 193 |
|
| 194 | *mode_ptr &= S_IFMT | perm;
|
| 195 |
|
| 196 | return 0;
|
| 197 | }
|
| 198 |
|
| 199 |
|
| 200 | int __exfat_truncate(struct inode *inode)
|
| 201 | {
|
| 202 | unsigned int num_clusters_new, num_clusters_phys;
|
| 203 | unsigned int last_clu = EXFAT_FREE_CLUSTER;
|
| 204 | struct exfat_chain clu;
|
| 205 | struct super_block *sb = inode->i_sb;
|
| 206 | struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
| 207 | struct exfat_inode_info *ei = EXFAT_I(inode);
|
| 208 |
|
| 209 |
|
| 210 | if (ei->type != TYPE_FILE && ei->type != TYPE_DIR)
|
| 211 | return -EPERM;
|
| 212 |
|
| 213 | exfat_set_volume_dirty(sb);
|
| 214 |
|
| 215 | num_clusters_new = exfat_bytes_to_cluster_round_up(sbi, i_size_read(inode));
|
| 216 | num_clusters_phys = exfat_bytes_to_cluster(sbi, exfat_ondisk_size(inode));
|
| 217 |
|
| 218 | exfat_chain_set(&clu, ei->start_clu, num_clusters_phys, ei->flags);
|
| 219 |
|
| 220 | if (i_size_read(inode) > 0) {
|
| 221 | |
| 222 | * Truncate FAT chain num_clusters after the first cluster
|
| 223 | * num_clusters = min(new, phys);
|
| 224 |
|
| 225 | unsigned int num_clusters =
|
| 226 | min(num_clusters_new, num_clusters_phys);
|
| 227 |
|
| 228 | |
| 229 | * Follow FAT chain
|
| 230 | * (defensive coding - works fine even with corrupted FAT table
|
| 231 |
|
| 232 | if (clu.flags == ALLOC_NO_FAT_CHAIN) {
|
| 233 | clu.dir += num_clusters;
|
| 234 | clu.size -= num_clusters;
|
| 235 | } else {
|
| 236 | while (num_clusters > 0) {
|
| 237 | last_clu = clu.dir;
|
| 238 | if (exfat_get_next_cluster(sb, &(clu.dir)))
|
| 239 | return -EIO;
|
| 240 |
|
| 241 | num_clusters--;
|
| 242 | clu.size--;
|
| 243 | }
|
| 244 | }
|
| 245 | } else {
|
| 246 | ei->flags = ALLOC_NO_FAT_CHAIN;
|
| 247 | ei->start_clu = EXFAT_EOF_CLUSTER;
|
| 248 | }
|
| 249 |
|
| 250 | if (i_size_read(inode) < ei->valid_size)
|
| 251 | ei->valid_size = ei->zeroed_size = i_size_read(inode);
|
| 252 |
|
| 253 | if (ei->type == TYPE_FILE)
|
| 254 | ei->attr |= EXFAT_ATTR_ARCHIVE;
|
| 255 |
|
| 256 | |
| 257 | * update the directory entry
|
| 258 | *
|
| 259 | * If the directory entry is updated by mark_inode_dirty(), the
|
| 260 | * directory entry will be written after a writeback cycle of
|
| 261 | * updating the bitmap/FAT, which may result in clusters being
|
| 262 | * freed but referenced by the directory entry in the event of a
|
| 263 | * sudden power failure.
|
| 264 | * __exfat_write_inode() is called for directory entry, bitmap
|
| 265 | * and FAT to be written in a same writeback.
|
| 266 |
|
| 267 | if (__exfat_write_inode(inode, inode_needs_sync(inode)))
|
| 268 | return -EIO;
|
| 269 |
|
| 270 |
|
| 271 | if (ei->flags == ALLOC_FAT_CHAIN && last_clu != EXFAT_FREE_CLUSTER &&
|
| 272 | last_clu != EXFAT_EOF_CLUSTER) {
|
| 273 | if (exfat_ent_set(sb, last_clu, EXFAT_EOF_CLUSTER))
|
| 274 | return -EIO;
|
| 275 | }
|
| 276 |
|
| 277 |
|
| 278 |
|
| 279 | exfat_cache_inval_inode(inode);
|
| 280 |
|
| 281 |
|
| 282 | ei->hint_bmap.off = EXFAT_EOF_CLUSTER;
|
| 283 | ei->hint_bmap.clu = EXFAT_EOF_CLUSTER;
|
| 284 |
|
| 285 |
|
| 286 | ei->hint_stat.eidx = 0;
|
| 287 | ei->hint_stat.clu = ei->start_clu;
|
| 288 | ei->hint_femp.eidx = EXFAT_HINT_NONE;
|
| 289 |
|
| 290 |
|
| 291 | if (exfat_free_cluster(inode, &clu))
|
| 292 | return -EIO;
|
| 293 |
|
| 294 | return 0;
|
| 295 | }
|
| 296 |
|
| 297 | static void exfat_truncate(struct inode *inode)
|
| 298 | {
|
| 299 | struct super_block *sb = inode->i_sb;
|
| 300 | struct exfat_sb_info *sbi = EXFAT_SB(sb);
|
| 301 | struct exfat_inode_info *ei = EXFAT_I(inode);
|
| 302 | int err;
|
| 303 |
|
| 304 | mutex_lock(&sbi->s_lock);
|
| 305 | if (ei->start_clu == 0) {
|
| 306 | |
| 307 | * Empty start_clu != ~0 (not allocated)
|
| 308 |
|
| 309 | exfat_fs_error(sb, "tried to truncate zeroed cluster.");
|
| 310 | goto write_size;
|
| 311 | }
|
| 312 |
|
| 313 | err = __exfat_truncate(inode);
|
| 314 | if (err)
|
| 315 | goto write_size;
|
| 316 |
|
| 317 | inode->i_blocks = round_up(i_size_read(inode), sbi->cluster_size) >> 9;
|
| 318 | write_size:
|
| 319 | mutex_unlock(&sbi->s_lock);
|
| 320 | }
|
| 321 |
|
| 322 | int exfat_getattr(const struct mnt_idmap *idmap, const struct path *path,
|
| 323 | struct kstat *stat, unsigned int request_mask,
|
| 324 | unsigned int query_flags)
|
| 325 | {
|
| 326 | struct inode *inode = d_backing_inode(path->dentry);
|
| 327 | struct exfat_inode_info *ei = EXFAT_I(inode);
|
| 328 |
|
| 329 | generic_fillattr(idmap, request_mask, inode, stat);
|
| 330 | exfat_truncate_atime(&stat->atime);
|
| 331 | stat->result_mask |= STATX_BTIME;
|
| 332 | stat->btime.tv_sec = ei->i_crtime.tv_sec;
|
| 333 | stat->btime.tv_nsec = ei->i_crtime.tv_nsec;
|
| 334 | stat->blksize = EXFAT_SB(inode->i_sb)->cluster_size;
|
| 335 | return 0;
|
| 336 | }
|
| 337 |
|
| 338 | int exfat_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
|
| 339 | {
|
| 340 | |
| 341 | * exFAT compares filenames through an upcase table, so lookup
|
| 342 | * is always case-insensitive. Long names are stored in UTF-16
|
| 343 | * with case intact; CASENONPRESERVING stays clear.
|
| 344 |
|
| 345 | fa->fsx_xflags |= FS_XFLAG_CASEFOLD;
|
| 346 | fa->flags |= FS_CASEFOLD_FL;
|
| 347 | return 0;
|
| 348 | }
|
| 349 |
|
| 350 | int exfat_setattr(const struct mnt_idmap *idmap, struct dentry *dentry,
|
| 351 | struct iattr *attr)
|
| 352 | {
|
| 353 | struct exfat_sb_info *sbi = EXFAT_SB(dentry->d_sb);
|
| 354 | struct inode *inode = dentry->d_inode;
|
| 355 | unsigned int ia_valid;
|
| 356 | int error;
|
| 357 |
|
| 358 | if (unlikely(exfat_forced_shutdown(inode->i_sb)))
|
| 359 | return -EIO;
|
| 360 |
|
| 361 | if ((attr->ia_valid & ATTR_SIZE) &&
|
| 362 | attr->ia_size > i_size_read(inode)) {
|
| 363 | error = exfat_cont_expand(inode, attr->ia_size);
|
| 364 | if (error || attr->ia_valid == ATTR_SIZE)
|
| 365 | return error;
|
| 366 | attr->ia_valid &= ~ATTR_SIZE;
|
| 367 | }
|
| 368 |
|
| 369 |
|
| 370 | ia_valid = attr->ia_valid;
|
| 371 | if ((ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET | ATTR_TIMES_SET)) &&
|
| 372 | exfat_allow_set_time(idmap, sbi, inode)) {
|
| 373 | attr->ia_valid &= ~(ATTR_MTIME_SET | ATTR_ATIME_SET |
|
| 374 | ATTR_TIMES_SET);
|
| 375 | }
|
| 376 |
|
| 377 | error = setattr_prepare(idmap, dentry, attr);
|
| 378 | attr->ia_valid = ia_valid;
|
| 379 | if (error)
|
| 380 | goto out;
|
| 381 |
|
| 382 | if (((attr->ia_valid & ATTR_UID) &&
|
| 383 | (!uid_eq(from_vfsuid(idmap, i_user_ns(inode), attr->ia_vfsuid),
|
| 384 | sbi->options.fs_uid))) ||
|
| 385 | ((attr->ia_valid & ATTR_GID) &&
|
| 386 | (!gid_eq(from_vfsgid(idmap, i_user_ns(inode), attr->ia_vfsgid),
|
| 387 | sbi->options.fs_gid))) ||
|
| 388 | ((attr->ia_valid & ATTR_MODE) &&
|
| 389 | (attr->ia_mode & ~(S_IFREG | S_IFLNK | S_IFDIR | 0777)))) {
|
| 390 | error = -EPERM;
|
| 391 | goto out;
|
| 392 | }
|
| 393 |
|
| 394 | |
| 395 | * We don't return -EPERM here. Yes, strange, but this is too
|
| 396 | * old behavior.
|
| 397 |
|
| 398 | if (attr->ia_valid & ATTR_MODE) {
|
| 399 | if (exfat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0)
|
| 400 | attr->ia_valid &= ~ATTR_MODE;
|
| 401 | }
|
| 402 |
|
| 403 | if (attr->ia_valid & ATTR_SIZE)
|
| 404 | inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
|
| 405 |
|
| 406 | setattr_copy(idmap, inode, attr);
|
| 407 | exfat_truncate_inode_atime(inode);
|
| 408 |
|
| 409 | if (attr->ia_valid & ATTR_SIZE) {
|
| 410 | |
| 411 | * Wait for any in-flight DIO to finish before truncating to
|
| 412 | * prevent a concurrent DIO from writing to clusters that are
|
| 413 | * about to be freed.
|
| 414 |
|
| 415 | inode_dio_wait(inode);
|
| 416 | truncate_setsize(inode, attr->ia_size);
|
| 417 |
|
| 418 | |
| 419 | * __exfat_write_inode() is called from exfat_truncate(), inode
|
| 420 | * is already written by it, so mark_inode_dirty() is unneeded.
|
| 421 |
|
| 422 | exfat_truncate(inode);
|
| 423 | } else
|
| 424 | mark_inode_dirty(inode);
|
| 425 |
|
| 426 | out:
|
| 427 | return error;
|
| 428 | }
|
| 429 |
|
| 430 | |
| 431 | * modified ioctls from fat/file.c by Welmer Almesberger
|
| 432 |
|
| 433 | static int exfat_ioctl_get_attributes(struct inode *inode, u32 __user *user_attr)
|
| 434 | {
|
| 435 | u32 attr;
|
| 436 |
|
| 437 | inode_lock_shared(inode);
|
| 438 | attr = exfat_make_attr(inode);
|
| 439 | inode_unlock_shared(inode);
|
| 440 |
|
| 441 | return put_user(attr, user_attr);
|
| 442 | }
|
| 443 |
|
| 444 | static int exfat_ioctl_set_attributes(struct file *file, u32 __user *user_attr)
|
| 445 | {
|
| 446 | struct inode *inode = file_inode(file);
|
| 447 | struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
|
| 448 | int is_dir = S_ISDIR(inode->i_mode);
|
| 449 | u32 attr, oldattr;
|
| 450 | struct iattr ia;
|
| 451 | int err;
|
| 452 |
|
| 453 | err = get_user(attr, user_attr);
|
| 454 | if (err)
|
| 455 | goto out;
|
| 456 |
|
| 457 | err = mnt_want_write_file(file);
|
| 458 | if (err)
|
| 459 | goto out;
|
| 460 | inode_lock(inode);
|
| 461 |
|
| 462 | oldattr = exfat_make_attr(inode);
|
| 463 |
|
| 464 | |
| 465 | * Mask attributes so we don't set reserved fields.
|
| 466 |
|
| 467 | attr &= (EXFAT_ATTR_READONLY | EXFAT_ATTR_HIDDEN | EXFAT_ATTR_SYSTEM |
|
| 468 | EXFAT_ATTR_ARCHIVE);
|
| 469 | attr |= (is_dir ? EXFAT_ATTR_SUBDIR : 0);
|
| 470 |
|
| 471 |
|
| 472 | ia.ia_valid = ATTR_MODE | ATTR_CTIME;
|
| 473 | ia.ia_ctime = current_time(inode);
|
| 474 | if (is_dir)
|
| 475 | ia.ia_mode = exfat_make_mode(sbi, attr, 0777);
|
| 476 | else
|
| 477 | ia.ia_mode = exfat_make_mode(sbi, attr, 0666 | (inode->i_mode & 0111));
|
| 478 |
|
| 479 |
|
| 480 | if (inode->i_ino == EXFAT_ROOT_INO && attr != EXFAT_ATTR_SUBDIR) {
|
| 481 | err = -EINVAL;
|
| 482 | goto out_unlock_inode;
|
| 483 | }
|
| 484 |
|
| 485 | if (((attr | oldattr) & EXFAT_ATTR_SYSTEM) &&
|
| 486 | !capable(CAP_LINUX_IMMUTABLE)) {
|
| 487 | err = -EPERM;
|
| 488 | goto out_unlock_inode;
|
| 489 | }
|
| 490 |
|
| 491 | |
| 492 | * The security check is questionable... We single
|
| 493 | * out the RO attribute for checking by the security
|
| 494 | * module, just because it maps to a file mode.
|
| 495 |
|
| 496 | err = security_inode_setattr(file_mnt_idmap(file),
|
| 497 | file->f_path.dentry, &ia);
|
| 498 | if (err)
|
| 499 | goto out_unlock_inode;
|
| 500 |
|
| 501 |
|
| 502 | err = exfat_setattr(file_mnt_idmap(file), file->f_path.dentry, &ia);
|
| 503 | if (err)
|
| 504 | goto out_unlock_inode;
|
| 505 |
|
| 506 | fsnotify_change(file->f_path.dentry, ia.ia_valid);
|
| 507 |
|
| 508 | exfat_save_attr(inode, attr);
|
| 509 | mark_inode_dirty(inode);
|
| 510 | out_unlock_inode:
|
| 511 | inode_unlock(inode);
|
| 512 | mnt_drop_write_file(file);
|
| 513 | out:
|
| 514 | return err;
|
| 515 | }
|
| 516 |
|
| 517 | static int exfat_ioctl_fitrim(struct inode *inode, unsigned long arg)
|
| 518 | {
|
| 519 | struct fstrim_range range;
|
| 520 | int ret = 0;
|
| 521 |
|
| 522 | if (!capable(CAP_SYS_ADMIN))
|
| 523 | return -EPERM;
|
| 524 |
|
| 525 | if (!bdev_max_discard_sectors(inode->i_sb->s_bdev))
|
| 526 | return -EOPNOTSUPP;
|
| 527 |
|
| 528 | if (copy_from_user(&range, (struct fstrim_range __user *)arg, sizeof(range)))
|
| 529 | return -EFAULT;
|
| 530 |
|
| 531 | range.minlen = max_t(unsigned int, range.minlen,
|
| 532 | bdev_discard_granularity(inode->i_sb->s_bdev));
|
| 533 |
|
| 534 | ret = exfat_trim_fs(inode, &range);
|
| 535 | if (ret < 0)
|
| 536 | return ret;
|
| 537 |
|
| 538 | if (copy_to_user((struct fstrim_range __user *)arg, &range, sizeof(range)))
|
| 539 | return -EFAULT;
|
| 540 |
|
| 541 | return 0;
|
| 542 | }
|
| 543 |
|
| 544 | static int exfat_ioctl_shutdown(struct super_block *sb, unsigned long arg)
|
| 545 | {
|
| 546 | u32 flags;
|
| 547 |
|
| 548 | if (!capable(CAP_SYS_ADMIN))
|
| 549 | return -EPERM;
|
| 550 |
|
| 551 | if (get_user(flags, (__u32 __user *)arg))
|
| 552 | return -EFAULT;
|
| 553 |
|
| 554 | return exfat_force_shutdown(sb, flags);
|
| 555 | }
|
| 556 |
|
| 557 | static int exfat_ioctl_get_volume_label(struct super_block *sb, unsigned long arg)
|
| 558 | {
|
| 559 | int ret;
|
| 560 | char label[FSLABEL_MAX] = {0};
|
| 561 | struct exfat_uni_name uniname;
|
| 562 |
|
| 563 | ret = exfat_read_volume_label(sb, &uniname);
|
| 564 | if (ret < 0)
|
| 565 | return ret;
|
| 566 |
|
| 567 | ret = exfat_utf16_to_nls(sb, &uniname, label, sizeof(label));
|
| 568 | if (ret < 0)
|
| 569 | return ret;
|
| 570 |
|
| 571 | if (copy_to_user((char __user *)arg, label, ret + 1))
|
| 572 | return -EFAULT;
|
| 573 |
|
| 574 | return 0;
|
| 575 | }
|
| 576 |
|
| 577 | static int exfat_ioctl_set_volume_label(struct super_block *sb,
|
| 578 | unsigned long arg)
|
| 579 | {
|
| 580 | int ret = 0, lossy, label_len;
|
| 581 | char label[FSLABEL_MAX] = {0};
|
| 582 | struct exfat_uni_name uniname;
|
| 583 |
|
| 584 | if (!capable(CAP_SYS_ADMIN))
|
| 585 | return -EPERM;
|
| 586 |
|
| 587 | if (copy_from_user(label, (char __user *)arg, FSLABEL_MAX))
|
| 588 | return -EFAULT;
|
| 589 |
|
| 590 | memset(&uniname, 0, sizeof(uniname));
|
| 591 | label_len = strnlen(label, FSLABEL_MAX - 1);
|
| 592 | if (label[0]) {
|
| 593 | ret = exfat_nls_to_utf16(sb, label, label_len,
|
| 594 | &uniname, &lossy);
|
| 595 | if (ret < 0)
|
| 596 | return ret;
|
| 597 | else if (lossy & NLS_NAME_LOSSY)
|
| 598 | return -EINVAL;
|
| 599 | }
|
| 600 |
|
| 601 | uniname.name_len = ret;
|
| 602 |
|
| 603 | return exfat_write_volume_label(sb, &uniname);
|
| 604 | }
|
| 605 |
|
| 606 | long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
| 607 | {
|
| 608 | struct inode *inode = file_inode(filp);
|
| 609 | u32 __user *user_attr = (u32 __user *)arg;
|
| 610 |
|
| 611 | switch (cmd) {
|
| 612 | case FAT_IOCTL_GET_ATTRIBUTES:
|
| 613 | return exfat_ioctl_get_attributes(inode, user_attr);
|
| 614 | case FAT_IOCTL_SET_ATTRIBUTES:
|
| 615 | return exfat_ioctl_set_attributes(filp, user_attr);
|
| 616 | case EXFAT_IOC_SHUTDOWN:
|
| 617 | return exfat_ioctl_shutdown(inode->i_sb, arg);
|
| 618 | case FITRIM:
|
| 619 | return exfat_ioctl_fitrim(inode, arg);
|
| 620 | case FS_IOC_GETFSLABEL:
|
| 621 | return exfat_ioctl_get_volume_label(inode->i_sb, arg);
|
| 622 | case FS_IOC_SETFSLABEL:
|
| 623 | return exfat_ioctl_set_volume_label(inode->i_sb, arg);
|
| 624 | default:
|
| 625 | return -ENOTTY;
|
| 626 | }
|
| 627 | }
|
| 628 |
|
| 629 | #ifdef CONFIG_COMPAT
|
| 630 | long exfat_compat_ioctl(struct file *filp, unsigned int cmd,
|
| 631 | unsigned long arg)
|
| 632 | {
|
| 633 | return exfat_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
|
| 634 | }
|
| 635 | #endif
|
| 636 |
|
| 637 | int exfat_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
|
| 638 | {
|
| 639 | struct inode *inode = filp->f_mapping->host;
|
| 640 | int err;
|
| 641 |
|
| 642 | if (unlikely(exfat_forced_shutdown(inode->i_sb)))
|
| 643 | return -EIO;
|
| 644 |
|
| 645 | err = simple_fsync_noflush(filp, start, end, datasync);
|
| 646 | if (err)
|
| 647 | return err;
|
| 648 |
|
| 649 | err = sync_blockdev(inode->i_sb->s_bdev);
|
| 650 | if (err)
|
| 651 | return err;
|
| 652 |
|
| 653 | return blkdev_issue_flush(inode->i_sb->s_bdev);
|
| 654 | }
|
| 655 |
|
| 656 | |
| 657 | * exfat_zero_new_range - zero [start, end) without overwriting uptodate blocks
|
| 658 | *
|
| 659 | * Uptodate blocks may contain data written through a shared mapping beyond
|
| 660 | * valid_size.
|
| 661 |
|
| 662 | static int exfat_zero_new_range(struct inode *inode, loff_t start, loff_t end)
|
| 663 | {
|
| 664 | struct address_space *mapping = inode->i_mapping;
|
| 665 | unsigned int blocksize = i_blocksize(inode);
|
| 666 | loff_t pos = start;
|
| 667 | int err;
|
| 668 |
|
| 669 | while (pos < end) {
|
| 670 | loff_t next = min_t(loff_t,
|
| 671 | round_down(pos, PAGE_SIZE) + PAGE_SIZE, end);
|
| 672 | struct folio *folio;
|
| 673 | loff_t bpos;
|
| 674 |
|
| 675 | folio = filemap_get_folio(mapping, pos >> PAGE_SHIFT);
|
| 676 | if (IS_ERR(folio)) {
|
| 677 | err = iomap_zero_range(inode, pos, next - pos, NULL,
|
| 678 | &exfat_iomap_ops, NULL, NULL);
|
| 679 | if (err < 0)
|
| 680 | return err;
|
| 681 | pos = next;
|
| 682 | continue;
|
| 683 | }
|
| 684 |
|
| 685 | if (folio_test_uptodate(folio)) {
|
| 686 | folio_lock(folio);
|
| 687 | if (folio->mapping == mapping)
|
| 688 | folio_mark_dirty(folio);
|
| 689 | folio_unlock(folio);
|
| 690 | folio_put(folio);
|
| 691 | pos = next;
|
| 692 | continue;
|
| 693 | }
|
| 694 |
|
| 695 | |
| 696 | * Zero not-uptodate block runs. iomap_zero_range() requires an
|
| 697 | * unlocked folio, so recheck ->mapping after each call.
|
| 698 |
|
| 699 | folio_lock(folio);
|
| 700 | bpos = pos;
|
| 701 | while (bpos < next) {
|
| 702 | loff_t rstart, rend;
|
| 703 |
|
| 704 | if (folio->mapping != mapping) {
|
| 705 | folio_unlock(folio);
|
| 706 | err = iomap_zero_range(inode, bpos, next - bpos,
|
| 707 | NULL, &exfat_iomap_ops, NULL, NULL);
|
| 708 | if (err < 0) {
|
| 709 | folio_put(folio);
|
| 710 | return err;
|
| 711 | }
|
| 712 | folio_lock(folio);
|
| 713 | break;
|
| 714 | }
|
| 715 |
|
| 716 | if (iomap_is_partially_uptodate(folio,
|
| 717 | offset_in_folio(folio, bpos), blocksize)) {
|
| 718 | bpos += blocksize;
|
| 719 | continue;
|
| 720 | }
|
| 721 |
|
| 722 | rstart = bpos;
|
| 723 | rend = min_t(loff_t, bpos + blocksize, next);
|
| 724 | while (rend < next &&
|
| 725 | !iomap_is_partially_uptodate(folio,
|
| 726 | offset_in_folio(folio, rend), blocksize))
|
| 727 | rend = min_t(loff_t, rend + blocksize, next);
|
| 728 |
|
| 729 | folio_unlock(folio);
|
| 730 | err = iomap_zero_range(inode, rstart, rend - rstart,
|
| 731 | NULL, &exfat_iomap_ops, NULL, NULL);
|
| 732 | if (err < 0) {
|
| 733 | folio_put(folio);
|
| 734 | return err;
|
| 735 | }
|
| 736 | folio_lock(folio);
|
| 737 | bpos = rend;
|
| 738 | }
|
| 739 |
|
| 740 | |
| 741 | * Dirty only a fully uptodate folio. Dirtying a partial folio could
|
| 742 | * write uninitialised cache contents over valid on-disk blocks.
|
| 743 |
|
| 744 | if (folio->mapping == mapping && folio_test_uptodate(folio))
|
| 745 | folio_mark_dirty(folio);
|
| 746 | folio_unlock(folio);
|
| 747 | folio_put(folio);
|
| 748 | pos = next;
|
| 749 | }
|
| 750 |
|
| 751 | return 0;
|
| 752 | }
|
| 753 |
|
| 754 | static int exfat_extend_valid_size(struct inode *inode, loff_t new_valid_size)
|
| 755 | {
|
| 756 | struct exfat_inode_info *ei = EXFAT_I(inode);
|
| 757 | loff_t old_valid_size = ei->valid_size;
|
| 758 | int ret = 0;
|
| 759 |
|
| 760 | if (old_valid_size < new_valid_size) {
|
| 761 |
|
| 762 | loff_t gap_start = max(old_valid_size, ei->zeroed_size);
|
| 763 |
|
| 764 | if (i_size_read(inode) < new_valid_size) {
|
| 765 | |
| 766 | * Allocate clusters before increasing i_size. The gap
|
| 767 | * may already be zeroed, so the subsequent zeroing
|
| 768 | * can be skipped.
|
| 769 |
|
| 770 | ret = exfat_cont_expand(inode, new_valid_size);
|
| 771 | if (ret)
|
| 772 | return ret;
|
| 773 | }
|
| 774 |
|
| 775 | |
| 776 | * Revoke writable PTEs while zeroing the gap. A racing mmap
|
| 777 | * store re-faults through exfat_page_mkwrite() after valid_size
|
| 778 | * is updated.
|
| 779 |
|
| 780 | filemap_invalidate_lock(inode->i_mapping);
|
| 781 | if (gap_start < new_valid_size)
|
| 782 | unmap_mapping_range(inode->i_mapping, gap_start,
|
| 783 | new_valid_size - gap_start, 0);
|
| 784 | ret = exfat_zero_new_range(inode, gap_start, new_valid_size);
|
| 785 | filemap_invalidate_unlock(inode->i_mapping);
|
| 786 | if (ret) {
|
| 787 | truncate_setsize(inode, old_valid_size);
|
| 788 | exfat_truncate(inode);
|
| 789 | return ret;
|
| 790 | }
|
| 791 |
|
| 792 | ei->valid_size = new_valid_size;
|
| 793 | if (ei->zeroed_size < round_up(new_valid_size, i_blocksize(inode)))
|
| 794 | ei->zeroed_size = round_up(new_valid_size, i_blocksize(inode));
|
| 795 | mark_inode_dirty(inode);
|
| 796 | }
|
| 797 |
|
| 798 | return ret;
|
| 799 | }
|
| 800 |
|
| 801 | static ssize_t exfat_fallback_buffered_write(struct kiocb *iocb,
|
| 802 | struct iov_iter *from)
|
| 803 | {
|
| 804 | loff_t offset = iocb->ki_pos, end;
|
| 805 | ssize_t written;
|
| 806 | int ret;
|
| 807 |
|
| 808 | iocb->ki_flags &= ~IOCB_DIRECT;
|
| 809 |
|
| 810 | written = iomap_file_buffered_write(iocb, from, &exfat_write_iomap_ops,
|
| 811 | NULL, NULL);
|
| 812 | if (written < 0)
|
| 813 | return written;
|
| 814 |
|
| 815 | end = iocb->ki_pos + written - 1;
|
| 816 | ret = filemap_write_and_wait_range(iocb->ki_filp->f_mapping,
|
| 817 | offset, end);
|
| 818 | if (ret)
|
| 819 | return -EIO;
|
| 820 |
|
| 821 | invalidate_mapping_pages(iocb->ki_filp->f_mapping,
|
| 822 | offset >> PAGE_SHIFT,
|
| 823 | end >> PAGE_SHIFT);
|
| 824 |
|
| 825 | return written;
|
| 826 | }
|
| 827 |
|
| 828 | static ssize_t exfat_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
|
| 829 | {
|
| 830 | ssize_t ret;
|
| 831 |
|
| 832 | ret = iomap_dio_rw(iocb, from, &exfat_write_iomap_ops,
|
| 833 | &exfat_write_dio_ops, 0, NULL, 0);
|
| 834 | if (ret == -ENOTBLK)
|
| 835 | ret = 0;
|
| 836 | else if (ret < 0)
|
| 837 | return ret;
|
| 838 |
|
| 839 | if (iov_iter_count(from)) {
|
| 840 | ssize_t written;
|
| 841 |
|
| 842 | written = exfat_fallback_buffered_write(iocb, from);
|
| 843 | if (written < 0)
|
| 844 | return written;
|
| 845 | ret += written;
|
| 846 | }
|
| 847 |
|
| 848 | return ret;
|
| 849 | }
|
| 850 |
|
| 851 | static ssize_t exfat_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
|
| 852 | {
|
| 853 | ssize_t ret;
|
| 854 | struct file *file = iocb->ki_filp;
|
| 855 | struct inode *inode = file_inode(file);
|
| 856 | struct exfat_inode_info *ei = EXFAT_I(inode);
|
| 857 | loff_t pos = iocb->ki_pos;
|
| 858 | loff_t valid_size;
|
| 859 | int err;
|
| 860 |
|
| 861 | if (unlikely(exfat_forced_shutdown(inode->i_sb)))
|
| 862 | return -EIO;
|
| 863 |
|
| 864 | inode_lock(inode);
|
| 865 |
|
| 866 | if (pos > i_size_read(inode))
|
| 867 | truncate_pagecache(inode, i_size_read(inode));
|
| 868 |
|
| 869 | valid_size = ei->valid_size;
|
| 870 |
|
| 871 | ret = generic_write_checks(iocb, iter);
|
| 872 | if (ret <= 0)
|
| 873 | goto unlock;
|
| 874 |
|
| 875 | err = file_modified(iocb->ki_filp);
|
| 876 | if (err) {
|
| 877 | ret = err;
|
| 878 | goto unlock;
|
| 879 | }
|
| 880 |
|
| 881 | if (pos > valid_size) {
|
| 882 | ret = exfat_extend_valid_size(inode, pos);
|
| 883 | if (ret < 0 && ret != -ENOSPC) {
|
| 884 | exfat_err(inode->i_sb,
|
| 885 | "write: fail to zero from %llu to %llu(%zd)",
|
| 886 | valid_size, pos, ret);
|
| 887 | }
|
| 888 | if (ret < 0)
|
| 889 | goto unlock;
|
| 890 | }
|
| 891 |
|
| 892 | if (iocb->ki_flags & IOCB_DIRECT)
|
| 893 | ret = exfat_dio_write_iter(iocb, iter);
|
| 894 | else
|
| 895 | ret = iomap_file_buffered_write(iocb, iter,
|
| 896 | &exfat_write_iomap_ops, NULL, NULL);
|
| 897 | if (ret < 0)
|
| 898 | goto unlock;
|
| 899 |
|
| 900 | inode_unlock(inode);
|
| 901 |
|
| 902 | if (pos > valid_size)
|
| 903 | pos = valid_size;
|
| 904 |
|
| 905 | if (iocb->ki_pos > pos) {
|
| 906 | ssize_t err = generic_write_sync(iocb, iocb->ki_pos - pos);
|
| 907 |
|
| 908 | if (err < 0)
|
| 909 | return err;
|
| 910 | }
|
| 911 |
|
| 912 | return ret;
|
| 913 |
|
| 914 | unlock:
|
| 915 | inode_unlock(inode);
|
| 916 |
|
| 917 | return ret;
|
| 918 | }
|
| 919 |
|
| 920 | static ssize_t exfat_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
|
| 921 | {
|
| 922 | struct inode *inode = file_inode(iocb->ki_filp);
|
| 923 | ssize_t ret;
|
| 924 |
|
| 925 | if (unlikely(exfat_forced_shutdown(inode->i_sb)))
|
| 926 | return -EIO;
|
| 927 |
|
| 928 | inode_lock_shared(inode);
|
| 929 |
|
| 930 | if (iocb->ki_flags & IOCB_DIRECT) {
|
| 931 | file_accessed(iocb->ki_filp);
|
| 932 | ret = iomap_dio_rw(iocb, iter, &exfat_iomap_ops, NULL, 0,
|
| 933 | NULL, 0);
|
| 934 | } else {
|
| 935 | ret = generic_file_read_iter(iocb, iter);
|
| 936 | }
|
| 937 |
|
| 938 | inode_unlock_shared(inode);
|
| 939 |
|
| 940 | return ret;
|
| 941 | }
|
| 942 |
|
| 943 | static vm_fault_t exfat_page_mkwrite(struct vm_fault *vmf)
|
| 944 | {
|
| 945 | struct inode *inode = file_inode(vmf->vma->vm_file);
|
| 946 | struct exfat_inode_info *ei = EXFAT_I(inode);
|
| 947 | vm_fault_t ret;
|
| 948 | loff_t new_valid_size, mmap_valid_size, fault_page_start;
|
| 949 |
|
| 950 | if (!inode_trylock(inode))
|
| 951 | return VM_FAULT_RETRY;
|
| 952 |
|
| 953 | mmap_valid_size = ((loff_t)vmf->pgoff + 1) << PAGE_SHIFT;
|
| 954 | fault_page_start = ((loff_t)vmf->pgoff) << PAGE_SHIFT;
|
| 955 | new_valid_size = min(mmap_valid_size, i_size_read(inode));
|
| 956 |
|
| 957 | if (ei->valid_size < new_valid_size) {
|
| 958 | if (ei->zeroed_size < fault_page_start) {
|
| 959 | int err;
|
| 960 |
|
| 961 | |
| 962 | * Zero only the gap below the faulting page. The read
|
| 963 | * fault populated its folio and iomap_page_mkwrite()
|
| 964 | * will dirty it.
|
| 965 |
|
| 966 | err = exfat_zero_new_range(inode, ei->zeroed_size,
|
| 967 | fault_page_start);
|
| 968 | if (err < 0) {
|
| 969 | inode_unlock(inode);
|
| 970 | return vmf_fs_error(err);
|
| 971 | }
|
| 972 | }
|
| 973 |
|
| 974 | |
| 975 | * Track zeroed_size by block, not page, because writeback stops
|
| 976 | * at i_size recording blocks wholly beyond it could skip a
|
| 977 | * later required zeroing.
|
| 978 |
|
| 979 | if (ei->zeroed_size < round_up(new_valid_size, i_blocksize(inode)))
|
| 980 | ei->zeroed_size = round_up(new_valid_size, i_blocksize(inode));
|
| 981 | ei->valid_size = new_valid_size;
|
| 982 | mark_inode_dirty(inode);
|
| 983 | }
|
| 984 |
|
| 985 | sb_start_pagefault(inode->i_sb);
|
| 986 | file_update_time(vmf->vma->vm_file);
|
| 987 |
|
| 988 | filemap_invalidate_lock_shared(inode->i_mapping);
|
| 989 | ret = iomap_page_mkwrite(vmf, &exfat_iomap_ops, NULL);
|
| 990 | filemap_invalidate_unlock_shared(inode->i_mapping);
|
| 991 | sb_end_pagefault(inode->i_sb);
|
| 992 | inode_unlock(inode);
|
| 993 |
|
| 994 | return ret;
|
| 995 | }
|
| 996 |
|
| 997 | static const struct vm_operations_struct exfat_file_vm_ops = {
|
| 998 | .fault = filemap_fault,
|
| 999 | .page_mkwrite = exfat_page_mkwrite,
|
| 1000 | };
|
| 1001 |
|
| 1002 | static int exfat_file_mmap_prepare(struct vm_area_desc *desc)
|
| 1003 | {
|
| 1004 | struct file *file = desc->file;
|
| 1005 |
|
| 1006 | if (unlikely(exfat_forced_shutdown(file_inode(desc->file)->i_sb)))
|
| 1007 | return -EIO;
|
| 1008 |
|
| 1009 | file_accessed(file);
|
| 1010 | desc->vm_ops = &exfat_file_vm_ops;
|
| 1011 | return 0;
|
| 1012 | }
|
| 1013 |
|
| 1014 | static ssize_t exfat_splice_read(struct file *in, loff_t *ppos,
|
| 1015 | struct pipe_inode_info *pipe, size_t len, unsigned int flags)
|
| 1016 | {
|
| 1017 | if (unlikely(exfat_forced_shutdown(file_inode(in)->i_sb)))
|
| 1018 | return -EIO;
|
| 1019 |
|
| 1020 | return filemap_splice_read(in, ppos, pipe, len, flags);
|
| 1021 | }
|
| 1022 |
|
| 1023 | static int exfat_file_open(struct inode *inode, struct file *filp)
|
| 1024 | {
|
| 1025 | int err;
|
| 1026 |
|
| 1027 | if (unlikely(exfat_forced_shutdown(inode->i_sb)))
|
| 1028 | return -EIO;
|
| 1029 |
|
| 1030 | err = generic_file_open(inode, filp);
|
| 1031 | if (err)
|
| 1032 | return err;
|
| 1033 |
|
| 1034 | filp->f_mode |= FMODE_CAN_ODIRECT;
|
| 1035 |
|
| 1036 | return 0;
|
| 1037 | }
|
| 1038 |
|
| 1039 | static loff_t exfat_file_llseek(struct file *file, loff_t offset, int whence)
|
| 1040 | {
|
| 1041 | struct inode *inode = file->f_mapping->host;
|
| 1042 |
|
| 1043 | switch (whence) {
|
| 1044 | case SEEK_HOLE:
|
| 1045 | inode_lock_shared(inode);
|
| 1046 | offset = iomap_seek_hole(inode, offset, &exfat_iomap_ops);
|
| 1047 | inode_unlock_shared(inode);
|
| 1048 | break;
|
| 1049 | case SEEK_DATA:
|
| 1050 | inode_lock_shared(inode);
|
| 1051 | offset = iomap_seek_data(inode, offset, &exfat_iomap_ops);
|
| 1052 | inode_unlock_shared(inode);
|
| 1053 | break;
|
| 1054 | default:
|
| 1055 | return generic_file_llseek(file, offset, whence);
|
| 1056 | }
|
| 1057 | if (offset < 0)
|
| 1058 | return offset;
|
| 1059 | return vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
|
| 1060 | }
|
| 1061 |
|
| 1062 | const struct file_operations exfat_file_operations = {
|
| 1063 | .open = exfat_file_open,
|
| 1064 | .llseek = exfat_file_llseek,
|
| 1065 | .read_iter = exfat_file_read_iter,
|
| 1066 | .write_iter = exfat_file_write_iter,
|
| 1067 | .unlocked_ioctl = exfat_ioctl,
|
| 1068 | #ifdef CONFIG_COMPAT
|
| 1069 | .compat_ioctl = exfat_compat_ioctl,
|
| 1070 | #endif
|
| 1071 | .mmap_prepare = exfat_file_mmap_prepare,
|
| 1072 | .fsync = exfat_file_fsync,
|
| 1073 | .splice_read = exfat_splice_read,
|
| 1074 | .splice_write = iter_file_splice_write,
|
| 1075 | .fallocate = exfat_fallocate,
|
| 1076 | .setlease = generic_setlease,
|
| 1077 | };
|
| 1078 |
|
| 1079 | const struct inode_operations exfat_file_inode_operations = {
|
| 1080 | .setattr = exfat_setattr,
|
| 1081 | .getattr = exfat_getattr,
|
| 1082 | .fileattr_get = exfat_fileattr_get,
|
| 1083 | };
|