Release 4.10 fs/nfs/direct.c

Directory: fs/nfs
/*
 * 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;

/*
 * This represents a set of asynchronous requests that we're waiting on
 */

struct nfs_direct_mirror {
	
ssize_t count;
};


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 */

	
struct nfs_direct_mirror mirrors[NFS_PAGEIO_DESCRIPTOR_MIRROR_MAX];
	
int			mirror_count;

	
ssize_t			count,		/* bytes actually processed */
				
max_count,	/* max expected count */
				
bytes_left,	/* bytes left to be sent */
				
io_start,	/* start of IO */
				
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;

#define NFS_ODIRECT_DO_COMMIT		(1)	/* an unstable reply was received */

#define NFS_ODIRECT_RESCHED_WRITES	(2)	/* write verification failed */
	
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);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 14 70.00% 1 50.00%
chuck lever chuck lever 6 30.00% 1 50.00%
Total 20 100.00% 2 100.00%



static inline int put_dreq(struct nfs_direct_req *dreq)
{
	return atomic_dec_and_test(&dreq->io_count);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 18 85.71% 1 33.33%
chuck lever chuck lever 3 14.29% 2 66.67%
Total 21 100.00% 3 100.00%


static void

nfs_direct_good_bytes(struct nfs_direct_req *dreq, struct nfs_pgio_header *hdr)
{
	int i;
	ssize_t count;

	WARN_ON_ONCE(dreq->count >= dreq->max_count);

	if (dreq->mirror_count == 1) {
		dreq->mirrors[hdr->pgio_mirror_idx].count += hdr->good_bytes;
		dreq->count += hdr->good_bytes;
	} else {
		/* mirrored writes */
		count = dreq->mirrors[hdr->pgio_mirror_idx].count;
		if (count + dreq->io_start < hdr->io_start + hdr->good_bytes) {
			count = hdr->io_start + hdr->good_bytes - dreq->io_start;
			dreq->mirrors[hdr->pgio_mirror_idx].count = count;
		}
		/* update the dreq->count by finding the minimum agreed count from all
                 * mirrors */
		count = dreq->mirrors[0].count;

		for (i = 1; i < dreq->mirror_count; i++)
			count = min(count, dreq->mirrors[i].count);

		dreq->count = count;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 108 61.02% 2 50.00%
peng tao peng tao 69 38.98% 2 50.00%
Total 177 100.00% 4 100.00%

/*
 * 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;
}


Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 79 89.77% 2 66.67%
kinglong mee kinglong mee 9 10.23% 1 33.33%
Total 88 100.00% 3 100.00%

/*
 * 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);
}

Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 70 100.00% 2 100.00%
Total 70 100.00% 2 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 32 100.00% 1 100.00%
Total 32 100.00% 1 100.00%

/*
 * 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);
}

Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 66 98.51% 2 66.67%
trond myklebust trond myklebust 1 1.49% 1 33.33%
Total 67 100.00% 3 100.00%

/*
 * 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)
		return 1;

	return nfs_direct_cmp_verf(verfp, &data->verf);
}

Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 58 98.31% 2 66.67%
trond myklebust trond myklebust 1 1.69% 1 33.33%
Total 59 100.00% 3 100.00%

/**
 * 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);
}

Contributors
Person Tokens Prop Commits CommitProp
peng tao peng tao 25 33.33% 1 16.67%
mel gorman mel gorman 25 33.33% 1 16.67%
chuck lever chuck lever 13 17.33% 1 16.67%
christoph hellwig christoph hellwig 4 5.33% 1 16.67%
al viro al viro 4 5.33% 1 16.67%
omar sandoval omar sandoval 4 5.33% 1 16.67%
Total 75 100.00% 6 100.00%



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]);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 38 92.68% 2 50.00%
chuck lever chuck lever 2 4.88% 1 25.00%
kirill a. shutemov kirill a. shutemov 1 2.44% 1 25.00%
Total 41 100.00% 4 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 52 96.30% 1 33.33%
dave wysochanski dave wysochanski 1 1.85% 1 33.33%
trond myklebust trond myklebust 1 1.85% 1 33.33%
Total 54 100.00% 3 100.00%



static inline void nfs_direct_setup_mirroring(struct nfs_direct_req *dreq,
					     struct nfs_pageio_descriptor *pgio,
					     struct nfs_page *req)
{
	int mirror_count = 1;

	if (pgio->pg_ops->pg_get_mirror_count)
		mirror_count = pgio->pg_ops->pg_get_mirror_count(pgio, req);

	dreq->mirror_count = mirror_count;
}

Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%



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);
	dreq->mirror_count = 1;
	spin_lock_init(&dreq->lock);

	return dreq;
}

Contributors
Person Tokens Prop Commits CommitProp
chuck lever chuck lever 53 51.46% 3 25.00%
trond myklebust trond myklebust 19 18.45% 5 41.67%
weston andros adamson weston andros adamson 15 14.56% 2 16.67%
fred isaman fred isaman 15 14.56% 1 8.33%
christoph lameter christoph lameter 1 0.97% 1 8.33%
Total 103 100.00% 12 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 57 80.28% 4 66.67%
peng tao peng tao 8 11.27% 1 16.67%
chuck lever chuck lever 6 8.45% 1 16.67%
Total 71 100.00% 6 100.00%



static void nfs_direct_req_release(struct nfs_direct_req *dreq)
{
	kref_put(&dreq->kref, nfs_direct_req_free);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq)
{
	return dreq->bytes_left;
}
Contributors
Person Tokens Prop Commits CommitProp
peng tao peng tao 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%


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;
}

Contributors
Person Tokens Prop Commits CommitProp
chuck lever chuck lever 41 52.56% 3 33.33%
trond myklebust trond myklebust 36 46.15% 5 55.56%
matthew wilcox matthew wilcox 1 1.28% 1 11.11%
Total 78 100.00% 9 100.00%

/*
 * 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);
}

Contributors
Person Tokens Prop Commits CommitProp
christoph hellwig christoph hellwig 47 47.47% 3 27.27%
trond myklebust trond myklebust 34 34.34% 5 45.45%
chuck lever chuck lever 16 16.16% 1 9.09%
jens axboe jens axboe 1 1.01% 1 9.09%
daniel wagner daniel wagner 1 1.01% 1 9.09%
Total 99 100.00% 11 100.00%



static void nfs_direct_readpage_release(struct nfs_page *req)
{
	dprintk("NFS: direct read done (%s/%llu %d@%lld)\n",
		req->wb_context->dentry->d_sb->s_id,
		(unsigned long long)NFS_FILEID(d_inode(req->wb_context->dentry)),
		req->wb_bytes,
		(long long)req_offset(req));
	nfs_release_request(req);
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 43 70.49% 1 12.50%
trond myklebust trond myklebust 12 19.67% 4 50.00%
david howells david howells 3 4.92% 1 12.50%
niels de vos niels de vos 2 3.28% 1 12.50%
al viro al viro 1 1.64% 1 12.50%
Total 61 100.00% 8 100.00%



static void nfs_direct_read_completion(struct nfs_pgio_header *hdr)
{
	unsigned long bytes = 0;
	struct nfs_direct_req *dreq = hdr->dreq;

	if (test_bit(NFS_IOHDR_REDO, &hdr->flags))
		goto out_put;

	spin_lock(&dreq->lock);
	if (test_bit(NFS_IOHDR_ERROR, &hdr->flags) && (hdr->good_bytes == 0))
		dreq->error = hdr->error;
	else
		nfs_direct_good_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)
			set_page_dirty(page);
		bytes += req->wb_bytes;
		nfs_list_remove_request(req);
		nfs_direct_readpage_release(req);
	}
out_put:
	if (put_dreq(dreq))
		nfs_direct_complete(dreq);
	hdr->release(hdr);
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 125 67.57% 2 18.18%
trond myklebust trond myklebust 44 23.78% 6 54.55%
chuck lever chuck lever 11 5.95% 1 9.09%
weston andros adamson weston andros adamson 4 2.16% 1 9.09%
jeff layton jeff layton 1 0.54% 1 9.09%
Total 185 100.00% 11 100.00%



static void nfs_read_sync_pgio_error(struct list_head *head)
{
	struct nfs_page *req;

	while (!list_empty(head)) {
		req = nfs_list_entry(head->next);
		nfs_list_remove_request(req);
		nfs_release_request(req);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 44 97.78% 2 66.67%
trond myklebust trond myklebust 1 2.22% 1 33.33%
Total 45 100.00% 3 100.00%



static void nfs_direct_pgio_init(struct nfs_pgio_header *hdr)
{
	get_dreq(hdr->dreq);
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 18 100.00% 2 100.00%
Total 18 100.00% 2 100.00%


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], NULL,
						 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 0;
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 110 29.73% 3 9.38%
trond myklebust trond myklebust 84 22.70% 13 40.62%
al viro al viro 80 21.62% 1 3.12%
chuck lever chuck lever 73 19.73% 9 28.12%
mel gorman mel gorman 7 1.89% 1 3.12%
peng tao peng tao 6 1.62% 1 3.12%
christoph hellwig christoph hellwig 4 1.08% 1 3.12%
weston andros adamson weston andros adamson 2 0.54% 1 3.12%
jens axboe jens axboe 2 0.54% 1 3.12%
linus torvalds linus torvalds 2 0.54% 1 3.12%
Total 370 100.00% 32 100.00%

/**
 * 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;
	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;

	nfs_start_io_direct(inode);

	NFS_I(inode)->read_io += count;
	result = nfs_direct_read_schedule_iovec(dreq, iter, iocb->ki_pos);

	nfs_end_io_direct(inode);

	if (!result) {
		result = nfs_direct_wait(dreq);
		if (result > 0)
			iocb->ki_pos += result;
	}

out_release:
	nfs_direct_req_release(dreq);
out:
	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 114 39.58% 10 40.00%
christoph hellwig christoph hellwig 103 35.76% 3 12.00%
chuck lever chuck lever 40 13.89% 6 24.00%
peng tao peng tao 18 6.25% 3 12.00%
al viro al viro 9 3.12% 2 8.00%
weston andros adamson weston andros adamson 4 1.39% 1 4.00%
Total 288 100.00% 25 100.00%


static void

nfs_direct_write_scan_commit_list(struct inode *inode,
				  struct list_head *list,
				  struct nfs_commit_info *cinfo)
{
	spin_lock(&cinfo->inode->i_lock);
#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);
	spin_unlock(&cinfo->inode->i_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
tom haynes tom haynes 84 91.30% 1 50.00%
dave wysochanski dave wysochanski 8 8.70% 1 50.00%
Total 92 100.00% 2 100.00%



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);
	int i;

	nfs_init_cinfo_from_dreq(&cinfo, dreq);
	nfs_direct_write_scan_commit_list(dreq->inode, &reqs, &cinfo);

	dreq->count = 0;
	dreq->verf.committed = NFS_INVALID_STABLE_HOW;
	nfs_clear_pnfs_ds_commit_verifiers(&dreq->ds_cinfo);
	for (i = 0; i < dreq->mirror_count; i++)
		dreq->mirrors[i].count = 0;
	get_dreq(dreq);

	nfs_pageio_init_write(&desc, dreq->inode, FLUSH_STABLE, false,
			      &nfs_direct_write_completion_ops);
	desc.pg_dreq = dreq;

	req = nfs_list_entry(reqs.next);
	nfs_direct_setup_mirroring(dreq, &desc, req);
	if (desc.pg_error < 0) {
		list_splice_init(&reqs, &failed);
		goto out_failed;
	}

	list_for_each_entry_safe(req, tmp, &reqs, wb_list) {
		if (!nfs_pageio_add_request(&desc, req)) {
			nfs_list_remove_request(req);
			nfs_list_add_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);

out_failed:
	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);
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 115 35.83% 2 8.33%
trond myklebust trond myklebust 100 31.15% 13 54.17%
weston andros adamson weston andros adamson 42 13.08% 1 4.17%
peng tao peng tao 41 12.77% 1 4.17%
chuck lever chuck lever 11 3.43% 4 16.67%
dave wysochanski dave wysochanski 8 2.49% 1 4.17%
christoph hellwig christoph hellwig 3 0.93% 1 4.17%
tom haynes tom haynes 1 0.31% 1 4.17%
Total 321 100.00% 24 100.00%



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) {
		dprintk("NFS: %5u commit failed with error %d.\n",
			data->task.tk_pid, status);
		dreq->flags = NFS_ODIRECT_RESCHED_WRITES;
	} else if (nfs_direct_cmp_commit_data_verf(dreq, data)) {
		dprintk("NFS: %5u commit verify failed\n", data->task.tk_pid);
		dreq->flags = NFS_ODIRECT_RESCHED_WRITES;
	}

	dprintk("NFS: %5u commit returned %d\n", data->task.tk_pid, status);
	while (!list_empty(&data->pages)) {
		req = nfs_list_entry(data->pages.next);
		nfs_list_remove_request(req);
		if (dreq->flags == NFS_ODIRECT_RESCHED_WRITES) {
			/* 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);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 101 51.79% 6 54.55%
fred isaman fred isaman 91 46.67% 3 27.27%
weston andros adamson weston andros adamson 3 1.54% 2 18.18%
Total 195 100.00% 11 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 50 86.21% 1 50.00%
fred isaman fred isaman 8 13.79% 1 50.00%
Total 58 100.00% 2 100.00%


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);
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 42 57.53% 1 11.11%
trond myklebust trond myklebust 30 41.10% 7 77.78%
chuck lever chuck lever 1 1.37% 1 11.11%
Total 73 100.00% 9 100.00%



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);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 60 73.17% 4 57.14%
fred isaman fred isaman 18 21.95% 1 14.29%
chuck lever chuck lever 3 3.66% 1 14.29%
christoph hellwig christoph hellwig 1 1.22% 1 14.29%
Total 82 100.00% 7 100.00%



static void nfs_direct_write_complete(struct nfs_direct_req *dreq)
{
	schedule_work(&dreq->work); /* Calls nfs_direct_write_schedule_work */
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 13 65.00% 5 83.33%
fred isaman fred isaman 7 35.00% 1 16.67%
Total 20 100.00% 6 100.00%



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);

	if (test_bit(NFS_IOHDR_REDO, &hdr->flags))
		goto out_put;

	nfs_init_cinfo_from_dreq(&cinfo, dreq);

	spin_lock(&dreq->lock);

	if (test_bit(NFS_IOHDR_ERROR, &hdr->flags)) {
		dreq->flags = 0;
		dreq->error = hdr->error;
	}
	if (dreq->error == 0) {
		nfs_direct_good_bytes(dreq, hdr);
		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);
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 174 59.79% 4 13.79%
trond myklebust trond myklebust 71 24.40% 15 51.72%
weston andros adamson weston andros adamson 25 8.59% 4 13.79%
chuck lever chuck lever 21 7.22% 6 20.69%
Total 291 100.00% 29 100.00%



static void nfs_write_sync_pgio_error(struct list_head *head)
{
	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);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 45 100.00% 2 100.00%
Total 45 100.00% 2 100.00%



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.count;
	}
	spin_unlock(&dreq->lock);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 71 100.00% 1 100.00%
Total 71 100.00% 1 100.00%


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], NULL,
						 pgbase, req_len);
			if (IS_ERR(req)) {
				result = PTR_ERR(req);
				break;
			}

			nfs_direct_setup_mirroring(dreq, &desc, req);
			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 0;
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 211 50.60% 3 21.43%
chuck lever chuck lever 108 25.90% 2 14.29%
peng tao peng tao 36 8.63% 2 14.29%
fred isaman fred isaman 28 6.71% 1 7.14%
trond myklebust trond myklebust 17 4.08% 1 7.14%
weston andros adamson weston andros adamson 10 2.40% 1 7.14%
christoph hellwig christoph hellwig 3 0.72% 1 7.14%
jens axboe jens axboe 2 0.48% 1 7.14%
linus torvalds linus torvalds 1 0.24% 1 7.14%
mel gorman mel gorman 1 0.24% 1 7.14%
Total 417 100.00% 14 100.00%

