]>
Commit | Line | Data |
---|---|---|
d7e09d03 PT |
1 | /* |
2 | * GPL HEADER START | |
3 | * | |
4 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 only, | |
8 | * as published by the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, but | |
11 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 | * General Public License version 2 for more details (a copy is included | |
14 | * in the LICENSE file that accompanied this code). | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * version 2 along with this program; If not, see | |
18 | * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf | |
19 | * | |
20 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
21 | * CA 95054 USA or visit www.sun.com if you need additional information or | |
22 | * have any questions. | |
23 | * | |
24 | * GPL HEADER END | |
25 | */ | |
26 | /* | |
27 | * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. | |
28 | * Use is subject to license terms. | |
29 | * | |
30 | * Copyright (c) 2011, 2012, Intel Corporation. | |
31 | */ | |
32 | /* | |
33 | * This file is part of Lustre, http://www.lustre.org/ | |
34 | * Lustre is a trademark of Sun Microsystems, Inc. | |
35 | * | |
36 | * lustre/lustre/llite/rw26.c | |
37 | * | |
38 | * Lustre Lite I/O page cache routines for the 2.5/2.6 kernel version | |
39 | */ | |
40 | ||
41 | #include <linux/kernel.h> | |
42 | #include <linux/mm.h> | |
43 | #include <linux/string.h> | |
44 | #include <linux/stat.h> | |
45 | #include <linux/errno.h> | |
46 | #include <linux/unistd.h> | |
9fb186cf | 47 | #include <linux/uaccess.h> |
d7e09d03 PT |
48 | |
49 | #include <linux/migrate.h> | |
50 | #include <linux/fs.h> | |
51 | #include <linux/buffer_head.h> | |
52 | #include <linux/mpage.h> | |
53 | #include <linux/writeback.h> | |
d7e09d03 PT |
54 | #include <linux/pagemap.h> |
55 | ||
56 | #define DEBUG_SUBSYSTEM S_LLITE | |
57 | ||
67a235f5 | 58 | #include "../include/lustre_lite.h" |
d7e09d03 | 59 | #include "llite_internal.h" |
67a235f5 | 60 | #include "../include/linux/lustre_compat25.h" |
d7e09d03 PT |
61 | |
62 | /** | |
63 | * Implements Linux VM address_space::invalidatepage() method. This method is | |
64 | * called when the page is truncate from a file, either as a result of | |
65 | * explicit truncate, or when inode is removed from memory (as a result of | |
66 | * final iput(), umount, or memory pressure induced icache shrinking). | |
67 | * | |
68 | * [0, offset] bytes of the page remain valid (this is for a case of not-page | |
69 | * aligned truncate). Lustre leaves partially truncated page in the cache, | |
70 | * relying on struct inode::i_size to limit further accesses. | |
71 | */ | |
5237c441 SR |
72 | static void ll_invalidatepage(struct page *vmpage, unsigned int offset, |
73 | unsigned int length) | |
d7e09d03 PT |
74 | { |
75 | struct inode *inode; | |
76 | struct lu_env *env; | |
77 | struct cl_page *page; | |
78 | struct cl_object *obj; | |
79 | ||
80 | int refcheck; | |
81 | ||
82 | LASSERT(PageLocked(vmpage)); | |
83 | LASSERT(!PageWriteback(vmpage)); | |
84 | ||
85 | /* | |
86 | * It is safe to not check anything in invalidatepage/releasepage | |
87 | * below because they are run with page locked and all our io is | |
88 | * happening with locked page too | |
89 | */ | |
09cbfeaf | 90 | if (offset == 0 && length == PAGE_SIZE) { |
d7e09d03 PT |
91 | env = cl_env_get(&refcheck); |
92 | if (!IS_ERR(env)) { | |
93 | inode = vmpage->mapping->host; | |
94 | obj = ll_i2info(inode)->lli_clob; | |
6e16818b | 95 | if (obj) { |
d7e09d03 | 96 | page = cl_vmpage_page(vmpage, obj); |
6e16818b | 97 | if (page) { |
d7e09d03 PT |
98 | lu_ref_add(&page->cp_reference, |
99 | "delete", vmpage); | |
100 | cl_page_delete(env, page); | |
101 | lu_ref_del(&page->cp_reference, | |
102 | "delete", vmpage); | |
103 | cl_page_put(env, page); | |
104 | } | |
105 | } else | |
106 | LASSERT(vmpage->private == 0); | |
107 | cl_env_put(env, &refcheck); | |
108 | } | |
109 | } | |
110 | } | |
111 | ||
46f93a14 | 112 | static int ll_releasepage(struct page *vmpage, gfp_t gfp_mask) |
d7e09d03 PT |
113 | { |
114 | struct cl_env_nest nest; | |
115 | struct lu_env *env; | |
116 | struct cl_object *obj; | |
117 | struct cl_page *page; | |
118 | struct address_space *mapping; | |
119 | int result; | |
120 | ||
121 | LASSERT(PageLocked(vmpage)); | |
122 | if (PageWriteback(vmpage) || PageDirty(vmpage)) | |
123 | return 0; | |
124 | ||
125 | mapping = vmpage->mapping; | |
6e16818b | 126 | if (!mapping) |
d7e09d03 PT |
127 | return 1; |
128 | ||
129 | obj = ll_i2info(mapping->host)->lli_clob; | |
6e16818b | 130 | if (!obj) |
d7e09d03 PT |
131 | return 1; |
132 | ||
133 | /* 1 for page allocator, 1 for cl_page and 1 for page cache */ | |
134 | if (page_count(vmpage) > 3) | |
135 | return 0; | |
136 | ||
137 | /* TODO: determine what gfp should be used by @gfp_mask. */ | |
138 | env = cl_env_nested_get(&nest); | |
139 | if (IS_ERR(env)) | |
140 | /* If we can't allocate an env we won't call cl_page_put() | |
141 | * later on which further means it's impossible to drop | |
142 | * page refcount by cl_page, so ask kernel to not free | |
c0894c6c OD |
143 | * this page. |
144 | */ | |
d7e09d03 PT |
145 | return 0; |
146 | ||
147 | page = cl_vmpage_page(vmpage, obj); | |
6e16818b OD |
148 | result = !page; |
149 | if (page) { | |
d7e09d03 PT |
150 | if (!cl_page_in_use(page)) { |
151 | result = 1; | |
152 | cl_page_delete(env, page); | |
153 | } | |
154 | cl_page_put(env, page); | |
155 | } | |
156 | cl_env_nested_put(&nest, env); | |
157 | return result; | |
158 | } | |
159 | ||
160 | static int ll_set_page_dirty(struct page *vmpage) | |
161 | { | |
162 | #if 0 | |
163 | struct cl_page *page = vvp_vmpage_page_transient(vmpage); | |
164 | struct vvp_object *obj = cl_inode2vvp(vmpage->mapping->host); | |
165 | struct vvp_page *cpg; | |
166 | ||
167 | /* | |
168 | * XXX should page method be called here? | |
169 | */ | |
170 | LASSERT(&obj->co_cl == page->cp_obj); | |
171 | cpg = cl2vvp_page(cl_page_at(page, &vvp_device_type)); | |
172 | /* | |
173 | * XXX cannot do much here, because page is possibly not locked: | |
174 | * sys_munmap()->... | |
175 | * ->unmap_page_range()->zap_pte_range()->set_page_dirty(). | |
176 | */ | |
177 | vvp_write_pending(obj, cpg); | |
178 | #endif | |
0a3bdb00 | 179 | return __set_page_dirty_nobuffers(vmpage); |
d7e09d03 PT |
180 | } |
181 | ||
907cd248 | 182 | #define MAX_DIRECTIO_SIZE (2*1024*1024*1024UL) |
d7e09d03 PT |
183 | |
184 | static inline int ll_get_user_pages(int rw, unsigned long user_addr, | |
185 | size_t size, struct page ***pages, | |
186 | int *max_pages) | |
187 | { | |
188 | int result = -ENOMEM; | |
189 | ||
190 | /* set an arbitrary limit to prevent arithmetic overflow */ | |
191 | if (size > MAX_DIRECTIO_SIZE) { | |
192 | *pages = NULL; | |
193 | return -EFBIG; | |
194 | } | |
195 | ||
09cbfeaf KS |
196 | *max_pages = (user_addr + size + PAGE_SIZE - 1) >> PAGE_SHIFT; |
197 | *max_pages -= user_addr >> PAGE_SHIFT; | |
d7e09d03 | 198 | |
e958f49b | 199 | *pages = libcfs_kvzalloc(*max_pages * sizeof(**pages), GFP_NOFS); |
d7e09d03 | 200 | if (*pages) { |
d1a168ec JK |
201 | result = get_user_pages_fast(user_addr, *max_pages, |
202 | (rw == READ), *pages); | |
d7e09d03 | 203 | if (unlikely(result <= 0)) |
e958f49b | 204 | kvfree(*pages); |
d7e09d03 PT |
205 | } |
206 | ||
207 | return result; | |
208 | } | |
209 | ||
210 | /* ll_free_user_pages - tear down page struct array | |
c0894c6c OD |
211 | * @pages: array of page struct pointers underlying target buffer |
212 | */ | |
d7e09d03 PT |
213 | static void ll_free_user_pages(struct page **pages, int npages, int do_dirty) |
214 | { | |
215 | int i; | |
216 | ||
217 | for (i = 0; i < npages; i++) { | |
d7e09d03 PT |
218 | if (do_dirty) |
219 | set_page_dirty_lock(pages[i]); | |
09cbfeaf | 220 | put_page(pages[i]); |
d7e09d03 | 221 | } |
91f79c43 | 222 | kvfree(pages); |
d7e09d03 PT |
223 | } |
224 | ||
225 | ssize_t ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io, | |
226 | int rw, struct inode *inode, | |
227 | struct ll_dio_pages *pv) | |
228 | { | |
229 | struct cl_page *clp; | |
230 | struct cl_2queue *queue; | |
231 | struct cl_object *obj = io->ci_obj; | |
232 | int i; | |
233 | ssize_t rc = 0; | |
234 | loff_t file_offset = pv->ldp_start_offset; | |
235 | long size = pv->ldp_size; | |
236 | int page_count = pv->ldp_nr; | |
237 | struct page **pages = pv->ldp_pages; | |
238 | long page_size = cl_page_size(obj); | |
239 | bool do_io; | |
240 | int io_pages = 0; | |
d7e09d03 PT |
241 | |
242 | queue = &io->ci_queue; | |
243 | cl_2queue_init(queue); | |
244 | for (i = 0; i < page_count; i++) { | |
245 | if (pv->ldp_offsets) | |
defa220f | 246 | file_offset = pv->ldp_offsets[i]; |
d7e09d03 PT |
247 | |
248 | LASSERT(!(file_offset & (page_size - 1))); | |
249 | clp = cl_page_find(env, obj, cl_index(obj, file_offset), | |
250 | pv->ldp_pages[i], CPT_TRANSIENT); | |
251 | if (IS_ERR(clp)) { | |
252 | rc = PTR_ERR(clp); | |
253 | break; | |
254 | } | |
255 | ||
256 | rc = cl_page_own(env, io, clp); | |
257 | if (rc) { | |
258 | LASSERT(clp->cp_state == CPS_FREEING); | |
259 | cl_page_put(env, clp); | |
260 | break; | |
261 | } | |
262 | ||
263 | do_io = true; | |
264 | ||
265 | /* check the page type: if the page is a host page, then do | |
c0894c6c OD |
266 | * write directly |
267 | */ | |
d7e09d03 PT |
268 | if (clp->cp_type == CPT_CACHEABLE) { |
269 | struct page *vmpage = cl_page_vmpage(env, clp); | |
270 | struct page *src_page; | |
271 | struct page *dst_page; | |
272 | void *src; | |
273 | void *dst; | |
274 | ||
275 | src_page = (rw == WRITE) ? pages[i] : vmpage; | |
276 | dst_page = (rw == WRITE) ? vmpage : pages[i]; | |
277 | ||
5e8ebf13 ZH |
278 | src = kmap_atomic(src_page); |
279 | dst = kmap_atomic(dst_page); | |
d7e09d03 | 280 | memcpy(dst, src, min(page_size, size)); |
5e8ebf13 ZH |
281 | kunmap_atomic(dst); |
282 | kunmap_atomic(src); | |
d7e09d03 PT |
283 | |
284 | /* make sure page will be added to the transfer by | |
c0894c6c OD |
285 | * cl_io_submit()->...->vvp_page_prep_write(). |
286 | */ | |
d7e09d03 PT |
287 | if (rw == WRITE) |
288 | set_page_dirty(vmpage); | |
289 | ||
290 | if (rw == READ) { | |
291 | /* do not issue the page for read, since it | |
292 | * may reread a ra page which has NOT uptodate | |
c0894c6c OD |
293 | * bit set. |
294 | */ | |
d7e09d03 PT |
295 | cl_page_disown(env, io, clp); |
296 | do_io = false; | |
297 | } | |
298 | } | |
299 | ||
300 | if (likely(do_io)) { | |
53f1a127 SB |
301 | /* |
302 | * Add a page to the incoming page list of 2-queue. | |
303 | */ | |
304 | cl_page_list_add(&queue->c2_qin, clp); | |
d7e09d03 PT |
305 | |
306 | /* | |
307 | * Set page clip to tell transfer formation engine | |
308 | * that page has to be sent even if it is beyond KMS. | |
309 | */ | |
310 | cl_page_clip(env, clp, 0, min(size, page_size)); | |
311 | ||
312 | ++io_pages; | |
313 | } | |
314 | ||
315 | /* drop the reference count for cl_page_find */ | |
316 | cl_page_put(env, clp); | |
317 | size -= page_size; | |
318 | file_offset += page_size; | |
319 | } | |
320 | ||
321 | if (rc == 0 && io_pages) { | |
322 | rc = cl_io_submit_sync(env, io, | |
323 | rw == READ ? CRT_READ : CRT_WRITE, | |
324 | queue, 0); | |
325 | } | |
326 | if (rc == 0) | |
327 | rc = pv->ldp_size; | |
328 | ||
329 | cl_2queue_discard(env, io, queue); | |
330 | cl_2queue_disown(env, io, queue); | |
331 | cl_2queue_fini(env, queue); | |
0a3bdb00 | 332 | return rc; |
d7e09d03 PT |
333 | } |
334 | EXPORT_SYMBOL(ll_direct_rw_pages); | |
335 | ||
336 | static ssize_t ll_direct_IO_26_seg(const struct lu_env *env, struct cl_io *io, | |
337 | int rw, struct inode *inode, | |
338 | struct address_space *mapping, | |
339 | size_t size, loff_t file_offset, | |
340 | struct page **pages, int page_count) | |
341 | { | |
22ea97f0 OD |
342 | struct ll_dio_pages pvec = { |
343 | .ldp_pages = pages, | |
344 | .ldp_nr = page_count, | |
345 | .ldp_size = size, | |
346 | .ldp_offsets = NULL, | |
347 | .ldp_start_offset = file_offset | |
348 | }; | |
349 | ||
350 | return ll_direct_rw_pages(env, io, rw, inode, &pvec); | |
d7e09d03 PT |
351 | } |
352 | ||
d7e09d03 PT |
353 | /* This is the maximum size of a single O_DIRECT request, based on the |
354 | * kmalloc limit. We need to fit all of the brw_page structs, each one | |
355 | * representing PAGE_SIZE worth of user data, into a single buffer, and | |
356 | * then truncate this to be a full-sized RPC. For 4kB PAGE_SIZE this is | |
c0894c6c OD |
357 | * up to 22MB for 128kB kmalloc and up to 682MB for 4MB kmalloc. |
358 | */ | |
12a880bf | 359 | #define MAX_DIO_SIZE ((KMALLOC_MAX_SIZE / sizeof(struct brw_page) * \ |
09cbfeaf | 360 | PAGE_SIZE) & ~(DT_MAX_BRW_SIZE - 1)) |
22c6186e OS |
361 | static ssize_t ll_direct_IO_26(struct kiocb *iocb, struct iov_iter *iter, |
362 | loff_t file_offset) | |
d7e09d03 PT |
363 | { |
364 | struct lu_env *env; | |
365 | struct cl_io *io; | |
366 | struct file *file = iocb->ki_filp; | |
367 | struct inode *inode = file->f_mapping->host; | |
368 | struct ccc_object *obj = cl_inode2ccc(inode); | |
91f79c43 AV |
369 | ssize_t count = iov_iter_count(iter); |
370 | ssize_t tot_bytes = 0, result = 0; | |
d7e09d03 | 371 | struct ll_inode_info *lli = ll_i2info(inode); |
d7e09d03 PT |
372 | long size = MAX_DIO_SIZE; |
373 | int refcheck; | |
d7e09d03 PT |
374 | |
375 | if (!lli->lli_has_smd) | |
0a3bdb00 | 376 | return -EBADF; |
d7e09d03 PT |
377 | |
378 | /* FIXME: io smaller than PAGE_SIZE is broken on ia64 ??? */ | |
379 | if ((file_offset & ~CFS_PAGE_MASK) || (count & ~CFS_PAGE_MASK)) | |
0a3bdb00 | 380 | return -EINVAL; |
d7e09d03 | 381 | |
b41a1fe0 GU |
382 | CDEBUG(D_VFSTRACE, |
383 | "VFS Op:inode=%lu/%u(%p), size=%zd (max %lu), offset=%lld=%llx, pages %zd (max %lu)\n", | |
d7e09d03 | 384 | inode->i_ino, inode->i_generation, inode, count, MAX_DIO_SIZE, |
09cbfeaf KS |
385 | file_offset, file_offset, count >> PAGE_SHIFT, |
386 | MAX_DIO_SIZE >> PAGE_SHIFT); | |
d7e09d03 PT |
387 | |
388 | /* Check that all user buffers are aligned as well */ | |
886a3911 AV |
389 | if (iov_iter_alignment(iter) & ~CFS_PAGE_MASK) |
390 | return -EINVAL; | |
d7e09d03 PT |
391 | |
392 | env = cl_env_get(&refcheck); | |
393 | LASSERT(!IS_ERR(env)); | |
394 | io = ccc_env_io(env)->cui_cl.cis_io; | |
6e16818b | 395 | LASSERT(io); |
d7e09d03 PT |
396 | |
397 | /* 0. Need locking between buffered and direct access. and race with | |
398 | * size changing by concurrent truncates and writes. | |
399 | * 1. Need inode mutex to operate transient pages. | |
400 | */ | |
6f673763 | 401 | if (iov_iter_rw(iter) == READ) |
5955102c | 402 | inode_lock(inode); |
d7e09d03 PT |
403 | |
404 | LASSERT(obj->cob_transient_pages == 0); | |
91f79c43 AV |
405 | while (iov_iter_count(iter)) { |
406 | struct page **pages; | |
407 | size_t offs; | |
d7e09d03 | 408 | |
91f79c43 | 409 | count = min_t(size_t, iov_iter_count(iter), size); |
6f673763 | 410 | if (iov_iter_rw(iter) == READ) { |
d7e09d03 PT |
411 | if (file_offset >= i_size_read(inode)) |
412 | break; | |
91f79c43 AV |
413 | if (file_offset + count > i_size_read(inode)) |
414 | count = i_size_read(inode) - file_offset; | |
d7e09d03 PT |
415 | } |
416 | ||
91f79c43 AV |
417 | result = iov_iter_get_pages_alloc(iter, &pages, count, &offs); |
418 | if (likely(result > 0)) { | |
ef96fddd | 419 | int n = DIV_ROUND_UP(result + offs, PAGE_SIZE); |
50ffcb7e | 420 | |
6f673763 OS |
421 | result = ll_direct_IO_26_seg(env, io, iov_iter_rw(iter), |
422 | inode, file->f_mapping, | |
423 | result, file_offset, pages, | |
424 | n); | |
425 | ll_free_user_pages(pages, n, iov_iter_rw(iter) == READ); | |
91f79c43 AV |
426 | } |
427 | if (unlikely(result <= 0)) { | |
428 | /* If we can't allocate a large enough buffer | |
429 | * for the request, shrink it to a smaller | |
430 | * PAGE_SIZE multiple and try again. | |
431 | * We should always be able to kmalloc for a | |
c0894c6c OD |
432 | * page worth of page pointers = 4MB on i386. |
433 | */ | |
91f79c43 | 434 | if (result == -ENOMEM && |
09cbfeaf KS |
435 | size > (PAGE_SIZE / sizeof(*pages)) * |
436 | PAGE_SIZE) { | |
91f79c43 AV |
437 | size = ((((size / 2) - 1) | |
438 | ~CFS_PAGE_MASK) + 1) & | |
439 | CFS_PAGE_MASK; | |
1d8cb70c | 440 | CDEBUG(D_VFSTRACE, "DIO size now %lu\n", |
91f79c43 AV |
441 | size); |
442 | continue; | |
d7e09d03 PT |
443 | } |
444 | ||
34e1f2bb | 445 | goto out; |
d7e09d03 | 446 | } |
91f79c43 AV |
447 | iov_iter_advance(iter, result); |
448 | tot_bytes += result; | |
449 | file_offset += result; | |
d7e09d03 PT |
450 | } |
451 | out: | |
452 | LASSERT(obj->cob_transient_pages == 0); | |
6f673763 | 453 | if (iov_iter_rw(iter) == READ) |
5955102c | 454 | inode_unlock(inode); |
d7e09d03 PT |
455 | |
456 | if (tot_bytes > 0) { | |
6f673763 | 457 | if (iov_iter_rw(iter) == WRITE) { |
d7e09d03 PT |
458 | struct lov_stripe_md *lsm; |
459 | ||
460 | lsm = ccc_inode_lsm_get(inode); | |
6e16818b | 461 | LASSERT(lsm); |
d7e09d03 PT |
462 | lov_stripe_lock(lsm); |
463 | obd_adjust_kms(ll_i2dtexp(inode), lsm, file_offset, 0); | |
464 | lov_stripe_unlock(lsm); | |
465 | ccc_inode_lsm_put(inode, lsm); | |
466 | } | |
467 | } | |
468 | ||
469 | cl_env_put(env, &refcheck); | |
0a3bdb00 | 470 | return tot_bytes ? : result; |
d7e09d03 PT |
471 | } |
472 | ||
473 | static int ll_write_begin(struct file *file, struct address_space *mapping, | |
e15ba45d OD |
474 | loff_t pos, unsigned len, unsigned flags, |
475 | struct page **pagep, void **fsdata) | |
d7e09d03 | 476 | { |
09cbfeaf | 477 | pgoff_t index = pos >> PAGE_SHIFT; |
d7e09d03 PT |
478 | struct page *page; |
479 | int rc; | |
09cbfeaf | 480 | unsigned from = pos & (PAGE_SIZE - 1); |
d7e09d03 PT |
481 | |
482 | page = grab_cache_page_write_begin(mapping, index, flags); | |
483 | if (!page) | |
0a3bdb00 | 484 | return -ENOMEM; |
d7e09d03 PT |
485 | |
486 | *pagep = page; | |
487 | ||
488 | rc = ll_prepare_write(file, page, from, from + len); | |
489 | if (rc) { | |
490 | unlock_page(page); | |
09cbfeaf | 491 | put_page(page); |
d7e09d03 | 492 | } |
0a3bdb00 | 493 | return rc; |
d7e09d03 PT |
494 | } |
495 | ||
496 | static int ll_write_end(struct file *file, struct address_space *mapping, | |
497 | loff_t pos, unsigned len, unsigned copied, | |
498 | struct page *page, void *fsdata) | |
499 | { | |
09cbfeaf | 500 | unsigned from = pos & (PAGE_SIZE - 1); |
d7e09d03 PT |
501 | int rc; |
502 | ||
503 | rc = ll_commit_write(file, page, from, from + copied); | |
504 | unlock_page(page); | |
09cbfeaf | 505 | put_page(page); |
d7e09d03 PT |
506 | |
507 | return rc ?: copied; | |
508 | } | |
509 | ||
510 | #ifdef CONFIG_MIGRATION | |
2d95f10e | 511 | static int ll_migratepage(struct address_space *mapping, |
e15ba45d OD |
512 | struct page *newpage, struct page *page, |
513 | enum migrate_mode mode | |
d7e09d03 PT |
514 | ) |
515 | { | |
516 | /* Always fail page migration until we have a proper implementation */ | |
517 | return -EIO; | |
518 | } | |
519 | #endif | |
520 | ||
2d95f10e JH |
521 | const struct address_space_operations ll_aops = { |
522 | .readpage = ll_readpage, | |
d7e09d03 PT |
523 | .direct_IO = ll_direct_IO_26, |
524 | .writepage = ll_writepage, | |
525 | .writepages = ll_writepages, | |
526 | .set_page_dirty = ll_set_page_dirty, | |
527 | .write_begin = ll_write_begin, | |
528 | .write_end = ll_write_end, | |
529 | .invalidatepage = ll_invalidatepage, | |
530 | .releasepage = (void *)ll_releasepage, | |
531 | #ifdef CONFIG_MIGRATION | |
532 | .migratepage = ll_migratepage, | |
533 | #endif | |
d7e09d03 | 534 | }; |