Release 4.10 fs/nfs/write.c

Directory: fs/nfs
/*
 * linux/fs/nfs/write.c
 *
 * Write file data over NFS.
 *
 * Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
 */

#include <linux/types.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/pagemap.h>
#include <linux/file.h>
#include <linux/writeback.h>
#include <linux/swap.h>
#include <linux/migrate.h>

#include <linux/sunrpc/clnt.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_mount.h>
#include <linux/nfs_page.h>
#include <linux/backing-dev.h>
#include <linux/export.h>
#include <linux/freezer.h>
#include <linux/wait.h>

#include <linux/uaccess.h>

#include "delegation.h"
#include "internal.h"
#include "iostat.h"
#include "nfs4_fs.h"
#include "fscache.h"
#include "pnfs.h"

#include "nfstrace.h"


#define NFSDBG_FACILITY		NFSDBG_PAGECACHE


#define MIN_POOL_WRITE		(32)

#define MIN_POOL_COMMIT		(4)

/*
 * Local function declarations
 */
static void nfs_redirty_request(struct nfs_page *req);

static const struct rpc_call_ops nfs_commit_ops;

static const struct nfs_pgio_completion_ops nfs_async_write_completion_ops;

static const struct nfs_commit_completion_ops nfs_commit_completion_ops;

static const struct nfs_rw_ops nfs_rw_write_ops;
static void nfs_clear_request_commit(struct nfs_page *req);
static void nfs_init_cinfo_from_inode(struct nfs_commit_info *cinfo,
				      struct inode *inode);
static struct nfs_page *
nfs_page_search_commits_for_head_request_locked(struct nfs_inode *nfsi,
						struct page *page);


static struct kmem_cache *nfs_wdata_cachep;

static mempool_t *nfs_wdata_mempool;

static struct kmem_cache *nfs_cdata_cachep;

static mempool_t *nfs_commit_mempool;



struct nfs_commit_data *nfs_commitdata_alloc(void)
{
	struct nfs_commit_data *p = mempool_alloc(nfs_commit_mempool, GFP_NOIO);

