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

TOMOYO Linux Cross Reference
Linux/fs/nfs/proc.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ 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.69 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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  *  linux/fs/nfs/proc.c
  3  *
  4  *  Copyright (C) 1992, 1993, 1994  Rick Sladkey
  5  *
  6  *  OS-independent nfs remote procedure call functions
  7  *
  8  *  Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers
  9  *  so at last we can have decent(ish) throughput off a 
 10  *  Sun server.
 11  *
 12  *  Coding optimized and cleaned up by Florian La Roche.
 13  *  Note: Error returns are optimized for NFS_OK, which isn't translated via
 14  *  nfs_stat_to_errno(), but happens to be already the right return code.
 15  *
 16  *  Also, the code currently doesn't check the size of the packet, when
 17  *  it decodes the packet.
 18  *
 19  *  Feel free to fix it and mail me the diffs if it worries you.
 20  *
 21  *  Completely rewritten to support the new RPC call interface;
 22  *  rewrote and moved the entire XDR stuff to xdr.c
 23  *  --Olaf Kirch June 1996
 24  *
 25  *  The code below initializes all auto variables explicitly, otherwise
 26  *  it will fail to work as a module (gcc generates a memset call for an
 27  *  incomplete struct).
 28  */
 29 
 30 #include <linux/types.h>
 31 #include <linux/param.h>
 32 #include <linux/time.h>
 33 #include <linux/mm.h>
 34 #include <linux/errno.h>
 35 #include <linux/string.h>
 36 #include <linux/in.h>
 37 #include <linux/pagemap.h>
 38 #include <linux/sunrpc/clnt.h>
 39 #include <linux/nfs.h>
 40 #include <linux/nfs2.h>
 41 #include <linux/nfs_fs.h>
 42 #include <linux/nfs_page.h>
 43 #include <linux/lockd/bind.h>
 44 #include <linux/freezer.h>
 45 #include "internal.h"
 46 
 47 #define NFSDBG_FACILITY         NFSDBG_PROC
 48 
 49 /*
 50  * Bare-bones access to getattr: this is for nfs_read_super.
 51  */
 52 static int
 53 nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
 54                   struct nfs_fsinfo *info)
 55 {
 56         struct nfs_fattr *fattr = info->fattr;
 57         struct nfs2_fsstat fsinfo;
 58         struct rpc_message msg = {
 59                 .rpc_proc       = &nfs_procedures[NFSPROC_GETATTR],
 60                 .rpc_argp       = fhandle,
 61                 .rpc_resp       = fattr,
 62         };
 63         int status;
 64 
 65         dprintk("%s: call getattr\n", __func__);
 66         nfs_fattr_init(fattr);
 67         status = rpc_call_sync(server->client, &msg, 0);
 68         /* Retry with default authentication if different */
 69         if (status && server->nfs_client->cl_rpcclient != server->client)
 70                 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
 71         dprintk("%s: reply getattr: %d\n", __func__, status);
 72         if (status)
 73                 return status;
 74         dprintk("%s: call statfs\n", __func__);
 75         msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
 76         msg.rpc_resp = &fsinfo;
 77         status = rpc_call_sync(server->client, &msg, 0);
 78         /* Retry with default authentication if different */
 79         if (status && server->nfs_client->cl_rpcclient != server->client)
 80                 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
 81         dprintk("%s: reply statfs: %d\n", __func__, status);
 82         if (status)
 83                 return status;
 84         info->rtmax  = NFS_MAXDATA;
 85         info->rtpref = fsinfo.tsize;
 86         info->rtmult = fsinfo.bsize;
 87         info->wtmax  = NFS_MAXDATA;
 88         info->wtpref = fsinfo.tsize;
 89         info->wtmult = fsinfo.bsize;
 90         info->dtpref = fsinfo.tsize;
 91         info->maxfilesize = 0x7FFFFFFF;
 92         info->lease_time = 0;
 93         return 0;
 94 }
 95 
 96 /*
 97  * One function for each procedure in the NFS protocol.
 98  */
 99 static int
