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
ocfs2_fault(struct vm_fault * vmf)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
__ocfs2_page_mkwrite(struct file * file,struct buffer_head * di_bh,struct page * page)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
ocfs2_page_mkwrite(struct vm_fault * vmf)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
ocfs2_mmap(struct file * file,struct vm_area_struct * vma)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