OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rtems-20020807/] [cpukit/] [librpc/] [include/] [rpcsvc/] [nfs_prot.x] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1026 ivang
/*
2
 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
3
 * unrestricted use provided that this legend is included on all tape
4
 * media and as a part of the software program in whole or part.  Users
5
 * may copy or modify Sun RPC without charge, but are not authorized
6
 * to license or distribute it to anyone else except as part of a product or
7
 * program developed by the user.
8
 *
9
 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
10
 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
11
 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
12
 *
13
 * Sun RPC is provided with no support and without any obligation on the
14
 * part of Sun Microsystems, Inc. to assist in its use, correction,
15
 * modification or enhancement.
16
 *
17
 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
18
 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
19
 * OR ANY PART THEREOF.
20
 *
21
 * In no event will Sun Microsystems, Inc. be liable for any lost revenue
22
 * or profits or other special, indirect and consequential damages, even if
23
 * Sun has been advised of the possibility of such damages.
24
 *
25
 * Sun Microsystems, Inc.
26
 * 2550 Garcia Avenue
27
 * Mountain View, California  94043
28
 */
29
 
30
#ifndef RPC_HDR
31
%#ifndef lint
32
%/*static char sccsid[] = "from: @(#)nfs_prot.x 1.2 87/10/12 Copyr 1987 Sun Micro";*/
33
%/*static char sccsid[] = "from: @(#)nfs_prot.x 2.1 88/08/01 4.0 RPCSRC";*/
34
%static const char rcsid[] =
35
%  "$FreeBSD: src/include/rpcsvc/nfs_prot.x,v 1.7 1999/08/27 23:45:08 peter Exp $";
36
%#endif /* not lint */
37
#endif
38
 
39
const NFS_PORT          = 2049;
40
const NFS_MAXDATA       = 8192;
41
const NFS_MAXPATHLEN    = 1024;
42
const NFS_MAXNAMLEN     = 255;
43
const NFS_FHSIZE        = 32;
44
const NFS_COOKIESIZE    = 4;
45
const NFS_FIFO_DEV      = -1;   /* size kludge for named pipes */
46
 
47
/*
48
 * File types
49
 */
50
const NFSMODE_FMT  = 0170000;   /* type of file */
51
const NFSMODE_DIR  = 0040000;   /* directory */
52
const NFSMODE_CHR  = 0020000;   /* character special */
53
const NFSMODE_BLK  = 0060000;   /* block special */
54
const NFSMODE_REG  = 0100000;   /* regular */
55
const NFSMODE_LNK  = 0120000;   /* symbolic link */
56
const NFSMODE_SOCK = 0140000;   /* socket */
57
const NFSMODE_FIFO = 0010000;   /* fifo */
58
 
59
/*
60
 * Error status
61
 */
62
enum nfsstat {
63
        NFS_OK= 0,              /* no error */
64
        NFSERR_PERM=1,          /* Not owner */
65
        NFSERR_NOENT=2,         /* No such file or directory */
66
        NFSERR_IO=5,            /* I/O error */
67
        NFSERR_NXIO=6,          /* No such device or address */
68
        NFSERR_ACCES=13,        /* Permission denied */
69
        NFSERR_EXIST=17,        /* File exists */
70
        NFSERR_NODEV=19,        /* No such device */
71
        NFSERR_NOTDIR=20,       /* Not a directory*/
72
        NFSERR_ISDIR=21,        /* Is a directory */
73
        NFSERR_FBIG=27,         /* File too large */
74
        NFSERR_NOSPC=28,        /* No space left on device */
75
        NFSERR_ROFS=30,         /* Read-only file system */
76
        NFSERR_NAMETOOLONG=63,  /* File name too long */
77
        NFSERR_NOTEMPTY=66,     /* Directory not empty */
78
        NFSERR_DQUOT=69,        /* Disc quota exceeded */
79
        NFSERR_STALE=70,        /* Stale NFS file handle */
80
        NFSERR_WFLUSH=99        /* write cache flushed */
81
};
82
 
83
/*
84
 * File types
85
 */
86
enum ftype {
87
        NFNON = 0,      /* non-file */
88
        NFREG = 1,      /* regular file */
89
        NFDIR = 2,      /* directory */
90
        NFBLK = 3,      /* block special */
91
        NFCHR = 4,      /* character special */
92
        NFLNK = 5,      /* symbolic link */
93
        NFSOCK = 6,     /* unix domain sockets */
94
        NFBAD = 7,      /* unused */
95
        NFFIFO = 8      /* named pipe */
96
};
97
 
98
/*
99
 * File access handle
100
 */
101
struct nfs_fh {
102
        opaque data[NFS_FHSIZE];
103
};
104
 
105
/*
106
 * Timeval
107
 */
108
struct nfstime {
109
        unsigned seconds;
110
        unsigned useconds;
111
};
112
 
113
 