	if (p) {
		memset(p, 0, sizeof(*p));
		INIT_LIST_HEAD(&p->pages);
	}
	return p;
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 48 94.12% 3 60.00%
fred isaman fred isaman 2 3.92% 1 20.00%
mel gorman mel gorman 1 1.96% 1 20.00%
Total 51 100.00% 5 100.00%


EXPORT_SYMBOL_GPL(nfs_commitdata_alloc);



void nfs_commit_free(struct nfs_commit_data *p)
{
	mempool_free(p, nfs_commit_mempool);
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 16 94.12% 3 75.00%
fred isaman fred isaman 1 5.88% 1 25.00%
Total 17 100.00% 4 100.00%


EXPORT_SYMBOL_GPL(nfs_commit_free);



static struct nfs_pgio_header *nfs_writehdr_alloc(void)
{
	struct nfs_pgio_header *p = mempool_alloc(nfs_wdata_mempool, GFP_NOIO);

	if (p)
		memset(p, 0, sizeof(*p));
	return p;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 32 76.19% 2 28.57%
fred isaman fred isaman 6 14.29% 2 28.57%
weston andros adamson weston andros adamson 2 4.76% 1 14.29%
mel gorman mel gorman 1 2.38% 1 14.29%
anna schumaker anna schumaker 1 2.38% 1 14.29%
Total 42 100.00% 7 100.00%



static void nfs_writehdr_free(struct nfs_pgio_header *hdr)
{
	mempool_free(hdr, nfs_wdata_mempool);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 10 55.56% 2 40.00%
anna schumaker anna schumaker 3 16.67% 1 20.00%
weston andros adamson weston andros adamson 3 16.67% 1 20.00%
fred isaman fred isaman 2 11.11% 1 20.00%
Total 18 100.00% 5 100.00%



static void nfs_context_set_write_error(struct nfs_open_context *ctx, int error)
{
	ctx->error = error;
	smp_wmb();
	set_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 27 81.82% 2 50.00%
fred isaman fred isaman 6 18.18% 2 50.00%
Total 33 100.00% 4 100.00%

/*
 * nfs_page_find_head_request_locked - find head request associated with @page
 *
 * must be called while holding the inode lock.
 *
 * returns matching head request with reference held, or NULL if not found.
 */

static struct nfs_page *

nfs_page_find_head_request_locked(struct nfs_inode *nfsi, struct page *page)
{
	struct nfs_page *req = NULL;

	if (PagePrivate(page))
		req = (struct nfs_page *)page_private(page);
	else if (unlikely(PageSwapCache(page)))
		req = nfs_page_search_commits_for_head_request_locked(nfsi,
			page);

	if (req) {
		WARN_ON_ONCE(req->wb_head != req);
		kref_get(&req->wb_kref);
	}

	return req;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 34 37.78% 3 33.33%
fred isaman fred isaman 29 32.22% 2 22.22%
weston andros adamson weston andros adamson 17 18.89% 2 22.22%
mel gorman mel gorman 9 10.00% 1 11.11%
chuck lever chuck lever 1 1.11% 1 11.11%
Total 90 100.00% 9 100.00%

/*
 * nfs_page_find_head_request - find head request associated with @page
 *
 * returns matching head request with reference held, or NULL if not found.
 */


static struct nfs_page *nfs_page_find_head_request(struct page *page)
{
	struct inode *inode = page_file_mapping(page)->host;
	struct nfs_page *req = NULL;

	spin_lock(&inode->i_lock);
	req = nfs_page_find_head_request_locked(NFS_I(inode), page);
	spin_unlock(&inode->i_lock);
	return req;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 49 77.78% 5 50.00%
mel gorman mel gorman 5 7.94% 2 20.00%
fred isaman fred isaman 4 6.35% 1 10.00%
bryan schumaker bryan schumaker 3 4.76% 1 10.00%
weston andros adamson weston andros adamson 2 3.17% 1 10.00%
Total 63 100.00% 10 100.00%

/* Adjust the file length if we're writing beyond the end */


static void nfs_grow_file(struct page *page, unsigned int offset, unsigned int count)
{
	struct inode *inode = page_file_mapping(page)->host;
	loff_t end, i_size;
	pgoff_t end_index;

	spin_lock(&inode->i_lock);
	i_size = i_size_read(inode);
	end_index = (i_size - 1) >> PAGE_SHIFT;
	if (i_size > 0 && page_index(page) < end_index)
		goto out;
	end = page_file_offset(page) + ((loff_t)offset+count);
	if (i_size >= end)
		goto out;
	i_size_write(inode, end);
	nfs_inc_stats(inode, NFSIOS_EXTENDWRITE);
out:
	spin_unlock(&inode->i_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 99 76.74% 6 42.86%
fred isaman fred isaman 14 10.85% 2 14.29%
pre-git pre-git 5 3.88% 1 7.14%
chuck lever chuck lever 4 3.10% 1 7.14%
bryan schumaker bryan schumaker 3 2.33% 1 7.14%
mel gorman mel gorman 2 1.55% 1 7.14%
kirill a. shutemov kirill a. shutemov 1 0.78% 1 7.14%
huang ying huang ying 1 0.78% 1 7.14%
Total 129 100.00% 14 100.00%

/* A writeback failed: mark the page as bad, and invalidate the page cache */


static void nfs_set_pageerror(struct page *page)
{
	nfs_zap_mapping(page_file_mapping(page)->host, page_file_mapping(page));
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 20 76.92% 2 50.00%
mel gorman mel gorman 6 23.08% 2 50.00%
Total 26 100.00% 4 100.00%

/*
 * nfs_page_group_search_locked
 * @head - head request of page group
 * @page_offset - offset into page
 *
 * Search page group with head @head to find a request that contains the
 * page offset @page_offset.
 *
 * Returns a pointer to the first matching nfs request, or NULL if no
 * match is found.
 *
 * Must be called with the page group lock held
 */

static struct nfs_page *

nfs_page_group_search_locked(struct nfs_page *head, unsigned int page_offset)
{
	struct nfs_page *req;

	WARN_ON_ONCE(head != head->wb_head);
	WARN_ON_ONCE(!test_bit(PG_HEADLOCK, &head->wb_head->wb_flags));

	req = head;
	do {
		if (page_offset >= req->wb_pgbase &&
		    page_offset < (req->wb_pgbase + req->wb_bytes))
			return req;

		req = req->wb_this_page;
	} while (req != head);

	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 64 68.82% 1 25.00%
mel gorman mel gorman 17 18.28% 1 25.00%
trond myklebust trond myklebust 12 12.90% 2 50.00%
Total 93 100.00% 4 100.00%

/*
 * nfs_page_group_covers_page
 * @head - head request of page group
 *
 * Return true if the page group with head @head covers the whole page,
 * returns false otherwise
 */


static bool nfs_page_group_covers_page(struct nfs_page *req)
{
	struct nfs_page *tmp;
	unsigned int pos = 0;
	unsigned int len = nfs_page_length(req->wb_page);

	nfs_page_group_lock(req, false);

	do {
		tmp = nfs_page_group_search_locked(req->wb_head, pos);
		if (tmp) {
			/* no way this should happen */
			WARN_ON_ONCE(tmp->wb_pgbase != pos);
			pos += tmp->wb_bytes - (pos - tmp->wb_pgbase);
		}
	} while (tmp && pos < len);

	nfs_page_group_unlock(req);
	WARN_ON_ONCE(pos > len);
	return pos == len;
}

Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 77 70.00% 3 42.86%
trond myklebust trond myklebust 31 28.18% 3 42.86%
mel gorman mel gorman 2 1.82% 1 14.29%
Total 110 100.00% 7 100.00%

/* We can set the PG_uptodate flag if we see that a write request
 * covers the full page.
 */


static void nfs_mark_uptodate(struct nfs_page *req)
{
	if (PageUptodate(req->wb_page))
		return;
	if (!nfs_page_group_covers_page(req))
		return;
	SetPageUptodate(req->wb_page);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 25 67.57% 1 50.00%
weston andros adamson weston andros adamson 12 32.43% 1 50.00%
Total 37 100.00% 2 100.00%



static int wb_priority(struct writeback_control *wbc)
{
	int ret = 0;

	if (wbc->sync_mode == WB_SYNC_ALL)
		ret = FLUSH_COND_STABLE;
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 17 54.84% 1 50.00%
neil brown neil brown 14 45.16% 1 50.00%
Total 31 100.00% 2 100.00%

/*
 * NFS congestion control
 */


int nfs_congestion_kb;


#define NFS_CONGESTION_ON_THRESH 	(nfs_congestion_kb >> (PAGE_SHIFT-10))

#define NFS_CONGESTION_OFF_THRESH	\
	(NFS_CONGESTION_ON_THRESH - (NFS_CONGESTION_ON_THRESH >> 2))



static void nfs_set_page_writeback(struct page *page)
{
	struct nfs_server *nfss = NFS_SERVER(page_file_mapping(page)->host);
	int ret = test_set_page_writeback(page);

	WARN_ON_ONCE(ret != 0);

	if (atomic_long_inc_return(&nfss->writeback) >
			NFS_CONGESTION_ON_THRESH) {
		set_bdi_congested(&nfss->backing_dev_info,
					BLK_RW_ASYNC);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
peter zijlstra peter zijlstra 42 64.62% 2 40.00%
trond myklebust trond myklebust 17 26.15% 1 20.00%
mel gorman mel gorman 3 4.62% 1 20.00%
jens axboe jens axboe 3 4.62% 1 20.00%
Total 65 100.00% 5 100.00%



static void nfs_end_page_writeback(struct nfs_page *req)
{
	struct inode *inode = page_file_mapping(req->wb_page)->host;
	struct nfs_server *nfss = NFS_SERVER(inode);

	if (!nfs_page_group_sync_on_bit(req, PG_WB_END))
		return;

	end_page_writeback(req->wb_page);
	if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
		clear_bdi_congested(&nfss->backing_dev_info, BLK_RW_ASYNC);
}


Contributors
Person Tokens Prop Commits CommitProp
peter zijlstra peter zijlstra 52 69.33% 2 40.00%
weston andros adamson weston andros adamson 19 25.33% 1 20.00%
mel gorman mel gorman 3 4.00% 1 20.00%
jens axboe jens axboe 1 1.33% 1 20.00%
Total 75 100.00% 5 100.00%

/* nfs_page_group_clear_bits
 *   @req - an nfs request
 * clears all page group related bits from @req
 */

static void

nfs_page_group_clear_bits(struct nfs_page *req)
{
	clear_bit(PG_TEARDOWN, &req->wb_flags);
	clear_bit(PG_UNLOCKPAGE, &req->wb_flags);
	clear_bit(PG_UPTODATE, &req->wb_flags);
	clear_bit(PG_WB_END, &req->wb_flags);
	clear_bit(PG_REMOVE, &req->wb_flags);
}


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

/*
 * nfs_unroll_locks_and_wait -  unlock all newly locked reqs and wait on @req
 *
 * this is a helper function for nfs_lock_and_join_requests
 *
 * @inode - inode associated with request page group, must be holding inode lock
 * @head  - head request of page group, must be holding head lock
 * @req   - request that couldn't lock and needs to wait on the req bit lock
 * @nonblock - if true, don't actually wait
 *
 * NOTE: this must be called holding page_group bit lock and inode spin lock
 *       and BOTH will be released before returning.
 *
 * returns 0 on success, < 0 on error.
 */

static int
nfs_unroll_locks_and_wait(struct inode *inode, struct nfs_page *head,
			  struct nfs_page *req, bool nonblock)
	__releases(&inode->i_lockContributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%

)
{
	struct nfs_page *tmp;
	int ret;

	/* relinquish all the locks successfully grabbed this run */
	for (tmp = head ; tmp != req; tmp = tmp->wb_this_page)
		nfs_unlock_request(tmp);

	WARN_ON_ONCE(test_bit(PG_TEARDOWN, &req->wb_flags));

	/* grab a ref on the request that will be waited on */
	kref_get(&req->wb_kref);

	nfs_page_group_unlock(head);
	spin_unlock(&inode->i_lock);

	/* release ref from nfs_page_find_head_request_locked */
	nfs_release_request(head);

	if (!nonblock)
		ret = nfs_wait_on_request(req);
	else
		ret = -EAGAIN;
	nfs_release_request(req);

	return ret;
}

/*
 * nfs_destroy_unlinked_subrequests - destroy recently unlinked subrequests
 *
 * @destroy_list - request list (using wb_this_page) terminated by @old_head
 * @old_head - the old head of the list
 *
 * All subrequests must be locked and removed from all lists, so at this point
 * they are only "active" in this function, and possibly in nfs_wait_on_request
 * with a reference held by some other context.
 */

static void

nfs_destroy_unlinked_subrequests(struct nfs_page *destroy_list,
				 struct nfs_page *old_head)
{
	while (destroy_list) {
		struct nfs_page *subreq = destroy_list;

		destroy_list = (subreq->wb_this_page == old_head) ?
				   NULL : subreq->wb_this_page;

		WARN_ON_ONCE(old_head != subreq->wb_head);

		/* make sure old group is not used */
		subreq->wb_head = subreq;
		subreq->wb_this_page = subreq;

		/* subreq is now totally disconnected from page group or any
                 * write / commit lists. last chance to wake any waiters */
		nfs_unlock_request(subreq);

		if (!test_bit(PG_TEARDOWN, &subreq->wb_flags)) {
			/* release ref on old head request */
			nfs_release_request(old_head);

			nfs_page_group_clear_bits(subreq);

			/* release the PG_INODE_REF reference */
			if (test_and_clear_bit(PG_INODE_REF, &subreq->wb_flags))
				nfs_release_request(subreq);
			else
				WARN_ON_ONCE(1);
		} else {
			WARN_ON_ONCE(test_bit(PG_CLEAN, &subreq->wb_flags));
			/* zombie requests have already released the last
                         * reference and were waiting on the rest of the
                         * group to complete. Since it's no longer part of a
                         * group, simply free the request */
			nfs_page_group_clear_bits(subreq);
			nfs_free_request(subreq);
		}
	}
}

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

/*
 * nfs_lock_and_join_requests - join all subreqs to the head req and return
 *                              a locked reference, cancelling any pending
 *                              operations for this page.
 *
 * @page - the page used to lookup the "page group" of nfs_page structures
 * @nonblock - if true, don't block waiting for request locks
 *
 * This function joins all sub requests to the head request by first
 * locking all requests in the group, cancelling any pending operations
 * and finally updating the head request to cover the whole range covered by
 * the (former) group.  All subrequests are removed from any write or commit
 * lists, unlinked from the group and destroyed.
 *
 * Returns a locked, referenced pointer to the head request - which after
 * this call is guaranteed to be the only request associated with the page.
 * Returns NULL if no requests are found for @page, or a ERR_PTR if an
 * error was encountered.
 */

static struct nfs_page *

nfs_lock_and_join_requests(struct page *page, bool nonblock)
{
	struct inode *inode = page_file_mapping(page)->host;
	struct nfs_page *head, *subreq;
	struct nfs_page *destroy_list = NULL;
	unsigned int total_bytes;
	int ret;

try_again:
	total_bytes = 0;

	WARN_ON_ONCE(destroy_list);

	spin_lock(&inode->i_lock);

	/*
         * A reference is taken only on the head request which acts as a
         * reference to the whole page group - the group will not be destroyed
         * until the head reference is released.
         */
	head = nfs_page_find_head_request_locked(NFS_I(inode), page);

	if (!head) {
		spin_unlock(&inode->i_lock);
		return NULL;
	}

	/* holding inode lock, so always make a non-blocking call to try the
         * page group lock */
	ret = nfs_page_group_lock(head, true);
	if (ret < 0) {
		spin_unlock(&inode->i_lock);

		if (!nonblock && ret == -EAGAIN) {
			nfs_page_group_lock_wait(head);
			nfs_release_request(head);
			goto try_again;
		}

		nfs_release_request(head);
		return ERR_PTR(ret);
	}

	/* lock each request in the page group */
	subreq = head;
	do {
		/*
                 * Subrequests are always contiguous, non overlapping
                 * and in order - but may be repeated (mirrored writes).
                 */
		if (subreq->wb_offset == (head->wb_offset + total_bytes)) {
			/* keep track of how many bytes this group covers */
			total_bytes += subreq->wb_bytes;
		} else if (WARN_ON_ONCE(subreq->wb_offset < head->wb_offset ||
			    ((subreq->wb_offset + subreq->wb_bytes) >
			     (head->wb_offset + total_bytes)))) {
			nfs_page_group_unlock(head);
			spin_unlock(&inode->i_lock);
			return ERR_PTR(-EIO);
		}

		if (!nfs_lock_request(subreq)) {
			/* releases page group bit lock and
                         * inode spin lock and all references */
			ret = nfs_unroll_locks_and_wait(inode, head,
				subreq, nonblock);

			if (ret == 0)
				goto try_again;

			return ERR_PTR(ret);
		}

		subreq = subreq->wb_this_page;
	} while (subreq != head);

	/* Now that all requests are locked, make sure they aren't on any list.
         * Commit list removal accounting is done after locks are dropped */
	subreq = head;
	do {
		nfs_clear_request_commit(subreq);
		subreq = subreq->wb_this_page;
	} while (subreq != head);

	/* unlink subrequests from head, destroy them later */
	if (head->wb_this_page != head) {
		/* destroy list will be terminated by head */
		destroy_list = head->wb_this_page;
		head->wb_this_page = head;

		/* change head request to cover whole range that
                 * the former page group covered */
		head->wb_bytes = total_bytes;
	}

	/*
         * prepare head request to be added to new pgio descriptor
         */
	nfs_page_group_clear_bits(head);

	/*
         * some part of the group was still on the inode list - otherwise
         * the group wouldn't be involved in async write.
         * grab a reference for the head request, iff it needs one.
         */
	if (!test_and_set_bit(PG_INODE_REF, &head->wb_flags))
		kref_get(&head->wb_kref);

	nfs_page_group_unlock(head);

	/* drop lock to clean uprequests on destroy list */
	spin_unlock(&inode->i_lock);

	nfs_destroy_unlinked_subrequests(destroy_list, head);

	/* still holds ref on head from nfs_page_find_head_request_locked
         * and still has lock on head from lock loop */
	return head;
}

Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 310 75.24% 8 50.00%
trond myklebust trond myklebust 94 22.82% 6 37.50%
mel gorman mel gorman 8 1.94% 2 12.50%
Total 412 100.00% 16 100.00%



static void nfs_write_error_remove_page(struct nfs_page *req)
{
	nfs_unlock_request(req);
	nfs_end_page_writeback(req);
	nfs_release_request(req);
	generic_error_remove_page(page_file_mapping(req->wb_page),
				  req->wb_page);
}

Contributors
Person Tokens Prop Commits CommitProp
peng tao peng tao 40 100.00% 1 100.00%
Total 40 100.00% 1 100.00%

/*
 * Find an associated nfs write request, and prepare to flush it out
 * May return an error if the user signalled nfs_wait_on_request().
 */


static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
				struct page *page, bool nonblock,
				bool launder)
{
	struct nfs_page *req;
	int ret = 0;

	req = nfs_lock_and_join_requests(page, nonblock);
	if (!req)
		goto out;
	ret = PTR_ERR(req);
	if (IS_ERR(req))
		goto out;

	nfs_set_page_writeback(page);
	WARN_ON_ONCE(test_bit(PG_CLEAN, &req->wb_flags));

	ret = 0;
	if (!nfs_pageio_add_request(pgio, req)) {
		ret = pgio->pg_error;
		/*
                 * Remove the problematic req upon fatal errors
                 * in launder case, while other dirty pages can
                 * still be around until they get flushed.
                 */
		if (nfs_error_is_fatal(ret)) {
			nfs_context_set_write_error(req->wb_context, ret);
			if (launder) {
				nfs_write_error_remove_page(req);
				goto out;
			}
		}
		nfs_redirty_request(req);
		ret = -EAGAIN;
	} else
		nfs_add_stats(page_file_mapping(page)->host,
				NFSIOS_WRITEPAGES, 1);
out:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 114 67.46% 8 66.67%
peng tao peng tao 44 26.04% 2 16.67%
fred isaman fred isaman 10 5.92% 1 8.33%
weston andros adamson weston andros adamson 1 0.59% 1 8.33%
Total 169 100.00% 12 100.00%



static int nfs_do_writepage(struct page *page, struct writeback_control *wbc,
			    struct nfs_pageio_descriptor *pgio, bool launder)
{
	int ret;

	nfs_pageio_cond_complete(pgio, page_index(page));
	ret = nfs_page_async_flush(pgio, page, wbc->sync_mode == WB_SYNC_NONE,
				   launder);
	if (ret == -EAGAIN) {
		redirty_page_for_writepage(wbc, page);
		ret = 0;
	}
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 58 75.32% 5 45.45%
pre-git pre-git 6 7.79% 2 18.18%
peng tao peng tao 5 6.49% 1 9.09%
andrew morton andrew morton 5 6.49% 1 9.09%
mel gorman mel gorman 2 2.60% 1 9.09%
huang ying huang ying 1 1.30% 1 9.09%
Total 77 100.00% 11 100.00%

/*
 * Write an mmapped page to the server.
 */


static int nfs_writepage_locked(struct page *page,
				struct writeback_control *wbc,
				bool launder)
{
	struct nfs_pageio_descriptor pgio;
	struct inode *inode = page_file_mapping(page)->host;
	int err;

	nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
	nfs_pageio_init_write(&pgio, inode, 0,
				false, &nfs_async_write_completion_ops);
	err = nfs_do_writepage(page, wbc, &pgio, launder);
	nfs_pageio_complete(&pgio);
	if (err < 0)
		return err;
	if (pgio.pg_error < 0)
		return pgio.pg_error;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 94 89.52% 8 72.73%
peng tao peng tao 5 4.76% 1 9.09%
christoph hellwig christoph hellwig 3 2.86% 1 9.09%
fred isaman fred isaman 3 2.86% 1 9.09%
Total 105 100.00% 11 100.00%



int nfs_writepage(struct page *page, struct writeback_control *wbc)
{
	int ret;

	ret = nfs_writepage_locked(page, wbc, false);
	unlock_page(page);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 29 78.38% 2 33.33%
pre-git pre-git 5 13.51% 2 33.33%
peng tao peng tao 2 5.41% 1 16.67%
andrew morton andrew morton 1 2.70% 1 16.67%
Total 37 100.00% 6 100.00%



static int nfs_writepages_callback(struct page *page, struct writeback_control *wbc, void *data)
{
	int ret;

	ret = nfs_do_writepage(page, wbc, data, false);
	unlock_page(page);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 40 90.91% 1 25.00%
peng tao peng tao 2 4.55% 1 25.00%
pre-git pre-git 2 4.55% 2 50.00%
Total 44 100.00% 4 100.00%



int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
{
	struct inode *inode = mapping->host;
	struct nfs_pageio_descriptor pgio;
	int err;

	nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);

	nfs_pageio_init_write(&pgio, inode, wb_priority(wbc), false,
				&nfs_async_write_completion_ops);
	err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);
	nfs_pageio_complete(&pgio);

	if (err < 0)
		goto out_err;
	err = pgio.pg_error;
	if (err < 0)
		goto out_err;
	return 0;
out_err:
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 95 87.96% 7 70.00%
chuck lever chuck lever 7 6.48% 1 10.00%
christoph hellwig christoph hellwig 3 2.78% 1 10.00%
fred isaman fred isaman 3 2.78% 1 10.00%
Total 108 100.00% 10 100.00%

/*
 * Insert a write request into an inode
 */


static void nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
{
	struct nfs_inode *nfsi = NFS_I(inode);

	WARN_ON_ONCE(req->wb_this_page != req);

	/* Lock the request! */
	nfs_lock_request(req);

	spin_lock(&inode->i_lock);
	if (!nfsi->nrequests &&
	    NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE))
		inode->i_version++;
	/*
         * Swap-space should not get truncated. Hence no need to plug the race
         * with invalidate/truncate.
         */
	if (likely(!PageSwapCache(req->wb_page))) {
		set_bit(PG_MAPPED, &req->wb_flags);
		SetPagePrivate(req->wb_page);
		set_page_private(req->wb_page, (unsigned long)req);
	}
	nfsi->nrequests++;
	/* this a head request for a page group - mark it as having an
         * extra reference so sub groups can follow suit.
         * This flag also informs pgio layer when to bump nrequests when
         * adding subrequests. */
	WARN_ON(test_and_set_bit(PG_INODE_REF, &req->wb_flags));
	kref_get(&req->wb_kref);
	spin_unlock(&inode->i_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 70 45.45% 11 47.83%
weston andros adamson weston andros adamson 25 16.23% 3 13.04%
pre-git pre-git 24 15.58% 5 21.74%
mel gorman mel gorman 16 10.39% 1 4.35%
linus torvalds linus torvalds 12 7.79% 1 4.35%
bryan schumaker bryan schumaker 6 3.90% 1 4.35%
fred isaman fred isaman 1 0.65% 1 4.35%
Total 154 100.00% 23 100.00%

/*
 * Remove a write request from an inode
 */


static void nfs_inode_remove_request(struct nfs_page *req)
{
	struct inode *inode = d_inode(req->wb_context->dentry);
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs_page *head;

	if (nfs_page_group_sync_on_bit(req, PG_REMOVE)) {
		head = req->wb_head;

		spin_lock(&inode->i_lock);
		if (likely(head->wb_page && !PageSwapCache(head->wb_page))) {
			set_page_private(head->wb_page, 0);
			ClearPagePrivate(head->wb_page);
			smp_mb__after_atomic();
			wake_up_page(head->wb_page, PG_private);
			clear_bit(PG_MAPPED, &head->wb_flags);
		}
		nfsi->nrequests--;
		spin_unlock(&inode->i_lock);
	} else {
		spin_lock(&inode->i_lock);
		nfsi->nrequests--;
		spin_unlock(&inode->i_lock);
	}

	if (test_and_clear_bit(PG_INODE_REF, &req->wb_flags))
		nfs_release_request(req);
}

Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 63 35.80% 3 16.67%
trond myklebust trond myklebust 45 25.57% 7 38.89%
pre-git pre-git 31 17.61% 3 16.67%
mel gorman mel gorman 14 7.95% 1 5.56%
neil brown neil brown 12 6.82% 1 5.56%
anna schumaker anna schumaker 4 2.27% 1 5.56%
linus torvalds linus torvalds 4 2.27% 1 5.56%
david howells david howells 3 1.70% 1 5.56%
Total 176 100.00% 18 100.00%


static void

nfs_mark_request_dirty(struct nfs_page *req)
{
	if (req->wb_page)
		__set_page_dirty_nobuffers(req->wb_page);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 17 70.83% 1 33.33%
anna schumaker anna schumaker 6 25.00% 1 33.33%
fred isaman fred isaman 1 4.17% 1 33.33%
Total 24 100.00% 3 100.00%

/*
 * nfs_page_search_commits_for_head_request_locked
 *
 * Search through commit lists on @inode for the head request for @page.
 * Must be called while holding the inode (which is cinfo) lock.
 *
 * Returns the head request if found, or NULL if not found.
 */

static struct nfs_page *

nfs_page_search_commits_for_head_request_locked(struct nfs_inode *nfsi,
						struct page *page)
{
	struct nfs_page *freq, *t;
	struct nfs_commit_info cinfo;
	struct inode *inode = &nfsi->vfs_inode;

	nfs_init_cinfo_from_inode(&cinfo, inode);

	/* search through pnfs commit lists */
	freq = pnfs_search_commit_reqs(inode, &cinfo, page);
	if (freq)
		return freq->wb_head;

	/* Linearly search the commit list for the correct request */
	list_for_each_entry_safe(freq, t, &cinfo.mds->list, wb_list) {
		if (freq->wb_page == page)
			return freq->wb_head;
	}

	return NULL;
}

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

/**
 * nfs_request_add_commit_list_locked - add request to a commit list
 * @req: pointer to a struct nfs_page
 * @dst: commit list head
 * @cinfo: holds list lock and accounting info
 *
 * This sets the PG_CLEAN bit, updates the cinfo count of
 * number of outstanding requests requiring a commit as well as
 * the MM page stats.
 *
 * The caller must hold cinfo->inode->i_lock, and the nfs_page lock.
 */

void

nfs_request_add_commit_list_locked(struct nfs_page *req, struct list_head *dst,
			    struct nfs_commit_info *cinfo)
{
	set_bit(PG_CLEAN, &req->wb_flags);
	nfs_list_add_request(req, dst);
	cinfo->mds->ncommit++;
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 22 50.00% 6 50.00%
fred isaman fred isaman 14 31.82% 3 25.00%
pre-git pre-git 8 18.18% 3 25.00%
Total 44 100.00% 12 100.00%


EXPORT_SYMBOL_GPL(nfs_request_add_commit_list_locked);

/**
 * nfs_request_add_commit_list - add request to a commit list
 * @req: pointer to a struct nfs_page
 * @dst: commit list head
 * @cinfo: holds list lock and accounting info
 *
 * This sets the PG_CLEAN bit, updates the cinfo count of
 * number of outstanding requests requiring a commit as well as
 * the MM page stats.
 *
 * The caller must _not_ hold the cinfo->lock, but must be
 * holding the nfs_page lock.
 */

void

nfs_request_add_commit_list(struct nfs_page *req, struct nfs_commit_info *cinfo)
{
	spin_lock(&cinfo->inode->i_lock);
	nfs_request_add_commit_list_locked(req, &cinfo->mds->list, cinfo);
	spin_unlock(&cinfo->inode->i_lock);
	if (req->wb_page)
		nfs_mark_page_unstable(req->wb_page, cinfo);
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 30 46.88% 2 13.33%
anna schumaker anna schumaker 12 18.75% 2 13.33%
dave wysochanski dave wysochanski 8 12.50% 1 6.67%
fred isaman fred isaman 3 4.69% 2 13.33%
peter zijlstra peter zijlstra 3 4.69% 1 6.67%
pre-git pre-git 3 4.69% 3 20.00%
linus torvalds linus torvalds 2 3.12% 2 13.33%
mel gorman mel gorman 2 3.12% 1 6.67%
tom haynes tom haynes 1 1.56% 1 6.67%
Total 64 100.00% 15 100.00%


EXPORT_SYMBOL_GPL(nfs_request_add_commit_list);

/**
 * nfs_request_remove_commit_list - Remove request from a commit list
 * @req: pointer to a nfs_page
 * @cinfo: holds list lock and accounting info
 *
 * This clears the PG_CLEAN bit, and updates the cinfo's count of
 * number of outstanding requests requiring a commit
 * It does not update the MM page stats.
 *
 * The caller _must_ hold the cinfo->lock and the nfs_page lock.
 */

void

nfs_request_remove_commit_list(struct nfs_page *req,
			       struct nfs_commit_info *cinfo)
{
	if (!test_and_clear_bit(PG_CLEAN, &(req)->wb_flags))
		return;
	nfs_list_remove_request(req);
	cinfo->mds->ncommit--;
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 35 81.40% 1 50.00%
fred isaman fred isaman 8 18.60% 1 50.00%
Total 43 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(nfs_request_remove_commit_list);



static void nfs_init_cinfo_from_inode(struct nfs_commit_info *cinfo,
				      struct inode *inode)
{
	cinfo->inode = inode;
	cinfo->mds = &NFS_I(inode)->commit_info;
	cinfo->ds = pnfs_get_ds_info(inode);
	cinfo->dreq = NULL;
	cinfo->completion_ops = &nfs_commit_completion_ops;
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 55 98.21% 3 75.00%
dave wysochanski dave wysochanski 1 1.79% 1 25.00%
Total 56 100.00% 4 100.00%



void nfs_init_cinfo(struct nfs_commit_info *cinfo,
		    struct inode *inode,
		    struct nfs_direct_req *dreq)
{
	if (dreq)
		nfs_init_cinfo_from_dreq(cinfo, dreq);
	else
		nfs_init_cinfo_from_inode(cinfo, inode);
}
Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 39 100.00% 2 100.00%
Total 39 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(nfs_init_cinfo);

/*
 * Add a request to the inode's commit list.
 */

void

nfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
			struct nfs_commit_info *cinfo, u32 ds_commit_idx)
{
	if (pnfs_mark_request_commit(req, lseg, cinfo, ds_commit_idx))
		return;
	nfs_request_add_commit_list(req, cinfo);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 31 70.45% 1 33.33%
fred isaman fred isaman 8 18.18% 1 33.33%
weston andros adamson weston andros adamson 5 11.36% 1 33.33%
Total 44 100.00% 3 100.00%


static void

nfs_clear_page_commit(struct page *page)
{
	dec_node_page_state(page, NR_UNSTABLE_NFS);
	dec_wb_stat(&inode_to_bdi(page_file_mapping(page)->host)->wb,
		    WB_RECLAIMABLE);
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 22 61.11% 1 16.67%
tejun heo tejun heo 5 13.89% 1 16.67%
mel gorman mel gorman 4 11.11% 2 33.33%
christoph hellwig christoph hellwig 4 11.11% 1 16.67%
trond myklebust trond myklebust 1 2.78% 1 16.67%
Total 36 100.00% 6 100.00%

/* Called holding inode (/cinfo) lock */

static void

nfs_clear_request_commit(struct nfs_page *req)
{
	if (test_bit(PG_CLEAN, &req->wb_flags)) {
		struct inode *inode = d_inode(req->wb_context->dentry);
		struct nfs_commit_info cinfo;

		nfs_init_cinfo_from_inode(&cinfo, inode);
		if (!pnfs_clear_request_commit(req, &cinfo)) {
			nfs_request_remove_commit_list(req, &cinfo);
		}
		nfs_clear_page_commit(req->wb_page);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 50 63.29% 2 40.00%
fred isaman fred isaman 26 32.91% 2 40.00%
david howells david howells 3 3.80% 1 20.00%
Total 79 100.00% 5 100.00%



int nfs_write_need_commit(struct nfs_pgio_header *hdr)
{
	if (hdr->verf.committed == NFS_DATA_SYNC)
		return hdr->lseg == NULL;
	return hdr->verf.committed != NFS_FILE_SYNC;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 16 44.44% 1 25.00%
fred isaman fred isaman 15 41.67% 2 50.00%
weston andros adamson weston andros adamson 5 13.89% 1 25.00%
Total 36 100.00% 4 100.00%



static void nfs_write_completion(struct nfs_pgio_header *hdr)
{
	struct nfs_commit_info cinfo;
	unsigned long bytes = 0;

	if (test_bit(NFS_IOHDR_REDO, &hdr->flags))
		goto out;
	nfs_init_cinfo_from_inode(&cinfo, hdr->inode);
	while (!list_empty(&hdr->pages)) {
		struct nfs_page *req = nfs_list_entry(hdr->pages.next);

		bytes += req->wb_bytes;
		nfs_list_remove_request(req);
		if (test_bit(NFS_IOHDR_ERROR, &hdr->flags) &&
		    (hdr->good_bytes < bytes)) {
			nfs_set_pageerror(req->wb_page);
			nfs_context_set_write_error(req->wb_context, hdr->error);
			goto remove_req;
		}
		if (nfs_write_need_commit(hdr)) {
			memcpy(&req->wb_verf, &hdr->verf.verifier, sizeof(req->wb_verf));
			nfs_mark_request_commit(req, hdr->lseg, &cinfo,
				hdr->pgio_mirror_idx);
			goto next;
		}
remove_req:
		nfs_inode_remove_request(req);
next:
		nfs_unlock_request(req);
		nfs_end_page_writeback(req);
		nfs_release_request(req);
	}
out:
	hdr->release(hdr);
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 152 72.38% 5 33.33%
trond myklebust trond myklebust 52 24.76% 6 40.00%
weston andros adamson weston andros adamson 5 2.38% 3 20.00%
anna schumaker anna schumaker 1 0.48% 1 6.67%
Total 210 100.00% 15 100.00%


unsigned long

nfs_reqs_to_commit(struct nfs_commit_info *cinfo)
{
	return cinfo->mds->ncommit;
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 12 66.67% 2 66.67%
trond myklebust trond myklebust 6 33.33% 1 33.33%
Total 18 100.00% 3 100.00%

/* cinfo->inode->i_lock held by caller */

int

nfs_scan_commit_list(struct list_head *src, struct list_head *dst,
		     struct nfs_commit_info *cinfo, int max)
{
	struct nfs_page *req, *tmp;
	int ret = 0;

	list_for_each_entry_safe(req, tmp, src, wb_list) {
		if (!nfs_lock_request(req))
			continue;
		kref_get(&req->wb_kref);
		if (cond_resched_lock(&cinfo->inode->i_lock))
			list_safe_reset_next(req, tmp, wb_list);
		nfs_request_remove_commit_list(req, cinfo);
		nfs_list_add_request(req, dst);
		ret++;
		if ((ret == max) && !cinfo->dreq)
			break;
	}
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 85 70.83% 3 37.50%
trond myklebust trond myklebust 31 25.83% 4 50.00%
dave wysochanski dave wysochanski 4 3.33% 1 12.50%
Total 120 100.00% 8 100.00%

/*
 * nfs_scan_commit - Scan an inode for commit requests
 * @inode: NFS inode to scan
 * @dst: mds destination list
 * @cinfo: mds and ds lists of reqs ready to commit
 *
 * Moves requests from the inode's 'commit' request list.
 * The requests are *not* checked to ensure that they form a contiguous set.
 */

int

nfs_scan_commit(struct inode *inode, struct list_head *dst,
		struct nfs_commit_info *cinfo)
{
	int ret = 0;

	spin_lock(&cinfo->inode->i_lock);
	if (cinfo->mds->ncommit > 0) {
		const int max = INT_MAX;

		ret = nfs_scan_commit_list(&cinfo->mds->list, dst,
					   cinfo, max);
		ret += pnfs_scan_commit_lists(inode, cinfo, max - ret);
	}
	spin_unlock(&cinfo->inode->i_lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 41 42.27% 3 21.43%
trond myklebust trond myklebust 18 18.56% 6 42.86%
pre-git pre-git 13 13.40% 1 7.14%
dave chinner dave chinner 10 10.31% 1 7.14%
dave wysochanski dave wysochanski 8 8.25% 1 7.14%
linus torvalds linus torvalds 7 7.22% 2 14.29%
Total 97 100.00% 14 100.00%

/*
 * Search for an existing write request, and attempt to update
 * it to reflect a new dirty region on a given page.
 *
 * If the attempt fails, then the existing request is flushed out
 * to disk.
 */


static struct nfs_page *nfs_try_to_update_request(struct inode *inode,
		struct page *page,
		unsigned int offset,
		unsigned int bytes)
{
	struct nfs_page *req;
	unsigned int rqend;
	unsigned int end;
	int error;

	if (!PagePrivate(page))
		return NULL;

	end = offset + bytes;
	spin_lock(&inode->i_lock);

	for (;;) {
		req = nfs_page_find_head_request_locked(NFS_I(inode), page);
		if (req == NULL)
			goto out_unlock;

		/* should be handled by nfs_flush_incompatible */
		WARN_ON_ONCE(req->wb_head != req);
		WARN_ON_ONCE(req->wb_this_page != req);

		rqend = req->wb_offset + req->wb_bytes;
		/*
                 * Tell the caller to flush out the request if
                 * the offsets are non-contiguous.
                 * Note: nfs_flush_incompatible() will already
                 * have flushed out requests having wrong owners.
                 */
		if (offset > rqend
		    || end < req->wb_offset)
			goto out_flushme;

		if (nfs_lock_request(req))
			break;

		/* The request is locked, so wait and then retry */
		spin_unlock(&inode->i_lock);
		error = nfs_wait_on_request(req);
		nfs_release_request(req);
		if (error != 0)
			goto out_err;
		spin_lock(&inode->i_lock);
	}

	/* Okay, the request matches. Update the region */
	if (offset < req->wb_offset) {
		req->wb_offset = offset;
		req->wb_pgbase = offset;
	}
	if (end > rqend)
		req->wb_bytes = end - req->wb_offset;
	else
		req->wb_bytes = rqend - req->wb_offset;
out_unlock:
	if (req)
		nfs_clear_request_commit(req);
	spin_unlock(&inode->i_lock);
	return req;
out_flushme:
	spin_unlock(&inode->i_lock);
	nfs_release_request(req);
	error = nfs_wb_page(inode, page);
out_err:
	return ERR_PTR(error);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 157 54.14% 7 41.18%
pre-git pre-git 83 28.62% 2 11.76%
weston andros adamson weston andros adamson 28 9.66% 3 17.65%
linus torvalds linus torvalds 7 2.41% 1 5.88%
fred isaman fred isaman 7 2.41% 2 11.76%
mel gorman mel gorman 5 1.72% 1 5.88%
nick piggin nick piggin 3 1.03% 1 5.88%
Total 290 100.00% 17 100.00%

/*
 * Try to update an existing write request, or create one if there is none.
 *
 * Note: Should always be called with the Page Lock held to prevent races
 * if we have to add a new request. Also assumes that the caller has
 * already called nfs_flush_incompatible() if necessary.
 */


static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx,
		struct page *page, unsigned int offset, unsigned int bytes)
{
	struct inode *inode = page_file_mapping(page)->host;
	struct nfs_page	*req;

	req = nfs_try_to_update_request(inode, page, offset, bytes);
	if (req != NULL)
		goto out;
	req = nfs_create_request(ctx, page, NULL, offset, bytes);
	if (IS_ERR(req))
		goto out;
	nfs_inode_add_request(inode, req);
out:
	return req;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 77 75.49% 4 44.44%
pre-git pre-git 17 16.67% 2 22.22%
mel gorman mel gorman 3 2.94% 1 11.11%
linus torvalds linus torvalds 3 2.94% 1 11.11%
weston andros adamson weston andros adamson 2 1.96% 1 11.11%
Total 102 100.00% 9 100.00%



static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
		unsigned int offset, unsigned int count)
{
	struct nfs_page	*req;

	req = nfs_setup_write_request(ctx, page, offset, count);
	if (IS_ERR(req))
		return PTR_ERR(req);
	/* Update file length */
	nfs_grow_file(page, offset, count);
	nfs_mark_uptodate(req);
	nfs_mark_request_dirty(req);
	nfs_unlock_and_release_request(req);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 63 75.90% 4 80.00%
pre-git pre-git 20 24.10% 1 20.00%
Total 83 100.00% 5 100.00%



int nfs_flush_incompatible(struct file *file, struct page *page)
{
	struct nfs_open_context *ctx = nfs_file_open_context(file);
	struct nfs_lock_context *l_ctx;
	struct file_lock_context *flctx = file_inode(file)->i_flctx;
	struct nfs_page	*req;
	int do_flush, status;
	/*
         * Look for a request corresponding to this page. If there
         * is one, and it belongs to another file, we flush it out
         * before we try to copy anything into the page. Do this
         * due to the lack of an ACCESS-type call in NFSv2.
         * Also do the same if we find a request from an existing
         * dropped page.
         */
	do {
		req = nfs_page_find_head_request(page);
		if (req == NULL)
			return 0;
		l_ctx = req->wb_lock_context;
		do_flush = req->wb_page != page ||
			!nfs_match_open_context(req->wb_context, ctx);
		/* for now, flush if more than 1 request in page_group */
		do_flush |= req->wb_this_page != req;
		if (l_ctx && flctx &&
		    !(list_empty_careful(&flctx->flc_posix) &&
		      list_empty_careful(&flctx->flc_flock))) {
			do_flush |= l_ctx->lockowner != current->files;
		}
		nfs_release_request(req);
		if (!do_flush)
			return 0;
		status = nfs_wb_page(page_file_mapping(page)->host, page);
	} while (status == 0);
	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 73 40.78% 8 57.14%
pre-git pre-git 48 26.82% 1 7.14%
jeff layton jeff layton 45 25.14% 2 14.29%
weston andros adamson weston andros adamson 10 5.59% 2 14.29%
mel gorman mel gorman 3 1.68% 1 7.14%
Total 179 100.00% 14 100.00%

/*
 * Avoid buffered writes when a open context credential's key would
 * expire soon.
 *
 * Returns -EACCES if the key will expire within RPC_KEY_EXPIRE_FAIL.
 *
 * Return 0 and set a credential flag which triggers the inode to flush
 * and performs  NFS_FILE_SYNC writes if the key will expired within
 * RPC_KEY_EXPIRE_TIMEO.
 */

int

nfs_key_timeout_notify(struct file *filp, struct inode *inode)
{
	struct nfs_open_context *ctx = nfs_file_open_context(filp);
	struct rpc_auth *auth = NFS_SERVER(inode)->client->cl_auth;

	return rpcauth_key_timeout_notify(auth, ctx->cred);
}

Contributors
Person Tokens Prop Commits CommitProp
andy adamson andy adamson 49 100.00% 1 100.00%
Total 49 100.00% 1 100.00%

/*
 * Test if the open context credential key is marked to expire soon.
 */


bool nfs_ctx_key_to_expire(struct nfs_open_context *ctx, struct inode *inode)
{
	struct rpc_auth *auth = NFS_SERVER(inode)->client->cl_auth;

	return rpcauth_cred_key_to_expire(auth, ctx->cred);
}

Contributors
Person Tokens Prop Commits CommitProp
scott mayhew scott mayhew 21 53.85% 1 50.00%
andy adamson andy adamson 18 46.15% 1 50.00%
Total 39 100.00% 2 100.00%

/*
 * If the page cache is marked as unsafe or invalid, then we can't rely on
 * the PageUptodate() flag. In this case, we will need to turn off
 * write optimisations that depend on the page contents being correct.
 */


static bool nfs_write_pageuptodate(struct page *page, struct inode *inode)
{
	struct nfs_inode *nfsi = NFS_I(inode);

	if (nfs_have_delegated_attributes(inode))
		goto out;
	if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
		return false;
	smp_rmb();
	if (test_bit(NFS_INO_INVALIDATING, &nfsi->flags))
		return false;
out:
	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
		return false;
	return PageUptodate(page) != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 46 53.49% 2 40.00%
jeff layton jeff layton 29 33.72% 2 40.00%
scott mayhew scott mayhew 11 12.79% 1 20.00%
Total 86 100.00% 5 100.00%


static bool

is_whole_file_wrlock(struct file_lock *fl)
{
	return fl->fl_start == 0 && fl->fl_end == OFFSET_MAX &&
			fl->fl_type == F_WRLCK;
}

Contributors
Person Tokens Prop Commits CommitProp
jeff layton jeff layton 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%

/* If we know the page is up to date, and we're not using byte range locks (or
 * if we have the whole file locked for writing), it may be more efficient to
 * extend the write to cover the entire page in order to avoid fragmentation
 * inefficiencies.
 *
 * If the file is opened for synchronous writes then we can just skip the rest
 * of the checks.
 */


static int nfs_can_extend_write(struct file *file, struct page *page, struct inode *inode)
{
	int ret;
	struct file_lock_context *flctx = inode->i_flctx;
	struct file_lock *fl;

	if (file->f_flags & O_DSYNC)
		return 0;
	if (!nfs_write_pageuptodate(page, inode))
		return 0;
	if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE))
		return 1;
	if (!flctx || (list_empty_careful(&flctx->flc_flock) &&
		       list_empty_careful(&flctx->flc_posix)))
		return 1;

	/* Check to see if there are whole file write locks */
	ret = 0;
	spin_lock(&flctx->flc_lock);
	if (!list_empty(&flctx->flc_posix)) {
		fl = list_first_entry(&flctx->flc_posix, struct file_lock,
					fl_list);
		if (is_whole_file_wrlock(fl))
			ret = 1;
	} else if (!list_empty(&flctx->flc_flock)) {
		fl = list_first_entry(&flctx->flc_flock, struct file_lock,
					fl_list);
		if (fl->fl_type == F_WRLCK)
			ret = 1;
	}
	spin_unlock(&flctx->flc_lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jeff layton jeff layton 134 64.11% 3 50.00%
scott mayhew scott mayhew 74 35.41% 2 33.33%
trond myklebust trond myklebust 1 0.48% 1 16.67%
Total 209 100.00% 6 100.00%

/*
 * Update and possibly write a cached page of an NFS file.
 *
 * XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
 * things with a page scheduled for an RPC call (e.g. invalidate it).
 */


int nfs_updatepage(struct file *file, struct page *page,
		unsigned int offset, unsigned int count)
{
	struct nfs_open_context *ctx = nfs_file_open_context(file);
	struct inode	*inode = page_file_mapping(page)->host;
	int		status = 0;

	nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);

	dprintk("NFS:       nfs_updatepage(%pD2 %d@%lld)\n",
		file, count, (long long)(page_file_offset(page) + offset));

	if (!count)
		goto out;

	if (nfs_can_extend_write(file, page, inode)) {
		count = max(count + offset, nfs_page_length(page));
		offset = 0;
	}

	status = nfs_writepage_setup(ctx, page, offset, count);
	if (status < 0)
		nfs_set_pageerror(page);
	else
		__set_page_dirty_nobuffers(page);
out:
	dprintk("NFS:       nfs_updatepage returns %d (isize %lld)\n",
			status, (long long)i_size_read(inode));
	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 72 42.60% 3 13.64%
trond myklebust trond myklebust 63 37.28% 10 45.45%
benjamin coddington benjamin coddington 10 5.92% 1 4.55%
chuck lever chuck lever 9 5.33% 3 13.64%
linus torvalds linus torvalds 4 2.37% 1 4.55%
mel gorman mel gorman 4 2.37% 1 4.55%
andrew morton andrew morton 3 1.78% 1 4.55%
scott mayhew scott mayhew 3 1.78% 1 4.55%
al viro al viro 1 0.59% 1 4.55%
Total 169 100.00% 22 100.00%



static int flush_task_priority(int how)
{
	switch (how & (FLUSH_HIGHPRI|FLUSH_LOWPRI)) {
		case FLUSH_HIGHPRI:
			return RPC_PRIORITY_HIGH;
		case FLUSH_LOWPRI:
			return RPC_PRIORITY_LOW;
	}
	return RPC_PRIORITY_NORMAL;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 31 86.11% 2 66.67%
fred isaman fred isaman 5 13.89% 1 33.33%
Total 36 100.00% 3 100.00%



static void nfs_initiate_write(struct nfs_pgio_header *hdr,
			       struct rpc_message *msg,
			       const struct nfs_rpc_ops *rpc_ops,
			       struct rpc_task_setup *task_setup_data, int how)
{
	int priority = flush_task_priority(how);

	task_setup_data->priority = priority;
	rpc_ops->write_setup(hdr, msg);

	nfs4_state_protect_write(NFS_SERVER(hdr->inode)->nfs_client,
				 &task_setup_data->rpc_client, msg, hdr);
}

Contributors
Person Tokens Prop Commits CommitProp
weston andros adamson weston andros adamson 21 28.38% 2 16.67%
trond myklebust trond myklebust 20 27.03% 6 50.00%
tom haynes tom haynes 9 12.16% 1 8.33%
andy adamson andy adamson 8 10.81% 1 8.33%
anna schumaker anna schumaker 8 10.81% 1 8.33%
pre-git pre-git 8 10.81% 1 8.33%
Total 74 100.00% 12 100.00%

/* If a nfs_flush_* function fails, it should remove reqs from @head and
 * call this on each, which will prepare them to be retried on next
 * writeback using standard nfs.
 */


static void nfs_redirty_request(struct nfs_page *req)
{
	nfs_mark_request_dirty(req);
	set_bit(NFS_CONTEXT_RESEND_WRITES, &req->wb_context->flags);
	nfs_unlock_request(req);
	nfs_end_page_writeback(req);
	nfs_release_request(req);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 32 74.42% 7 70.00%
fred isaman fred isaman 7 16.28% 1 10.00%
bryan schumaker bryan schumaker 3 6.98% 1 10.00%
pre-git pre-git 1 2.33% 1 10.00%
Total 43 100.00% 10 100.00%



static void nfs_async_write_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_redirty_request(req);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 30 66.67% 2 28.57%
trond myklebust trond myklebust 14 31.11% 4 57.14%
pre-git pre-git 1 2.22% 1 14.29%
Total 45 100.00% 7 100.00%



static void nfs_async_write_reschedule_io(struct nfs_pgio_header *hdr)
{
	nfs_async_write_error(&hdr->pages);
}

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


static const struct nfs_pgio_completion_ops nfs_async_write_completion_ops = {
	.error_cleanup = nfs_async_write_error,
	.completion = nfs_write_completion,
	.reschedule_io = nfs_async_write_reschedule_io,
};



void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
			       struct inode *inode, int ioflags, bool force_mds,
			       const struct nfs_pgio_completion_ops *compl_ops)
{
	struct nfs_server *server = NFS_SERVER(inode);
	const struct nfs_pageio_ops *pg_ops = &nfs_pgio_rw_ops;

#ifdef CONFIG_NFS_V4_1
	if (server->pnfs_curr_ld && !force_mds)
		pg_ops = server->pnfs_curr_ld->pg_write_ops;
#endif
	nfs_pageio_init(pgio, inode, pg_ops, compl_ops, &nfs_rw_write_ops,
			server->wsize, ioflags);
}
Contributors
Person Tokens Prop Commits CommitProp
christoph hellwig christoph hellwig 45 51.14% 1 10.00%
trond myklebust trond myklebust 23 26.14% 3 30.00%
fred isaman fred isaman 8 9.09% 1 10.00%
pre-git pre-git 5 5.68% 1 10.00%
anna schumaker anna schumaker 4 4.55% 2 20.00%
linus torvalds linus torvalds 2 2.27% 1 10.00%
bryan schumaker bryan schumaker 1 1.14% 1 10.00%
Total 88 100.00% 10 100.00%


EXPORT_SYMBOL_GPL(nfs_pageio_init_write);



void nfs_pageio_reset_write_mds(struct nfs_pageio_descriptor *pgio)
{
	struct nfs_pgio_mirror *mirror;

	if (pgio->pg_ops && pgio->pg_ops->pg_cleanup)
		pgio->pg_ops->pg_cleanup(pgio);

	pgio->pg_ops = &nfs_pgio_rw_ops;

	nfs_pageio_stop_mirroring(pgio);

	mirror = &pgio->pg_mirrors[0];
	mirror->pg_bsize = NFS_SERVER(pgio->pg_inode)->wsize;
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 31 43.66% 1 25.00%
kinglong mee kinglong mee 21 29.58% 1 25.00%
weston andros adamson weston andros adamson 18 25.35% 1 25.00%
anna schumaker anna schumaker 1 1.41% 1 25.00%
Total 71 100.00% 4 100.00%


EXPORT_SYMBOL_GPL(nfs_pageio_reset_write_mds);




void nfs_commit_prepare(struct rpc_task *task, void *calldata)
{
	struct nfs_commit_data *data = calldata;

	NFS_PROTO(data->inode)->commit_rpc_prepare(task, data);
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 26 74.29% 2 40.00%
chuck lever chuck lever 4 11.43% 1 20.00%
trond myklebust trond myklebust 3 8.57% 1 20.00%
pre-git pre-git 2 5.71% 1 20.00%
Total 35 100.00% 5 100.00%

/*
 * Special version of should_remove_suid() that ignores capabilities.
 */


static int nfs_should_remove_suid(const struct inode *inode)
{
	umode_t mode = inode->i_mode;
	int kill = 0;

	/* suid always must be killed */
	if (unlikely(mode & S_ISUID))
		kill = ATTR_KILL_SUID;

	/*
         * sgid without any exec bits is just a mandatory locking mark; leave
         * it alone.  If some exec bits are set, it's a real sgid; kill it.
         */
	if (unlikely((mode & S_ISGID) && (mode & S_IXGRP)))
		kill |= ATTR_KILL_SGID;

	if (unlikely(kill && S_ISREG(mode)))
		return kill;

	return 0;
}

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



static void nfs_writeback_check_extend(struct nfs_pgio_header *hdr,
		struct nfs_fattr *fattr)
{
	struct nfs_pgio_args *argp = &hdr->args;
	struct nfs_pgio_res *resp = &hdr->res;
	u64 size = argp->offset + resp->count;

	if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
		fattr->size = size;
	if (nfs_size_to_loff_t(fattr->size) < i_size_read(hdr->inode)) {
		fattr->valid &= ~NFS_ATTR_FATTR_SIZE;
		return;
	}
	if (size != fattr->size)
		return;
	/* Set attribute barrier */
	nfs_fattr_set_barrier(fattr);
	/* ...and update size */
	fattr->valid |= NFS_ATTR_FATTR_SIZE;
}

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



void nfs_writeback_update_inode(struct nfs_pgio_header *hdr)
{
	struct nfs_fattr *fattr = &hdr->fattr;
	struct inode *inode = hdr->inode;

	spin_lock(&inode->i_lock);
	nfs_writeback_check_extend(hdr, fattr);
	nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
	spin_unlock(&inode->i_lock);
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 59 100.00% 2 100.00%
Total 59 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(nfs_writeback_update_inode);

/*
 * This function is called when the WRITE call is complete.
 */


static int nfs_writeback_done(struct rpc_task *task,
			      struct nfs_pgio_header *hdr,
			      struct inode *inode)
{
	int status;

	/*
         * ->write_done will attempt to use post-op attributes to detect
         * conflicting writes by other clients.  A strict interpretation
         * of close-to-open would allow us to continue caching even if
         * another writer had changed the file, but some applications
         * depend on tighter cache coherency when writing.
         */
	status = NFS_PROTO(inode)->write_done(task, hdr);
	if (status != 0)
		return status;
	nfs_add_stats(inode, NFSIOS_SERVERWRITTENBYTES, hdr->res.count);

	if (hdr->res.verf->committed < hdr->args.stable &&
	    task->tk_status >= 0) {
		/* We tried a write call, but the server did not
                 * commit data to stable storage even though we
                 * requested it.
                 * Note: There is a known bug in Tru64 < 5.0 in which
                 *       the server reports NFS_DATA_SYNC, but performs
                 *       NFS_FILE_SYNC. We therefore implement this checking
                 *       as a dprintk() in order to avoid filling syslog.
                 */
		static unsigned long    complain;

		/* Note this will print the MDS for a DS write */
		if (time_before(complain, jiffies)) {
			dprintk("NFS:       faulty NFS server %s:"
				" (committed = %d) != (stable = %d)\n",
				NFS_SERVER(inode)->nfs_client->cl_hostname,
				hdr->res.verf->committed, hdr->args.stable);
			complain = jiffies + 300 * HZ;
		}
	}

	/* Deal with the suid/sgid bit corner case */
	if (nfs_should_remove_suid(inode))
		nfs_mark_for_revalidate(inode);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 100 64.10% 5 33.33%
anna schumaker anna schumaker 22 14.10% 1 6.67%
chuck lever chuck lever 12 7.69% 3 20.00%
weston andros adamson weston andros adamson 8 5.13% 1 6.67%
fred isaman fred isaman 7 4.49% 3 20.00%
rakib mullick rakib mullick 4 2.56% 1 6.67%
david howells david howells 3 1.92% 1 6.67%
Total 156 100.00% 15 100.00%

/*
 * This function is called when the WRITE call is complete.
 */


static void nfs_writeback_result(struct rpc_task *task,
				 struct nfs_pgio_header *hdr)
{
	struct nfs_pgio_args	*argp = &hdr->args;
	struct nfs_pgio_res	*resp = &hdr->res;

	if (resp->count < argp->count) {
		static unsigned long    complain;

		/* This a short write! */
		nfs_inc_stats(hdr->inode, NFSIOS_SHORTWRITE);

		/* Has the server at least made some progress? */
		if (resp->count == 0) {
			if (time_before(complain, jiffies)) {
				printk(KERN_WARNING
				       "NFS: Server wrote zero bytes, expected %u.\n",
				       argp->count);
				complain = jiffies + 300 * HZ;
			}
			nfs_set_pgio_error(hdr, -EIO, argp->offset);
			task->tk_status = -EIO;
			return;
		}

		/* For non rpc-based layout drivers, retry-through-MDS */
		if (!task->tk_ops) {
			hdr->pnfs_error = -EAGAIN;
			return;
		}

		/* Was this an NFSv2 write or an NFSv3 stable write? */
		if (resp->verf->committed != NFS_UNSTABLE) {
			/* Resend from where the server left off */
			hdr->mds_offset += resp->count;
			argp->offset += resp->count;
			argp->pgbase += resp->count;
			argp->count -= resp->count;
		} else {
			/* Resend as a stable write in order to avoid
                         * headaches in the case of a server crash.
                         */
			argp->stable = NFS_FILE_SYNC;
		}
		rpc_restart_call_prepare(task);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 74 36.63% 3 30.00%
fred isaman fred isaman 64 31.68% 2 20.00%
anna schumaker anna schumaker 29 14.36% 1 10.00%
kinglong mee kinglong mee 18 8.91% 1 10.00%
weston andros adamson weston andros adamson 7 3.47% 1 10.00%
chuck lever chuck lever 7 3.47% 1 10.00%
pre-git pre-git 3 1.49% 1 10.00%
Total 202 100.00% 10 100.00%



static int wait_on_commit(struct nfs_mds_commit_info *cinfo)
{
	return wait_on_atomic_t(&cinfo->rpcs_out,
			nfs_wait_atomic_killable, TASK_KILLABLE);
}

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



static void nfs_commit_begin(struct nfs_mds_commit_info *cinfo)
{
	atomic_inc(&cinfo->rpcs_out);
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 18 94.74% 2 66.67%
fred isaman fred isaman 1 5.26% 1 33.33%
Total 19 100.00% 3 100.00%



static void nfs_commit_end(struct nfs_mds_commit_info *cinfo)
{
	if (atomic_dec_and_test(&cinfo->rpcs_out))
		wake_up_atomic_t(&cinfo->rpcs_out);
}

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



void nfs_commitdata_release(struct nfs_commit_data *data)
{
	put_nfs_open_context(data->context);
	nfs_commit_free(data);
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 18 81.82% 3 75.00%
fred isaman fred isaman 4 18.18% 1 25.00%
Total 22 100.00% 4 100.00%


EXPORT_SYMBOL_GPL(nfs_commitdata_release);



int nfs_initiate_commit(struct rpc_clnt *clnt, struct nfs_commit_data *data,
			const struct nfs_rpc_ops *nfs_ops,
			const struct rpc_call_ops *call_ops,
			int how, int flags)
{
	struct rpc_task *task;
	int priority = flush_task_priority(how);
	struct rpc_message msg = {
		.rpc_argp = &data->args,
		.rpc_resp = &data->res,
		.rpc_cred = data->cred,
        };
	struct rpc_task_setup task_setup_data = {
		.task = &data->task,
		.rpc_client = clnt,
		.rpc_message = &msg,
		.callback_ops = call_ops,
		.callback_data = data,
		.workqueue = nfsiod_workqueue,
		.flags = RPC_TASK_ASYNC | flags,
		.priority = priority,
        };
	/* Set up the initial task struct.  */
	nfs_ops->commit_setup(data, &msg);

	dprintk("NFS: initiated commit call\n");

	nfs4_state_protect(NFS_SERVER(data->inode)->nfs_client,
		NFS_SP4_MACH_CRED_COMMIT, &task_setup_data.rpc_client, &msg);

	task = rpc_run_task(&task_setup_data);
	if (IS_ERR(task))
		return PTR_ERR(task);
	if (how & FLUSH_SYNC)
		rpc_wait_for_completion_task(task);
	rpc_put_task(task);
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 88 42.93% 9 56.25%
fred isaman fred isaman 71 34.63% 2 12.50%
weston andros adamson weston andros adamson 22 10.73% 1 6.25%
pre-git pre-git 11 5.37% 1 6.25%
peng tao peng tao 7 3.41% 1 6.25%
andy adamson andy adamson 5 2.44% 1 6.25%
kinglong mee kinglong mee 1 0.49% 1 6.25%
Total 205 100.00% 16 100.00%


EXPORT_SYMBOL_GPL(nfs_initiate_commit);



static loff_t nfs_get_lwb(struct list_head *head)
{
	loff_t lwb = 0;
	struct nfs_page *req;

	list_for_each_entry(req, head, wb_list)
		if (lwb < (req_offset(req) + req->wb_bytes))
			lwb = req_offset(req) + req->wb_bytes;

	return lwb;
}

Contributors
Person Tokens Prop Commits CommitProp
peng tao peng tao 58 100.00% 1 100.00%
Total 58 100.00% 1 100.00%

/*
 * Set up the argument/result storage required for the RPC call.
 */


void nfs_init_commit(struct nfs_commit_data *data,
		     struct list_head *head,
		     struct pnfs_layout_segment *lseg,
		     struct nfs_commit_info *cinfo)
{
	struct nfs_page *first = nfs_list_entry(head->next);
	struct inode *inode = d_inode(first->wb_context->dentry);

	/* Set up the RPC argument and reply structs
         * NB: take care not to mess about with data->commit et al. */

	list_splice_init(head, &data->pages);

	data->inode	  = inode;
	data->cred	  = first->wb_context->cred;
	data->lseg	  = lseg; /* reference transferred */
	/* only set lwb for pnfs commit */
	if (lseg)
		data->lwb = nfs_get_lwb(&data->pages);
	data->mds_ops     = &nfs_commit_ops;
	data->completion_ops = cinfo->completion_ops;
	data->dreq	  = cinfo->dreq;

	data->args.fh     = NFS_FH(data->inode);
	/* Note: we always request a commit of the entire inode */
	data->args.offset = 0;
	data->args.count  = 0;
	data->context     = get_nfs_open_context(first->wb_context);
	data->res.fattr   = &data->fattr;
	data->res.verf    = &data->verf;
	nfs_fattr_init(&data->fattr);
}
Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 82 41.84% 5 33.33%
trond myklebust trond myklebust 71 36.22% 4 26.67%
pre-git pre-git 22 11.22% 3 20.00%
peng tao peng tao 17 8.67% 1 6.67%
david howells david howells 3 1.53% 1 6.67%
andrew morton andrew morton 1 0.51% 1 6.67%
Total 196 100.00% 15 100.00%


EXPORT_SYMBOL_GPL(nfs_init_commit);



void nfs_retry_commit(struct list_head *page_list,
		      struct pnfs_layout_segment *lseg,
		      struct nfs_commit_info *cinfo,
		      u32 ds_commit_idx)
{
	struct nfs_page *req;

	while (!list_empty(page_list)) {
		req = nfs_list_entry(page_list->next);
		nfs_list_remove_request(req);
		nfs_mark_request_commit(req, lseg, cinfo, ds_commit_idx);
		if (!cinfo->dreq)
			nfs_clear_page_commit(req->wb_page);
		nfs_unlock_and_release_request(req);
	}
}
Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 73 89.02% 4 50.00%
weston andros adamson weston andros adamson 5 6.10% 1 12.50%
mel gorman mel gorman 2 2.44% 1 12.50%
trond myklebust trond myklebust 1 1.22% 1 12.50%
tom haynes tom haynes 1 1.22% 1 12.50%
Total 82 100.00% 8 100.00%


EXPORT_SYMBOL_GPL(nfs_retry_commit);


static void

nfs_commit_resched_write(struct nfs_commit_info *cinfo,
		struct nfs_page *req)
{
	__set_page_dirty_nobuffers(req->wb_page);
}

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

/*
 * Commit dirty pages
 */

static int

nfs_commit_list(struct inode *inode, struct list_head *head, int how,
		struct nfs_commit_info *cinfo)
{
	struct nfs_commit_data	*data;

	/* another commit raced with us */
	if (list_empty(head))
		return 0;

	data = nfs_commitdata_alloc();

	if (!data)
		goto out_bad;

	/* Set up the argument struct */
	nfs_init_commit(data, head, NULL, cinfo);
	atomic_inc(&cinfo->mds->rpcs_out);
	return nfs_initiate_commit(NFS_CLIENT(inode), data, NFS_PROTO(inode),
				   data->mds_ops, how, 0);
 out_bad:
	nfs_retry_commit(head, NULL, cinfo, 0);
	return -ENOMEM;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 45 38.79% 1 5.88%
fred isaman fred isaman 41 35.34% 7 41.18%
weston andros adamson weston andros adamson 13 11.21% 2 11.76%
chuck lever chuck lever 5 4.31% 1 5.88%
peng tao peng tao 5 4.31% 1 5.88%
trond myklebust trond myklebust 5 4.31% 4 23.53%
andy adamson andy adamson 2 1.72% 1 5.88%
Total 116 100.00% 17 100.00%



int nfs_commit_file(struct file *file, struct nfs_write_verifier *verf)
{
	struct inode *inode = file_inode(file);
	struct nfs_open_context *open;
	struct nfs_commit_info cinfo;
	struct nfs_page *req;
	int ret;

	open = get_nfs_open_context(nfs_file_open_context(file));
	req  = nfs_create_request(open, NULL, NULL, 0, i_size_read(inode));
	if (IS_ERR(req)) {
		ret = PTR_ERR(req);
		goto out_put;
	}

	nfs_init_cinfo_from_inode(&cinfo, inode);

	memcpy(&req->wb_verf, verf, sizeof(struct nfs_write_verifier));
	nfs_request_add_commit_list(req, &cinfo);
	ret = nfs_commit_inode(inode, FLUSH_SYNC);
	if (ret > 0)
		ret = 0;

	nfs_free_request(req);
out_put:
	put_nfs_open_context(open);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
anna schumaker anna schumaker 148 95.48% 1 50.00%
dan carpenter dan carpenter 7 4.52% 1 50.00%
Total 155 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(nfs_commit_file);

/*
 * COMMIT call returned
 */


static void nfs_commit_done(struct rpc_task *task, void *calldata)
{
	struct nfs_commit_data	*data = calldata;

        dprintk("NFS: %5u nfs_commit_done (status %d)\n",
                                task->tk_pid, task->tk_status);

	/* Call the NFS version-specific code */
	NFS_PROTO(data->inode)->commit_done(task, data);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 25 50.00% 1 14.29%
trond myklebust trond myklebust 23 46.00% 4 57.14%
chuck lever chuck lever 1 2.00% 1 14.29%
fred isaman fred isaman 1 2.00% 1 14.29%
Total 50 100.00% 7 100.00%



static void nfs_commit_release_pages(struct nfs_commit_data *data)
{
	struct nfs_page	*req;
	int status = data->task.tk_status;
	struct nfs_commit_info cinfo;
	struct nfs_server *nfss;

	while (!list_empty(&data->pages)) {
		req = nfs_list_entry(data->pages.next);
		nfs_list_remove_request(req);
		if (req->wb_page)
			nfs_clear_page_commit(req->wb_page);

		dprintk("NFS:       commit (%s/%llu %d@%lld)",
			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));
		if (status < 0) {
			nfs_context_set_write_error(req->wb_context, status);
			nfs_inode_remove_request(req);
			dprintk(", error = %d\n", status);
			goto next;
		}

		/* Okay, COMMIT succeeded, apparently. Check the verifier
                 * returned by the server against all stored verfs. */
		if (!nfs_write_verifier_cmp(&req->wb_verf, &data->verf.verifier)) {
			/* We have a match */
			nfs_inode_remove_request(req);
			dprintk(" OK\n");
			goto next;
		}
		/* We have a mismatch. Write the page again */
		dprintk(" mismatch\n");
		nfs_mark_request_dirty(req);
		set_bit(NFS_CONTEXT_RESEND_WRITES, &req->wb_context->flags);
	next:
		nfs_unlock_and_release_request(req);
	}
	nfss = NFS_SERVER(data->inode);
	if (atomic_long_read(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH)
		clear_bdi_congested(&nfss->backing_dev_info, BLK_RW_ASYNC);

	nfs_init_cinfo(&cinfo, data->inode, data->dreq);
	nfs_commit_end(cinfo.mds);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 127 47.04% 3 10.71%
trond myklebust trond myklebust 53 19.63% 9 32.14%
neil brown neil brown 36 13.33% 1 3.57%
fred isaman fred isaman 34 12.59% 6 21.43%
anna schumaker anna schumaker 6 2.22% 1 3.57%
chuck lever chuck lever 3 1.11% 2 7.14%
linus torvalds linus torvalds 3 1.11% 2 7.14%
david howells david howells 3 1.11% 1 3.57%
niels de vos niels de vos 2 0.74% 1 3.57%
peter zijlstra peter zijlstra 2 0.74% 1 3.57%
al viro al viro 1 0.37% 1 3.57%
Total 270 100.00% 28 100.00%



static void nfs_commit_release(void *calldata)
{
	struct nfs_commit_data *data = calldata;

	data->completion_ops->completion(data);
	nfs_commitdata_release(calldata);
}

Contributors
Person Tokens Prop Commits CommitProp
fred isaman fred isaman 21 67.74% 3 50.00%
trond myklebust trond myklebust 9 29.03% 2 33.33%
pre-git pre-git 1 3.23% 1 16.67%
Total 31 100.00% 6 100.00%


static const struct rpc_call_ops nfs_commit_ops = {
	.rpc_call_prepare = nfs_commit_prepare,
	.rpc_call_done = nfs_commit_done,
	.rpc_release = nfs_commit_release,
};


static const struct nfs_commit_completion_ops nfs_commit_completion_ops = {
	.completion = nfs_commit_release_pages,
	.resched_write = nfs_commit_resched_write,
};



int nfs_generic_commit_list(struct inode *inode, struct list_head *head,
			    int how, struct nfs_commit_info *cinfo)
{
	int status;

	status = pnfs_commit_list(inode, head, how, cinfo);
	if (status == PNFS_NOT_ATTEMPTED)
		status = nfs_commit_list(inode, head, how, cinfo);
	return status;
}

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



int nfs_commit_inode(struct inode *inode, int how)
{
	LIST_HEAD(head);
	struct nfs_commit_info cinfo;
	int may_wait = how & FLUSH_SYNC;
	int error = 0;
	int res;

	nfs_init_cinfo_from_inode(&cinfo, inode);
	nfs_commit_begin(cinfo.mds);
	res = nfs_scan_commit(inode, &head, &cinfo);
	if (res)
		error = nfs_generic_commit_list(inode, &head, how, &cinfo);
	nfs_commit_end(cinfo.mds);
	if (error < 0)
		goto out_error;
	if (!may_wait)
		goto out_mark_dirty;
	error = wait_on_commit(cinfo.mds);
	if (error < 0)
		return error;
	return res;
out_error:
	res = error;
	/* Note: If we exit without ensuring that the commit is complete,
         * we must mark the inode as dirty. Otherwise, future calls to
         * sync_inode() with the WB_SYNC_ALL flag set will fail to ensure
         * that the data is on the disk.
         */
out_mark_dirty:
	__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
	return res;
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 88 59.46% 7 53.85%
pre-git pre-git 37 25.00% 2 15.38%
fred isaman fred isaman 22 14.86% 3 23.08%
linus torvalds linus torvalds 1 0.68% 1 7.69%
Total 148 100.00% 13 100.00%


EXPORT_SYMBOL_GPL(nfs_commit_inode);



int nfs_write_inode(struct inode *inode, struct writeback_control *wbc)
{
	struct nfs_inode *nfsi = NFS_I(inode);
	int flags = FLUSH_SYNC;
	int ret = 0;

	/* no commits means nothing needs to be done */
	if (!nfsi->commit_info.ncommit)
		return ret;

	if (wbc->sync_mode == WB_SYNC_NONE) {
		/* Don't commit yet if this is a non-blocking flush and there
                 * are a lot of outstanding writes for this mapping.
                 */
		if (nfsi->commit_info.ncommit <= (nfsi->nrequests >> 1))
			goto out_mark_dirty;

		/* don't wait for the COMMIT response */
		flags = 0;
	}

	ret = nfs_commit_inode(inode, flags);
	if (ret >= 0) {
		if (wbc->sync_mode == WB_SYNC_NONE) {
			if (ret < wbc->nr_to_write)
				wbc->nr_to_write -= ret;
			else
				wbc->nr_to_write = 0;
		}
		return 0;
	}
out_mark_dirty:
	__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 122 83.56% 2 28.57%
jeff layton jeff layton 18 12.33% 2 28.57%
fred isaman fred isaman 4 2.74% 1 14.29%
anna schumaker anna schumaker 1 0.68% 1 14.29%
weston andros adamson weston andros adamson 1 0.68% 1 14.29%
Total 146 100.00% 7 100.00%


EXPORT_SYMBOL_GPL(nfs_write_inode);

/*
 * Wrapper for filemap_write_and_wait_range()
 *
 * Needed for pNFS in order to ensure data becomes visible to the
 * client.
 */


int nfs_filemap_write_and_wait_range(struct address_space *mapping,
		loff_t lstart, loff_t lend)
{
	int ret;

	ret = filemap_write_and_wait_range(mapping, lstart, lend);
	if (ret == 0)
		ret = pnfs_sync_inode(mapping->host, true);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 50 100.00% 1 100.00%
Total 50 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(nfs_filemap_write_and_wait_range);

/*
 * flush the inode to disk.
 */


int nfs_wb_all(struct inode *inode)
{
	int ret;

	trace_nfs_writeback_inode_enter(inode);

	ret = filemap_write_and_wait(inode->i_mapping);
	if (ret)
		goto out;
	ret = nfs_commit_inode(inode, FLUSH_SYNC);
	if (ret < 0)
		goto out;
	pnfs_sync_inode(inode, true);
	ret = 0;

out:
	trace_nfs_writeback_inode_exit(inode, ret);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 58 77.33% 3 60.00%
chuck lever chuck lever 14 18.67% 1 20.00%
pre-git pre-git 3 4.00% 1 20.00%
Total 75 100.00% 5 100.00%


EXPORT_SYMBOL_GPL(nfs_wb_all);



int nfs_wb_page_cancel(struct inode *inode, struct page *page)
{
	struct nfs_page *req;
	int ret = 0;

	wait_on_page_writeback(page);

	/* blocking call to cancel all requests and join to a single (head)
         * request */
	req = nfs_lock_and_join_requests(page, false);

	if (IS_ERR(req)) {
		ret = PTR_ERR(req);
	} else if (req) {
		/* all requests from this page have been cancelled by
                 * nfs_lock_and_join_requests, so just remove the head
                 * request from the inode / page_private pointer and
                 * release it */
		nfs_inode_remove_request(req);
		nfs_unlock_and_release_request(req);
	}

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 61 79.22% 7 87.50%
weston andros adamson weston andros adamson 16 20.78% 1 12.50%
Total 77 100.00% 8 100.00%

/*
 * Write back all requests on one page - we do this before reading it.
 */


int nfs_wb_single_page(struct inode *inode, struct page *page, bool launder)
{
	loff_t range_start = page_file_offset(page);
	loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
	struct writeback_control wbc = {
		.sync_mode = WB_SYNC_ALL,
		.nr_to_write = 0,
		.range_start = range_start,
		.range_end = range_end,
        };
	int ret;

	trace_nfs_writeback_page_enter(inode);

	for (;;) {
		wait_on_page_writeback(page);
		if (clear_page_dirty_for_io(page)) {
			ret = nfs_writepage_locked(page, &wbc, launder);
			if (ret < 0)
				goto out_error;
			continue;
		}
		ret = 0;
		if (!PagePrivate(page))
			break;
		ret = nfs_commit_inode(inode, FLUSH_SYNC);
		if (ret < 0)
			goto out_error;
	}
out_error:
	trace_nfs_writeback_page_exit(inode, ret);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 152 95.00% 7 70.00%
peng tao peng tao 6 3.75% 1 10.00%
kirill a. shutemov kirill a. shutemov 1 0.62% 1 10.00%
mel gorman mel gorman 1 0.62% 1 10.00%
Total 160 100.00% 10 100.00%

#ifdef CONFIG_MIGRATION


int nfs_migrate_page(struct address_space *mapping, struct page *newpage,
		struct page *page, enum migrate_mode mode)
{
	/*
         * If PagePrivate is set, then the page is currently associated with
         * an in-progress read or write request. Don't try to migrate it.
         *
         * FIXME: we could do this in principle, but we'll need a way to ensure
         *        that we can safely release the inode reference while holding
         *        the page lock.
         */
	if (PagePrivate(page))
		return -EBUSY;

	if (!nfs_fscache_release_page(page, GFP_KERNEL))
		return -EBUSY;

	return migrate_page(mapping, newpage, page, mode);
}
Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 36 58.06% 2 33.33%
jeff layton jeff layton 12 19.35% 1 16.67%
david howells david howells 8 12.90% 1 16.67%
mel gorman mel gorman 6 9.68% 2 33.33%
Total 62 100.00% 6 100.00%

#endif



int __init nfs_init_writepagecache(void)
{
	nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
					     sizeof(struct nfs_pgio_header),
					     0, SLAB_HWCACHE_ALIGN,
					     NULL);
	if (nfs_wdata_cachep == NULL)
		return -ENOMEM;

	nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
						     nfs_wdata_cachep);
	if (nfs_wdata_mempool == NULL)
		goto out_destroy_write_cache;

	nfs_cdata_cachep = kmem_cache_create("nfs_commit_data",
					     sizeof(struct nfs_commit_data),
					     0, SLAB_HWCACHE_ALIGN,
					     NULL);
	if (nfs_cdata_cachep == NULL)
		goto out_destroy_write_mempool;

	nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
						      nfs_cdata_cachep);
	if (nfs_commit_mempool == NULL)
		goto out_destroy_commit_cache;

	/*
         * NFS congestion size, scale with available memory.
         *
         *  64MB:    8192k
         * 128MB:   11585k
         * 256MB:   16384k
         * 512MB:   23170k
         *   1GB:   32768k
         *   2GB:   46340k
         *   4GB:   65536k
         *   8GB:   92681k
         *  16GB:  131072k
         *
         * This allows larger machines to have larger/more transfers.
         * Limit the default to 256M
         */
	nfs_congestion_kb = (16*int_sqrt(totalram_pages)) << (PAGE_SHIFT-10);
	if (nfs_congestion_kb > 256*1024)
		nfs_congestion_kb = 256*1024;

	return 0;

out_destroy_commit_cache:
	kmem_cache_destroy(nfs_cdata_cachep);
out_destroy_write_mempool:
	mempool_destroy(nfs_wdata_mempool);
out_destroy_write_cache:
	kmem_cache_destroy(nfs_wdata_cachep);
	return -ENOMEM;
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 37 22.98% 3 25.00%
jeff layton jeff layton 34 21.12% 1 8.33%
peter zijlstra peter zijlstra 32 19.88% 1 8.33%
trond myklebust trond myklebust 27 16.77% 1 8.33%
fred isaman fred isaman 25 15.53% 1 8.33%
matthew dobson matthew dobson 2 1.24% 1 8.33%
david howells david howells 1 0.62% 1 8.33%
linus torvalds linus torvalds 1 0.62% 1 8.33%
yanchuan nian yanchuan nian 1 0.62% 1 8.33%
weston andros adamson weston andros adamson 1 0.62% 1 8.33%
Total 161 100.00% 12 100.00%



void nfs_destroy_writepagecache(void)
{
	mempool_destroy(nfs_commit_mempool);
	kmem_cache_destroy(nfs_cdata_cachep);
	mempool_destroy(nfs_wdata_mempool);
	kmem_cache_destroy(nfs_wdata_cachep);
}

Contributors
Person Tokens Prop Commits CommitProp
pre-git pre-git 11 40.74% 3 50.00%
trond myklebust trond myklebust 10 37.04% 1 16.67%
jeff layton jeff layton 5 18.52% 1 16.67%
linus torvalds linus torvalds 1 3.70% 1 16.67%
Total 27 100.00% 6 100.00%


static const struct nfs_rw_ops nfs_rw_write_ops = {
	.rw_mode		= FMODE_WRITE,
	.rw_alloc_header	= nfs_writehdr_alloc,
	.rw_free_header		= nfs_writehdr_free,
	.rw_done		= nfs_writeback_done,
	.rw_result		= nfs_writeback_result,
	.rw_initiate		= nfs_initiate_write,
};
Overall Contributors
Person Tokens Prop Commits CommitProp
trond myklebust trond myklebust 3683 43.42% 124 42.91%
fred isaman fred isaman 1247 14.70% 25 8.65%
weston andros adamson weston andros adamson 1133 13.36% 22 7.61%
pre-git pre-git 719 8.48% 17 5.88%
jeff layton jeff layton 307 3.62% 9 3.11%
anna schumaker anna schumaker 296 3.49% 9 3.11%
peng tao peng tao 191 2.25% 4 1.38%
peter zijlstra peter zijlstra 148 1.74% 3 1.04%
mel gorman mel gorman 119 1.40% 6 2.08%
scott mayhew scott mayhew 110 1.30% 4 1.38%
andy adamson andy adamson 91 1.07% 5 1.73%
chuck lever chuck lever 70 0.83% 10 3.46%
neil brown neil brown 62 0.73% 3 1.04%
christoph hellwig christoph hellwig 55 0.65% 2 0.69%
linus torvalds linus torvalds 50 0.59% 10 3.46%
kinglong mee kinglong mee 40 0.47% 3 1.04%
bryan schumaker bryan schumaker 31 0.37% 4 1.38%
david howells david howells 24 0.28% 4 1.38%
dave wysochanski dave wysochanski 23 0.27% 1 0.35%
andrew morton andrew morton 13 0.15% 5 1.73%
tom haynes tom haynes 11 0.13% 3 1.04%
dave chinner dave chinner 10 0.12% 1 0.35%
benjamin coddington benjamin coddington 10 0.12% 1 0.35%
dan carpenter dan carpenter 7 0.08% 1 0.35%
tejun heo tejun heo 5 0.06% 1 0.35%
jens axboe jens axboe 4 0.05% 1 0.35%
rakib mullick rakib mullick 4 0.05% 1 0.35%
nick piggin nick piggin 3 0.04% 1 0.35%
paul gortmaker paul gortmaker 3 0.04% 1 0.35%
matthew dobson matthew dobson 2 0.02% 1 0.35%
kirill a. shutemov kirill a. shutemov 2 0.02% 1 0.35%
al viro al viro 2 0.02% 2 0.69%
huang ying huang ying 2 0.02% 1 0.35%
niels de vos niels de vos 2 0.02% 1 0.35%
christoph lameter christoph lameter 2 0.02% 1 0.35%
yanchuan nian yanchuan nian 1 0.01% 1 0.35%
Total 8482 100.00% 289 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	48	94.12%	3	60.00%
fred isaman	fred isaman	2	3.92%	1	20.00%
mel gorman	mel gorman	1	1.96%	1	20.00%
	Total	51	100.00%	5	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 fs/nfs/write.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

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

Contributors

Contributors
