1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * mmap.c 5 * 6 * Code to deal with the mess that is clustered mmap. 7 * 8 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public 12 * License as published by the Free Software Foundation; either 13 * version 2 of the License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public 21 * License along with this program; if not, write to the 22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 23 * Boston, MA 021110-1307, USA. 24 */ 25 26 #include <linux/fs.h> 27 #include <linux/types.h> 28 #include <linux/highmem.h> 29 #include <linux/pagemap.h> 30 #include <linux/uio.h> 31 #include <linux/signal.h> 32 #include <linux/rbtree.h> 33 34 #define MLOG_MASK_PREFIX ML_FILE_IO 35 #include <cluster/masklog.h> 36 37 #include "ocfs2.h" 38 39 #include "aops.h" 40 #include "dlmglue.h" 41 #include "file.h" 42 #include "inode.h" 43 #include "mmap.h" 44 #include "super.h" 45 46 47 static int ocfs2_fault(struct vm_area_struct *area, struct vm_fault *vmf) 48 { 49 sigset_t oldset; 50 int ret; 51 52 mlog_entry("(area=%p, page offset=%lu)\n", area, vmf->pgoff); 53 54 ocfs2_block_signals(&oldset); 55 ret = filemap_fault(area, vmf); 56 ocfs2_unblock_signals(&oldset); 57 58 mlog_exit_ptr(vmf->page); 59 return ret; 60 } 61 62 static int __ocfs2_page_mkwrite(struct file *file, struct buffer_head *di_bh, 63 struct page *page) 64 { 65 int ret; 66 struct inode *inode = file->f_path.dentry->d_inode; 67 struct address_space *mapping = inode->i_mapping; 68 loff_t pos = page_offset(page); 69 unsigned int len = PAGE_CACHE_SIZE; 70 pgoff_t last_index; 71 struct page *locked_page = NULL; 72 void *fsdata; 73 loff_t size = i_size_read(inode); 74 75 /* 76 * Another node might have truncated while we were waiting on 77 * cluster locks. 78 */ 79 last_index = size >> PAGE_CACHE_SHIFT; 80 if (page->index > last_index) { 81 ret = -EINVAL; 82 goto out; 83 } 84 85 /* 86 * The i_size check above doesn't catch the case where nodes 87 * truncated and then re-extended the file. We'll re-check the 88 * page mapping after taking the page lock inside of 89 * ocfs2_write_begin_nolock(). 90 */ 91 if (!PageUptodate(page) || page->mapping != inode->i_mapping) { 92 /* 93 * the page has been umapped in ocfs2_data_downconvert_worker. 94 * So return 0 here and let VFS retry. 95 */ 96 ret = 0; 97 goto out; 98 } 99 100 /* 101 * Call ocfs2_write_begin() and ocfs2_write_end() to take 102 * advantage of the allocation code there. We pass a write 103 * length of the whole page (chopped to i_size) to make sure 104 * the whole thing is allocated. 105 * 106 * Since we know the page is up to date, we don't have to 107 * worry about ocfs2_write_begin() skipping some buffer reads 108 * because the "write" would invalidate their data. 109 */ 110 if (page->index == last_index) 111 len = size & ~PAGE_CACHE_MASK; 112 113 ret = ocfs2_write_begin_nolock(file, mapping, pos, len, 0, &locked_page, 114 &fsdata, di_bh, page); 115 if (ret) { 116 if (ret != -ENOSPC) 117 mlog_errno(ret); 118 goto out; 119 } 120 121 ret = ocfs2_write_end_nolock(mapping, pos, len, len, locked_page, 122 fsdata); 123 if (ret < 0) { 124 mlog_errno(ret); 125 goto out; 126 } 127 BUG_ON(ret != len); 128 ret = 0; 129 out: 130 return ret; 131 } 132 133 static int ocfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 134 { 135 struct page *page = vmf->page; 136 struct inode *inode = vma->vm_file->f_path.dentry->d_inode; 137 struct buffer_head *di_bh = NULL; 138 sigset_t oldset; 139 int ret; 140 141 ocfs2_block_signals(&oldset); 142 143 /* 144 * The cluster locks taken will block a truncate from another 145 * node. Taking the data lock will also ensure that we don't 146 * attempt page truncation as part of a downconvert. 147 */ 148 ret = ocfs2_inode_lock(inode, &di_bh, 1); 149 if (ret < 0) { 150 mlog_errno(ret); 151 goto out; 152 } 153 154 /* 155 * The alloc sem should be enough to serialize with 156 * ocfs2_truncate_file() changing i_size as well as any thread 157 * modifying the inode btree. 158 */ 159 down_write(&OCFS2_I(inode)->ip_alloc_sem); 160 161 ret = __ocfs2_page_mkwrite(vma->vm_file, di_bh, page); 162 163 up_write(&OCFS2_I(inode)->ip_alloc_sem); 164 165 brelse(di_bh); 166 ocfs2_inode_unlock(inode, 1); 167 168 out: 169 ocfs2_unblock_signals(&oldset); 170 if (ret) 171 ret = VM_FAULT_SIGBUS; 172 return ret; 173 } 174 175 static const struct vm_operations_struct ocfs2_file_vm_ops = { 176 .fault = ocfs2_fault, 177 .page_mkwrite = ocfs2_page_mkwrite, 178 }; 179 180 int ocfs2_mmap(struct file *file, struct vm_area_struct *vma) 181 { 182 int ret = 0, lock_level = 0; 183 184 ret = ocfs2_inode_lock_atime(file->f_dentry->d_inode, 185 file->f_vfsmnt, &lock_level); 186 if (ret < 0) { 187 mlog_errno(ret); 188 goto out; 189 } 190 ocfs2_inode_unlock(file->f_dentry->d_inode, lock_level); 191 out: 192 vma->vm_ops = &ocfs2_file_vm_ops; 193 vma->vm_flags |= VM_CAN_NONLINEAR; 194 return 0; 195 } 196 197