fs/nfs/write.c

65 				      struct inode *inode);
151 nfs_page_set_inode_ref(struct nfs_page *req, struct inode *inode)
155 		atomic_long_inc(&NFS_I(inode)->nrequests);
160 nfs_cancel_remove_inode(struct nfs_page *req, struct inode *inode)
170 		nfs_page_set_inode_ref(req, inode);
184  * must be called while holding the inode lock.
207 	struct inode *inode = folio_file_mapping(folio)->host;
208 	struct nfs_inode *nfsi = NFS_I(inode);
243 	struct inode *inode = folio_file_mapping(folio)->host;
256 		ret = nfs_cancel_remove_inode(head, inode);
275 	struct inode *inode = folio_file_mapping(folio)->host;
279 	spin_lock(&inode->i_lock);
280 	i_size = i_size_read(inode);
287 	trace_nfs_size_grow(inode, end);
288 	i_size_write(inode, end);
289 	NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE;
290 	nfs_inc_stats(inode, NFSIOS_EXTENDWRITE);
292 	spin_unlock(&inode->i_lock);
293 	nfs_fscache_invalidate(inode, 0);
299 	struct inode *inode = mapping->host;
303 	spin_lock(&inode->i_lock);
304 	nfs_set_cache_invalid(inode, NFS_INO_REVAL_FORCED |
307 	spin_unlock(&inode->i_lock);
452 				 struct inode *inode)
486 			atomic_long_dec(&NFS_I(inode)->nrequests);
498  * @inode: Inode to which the request belongs.
507 			 struct inode *inode)
548 	nfs_destroy_unlinked_subrequests(destroy_list, head, inode);
568 	struct inode *inode = folio_file_mapping(folio)->host;
573 	nfs_init_cinfo_from_inode(&cinfo, inode);
590 	nfs_join_page_group(head, &cinfo, inode);
667 	struct inode *inode = folio_file_mapping(folio)->host;
670 	nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
671 	nfs_pageio_init_write(&pgio, inode, 0, false,
690 static void nfs_io_completion_commit(void *inode)
692 	nfs_commit_inode(inode, 0);
697 	struct inode *inode = mapping->host;
700 	unsigned int mntflags = NFS_SERVER(inode)->flags;
705 	    NFS_SERVER(inode)->write_congested)
708 	nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
715 					       inode);
720 		nfs_pageio_init_write(&pgio, inode, priority, false,
740  * Insert a write request into an inode
774  * Remove a write request from an inode
809  * Search through commit lists on @inode for the head request for @folio.
810  * Must be called while holding the inode (which is cinfo) lock.
820 	struct inode *inode = &nfsi->vfs_inode;
822 	nfs_init_cinfo_from_inode(&cinfo, inode);
825 	freq = pnfs_search_commit_reqs(inode, &cinfo, folio);
848  * The caller must hold NFS_I(cinfo->inode)->commit_mutex, and the
876 	mutex_lock(&NFS_I(cinfo->inode)->commit_mutex);
878 	mutex_unlock(&NFS_I(cinfo->inode)->commit_mutex);
906 				      struct inode *inode)
908 	cinfo->inode = inode;
909 	cinfo->mds = &NFS_I(inode)->commit_info;
910 	cinfo->ds = pnfs_get_ds_info(inode);
916 		    struct inode *inode,
922 		nfs_init_cinfo_from_inode(cinfo, inode);
927  * Add a request to the inode's commit list.
955 		struct inode *inode = d_inode(ctx->dentry);
957 		mutex_lock(&NFS_I(inode)->commit_mutex);
961 		mutex_unlock(&NFS_I(inode)->commit_mutex);
985 	nfs_init_cinfo_from_inode(&cinfo, hdr->inode);
993 			trace_nfs_comp_error(hdr->inode, req, hdr->error);
1023 /* NFS_I(cinfo->inode)->commit_mutex held by caller */
1050  * nfs_scan_commit - Scan an inode for commit requests
1051  * @inode: NFS inode to scan
1055  * Moves requests from the inode's 'commit' request list.
1059 nfs_scan_commit(struct inode *inode, struct list_head *dst,
1066 	mutex_lock(&NFS_I(cinfo->inode)->commit_mutex);
1072 		ret += pnfs_scan_commit_lists(inode, cinfo, max - ret);
1074 	mutex_unlock(&NFS_I(cinfo->inode)->commit_mutex);
1216  * Return 0 and set a credential flag which triggers the inode to flush
1221 nfs_key_timeout_notify(struct file *filp, struct inode *inode)
1225 	if (nfs_ctx_key_to_expire(ctx, inode) &&
1235 bool nfs_ctx_key_to_expire(struct nfs_open_context *ctx, struct inode *inode)
1237 	struct rpc_auth *auth = NFS_SERVER(inode)->client->cl_auth;
1279 	struct inode *inode = folio_file_mapping(folio)->host;
1280 	struct nfs_inode *nfsi = NFS_I(inode);
1282 	if (nfs_have_delegated_attributes(inode))
1314 	struct inode *inode = file_inode(file);
1315 	struct file_lock_context *flctx = locks_inode_context(inode);
1323 	if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE))
1358 	struct inode *inode = mapping->host;
1362 	nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
1380 			status, (long long)i_size_read(inode));
1402 	if (IS_SWAPFILE(hdr->inode))
1452 			       struct inode *inode, int ioflags, bool force_mds,
1455 	struct nfs_server *server = NFS_SERVER(inode);
1462 	nfs_pageio_init(pgio, inode, pg_ops, compl_ops, &nfs_rw_write_ops,
1488 	NFS_PROTO(data->inode)->commit_rpc_prepare(task, data);
1500 	if (nfs_size_to_loff_t(fattr->size) < i_size_read(hdr->inode)) {
1515 	struct inode *inode = hdr->inode;
1517 	spin_lock(&inode->i_lock);
1519 	nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
1520 	spin_unlock(&inode->i_lock);
1529 			      struct inode *inode)
1540 	status = NFS_PROTO(inode)->write_done(task, hdr);
1544 	nfs_add_stats(inode, NFSIOS_SERVERWRITTENBYTES, hdr->res.count);
1574 					NFS_SERVER(inode)->nfs_client->cl_hostname,
1582 	if (nfs_should_remove_suid(inode)) {
1583 		spin_lock(&inode->i_lock);
1584 		nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE);
1585 		spin_unlock(&inode->i_lock);
1603 		nfs_inc_stats(hdr->inode, NFSIOS_SHORTWRITE);
1693 	if (nfs_server_capable(data->inode, NFS_CAP_MOVEABLE))
1734 	struct inode *inode;
1744 	inode = d_inode(ctx->dentry);
1746 	data->inode	  = inode;
1756 	data->args.fh     = NFS_FH(data->inode);
1757 	/* Note: we always request a commit of the entire inode */
1797 nfs_commit_list(struct inode *inode, struct list_head *head, int how,
1815 	if (NFS_SERVER(inode)->nfs_client->cl_minorversion)
1817 	return nfs_initiate_commit(NFS_CLIENT(inode), data, NFS_PROTO(inode),
1830 	NFS_PROTO(data->inode)->commit_done(task, data);
1856 				trace_nfs_commit_error(data->inode, req,
1877 		atomic_long_inc(&NFS_I(data->inode)->redirtied_pages);
1883 	nfss = NFS_SERVER(data->inode);
1887 	nfs_init_cinfo(&cinfo, data->inode, data->dreq);
1910 int nfs_generic_commit_list(struct inode *inode, struct list_head *head,
1915 	status = pnfs_commit_list(inode, head, how, cinfo);
1917 		status = nfs_commit_list(inode, head, how, cinfo);
1921 static int __nfs_commit_inode(struct inode *inode, int how,
1930 	nfs_init_cinfo_from_inode(&cinfo, inode);
1933 		ret = nscan = nfs_scan_commit(inode, &head, &cinfo);
1936 		ret = nfs_generic_commit_list(inode, &head, how, &cinfo);
1956 int nfs_commit_inode(struct inode *inode, int how)
1958 	return __nfs_commit_inode(inode, how, NULL);
1962 int nfs_write_inode(struct inode *inode, struct writeback_control *wbc)
1964 	struct nfs_inode *nfsi = NFS_I(inode);
1976 		if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK))
1983 	ret = __nfs_commit_inode(inode, flags, wbc);
1994 	__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
2018  * flush the inode to disk.
2020 int nfs_wb_all(struct inode *inode)
2024 	trace_nfs_writeback_inode_enter(inode);
2026 	ret = filemap_write_and_wait(inode->i_mapping);
2029 	ret = nfs_commit_inode(inode, FLUSH_SYNC);
2032 	pnfs_sync_inode(inode, true);
2036 	trace_nfs_writeback_inode_exit(inode, ret);
2041 int nfs_wb_folio_cancel(struct inode *inode, struct folio *folio)
2057 		 * request from the inode / page_private pointer and
2068  * @inode: pointer to page
2074 int nfs_wb_folio(struct inode *inode, struct folio *folio)
2086 	trace_nfs_writeback_folio(inode, folio);
2099 		ret = nfs_commit_inode(inode, FLUSH_SYNC);
2104 	trace_nfs_writeback_folio_done(inode, folio, ret);
2117 	 *        that we can safely release the inode reference while holding