Lines Matching refs:req
56 static void nfs_redirty_request(struct nfs_page *req);
61 static void nfs_inode_remove_request(struct nfs_page *req);
63 struct nfs_page *req);
151 nfs_page_set_inode_ref(struct nfs_page *req, struct inode *inode)
153 if (!test_and_set_bit(PG_INODE_REF, &req->wb_flags)) {
154 kref_get(&req->wb_kref);
160 nfs_cancel_remove_inode(struct nfs_page *req, struct inode *inode)
164 if (!test_bit(PG_REMOVE, &req->wb_flags))
166 ret = nfs_page_group_lock(req);
169 if (test_and_clear_bit(PG_REMOVE, &req->wb_flags))
170 nfs_page_set_inode_ref(req, inode);
171 nfs_page_group_unlock(req);
191 struct nfs_page *req;
196 req = nfs_folio_private_request(folio);
197 if (req) {
198 WARN_ON_ONCE(req->wb_head != req);
199 kref_get(&req->wb_kref);
202 return req;
209 struct nfs_page *req = NULL;
214 req = nfs_page_search_commits_for_head_request_locked(nfsi,
216 if (req) {
217 WARN_ON_ONCE(req->wb_head != req);
218 kref_get(&req->wb_kref);
222 return req;
233 struct nfs_page *req;
235 req = nfs_folio_find_private_request(folio);
236 if (!req)
237 req = nfs_folio_find_swap_request(folio);
238 return req;
244 struct nfs_page *req, *head;
248 req = nfs_folio_find_head_request(folio);
249 if (!req)
250 return req;
251 head = nfs_page_group_lock_head(req);
252 if (head != req)
253 nfs_release_request(req);
338 struct nfs_page *req;
340 req = head;
342 if (page_offset >= req->wb_pgbase &&
343 page_offset < (req->wb_pgbase + req->wb_bytes))
344 return req;
346 req = req->wb_this_page;
347 } while (req != head);
359 static bool nfs_page_group_covers_page(struct nfs_page *req)
361 unsigned int len = nfs_folio_length(nfs_page_to_folio(req));
365 nfs_page_group_lock(req);
368 tmp = nfs_page_group_search_locked(req->wb_head, pos);
374 nfs_page_group_unlock(req);
381 static void nfs_mark_uptodate(struct nfs_page *req)
383 struct folio *folio = nfs_page_to_folio(req);
387 if (!nfs_page_group_covers_page(req))
430 static void nfs_page_end_writeback(struct nfs_page *req)
432 if (nfs_page_group_sync_on_bit(req, PG_WB_END)) {
433 nfs_unlock_request(req);
434 nfs_folio_end_writeback(nfs_page_to_folio(req));
436 nfs_unlock_request(req);
496 * nfs_join_page_group - destroy subrequests of the head req
552 * nfs_lock_and_join_requests - join all subreqs to the head req
595 static void nfs_write_error(struct nfs_page *req, int error)
597 trace_nfs_write_error(nfs_page_to_inode(req), req, error);
598 nfs_mapping_set_error(nfs_page_to_folio(req), error);
599 nfs_inode_remove_request(req);
600 nfs_page_end_writeback(req);
601 nfs_release_request(req);
612 struct nfs_page *req;
615 req = nfs_lock_and_join_requests(folio);
616 if (!req)
618 ret = PTR_ERR(req);
619 if (IS_ERR(req))
623 WARN_ON_ONCE(test_bit(PG_CLEAN, &req->wb_flags));
631 if (!nfs_pageio_add_request(pgio, req)) {
634 * Remove the problematic req upon fatal errors on the server
641 nfs_redirty_request(req);
649 nfs_write_error(req, ret);
757 static void nfs_inode_add_request(struct nfs_page *req)
759 struct folio *folio = nfs_page_to_folio(req);
763 WARN_ON_ONCE(req->wb_this_page != req);
766 nfs_lock_request(req);
774 set_bit(PG_MAPPED, &req->wb_flags);
776 folio->private = req;
784 WARN_ON(test_and_set_bit(PG_INODE_REF, &req->wb_flags));
785 kref_get(&req->wb_kref);
791 static void nfs_inode_remove_request(struct nfs_page *req)
793 struct nfs_inode *nfsi = NFS_I(nfs_page_to_inode(req));
795 if (nfs_page_group_sync_on_bit(req, PG_REMOVE)) {
796 struct folio *folio = nfs_page_to_folio(req->wb_head);
803 clear_bit(PG_MAPPED, &req->wb_head->wb_flags);
808 if (test_and_clear_bit(PG_INODE_REF, &req->wb_flags)) {
810 nfs_release_request(req);
814 static void nfs_mark_request_dirty(struct nfs_page *req)
816 struct folio *folio = nfs_page_to_folio(req);
855 * @req: pointer to a struct nfs_page
867 nfs_request_add_commit_list_locked(struct nfs_page *req, struct list_head *dst,
870 set_bit(PG_CLEAN, &req->wb_flags);
871 nfs_list_add_request(req, dst);
878 * @req: pointer to a struct nfs_page
889 nfs_request_add_commit_list(struct nfs_page *req, struct nfs_commit_info *cinfo)
892 nfs_request_add_commit_list_locked(req, &cinfo->mds->list, cinfo);
894 nfs_folio_mark_unstable(nfs_page_to_folio(req), cinfo);
900 * @req: pointer to a nfs_page
910 nfs_request_remove_commit_list(struct nfs_page *req,
913 if (!test_and_clear_bit(PG_CLEAN, &(req)->wb_flags))
915 nfs_list_remove_request(req);
945 nfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
948 if (pnfs_mark_request_commit(req, lseg, cinfo, ds_commit_idx))
950 nfs_request_add_commit_list(req, cinfo);
964 /* Called holding the request lock on @req */
966 struct nfs_page *req)
968 if (test_bit(PG_CLEAN, &req->wb_flags)) {
969 struct nfs_open_context *ctx = nfs_req_openctx(req);
973 if (!pnfs_clear_request_commit(req, cinfo)) {
974 nfs_request_remove_commit_list(req, cinfo);
977 nfs_folio_clear_commit(nfs_page_to_folio(req));
1002 struct nfs_page *req = nfs_list_entry(hdr->pages.next);
1004 bytes += req->wb_bytes;
1005 nfs_list_remove_request(req);
1008 trace_nfs_comp_error(hdr->inode, req, hdr->error);
1009 nfs_mapping_set_error(nfs_page_to_folio(req),
1015 req->wb_nio = 0;
1016 memcpy(&req->wb_verf, &hdr->verf.verifier, sizeof(req->wb_verf));
1017 nfs_mark_request_commit(req, hdr->lseg, &cinfo,
1022 nfs_inode_remove_request(req);
1024 nfs_page_end_writeback(req);
1025 nfs_release_request(req);
1043 struct nfs_page *req, *tmp;
1046 list_for_each_entry_safe(req, tmp, src, wb_list) {
1047 kref_get(&req->wb_kref);
1048 if (!nfs_lock_request(req)) {
1049 nfs_release_request(req);
1052 nfs_request_remove_commit_list(req, cinfo);
1053 clear_bit(PG_COMMIT_TO_DS, &req->wb_flags);
1054 nfs_list_add_request(req, dst);
1104 struct nfs_page *req;
1111 req = nfs_lock_and_join_requests(folio);
1112 if (IS_ERR_OR_NULL(req))
1113 return req;
1115 rqend = req->wb_offset + req->wb_bytes;
1122 if (offset > rqend || end < req->wb_offset)
1126 if (offset < req->wb_offset) {
1127 req->wb_offset = offset;
1128 req->wb_pgbase = offset;
1131 req->wb_bytes = end - req->wb_offset;
1133 req->wb_bytes = rqend - req->wb_offset;
1134 req->wb_nio = 0;
1135 return req;
1142 nfs_mark_request_dirty(req);
1143 nfs_unlock_and_release_request(req);
1160 struct nfs_page *req;
1162 req = nfs_try_to_update_request(folio, offset, bytes);
1163 if (req != NULL)
1165 req = nfs_page_create_from_folio(ctx, folio, offset, bytes);
1166 if (IS_ERR(req))
1168 nfs_inode_add_request(req);
1170 return req;
1177 struct nfs_page *req;
1179 req = nfs_setup_write_request(ctx, folio, offset, count);
1180 if (IS_ERR(req))
1181 return PTR_ERR(req);
1184 nfs_mark_uptodate(req);
1185 nfs_mark_request_dirty(req);
1186 nfs_unlock_and_release_request(req);
1195 struct nfs_page *req;
1206 req = nfs_folio_find_head_request(folio);
1207 if (req == NULL)
1209 l_ctx = req->wb_lock_context;
1210 do_flush = nfs_page_to_folio(req) != folio ||
1211 !nfs_match_open_context(nfs_req_openctx(req), ctx);
1217 nfs_release_request(req);
1428 static void nfs_redirty_request(struct nfs_page *req)
1430 struct nfs_inode *nfsi = NFS_I(nfs_page_to_inode(req));
1433 req->wb_nio++;
1434 nfs_mark_request_dirty(req);
1436 nfs_page_end_writeback(req);
1437 nfs_release_request(req);
1442 struct nfs_page *req;
1445 req = nfs_list_entry(head->next);
1446 nfs_list_remove_request(req);
1448 nfs_write_error(req, error);
1450 nfs_redirty_request(req);
1730 struct nfs_page *req;
1732 list_for_each_entry(req, head, wb_list)
1733 if (lwb < (req_offset(req) + req->wb_bytes))
1734 lwb = req_offset(req) + req->wb_bytes;
1788 struct nfs_page *req;
1791 req = nfs_list_entry(page_list->next);
1792 nfs_list_remove_request(req);
1793 nfs_mark_request_commit(req, lseg, cinfo, ds_commit_idx);
1794 nfs_folio_clear_commit(nfs_page_to_folio(req));
1795 nfs_unlock_and_release_request(req);
1801 struct nfs_page *req)
1803 struct folio *folio = nfs_page_to_folio(req);
1852 struct nfs_page *req;
1859 req = nfs_list_entry(data->pages.next);
1860 nfs_list_remove_request(req);
1861 folio = nfs_page_to_folio(req);
1865 nfs_req_openctx(req)->dentry->d_sb->s_id,
1866 (unsigned long long)NFS_FILEID(d_inode(nfs_req_openctx(req)->dentry)),
1867 req->wb_bytes,
1868 (long long)req_offset(req));
1871 trace_nfs_commit_error(data->inode, req,
1874 nfs_inode_remove_request(req);
1882 if (nfs_write_match_verf(verf, req)) {
1885 nfs_inode_remove_request(req);
1891 nfs_mark_request_dirty(req);
1894 nfs_unlock_and_release_request(req);
2058 struct nfs_page *req;
2065 req = nfs_lock_and_join_requests(folio);
2067 if (IS_ERR(req)) {
2068 ret = PTR_ERR(req);
2069 } else if (req) {
2074 nfs_inode_remove_request(req);
2075 nfs_unlock_and_release_request(req);