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 folio *folio = page_folio(vmf->page); 49 struct inode *inode = file_inode(vma->vm_file); 50 struct nilfs_transaction_info ti; 51 struct buffer_head *bh, *head; 52 int ret = 0; 53 54 if (unlikely(nilfs_near_disk_full(inode->i_sb->s_fs_info))) 55 return VM_FAULT_SIGBUS; /* -ENOSPC */ 56 57 sb_start_pagefault(inode->i_sb); 58 folio_lock(folio); 59 if (folio->mapping != inode->i_mapping || 60 folio_pos(folio) >= i_size_read(inode) || 61 !folio_test_uptodate(folio)) { 62 folio_unlock(folio); 63 ret = -EFAULT; /* make the VM retry the fault */ 64 goto out; 65 } 66 67 /* 68 * check to see if the folio is mapped already (no holes) 69 */ 70 if (folio_test_mappedtodisk(folio)) 71 goto mapped; 72 73 head = folio_buffers(folio); 74 if (head) { 75 int fully_mapped = 1; 76 77 bh = head; 78 do { 79 if (!buffer_mapped(bh)) { 80 fully_mapped = 0; 81 break; 82 } 83 } while (bh = bh->b_this_page, bh != head); 84 85 if (fully_mapped) { 86 folio_set_mappedtodisk(folio); 87 goto mapped; 88 } 89 } 90 folio_unlock(folio); 91 92 /* 93 * fill hole blocks 94 */ 95 ret = nilfs_transaction_begin(inode->i_sb, &ti, 1); 96 /* never returns -ENOMEM, but may return -ENOSPC */ 97 if (unlikely(ret)) 98 goto out; 99 100 file_update_time(vma->vm_file); 101 ret = block_page_mkwrite(vma, vmf, nilfs_get_block); 102 if (ret) { 103 nilfs_transaction_abort(inode->i_sb); 104 goto out; 105 } 106 nilfs_set_file_dirty(inode, 1 << (PAGE_SHIFT - inode->i_blkbits)); 107 nilfs_transaction_commit(inode->i_sb); 108 109 mapped: 110 /* 111 * Since checksumming including data blocks is performed to determine 112 * the validity of the log to be written and used for recovery, it is 113 * necessary to wait for writeback to finish here, regardless of the 114 * stable write requirement of the backing device. 115 */ 116 folio_wait_writeback(folio); 117 out: 118 sb_end_pagefault(inode->i_sb); 119 return vmf_fs_error(ret); 120 } 121 122 static const struct vm_operations_struct nilfs_file_vm_ops = { 123 .fault = filemap_fault, 124 .map_pages = filemap_map_pages, 125 .page_mkwrite = nilfs_page_mkwrite, 126 }; 127 128 static int nilfs_file_mmap(struct file *file, struct vm_area_struct *vma) 129 { 130 file_accessed(file); 131 vma->vm_ops = &nilfs_file_vm_ops; 132 return 0; 133 } 134 135 /* 136 * We have mostly NULL's here: the current defaults are ok for 137 * the nilfs filesystem. 138 */ 139 const struct file_operations nilfs_file_operations = { 140 .llseek = generic_file_llseek, 141 .read_iter = generic_file_read_iter, 142 .write_iter = generic_file_write_iter, 143 .unlocked_ioctl = nilfs_ioctl, 144 #ifdef CONFIG_COMPAT 145 .compat_ioctl = nilfs_compat_ioctl, 146 #endif /* CONFIG_COMPAT */ 147 .mmap = nilfs_file_mmap, 148 .open = generic_file_open, 149 /* .release = nilfs_release_file, */ 150 .fsync = nilfs_sync_file, 151 .splice_read = filemap_splice_read, 152 .splice_write = iter_file_splice_write, 153 }; 154 155 const struct inode_operations nilfs_file_inode_operations = { 156 .setattr = nilfs_setattr, 157 .permission = nilfs_permission, 158 .fiemap = nilfs_fiemap, 159 .fileattr_get = nilfs_fileattr_get, 160 .fileattr_set = nilfs_fileattr_set, 161 }; 162 163 /* end of file */ 164