Merge tag 'seabios-20211203-pull-request' of git://git.kraxel.org/qemu into staging
[qemu.git] / hw / 9pfs / codir.c
1 /*
2 * 9p backend
3 *
4 * Copyright IBM, Corp. 2011
5 *
6 * Authors:
7 * Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
12 */
13
14 #include "qemu/osdep.h"
15 #include "fsdev/qemu-fsdev.h"
16 #include "qemu/thread.h"
17 #include "qemu/coroutine.h"
18 #include "qemu/main-loop.h"
19 #include "coth.h"
20
21 /*
22 * Intended to be called from bottom-half (e.g. background I/O thread)
23 * context.
24 */
25 static int do_readdir(V9fsPDU *pdu, V9fsFidState *fidp, struct dirent **dent)
26 {
27 int err = 0;
28 V9fsState *s = pdu->s;
29 struct dirent *entry;
30
31 errno = 0;
32 entry = s->ops->readdir(&s->ctx, &fidp->fs);
33 if (!entry && errno) {
34 *dent = NULL;
35 err = -errno;
36 } else {
37 *dent = entry;
38 }
39 return err;
40 }
41
42 /*
43 * TODO: This will be removed for performance reasons.
44 * Use v9fs_co_readdir_many() instead.
45 */
46 int coroutine_fn v9fs_co_readdir(V9fsPDU *pdu, V9fsFidState *fidp,
47 struct dirent **dent)
48 {
49 int err;
50
51 if (v9fs_request_cancelled(pdu)) {
52 return -EINTR;
53 }
54 v9fs_co_run_in_worker({
55 err = do_readdir(pdu, fidp, dent);
56 });
57 return err;
58 }
59
60 /*
61 * This is solely executed on a background IO thread.
62 *
63 * See v9fs_co_readdir_many() (as its only user) below for details.
64 */
65 static int do_readdir_many(V9fsPDU *pdu, V9fsFidState *fidp,
66 struct V9fsDirEnt **entries, off_t offset,
67 int32_t maxsize, bool dostat)
68 {
69 V9fsState *s = pdu->s;
70 V9fsString name;
71 int len, err = 0;
72 int32_t size = 0;
73 off_t saved_dir_pos;
74 struct dirent *dent;
75 struct V9fsDirEnt *e = NULL;
76 V9fsPath path;
77 struct stat stbuf;
78
79 *entries = NULL;
80 v9fs_path_init(&path);
81
82 /*
83 * TODO: Here should be a warn_report_once() if lock failed.
84 *
85 * With a good 9p client we should not get into concurrency here,
86 * because a good client would not use the same fid for concurrent
87 * requests. We do the lock here for safety reasons though. However
88 * the client would then suffer performance issues, so better log that
89 * issue here.
90 */
91 v9fs_readdir_lock(&fidp->fs.dir);
92
93 /* seek directory to requested initial position */
94 if (offset == 0) {
95 s->ops->rewinddir(&s->ctx, &fidp->fs);
96 } else {
97 s->ops->seekdir(&s->ctx, &fidp->fs, offset);
98 }
99
100 /* save the directory position */
101 saved_dir_pos = s->ops->telldir(&s->ctx, &fidp->fs);
102 if (saved_dir_pos < 0) {
103 err = saved_dir_pos;
104 goto out;
105 }
106
107 while (true) {
108 /* interrupt loop if request was cancelled by a Tflush request */
109 if (v9fs_request_cancelled(pdu)) {
110 err = -EINTR;
111 break;
112 }
113
114 /* get directory entry from fs driver */
115 err = do_readdir(pdu, fidp, &dent);
116 if (err || !dent) {
117 break;
118 }
119
120 /*
121 * stop this loop as soon as it would exceed the allowed maximum
122 * response message size for the directory entries collected so far,
123 * because anything beyond that size would need to be discarded by
124 * 9p controller (main thread / top half) anyway
125 */
126 v9fs_string_init(&name);
127 v9fs_string_sprintf(&name, "%s", dent->d_name);
128 len = v9fs_readdir_response_size(&name);
129 v9fs_string_free(&name);
130 if (size + len > maxsize) {
131 /* this is not an error case actually */
132 break;
133 }
134
135 /* append next node to result chain */
136 if (!e) {
137 *entries = e = g_malloc0(sizeof(V9fsDirEnt));
138 } else {
139 e = e->next = g_malloc0(sizeof(V9fsDirEnt));
140 }
141 e->dent = g_malloc0(sizeof(struct dirent));
142 memcpy(e->dent, dent, sizeof(struct dirent));
143
144 /* perform a full stat() for directory entry if requested by caller */
145 if (dostat) {
146 err = s->ops->name_to_path(
147 &s->ctx, &fidp->path, dent->d_name, &path
148 );
149 if (err < 0) {
150 err = -errno;
151 break;
152 }
153
154 err = s->ops->lstat(&s->ctx, &path, &stbuf);
155 if (err < 0) {
156 err = -errno;
157 break;
158 }
159
160 e->st = g_malloc0(sizeof(struct stat));
161 memcpy(e->st, &stbuf, sizeof(struct stat));
162 }
163
164 size += len;
165 saved_dir_pos = dent->d_off;
166 }
167
168 /* restore (last) saved position */
169 s->ops->seekdir(&s->ctx, &fidp->fs, saved_dir_pos);
170
171 out:
172 v9fs_readdir_unlock(&fidp->fs.dir);
173 v9fs_path_free(&path);
174 if (err < 0) {
175 return err;
176 }
177 return size;
178 }
179
180 /**
181 * @brief Reads multiple directory entries in one rush.
182 *
183 * Retrieves the requested (max. amount of) directory entries from the fs
184 * driver. This function must only be called by the main IO thread (top half).
185 * Internally this function call will be dispatched to a background IO thread
186 * (bottom half) where it is eventually executed by the fs driver.
187 *
188 * @discussion Acquiring multiple directory entries in one rush from the fs
189 * driver, instead of retrieving each directory entry individually, is very
190 * beneficial from performance point of view. Because for every fs driver
191 * request latency is added, which in practice could lead to overall
192 * latencies of several hundred ms for reading all entries (of just a single
193 * directory) if every directory entry was individually requested from fs
194 * driver.
195 *
196 * @note You must @b ALWAYS call @c v9fs_free_dirents(entries) after calling
197 * v9fs_co_readdir_many(), both on success and on error cases of this
198 * function, to avoid memory leaks once @p entries are no longer needed.
199 *
200 * @param pdu - the causing 9p (T_readdir) client request
201 * @param fidp - already opened directory where readdir shall be performed on
202 * @param entries - output for directory entries (must not be NULL)
203 * @param offset - initial position inside the directory the function shall
204 * seek to before retrieving the directory entries
205 * @param maxsize - maximum result message body size (in bytes)
206 * @param dostat - whether a stat() should be performed and returned for
207 * each directory entry
208 * @returns resulting response message body size (in bytes) on success,
209 * negative error code otherwise
210 */
211 int coroutine_fn v9fs_co_readdir_many(V9fsPDU *pdu, V9fsFidState *fidp,
212 struct V9fsDirEnt **entries,
213 off_t offset, int32_t maxsize,
214 bool dostat)
215 {
216 int err = 0;
217
218 if (v9fs_request_cancelled(pdu)) {
219 return -EINTR;
220 }
221 v9fs_co_run_in_worker({
222 err = do_readdir_many(pdu, fidp, entries, offset, maxsize, dostat);
223 });
224 return err;
225 }
226
227 off_t v9fs_co_telldir(V9fsPDU *pdu, V9fsFidState *fidp)
228 {
229 off_t err;
230 V9fsState *s = pdu->s;
231
232 if (v9fs_request_cancelled(pdu)) {
233 return -EINTR;
234 }
235 v9fs_co_run_in_worker(
236 {
237 err = s->ops->telldir(&s->ctx, &fidp->fs);
238 if (err < 0) {
239 err = -errno;
240 }
241 });
242 return err;
243 }
244
245 void coroutine_fn v9fs_co_seekdir(V9fsPDU *pdu, V9fsFidState *fidp,
246 off_t offset)
247 {
248 V9fsState *s = pdu->s;
249 if (v9fs_request_cancelled(pdu)) {
250 return;
251 }
252 v9fs_co_run_in_worker(
253 {
254 s->ops->seekdir(&s->ctx, &fidp->fs, offset);
255 });
256 }
257
258 void coroutine_fn v9fs_co_rewinddir(V9fsPDU *pdu, V9fsFidState *fidp)
259 {
260 V9fsState *s = pdu->s;
261 if (v9fs_request_cancelled(pdu)) {
262 return;
263 }
264 v9fs_co_run_in_worker(
265 {
266 s->ops->rewinddir(&s->ctx, &fidp->fs);
267 });
268 }
269
270 int coroutine_fn v9fs_co_mkdir(V9fsPDU *pdu, V9fsFidState *fidp,
271 V9fsString *name, mode_t mode, uid_t uid,
272 gid_t gid, struct stat *stbuf)
273 {
274 int err;
275 FsCred cred;
276 V9fsPath path;
277 V9fsState *s = pdu->s;
278
279 if (v9fs_request_cancelled(pdu)) {
280 return -EINTR;
281 }
282 cred_init(&cred);
283 cred.fc_mode = mode;
284 cred.fc_uid = uid;
285 cred.fc_gid = gid;
286 v9fs_path_read_lock(s);
287 v9fs_co_run_in_worker(
288 {
289 err = s->ops->mkdir(&s->ctx, &fidp->path, name->data, &cred);
290 if (err < 0) {
291 err = -errno;
292 } else {
293 v9fs_path_init(&path);
294 err = v9fs_name_to_path(s, &fidp->path, name->data, &path);
295 if (!err) {
296 err = s->ops->lstat(&s->ctx, &path, stbuf);
297 if (err < 0) {
298 err = -errno;
299 }
300 }
301 v9fs_path_free(&path);
302 }
303 });
304 v9fs_path_unlock(s);
305 return err;
306 }
307
308 int coroutine_fn v9fs_co_opendir(V9fsPDU *pdu, V9fsFidState *fidp)
309 {
310 int err;
311 V9fsState *s = pdu->s;
312
313 if (v9fs_request_cancelled(pdu)) {
314 return -EINTR;
315 }
316 v9fs_path_read_lock(s);
317 v9fs_co_run_in_worker(
318 {
319 err = s->ops->opendir(&s->ctx, &fidp->path, &fidp->fs);
320 if (err < 0) {
321 err = -errno;
322 } else {
323 err = 0;
324 }
325 });
326 v9fs_path_unlock(s);
327 if (!err) {
328 total_open_fd++;
329 if (total_open_fd > open_fd_hw) {
330 v9fs_reclaim_fd(pdu);
331 }
332 }
333 return err;
334 }
335
336 int coroutine_fn v9fs_co_closedir(V9fsPDU *pdu, V9fsFidOpenState *fs)
337 {
338 int err;
339 V9fsState *s = pdu->s;
340
341 if (v9fs_request_cancelled(pdu)) {
342 return -EINTR;
343 }
344 v9fs_co_run_in_worker(
345 {
346 err = s->ops->closedir(&s->ctx, fs);
347 if (err < 0) {
348 err = -errno;
349 }
350 });
351 if (!err) {
352 total_open_fd--;
353 }
354 return err;
355 }