1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* -*- mode: c; c-basic-offset: 8; -*-
3 * vim: noexpandtab sw=8 ts=8 sts=0:
7 * Code to deal with the mess that is clustered mmap.
9 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
13 #include <linux/types.h>
14 #include <linux/highmem.h>
15 #include <linux/pagemap.h>
16 #include <linux/uio.h>
17 #include <linux/signal.h>
18 #include <linux/rbtree.h>
20 #include <cluster/masklog.h>
30 #include "ocfs2_trace.h"
33 static vm_fault_t
ocfs2_fault(struct vm_fault
*vmf
)
35 struct vm_area_struct
*vma
= vmf
->vma
;
39 ocfs2_block_signals(&oldset
);
40 ret
= filemap_fault(vmf
);
41 ocfs2_unblock_signals(&oldset
);
43 trace_ocfs2_fault(OCFS2_I(vma
->vm_file
->f_mapping
->host
)->ip_blkno
,
44 vma
, vmf
->page
, vmf
->pgoff
);
48 static vm_fault_t
__ocfs2_page_mkwrite(struct file
*file
,
49 struct buffer_head
*di_bh
, struct page
*page
)
52 vm_fault_t ret
= VM_FAULT_NOPAGE
;
53 struct inode
*inode
= file_inode(file
);
54 struct address_space
*mapping
= inode
->i_mapping
;
55 loff_t pos
= page_offset(page
);
56 unsigned int len
= PAGE_SIZE
;
58 struct page
*locked_page
= NULL
;
60 loff_t size
= i_size_read(inode
);
62 last_index
= (size
- 1) >> PAGE_SHIFT
;
65 * There are cases that lead to the page no longer belonging to the
67 * 1) pagecache truncates locally due to memory pressure.
68 * 2) pagecache truncates when another is taking EX lock against
69 * inode lock. see ocfs2_data_convert_worker.
71 * The i_size check doesn't catch the case where nodes truncated and
72 * then re-extended the file. We'll re-check the page mapping after
73 * taking the page lock inside of ocfs2_write_begin_nolock().
75 * Let VM retry with these cases.
77 if ((page
->mapping
!= inode
->i_mapping
) ||
78 (!PageUptodate(page
)) ||
79 (page_offset(page
) >= size
))
83 * Call ocfs2_write_begin() and ocfs2_write_end() to take
84 * advantage of the allocation code there. We pass a write
85 * length of the whole page (chopped to i_size) to make sure
86 * the whole thing is allocated.
88 * Since we know the page is up to date, we don't have to
89 * worry about ocfs2_write_begin() skipping some buffer reads
90 * because the "write" would invalidate their data.
92 if (page
->index
== last_index
)
93 len
= ((size
- 1) & ~PAGE_MASK
) + 1;
95 err
= ocfs2_write_begin_nolock(mapping
, pos
, len
, OCFS2_WRITE_MMAP
,
96 &locked_page
, &fsdata
, di_bh
, page
);
100 ret
= vmf_error(err
);
105 ret
= VM_FAULT_NOPAGE
;
108 err
= ocfs2_write_end_nolock(mapping
, pos
, len
, len
, fsdata
);
110 ret
= VM_FAULT_LOCKED
;
115 static vm_fault_t
ocfs2_page_mkwrite(struct vm_fault
*vmf
)
117 struct page
*page
= vmf
->page
;
118 struct inode
*inode
= file_inode(vmf
->vma
->vm_file
);
119 struct buffer_head
*di_bh
= NULL
;
124 sb_start_pagefault(inode
->i_sb
);
125 ocfs2_block_signals(&oldset
);
128 * The cluster locks taken will block a truncate from another
129 * node. Taking the data lock will also ensure that we don't
130 * attempt page truncation as part of a downconvert.
132 err
= ocfs2_inode_lock(inode
, &di_bh
, 1);
135 ret
= vmf_error(err
);
140 * The alloc sem should be enough to serialize with
141 * ocfs2_truncate_file() changing i_size as well as any thread
142 * modifying the inode btree.
144 down_write(&OCFS2_I(inode
)->ip_alloc_sem
);
146 ret
= __ocfs2_page_mkwrite(vmf
->vma
->vm_file
, di_bh
, page
);
148 up_write(&OCFS2_I(inode
)->ip_alloc_sem
);
151 ocfs2_inode_unlock(inode
, 1);
154 ocfs2_unblock_signals(&oldset
);
155 sb_end_pagefault(inode
->i_sb
);
159 static const struct vm_operations_struct ocfs2_file_vm_ops
= {
160 .fault
= ocfs2_fault
,
161 .page_mkwrite
= ocfs2_page_mkwrite
,
164 int ocfs2_mmap(struct file
*file
, struct vm_area_struct
*vma
)
166 int ret
= 0, lock_level
= 0;
168 ret
= ocfs2_inode_lock_atime(file_inode(file
),
169 file
->f_path
.mnt
, &lock_level
, 1);
174 ocfs2_inode_unlock(file_inode(file
), lock_level
);
176 vma
->vm_ops
= &ocfs2_file_vm_ops
;