114
/*
115
 * File attributes
116
 */
117
struct fattr {
118
        ftype type;             /* file type */
119
        unsigned mode;          /* protection mode bits */
120
        unsigned nlink;         /* # hard links */
121
        unsigned uid;           /* owner user id */
122
        unsigned gid;           /* owner group id */
123
        unsigned size;          /* file size in bytes */
124
        unsigned blocksize;     /* prefered block size */
125
        unsigned rdev;          /* special device # */
126
        unsigned blocks;        /* Kb of disk used by file */
127
        unsigned fsid;          /* device # */
128
        unsigned fileid;        /* inode # */
129
        nfstime atime;          /* time of last access */
130
        nfstime mtime;          /* time of last modification */
131
        nfstime ctime;          /* time of last change */
132
};
133
 
134
/*
135
 * File attributes which can be set
136
 */
137
struct sattr {
138
        unsigned mode;  /* protection mode bits */
139
        unsigned uid;   /* owner user id */
140
        unsigned gid;   /* owner group id */
141
        unsigned size;  /* file size in bytes */
142
        nfstime atime;  /* time of last access */
143
        nfstime mtime;  /* time of last modification */
144
};
145
 
146
 
147
typedef string filename;
148
typedef string nfspath;
149
 
150
/*
151
 * Reply status with file attributes
152
 */
153
union attrstat switch (nfsstat status) {
154
case NFS_OK:
155
        fattr attributes;
156
default:
157
        void;
158
};
159
 
160
struct sattrargs {
161
        nfs_fh file;
162
        sattr attributes;
163
};
164
 
165
/*
166
 * Arguments for directory operations
167
 */
168
struct diropargs {
169
        nfs_fh  dir;    /* directory file handle */
170
        filename name;          /* name (up to NFS_MAXNAMLEN bytes) */
171
};
172
 
173
struct diropokres {
174
        nfs_fh file;
175
        fattr attributes;
176
};
177
 
178
/*
179
 * Results from directory operation
180
 */
181
union diropres switch (nfsstat status) {
182
case NFS_OK:
183
        diropokres diropres;
184
default:
185
        void;
186
};
187
 
188
union readlinkres switch (nfsstat status) {
189
case NFS_OK:
190
        nfspath data;
191
default:
192
        void;
193
};
194
 
195
/*
196
 * Arguments to remote read
197
 */
198
struct readargs {
199
        nfs_fh file;            /* handle for file */
200
        unsigned offset;        /* byte offset in file */
201
        unsigned count;         /* immediate read count */
202
        unsigned totalcount;    /* total read count (from this offset)*/
203
};
204
 
205
/*
206
 * Status OK portion of remote read reply
207
 */
208
struct readokres {
209
        fattr   attributes;     /* attributes, need for pagin*/
210
        opaque data;
211
};
212
 
213
union readres switch (nfsstat status) {
214
case NFS_OK:
215
        readokres reply;
216
default:
217
        void;
218
};
219
 
220
/*
221
 * Arguments to remote write
222
 */
223
struct writeargs {
224
        nfs_fh  file;           /* handle for file */
225
        unsigned beginoffset;   /* beginning byte offset in file */
226
        unsigned offset;        /* current byte offset in file */
227
        unsigned totalcount;    /* total write count (to this offset)*/
228
        opaque data;
229
};
230
 
231
struct createargs {
232
        diropargs where;
233
        sattr attributes;
234
};
235
 
236
struct renameargs {
237
        diropargs from;
238
        diropargs to;
239
};
240
 
241
struct linkargs {
242
        nfs_fh from;
243
        diropargs to;
244
};
245
 
246
struct symlinkargs {
247
        diropargs from;
248
        nfspath to;
249
        sattr attributes;
250
};
251
 
252
 
253
typedef opaque nfscookie[NFS_COOKIESIZE];
254
 
255
/*
256
 * Arguments to readdir
257
 */
258
struct readdirargs {
259
        nfs_fh dir;             /* directory handle */
260
        nfscookie cookie;
261
        unsigned count;         /* number of directory bytes to read */
262
};
263
 
264
struct entry {
265
        unsigned fileid;
266
        filename name;
267
        nfscookie cookie;
268
        entry *nextentry;
269
};
270
 
271
struct dirlist {
272
        entry *entries;
273
        bool eof;
274
};
275
 
276
union readdirres switch (nfsstat status) {
277
case NFS_OK:
278
        dirlist reply;
279
default:
280
        void;
281
};
282
 
283
struct statfsokres {
284
        unsigned tsize; /* preferred transfer size in bytes */
285
        unsigned bsize; /* fundamental file system block size */
286
        unsigned blocks;        /* total blocks in file system */
287
        unsigned bfree; /* free blocks in fs */
288
        unsigned bavail;        /* free blocks avail to non-superuser */
289
};
290
 
