blob: 2068a4779d47481f1ab7fe820e5d30f285280e79 [file] [log] [blame]
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -07001/*
Greg Kurzaf8b38b2016-06-06 11:52:34 +02002 * 9p backend
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -07003 *
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
Christian Schoenebeck6f569082021-05-06 15:12:23 +020014/*
15 * Not so fast! You might want to read the 9p developer docs first:
16 * https://wiki.qemu.org/Documentation/9p
17 */
18
Peter Maydellfbc04122016-01-26 18:17:10 +000019#include "qemu/osdep.h"
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -070020#include "fsdev/qemu-fsdev.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010021#include "qemu/thread.h"
Markus Armbrusterdb725812019-08-12 07:23:50 +020022#include "qemu/main-loop.h"
Wei Liufe528402015-11-18 17:57:30 +000023#include "coth.h"
Keno Fischer6b3b2792022-02-27 17:35:15 -050024#include "9p-xattr.h"
25#include "9p-util.h"
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -070026
Christian Schoenebeckdd8151f2020-07-29 10:11:54 +020027/*
28 * Intended to be called from bottom-half (e.g. background I/O thread)
29 * context.
30 */
31static int do_readdir(V9fsPDU *pdu, V9fsFidState *fidp, struct dirent **dent)
32{
33 int err = 0;
34 V9fsState *s = pdu->s;
35 struct dirent *entry;
36
37 errno = 0;
38 entry = s->ops->readdir(&s->ctx, &fidp->fs);
39 if (!entry && errno) {
40 *dent = NULL;
41 err = -errno;
42 } else {
43 *dent = entry;
44 }
45 return err;
46}
47
Christian Schoenebeck21496752020-07-29 10:12:33 +020048/*
49 * TODO: This will be removed for performance reasons.
50 * Use v9fs_co_readdir_many() instead.
51 */
Greg Kurz5bdade62016-10-17 14:13:58 +020052int coroutine_fn v9fs_co_readdir(V9fsPDU *pdu, V9fsFidState *fidp,
53 struct dirent **dent)
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -070054{
55 int err;
56
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +053057 if (v9fs_request_cancelled(pdu)) {
58 return -EINTR;
59 }
Christian Schoenebeckdd8151f2020-07-29 10:11:54 +020060 v9fs_co_run_in_worker({
61 err = do_readdir(pdu, fidp, dent);
62 });
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -070063 return err;
64}
65
Christian Schoenebeck21496752020-07-29 10:12:33 +020066/*
67 * This is solely executed on a background IO thread.
68 *
69 * See v9fs_co_readdir_many() (as its only user) below for details.
70 */
Paolo Bonzinic3b21fb2023-03-09 09:44:52 +010071static int coroutine_fn
72do_readdir_many(V9fsPDU *pdu, V9fsFidState *fidp, struct V9fsDirEnt **entries,
73 off_t offset, int32_t maxsize, bool dostat)
Christian Schoenebeck21496752020-07-29 10:12:33 +020074{
75 V9fsState *s = pdu->s;
76 V9fsString name;
77 int len, err = 0;
78 int32_t size = 0;
79 off_t saved_dir_pos;
80 struct dirent *dent;
81 struct V9fsDirEnt *e = NULL;
82 V9fsPath path;
83 struct stat stbuf;
84
85 *entries = NULL;
86 v9fs_path_init(&path);
87
88 /*
89 * TODO: Here should be a warn_report_once() if lock failed.
90 *
91 * With a good 9p client we should not get into concurrency here,
92 * because a good client would not use the same fid for concurrent
93 * requests. We do the lock here for safety reasons though. However
94 * the client would then suffer performance issues, so better log that
95 * issue here.
96 */
97 v9fs_readdir_lock(&fidp->fs.dir);
98
99 /* seek directory to requested initial position */
100 if (offset == 0) {
101 s->ops->rewinddir(&s->ctx, &fidp->fs);
102 } else {
103 s->ops->seekdir(&s->ctx, &fidp->fs, offset);
104 }
105
106 /* save the directory position */
107 saved_dir_pos = s->ops->telldir(&s->ctx, &fidp->fs);
108 if (saved_dir_pos < 0) {
109 err = saved_dir_pos;
110 goto out;
111 }
112
113 while (true) {
114 /* interrupt loop if request was cancelled by a Tflush request */
115 if (v9fs_request_cancelled(pdu)) {
116 err = -EINTR;
117 break;
118 }
119
120 /* get directory entry from fs driver */
121 err = do_readdir(pdu, fidp, &dent);
122 if (err || !dent) {
123 break;
124 }
125
126 /*
127 * stop this loop as soon as it would exceed the allowed maximum
128 * response message size for the directory entries collected so far,
129 * because anything beyond that size would need to be discarded by
130 * 9p controller (main thread / top half) anyway
131 */
132 v9fs_string_init(&name);
133 v9fs_string_sprintf(&name, "%s", dent->d_name);
134 len = v9fs_readdir_response_size(&name);
135 v9fs_string_free(&name);
136 if (size + len > maxsize) {
137 /* this is not an error case actually */
138 break;
139 }
140
141 /* append next node to result chain */
142 if (!e) {
Markus Armbruster13662442022-03-15 15:41:55 +0100143 *entries = e = g_new0(V9fsDirEnt, 1);
Christian Schoenebeck21496752020-07-29 10:12:33 +0200144 } else {
Markus Armbruster13662442022-03-15 15:41:55 +0100145 e = e->next = g_new0(V9fsDirEnt, 1);
Christian Schoenebeck21496752020-07-29 10:12:33 +0200146 }
Vitaly Chikunove64e27d2022-02-16 21:18:21 +0300147 e->dent = qemu_dirent_dup(dent);
Christian Schoenebeck21496752020-07-29 10:12:33 +0200148
149 /* perform a full stat() for directory entry if requested by caller */
150 if (dostat) {
151 err = s->ops->name_to_path(
152 &s->ctx, &fidp->path, dent->d_name, &path
153 );
154 if (err < 0) {
155 err = -errno;
156 break;
157 }
158
159 err = s->ops->lstat(&s->ctx, &path, &stbuf);
160 if (err < 0) {
161 err = -errno;
162 break;
163 }
164
Markus Armbruster13662442022-03-15 15:41:55 +0100165 e->st = g_new0(struct stat, 1);
Christian Schoenebeck21496752020-07-29 10:12:33 +0200166 memcpy(e->st, &stbuf, sizeof(struct stat));
167 }
168
169 size += len;
Keno Fischer6b3b2792022-02-27 17:35:15 -0500170 saved_dir_pos = qemu_dirent_off(dent);
Christian Schoenebeck21496752020-07-29 10:12:33 +0200171 }
172
173 /* restore (last) saved position */
174 s->ops->seekdir(&s->ctx, &fidp->fs, saved_dir_pos);
175
176out:
177 v9fs_readdir_unlock(&fidp->fs.dir);
178 v9fs_path_free(&path);
179 if (err < 0) {
180 return err;
181 }
182 return size;
183}
184
185/**
Christian Schoenebeck1a7f2402022-03-03 13:52:14 +0100186 * v9fs_co_readdir_many() - Reads multiple directory entries in one rush.
187 *
188 * @pdu: the causing 9p (T_readdir) client request
189 * @fidp: already opened directory where readdir shall be performed on
190 * @entries: output for directory entries (must not be NULL)
191 * @offset: initial position inside the directory the function shall
192 * seek to before retrieving the directory entries
193 * @maxsize: maximum result message body size (in bytes)
194 * @dostat: whether a stat() should be performed and returned for
195 * each directory entry
196 * Return: resulting response message body size (in bytes) on success,
197 * negative error code otherwise
Christian Schoenebeck21496752020-07-29 10:12:33 +0200198 *
199 * Retrieves the requested (max. amount of) directory entries from the fs
200 * driver. This function must only be called by the main IO thread (top half).
201 * Internally this function call will be dispatched to a background IO thread
202 * (bottom half) where it is eventually executed by the fs driver.
203 *
Christian Schoenebeck1a7f2402022-03-03 13:52:14 +0100204 * Acquiring multiple directory entries in one rush from the fs
Christian Schoenebeck21496752020-07-29 10:12:33 +0200205 * driver, instead of retrieving each directory entry individually, is very
206 * beneficial from performance point of view. Because for every fs driver
207 * request latency is added, which in practice could lead to overall
208 * latencies of several hundred ms for reading all entries (of just a single
209 * directory) if every directory entry was individually requested from fs
210 * driver.
211 *
Christian Schoenebeck1a7f2402022-03-03 13:52:14 +0100212 * NOTE: You must ALWAYS call v9fs_free_dirents(entries) after calling
Christian Schoenebeck21496752020-07-29 10:12:33 +0200213 * v9fs_co_readdir_many(), both on success and on error cases of this
Christian Schoenebeck1a7f2402022-03-03 13:52:14 +0100214 * function, to avoid memory leaks once @entries are no longer needed.
Christian Schoenebeck21496752020-07-29 10:12:33 +0200215 */
216int coroutine_fn v9fs_co_readdir_many(V9fsPDU *pdu, V9fsFidState *fidp,
217 struct V9fsDirEnt **entries,
218 off_t offset, int32_t maxsize,
219 bool dostat)
220{
221 int err = 0;
222
223 if (v9fs_request_cancelled(pdu)) {
224 return -EINTR;
225 }
226 v9fs_co_run_in_worker({
227 err = do_readdir_many(pdu, fidp, entries, offset, maxsize, dostat);
228 });
229 return err;
230}
231
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530232off_t v9fs_co_telldir(V9fsPDU *pdu, V9fsFidState *fidp)
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -0700233{
234 off_t err;
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530235 V9fsState *s = pdu->s;
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -0700236
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530237 if (v9fs_request_cancelled(pdu)) {
238 return -EINTR;
239 }
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -0700240 v9fs_co_run_in_worker(
241 {
Aneesh Kumar K.Vcc720dd2011-10-25 12:10:40 +0530242 err = s->ops->telldir(&s->ctx, &fidp->fs);
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -0700243 if (err < 0) {
244 err = -errno;
245 }
246 });
247 return err;
248}
249
Greg Kurz5bdade62016-10-17 14:13:58 +0200250void coroutine_fn v9fs_co_seekdir(V9fsPDU *pdu, V9fsFidState *fidp,
251 off_t offset)
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -0700252{
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530253 V9fsState *s = pdu->s;
254 if (v9fs_request_cancelled(pdu)) {
255 return;
256 }
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -0700257 v9fs_co_run_in_worker(
258 {
Aneesh Kumar K.Vcc720dd2011-10-25 12:10:40 +0530259 s->ops->seekdir(&s->ctx, &fidp->fs, offset);
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -0700260 });
261}
262
Greg Kurz5bdade62016-10-17 14:13:58 +0200263void coroutine_fn v9fs_co_rewinddir(V9fsPDU *pdu, V9fsFidState *fidp)
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -0700264{
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530265 V9fsState *s = pdu->s;
266 if (v9fs_request_cancelled(pdu)) {
267 return;
268 }
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -0700269 v9fs_co_run_in_worker(
270 {
Aneesh Kumar K.Vcc720dd2011-10-25 12:10:40 +0530271 s->ops->rewinddir(&s->ctx, &fidp->fs);
Aneesh Kumar K.Vdcb9dbe2011-05-18 15:42:42 -0700272 });
273}
Venkateswararao Jujjurid0884642011-08-08 23:44:24 +0530274
Greg Kurz5bdade62016-10-17 14:13:58 +0200275int coroutine_fn v9fs_co_mkdir(V9fsPDU *pdu, V9fsFidState *fidp,
276 V9fsString *name, mode_t mode, uid_t uid,
277 gid_t gid, struct stat *stbuf)
Venkateswararao Jujjurid0884642011-08-08 23:44:24 +0530278{
279 int err;
280 FsCred cred;
Aneesh Kumar K.V2289be12011-09-09 15:14:18 +0530281 V9fsPath path;
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530282 V9fsState *s = pdu->s;
Venkateswararao Jujjurid0884642011-08-08 23:44:24 +0530283
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530284 if (v9fs_request_cancelled(pdu)) {
Dong Xu Wang3a931132011-11-29 16:52:38 +0800285 return -EINTR;
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530286 }
Venkateswararao Jujjurid0884642011-08-08 23:44:24 +0530287 cred_init(&cred);
288 cred.fc_mode = mode;
289 cred.fc_uid = uid;
290 cred.fc_gid = gid;
Aneesh Kumar K.V532decb2011-08-02 11:35:54 +0530291 v9fs_path_read_lock(s);
Venkateswararao Jujjurid0884642011-08-08 23:44:24 +0530292 v9fs_co_run_in_worker(
293 {
Aneesh Kumar K.V2289be12011-09-09 15:14:18 +0530294 err = s->ops->mkdir(&s->ctx, &fidp->path, name->data, &cred);
Venkateswararao Jujjurid0884642011-08-08 23:44:24 +0530295 if (err < 0) {
296 err = -errno;
Aneesh Kumar K.V02cb7f32011-05-24 15:10:56 +0530297 } else {
Aneesh Kumar K.V2289be12011-09-09 15:14:18 +0530298 v9fs_path_init(&path);
299 err = v9fs_name_to_path(s, &fidp->path, name->data, &path);
300 if (!err) {
301 err = s->ops->lstat(&s->ctx, &path, stbuf);
302 if (err < 0) {
303 err = -errno;
304 }
Aneesh Kumar K.V02cb7f32011-05-24 15:10:56 +0530305 }
Aneesh Kumar K.V2289be12011-09-09 15:14:18 +0530306 v9fs_path_free(&path);
Venkateswararao Jujjurid0884642011-08-08 23:44:24 +0530307 }
308 });
Aneesh Kumar K.V532decb2011-08-02 11:35:54 +0530309 v9fs_path_unlock(s);
Venkateswararao Jujjurid0884642011-08-08 23:44:24 +0530310 return err;
311}
Aneesh Kumar K.Vf6b7f0a2011-05-07 18:12:42 +0530312
Greg Kurz5bdade62016-10-17 14:13:58 +0200313int coroutine_fn v9fs_co_opendir(V9fsPDU *pdu, V9fsFidState *fidp)
Aneesh Kumar K.Vf6b7f0a2011-05-07 18:12:42 +0530314{
315 int err;
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530316 V9fsState *s = pdu->s;
Aneesh Kumar K.Vf6b7f0a2011-05-07 18:12:42 +0530317
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530318 if (v9fs_request_cancelled(pdu)) {
Dong Xu Wang3a931132011-11-29 16:52:38 +0800319 return -EINTR;
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530320 }
Aneesh Kumar K.V532decb2011-08-02 11:35:54 +0530321 v9fs_path_read_lock(s);
Aneesh Kumar K.Vf6b7f0a2011-05-07 18:12:42 +0530322 v9fs_co_run_in_worker(
323 {
Aneesh Kumar K.Vcc720dd2011-10-25 12:10:40 +0530324 err = s->ops->opendir(&s->ctx, &fidp->path, &fidp->fs);
325 if (err < 0) {
Aneesh Kumar K.Vf6b7f0a2011-05-07 18:12:42 +0530326 err = -errno;
327 } else {
328 err = 0;
329 }
330 });
Aneesh Kumar K.V532decb2011-08-02 11:35:54 +0530331 v9fs_path_unlock(s);
Aneesh Kumar K.V95f65512011-05-18 17:08:34 +0530332 if (!err) {
333 total_open_fd++;
334 if (total_open_fd > open_fd_hw) {
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530335 v9fs_reclaim_fd(pdu);
Aneesh Kumar K.V95f65512011-05-18 17:08:34 +0530336 }
337 }
Aneesh Kumar K.Vf6b7f0a2011-05-07 18:12:42 +0530338 return err;
339}
Aneesh Kumar K.Vbed43522011-05-07 21:09:24 +0530340
Greg Kurz5bdade62016-10-17 14:13:58 +0200341int coroutine_fn v9fs_co_closedir(V9fsPDU *pdu, V9fsFidOpenState *fs)
Aneesh Kumar K.Vbed43522011-05-07 21:09:24 +0530342{
343 int err;
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530344 V9fsState *s = pdu->s;
Aneesh Kumar K.Vbed43522011-05-07 21:09:24 +0530345
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530346 if (v9fs_request_cancelled(pdu)) {
Dong Xu Wang3a931132011-11-29 16:52:38 +0800347 return -EINTR;
Aneesh Kumar K.Vbccacf62011-08-02 11:36:17 +0530348 }
Aneesh Kumar K.Vbed43522011-05-07 21:09:24 +0530349 v9fs_co_run_in_worker(
350 {
Aneesh Kumar K.Vcc720dd2011-10-25 12:10:40 +0530351 err = s->ops->closedir(&s->ctx, fs);
Aneesh Kumar K.Vbed43522011-05-07 21:09:24 +0530352 if (err < 0) {
353 err = -errno;
354 }
355 });
Aneesh Kumar K.V95f65512011-05-18 17:08:34 +0530356 if (!err) {
357 total_open_fd--;
358 }
Aneesh Kumar K.Vbed43522011-05-07 21:09:24 +0530359 return err;
360}