1 /* 2 * linux/fs/ext4/file.c 3 * 4 * Copyright (C) 1992, 1993, 1994, 1995 5 * Remy Card (card@masi.ibp.fr) 6 * Laboratoire MASI - Institut Blaise Pascal 7 * Universite Pierre et Marie Curie (Paris VI) 8 * 9 * from 10 * 11 * linux/fs/minix/file.c 12 * 13 * Copyright (C) 1991, 1992 Linus Torvalds 14 * 15 * ext4 fs regular file handling primitives 16 * 17 * 64-bit file support on 64-bit platforms by Jakub Jelinek 18 * (jj@sunsite.ms.mff.cuni.cz) 19 */ 20 21 #include <linux/time.h> 22 #include <linux/fs.h> 23 #include <linux/jbd2.h> 24 #include <linux/mount.h> 25 #include <linux/path.h> 26 #include <linux/aio.h> 27 #include <linux/quotaops.h> 28 #include <linux/pagevec.h> 29 #include "ext4.h" 30 #include "ext4_jbd2.h" 31 #include "xattr.h" 32 #include "acl.h" 33 34 /* 35 * Called when an inode is released. Note that this is different 36 * from ext4_file_open: open gets called at every open, but release 37 * gets called only when /all/ the files are closed. 38 */ 39 static int ext4_release_file(struct inode *inode, struct file *filp) 40 { 41 if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) { 42 ext4_alloc_da_blocks(inode); 43 ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE); 44 } 45 /* if we are the last writer on the inode, drop the block reservation */ 46 if ((filp->f_mode & FMODE_WRITE) && 47 (atomic_read(&inode->i_writecount) == 1) && 48 !EXT4_I(inode)->i_reserved_data_blocks) 49 { 50 down_write(&EXT4_I(inode)->i_data_sem); 51 ext4_discard_preallocations(inode); 52 up_write(&EXT4_I(inode)->i_data_sem); 53 } 54 if (is_dx(inode) && filp->private_data) 55 ext4_htree_free_dir_info(filp->private_data); 56 57 return 0; 58 } 59 60 static void ext4_unwritten_wait(struct inode *inode) 61 { 62 wait_queue_head_t *wq = ext4_ioend_wq(inode); 63 64 wait_event(*wq, (atomic_read(&EXT4_I(inode)->i_unwritten) == 0)); 65 } 66 67 /* 68 * This tests whether the IO in question is block-aligned or not. 69 * Ext4 utilizes unwritten extents when hole-filling during direct IO, and they 70 * are converted to written only after the IO is complete. Until they are 71 * mapped, these blocks appear as holes, so dio_zero_block() will assume that 72 * it needs to zero out portions of the start and/or end block. If 2 AIO 73 * threads are at work on the same unwritten block, they must be synchronized 74 * or one thread will zero the other's data, causing corruption. 75 */ 76 static int 77 ext4_unaligned_aio(struct inode *inode, struct iov_iter *from, loff_t pos) 78 { 79 struct super_block *sb = inode->i_sb; 80 int blockmask = sb->s_blocksize - 1; 81 82 if (pos >= i_size_read(inode)) 83 return 0; 84 85 if ((pos | iov_iter_alignment(from)) & blockmask) 86 return 1; 87 88 return 0; 89 } 90 91 static ssize_t 92 ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 93 { 94 struct file *file = iocb->ki_filp; 95 struct inode *inode = file_inode(iocb->ki_filp); 96 struct mutex *aio_mutex = NULL; 97 struct blk_plug plug; 98 int o_direct = file->f_flags & O_DIRECT; 99 int overwrite = 0; 100 size_t length = iov_iter_count(from); 101 ssize_t ret; 102 loff_t pos = iocb->ki_pos; 103 104 /* 105 * Unaligned direct AIO must be serialized; see comment above 106 * In the case of O_APPEND, assume that we must always serialize 107 */ 108 if (o_direct && 109 ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) && 110 !is_sync_kiocb(iocb) && 111 (file->f_flags & O_APPEND || 112 ext4_unaligned_aio(inode, from, pos))) { 113 aio_mutex = ext4_aio_mutex(inode); 114 mutex_lock(aio_mutex); 115 ext4_unwritten_wait(inode); 116 } 117 118 mutex_lock(&inode->i_mutex); 119 if (file->f_flags & O_APPEND) 120 iocb->ki_pos = pos = i_size_read(inode); 121 122 /* 123 * If we have encountered a bitmap-format file, the size limit 124 * is smaller than s_maxbytes, which is for extent-mapped files. 125 */ 126 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) { 127 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 128 129 if ((pos > sbi->s_bitmap_maxbytes) || 130 (pos == sbi->s_bitmap_maxbytes && length > 0)) { 131 mutex_unlock(&inode->i_mutex); 132 ret = -EFBIG; 133 goto errout; 134 } 135 136 if (pos + length > sbi->s_bitmap_maxbytes) 137 iov_iter_truncate(from, sbi->s_bitmap_maxbytes - pos); 138 } 139 140 iocb->private = &overwrite; 141 if (o_direct) { 142 blk_start_plug(&plug); 143 144 145 /* check whether we do a DIO overwrite or not */ 146 if (ext4_should_dioread_nolock(inode) && !aio_mutex && 147 !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) { 148 struct ext4_map_blocks map; 149 unsigned int blkbits = inode->i_blkbits; 150 int err, len; 151 152 map.m_lblk = pos >> blkbits; 153 map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits) 154 - map.m_lblk; 155 len = map.m_len; 156 157 err = ext4_map_blocks(NULL, inode, &map, 0); 158 /* 159 * 'err==len' means that all of blocks has 160 * been preallocated no matter they are 161 * initialized or not. For excluding 162 * unwritten extents, we need to check 163 * m_flags. There are two conditions that 164 * indicate for initialized extents. 1) If we 165 * hit extent cache, EXT4_MAP_MAPPED flag is 166 * returned; 2) If we do a real lookup, 167 * non-flags are returned. So we should check 168 * these two conditions. 169 */ 170 if (err == len && (map.m_flags & EXT4_MAP_MAPPED)) 171 overwrite = 1; 172 } 173 } 174 175 ret = __generic_file_write_iter(iocb, from); 176 mutex_unlock(&inode->i_mutex); 177 178 if (ret > 0) { 179 ssize_t err; 180 181 err = generic_write_sync(file, iocb->ki_pos - ret, ret); 182 if (err < 0) 183 ret = err; 184 } 185 if (o_direct) 186 blk_finish_plug(&plug); 187 188 errout: 189 if (aio_mutex) 190 mutex_unlock(aio_mutex); 191 return ret; 192 } 193 194 static const struct vm_operations_struct ext4_file_vm_ops = { 195 .fault = filemap_fault, 196 .map_pages = filemap_map_pages, 197 .page_mkwrite = ext4_page_mkwrite, 198 .remap_pages = generic_file_remap_pages, 199 }; 200 201 static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma) 202 { 203 file_accessed(file); 204 vma->vm_ops = &ext4_file_vm_ops; 205 return 0; 206 } 207 208 static int ext4_file_open(struct inode * inode, struct file * filp) 209 { 210 struct super_block *sb = inode->i_sb; 211 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 212 struct vfsmount *mnt = filp->f_path.mnt; 213 struct path path; 214 char buf[64], *cp; 215 216 if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) && 217 !(sb->s_flags & MS_RDONLY))) { 218 sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED; 219 /* 220 * Sample where the filesystem has been mounted and 221 * store it in the superblock for sysadmin convenience 222 * when trying to sort through large numbers of block 223 * devices or filesystem images. 224 */ 225 memset(buf, 0, sizeof(buf)); 226 path.mnt = mnt; 227 path.dentry = mnt->mnt_root; 228 cp = d_path(&path, buf, sizeof(buf)); 229 if (!IS_ERR(cp)) { 230 handle_t *handle; 231 int err; 232 233 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1); 234 if (IS_ERR(handle)) 235 return PTR_ERR(handle); 236 BUFFER_TRACE(sbi->s_sbh, "get_write_access"); 237 err = ext4_journal_get_write_access(handle, sbi->s_sbh); 238 if (err) { 239 ext4_journal_stop(handle); 240 return err; 241 } 242 strlcpy(sbi->s_es->s_last_mounted, cp, 243 sizeof(sbi->s_es->s_last_mounted)); 244 ext4_handle_dirty_super(handle, sb); 245 ext4_journal_stop(handle); 246 } 247 } 248 /* 249 * Set up the jbd2_inode if we are opening the inode for 250 * writing and the journal is present 251 */ 252 if (filp->f_mode & FMODE_WRITE) { 253 int ret = ext4_inode_attach_jinode(inode); 254 if (ret < 0) 255 return ret; 256 } 257 return dquot_file_open(inode, filp); 258 } 259 260 /* 261 * Here we use ext4_map_blocks() to get a block mapping for a extent-based 262 * file rather than ext4_ext_walk_space() because we can introduce 263 * SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same 264 * function. When extent status tree has been fully implemented, it will 265 * track all extent status for a file and we can directly use it to 266 * retrieve the offset for SEEK_DATA/SEEK_HOLE. 267 */ 268 269 /* 270 * When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to 271 * lookup page cache to check whether or not there has some data between 272 * [startoff, endoff] because, if this range contains an unwritten extent, 273 * we determine this extent as a data or a hole according to whether the 274 * page cache has data or not. 275 */ 276 static int ext4_find_unwritten_pgoff(struct inode *inode, int whence, 277 loff_t endoff, loff_t *offset) 278 { 279 struct pagevec pvec; 280 pgoff_t index; 281 pgoff_t end; 282 loff_t startoff; 283 loff_t lastoff; 284 int found = 0; 285 286 startoff = *offset; 287 lastoff = startoff; 288 289 290 index = startoff >> PAGE_CACHE_SHIFT; 291 end = endoff >> PAGE_CACHE_SHIFT; 292 293 pagevec_init(&pvec, 0); 294 do { 295 int i, num; 296 unsigned long nr_pages; 297 298 num = min_t(pgoff_t, end - index, PAGEVEC_SIZE); 299 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index, 300 (pgoff_t)num); 301 if (nr_pages == 0) { 302 if (whence == SEEK_DATA) 303 break; 304 305 BUG_ON(whence != SEEK_HOLE); 306 /* 307 * If this is the first time to go into the loop and 308 * offset is not beyond the end offset, it will be a 309 * hole at this offset 310 */ 311 if (lastoff == startoff || lastoff < endoff) 312 found = 1; 313 break; 314 } 315 316 /* 317 * If this is the first time to go into the loop and 318 * offset is smaller than the first page offset, it will be a 319 * hole at this offset. 320 */ 321 if (lastoff == startoff && whence == SEEK_HOLE && 322 lastoff < page_offset(pvec.pages[0])) { 323 found = 1; 324 break; 325 } 326 327 for (i = 0; i < nr_pages; i++) { 328 struct page *page = pvec.pages[i]; 329 struct buffer_head *bh, *head; 330 331 /* 332 * If the current offset is not beyond the end of given 333 * range, it will be a hole. 334 */ 335 if (lastoff < endoff && whence == SEEK_HOLE && 336 page->index > end) { 337 found = 1; 338 *offset = lastoff; 339 goto out; 340 } 341 342 lock_page(page); 343 344 if (unlikely(page->mapping != inode->i_mapping)) { 345 unlock_page(page); 346 continue; 347 } 348 349 if (!page_has_buffers(page)) { 350 unlock_page(page); 351 continue; 352 } 353 354 if (page_has_buffers(page)) { 355 lastoff = page_offset(page); 356 bh = head = page_buffers(page); 357 do { 358 if (buffer_uptodate(bh) || 359 buffer_unwritten(bh)) { 360 if (whence == SEEK_DATA) 361 found = 1; 362 } else { 363 if (whence == SEEK_HOLE) 364 found = 1; 365 } 366 if (found) { 367 *offset = max_t(loff_t, 368 startoff, lastoff); 369 unlock_page(page); 370 goto out; 371 } 372 lastoff += bh->b_size; 373 bh = bh->b_this_page; 374 } while (bh != head); 375 } 376 377 lastoff = page_offset(page) + PAGE_SIZE; 378 unlock_page(page); 379 } 380 381 /* 382 * The no. of pages is less than our desired, that would be a 383 * hole in there. 384 */ 385 if (nr_pages < num && whence == SEEK_HOLE) { 386 found = 1; 387 *offset = lastoff; 388 break; 389 } 390 391 index = pvec.pages[i - 1]->index + 1; 392 pagevec_release(&pvec); 393 } while (index <= end); 394 395 out: 396 pagevec_release(&pvec); 397 return found; 398 } 399 400 /* 401 * ext4_seek_data() retrieves the offset for SEEK_DATA. 402 */ 403 static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize) 404 { 405 struct inode *inode = file->f_mapping->host; 406 struct fiemap_extent_info fie; 407 struct fiemap_extent ext[2]; 408 loff_t next; 409 int i, ret = 0; 410 411 mutex_lock(&inode->i_mutex); 412 if (offset >= inode->i_size) { 413 mutex_unlock(&inode->i_mutex); 414 return -ENXIO; 415 } 416 fie.fi_flags = 0; 417 fie.fi_extents_max = 2; 418 fie.fi_extents_start = (struct fiemap_extent __user *) &ext; 419 while (1) { 420 mm_segment_t old_fs = get_fs(); 421 422 fie.fi_extents_mapped = 0; 423 memset(ext, 0, sizeof(*ext) * fie.fi_extents_max); 424 425 set_fs(get_ds()); 426 ret = ext4_fiemap(inode, &fie, offset, maxsize - offset); 427 set_fs(old_fs); 428 if (ret) 429 break; 430 431 /* No extents found, EOF */ 432 if (!fie.fi_extents_mapped) { 433 ret = -ENXIO; 434 break; 435 } 436 for (i = 0; i < fie.fi_extents_mapped; i++) { 437 next = (loff_t)(ext[i].fe_length + ext[i].fe_logical); 438 439 if (offset < (loff_t)ext[i].fe_logical) 440 offset = (loff_t)ext[i].fe_logical; 441 /* 442 * If extent is not unwritten, then it contains valid 443 * data, mapped or delayed. 444 */ 445 if (!(ext[i].fe_flags & FIEMAP_EXTENT_UNWRITTEN)) 446 goto out; 447 448 /* 449 * If there is a unwritten extent at this offset, 450 * it will be as a data or a hole according to page 451 * cache that has data or not. 452 */ 453 if (ext4_find_unwritten_pgoff(inode, SEEK_DATA, 454 next, &offset)) 455 goto out; 456 457 if (ext[i].fe_flags & FIEMAP_EXTENT_LAST) { 458 ret = -ENXIO; 459 goto out; 460 } 461 offset = next; 462 } 463 } 464 if (offset > inode->i_size) 465 offset = inode->i_size; 466 out: 467 mutex_unlock(&inode->i_mutex); 468 if (ret) 469 return ret; 470 471 return vfs_setpos(file, offset, maxsize); 472 } 473 474 /* 475 * ext4_seek_hole() retrieves the offset for SEEK_HOLE 476 */ 477 static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize) 478 { 479 struct inode *inode = file->f_mapping->host; 480 struct fiemap_extent_info fie; 481 struct fiemap_extent ext[2]; 482 loff_t next; 483 int i, ret = 0; 484 485 mutex_lock(&inode->i_mutex); 486 if (offset >= inode->i_size) { 487 mutex_unlock(&inode->i_mutex); 488 return -ENXIO; 489 } 490 491 fie.fi_flags = 0; 492 fie.fi_extents_max = 2; 493 fie.fi_extents_start = (struct fiemap_extent __user *)&ext; 494 while (1) { 495 mm_segment_t old_fs = get_fs(); 496 497 fie.fi_extents_mapped = 0; 498 memset(ext, 0, sizeof(*ext)); 499 500 set_fs(get_ds()); 501 ret = ext4_fiemap(inode, &fie, offset, maxsize - offset); 502 set_fs(old_fs); 503 if (ret) 504 break; 505 506 /* No extents found */ 507 if (!fie.fi_extents_mapped) 508 break; 509 510 for (i = 0; i < fie.fi_extents_mapped; i++) { 511 next = (loff_t)(ext[i].fe_logical + ext[i].fe_length); 512 /* 513 * If extent is not unwritten, then it contains valid 514 * data, mapped or delayed. 515 */ 516 if (!(ext[i].fe_flags & FIEMAP_EXTENT_UNWRITTEN)) { 517 if (offset < (loff_t)ext[i].fe_logical) 518 goto out; 519 offset = next; 520 continue; 521 } 522 /* 523 * If there is a unwritten extent at this offset, 524 * it will be as a data or a hole according to page 525 * cache that has data or not. 526 */ 527 if (ext4_find_unwritten_pgoff(inode, SEEK_HOLE, 528 next, &offset)) 529 goto out; 530 531 offset = next; 532 if (ext[i].fe_flags & FIEMAP_EXTENT_LAST) 533 goto out; 534 } 535 } 536 if (offset > inode->i_size) 537 offset = inode->i_size; 538 out: 539 mutex_unlock(&inode->i_mutex); 540 if (ret) 541 return ret; 542 543 return vfs_setpos(file, offset, maxsize); 544 } 545 546 /* 547 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values 548 * by calling generic_file_llseek_size() with the appropriate maxbytes 549 * value for each. 550 */ 551 loff_t ext4_llseek(struct file *file, loff_t offset, int whence) 552 { 553 struct inode *inode = file->f_mapping->host; 554 loff_t maxbytes; 555 556 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) 557 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes; 558 else 559 maxbytes = inode->i_sb->s_maxbytes; 560 561 switch (whence) { 562 case SEEK_SET: 563 case SEEK_CUR: 564 case SEEK_END: 565 return generic_file_llseek_size(file, offset, whence, 566 maxbytes, i_size_read(inode)); 567 case SEEK_DATA: 568 return ext4_seek_data(file, offset, maxbytes); 569 case SEEK_HOLE: 570 return ext4_seek_hole(file, offset, maxbytes); 571 } 572 573 return -EINVAL; 574 } 575 576 const struct file_operations ext4_file_operations = { 577 .llseek = ext4_llseek, 578 .read = new_sync_read, 579 .write = new_sync_write, 580 .read_iter = generic_file_read_iter, 581 .write_iter = ext4_file_write_iter, 582 .unlocked_ioctl = ext4_ioctl, 583 #ifdef CONFIG_COMPAT 584 .compat_ioctl = ext4_compat_ioctl, 585 #endif 586 .mmap = ext4_file_mmap, 587 .open = ext4_file_open, 588 .release = ext4_release_file, 589 .fsync = ext4_sync_file, 590 .splice_read = generic_file_splice_read, 591 .splice_write = iter_file_splice_write, 592 .fallocate = ext4_fallocate, 593 }; 594 595 const struct inode_operations ext4_file_inode_operations = { 596 .setattr = ext4_setattr, 597 .getattr = ext4_getattr, 598 .setxattr = generic_setxattr, 599 .getxattr = generic_getxattr, 600 .listxattr = ext4_listxattr, 601 .removexattr = generic_removexattr, 602 .get_acl = ext4_get_acl, 603 .set_acl = ext4_set_acl, 604 .fiemap = ext4_fiemap, 605 }; 606 607