1
2
3
4
5
6
7
8
9
10
11
12#include <linux/module.h>
13#include <linux/fs.h>
14#include <linux/mm.h>
15#include <linux/pagemap.h>
16#include <linux/highmem.h>
17#include <linux/init.h>
18#include <linux/string.h>
19#include <linux/backing-dev.h>
20#include <linux/ramfs.h>
21#include <linux/pagevec.h>
22#include <linux/mman.h>
23#include <linux/sched.h>
24
25#include <asm/uaccess.h>
26#include "internal.h"
27
28static int ramfs_nommu_setattr(struct dentry *, struct iattr *);
29
30const struct address_space_operations ramfs_aops = {
31 .readpage = simple_readpage,
32 .write_begin = simple_write_begin,
33 .write_end = simple_write_end,
34 .set_page_dirty = __set_page_dirty_no_writeback,
35};
36
37const struct file_operations ramfs_file_operations = {
38 .mmap = ramfs_nommu_mmap,
39 .get_unmapped_area = ramfs_nommu_get_unmapped_area,
40 .read = do_sync_read,
41 .aio_read = generic_file_aio_read,
42 .write = do_sync_write,
43 .aio_write = generic_file_aio_write,
44 .fsync = simple_sync_file,
45 .splice_read = generic_file_splice_read,
46 .splice_write = generic_file_splice_write,
47 .llseek = generic_file_llseek,
48};
49
50const struct inode_operations ramfs_file_inode_operations = {
51 .setattr = ramfs_nommu_setattr,
52 .getattr = simple_getattr,
53};
54
55
56
57
58
59
60
61int ramfs_nommu_expand_for_mapping(struct inode *inode, size_t newsize)
62{
63 unsigned long npages, xpages, loop, limit;
64 struct page *pages;
65 unsigned order;
66 void *data;
67 int ret;
68
69
70 order = get_order(newsize);
71 if (unlikely(order >= MAX_ORDER))
72 return -EFBIG;
73
74 ret = inode_newsize_ok(inode, newsize);
75 if (ret)
76 return ret;
77
78 i_size_write(inode, newsize);
79
80
81
82 pages = alloc_pages(mapping_gfp_mask(inode->i_mapping), order);
83 if (!pages)
84 return -ENOMEM;
85
86
87 xpages = 1UL << order;
88 npages = (newsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
89
90 split_page(pages, order);
91
92
93 for (loop = npages; loop < xpages; loop++)
94 __free_page(pages + loop);
95
96
97 newsize = PAGE_SIZE * npages;
98 data = page_address(pages);
99 memset(data, 0, newsize);
100
101
102 for (loop = 0; loop < npages; loop++) {
103 struct page *page = pages + loop;
104
105 ret = add_to_page_cache_lru(page, inode->i_mapping, loop,
106 GFP_KERNEL);
107 if (ret < 0)
108 goto add_error;
109
110
111 SetPageDirty(page);
112
113 unlock_page(page);
114 }
115
116 return 0;
117
118add_error:
119 while (loop < npages)
120 __free_page(pages + loop++);
121 return ret;
122}
123
124
125
126
127
128static int ramfs_nommu_check_mappings(struct inode *inode,
129 size_t newsize, size_t size)
130{
131 struct vm_area_struct *vma;
132 struct prio_tree_iter iter;
133
134
135 vma_prio_tree_foreach(vma, &iter, &inode->i_mapping->i_mmap,
136 newsize >> PAGE_SHIFT,
137 (size + PAGE_SIZE - 1) >> PAGE_SHIFT
138 ) {
139
140
141 if (vma->vm_flags & VM_SHARED)
142 return -ETXTBSY;
143 }
144
145 return 0;
146}
147
148
149
150
151
152static int ramfs_nommu_resize(struct inode *inode, loff_t newsize, loff_t size)
153{
154 int ret;
155
156
157
158 if (size == 0) {
159 if (unlikely(newsize >> 32))
160 return -EFBIG;
161
162 return ramfs_nommu_expand_for_mapping(inode, newsize);
163 }
164
165
166 if (newsize < size) {
167 ret = ramfs_nommu_check_mappings(inode, newsize, size);
168 if (ret < 0)
169 return ret;
170 }
171
172 ret = vmtruncate(inode, newsize);
173
174 return ret;
175}
176
177
178
179
180
181
182static int ramfs_nommu_setattr(struct dentry *dentry, struct iattr *ia)
183{
184 struct inode *inode = dentry->d_inode;
185 unsigned int old_ia_valid = ia->ia_valid;
186 int ret = 0;
187
188
189 ret = inode_change_ok(inode, ia);
190 if (ret)
191 return ret;
192
193
194 if (ia->ia_valid & ATTR_SIZE) {
195 loff_t size = i_size_read(inode);
196 if (ia->ia_size != size) {
197 ret = ramfs_nommu_resize(inode, ia->ia_size, size);
198 if (ret < 0 || ia->ia_valid == ATTR_SIZE)
199 goto out;
200 } else {
201
202
203
204 ia->ia_valid |= ATTR_MTIME|ATTR_CTIME;
205 }
206 }
207
208 ret = inode_setattr(inode, ia);
209 out:
210 ia->ia_valid = old_ia_valid;
211 return ret;
212}
213
214
215
216
217
218
219
220
221unsigned long ramfs_nommu_get_unmapped_area(struct file *file,
222 unsigned long addr, unsigned long len,
223 unsigned long pgoff, unsigned long flags)
224{
225 unsigned long maxpages, lpages, nr, loop, ret;
226 struct inode *inode = file->f_path.dentry->d_inode;
227 struct page **pages = NULL, **ptr, *page;
228 loff_t isize;
229
230 if (!(flags & MAP_SHARED))
231 return addr;
232
233
234 lpages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
235 isize = i_size_read(inode);
236
237 ret = -EINVAL;
238 maxpages = (isize + PAGE_SIZE - 1) >> PAGE_SHIFT;
239 if (pgoff >= maxpages)
240 goto out;
241
242 if (maxpages - pgoff < lpages)
243 goto out;
244
245
246 ret = -ENOMEM;
247 pages = kzalloc(lpages * sizeof(struct page *), GFP_KERNEL);
248 if (!pages)
249 goto out_free;
250
251 nr = find_get_pages(inode->i_mapping, pgoff, lpages, pages);
252 if (nr != lpages)
253 goto out_free_pages;
254
255
256 ptr = pages;
257 page = *ptr++;
258 page++;
259 for (loop = lpages; loop > 1; loop--)
260 if (*ptr++ != page++)
261 goto out_free_pages;
262
263
264 ret = (unsigned long) page_address(pages[0]);
265
266out_free_pages:
267 ptr = pages;
268 for (loop = nr; loop > 0; loop--)
269 put_page(*ptr++);
270out_free:
271 kfree(pages);
272out:
273 return ret;
274}
275
276
277
278
279
280int ramfs_nommu_mmap(struct file *file, struct vm_area_struct *vma)
281{
282 if (!(vma->vm_flags & VM_SHARED))
283 return -ENOSYS;
284
285 file_accessed(file);
286 vma->vm_ops = &generic_file_vm_ops;
287 return 0;
288}
289