Root/fs/ocfs2/mmap.c

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#define MLOG_MASK_PREFIX ML_FILE_IO
35#include <cluster/masklog.h>
36
37#include "ocfs2.h"
38
39#include "aops.h"
40#include "dlmglue.h"
41#include "file.h"
42#include "inode.h"
43#include "mmap.h"
44
45static 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
57static inline int ocfs2_vm_op_unblock_sigs(sigset_t *oldset)
58{
59    return sigprocmask(SIG_SETMASK, oldset, NULL);
60}
61
62static int ocfs2_fault(struct vm_area_struct *area, struct vm_fault *vmf)
63{
64    sigset_t blocked, oldset;
65    int error, ret;
66
67    mlog_entry("(area=%p, page offset=%lu)\n", area, vmf->pgoff);
68
69    error = ocfs2_vm_op_block_sigs(&blocked, &oldset);
70    if (error < 0) {
71        mlog_errno(error);
72        ret = VM_FAULT_SIGBUS;
73        goto out;
74    }
75
76    ret = filemap_fault(area, vmf);
77
78    error = ocfs2_vm_op_unblock_sigs(&oldset);
79    if (error < 0)
80        mlog_errno(error);
81out:
82    mlog_exit_ptr(vmf->page);
83    return ret;
84}
85
86static 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;
91    loff_t pos = page_offset(page);
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);
97
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) {
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;
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 vm_fault *vmf)
157{
158    struct page *page = vmf->page;
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     */
175    ret = ocfs2_inode_lock(inode, &di_bh, 1);
176    if (ret < 0) {
177        mlog_errno(ret);
178        goto out;
179    }
180
181    /*
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.
185     */
186    down_write(&OCFS2_I(inode)->ip_alloc_sem);
187
188    ret = __ocfs2_page_mkwrite(inode, di_bh, page);
189
190    up_write(&OCFS2_I(inode)->ip_alloc_sem);
191
192    brelse(di_bh);
193    ocfs2_inode_unlock(inode, 1);
194
195out:
196    ret2 = ocfs2_vm_op_unblock_sigs(&oldset);
197    if (ret2 < 0)
198        mlog_errno(ret2);
199    if (ret)
200        ret = VM_FAULT_SIGBUS;
201    return ret;
202}
203
204static const struct vm_operations_struct ocfs2_file_vm_ops = {
205    .fault = ocfs2_fault,
206    .page_mkwrite = ocfs2_page_mkwrite,
207};
208
209int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
210{
211    int ret = 0, lock_level = 0;
212
213    ret = ocfs2_inode_lock_atime(file->f_dentry->d_inode,
214                    file->f_vfsmnt, &lock_level);
215    if (ret < 0) {
216        mlog_errno(ret);
217        goto out;
218    }
219    ocfs2_inode_unlock(file->f_dentry->d_inode, lock_level);
220out:
221    vma->vm_ops = &ocfs2_file_vm_ops;
222    vma->vm_flags |= VM_CAN_NONLINEAR;
223    return 0;
224}
225
226

Archive Download this file



interactive