291
union statfsres switch (nfsstat status) {
292
case NFS_OK:
293
        statfsokres reply;
294
default:
295
        void;
296
};
297
 
298
#ifdef WANT_NFS3
299
 
300
/*
301
 * NFSv3 constants and types
302
 */
303
const NFS3_FHSIZE       = 64;   /* maximum size in bytes of a file handle */
304
const NFS3_COOKIEVERFSIZE = 8;  /* size of a cookie verifier for READDIR */
305
const NFS3_CREATEVERFSIZE = 8;  /* size of the verifier used for CREATE */
306
const NFS3_WRITEVERFSIZE = 8;   /* size of the verifier used for WRITE */
307
 
308
typedef unsigned hyper uint64;
309
typedef hyper int64;
310
typedef unsigned long uint32;
311
typedef long int32;
312
typedef string filename3<>;
313
typedef string nfspath3<>;
314
typedef uint64 fileid3;
315
typedef uint64 cookie3;
316
typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
317
typedef opaque createverf3[NFS3_CREATEVERFSIZE];
318
typedef opaque writeverf3[NFS3_WRITEVERFSIZE];
319
typedef uint32 uid3;
320
typedef uint32 gid3;
321
typedef uint64 size3;
322
typedef uint64 offset3;
323
typedef uint32 mode3;
324
typedef uint32 count3;
325
 
326
/*
327
 * Error status (v3)
328
 */
329
enum nfsstat3 {
330
        NFS3_OK = 0,
331
        NFS3ERR_PERM            = 1,
332
        NFS3ERR_NOENT           = 2,
333
        NFS3ERR_IO              = 5,
334
        NFS3ERR_NXIO            = 6,
335
        NFS3ERR_ACCES           = 13,
336
        NFS3ERR_EXIST           = 17,
337
        NFS3ERR_XDEV            = 18,
338
        NFS3ERR_NODEV           = 19,
339
        NFS3ERR_NOTDIR          = 20,
340
        NFS3ERR_ISDIR           = 21,
341
        NFS3ERR_INVAL           = 22,
342
        NFS3ERR_FBIG            = 27,
343
        NFS3ERR_NOSPC           = 28,
344
        NFS3ERR_ROFS            = 30,
345
        NFS3ERR_MLINK           = 31,
346
        NFS3ERR_NAMETOOLONG     = 63,
347
        NFS3ERR_NOTEMPTY        = 66,
348
        NFS3ERR_DQUOT           = 69,
349
        NFS3ERR_STALE           = 70,
350
        NFS3ERR_REMOTE          = 71,
351
        NFS3ERR_BADHANDLE       = 10001,
352
        NFS3ERR_NOT_SYNC        = 10002,
353
        NFS3ERR_BAD_COOKIE      = 10003,
354
        NFS3ERR_NOTSUPP         = 10004,
355
        NFS3ERR_TOOSMALL        = 10005,
356
        NFS3ERR_SERVERFAULT     = 10006,
357
        NFS3ERR_BADTYPE         = 10007,
358
        NFS3ERR_JUKEBOX         = 10008
359
};
360
 
361
/*
362
 * File types (v3)
363
 */
364
enum ftype3 {
365
        NF3REG  = 1,            /* regular file */
366
        NF3DIR  = 2,            /* directory */
367
        NF3BLK  = 3,            /* block special */
368
        NF3CHR  = 4,            /* character special */
369
        NF3LNK  = 5,            /* symbolic link */
370
        NF3SOCK = 6,            /* unix domain sockets */
371
        NF3FIFO = 7             /* named pipe */
372
};
373
 
374
struct specdata3 {
375
        uint32  specdata1;
376
        uint32  specdata2;
377
};
378
 
379
/*
380
 * File access handle (v3)
381
 */
382
struct nfs_fh3 {
383
        opaque data;
384
};
385
 
386
/*
387
 * Timeval (v3)
388
 */
389
struct nfstime3 {
390
        uint32  seconds;
391
        uint32  nseconds;
392
};
393
 
394
 
395
/*
396
 * File attributes (v3)
397
 */
398
struct fattr3 {
399
        ftype3  type;           /* file type */
400
        mode3   mode;           /* protection mode bits */
401
        uint32  nlink;          /* # hard links */
402
        uid3    uid;            /* owner user id */
403
        gid3    gid;            /* owner group id */
404
        size3   size;           /* file size in bytes */
405
        size3   used;           /* prefered block size */
406
        specdata3 rdev;         /* special device # */
407
        uint64 fsid;            /* device # */
408
        fileid3 fileid;         /* inode # */
409
        nfstime3 atime;         /* time of last access */
410
        nfstime3 mtime;         /* time of last modification */
411
        nfstime3 ctime;         /* time of last change */
412
};
413
 
414
union post_op_attr switch (bool attributes_follow) {
415
case TRUE:
416
        fattr3  attributes;
417
case FALSE:
418
        void;
419
};
420
 
