]>
Commit | Line | Data |
---|---|---|
ccd979bd MF |
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> | |
ccd979bd MF |
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 | ||
7307de80 | 39 | #include "aops.h" |
ccd979bd MF |
40 | #include "dlmglue.h" |
41 | #include "file.h" | |
42 | #include "inode.h" | |
43 | #include "mmap.h" | |
44 | ||
7307de80 MF |
45 | static inline int ocfs2_vm_op_block_sigs(sigset_t *blocked, sigset_t *oldset) |
46 | { | |
47 | /* The best way to deal with signals in the vm path is | |
48 | * to block them upfront, rather than allowing the | |
49 | * locking paths to return -ERESTARTSYS. */ | |
50 | sigfillset(blocked); | |
51 | ||
52 | /* We should technically never get a bad return value | |
53 | * from sigprocmask */ | |
54 | return sigprocmask(SIG_BLOCK, blocked, oldset); | |
55 | } | |
56 | ||
57 | static inline int ocfs2_vm_op_unblock_sigs(sigset_t *oldset) | |
58 | { | |
59 | return sigprocmask(SIG_SETMASK, oldset, NULL); | |
60 | } | |
61 | ||
d0217ac0 | 62 | static int ocfs2_fault(struct vm_area_struct *area, struct vm_fault *vmf) |
ccd979bd | 63 | { |
ccd979bd | 64 | sigset_t blocked, oldset; |
d0217ac0 | 65 | int error, ret; |
ccd979bd | 66 | |
d0217ac0 | 67 | mlog_entry("(area=%p, page offset=%lu)\n", area, vmf->pgoff); |
ccd979bd | 68 | |
d0217ac0 NP |
69 | error = ocfs2_vm_op_block_sigs(&blocked, &oldset); |
70 | if (error < 0) { | |
71 | mlog_errno(error); | |
72 | ret = VM_FAULT_SIGBUS; | |
ccd979bd MF |
73 | goto out; |
74 | } | |
75 | ||
d0217ac0 | 76 | ret = filemap_fault(area, vmf); |
ccd979bd | 77 | |
d0217ac0 NP |
78 | error = ocfs2_vm_op_unblock_sigs(&oldset); |
79 | if (error < 0) | |
80 | mlog_errno(error); | |
ccd979bd | 81 | out: |
d0217ac0 NP |
82 | mlog_exit_ptr(vmf->page); |
83 | return ret; | |
ccd979bd MF |
84 | } |
85 | ||
7307de80 MF |
86 | static int __ocfs2_page_mkwrite(struct inode *inode, struct buffer_head *di_bh, |
87 | struct page *page) | |
88 | { | |
89 | int ret; | |
90 | struct address_space *mapping = inode->i_mapping; | |
18336338 | 91 | loff_t pos = page_offset(page); |
7307de80 MF |
92 | unsigned int len = PAGE_CACHE_SIZE; |
93 | pgoff_t last_index; | |
94 | struct page *locked_page = NULL; | |
95 | void *fsdata; | |
96 | loff_t size = i_size_read(inode); | |
ccd979bd | 97 | |
7307de80 MF |
98 | /* |
99 | * Another node might have truncated while we were waiting on | |
100 | * cluster locks. | |
101 | */ | |
102 | last_index = size >> PAGE_CACHE_SHIFT; | |
103 | if (page->index > last_index) { | |
104 | ret = -EINVAL; | |
105 | goto out; | |
106 | } | |
107 | ||
108 | /* | |
109 | * The i_size check above doesn't catch the case where nodes | |
110 | * truncated and then re-extended the file. We'll re-check the | |
111 | * page mapping after taking the page lock inside of | |
112 | * ocfs2_write_begin_nolock(). | |
113 | */ | |
114 | if (!PageUptodate(page) || page->mapping != inode->i_mapping) { | |
4c1bbf1b TM |
115 | /* |
116 | * the page has been umapped in ocfs2_data_downconvert_worker. | |
117 | * So return 0 here and let VFS retry. | |
118 | */ | |
119 | ret = 0; | |
7307de80 MF |
120 | goto out; |
121 | } | |
122 | ||
123 | /* | |
124 | * Call ocfs2_write_begin() and ocfs2_write_end() to take | |
125 | * advantage of the allocation code there. We pass a write | |
126 | * length of the whole page (chopped to i_size) to make sure | |
127 | * the whole thing is allocated. | |
128 | * | |
129 | * Since we know the page is up to date, we don't have to | |
130 | * worry about ocfs2_write_begin() skipping some buffer reads | |
131 | * because the "write" would invalidate their data. | |
132 | */ | |
133 | if (page->index == last_index) | |
134 | len = size & ~PAGE_CACHE_MASK; | |
135 | ||
136 | ret = ocfs2_write_begin_nolock(mapping, pos, len, 0, &locked_page, | |
137 | &fsdata, di_bh, page); | |
138 | if (ret) { | |
139 | if (ret != -ENOSPC) | |
140 | mlog_errno(ret); | |
141 | goto out; | |
142 | } | |
143 | ||
144 | ret = ocfs2_write_end_nolock(mapping, pos, len, len, locked_page, | |
145 | fsdata); | |
146 | if (ret < 0) { | |
147 | mlog_errno(ret); | |
148 | goto out; | |
149 | } | |
150 | BUG_ON(ret != len); | |
151 | ret = 0; | |
152 | out: | |
153 | return ret; | |
154 | } | |
155 | ||
c2ec175c | 156 | static int ocfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) |
ccd979bd | 157 | { |
c2ec175c | 158 | struct page *page = vmf->page; |
7307de80 MF |
159 | struct inode *inode = vma->vm_file->f_path.dentry->d_inode; |
160 | struct buffer_head *di_bh = NULL; | |
161 | sigset_t blocked, oldset; | |
162 | int ret, ret2; | |
163 | ||
164 | ret = ocfs2_vm_op_block_sigs(&blocked, &oldset); | |
165 | if (ret < 0) { | |
166 | mlog_errno(ret); | |
167 | return ret; | |
168 | } | |
169 | ||
170 | /* | |
171 | * The cluster locks taken will block a truncate from another | |
172 | * node. Taking the data lock will also ensure that we don't | |
173 | * attempt page truncation as part of a downconvert. | |
174 | */ | |
e63aecb6 | 175 | ret = ocfs2_inode_lock(inode, &di_bh, 1); |
7307de80 MF |
176 | if (ret < 0) { |
177 | mlog_errno(ret); | |
178 | goto out; | |
179 | } | |
25899dee | 180 | |
89488984 | 181 | /* |
7307de80 MF |
182 | * The alloc sem should be enough to serialize with |
183 | * ocfs2_truncate_file() changing i_size as well as any thread | |
184 | * modifying the inode btree. | |
89488984 | 185 | */ |
7307de80 MF |
186 | down_write(&OCFS2_I(inode)->ip_alloc_sem); |
187 | ||
7307de80 MF |
188 | ret = __ocfs2_page_mkwrite(inode, di_bh, page); |
189 | ||
7307de80 MF |
190 | up_write(&OCFS2_I(inode)->ip_alloc_sem); |
191 | ||
192 | brelse(di_bh); | |
e63aecb6 | 193 | ocfs2_inode_unlock(inode, 1); |
7307de80 MF |
194 | |
195 | out: | |
196 | ret2 = ocfs2_vm_op_unblock_sigs(&oldset); | |
197 | if (ret2 < 0) | |
198 | mlog_errno(ret2); | |
c2ec175c NP |
199 | if (ret) |
200 | ret = VM_FAULT_SIGBUS; | |
7307de80 MF |
201 | return ret; |
202 | } | |
203 | ||
f0f37e2f | 204 | static const struct vm_operations_struct ocfs2_file_vm_ops = { |
54cb8821 | 205 | .fault = ocfs2_fault, |
7307de80 MF |
206 | .page_mkwrite = ocfs2_page_mkwrite, |
207 | }; | |
208 | ||
209 | int ocfs2_mmap(struct file *file, struct vm_area_struct *vma) | |
210 | { | |
211 | int ret = 0, lock_level = 0; | |
212 | ||
e63aecb6 | 213 | ret = ocfs2_inode_lock_atime(file->f_dentry->d_inode, |
25899dee TY |
214 | file->f_vfsmnt, &lock_level); |
215 | if (ret < 0) { | |
216 | mlog_errno(ret); | |
217 | goto out; | |
218 | } | |
e63aecb6 | 219 | ocfs2_inode_unlock(file->f_dentry->d_inode, lock_level); |
25899dee | 220 | out: |
ccd979bd | 221 | vma->vm_ops = &ocfs2_file_vm_ops; |
d0217ac0 | 222 | vma->vm_flags |= VM_CAN_NONLINEAR; |
ccd979bd MF |
223 | return 0; |
224 | } | |
225 |