Lines Matching +full:eye +full:- +full:src
1 // SPDX-License-Identifier: GPL-2.0-only
23 #include <linux/backing-dev.h>
85 INIT_LIST_HEAD(&p->pages); in nfs_commitdata_alloc()
107 p->rw_mode = FMODE_WRITE; in nfs_writehdr_alloc()
124 ioc->complete = complete; in nfs_io_completion_init()
125 ioc->data = data; in nfs_io_completion_init()
126 kref_init(&ioc->refcount); in nfs_io_completion_init()
133 ioc->complete(ioc->data); in nfs_io_completion_release()
140 kref_get(&ioc->refcount); in nfs_io_completion_get()
146 kref_put(&ioc->refcount, nfs_io_completion_release); in nfs_io_completion_put()
152 if (!test_and_set_bit(PG_INODE_REF, &req->wb_flags)) { in nfs_page_set_inode_ref()
153 kref_get(&req->wb_kref); in nfs_page_set_inode_ref()
154 atomic_long_inc(&NFS_I(inode)->nrequests); in nfs_page_set_inode_ref()
163 if (!test_bit(PG_REMOVE, &req->wb_flags)) in nfs_cancel_remove_inode()
168 if (test_and_clear_bit(PG_REMOVE, &req->wb_flags)) in nfs_cancel_remove_inode()
183 * nfs_page_find_head_request_locked - find head request associated with @page
197 spin_lock(&mapping->private_lock); in nfs_page_find_private_request()
200 WARN_ON_ONCE(req->wb_head != req); in nfs_page_find_private_request()
201 kref_get(&req->wb_kref); in nfs_page_find_private_request()
203 spin_unlock(&mapping->private_lock); in nfs_page_find_private_request()
210 struct inode *inode = page_file_mapping(page)->host; in nfs_page_find_swap_request()
215 mutex_lock(&nfsi->commit_mutex); in nfs_page_find_swap_request()
220 WARN_ON_ONCE(req->wb_head != req); in nfs_page_find_swap_request()
221 kref_get(&req->wb_kref); in nfs_page_find_swap_request()
224 mutex_unlock(&nfsi->commit_mutex); in nfs_page_find_swap_request()
229 * nfs_page_find_head_request - find head request associated with @page
245 struct inode *inode = page_file_mapping(page)->host; in nfs_find_and_lock_page_request()
276 struct inode *inode = page_file_mapping(page)->host; in nfs_grow_file()
280 spin_lock(&inode->i_lock); in nfs_grow_file()
282 end_index = (i_size - 1) >> PAGE_SHIFT; in nfs_grow_file()
289 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE; in nfs_grow_file()
292 spin_unlock(&inode->i_lock); in nfs_grow_file()
298 struct inode *inode = mapping->host; in nfs_set_pageerror()
300 nfs_zap_mapping(mapping->host, mapping); in nfs_set_pageerror()
302 spin_lock(&inode->i_lock); in nfs_set_pageerror()
303 NFS_I(inode)->cache_validity |= NFS_INO_REVAL_FORCED | in nfs_set_pageerror()
306 spin_unlock(&inode->i_lock); in nfs_set_pageerror()
315 if (mapping->host) in nfs_mapping_set_error()
316 errseq_set(&mapping->host->i_sb->s_wb_err, in nfs_mapping_set_error()
317 error == -ENOSPC ? -ENOSPC : -EIO); in nfs_mapping_set_error()
323 * @head - head request of page group
324 * @page_offset - offset into page
341 if (page_offset >= req->wb_pgbase && in nfs_page_group_search_locked()
342 page_offset < (req->wb_pgbase + req->wb_bytes)) in nfs_page_group_search_locked()
345 req = req->wb_this_page; in nfs_page_group_search_locked()
353 * @head - head request of page group
362 unsigned int len = nfs_page_length(req->wb_page); in nfs_page_group_covers_page()
367 tmp = nfs_page_group_search_locked(req->wb_head, pos); in nfs_page_group_covers_page()
370 pos = tmp->wb_pgbase + tmp->wb_bytes; in nfs_page_group_covers_page()
382 if (PageUptodate(req->wb_page)) in nfs_mark_uptodate()
386 SetPageUptodate(req->wb_page); in nfs_mark_uptodate()
393 if (wbc->sync_mode == WB_SYNC_ALL) in wb_priority()
404 #define NFS_CONGESTION_ON_THRESH (nfs_congestion_kb >> (PAGE_SHIFT-10))
406 (NFS_CONGESTION_ON_THRESH - (NFS_CONGESTION_ON_THRESH >> 2))
410 struct inode *inode = page_file_mapping(page)->host; in nfs_set_page_writeback()
416 if (atomic_long_inc_return(&nfss->writeback) > in nfs_set_page_writeback()
423 struct inode *inode = page_file_mapping(req->wb_page)->host; in nfs_end_page_writeback()
432 end_page_writeback(req->wb_page); in nfs_end_page_writeback()
433 if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH) in nfs_end_page_writeback()
438 * nfs_destroy_unlinked_subrequests - destroy recently unlinked subrequests
440 * @destroy_list - request list (using wb_this_page) terminated by @old_head
441 * @old_head - the old head of the list
455 destroy_list = (subreq->wb_this_page == old_head) ? in nfs_destroy_unlinked_subrequests()
456 NULL : subreq->wb_this_page; in nfs_destroy_unlinked_subrequests()
458 /* Note: lock subreq in order to change subreq->wb_head */ in nfs_destroy_unlinked_subrequests()
460 WARN_ON_ONCE(old_head != subreq->wb_head); in nfs_destroy_unlinked_subrequests()
463 subreq->wb_this_page = subreq; in nfs_destroy_unlinked_subrequests()
464 subreq->wb_head = subreq; in nfs_destroy_unlinked_subrequests()
466 clear_bit(PG_REMOVE, &subreq->wb_flags); in nfs_destroy_unlinked_subrequests()
469 if (!kref_read(&subreq->wb_kref)) { in nfs_destroy_unlinked_subrequests()
471 if (test_and_clear_bit(PG_TEARDOWN, &subreq->wb_flags)) { in nfs_destroy_unlinked_subrequests()
482 if (test_and_clear_bit(PG_INODE_REF, &subreq->wb_flags)) { in nfs_destroy_unlinked_subrequests()
484 atomic_long_dec(&NFS_I(inode)->nrequests); in nfs_destroy_unlinked_subrequests()
494 * nfs_join_page_group - destroy subrequests of the head req
511 pgbase = head->wb_pgbase; in nfs_join_page_group()
512 bytes = head->wb_bytes; in nfs_join_page_group()
513 off = head->wb_offset; in nfs_join_page_group()
514 for (subreq = head->wb_this_page; subreq != head; in nfs_join_page_group()
515 subreq = subreq->wb_this_page) { in nfs_join_page_group()
517 if (pgbase > subreq->wb_pgbase) { in nfs_join_page_group()
518 off -= pgbase - subreq->wb_pgbase; in nfs_join_page_group()
519 bytes += pgbase - subreq->wb_pgbase; in nfs_join_page_group()
520 pgbase = subreq->wb_pgbase; in nfs_join_page_group()
522 bytes = max(subreq->wb_pgbase + subreq->wb_bytes in nfs_join_page_group()
523 - pgbase, bytes); in nfs_join_page_group()
527 head->wb_pgbase = pgbase; in nfs_join_page_group()
528 head->wb_bytes = bytes; in nfs_join_page_group()
529 head->wb_offset = off; in nfs_join_page_group()
536 subreq = subreq->wb_this_page; in nfs_join_page_group()
540 if (head->wb_this_page != head) { in nfs_join_page_group()
542 destroy_list = head->wb_this_page; in nfs_join_page_group()
543 head->wb_this_page = head; in nfs_join_page_group()
550 * nfs_lock_and_join_requests - join all subreqs to the head req
559 * Returns a locked, referenced pointer to the head request - which after
567 struct inode *inode = page_file_mapping(page)->host; in nfs_lock_and_join_requests()
575 * reference to the whole page group - the group will not be destroyed in nfs_lock_and_join_requests()
597 nfs_mapping_set_error(req->wb_page, error); in nfs_write_error()
621 WARN_ON_ONCE(test_bit(PG_CLEAN, &req->wb_flags)); in nfs_page_async_flush()
624 ret = pgio->pg_error; in nfs_page_async_flush()
630 ret = pgio->pg_error; in nfs_page_async_flush()
638 ret = -EAGAIN; in nfs_page_async_flush()
640 pgio->pg_error = 0; in nfs_page_async_flush()
642 nfs_add_stats(page_file_mapping(page)->host, in nfs_page_async_flush()
658 if (ret == -EAGAIN) { in nfs_do_writepage()
672 struct inode *inode = page_file_mapping(page)->host; in nfs_writepage_locked()
711 struct inode *inode = mapping->host; in nfs_writepages()
742 struct address_space *mapping = page_file_mapping(req->wb_page); in nfs_inode_add_request()
745 WARN_ON_ONCE(req->wb_this_page != req); in nfs_inode_add_request()
751 * Swap-space should not get truncated. Hence no need to plug the race in nfs_inode_add_request()
754 spin_lock(&mapping->private_lock); in nfs_inode_add_request()
756 NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE)) in nfs_inode_add_request()
758 if (likely(!PageSwapCache(req->wb_page))) { in nfs_inode_add_request()
759 set_bit(PG_MAPPED, &req->wb_flags); in nfs_inode_add_request()
760 SetPagePrivate(req->wb_page); in nfs_inode_add_request()
761 set_page_private(req->wb_page, (unsigned long)req); in nfs_inode_add_request()
763 spin_unlock(&mapping->private_lock); in nfs_inode_add_request()
764 atomic_long_inc(&nfsi->nrequests); in nfs_inode_add_request()
765 /* this a head request for a page group - mark it as having an in nfs_inode_add_request()
769 WARN_ON(test_and_set_bit(PG_INODE_REF, &req->wb_flags)); in nfs_inode_add_request()
770 kref_get(&req->wb_kref); in nfs_inode_add_request()
778 struct address_space *mapping = page_file_mapping(req->wb_page); in nfs_inode_remove_request()
779 struct inode *inode = mapping->host; in nfs_inode_remove_request()
784 head = req->wb_head; in nfs_inode_remove_request()
786 spin_lock(&mapping->private_lock); in nfs_inode_remove_request()
787 if (likely(head->wb_page && !PageSwapCache(head->wb_page))) { in nfs_inode_remove_request()
788 set_page_private(head->wb_page, 0); in nfs_inode_remove_request()
789 ClearPagePrivate(head->wb_page); in nfs_inode_remove_request()
790 clear_bit(PG_MAPPED, &head->wb_flags); in nfs_inode_remove_request()
792 spin_unlock(&mapping->private_lock); in nfs_inode_remove_request()
795 if (test_and_clear_bit(PG_INODE_REF, &req->wb_flags)) { in nfs_inode_remove_request()
797 atomic_long_dec(&nfsi->nrequests); in nfs_inode_remove_request()
804 if (req->wb_page) in nfs_mark_request_dirty()
805 __set_page_dirty_nobuffers(req->wb_page); in nfs_mark_request_dirty()
822 struct inode *inode = &nfsi->vfs_inode; in nfs_page_search_commits_for_head_request_locked()
829 return freq->wb_head; in nfs_page_search_commits_for_head_request_locked()
832 list_for_each_entry_safe(freq, t, &cinfo.mds->list, wb_list) { in nfs_page_search_commits_for_head_request_locked()
833 if (freq->wb_page == page) in nfs_page_search_commits_for_head_request_locked()
834 return freq->wb_head; in nfs_page_search_commits_for_head_request_locked()
841 * nfs_request_add_commit_list_locked - add request to a commit list
850 * The caller must hold NFS_I(cinfo->inode)->commit_mutex, and the
857 set_bit(PG_CLEAN, &req->wb_flags); in nfs_request_add_commit_list_locked()
859 atomic_long_inc(&cinfo->mds->ncommit); in nfs_request_add_commit_list_locked()
864 * nfs_request_add_commit_list - add request to a commit list
872 * The caller must _not_ hold the cinfo->lock, but must be
878 mutex_lock(&NFS_I(cinfo->inode)->commit_mutex); in nfs_request_add_commit_list()
879 nfs_request_add_commit_list_locked(req, &cinfo->mds->list, cinfo); in nfs_request_add_commit_list()
880 mutex_unlock(&NFS_I(cinfo->inode)->commit_mutex); in nfs_request_add_commit_list()
881 if (req->wb_page) in nfs_request_add_commit_list()
882 nfs_mark_page_unstable(req->wb_page, cinfo); in nfs_request_add_commit_list()
887 * nfs_request_remove_commit_list - Remove request from a commit list
895 * The caller _must_ hold the cinfo->lock and the nfs_page lock.
901 if (!test_and_clear_bit(PG_CLEAN, &(req)->wb_flags)) in nfs_request_remove_commit_list()
904 atomic_long_dec(&cinfo->mds->ncommit); in nfs_request_remove_commit_list()
911 cinfo->inode = inode; in nfs_init_cinfo_from_inode()
912 cinfo->mds = &NFS_I(inode)->commit_info; in nfs_init_cinfo_from_inode()
913 cinfo->ds = pnfs_get_ds_info(inode); in nfs_init_cinfo_from_inode()
914 cinfo->dreq = NULL; in nfs_init_cinfo_from_inode()
915 cinfo->completion_ops = &nfs_commit_completion_ops; in nfs_init_cinfo_from_inode()
945 dec_wb_stat(&inode_to_bdi(page_file_mapping(page)->host)->wb, in nfs_clear_page_commit()
953 if (test_bit(PG_CLEAN, &req->wb_flags)) { in nfs_clear_request_commit()
955 struct inode *inode = d_inode(ctx->dentry); in nfs_clear_request_commit()
957 mutex_lock(&NFS_I(inode)->commit_mutex); in nfs_clear_request_commit()
961 mutex_unlock(&NFS_I(inode)->commit_mutex); in nfs_clear_request_commit()
962 nfs_clear_page_commit(req->wb_page); in nfs_clear_request_commit()
968 if (hdr->verf.committed == NFS_DATA_SYNC) in nfs_write_need_commit()
969 return hdr->lseg == NULL; in nfs_write_need_commit()
970 return hdr->verf.committed != NFS_FILE_SYNC; in nfs_write_need_commit()
975 nfs_io_completion_get(hdr->io_completion); in nfs_async_write_init()
983 if (test_bit(NFS_IOHDR_REDO, &hdr->flags)) in nfs_write_completion()
985 nfs_init_cinfo_from_inode(&cinfo, hdr->inode); in nfs_write_completion()
986 while (!list_empty(&hdr->pages)) { in nfs_write_completion()
987 struct nfs_page *req = nfs_list_entry(hdr->pages.next); in nfs_write_completion()
989 bytes += req->wb_bytes; in nfs_write_completion()
991 if (test_bit(NFS_IOHDR_ERROR, &hdr->flags) && in nfs_write_completion()
992 (hdr->good_bytes < bytes)) { in nfs_write_completion()
993 trace_nfs_comp_error(req, hdr->error); in nfs_write_completion()
994 nfs_mapping_set_error(req->wb_page, hdr->error); in nfs_write_completion()
999 req->wb_nio = 0; in nfs_write_completion()
1000 memcpy(&req->wb_verf, &hdr->verf.verifier, sizeof(req->wb_verf)); in nfs_write_completion()
1001 nfs_mark_request_commit(req, hdr->lseg, &cinfo, in nfs_write_completion()
1002 hdr->pgio_mirror_idx); in nfs_write_completion()
1012 nfs_io_completion_put(hdr->io_completion); in nfs_write_completion()
1013 hdr->release(hdr); in nfs_write_completion()
1019 return atomic_long_read(&cinfo->mds->ncommit); in nfs_reqs_to_commit()
1022 /* NFS_I(cinfo->inode)->commit_mutex held by caller */
1024 nfs_scan_commit_list(struct list_head *src, struct list_head *dst, in nfs_scan_commit_list() argument
1030 list_for_each_entry_safe(req, tmp, src, wb_list) { in nfs_scan_commit_list()
1031 kref_get(&req->wb_kref); in nfs_scan_commit_list()
1037 clear_bit(PG_COMMIT_TO_DS, &req->wb_flags); in nfs_scan_commit_list()
1040 if ((ret == max) && !cinfo->dreq) in nfs_scan_commit_list()
1049 * nfs_scan_commit - Scan an inode for commit requests
1063 if (!atomic_long_read(&cinfo->mds->ncommit)) in nfs_scan_commit()
1065 mutex_lock(&NFS_I(cinfo->inode)->commit_mutex); in nfs_scan_commit()
1066 if (atomic_long_read(&cinfo->mds->ncommit) > 0) { in nfs_scan_commit()
1069 ret = nfs_scan_commit_list(&cinfo->mds->list, dst, in nfs_scan_commit()
1071 ret += pnfs_scan_commit_lists(inode, cinfo, max - ret); in nfs_scan_commit()
1073 mutex_unlock(&NFS_I(cinfo->inode)->commit_mutex); in nfs_scan_commit()
1100 rqend = req->wb_offset + req->wb_bytes; in nfs_try_to_update_request()
1103 * the offsets are non-contiguous. in nfs_try_to_update_request()
1107 if (offset > rqend || end < req->wb_offset) in nfs_try_to_update_request()
1111 if (offset < req->wb_offset) { in nfs_try_to_update_request()
1112 req->wb_offset = offset; in nfs_try_to_update_request()
1113 req->wb_pgbase = offset; in nfs_try_to_update_request()
1116 req->wb_bytes = end - req->wb_offset; in nfs_try_to_update_request()
1118 req->wb_bytes = rqend - req->wb_offset; in nfs_try_to_update_request()
1119 req->wb_nio = 0; in nfs_try_to_update_request()
1143 struct inode *inode = page_file_mapping(page)->host; in nfs_setup_write_request()
1177 struct file_lock_context *flctx = file_inode(file)->i_flctx; in nfs_flush_incompatible()
1184 * due to the lack of an ACCESS-type call in NFSv2. in nfs_flush_incompatible()
1192 l_ctx = req->wb_lock_context; in nfs_flush_incompatible()
1193 do_flush = req->wb_page != page || in nfs_flush_incompatible()
1196 !(list_empty_careful(&flctx->flc_posix) && in nfs_flush_incompatible()
1197 list_empty_careful(&flctx->flc_flock))) { in nfs_flush_incompatible()
1198 do_flush |= l_ctx->lockowner != current->files; in nfs_flush_incompatible()
1203 status = nfs_wb_page(page_file_mapping(page)->host, page); in nfs_flush_incompatible()
1212 * Returns -EACCES if the key will expire within RPC_KEY_EXPIRE_FAIL.
1224 !ctx->ll_cred) in nfs_key_timeout_notify()
1226 return -EACCES; in nfs_key_timeout_notify()
1235 struct rpc_auth *auth = NFS_SERVER(inode)->client->cl_auth; in nfs_ctx_key_to_expire()
1236 struct rpc_cred *cred = ctx->ll_cred; in nfs_ctx_key_to_expire()
1238 .cred = ctx->cred, in nfs_ctx_key_to_expire()
1241 if (cred && !cred->cr_ops->crmatch(&acred, cred, 0)) { in nfs_ctx_key_to_expire()
1243 ctx->ll_cred = NULL; in nfs_ctx_key_to_expire()
1247 cred = auth->au_ops->lookup_cred(auth, &acred, 0); in nfs_ctx_key_to_expire()
1250 ctx->ll_cred = cred; in nfs_ctx_key_to_expire()
1251 return !!(cred->cr_ops->crkey_timeout && in nfs_ctx_key_to_expire()
1252 cred->cr_ops->crkey_timeout(cred)); in nfs_ctx_key_to_expire()
1266 if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE) in nfs_write_pageuptodate()
1269 if (test_bit(NFS_INO_INVALIDATING, &nfsi->flags)) in nfs_write_pageuptodate()
1272 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) in nfs_write_pageuptodate()
1280 return fl->fl_start == 0 && fl->fl_end == OFFSET_MAX && in is_whole_file_wrlock()
1281 fl->fl_type == F_WRLCK; in is_whole_file_wrlock()
1295 struct file_lock_context *flctx = inode->i_flctx; in nfs_can_extend_write()
1298 if (file->f_flags & O_DSYNC) in nfs_can_extend_write()
1302 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE)) in nfs_can_extend_write()
1304 if (!flctx || (list_empty_careful(&flctx->flc_flock) && in nfs_can_extend_write()
1305 list_empty_careful(&flctx->flc_posix))) in nfs_can_extend_write()
1310 spin_lock(&flctx->flc_lock); in nfs_can_extend_write()
1311 if (!list_empty(&flctx->flc_posix)) { in nfs_can_extend_write()
1312 fl = list_first_entry(&flctx->flc_posix, struct file_lock, in nfs_can_extend_write()
1316 } else if (!list_empty(&flctx->flc_flock)) { in nfs_can_extend_write()
1317 fl = list_first_entry(&flctx->flc_flock, struct file_lock, in nfs_can_extend_write()
1319 if (fl->fl_type == F_WRLCK) in nfs_can_extend_write()
1322 spin_unlock(&flctx->flc_lock); in nfs_can_extend_write()
1329 * XXX: Keep an eye on generic_file_read to make sure it doesn't do bad
1337 struct inode *inode = mapping->host; in nfs_updatepage()
1382 task_setup_data->priority = priority; in nfs_initiate_write()
1383 rpc_ops->write_setup(hdr, msg, &task_setup_data->rpc_client); in nfs_initiate_write()
1394 req->wb_nio++; in nfs_redirty_request()
1396 set_bit(NFS_CONTEXT_RESEND_WRITES, &nfs_req_openctx(req)->flags); in nfs_redirty_request()
1406 req = nfs_list_entry(head->next); in nfs_async_write_error()
1417 nfs_async_write_error(&hdr->pages, 0); in nfs_async_write_reschedule_io()
1418 filemap_fdatawrite_range(hdr->inode->i_mapping, hdr->args.offset, in nfs_async_write_reschedule_io()
1419 hdr->args.offset + hdr->args.count - 1); in nfs_async_write_reschedule_io()
1437 if (server->pnfs_curr_ld && !force_mds) in nfs_pageio_init_write()
1438 pg_ops = server->pnfs_curr_ld->pg_write_ops; in nfs_pageio_init_write()
1441 server->wsize, ioflags); in nfs_pageio_init_write()
1449 if (pgio->pg_ops && pgio->pg_ops->pg_cleanup) in nfs_pageio_reset_write_mds()
1450 pgio->pg_ops->pg_cleanup(pgio); in nfs_pageio_reset_write_mds()
1452 pgio->pg_ops = &nfs_pgio_rw_ops; in nfs_pageio_reset_write_mds()
1456 mirror = &pgio->pg_mirrors[0]; in nfs_pageio_reset_write_mds()
1457 mirror->pg_bsize = NFS_SERVER(pgio->pg_inode)->wsize; in nfs_pageio_reset_write_mds()
1466 NFS_PROTO(data->inode)->commit_rpc_prepare(task, data); in nfs_commit_prepare()
1474 umode_t mode = inode->i_mode; in nfs_should_remove_suid()
1497 struct nfs_pgio_args *argp = &hdr->args; in nfs_writeback_check_extend()
1498 struct nfs_pgio_res *resp = &hdr->res; in nfs_writeback_check_extend()
1499 u64 size = argp->offset + resp->count; in nfs_writeback_check_extend()
1501 if (!(fattr->valid & NFS_ATTR_FATTR_SIZE)) in nfs_writeback_check_extend()
1502 fattr->size = size; in nfs_writeback_check_extend()
1503 if (nfs_size_to_loff_t(fattr->size) < i_size_read(hdr->inode)) { in nfs_writeback_check_extend()
1504 fattr->valid &= ~NFS_ATTR_FATTR_SIZE; in nfs_writeback_check_extend()
1507 if (size != fattr->size) in nfs_writeback_check_extend()
1512 fattr->valid |= NFS_ATTR_FATTR_SIZE; in nfs_writeback_check_extend()
1517 struct nfs_fattr *fattr = &hdr->fattr; in nfs_writeback_update_inode()
1518 struct inode *inode = hdr->inode; in nfs_writeback_update_inode()
1520 spin_lock(&inode->i_lock); in nfs_writeback_update_inode()
1523 spin_unlock(&inode->i_lock); in nfs_writeback_update_inode()
1537 * ->write_done will attempt to use post-op attributes to detect in nfs_writeback_done()
1539 * of close-to-open would allow us to continue caching even if in nfs_writeback_done()
1543 status = NFS_PROTO(inode)->write_done(task, hdr); in nfs_writeback_done()
1547 nfs_add_stats(inode, NFSIOS_SERVERWRITTENBYTES, hdr->res.count); in nfs_writeback_done()
1550 if (hdr->res.verf->committed < hdr->args.stable && in nfs_writeback_done()
1551 task->tk_status >= 0) { in nfs_writeback_done()
1566 NFS_SERVER(inode)->nfs_client->cl_hostname, in nfs_writeback_done()
1567 hdr->res.verf->committed, hdr->args.stable); in nfs_writeback_done()
1574 spin_lock(&inode->i_lock); in nfs_writeback_done()
1575 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_OTHER; in nfs_writeback_done()
1576 spin_unlock(&inode->i_lock); in nfs_writeback_done()
1587 struct nfs_pgio_args *argp = &hdr->args; in nfs_writeback_result()
1588 struct nfs_pgio_res *resp = &hdr->res; in nfs_writeback_result()
1590 if (resp->count < argp->count) { in nfs_writeback_result()
1594 nfs_inc_stats(hdr->inode, NFSIOS_SHORTWRITE); in nfs_writeback_result()
1597 if (resp->count == 0) { in nfs_writeback_result()
1601 argp->count); in nfs_writeback_result()
1604 nfs_set_pgio_error(hdr, -EIO, argp->offset); in nfs_writeback_result()
1605 task->tk_status = -EIO; in nfs_writeback_result()
1609 /* For non rpc-based layout drivers, retry-through-MDS */ in nfs_writeback_result()
1610 if (!task->tk_ops) { in nfs_writeback_result()
1611 hdr->pnfs_error = -EAGAIN; in nfs_writeback_result()
1616 if (resp->verf->committed != NFS_UNSTABLE) { in nfs_writeback_result()
1618 hdr->mds_offset += resp->count; in nfs_writeback_result()
1619 argp->offset += resp->count; in nfs_writeback_result()
1620 argp->pgbase += resp->count; in nfs_writeback_result()
1621 argp->count -= resp->count; in nfs_writeback_result()
1626 argp->stable = NFS_FILE_SYNC; in nfs_writeback_result()
1628 resp->count = 0; in nfs_writeback_result()
1629 resp->verf->committed = 0; in nfs_writeback_result()
1636 return wait_var_event_killable(&cinfo->rpcs_out, in wait_on_commit()
1637 !atomic_read(&cinfo->rpcs_out)); in wait_on_commit()
1642 atomic_inc(&cinfo->rpcs_out); in nfs_commit_begin()
1647 if (atomic_dec_and_test(&cinfo->rpcs_out)) { in nfs_commit_end()
1648 wake_up_var(&cinfo->rpcs_out); in nfs_commit_end()
1656 put_nfs_open_context(data->context); in nfs_commitdata_release()
1669 .rpc_argp = &data->args, in nfs_initiate_commit()
1670 .rpc_resp = &data->res, in nfs_initiate_commit()
1671 .rpc_cred = data->cred, in nfs_initiate_commit()
1674 .task = &data->task, in nfs_initiate_commit()
1684 nfs_ops->commit_setup(data, &msg, &task_setup_data.rpc_client); in nfs_initiate_commit()
1705 if (lwb < (req_offset(req) + req->wb_bytes)) in nfs_get_lwb()
1706 lwb = req_offset(req) + req->wb_bytes; in nfs_get_lwb()
1724 * NB: take care not to mess about with data->commit et al. */ in nfs_init_commit()
1727 list_splice_init(head, &data->pages); in nfs_init_commit()
1729 first = nfs_list_entry(data->pages.next); in nfs_init_commit()
1731 inode = d_inode(ctx->dentry); in nfs_init_commit()
1733 data->inode = inode; in nfs_init_commit()
1734 data->cred = ctx->cred; in nfs_init_commit()
1735 data->lseg = lseg; /* reference transferred */ in nfs_init_commit()
1738 data->lwb = nfs_get_lwb(&data->pages); in nfs_init_commit()
1739 data->mds_ops = &nfs_commit_ops; in nfs_init_commit()
1740 data->completion_ops = cinfo->completion_ops; in nfs_init_commit()
1741 data->dreq = cinfo->dreq; in nfs_init_commit()
1743 data->args.fh = NFS_FH(data->inode); in nfs_init_commit()
1745 data->args.offset = 0; in nfs_init_commit()
1746 data->args.count = 0; in nfs_init_commit()
1747 data->context = get_nfs_open_context(ctx); in nfs_init_commit()
1748 data->res.fattr = &data->fattr; in nfs_init_commit()
1749 data->res.verf = &data->verf; in nfs_init_commit()
1750 nfs_fattr_init(&data->fattr); in nfs_init_commit()
1751 nfs_commit_begin(cinfo->mds); in nfs_init_commit()
1763 req = nfs_list_entry(page_list->next); in nfs_retry_commit()
1766 if (!cinfo->dreq) in nfs_retry_commit()
1767 nfs_clear_page_commit(req->wb_page); in nfs_retry_commit()
1777 __set_page_dirty_nobuffers(req->wb_page); in nfs_commit_resched_write()
1795 nfs_retry_commit(head, NULL, cinfo, -1); in nfs_commit_list()
1796 return -ENOMEM; in nfs_commit_list()
1802 data->mds_ops, how, RPC_TASK_CRED_NOREF); in nfs_commit_list()
1813 task->tk_pid, task->tk_status); in nfs_commit_done()
1815 /* Call the NFS version-specific code */ in nfs_commit_done()
1816 NFS_PROTO(data->inode)->commit_done(task, data); in nfs_commit_done()
1822 const struct nfs_writeverf *verf = data->res.verf; in nfs_commit_release_pages()
1824 int status = data->task.tk_status; in nfs_commit_release_pages()
1828 while (!list_empty(&data->pages)) { in nfs_commit_release_pages()
1829 req = nfs_list_entry(data->pages.next); in nfs_commit_release_pages()
1831 if (req->wb_page) in nfs_commit_release_pages()
1832 nfs_clear_page_commit(req->wb_page); in nfs_commit_release_pages()
1835 nfs_req_openctx(req)->dentry->d_sb->s_id, in nfs_commit_release_pages()
1836 (unsigned long long)NFS_FILEID(d_inode(nfs_req_openctx(req)->dentry)), in nfs_commit_release_pages()
1837 req->wb_bytes, in nfs_commit_release_pages()
1840 if (req->wb_page) { in nfs_commit_release_pages()
1842 nfs_mapping_set_error(req->wb_page, status); in nfs_commit_release_pages()
1853 if (req->wb_page) in nfs_commit_release_pages()
1861 set_bit(NFS_CONTEXT_RESEND_WRITES, &nfs_req_openctx(req)->flags); in nfs_commit_release_pages()
1867 nfss = NFS_SERVER(data->inode); in nfs_commit_release_pages()
1868 if (atomic_long_read(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH) in nfs_commit_release_pages()
1869 clear_bdi_congested(inode_to_bdi(data->inode), BLK_RW_ASYNC); in nfs_commit_release_pages()
1871 nfs_init_cinfo(&cinfo, data->inode, data->dreq); in nfs_commit_release_pages()
1879 data->completion_ops->completion(data); in nfs_commit_release()
1924 if (wbc && wbc->sync_mode == WB_SYNC_NONE) { in __nfs_commit_inode()
1925 if (nscan < wbc->nr_to_write) in __nfs_commit_inode()
1926 wbc->nr_to_write -= nscan; in __nfs_commit_inode()
1928 wbc->nr_to_write = 0; in __nfs_commit_inode()
1952 if (wbc->sync_mode == WB_SYNC_NONE) { in nfs_write_inode()
1954 if (!atomic_long_read(&nfsi->commit_info.ncommit)) in nfs_write_inode()
1957 /* Don't commit yet if this is a non-blocking flush and there in nfs_write_inode()
1960 if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK)) in nfs_write_inode()
1971 } else if (atomic_long_read(&nfsi->commit_info.ncommit)) in nfs_write_inode()
1975 if (!atomic_read(&nfsi->commit_info.rpcs_out)) in nfs_write_inode()
1996 ret = pnfs_sync_inode(mapping->host, true); in nfs_filemap_write_and_wait_range()
2010 ret = filemap_write_and_wait(inode->i_mapping); in nfs_wb_all()
2051 * Write back all requests on one page - we do this before reading it.
2056 loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1); in nfs_wb_page()
2093 * an in-progress read or write request. Don't try to migrate it. in nfs_migrate_page()
2100 return -EBUSY; in nfs_migrate_page()
2103 return -EBUSY; in nfs_migrate_page()
2116 return -ENOMEM; in nfs_init_writepagecache()
2151 nfs_congestion_kb = (16*int_sqrt(totalram_pages())) << (PAGE_SHIFT-10); in nfs_init_writepagecache()
2163 return -ENOMEM; in nfs_init_writepagecache()