100 nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
101                 struct nfs_fattr *fattr, struct nfs4_label *label)
102 {
103         struct rpc_message msg = {
104                 .rpc_proc       = &nfs_procedures[NFSPROC_GETATTR],
105                 .rpc_argp       = fhandle,
106                 .rpc_resp       = fattr,
107         };
108         int     status;
109 
110         dprintk("NFS call  getattr\n");
111         nfs_fattr_init(fattr);
112         status = rpc_call_sync(server->client, &msg, 0);
113         dprintk("NFS reply getattr: %d\n", status);
114         return status;
115 }
116 
117 static int
118 nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
119                  struct iattr *sattr)
120 {
121         struct inode *inode = d_inode(dentry);
122         struct nfs_sattrargs    arg = { 
123                 .fh     = NFS_FH(inode),
124                 .sattr  = sattr
125         };
126         struct rpc_message msg = {
127                 .rpc_proc       = &nfs_procedures[NFSPROC_SETATTR],
128                 .rpc_argp       = &arg,
129                 .rpc_resp       = fattr,
130         };
131         int     status;
132 
133         /* Mask out the non-modebit related stuff from attr->ia_mode */
134         sattr->ia_mode &= S_IALLUGO;
135 
136         dprintk("NFS call  setattr\n");
137         if (sattr->ia_valid & ATTR_FILE)
138                 msg.rpc_cred = nfs_file_cred(sattr->ia_file);
139         nfs_fattr_init(fattr);
140         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
141         if (status == 0)
142                 nfs_setattr_update_inode(inode, sattr, fattr);
143         dprintk("NFS reply setattr: %d\n", status);
144         return status;
145 }
146 
147 static int
148 nfs_proc_lookup(struct inode *dir, struct qstr *name,
149                 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
150                 struct nfs4_label *label)
151 {
152         struct nfs_diropargs    arg = {
153                 .fh             = NFS_FH(dir),
154                 .name           = name->name,
155                 .len            = name->len
156         };
157         struct nfs_diropok      res = {
158                 .fh             = fhandle,
159                 .fattr          = fattr
160         };
161         struct rpc_message msg = {
162                 .rpc_proc       = &nfs_procedures[NFSPROC_LOOKUP],
163                 .rpc_argp       = &arg,
164                 .rpc_resp       = &res,
165         };
166         int                     status;
167 
168         dprintk("NFS call  lookup %s\n", name->name);
169         nfs_fattr_init(fattr);
170         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
171         dprintk("NFS reply lookup: %d\n", status);
172         return status;
173 }
174 
175 static int nfs_proc_readlink(struct inode *inode, struct page *page,
176                 unsigned int pgbase, unsigned int pglen)
177 {
178         struct nfs_readlinkargs args = {
179                 .fh             = NFS_FH(inode),
180                 .pgbase         = pgbase,
181                 .pglen          = pglen,
182                 .pages          = &page
183         };
184         struct rpc_message msg = {
185                 .rpc_proc       = &nfs_procedures[NFSPROC_READLINK],
186                 .rpc_argp       = &args,
187         };
188         int                     status;
189 
190         dprintk("NFS call  readlink\n");
191         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
192         dprintk("NFS reply readlink: %d\n", status);
193         return status;
194 }
195 
196 struct nfs_createdata {
197         struct nfs_createargs arg;
198         struct nfs_diropok res;
199         struct nfs_fh fhandle;
200         struct nfs_fattr fattr;
201 };
202 
203 static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir,
204                 struct dentry *dentry, struct iattr *sattr)
205 {
206         struct nfs_createdata *data;
207 
208         data = kmalloc(sizeof(*data), GFP_KERNEL);
209 
210         if (data != NULL) {
211                 data->arg.fh = NFS_FH(dir);
212                 data->arg.name = dentry->d_name.name;
213                 data->arg.len = dentry->d_name.len;
214                 data->arg.sattr = sattr;
215                 nfs_fattr_init(&data->fattr);
216                 data->fhandle.size = 0;
217                 data->res.fh = &data->fhandle;
218                 data->res.fattr = &data->fattr;
219         }
220         return data;
221 };
222 
223 static void nfs_free_createdata(const struct nfs_createdata *data)
224 {
225         kfree(data);
226 }
227 
228 static int
229 nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
230                 int flags)
231 {
232         struct nfs_createdata *data;
233         struct rpc_message msg = {
234                 .rpc_proc       = &nfs_procedures[NFSPROC_CREATE],
235         };
236         int status = -ENOMEM;
237 
238         dprintk("NFS call  create %pd\n", dentry);
239         data = nfs_alloc_createdata(dir, dentry, sattr);
240         if (data == NULL)
241                 goto out;
242         msg.rpc_argp = &data->arg;
243         msg.rpc_resp = &data->res;
244         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
245         nfs_mark_for_revalidate(dir);
246         if (status == 0)
247                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
248         nfs_free_createdata(data);
249 out:
250         dprintk("NFS reply create: %d\n", status);
251         return status;
252 }
253 
254 /*
255  * In NFSv2, mknod is grafted onto the create call.
256  */
257 static int
258 nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
259                dev_t rdev)
260 {
261         struct nfs_createdata *data;
262         struct rpc_message msg = {
263                 .rpc_proc       = &nfs_procedures[NFSPROC_CREATE],
264         };
265         umode_t mode;
266         int status = -ENOMEM;
267 
268         dprintk("NFS call  mknod %pd\n", dentry);
269 
270         mode = sattr->ia_mode;
271         if (S_ISFIFO(mode)) {
272                 sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
273                 sattr->ia_valid &= ~ATTR_SIZE;
274         } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
275                 sattr->ia_valid |= ATTR_SIZE;
276                 sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
277         }
278 
279         data = nfs_alloc_createdata(dir, dentry, sattr);
280         if (data == NULL)
281                 goto out;
282         msg.rpc_argp = &data->arg;
283         msg.rpc_resp = &data->res;
284 
285         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
286         nfs_mark_for_revalidate(dir);
287 
288         if (status == -EINVAL && S_ISFIFO(mode)) {
289                 sattr->ia_mode = mode;
290                 nfs_fattr_init(data->res.fattr);
291                 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
292         }
293         if (status == 0)
294                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
295         nfs_free_createdata(data);
296 out:
297         dprintk("NFS reply mknod: %d\n", status);
298         return status;
299 }
300   
301 static int
302 nfs_proc_remove(struct inode *dir, struct qstr *name)
303 {
304         struct nfs_removeargs arg = {
305                 .fh = NFS_FH(dir),
306                 .name = *name,
307         };
308         struct rpc_message msg = { 
309                 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
310                 .rpc_argp = &arg,
311         };
312         int                     status;
313 
314         dprintk("NFS call  remove %s\n", name->name);
315         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
316         nfs_mark_for_revalidate(dir);
317 
318         dprintk("NFS reply remove: %d\n", status);
319         return status;
320 }
321 
322 static void
323 nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
324 {
325         msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
326 }
327 
328 static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
329 {
330         rpc_call_start(task);
331 }
332 
333 static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
334 {
335         nfs_mark_for_revalidate(dir);
336         return 1;
337 }
338 
339 static void
340 nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
341 {
342         msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
343 }
344 
345 static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
346 {
347         rpc_call_start(task);
348 }
349 
350 static int
351 nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
352                      struct inode *new_dir)
353 {
354         nfs_mark_for_revalidate(old_dir);
355         nfs_mark_for_revalidate(new_dir);
356         return 1;
357 }
358 
359 static int
360 nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
361 {
362         struct nfs_linkargs     arg = {
363                 .fromfh         = NFS_FH(inode),
364                 .tofh           = NFS_FH(dir),
365                 .toname         = name->name,
366                 .tolen          = name->len
367         };
368         struct rpc_message msg = {
369                 .rpc_proc       = &nfs_procedures[NFSPROC_LINK],
370                 .rpc_argp       = &arg,
371         };
372         int                     status;
373 
374         dprintk("NFS call  link %s\n", name->name);
375         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
376         nfs_mark_for_revalidate(inode);
377         nfs_mark_for_revalidate(dir);
378         dprintk("NFS reply link: %d\n", status);
379         return status;
380 }
381 
382 static int
383 nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
384                  unsigned int len, struct iattr *sattr)
385 {
386         struct nfs_fh *fh;
387         struct nfs_fattr *fattr;
388         struct nfs_symlinkargs  arg = {
389                 .fromfh         = NFS_FH(dir),
390                 .fromname       = dentry->d_name.name,
391                 .fromlen        = dentry->d_name.len,
392                 .pages          = &page,
393                 .pathlen        = len,
394                 .sattr          = sattr
395         };
396         struct rpc_message msg = {
397                 .rpc_proc       = &nfs_procedures[NFSPROC_SYMLINK],
398                 .rpc_argp       = &arg,
399         };
400         int status = -ENAMETOOLONG;
401 
402         dprintk("NFS call  symlink %pd\n", dentry);
403 
404         if (len > NFS2_MAXPATHLEN)
405                 goto out;
406 
407         fh = nfs_alloc_fhandle();
408         fattr = nfs_alloc_fattr();
409         status = -ENOMEM;
410         if (fh == NULL || fattr == NULL)
411                 goto out_free;
412 
413         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
414         nfs_mark_for_revalidate(dir);
415 
416         /*
417          * V2 SYMLINK requests don't return any attributes.  Setting the
418          * filehandle size to zero indicates to nfs_instantiate that it
419          * should fill in the data with a LOOKUP call on the wire.
420          */
421         if (status == 0)
422                 status = nfs_instantiate(dentry, fh, fattr, NULL);
423 
424 out_free:
425         nfs_free_fattr(fattr);
426         nfs_free_fhandle(fh);
427 out:
428         dprintk("NFS reply symlink: %d\n", status);
429         return status;
430 }
431 
432 static int
433 nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
434 {
435         struct nfs_createdata *data;
436         struct rpc_message msg = {
437                 .rpc_proc       = &nfs_procedures[NFSPROC_MKDIR],
438         };
439         int status = -ENOMEM;
440 
441         dprintk("NFS call  mkdir %pd\n", dentry);
442         data = nfs_alloc_createdata(dir, dentry, sattr);
443         if (data == NULL)
444                 goto out;
445         msg.rpc_argp = &data->arg;
446         msg.rpc_resp = &data->res;
447 
448         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
449         nfs_mark_for_revalidate(dir);
450         if (status == 0)
451                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
452         nfs_free_createdata(data);
453 out:
454         dprintk("NFS reply mkdir: %d\n", status);
455         return status;
456 }
457 
458 static int
459 nfs_proc_rmdir(struct inode *dir, struct qstr *name)
460 {
461         struct nfs_diropargs    arg = {
462                 .fh             = NFS_FH(dir),
463                 .name           = name->name,
464                 .len            = name->len
465         };
466         struct rpc_message msg = {
467                 .rpc_proc       = &nfs_procedures[NFSPROC_RMDIR],
468                 .rpc_argp       = &arg,
469         };
470         int                     status;
471 
472         dprintk("NFS call  rmdir %s\n", name->name);
473         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
474         nfs_mark_for_revalidate(dir);
475         dprintk("NFS reply rmdir: %d\n", status);
476         return status;
477 }
478 
479 /*
480  * The READDIR implementation is somewhat hackish - we pass a temporary
481  * buffer to the encode function, which installs it in the receive
482  * the receive iovec. The decode function just parses the reply to make
483  * sure it is syntactically correct; the entries itself are decoded
484  * from nfs_readdir by calling the decode_entry function directly.
485  */
486 static int
487 nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
488                  u64 cookie, struct page **pages, unsigned int count, int plus)
489 {
490         struct inode            *dir = d_inode(dentry);
491         struct nfs_readdirargs  arg = {
492                 .fh             = NFS_FH(dir),
493                 .cookie         = cookie,
494                 .count          = count,
495                 .pages          = pages,
496         };
497         struct rpc_message      msg = {
498                 .rpc_proc       = &nfs_procedures[NFSPROC_READDIR],
499                 .rpc_argp       = &arg,
500                 .rpc_cred       = cred,
501         };
502         int                     status;
503 
504         dprintk("NFS call  readdir %d\n", (unsigned int)cookie);
505         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
506 
507         nfs_invalidate_atime(dir);
508 
509         dprintk("NFS reply readdir: %d\n", status);
510         return status;
511 }
512 
513 static int
514 nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
515                         struct nfs_fsstat *stat)
516 {
517         struct nfs2_fsstat fsinfo;
518         struct rpc_message msg = {
519                 .rpc_proc       = &nfs_procedures[NFSPROC_STATFS],
520                 .rpc_argp       = fhandle,
521                 .rpc_resp       = &fsinfo,
522         };
523         int     status;
524 
525         dprintk("NFS call  statfs\n");
526         nfs_fattr_init(stat->fattr);
527         status = rpc_call_sync(server->client, &msg, 0);
528         dprintk("NFS reply statfs: %d\n", status);
529         if (status)
530                 goto out;
531         stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
532         stat->fbytes = (u64)fsinfo.bfree  * fsinfo.bsize;
533         stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
534         stat->tfiles = 0;
535         stat->ffiles = 0;
536         stat->afiles = 0;
537 out:
538         return status;
539 }
540 
541 static int
542 nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
543                         struct nfs_fsinfo *info)
544 {
545         struct nfs2_fsstat fsinfo;
546         struct rpc_message msg = {
547                 .rpc_proc       = &nfs_procedures[NFSPROC_STATFS],
548                 .rpc_argp       = fhandle,
549                 .rpc_resp       = &fsinfo,
550         };
551         int     status;
552 
553         dprintk("NFS call  fsinfo\n");
554         nfs_fattr_init(info->fattr);
555         status = rpc_call_sync(server->client, &msg, 0);
556         dprintk("NFS reply fsinfo: %d\n", status);
557         if (status)
558                 goto out;
559         info->rtmax  = NFS_MAXDATA;
560         info->rtpref = fsinfo.tsize;
561         info->rtmult = fsinfo.bsize;
562         info->wtmax  = NFS_MAXDATA;
563         info->wtpref = fsinfo.tsize;
564         info->wtmult = fsinfo.bsize;
565         info->dtpref = fsinfo.tsize;
566         info->maxfilesize = 0x7FFFFFFF;
567         info->lease_time = 0;
568 out:
569         return status;
570 }
571 
572 static int
573 nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
574                   struct nfs_pathconf *info)
575 {
576         info->max_link = 0;
577         info->max_namelen = NFS2_MAXNAMLEN;
578         return 0;
579 }
580 
581 static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
582 {
583         struct inode *inode = hdr->inode;
584 
585         nfs_invalidate_atime(inode);
586         if (task->tk_status >= 0) {
587                 nfs_refresh_inode(inode, hdr->res.fattr);
588                 /* Emulate the eof flag, which isn't normally needed in NFSv2
589                  * as it is guaranteed to always return the file attributes
590                  */
591                 if (hdr->args.offset + hdr->res.count >= hdr->res.fattr->size)
592                         hdr->res.eof = 1;
593         }
594         return 0;
595 }
596 
597 static void nfs_proc_read_setup(struct nfs_pgio_header *hdr,
598                                 struct rpc_message *msg)
599 {
600         msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
601 }
602 
603 static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task,
604                                      struct nfs_pgio_header *hdr)
605 {
606         rpc_call_start(task);
607         return 0;
608 }
609 
610 static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
611 {
612         if (task->tk_status >= 0)
613                 nfs_writeback_update_inode(hdr);
614         return 0;
615 }
616 
617 static void nfs_proc_write_setup(struct nfs_pgio_header *hdr,
618                                  struct rpc_message *msg)
619 {
620         /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
621         hdr->args.stable = NFS_FILE_SYNC;
622         msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
623 }
624 
625 static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
626 {
627         BUG();
628 }
629 
630 static void
631 nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
632 {
633         BUG();
634 }
635 
636 static int
637 nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
638 {
639         struct inode *inode = file_inode(filp);
640 
641         return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
642 }
643 
644 /* Helper functions for NFS lock bounds checking */
645 #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
646 static int nfs_lock_check_bounds(const struct file_lock *fl)
647 {
648         __s32 start, end;
649 
650         start = (__s32)fl->fl_start;
651         if ((loff_t)start != fl->fl_start)
652                 goto out_einval;
653 
654         if (fl->fl_end != OFFSET_MAX) {
655                 end = (__s32)fl->fl_end;
656                 if ((loff_t)end != fl->fl_end)
657                         goto out_einval;
658         } else
659                 end = NFS_LOCK32_OFFSET_MAX;
660 
661         if (start < 0 || start > end)
662                 goto out_einval;
663         return 0;
664 out_einval:
665         return -EINVAL;
666 }
667 
668 static int nfs_have_delegation(struct inode *inode, fmode_t flags)
669 {
670         return 0;
671 }
672 
673 static int nfs_return_delegation(struct inode *inode)
674 {
675         nfs_wb_all(inode);
676         return 0;
677 }
678 
679 static const struct inode_operations nfs_dir_inode_operations = {
680         .create         = nfs_create,
681         .lookup         = nfs_lookup,
682         .link           = nfs_link,
683         .unlink         = nfs_unlink,
684         .symlink        = nfs_symlink,
685         .mkdir          = nfs_mkdir,
686         .rmdir          = nfs_rmdir,
687         .mknod          = nfs_mknod,
688         .rename         = nfs_rename,
689         .permission     = nfs_permission,
690         .getattr        = nfs_getattr,
691         .setattr        = nfs_setattr,
692 };
693 
694 static const struct inode_operations nfs_file_inode_operations = {
695         .permission     = nfs_permission,
696         .getattr        = nfs_getattr,
697         .setattr        = nfs_setattr,
698 };
699 
700 const struct nfs_rpc_ops nfs_v2_clientops = {
701         .version        = 2,                   /* protocol version */
702         .dentry_ops     = &nfs_dentry_operations,
703         .dir_inode_ops  = &nfs_dir_inode_operations,
704         .file_inode_ops = &nfs_file_inode_operations,
705         .file_ops       = &nfs_file_operations,
706         .getroot        = nfs_proc_get_root,
707         .submount       = nfs_submount,
708         .try_mount      = nfs_try_mount,
709         .getattr        = nfs_proc_getattr,
710         .setattr        = nfs_proc_setattr,
711         .lookup         = nfs_proc_lookup,
712         .access         = NULL,                /* access */
713         .readlink       = nfs_proc_readlink,
714         .create         = nfs_proc_create,
715         .remove         = nfs_proc_remove,
716         .unlink_setup   = nfs_proc_unlink_setup,
717         .unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
718         .unlink_done    = nfs_proc_unlink_done,
719         .rename_setup   = nfs_proc_rename_setup,
720         .rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
721         .rename_done    = nfs_proc_rename_done,
722         .link           = nfs_proc_link,
723         .symlink        = nfs_proc_symlink,
724         .mkdir          = nfs_proc_mkdir,
725         .rmdir          = nfs_proc_rmdir,
726         .readdir        = nfs_proc_readdir,
727         .mknod          = nfs_proc_mknod,
728         .statfs         = nfs_proc_statfs,
729         .fsinfo         = nfs_proc_fsinfo,
730         .pathconf       = nfs_proc_pathconf,
731         .decode_dirent  = nfs2_decode_dirent,
732         .pgio_rpc_prepare = nfs_proc_pgio_rpc_prepare,
733         .read_setup     = nfs_proc_read_setup,
734         .read_done      = nfs_read_done,
735         .write_setup    = nfs_proc_write_setup,
736         .write_done     = nfs_write_done,
737         .commit_setup   = nfs_proc_commit_setup,
738         .commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
739         .lock           = nfs_proc_lock,
740         .lock_check_bounds = nfs_lock_check_bounds,
741         .close_context  = nfs_close_context,
742         .have_delegation = nfs_have_delegation,
743         .return_delegation = nfs_return_delegation,
744         .alloc_client   = nfs_alloc_client,
745         .init_client    = nfs_init_client,
746         .free_client    = nfs_free_client,
747         .create_server  = nfs_create_server,
748         .clone_server   = nfs_clone_server,
749 };
750 

~ [ 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