1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* -*- mode: c; c-basic-offset: 8; -*- 3 * vim: noexpandtab sw=8 ts=8 sts=0: 4 * 5 * mmap.c 6 * 7 * Code to deal with the mess that is clustered mmap. 8 * 9 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 10 */ 11 12 #include <linux/fs.h> 13 #include <linux/types.h> 14 #include <linux/highmem.h> 15 #include <linux/pagemap.h> 16 #include <linux/uio.h> 17 #include <linux/signal.h> 18 #include <linux/rbtree.h> 19 20 #include <cluster/masklog.h> 21 22 #include "ocfs2.h" 23 24 #include "aops.h" 25 #include "dlmglue.h" 26 #include "file.h" 27 #include "inode.h" 28 #include "mmap.h" 29 #include "super.h" 30 #include "ocfs2_trace.h" 31 32 ocfs2_fault(struct vm_fault * vmf)33 static vm_fault_t ocfs2_fault(struct vm_fault *vmf) 34 { 35 struct vm_area_struct *vma = vmf->vma; 36 sigset_t oldset; 37 vm_fault_t ret; 38 39 ocfs2_block_signals(&oldset); 40 ret = filemap_fault(vmf); 41 ocfs2_unblock_signals(&oldset); 42 43 trace_ocfs2_fault(OCFS2_I(vma->vm_file->f_mapping->host)->ip_blkno, 44 vma, vmf->page, vmf->pgoff); 45 return ret; 46 } 47 __ocfs2_page_mkwrite(struct file * file,struct buffer_head * di_bh,struct page * page)48 static vm_fault_t __ocfs2_page_mkwrite(struct file *file, 49 struct buffer_head *di_bh, struct page *page) 50 { 51 int err; 52 vm_fault_t ret = VM_FAULT_NOPAGE; 53 struct inode *inode = file_inode(file); 54 struct address_space *mapping = inode->i_mapping; 55 loff_t pos = page_offset(page); 56 unsigned int len = PAGE_SIZE; 57 pgoff_t last_index; 58 struct page *locked_page = NULL; 59 void *fsdata; 60 loff_t size = i_size_read(inode); 61 62 last_index = (size - 1) >> PAGE_SHIFT; 63 64 /* 65 * There are cases that lead to the page no longer belonging to the 66 * mapping. 67 * 1) pagecache truncates locally due to memory pressure. 68 * 2) pagecache truncates when another is taking EX lock against 69 * inode lock. see ocfs2_data_convert_worker. 70 * 71 * The i_size check doesn't catch the case where nodes truncated and 72 * then re-extended the file. We'll re-check the page mapping after 73 * taking the page lock inside of ocfs2_write_begin_nolock(). 74 * 75 * Let VM retry with these cases. 76 */ 77 if ((page->mapping != inode->i_mapping) || 78 (!PageUptodate(page)) || 79 (page_offset(page) >= size)) 80 goto out; 81 82 /* 83 * Call ocfs2_write_begin() and ocfs2_write_end() to take 84 * advantage of the allocation code there. We pass a write 85 * length of the whole page (chopped to i_size) to make sure 86 * the whole thing is allocated. 87 * 88 * Since we know the page is up to date, we don't have to 89 * worry about ocfs2_write_begin() skipping some buffer reads 90 * because the "write" would invalidate their data. 91 */ 92 if (page->index == last_index) 93 len = ((size - 1) & ~PAGE_MASK) + 1; 94 95 err = ocfs2_write_begin_nolock(mapping, pos, len, OCFS2_WRITE_MMAP, 96 &locked_page, &fsdata, di_bh, page); 97 if (err) { 98 if (err != -ENOSPC) 99 mlog_errno(err); 100 ret = vmf_error(err); 101 goto out; 102 } 103 104 if (!locked_page) { 105 ret = VM_FAULT_NOPAGE; 106 goto out; 107 } 108 err = ocfs2_write_end_nolock(mapping, pos, len, len, fsdata); 109 BUG_ON(err != len); 110 ret = VM_FAULT_LOCKED; 111 out: 112 return ret; 113 } 114 ocfs2_page_mkwrite(struct vm_fault * vmf)115 static vm_fault_t ocfs2_page_mkwrite(struct vm_fault *vmf) 116 { 117 struct page *page = vmf->page; 118 struct inode *inode = file_inode(vmf->vma->vm_file); 119 struct buffer_head *di_bh = NULL; 120 sigset_t oldset; 121 int err; 122 vm_fault_t ret; 123 124 sb_start_pagefault(inode->i_sb); 125 ocfs2_block_signals(&oldset); 126 127 /* 128 * The cluster locks taken will block a truncate from another 129 * node. Taking the data lock will also ensure that we don't 130 * attempt page truncation as part of a downconvert. 131 */ 132 err = ocfs2_inode_lock(inode, &di_bh, 1); 133 if (err < 0) { 134 mlog_errno(err); 135 ret = vmf_error(err); 136 goto out; 137 } 138 139 /* 140 * The alloc sem should be enough to serialize with 141 * ocfs2_truncate_file() changing i_size as well as any thread 142 * modifying the inode btree. 143 */ 144 down_write(&OCFS2_I(inode)->ip_alloc_sem); 145 146 ret = __ocfs2_page_mkwrite(vmf->vma->vm_file, di_bh, page); 147 148 up_write(&OCFS2_I(inode)->ip_alloc_sem); 149 150 brelse(di_bh); 151 ocfs2_inode_unlock(inode, 1); 152 153 out: 154 ocfs2_unblock_signals(&oldset); 155 sb_end_pagefault(inode->i_sb); 156 return ret; 157 } 158 159 static const struct vm_operations_struct ocfs2_file_vm_ops = { 160 .fault = ocfs2_fault, 161 .page_mkwrite = ocfs2_page_mkwrite, 162 }; 163 ocfs2_mmap(struct file * file,struct vm_area_struct * vma)164 int ocfs2_mmap(struct file *file, struct vm_area_struct *vma) 165 { 166 int ret = 0, lock_level = 0; 167 168 ret = ocfs2_inode_lock_atime(file_inode(file), 169 file->f_path.mnt, &lock_level, 1); 170 if (ret < 0) { 171 mlog_errno(ret); 172 goto out; 173 } 174 ocfs2_inode_unlock(file_inode(file), lock_level); 175 out: 176 vma->vm_ops = &ocfs2_file_vm_ops; 177 return 0; 178 } 179 180