Commit | Line | Data |
---|---|---|
457c8996 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
1da177e4 LT |
2 | /* |
3 | * linux/fs/nfs/read.c | |
4 | * | |
5 | * Block I/O for NFS | |
6 | * | |
7 | * Partial copy of Linus' read cache modifications to fs/nfs/file.c | |
8 | * modified for async RPC by okir@monad.swb.de | |
1da177e4 LT |
9 | */ |
10 | ||
1da177e4 LT |
11 | #include <linux/time.h> |
12 | #include <linux/kernel.h> | |
13 | #include <linux/errno.h> | |
14 | #include <linux/fcntl.h> | |
15 | #include <linux/stat.h> | |
16 | #include <linux/mm.h> | |
17 | #include <linux/slab.h> | |
18 | #include <linux/pagemap.h> | |
19 | #include <linux/sunrpc/clnt.h> | |
20 | #include <linux/nfs_fs.h> | |
21 | #include <linux/nfs_page.h> | |
64419a9b | 22 | #include <linux/module.h> |
1da177e4 | 23 | |
f11c88af | 24 | #include "nfs4_fs.h" |
49a70f27 | 25 | #include "internal.h" |
91d5b470 | 26 | #include "iostat.h" |
9a9fc1c0 | 27 | #include "fscache.h" |
fab5fc25 | 28 | #include "pnfs.h" |
8224b273 | 29 | #include "nfstrace.h" |
91d5b470 | 30 | |
1da177e4 LT |
31 | #define NFSDBG_FACILITY NFSDBG_PAGECACHE |
32 | ||
061ae2ed | 33 | static const struct nfs_pgio_completion_ops nfs_async_read_completion_ops; |
4a0de55c | 34 | static const struct nfs_rw_ops nfs_rw_read_ops; |
1da177e4 | 35 | |
e18b890b | 36 | static struct kmem_cache *nfs_rdata_cachep; |
1da177e4 | 37 | |
1e7f3a48 | 38 | static struct nfs_pgio_header *nfs_readhdr_alloc(void) |
3feb2d49 | 39 | { |
fbe77c30 BC |
40 | struct nfs_pgio_header *p = kmem_cache_zalloc(nfs_rdata_cachep, GFP_KERNEL); |
41 | ||
42 | if (p) | |
43 | p->rw_mode = FMODE_READ; | |
44 | return p; | |
4db6e0b7 FI |
45 | } |
46 | ||
1e7f3a48 | 47 | static void nfs_readhdr_free(struct nfs_pgio_header *rhdr) |
3feb2d49 | 48 | { |
cd841605 | 49 | kmem_cache_free(nfs_rdata_cachep, rhdr); |
3feb2d49 TM |
50 | } |
51 | ||
1da177e4 LT |
52 | static |
53 | int nfs_return_empty_page(struct page *page) | |
54 | { | |
09cbfeaf | 55 | zero_user(page, 0, PAGE_SIZE); |
1da177e4 LT |
56 | SetPageUptodate(page); |
57 | unlock_page(page); | |
58 | return 0; | |
59 | } | |
60 | ||
1abb5088 | 61 | void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio, |
fab5fc25 | 62 | struct inode *inode, bool force_mds, |
061ae2ed | 63 | const struct nfs_pgio_completion_ops *compl_ops) |
1751c363 | 64 | { |
fab5fc25 | 65 | struct nfs_server *server = NFS_SERVER(inode); |
41d8d5b7 | 66 | const struct nfs_pageio_ops *pg_ops = &nfs_pgio_rw_ops; |
fab5fc25 CH |
67 | |
68 | #ifdef CONFIG_NFS_V4_1 | |
69 | if (server->pnfs_curr_ld && !force_mds) | |
70 | pg_ops = server->pnfs_curr_ld->pg_read_ops; | |
71 | #endif | |
4a0de55c | 72 | nfs_pageio_init(pgio, inode, pg_ops, compl_ops, &nfs_rw_read_ops, |
3bde7afd | 73 | server->rsize, 0); |
1751c363 | 74 | } |
ddda8e0a | 75 | EXPORT_SYMBOL_GPL(nfs_pageio_init_read); |
1751c363 | 76 | |
493292dd TM |
77 | void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio) |
78 | { | |
a7d42ddb WAA |
79 | struct nfs_pgio_mirror *mirror; |
80 | ||
6f29b9bb KM |
81 | if (pgio->pg_ops && pgio->pg_ops->pg_cleanup) |
82 | pgio->pg_ops->pg_cleanup(pgio); | |
83 | ||
41d8d5b7 | 84 | pgio->pg_ops = &nfs_pgio_rw_ops; |
a7d42ddb WAA |
85 | |
86 | /* read path should never have more than one mirror */ | |
87 | WARN_ON_ONCE(pgio->pg_mirror_count != 1); | |
88 | ||
89 | mirror = &pgio->pg_mirrors[0]; | |
90 | mirror->pg_bsize = NFS_SERVER(pgio->pg_inode)->rsize; | |
493292dd | 91 | } |
1f945357 | 92 | EXPORT_SYMBOL_GPL(nfs_pageio_reset_read_mds); |
493292dd | 93 | |
8f54c7a4 | 94 | static void nfs_readpage_release(struct nfs_page *req, int error) |
0bcbf039 | 95 | { |
9fcd5960 | 96 | struct inode *inode = d_inode(nfs_req_openctx(req)->dentry); |
8f54c7a4 | 97 | struct page *page = req->wb_page; |
0bcbf039 PT |
98 | |
99 | dprintk("NFS: read done (%s/%llu %d@%lld)\n", inode->i_sb->s_id, | |
100 | (unsigned long long)NFS_FILEID(inode), req->wb_bytes, | |
101 | (long long)req_offset(req)); | |
102 | ||
8f54c7a4 TM |
103 | if (nfs_error_is_fatal_on_server(error) && error != -ETIMEDOUT) |
104 | SetPageError(page); | |
0bcbf039 | 105 | if (nfs_page_group_sync_on_bit(req, PG_UNLOCKPAGE)) { |
8f54c7a4 | 106 | struct address_space *mapping = page_file_mapping(page); |
0bcbf039 | 107 | |
8f54c7a4 TM |
108 | if (PageUptodate(page)) |
109 | nfs_readpage_to_fscache(inode, page, 0); | |
110 | else if (!PageError(page) && !PagePrivate(page)) | |
111 | generic_error_remove_page(mapping, page); | |
112 | unlock_page(page); | |
0bcbf039 PT |
113 | } |
114 | nfs_release_request(req); | |
115 | } | |
116 | ||
f42b293d DH |
117 | int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode, |
118 | struct page *page) | |
1da177e4 | 119 | { |
1da177e4 LT |
120 | struct nfs_page *new; |
121 | unsigned int len; | |
c76069bd | 122 | struct nfs_pageio_descriptor pgio; |
a7d42ddb | 123 | struct nfs_pgio_mirror *pgm; |
1da177e4 | 124 | |
49a70f27 | 125 | len = nfs_page_length(page); |
1da177e4 LT |
126 | if (len == 0) |
127 | return nfs_return_empty_page(page); | |
28b1d3f5 | 128 | new = nfs_create_request(ctx, page, 0, len); |
1da177e4 LT |
129 | if (IS_ERR(new)) { |
130 | unlock_page(page); | |
131 | return PTR_ERR(new); | |
132 | } | |
09cbfeaf KS |
133 | if (len < PAGE_SIZE) |
134 | zero_user_segment(page, len, PAGE_SIZE); | |
1da177e4 | 135 | |
fab5fc25 CH |
136 | nfs_pageio_init_read(&pgio, inode, false, |
137 | &nfs_async_read_completion_ops); | |
0bcbf039 PT |
138 | if (!nfs_pageio_add_request(&pgio, new)) { |
139 | nfs_list_remove_request(new); | |
8f54c7a4 | 140 | nfs_readpage_release(new, pgio.pg_error); |
0bcbf039 | 141 | } |
1751c363 | 142 | nfs_pageio_complete(&pgio); |
a7d42ddb WAA |
143 | |
144 | /* It doesn't make sense to do mirrored reads! */ | |
145 | WARN_ON_ONCE(pgio.pg_mirror_count != 1); | |
146 | ||
147 | pgm = &pgio.pg_mirrors[0]; | |
148 | NFS_I(inode)->read_io += pgm->pg_bytes_written; | |
149 | ||
d600ad1f | 150 | return pgio.pg_error < 0 ? pgio.pg_error : 0; |
1da177e4 LT |
151 | } |
152 | ||
67d0338e WAA |
153 | static void nfs_page_group_set_uptodate(struct nfs_page *req) |
154 | { | |
155 | if (nfs_page_group_sync_on_bit(req, PG_UPTODATE)) | |
156 | SetPageUptodate(req->wb_page); | |
157 | } | |
158 | ||
061ae2ed | 159 | static void nfs_read_completion(struct nfs_pgio_header *hdr) |
4db6e0b7 FI |
160 | { |
161 | unsigned long bytes = 0; | |
8f54c7a4 | 162 | int error; |
4db6e0b7 FI |
163 | |
164 | if (test_bit(NFS_IOHDR_REDO, &hdr->flags)) | |
165 | goto out; | |
4bd8b010 TM |
166 | while (!list_empty(&hdr->pages)) { |
167 | struct nfs_page *req = nfs_list_entry(hdr->pages.next); | |
168 | struct page *page = req->wb_page; | |
68072992 WAA |
169 | unsigned long start = req->wb_pgbase; |
170 | unsigned long end = req->wb_pgbase + req->wb_bytes; | |
4bd8b010 TM |
171 | |
172 | if (test_bit(NFS_IOHDR_EOF, &hdr->flags)) { | |
68072992 WAA |
173 | /* note: regions of the page not covered by a |
174 | * request are zeroed in nfs_readpage_async / | |
175 | * readpage_async_filler */ | |
176 | if (bytes > hdr->good_bytes) { | |
177 | /* nothing in this request was good, so zero | |
178 | * the full extent of the request */ | |
179 | zero_user_segment(page, start, end); | |
180 | ||
181 | } else if (hdr->good_bytes - bytes < req->wb_bytes) { | |
182 | /* part of this request has good bytes, but | |
183 | * not all. zero the bad bytes */ | |
184 | start += hdr->good_bytes - bytes; | |
185 | WARN_ON(start < req->wb_pgbase); | |
186 | zero_user_segment(page, start, end); | |
187 | } | |
4db6e0b7 | 188 | } |
8f54c7a4 | 189 | error = 0; |
4bd8b010 TM |
190 | bytes += req->wb_bytes; |
191 | if (test_bit(NFS_IOHDR_ERROR, &hdr->flags)) { | |
4db6e0b7 | 192 | if (bytes <= hdr->good_bytes) |
67d0338e | 193 | nfs_page_group_set_uptodate(req); |
8f54c7a4 TM |
194 | else { |
195 | error = hdr->error; | |
196 | xchg(&nfs_req_openctx(req)->error, error); | |
197 | } | |
4bd8b010 | 198 | } else |
67d0338e | 199 | nfs_page_group_set_uptodate(req); |
4bd8b010 | 200 | nfs_list_remove_request(req); |
8f54c7a4 | 201 | nfs_readpage_release(req, error); |
4db6e0b7 FI |
202 | } |
203 | out: | |
204 | hdr->release(hdr); | |
205 | } | |
206 | ||
d45f60c6 WAA |
207 | static void nfs_initiate_read(struct nfs_pgio_header *hdr, |
208 | struct rpc_message *msg, | |
abde71f4 | 209 | const struct nfs_rpc_ops *rpc_ops, |
1ed26f33 | 210 | struct rpc_task_setup *task_setup_data, int how) |
1da177e4 | 211 | { |
d45f60c6 | 212 | struct inode *inode = hdr->inode; |
84115e1c | 213 | int swap_flags = IS_SWAPFILE(inode) ? NFS_RPC_SWAPFLAGS : 0; |
1da177e4 | 214 | |
1ed26f33 | 215 | task_setup_data->flags |= swap_flags; |
abde71f4 | 216 | rpc_ops->read_setup(hdr, msg); |
8224b273 | 217 | trace_nfs_initiate_read(inode, hdr->io_start, hdr->good_bytes); |
64419a9b AA |
218 | } |
219 | ||
061ae2ed | 220 | static void |
df3accb8 | 221 | nfs_async_read_error(struct list_head *head, int error) |
1da177e4 LT |
222 | { |
223 | struct nfs_page *req; | |
224 | ||
225 | while (!list_empty(head)) { | |
226 | req = nfs_list_entry(head->next); | |
227 | nfs_list_remove_request(req); | |
8f54c7a4 | 228 | nfs_readpage_release(req, error); |
1da177e4 LT |
229 | } |
230 | } | |
231 | ||
061ae2ed FI |
232 | static const struct nfs_pgio_completion_ops nfs_async_read_completion_ops = { |
233 | .error_cleanup = nfs_async_read_error, | |
234 | .completion = nfs_read_completion, | |
235 | }; | |
236 | ||
0b671301 TM |
237 | /* |
238 | * This is the callback from RPC telling us whether a reply was | |
239 | * received or some error occurred (timeout or socket shutdown). | |
240 | */ | |
d45f60c6 WAA |
241 | static int nfs_readpage_done(struct rpc_task *task, |
242 | struct nfs_pgio_header *hdr, | |
0eecb214 | 243 | struct inode *inode) |
0b671301 | 244 | { |
d45f60c6 | 245 | int status = NFS_PROTO(inode)->read_done(task, hdr); |
0b671301 TM |
246 | if (status != 0) |
247 | return status; | |
248 | ||
d45f60c6 | 249 | nfs_add_stats(inode, NFSIOS_SERVERREADBYTES, hdr->res.count); |
8224b273 CL |
250 | trace_nfs_readpage_done(inode, task->tk_status, |
251 | hdr->args.offset, hdr->res.eof); | |
0b671301 TM |
252 | |
253 | if (task->tk_status == -ESTALE) { | |
cd841605 FI |
254 | set_bit(NFS_INO_STALE, &NFS_I(inode)->flags); |
255 | nfs_mark_for_revalidate(inode); | |
0b671301 | 256 | } |
0b671301 TM |
257 | return 0; |
258 | } | |
259 | ||
d45f60c6 WAA |
260 | static void nfs_readpage_retry(struct rpc_task *task, |
261 | struct nfs_pgio_header *hdr) | |
0b671301 | 262 | { |
d45f60c6 WAA |
263 | struct nfs_pgio_args *argp = &hdr->args; |
264 | struct nfs_pgio_res *resp = &hdr->res; | |
0b671301 | 265 | |
0b671301 | 266 | /* This is a short read! */ |
d45f60c6 | 267 | nfs_inc_stats(hdr->inode, NFSIOS_SHORTREAD); |
0b671301 | 268 | /* Has the server at least made some progress? */ |
4db6e0b7 | 269 | if (resp->count == 0) { |
d45f60c6 | 270 | nfs_set_pgio_error(hdr, -EIO, argp->offset); |
d61e612a | 271 | return; |
4db6e0b7 | 272 | } |
f8417b48 KM |
273 | |
274 | /* For non rpc-based layout drivers, retry-through-MDS */ | |
275 | if (!task->tk_ops) { | |
276 | hdr->pnfs_error = -EAGAIN; | |
277 | return; | |
278 | } | |
279 | ||
d45f60c6 WAA |
280 | /* Yes, so retry the read at the end of the hdr */ |
281 | hdr->mds_offset += resp->count; | |
0b671301 TM |
282 | argp->offset += resp->count; |
283 | argp->pgbase += resp->count; | |
284 | argp->count -= resp->count; | |
d00c5d43 | 285 | rpc_restart_call_prepare(task); |
0b671301 TM |
286 | } |
287 | ||
d45f60c6 WAA |
288 | static void nfs_readpage_result(struct rpc_task *task, |
289 | struct nfs_pgio_header *hdr) | |
1da177e4 | 290 | { |
d45f60c6 | 291 | if (hdr->res.eof) { |
1c6c4b74 TM |
292 | loff_t pos = hdr->args.offset + hdr->res.count; |
293 | unsigned int new = pos - hdr->io_start; | |
4db6e0b7 | 294 | |
1c6c4b74 TM |
295 | if (hdr->good_bytes > new) { |
296 | hdr->good_bytes = new; | |
4db6e0b7 FI |
297 | set_bit(NFS_IOHDR_EOF, &hdr->flags); |
298 | clear_bit(NFS_IOHDR_ERROR, &hdr->flags); | |
4db6e0b7 | 299 | } |
f8417b48 | 300 | } else if (hdr->res.count < hdr->args.count) |
d45f60c6 | 301 | nfs_readpage_retry(task, hdr); |
fdd1e74c TM |
302 | } |
303 | ||
1da177e4 LT |
304 | /* |
305 | * Read a page over NFS. | |
306 | * We read the page synchronously in the following case: | |
307 | * - The error flag is set for this page. This happens only when a | |
308 | * previous async read operation failed. | |
309 | */ | |
310 | int nfs_readpage(struct file *file, struct page *page) | |
311 | { | |
312 | struct nfs_open_context *ctx; | |
d56b4ddf | 313 | struct inode *inode = page_file_mapping(page)->host; |
1da177e4 LT |
314 | int error; |
315 | ||
316 | dprintk("NFS: nfs_readpage (%p %ld@%lu)\n", | |
8cd79788 | 317 | page, PAGE_SIZE, page_index(page)); |
91d5b470 | 318 | nfs_inc_stats(inode, NFSIOS_VFSREADPAGE); |
3708f842 | 319 | nfs_add_stats(inode, NFSIOS_READPAGES, 1); |
91d5b470 | 320 | |
1da177e4 LT |
321 | /* |
322 | * Try to flush any pending writes to the file.. | |
323 | * | |
324 | * NOTE! Because we own the page lock, there cannot | |
325 | * be any new pending writes generated at this point | |
326 | * for this page (other pages can be written to). | |
327 | */ | |
328 | error = nfs_wb_page(inode, page); | |
329 | if (error) | |
de05a0cc TM |
330 | goto out_unlock; |
331 | if (PageUptodate(page)) | |
332 | goto out_unlock; | |
1da177e4 | 333 | |
5f004cf2 TM |
334 | error = -ESTALE; |
335 | if (NFS_STALE(inode)) | |
de05a0cc | 336 | goto out_unlock; |
5f004cf2 | 337 | |
1da177e4 | 338 | if (file == NULL) { |
cf1308ff | 339 | error = -EBADF; |
d530838b | 340 | ctx = nfs_find_open_context(inode, NULL, FMODE_READ); |
1da177e4 | 341 | if (ctx == NULL) |
de05a0cc | 342 | goto out_unlock; |
1da177e4 | 343 | } else |
cd3758e3 | 344 | ctx = get_nfs_open_context(nfs_file_open_context(file)); |
1da177e4 | 345 | |
9a9fc1c0 DH |
346 | if (!IS_SYNC(inode)) { |
347 | error = nfs_readpage_from_fscache(ctx, inode, page); | |
348 | if (error == 0) | |
349 | goto out; | |
350 | } | |
351 | ||
8f54c7a4 | 352 | xchg(&ctx->error, 0); |
8e0969f0 | 353 | error = nfs_readpage_async(ctx, inode, page); |
8f54c7a4 TM |
354 | if (!error) { |
355 | error = wait_on_page_locked_killable(page); | |
356 | if (!PageUptodate(page) && !error) | |
357 | error = xchg(&ctx->error, 0); | |
358 | } | |
9a9fc1c0 | 359 | out: |
1da177e4 LT |
360 | put_nfs_open_context(ctx); |
361 | return error; | |
de05a0cc | 362 | out_unlock: |
1da177e4 LT |
363 | unlock_page(page); |
364 | return error; | |
365 | } | |
366 | ||
367 | struct nfs_readdesc { | |
8b09bee3 | 368 | struct nfs_pageio_descriptor *pgio; |
1da177e4 LT |
369 | struct nfs_open_context *ctx; |
370 | }; | |
371 | ||
372 | static int | |
373 | readpage_async_filler(void *data, struct page *page) | |
374 | { | |
375 | struct nfs_readdesc *desc = (struct nfs_readdesc *)data; | |
1da177e4 LT |
376 | struct nfs_page *new; |
377 | unsigned int len; | |
de05a0cc TM |
378 | int error; |
379 | ||
49a70f27 | 380 | len = nfs_page_length(page); |
1da177e4 LT |
381 | if (len == 0) |
382 | return nfs_return_empty_page(page); | |
de05a0cc | 383 | |
28b1d3f5 | 384 | new = nfs_create_request(desc->ctx, page, 0, len); |
de05a0cc TM |
385 | if (IS_ERR(new)) |
386 | goto out_error; | |
387 | ||
09cbfeaf KS |
388 | if (len < PAGE_SIZE) |
389 | zero_user_segment(page, len, PAGE_SIZE); | |
f8512ad0 | 390 | if (!nfs_pageio_add_request(desc->pgio, new)) { |
0bcbf039 | 391 | nfs_list_remove_request(new); |
f8512ad0 | 392 | error = desc->pgio->pg_error; |
8f54c7a4 | 393 | nfs_readpage_release(new, error); |
cbebaf89 | 394 | goto out; |
f8512ad0 | 395 | } |
1da177e4 | 396 | return 0; |
de05a0cc TM |
397 | out_error: |
398 | error = PTR_ERR(new); | |
de05a0cc | 399 | unlock_page(page); |
cbebaf89 | 400 | out: |
de05a0cc | 401 | return error; |
1da177e4 LT |
402 | } |
403 | ||
404 | int nfs_readpages(struct file *filp, struct address_space *mapping, | |
405 | struct list_head *pages, unsigned nr_pages) | |
406 | { | |
8b09bee3 | 407 | struct nfs_pageio_descriptor pgio; |
a7d42ddb | 408 | struct nfs_pgio_mirror *pgm; |
1da177e4 | 409 | struct nfs_readdesc desc = { |
8b09bee3 | 410 | .pgio = &pgio, |
1da177e4 LT |
411 | }; |
412 | struct inode *inode = mapping->host; | |
8b09bee3 | 413 | unsigned long npages; |
5f004cf2 | 414 | int ret = -ESTALE; |
1da177e4 | 415 | |
1e8968c5 | 416 | dprintk("NFS: nfs_readpages (%s/%Lu %d)\n", |
1da177e4 | 417 | inode->i_sb->s_id, |
1e8968c5 | 418 | (unsigned long long)NFS_FILEID(inode), |
1da177e4 | 419 | nr_pages); |
91d5b470 | 420 | nfs_inc_stats(inode, NFSIOS_VFSREADPAGES); |
1da177e4 | 421 | |
5f004cf2 TM |
422 | if (NFS_STALE(inode)) |
423 | goto out; | |
424 | ||
1da177e4 | 425 | if (filp == NULL) { |
d530838b | 426 | desc.ctx = nfs_find_open_context(inode, NULL, FMODE_READ); |
1da177e4 LT |
427 | if (desc.ctx == NULL) |
428 | return -EBADF; | |
429 | } else | |
cd3758e3 | 430 | desc.ctx = get_nfs_open_context(nfs_file_open_context(filp)); |
9a9fc1c0 DH |
431 | |
432 | /* attempt to read as many of the pages as possible from the cache | |
433 | * - this returns -ENOBUFS immediately if the cookie is negative | |
434 | */ | |
435 | ret = nfs_readpages_from_fscache(desc.ctx, inode, mapping, | |
436 | pages, &nr_pages); | |
437 | if (ret == 0) | |
438 | goto read_complete; /* all pages were read */ | |
439 | ||
fab5fc25 CH |
440 | nfs_pageio_init_read(&pgio, inode, false, |
441 | &nfs_async_read_completion_ops); | |
8b09bee3 | 442 | |
1da177e4 | 443 | ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc); |
8b09bee3 | 444 | nfs_pageio_complete(&pgio); |
a7d42ddb WAA |
445 | |
446 | /* It doesn't make sense to do mirrored reads! */ | |
447 | WARN_ON_ONCE(pgio.pg_mirror_count != 1); | |
448 | ||
449 | pgm = &pgio.pg_mirrors[0]; | |
450 | NFS_I(inode)->read_io += pgm->pg_bytes_written; | |
09cbfeaf KS |
451 | npages = (pgm->pg_bytes_written + PAGE_SIZE - 1) >> |
452 | PAGE_SHIFT; | |
8b09bee3 | 453 | nfs_add_stats(inode, NFSIOS_READPAGES, npages); |
9a9fc1c0 | 454 | read_complete: |
1da177e4 | 455 | put_nfs_open_context(desc.ctx); |
5f004cf2 | 456 | out: |
1da177e4 LT |
457 | return ret; |
458 | } | |
459 | ||
f7b422b1 | 460 | int __init nfs_init_readpagecache(void) |
1da177e4 LT |
461 | { |
462 | nfs_rdata_cachep = kmem_cache_create("nfs_read_data", | |
1e7f3a48 | 463 | sizeof(struct nfs_pgio_header), |
1da177e4 | 464 | 0, SLAB_HWCACHE_ALIGN, |
20c2df83 | 465 | NULL); |
1da177e4 LT |
466 | if (nfs_rdata_cachep == NULL) |
467 | return -ENOMEM; | |
468 | ||
1da177e4 LT |
469 | return 0; |
470 | } | |
471 | ||
266bee88 | 472 | void nfs_destroy_readpagecache(void) |
1da177e4 | 473 | { |
1a1d92c1 | 474 | kmem_cache_destroy(nfs_rdata_cachep); |
1da177e4 | 475 | } |
4a0de55c AS |
476 | |
477 | static const struct nfs_rw_ops nfs_rw_read_ops = { | |
478 | .rw_alloc_header = nfs_readhdr_alloc, | |
479 | .rw_free_header = nfs_readhdr_free, | |
0eecb214 AS |
480 | .rw_done = nfs_readpage_done, |
481 | .rw_result = nfs_readpage_result, | |
1ed26f33 | 482 | .rw_initiate = nfs_initiate_read, |
4a0de55c | 483 | }; |