1 /* 2 * linux/fs/hfs/inode.c 3 * 4 * Copyright (C) 1995-1997 Paul H. Hargrove 5 * (C) 2003 Ardis Technologies <roman@ardistech.com> 6 * This file may be distributed under the terms of the GNU General Public License. 7 * 8 * This file contains inode-related functions which do not depend on 9 * which scheme is being used to represent forks. 10 * 11 * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds 12 */ 13 14 #include <linux/pagemap.h> 15 #include <linux/mpage.h> 16 #include <linux/sched.h> 17 18 #include "hfs_fs.h" 19 #include "btree.h" 20 21 static const struct file_operations hfs_file_operations; 22 static const struct inode_operations hfs_file_inode_operations; 23 24 /*================ Variable-like macros ================*/ 25 26 #define HFS_VALID_MODE_BITS (S_IFREG | S_IFDIR | S_IRWXUGO) 27 28 static int hfs_writepage(struct page *page, struct writeback_control *wbc) 29 { 30 return block_write_full_page(page, hfs_get_block, wbc); 31 } 32 33 static int hfs_readpage(struct file *file, struct page *page) 34 { 35 return block_read_full_page(page, hfs_get_block); 36 } 37 38 static int hfs_write_begin(struct file *file, struct address_space *mapping, 39 loff_t pos, unsigned len, unsigned flags, 40 struct page **pagep, void **fsdata) 41 { 42 int ret; 43 44 *pagep = NULL; 45 ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata, 46 hfs_get_block, 47 &HFS_I(mapping->host)->phys_size); 48 if (unlikely(ret)) { 49 loff_t isize = mapping->host->i_size; 50 if (pos + len > isize) 51 vmtruncate(mapping->host, isize); 52 } 53 54 return ret; 55 } 56 57 static sector_t hfs_bmap(struct address_space *mapping, sector_t block) 58 { 59 return generic_block_bmap(mapping, block, hfs_get_block); 60 } 61 62 static int hfs_releasepage(struct page *page, gfp_t mask) 63 { 64 struct inode *inode = page->mapping->host; 65 struct super_block *sb = inode->i_sb; 66 struct hfs_btree *tree; 67 struct hfs_bnode *node; 68 u32 nidx; 69 int i, res = 1; 70 71 switch (inode->i_ino) { 72 case HFS_EXT_CNID: 73 tree = HFS_SB(sb)->ext_tree; 74 break; 75 case HFS_CAT_CNID: 76 tree = HFS_SB(sb)->cat_tree; 77 break; 78 default: 79 BUG(); 80 return 0; 81 } 82 83 if (!tree) 84 return 0; 85 86 if (tree->node_size >= PAGE_CACHE_SIZE) { 87 nidx = page->index >> (tree->node_size_shift - PAGE_CACHE_SHIFT); 88 spin_lock(&tree->hash_lock); 89 node = hfs_bnode_findhash(tree, nidx); 90 if (!node) 91 ; 92 else if (atomic_read(&node->refcnt)) 93 res = 0; 94 if (res && node) { 95 hfs_bnode_unhash(node); 96 hfs_bnode_free(node); 97 } 98 spin_unlock(&tree->hash_lock); 99 } else { 100 nidx = page->index << (PAGE_CACHE_SHIFT - tree->node_size_shift); 101 i = 1 << (PAGE_CACHE_SHIFT - tree->node_size_shift); 102 spin_lock(&tree->hash_lock); 103 do { 104 node = hfs_bnode_findhash(tree, nidx++); 105 if (!node) 106 continue; 107 if (atomic_read(&node->refcnt)) { 108 res = 0; 109 break; 110 } 111 hfs_bnode_unhash(node); 112 hfs_bnode_free(node); 113 } while (--i && nidx < tree->node_count); 114 spin_unlock(&tree->hash_lock); 115 } 116 return res ? try_to_free_buffers(page) : 0; 117 } 118 119 static ssize_t hfs_direct_IO(int rw, struct kiocb *iocb, 120 const struct iovec *iov, loff_t offset, unsigned long nr_segs) 121 { 122 struct file *file = iocb->ki_filp; 123 struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host; 124 ssize_t ret; 125 126 ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov, 127 offset, nr_segs, hfs_get_block, NULL); 128 129 /* 130 * In case of error extending write may have instantiated a few 131 * blocks outside i_size. Trim these off again. 132 */ 133 if (unlikely((rw & WRITE) && ret < 0)) { 134 loff_t isize = i_size_read(inode); 135 loff_t end = offset + iov_length(iov, nr_segs); 136 137 if (end > isize) 138 vmtruncate(inode, isize); 139 } 140 141 return ret; 142 } 143 144 static int hfs_writepages(struct address_space *mapping, 145 struct writeback_control *wbc) 146 { 147 return mpage_writepages(mapping, wbc, hfs_get_block); 148 } 149 150 const struct address_space_operations hfs_btree_aops = { 151 .readpage = hfs_readpage, 152 .writepage = hfs_writepage, 153 .sync_page = block_sync_page, 154 .write_begin = hfs_write_begin, 155 .write_end = generic_write_end, 156 .bmap = hfs_bmap, 157 .releasepage = hfs_releasepage, 158 }; 159 160 const struct address_space_operations hfs_aops = { 161 .readpage = hfs_readpage, 162 .writepage = hfs_writepage, 163 .sync_page = block_sync_page, 164 .write_begin = hfs_write_begin, 165 .write_end = generic_write_end, 166 .bmap = hfs_bmap, 167 .direct_IO = hfs_direct_IO, 168 .writepages = hfs_writepages, 169 }; 170 171 /* 172 * hfs_new_inode 173 */ 174 struct inode *hfs_new_inode(struct inode *dir, struct qstr *name, int mode) 175 { 176 struct super_block *sb = dir->i_sb; 177 struct inode *inode = new_inode(sb); 178 if (!inode) 179 return NULL; 180 181 mutex_init(&HFS_I(inode)->extents_lock); 182 INIT_LIST_HEAD(&HFS_I(inode)->open_dir_list); 183 hfs_cat_build_key(sb, (btree_key *)&HFS_I(inode)->cat_key, dir->i_ino, name); 184 inode->i_ino = HFS_SB(sb)->next_id++; 185 inode->i_mode = mode; 186 inode->i_uid = current_fsuid(); 187 inode->i_gid = current_fsgid(); 188 inode->i_nlink = 1; 189 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC; 190 HFS_I(inode)->flags = 0; 191 HFS_I(inode)->rsrc_inode = NULL; 192 HFS_I(inode)->fs_blocks = 0; 193 if (S_ISDIR(mode)) { 194 inode->i_size = 2; 195 HFS_SB(sb)->folder_count++; 196 if (dir->i_ino == HFS_ROOT_CNID) 197 HFS_SB(sb)->root_dirs++; 198 inode->i_op = &hfs_dir_inode_operations; 199 inode->i_fop = &hfs_dir_operations; 200 inode->i_mode |= S_IRWXUGO; 201 inode->i_mode &= ~HFS_SB(inode->i_sb)->s_dir_umask; 202 } else if (S_ISREG(mode)) { 203 HFS_I(inode)->clump_blocks = HFS_SB(sb)->clumpablks; 204 HFS_SB(sb)->file_count++; 205 if (dir->i_ino == HFS_ROOT_CNID) 206 HFS_SB(sb)->root_files++; 207 inode->i_op = &hfs_file_inode_operations; 208 inode->i_fop = &hfs_file_operations; 209 inode->i_mapping->a_ops = &hfs_aops; 210 inode->i_mode |= S_IRUGO|S_IXUGO; 211 if (mode & S_IWUSR) 212 inode->i_mode |= S_IWUGO; 213 inode->i_mode &= ~HFS_SB(inode->i_sb)->s_file_umask; 214 HFS_I(inode)->phys_size = 0; 215 HFS_I(inode)->alloc_blocks = 0; 216 HFS_I(inode)->first_blocks = 0; 217 HFS_I(inode)->cached_start = 0; 218 HFS_I(inode)->cached_blocks = 0; 219 memset(HFS_I(inode)->first_extents, 0, sizeof(hfs_extent_rec)); 220 memset(HFS_I(inode)->cached_extents, 0, sizeof(hfs_extent_rec)); 221 } 222 insert_inode_hash(inode); 223 mark_inode_dirty(inode); 224 set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags); 225 sb->s_dirt = 1; 226 227 return inode; 228 } 229 230 void hfs_delete_inode(struct inode *inode) 231 { 232 struct super_block *sb = inode->i_sb; 233 234 dprint(DBG_INODE, "delete_inode: %lu\n", inode->i_ino); 235 if (S_ISDIR(inode->i_mode)) { 236 HFS_SB(sb)->folder_count--; 237 if (HFS_I(inode)->cat_key.ParID == cpu_to_be32(HFS_ROOT_CNID)) 238 HFS_SB(sb)->root_dirs--; 239 set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags); 240 sb->s_dirt = 1; 241 return; 242 } 243 HFS_SB(sb)->file_count--; 244 if (HFS_I(inode)->cat_key.ParID == cpu_to_be32(HFS_ROOT_CNID)) 245 HFS_SB(sb)->root_files--; 246 if (S_ISREG(inode->i_mode)) { 247 if (!inode->i_nlink) { 248 inode->i_size = 0; 249 hfs_file_truncate(inode); 250 } 251 } 252 set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags); 253 sb->s_dirt = 1; 254 } 255 256 void hfs_inode_read_fork(struct inode *inode, struct hfs_extent *ext, 257 __be32 __log_size, __be32 phys_size, u32 clump_size) 258 { 259 struct super_block *sb = inode->i_sb; 260 u32 log_size = be32_to_cpu(__log_size); 261 u16 count; 262 int i; 263 264 memcpy(HFS_I(inode)->first_extents, ext, sizeof(hfs_extent_rec)); 265 for (count = 0, i = 0; i < 3; i++) 266 count += be16_to_cpu(ext[i].count); 267 HFS_I(inode)->first_blocks = count; 268 269 inode->i_size = HFS_I(inode)->phys_size = log_size; 270 HFS_I(inode)->fs_blocks = (log_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits; 271 inode_set_bytes(inode, HFS_I(inode)->fs_blocks << sb->s_blocksize_bits); 272 HFS_I(inode)->alloc_blocks = be32_to_cpu(phys_size) / 273 HFS_SB(sb)->alloc_blksz; 274 HFS_I(inode)->clump_blocks = clump_size / HFS_SB(sb)->alloc_blksz; 275 if (!HFS_I(inode)->clump_blocks) 276 HFS_I(inode)->clump_blocks = HFS_SB(sb)->clumpablks; 277 } 278 279 struct hfs_iget_data { 280 struct hfs_cat_key *key; 281 hfs_cat_rec *rec; 282 }; 283 284 static int hfs_test_inode(struct inode *inode, void *data) 285 { 286 struct hfs_iget_data *idata = data; 287 hfs_cat_rec *rec; 288 289 rec = idata->rec; 290 switch (rec->type) { 291 case HFS_CDR_DIR: 292 return inode->i_ino == be32_to_cpu(rec->dir.DirID); 293 case HFS_CDR_FIL: 294 return inode->i_ino == be32_to_cpu(rec->file.FlNum); 295 default: 296 BUG(); 297 return 1; 298 } 299 } 300 301 /* 302 * hfs_read_inode 303 */ 304 static int hfs_read_inode(struct inode *inode, void *data) 305 { 306 struct hfs_iget_data *idata = data; 307 struct hfs_sb_info *hsb = HFS_SB(inode->i_sb); 308 hfs_cat_rec *rec; 309 310 HFS_I(inode)->flags = 0; 311 HFS_I(inode)->rsrc_inode = NULL; 312 mutex_init(&HFS_I(inode)->extents_lock); 313 INIT_LIST_HEAD(&HFS_I(inode)->open_dir_list); 314 315 /* Initialize the inode */ 316 inode->i_uid = hsb->s_uid; 317 inode->i_gid = hsb->s_gid; 318 inode->i_nlink = 1; 319 320 if (idata->key) 321 HFS_I(inode)->cat_key = *idata->key; 322 else 323 HFS_I(inode)->flags |= HFS_FLG_RSRC; 324 HFS_I(inode)->tz_secondswest = sys_tz.tz_minuteswest * 60; 325 326 rec = idata->rec; 327 switch (rec->type) { 328 case HFS_CDR_FIL: 329 if (!HFS_IS_RSRC(inode)) { 330 hfs_inode_read_fork(inode, rec->file.ExtRec, rec->file.LgLen, 331 rec->file.PyLen, be16_to_cpu(rec->file.ClpSize)); 332 } else { 333 hfs_inode_read_fork(inode, rec->file.RExtRec, rec->file.RLgLen, 334 rec->file.RPyLen, be16_to_cpu(rec->file.ClpSize)); 335 } 336 337 inode->i_ino = be32_to_cpu(rec->file.FlNum); 338 inode->i_mode = S_IRUGO | S_IXUGO; 339 if (!(rec->file.Flags & HFS_FIL_LOCK)) 340 inode->i_mode |= S_IWUGO; 341 inode->i_mode &= ~hsb->s_file_umask; 342 inode->i_mode |= S_IFREG; 343 inode->i_ctime = inode->i_atime = inode->i_mtime = 344 hfs_m_to_utime(rec->file.MdDat); 345 inode->i_op = &hfs_file_inode_operations; 346 inode->i_fop = &hfs_file_operations; 347 inode->i_mapping->a_ops = &hfs_aops; 348 break; 349 case HFS_CDR_DIR: 350 inode->i_ino = be32_to_cpu(rec->dir.DirID); 351 inode->i_size = be16_to_cpu(rec->dir.Val) + 2; 352 HFS_I(inode)->fs_blocks = 0; 353 inode->i_mode = S_IFDIR | (S_IRWXUGO & ~hsb->s_dir_umask); 354 inode->i_ctime = inode->i_atime = inode->i_mtime = 355 hfs_m_to_utime(rec->dir.MdDat); 356 inode->i_op = &hfs_dir_inode_operations; 357 inode->i_fop = &hfs_dir_operations; 358 break; 359 default: 360 make_bad_inode(inode); 361 } 362 return 0; 363 } 364 365 /* 366 * __hfs_iget() 367 * 368 * Given the MDB for a HFS filesystem, a 'key' and an 'entry' in 369 * the catalog B-tree and the 'type' of the desired file return the 370 * inode for that file/directory or NULL. Note that 'type' indicates 371 * whether we want the actual file or directory, or the corresponding 372 * metadata (AppleDouble header file or CAP metadata file). 373 */ 374 struct inode *hfs_iget(struct super_block *sb, struct hfs_cat_key *key, hfs_cat_rec *rec) 375 { 376 struct hfs_iget_data data = { key, rec }; 377 struct inode *inode; 378 u32 cnid; 379 380 switch (rec->type) { 381 case HFS_CDR_DIR: 382 cnid = be32_to_cpu(rec->dir.DirID); 383 break; 384 case HFS_CDR_FIL: 385 cnid = be32_to_cpu(rec->file.FlNum); 386 break; 387 default: 388 return NULL; 389 } 390 inode = iget5_locked(sb, cnid, hfs_test_inode, hfs_read_inode, &data); 391 if (inode && (inode->i_state & I_NEW)) 392 unlock_new_inode(inode); 393 return inode; 394 } 395 396 void hfs_inode_write_fork(struct inode *inode, struct hfs_extent *ext, 397 __be32 *log_size, __be32 *phys_size) 398 { 399 memcpy(ext, HFS_I(inode)->first_extents, sizeof(hfs_extent_rec)); 400 401 if (log_size) 402 *log_size = cpu_to_be32(inode->i_size); 403 if (phys_size) 404 *phys_size = cpu_to_be32(HFS_I(inode)->alloc_blocks * 405 HFS_SB(inode->i_sb)->alloc_blksz); 406 } 407 408 int hfs_write_inode(struct inode *inode, struct writeback_control *wbc) 409 { 410 struct inode *main_inode = inode; 411 struct hfs_find_data fd; 412 hfs_cat_rec rec; 413 414 dprint(DBG_INODE, "hfs_write_inode: %lu\n", inode->i_ino); 415 hfs_ext_write_extent(inode); 416 417 if (inode->i_ino < HFS_FIRSTUSER_CNID) { 418 switch (inode->i_ino) { 419 case HFS_ROOT_CNID: 420 break; 421 case HFS_EXT_CNID: 422 hfs_btree_write(HFS_SB(inode->i_sb)->ext_tree); 423 return 0; 424 case HFS_CAT_CNID: 425 hfs_btree_write(HFS_SB(inode->i_sb)->cat_tree); 426 return 0; 427 default: 428 BUG(); 429 return -EIO; 430 } 431 } 432 433 if (HFS_IS_RSRC(inode)) 434 main_inode = HFS_I(inode)->rsrc_inode; 435 436 if (!main_inode->i_nlink) 437 return 0; 438 439 if (hfs_find_init(HFS_SB(main_inode->i_sb)->cat_tree, &fd)) 440 /* panic? */ 441 return -EIO; 442 443 fd.search_key->cat = HFS_I(main_inode)->cat_key; 444 if (hfs_brec_find(&fd)) 445 /* panic? */ 446 goto out; 447 448 if (S_ISDIR(main_inode->i_mode)) { 449 if (fd.entrylength < sizeof(struct hfs_cat_dir)) 450 /* panic? */; 451 hfs_bnode_read(fd.bnode, &rec, fd.entryoffset, 452 sizeof(struct hfs_cat_dir)); 453 if (rec.type != HFS_CDR_DIR || 454 be32_to_cpu(rec.dir.DirID) != inode->i_ino) { 455 } 456 457 rec.dir.MdDat = hfs_u_to_mtime(inode->i_mtime); 458 rec.dir.Val = cpu_to_be16(inode->i_size - 2); 459 460 hfs_bnode_write(fd.bnode, &rec, fd.entryoffset, 461 sizeof(struct hfs_cat_dir)); 462 } else if (HFS_IS_RSRC(inode)) { 463 hfs_bnode_read(fd.bnode, &rec, fd.entryoffset, 464 sizeof(struct hfs_cat_file)); 465 hfs_inode_write_fork(inode, rec.file.RExtRec, 466 &rec.file.RLgLen, &rec.file.RPyLen); 467 hfs_bnode_write(fd.bnode, &rec, fd.entryoffset, 468 sizeof(struct hfs_cat_file)); 469 } else { 470 if (fd.entrylength < sizeof(struct hfs_cat_file)) 471 /* panic? */; 472 hfs_bnode_read(fd.bnode, &rec, fd.entryoffset, 473 sizeof(struct hfs_cat_file)); 474 if (rec.type != HFS_CDR_FIL || 475 be32_to_cpu(rec.file.FlNum) != inode->i_ino) { 476 } 477 478 if (inode->i_mode & S_IWUSR) 479 rec.file.Flags &= ~HFS_FIL_LOCK; 480 else 481 rec.file.Flags |= HFS_FIL_LOCK; 482 hfs_inode_write_fork(inode, rec.file.ExtRec, &rec.file.LgLen, &rec.file.PyLen); 483 rec.file.MdDat = hfs_u_to_mtime(inode->i_mtime); 484 485 hfs_bnode_write(fd.bnode, &rec, fd.entryoffset, 486 sizeof(struct hfs_cat_file)); 487 } 488 out: 489 hfs_find_exit(&fd); 490 return 0; 491 } 492 493 static struct dentry *hfs_file_lookup(struct inode *dir, struct dentry *dentry, 494 struct nameidata *nd) 495 { 496 struct inode *inode = NULL; 497 hfs_cat_rec rec; 498 struct hfs_find_data fd; 499 int res; 500 501 if (HFS_IS_RSRC(dir) || strcmp(dentry->d_name.name, "rsrc")) 502 goto out; 503 504 inode = HFS_I(dir)->rsrc_inode; 505 if (inode) 506 goto out; 507 508 inode = new_inode(dir->i_sb); 509 if (!inode) 510 return ERR_PTR(-ENOMEM); 511 512 hfs_find_init(HFS_SB(dir->i_sb)->cat_tree, &fd); 513 fd.search_key->cat = HFS_I(dir)->cat_key; 514 res = hfs_brec_read(&fd, &rec, sizeof(rec)); 515 if (!res) { 516 struct hfs_iget_data idata = { NULL, &rec }; 517 hfs_read_inode(inode, &idata); 518 } 519 hfs_find_exit(&fd); 520 if (res) { 521 iput(inode); 522 return ERR_PTR(res); 523 } 524 HFS_I(inode)->rsrc_inode = dir; 525 HFS_I(dir)->rsrc_inode = inode; 526 igrab(dir); 527 hlist_add_fake(&inode->i_hash); 528 mark_inode_dirty(inode); 529 out: 530 d_add(dentry, inode); 531 return NULL; 532 } 533 534 void hfs_evict_inode(struct inode *inode) 535 { 536 truncate_inode_pages(&inode->i_data, 0); 537 end_writeback(inode); 538 if (HFS_IS_RSRC(inode) && HFS_I(inode)->rsrc_inode) { 539 HFS_I(HFS_I(inode)->rsrc_inode)->rsrc_inode = NULL; 540 iput(HFS_I(inode)->rsrc_inode); 541 } 542 } 543 544 static int hfs_file_open(struct inode *inode, struct file *file) 545 { 546 if (HFS_IS_RSRC(inode)) 547 inode = HFS_I(inode)->rsrc_inode; 548 atomic_inc(&HFS_I(inode)->opencnt); 549 return 0; 550 } 551 552 static int hfs_file_release(struct inode *inode, struct file *file) 553 { 554 //struct super_block *sb = inode->i_sb; 555 556 if (HFS_IS_RSRC(inode)) 557 inode = HFS_I(inode)->rsrc_inode; 558 if (atomic_dec_and_test(&HFS_I(inode)->opencnt)) { 559 mutex_lock(&inode->i_mutex); 560 hfs_file_truncate(inode); 561 //if (inode->i_flags & S_DEAD) { 562 // hfs_delete_cat(inode->i_ino, HFSPLUS_SB(sb).hidden_dir, NULL); 563 // hfs_delete_inode(inode); 564 //} 565 mutex_unlock(&inode->i_mutex); 566 } 567 return 0; 568 } 569 570 /* 571 * hfs_notify_change() 572 * 573 * Based very closely on fs/msdos/inode.c by Werner Almesberger 574 * 575 * This is the notify_change() field in the super_operations structure 576 * for HFS file systems. The purpose is to take that changes made to 577 * an inode and apply then in a filesystem-dependent manner. In this 578 * case the process has a few of tasks to do: 579 * 1) prevent changes to the i_uid and i_gid fields. 580 * 2) map file permissions to the closest allowable permissions 581 * 3) Since multiple Linux files can share the same on-disk inode under 582 * HFS (for instance the data and resource forks of a file) a change 583 * to permissions must be applied to all other in-core inodes which 584 * correspond to the same HFS file. 585 */ 586 587 int hfs_inode_setattr(struct dentry *dentry, struct iattr * attr) 588 { 589 struct inode *inode = dentry->d_inode; 590 struct hfs_sb_info *hsb = HFS_SB(inode->i_sb); 591 int error; 592 593 error = inode_change_ok(inode, attr); /* basic permission checks */ 594 if (error) 595 return error; 596 597 /* no uig/gid changes and limit which mode bits can be set */ 598 if (((attr->ia_valid & ATTR_UID) && 599 (attr->ia_uid != hsb->s_uid)) || 600 ((attr->ia_valid & ATTR_GID) && 601 (attr->ia_gid != hsb->s_gid)) || 602 ((attr->ia_valid & ATTR_MODE) && 603 ((S_ISDIR(inode->i_mode) && 604 (attr->ia_mode != inode->i_mode)) || 605 (attr->ia_mode & ~HFS_VALID_MODE_BITS)))) { 606 return hsb->s_quiet ? 0 : error; 607 } 608 609 if (attr->ia_valid & ATTR_MODE) { 610 /* Only the 'w' bits can ever change and only all together. */ 611 if (attr->ia_mode & S_IWUSR) 612 attr->ia_mode = inode->i_mode | S_IWUGO; 613 else 614 attr->ia_mode = inode->i_mode & ~S_IWUGO; 615 attr->ia_mode &= S_ISDIR(inode->i_mode) ? ~hsb->s_dir_umask: ~hsb->s_file_umask; 616 } 617 618 if ((attr->ia_valid & ATTR_SIZE) && 619 attr->ia_size != i_size_read(inode)) { 620 error = vmtruncate(inode, attr->ia_size); 621 if (error) 622 return error; 623 } 624 625 setattr_copy(inode, attr); 626 mark_inode_dirty(inode); 627 return 0; 628 } 629 630 static int hfs_file_fsync(struct file *filp, int datasync) 631 { 632 struct inode *inode = filp->f_mapping->host; 633 struct super_block * sb; 634 int ret, err; 635 636 /* sync the inode to buffers */ 637 ret = write_inode_now(inode, 0); 638 639 /* sync the superblock to buffers */ 640 sb = inode->i_sb; 641 if (sb->s_dirt) { 642 lock_super(sb); 643 sb->s_dirt = 0; 644 if (!(sb->s_flags & MS_RDONLY)) 645 hfs_mdb_commit(sb); 646 unlock_super(sb); 647 } 648 /* .. finally sync the buffers to disk */ 649 err = sync_blockdev(sb->s_bdev); 650 if (!ret) 651 ret = err; 652 return ret; 653 } 654 655 static const struct file_operations hfs_file_operations = { 656 .llseek = generic_file_llseek, 657 .read = do_sync_read, 658 .aio_read = generic_file_aio_read, 659 .write = do_sync_write, 660 .aio_write = generic_file_aio_write, 661 .mmap = generic_file_mmap, 662 .splice_read = generic_file_splice_read, 663 .fsync = hfs_file_fsync, 664 .open = hfs_file_open, 665 .release = hfs_file_release, 666 }; 667 668 static const struct inode_operations hfs_file_inode_operations = { 669 .lookup = hfs_file_lookup, 670 .truncate = hfs_file_truncate, 671 .setattr = hfs_inode_setattr, 672 .setxattr = hfs_setxattr, 673 .getxattr = hfs_getxattr, 674 .listxattr = hfs_listxattr, 675 }; 676