421
struct wcc_attr {
422
        size3   size;
423
        nfstime3 mtime;
424
        nfstime3 ctime;
425
};
426
 
427
union pre_op_attr switch (bool attributes_follow) {
428
case TRUE:
429
        wcc_attr attributes;
430
case FALSE:
431
        void;
432
};
433
 
434
struct wcc_data {
435
        pre_op_attr before;
436
        post_op_attr after;
437
};
438
 
439
union post_op_fh3 switch (bool handle_follows) {
440
case TRUE:
441
        nfs_fh3 handle;
442
case FALSE:
443
        void;
444
};
445
 
446
/*
447
 * File attributes which can be set (v3)
448
 */
449
enum time_how {
450
        DONT_CHANGE             = 0,
451
        SET_TO_SERVER_TIME      = 1,
452
        SET_TO_CLIENT_TIME      = 2
453
};
454
 
455
union set_mode3 switch (bool set_it) {
456
case TRUE:
457
        mode3   mode;
458
default:
459
        void;
460
};
461
 
462
union set_uid3 switch (bool set_it) {
463
case TRUE:
464
        uid3    uid;
465
default:
466
        void;
467
};
468
 
469
union set_gid3 switch (bool set_it) {
470
case TRUE:
471
        gid3    gid;
472
default:
473
        void;
474
};
475
 
476
union set_size3 switch (bool set_it) {
477
case TRUE:
478
        size3   size;
479
default:
480
        void;
481
};
482
 
483
union set_atime switch (time_how set_it) {
484
case SET_TO_CLIENT_TIME:
485
        nfstime3        atime;
486
default:
487
        void;
488
};
489
 
490
union set_mtime switch (time_how set_it) {
491
case SET_TO_CLIENT_TIME:
492
        nfstime3        mtime;
493
default:
494
        void;
495
};
496
 
497
struct sattr3 {
498
        set_mode3       mode;
499
        set_uid3        uid;
500
        set_gid3        gid;
501
        set_size3       size;
502
        set_atime       atime;
503
        set_mtime       mtime;
504
};
505
 
506
/*
507
 * Arguments for directory operations (v3)
508
 */
509
struct diropargs3 {
510
        nfs_fh3 dir;            /* directory file handle */
511
        filename3 name;         /* name (up to NFS_MAXNAMLEN bytes) */
512
};
513
 
514
/*
515
 * Arguments to getattr (v3).
516
 */
517
struct GETATTR3args {
518
        nfs_fh3         object;
519
};
520
 
521
struct GETATTR3resok {
522
        fattr3          obj_attributes;
523
};
524
 
525
union GETATTR3res switch (nfsstat3 status) {
526
case NFS3_OK:
527
        GETATTR3resok   resok;
528
default:
529
        void;
530
};
531
 
532
/*
533
 * Arguments to setattr (v3).
534
 */
535
union sattrguard3 switch (bool check) {
536
case TRUE:
537
        nfstime3        obj_ctime;
538
case FALSE:
539
        void;
540
};
541
 
542
struct SETATTR3args {
543
        nfs_fh3         object;
544
        sattr3          new_attributes;
545
        sattrguard3     guard;
546
};
547
 
548
struct SETATTR3resok {
549
        wcc_data        obj_wcc;
550
};
551
 
552
struct SETATTR3resfail {
553
        wcc_data        obj_wcc;
554
};
555
 
556
union SETATTR3res switch (nfsstat3 status) {
557
case NFS3_OK:
558
        SETATTR3resok   resok;
559
default:
560
        SETATTR3resfail resfail;
561
};
562
 
563
/*
564
 * Arguments to lookup (v3).
565
 */
566
struct LOOKUP3args {
567
        diropargs3      what;
568
};
569
 
570
struct LOOKUP3resok {
571
        nfs_fh3         object;
572
        post_op_attr    obj_attributes;
573
        post_op_attr    dir_attributes;
574
};
575
 
576
struct LOOKUP3resfail {
577
        post_op_attr    dir_attributes;
578
};
579
 
580
union LOOKUP3res switch (nfsstat3 status) {
581
case NFS3_OK:
582
        LOOKUP3resok    resok;
583
default:
584
        LOOKUP3resfail  resfail;
585
};
586
 
587
/*
588
 * Arguments to access (v3).
589
 */
590
const ACCESS3_READ      = 0x0001;
591
const ACCESS3_LOOKUP    = 0x0002;
592
const ACCESS3_MODIFY    = 0x0004;
593
const ACCESS3_EXTEND    = 0x0008;
594
const ACCESS3_DELETE    = 0x0010;
595
const ACCESS3_EXECUTE   = 0x0020;
596
 
597
struct ACCESS3args {
598
        nfs_fh3         object;
599
        uint32          access;
600
};
601
 
602
struct ACCESS3resok {
603
        post_op_attr    obj_attributes;
604
        uint32          access;
605
};
606
 