/**
 * 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;
	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);

	result = 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 (!result) {
		result = nfs_direct_wait(dreq);
		if (result > 0) {
			iocb->ki_pos = pos + result;
			/* XXX: should check the generic_write_sync retval */
			generic_write_sync(iocb, result);
		}
	}
out_release:
	nfs_direct_req_release(dreq);
out:
	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
christoph hellwig christoph hellwig 164 48.38% 4 15.38%
trond myklebust trond myklebust 97 28.61% 4 15.38%
al viro al viro 38 11.21% 4 15.38%
chuck lever chuck lever 21 6.19% 8 30.77%
peng tao peng tao 6 1.77% 1 3.85%
konstantin khlebnikov konstantin khlebnikov 4 1.18% 1 3.85%
weston andros adamson weston andros adamson 4 1.18% 1 3.85%
kirill a. shutemov kirill a. shutemov 2 0.59% 1 3.85%
fred isaman fred isaman 2 0.59% 1 3.85%
badari pulavarty badari pulavarty 1 0.29% 1 3.85%
Total 339 100.00% 26 100.00%

/**
 * 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;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 39 88.64% 1 25.00%
paul jackson paul jackson 4 9.09% 2 50.00%
david howells david howells 1 2.27% 1 25.00%
Total 44 100.00% 4 100.00%

/**
 * nfs_destroy_directcache - destroy the slab cache for nfs_direct_req structures
 *
 */


