Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/i2c-2.6
[linux-2.6] / fs / nfs / read.c
1 /*
2  * linux/fs/nfs/read.c
3  *
4  * Block I/O for NFS
5  *
6  * Partial copy of Linus' read cache modifications to fs/nfs/file.c
7  * modified for async RPC by okir@monad.swb.de
8  *
9  * We do an ugly hack here in order to return proper error codes to the
10  * user program when a read request failed: since generic_file_read
11  * only checks the return value of inode->i_op->readpage() which is always 0
12  * for async RPC, we set the error bit of the page to 1 when an error occurs,
13  * and make nfs_readpage transmit requests synchronously when encountering this.
14  * This is only a small problem, though, since we now retry all operations
15  * within the RPC code when root squashing is suspected.
16  */
17
18 #include <linux/config.h>
19 #include <linux/time.h>
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/fcntl.h>
23 #include <linux/stat.h>
24 #include <linux/mm.h>
25 #include <linux/slab.h>
26 #include <linux/pagemap.h>
27 #include <linux/sunrpc/clnt.h>
28 #include <linux/nfs_fs.h>
29 #include <linux/nfs_page.h>
30 #include <linux/smp_lock.h>
31
32 #include <asm/system.h>
33
34 #define NFSDBG_FACILITY         NFSDBG_PAGECACHE
35
36 static int nfs_pagein_one(struct list_head *, struct inode *);
37 static void nfs_readpage_result_partial(struct nfs_read_data *, int);
38 static void nfs_readpage_result_full(struct nfs_read_data *, int);
39
40 static kmem_cache_t *nfs_rdata_cachep;
41 mempool_t *nfs_rdata_mempool;
42
43 #define MIN_POOL_READ   (32)
44
45 void nfs_readdata_release(void *data)
46 {
47         nfs_readdata_free(data);
48 }
49
50 static
51 unsigned int nfs_page_length(struct inode *inode, struct page *page)
52 {
53         loff_t i_size = i_size_read(inode);
54         unsigned long idx;
55
56         if (i_size <= 0)
57                 return 0;
58         idx = (i_size - 1) >> PAGE_CACHE_SHIFT;
59         if (page->index > idx)
60                 return 0;
61         if (page->index != idx)
62                 return PAGE_CACHE_SIZE;
63         return 1 + ((i_size - 1) & (PAGE_CACHE_SIZE - 1));
64 }
65
66 static
67 int nfs_return_empty_page(struct page *page)
68 {
69         memclear_highpage_flush(page, 0, PAGE_CACHE_SIZE);
70         SetPageUptodate(page);
71         unlock_page(page);
72         return 0;
73 }
74
75 /*
76  * Read a page synchronously.
77  */
78 static int nfs_readpage_sync(struct nfs_open_context *ctx, struct inode *inode,
79                 struct page *page)
80 {
81         unsigned int    rsize = NFS_SERVER(inode)->rsize;
82         unsigned int    count = PAGE_CACHE_SIZE;
83         int             result;
84         struct nfs_read_data *rdata;
85
86         rdata = nfs_readdata_alloc(1);
87         if (!rdata)
88                 return -ENOMEM;
89
90         memset(rdata, 0, sizeof(*rdata));
91         rdata->flags = (IS_SWAPFILE(inode)? NFS_RPC_SWAPFLAGS : 0);
92         rdata->cred = ctx->cred;
93         rdata->inode = inode;
94         INIT_LIST_HEAD(&rdata->pages);
95         rdata->args.fh = NFS_FH(inode);
96         rdata->args.context = ctx;
97         rdata->args.pages = &page;
98         rdata->args.pgbase = 0UL;
99         rdata->args.count = rsize;
100         rdata->res.fattr = &rdata->fattr;
101
102         dprintk("NFS: nfs_readpage_sync(%p)\n", page);
103
104         /*
105          * This works now because the socket layer never tries to DMA
106          * into this buffer directly.
107          */
108         do {
109                 if (count < rsize)
110                         rdata->args.count = count;
111                 rdata->res.count = rdata->args.count;
112                 rdata->args.offset = page_offset(page) + rdata->args.pgbase;
113
114                 dprintk("NFS: nfs_proc_read(%s, (%s/%Ld), %Lu, %u)\n",
115                         NFS_SERVER(inode)->hostname,
116                         inode->i_sb->s_id,
117                         (long long)NFS_FILEID(inode),
118                         (unsigned long long)rdata->args.pgbase,
119                         rdata->args.count);
120
121                 lock_kernel();
122                 result = NFS_PROTO(inode)->read(rdata);
123                 unlock_kernel();
124
125                 /*
126                  * Even if we had a partial success we can't mark the page
127                  * cache valid.
128                  */
129                 if (result < 0) {
130                         if (result == -EISDIR)
131                                 result = -EINVAL;
132                         goto io_error;
133                 }
134                 count -= result;
135                 rdata->args.pgbase += result;
136                 /* Note: result == 0 should only happen if we're caching
137                  * a write that extends the file and punches a hole.
138                  */
139                 if (rdata->res.eof != 0 || result == 0)
140                         break;
141         } while (count);
142         spin_lock(&inode->i_lock);
143         NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
144         spin_unlock(&inode->i_lock);
145
146         if (count)
147                 memclear_highpage_flush(page, rdata->args.pgbase, count);
148         SetPageUptodate(page);
149         if (PageError(page))
150                 ClearPageError(page);
151         result = 0;
152
153 io_error:
154         unlock_page(page);
155         nfs_readdata_free(rdata);
156         return result;
157 }
158
159 static int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
160                 struct page *page)
161 {
162         LIST_HEAD(one_request);
163         struct nfs_page *new;
164         unsigned int len;
165
166         len = nfs_page_length(inode, page);
167         if (len == 0)
168                 return nfs_return_empty_page(page);
169         new = nfs_create_request(ctx, inode, page, 0, len);
170         if (IS_ERR(new)) {
171                 unlock_page(page);
172                 return PTR_ERR(new);
173         }
174         if (len < PAGE_CACHE_SIZE)
175                 memclear_highpage_flush(page, len, PAGE_CACHE_SIZE - len);
176
177         nfs_list_add_request(new, &one_request);
178         nfs_pagein_one(&one_request, inode);
179         return 0;
180 }
181
182 static void nfs_readpage_release(struct nfs_page *req)
183 {
184         unlock_page(req->wb_page);
185
186         dprintk("NFS: read done (%s/%Ld %d@%Ld)\n",
187                         req->wb_context->dentry->d_inode->i_sb->s_id,
188                         (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
189                         req->wb_bytes,
190                         (long long)req_offset(req));
191         nfs_clear_request(req);
192         nfs_release_request(req);
193 }
194
195 /*
196  * Set up the NFS read request struct
197  */
198 static void nfs_read_rpcsetup(struct nfs_page *req, struct nfs_read_data *data,
199                 unsigned int count, unsigned int offset)
200 {
201         struct inode            *inode;
202
203         data->req         = req;
204         data->inode       = inode = req->wb_context->dentry->d_inode;
205         data->cred        = req->wb_context->cred;
206
207         data->args.fh     = NFS_FH(inode);
208         data->args.offset = req_offset(req) + offset;
209         data->args.pgbase = req->wb_pgbase + offset;
210         data->args.pages  = data->pagevec;
211         data->args.count  = count;
212         data->args.context = req->wb_context;
213
214         data->res.fattr   = &data->fattr;
215         data->res.count   = count;
216         data->res.eof     = 0;
217         nfs_fattr_init(&data->fattr);
218
219         NFS_PROTO(inode)->read_setup(data);
220
221         data->task.tk_cookie = (unsigned long)inode;
222
223         dprintk("NFS: %4d initiated read call (req %s/%Ld, %u bytes @ offset %Lu)\n",
224                         data->task.tk_pid,
225                         inode->i_sb->s_id,
226                         (long long)NFS_FILEID(inode),
227                         count,
228                         (unsigned long long)data->args.offset);
229 }
230
231 static void
232 nfs_async_read_error(struct list_head *head)
233 {
234         struct nfs_page *req;
235
236         while (!list_empty(head)) {
237                 req = nfs_list_entry(head->next);
238                 nfs_list_remove_request(req);
239                 SetPageError(req->wb_page);
240                 nfs_readpage_release(req);
241         }
242 }
243
244 /*
245  * Start an async read operation
246  */
247 static void nfs_execute_read(struct nfs_read_data *data)
248 {
249         struct rpc_clnt *clnt = NFS_CLIENT(data->inode);
250         sigset_t oldset;
251
252         rpc_clnt_sigmask(clnt, &oldset);
253         lock_kernel();
254         rpc_execute(&data->task);
255         unlock_kernel();
256         rpc_clnt_sigunmask(clnt, &oldset);
257 }
258
259 /*
260  * Generate multiple requests to fill a single page.
261  *
262  * We optimize to reduce the number of read operations on the wire.  If we
263  * detect that we're reading a page, or an area of a page, that is past the
264  * end of file, we do not generate NFS read operations but just clear the
265  * parts of the page that would have come back zero from the server anyway.
266  *
267  * We rely on the cached value of i_size to make this determination; another
268  * client can fill pages on the server past our cached end-of-file, but we
269  * won't see the new data until our attribute cache is updated.  This is more
270  * or less conventional NFS client behavior.
271  */
272 static int nfs_pagein_multi(struct list_head *head, struct inode *inode)
273 {
274         struct nfs_page *req = nfs_list_entry(head->next);
275         struct page *page = req->wb_page;
276         struct nfs_read_data *data;
277         unsigned int rsize = NFS_SERVER(inode)->rsize;
278         unsigned int nbytes, offset;
279         int requests = 0;
280         LIST_HEAD(list);
281
282         nfs_list_remove_request(req);
283
284         nbytes = req->wb_bytes;
285         for(;;) {
286                 data = nfs_readdata_alloc(1);
287                 if (!data)
288                         goto out_bad;
289                 INIT_LIST_HEAD(&data->pages);
290                 list_add(&data->pages, &list);
291                 requests++;
292                 if (nbytes <= rsize)
293                         break;
294                 nbytes -= rsize;
295         }
296         atomic_set(&req->wb_complete, requests);
297
298         ClearPageError(page);
299         offset = 0;
300         nbytes = req->wb_bytes;
301         do {
302                 data = list_entry(list.next, struct nfs_read_data, pages);
303                 list_del_init(&data->pages);
304
305                 data->pagevec[0] = page;
306                 data->complete = nfs_readpage_result_partial;
307
308                 if (nbytes > rsize) {
309                         nfs_read_rpcsetup(req, data, rsize, offset);
310                         offset += rsize;
311                         nbytes -= rsize;
312                 } else {
313                         nfs_read_rpcsetup(req, data, nbytes, offset);
314                         nbytes = 0;
315                 }
316                 nfs_execute_read(data);
317         } while (nbytes != 0);
318
319         return 0;
320
321 out_bad:
322         while (!list_empty(&list)) {
323                 data = list_entry(list.next, struct nfs_read_data, pages);
324                 list_del(&data->pages);
325                 nfs_readdata_free(data);
326         }
327         SetPageError(page);
328         nfs_readpage_release(req);
329         return -ENOMEM;
330 }
331
332 static int nfs_pagein_one(struct list_head *head, struct inode *inode)
333 {
334         struct nfs_page         *req;
335         struct page             **pages;
336         struct nfs_read_data    *data;
337         unsigned int            count;
338
339         if (NFS_SERVER(inode)->rsize < PAGE_CACHE_SIZE)
340                 return nfs_pagein_multi(head, inode);
341
342         data = nfs_readdata_alloc(NFS_SERVER(inode)->rpages);
343         if (!data)
344                 goto out_bad;
345
346         INIT_LIST_HEAD(&data->pages);
347         pages = data->pagevec;
348         count = 0;
349         while (!list_empty(head)) {
350                 req = nfs_list_entry(head->next);
351                 nfs_list_remove_request(req);
352                 nfs_list_add_request(req, &data->pages);
353                 ClearPageError(req->wb_page);
354                 *pages++ = req->wb_page;
355                 count += req->wb_bytes;
356         }
357         req = nfs_list_entry(data->pages.next);
358
359         data->complete = nfs_readpage_result_full;
360         nfs_read_rpcsetup(req, data, count, 0);
361
362         nfs_execute_read(data);
363         return 0;
364 out_bad:
365         nfs_async_read_error(head);
366         return -ENOMEM;
367 }
368
369 static int
370 nfs_pagein_list(struct list_head *head, int rpages)
371 {
372         LIST_HEAD(one_request);
373         struct nfs_page         *req;
374         int                     error = 0;
375         unsigned int            pages = 0;
376
377         while (!list_empty(head)) {
378                 pages += nfs_coalesce_requests(head, &one_request, rpages);
379                 req = nfs_list_entry(one_request.next);
380                 error = nfs_pagein_one(&one_request, req->wb_context->dentry->d_inode);
381                 if (error < 0)
382                         break;
383         }
384         if (error >= 0)
385                 return pages;
386
387         nfs_async_read_error(head);
388         return error;
389 }
390
391 /*
392  * Handle a read reply that fills part of a page.
393  */
394 static void nfs_readpage_result_partial(struct nfs_read_data *data, int status)
395 {
396         struct nfs_page *req = data->req;
397         struct page *page = req->wb_page;
398  
399         if (status >= 0) {
400                 unsigned int request = data->args.count;
401                 unsigned int result = data->res.count;
402
403                 if (result < request) {
404                         memclear_highpage_flush(page,
405                                                 data->args.pgbase + result,
406                                                 request - result);
407                 }
408         } else
409                 SetPageError(page);
410
411         if (atomic_dec_and_test(&req->wb_complete)) {
412                 if (!PageError(page))
413                         SetPageUptodate(page);
414                 nfs_readpage_release(req);
415         }
416 }
417
418 /*
419  * This is the callback from RPC telling us whether a reply was
420  * received or some error occurred (timeout or socket shutdown).
421  */
422 static void nfs_readpage_result_full(struct nfs_read_data *data, int status)
423 {
424         unsigned int count = data->res.count;
425
426         while (!list_empty(&data->pages)) {
427                 struct nfs_page *req = nfs_list_entry(data->pages.next);
428                 struct page *page = req->wb_page;
429                 nfs_list_remove_request(req);
430
431                 if (status >= 0) {
432                         if (count < PAGE_CACHE_SIZE) {
433                                 if (count < req->wb_bytes)
434                                         memclear_highpage_flush(page,
435                                                         req->wb_pgbase + count,
436                                                         req->wb_bytes - count);
437                                 count = 0;
438                         } else
439                                 count -= PAGE_CACHE_SIZE;
440                         SetPageUptodate(page);
441                 } else
442                         SetPageError(page);
443                 nfs_readpage_release(req);
444         }
445 }
446
447 /*
448  * This is the callback from RPC telling us whether a reply was
449  * received or some error occurred (timeout or socket shutdown).
450  */
451 void nfs_readpage_result(struct rpc_task *task, void *calldata)
452 {
453         struct nfs_read_data *data = calldata;
454         struct nfs_readargs *argp = &data->args;
455         struct nfs_readres *resp = &data->res;
456         int status = task->tk_status;
457
458         dprintk("NFS: %4d nfs_readpage_result, (status %d)\n",
459                 task->tk_pid, status);
460
461         /* Is this a short read? */
462         if (task->tk_status >= 0 && resp->count < argp->count && !resp->eof) {
463                 /* Has the server at least made some progress? */
464                 if (resp->count != 0) {
465                         /* Yes, so retry the read at the end of the data */
466                         argp->offset += resp->count;
467                         argp->pgbase += resp->count;
468                         argp->count -= resp->count;
469                         rpc_restart_call(task);
470                         return;
471                 }
472                 task->tk_status = -EIO;
473         }
474         spin_lock(&data->inode->i_lock);
475         NFS_I(data->inode)->cache_validity |= NFS_INO_INVALID_ATIME;
476         spin_unlock(&data->inode->i_lock);
477         data->complete(data, status);
478 }
479
480 /*
481  * Read a page over NFS.
482  * We read the page synchronously in the following case:
483  *  -   The error flag is set for this page. This happens only when a
484  *      previous async read operation failed.
485  */
486 int nfs_readpage(struct file *file, struct page *page)
487 {
488         struct nfs_open_context *ctx;
489         struct inode *inode = page->mapping->host;
490         int             error;
491
492         dprintk("NFS: nfs_readpage (%p %ld@%lu)\n",
493                 page, PAGE_CACHE_SIZE, page->index);
494         /*
495          * Try to flush any pending writes to the file..
496          *
497          * NOTE! Because we own the page lock, there cannot
498          * be any new pending writes generated at this point
499          * for this page (other pages can be written to).
500          */
501         error = nfs_wb_page(inode, page);
502         if (error)
503                 goto out_error;
504
505         if (file == NULL) {
506                 ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
507                 if (ctx == NULL)
508                         return -EBADF;
509         } else
510                 ctx = get_nfs_open_context((struct nfs_open_context *)
511                                 file->private_data);
512         if (!IS_SYNC(inode)) {
513                 error = nfs_readpage_async(ctx, inode, page);
514                 goto out;
515         }
516
517         error = nfs_readpage_sync(ctx, inode, page);
518         if (error < 0 && IS_SWAPFILE(inode))
519                 printk("Aiee.. nfs swap-in of page failed!\n");
520 out:
521         put_nfs_open_context(ctx);
522         return error;
523
524 out_error:
525         unlock_page(page);
526         return error;
527 }
528
529 struct nfs_readdesc {
530         struct list_head *head;
531         struct nfs_open_context *ctx;
532 };
533
534 static int
535 readpage_async_filler(void *data, struct page *page)
536 {
537         struct nfs_readdesc *desc = (struct nfs_readdesc *)data;
538         struct inode *inode = page->mapping->host;
539         struct nfs_page *new;
540         unsigned int len;
541
542         nfs_wb_page(inode, page);
543         len = nfs_page_length(inode, page);
544         if (len == 0)
545                 return nfs_return_empty_page(page);
546         new = nfs_create_request(desc->ctx, inode, page, 0, len);
547         if (IS_ERR(new)) {
548                         SetPageError(page);
549                         unlock_page(page);
550                         return PTR_ERR(new);
551         }
552         if (len < PAGE_CACHE_SIZE)
553                 memclear_highpage_flush(page, len, PAGE_CACHE_SIZE - len);
554         nfs_list_add_request(new, desc->head);
555         return 0;
556 }
557
558 int nfs_readpages(struct file *filp, struct address_space *mapping,
559                 struct list_head *pages, unsigned nr_pages)
560 {
561         LIST_HEAD(head);
562         struct nfs_readdesc desc = {
563                 .head           = &head,
564         };
565         struct inode *inode = mapping->host;
566         struct nfs_server *server = NFS_SERVER(inode);
567         int ret;
568
569         dprintk("NFS: nfs_readpages (%s/%Ld %d)\n",
570                         inode->i_sb->s_id,
571                         (long long)NFS_FILEID(inode),
572                         nr_pages);
573
574         if (filp == NULL) {
575                 desc.ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
576                 if (desc.ctx == NULL)
577                         return -EBADF;
578         } else
579                 desc.ctx = get_nfs_open_context((struct nfs_open_context *)
580                                 filp->private_data);
581         ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);
582         if (!list_empty(&head)) {
583                 int err = nfs_pagein_list(&head, server->rpages);
584                 if (!ret)
585                         ret = err;
586         }
587         put_nfs_open_context(desc.ctx);
588         return ret;
589 }
590
591 int nfs_init_readpagecache(void)
592 {
593         nfs_rdata_cachep = kmem_cache_create("nfs_read_data",
594                                              sizeof(struct nfs_read_data),
595                                              0, SLAB_HWCACHE_ALIGN,
596                                              NULL, NULL);
597         if (nfs_rdata_cachep == NULL)
598                 return -ENOMEM;
599
600         nfs_rdata_mempool = mempool_create(MIN_POOL_READ,
601                                            mempool_alloc_slab,
602                                            mempool_free_slab,
603                                            nfs_rdata_cachep);
604         if (nfs_rdata_mempool == NULL)
605                 return -ENOMEM;
606
607         return 0;
608 }
609
610 void nfs_destroy_readpagecache(void)
611 {
612         mempool_destroy(nfs_rdata_mempool);
613         if (kmem_cache_destroy(nfs_rdata_cachep))
614                 printk(KERN_INFO "nfs_read_data: not all structures were freed\n");
615 }