1// SPDX-License-Identifier: GPL-2.0-only
  2/* Object lifetime handling and tracing.
  3 *
  4 * Copyright (C) 2022 Red Hat, Inc. All Rights Reserved.
  5 * Written by David Howells (dhowells@redhat.com)
  6 */
  7
  8#include <linux/slab.h>
  9#include "internal.h"
 10
 11/*
 12 * Allocate an I/O request and initialise it.
 13 */
 14struct netfs_io_request *netfs_alloc_request(struct address_space *mapping,
 15					     struct file *file,
 16					     loff_t start, size_t len,
 17					     enum netfs_io_origin origin)
 18{
 19	static atomic_t debug_ids;
 20	struct inode *inode = file ? file_inode(file) : mapping->host;
 21	struct netfs_inode *ctx = netfs_inode(inode);
 22	struct netfs_io_request *rreq;
 23	bool is_unbuffered = (origin == NETFS_UNBUFFERED_WRITE ||
 24			      origin == NETFS_DIO_READ ||
 25			      origin == NETFS_DIO_WRITE);
 26	bool cached = !is_unbuffered && netfs_is_cache_enabled(ctx);
 27	int ret;
 28
 29	rreq = kzalloc(ctx->ops->io_request_size ?: sizeof(struct netfs_io_request),
 30		       GFP_KERNEL);
 31	if (!rreq)
 32		return ERR_PTR(-ENOMEM);
 33
 34	rreq->start	= start;
 35	rreq->len	= len;
 36	rreq->upper_len	= len;
 37	rreq->origin	= origin;
 38	rreq->netfs_ops	= ctx->ops;
 39	rreq->mapping	= mapping;
 40	rreq->inode	= inode;
 41	rreq->i_size	= i_size_read(inode);
 42	rreq->debug_id	= atomic_inc_return(&debug_ids);
 43	INIT_LIST_HEAD(&rreq->subrequests);
 44	INIT_WORK(&rreq->work, NULL);
 45	refcount_set(&rreq->ref, 1);
 46
 47	__set_bit(NETFS_RREQ_IN_PROGRESS, &rreq->flags);
 48	if (cached)
 49		__set_bit(NETFS_RREQ_WRITE_TO_CACHE, &rreq->flags);
 50	if (file && file->f_flags & O_NONBLOCK)
 51		__set_bit(NETFS_RREQ_NONBLOCK, &rreq->flags);
 52	if (rreq->netfs_ops->init_request) {
 53		ret = rreq->netfs_ops->init_request(rreq, file);
 54		if (ret < 0) {
 55			kfree(rreq);
 56			return ERR_PTR(ret);
 57		}
 58	}
 59
 60	trace_netfs_rreq_ref(rreq->debug_id, 1, netfs_rreq_trace_new);
 61	netfs_proc_add_rreq(rreq);
 62	netfs_stat(&netfs_n_rh_rreq);
 63	return rreq;
 64}
 65
 66void netfs_get_request(struct netfs_io_request *rreq, enum netfs_rreq_ref_trace what)
 67{
 68	int r;
 69
 70	__refcount_inc(&rreq->ref, &r);
 71	trace_netfs_rreq_ref(rreq->debug_id, r + 1, what);
 72}
 73
 74void netfs_clear_subrequests(struct netfs_io_request *rreq, bool was_async)
 75{
 76	struct netfs_io_subrequest *subreq;
 77
 78	while (!list_empty(&rreq->subrequests)) {
 79		subreq = list_first_entry(&rreq->subrequests,
 80					  struct netfs_io_subrequest, rreq_link);
 81		list_del(&subreq->rreq_link);
 82		netfs_put_subrequest(subreq, was_async,
 83				     netfs_sreq_trace_put_clear);
 84	}
 85}
 86
 87static void netfs_free_request(struct work_struct *work)
 88{
 89	struct netfs_io_request *rreq =
 90		container_of(work, struct netfs_io_request, work);
 91	unsigned int i;
 92
 93	trace_netfs_rreq(rreq, netfs_rreq_trace_free);
 94	netfs_proc_del_rreq(rreq);
 95	netfs_clear_subrequests(rreq, false);
 96	if (rreq->netfs_ops->free_request)
 97		rreq->netfs_ops->free_request(rreq);
 98	if (rreq->cache_resources.ops)
 99		rreq->cache_resources.ops->end_operation(&rreq->cache_resources);
100	if (rreq->direct_bv) {
101		for (i = 0; i < rreq->direct_bv_count; i++) {
102			if (rreq->direct_bv[i].bv_page) {
103				if (rreq->direct_bv_unpin)
104					unpin_user_page(rreq->direct_bv[i].bv_page);
105			}
106		}
107		kvfree(rreq->direct_bv);
108	}
109	kfree_rcu(rreq, rcu);
110	netfs_stat_d(&netfs_n_rh_rreq);
111}
112
113void netfs_put_request(struct netfs_io_request *rreq, bool was_async,
114		       enum netfs_rreq_ref_trace what)
115{
116	unsigned int debug_id;
117	bool dead;
118	int r;
119
120	if (rreq) {
121		debug_id = rreq->debug_id;
122		dead = __refcount_dec_and_test(&rreq->ref, &r);
123		trace_netfs_rreq_ref(debug_id, r - 1, what);
124		if (dead) {
125			if (was_async) {
126				rreq->work.func = netfs_free_request;
127				if (!queue_work(system_unbound_wq, &rreq->work))
128					BUG();
129			} else {
130				netfs_free_request(&rreq->work);
131			}
132		}
133	}
134}
135
136/*
137 * Allocate and partially initialise an I/O request structure.
138 */
139struct netfs_io_subrequest *netfs_alloc_subrequest(struct netfs_io_request *rreq)
140{
141	struct netfs_io_subrequest *subreq;
142
143	subreq = kzalloc(rreq->netfs_ops->io_subrequest_size ?:
144			 sizeof(struct netfs_io_subrequest),
145			 GFP_KERNEL);
146	if (subreq) {
147		INIT_WORK(&subreq->work, NULL);
148		INIT_LIST_HEAD(&subreq->rreq_link);
149		refcount_set(&subreq->ref, 2);
150		subreq->rreq = rreq;
151		netfs_get_request(rreq, netfs_rreq_trace_get_subreq);
152		netfs_stat(&netfs_n_rh_sreq);
153	}
154
155	return subreq;
156}
157
158void netfs_get_subrequest(struct netfs_io_subrequest *subreq,
159			  enum netfs_sreq_ref_trace what)
160{
161	int r;
162
163	__refcount_inc(&subreq->ref, &r);
164	trace_netfs_sreq_ref(subreq->rreq->debug_id, subreq->debug_index, r + 1,
165			     what);
166}
167
168static void netfs_free_subrequest(struct netfs_io_subrequest *subreq,
169				  bool was_async)
170{
171	struct netfs_io_request *rreq = subreq->rreq;
172
173	trace_netfs_sreq(subreq, netfs_sreq_trace_free);
174	if (rreq->netfs_ops->free_subrequest)
175		rreq->netfs_ops->free_subrequest(subreq);
176	kfree(subreq);
177	netfs_stat_d(&netfs_n_rh_sreq);
178	netfs_put_request(rreq, was_async, netfs_rreq_trace_put_subreq);
179}
180
181void netfs_put_subrequest(struct netfs_io_subrequest *subreq, bool was_async,
182			  enum netfs_sreq_ref_trace what)
183{
184	unsigned int debug_index = subreq->debug_index;
185	unsigned int debug_id = subreq->rreq->debug_id;
186	bool dead;
187	int r;
188
189	dead = __refcount_dec_and_test(&subreq->ref, &r);
190	trace_netfs_sreq_ref(debug_id, debug_index, r - 1, what);
191	if (dead)
192		netfs_free_subrequest(subreq, was_async);
193}