blob: 16e10680518c4cba784296ff96ddcc2643cabf82 [file] [log] [blame]
Eric Van Hensbergenace51c42008-10-13 20:40:27 -05001/*
2 * net/9p/protocol.c
3 *
4 * 9P Protocol Support Code
5 *
6 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
7 *
8 * Base on code from Anthony Liguori <aliguori@us.ibm.com>
9 * Copyright (C) 2008 by IBM, Corp.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2
13 * as published by the Free Software Foundation.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to:
22 * Free Software Foundation
23 * 51 Franklin Street, Fifth Floor
24 * Boston, MA 02111-1301 USA
25 *
26 */
27
28#include <linux/module.h>
29#include <linux/errno.h>
Thiago Farina01b0c5c2010-12-04 15:22:46 +000030#include <linux/kernel.h>
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -050031#include <linux/uaccess.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090032#include <linux/slab.h>
Eric Van Hensbergene7f4b8f2008-10-17 16:20:07 -050033#include <linux/sched.h>
Thiago Farina01b0c5c2010-12-04 15:22:46 +000034#include <linux/stddef.h>
Eric Van Hensbergenbeeebc92009-02-06 22:07:41 -080035#include <linux/types.h>
Al Viro4f3b35c2015-04-01 19:57:53 -040036#include <linux/uio.h>
Eric Van Hensbergenace51c42008-10-13 20:40:27 -050037#include <net/9p/9p.h>
38#include <net/9p/client.h>
39#include "protocol.h"
40
Aneesh Kumar K.V348b5902011-08-07 00:46:59 +053041#include <trace/events/9p.h>
42
Eric Van Hensbergenace51c42008-10-13 20:40:27 -050043static int
Sripathi Kodi342fee12010-03-05 18:50:14 +000044p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -050045
46void p9stat_free(struct p9_wstat *stbuf)
47{
48 kfree(stbuf->name);
49 kfree(stbuf->uid);
50 kfree(stbuf->gid);
51 kfree(stbuf->muid);
52 kfree(stbuf->extension);
53}
54EXPORT_SYMBOL(p9stat_free);
55
Aneesh Kumar K.Vabfa0342011-08-16 10:50:10 +053056size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size)
Eric Van Hensbergenace51c42008-10-13 20:40:27 -050057{
Thiago Farina01b0c5c2010-12-04 15:22:46 +000058 size_t len = min(pdu->size - pdu->offset, size);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -050059 memcpy(data, &pdu->sdata[pdu->offset], len);
60 pdu->offset += len;
61 return size - len;
62}
63
64static size_t pdu_write(struct p9_fcall *pdu, const void *data, size_t size)
65{
Thiago Farina01b0c5c2010-12-04 15:22:46 +000066 size_t len = min(pdu->capacity - pdu->size, size);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -050067 memcpy(&pdu->sdata[pdu->size], data, len);
68 pdu->size += len;
69 return size - len;
70}
71
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -050072static size_t
Al Viro4f3b35c2015-04-01 19:57:53 -040073pdu_write_u(struct p9_fcall *pdu, struct iov_iter *from, size_t size)
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -050074{
Thiago Farina01b0c5c2010-12-04 15:22:46 +000075 size_t len = min(pdu->capacity - pdu->size, size);
Al Viro4f3b35c2015-04-01 19:57:53 -040076 struct iov_iter i = *from;
Al Viro1c512a72017-02-17 23:16:09 -050077 if (!copy_from_iter_full(&pdu->sdata[pdu->size], len, &i))
Aneesh Kumar K.V7b3bb3f2010-10-19 09:17:02 +053078 len = 0;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -050079
80 pdu->size += len;
81 return size - len;
82}
83
Eric Van Hensbergenace51c42008-10-13 20:40:27 -050084/*
85 b - int8_t
86 w - int16_t
87 d - int32_t
88 q - int64_t
89 s - string
Eric W. Biederman97fc8b12013-01-29 17:07:42 -080090 u - numeric uid
91 g - numeric gid
Eric Van Hensbergenace51c42008-10-13 20:40:27 -050092 S - stat
93 Q - qid
94 D - data blob (int32_t size followed by void *, results are not freed)
95 T - array of strings (int16_t count, followed by strings)
96 R - array of qids (int16_t count, followed by qids)
Sripathi Kodif0853122010-07-12 20:07:23 +053097 A - stat for 9p2000.L (p9_stat_dotl)
Eric Van Hensbergenace51c42008-10-13 20:40:27 -050098 ? - if optional = 1, continue parsing
99*/
100
101static int
Sripathi Kodi342fee12010-03-05 18:50:14 +0000102p9pdu_vreadf(struct p9_fcall *pdu, int proto_version, const char *fmt,
103 va_list ap)
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500104{
105 const char *ptr;
106 int errcode = 0;
107
108 for (ptr = fmt; *ptr; ptr++) {
109 switch (*ptr) {
110 case 'b':{
111 int8_t *val = va_arg(ap, int8_t *);
112 if (pdu_read(pdu, val, sizeof(*val))) {
113 errcode = -EFAULT;
114 break;
115 }
116 }
117 break;
118 case 'w':{
119 int16_t *val = va_arg(ap, int16_t *);
Eric Van Hensbergenbeeebc92009-02-06 22:07:41 -0800120 __le16 le_val;
121 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500122 errcode = -EFAULT;
123 break;
124 }
Eric Van Hensbergenbeeebc92009-02-06 22:07:41 -0800125 *val = le16_to_cpu(le_val);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500126 }
127 break;
128 case 'd':{
129 int32_t *val = va_arg(ap, int32_t *);
Eric Van Hensbergenbeeebc92009-02-06 22:07:41 -0800130 __le32 le_val;
131 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500132 errcode = -EFAULT;
133 break;
134 }
Eric Van Hensbergenbeeebc92009-02-06 22:07:41 -0800135 *val = le32_to_cpu(le_val);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500136 }
137 break;
138 case 'q':{
139 int64_t *val = va_arg(ap, int64_t *);
Eric Van Hensbergenbeeebc92009-02-06 22:07:41 -0800140 __le64 le_val;
141 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500142 errcode = -EFAULT;
143 break;
144 }
Eric Van Hensbergenbeeebc92009-02-06 22:07:41 -0800145 *val = le64_to_cpu(le_val);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500146 }
147 break;
148 case 's':{
Eric Van Hensbergene45c5402008-10-22 18:54:47 -0500149 char **sptr = va_arg(ap, char **);
M. Mohan Kumar219fd582011-01-10 14:23:53 -0600150 uint16_t len;
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500151
Sripathi Kodi342fee12010-03-05 18:50:14 +0000152 errcode = p9pdu_readf(pdu, proto_version,
153 "w", &len);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500154 if (errcode)
155 break;
156
Aneesh Kumar K.Veeff66e2011-03-08 16:39:47 +0530157 *sptr = kmalloc(len + 1, GFP_NOFS);
Eric Van Hensbergene45c5402008-10-22 18:54:47 -0500158 if (*sptr == NULL) {
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500159 errcode = -EFAULT;
160 break;
161 }
M. Mohan Kumar219fd582011-01-10 14:23:53 -0600162 if (pdu_read(pdu, *sptr, len)) {
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500163 errcode = -EFAULT;
Eric Van Hensbergene45c5402008-10-22 18:54:47 -0500164 kfree(*sptr);
165 *sptr = NULL;
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500166 } else
M. Mohan Kumar219fd582011-01-10 14:23:53 -0600167 (*sptr)[len] = 0;
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500168 }
169 break;
Eric W. Biederman97fc8b12013-01-29 17:07:42 -0800170 case 'u': {
171 kuid_t *uid = va_arg(ap, kuid_t *);
172 __le32 le_val;
173 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
174 errcode = -EFAULT;
175 break;
176 }
177 *uid = make_kuid(&init_user_ns,
178 le32_to_cpu(le_val));
179 } break;
180 case 'g': {
181 kgid_t *gid = va_arg(ap, kgid_t *);
182 __le32 le_val;
183 if (pdu_read(pdu, &le_val, sizeof(le_val))) {
184 errcode = -EFAULT;
185 break;
186 }
187 *gid = make_kgid(&init_user_ns,
188 le32_to_cpu(le_val));
189 } break;
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500190 case 'Q':{
191 struct p9_qid *qid =
192 va_arg(ap, struct p9_qid *);
193
Sripathi Kodi342fee12010-03-05 18:50:14 +0000194 errcode = p9pdu_readf(pdu, proto_version, "bdq",
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500195 &qid->type, &qid->version,
196 &qid->path);
197 }
198 break;
199 case 'S':{
200 struct p9_wstat *stbuf =
201 va_arg(ap, struct p9_wstat *);
202
Eric Van Hensbergenf0a0ac22008-10-17 12:45:23 -0500203 memset(stbuf, 0, sizeof(struct p9_wstat));
Eric W. Biederman447c5092013-01-29 16:18:50 -0800204 stbuf->n_uid = stbuf->n_muid = INVALID_UID;
205 stbuf->n_gid = INVALID_GID;
206
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500207 errcode =
Sripathi Kodi342fee12010-03-05 18:50:14 +0000208 p9pdu_readf(pdu, proto_version,
Eric W. Biederman447c5092013-01-29 16:18:50 -0800209 "wwdQdddqssss?sugu",
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500210 &stbuf->size, &stbuf->type,
211 &stbuf->dev, &stbuf->qid,
212 &stbuf->mode, &stbuf->atime,
213 &stbuf->mtime, &stbuf->length,
214 &stbuf->name, &stbuf->uid,
215 &stbuf->gid, &stbuf->muid,
216 &stbuf->extension,
217 &stbuf->n_uid, &stbuf->n_gid,
218 &stbuf->n_muid);
219 if (errcode)
220 p9stat_free(stbuf);
221 }
222 break;
223 case 'D':{
M. Mohan Kumar219fd582011-01-10 14:23:53 -0600224 uint32_t *count = va_arg(ap, uint32_t *);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500225 void **data = va_arg(ap, void **);
226
227 errcode =
Sripathi Kodi342fee12010-03-05 18:50:14 +0000228 p9pdu_readf(pdu, proto_version, "d", count);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500229 if (!errcode) {
230 *count =
M. Mohan Kumar219fd582011-01-10 14:23:53 -0600231 min_t(uint32_t, *count,
Thiago Farina01b0c5c2010-12-04 15:22:46 +0000232 pdu->size - pdu->offset);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500233 *data = &pdu->sdata[pdu->offset];
234 }
235 }
236 break;
237 case 'T':{
Harsh Prateek Borab76225e2011-03-31 15:49:39 +0530238 uint16_t *nwname = va_arg(ap, uint16_t *);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500239 char ***wnames = va_arg(ap, char ***);
240
Sripathi Kodi342fee12010-03-05 18:50:14 +0000241 errcode = p9pdu_readf(pdu, proto_version,
242 "w", nwname);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500243 if (!errcode) {
244 *wnames =
245 kmalloc(sizeof(char *) * *nwname,
Aneesh Kumar K.Veeff66e2011-03-08 16:39:47 +0530246 GFP_NOFS);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500247 if (!*wnames)
248 errcode = -ENOMEM;
249 }
250
251 if (!errcode) {
252 int i;
253
254 for (i = 0; i < *nwname; i++) {
255 errcode =
Sripathi Kodi342fee12010-03-05 18:50:14 +0000256 p9pdu_readf(pdu,
257 proto_version,
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500258 "s",
259 &(*wnames)[i]);
260 if (errcode)
261 break;
262 }
263 }
264
265 if (errcode) {
266 if (*wnames) {
267 int i;
268
269 for (i = 0; i < *nwname; i++)
270 kfree((*wnames)[i]);
271 }
272 kfree(*wnames);
273 *wnames = NULL;
274 }
275 }
276 break;
277 case 'R':{
Kirill A. Shutemov6250a8b2014-12-30 02:48:09 +0200278 uint16_t *nwqid = va_arg(ap, uint16_t *);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500279 struct p9_qid **wqids =
280 va_arg(ap, struct p9_qid **);
281
282 *wqids = NULL;
283
284 errcode =
Sripathi Kodi342fee12010-03-05 18:50:14 +0000285 p9pdu_readf(pdu, proto_version, "w", nwqid);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500286 if (!errcode) {
287 *wqids =
288 kmalloc(*nwqid *
289 sizeof(struct p9_qid),
Aneesh Kumar K.Veeff66e2011-03-08 16:39:47 +0530290 GFP_NOFS);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500291 if (*wqids == NULL)
292 errcode = -ENOMEM;
293 }
294
295 if (!errcode) {
296 int i;
297
298 for (i = 0; i < *nwqid; i++) {
299 errcode =
Sripathi Kodi342fee12010-03-05 18:50:14 +0000300 p9pdu_readf(pdu,
301 proto_version,
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500302 "Q",
303 &(*wqids)[i]);
304 if (errcode)
305 break;
306 }
307 }
308
309 if (errcode) {
310 kfree(*wqids);
311 *wqids = NULL;
312 }
313 }
314 break;
Sripathi Kodif0853122010-07-12 20:07:23 +0530315 case 'A': {
316 struct p9_stat_dotl *stbuf =
317 va_arg(ap, struct p9_stat_dotl *);
318
319 memset(stbuf, 0, sizeof(struct p9_stat_dotl));
320 errcode =
321 p9pdu_readf(pdu, proto_version,
Eric W. Biederman447c5092013-01-29 16:18:50 -0800322 "qQdugqqqqqqqqqqqqqqq",
Sripathi Kodif0853122010-07-12 20:07:23 +0530323 &stbuf->st_result_mask,
324 &stbuf->qid,
325 &stbuf->st_mode,
326 &stbuf->st_uid, &stbuf->st_gid,
327 &stbuf->st_nlink,
328 &stbuf->st_rdev, &stbuf->st_size,
329 &stbuf->st_blksize, &stbuf->st_blocks,
330 &stbuf->st_atime_sec,
331 &stbuf->st_atime_nsec,
332 &stbuf->st_mtime_sec,
333 &stbuf->st_mtime_nsec,
334 &stbuf->st_ctime_sec,
335 &stbuf->st_ctime_nsec,
336 &stbuf->st_btime_sec,
337 &stbuf->st_btime_nsec,
338 &stbuf->st_gen,
339 &stbuf->st_data_version);
340 }
341 break;
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500342 case '?':
Sripathi Kodic56e4ac2010-03-25 12:40:35 +0000343 if ((proto_version != p9_proto_2000u) &&
344 (proto_version != p9_proto_2000L))
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500345 return 0;
346 break;
347 default:
348 BUG();
349 break;
350 }
351
352 if (errcode)
353 break;
354 }
355
356 return errcode;
357}
358
359int
Sripathi Kodi342fee12010-03-05 18:50:14 +0000360p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
361 va_list ap)
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500362{
363 const char *ptr;
364 int errcode = 0;
365
366 for (ptr = fmt; *ptr; ptr++) {
367 switch (*ptr) {
368 case 'b':{
369 int8_t val = va_arg(ap, int);
370 if (pdu_write(pdu, &val, sizeof(val)))
371 errcode = -EFAULT;
372 }
373 break;
374 case 'w':{
Eric Van Hensbergenbeeebc92009-02-06 22:07:41 -0800375 __le16 val = cpu_to_le16(va_arg(ap, int));
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500376 if (pdu_write(pdu, &val, sizeof(val)))
377 errcode = -EFAULT;
378 }
379 break;
380 case 'd':{
Eric Van Hensbergenbeeebc92009-02-06 22:07:41 -0800381 __le32 val = cpu_to_le32(va_arg(ap, int32_t));
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500382 if (pdu_write(pdu, &val, sizeof(val)))
383 errcode = -EFAULT;
384 }
385 break;
386 case 'q':{
Eric Van Hensbergenbeeebc92009-02-06 22:07:41 -0800387 __le64 val = cpu_to_le64(va_arg(ap, int64_t));
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500388 if (pdu_write(pdu, &val, sizeof(val)))
389 errcode = -EFAULT;
390 }
391 break;
392 case 's':{
Eric Van Hensbergene45c5402008-10-22 18:54:47 -0500393 const char *sptr = va_arg(ap, const char *);
M. Mohan Kumar219fd582011-01-10 14:23:53 -0600394 uint16_t len = 0;
Eric Van Hensbergene45c5402008-10-22 18:54:47 -0500395 if (sptr)
Dan Carpenterd31bb4f2012-06-26 23:01:41 +0000396 len = min_t(size_t, strlen(sptr),
M. Mohan Kumar219fd582011-01-10 14:23:53 -0600397 USHRT_MAX);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500398
Sripathi Kodi342fee12010-03-05 18:50:14 +0000399 errcode = p9pdu_writef(pdu, proto_version,
400 "w", len);
Eric Van Hensbergene45c5402008-10-22 18:54:47 -0500401 if (!errcode && pdu_write(pdu, sptr, len))
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500402 errcode = -EFAULT;
403 }
404 break;
Eric W. Biederman97fc8b12013-01-29 17:07:42 -0800405 case 'u': {
406 kuid_t uid = va_arg(ap, kuid_t);
407 __le32 val = cpu_to_le32(
408 from_kuid(&init_user_ns, uid));
409 if (pdu_write(pdu, &val, sizeof(val)))
410 errcode = -EFAULT;
411 } break;
412 case 'g': {
413 kgid_t gid = va_arg(ap, kgid_t);
414 __le32 val = cpu_to_le32(
415 from_kgid(&init_user_ns, gid));
416 if (pdu_write(pdu, &val, sizeof(val)))
417 errcode = -EFAULT;
418 } break;
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500419 case 'Q':{
420 const struct p9_qid *qid =
421 va_arg(ap, const struct p9_qid *);
422 errcode =
Sripathi Kodi342fee12010-03-05 18:50:14 +0000423 p9pdu_writef(pdu, proto_version, "bdq",
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500424 qid->type, qid->version,
425 qid->path);
426 } break;
427 case 'S':{
428 const struct p9_wstat *stbuf =
429 va_arg(ap, const struct p9_wstat *);
430 errcode =
Sripathi Kodi342fee12010-03-05 18:50:14 +0000431 p9pdu_writef(pdu, proto_version,
Eric W. Biederman447c5092013-01-29 16:18:50 -0800432 "wwdQdddqssss?sugu",
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500433 stbuf->size, stbuf->type,
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500434 stbuf->dev, &stbuf->qid,
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500435 stbuf->mode, stbuf->atime,
436 stbuf->mtime, stbuf->length,
437 stbuf->name, stbuf->uid,
438 stbuf->gid, stbuf->muid,
439 stbuf->extension, stbuf->n_uid,
440 stbuf->n_gid, stbuf->n_muid);
441 } break;
Al Viro4f3b35c2015-04-01 19:57:53 -0400442 case 'V':{
M. Mohan Kumar219fd582011-01-10 14:23:53 -0600443 uint32_t count = va_arg(ap, uint32_t);
Al Viro4f3b35c2015-04-01 19:57:53 -0400444 struct iov_iter *from =
445 va_arg(ap, struct iov_iter *);
Sripathi Kodi342fee12010-03-05 18:50:14 +0000446 errcode = p9pdu_writef(pdu, proto_version, "d",
447 count);
Al Viro4f3b35c2015-04-01 19:57:53 -0400448 if (!errcode && pdu_write_u(pdu, from, count))
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500449 errcode = -EFAULT;
450 }
451 break;
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500452 case 'T':{
Harsh Prateek Borab76225e2011-03-31 15:49:39 +0530453 uint16_t nwname = va_arg(ap, int);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500454 const char **wnames = va_arg(ap, const char **);
455
Sripathi Kodi342fee12010-03-05 18:50:14 +0000456 errcode = p9pdu_writef(pdu, proto_version, "w",
457 nwname);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500458 if (!errcode) {
459 int i;
460
461 for (i = 0; i < nwname; i++) {
462 errcode =
Sripathi Kodi342fee12010-03-05 18:50:14 +0000463 p9pdu_writef(pdu,
464 proto_version,
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500465 "s",
466 wnames[i]);
467 if (errcode)
468 break;
469 }
470 }
471 }
472 break;
473 case 'R':{
Kirill A. Shutemov6250a8b2014-12-30 02:48:09 +0200474 uint16_t nwqid = va_arg(ap, int);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500475 struct p9_qid *wqids =
476 va_arg(ap, struct p9_qid *);
477
Sripathi Kodi342fee12010-03-05 18:50:14 +0000478 errcode = p9pdu_writef(pdu, proto_version, "w",
479 nwqid);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500480 if (!errcode) {
481 int i;
482
483 for (i = 0; i < nwqid; i++) {
484 errcode =
Sripathi Kodi342fee12010-03-05 18:50:14 +0000485 p9pdu_writef(pdu,
486 proto_version,
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500487 "Q",
488 &wqids[i]);
489 if (errcode)
490 break;
491 }
492 }
493 }
494 break;
Sripathi Kodi87d78452010-06-18 11:50:10 +0530495 case 'I':{
496 struct p9_iattr_dotl *p9attr = va_arg(ap,
497 struct p9_iattr_dotl *);
498
499 errcode = p9pdu_writef(pdu, proto_version,
Eric W. Biederman447c5092013-01-29 16:18:50 -0800500 "ddugqqqqq",
Sripathi Kodi87d78452010-06-18 11:50:10 +0530501 p9attr->valid,
502 p9attr->mode,
503 p9attr->uid,
504 p9attr->gid,
505 p9attr->size,
506 p9attr->atime_sec,
507 p9attr->atime_nsec,
508 p9attr->mtime_sec,
509 p9attr->mtime_nsec);
510 }
511 break;
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500512 case '?':
Sripathi Kodic56e4ac2010-03-25 12:40:35 +0000513 if ((proto_version != p9_proto_2000u) &&
514 (proto_version != p9_proto_2000L))
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500515 return 0;
516 break;
517 default:
518 BUG();
519 break;
520 }
521
522 if (errcode)
523 break;
524 }
525
526 return errcode;
527}
528
Sripathi Kodi342fee12010-03-05 18:50:14 +0000529int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500530{
531 va_list ap;
532 int ret;
533
534 va_start(ap, fmt);
Sripathi Kodi342fee12010-03-05 18:50:14 +0000535 ret = p9pdu_vreadf(pdu, proto_version, fmt, ap);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500536 va_end(ap);
537
538 return ret;
539}
540
541static int
Sripathi Kodi342fee12010-03-05 18:50:14 +0000542p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500543{
544 va_list ap;
545 int ret;
546
547 va_start(ap, fmt);
Sripathi Kodi342fee12010-03-05 18:50:14 +0000548 ret = p9pdu_vwritef(pdu, proto_version, fmt, ap);
Eric Van Hensbergenace51c42008-10-13 20:40:27 -0500549 va_end(ap);
550
551 return ret;
552}
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500553
Aneesh Kumar K.V348b5902011-08-07 00:46:59 +0530554int p9stat_read(struct p9_client *clnt, char *buf, int len, struct p9_wstat *st)
Eric Van Hensbergen02da3982008-10-16 08:29:30 -0500555{
556 struct p9_fcall fake_pdu;
Eric Van Hensbergene7f4b8f2008-10-17 16:20:07 -0500557 int ret;
Eric Van Hensbergen02da3982008-10-16 08:29:30 -0500558
559 fake_pdu.size = len;
560 fake_pdu.capacity = len;
561 fake_pdu.sdata = buf;
562 fake_pdu.offset = 0;
563
Aneesh Kumar K.V348b5902011-08-07 00:46:59 +0530564 ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st);
Eric Van Hensbergene7f4b8f2008-10-17 16:20:07 -0500565 if (ret) {
Joe Perches5d385152011-11-28 10:40:46 -0800566 p9_debug(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
Aneesh Kumar K.V348b5902011-08-07 00:46:59 +0530567 trace_9p_protocol_dump(clnt, &fake_pdu);
Eric Van Hensbergene7f4b8f2008-10-17 16:20:07 -0500568 }
569
570 return ret;
Eric Van Hensbergen02da3982008-10-16 08:29:30 -0500571}
572EXPORT_SYMBOL(p9stat_read);
573
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500574int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
575{
Venkateswararao Jujjuri (JV)9bb6c102011-02-02 17:52:46 -0800576 pdu->id = type;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500577 return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
578}
579
Aneesh Kumar K.V348b5902011-08-07 00:46:59 +0530580int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu)
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500581{
582 int size = pdu->size;
583 int err;
584
585 pdu->size = 0;
586 err = p9pdu_writef(pdu, 0, "d", size);
587 pdu->size = size;
588
Aneesh Kumar K.V348b5902011-08-07 00:46:59 +0530589 trace_9p_protocol_dump(clnt, pdu);
Joe Perches5d385152011-11-28 10:40:46 -0800590 p9_debug(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n",
591 pdu->size, pdu->id, pdu->tag);
Eric Van Hensbergene7f4b8f2008-10-17 16:20:07 -0500592
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500593 return err;
594}
595
596void p9pdu_reset(struct p9_fcall *pdu)
597{
598 pdu->offset = 0;
599 pdu->size = 0;
600}
Sripathi Kodi7751bdb2010-06-04 13:41:26 +0000601
Aneesh Kumar K.V348b5902011-08-07 00:46:59 +0530602int p9dirent_read(struct p9_client *clnt, char *buf, int len,
603 struct p9_dirent *dirent)
Sripathi Kodi7751bdb2010-06-04 13:41:26 +0000604{
605 struct p9_fcall fake_pdu;
606 int ret;
607 char *nameptr;
608
609 fake_pdu.size = len;
610 fake_pdu.capacity = len;
611 fake_pdu.sdata = buf;
612 fake_pdu.offset = 0;
613
Aneesh Kumar K.V348b5902011-08-07 00:46:59 +0530614 ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid,
615 &dirent->d_off, &dirent->d_type, &nameptr);
Sripathi Kodi7751bdb2010-06-04 13:41:26 +0000616 if (ret) {
Joe Perches5d385152011-11-28 10:40:46 -0800617 p9_debug(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
Aneesh Kumar K.V348b5902011-08-07 00:46:59 +0530618 trace_9p_protocol_dump(clnt, &fake_pdu);
Sripathi Kodi7751bdb2010-06-04 13:41:26 +0000619 goto out;
620 }
621
622 strcpy(dirent->d_name, nameptr);
Pedro Scarapicchia Junior1b0bcbcf62011-05-09 14:10:49 +0000623 kfree(nameptr);
Sripathi Kodi7751bdb2010-06-04 13:41:26 +0000624
625out:
626 return fake_pdu.offset;
627}
628EXPORT_SYMBOL(p9dirent_read);