1b9b15dfeaf01ed078ee2b16fe796ae028336c46
[linux-2.6.git] / fs / 9p / conv.c
1 /*
2  * linux/fs/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 as published by
12  *  the Free Software Foundation; either version 2 of the License, or
13  *  (at your option) any later version.
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/config.h>
29 #include <linux/module.h>
30 #include <linux/errno.h>
31 #include <linux/fs.h>
32 #include <linux/idr.h>
33
34 #include "debug.h"
35 #include "v9fs.h"
36 #include "9p.h"
37 #include "conv.h"
38
39 /*
40  * Buffer to help with string parsing
41  */
42 struct cbuf {
43         unsigned char *sp;
44         unsigned char *p;
45         unsigned char *ep;
46 };
47
48 static inline void buf_init(struct cbuf *buf, void *data, int datalen)
49 {
50         buf->sp = buf->p = data;
51         buf->ep = data + datalen;
52 }
53
54 static inline int buf_check_overflow(struct cbuf *buf)
55 {
56         return buf->p > buf->ep;
57 }
58
59 static inline int buf_check_size(struct cbuf *buf, int len)
60 {
61         if (buf->p+len > buf->ep) {
62                 if (buf->p < buf->ep) {
63                         eprintk(KERN_ERR, "buffer overflow\n");
64                         buf->p = buf->ep + 1;
65                         return 0;
66                 }
67         }
68
69         return 1;
70 }
71
72 static inline 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 inline 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 inline 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 inline 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 inline 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 inline void buf_put_stringn(struct cbuf *buf, const char *s, u16 slen)
117 {
118         if (buf_check_size(buf, slen + 2)) {
119                 buf_put_int16(buf, slen);
120                 memcpy(buf->p, s, slen);
121                 buf->p += slen;
122         }
123 }
124
125 static inline void buf_put_string(struct cbuf *buf, const char *s)
126 {
127         buf_put_stringn(buf, s, strlen(s));
128 }
129
130 static inline void buf_put_data(struct cbuf *buf, void *data, u32 datalen)
131 {
132         if (buf_check_size(buf, datalen)) {
133                 memcpy(buf->p, data, datalen);
134                 buf->p += datalen;
135         }
136 }
137
138 static inline u8 buf_get_int8(struct cbuf *buf)
139 {
140         u8 ret = 0;
141
142         if (buf_check_size(buf, 1)) {
143                 ret = buf->p[0];
144                 buf->p++;
145         }
146
147         return ret;
148 }
149
150 static inline u16 buf_get_int16(struct cbuf *buf)
151 {
152         u16 ret = 0;
153
154         if (buf_check_size(buf, 2)) {
155                 ret = le16_to_cpu(*(__le16 *)buf->p);
156                 buf->p += 2;
157         }
158
159         return ret;
160 }
161
162 static inline u32 buf_get_int32(struct cbuf *buf)
163 {
164         u32 ret = 0;
165
166         if (buf_check_size(buf, 4)) {
167                 ret = le32_to_cpu(*(__le32 *)buf->p);
168                 buf->p += 4;
169         }
170
171         return ret;
172 }
173
174 static inline u64 buf_get_int64(struct cbuf *buf)
175 {
176         u64 ret = 0;
177
178         if (buf_check_size(buf, 8)) {
179                 ret = le64_to_cpu(*(__le64 *)buf->p);
180                 buf->p += 8;
181         }
182
183         return ret;
184 }
185
186 static inline int
187 buf_get_string(struct cbuf *buf, char *data, unsigned int datalen)
188 {
189         u16 len = 0;
190
191         len = buf_get_int16(buf);
192         if (!buf_check_overflow(buf) && buf_check_size(buf, len) && len+1>datalen) {
193                 memcpy(data, buf->p, len);
194                 data[len] = 0;
195                 buf->p += len;
196                 len++;
197         }
198
199         return len;
200 }
201
202 static inline char *buf_get_stringb(struct cbuf *buf, struct cbuf *sbuf)
203 {
204         char *ret;
205         u16 len;
206
207         ret = NULL;
208         len = buf_get_int16(buf);
209
210         if (!buf_check_overflow(buf) && buf_check_size(buf, len) &&
211                 buf_check_size(sbuf, len + 1)) {
212
213                 memcpy(sbuf->p, buf->p, len);
214                 sbuf->p[len] = 0;
215                 ret = sbuf->p;
216                 buf->p += len;
217                 sbuf->p += len + 1;
218         }
219
220         return ret;
221 }
222
223 static inline int buf_get_data(struct cbuf *buf, void *data, int datalen)
224 {
225         int ret = 0;
226
227         if (buf_check_size(buf, datalen)) {
228                 memcpy(data, buf->p, datalen);
229                 buf->p += datalen;
230                 ret = datalen;
231         }
232
233         return ret;
234 }
235
236 static inline void *buf_get_datab(struct cbuf *buf, struct cbuf *dbuf,
237                                   int datalen)
238 {
239         char *ret = NULL;
240         int n = 0;
241
242         if (buf_check_size(dbuf, datalen)) {
243                 n = buf_get_data(buf, dbuf->p, datalen);
244                 if (n > 0) {
245                         ret = dbuf->p;
246                         dbuf->p += n;
247                 }
248         }
249
250         return ret;
251 }
252
253 /**
254  * v9fs_size_stat - calculate the size of a variable length stat struct
255  * @stat: metadata (stat) structure
256  * @extended: non-zero if 9P2000.u
257  *
258  */
259
260 static int v9fs_size_stat(struct v9fs_stat *stat, int extended)
261 {
262         int size = 0;
263
264         if (stat == NULL) {
265                 eprintk(KERN_ERR, "v9fs_size_stat: got a NULL stat pointer\n");
266                 return 0;
267         }
268
269         size =                  /* 2 + *//* size[2] */
270             2 +                 /* type[2] */
271             4 +                 /* dev[4] */
272             1 +                 /* qid.type[1] */
273             4 +                 /* qid.vers[4] */
274             8 +                 /* qid.path[8] */
275             4 +                 /* mode[4] */
276             4 +                 /* atime[4] */
277             4 +                 /* mtime[4] */
278             8 +                 /* length[8] */
279             8;                  /* minimum sum of string lengths */
280
281         if (stat->name)
282                 size += strlen(stat->name);
283         if (stat->uid)
284                 size += strlen(stat->uid);
285         if (stat->gid)
286                 size += strlen(stat->gid);
287         if (stat->muid)
288                 size += strlen(stat->muid);
289
290         if (extended) {
291                 size += 4 +     /* n_uid[4] */
292                     4 +         /* n_gid[4] */
293                     4 +         /* n_muid[4] */
294                     2;          /* string length of extension[4] */
295                 if (stat->extension)
296                         size += strlen(stat->extension);
297         }
298
299         return size;
300 }
301
302 /**
303  * serialize_stat - safely format a stat structure for transmission
304  * @stat: metadata (stat) structure
305  * @bufp: buffer to serialize structure into
306  * @extended: non-zero if 9P2000.u
307  *
308  */
309
310 static int
311 serialize_stat(struct v9fs_stat *stat, struct cbuf *bufp, int extended)
312 {
313         buf_put_int16(bufp, stat->size);
314         buf_put_int16(bufp, stat->type);
315         buf_put_int32(bufp, stat->dev);
316         buf_put_int8(bufp, stat->qid.type);
317         buf_put_int32(bufp, stat->qid.version);
318         buf_put_int64(bufp, stat->qid.path);
319         buf_put_int32(bufp, stat->mode);
320         buf_put_int32(bufp, stat->atime);
321         buf_put_int32(bufp, stat->mtime);
322         buf_put_int64(bufp, stat->length);
323
324         buf_put_string(bufp, stat->name);
325         buf_put_string(bufp, stat->uid);
326         buf_put_string(bufp, stat->gid);
327         buf_put_string(bufp, stat->muid);
328
329         if (extended) {
330                 buf_put_string(bufp, stat->extension);
331                 buf_put_int32(bufp, stat->n_uid);
332                 buf_put_int32(bufp, stat->n_gid);
333                 buf_put_int32(bufp, stat->n_muid);
334         }
335
336         if (buf_check_overflow(bufp))
337                 return 0;
338
339         return stat->size;
340 }
341
342 /**
343  * deserialize_stat - safely decode a recieved metadata (stat) structure
344  * @bufp: buffer to deserialize
345  * @stat: metadata (stat) structure
346  * @dbufp: buffer to deserialize variable strings into
347  * @extended: non-zero if 9P2000.u
348  *
349  */
350
351 static inline int
352 deserialize_stat(struct cbuf *bufp, struct v9fs_stat *stat,
353                  struct cbuf *dbufp, int extended)
354 {
355
356         stat->size = buf_get_int16(bufp);
357         stat->type = buf_get_int16(bufp);
358         stat->dev = buf_get_int32(bufp);
359         stat->qid.type = buf_get_int8(bufp);
360         stat->qid.version = buf_get_int32(bufp);
361         stat->qid.path = buf_get_int64(bufp);
362         stat->mode = buf_get_int32(bufp);
363         stat->atime = buf_get_int32(bufp);
364         stat->mtime = buf_get_int32(bufp);
365         stat->length = buf_get_int64(bufp);
366         stat->name = buf_get_stringb(bufp, dbufp);
367         stat->uid = buf_get_stringb(bufp, dbufp);
368         stat->gid = buf_get_stringb(bufp, dbufp);
369         stat->muid = buf_get_stringb(bufp, dbufp);
370
371         if (extended) {
372                 stat->extension = buf_get_stringb(bufp, dbufp);
373                 stat->n_uid = buf_get_int32(bufp);
374                 stat->n_gid = buf_get_int32(bufp);
375                 stat->n_muid = buf_get_int32(bufp);
376         }
377
378         if (buf_check_overflow(bufp) || buf_check_overflow(dbufp))
379                 return 0;
380
381         return stat->size + 2;
382 }
383
384 /**
385  * deserialize_statb - wrapper for decoding a received metadata structure
386  * @bufp: buffer to deserialize
387  * @dbufp: buffer to deserialize variable strings into
388  * @extended: non-zero if 9P2000.u
389  *
390  */
391
392 static inline struct v9fs_stat *deserialize_statb(struct cbuf *bufp,
393                                                   struct cbuf *dbufp,
394                                                   int extended)
395 {
396         struct v9fs_stat *ret = buf_alloc(dbufp, sizeof(struct v9fs_stat));
397
398         if (ret) {
399                 int n = deserialize_stat(bufp, ret, dbufp, extended);
400                 if (n <= 0)
401                         return NULL;
402         }
403
404         return ret;
405 }
406
407 /**
408  * v9fs_deserialize_stat - decode a received metadata structure
409  * @buf: buffer to deserialize
410  * @buflen: length of received buffer
411  * @stat: metadata structure to decode into
412  * @statlen: length of destination metadata structure
413  * @extended: non-zero if 9P2000.u
414  *
415  */
416
417 int v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
418                           u32 statlen, int extended)
419 {
420         struct cbuf buffer;
421         struct cbuf *bufp = &buffer;
422         struct cbuf dbuffer;
423         struct cbuf *dbufp = &dbuffer;
424
425         buf_init(bufp, buf, buflen);
426         buf_init(dbufp, (char *)stat + sizeof(struct v9fs_stat),
427                  statlen - sizeof(struct v9fs_stat));
428
429         return deserialize_stat(bufp, stat, dbufp, extended);
430 }
431
432 static inline int v9fs_size_fcall(struct v9fs_fcall *fcall, int extended)
433 {
434         int size = 4 + 1 + 2;   /* size[4] msg[1] tag[2] */
435         int i = 0;
436
437         switch (fcall->id) {
438         default:
439                 eprintk(KERN_ERR, "bad msg type %d\n", fcall->id);
440                 return 0;
441         case TVERSION:          /* msize[4] version[s] */
442                 size += 4 + 2 + strlen(fcall->params.tversion.version);
443                 break;
444         case TAUTH:             /* afid[4] uname[s] aname[s] */
445                 size += 4 + 2 + strlen(fcall->params.tauth.uname) +
446                     2 + strlen(fcall->params.tauth.aname);
447                 break;
448         case TFLUSH:            /* oldtag[2] */
449                 size += 2;
450                 break;
451         case TATTACH:           /* fid[4] afid[4] uname[s] aname[s] */
452                 size += 4 + 4 + 2 + strlen(fcall->params.tattach.uname) +
453                     2 + strlen(fcall->params.tattach.aname);
454                 break;
455         case TWALK:             /* fid[4] newfid[4] nwname[2] nwname*(wname[s]) */
456                 size += 4 + 4 + 2;
457                 /* now compute total for the array of names */
458                 for (i = 0; i < fcall->params.twalk.nwname; i++)
459                         size += 2 + strlen(fcall->params.twalk.wnames[i]);
460                 break;
461         case TOPEN:             /* fid[4] mode[1] */
462                 size += 4 + 1;
463                 break;
464         case TCREATE:           /* fid[4] name[s] perm[4] mode[1] */
465                 size += 4 + 2 + strlen(fcall->params.tcreate.name) + 4 + 1;
466                 break;
467         case TREAD:             /* fid[4] offset[8] count[4] */
468                 size += 4 + 8 + 4;
469                 break;
470         case TWRITE:            /* fid[4] offset[8] count[4] data[count] */
471                 size += 4 + 8 + 4 + fcall->params.twrite.count;
472                 break;
473         case TCLUNK:            /* fid[4] */
474                 size += 4;
475                 break;
476         case TREMOVE:           /* fid[4] */
477                 size += 4;
478                 break;
479         case TSTAT:             /* fid[4] */
480                 size += 4;
481                 break;
482         case TWSTAT:            /* fid[4] stat[n] */
483                 fcall->params.twstat.stat->size =
484                     v9fs_size_stat(fcall->params.twstat.stat, extended);
485                 size += 4 + 2 + 2 + fcall->params.twstat.stat->size;
486         }
487         return size;
488 }
489
490 /*
491  * v9fs_serialize_fcall - marshall fcall struct into a packet
492  * @fcall: structure to convert
493  * @data: buffer to serialize fcall into
494  * @datalen: length of buffer to serialize fcall into
495  * @extended: non-zero if 9P2000.u
496  *
497  */
498
499 int
500 v9fs_serialize_fcall(struct v9fs_fcall *fcall, void *data, u32 datalen,
501                      int extended)
502 {
503         int i = 0;
504         struct v9fs_stat *stat = NULL;
505         struct cbuf buffer;
506         struct cbuf *bufp = &buffer;
507
508         buf_init(bufp, data, datalen);
509
510         if (!fcall) {
511                 eprintk(KERN_ERR, "no fcall\n");
512                 return -EINVAL;
513         }
514
515         fcall->size = v9fs_size_fcall(fcall, extended);
516
517         buf_put_int32(bufp, fcall->size);
518         buf_put_int8(bufp, fcall->id);
519         buf_put_int16(bufp, fcall->tag);
520
521         dprintk(DEBUG_CONV, "size %d id %d tag %d\n", fcall->size, fcall->id,
522                 fcall->tag);
523
524         /* now encode it */
525         switch (fcall->id) {
526         default:
527                 eprintk(KERN_ERR, "bad msg type: %d\n", fcall->id);
528                 return -EPROTO;
529         case TVERSION:
530                 buf_put_int32(bufp, fcall->params.tversion.msize);
531                 buf_put_string(bufp, fcall->params.tversion.version);
532                 break;
533         case TAUTH:
534                 buf_put_int32(bufp, fcall->params.tauth.afid);
535                 buf_put_string(bufp, fcall->params.tauth.uname);
536                 buf_put_string(bufp, fcall->params.tauth.aname);
537                 break;
538         case TFLUSH:
539                 buf_put_int16(bufp, fcall->params.tflush.oldtag);
540                 break;
541         case TATTACH:
542                 buf_put_int32(bufp, fcall->params.tattach.fid);
543                 buf_put_int32(bufp, fcall->params.tattach.afid);
544                 buf_put_string(bufp, fcall->params.tattach.uname);
545                 buf_put_string(bufp, fcall->params.tattach.aname);
546                 break;
547         case TWALK:
548                 buf_put_int32(bufp, fcall->params.twalk.fid);
549                 buf_put_int32(bufp, fcall->params.twalk.newfid);
550                 buf_put_int16(bufp, fcall->params.twalk.nwname);
551                 for (i = 0; i < fcall->params.twalk.nwname; i++)
552                         buf_put_string(bufp, fcall->params.twalk.wnames[i]);
553                 break;
554         case TOPEN:
555                 buf_put_int32(bufp, fcall->params.topen.fid);
556                 buf_put_int8(bufp, fcall->params.topen.mode);
557                 break;
558         case TCREATE:
559                 buf_put_int32(bufp, fcall->params.tcreate.fid);
560                 buf_put_string(bufp, fcall->params.tcreate.name);
561                 buf_put_int32(bufp, fcall->params.tcreate.perm);
562                 buf_put_int8(bufp, fcall->params.tcreate.mode);
563                 break;
564         case TREAD:
565                 buf_put_int32(bufp, fcall->params.tread.fid);
566                 buf_put_int64(bufp, fcall->params.tread.offset);
567                 buf_put_int32(bufp, fcall->params.tread.count);
568                 break;
569         case TWRITE:
570                 buf_put_int32(bufp, fcall->params.twrite.fid);
571                 buf_put_int64(bufp, fcall->params.twrite.offset);
572                 buf_put_int32(bufp, fcall->params.twrite.count);
573                 buf_put_data(bufp, fcall->params.twrite.data,
574                              fcall->params.twrite.count);
575                 break;
576         case TCLUNK:
577                 buf_put_int32(bufp, fcall->params.tclunk.fid);
578                 break;
579         case TREMOVE:
580                 buf_put_int32(bufp, fcall->params.tremove.fid);
581                 break;
582         case TSTAT:
583                 buf_put_int32(bufp, fcall->params.tstat.fid);
584                 break;
585         case TWSTAT:
586                 buf_put_int32(bufp, fcall->params.twstat.fid);
587                 stat = fcall->params.twstat.stat;
588
589                 buf_put_int16(bufp, stat->size + 2);
590                 serialize_stat(stat, bufp, extended);
591                 break;
592         }
593
594         if (buf_check_overflow(bufp)) {
595                 dprintk(DEBUG_ERROR, "buffer overflow\n");
596                 return -EIO;
597         }
598
599         return fcall->size;
600 }
601
602 /**
603  * deserialize_fcall - unmarshal a response
604  * @buf: recieved buffer
605  * @buflen: length of received buffer
606  * @rcall: fcall structure to populate
607  * @rcalllen: length of fcall structure to populate
608  * @extended: non-zero if 9P2000.u
609  *
610  */
611
612 int
613 v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
614                        int rcalllen, int extended)
615 {
616
617         struct cbuf buffer;
618         struct cbuf *bufp = &buffer;
619         struct cbuf dbuffer;
620         struct cbuf *dbufp = &dbuffer;
621         int i = 0;
622
623         buf_init(bufp, buf, buflen);
624         buf_init(dbufp, (char *)rcall + sizeof(struct v9fs_fcall),
625                  rcalllen - sizeof(struct v9fs_fcall));
626
627         rcall->size = buf_get_int32(bufp);
628         rcall->id = buf_get_int8(bufp);
629         rcall->tag = buf_get_int16(bufp);
630
631         dprintk(DEBUG_CONV, "size %d id %d tag %d\n", rcall->size, rcall->id,
632                 rcall->tag);
633         switch (rcall->id) {
634         default:
635                 eprintk(KERN_ERR, "unknown message type: %d\n", rcall->id);
636                 return -EPROTO;
637         case RVERSION:
638                 rcall->params.rversion.msize = buf_get_int32(bufp);
639                 rcall->params.rversion.version = buf_get_stringb(bufp, dbufp);
640                 break;
641         case RFLUSH:
642                 break;
643         case RATTACH:
644                 rcall->params.rattach.qid.type = buf_get_int8(bufp);
645                 rcall->params.rattach.qid.version = buf_get_int32(bufp);
646                 rcall->params.rattach.qid.path = buf_get_int64(bufp);
647                 break;
648         case RWALK:
649                 rcall->params.rwalk.nwqid = buf_get_int16(bufp);
650                 if (rcall->params.rwalk.nwqid > 16) {
651                         eprintk(KERN_ERR, "Rwalk with more than 16 qids: %d\n",
652                                 rcall->params.rwalk.nwqid);
653                         return -EPROTO;
654                 }
655
656                 rcall->params.rwalk.wqids = buf_alloc(dbufp,
657                       rcall->params.rwalk.nwqid * sizeof(struct v9fs_qid));
658                 if (rcall->params.rwalk.wqids)
659                         for (i = 0; i < rcall->params.rwalk.nwqid; i++) {
660                                 rcall->params.rwalk.wqids[i].type =
661                                     buf_get_int8(bufp);
662                                 rcall->params.rwalk.wqids[i].version =
663                                     buf_get_int16(bufp);
664                                 rcall->params.rwalk.wqids[i].path =
665                                     buf_get_int64(bufp);
666                         }
667                 break;
668         case ROPEN:
669                 rcall->params.ropen.qid.type = buf_get_int8(bufp);
670                 rcall->params.ropen.qid.version = buf_get_int32(bufp);
671                 rcall->params.ropen.qid.path = buf_get_int64(bufp);
672                 rcall->params.ropen.iounit = buf_get_int32(bufp);
673                 break;
674         case RCREATE:
675                 rcall->params.rcreate.qid.type = buf_get_int8(bufp);
676                 rcall->params.rcreate.qid.version = buf_get_int32(bufp);
677                 rcall->params.rcreate.qid.path = buf_get_int64(bufp);
678                 rcall->params.rcreate.iounit = buf_get_int32(bufp);
679                 break;
680         case RREAD:
681                 rcall->params.rread.count = buf_get_int32(bufp);
682                 rcall->params.rread.data = buf_get_datab(bufp, dbufp,
683                         rcall->params.rread.count);
684                 break;
685         case RWRITE:
686                 rcall->params.rwrite.count = buf_get_int32(bufp);
687                 break;
688         case RCLUNK:
689                 break;
690         case RREMOVE:
691                 break;
692         case RSTAT:
693                 buf_get_int16(bufp);
694                 rcall->params.rstat.stat =
695                     deserialize_statb(bufp, dbufp, extended);
696                 break;
697         case RWSTAT:
698                 break;
699         case RERROR:
700                 rcall->params.rerror.error = buf_get_stringb(bufp, dbufp);
701                 if (extended)
702                         rcall->params.rerror.errno = buf_get_int16(bufp);
703                 break;
704         }
705
706         if (buf_check_overflow(bufp) || buf_check_overflow(dbufp)) {
707                 dprintk(DEBUG_ERROR, "buffer overflow\n");
708                 return -EIO;
709         }
710
711         return rcall->size;
712 }