1 /* 2 * linux/fs/fat/file.c 3 * 4 * Written 1992,1993 by Werner Almesberger 5 * 6 * regular file handling primitives for fat-based filesystems 7 */ 8 9 #include <linux/capability.h> 10 #include <linux/module.h> 11 #include <linux/mount.h> 12 #include <linux/time.h> 13 #include <linux/buffer_head.h> 14 #include <linux/writeback.h> 15 #include <linux/backing-dev.h> 16 #include <linux/blkdev.h> 17 #include <linux/fsnotify.h> 18 #include <linux/security.h> 19 #include "fat.h" 20 21 int fat_generic_ioctl(struct inode *inode, struct file *filp, 22 unsigned int cmd, unsigned long arg) 23 { 24 struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); 25 u32 __user *user_attr = (u32 __user *)arg; 26 27 switch (cmd) { 28 case FAT_IOCTL_GET_ATTRIBUTES: 29 { 30 u32 attr; 31 32 mutex_lock(&inode->i_mutex); 33 attr = fat_make_attrs(inode); 34 mutex_unlock(&inode->i_mutex); 35 36 return put_user(attr, user_attr); 37 } 38 case FAT_IOCTL_SET_ATTRIBUTES: 39 { 40 u32 attr, oldattr; 41 int err, is_dir = S_ISDIR(inode->i_mode); 42 struct iattr ia; 43 44 err = get_user(attr, user_attr); 45 if (err) 46 return err; 47 48 mutex_lock(&inode->i_mutex); 49 50 err = mnt_want_write(filp->f_path.mnt); 51 if (err) 52 goto up_no_drop_write; 53 54 /* 55 * ATTR_VOLUME and ATTR_DIR cannot be changed; this also 56 * prevents the user from turning us into a VFAT 57 * longname entry. Also, we obviously can't set 58 * any of the NTFS attributes in the high 24 bits. 59 */ 60 attr &= 0xff & ~(ATTR_VOLUME | ATTR_DIR); 61 /* Merge in ATTR_VOLUME and ATTR_DIR */ 62 attr |= (MSDOS_I(inode)->i_attrs & ATTR_VOLUME) | 63 (is_dir ? ATTR_DIR : 0); 64 oldattr = fat_make_attrs(inode); 65 66 /* Equivalent to a chmod() */ 67 ia.ia_valid = ATTR_MODE | ATTR_CTIME; 68 ia.ia_ctime = current_fs_time(inode->i_sb); 69 if (is_dir) 70 ia.ia_mode = fat_make_mode(sbi, attr, S_IRWXUGO); 71 else { 72 ia.ia_mode = fat_make_mode(sbi, attr, 73 S_IRUGO | S_IWUGO | (inode->i_mode & S_IXUGO)); 74 } 75 76 /* The root directory has no attributes */ 77 if (inode->i_ino == MSDOS_ROOT_INO && attr != ATTR_DIR) { 78 err = -EINVAL; 79 goto up; 80 } 81 82 if (sbi->options.sys_immutable) { 83 if ((attr | oldattr) & ATTR_SYS) { 84 if (!capable(CAP_LINUX_IMMUTABLE)) { 85 err = -EPERM; 86 goto up; 87 } 88 } 89 } 90 91 /* 92 * The security check is questionable... We single 93 * out the RO attribute for checking by the security 94 * module, just because it maps to a file mode. 95 */ 96 err = security_inode_setattr(filp->f_path.dentry, &ia); 97 if (err) 98 goto up; 99 100 /* This MUST be done before doing anything irreversible... */ 101 err = fat_setattr(filp->f_path.dentry, &ia); 102 if (err) 103 goto up; 104 105 fsnotify_change(filp->f_path.dentry, ia.ia_valid); 106 if (sbi->options.sys_immutable) { 107 if (attr & ATTR_SYS) 108 inode->i_flags |= S_IMMUTABLE; 109 else 110 inode->i_flags &= S_IMMUTABLE; 111 } 112 113 fat_save_attrs(inode, attr); 114 mark_inode_dirty(inode); 115 up: 116 mnt_drop_write(filp->f_path.mnt); 117 up_no_drop_write: 118 mutex_unlock(&inode->i_mutex); 119 return err; 120 } 121 default: 122 return -ENOTTY; /* Inappropriate ioctl for device */ 123 } 124 } 125 126 static int fat_file_release(struct inode *inode, struct file *filp) 127 { 128 if ((filp->f_mode & FMODE_WRITE) && 129 MSDOS_SB(inode->i_sb)->options.flush) { 130 fat_flush_inodes(inode->i_sb, inode, NULL); 131 congestion_wait(WRITE, HZ/10); 132 } 133 return 0; 134 } 135 136 const struct file_operations fat_file_operations = { 137 .llseek = generic_file_llseek, 138 .read = do_sync_read, 139 .write = do_sync_write, 140 .aio_read = generic_file_aio_read, 141 .aio_write = generic_file_aio_write, 142 .mmap = generic_file_mmap, 143 .release = fat_file_release, 144 .ioctl = fat_generic_ioctl, 145 .fsync = file_fsync, 146 .splice_read = generic_file_splice_read, 147 }; 148 149 static int fat_cont_expand(struct inode *inode, loff_t size) 150 { 151 struct address_space *mapping = inode->i_mapping; 152 loff_t start = inode->i_size, count = size - inode->i_size; 153 int err; 154 155 err = generic_cont_expand_simple(inode, size); 156 if (err) 157 goto out; 158 159 inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 160 mark_inode_dirty(inode); 161 if (IS_SYNC(inode)) 162 err = sync_page_range_nolock(inode, mapping, start, count); 163 out: 164 return err; 165 } 166 167 /* Free all clusters after the skip'th cluster. */ 168 static int fat_free(struct inode *inode, int skip) 169 { 170 struct super_block *sb = inode->i_sb; 171 int err, wait, free_start, i_start, i_logstart; 172 173 if (MSDOS_I(inode)->i_start == 0) 174 return 0; 175 176 fat_cache_inval_inode(inode); 177 178 wait = IS_DIRSYNC(inode); 179 i_start = free_start = MSDOS_I(inode)->i_start; 180 i_logstart = MSDOS_I(inode)->i_logstart; 181 182 /* First, we write the new file size. */ 183 if (!skip) { 184 MSDOS_I(inode)->i_start = 0; 185 MSDOS_I(inode)->i_logstart = 0; 186 } 187 MSDOS_I(inode)->i_attrs |= ATTR_ARCH; 188 inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 189 if (wait) { 190 err = fat_sync_inode(inode); 191 if (err) { 192 MSDOS_I(inode)->i_start = i_start; 193 MSDOS_I(inode)->i_logstart = i_logstart; 194 return err; 195 } 196 } else 197 mark_inode_dirty(inode); 198 199 /* Write a new EOF, and get the remaining cluster chain for freeing. */ 200 if (skip) { 201 struct fat_entry fatent; 202 int ret, fclus, dclus; 203 204 ret = fat_get_cluster(inode, skip - 1, &fclus, &dclus); 205 if (ret < 0) 206 return ret; 207 else if (ret == FAT_ENT_EOF) 208 return 0; 209 210 fatent_init(&fatent); 211 ret = fat_ent_read(inode, &fatent, dclus); 212 if (ret == FAT_ENT_EOF) { 213 fatent_brelse(&fatent); 214 return 0; 215 } else if (ret == FAT_ENT_FREE) { 216 fat_fs_panic(sb, 217 "%s: invalid cluster chain (i_pos %lld)", 218 __func__, MSDOS_I(inode)->i_pos); 219 ret = -EIO; 220 } else if (ret > 0) { 221 err = fat_ent_write(inode, &fatent, FAT_ENT_EOF, wait); 222 if (err) 223 ret = err; 224 } 225 fatent_brelse(&fatent); 226 if (ret < 0) 227 return ret; 228 229 free_start = ret; 230 } 231 inode->i_blocks = skip << (MSDOS_SB(sb)->cluster_bits - 9); 232 233 /* Freeing the remained cluster chain */ 234 return fat_free_clusters(inode, free_start); 235 } 236 237 void fat_truncate(struct inode *inode) 238 { 239 struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); 240 const unsigned int cluster_size = sbi->cluster_size; 241 int nr_clusters; 242 243 /* 244 * This protects against truncating a file bigger than it was then 245 * trying to write into the hole. 246 */ 247 if (MSDOS_I(inode)->mmu_private > inode->i_size) 248 MSDOS_I(inode)->mmu_private = inode->i_size; 249 250 nr_clusters = (inode->i_size + (cluster_size - 1)) >> sbi->cluster_bits; 251 252 fat_free(inode, nr_clusters); 253 fat_flush_inodes(inode->i_sb, inode, NULL); 254 } 255 256 int fat_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 257 { 258 struct inode *inode = dentry->d_inode; 259 generic_fillattr(inode, stat); 260 stat->blksize = MSDOS_SB(inode->i_sb)->cluster_size; 261 return 0; 262 } 263 EXPORT_SYMBOL_GPL(fat_getattr); 264 265 static int fat_sanitize_mode(const struct msdos_sb_info *sbi, 266 struct inode *inode, umode_t *mode_ptr) 267 { 268 mode_t mask, perm; 269 270 /* 271 * Note, the basic check is already done by a caller of 272 * (attr->ia_mode & ~FAT_VALID_MODE) 273 */ 274 275 if (S_ISREG(inode->i_mode)) 276 mask = sbi->options.fs_fmask; 277 else 278 mask = sbi->options.fs_dmask; 279 280 perm = *mode_ptr & ~(S_IFMT | mask); 281 282 /* 283 * Of the r and x bits, all (subject to umask) must be present. Of the 284 * w bits, either all (subject to umask) or none must be present. 285 * 286 * If fat_mode_can_hold_ro(inode) is false, can't change w bits. 287 */ 288 if ((perm & (S_IRUGO | S_IXUGO)) != (inode->i_mode & (S_IRUGO|S_IXUGO))) 289 return -EPERM; 290 if (fat_mode_can_hold_ro(inode)) { 291 if ((perm & S_IWUGO) && ((perm & S_IWUGO) != (S_IWUGO & ~mask))) 292 return -EPERM; 293 } else { 294 if ((perm & S_IWUGO) != (S_IWUGO & ~mask)) 295 return -EPERM; 296 } 297 298 *mode_ptr &= S_IFMT | perm; 299 300 return 0; 301 } 302 303 static int fat_allow_set_time(struct msdos_sb_info *sbi, struct inode *inode) 304 { 305 mode_t allow_utime = sbi->options.allow_utime; 306 307 if (current_fsuid() != inode->i_uid) { 308 if (in_group_p(inode->i_gid)) 309 allow_utime >>= 3; 310 if (allow_utime & MAY_WRITE) 311 return 1; 312 } 313 314 /* use a default check */ 315 return 0; 316 } 317 318 #define TIMES_SET_FLAGS (ATTR_MTIME_SET | ATTR_ATIME_SET | ATTR_TIMES_SET) 319 /* valid file mode bits */ 320 #define FAT_VALID_MODE (S_IFREG | S_IFDIR | S_IRWXUGO) 321 322 int fat_setattr(struct dentry *dentry, struct iattr *attr) 323 { 324 struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb); 325 struct inode *inode = dentry->d_inode; 326 unsigned int ia_valid; 327 int error; 328 329 /* 330 * Expand the file. Since inode_setattr() updates ->i_size 331 * before calling the ->truncate(), but FAT needs to fill the 332 * hole before it. 333 */ 334 if (attr->ia_valid & ATTR_SIZE) { 335 if (attr->ia_size > inode->i_size) { 336 error = fat_cont_expand(inode, attr->ia_size); 337 if (error || attr->ia_valid == ATTR_SIZE) 338 goto out; 339 attr->ia_valid &= ~ATTR_SIZE; 340 } 341 } 342 343 /* Check for setting the inode time. */ 344 ia_valid = attr->ia_valid; 345 if (ia_valid & TIMES_SET_FLAGS) { 346 if (fat_allow_set_time(sbi, inode)) 347 attr->ia_valid &= ~TIMES_SET_FLAGS; 348 } 349 350 error = inode_change_ok(inode, attr); 351 attr->ia_valid = ia_valid; 352 if (error) { 353 if (sbi->options.quiet) 354 error = 0; 355 goto out; 356 } 357 358 if (((attr->ia_valid & ATTR_UID) && 359 (attr->ia_uid != sbi->options.fs_uid)) || 360 ((attr->ia_valid & ATTR_GID) && 361 (attr->ia_gid != sbi->options.fs_gid)) || 362 ((attr->ia_valid & ATTR_MODE) && 363 (attr->ia_mode & ~FAT_VALID_MODE))) 364 error = -EPERM; 365 366 if (error) { 367 if (sbi->options.quiet) 368 error = 0; 369 goto out; 370 } 371 372 /* 373 * We don't return -EPERM here. Yes, strange, but this is too 374 * old behavior. 375 */ 376 if (attr->ia_valid & ATTR_MODE) { 377 if (fat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0) 378 attr->ia_valid &= ~ATTR_MODE; 379 } 380 381 if (attr->ia_valid) 382 error = inode_setattr(inode, attr); 383 out: 384 return error; 385 } 386 EXPORT_SYMBOL_GPL(fat_setattr); 387 388 const struct inode_operations fat_file_inode_operations = { 389 .truncate = fat_truncate, 390 .setattr = fat_setattr, 391 .getattr = fat_getattr, 392 }; 393