607
struct ACCESS3resfail {
608
        post_op_attr    obj_attributes;
609
};
610
 
611
union ACCESS3res switch (nfsstat3 status) {
612
case NFS3_OK:
613
        ACCESS3resok    resok;
614
default:
615
        ACCESS3resfail  resfail;
616
};
617
 
618
/*
619
 * Arguments to readlink (v3).
620
 */
621
struct READLINK3args {
622
        nfs_fh3         symlink;
623
};
624
 
625
struct READLINK3resok {
626
        post_op_attr    symlink_attributes;
627
        nfspath3        data;
628
};
629
 
630
struct READLINK3resfail {
631
        post_op_attr    symlink_attributes;
632
};
633
 
634
union READLINK3res switch (nfsstat3 status) {
635
case NFS3_OK:
636
        READLINK3resok  resok;
637
default:
638
        READLINK3resfail resfail;
639
};
640
 
641
/*
642
 * Arguments to read (v3).
643
 */
644
struct READ3args {
645
        nfs_fh3         file;
646
        offset3         offset;
647
        count3          count;
648
};
649
 
650
struct READ3resok {
651
        post_op_attr    file_attributes;
652
        count3          count;
653
        bool            eof;
654
        opaque          data<>;
655
};
656
 
657
struct READ3resfail {
658
        post_op_attr    file_attributes;
659
};
660
 
661
/* XXX: solaris 2.6 uses ``nfsstat'' here */
662
union READ3res switch (nfsstat3 status) {
663
case NFS3_OK:
664
        READ3resok      resok;
665
default:
666
        READ3resfail    resfail;
667
};
668
 
669
/*
670
 * Arguments to write (v3).
671
 */
672
enum stable_how {
673
        UNSTABLE        = 0,
674
        DATA_SYNC       = 1,
675
        FILE_SYNC       = 2
676
};
677
 
678
struct WRITE3args {
679
        nfs_fh3         file;
680
        offset3         offset;
681
        count3          count;
682
        stable_how      stable;
683
        opaque          data<>;
684
};
685
 
686
struct WRITE3resok {
687
        wcc_data        file_wcc;
688
        count3          count;
689
        stable_how      committed;
690
        writeverf3      verf;
691
};
692
 
693
struct WRITE3resfail {
694
        wcc_data        file_wcc;
695
};
696
 
697
union WRITE3res switch (nfsstat3 status) {
698
case NFS3_OK:
699
        WRITE3resok     resok;
700
default:
701
        WRITE3resfail   resfail;
702
};
703
 
704
/*
705
 * Arguments to create (v3).
706
 */
707
enum createmode3 {
708
        UNCHECKED       = 0,
709
        GUARDED         = 1,
710
        EXCLUSIVE       = 2
711
};
712
 
713
union createhow3 switch (createmode3 mode) {
714
case UNCHECKED:
715
case GUARDED:
716
        sattr3          obj_attributes;
717
case EXCLUSIVE:
718
        createverf3     verf;
719
};
720
 
721
struct CREATE3args {
722
        diropargs3      where;
723
        createhow3      how;
724
};
725
 
726
struct CREATE3resok {
727
        post_op_fh3     obj;
728
        post_op_attr    obj_attributes;
729
        wcc_data        dir_wcc;
730
};
731
 
732
struct CREATE3resfail {
733
        wcc_data        dir_wcc;
734
};
735
 
736
union CREATE3res switch (nfsstat3 status) {
737
case NFS3_OK:
738
        CREATE3resok    resok;
739
default:
740
        CREATE3resfail  resfail;
741
};
742
 
743
/*
744
 * Arguments to mkdir (v3).
745
 */
746
struct MKDIR3args {
747
        diropargs3      where;
748
        sattr3          attributes;
749
};
750
 
751
struct MKDIR3resok {
752
        post_op_fh3     obj;
753
        post_op_attr    obj_attributes;
754
        wcc_data        dir_wcc;
755
};
756
 
757
struct MKDIR3resfail {
758
        wcc_data        dir_wcc;
759
};
760
 
761
union MKDIR3res switch (nfsstat3 status) {
762
case NFS3_OK:
763
        MKDIR3resok     resok;
764
default:
765
        MKDIR3resfail   resfail;
766
};
767
 
768
/*
769
 * Arguments to symlink (v3).
770
 */
771
struct symlinkdata3 {
772
        sattr3          symlink_attributes;
773
        nfspath3        symlink_data;
774
};
775
 
776
struct SYMLINK3args {
777
        diropargs3      where;
778
        symlinkdata3    symlink;
779
};
780
 
781
struct SYMLINK3resok {
782
        post_op_fh3     obj;
783
        post_op_attr    obj_attributes;
784
        wcc_data        dir_wcc;
785
};
786
 
787
struct SYMLINK3resfail {
788
        wcc_data        dir_wcc;
789
};
790
 
