aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--fs/ocfs2/aops.c56
-rw-r--r--fs/ocfs2/aops.h9
-rw-r--r--fs/ocfs2/file.c7
-rw-r--r--fs/ocfs2/mmap.c167
4 files changed, 200 insertions, 39 deletions
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index fc723fb9c981..b8869fd0884f 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -1034,7 +1034,8 @@ out:
1034 */ 1034 */
1035static int ocfs2_grab_pages_for_write(struct address_space *mapping, 1035static int ocfs2_grab_pages_for_write(struct address_space *mapping,
1036 struct ocfs2_write_ctxt *wc, 1036 struct ocfs2_write_ctxt *wc,
1037 u32 cpos, loff_t user_pos, int new) 1037 u32 cpos, loff_t user_pos, int new,
1038 struct page *mmap_page)
1038{ 1039{
1039 int ret = 0, i; 1040 int ret = 0, i;
1040 unsigned long start, target_index, index; 1041 unsigned long start, target_index, index;
@@ -1058,11 +1059,36 @@ static int ocfs2_grab_pages_for_write(struct address_space *mapping,
1058 for(i = 0; i < wc->w_num_pages; i++) { 1059 for(i = 0; i < wc->w_num_pages; i++) {
1059 index = start + i; 1060 index = start + i;
1060 1061
1061 wc->w_pages[i] = find_or_create_page(mapping, index, GFP_NOFS); 1062 if (index == target_index && mmap_page) {
1062 if (!wc->w_pages[i]) { 1063 /*
1063 ret = -ENOMEM; 1064 * ocfs2_pagemkwrite() is a little different
1064 mlog_errno(ret); 1065 * and wants us to directly use the page
1065 goto out; 1066 * passed in.
1067 */
1068 lock_page(mmap_page);
1069
1070 if (mmap_page->mapping != mapping) {
1071 unlock_page(mmap_page);
1072 /*
1073 * Sanity check - the locking in
1074 * ocfs2_pagemkwrite() should ensure
1075 * that this code doesn't trigger.
1076 */
1077 ret = -EINVAL;
1078 mlog_errno(ret);
1079 goto out;
1080 }
1081
1082 page_cache_get(mmap_page);
1083 wc->w_pages[i] = mmap_page;
1084 } else {
1085 wc->w_pages[i] = find_or_create_page(mapping, index,
1086 GFP_NOFS);
1087 if (!wc->w_pages[i]) {
1088 ret = -ENOMEM;
1089 mlog_errno(ret);
1090 goto out;
1091 }
1066 } 1092 }
1067 1093
1068 if (index == target_index) 1094 if (index == target_index)
@@ -1213,10 +1239,10 @@ static void ocfs2_set_target_boundaries(struct ocfs2_super *osb,
1213 } 1239 }
1214} 1240}
1215 1241
1216static int ocfs2_write_begin_nolock(struct address_space *mapping, 1242int ocfs2_write_begin_nolock(struct address_space *mapping,
1217 loff_t pos, unsigned len, unsigned flags, 1243 loff_t pos, unsigned len, unsigned flags,
1218 struct page **pagep, void **fsdata, 1244 struct page **pagep, void **fsdata,
1219 struct buffer_head *di_bh) 1245 struct buffer_head *di_bh, struct page *mmap_page)
1220{ 1246{
1221 int ret, i, credits = OCFS2_INODE_UPDATE_CREDITS; 1247 int ret, i, credits = OCFS2_INODE_UPDATE_CREDITS;
1222 unsigned int num_clusters = 0, clusters_to_alloc = 0; 1248 unsigned int num_clusters = 0, clusters_to_alloc = 0;
@@ -1318,7 +1344,7 @@ static int ocfs2_write_begin_nolock(struct address_space *mapping,
1318 * extent. 1344 * extent.
1319 */ 1345 */
1320 ret = ocfs2_grab_pages_for_write(mapping, wc, wc->w_cpos, pos, 1346 ret = ocfs2_grab_pages_for_write(mapping, wc, wc->w_cpos, pos,
1321 clusters_to_alloc); 1347 clusters_to_alloc, mmap_page);
1322 if (ret) { 1348 if (ret) {
1323 mlog_errno(ret); 1349 mlog_errno(ret);
1324 goto out_commit; 1350 goto out_commit;
@@ -1386,7 +1412,7 @@ int ocfs2_write_begin(struct file *file, struct address_space *mapping,
1386 } 1412 }
1387 1413
1388 ret = ocfs2_write_begin_nolock(mapping, pos, len, flags, pagep, 1414 ret = ocfs2_write_begin_nolock(mapping, pos, len, flags, pagep,
1389 fsdata, di_bh); 1415 fsdata, di_bh, NULL);
1390 if (ret) { 1416 if (ret) {
1391 mlog_errno(ret); 1417 mlog_errno(ret);
1392 goto out_fail_data; 1418 goto out_fail_data;
@@ -1407,9 +1433,9 @@ out_fail:
1407 return ret; 1433 return ret;
1408} 1434}
1409 1435
1410static int ocfs2_write_end_nolock(struct address_space *mapping, 1436int ocfs2_write_end_nolock(struct address_space *mapping,
1411 loff_t pos, unsigned len, unsigned copied, 1437 loff_t pos, unsigned len, unsigned copied,
1412 struct page *page, void *fsdata) 1438 struct page *page, void *fsdata)
1413{ 1439{
1414 int i; 1440 int i;
1415 unsigned from, to, start = pos & (PAGE_CACHE_SIZE - 1); 1441 unsigned from, to, start = pos & (PAGE_CACHE_SIZE - 1);
diff --git a/fs/ocfs2/aops.h b/fs/ocfs2/aops.h
index bdcdd1ae63a9..389579bd64e3 100644
--- a/fs/ocfs2/aops.h
+++ b/fs/ocfs2/aops.h
@@ -50,6 +50,15 @@ int ocfs2_write_end(struct file *file, struct address_space *mapping,
50 loff_t pos, unsigned len, unsigned copied, 50 loff_t pos, unsigned len, unsigned copied,
51 struct page *page, void *fsdata); 51 struct page *page, void *fsdata);
52 52
53int ocfs2_write_end_nolock(struct address_space *mapping,
54 loff_t pos, unsigned len, unsigned copied,
55 struct page *page, void *fsdata);
56
57int ocfs2_write_begin_nolock(struct address_space *mapping,
58 loff_t pos, unsigned len, unsigned flags,
59 struct page **pagep, void **fsdata,
60 struct buffer_head *di_bh, struct page *mmap_page);
61
53/* all ocfs2_dio_end_io()'s fault */ 62/* all ocfs2_dio_end_io()'s fault */
54#define ocfs2_iocb_is_rw_locked(iocb) \ 63#define ocfs2_iocb_is_rw_locked(iocb) \
55 test_bit(0, (unsigned long *)&iocb->private) 64 test_bit(0, (unsigned long *)&iocb->private)
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 4c850d00c269..a80f31776d94 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1001,6 +1001,13 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
1001 goto bail_unlock; 1001 goto bail_unlock;
1002 } 1002 }
1003 1003
1004 /*
1005 * This will intentionally not wind up calling vmtruncate(),
1006 * since all the work for a size change has been done above.
1007 * Otherwise, we could get into problems with truncate as
1008 * ip_alloc_sem is used there to protect against i_size
1009 * changes.
1010 */
1004 status = inode_setattr(inode, attr); 1011 status = inode_setattr(inode, attr);
1005 if (status < 0) { 1012 if (status < 0) {
1006 mlog_errno(status); 1013 mlog_errno(status);
diff --git a/fs/ocfs2/mmap.c b/fs/ocfs2/mmap.c
index af01158b39f5..d79aa12137d2 100644
--- a/fs/ocfs2/mmap.c
+++ b/fs/ocfs2/mmap.c
@@ -37,11 +37,29 @@
37 37
38#include "ocfs2.h" 38#include "ocfs2.h"
39 39
40#include "aops.h"
40#include "dlmglue.h" 41#include "dlmglue.h"
41#include "file.h" 42#include "file.h"
42#include "inode.h" 43#include "inode.h"
43#include "mmap.h" 44#include "mmap.h"
44 45
46static inline int ocfs2_vm_op_block_sigs(sigset_t *blocked, sigset_t *oldset)
47{
48 /* The best way to deal with signals in the vm path is
49 * to block them upfront, rather than allowing the
50 * locking paths to return -ERESTARTSYS. */
51 sigfillset(blocked);
52
53 /* We should technically never get a bad return value
54 * from sigprocmask */
55 return sigprocmask(SIG_BLOCK, blocked, oldset);
56}
57
58static inline int ocfs2_vm_op_unblock_sigs(sigset_t *oldset)
59{
60 return sigprocmask(SIG_SETMASK, oldset, NULL);
61}
62
45static struct page *ocfs2_nopage(struct vm_area_struct * area, 63static struct page *ocfs2_nopage(struct vm_area_struct * area,
46 unsigned long address, 64 unsigned long address,
47 int *type) 65 int *type)
@@ -53,14 +71,7 @@ static struct page *ocfs2_nopage(struct vm_area_struct * area,
53 mlog_entry("(area=%p, address=%lu, type=%p)\n", area, address, 71 mlog_entry("(area=%p, address=%lu, type=%p)\n", area, address,
54 type); 72 type);
55 73
56 /* The best way to deal with signals in this path is 74 ret = ocfs2_vm_op_block_sigs(&blocked, &oldset);
57 * to block them upfront, rather than allowing the
58 * locking paths to return -ERESTARTSYS. */
59 sigfillset(&blocked);
60
61 /* We should technically never get a bad ret return
62 * from sigprocmask */
63 ret = sigprocmask(SIG_BLOCK, &blocked, &oldset);
64 if (ret < 0) { 75 if (ret < 0) {
65 mlog_errno(ret); 76 mlog_errno(ret);
66 goto out; 77 goto out;
@@ -68,7 +79,7 @@ static struct page *ocfs2_nopage(struct vm_area_struct * area,
68 79
69 page = filemap_nopage(area, address, type); 80 page = filemap_nopage(area, address, type);
70 81
71 ret = sigprocmask(SIG_SETMASK, &oldset, NULL); 82 ret = ocfs2_vm_op_unblock_sigs(&oldset);
72 if (ret < 0) 83 if (ret < 0)
73 mlog_errno(ret); 84 mlog_errno(ret);
74out: 85out:
@@ -76,28 +87,136 @@ out:
76 return page; 87 return page;
77} 88}
78 89
79static struct vm_operations_struct ocfs2_file_vm_ops = { 90static int __ocfs2_page_mkwrite(struct inode *inode, struct buffer_head *di_bh,
80 .nopage = ocfs2_nopage, 91 struct page *page)
81}; 92{
93 int ret;
94 struct address_space *mapping = inode->i_mapping;
95 loff_t pos = page->index << PAGE_CACHE_SHIFT;
96 unsigned int len = PAGE_CACHE_SIZE;
97 pgoff_t last_index;
98 struct page *locked_page = NULL;
99 void *fsdata;
100 loff_t size = i_size_read(inode);
82 101
83int ocfs2_mmap(struct file *file, struct vm_area_struct *vma) 102 /*
103 * Another node might have truncated while we were waiting on
104 * cluster locks.
105 */
106 last_index = size >> PAGE_CACHE_SHIFT;
107 if (page->index > last_index) {
108 ret = -EINVAL;
109 goto out;
110 }
111
112 /*
113 * The i_size check above doesn't catch the case where nodes
114 * truncated and then re-extended the file. We'll re-check the
115 * page mapping after taking the page lock inside of
116 * ocfs2_write_begin_nolock().
117 */
118 if (!PageUptodate(page) || page->mapping != inode->i_mapping) {
119 ret = -EINVAL;
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;
152out:
153 return ret;
154}
155
156static int ocfs2_page_mkwrite(struct vm_area_struct *vma, struct page *page)
84{ 157{
85 int ret = 0, lock_level = 0; 158 struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
86 struct ocfs2_super *osb = OCFS2_SB(file->f_dentry->d_inode->i_sb); 159 struct buffer_head *di_bh = NULL;
160 sigset_t blocked, oldset;
161 int ret, ret2;
162
163 ret = ocfs2_vm_op_block_sigs(&blocked, &oldset);
164 if (ret < 0) {
165 mlog_errno(ret);
166 return ret;
167 }
168
169 /*
170 * The cluster locks taken will block a truncate from another
171 * node. Taking the data lock will also ensure that we don't
172 * attempt page truncation as part of a downconvert.
173 */
174 ret = ocfs2_meta_lock(inode, &di_bh, 1);
175 if (ret < 0) {
176 mlog_errno(ret);
177 goto out;
178 }
87 179
88 /* 180 /*
89 * Only support shared writeable mmap for local mounts which 181 * The alloc sem should be enough to serialize with
90 * don't know about holes. 182 * ocfs2_truncate_file() changing i_size as well as any thread
183 * modifying the inode btree.
91 */ 184 */
92 if ((!ocfs2_mount_local(osb) || ocfs2_sparse_alloc(osb)) && 185 down_write(&OCFS2_I(inode)->ip_alloc_sem);
93 ((vma->vm_flags & VM_SHARED) || (vma->vm_flags & VM_MAYSHARE)) && 186
94 ((vma->vm_flags & VM_WRITE) || (vma->vm_flags & VM_MAYWRITE))) { 187 ret = ocfs2_data_lock(inode, 1);
95 mlog(0, "disallow shared writable mmaps %lx\n", vma->vm_flags); 188 if (ret < 0) {
96 /* This is -EINVAL because generic_file_readonly_mmap 189 mlog_errno(ret);
97 * returns it in a similar situation. */ 190 goto out_meta_unlock;
98 return -EINVAL;
99 } 191 }
100 192
193 ret = __ocfs2_page_mkwrite(inode, di_bh, page);
194
195 ocfs2_data_unlock(inode, 1);
196
197out_meta_unlock:
198 up_write(&OCFS2_I(inode)->ip_alloc_sem);
199
200 brelse(di_bh);
201 ocfs2_meta_unlock(inode, 1);
202
203out:
204 ret2 = ocfs2_vm_op_unblock_sigs(&oldset);
205 if (ret2 < 0)
206 mlog_errno(ret2);
207
208 return ret;
209}
210
211static struct vm_operations_struct ocfs2_file_vm_ops = {
212 .nopage = ocfs2_nopage,
213 .page_mkwrite = ocfs2_page_mkwrite,
214};
215
216int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
217{
218 int ret = 0, lock_level = 0;
219
101 ret = ocfs2_meta_lock_atime(file->f_dentry->d_inode, 220 ret = ocfs2_meta_lock_atime(file->f_dentry->d_inode,
102 file->f_vfsmnt, &lock_level); 221 file->f_vfsmnt, &lock_level);
103 if (ret < 0) { 222 if (ret < 0) {