~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfsd/nfsproc.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.14 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.57 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.138 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.193 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * nfsproc2.c   Process version 2 NFS requests.
  3  * linux/fs/nfsd/nfs2proc.c
  4  * 
  5  * Process version 2 NFS requests.
  6  *
  7  * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
  8  */
  9 
 10 #include <linux/linkage.h>
 11 #include <linux/time.h>
 12 #include <linux/errno.h>
 13 #include <linux/fs.h>
 14 #include <linux/stat.h>
 15 #include <linux/fcntl.h>
 16 #include <linux/net.h>
 17 #include <linux/in.h>
 18 #include <linux/namei.h>
 19 #include <linux/unistd.h>
 20 #include <linux/slab.h>
 21 
 22 #include <linux/sunrpc/svc.h>
 23 #include <linux/nfsd/nfsd.h>
 24 #include <linux/nfsd/cache.h>
 25 #include <linux/nfsd/xdr.h>
 26 
 27 typedef struct svc_rqst svc_rqst;
 28 typedef struct svc_buf  svc_buf;
 29 
 30 #define NFSDDBG_FACILITY                NFSDDBG_PROC
 31 
 32 
 33 static int
 34 nfsd_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
 35 {
 36         return nfs_ok;
 37 }
 38 
 39 /*
 40  * Get a file's attributes
 41  * N.B. After this call resp->fh needs an fh_put
 42  */
 43 static int
 44 nfsd_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
 45                                           struct nfsd_attrstat *resp)
 46 {
 47         dprintk("nfsd: GETATTR  %s\n", SVCFH_fmt(&argp->fh));
 48 
 49         fh_copy(&resp->fh, &argp->fh);
 50         return fh_verify(rqstp, &resp->fh, 0, MAY_NOP);
 51 }
 52 
 53 /*
 54  * Set a file's attributes
 55  * N.B. After this call resp->fh needs an fh_put
 56  */
 57 static int
 58 nfsd_proc_setattr(struct svc_rqst *rqstp, struct nfsd_sattrargs *argp,
 59                                           struct nfsd_attrstat  *resp)
 60 {
 61         dprintk("nfsd: SETATTR  %s, valid=%x, size=%ld\n",
 62                 SVCFH_fmt(&argp->fh),
 63                 argp->attrs.ia_valid, (long) argp->attrs.ia_size);
 64 
 65         fh_copy(&resp->fh, &argp->fh);
 66         return nfsd_setattr(rqstp, &resp->fh, &argp->attrs,0, (time_t)0);
 67 }
 68 
 69 /*
 70  * Look up a path name component
 71  * Note: the dentry in the resp->fh may be negative if the file
 72  * doesn't exist yet.
 73  * N.B. After this call resp->fh needs an fh_put
 74  */
 75 static int
 76 nfsd_proc_lookup(struct svc_rqst *rqstp, struct nfsd_diropargs *argp,
 77                                          struct nfsd_diropres  *resp)
 78 {
 79         int     nfserr;
 80 
 81         dprintk("nfsd: LOOKUP   %s %.*s\n",
 82                 SVCFH_fmt(&argp->fh), argp->len, argp->name);
 83 
 84         fh_init(&resp->fh, NFS_FHSIZE);
 85         nfserr = nfsd_lookup(rqstp, &argp->fh, argp->name, argp->len,
 86                                  &resp->fh);
 87 
 88         fh_put(&argp->fh);
 89         return nfserr;
 90 }
 91 
 92 /*
 93  * Read a symlink.
 94  */
 95 static int
 96 nfsd_proc_readlink(struct svc_rqst *rqstp, struct nfsd_readlinkargs *argp,
 97                                            struct nfsd_readlinkres *resp)
 98 {
 99         int     nfserr;
100 
101         dprintk("nfsd: READLINK %s\n", SVCFH_fmt(&argp->fh));
102 
103         /* Read the symlink. */
104         resp->len = NFS_MAXPATHLEN;
105         nfserr = nfsd_readlink(rqstp, &argp->fh, argp->buffer, &resp->len);
106 
107         fh_put(&argp->fh);
108         return nfserr;
109 }
110 
111 /*
112  * Read a portion of a file.
113  * N.B. After this call resp->fh needs an fh_put
114  */
115 static int
116 nfsd_proc_read(struct svc_rqst *rqstp, struct nfsd_readargs *argp,
117                                        struct nfsd_readres  *resp)
118 {
119         int     nfserr;
120 
121         dprintk("nfsd: READ    %s %d bytes at %d\n",
122                 SVCFH_fmt(&argp->fh),
123                 argp->count, argp->offset);
124 
125         /* Obtain buffer pointer for payload. 19 is 1 word for
126          * status, 17 words for fattr, and 1 word for the byte count.
127          */
128 
129         if (NFSSVC_MAXBLKSIZE < argp->count) {
130                 printk(KERN_NOTICE
131                         "oversized read request from %08x:%d (%d bytes)\n",
132                                 ntohl(rqstp->rq_addr.sin_addr.s_addr),
133                                 ntohs(rqstp->rq_addr.sin_port),
134                                 argp->count);
135                 argp->count = NFSSVC_MAXBLKSIZE;
136         }
137         svc_reserve(rqstp, (19<<2) + argp->count + 4);
138 
139         resp->count = argp->count;
140         nfserr = nfsd_read(rqstp, fh_copy(&resp->fh, &argp->fh),
141                                   argp->offset,
142                                   argp->vec, argp->vlen,
143                                   &resp->count);
144 
145         return nfserr;
146 }
147 
148 /*
149  * Write data to a file
150  * N.B. After this call resp->fh needs an fh_put
151  */
152 static int
153 nfsd_proc_write(struct svc_rqst *rqstp, struct nfsd_writeargs *argp,
154                                         struct nfsd_attrstat  *resp)
155 {
156         int     nfserr;
157         int     stable = 1;
158 
159         dprintk("nfsd: WRITE    %s %d bytes at %d\n",
160                 SVCFH_fmt(&argp->fh),
161                 argp->len, argp->offset);
162 
163         nfserr = nfsd_write(rqstp, fh_copy(&resp->fh, &argp->fh),
164                                    argp->offset,
165                                    argp->vec, argp->vlen,
166                                    argp->len,
167                                    &stable);
168         return nfserr;
169 }
170 
171 /*
172  * CREATE processing is complicated. The keyword here is `overloaded.'
173  * The parent directory is kept locked between the check for existence
174  * and the actual create() call in compliance with VFS protocols.
175  * N.B. After this call _both_ argp->fh and resp->fh need an fh_put
176  */
177 static int
178 nfsd_proc_create(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
179                                          struct nfsd_diropres   *resp)
180 {
181         svc_fh          *dirfhp = &argp->fh;
182         svc_fh          *newfhp = &resp->fh;
183         struct iattr    *attr = &argp->attrs;
184         struct inode    *inode;
185         struct dentry   *dchild;
186         int             nfserr, type, mode;
187         dev_t           rdev = 0, wanted = new_decode_dev(attr->ia_size);
188 
189         dprintk("nfsd: CREATE   %s %.*s\n",
190                 SVCFH_fmt(dirfhp), argp->len, argp->name);
191 
192         /* First verify the parent file handle */
193         nfserr = fh_verify(rqstp, dirfhp, S_IFDIR, MAY_EXEC);
194         if (nfserr)
195                 goto done; /* must fh_put dirfhp even on error */
196 
197         /* Check for MAY_WRITE in nfsd_create if necessary */
198 
199         nfserr = nfserr_acces;
200         if (!argp->len)
201                 goto done;
202         nfserr = nfserr_exist;
203         if (isdotent(argp->name, argp->len))
204                 goto done;
205         fh_lock(dirfhp);
206         dchild = lookup_one_len(argp->name, dirfhp->fh_dentry, argp->len);
207         if (IS_ERR(dchild)) {
208                 nfserr = nfserrno(PTR_ERR(dchild));
209                 goto out_unlock;
210         }
211         fh_init(newfhp, NFS_FHSIZE);
212         nfserr = fh_compose(newfhp, dirfhp->fh_export, dchild, dirfhp);
213         if (!nfserr && !dchild->d_inode)
214                 nfserr = nfserr_noent;
215         if (nfserr) {
216                 if (nfserr != nfserr_noent)
217                         goto out_unlock;
218                 /*
219                  * If the new file handle wasn't verified, we can't tell
220                  * whether the file exists or not. Time to bail ...
221                  */
222                 nfserr = nfserr_acces;
223                 if (!newfhp->fh_dentry) {
224                         printk(KERN_WARNING 
225                                 "nfsd_proc_create: file handle not verified\n");
226                         goto out_unlock;
227                 }
228         }
229 
230         inode = newfhp->fh_dentry->d_inode;
231 
232         /* Unfudge the mode bits */
233         if (attr->ia_valid & ATTR_MODE) {
234                 type = attr->ia_mode & S_IFMT;
235                 mode = attr->ia_mode & ~S_IFMT;
236                 if (!type) {
237                         /* no type, so if target exists, assume same as that,
238                          * else assume a file */
239                         if (inode) {
240                                 type = inode->i_mode & S_IFMT;
241                                 switch(type) {
242                                 case S_IFCHR:
243                                 case S_IFBLK:
244                                         /* reserve rdev for later checking */
245                                         rdev = inode->i_rdev;
246                                         attr->ia_valid |= ATTR_SIZE;
247 
248                                         /* FALLTHROUGH */
249                                 case S_IFIFO:
250                                         /* this is probably a permission check..
251                                          * at least IRIX implements perm checking on
252                                          *   echo thing > device-special-file-or-pipe
253                                          * by doing a CREATE with type==0
254                                          */
255                                         nfserr = nfsd_permission(newfhp->fh_export,
256                                                                  newfhp->fh_dentry,
257                                                                  MAY_WRITE|MAY_LOCAL_ACCESS);
258                                         if (nfserr && nfserr != nfserr_rofs)
259                                                 goto out_unlock;
260                                 }
261                         } else
262                                 type = S_IFREG;
263                 }
264         } else if (inode) {
265                 type = inode->i_mode & S_IFMT;
266                 mode = inode->i_mode & ~S_IFMT;
267         } else {
268                 type = S_IFREG;
269                 mode = 0;       /* ??? */
270         }
271 
272         attr->ia_valid |= ATTR_MODE;
273         attr->ia_mode = mode;
274 
275         /* Special treatment for non-regular files according to the
276          * gospel of sun micro
277          */
278         if (type != S_IFREG) {
279                 int     is_borc = 0;
280                 if (type != S_IFBLK && type != S_IFCHR) {
281                         rdev = 0;
282                 } else if (type == S_IFCHR && !(attr->ia_valid & ATTR_SIZE)) {
283                         /* If you think you've seen the worst, grok this. */
284                         type = S_IFIFO;
285                 } else {
286                         /* Okay, char or block special */
287                         is_borc = 1;
288                         if (!rdev)
289                                 rdev = wanted;
290                 }
291 
292                 /* we've used the SIZE information, so discard it */
293                 attr->ia_valid &= ~ATTR_SIZE;
294 
295                 /* Make sure the type and device matches */
296                 nfserr = nfserr_exist;
297                 if (inode && type != (inode->i_mode & S_IFMT))
298                         goto out_unlock;
299         }
300 
301         nfserr = 0;
302         if (!inode) {
303                 /* File doesn't exist. Create it and set attrs */
304                 nfserr = nfsd_create(rqstp, dirfhp, argp->name, argp->len,
305                                         attr, type, rdev, newfhp);
306         } else if (type == S_IFREG) {
307                 dprintk("nfsd:   existing %s, valid=%x, size=%ld\n",
308                         argp->name, attr->ia_valid, (long) attr->ia_size);
309                 /* File already exists. We ignore all attributes except
310                  * size, so that creat() behaves exactly like
311                  * open(..., O_CREAT|O_TRUNC|O_WRONLY).
312                  */
313                 attr->ia_valid &= ATTR_SIZE;
314                 if (attr->ia_valid)
315                         nfserr = nfsd_setattr(rqstp, newfhp, attr, 0, (time_t)0);
316         }
317 
318 out_unlock:
319         /* We don't really need to unlock, as fh_put does it. */
320         fh_unlock(dirfhp);
321 
322 done:
323         fh_put(dirfhp);
324         return nfserr;
325 }
326 
327 static int
328 nfsd_proc_remove(struct svc_rqst *rqstp, struct nfsd_diropargs *argp,
329                                          void                  *resp)
330 {
331         int     nfserr;
332 
333         dprintk("nfsd: REMOVE   %s %.*s\n", SVCFH_fmt(&argp->fh),
334                 argp->len, argp->name);
335 
336         /* Unlink. -SIFDIR means file must not be a directory */
337         nfserr = nfsd_unlink(rqstp, &argp->fh, -S_IFDIR, argp->name, argp->len);
338         fh_put(&argp->fh);
339         return nfserr;
340 }
341 
342 static int
343 nfsd_proc_rename(struct svc_rqst *rqstp, struct nfsd_renameargs *argp,
344                                          void                   *resp)
345 {
346         int     nfserr;
347 
348         dprintk("nfsd: RENAME   %s %.*s -> \n",
349                 SVCFH_fmt(&argp->ffh), argp->flen, argp->fname);
350         dprintk("nfsd:        ->  %s %.*s\n",
351                 SVCFH_fmt(&argp->tfh), argp->tlen, argp->tname);
352 
353         nfserr = nfsd_rename(rqstp, &argp->ffh, argp->fname, argp->flen,
354                                     &argp->tfh, argp->tname, argp->tlen);
355         fh_put(&argp->ffh);
356         fh_put(&argp->tfh);
357         return nfserr;
358 }
359 
360 static int
361 nfsd_proc_link(struct svc_rqst *rqstp, struct nfsd_linkargs *argp,
362                                 void                        *resp)
363 {
364         int     nfserr;
365 
366         dprintk("nfsd: LINK     %s ->\n",
367                 SVCFH_fmt(&argp->ffh));
368         dprintk("nfsd:    %s %.*s\n",
369                 SVCFH_fmt(&argp->tfh),
370                 argp->tlen,
371                 argp->tname);
372 
373         nfserr = nfsd_link(rqstp, &argp->tfh, argp->tname, argp->tlen,
374                                   &argp->ffh);
375         fh_put(&argp->ffh);
376         fh_put(&argp->tfh);
377         return nfserr;
378 }
379 
380 static int
381 nfsd_proc_symlink(struct svc_rqst *rqstp, struct nfsd_symlinkargs *argp,
382                                           void                    *resp)
383 {
384         struct svc_fh   newfh;
385         int             nfserr;
386 
387         dprintk("nfsd: SYMLINK  %s %.*s -> %.*s\n",
388                 SVCFH_fmt(&argp->ffh), argp->flen, argp->fname,
389                 argp->tlen, argp->tname);
390 
391         fh_init(&newfh, NFS_FHSIZE);
392         /*
393          * Create the link, look up new file and set attrs.
394          */
395         nfserr = nfsd_symlink(rqstp, &argp->ffh, argp->fname, argp->flen,
396                                                  argp->tname, argp->tlen,
397                                                  &newfh, &argp->attrs);
398 
399 
400         fh_put(&argp->ffh);
401         fh_put(&newfh);
402         return nfserr;
403 }
404 
405 /*
406  * Make directory. This operation is not idempotent.
407  * N.B. After this call resp->fh needs an fh_put
408  */
409 static int
410 nfsd_proc_mkdir(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
411                                         struct nfsd_diropres   *resp)
412 {
413         int     nfserr;
414 
415         dprintk("nfsd: MKDIR    %s %.*s\n", SVCFH_fmt(&argp->fh), argp->len, argp->name);
416 
417         if (resp->fh.fh_dentry) {
418                 printk(KERN_WARNING
419                         "nfsd_proc_mkdir: response already verified??\n");
420         }
421 
422         argp->attrs.ia_valid &= ~ATTR_SIZE;
423         fh_init(&resp->fh, NFS_FHSIZE);
424         nfserr = nfsd_create(rqstp, &argp->fh, argp->name, argp->len,
425                                     &argp->attrs, S_IFDIR, 0, &resp->fh);
426         fh_put(&argp->fh);
427         return nfserr;
428 }
429 
430 /*
431  * Remove a directory
432  */
433 static int
434 nfsd_proc_rmdir(struct svc_rqst *rqstp, struct nfsd_diropargs *argp,
435                                         void                  *resp)
436 {
437         int     nfserr;
438 
439         dprintk("nfsd: RMDIR    %s %.*s\n", SVCFH_fmt(&argp->fh), argp->len, argp->name);
440 
441         nfserr = nfsd_unlink(rqstp, &argp->fh, S_IFDIR, argp->name, argp->len);
442         fh_put(&argp->fh);
443         return nfserr;
444 }
445 
446 /*
447  * Read a portion of a directory.
448  */
449 static int
450 nfsd_proc_readdir(struct svc_rqst *rqstp, struct nfsd_readdirargs *argp,
451                                           struct nfsd_readdirres  *resp)
452 {
453         int             nfserr, count;
454         loff_t          offset;
455 
456         dprintk("nfsd: READDIR  %s %d bytes at %d\n",
457                 SVCFH_fmt(&argp->fh),           
458                 argp->count, argp->cookie);
459 
460         /* Shrink to the client read size */
461         count = (argp->count >> 2) - 2;
462 
463         /* Make sure we've room for the NULL ptr & eof flag */
464         count -= 2;
465         if (count < 0)
466                 count = 0;
467 
468         resp->buffer = argp->buffer;
469         resp->offset = NULL;
470         resp->buflen = count;
471         resp->common.err = nfs_ok;
472         /* Read directory and encode entries on the fly */
473         offset = argp->cookie;
474         nfserr = nfsd_readdir(rqstp, &argp->fh, &offset, 
475                               &resp->common, nfssvc_encode_entry);
476 
477         resp->count = resp->buffer - argp->buffer;
478         if (resp->offset)
479                 *resp->offset = htonl(offset);
480 
481         fh_put(&argp->fh);
482         return nfserr;
483 }
484 
485 /*
486  * Get file system info
487  */
488 static int
489 nfsd_proc_statfs(struct svc_rqst * rqstp, struct nfsd_fhandle   *argp,
490                                           struct nfsd_statfsres *resp)
491 {
492         int     nfserr;
493 
494         dprintk("nfsd: STATFS   %s\n", SVCFH_fmt(&argp->fh));
495 
496         nfserr = nfsd_statfs(rqstp, &argp->fh, &resp->stats);
497         fh_put(&argp->fh);
498         return nfserr;
499 }
500 
501 /*
502  * NFSv2 Server procedures.
503  * Only the results of non-idempotent operations are cached.
504  */
505 #define nfsd_proc_none          NULL
506 #define nfssvc_release_none     NULL
507 struct nfsd_void { int dummy; };
508 
509 #define PROC(name, argt, rest, relt, cache, respsize)   \
510  { (svc_procfunc) nfsd_proc_##name,             \
511    (kxdrproc_t) nfssvc_decode_##argt,           \
512    (kxdrproc_t) nfssvc_encode_##rest,           \
513    (kxdrproc_t) nfssvc_release_##relt,          \
514    sizeof(struct nfsd_##argt),                  \
515    sizeof(struct nfsd_##rest),                  \
516    0,                                           \
517    cache,                                       \
518    respsize,                                    \
519  }
520 
521 #define ST 1            /* status */
522 #define FH 8            /* filehandle */
523 #define AT 18           /* attributes */
524 
525 static struct svc_procedure             nfsd_procedures2[18] = {
526   PROC(null,     void,          void,           none,           RC_NOCACHE, ST),
527   PROC(getattr,  fhandle,       attrstat,       fhandle,        RC_NOCACHE, ST+AT),
528   PROC(setattr,  sattrargs,     attrstat,       fhandle,        RC_REPLBUFF, ST+AT),
529   PROC(none,     void,          void,           none,           RC_NOCACHE, ST),
530   PROC(lookup,   diropargs,     diropres,       fhandle,        RC_NOCACHE, ST+FH+AT),
531   PROC(readlink, readlinkargs,  readlinkres,    none,           RC_NOCACHE, ST+1+NFS_MAXPATHLEN/4),
532   PROC(read,     readargs,      readres,        fhandle,        RC_NOCACHE, ST+AT+1+NFSSVC_MAXBLKSIZE),
533   PROC(none,     void,          void,           none,           RC_NOCACHE, ST),
534   PROC(write,    writeargs,     attrstat,       fhandle,        RC_REPLBUFF, ST+AT),
535   PROC(create,   createargs,    diropres,       fhandle,        RC_REPLBUFF, ST+FH+AT),
536   PROC(remove,   diropargs,     void,           none,           RC_REPLSTAT, ST),
537   PROC(rename,   renameargs,    void,           none,           RC_REPLSTAT, ST),
538   PROC(link,     linkargs,      void,           none,           RC_REPLSTAT, ST),
539   PROC(symlink,  symlinkargs,   void,           none,           RC_REPLSTAT, ST),
540   PROC(mkdir,    createargs,    diropres,       fhandle,        RC_REPLBUFF, ST+FH+AT),
541   PROC(rmdir,    diropargs,     void,           none,           RC_REPLSTAT, ST),
542   PROC(readdir,  readdirargs,   readdirres,     none,           RC_REPLBUFF, 0),
543   PROC(statfs,   fhandle,       statfsres,      none,           RC_NOCACHE, ST+5),
544 };
545 
546 
547 struct svc_version      nfsd_version2 = {
548                 .vs_vers        = 2,
549                 .vs_nproc       = 18,
550                 .vs_proc        = nfsd_procedures2,
551                 .vs_dispatch    = nfsd_dispatch,
552                 .vs_xdrsize     = NFS2_SVC_XDRSIZE,
553 };
554 
555 /*
556  * Map errnos to NFS errnos.
557  */
558 int
559 nfserrno (int errno)
560 {
561         static struct {
562                 int     nfserr;
563                 int     syserr;
564         } nfs_errtbl[] = {
565                 { nfs_ok, 0 },
566                 { nfserr_perm, -EPERM },
567                 { nfserr_noent, -ENOENT },
568                 { nfserr_io, -EIO },
569                 { nfserr_nxio, -ENXIO },
570                 { nfserr_acces, -EACCES },
571                 { nfserr_exist, -EEXIST },
572                 { nfserr_xdev, -EXDEV },
573                 { nfserr_mlink, -EMLINK },
574                 { nfserr_nodev, -ENODEV },
575                 { nfserr_notdir, -ENOTDIR },
576                 { nfserr_isdir, -EISDIR },
577                 { nfserr_inval, -EINVAL },
578                 { nfserr_fbig, -EFBIG },
579                 { nfserr_nospc, -ENOSPC },
580                 { nfserr_rofs, -EROFS },
581                 { nfserr_mlink, -EMLINK },
582                 { nfserr_nametoolong, -ENAMETOOLONG },
583                 { nfserr_notempty, -ENOTEMPTY },
584 #ifdef EDQUOT
585                 { nfserr_dquot, -EDQUOT },
586 #endif
587                 { nfserr_stale, -ESTALE },
588                 { nfserr_dropit, -EAGAIN },
589                 { nfserr_dropit, -ENOMEM },
590                 { -1, -EIO }
591         };
592         int     i;
593 
594         for (i = 0; nfs_errtbl[i].nfserr != -1; i++) {
595                 if (nfs_errtbl[i].syserr == errno)
596                         return nfs_errtbl[i].nfserr;
597         }
598         printk (KERN_INFO "nfsd: non-standard errno: %d\n", errno);
599         return nfserr_io;
600 }
601 
602 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp