?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.25-rc4
[linux-2.6/next.git] / net / 9p / conv.c
blob3fe35d532c87a0c2f17afb2baf961077a954f96e
1 /*
2 * net/9p/conv.c
3 *
4 * 9P protocol conversion functions
5 *
6 * Copyright (C) 2004, 2005 by Latchesar Ionkov <lucho@ionkov.net>
7 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
8 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2
12 * as published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to:
21 * Free Software Foundation
22 * 51 Franklin Street, Fifth Floor
23 * Boston, MA 02111-1301 USA
24 *
25 */
26
27 #include <linux/module.h>
28 #include <linux/errno.h>
29 #include <linux/fs.h>
30 #include <linux/sched.h>
31 #include <linux/idr.h>
32 #include <linux/uaccess.h>
33 #include <net/9p/9p.h>
34
35 /*
36 * Buffer to help with string parsing
37 */
38 struct cbuf {
39 unsigned char *sp;
40 unsigned char *p;
41 unsigned char *ep;
42 };
43
44 static inline void buf_init(struct cbuf *buf, void *data, int datalen)
45 {
46 buf->sp = buf->p = data;
47 buf->ep = data + datalen;
48 }
49
50 static inline int buf_check_overflow(struct cbuf *buf)
51 {
52 return buf->p > buf->ep;
53 }
54
55 static int buf_check_size(struct cbuf *buf, int len)
56 {
57 if (buf->p + len > buf->ep) {
58 if (buf->p < buf->ep) {
59 P9_EPRINTK(KERN_ERR,
60 "buffer overflow: want %d has %d\n", len,
61 (int)(buf->ep - buf->p));
62 dump_stack();
63 buf->p = buf->ep + 1;
64 }
65
66 return 0;
67 }
68
69 return 1;
70 }
71
72 static void *buf_alloc(struct cbuf *buf, int len)
73 {
74 void *ret = NULL;
75
76 if (buf_check_size(buf, len)) {
77 ret = buf->p;
78 buf->p += len;
79 }
80
81 return ret;
82 }
83
84 static void buf_put_int8(struct cbuf *buf, u8 val)
85 {
86 if (buf_check_size(buf, 1)) {
87 buf->p[0] = val;
88 buf->p++;
89 }
90 }
91
92 static void buf_put_int16(struct cbuf *buf, u16 val)
93 {
94 if (buf_check_size(buf, 2)) {
95 *(__le16 *) buf->p = cpu_to_le16(val);
96 buf->p += 2;
97 }
98 }
99
100 static void buf_put_int32(struct cbuf *buf, u32 val)
101 {
102 if (buf_check_size(buf, 4)) {
103 *(__le32 *)buf->p = cpu_to_le32(val);
104 buf->p += 4;
105 }
106 }
107
108 static void buf_put_int64(struct cbuf *buf, u64 val)
109 {
110 if (buf_check_size(buf, 8)) {
111 *(__le64 *)buf->p = cpu_to_le64(val);
112 buf->p += 8;
113 }
114 }
115
116 static char *buf_put_stringn(struct cbuf *buf, const char *s, u16 slen)
117 {
118 char *ret;
119
120 ret = NULL;
121 if (buf_check_size(buf, slen + 2)) {
122 buf_put_int16(buf, slen);
123 ret = buf->p;
124 memcpy(buf->p, s, slen);
125 buf->p += slen;
126 }
127
128 return ret;
129 }
130
131 static u8 buf_get_int8(struct cbuf *buf)
132 {
133 u8 ret = 0;
134
135 if (buf_check_size(buf, 1)) {
136 ret = buf->p[0];
137 buf->p++;
138 }
139
140 return ret;
141 }
142
143 static u16 buf_get_int16(struct cbuf *buf)
144 {
145 u16 ret = 0;
146
147 if (buf_check_size(buf, 2)) {
148 ret = le16_to_cpu(*(__le16 *)buf->p);
149 buf->p += 2;
150 }
151
152 return ret;
153 }
154
155 static u32 buf_get_int32(struct cbuf *buf)
156 {
157 u32 ret = 0;
158
159 if (buf_check_size(buf, 4)) {
160 ret = le32_to_cpu(*(__le32 *)buf->p);
161 buf->p += 4;
162 }
163
164 return ret;
165 }
166
167 static u64 buf_get_int64(struct cbuf *buf)
168 {
169 u64 ret = 0;
170
171 if (buf_check_size(buf, 8)) {
172 ret = le64_to_cpu(*(__le64 *)buf->p);
173 buf->p += 8;
174 }
175
176 return ret;
177 }
178
179 static void buf_get_str(struct cbuf *buf, struct p9_str *vstr)
180 {
181 vstr->len = buf_get_int16(buf);
182 if (!buf_check_overflow(buf) && buf_check_size(buf, vstr->len)) {
183 vstr->str = buf->p;
184 buf->p += vstr->len;
185 } else {
186 vstr->len = 0;
187 vstr->str = NULL;
188 }
189 }
190
191 static void buf_get_qid(struct cbuf *bufp, struct p9_qid *qid)
192 {
193 qid->type = buf_get_int8(bufp);
194 qid->version = buf_get_int32(bufp);
195 qid->path = buf_get_int64(bufp);
196 }
197
198 /**
199 * p9_size_wstat - calculate the size of a variable length stat struct
200 * @stat: metadata (stat) structure
201 * @dotu: non-zero if 9P2000.u
202 *
203 */
204
205 static int p9_size_wstat(struct p9_wstat *wstat, int dotu)
206 {
207 int size = 0;
208
209 if (wstat == NULL) {
210 P9_EPRINTK(KERN_ERR, "p9_size_stat: got a NULL stat pointer\n");
211 return 0;
212 }
213
214 size = /* 2 + *//* size[2] */
215 2 + /* type[2] */
216 4 + /* dev[4] */
217 1 + /* qid.type[1] */
218 4 + /* qid.vers[4] */
219 8 + /* qid.path[8] */
220 4 + /* mode[4] */
221 4 + /* atime[4] */
222 4 + /* mtime[4] */
223 8 + /* length[8] */
224 8; /* minimum sum of string lengths */
225
226 if (wstat->name)
227 size += strlen(wstat->name);
228 if (wstat->uid)
229 size += strlen(wstat->uid);
230 if (wstat->gid)
231 size += strlen(wstat->gid);
232 if (wstat->muid)
233 size += strlen(wstat->muid);
234
235 if (dotu) {
236 size += 4 + /* n_uid[4] */
237 4 + /* n_gid[4] */
238 4 + /* n_muid[4] */
239 2; /* string length of extension[4] */
240 if (wstat->extension)
241 size += strlen(wstat->extension);
242 }
243
244 return size;
245 }
246
247 /**
248 * buf_get_stat - safely decode a recieved metadata (stat) structure
249 * @bufp: buffer to deserialize
250 * @stat: metadata (stat) structure
251 * @dotu: non-zero if 9P2000.u
252 *
253 */
254
255 static void
256 buf_get_stat(struct cbuf *bufp, struct p9_stat *stat, int dotu)
257 {
258 stat->size = buf_get_int16(bufp);
259 stat->type = buf_get_int16(bufp);
260 stat->dev = buf_get_int32(bufp);
261 stat->qid.type = buf_get_int8(bufp);
262 stat->qid.version = buf_get_int32(bufp);
263 stat->qid.path = buf_get_int64(bufp);
264 stat->mode = buf_get_int32(bufp);
265 stat->atime = buf_get_int32(bufp);
266 stat->mtime = buf_get_int32(bufp);
267 stat->length = buf_get_int64(bufp);
268 buf_get_str(bufp, &stat->name);
269 buf_get_str(bufp, &stat->uid);
270 buf_get_str(bufp, &stat->gid);
271 buf_get_str(bufp, &stat->muid);
272
273 if (dotu) {
274 buf_get_str(bufp, &stat->extension);
275 stat->n_uid = buf_get_int32(bufp);
276 stat->n_gid = buf_get_int32(bufp);
277 stat->n_muid = buf_get_int32(bufp);
278 }
279 }
280
281 /**
282 * p9_deserialize_stat - decode a received metadata structure
283 * @buf: buffer to deserialize
284 * @buflen: length of received buffer
285 * @stat: metadata structure to decode into
286 * @dotu: non-zero if 9P2000.u
287 *
288 * Note: stat will point to the buf region.
289 */
290
291 int
292 p9_deserialize_stat(void *buf, u32 buflen, struct p9_stat *stat,
293 int dotu)
294 {
295 struct cbuf buffer;
296 struct cbuf *bufp = &buffer;
297 unsigned char *p;
298
299 buf_init(bufp, buf, buflen);
300 p = bufp->p;
301 buf_get_stat(bufp, stat, dotu);
302
303 if (buf_check_overflow(bufp))
304 return 0;
305 else
306 return bufp->p - p;
307 }
308 EXPORT_SYMBOL(p9_deserialize_stat);
309
310 /**
311 * deserialize_fcall - unmarshal a response
312 * @buf: recieved buffer
313 * @buflen: length of received buffer
314 * @rcall: fcall structure to populate
315 * @rcalllen: length of fcall structure to populate
316 * @dotu: non-zero if 9P2000.u
317 *
318 */
319
320 int
321 p9_deserialize_fcall(void *buf, u32 buflen, struct p9_fcall *rcall,
322 int dotu)
323 {
324
325 struct cbuf buffer;
326 struct cbuf *bufp = &buffer;
327 int i = 0;
328
329 buf_init(bufp, buf, buflen);
330
331 rcall->size = buf_get_int32(bufp);
332 rcall->id = buf_get_int8(bufp);
333 rcall->tag = buf_get_int16(bufp);
334
335 P9_DPRINTK(P9_DEBUG_CONV, "size %d id %d tag %d\n", rcall->size,
336 rcall->id, rcall->tag);
337
338 switch (rcall->id) {
339 default:
340 P9_EPRINTK(KERN_ERR, "unknown message type: %d\n", rcall->id);
341 return -EPROTO;
342 case P9_RVERSION:
343 rcall->params.rversion.msize = buf_get_int32(bufp);
344 buf_get_str(bufp, &rcall->params.rversion.version);
345 break;
346 case P9_RFLUSH:
347 break;
348 case P9_RATTACH:
349 rcall->params.rattach.qid.type = buf_get_int8(bufp);
350 rcall->params.rattach.qid.version = buf_get_int32(bufp);
351 rcall->params.rattach.qid.path = buf_get_int64(bufp);
352 break;
353 case P9_RWALK:
354 rcall->params.rwalk.nwqid = buf_get_int16(bufp);
355 if (rcall->params.rwalk.nwqid > P9_MAXWELEM) {
356 P9_EPRINTK(KERN_ERR,
357 "Rwalk with more than %d qids: %d\n",
358 P9_MAXWELEM, rcall->params.rwalk.nwqid);
359 return -EPROTO;
360 }
361
362 for (i = 0; i < rcall->params.rwalk.nwqid; i++)
363 buf_get_qid(bufp, &rcall->params.rwalk.wqids[i]);
364 break;
365 case P9_ROPEN:
366 buf_get_qid(bufp, &rcall->params.ropen.qid);
367 rcall->params.ropen.iounit = buf_get_int32(bufp);
368 break;
369 case P9_RCREATE:
370 buf_get_qid(bufp, &rcall->params.rcreate.qid);
371 rcall->params.rcreate.iounit = buf_get_int32(bufp);
372 break;
373 case P9_RREAD:
374 rcall->params.rread.count = buf_get_int32(bufp);
375 rcall->params.rread.data = bufp->p;
376 buf_check_size(bufp, rcall->params.rread.count);
377 break;
378 case P9_RWRITE:
379 rcall->params.rwrite.count = buf_get_int32(bufp);
380 break;
381 case P9_RCLUNK:
382 break;
383 case P9_RREMOVE:
384 break;
385 case P9_RSTAT:
386 buf_get_int16(bufp);
387 buf_get_stat(bufp, &rcall->params.rstat.stat, dotu);
388 break;
389 case P9_RWSTAT:
390 break;
391 case P9_RERROR:
392 buf_get_str(bufp, &rcall->params.rerror.error);
393 if (dotu)
394 rcall->params.rerror.errno = buf_get_int16(bufp);
395 break;
396 }
397
398 if (buf_check_overflow(bufp)) {
399 P9_DPRINTK(P9_DEBUG_ERROR, "buffer overflow\n");
400 return -EIO;
401 }
402
403 return bufp->p - bufp->sp;
404 }
405 EXPORT_SYMBOL(p9_deserialize_fcall);
406
407 static inline void p9_put_int8(struct cbuf *bufp, u8 val, u8 * p)
408 {
409 *p = val;
410 buf_put_int8(bufp, val);
411 }
412
413 static inline void p9_put_int16(struct cbuf *bufp, u16 val, u16 * p)
414 {
415 *p = val;
416 buf_put_int16(bufp, val);
417 }
418
419 static inline void p9_put_int32(struct cbuf *bufp, u32 val, u32 * p)
420 {
421 *p = val;
422 buf_put_int32(bufp, val);
423 }
424
425 static inline void p9_put_int64(struct cbuf *bufp, u64 val, u64 * p)
426 {
427 *p = val;
428 buf_put_int64(bufp, val);
429 }
430
431 static void
432 p9_put_str(struct cbuf *bufp, char *data, struct p9_str *str)
433 {
434 int len;
435 char *s;
436
437 if (data)
438 len = strlen(data);
439 else
440 len = 0;
441
442 s = buf_put_stringn(bufp, data, len);
443 if (str) {
444 str->len = len;
445 str->str = s;
446 }
447 }
448
449 static int
450 p9_put_data(struct cbuf *bufp, const char *data, int count,
451 unsigned char **pdata)
452 {
453 *pdata = buf_alloc(bufp, count);
454 memmove(*pdata, data, count);
455 return count;
456 }
457
458 static int
459 p9_put_user_data(struct cbuf *bufp, const char __user *data, int count,
460 unsigned char **pdata)
461 {
462 *pdata = buf_alloc(bufp, count);
463 return copy_from_user(*pdata, data, count);
464 }
465
466 static void
467 p9_put_wstat(struct cbuf *bufp, struct p9_wstat *wstat,
468 struct p9_stat *stat, int statsz, int dotu)
469 {
470 p9_put_int16(bufp, statsz, &stat->size);
471 p9_put_int16(bufp, wstat->type, &stat->type);
472 p9_put_int32(bufp, wstat->dev, &stat->dev);
473 p9_put_int8(bufp, wstat->qid.type, &stat->qid.type);
474 p9_put_int32(bufp, wstat->qid.version, &stat->qid.version);
475 p9_put_int64(bufp, wstat->qid.path, &stat->qid.path);
476 p9_put_int32(bufp, wstat->mode, &stat->mode);
477 p9_put_int32(bufp, wstat->atime, &stat->atime);
478 p9_put_int32(bufp, wstat->mtime, &stat->mtime);
479 p9_put_int64(bufp, wstat->length, &stat->length);
480
481 p9_put_str(bufp, wstat->name, &stat->name);
482 p9_put_str(bufp, wstat->uid, &stat->uid);
483 p9_put_str(bufp, wstat->gid, &stat->gid);
484 p9_put_str(bufp, wstat->muid, &stat->muid);
485
486 if (dotu) {
487 p9_put_str(bufp, wstat->extension, &stat->extension);
488 p9_put_int32(bufp, wstat->n_uid, &stat->n_uid);
489 p9_put_int32(bufp, wstat->n_gid, &stat->n_gid);
490 p9_put_int32(bufp, wstat->n_muid, &stat->n_muid);
491 }
492 }
493
494 static struct p9_fcall *
495 p9_create_common(struct cbuf *bufp, u32 size, u8 id)
496 {
497 struct p9_fcall *fc;
498
499 size += 4 + 1 + 2; /* size[4] id[1] tag[2] */
500 fc = kmalloc(sizeof(struct p9_fcall) + size, GFP_KERNEL);
501 if (!fc)
502 return ERR_PTR(-ENOMEM);
503
504 fc->sdata = (char *)fc + sizeof(*fc);
505
506 buf_init(bufp, (char *)fc->sdata, size);
507 p9_put_int32(bufp, size, &fc->size);
508 p9_put_int8(bufp, id, &fc->id);
509 p9_put_int16(bufp, P9_NOTAG, &fc->tag);
510
511 return fc;
512 }
513
514 void p9_set_tag(struct p9_fcall *fc, u16 tag)
515 {
516 fc->tag = tag;
517 *(__le16 *) (fc->sdata + 5) = cpu_to_le16(tag);
518 }
519 EXPORT_SYMBOL(p9_set_tag);
520
521 struct p9_fcall *p9_create_tversion(u32 msize, char *version)
522 {
523 int size;
524 struct p9_fcall *fc;
525 struct cbuf buffer;
526 struct cbuf *bufp = &buffer;
527
528 size = 4 + 2 + strlen(version); /* msize[4] version[s] */
529 fc = p9_create_common(bufp, size, P9_TVERSION);
530 if (IS_ERR(fc))
531 goto error;
532
533 p9_put_int32(bufp, msize, &fc->params.tversion.msize);
534 p9_put_str(bufp, version, &fc->params.tversion.version);
535
536 if (buf_check_overflow(bufp)) {
537 kfree(fc);
538 fc = ERR_PTR(-ENOMEM);
539 }
540 error:
541 return fc;
542 }
543 EXPORT_SYMBOL(p9_create_tversion);
544
545 struct p9_fcall *p9_create_tauth(u32 afid, char *uname, char *aname,
546 u32 n_uname, int dotu)
547 {
548 int size;
549 struct p9_fcall *fc;
550 struct cbuf buffer;
551 struct cbuf *bufp = &buffer;
552
553 /* afid[4] uname[s] aname[s] */
554 size = 4 + 2 + 2;
555 if (uname)
556 size += strlen(uname);
557
558 if (aname)
559 size += strlen(aname);
560
561 if (dotu)
562 size += 4; /* n_uname */
563
564 fc = p9_create_common(bufp, size, P9_TAUTH);
565 if (IS_ERR(fc))
566 goto error;
567
568 p9_put_int32(bufp, afid, &fc->params.tauth.afid);
569 p9_put_str(bufp, uname, &fc->params.tauth.uname);
570 p9_put_str(bufp, aname, &fc->params.tauth.aname);
571 if (dotu)
572 p9_put_int32(bufp, n_uname, &fc->params.tauth.n_uname);
573
574 if (buf_check_overflow(bufp)) {
575 kfree(fc);
576 fc = ERR_PTR(-ENOMEM);
577 }
578 error:
579 return fc;
580 }
581 EXPORT_SYMBOL(p9_create_tauth);
582
583 struct p9_fcall *
584 p9_create_tattach(u32 fid, u32 afid, char *uname, char *aname,
585 u32 n_uname, int dotu)
586 {
587 int size;
588 struct p9_fcall *fc;
589 struct cbuf buffer;
590 struct cbuf *bufp = &buffer;
591
592 /* fid[4] afid[4] uname[s] aname[s] */
593 size = 4 + 4 + 2 + 2;
594 if (uname)
595 size += strlen(uname);
596
597 if (aname)
598 size += strlen(aname);
599
600 if (dotu)
601 size += 4; /* n_uname */
602
603 fc = p9_create_common(bufp, size, P9_TATTACH);
604 if (IS_ERR(fc))
605 goto error;
606
607 p9_put_int32(bufp, fid, &fc->params.tattach.fid);
608 p9_put_int32(bufp, afid, &fc->params.tattach.afid);
609 p9_put_str(bufp, uname, &fc->params.tattach.uname);
610 p9_put_str(bufp, aname, &fc->params.tattach.aname);
611 if (dotu)
612 p9_put_int32(bufp, n_uname, &fc->params.tattach.n_uname);
613
614 error:
615 return fc;
616 }
617 EXPORT_SYMBOL(p9_create_tattach);
618
619 struct p9_fcall *p9_create_tflush(u16 oldtag)
620 {
621 int size;
622 struct p9_fcall *fc;
623 struct cbuf buffer;
624 struct cbuf *bufp = &buffer;
625
626 size = 2; /* oldtag[2] */
627 fc = p9_create_common(bufp, size, P9_TFLUSH);
628 if (IS_ERR(fc))
629 goto error;
630
631 p9_put_int16(bufp, oldtag, &fc->params.tflush.oldtag);
632
633 if (buf_check_overflow(bufp)) {
634 kfree(fc);
635 fc = ERR_PTR(-ENOMEM);
636 }
637 error:
638 return fc;
639 }
640 EXPORT_SYMBOL(p9_create_tflush);
641
642 struct p9_fcall *p9_create_twalk(u32 fid, u32 newfid, u16 nwname,
643 char **wnames)
644 {
645 int i, size;
646 struct p9_fcall *fc;
647 struct cbuf buffer;
648 struct cbuf *bufp = &buffer;
649
650 if (nwname > P9_MAXWELEM) {
651 P9_DPRINTK(P9_DEBUG_ERROR, "nwname > %d\n", P9_MAXWELEM);
652 return NULL;
653 }
654
655 size = 4 + 4 + 2; /* fid[4] newfid[4] nwname[2] ... */
656 for (i = 0; i < nwname; i++) {
657 size += 2 + strlen(wnames[i]); /* wname[s] */
658 }
659
660 fc = p9_create_common(bufp, size, P9_TWALK);
661 if (IS_ERR(fc))
662 goto error;
663
664 p9_put_int32(bufp, fid, &fc->params.twalk.fid);
665 p9_put_int32(bufp, newfid, &fc->params.twalk.newfid);
666 p9_put_int16(bufp, nwname, &fc->params.twalk.nwname);
667 for (i = 0; i < nwname; i++) {
668 p9_put_str(bufp, wnames[i], &fc->params.twalk.wnames[i]);
669 }
670
671 if (buf_check_overflow(bufp)) {
672 kfree(fc);
673 fc = ERR_PTR(-ENOMEM);
674 }
675 error:
676 return fc;
677 }
678 EXPORT_SYMBOL(p9_create_twalk);
679
680 struct p9_fcall *p9_create_topen(u32 fid, u8 mode)
681 {
682 int size;
683 struct p9_fcall *fc;
684 struct cbuf buffer;
685 struct cbuf *bufp = &buffer;
686
687 size = 4 + 1; /* fid[4] mode[1] */
688 fc = p9_create_common(bufp, size, P9_TOPEN);
689 if (IS_ERR(fc))
690 goto error;
691
692 p9_put_int32(bufp, fid, &fc->params.topen.fid);
693 p9_put_int8(bufp, mode, &fc->params.topen.mode);
694
695 if (buf_check_overflow(bufp)) {
696 kfree(fc);
697 fc = ERR_PTR(-ENOMEM);
698 }
699 error:
700 return fc;
701 }
702 EXPORT_SYMBOL(p9_create_topen);
703
704 struct p9_fcall *p9_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
705 char *extension, int dotu)
706 {
707 int size;
708 struct p9_fcall *fc;
709 struct cbuf buffer;
710 struct cbuf *bufp = &buffer;
711
712 /* fid[4] name[s] perm[4] mode[1] */
713 size = 4 + 2 + strlen(name) + 4 + 1;
714 if (dotu) {
715 size += 2 + /* extension[s] */
716 (extension == NULL ? 0 : strlen(extension));
717 }
718
719 fc = p9_create_common(bufp, size, P9_TCREATE);
720 if (IS_ERR(fc))
721 goto error;
722
723 p9_put_int32(bufp, fid, &fc->params.tcreate.fid);
724 p9_put_str(bufp, name, &fc->params.tcreate.name);
725 p9_put_int32(bufp, perm, &fc->params.tcreate.perm);
726 p9_put_int8(bufp, mode, &fc->params.tcreate.mode);
727 if (dotu)
728 p9_put_str(bufp, extension, &fc->params.tcreate.extension);
729
730 if (buf_check_overflow(bufp)) {
731 kfree(fc);
732 fc = ERR_PTR(-ENOMEM);
733 }
734 error:
735 return fc;
736 }
737 EXPORT_SYMBOL(p9_create_tcreate);
738
739 struct p9_fcall *p9_create_tread(u32 fid, u64 offset, u32 count)
740 {
741 int size;
742 struct p9_fcall *fc;
743 struct cbuf buffer;
744 struct cbuf *bufp = &buffer;
745
746 size = 4 + 8 + 4; /* fid[4] offset[8] count[4] */
747 fc = p9_create_common(bufp, size, P9_TREAD);
748 if (IS_ERR(fc))
749 goto error;
750
751 p9_put_int32(bufp, fid, &fc->params.tread.fid);
752 p9_put_int64(bufp, offset, &fc->params.tread.offset);
753 p9_put_int32(bufp, count, &fc->params.tread.count);
754
755 if (buf_check_overflow(bufp)) {
756 kfree(fc);
757 fc = ERR_PTR(-ENOMEM);
758 }
759 error:
760 return fc;
761 }
762 EXPORT_SYMBOL(p9_create_tread);
763
764 struct p9_fcall *p9_create_twrite(u32 fid, u64 offset, u32 count,
765 const char *data)
766 {
767 int size, err;
768 struct p9_fcall *fc;
769 struct cbuf buffer;
770 struct cbuf *bufp = &buffer;
771
772 /* fid[4] offset[8] count[4] data[count] */
773 size = 4 + 8 + 4 + count;
774 fc = p9_create_common(bufp, size, P9_TWRITE);
775 if (IS_ERR(fc))
776 goto error;
777
778 p9_put_int32(bufp, fid, &fc->params.twrite.fid);
779 p9_put_int64(bufp, offset, &fc->params.twrite.offset);
780 p9_put_int32(bufp, count, &fc->params.twrite.count);
781 err = p9_put_data(bufp, data, count, &fc->params.twrite.data);
782 if (err) {
783 kfree(fc);
784 fc = ERR_PTR(err);
785 goto error;
786 }
787
788 if (buf_check_overflow(bufp)) {
789 kfree(fc);
790 fc = ERR_PTR(-ENOMEM);
791 }
792 error:
793 return fc;
794 }
795 EXPORT_SYMBOL(p9_create_twrite);
796
797 struct p9_fcall *p9_create_twrite_u(u32 fid, u64 offset, u32 count,
798 const char __user *data)
799 {
800 int size, err;
801 struct p9_fcall *fc;
802 struct cbuf buffer;
803 struct cbuf *bufp = &buffer;
804
805 /* fid[4] offset[8] count[4] data[count] */
806 size = 4 + 8 + 4 + count;
807 fc = p9_create_common(bufp, size, P9_TWRITE);
808 if (IS_ERR(fc))
809 goto error;
810
811 p9_put_int32(bufp, fid, &fc->params.twrite.fid);
812 p9_put_int64(bufp, offset, &fc->params.twrite.offset);
813 p9_put_int32(bufp, count, &fc->params.twrite.count);
814 err = p9_put_user_data(bufp, data, count, &fc->params.twrite.data);
815 if (err) {
816 kfree(fc);
817 fc = ERR_PTR(err);
818 goto error;
819 }
820
821 if (buf_check_overflow(bufp)) {
822 kfree(fc);
823 fc = ERR_PTR(-ENOMEM);
824 }
825 error:
826 return fc;
827 }
828 EXPORT_SYMBOL(p9_create_twrite_u);
829
830 struct p9_fcall *p9_create_tclunk(u32 fid)
831 {
832 int size;
833 struct p9_fcall *fc;
834 struct cbuf buffer;
835 struct cbuf *bufp = &buffer;
836
837 size = 4; /* fid[4] */
838 fc = p9_create_common(bufp, size, P9_TCLUNK);
839 if (IS_ERR(fc))
840 goto error;
841
842 p9_put_int32(bufp, fid, &fc->params.tclunk.fid);
843
844 if (buf_check_overflow(bufp)) {
845 kfree(fc);
846 fc = ERR_PTR(-ENOMEM);
847 }
848 error:
849 return fc;
850 }
851 EXPORT_SYMBOL(p9_create_tclunk);
852
853 struct p9_fcall *p9_create_tremove(u32 fid)
854 {
855 int size;
856 struct p9_fcall *fc;
857 struct cbuf buffer;
858 struct cbuf *bufp = &buffer;
859
860 size = 4; /* fid[4] */
861 fc = p9_create_common(bufp, size, P9_TREMOVE);
862 if (IS_ERR(fc))
863 goto error;
864
865 p9_put_int32(bufp, fid, &fc->params.tremove.fid);
866
867 if (buf_check_overflow(bufp)) {
868 kfree(fc);
869 fc = ERR_PTR(-ENOMEM);
870 }
871 error:
872 return fc;
873 }
874 EXPORT_SYMBOL(p9_create_tremove);
875
876 struct p9_fcall *p9_create_tstat(u32 fid)
877 {
878 int size;
879 struct p9_fcall *fc;
880 struct cbuf buffer;
881 struct cbuf *bufp = &buffer;
882
883 size = 4; /* fid[4] */
884 fc = p9_create_common(bufp, size, P9_TSTAT);
885 if (IS_ERR(fc))
886 goto error;
887
888 p9_put_int32(bufp, fid, &fc->params.tstat.fid);
889
890 if (buf_check_overflow(bufp)) {
891 kfree(fc);
892 fc = ERR_PTR(-ENOMEM);
893 }
894 error:
895 return fc;
896 }
897 EXPORT_SYMBOL(p9_create_tstat);
898
899 struct p9_fcall *p9_create_twstat(u32 fid, struct p9_wstat *wstat,
900 int dotu)
901 {
902 int size, statsz;
903 struct p9_fcall *fc;
904 struct cbuf buffer;
905 struct cbuf *bufp = &buffer;
906
907 statsz = p9_size_wstat(wstat, dotu);
908 size = 4 + 2 + 2 + statsz; /* fid[4] stat[n] */
909 fc = p9_create_common(bufp, size, P9_TWSTAT);
910 if (IS_ERR(fc))
911 goto error;
912
913 p9_put_int32(bufp, fid, &fc->params.twstat.fid);
914 buf_put_int16(bufp, statsz + 2);
915 p9_put_wstat(bufp, wstat, &fc->params.twstat.stat, statsz, dotu);
916
917 if (buf_check_overflow(bufp)) {
918 kfree(fc);
919 fc = ERR_PTR(-ENOMEM);
920 }
921 error:
922 return fc;
923 }
924 EXPORT_SYMBOL(p9_create_twstat);
linux-next