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