791
union SYMLINK3res switch (nfsstat3 status) {
792
case NFS3_OK:
793
        SYMLINK3resok   resok;
794
default:
795
        SYMLINK3resfail resfail;
796
};
797
 
798
/*
799
 * Arguments to mknod (v3).
800
 */
801
struct devicedata3 {
802
        sattr3          dev_attributes;
803
        specdata3       spec;
804
};
805
 
806
union mknoddata3 switch (ftype3 type) {
807
case NF3CHR:
808
case NF3BLK:
809
        devicedata3     device;
810
case NF3SOCK:
811
case NF3FIFO:
812
        sattr3          pipe_attributes;
813
default:
814
        void;
815
};
816
 
817
struct MKNOD3args {
818
        diropargs3      where;
819
        mknoddata3      what;
820
};
821
 
822
struct MKNOD3resok {
823
        post_op_fh3     obj;
824
        post_op_attr    obj_attributes;
825
        wcc_data        dir_wcc;
826
};
827
 
828
struct MKNOD3resfail {
829
        wcc_data        dir_wcc;
830
};
831
 
832
union MKNOD3res switch (nfsstat3 status) {
833
case NFS3_OK:
834
        MKNOD3resok     resok;
835
default:
836
        MKNOD3resfail   resfail;
837
};
838
 
839
/*
840
 * Arguments to remove (v3).
841
 */
842
struct REMOVE3args {
843
        diropargs3      object;
844
};
845
 
846
struct REMOVE3resok {
847
        wcc_data        dir_wcc;
848
};
849
 
850
struct REMOVE3resfail {
851
        wcc_data        dir_wcc;
852
};
853
 
854
union REMOVE3res switch (nfsstat3 status) {
855
case NFS3_OK:
856
        REMOVE3resok    resok;
857
default:
858
        REMOVE3resfail  resfail;
859
};
860
 
861
/*
862
 * Arguments to rmdir (v3).
863
 */
864
struct RMDIR3args {
865
        diropargs3      object;
866
};
867
 
868
struct RMDIR3resok {
869
        wcc_data        dir_wcc;
870
};
871
 
872
struct RMDIR3resfail {
873
        wcc_data        dir_wcc;
874
};
875
 
876
union RMDIR3res switch (nfsstat3 status) {
877
case NFS3_OK:
878
        RMDIR3resok     resok;
879
default:
880
        RMDIR3resfail   resfail;
881
};
882
 
883
/*
884
 * Arguments to rename (v3).
885
 */
886
struct RENAME3args {
887
        diropargs3      from;
888
        diropargs3      to;
889
};
890
 
891
struct RENAME3resok {
892
        wcc_data        fromdir_wcc;
893
        wcc_data        todir_wcc;
894
};
895
 
896
struct RENAME3resfail {
897
        wcc_data        fromdir_wcc;
898
        wcc_data        todir_wcc;
899
};
900
 
901
union RENAME3res switch (nfsstat3 status) {
902
case NFS3_OK:
903
        RENAME3resok    resok;
904
default:
905
        RENAME3resfail  resfail;
906
};
907
 
908
/*
909
 * Arguments to link (v3).
910
 */
911
struct LINK3args {
912
        nfs_fh3         file;
913
        diropargs3      link;
914
};
915
 
916
struct LINK3resok {
917
        post_op_attr    file_attributes;
918
        wcc_data        linkdir_wcc;
919
};
920
 
921
struct LINK3resfail {
922
        post_op_attr    file_attributes;
923
        wcc_data        linkdir_wcc;
924
};
925
 
926
union LINK3res switch (nfsstat3 status) {
927
case NFS3_OK:
928
        LINK3resok      resok;
929
default:
930
        LINK3resfail    resfail;
931
};
932
 
933
/*
934
 * Arguments to readdir (v3).
935
 */
936
struct READDIR3args {
937
        nfs_fh3         dir;
938
        cookie3         cookie;
939
        cookieverf3     cookieverf;
940
        count3          count;
941
};
942
 
943
struct entry3 {
944
        fileid3         fileid;
945
        filename3       name;
946
        cookie3         cookie;
947
        entry3          *nextentry;
948
};
949
 
950
struct dirlist3 {
951
        entry3          *entries;
952
        bool            eof;
953
};
954
 
955
struct READDIR3resok {
956
        post_op_attr    dir_attributes;
957
        cookieverf3     cookieverf;
958
        dirlist3        reply;
959
};
960
 
961
struct READDIR3resfail {
962
        post_op_attr    dir_attributes;
963
};
964
 
965
union READDIR3res switch (nfsstat3 status) {
966
case NFS3_OK:
967
        READDIR3resok   resok;
968
default:
969
        READDIR3resfail resfail;
970
};
971
 
972
/*
973
 * Arguments to readdirplus (v3).
974
 */
