1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * NILFS regular file handling primitives including fsync(). 4 * 5 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. 6 * 7 * Written by Amagai Yoshiji and Ryusuke Konishi. 8 */ 9 10 #include <linux/fs.h> 11 #include <linux/mm.h> 12 #include <linux/writeback.h> 13 #include "nilfs.h" 14 #include "segment.h" 15 16 int nilfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync) 17 { 18 /* 19 * Called from fsync() system call 20 * This is the only entry point that can catch write and synch 21 * timing for both data blocks and intermediate blocks. 22 * 23 * This function should be implemented when the writeback function 24 * will be implemented. 25 */ 26 struct the_nilfs *nilfs; 27 struct inode *inode = file->f_mapping->host; 28 int err = 0; 29 30 if (nilfs_inode_dirty(inode)) { 31 if (datasync) 32 err = nilfs_construct_dsync_segment(inode->i_sb, inode, 33 start, end); 34 else 35 err = nilfs_construct_segment(inode->i_sb); 36 } 37 38 nilfs = inode->i_sb->s_fs_info; 39 if (!err) 40 err = nilfs_flush_device(nilfs); 41 42 return err; 43 } 44 45 static vm_fault_t nilfs_page_mkwrite(struct vm_fault *vmf) 46 { 47 struct vm_area_struct *vma = vmf->vma; 48 struct page *page = vmf->page; 49 struct inode *inode = file_inode(vma->vm_file); 50 struct nilfs_transaction_info ti; 51 int ret = 0; 52 53 if (unlikely(nilfs_near_disk_full(inode->i_sb->s_fs_info))) 54 return VM_FAULT_SIGBUS; /* -ENOSPC */ 55 56 sb_start_pagefault(inode->i_sb); 57 lock_page(page); 58 if (page->mapping != inode->i_mapping || 59 page_offset(page) >= i_size_read(inode) || !PageUptodate(page)) { 60 unlock_page(page); 61 ret = -EFAULT; /* make the VM retry the fault */ 62 goto out; 63 } 64 65 /* 66 * check to see if the page is mapped already (no holes) 67 */ 68 if (PageMappedToDisk(page)) 69 goto mapped; 70 71 if (page_has_buffers(page)) { 72 struct buffer_head *bh, *head; 73 int fully_mapped = 1; 74 75 bh = head = page_buffers(page); 76 do { 77 if (!buffer_mapped(bh)) { 78 fully_mapped = 0; 79 break; 80 } 81 } while (bh = bh->b_this_page, bh != head); 82 83 if (fully_mapped) { 84 SetPageMappedToDisk(page); 85 goto mapped; 86 } 87 } 88 unlock_page(page); 89 90 /* 91 * fill hole blocks 92 */ 93 ret = nilfs_transaction_begin(inode->i_sb, &ti, 1); 94 /* never returns -ENOMEM, but may return -ENOSPC */ 95 if (unlikely(ret)) 96 goto out; 97 98 file_update_time(vma->vm_file); 99 ret = block_page_mkwrite(vma, vmf, nilfs_get_block); 100 if (ret) { 101 nilfs_transaction_abort(inode->i_sb); 102 goto out; 103 } 104 nilfs_set_file_dirty(inode, 1 << (PAGE_SHIFT - inode->i_blkbits)); 105 nilfs_transaction_commit(inode->i_sb); 106 107 mapped: 108 /* 109 * Since checksumming including data blocks is performed to determine 110 * the validity of the log to be written and used for recovery, it is 111 * necessary to wait for writeback to finish here, regardless of the 112 * stable write requirement of the backing device. 113 */ 114 wait_on_page_writeback(page); 115 out: 116 sb_end_pagefault(inode->i_sb); 117 return vmf_fs_error(ret); 118 } 119 120 static const struct vm_operations_struct nilfs_file_vm_ops = { 121 .fault = filemap_fault, 122 .map_pages = filemap_map_pages, 123 .page_mkwrite = nilfs_page_mkwrite, 124 }; 125 126 static int nilfs_file_mmap(struct file *file, struct vm_area_struct *vma) 127 { 128 file_accessed(file); 129 vma->vm_ops = &nilfs_file_vm_ops; 130 return 0; 131 } 132 133 /* 134 * We have mostly NULL's here: the current defaults are ok for 135 * the nilfs filesystem. 136 */ 137 const struct file_operations nilfs_file_operations = { 138 .llseek = generic_file_llseek, 139 .read_iter = generic_file_read_iter, 140 .write_iter = generic_file_write_iter, 141 .unlocked_ioctl = nilfs_ioctl, 142 #ifdef CONFIG_COMPAT 143 .compat_ioctl = nilfs_compat_ioctl, 144 #endif /* CONFIG_COMPAT */ 145 .mmap = nilfs_file_mmap, 146 .open = generic_file_open, 147 /* .release = nilfs_release_file, */ 148 .fsync = nilfs_sync_file, 149 .splice_read = filemap_splice_read, 150 .splice_write = iter_file_splice_write, 151 }; 152 153 const struct inode_operations nilfs_file_inode_operations = { 154 .setattr = nilfs_setattr, 155 .permission = nilfs_permission, 156 .fiemap = nilfs_fiemap, 157 .fileattr_get = nilfs_fileattr_get, 158 .fileattr_set = nilfs_fileattr_set, 159 }; 160 161 /* end of file */ 162