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 if (o_direct) { 141 blk_start_plug(&plug); 142 143 iocb->private = &overwrite; 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 struct address_space *mapping = file->f_mapping; 204 205 if (!mapping->a_ops->readpage) 206 return -ENOEXEC; 207 file_accessed(file); 208 vma->vm_ops = &ext4_file_vm_ops; 209 return 0; 210 } 211 212 static int ext4_file_open(struct inode * inode, struct file * filp) 213 { 214 struct super_block *sb = inode->i_sb; 215 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 216 struct vfsmount *mnt = filp->f_path.mnt; 217 struct path path; 218 char buf[64], *cp; 219 220 if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) && 221 !(sb->s_flags & MS_RDONLY))) { 222 sbi->s_mount_flags |= EXT4_MF_MNTDIR_SAMPLED; 223 /* 224 * Sample where the filesystem has been mounted and 225 * store it in the superblock for sysadmin convenience 226 * when trying to sort through large numbers of block 227 * devices or filesystem images. 228 */ 229 memset(buf, 0, sizeof(buf)); 230 path.mnt = mnt; 231 path.dentry = mnt->mnt_root; 232 cp = d_path(&path, buf, sizeof(buf)); 233 if (!IS_ERR(cp)) { 234 handle_t *handle; 235 int err; 236 237 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1); 238 if (IS_ERR(handle)) 239 return PTR_ERR(handle); 240 BUFFER_TRACE(sbi->s_sbh, "get_write_access"); 241 err = ext4_journal_get_write_access(handle, sbi->s_sbh); 242 if (err) { 243 ext4_journal_stop(handle); 244 return err; 245 } 246 strlcpy(sbi->s_es->s_last_mounted, cp, 247 sizeof(sbi->s_es->s_last_mounted)); 248 ext4_handle_dirty_super(handle, sb); 249 ext4_journal_stop(handle); 250 } 251 } 252 /* 253 * Set up the jbd2_inode if we are opening the inode for 254 * writing and the journal is present 255 */ 256 if (filp->f_mode & FMODE_WRITE) { 257 int ret = ext4_inode_attach_jinode(inode); 258 if (ret < 0) 259 return ret; 260 } 261 return dquot_file_open(inode, filp); 262 } 263 264 /* 265 * Here we use ext4_map_blocks() to get a block mapping for a extent-based 266 * file rather than ext4_ext_walk_space() because we can introduce 267 * SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same 268 * function. When extent status tree has been fully implemented, it will 269 * track all extent status for a file and we can directly use it to 270 * retrieve the offset for SEEK_DATA/SEEK_HOLE. 271 */ 272 273 /* 274 * When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to 275 * lookup page cache to check whether or not there has some data between 276 * [startoff, endoff] because, if this range contains an unwritten extent, 277 * we determine this extent as a data or a hole according to whether the 278 * page cache has data or not. 279 */ 280 static int ext4_find_unwritten_pgoff(struct inode *inode, 281 int whence, 282 struct ext4_map_blocks *map, 283 loff_t *offset) 284 { 285 struct pagevec pvec; 286 unsigned int blkbits; 287 pgoff_t index; 288 pgoff_t end; 289 loff_t endoff; 290 loff_t startoff; 291 loff_t lastoff; 292 int found = 0; 293 294 blkbits = inode->i_sb->s_blocksize_bits; 295 startoff = *offset; 296 lastoff = startoff; 297 endoff = (loff_t)(map->m_lblk + map->m_len) << blkbits; 298 299 index = startoff >> PAGE_CACHE_SHIFT; 300 end = endoff >> PAGE_CACHE_SHIFT; 301 302 pagevec_init(&pvec, 0); 303 do { 304 int i, num; 305 unsigned long nr_pages; 306 307 num = min_t(pgoff_t, end - index, PAGEVEC_SIZE); 308 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index, 309 (pgoff_t)num); 310 if (nr_pages == 0) { 311 if (whence == SEEK_DATA) 312 break; 313 314 BUG_ON(whence != SEEK_HOLE); 315 /* 316 * If this is the first time to go into the loop and 317 * offset is not beyond the end offset, it will be a 318 * hole at this offset 319 */ 320 if (lastoff == startoff || lastoff < endoff) 321 found = 1; 322 break; 323 } 324 325 /* 326 * If this is the first time to go into the loop and 327 * offset is smaller than the first page offset, it will be a 328 * hole at this offset. 329 */ 330 if (lastoff == startoff && whence == SEEK_HOLE && 331 lastoff < page_offset(pvec.pages[0])) { 332 found = 1; 333 break; 334 } 335 336 for (i = 0; i < nr_pages; i++) { 337 struct page *page = pvec.pages[i]; 338 struct buffer_head *bh, *head; 339 340 /* 341 * If the current offset is not beyond the end of given 342 * range, it will be a hole. 343 */ 344 if (lastoff < endoff && whence == SEEK_HOLE && 345 page->index > end) { 346 found = 1; 347 *offset = lastoff; 348 goto out; 349 } 350 351 lock_page(page); 352 353 if (unlikely(page->mapping != inode->i_mapping)) { 354 unlock_page(page); 355 continue; 356 } 357 358 if (!page_has_buffers(page)) { 359 unlock_page(page); 360 continue; 361 } 362 363 if (page_has_buffers(page)) { 364 lastoff = page_offset(page); 365 bh = head = page_buffers(page); 366 do { 367 if (buffer_uptodate(bh) || 368 buffer_unwritten(bh)) { 369 if (whence == SEEK_DATA) 370 found = 1; 371 } else { 372 if (whence == SEEK_HOLE) 373 found = 1; 374 } 375 if (found) { 376 *offset = max_t(loff_t, 377 startoff, lastoff); 378 unlock_page(page); 379 goto out; 380 } 381 lastoff += bh->b_size; 382 bh = bh->b_this_page; 383 } while (bh != head); 384 } 385 386 lastoff = page_offset(page) + PAGE_SIZE; 387 unlock_page(page); 388 } 389 390 /* 391 * The no. of pages is less than our desired, that would be a 392 * hole in there. 393 */ 394 if (nr_pages < num && whence == SEEK_HOLE) { 395 found = 1; 396 *offset = lastoff; 397 break; 398 } 399 400 index = pvec.pages[i - 1]->index + 1; 401 pagevec_release(&pvec); 402 } while (index <= end); 403 404 out: 405 pagevec_release(&pvec); 406 return found; 407 } 408 409 /* 410 * ext4_seek_data() retrieves the offset for SEEK_DATA. 411 */ 412 static loff_t ext4_seek_data(struct file *file, loff_t offset, loff_t maxsize) 413 { 414 struct inode *inode = file->f_mapping->host; 415 struct ext4_map_blocks map; 416 struct extent_status es; 417 ext4_lblk_t start, last, end; 418 loff_t dataoff, isize; 419 int blkbits; 420 int ret = 0; 421 422 mutex_lock(&inode->i_mutex); 423 424 isize = i_size_read(inode); 425 if (offset >= isize) { 426 mutex_unlock(&inode->i_mutex); 427 return -ENXIO; 428 } 429 430 blkbits = inode->i_sb->s_blocksize_bits; 431 start = offset >> blkbits; 432 last = start; 433 end = isize >> blkbits; 434 dataoff = offset; 435 436 do { 437 map.m_lblk = last; 438 map.m_len = end - last + 1; 439 ret = ext4_map_blocks(NULL, inode, &map, 0); 440 if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) { 441 if (last != start) 442 dataoff = (loff_t)last << blkbits; 443 break; 444 } 445 446 /* 447 * If there is a delay extent at this offset, 448 * it will be as a data. 449 */ 450 ext4_es_find_delayed_extent_range(inode, last, last, &es); 451 if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) { 452 if (last != start) 453 dataoff = (loff_t)last << blkbits; 454 break; 455 } 456 457 /* 458 * If there is a unwritten extent at this offset, 459 * it will be as a data or a hole according to page 460 * cache that has data or not. 461 */ 462 if (map.m_flags & EXT4_MAP_UNWRITTEN) { 463 int unwritten; 464 unwritten = ext4_find_unwritten_pgoff(inode, SEEK_DATA, 465 &map, &dataoff); 466 if (unwritten) 467 break; 468 } 469 470 last++; 471 dataoff = (loff_t)last << blkbits; 472 } while (last <= end); 473 474 mutex_unlock(&inode->i_mutex); 475 476 if (dataoff > isize) 477 return -ENXIO; 478 479 return vfs_setpos(file, dataoff, maxsize); 480 } 481 482 /* 483 * ext4_seek_hole() retrieves the offset for SEEK_HOLE. 484 */ 485 static loff_t ext4_seek_hole(struct file *file, loff_t offset, loff_t maxsize) 486 { 487 struct inode *inode = file->f_mapping->host; 488 struct ext4_map_blocks map; 489 struct extent_status es; 490 ext4_lblk_t start, last, end; 491 loff_t holeoff, isize; 492 int blkbits; 493 int ret = 0; 494 495 mutex_lock(&inode->i_mutex); 496 497 isize = i_size_read(inode); 498 if (offset >= isize) { 499 mutex_unlock(&inode->i_mutex); 500 return -ENXIO; 501 } 502 503 blkbits = inode->i_sb->s_blocksize_bits; 504 start = offset >> blkbits; 505 last = start; 506 end = isize >> blkbits; 507 holeoff = offset; 508 509 do { 510 map.m_lblk = last; 511 map.m_len = end - last + 1; 512 ret = ext4_map_blocks(NULL, inode, &map, 0); 513 if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) { 514 last += ret; 515 holeoff = (loff_t)last << blkbits; 516 continue; 517 } 518 519 /* 520 * If there is a delay extent at this offset, 521 * we will skip this extent. 522 */ 523 ext4_es_find_delayed_extent_range(inode, last, last, &es); 524 if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) { 525 last = es.es_lblk + es.es_len; 526 holeoff = (loff_t)last << blkbits; 527 continue; 528 } 529 530 /* 531 * If there is a unwritten extent at this offset, 532 * it will be as a data or a hole according to page 533 * cache that has data or not. 534 */ 535 if (map.m_flags & EXT4_MAP_UNWRITTEN) { 536 int unwritten; 537 unwritten = ext4_find_unwritten_pgoff(inode, SEEK_HOLE, 538 &map, &holeoff); 539 if (!unwritten) { 540 last += ret; 541 holeoff = (loff_t)last << blkbits; 542 continue; 543 } 544 } 545 546 /* find a hole */ 547 break; 548 } while (last <= end); 549 550 mutex_unlock(&inode->i_mutex); 551 552 if (holeoff > isize) 553 holeoff = isize; 554 555 return vfs_setpos(file, holeoff, maxsize); 556 } 557 558 /* 559 * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values 560 * by calling generic_file_llseek_size() with the appropriate maxbytes 561 * value for each. 562 */ 563 loff_t ext4_llseek(struct file *file, loff_t offset, int whence) 564 { 565 struct inode *inode = file->f_mapping->host; 566 loff_t maxbytes; 567 568 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) 569 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes; 570 else 571 maxbytes = inode->i_sb->s_maxbytes; 572 573 switch (whence) { 574 case SEEK_SET: 575 case SEEK_CUR: 576 case SEEK_END: 577 return generic_file_llseek_size(file, offset, whence, 578 maxbytes, i_size_read(inode)); 579 case SEEK_DATA: 580 return ext4_seek_data(file, offset, maxbytes); 581 case SEEK_HOLE: 582 return ext4_seek_hole(file, offset, maxbytes); 583 } 584 585 return -EINVAL; 586 } 587 588 const struct file_operations ext4_file_operations = { 589 .llseek = ext4_llseek, 590 .read = new_sync_read, 591 .write = new_sync_write, 592 .read_iter = generic_file_read_iter, 593 .write_iter = ext4_file_write_iter, 594 .unlocked_ioctl = ext4_ioctl, 595 #ifdef CONFIG_COMPAT 596 .compat_ioctl = ext4_compat_ioctl, 597 #endif 598 .mmap = ext4_file_mmap, 599 .open = ext4_file_open, 600 .release = ext4_release_file, 601 .fsync = ext4_sync_file, 602 .splice_read = generic_file_splice_read, 603 .splice_write = iter_file_splice_write, 604 .fallocate = ext4_fallocate, 605 }; 606 607 const struct inode_operations ext4_file_inode_operations = { 608 .setattr = ext4_setattr, 609 .getattr = ext4_getattr, 610 .setxattr = generic_setxattr, 611 .getxattr = generic_getxattr, 612 .listxattr = ext4_listxattr, 613 .removexattr = generic_removexattr, 614 .get_acl = ext4_get_acl, 615 .set_acl = ext4_set_acl, 616 .fiemap = ext4_fiemap, 617 }; 618 619