975
struct READDIRPLUS3args {
976
        nfs_fh3         dir;
977
        cookie3         cookie;
978
        cookieverf3     cookieverf;
979
        count3          dircount;
980
        count3          maxcount;
981
};
982
 
983
struct entryplus3 {
984
        fileid3         fileid;
985
        filename3       name;
986
        cookie3         cookie;
987
        post_op_attr    name_attributes;
988
        post_op_fh3     name_handle;
989
        entryplus3      *nextentry;
990
};
991
 
992
struct dirlistplus3 {
993
        entryplus3      *entries;
994
        bool            eof;
995
};
996
 
997
struct READDIRPLUS3resok {
998
        post_op_attr    dir_attributes;
999
        cookieverf3     cookieverf;
1000
        dirlistplus3    reply;
1001
};
1002
 
1003
struct READDIRPLUS3resfail {
1004
        post_op_attr    dir_attributes;
1005
};
1006
 
1007
union READDIRPLUS3res switch (nfsstat3 status) {
1008
case NFS3_OK:
1009
        READDIRPLUS3resok       resok;
1010
default:
1011
        READDIRPLUS3resfail     resfail;
1012
};
1013
 
1014
/*
1015
 * Arguments to fsstat (v3).
1016
 */
1017
struct FSSTAT3args {
1018
        nfs_fh3         fsroot;
1019
};
1020
 
1021
struct FSSTAT3resok {
1022
        post_op_attr    obj_attributes;
1023
        size3           tbytes;
1024
        size3           fbytes;
1025
        size3           abytes;
1026
        size3           tfiles;
1027
        size3           ffiles;
1028
        size3           afiles;
1029
        uint32          invarsec;
1030
};
1031
 
1032
struct FSSTAT3resfail {
1033
        post_op_attr    obj_attributes;
1034
};
1035
 
1036
union FSSTAT3res switch (nfsstat3 status) {
1037
case NFS3_OK:
1038
        FSSTAT3resok    resok;
1039
default:
1040
        FSSTAT3resfail  resfail;
1041
};
1042
 
1043
/*
1044
 * Arguments to fsinfo (v3).
1045
 */
1046
const FSF3_LINK         = 0x0001;
1047
const FSF3_SYMLINK      = 0x0002;
1048
const FSF3_HOMOGENEOUS  = 0x0008;
1049
const FSF3_CANSETTIME   = 0x0010;
1050
 
1051
struct FSINFO3args {
1052
        nfs_fh3         fsroot;
1053
};
1054
 
1055
struct FSINFO3resok {
1056
        post_op_attr    obj_attributes;
1057
        uint32          rtmax;
1058
        uint32          rtpref;
1059
        uint32          rtmult;
1060
        uint32          wtmax;
1061
        uint32          wtpref;
1062
        uint32          wtmult;
1063
        uint32          dtpref;
1064
        size3           maxfilesize;
1065
        nfstime3        time_delta;
1066
        uint32          properties;
1067
};
1068
 
1069
struct FSINFO3resfail {
1070
        post_op_attr    obj_attributes;
1071
};
1072
 
1073
union FSINFO3res switch (nfsstat3 status) {
1074
case NFS3_OK:
1075
        FSINFO3resok    resok;
1076
default:
1077
        FSINFO3resfail  resfail;
1078
};
1079
 
1080
/*
1081
 * Arguments to pathconf (v3).
1082
 */
1083
struct PATHCONF3args {
1084
        nfs_fh3         object;
1085
};
1086
 
1087
struct PATHCONF3resok {
1088
        post_op_attr    obj_attributes;
1089
        uint32          linkmax;
1090
        uint32          name_max;
1091
        bool            no_trunc;
1092
        bool            chown_restricted;
1093
        bool            case_insensitive;
1094
        bool            case_preserving;
1095
};
1096
 
1097
struct PATHCONF3resfail {
1098
        post_op_attr    obj_attributes;
1099
};
1100
 
1101
union PATHCONF3res switch (nfsstat3 status) {
1102
case NFS3_OK:
1103
        PATHCONF3resok  resok;
1104
default:
1105
        PATHCONF3resfail        resfail;
1106
};
1107
 
1108
/*
1109
 * Arguments to commit (v3).
1110
 */
1111
struct COMMIT3args {
1112
        nfs_fh3         file;
1113
        offset3         offset;
1114
        count3          count;
1115
};
1116
 
1117
struct COMMIT3resok {
1118
        wcc_data        file_wcc;
1119
        writeverf3      verf;
1120
};
1121
 
1122
struct COMMIT3resfail {
1123
        wcc_data        file_wcc;
1124
};
1125
 
1126
union COMMIT3res switch (nfsstat3 status) {
1127
case NFS3_OK:
1128
        COMMIT3resok    resok;
1129
default:
1130
        COMMIT3resfail  resfail;
1131
};
1132
 