void nfs_destroy_directcache(void)
{
	kmem_cache_destroy(nfs_direct_cachep);
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 12 100.00% 1 100.00%
Total 12 100.00% 1 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 1344 30.06% 53 34.42%
fred isaman fred isaman 973 21.76% 9 5.84%
weston andros adamson weston andros adamson 569 12.73% 8 5.19%
chuck lever chuck lever 480 10.74% 30 19.48%
al viro al viro 346 7.74% 9 5.84%
christoph hellwig christoph hellwig 331 7.40% 13 8.44%
peng tao peng tao 238 5.32% 8 5.19%
tom haynes tom haynes 85 1.90% 1 0.65%
mel gorman mel gorman 33 0.74% 1 0.65%
dave wysochanski dave wysochanski 17 0.38% 1 0.65%
kinglong mee kinglong mee 9 0.20% 1 0.65%
konstantin khlebnikov konstantin khlebnikov 7 0.16% 1 0.65%
jens axboe jens axboe 5 0.11% 1 0.65%
david howells david howells 5 0.11% 2 1.30%
paul jackson paul jackson 4 0.09% 2 1.30%
omar sandoval omar sandoval 4 0.09% 1 0.65%
linus torvalds linus torvalds 4 0.09% 2 1.30%
tejun heo tejun heo 3 0.07% 1 0.65%
christoph lameter christoph lameter 3 0.07% 2 1.30%
kirill a. shutemov kirill a. shutemov 3 0.07% 1 0.65%
niels de vos niels de vos 2 0.04% 1 0.65%
badari pulavarty badari pulavarty 1 0.02% 1 0.65%
arun sharma arun sharma 1 0.02% 1 0.65%
daniel wagner daniel wagner 1 0.02% 1 0.65%
jeff layton jeff layton 1 0.02% 1 0.65%
andy adamson andy adamson 1 0.02% 1 0.65%
matthew wilcox matthew wilcox 1 0.02% 1 0.65%
Total 4471 100.00% 154 100.00%
Directory: fs/nfs

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
trond myklebust	trond myklebust	14	70.00%	1	50.00%
chuck lever	chuck lever	6	30.00%	1	50.00%
	Total	20	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 fs/nfs/direct.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
