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