1133
#endif /* WANT_NFS3 */
1134
 
1135
/*
1136
 * Remote file service routines
1137
 */
1138
program NFS_PROGRAM {
1139
        version NFS_VERSION {
1140
                void
1141
                NFSPROC_NULL(void) = 0;
1142
 
1143
                attrstat
1144
                NFSPROC_GETATTR(nfs_fh) =       1;
1145
 
1146
                attrstat
1147
                NFSPROC_SETATTR(sattrargs) = 2;
1148
 
1149
                void
1150
                NFSPROC_ROOT(void) = 3;
1151
 
1152
                diropres
1153
                NFSPROC_LOOKUP(diropargs) = 4;
1154
 
1155
                readlinkres
1156
                NFSPROC_READLINK(nfs_fh) = 5;
1157
 
1158
                readres
1159
                NFSPROC_READ(readargs) = 6;
1160
 
1161
                void
1162
                NFSPROC_WRITECACHE(void) = 7;
1163
 
1164
                attrstat
1165
                NFSPROC_WRITE(writeargs) = 8;
1166
 
1167
                diropres
1168
                NFSPROC_CREATE(createargs) = 9;
1169
 
1170
                nfsstat
1171
                NFSPROC_REMOVE(diropargs) = 10;
1172
 
1173
                nfsstat
1174
                NFSPROC_RENAME(renameargs) = 11;
1175
 
1176
                nfsstat
1177
                NFSPROC_LINK(linkargs) = 12;
1178
 
1179
                nfsstat
1180
                NFSPROC_SYMLINK(symlinkargs) = 13;
1181
 
1182
                diropres
1183
                NFSPROC_MKDIR(createargs) = 14;
1184
 
1185
                nfsstat
1186
                NFSPROC_RMDIR(diropargs) = 15;
1187
 
1188
                readdirres
1189
                NFSPROC_READDIR(readdirargs) = 16;
1190
 
1191
                statfsres
1192
                NFSPROC_STATFS(nfs_fh) = 17;
1193
        } = 2;
1194
} = 100003;
1195
#ifdef WANT_NFS3
1196
program NFS3_PROGRAM {
1197
        version NFS_V3 {
1198
                void
1199
                NFSPROC3_NULL(void)                     = 0;
1200
 
1201
                GETATTR3res
1202
                NFSPROC3_GETATTR(GETATTR3args)          = 1;
1203
 
1204
                SETATTR3res
1205
                NFSPROC3_SETATTR(SETATTR3args)          = 2;
1206
 
1207
                LOOKUP3res
1208
                NFSPROC3_LOOKUP(LOOKUP3args)            = 3;
1209
 
1210
                ACCESS3res
1211
                NFSPROC3_ACCESS(ACCESS3args)            = 4;
1212
 
1213
                READLINK3res
1214
                NFSPROC3_READLINK(READLINK3args)        = 5;
1215
 
1216
                READ3res
1217
                NFSPROC3_READ(READ3args)                = 6;
1218
 
1219
                WRITE3res
1220
                NFSPROC3_WRITE(WRITE3args)              = 7;
1221
 
1222
                CREATE3res
1223
                NFSPROC3_CREATE(CREATE3args)            = 8;
1224
 
1225
                MKDIR3res
1226
                NFSPROC3_MKDIR(MKDIR3args)              = 9;
1227
 
1228
                SYMLINK3res
1229
                NFSPROC3_SYMLINK(SYMLINK3args)          = 10;
1230
 
1231
                MKNOD3res
1232
                NFSPROC3_MKNOD(MKNOD3args)              = 11;
1233
 
1234
                REMOVE3res
1235
                NFSPROC3_REMOVE(REMOVE3args)            = 12;
1236
 
1237
                RMDIR3res
1238
                NFSPROC3_RMDIR(RMDIR3args)              = 13;
1239
 
1240
                RENAME3res
1241
                NFSPROC3_RENAME(RENAME3args)            = 14;
1242
 
1243
                LINK3res
1244
                NFSPROC3_LINK(LINK3args)                = 15;
1245
 
1246
                READDIR3res
1247
                NFSPROC3_READDIR(READDIR3args)          = 16;
1248
 
1249
                READDIRPLUS3res
1250
                NFSPROC3_READDIRPLUS(READDIRPLUS3args)  = 17;
1251
 
1252
                FSSTAT3res
1253
                NFSPROC3_FSSTAT(FSSTAT3args)            = 18;
1254
 
1255
                FSINFO3res
1256
                NFSPROC3_FSINFO(FSINFO3args)            = 19;
1257
 
1258
                PATHCONF3res
1259
                NFSPROC3_PATHCONF(PATHCONF3args)        = 20;
1260
 
1261
                COMMIT3res
1262
                NFSPROC3_COMMIT(COMMIT3args)            = 21;
1263
        } = 3;
1264
} = 100003;
1265
#endif
1266
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.