| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Trond Myklebust | 1517 | 35.20% | 60 | 36.59% |
| Fred Isaman | 857 | 19.88% | 9 | 5.49% |
| Chuck Lever | 468 | 10.86% | 31 | 18.90% |
| Al Viro | 397 | 9.21% | 9 | 5.49% |
| Weston Andros Adamson | 362 | 8.40% | 7 | 4.27% |
| Christoph Hellwig | 328 | 7.61% | 13 | 7.93% |
| Peng Tao | 167 | 3.87% | 8 | 4.88% |
| Tom Haynes | 83 | 1.93% | 1 | 0.61% |
| Mel Gorman | 33 | 0.77% | 1 | 0.61% |
| Dave Kleikamp | 28 | 0.65% | 1 | 0.61% |
| Dave Wysochanski | 15 | 0.35% | 1 | 0.61% |
| Kinglong Mee | 9 | 0.21% | 1 | 0.61% |
| Konstantin Khlebnikov | 7 | 0.16% | 1 | 0.61% |
| Jens Axboe | 5 | 0.12% | 1 | 0.61% |
| Omar Sandoval | 4 | 0.09% | 1 | 0.61% |
| Paul Jackson | 4 | 0.09% | 2 | 1.22% |
| Neil Brown | 3 | 0.07% | 1 | 0.61% |
| Kirill A. Shutemov | 3 | 0.07% | 1 | 0.61% |
| Tejun Heo | 3 | 0.07% | 1 | 0.61% |
| Linus Torvalds | 3 | 0.07% | 2 | 1.22% |
| Christoph Lameter | 3 | 0.07% | 2 | 1.22% |
| David Howells | 2 | 0.05% | 1 | 0.61% |
| Anna Schumaker | 2 | 0.05% | 2 | 1.22% |
| Thomas Gleixner | 1 | 0.02% | 1 | 0.61% |
| Matthew Wilcox | 1 | 0.02% | 1 | 0.61% |
| Jeff Layton | 1 | 0.02% | 1 | 0.61% |
| Andy Adamson | 1 | 0.02% | 1 | 0.61% |
| Daniel Wagner | 1 | 0.02% | 1 | 0.61% |
| Arun Sharma | 1 | 0.02% | 1 | 0.61% |
| Badari Pulavarty | 1 | 0.02% | 1 | 0.61% |
| Total | 4310 | 164 |
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052
// SPDX-License-Identifier: GPL-2.0-only /* * linux/fs/nfs/direct.c * * Copyright (C) 2003 by Chuck Lever <cel@netapp.com> * * High-performance uncached I/O for the Linux NFS client * * There are important applications whose performance or correctness * depends on uncached access to file data. Database clusters * (multiple copies of the same instance running on separate hosts) * implement their own cache coherency protocol that subsumes file * system cache protocols. Applications that process datasets * considerably larger than the client's memory do not always benefit * from a local cache. A streaming video server, for instance, has no * need to cache the contents of a file. * * When an application requests uncached I/O, all read and write requests * are made directly to the server; data stored or fetched via these * requests is not cached in the Linux page cache. The client does not * correct unaligned requests from applications. All requested bytes are * held on permanent storage before a direct write system call returns to * an application. * * Solaris implements an uncached I/O facility called directio() that * is used for backups and sequential I/O to very large files. Solaris * also supports uncaching whole NFS partitions with "-o forcedirectio," * an undocumented mount option. * * Designed by Jeff Kimmel, Chuck Lever, and Trond Myklebust, with * help from Andrew Morton. * * 18 Dec 2001 Initial implementation for 2.4 --cel * 08 Jul 2002 Version for 2.4.19, with bug fixes --trondmy * 08 Jun 2003 Port to 2.5 APIs --cel * 31 Mar 2004 Handle direct I/O without VFS support --cel * 15 Sep 2004 Parallel async reads --cel * 04 May 2005 support O_DIRECT with aio --cel * */ #include <linux/errno.h> #include <linux/sched.h> #include <linux/kernel.h> #include <linux/file.h> #include <linux/pagemap.h> #include <linux/kref.h> #include <linux/slab.h> #include <linux/task_io_accounting_ops.h> #include <linux/module.h> #include <linux/nfs_fs.h> #include <linux/nfs_page.h> #include <linux/sunrpc/clnt.h> #include <linux/uaccess.h> #include <linux/atomic.h> #include "internal.h" #include "iostat.h" #include "pnfs.h" #define NFSDBG_FACILITY NFSDBG_VFS static struct kmem_cache *nfs_direct_cachep; struct nfs_direct_req { struct kref kref; /* release manager */ /* I/O parameters */ struct nfs_open_context *ctx; /* file open context info */ struct nfs_lock_context *l_ctx; /* Lock context info */ struct kiocb * iocb; /* controlling i/o request */ struct inode * inode; /* target file of i/o */ /* completion state */ atomic_t io_count; /* i/os we're waiting for */ spinlock_t lock; /* protect completion state */ loff_t io_start; /* Start offset for I/O */ ssize_t count, /* bytes actually processed */ max_count, /* max expected count */ bytes_left, /* bytes left to be sent */ error; /* any reported error */ struct completion completion; /* wait for i/o completion */ /* commit state */ struct nfs_mds_commit_info mds_cinfo; /* Storage for cinfo */ struct pnfs_ds_commit_info ds_cinfo; /* Storage for cinfo */ struct work_struct work; int flags; /* for write */ #define NFS_ODIRECT_DO_COMMIT (1) /* an unstable reply was received */ #define NFS_ODIRECT_RESCHED_WRITES (2) /* write verification failed */ /* for read */ #define NFS_ODIRECT_SHOULD_DIRTY (3) /* dirty user-space page after read */ struct nfs_writeverf verf; /* unstable write verifier */ }; static const struct nfs_pgio_completion_ops nfs_direct_write_completion_ops; static const struct nfs_commit_completion_ops nfs_direct_commit_completion_ops; static void nfs_direct_write_complete(struct nfs_direct_req *dreq); static void nfs_direct_write_schedule_work(struct work_struct *work); static inline void get_dreq(struct nfs_direct_req *dreq) { atomic_inc(&dreq->io_count); } static inline int put_dreq(struct nfs_direct_req *dreq) { return atomic_dec_and_test(&dreq->io_count); } static void nfs_direct_handle_truncated(struct nfs_direct_req *dreq, const struct nfs_pgio_header *hdr, ssize_t dreq_len) { if (!(test_bit(NFS_IOHDR_ERROR, &hdr->flags) || test_bit(NFS_IOHDR_EOF, &hdr->flags))) return; if (dreq->max_count >= dreq_len) { dreq->max_count = dreq_len; if (dreq->count > dreq_len) dreq->count = dreq_len; if (test_bit(NFS_IOHDR_ERROR, &hdr->flags)) dreq->error = hdr->error; else /* Clear outstanding error if this is EOF */ dreq->error = 0; } } static void nfs_direct_count_bytes(struct nfs_direct_req *dreq, const struct nfs_pgio_header *hdr) { loff_t hdr_end = hdr->io_start + hdr->good_bytes; ssize_t dreq_len = 0; if (hdr_end > dreq->io_start) dreq_len = hdr_end - dreq->io_start; nfs_direct_handle_truncated(dreq, hdr, dreq_len); if (dreq_len > dreq->max_count) dreq_len = dreq->max_count; if (dreq->count < dreq_len) dreq->count = dreq_len; } /* * nfs_direct_select_verf - select the right verifier * @dreq - direct request possibly spanning multiple servers * @ds_clp - nfs_client of data server or NULL if MDS / non-pnfs * @commit_idx - commit bucket index for the DS * * returns the correct verifier to use given the role of the server */ static struct nfs_writeverf * nfs_direct_select_verf(struct nfs_direct_req *dreq, struct nfs_client *ds_clp, int commit_idx) { struct nfs_writeverf *verfp = &dreq->verf; #ifdef CONFIG_NFS_V4_1 /* * pNFS is in use, use the DS verf except commit_through_mds is set * for layout segment where nbuckets is zero. */ if (ds_clp && dreq->ds_cinfo.nbuckets > 0) { if (commit_idx >= 0 && commit_idx < dreq->ds_cinfo.nbuckets) verfp = &dreq->ds_cinfo.buckets[commit_idx].direct_verf; else WARN_ON_ONCE(1); } #endif return verfp; } /* * nfs_direct_set_hdr_verf - set the write/commit verifier * @dreq - direct request possibly spanning multiple servers * @hdr - pageio header to validate against previously seen verfs * * Set the server's (MDS or DS) "seen" verifier */ static void nfs_direct_set_hdr_verf(struct nfs_direct_req *dreq, struct nfs_pgio_header *hdr) { struct nfs_writeverf *verfp; verfp = nfs_direct_select_verf(dreq, hdr->ds_clp, hdr->ds_commit_idx); WARN_ON_ONCE(verfp->committed >= 0); memcpy(verfp, &hdr->verf, sizeof(struct nfs_writeverf)); WARN_ON_ONCE(verfp->committed < 0); } static int nfs_direct_cmp_verf(const struct nfs_writeverf *v1, const struct nfs_writeverf *v2) { return nfs_write_verifier_cmp(&v1->verifier, &v2->verifier); } /* * nfs_direct_cmp_hdr_verf - compare verifier for pgio header * @dreq - direct request possibly spanning multiple servers * @hdr - pageio header to validate against previously seen verf * * set the server's "seen" verf if not initialized. * returns result of comparison between @hdr->verf and the "seen" * verf of the server used by @hdr (DS or MDS) */ static int nfs_direct_set_or_cmp_hdr_verf(struct nfs_direct_req *dreq, struct nfs_pgio_header *hdr) { struct nfs_writeverf *verfp; verfp = nfs_direct_select_verf(dreq, hdr->ds_clp, hdr->ds_commit_idx); if (verfp->committed < 0) { nfs_direct_set_hdr_verf(dreq, hdr); return 0; } return nfs_direct_cmp_verf(verfp, &hdr->verf); } /* * nfs_direct_cmp_commit_data_verf - compare verifier for commit data * @dreq - direct request possibly spanning multiple servers * @data - commit data to validate against previously seen verf * * returns result of comparison between @data->verf and the verf of * the server used by @data (DS or MDS) */ static int nfs_direct_cmp_commit_data_verf(struct nfs_direct_req *dreq, struct nfs_commit_data *data) { struct nfs_writeverf *verfp; verfp = nfs_direct_select_verf(dreq, data->ds_clp, data->ds_commit_index); /* verifier not set so always fail */ if (verfp->committed < 0 || data->res.verf->committed <= NFS_UNSTABLE) return 1; return nfs_direct_cmp_verf(verfp, data->res.verf); } /** * nfs_direct_IO - NFS address space operation for direct I/O * @iocb: target I/O control block * @iter: I/O buffer * * The presence of this routine in the address space ops vector means * the NFS client supports direct I/O. However, for most direct IO, we * shunt off direct read and write requests before the VFS gets them, * so this method is only ever called for swap. */ ssize_t nfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) { struct inode *inode = iocb->ki_filp->f_mapping->host; /* we only support swap file calling nfs_direct_IO */ if (!IS_SWAPFILE(inode)) return 0; VM_BUG_ON(iov_iter_count(iter) != PAGE_SIZE); if (iov_iter_rw(iter) == READ) return nfs_file_direct_read(iocb, iter); return nfs_file_direct_write(iocb, iter); } static void nfs_direct_release_pages(struct page **pages, unsigned int npages) { unsigned int i; for (i = 0; i < npages; i++) put_page(pages[i]); } void nfs_init_cinfo_from_dreq(struct nfs_commit_info *cinfo, struct nfs_direct_req *dreq) { cinfo->inode = dreq->inode; cinfo->mds = &dreq->mds_cinfo; cinfo->ds = &dreq->ds_cinfo; cinfo->dreq = dreq; cinfo->completion_ops = &nfs_direct_commit_completion_ops; } static inline struct nfs_direct_req *nfs_direct_req_alloc(void) { struct nfs_direct_req *dreq; dreq = kmem_cache_zalloc(nfs_direct_cachep, GFP_KERNEL); if (!dreq) return NULL; kref_init(&dreq->kref); kref_get(&dreq->kref); init_completion(&dreq->completion); INIT_LIST_HEAD(&dreq->mds_cinfo.list); dreq->verf.committed = NFS_INVALID_STABLE_HOW; /* not set yet */ INIT_WORK(&dreq->work, nfs_direct_write_schedule_work); spin_lock_init(&dreq->lock); return dreq; } static void nfs_direct_req_free(struct kref *kref) { struct nfs_direct_req *dreq = container_of(kref, struct nfs_direct_req, kref); nfs_free_pnfs_ds_cinfo(&dreq->ds_cinfo); if (dreq->l_ctx != NULL) nfs_put_lock_context(dreq->l_ctx); if (dreq->ctx != NULL) put_nfs_open_context(dreq->ctx); kmem_cache_free(nfs_direct_cachep, dreq); } static void nfs_direct_req_release(struct nfs_direct_req *dreq) { kref_put(&dreq->kref, nfs_direct_req_free); } ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq) { return dreq->bytes_left; } EXPORT_SYMBOL_GPL(nfs_dreq_bytes_left); /* * Collects and returns the final error value/byte-count. */ static ssize_t nfs_direct_wait(struct nfs_direct_req *dreq) { ssize_t result = -EIOCBQUEUED; /* Async requests don't wait here */ if (dreq->iocb) goto out; result = wait_for_completion_killable(&dreq->completion); if (!result) { result = dreq->count; WARN_ON_ONCE(dreq->count < 0); } if (!result) result = dreq->error; out: return (ssize_t) result; } /* * Synchronous I/O uses a stack-allocated iocb. Thus we can't trust * the iocb is still valid here if this is a synchronous request. */ static void nfs_direct_complete(struct nfs_direct_req *dreq) { struct inode *inode = dreq->inode; inode_dio_end(inode); if (dreq->iocb) { long res = (long) dreq->error; if (dreq->count != 0) { res = (long) dreq->count; WARN_ON_ONCE(dreq->count < 0); } dreq->iocb->ki_complete(dreq->iocb, res, 0); } complete(&dreq->completion); nfs_direct_req_release(dreq); } static void nfs_direct_read_completion(struct nfs_pgio_header *hdr) { unsigned long bytes = 0; struct nfs_direct_req *dreq = hdr->dreq; spin_lock(&dreq->lock); if (test_bit(NFS_IOHDR_REDO, &hdr->flags)) { spin_unlock(&dreq->lock); goto out_put; } nfs_direct_count_bytes(dreq, hdr); spin_unlock(&dreq->lock); while (!list_empty(&hdr->pages)) { struct nfs_page *req = nfs_list_entry(hdr->pages.next); struct page *page = req->wb_page; if (!PageCompound(page) && bytes < hdr->good_bytes && (dreq->flags == NFS_ODIRECT_SHOULD_DIRTY)) set_page_dirty(page); bytes += req->wb_bytes; nfs_list_remove_request(req); nfs_release_request(req); } out_put: if (put_dreq(dreq)) nfs_direct_complete(dreq); hdr->release(hdr); } static void nfs_read_sync_pgio_error(struct list_head *head, int error) { struct nfs_page *req; while (!list_empty(head)) { req = nfs_list_entry(head->next); nfs_list_remove_request(req); nfs_release_request(req); } } static void nfs_direct_pgio_init(struct nfs_pgio_header *hdr) { get_dreq(hdr->dreq); } static const struct nfs_pgio_completion_ops nfs_direct_read_completion_ops = { .error_cleanup = nfs_read_sync_pgio_error, .init_hdr = nfs_direct_pgio_init, .completion = nfs_direct_read_completion, }; /* * For each rsize'd chunk of the user's buffer, dispatch an NFS READ * operation. If nfs_readdata_alloc() or get_user_pages() fails, * bail and stop sending more reads. Read length accounting is * handled automatically by nfs_direct_read_result(). Otherwise, if * no requests have been sent, just return an error. */ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq, struct iov_iter *iter, loff_t pos) { struct nfs_pageio_descriptor desc; struct inode *inode = dreq->inode; ssize_t result = -EINVAL; size_t requested_bytes = 0; size_t rsize = max_t(size_t, NFS_SERVER(inode)->rsize, PAGE_SIZE); nfs_pageio_init_read(&desc, dreq->inode, false, &nfs_direct_read_completion_ops); get_dreq(dreq); desc.pg_dreq = dreq; inode_dio_begin(inode); while (iov_iter_count(iter)) { struct page **pagevec; size_t bytes; size_t pgbase; unsigned npages, i; result = iov_iter_get_pages_alloc(iter, &pagevec, rsize, &pgbase); if (result < 0) break; bytes = result; iov_iter_advance(iter, bytes); npages = (result + pgbase + PAGE_SIZE - 1) / PAGE_SIZE; for (i = 0; i < npages; i++) { struct nfs_page *req; unsigned int req_len = min_t(size_t, bytes, PAGE_SIZE - pgbase); /* XXX do we need to do the eof zeroing found in async_filler? */ req = nfs_create_request(dreq->ctx, pagevec[i], pgbase, req_len); if (IS_ERR(req)) { result = PTR_ERR(req); break; } req->wb_index = pos >> PAGE_SHIFT; req->wb_offset = pos & ~PAGE_MASK; if (!nfs_pageio_add_request(&desc, req)) { result = desc.pg_error; nfs_release_request(req); break; } pgbase = 0; bytes -= req_len; requested_bytes += req_len; pos += req_len; dreq->bytes_left -= req_len; } nfs_direct_release_pages(pagevec, npages); kvfree(pagevec); if (result < 0) break; } nfs_pageio_complete(&desc); /* * If no bytes were started, return the error, and let the * generic layer handle the completion. */ if (requested_bytes == 0) { inode_dio_end(inode); nfs_direct_req_release(dreq); return result < 0 ? result : -EIO; } if (put_dreq(dreq)) nfs_direct_complete(dreq); return requested_bytes; } /** * nfs_file_direct_read - file direct read operation for NFS files * @iocb: target I/O control block * @iter: vector of user buffers into which to read data * * We use this function for direct reads instead of calling * generic_file_aio_read() in order to avoid gfar's check to see if * the request starts before the end of the file. For that check * to work, we must generate a GETATTR before each direct read, and * even then there is a window between the GETATTR and the subsequent * READ where the file size could change. Our preference is simply * to do all reads the application wants, and the server will take * care of managing the end of file boundary. * * This function also eliminates unnecessarily updating the file's * atime locally, as the NFS server sets the file's atime, and this * client must read the updated atime from the server back into its * cache. */ ssize_t nfs_file_direct_read(struct kiocb *iocb, struct iov_iter *iter) { struct file *file = iocb->ki_filp; struct address_space *mapping = file->f_mapping; struct inode *inode = mapping->host; struct nfs_direct_req *dreq; struct nfs_lock_context *l_ctx; ssize_t result = -EINVAL, requested; size_t count = iov_iter_count(iter); nfs_add_stats(mapping->host, NFSIOS_DIRECTREADBYTES, count); dfprintk(FILE, "NFS: direct read(%pD2, %zd@%Ld)\n", file, count, (long long) iocb->ki_pos); result = 0; if (!count) goto out; task_io_account_read(count); result = -ENOMEM; dreq = nfs_direct_req_alloc(); if (dreq == NULL) goto out; dreq->inode = inode; dreq->bytes_left = dreq->max_count = count; dreq->io_start = iocb->ki_pos; dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp)); l_ctx = nfs_get_lock_context(dreq->ctx); if (IS_ERR(l_ctx)) { result = PTR_ERR(l_ctx); goto out_release; } dreq->l_ctx = l_ctx; if (!is_sync_kiocb(iocb)) dreq->iocb = iocb; if (iter_is_iovec(iter)) dreq->flags = NFS_ODIRECT_SHOULD_DIRTY; nfs_start_io_direct(inode); NFS_I(inode)->read_io += count; requested = nfs_direct_read_schedule_iovec(dreq, iter, iocb->ki_pos); nfs_end_io_direct(inode); if (requested > 0) { result = nfs_direct_wait(dreq); if (result > 0) { requested -= result; iocb->ki_pos += result; } iov_iter_revert(iter, requested); } else { result = requested; } out_release: nfs_direct_req_release(dreq); out: return result; } static void nfs_direct_write_scan_commit_list(struct inode *inode, struct list_head *list, struct nfs_commit_info *cinfo) { mutex_lock(&NFS_I(cinfo->inode)->commit_mutex); #ifdef CONFIG_NFS_V4_1 if (cinfo->ds != NULL && cinfo->ds->nwritten != 0) NFS_SERVER(inode)->pnfs_curr_ld->recover_commit_reqs(list, cinfo); #endif nfs_scan_commit_list(&cinfo->mds->list, list, cinfo, 0); mutex_unlock(&NFS_I(cinfo->inode)->commit_mutex); } static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq) { struct nfs_pageio_descriptor desc; struct nfs_page *req, *tmp; LIST_HEAD(reqs); struct nfs_commit_info cinfo; LIST_HEAD(failed); nfs_init_cinfo_from_dreq(&cinfo, dreq); nfs_direct_write_scan_commit_list(dreq->inode, &reqs, &cinfo); dreq->count = 0; dreq->max_count = 0; list_for_each_entry(req, &reqs, wb_list) dreq->max_count += req->wb_bytes; dreq->verf.committed = NFS_INVALID_STABLE_HOW; nfs_clear_pnfs_ds_commit_verifiers(&dreq->ds_cinfo); get_dreq(dreq); nfs_pageio_init_write(&desc, dreq->inode, FLUSH_STABLE, false, &nfs_direct_write_completion_ops); desc.pg_dreq = dreq; list_for_each_entry_safe(req, tmp, &reqs, wb_list) { /* Bump the transmission count */ req->wb_nio++; if (!nfs_pageio_add_request(&desc, req)) { nfs_list_move_request(req, &failed); spin_lock(&cinfo.inode->i_lock); dreq->flags = 0; if (desc.pg_error < 0) dreq->error = desc.pg_error; else dreq->error = -EIO; spin_unlock(&cinfo.inode->i_lock); } nfs_release_request(req); } nfs_pageio_complete(&desc); while (!list_empty(&failed)) { req = nfs_list_entry(failed.next); nfs_list_remove_request(req); nfs_unlock_and_release_request(req); } if (put_dreq(dreq)) nfs_direct_write_complete(dreq); } static void nfs_direct_commit_complete(struct nfs_commit_data *data) { struct nfs_direct_req *dreq = data->dreq; struct nfs_commit_info cinfo; struct nfs_page *req; int status = data->task.tk_status; nfs_init_cinfo_from_dreq(&cinfo, dreq); if (status < 0 || nfs_direct_cmp_commit_data_verf(dreq, data)) dreq->flags = NFS_ODIRECT_RESCHED_WRITES; while (!list_empty(&data->pages)) { req = nfs_list_entry(data->pages.next); nfs_list_remove_request(req); if (dreq->flags == NFS_ODIRECT_RESCHED_WRITES) { /* * Despite the reboot, the write was successful, * so reset wb_nio. */ req->wb_nio = 0; /* Note the rewrite will go through mds */ nfs_mark_request_commit(req, NULL, &cinfo, 0); } else nfs_release_request(req); nfs_unlock_and_release_request(req); } if (atomic_dec_and_test(&cinfo.mds->rpcs_out)) nfs_direct_write_complete(dreq); } static void nfs_direct_resched_write(struct nfs_commit_info *cinfo, struct nfs_page *req) { struct nfs_direct_req *dreq = cinfo->dreq; spin_lock(&dreq->lock); dreq->flags = NFS_ODIRECT_RESCHED_WRITES; spin_unlock(&dreq->lock); nfs_mark_request_commit(req, NULL, cinfo, 0); } static const struct nfs_commit_completion_ops nfs_direct_commit_completion_ops = { .completion = nfs_direct_commit_complete, .resched_write = nfs_direct_resched_write, }; static void nfs_direct_commit_schedule(struct nfs_direct_req *dreq) { int res; struct nfs_commit_info cinfo; LIST_HEAD(mds_list); nfs_init_cinfo_from_dreq(&cinfo, dreq); nfs_scan_commit(dreq->inode, &mds_list, &cinfo); res = nfs_generic_commit_list(dreq->inode, &mds_list, 0, &cinfo); if (res < 0) /* res == -ENOMEM */ nfs_direct_write_reschedule(dreq); } static void nfs_direct_write_schedule_work(struct work_struct *work) { struct nfs_direct_req *dreq = container_of(work, struct nfs_direct_req, work); int flags = dreq->flags; dreq->flags = 0; switch (flags) { case NFS_ODIRECT_DO_COMMIT: nfs_direct_commit_schedule(dreq); break; case NFS_ODIRECT_RESCHED_WRITES: nfs_direct_write_reschedule(dreq); break; default: nfs_zap_mapping(dreq->inode, dreq->inode->i_mapping); nfs_direct_complete(dreq); } } static void nfs_direct_write_complete(struct nfs_direct_req *dreq) { queue_work(nfsiod_workqueue, &dreq->work); /* Calls nfs_direct_write_schedule_work */ } static void nfs_direct_write_completion(struct nfs_pgio_header *hdr) { struct nfs_direct_req *dreq = hdr->dreq; struct nfs_commit_info cinfo; bool request_commit = false; struct nfs_page *req = nfs_list_entry(hdr->pages.next); nfs_init_cinfo_from_dreq(&cinfo, dreq); spin_lock(&dreq->lock); if (test_bit(NFS_IOHDR_REDO, &hdr->flags)) { spin_unlock(&dreq->lock); goto out_put; } nfs_direct_count_bytes(dreq, hdr); if (hdr->good_bytes != 0) { if (nfs_write_need_commit(hdr)) { if (dreq->flags == NFS_ODIRECT_RESCHED_WRITES) request_commit = true; else if (dreq->flags == 0) { nfs_direct_set_hdr_verf(dreq, hdr); request_commit = true; dreq->flags = NFS_ODIRECT_DO_COMMIT; } else if (dreq->flags == NFS_ODIRECT_DO_COMMIT) { request_commit = true; if (nfs_direct_set_or_cmp_hdr_verf(dreq, hdr)) dreq->flags = NFS_ODIRECT_RESCHED_WRITES; } } } spin_unlock(&dreq->lock); while (!list_empty(&hdr->pages)) { req = nfs_list_entry(hdr->pages.next); nfs_list_remove_request(req); if (request_commit) { kref_get(&req->wb_kref); nfs_mark_request_commit(req, hdr->lseg, &cinfo, hdr->ds_commit_idx); } nfs_unlock_and_release_request(req); } out_put: if (put_dreq(dreq)) nfs_direct_write_complete(dreq); hdr->release(hdr); } static void nfs_write_sync_pgio_error(struct list_head *head, int error) { struct nfs_page *req; while (!list_empty(head)) { req = nfs_list_entry(head->next); nfs_list_remove_request(req); nfs_unlock_and_release_request(req); } } static void nfs_direct_write_reschedule_io(struct nfs_pgio_header *hdr) { struct nfs_direct_req *dreq = hdr->dreq; spin_lock(&dreq->lock); if (dreq->error == 0) { dreq->flags = NFS_ODIRECT_RESCHED_WRITES; /* fake unstable write to let common nfs resend pages */ hdr->verf.committed = NFS_UNSTABLE; hdr->good_bytes = hdr->args.offset + hdr->args.count - hdr->io_start; } spin_unlock(&dreq->lock); } static const struct nfs_pgio_completion_ops nfs_direct_write_completion_ops = { .error_cleanup = nfs_write_sync_pgio_error, .init_hdr = nfs_direct_pgio_init, .completion = nfs_direct_write_completion, .reschedule_io = nfs_direct_write_reschedule_io, }; /* * NB: Return the value of the first error return code. Subsequent * errors after the first one are ignored. */ /* * For each wsize'd chunk of the user's buffer, dispatch an NFS WRITE * operation. If nfs_writedata_alloc() or get_user_pages() fails, * bail and stop sending more writes. Write length accounting is * handled automatically by nfs_direct_write_result(). Otherwise, if * no requests have been sent, just return an error. */ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq, struct iov_iter *iter, loff_t pos) { struct nfs_pageio_descriptor desc; struct inode *inode = dreq->inode; ssize_t result = 0; size_t requested_bytes = 0; size_t wsize = max_t(size_t, NFS_SERVER(inode)->wsize, PAGE_SIZE); nfs_pageio_init_write(&desc, inode, FLUSH_COND_STABLE, false, &nfs_direct_write_completion_ops); desc.pg_dreq = dreq; get_dreq(dreq); inode_dio_begin(inode); NFS_I(inode)->write_io += iov_iter_count(iter); while (iov_iter_count(iter)) { struct page **pagevec; size_t bytes; size_t pgbase; unsigned npages, i; result = iov_iter_get_pages_alloc(iter, &pagevec, wsize, &pgbase); if (result < 0) break; bytes = result; iov_iter_advance(iter, bytes); npages = (result + pgbase + PAGE_SIZE - 1) / PAGE_SIZE; for (i = 0; i < npages; i++) { struct nfs_page *req; unsigned int req_len = min_t(size_t, bytes, PAGE_SIZE - pgbase); req = nfs_create_request(dreq->ctx, pagevec[i], pgbase, req_len); if (IS_ERR(req)) { result = PTR_ERR(req); break; } if (desc.pg_error < 0) { nfs_free_request(req); result = desc.pg_error; break; } nfs_lock_request(req); req->wb_index = pos >> PAGE_SHIFT; req->wb_offset = pos & ~PAGE_MASK; if (!nfs_pageio_add_request(&desc, req)) { result = desc.pg_error; nfs_unlock_and_release_request(req); break; } pgbase = 0; bytes -= req_len; requested_bytes += req_len; pos += req_len; dreq->bytes_left -= req_len; } nfs_direct_release_pages(pagevec, npages); kvfree(pagevec); if (result < 0) break; } nfs_pageio_complete(&desc); /* * If no bytes were started, return the error, and let the * generic layer handle the completion. */ if (requested_bytes == 0) { inode_dio_end(inode); nfs_direct_req_release(dreq); return result < 0 ? result : -EIO; } if (put_dreq(dreq)) nfs_direct_write_complete(dreq); return requested_bytes; } /** * nfs_file_direct_write - file direct write operation for NFS files * @iocb: target I/O control block * @iter: vector of user buffers from which to write data * * We use this function for direct writes instead of calling * generic_file_aio_write() in order to avoid taking the inode * semaphore and updating the i_size. The NFS server will set * the new i_size and this client must read the updated size * back into its cache. We let the server do generic write * parameter checking and report problems. * * We eliminate local atime updates, see direct read above. * * We avoid unnecessary page cache invalidations for normal cached * readers of this file. * * Note that O_APPEND is not supported for NFS direct writes, as there * is no atomic O_APPEND write facility in the NFS protocol. */ ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter) { ssize_t result = -EINVAL, requested; size_t count; struct file *file = iocb->ki_filp; struct address_space *mapping = file->f_mapping; struct inode *inode = mapping->host; struct nfs_direct_req *dreq; struct nfs_lock_context *l_ctx; loff_t pos, end; dfprintk(FILE, "NFS: direct write(%pD2, %zd@%Ld)\n", file, iov_iter_count(iter), (long long) iocb->ki_pos); result = generic_write_checks(iocb, iter); if (result <= 0) return result; count = result; nfs_add_stats(mapping->host, NFSIOS_DIRECTWRITTENBYTES, count); pos = iocb->ki_pos; end = (pos + iov_iter_count(iter) - 1) >> PAGE_SHIFT; task_io_account_write(count); result = -ENOMEM; dreq = nfs_direct_req_alloc(); if (!dreq) goto out; dreq->inode = inode; dreq->bytes_left = dreq->max_count = count; dreq->io_start = pos; dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp)); l_ctx = nfs_get_lock_context(dreq->ctx); if (IS_ERR(l_ctx)) { result = PTR_ERR(l_ctx); goto out_release; } dreq->l_ctx = l_ctx; if (!is_sync_kiocb(iocb)) dreq->iocb = iocb; nfs_start_io_direct(inode); requested = nfs_direct_write_schedule_iovec(dreq, iter, pos); if (mapping->nrpages) { invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT, end); } nfs_end_io_direct(inode); if (requested > 0) { result = nfs_direct_wait(dreq); if (result > 0) { requested -= result; iocb->ki_pos = pos + result; /* XXX: should check the generic_write_sync retval */ generic_write_sync(iocb, result); } iov_iter_revert(iter, requested); } else { result = requested; } out_release: nfs_direct_req_release(dreq); out: return result; } /** * nfs_init_directcache - create a slab cache for nfs_direct_req structures * */ int __init nfs_init_directcache(void) { nfs_direct_cachep = kmem_cache_create("nfs_direct_cache", sizeof(struct nfs_direct_req), 0, (SLAB_RECLAIM_ACCOUNT| SLAB_MEM_SPREAD), NULL); if (nfs_direct_cachep == NULL) return -ENOMEM; return 0; } /** * nfs_destroy_directcache - destroy the slab cache for nfs_direct_req structures * */ void nfs_destroy_directcache(void) { kmem_cache_destroy(nfs_direct_cachep); }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1