Branch data Line data Source code
1 : : /*
2 : : * linux/fs/nfs/direct.c
3 : : *
4 : : * Copyright (C) 2003 by Chuck Lever <cel@netapp.com>
5 : : *
6 : : * High-performance uncached I/O for the Linux NFS client
7 : : *
8 : : * There are important applications whose performance or correctness
9 : : * depends on uncached access to file data. Database clusters
10 : : * (multiple copies of the same instance running on separate hosts)
11 : : * implement their own cache coherency protocol that subsumes file
12 : : * system cache protocols. Applications that process datasets
13 : : * considerably larger than the client's memory do not always benefit
14 : : * from a local cache. A streaming video server, for instance, has no
15 : : * need to cache the contents of a file.
16 : : *
17 : : * When an application requests uncached I/O, all read and write requests
18 : : * are made directly to the server; data stored or fetched via these
19 : : * requests is not cached in the Linux page cache. The client does not
20 : : * correct unaligned requests from applications. All requested bytes are
21 : : * held on permanent storage before a direct write system call returns to
22 : : * an application.
23 : : *
24 : : * Solaris implements an uncached I/O facility called directio() that
25 : : * is used for backups and sequential I/O to very large files. Solaris
26 : : * also supports uncaching whole NFS partitions with "-o forcedirectio,"
27 : : * an undocumented mount option.
28 : : *
29 : : * Designed by Jeff Kimmel, Chuck Lever, and Trond Myklebust, with
30 : : * help from Andrew Morton.
31 : : *
32 : : * 18 Dec 2001 Initial implementation for 2.4 --cel
33 : : * 08 Jul 2002 Version for 2.4.19, with bug fixes --trondmy
34 : : * 08 Jun 2003 Port to 2.5 APIs --cel
35 : : * 31 Mar 2004 Handle direct I/O without VFS support --cel
36 : : * 15 Sep 2004 Parallel async reads --cel
37 : : * 04 May 2005 support O_DIRECT with aio --cel
38 : : *
39 : : */
40 : :
41 : : #include <linux/errno.h>
42 : : #include <linux/sched.h>
43 : : #include <linux/kernel.h>
44 : : #include <linux/file.h>
45 : : #include <linux/pagemap.h>
46 : : #include <linux/kref.h>
47 : : #include <linux/slab.h>
48 : : #include <linux/task_io_accounting_ops.h>
49 : : #include <linux/module.h>
50 : :
51 : : #include <linux/nfs_fs.h>
52 : : #include <linux/nfs_page.h>
53 : : #include <linux/sunrpc/clnt.h>
54 : :
55 : : #include <asm/uaccess.h>
56 : : #include <linux/atomic.h>
57 : :
58 : : #include "internal.h"
59 : : #include "iostat.h"
60 : : #include "pnfs.h"
61 : :
62 : : #define NFSDBG_FACILITY NFSDBG_VFS
63 : :
64 : : static struct kmem_cache *nfs_direct_cachep;
65 : :
66 : : /*
67 : : * This represents a set of asynchronous requests that we're waiting on
68 : : */
69 : : struct nfs_direct_req {
70 : : struct kref kref; /* release manager */
71 : :
72 : : /* I/O parameters */
73 : : struct nfs_open_context *ctx; /* file open context info */
74 : : struct nfs_lock_context *l_ctx; /* Lock context info */
75 : : struct kiocb * iocb; /* controlling i/o request */
76 : : struct inode * inode; /* target file of i/o */
77 : :
78 : : /* completion state */
79 : : atomic_t io_count; /* i/os we're waiting for */
80 : : spinlock_t lock; /* protect completion state */
81 : : ssize_t count, /* bytes actually processed */
82 : : bytes_left, /* bytes left to be sent */
83 : : error; /* any reported error */
84 : : struct completion completion; /* wait for i/o completion */
85 : :
86 : : /* commit state */
87 : : struct nfs_mds_commit_info mds_cinfo; /* Storage for cinfo */
88 : : struct pnfs_ds_commit_info ds_cinfo; /* Storage for cinfo */
89 : : struct work_struct work;
90 : : int flags;
91 : : #define NFS_ODIRECT_DO_COMMIT (1) /* an unstable reply was received */
92 : : #define NFS_ODIRECT_RESCHED_WRITES (2) /* write verification failed */
93 : : struct nfs_writeverf verf; /* unstable write verifier */
94 : : };
95 : :
96 : : static const struct nfs_pgio_completion_ops nfs_direct_write_completion_ops;
97 : : static const struct nfs_commit_completion_ops nfs_direct_commit_completion_ops;
98 : : static void nfs_direct_write_complete(struct nfs_direct_req *dreq, struct inode *inode);
99 : : static void nfs_direct_write_schedule_work(struct work_struct *work);
100 : :
101 : : static inline void get_dreq(struct nfs_direct_req *dreq)
102 : : {
103 : 0 : atomic_inc(&dreq->io_count);
104 : : }
105 : :
106 : : static inline int put_dreq(struct nfs_direct_req *dreq)
107 : : {
108 : 0 : return atomic_dec_and_test(&dreq->io_count);
109 : : }
110 : :
111 : : /**
112 : : * nfs_direct_IO - NFS address space operation for direct I/O
113 : : * @rw: direction (read or write)
114 : : * @iocb: target I/O control block
115 : : * @iov: array of vectors that define I/O buffer
116 : : * @pos: offset in file to begin the operation
117 : : * @nr_segs: size of iovec array
118 : : *
119 : : * The presence of this routine in the address space ops vector means
120 : : * the NFS client supports direct I/O. However, for most direct IO, we
121 : : * shunt off direct read and write requests before the VFS gets them,
122 : : * so this method is only ever called for swap.
123 : : */
124 : 0 : ssize_t nfs_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, loff_t pos, unsigned long nr_segs)
125 : : {
126 : : #ifndef CONFIG_NFS_SWAP
127 : : dprintk("NFS: nfs_direct_IO (%pD) off/no(%Ld/%lu) EINVAL\n",
128 : : iocb->ki_filp, (long long) pos, nr_segs);
129 : :
130 : 0 : return -EINVAL;
131 : : #else
132 : : VM_BUG_ON(iocb->ki_nbytes != PAGE_SIZE);
133 : :
134 : : if (rw == READ || rw == KERNEL_READ)
135 : : return nfs_file_direct_read(iocb, iov, nr_segs, pos,
136 : : rw == READ ? true : false);
137 : : return nfs_file_direct_write(iocb, iov, nr_segs, pos,
138 : : rw == WRITE ? true : false);
139 : : #endif /* CONFIG_NFS_SWAP */
140 : : }
141 : :
142 : : static void nfs_direct_release_pages(struct page **pages, unsigned int npages)
143 : : {
144 : : unsigned int i;
145 [ # # ][ # # ]: 0 : for (i = 0; i < npages; i++)
[ # # ][ # # ]
146 : 0 : page_cache_release(pages[i]);
147 : : }
148 : :
149 : 0 : void nfs_init_cinfo_from_dreq(struct nfs_commit_info *cinfo,
150 : : struct nfs_direct_req *dreq)
151 : : {
152 : 0 : cinfo->lock = &dreq->lock;
153 : 0 : cinfo->mds = &dreq->mds_cinfo;
154 : 0 : cinfo->ds = &dreq->ds_cinfo;
155 : 0 : cinfo->dreq = dreq;
156 : 0 : cinfo->completion_ops = &nfs_direct_commit_completion_ops;
157 : 0 : }
158 : :
159 : : static inline struct nfs_direct_req *nfs_direct_req_alloc(void)
160 : : {
161 : : struct nfs_direct_req *dreq;
162 : :
163 : 0 : dreq = kmem_cache_zalloc(nfs_direct_cachep, GFP_KERNEL);
164 [ # # # # ]: 0 : if (!dreq)
165 : : return NULL;
166 : :
167 : : kref_init(&dreq->kref);
168 : : kref_get(&dreq->kref);
169 : : init_completion(&dreq->completion);
170 : 0 : INIT_LIST_HEAD(&dreq->mds_cinfo.list);
171 : 0 : INIT_WORK(&dreq->work, nfs_direct_write_schedule_work);
172 : 0 : spin_lock_init(&dreq->lock);
173 : :
174 : : return dreq;
175 : : }
176 : :
177 : 0 : static void nfs_direct_req_free(struct kref *kref)
178 : : {
179 : : struct nfs_direct_req *dreq = container_of(kref, struct nfs_direct_req, kref);
180 : :
181 [ # # ]: 0 : if (dreq->l_ctx != NULL)
182 : 0 : nfs_put_lock_context(dreq->l_ctx);
183 [ # # ]: 0 : if (dreq->ctx != NULL)
184 : 0 : put_nfs_open_context(dreq->ctx);
185 : 0 : kmem_cache_free(nfs_direct_cachep, dreq);
186 : 0 : }
187 : :
188 : 0 : static void nfs_direct_req_release(struct nfs_direct_req *dreq)
189 : : {
190 : 0 : kref_put(&dreq->kref, nfs_direct_req_free);
191 : 0 : }
192 : :
193 : 0 : ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq)
194 : : {
195 : 0 : return dreq->bytes_left;
196 : : }
197 : : EXPORT_SYMBOL_GPL(nfs_dreq_bytes_left);
198 : :
199 : : /*
200 : : * Collects and returns the final error value/byte-count.
201 : : */
202 : 0 : static ssize_t nfs_direct_wait(struct nfs_direct_req *dreq)
203 : : {
204 : : ssize_t result = -EIOCBQUEUED;
205 : :
206 : : /* Async requests don't wait here */
207 [ # # ]: 0 : if (dreq->iocb)
208 : : goto out;
209 : :
210 : 0 : result = wait_for_completion_killable(&dreq->completion);
211 : :
212 [ # # ]: 0 : if (!result)
213 : 0 : result = dreq->error;
214 [ # # ]: 0 : if (!result)
215 : 0 : result = dreq->count;
216 : :
217 : : out:
218 : 0 : return (ssize_t) result;
219 : : }
220 : :
221 : : /*
222 : : * Synchronous I/O uses a stack-allocated iocb. Thus we can't trust
223 : : * the iocb is still valid here if this is a synchronous request.
224 : : */
225 : 0 : static void nfs_direct_complete(struct nfs_direct_req *dreq, bool write)
226 : : {
227 : 0 : struct inode *inode = dreq->inode;
228 : :
229 [ # # ][ # # ]: 0 : if (dreq->iocb && write) {
230 : 0 : loff_t pos = dreq->iocb->ki_pos + dreq->count;
231 : :
232 : : spin_lock(&inode->i_lock);
233 [ # # ]: 0 : if (i_size_read(inode) < pos)
234 : : i_size_write(inode, pos);
235 : : spin_unlock(&inode->i_lock);
236 : : }
237 : :
238 [ # # ]: 0 : if (write)
239 : 0 : nfs_zap_mapping(inode, inode->i_mapping);
240 : :
241 : 0 : inode_dio_done(inode);
242 : :
243 [ # # ]: 0 : if (dreq->iocb) {
244 : 0 : long res = (long) dreq->error;
245 [ # # ]: 0 : if (!res)
246 : 0 : res = (long) dreq->count;
247 : 0 : aio_complete(dreq->iocb, res, 0);
248 : : }
249 : :
250 : 0 : complete_all(&dreq->completion);
251 : :
252 : 0 : nfs_direct_req_release(dreq);
253 : 0 : }
254 : :
255 : : static void nfs_direct_readpage_release(struct nfs_page *req)
256 : : {
257 : : dprintk("NFS: direct read done (%s/%llu %d@%lld)\n",
258 : : req->wb_context->dentry->d_inode->i_sb->s_id,
259 : : (unsigned long long)NFS_FILEID(req->wb_context->dentry->d_inode),
260 : : req->wb_bytes,
261 : : (long long)req_offset(req));
262 : 0 : nfs_release_request(req);
263 : : }
264 : :
265 : 0 : static void nfs_direct_read_completion(struct nfs_pgio_header *hdr)
266 : : {
267 : : unsigned long bytes = 0;
268 : 0 : struct nfs_direct_req *dreq = hdr->dreq;
269 : :
270 [ # # ]: 0 : if (test_bit(NFS_IOHDR_REDO, &hdr->flags))
271 : : goto out_put;
272 : :
273 : : spin_lock(&dreq->lock);
274 [ # # ][ # # ]: 0 : if (test_bit(NFS_IOHDR_ERROR, &hdr->flags) && (hdr->good_bytes == 0))
275 : 0 : dreq->error = hdr->error;
276 : : else
277 : 0 : dreq->count += hdr->good_bytes;
278 : : spin_unlock(&dreq->lock);
279 : :
280 [ # # ]: 0 : while (!list_empty(&hdr->pages)) {
281 : : struct nfs_page *req = nfs_list_entry(hdr->pages.next);
282 : 0 : struct page *page = req->wb_page;
283 : :
284 [ # # ][ # # ]: 0 : if (!PageCompound(page) && bytes < hdr->good_bytes)
285 : 0 : set_page_dirty(page);
286 : 0 : bytes += req->wb_bytes;
287 : : nfs_list_remove_request(req);
288 : : nfs_direct_readpage_release(req);
289 : : }
290 : : out_put:
291 [ # # ]: 0 : if (put_dreq(dreq))
292 : 0 : nfs_direct_complete(dreq, false);
293 : 0 : hdr->release(hdr);
294 : 0 : }
295 : :
296 : 0 : static void nfs_read_sync_pgio_error(struct list_head *head)
297 : : {
298 : : struct nfs_page *req;
299 : :
300 [ # # ]: 0 : while (!list_empty(head)) {
301 : : req = nfs_list_entry(head->next);
302 : : nfs_list_remove_request(req);
303 : 0 : nfs_release_request(req);
304 : : }
305 : 0 : }
306 : :
307 : 0 : static void nfs_direct_pgio_init(struct nfs_pgio_header *hdr)
308 : : {
309 : 0 : get_dreq(hdr->dreq);
310 : 0 : }
311 : :
312 : : static const struct nfs_pgio_completion_ops nfs_direct_read_completion_ops = {
313 : : .error_cleanup = nfs_read_sync_pgio_error,
314 : : .init_hdr = nfs_direct_pgio_init,
315 : : .completion = nfs_direct_read_completion,
316 : : };
317 : :
318 : : /*
319 : : * For each rsize'd chunk of the user's buffer, dispatch an NFS READ
320 : : * operation. If nfs_readdata_alloc() or get_user_pages() fails,
321 : : * bail and stop sending more reads. Read length accounting is
322 : : * handled automatically by nfs_direct_read_result(). Otherwise, if
323 : : * no requests have been sent, just return an error.
324 : : */
325 : 0 : static ssize_t nfs_direct_read_schedule_segment(struct nfs_pageio_descriptor *desc,
326 : : const struct iovec *iov,
327 : : loff_t pos, bool uio)
328 : : {
329 : 0 : struct nfs_direct_req *dreq = desc->pg_dreq;
330 : 0 : struct nfs_open_context *ctx = dreq->ctx;
331 : 0 : struct inode *inode = ctx->dentry->d_inode;
332 : 0 : unsigned long user_addr = (unsigned long)iov->iov_base;
333 : 0 : size_t count = iov->iov_len;
334 : 0 : size_t rsize = NFS_SERVER(inode)->rsize;
335 : : unsigned int pgbase;
336 : : int result;
337 : : ssize_t started = 0;
338 : : struct page **pagevec = NULL;
339 : : unsigned int npages;
340 : :
341 : : do {
342 : : size_t bytes;
343 : : int i;
344 : :
345 : 0 : pgbase = user_addr & ~PAGE_MASK;
346 : 0 : bytes = min(max_t(size_t, rsize, PAGE_SIZE), count);
347 : :
348 : : result = -ENOMEM;
349 : : npages = nfs_page_array_len(pgbase, bytes);
350 [ # # ]: 0 : if (!pagevec)
351 : 0 : pagevec = kmalloc(npages * sizeof(struct page *),
352 : : GFP_KERNEL);
353 [ # # ]: 0 : if (!pagevec)
354 : : break;
355 [ # # ]: 0 : if (uio) {
356 : 0 : down_read(¤t->mm->mmap_sem);
357 : 0 : result = get_user_pages(current, current->mm, user_addr,
358 : : npages, 1, 0, pagevec, NULL);
359 : 0 : up_read(¤t->mm->mmap_sem);
360 [ # # ]: 0 : if (result < 0)
361 : : break;
362 : : } else {
363 [ # # ]: 0 : WARN_ON(npages != 1);
364 : 0 : result = get_kernel_page(user_addr, 1, pagevec);
365 [ # # ][ # # ]: 0 : if (WARN_ON(result != 1))
366 : : break;
367 : : }
368 : :
369 [ # # ]: 0 : if ((unsigned)result < npages) {
370 : 0 : bytes = result * PAGE_SIZE;
371 [ # # ]: 0 : if (bytes <= pgbase) {
372 : : nfs_direct_release_pages(pagevec, result);
373 : : break;
374 : : }
375 : 0 : bytes -= pgbase;
376 : : npages = result;
377 : : }
378 : :
379 [ # # ]: 0 : for (i = 0; i < npages; i++) {
380 : : struct nfs_page *req;
381 : 0 : unsigned int req_len = min_t(size_t, bytes, PAGE_SIZE - pgbase);
382 : : /* XXX do we need to do the eof zeroing found in async_filler? */
383 : 0 : req = nfs_create_request(dreq->ctx, dreq->inode,
384 : 0 : pagevec[i],
385 : : pgbase, req_len);
386 [ # # ]: 0 : if (IS_ERR(req)) {
387 : : result = PTR_ERR(req);
388 : 0 : break;
389 : : }
390 : 0 : req->wb_index = pos >> PAGE_SHIFT;
391 : 0 : req->wb_offset = pos & ~PAGE_MASK;
392 [ # # ]: 0 : if (!nfs_pageio_add_request(desc, req)) {
393 : 0 : result = desc->pg_error;
394 : 0 : nfs_release_request(req);
395 : 0 : break;
396 : : }
397 : : pgbase = 0;
398 : 0 : bytes -= req_len;
399 : 0 : started += req_len;
400 : 0 : user_addr += req_len;
401 : 0 : pos += req_len;
402 : 0 : count -= req_len;
403 : 0 : dreq->bytes_left -= req_len;
404 : : }
405 : : /* The nfs_page now hold references to these pages */
406 : : nfs_direct_release_pages(pagevec, npages);
407 [ # # ]: 0 : } while (count != 0 && result >= 0);
408 : :
409 : 0 : kfree(pagevec);
410 : :
411 [ # # ]: 0 : if (started)
412 : : return started;
413 [ # # ]: 0 : return result < 0 ? (ssize_t) result : -EFAULT;
414 : : }
415 : :
416 : 0 : static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq,
417 : : const struct iovec *iov,
418 : : unsigned long nr_segs,
419 : : loff_t pos, bool uio)
420 : : {
421 : : struct nfs_pageio_descriptor desc;
422 : 0 : struct inode *inode = dreq->inode;
423 : : ssize_t result = -EINVAL;
424 : : size_t requested_bytes = 0;
425 : : unsigned long seg;
426 : :
427 : 0 : NFS_PROTO(dreq->inode)->read_pageio_init(&desc, dreq->inode,
428 : : &nfs_direct_read_completion_ops);
429 : : get_dreq(dreq);
430 : 0 : desc.pg_dreq = dreq;
431 : 0 : atomic_inc(&inode->i_dio_count);
432 : :
433 [ # # ]: 0 : for (seg = 0; seg < nr_segs; seg++) {
434 : 0 : const struct iovec *vec = &iov[seg];
435 : 0 : result = nfs_direct_read_schedule_segment(&desc, vec, pos, uio);
436 [ # # ]: 0 : if (result < 0)
437 : : break;
438 : 0 : requested_bytes += result;
439 [ # # ]: 0 : if ((size_t)result < vec->iov_len)
440 : : break;
441 : 0 : pos += vec->iov_len;
442 : : }
443 : :
444 : 0 : nfs_pageio_complete(&desc);
445 : :
446 : : /*
447 : : * If no bytes were started, return the error, and let the
448 : : * generic layer handle the completion.
449 : : */
450 [ # # ]: 0 : if (requested_bytes == 0) {
451 : 0 : inode_dio_done(inode);
452 : 0 : nfs_direct_req_release(dreq);
453 [ # # ]: 0 : return result < 0 ? result : -EIO;
454 : : }
455 : :
456 [ # # ]: 0 : if (put_dreq(dreq))
457 : 0 : nfs_direct_complete(dreq, false);
458 : : return 0;
459 : : }
460 : :
461 : : /**
462 : : * nfs_file_direct_read - file direct read operation for NFS files
463 : : * @iocb: target I/O control block
464 : : * @iov: vector of user buffers into which to read data
465 : : * @nr_segs: size of iov vector
466 : : * @pos: byte offset in file where reading starts
467 : : *
468 : : * We use this function for direct reads instead of calling
469 : : * generic_file_aio_read() in order to avoid gfar's check to see if
470 : : * the request starts before the end of the file. For that check
471 : : * to work, we must generate a GETATTR before each direct read, and
472 : : * even then there is a window between the GETATTR and the subsequent
473 : : * READ where the file size could change. Our preference is simply
474 : : * to do all reads the application wants, and the server will take
475 : : * care of managing the end of file boundary.
476 : : *
477 : : * This function also eliminates unnecessarily updating the file's
478 : : * atime locally, as the NFS server sets the file's atime, and this
479 : : * client must read the updated atime from the server back into its
480 : : * cache.
481 : : */
482 : 0 : ssize_t nfs_file_direct_read(struct kiocb *iocb, const struct iovec *iov,
483 : : unsigned long nr_segs, loff_t pos, bool uio)
484 : : {
485 : 0 : struct file *file = iocb->ki_filp;
486 : 0 : struct address_space *mapping = file->f_mapping;
487 : 0 : struct inode *inode = mapping->host;
488 : : struct nfs_direct_req *dreq;
489 : : struct nfs_lock_context *l_ctx;
490 : : ssize_t result = -EINVAL;
491 : : size_t count;
492 : :
493 : : count = iov_length(iov, nr_segs);
494 : 0 : nfs_add_stats(mapping->host, NFSIOS_DIRECTREADBYTES, count);
495 : :
496 : : dfprintk(FILE, "NFS: direct read(%pD2, %zd@%Ld)\n",
497 : : file, count, (long long) pos);
498 : :
499 : : result = 0;
500 [ # # ]: 0 : if (!count)
501 : : goto out;
502 : :
503 : 0 : mutex_lock(&inode->i_mutex);
504 : 0 : result = nfs_sync_mapping(mapping);
505 [ # # ]: 0 : if (result)
506 : : goto out_unlock;
507 : :
508 : : task_io_account_read(count);
509 : :
510 : : result = -ENOMEM;
511 : : dreq = nfs_direct_req_alloc();
512 [ # # ]: 0 : if (dreq == NULL)
513 : : goto out_unlock;
514 : :
515 : 0 : dreq->inode = inode;
516 : 0 : dreq->bytes_left = iov_length(iov, nr_segs);
517 : 0 : dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp));
518 : 0 : l_ctx = nfs_get_lock_context(dreq->ctx);
519 [ # # ]: 0 : if (IS_ERR(l_ctx)) {
520 : : result = PTR_ERR(l_ctx);
521 : : goto out_release;
522 : : }
523 : 0 : dreq->l_ctx = l_ctx;
524 [ # # ]: 0 : if (!is_sync_kiocb(iocb))
525 : 0 : dreq->iocb = iocb;
526 : :
527 : 0 : NFS_I(inode)->read_io += iov_length(iov, nr_segs);
528 : 0 : result = nfs_direct_read_schedule_iovec(dreq, iov, nr_segs, pos, uio);
529 : :
530 : 0 : mutex_unlock(&inode->i_mutex);
531 : :
532 [ # # ]: 0 : if (!result) {
533 : 0 : result = nfs_direct_wait(dreq);
534 [ # # ]: 0 : if (result > 0)
535 : 0 : iocb->ki_pos = pos + result;
536 : : }
537 : :
538 : 0 : nfs_direct_req_release(dreq);
539 : 0 : return result;
540 : :
541 : : out_release:
542 : 0 : nfs_direct_req_release(dreq);
543 : : out_unlock:
544 : 0 : mutex_unlock(&inode->i_mutex);
545 : : out:
546 : 0 : return result;
547 : : }
548 : :
549 : : #if IS_ENABLED(CONFIG_NFS_V3) || IS_ENABLED(CONFIG_NFS_V4)
550 : 0 : static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq)
551 : : {
552 : : struct nfs_pageio_descriptor desc;
553 : : struct nfs_page *req, *tmp;
554 : 0 : LIST_HEAD(reqs);
555 : : struct nfs_commit_info cinfo;
556 : 0 : LIST_HEAD(failed);
557 : :
558 : : nfs_init_cinfo_from_dreq(&cinfo, dreq);
559 : : pnfs_recover_commit_reqs(dreq->inode, &reqs, &cinfo);
560 : : spin_lock(cinfo.lock);
561 : 0 : nfs_scan_commit_list(&cinfo.mds->list, &reqs, &cinfo, 0);
562 : 0 : spin_unlock(cinfo.lock);
563 : :
564 : 0 : dreq->count = 0;
565 : : get_dreq(dreq);
566 : :
567 : 0 : NFS_PROTO(dreq->inode)->write_pageio_init(&desc, dreq->inode, FLUSH_STABLE,
568 : : &nfs_direct_write_completion_ops);
569 : 0 : desc.pg_dreq = dreq;
570 : :
571 [ # # ]: 0 : list_for_each_entry_safe(req, tmp, &reqs, wb_list) {
572 [ # # ]: 0 : if (!nfs_pageio_add_request(&desc, req)) {
573 : : nfs_list_remove_request(req);
574 : : nfs_list_add_request(req, &failed);
575 : 0 : spin_lock(cinfo.lock);
576 : 0 : dreq->flags = 0;
577 : 0 : dreq->error = -EIO;
578 : 0 : spin_unlock(cinfo.lock);
579 : : }
580 : 0 : nfs_release_request(req);
581 : : }
582 : 0 : nfs_pageio_complete(&desc);
583 : :
584 [ # # ]: 0 : while (!list_empty(&failed)) {
585 : : req = nfs_list_entry(failed.next);
586 : : nfs_list_remove_request(req);
587 : 0 : nfs_unlock_and_release_request(req);
588 : : }
589 : :
590 [ # # ]: 0 : if (put_dreq(dreq))
591 : : nfs_direct_write_complete(dreq, dreq->inode);
592 : 0 : }
593 : :
594 : 0 : static void nfs_direct_commit_complete(struct nfs_commit_data *data)
595 : : {
596 : 0 : struct nfs_direct_req *dreq = data->dreq;
597 : : struct nfs_commit_info cinfo;
598 : : struct nfs_page *req;
599 : 0 : int status = data->task.tk_status;
600 : :
601 : : nfs_init_cinfo_from_dreq(&cinfo, dreq);
602 [ # # ]: 0 : if (status < 0) {
603 : : dprintk("NFS: %5u commit failed with error %d.\n",
604 : : data->task.tk_pid, status);
605 : 0 : dreq->flags = NFS_ODIRECT_RESCHED_WRITES;
606 [ # # ]: 0 : } else if (memcmp(&dreq->verf, &data->verf, sizeof(data->verf))) {
607 : : dprintk("NFS: %5u commit verify failed\n", data->task.tk_pid);
608 : 0 : dreq->flags = NFS_ODIRECT_RESCHED_WRITES;
609 : : }
610 : :
611 : : dprintk("NFS: %5u commit returned %d\n", data->task.tk_pid, status);
612 [ # # ]: 0 : while (!list_empty(&data->pages)) {
613 : : req = nfs_list_entry(data->pages.next);
614 : : nfs_list_remove_request(req);
615 [ # # ]: 0 : if (dreq->flags == NFS_ODIRECT_RESCHED_WRITES) {
616 : : /* Note the rewrite will go through mds */
617 : 0 : nfs_mark_request_commit(req, NULL, &cinfo);
618 : : } else
619 : 0 : nfs_release_request(req);
620 : 0 : nfs_unlock_and_release_request(req);
621 : : }
622 : :
623 [ # # ]: 0 : if (atomic_dec_and_test(&cinfo.mds->rpcs_out))
624 : : nfs_direct_write_complete(dreq, data->inode);
625 : 0 : }
626 : :
627 : 0 : static void nfs_direct_error_cleanup(struct nfs_inode *nfsi)
628 : : {
629 : : /* There is no lock to clear */
630 : 0 : }
631 : :
632 : : static const struct nfs_commit_completion_ops nfs_direct_commit_completion_ops = {
633 : : .completion = nfs_direct_commit_complete,
634 : : .error_cleanup = nfs_direct_error_cleanup,
635 : : };
636 : :
637 : 0 : static void nfs_direct_commit_schedule(struct nfs_direct_req *dreq)
638 : : {
639 : : int res;
640 : : struct nfs_commit_info cinfo;
641 : 0 : LIST_HEAD(mds_list);
642 : :
643 : : nfs_init_cinfo_from_dreq(&cinfo, dreq);
644 : 0 : nfs_scan_commit(dreq->inode, &mds_list, &cinfo);
645 : 0 : res = nfs_generic_commit_list(dreq->inode, &mds_list, 0, &cinfo);
646 [ # # ]: 0 : if (res < 0) /* res == -ENOMEM */
647 : 0 : nfs_direct_write_reschedule(dreq);
648 : 0 : }
649 : :
650 : 0 : static void nfs_direct_write_schedule_work(struct work_struct *work)
651 : : {
652 : 0 : struct nfs_direct_req *dreq = container_of(work, struct nfs_direct_req, work);
653 : 0 : int flags = dreq->flags;
654 : :
655 : 0 : dreq->flags = 0;
656 [ # # # ]: 0 : switch (flags) {
657 : : case NFS_ODIRECT_DO_COMMIT:
658 : 0 : nfs_direct_commit_schedule(dreq);
659 : 0 : break;
660 : : case NFS_ODIRECT_RESCHED_WRITES:
661 : 0 : nfs_direct_write_reschedule(dreq);
662 : 0 : break;
663 : : default:
664 : 0 : nfs_direct_complete(dreq, true);
665 : : }
666 : 0 : }
667 : :
668 : : static void nfs_direct_write_complete(struct nfs_direct_req *dreq, struct inode *inode)
669 : : {
670 : 0 : schedule_work(&dreq->work); /* Calls nfs_direct_write_schedule_work */
671 : : }
672 : :
673 : : #else
674 : : static void nfs_direct_write_schedule_work(struct work_struct *work)
675 : : {
676 : : }
677 : :
678 : : static void nfs_direct_write_complete(struct nfs_direct_req *dreq, struct inode *inode)
679 : : {
680 : : nfs_direct_complete(dreq, true);
681 : : }
682 : : #endif
683 : :
684 : : /*
685 : : * NB: Return the value of the first error return code. Subsequent
686 : : * errors after the first one are ignored.
687 : : */
688 : : /*
689 : : * For each wsize'd chunk of the user's buffer, dispatch an NFS WRITE
690 : : * operation. If nfs_writedata_alloc() or get_user_pages() fails,
691 : : * bail and stop sending more writes. Write length accounting is
692 : : * handled automatically by nfs_direct_write_result(). Otherwise, if
693 : : * no requests have been sent, just return an error.
694 : : */
695 : 0 : static ssize_t nfs_direct_write_schedule_segment(struct nfs_pageio_descriptor *desc,
696 : : const struct iovec *iov,
697 : : loff_t pos, bool uio)
698 : : {
699 : 0 : struct nfs_direct_req *dreq = desc->pg_dreq;
700 : 0 : struct nfs_open_context *ctx = dreq->ctx;
701 : 0 : struct inode *inode = ctx->dentry->d_inode;
702 : 0 : unsigned long user_addr = (unsigned long)iov->iov_base;
703 : 0 : size_t count = iov->iov_len;
704 : 0 : size_t wsize = NFS_SERVER(inode)->wsize;
705 : : unsigned int pgbase;
706 : : int result;
707 : : ssize_t started = 0;
708 : : struct page **pagevec = NULL;
709 : : unsigned int npages;
710 : :
711 : : do {
712 : : size_t bytes;
713 : : int i;
714 : :
715 : 0 : pgbase = user_addr & ~PAGE_MASK;
716 : 0 : bytes = min(max_t(size_t, wsize, PAGE_SIZE), count);
717 : :
718 : : result = -ENOMEM;
719 : : npages = nfs_page_array_len(pgbase, bytes);
720 [ # # ]: 0 : if (!pagevec)
721 : 0 : pagevec = kmalloc(npages * sizeof(struct page *), GFP_KERNEL);
722 [ # # ]: 0 : if (!pagevec)
723 : : break;
724 : :
725 [ # # ]: 0 : if (uio) {
726 : 0 : down_read(¤t->mm->mmap_sem);
727 : 0 : result = get_user_pages(current, current->mm, user_addr,
728 : : npages, 0, 0, pagevec, NULL);
729 : 0 : up_read(¤t->mm->mmap_sem);
730 [ # # ]: 0 : if (result < 0)
731 : : break;
732 : : } else {
733 [ # # ]: 0 : WARN_ON(npages != 1);
734 : 0 : result = get_kernel_page(user_addr, 0, pagevec);
735 [ # # ][ # # ]: 0 : if (WARN_ON(result != 1))
736 : : break;
737 : : }
738 : :
739 [ # # ]: 0 : if ((unsigned)result < npages) {
740 : 0 : bytes = result * PAGE_SIZE;
741 [ # # ]: 0 : if (bytes <= pgbase) {
742 : : nfs_direct_release_pages(pagevec, result);
743 : : break;
744 : : }
745 : 0 : bytes -= pgbase;
746 : : npages = result;
747 : : }
748 : :
749 [ # # ]: 0 : for (i = 0; i < npages; i++) {
750 : : struct nfs_page *req;
751 : 0 : unsigned int req_len = min_t(size_t, bytes, PAGE_SIZE - pgbase);
752 : :
753 : 0 : req = nfs_create_request(dreq->ctx, dreq->inode,
754 : 0 : pagevec[i],
755 : : pgbase, req_len);
756 [ # # ]: 0 : if (IS_ERR(req)) {
757 : : result = PTR_ERR(req);
758 : 0 : break;
759 : : }
760 : : nfs_lock_request(req);
761 : 0 : req->wb_index = pos >> PAGE_SHIFT;
762 : 0 : req->wb_offset = pos & ~PAGE_MASK;
763 [ # # ]: 0 : if (!nfs_pageio_add_request(desc, req)) {
764 : 0 : result = desc->pg_error;
765 : 0 : nfs_unlock_and_release_request(req);
766 : 0 : break;
767 : : }
768 : : pgbase = 0;
769 : 0 : bytes -= req_len;
770 : 0 : started += req_len;
771 : 0 : user_addr += req_len;
772 : 0 : pos += req_len;
773 : 0 : count -= req_len;
774 : 0 : dreq->bytes_left -= req_len;
775 : : }
776 : : /* The nfs_page now hold references to these pages */
777 : : nfs_direct_release_pages(pagevec, npages);
778 [ # # ]: 0 : } while (count != 0 && result >= 0);
779 : :
780 : 0 : kfree(pagevec);
781 : :
782 [ # # ]: 0 : if (started)
783 : : return started;
784 [ # # ]: 0 : return result < 0 ? (ssize_t) result : -EFAULT;
785 : : }
786 : :
787 : 0 : static void nfs_direct_write_completion(struct nfs_pgio_header *hdr)
788 : : {
789 : 0 : struct nfs_direct_req *dreq = hdr->dreq;
790 : : struct nfs_commit_info cinfo;
791 : : int bit = -1;
792 : : struct nfs_page *req = nfs_list_entry(hdr->pages.next);
793 : :
794 [ # # ]: 0 : if (test_bit(NFS_IOHDR_REDO, &hdr->flags))
795 : : goto out_put;
796 : :
797 : : nfs_init_cinfo_from_dreq(&cinfo, dreq);
798 : :
799 : : spin_lock(&dreq->lock);
800 : :
801 [ # # ]: 0 : if (test_bit(NFS_IOHDR_ERROR, &hdr->flags)) {
802 : 0 : dreq->flags = 0;
803 : 0 : dreq->error = hdr->error;
804 : : }
805 [ # # ]: 0 : if (dreq->error != 0)
806 : : bit = NFS_IOHDR_ERROR;
807 : : else {
808 : 0 : dreq->count += hdr->good_bytes;
809 [ # # ]: 0 : if (test_bit(NFS_IOHDR_NEED_RESCHED, &hdr->flags)) {
810 : 0 : dreq->flags = NFS_ODIRECT_RESCHED_WRITES;
811 : : bit = NFS_IOHDR_NEED_RESCHED;
812 [ # # ]: 0 : } else if (test_bit(NFS_IOHDR_NEED_COMMIT, &hdr->flags)) {
813 [ # # ]: 0 : if (dreq->flags == NFS_ODIRECT_RESCHED_WRITES)
814 : : bit = NFS_IOHDR_NEED_RESCHED;
815 [ # # ]: 0 : else if (dreq->flags == 0) {
816 : 0 : memcpy(&dreq->verf, hdr->verf,
817 : : sizeof(dreq->verf));
818 : : bit = NFS_IOHDR_NEED_COMMIT;
819 : 0 : dreq->flags = NFS_ODIRECT_DO_COMMIT;
820 [ # # ]: 0 : } else if (dreq->flags == NFS_ODIRECT_DO_COMMIT) {
821 [ # # ]: 0 : if (memcmp(&dreq->verf, hdr->verf, sizeof(dreq->verf))) {
822 : 0 : dreq->flags = NFS_ODIRECT_RESCHED_WRITES;
823 : : bit = NFS_IOHDR_NEED_RESCHED;
824 : : } else
825 : : bit = NFS_IOHDR_NEED_COMMIT;
826 : : }
827 : : }
828 : : }
829 : : spin_unlock(&dreq->lock);
830 : :
831 [ # # ]: 0 : while (!list_empty(&hdr->pages)) {
832 : : req = nfs_list_entry(hdr->pages.next);
833 : : nfs_list_remove_request(req);
834 [ # # ]: 0 : switch (bit) {
835 : : case NFS_IOHDR_NEED_RESCHED:
836 : : case NFS_IOHDR_NEED_COMMIT:
837 : : kref_get(&req->wb_kref);
838 : 0 : nfs_mark_request_commit(req, hdr->lseg, &cinfo);
839 : : }
840 : 0 : nfs_unlock_and_release_request(req);
841 : : }
842 : :
843 : : out_put:
844 [ # # ]: 0 : if (put_dreq(dreq))
845 : : nfs_direct_write_complete(dreq, hdr->inode);
846 : 0 : hdr->release(hdr);
847 : 0 : }
848 : :
849 : 0 : static void nfs_write_sync_pgio_error(struct list_head *head)
850 : : {
851 : : struct nfs_page *req;
852 : :
853 [ # # ]: 0 : while (!list_empty(head)) {
854 : : req = nfs_list_entry(head->next);
855 : : nfs_list_remove_request(req);
856 : 0 : nfs_unlock_and_release_request(req);
857 : : }
858 : 0 : }
859 : :
860 : : static const struct nfs_pgio_completion_ops nfs_direct_write_completion_ops = {
861 : : .error_cleanup = nfs_write_sync_pgio_error,
862 : : .init_hdr = nfs_direct_pgio_init,
863 : : .completion = nfs_direct_write_completion,
864 : : };
865 : :
866 : 0 : static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq,
867 : : const struct iovec *iov,
868 : : unsigned long nr_segs,
869 : : loff_t pos, bool uio)
870 : : {
871 : : struct nfs_pageio_descriptor desc;
872 : 0 : struct inode *inode = dreq->inode;
873 : : ssize_t result = 0;
874 : : size_t requested_bytes = 0;
875 : : unsigned long seg;
876 : :
877 : 0 : NFS_PROTO(inode)->write_pageio_init(&desc, inode, FLUSH_COND_STABLE,
878 : : &nfs_direct_write_completion_ops);
879 : 0 : desc.pg_dreq = dreq;
880 : : get_dreq(dreq);
881 : 0 : atomic_inc(&inode->i_dio_count);
882 : :
883 : 0 : NFS_I(dreq->inode)->write_io += iov_length(iov, nr_segs);
884 [ # # ]: 0 : for (seg = 0; seg < nr_segs; seg++) {
885 : 0 : const struct iovec *vec = &iov[seg];
886 : 0 : result = nfs_direct_write_schedule_segment(&desc, vec, pos, uio);
887 [ # # ]: 0 : if (result < 0)
888 : : break;
889 : 0 : requested_bytes += result;
890 [ # # ]: 0 : if ((size_t)result < vec->iov_len)
891 : : break;
892 : 0 : pos += vec->iov_len;
893 : : }
894 : 0 : nfs_pageio_complete(&desc);
895 : :
896 : : /*
897 : : * If no bytes were started, return the error, and let the
898 : : * generic layer handle the completion.
899 : : */
900 [ # # ]: 0 : if (requested_bytes == 0) {
901 : 0 : inode_dio_done(inode);
902 : 0 : nfs_direct_req_release(dreq);
903 [ # # ]: 0 : return result < 0 ? result : -EIO;
904 : : }
905 : :
906 [ # # ]: 0 : if (put_dreq(dreq))
907 : : nfs_direct_write_complete(dreq, dreq->inode);
908 : : return 0;
909 : : }
910 : :
911 : : /**
912 : : * nfs_file_direct_write - file direct write operation for NFS files
913 : : * @iocb: target I/O control block
914 : : * @iov: vector of user buffers from which to write data
915 : : * @nr_segs: size of iov vector
916 : : * @pos: byte offset in file where writing starts
917 : : *
918 : : * We use this function for direct writes instead of calling
919 : : * generic_file_aio_write() in order to avoid taking the inode
920 : : * semaphore and updating the i_size. The NFS server will set
921 : : * the new i_size and this client must read the updated size
922 : : * back into its cache. We let the server do generic write
923 : : * parameter checking and report problems.
924 : : *
925 : : * We eliminate local atime updates, see direct read above.
926 : : *
927 : : * We avoid unnecessary page cache invalidations for normal cached
928 : : * readers of this file.
929 : : *
930 : : * Note that O_APPEND is not supported for NFS direct writes, as there
931 : : * is no atomic O_APPEND write facility in the NFS protocol.
932 : : */
933 : 0 : ssize_t nfs_file_direct_write(struct kiocb *iocb, const struct iovec *iov,
934 : : unsigned long nr_segs, loff_t pos, bool uio)
935 : : {
936 : : ssize_t result = -EINVAL;
937 : 0 : struct file *file = iocb->ki_filp;
938 : 0 : struct address_space *mapping = file->f_mapping;
939 : 0 : struct inode *inode = mapping->host;
940 : : struct nfs_direct_req *dreq;
941 : : struct nfs_lock_context *l_ctx;
942 : : loff_t end;
943 : : size_t count;
944 : :
945 : 0 : count = iov_length(iov, nr_segs);
946 : 0 : end = (pos + count - 1) >> PAGE_CACHE_SHIFT;
947 : :
948 : 0 : nfs_add_stats(mapping->host, NFSIOS_DIRECTWRITTENBYTES, count);
949 : :
950 : : dfprintk(FILE, "NFS: direct write(%pD2, %zd@%Ld)\n",
951 : : file, count, (long long) pos);
952 : :
953 : 0 : result = generic_write_checks(file, &pos, &count, 0);
954 [ # # ]: 0 : if (result)
955 : : goto out;
956 : :
957 : : result = -EINVAL;
958 [ # # ]: 0 : if ((ssize_t) count < 0)
959 : : goto out;
960 : : result = 0;
961 [ # # ]: 0 : if (!count)
962 : : goto out;
963 : :
964 : 0 : mutex_lock(&inode->i_mutex);
965 : :
966 : 0 : result = nfs_sync_mapping(mapping);
967 [ # # ]: 0 : if (result)
968 : : goto out_unlock;
969 : :
970 [ # # ]: 0 : if (mapping->nrpages) {
971 : 0 : result = invalidate_inode_pages2_range(mapping,
972 : 0 : pos >> PAGE_CACHE_SHIFT, end);
973 [ # # ]: 0 : if (result)
974 : : goto out_unlock;
975 : : }
976 : :
977 : : task_io_account_write(count);
978 : :
979 : : result = -ENOMEM;
980 : : dreq = nfs_direct_req_alloc();
981 [ # # ]: 0 : if (!dreq)
982 : : goto out_unlock;
983 : :
984 : 0 : dreq->inode = inode;
985 : 0 : dreq->bytes_left = count;
986 : 0 : dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp));
987 : 0 : l_ctx = nfs_get_lock_context(dreq->ctx);
988 [ # # ]: 0 : if (IS_ERR(l_ctx)) {
989 : : result = PTR_ERR(l_ctx);
990 : : goto out_release;
991 : : }
992 : 0 : dreq->l_ctx = l_ctx;
993 [ # # ]: 0 : if (!is_sync_kiocb(iocb))
994 : 0 : dreq->iocb = iocb;
995 : :
996 : 0 : result = nfs_direct_write_schedule_iovec(dreq, iov, nr_segs, pos, uio);
997 : :
998 [ # # ]: 0 : if (mapping->nrpages) {
999 : 0 : invalidate_inode_pages2_range(mapping,
1000 : 0 : pos >> PAGE_CACHE_SHIFT, end);
1001 : : }
1002 : :
1003 : 0 : mutex_unlock(&inode->i_mutex);
1004 : :
1005 [ # # ]: 0 : if (!result) {
1006 : 0 : result = nfs_direct_wait(dreq);
1007 [ # # ]: 0 : if (result > 0) {
1008 : 0 : struct inode *inode = mapping->host;
1009 : :
1010 : 0 : iocb->ki_pos = pos + result;
1011 : : spin_lock(&inode->i_lock);
1012 [ # # ]: 0 : if (i_size_read(inode) < iocb->ki_pos)
1013 : : i_size_write(inode, iocb->ki_pos);
1014 : : spin_unlock(&inode->i_lock);
1015 : : }
1016 : : }
1017 : 0 : nfs_direct_req_release(dreq);
1018 : 0 : return result;
1019 : :
1020 : : out_release:
1021 : 0 : nfs_direct_req_release(dreq);
1022 : : out_unlock:
1023 : 0 : mutex_unlock(&inode->i_mutex);
1024 : : out:
1025 : 0 : return result;
1026 : : }
1027 : :
1028 : : /**
1029 : : * nfs_init_directcache - create a slab cache for nfs_direct_req structures
1030 : : *
1031 : : */
1032 : 0 : int __init nfs_init_directcache(void)
1033 : : {
1034 : 0 : nfs_direct_cachep = kmem_cache_create("nfs_direct_cache",
1035 : : sizeof(struct nfs_direct_req),
1036 : : 0, (SLAB_RECLAIM_ACCOUNT|
1037 : : SLAB_MEM_SPREAD),
1038 : : NULL);
1039 [ # # ]: 0 : if (nfs_direct_cachep == NULL)
1040 : : return -ENOMEM;
1041 : :
1042 : 0 : return 0;
1043 : : }
1044 : :
1045 : : /**
1046 : : * nfs_destroy_directcache - destroy the slab cache for nfs_direct_req structures
1047 : : *
1048 : : */
1049 : 0 : void nfs_destroy_directcache(void)
1050 : : {
1051 : 0 : kmem_cache_destroy(nfs_direct_cachep);
1052 : 0 : }
|
