f988a9417b13dc7d7e73c18dbd79f9b1b1eab6d5
[linux-2.6.git] / fs / nfs / nfs4proc.c
1 /*
2  *  fs/nfs/nfs4proc.c
3  *
4  *  Client-side procedure declarations for NFSv4.
5  *
6  *  Copyright (c) 2002 The Regents of the University of Michigan.
7  *  All rights reserved.
8  *
9  *  Kendrick Smith <kmsmith@umich.edu>
10  *  Andy Adamson   <andros@umich.edu>
11  *
12  *  Redistribution and use in source and binary forms, with or without
13  *  modification, are permitted provided that the following conditions
14  *  are met:
15  *
16  *  1. Redistributions of source code must retain the above copyright
17  *     notice, this list of conditions and the following disclaimer.
18  *  2. Redistributions in binary form must reproduce the above copyright
19  *     notice, this list of conditions and the following disclaimer in the
20  *     documentation and/or other materials provided with the distribution.
21  *  3. Neither the name of the University nor the names of its
22  *     contributors may be used to endorse or promote products derived
23  *     from this software without specific prior written permission.
24  *
25  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  */
37
38 #include <linux/mm.h>
39 #include <linux/utsname.h>
40 #include <linux/delay.h>
41 #include <linux/errno.h>
42 #include <linux/string.h>
43 #include <linux/sunrpc/clnt.h>
44 #include <linux/nfs.h>
45 #include <linux/nfs4.h>
46 #include <linux/nfs_fs.h>
47 #include <linux/nfs_page.h>
48 #include <linux/smp_lock.h>
49 #include <linux/namei.h>
50 #include <linux/mount.h>
51
52 #include "nfs4_fs.h"
53 #include "delegation.h"
54
55 #define NFSDBG_FACILITY         NFSDBG_PROC
56
57 #define NFS4_POLL_RETRY_MIN     (1*HZ)
58 #define NFS4_POLL_RETRY_MAX     (15*HZ)
59
60 static int _nfs4_proc_open_confirm(struct rpc_clnt *clnt, const struct nfs_fh *fh, struct nfs4_state_owner *sp, nfs4_stateid *stateid, struct nfs_seqid *seqid);
61 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
62 static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *);
63 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry);
64 static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception);
65 extern u32 *nfs4_decode_dirent(u32 *p, struct nfs_entry *entry, int plus);
66 extern struct rpc_procinfo nfs4_procedures[];
67
68 /* Prevent leaks of NFSv4 errors into userland */
69 int nfs4_map_errors(int err)
70 {
71         if (err < -1000) {
72                 dprintk("%s could not handle NFSv4 error %d\n",
73                                 __FUNCTION__, -err);
74                 return -EIO;
75         }
76         return err;
77 }
78
79 /*
80  * This is our standard bitmap for GETATTR requests.
81  */
82 const u32 nfs4_fattr_bitmap[2] = {
83         FATTR4_WORD0_TYPE
84         | FATTR4_WORD0_CHANGE
85         | FATTR4_WORD0_SIZE
86         | FATTR4_WORD0_FSID
87         | FATTR4_WORD0_FILEID,
88         FATTR4_WORD1_MODE
89         | FATTR4_WORD1_NUMLINKS
90         | FATTR4_WORD1_OWNER
91         | FATTR4_WORD1_OWNER_GROUP
92         | FATTR4_WORD1_RAWDEV
93         | FATTR4_WORD1_SPACE_USED
94         | FATTR4_WORD1_TIME_ACCESS
95         | FATTR4_WORD1_TIME_METADATA
96         | FATTR4_WORD1_TIME_MODIFY
97 };
98
99 const u32 nfs4_statfs_bitmap[2] = {
100         FATTR4_WORD0_FILES_AVAIL
101         | FATTR4_WORD0_FILES_FREE
102         | FATTR4_WORD0_FILES_TOTAL,
103         FATTR4_WORD1_SPACE_AVAIL
104         | FATTR4_WORD1_SPACE_FREE
105         | FATTR4_WORD1_SPACE_TOTAL
106 };
107
108 const u32 nfs4_pathconf_bitmap[2] = {
109         FATTR4_WORD0_MAXLINK
110         | FATTR4_WORD0_MAXNAME,
111         0
112 };
113
114 const u32 nfs4_fsinfo_bitmap[2] = { FATTR4_WORD0_MAXFILESIZE
115                         | FATTR4_WORD0_MAXREAD
116                         | FATTR4_WORD0_MAXWRITE
117                         | FATTR4_WORD0_LEASE_TIME,
118                         0
119 };
120
121 static void nfs4_setup_readdir(u64 cookie, u32 *verifier, struct dentry *dentry,
122                 struct nfs4_readdir_arg *readdir)
123 {
124         u32 *start, *p;
125
126         BUG_ON(readdir->count < 80);
127         if (cookie > 2) {
128                 readdir->cookie = cookie;
129                 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
130                 return;
131         }
132
133         readdir->cookie = 0;
134         memset(&readdir->verifier, 0, sizeof(readdir->verifier));
135         if (cookie == 2)
136                 return;
137         
138         /*
139          * NFSv4 servers do not return entries for '.' and '..'
140          * Therefore, we fake these entries here.  We let '.'
141          * have cookie 0 and '..' have cookie 1.  Note that
142          * when talking to the server, we always send cookie 0
143          * instead of 1 or 2.
144          */
145         start = p = (u32 *)kmap_atomic(*readdir->pages, KM_USER0);
146         
147         if (cookie == 0) {
148                 *p++ = xdr_one;                                  /* next */
149                 *p++ = xdr_zero;                   /* cookie, first word */
150                 *p++ = xdr_one;                   /* cookie, second word */
151                 *p++ = xdr_one;                             /* entry len */
152                 memcpy(p, ".\0\0\0", 4);                        /* entry */
153                 p++;
154                 *p++ = xdr_one;                         /* bitmap length */
155                 *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
156                 *p++ = htonl(8);              /* attribute buffer length */
157                 p = xdr_encode_hyper(p, dentry->d_inode->i_ino);
158         }
159         
160         *p++ = xdr_one;                                  /* next */
161         *p++ = xdr_zero;                   /* cookie, first word */
162         *p++ = xdr_two;                   /* cookie, second word */
163         *p++ = xdr_two;                             /* entry len */
164         memcpy(p, "..\0\0", 4);                         /* entry */
165         p++;
166         *p++ = xdr_one;                         /* bitmap length */
167         *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
168         *p++ = htonl(8);              /* attribute buffer length */
169         p = xdr_encode_hyper(p, dentry->d_parent->d_inode->i_ino);
170
171         readdir->pgbase = (char *)p - (char *)start;
172         readdir->count -= readdir->pgbase;
173         kunmap_atomic(start, KM_USER0);
174 }
175
176 static void
177 renew_lease(struct nfs_server *server, unsigned long timestamp)
178 {
179         struct nfs4_client *clp = server->nfs4_state;
180         spin_lock(&clp->cl_lock);
181         if (time_before(clp->cl_last_renewal,timestamp))
182                 clp->cl_last_renewal = timestamp;
183         spin_unlock(&clp->cl_lock);
184 }
185
186 static void update_changeattr(struct inode *inode, struct nfs4_change_info *cinfo)
187 {
188         struct nfs_inode *nfsi = NFS_I(inode);
189
190         spin_lock(&inode->i_lock);
191         nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
192         if (cinfo->before == nfsi->change_attr && cinfo->atomic)
193                 nfsi->change_attr = cinfo->after;
194         spin_unlock(&inode->i_lock);
195 }
196
197 /* Helper for asynchronous RPC calls */
198 static int nfs4_call_async(struct rpc_clnt *clnt, rpc_action tk_begin,
199                 rpc_action tk_exit, void *calldata)
200 {
201         struct rpc_task *task;
202
203         if (!(task = rpc_new_task(clnt, tk_exit, RPC_TASK_ASYNC)))
204                 return -ENOMEM;
205
206         task->tk_calldata = calldata;
207         task->tk_action = tk_begin;
208         rpc_execute(task);
209         return 0;
210 }
211
212 static void update_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
213 {
214         struct inode *inode = state->inode;
215
216         open_flags &= (FMODE_READ|FMODE_WRITE);
217         /* Protect against nfs4_find_state_byowner() */
218         spin_lock(&state->owner->so_lock);
219         spin_lock(&inode->i_lock);
220         memcpy(&state->stateid, stateid, sizeof(state->stateid));
221         if ((open_flags & FMODE_WRITE))
222                 state->nwriters++;
223         if (open_flags & FMODE_READ)
224                 state->nreaders++;
225         nfs4_state_set_mode_locked(state, state->state | open_flags);
226         spin_unlock(&inode->i_lock);
227         spin_unlock(&state->owner->so_lock);
228 }
229
230 /*
231  * OPEN_RECLAIM:
232  *      reclaim state on the server after a reboot.
233  */
234 static int _nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
235 {
236         struct inode *inode = state->inode;
237         struct nfs_server *server = NFS_SERVER(inode);
238         struct nfs_delegation *delegation = NFS_I(inode)->delegation;
239         struct nfs_openargs o_arg = {
240                 .fh = NFS_FH(inode),
241                 .id = sp->so_id,
242                 .open_flags = state->state,
243                 .clientid = server->nfs4_state->cl_clientid,
244                 .claim = NFS4_OPEN_CLAIM_PREVIOUS,
245                 .bitmask = server->attr_bitmask,
246         };
247         struct nfs_openres o_res = {
248                 .server = server,       /* Grrr */
249         };
250         struct rpc_message msg = {
251                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR],
252                 .rpc_argp       = &o_arg,
253                 .rpc_resp       = &o_res,
254                 .rpc_cred       = sp->so_cred,
255         };
256         int status;
257
258         if (delegation != NULL) {
259                 if (!(delegation->flags & NFS_DELEGATION_NEED_RECLAIM)) {
260                         memcpy(&state->stateid, &delegation->stateid,
261                                         sizeof(state->stateid));
262                         set_bit(NFS_DELEGATED_STATE, &state->flags);
263                         return 0;
264                 }
265                 o_arg.u.delegation_type = delegation->type;
266         }
267         o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
268         if (o_arg.seqid == NULL)
269                 return -ENOMEM;
270         status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
271         /* Confirm the sequence as being established */
272         nfs_confirm_seqid(&sp->so_seqid, status);
273         nfs_increment_open_seqid(status, o_arg.seqid);
274         if (status == 0) {
275                 memcpy(&state->stateid, &o_res.stateid, sizeof(state->stateid));
276                 if (o_res.delegation_type != 0) {
277                         nfs_inode_reclaim_delegation(inode, sp->so_cred, &o_res);
278                         /* Did the server issue an immediate delegation recall? */
279                         if (o_res.do_recall)
280                                 nfs_async_inode_return_delegation(inode, &o_res.stateid);
281                 }
282         }
283         nfs_free_seqid(o_arg.seqid);
284         clear_bit(NFS_DELEGATED_STATE, &state->flags);
285         /* Ensure we update the inode attributes */
286         NFS_CACHEINV(inode);
287         return status;
288 }
289
290 static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
291 {
292         struct nfs_server *server = NFS_SERVER(state->inode);
293         struct nfs4_exception exception = { };
294         int err;
295         do {
296                 err = _nfs4_open_reclaim(sp, state);
297                 if (err != -NFS4ERR_DELAY)
298                         break;
299                 nfs4_handle_exception(server, err, &exception);
300         } while (exception.retry);
301         return err;
302 }
303
304 static int _nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state *state)
305 {
306         struct nfs4_state_owner  *sp  = state->owner;
307         struct inode *inode = dentry->d_inode;
308         struct nfs_server *server = NFS_SERVER(inode);
309         struct dentry *parent = dget_parent(dentry);
310         struct nfs_openargs arg = {
311                 .fh = NFS_FH(parent->d_inode),
312                 .clientid = server->nfs4_state->cl_clientid,
313                 .name = &dentry->d_name,
314                 .id = sp->so_id,
315                 .server = server,
316                 .bitmask = server->attr_bitmask,
317                 .claim = NFS4_OPEN_CLAIM_DELEGATE_CUR,
318         };
319         struct nfs_openres res = {
320                 .server = server,
321         };
322         struct  rpc_message msg = {
323                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR],
324                 .rpc_argp       = &arg,
325                 .rpc_resp       = &res,
326                 .rpc_cred       = sp->so_cred,
327         };
328         int status = 0;
329
330         if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
331                 goto out;
332         if (state->state == 0)
333                 goto out;
334         arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
335         status = -ENOMEM;
336         if (arg.seqid == NULL)
337                 goto out;
338         arg.open_flags = state->state;
339         memcpy(arg.u.delegation.data, state->stateid.data, sizeof(arg.u.delegation.data));
340         status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
341         nfs_increment_open_seqid(status, arg.seqid);
342         if (status != 0)
343                 goto out_free;
344         if(res.rflags & NFS4_OPEN_RESULT_CONFIRM) {
345                 status = _nfs4_proc_open_confirm(server->client, NFS_FH(inode),
346                                 sp, &res.stateid, arg.seqid);
347                 if (status != 0)
348                         goto out_free;
349         }
350         nfs_confirm_seqid(&sp->so_seqid, 0);
351         if (status >= 0) {
352                 memcpy(state->stateid.data, res.stateid.data,
353                                 sizeof(state->stateid.data));
354                 clear_bit(NFS_DELEGATED_STATE, &state->flags);
355         }
356 out_free:
357         nfs_free_seqid(arg.seqid);
358 out:
359         dput(parent);
360         return status;
361 }
362
363 int nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state *state)
364 {
365         struct nfs4_exception exception = { };
366         struct nfs_server *server = NFS_SERVER(dentry->d_inode);
367         int err;
368         do {
369                 err = _nfs4_open_delegation_recall(dentry, state);
370                 switch (err) {
371                         case 0:
372                                 return err;
373                         case -NFS4ERR_STALE_CLIENTID:
374                         case -NFS4ERR_STALE_STATEID:
375                         case -NFS4ERR_EXPIRED:
376                                 /* Don't recall a delegation if it was lost */
377                                 nfs4_schedule_state_recovery(server->nfs4_state);
378                                 return err;
379                 }
380                 err = nfs4_handle_exception(server, err, &exception);
381         } while (exception.retry);
382         return err;
383 }
384
385 static int _nfs4_proc_open_confirm(struct rpc_clnt *clnt, const struct nfs_fh *fh, struct nfs4_state_owner *sp, nfs4_stateid *stateid, struct nfs_seqid *seqid)
386 {
387         struct nfs_open_confirmargs arg = {
388                 .fh             = fh,
389                 .seqid          = seqid,
390                 .stateid        = *stateid,
391         };
392         struct nfs_open_confirmres res;
393         struct  rpc_message msg = {
394                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
395                 .rpc_argp       = &arg,
396                 .rpc_resp       = &res,
397                 .rpc_cred       = sp->so_cred,
398         };
399         int status;
400
401         status = rpc_call_sync(clnt, &msg, RPC_TASK_NOINTR);
402         /* Confirm the sequence as being established */
403         nfs_confirm_seqid(&sp->so_seqid, status);
404         nfs_increment_open_seqid(status, seqid);
405         if (status >= 0)
406                 memcpy(stateid, &res.stateid, sizeof(*stateid));
407         return status;
408 }
409
410 static int _nfs4_proc_open(struct inode *dir, struct nfs4_state_owner  *sp, struct nfs_openargs *o_arg, struct nfs_openres *o_res)
411 {
412         struct nfs_server *server = NFS_SERVER(dir);
413         struct rpc_message msg = {
414                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
415                 .rpc_argp = o_arg,
416                 .rpc_resp = o_res,
417                 .rpc_cred = sp->so_cred,
418         };
419         int status;
420
421         /* Update sequence id. The caller must serialize! */
422         o_arg->id = sp->so_id;
423         o_arg->clientid = sp->so_client->cl_clientid;
424
425         status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
426         if (status == 0) {
427                 /* OPEN on anything except a regular file is disallowed in NFSv4 */
428                 switch (o_res->f_attr->mode & S_IFMT) {
429                         case S_IFREG:
430                                 break;
431                         case S_IFLNK:
432                                 status = -ELOOP;
433                                 break;
434                         case S_IFDIR:
435                                 status = -EISDIR;
436                                 break;
437                         default:
438                                 status = -ENOTDIR;
439                 }
440         }
441
442         nfs_increment_open_seqid(status, o_arg->seqid);
443         if (status != 0)
444                 goto out;
445         if (o_arg->open_flags & O_CREAT) {
446                 update_changeattr(dir, &o_res->cinfo);
447                 nfs_post_op_update_inode(dir, o_res->dir_attr);
448         } else
449                 nfs_refresh_inode(dir, o_res->dir_attr);
450         if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
451                 status = _nfs4_proc_open_confirm(server->client, &o_res->fh,
452                                 sp, &o_res->stateid, o_arg->seqid);
453                 if (status != 0)
454                         goto out;
455         }
456         nfs_confirm_seqid(&sp->so_seqid, 0);
457         if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
458                 status = server->rpc_ops->getattr(server, &o_res->fh, o_res->f_attr);
459 out:
460         return status;
461 }
462
463 static int _nfs4_do_access(struct inode *inode, struct rpc_cred *cred, int openflags)
464 {
465         struct nfs_access_entry cache;
466         int mask = 0;
467         int status;
468
469         if (openflags & FMODE_READ)
470                 mask |= MAY_READ;
471         if (openflags & FMODE_WRITE)
472                 mask |= MAY_WRITE;
473         status = nfs_access_get_cached(inode, cred, &cache);
474         if (status == 0)
475                 goto out;
476
477         /* Be clever: ask server to check for all possible rights */
478         cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
479         cache.cred = cred;
480         cache.jiffies = jiffies;
481         status = _nfs4_proc_access(inode, &cache);
482         if (status != 0)
483                 return status;
484         nfs_access_add_cache(inode, &cache);
485 out:
486         if ((cache.mask & mask) == mask)
487                 return 0;
488         return -EACCES;
489 }
490
491 /*
492  * OPEN_EXPIRED:
493  *      reclaim state on the server after a network partition.
494  *      Assumes caller holds the appropriate lock
495  */
496 static int _nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state, struct dentry *dentry)
497 {
498         struct dentry *parent = dget_parent(dentry);
499         struct inode *dir = parent->d_inode;
500         struct inode *inode = state->inode;
501         struct nfs_server *server = NFS_SERVER(dir);
502         struct nfs_delegation *delegation = NFS_I(inode)->delegation;
503         struct nfs_fattr f_attr, dir_attr;
504         struct nfs_openargs o_arg = {
505                 .fh = NFS_FH(dir),
506                 .open_flags = state->state,
507                 .name = &dentry->d_name,
508                 .bitmask = server->attr_bitmask,
509                 .claim = NFS4_OPEN_CLAIM_NULL,
510         };
511         struct nfs_openres o_res = {
512                 .f_attr = &f_attr,
513                 .dir_attr = &dir_attr,
514                 .server = server,
515         };
516         int status = 0;
517
518         if (delegation != NULL && !(delegation->flags & NFS_DELEGATION_NEED_RECLAIM)) {
519                 status = _nfs4_do_access(inode, sp->so_cred, state->state);
520                 if (status < 0)
521                         goto out;
522                 memcpy(&state->stateid, &delegation->stateid, sizeof(state->stateid));
523                 set_bit(NFS_DELEGATED_STATE, &state->flags);
524                 goto out;
525         }
526         o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
527         status = -ENOMEM;
528         if (o_arg.seqid == NULL)
529                 goto out;
530         nfs_fattr_init(&f_attr);
531         nfs_fattr_init(&dir_attr);
532         status = _nfs4_proc_open(dir, sp, &o_arg, &o_res);
533         if (status != 0)
534                 goto out_nodeleg;
535         /* Check if files differ */
536         if ((f_attr.mode & S_IFMT) != (inode->i_mode & S_IFMT))
537                 goto out_stale;
538         /* Has the file handle changed? */
539         if (nfs_compare_fh(&o_res.fh, NFS_FH(inode)) != 0) {
540                 /* Verify if the change attributes are the same */
541                 if (f_attr.change_attr != NFS_I(inode)->change_attr)
542                         goto out_stale;
543                 if (nfs_size_to_loff_t(f_attr.size) != inode->i_size)
544                         goto out_stale;
545                 /* Lets just pretend that this is the same file */
546                 nfs_copy_fh(NFS_FH(inode), &o_res.fh);
547                 NFS_I(inode)->fileid = f_attr.fileid;
548         }
549         memcpy(&state->stateid, &o_res.stateid, sizeof(state->stateid));
550         if (o_res.delegation_type != 0) {
551                 if (!(delegation->flags & NFS_DELEGATION_NEED_RECLAIM))
552                         nfs_inode_set_delegation(inode, sp->so_cred, &o_res);
553                 else
554                         nfs_inode_reclaim_delegation(inode, sp->so_cred, &o_res);
555         }
556 out_nodeleg:
557         nfs_free_seqid(o_arg.seqid);
558         clear_bit(NFS_DELEGATED_STATE, &state->flags);
559 out:
560         dput(parent);
561         return status;
562 out_stale:
563         status = -ESTALE;
564         /* Invalidate the state owner so we don't ever use it again */
565         nfs4_drop_state_owner(sp);
566         d_drop(dentry);
567         /* Should we be trying to close that stateid? */
568         goto out_nodeleg;
569 }
570
571 static inline int nfs4_do_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state, struct dentry *dentry)
572 {
573         struct nfs_server *server = NFS_SERVER(dentry->d_inode);
574         struct nfs4_exception exception = { };
575         int err;
576
577         do {
578                 err = _nfs4_open_expired(sp, state, dentry);
579                 if (err == -NFS4ERR_DELAY)
580                         nfs4_handle_exception(server, err, &exception);
581         } while (exception.retry);
582         return err;
583 }
584
585 static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
586 {
587         struct nfs_inode *nfsi = NFS_I(state->inode);
588         struct nfs_open_context *ctx;
589         int status;
590
591         spin_lock(&state->inode->i_lock);
592         list_for_each_entry(ctx, &nfsi->open_files, list) {
593                 if (ctx->state != state)
594                         continue;
595                 get_nfs_open_context(ctx);
596                 spin_unlock(&state->inode->i_lock);
597                 status = nfs4_do_open_expired(sp, state, ctx->dentry);
598                 put_nfs_open_context(ctx);
599                 return status;
600         }
601         spin_unlock(&state->inode->i_lock);
602         return -ENOENT;
603 }
604
605 /*
606  * Returns an nfs4_state + an extra reference to the inode
607  */
608 static int _nfs4_open_delegated(struct inode *inode, int flags, struct rpc_cred *cred, struct nfs4_state **res)
609 {
610         struct nfs_delegation *delegation;
611         struct nfs_server *server = NFS_SERVER(inode);
612         struct nfs4_client *clp = server->nfs4_state;
613         struct nfs_inode *nfsi = NFS_I(inode);
614         struct nfs4_state_owner *sp = NULL;
615         struct nfs4_state *state = NULL;
616         int open_flags = flags & (FMODE_READ|FMODE_WRITE);
617         int err;
618
619         /* Protect against reboot recovery - NOTE ORDER! */
620         down_read(&clp->cl_sem);
621         /* Protect against delegation recall */
622         down_read(&nfsi->rwsem);
623         delegation = NFS_I(inode)->delegation;
624         err = -ENOENT;
625         if (delegation == NULL || (delegation->type & open_flags) != open_flags)
626                 goto out_err;
627         err = -ENOMEM;
628         if (!(sp = nfs4_get_state_owner(server, cred))) {
629                 dprintk("%s: nfs4_get_state_owner failed!\n", __FUNCTION__);
630                 goto out_err;
631         }
632         state = nfs4_get_open_state(inode, sp);
633         if (state == NULL)
634                 goto out_err;
635
636         err = -ENOENT;
637         if ((state->state & open_flags) == open_flags) {
638                 spin_lock(&inode->i_lock);
639                 if (open_flags & FMODE_READ)
640                         state->nreaders++;
641                 if (open_flags & FMODE_WRITE)
642                         state->nwriters++;
643                 spin_unlock(&inode->i_lock);
644                 goto out_ok;
645         } else if (state->state != 0)
646                 goto out_err;
647
648         lock_kernel();
649         err = _nfs4_do_access(inode, cred, open_flags);
650         unlock_kernel();
651         if (err != 0)
652                 goto out_err;
653         set_bit(NFS_DELEGATED_STATE, &state->flags);
654         update_open_stateid(state, &delegation->stateid, open_flags);
655 out_ok:
656         nfs4_put_state_owner(sp);
657         up_read(&nfsi->rwsem);
658         up_read(&clp->cl_sem);
659         igrab(inode);
660         *res = state;
661         return 0; 
662 out_err:
663         if (sp != NULL) {
664                 if (state != NULL)
665                         nfs4_put_open_state(state);
666                 nfs4_put_state_owner(sp);
667         }
668         up_read(&nfsi->rwsem);
669         up_read(&clp->cl_sem);
670         if (err != -EACCES)
671                 nfs_inode_return_delegation(inode);
672         return err;
673 }
674
675 static struct nfs4_state *nfs4_open_delegated(struct inode *inode, int flags, struct rpc_cred *cred)
676 {
677         struct nfs4_exception exception = { };
678         struct nfs4_state *res;
679         int err;
680
681         do {
682                 err = _nfs4_open_delegated(inode, flags, cred, &res);
683                 if (err == 0)
684                         break;
685                 res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(inode),
686                                         err, &exception));
687         } while (exception.retry);
688         return res;
689 }
690
691 /*
692  * Returns an nfs4_state + an referenced inode
693  */
694 static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
695 {
696         struct nfs4_state_owner  *sp;
697         struct nfs4_state     *state = NULL;
698         struct nfs_server       *server = NFS_SERVER(dir);
699         struct nfs4_client *clp = server->nfs4_state;
700         struct inode *inode = NULL;
701         int                     status;
702         struct nfs_fattr f_attr, dir_attr;
703         struct nfs_openargs o_arg = {
704                 .fh             = NFS_FH(dir),
705                 .open_flags     = flags,
706                 .name           = &dentry->d_name,
707                 .server         = server,
708                 .bitmask = server->attr_bitmask,
709                 .claim = NFS4_OPEN_CLAIM_NULL,
710         };
711         struct nfs_openres o_res = {
712                 .f_attr         = &f_attr,
713                 .dir_attr       = &dir_attr,
714                 .server         = server,
715         };
716
717         /* Protect against reboot recovery conflicts */
718         down_read(&clp->cl_sem);
719         status = -ENOMEM;
720         if (!(sp = nfs4_get_state_owner(server, cred))) {
721                 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
722                 goto out_err;
723         }
724         if (flags & O_EXCL) {
725                 u32 *p = (u32 *) o_arg.u.verifier.data;
726                 p[0] = jiffies;
727                 p[1] = current->pid;
728         } else
729                 o_arg.u.attrs = sattr;
730         /* Serialization for the sequence id */
731
732         o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
733         if (o_arg.seqid == NULL)
734                 return -ENOMEM;
735         nfs_fattr_init(&f_attr);
736         nfs_fattr_init(&dir_attr);
737         status = _nfs4_proc_open(dir, sp, &o_arg, &o_res);
738         if (status != 0)
739                 goto out_err;
740
741         status = -ENOMEM;
742         inode = nfs_fhget(dir->i_sb, &o_res.fh, &f_attr);
743         if (!inode)
744                 goto out_err;
745         state = nfs4_get_open_state(inode, sp);
746         if (!state)
747                 goto out_err;
748         update_open_stateid(state, &o_res.stateid, flags);
749         if (o_res.delegation_type != 0)
750                 nfs_inode_set_delegation(inode, cred, &o_res);
751         nfs_free_seqid(o_arg.seqid);
752         nfs4_put_state_owner(sp);
753         up_read(&clp->cl_sem);
754         *res = state;
755         return 0;
756 out_err:
757         if (sp != NULL) {
758                 if (state != NULL)
759                         nfs4_put_open_state(state);
760                 nfs_free_seqid(o_arg.seqid);
761                 nfs4_put_state_owner(sp);
762         }
763         /* Note: clp->cl_sem must be released before nfs4_put_open_state()! */
764         up_read(&clp->cl_sem);
765         if (inode != NULL)
766                 iput(inode);
767         *res = NULL;
768         return status;
769 }
770
771
772 static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, struct iattr *sattr, struct rpc_cred *cred)
773 {
774         struct nfs4_exception exception = { };
775         struct nfs4_state *res;
776         int status;
777
778         do {
779                 status = _nfs4_do_open(dir, dentry, flags, sattr, cred, &res);
780                 if (status == 0)
781                         break;
782                 /* NOTE: BAD_SEQID means the server and client disagree about the
783                  * book-keeping w.r.t. state-changing operations
784                  * (OPEN/CLOSE/LOCK/LOCKU...)
785                  * It is actually a sign of a bug on the client or on the server.
786                  *
787                  * If we receive a BAD_SEQID error in the particular case of
788                  * doing an OPEN, we assume that nfs_increment_open_seqid() will
789                  * have unhashed the old state_owner for us, and that we can
790                  * therefore safely retry using a new one. We should still warn
791                  * the user though...
792                  */
793                 if (status == -NFS4ERR_BAD_SEQID) {
794                         printk(KERN_WARNING "NFS: v4 server returned a bad sequence-id error!\n");
795                         exception.retry = 1;
796                         continue;
797                 }
798                 /*
799                  * BAD_STATEID on OPEN means that the server cancelled our
800                  * state before it received the OPEN_CONFIRM.
801                  * Recover by retrying the request as per the discussion
802                  * on Page 181 of RFC3530.
803                  */
804                 if (status == -NFS4ERR_BAD_STATEID) {
805                         exception.retry = 1;
806                         continue;
807                 }
808                 res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir),
809                                         status, &exception));
810         } while (exception.retry);
811         return res;
812 }
813
814 static int _nfs4_do_setattr(struct nfs_server *server, struct nfs_fattr *fattr,
815                 struct nfs_fh *fhandle, struct iattr *sattr,
816                 struct nfs4_state *state)
817 {
818         struct nfs_setattrargs  arg = {
819                 .fh             = fhandle,
820                 .iap            = sattr,
821                 .server         = server,
822                 .bitmask = server->attr_bitmask,
823         };
824         struct nfs_setattrres  res = {
825                 .fattr          = fattr,
826                 .server         = server,
827         };
828         struct rpc_message msg = {
829                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
830                 .rpc_argp       = &arg,
831                 .rpc_resp       = &res,
832         };
833         int status;
834
835         nfs_fattr_init(fattr);
836
837         if (state != NULL) {
838                 msg.rpc_cred = state->owner->so_cred;
839                 nfs4_copy_stateid(&arg.stateid, state, current->files);
840         } else
841                 memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid));
842
843         status = rpc_call_sync(server->client, &msg, 0);
844         return status;
845 }
846
847 static int nfs4_do_setattr(struct nfs_server *server, struct nfs_fattr *fattr,
848                 struct nfs_fh *fhandle, struct iattr *sattr,
849                 struct nfs4_state *state)
850 {
851         struct nfs4_exception exception = { };
852         int err;
853         do {
854                 err = nfs4_handle_exception(server,
855                                 _nfs4_do_setattr(server, fattr, fhandle, sattr,
856                                         state),
857                                 &exception);
858         } while (exception.retry);
859         return err;
860 }
861
862 struct nfs4_closedata {
863         struct inode *inode;
864         struct nfs4_state *state;
865         struct nfs_closeargs arg;
866         struct nfs_closeres res;
867         struct nfs_fattr fattr;
868 };
869
870 static void nfs4_free_closedata(struct nfs4_closedata *calldata)
871 {
872         struct nfs4_state *state = calldata->state;
873         struct nfs4_state_owner *sp = state->owner;
874
875         nfs4_put_open_state(calldata->state);
876         nfs_free_seqid(calldata->arg.seqid);
877         nfs4_put_state_owner(sp);
878         kfree(calldata);
879 }
880
881 static void nfs4_close_done(struct rpc_task *task)
882 {
883         struct nfs4_closedata *calldata = (struct nfs4_closedata *)task->tk_calldata;
884         struct nfs4_state *state = calldata->state;
885         struct nfs_server *server = NFS_SERVER(calldata->inode);
886
887         /* hmm. we are done with the inode, and in the process of freeing
888          * the state_owner. we keep this around to process errors
889          */
890         nfs_increment_open_seqid(task->tk_status, calldata->arg.seqid);
891         switch (task->tk_status) {
892                 case 0:
893                         memcpy(&state->stateid, &calldata->res.stateid,
894                                         sizeof(state->stateid));
895                         break;
896                 case -NFS4ERR_STALE_STATEID:
897                 case -NFS4ERR_EXPIRED:
898                         nfs4_schedule_state_recovery(server->nfs4_state);
899                         break;
900                 default:
901                         if (nfs4_async_handle_error(task, server) == -EAGAIN) {
902                                 rpc_restart_call(task);
903                                 return;
904                         }
905         }
906         nfs_refresh_inode(calldata->inode, calldata->res.fattr);
907         nfs4_free_closedata(calldata);
908 }
909
910 static void nfs4_close_begin(struct rpc_task *task)
911 {
912         struct nfs4_closedata *calldata = (struct nfs4_closedata *)task->tk_calldata;
913         struct nfs4_state *state = calldata->state;
914         struct rpc_message msg = {
915                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
916                 .rpc_argp = &calldata->arg,
917                 .rpc_resp = &calldata->res,
918                 .rpc_cred = state->owner->so_cred,
919         };
920         int mode = 0, old_mode;
921         int status;
922
923         status = nfs_wait_on_sequence(calldata->arg.seqid, task);
924         if (status != 0)
925                 return;
926         /* Recalculate the new open mode in case someone reopened the file
927          * while we were waiting in line to be scheduled.
928          */
929         spin_lock(&state->owner->so_lock);
930         spin_lock(&calldata->inode->i_lock);
931         mode = old_mode = state->state;
932         if (state->nreaders == 0)
933                 mode &= ~FMODE_READ;
934         if (state->nwriters == 0)
935                 mode &= ~FMODE_WRITE;
936         nfs4_state_set_mode_locked(state, mode);
937         spin_unlock(&calldata->inode->i_lock);
938         spin_unlock(&state->owner->so_lock);
939         if (mode == old_mode || test_bit(NFS_DELEGATED_STATE, &state->flags)) {
940                 nfs4_free_closedata(calldata);
941                 task->tk_exit = NULL;
942                 rpc_exit(task, 0);
943                 return;
944         }
945         nfs_fattr_init(calldata->res.fattr);
946         if (mode != 0)
947                 msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
948         calldata->arg.open_flags = mode;
949         rpc_call_setup(task, &msg, 0);
950 }
951
952 /* 
953  * It is possible for data to be read/written from a mem-mapped file 
954  * after the sys_close call (which hits the vfs layer as a flush).
955  * This means that we can't safely call nfsv4 close on a file until 
956  * the inode is cleared. This in turn means that we are not good
957  * NFSv4 citizens - we do not indicate to the server to update the file's 
958  * share state even when we are done with one of the three share 
959  * stateid's in the inode.
960  *
961  * NOTE: Caller must be holding the sp->so_owner semaphore!
962  */
963 int nfs4_do_close(struct inode *inode, struct nfs4_state *state) 
964 {
965         struct nfs_server *server = NFS_SERVER(inode);
966         struct nfs4_closedata *calldata;
967         int status = -ENOMEM;
968
969         calldata = kmalloc(sizeof(*calldata), GFP_KERNEL);
970         if (calldata == NULL)
971                 goto out;
972         calldata->inode = inode;
973         calldata->state = state;
974         calldata->arg.fh = NFS_FH(inode);
975         calldata->arg.stateid = &state->stateid;
976         /* Serialization for the sequence id */
977         calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid);
978         if (calldata->arg.seqid == NULL)
979                 goto out_free_calldata;
980         calldata->arg.bitmask = server->attr_bitmask;
981         calldata->res.fattr = &calldata->fattr;
982         calldata->res.server = server;
983
984         status = nfs4_call_async(server->client, nfs4_close_begin,
985                         nfs4_close_done, calldata);
986         if (status == 0)
987                 goto out;
988
989         nfs_free_seqid(calldata->arg.seqid);
990 out_free_calldata:
991         kfree(calldata);
992 out:
993         return status;
994 }
995
996 static void nfs4_intent_set_file(struct nameidata *nd, struct dentry *dentry, struct nfs4_state *state)
997 {
998         struct file *filp;
999
1000         filp = lookup_instantiate_filp(nd, dentry, NULL);
1001         if (!IS_ERR(filp)) {
1002                 struct nfs_open_context *ctx;
1003                 ctx = (struct nfs_open_context *)filp->private_data;
1004                 ctx->state = state;
1005         } else
1006                 nfs4_close_state(state, nd->intent.open.flags);
1007 }
1008
1009 struct dentry *
1010 nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
1011 {
1012         struct iattr attr;
1013         struct rpc_cred *cred;
1014         struct nfs4_state *state;
1015         struct dentry *res;
1016
1017         if (nd->flags & LOOKUP_CREATE) {
1018                 attr.ia_mode = nd->intent.open.create_mode;
1019                 attr.ia_valid = ATTR_MODE;
1020                 if (!IS_POSIXACL(dir))
1021                         attr.ia_mode &= ~current->fs->umask;
1022         } else {
1023                 attr.ia_valid = 0;
1024                 BUG_ON(nd->intent.open.flags & O_CREAT);
1025         }
1026
1027         cred = rpcauth_lookupcred(NFS_SERVER(dir)->client->cl_auth, 0);
1028         if (IS_ERR(cred))
1029                 return (struct dentry *)cred;
1030         state = nfs4_do_open(dir, dentry, nd->intent.open.flags, &attr, cred);
1031         put_rpccred(cred);
1032         if (IS_ERR(state)) {
1033                 if (PTR_ERR(state) == -ENOENT)
1034                         d_add(dentry, NULL);
1035                 return (struct dentry *)state;
1036         }
1037         res = d_add_unique(dentry, state->inode);
1038         if (res != NULL)
1039                 dentry = res;
1040         nfs4_intent_set_file(nd, dentry, state);
1041         return res;
1042 }
1043
1044 int
1045 nfs4_open_revalidate(struct inode *dir, struct dentry *dentry, int openflags, struct nameidata *nd)
1046 {
1047         struct rpc_cred *cred;
1048         struct nfs4_state *state;
1049         struct inode *inode;
1050
1051         cred = rpcauth_lookupcred(NFS_SERVER(dir)->client->cl_auth, 0);
1052         if (IS_ERR(cred))
1053                 return PTR_ERR(cred);
1054         state = nfs4_open_delegated(dentry->d_inode, openflags, cred);
1055         if (IS_ERR(state))
1056                 state = nfs4_do_open(dir, dentry, openflags, NULL, cred);
1057         put_rpccred(cred);
1058         if (IS_ERR(state)) {
1059                 switch (PTR_ERR(state)) {
1060                         case -EPERM:
1061                         case -EACCES:
1062                         case -EDQUOT:
1063                         case -ENOSPC:
1064                         case -EROFS:
1065                                 lookup_instantiate_filp(nd, (struct dentry *)state, NULL);
1066                                 return 1;
1067                         case -ENOENT:
1068                                 if (dentry->d_inode == NULL)
1069                                         return 1;
1070                 }
1071                 goto out_drop;
1072         }
1073         inode = state->inode;
1074         iput(inode);
1075         if (inode == dentry->d_inode) {
1076                 nfs4_intent_set_file(nd, dentry, state);
1077                 return 1;
1078         }
1079         nfs4_close_state(state, openflags);
1080 out_drop:
1081         d_drop(dentry);
1082         return 0;
1083 }
1084
1085
1086 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
1087 {
1088         struct nfs4_server_caps_res res = {};
1089         struct rpc_message msg = {
1090                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
1091                 .rpc_argp = fhandle,
1092                 .rpc_resp = &res,
1093         };
1094         int status;
1095
1096         status = rpc_call_sync(server->client, &msg, 0);
1097         if (status == 0) {
1098                 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
1099                 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL)
1100                         server->caps |= NFS_CAP_ACLS;
1101                 if (res.has_links != 0)
1102                         server->caps |= NFS_CAP_HARDLINKS;
1103                 if (res.has_symlinks != 0)
1104                         server->caps |= NFS_CAP_SYMLINKS;
1105                 server->acl_bitmask = res.acl_bitmask;
1106         }
1107         return status;
1108 }
1109
1110 static int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
1111 {
1112         struct nfs4_exception exception = { };
1113         int err;
1114         do {
1115                 err = nfs4_handle_exception(server,
1116                                 _nfs4_server_capabilities(server, fhandle),
1117                                 &exception);
1118         } while (exception.retry);
1119         return err;
1120 }
1121
1122 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
1123                 struct nfs_fsinfo *info)
1124 {
1125         struct nfs4_lookup_root_arg args = {
1126                 .bitmask = nfs4_fattr_bitmap,
1127         };
1128         struct nfs4_lookup_res res = {
1129                 .server = server,
1130                 .fattr = info->fattr,
1131                 .fh = fhandle,
1132         };
1133         struct rpc_message msg = {
1134                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
1135                 .rpc_argp = &args,
1136                 .rpc_resp = &res,
1137         };
1138         nfs_fattr_init(info->fattr);
1139         return rpc_call_sync(server->client, &msg, 0);
1140 }
1141
1142 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
1143                 struct nfs_fsinfo *info)
1144 {
1145         struct nfs4_exception exception = { };
1146         int err;
1147         do {
1148                 err = nfs4_handle_exception(server,
1149                                 _nfs4_lookup_root(server, fhandle, info),
1150                                 &exception);
1151         } while (exception.retry);
1152         return err;
1153 }
1154
1155 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
1156                 struct nfs_fsinfo *info)
1157 {
1158         struct nfs_fattr *      fattr = info->fattr;
1159         unsigned char *         p;
1160         struct qstr             q;
1161         struct nfs4_lookup_arg args = {
1162                 .dir_fh = fhandle,
1163                 .name = &q,
1164                 .bitmask = nfs4_fattr_bitmap,
1165         };
1166         struct nfs4_lookup_res res = {
1167                 .server = server,
1168                 .fattr = fattr,
1169                 .fh = fhandle,
1170         };
1171         struct rpc_message msg = {
1172                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
1173                 .rpc_argp = &args,
1174                 .rpc_resp = &res,
1175         };
1176         int status;
1177
1178         /*
1179          * Now we do a separate LOOKUP for each component of the mount path.
1180          * The LOOKUPs are done separately so that we can conveniently
1181          * catch an ERR_WRONGSEC if it occurs along the way...
1182          */
1183         status = nfs4_lookup_root(server, fhandle, info);
1184         if (status)
1185                 goto out;
1186
1187         p = server->mnt_path;
1188         for (;;) {
1189                 struct nfs4_exception exception = { };
1190
1191                 while (*p == '/')
1192                         p++;
1193                 if (!*p)
1194                         break;
1195                 q.name = p;
1196                 while (*p && (*p != '/'))
1197                         p++;
1198                 q.len = p - q.name;
1199
1200                 do {
1201                         nfs_fattr_init(fattr);
1202                         status = nfs4_handle_exception(server,
1203                                         rpc_call_sync(server->client, &msg, 0),
1204                                         &exception);
1205                 } while (exception.retry);
1206                 if (status == 0)
1207                         continue;
1208                 if (status == -ENOENT) {
1209                         printk(KERN_NOTICE "NFS: mount path %s does not exist!\n", server->mnt_path);
1210                         printk(KERN_NOTICE "NFS: suggestion: try mounting '/' instead.\n");
1211                 }
1212                 break;
1213         }
1214         if (status == 0)
1215                 status = nfs4_server_capabilities(server, fhandle);
1216         if (status == 0)
1217                 status = nfs4_do_fsinfo(server, fhandle, info);
1218 out:
1219         return status;
1220 }
1221
1222 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1223 {
1224         struct nfs4_getattr_arg args = {
1225                 .fh = fhandle,
1226                 .bitmask = server->attr_bitmask,
1227         };
1228         struct nfs4_getattr_res res = {
1229                 .fattr = fattr,
1230                 .server = server,
1231         };
1232         struct rpc_message msg = {
1233                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
1234                 .rpc_argp = &args,
1235                 .rpc_resp = &res,
1236         };
1237         
1238         nfs_fattr_init(fattr);
1239         return rpc_call_sync(server->client, &msg, 0);
1240 }
1241
1242 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1243 {
1244         struct nfs4_exception exception = { };
1245         int err;
1246         do {
1247                 err = nfs4_handle_exception(server,
1248                                 _nfs4_proc_getattr(server, fhandle, fattr),
1249                                 &exception);
1250         } while (exception.retry);
1251         return err;
1252 }
1253
1254 /* 
1255  * The file is not closed if it is opened due to the a request to change
1256  * the size of the file. The open call will not be needed once the
1257  * VFS layer lookup-intents are implemented.
1258  *
1259  * Close is called when the inode is destroyed.
1260  * If we haven't opened the file for O_WRONLY, we
1261  * need to in the size_change case to obtain a stateid.
1262  *
1263  * Got race?
1264  * Because OPEN is always done by name in nfsv4, it is
1265  * possible that we opened a different file by the same
1266  * name.  We can recognize this race condition, but we
1267  * can't do anything about it besides returning an error.
1268  *
1269  * This will be fixed with VFS changes (lookup-intent).
1270  */
1271 static int
1272 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
1273                   struct iattr *sattr)
1274 {
1275         struct rpc_cred *cred;
1276         struct inode *inode = dentry->d_inode;
1277         struct nfs_open_context *ctx;
1278         struct nfs4_state *state = NULL;
1279         int status;
1280
1281         nfs_fattr_init(fattr);
1282         
1283         cred = rpcauth_lookupcred(NFS_SERVER(inode)->client->cl_auth, 0);
1284         if (IS_ERR(cred))
1285                 return PTR_ERR(cred);
1286
1287         /* Search for an existing open(O_WRITE) file */
1288         ctx = nfs_find_open_context(inode, cred, FMODE_WRITE);
1289         if (ctx != NULL)
1290                 state = ctx->state;
1291
1292         status = nfs4_do_setattr(NFS_SERVER(inode), fattr,
1293                         NFS_FH(inode), sattr, state);
1294         if (status == 0)
1295                 nfs_setattr_update_inode(inode, sattr);
1296         if (ctx != NULL)
1297                 put_nfs_open_context(ctx);
1298         put_rpccred(cred);
1299         return status;
1300 }
1301
1302 static int _nfs4_proc_lookup(struct inode *dir, struct qstr *name,
1303                 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1304 {
1305         int                    status;
1306         struct nfs_server *server = NFS_SERVER(dir);
1307         struct nfs4_lookup_arg args = {
1308                 .bitmask = server->attr_bitmask,
1309                 .dir_fh = NFS_FH(dir),
1310                 .name = name,
1311         };
1312         struct nfs4_lookup_res res = {
1313                 .server = server,
1314                 .fattr = fattr,
1315                 .fh = fhandle,
1316         };
1317         struct rpc_message msg = {
1318                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
1319                 .rpc_argp = &args,
1320                 .rpc_resp = &res,
1321         };
1322         
1323         nfs_fattr_init(fattr);
1324         
1325         dprintk("NFS call  lookup %s\n", name->name);
1326         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
1327         dprintk("NFS reply lookup: %d\n", status);
1328         return status;
1329 }
1330
1331 static int nfs4_proc_lookup(struct inode *dir, struct qstr *name, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1332 {
1333         struct nfs4_exception exception = { };
1334         int err;
1335         do {
1336                 err = nfs4_handle_exception(NFS_SERVER(dir),
1337                                 _nfs4_proc_lookup(dir, name, fhandle, fattr),
1338                                 &exception);
1339         } while (exception.retry);
1340         return err;
1341 }
1342
1343 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
1344 {
1345         struct nfs4_accessargs args = {
1346                 .fh = NFS_FH(inode),
1347         };
1348         struct nfs4_accessres res = { 0 };
1349         struct rpc_message msg = {
1350                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
1351                 .rpc_argp = &args,
1352                 .rpc_resp = &res,
1353                 .rpc_cred = entry->cred,
1354         };
1355         int mode = entry->mask;
1356         int status;
1357
1358         /*
1359          * Determine which access bits we want to ask for...
1360          */
1361         if (mode & MAY_READ)
1362                 args.access |= NFS4_ACCESS_READ;
1363         if (S_ISDIR(inode->i_mode)) {
1364                 if (mode & MAY_WRITE)
1365                         args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
1366                 if (mode & MAY_EXEC)
1367                         args.access |= NFS4_ACCESS_LOOKUP;
1368         } else {
1369                 if (mode & MAY_WRITE)
1370                         args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
1371                 if (mode & MAY_EXEC)
1372                         args.access |= NFS4_ACCESS_EXECUTE;
1373         }
1374         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
1375         if (!status) {
1376                 entry->mask = 0;
1377                 if (res.access & NFS4_ACCESS_READ)
1378                         entry->mask |= MAY_READ;
1379                 if (res.access & (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))
1380                         entry->mask |= MAY_WRITE;
1381                 if (res.access & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))
1382                         entry->mask |= MAY_EXEC;
1383         }
1384         return status;
1385 }
1386
1387 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
1388 {
1389         struct nfs4_exception exception = { };
1390         int err;
1391         do {
1392                 err = nfs4_handle_exception(NFS_SERVER(inode),
1393                                 _nfs4_proc_access(inode, entry),
1394                                 &exception);
1395         } while (exception.retry);
1396         return err;
1397 }
1398
1399 /*
1400  * TODO: For the time being, we don't try to get any attributes
1401  * along with any of the zero-copy operations READ, READDIR,
1402  * READLINK, WRITE.
1403  *
1404  * In the case of the first three, we want to put the GETATTR
1405  * after the read-type operation -- this is because it is hard
1406  * to predict the length of a GETATTR response in v4, and thus
1407  * align the READ data correctly.  This means that the GETATTR
1408  * may end up partially falling into the page cache, and we should
1409  * shift it into the 'tail' of the xdr_buf before processing.
1410  * To do this efficiently, we need to know the total length
1411  * of data received, which doesn't seem to be available outside
1412  * of the RPC layer.
1413  *
1414  * In the case of WRITE, we also want to put the GETATTR after
1415  * the operation -- in this case because we want to make sure
1416  * we get the post-operation mtime and size.  This means that
1417  * we can't use xdr_encode_pages() as written: we need a variant
1418  * of it which would leave room in the 'tail' iovec.
1419  *
1420  * Both of these changes to the XDR layer would in fact be quite
1421  * minor, but I decided to leave them for a subsequent patch.
1422  */
1423 static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
1424                 unsigned int pgbase, unsigned int pglen)
1425 {
1426         struct nfs4_readlink args = {
1427                 .fh       = NFS_FH(inode),
1428                 .pgbase   = pgbase,
1429                 .pglen    = pglen,
1430                 .pages    = &page,
1431         };
1432         struct rpc_message msg = {
1433                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
1434                 .rpc_argp = &args,
1435                 .rpc_resp = NULL,
1436         };
1437
1438         return rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
1439 }
1440
1441 static int nfs4_proc_readlink(struct inode *inode, struct page *page,
1442                 unsigned int pgbase, unsigned int pglen)
1443 {
1444         struct nfs4_exception exception = { };
1445         int err;
1446         do {
1447                 err = nfs4_handle_exception(NFS_SERVER(inode),
1448                                 _nfs4_proc_readlink(inode, page, pgbase, pglen),
1449                                 &exception);
1450         } while (exception.retry);
1451         return err;
1452 }
1453
1454 static int _nfs4_proc_read(struct nfs_read_data *rdata)
1455 {
1456         int flags = rdata->flags;
1457         struct inode *inode = rdata->inode;
1458         struct nfs_fattr *fattr = rdata->res.fattr;
1459         struct nfs_server *server = NFS_SERVER(inode);
1460         struct rpc_message msg = {
1461                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_READ],
1462                 .rpc_argp       = &rdata->args,
1463                 .rpc_resp       = &rdata->res,
1464                 .rpc_cred       = rdata->cred,
1465         };
1466         unsigned long timestamp = jiffies;
1467         int status;
1468
1469         dprintk("NFS call  read %d @ %Ld\n", rdata->args.count,
1470                         (long long) rdata->args.offset);
1471
1472         nfs_fattr_init(fattr);
1473         status = rpc_call_sync(server->client, &msg, flags);
1474         if (!status)
1475                 renew_lease(server, timestamp);
1476         dprintk("NFS reply read: %d\n", status);
1477         return status;
1478 }
1479
1480 static int nfs4_proc_read(struct nfs_read_data *rdata)
1481 {
1482         struct nfs4_exception exception = { };
1483         int err;
1484         do {
1485                 err = nfs4_handle_exception(NFS_SERVER(rdata->inode),
1486                                 _nfs4_proc_read(rdata),
1487                                 &exception);
1488         } while (exception.retry);
1489         return err;
1490 }
1491
1492 static int _nfs4_proc_write(struct nfs_write_data *wdata)
1493 {
1494         int rpcflags = wdata->flags;
1495         struct inode *inode = wdata->inode;
1496         struct nfs_fattr *fattr = wdata->res.fattr;
1497         struct nfs_server *server = NFS_SERVER(inode);
1498         struct rpc_message msg = {
1499                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_WRITE],
1500                 .rpc_argp       = &wdata->args,
1501                 .rpc_resp       = &wdata->res,
1502                 .rpc_cred       = wdata->cred,
1503         };
1504         int status;
1505
1506         dprintk("NFS call  write %d @ %Ld\n", wdata->args.count,
1507                         (long long) wdata->args.offset);
1508
1509         wdata->args.bitmask = server->attr_bitmask;
1510         wdata->res.server = server;
1511         nfs_fattr_init(fattr);
1512         status = rpc_call_sync(server->client, &msg, rpcflags);
1513         dprintk("NFS reply write: %d\n", status);
1514         if (status < 0)
1515                 return status;
1516         nfs_post_op_update_inode(inode, fattr);
1517         return wdata->res.count;
1518 }
1519
1520 static int nfs4_proc_write(struct nfs_write_data *wdata)
1521 {
1522         struct nfs4_exception exception = { };
1523         int err;
1524         do {
1525                 err = nfs4_handle_exception(NFS_SERVER(wdata->inode),
1526                                 _nfs4_proc_write(wdata),
1527                                 &exception);
1528         } while (exception.retry);
1529         return err;
1530 }
1531
1532 static int _nfs4_proc_commit(struct nfs_write_data *cdata)
1533 {
1534         struct inode *inode = cdata->inode;
1535         struct nfs_fattr *fattr = cdata->res.fattr;
1536         struct nfs_server *server = NFS_SERVER(inode);
1537         struct rpc_message msg = {
1538                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_COMMIT],
1539                 .rpc_argp       = &cdata->args,
1540                 .rpc_resp       = &cdata->res,
1541                 .rpc_cred       = cdata->cred,
1542         };
1543         int status;
1544
1545         dprintk("NFS call  commit %d @ %Ld\n", cdata->args.count,
1546                         (long long) cdata->args.offset);
1547
1548         cdata->args.bitmask = server->attr_bitmask;
1549         cdata->res.server = server;
1550         nfs_fattr_init(fattr);
1551         status = rpc_call_sync(server->client, &msg, 0);
1552         dprintk("NFS reply commit: %d\n", status);
1553         if (status >= 0)
1554                 nfs_post_op_update_inode(inode, fattr);
1555         return status;
1556 }
1557
1558 static int nfs4_proc_commit(struct nfs_write_data *cdata)
1559 {
1560         struct nfs4_exception exception = { };
1561         int err;
1562         do {
1563                 err = nfs4_handle_exception(NFS_SERVER(cdata->inode),
1564                                 _nfs4_proc_commit(cdata),
1565                                 &exception);
1566         } while (exception.retry);
1567         return err;
1568 }
1569
1570 /*
1571  * Got race?
1572  * We will need to arrange for the VFS layer to provide an atomic open.
1573  * Until then, this create/open method is prone to inefficiency and race
1574  * conditions due to the lookup, create, and open VFS calls from sys_open()
1575  * placed on the wire.
1576  *
1577  * Given the above sorry state of affairs, I'm simply sending an OPEN.
1578  * The file will be opened again in the subsequent VFS open call
1579  * (nfs4_proc_file_open).
1580  *
1581  * The open for read will just hang around to be used by any process that
1582  * opens the file O_RDONLY. This will all be resolved with the VFS changes.
1583  */
1584
1585 static int
1586 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
1587                  int flags, struct nameidata *nd)
1588 {
1589         struct nfs4_state *state;
1590         struct rpc_cred *cred;
1591         int status = 0;
1592
1593         cred = rpcauth_lookupcred(NFS_SERVER(dir)->client->cl_auth, 0);
1594         if (IS_ERR(cred)) {
1595                 status = PTR_ERR(cred);
1596                 goto out;
1597         }
1598         state = nfs4_do_open(dir, dentry, flags, sattr, cred);
1599         put_rpccred(cred);
1600         if (IS_ERR(state)) {
1601                 status = PTR_ERR(state);
1602                 goto out;
1603         }
1604         d_instantiate(dentry, state->inode);
1605         if (flags & O_EXCL) {
1606                 struct nfs_fattr fattr;
1607                 status = nfs4_do_setattr(NFS_SERVER(dir), &fattr,
1608                                      NFS_FH(state->inode), sattr, state);
1609                 if (status == 0)
1610                         nfs_setattr_update_inode(state->inode, sattr);
1611         }
1612         if (status == 0 && nd != NULL && (nd->flags & LOOKUP_OPEN))
1613                 nfs4_intent_set_file(nd, dentry, state);
1614         else
1615                 nfs4_close_state(state, flags);
1616 out:
1617         return status;
1618 }
1619
1620 static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
1621 {
1622         struct nfs_server *server = NFS_SERVER(dir);
1623         struct nfs4_remove_arg args = {
1624                 .fh = NFS_FH(dir),
1625                 .name = name,
1626                 .bitmask = server->attr_bitmask,
1627         };
1628         struct nfs_fattr dir_attr;
1629         struct nfs4_remove_res  res = {
1630                 .server = server,
1631                 .dir_attr = &dir_attr,
1632         };
1633         struct rpc_message msg = {
1634                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
1635                 .rpc_argp       = &args,
1636                 .rpc_resp       = &res,
1637         };
1638         int                     status;
1639
1640         nfs_fattr_init(res.dir_attr);
1641         status = rpc_call_sync(server->client, &msg, 0);
1642         if (status == 0) {
1643                 update_changeattr(dir, &res.cinfo);
1644                 nfs_post_op_update_inode(dir, res.dir_attr);
1645         }
1646         return status;
1647 }
1648
1649 static int nfs4_proc_remove(struct inode *dir, struct qstr *name)
1650 {
1651         struct nfs4_exception exception = { };
1652         int err;
1653         do {
1654                 err = nfs4_handle_exception(NFS_SERVER(dir),
1655                                 _nfs4_proc_remove(dir, name),
1656                                 &exception);
1657         } while (exception.retry);
1658         return err;
1659 }
1660
1661 struct unlink_desc {
1662         struct nfs4_remove_arg  args;
1663         struct nfs4_remove_res  res;
1664         struct nfs_fattr dir_attr;
1665 };
1666
1667 static int nfs4_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir,
1668                 struct qstr *name)
1669 {
1670         struct nfs_server *server = NFS_SERVER(dir->d_inode);
1671         struct unlink_desc *up;
1672
1673         up = (struct unlink_desc *) kmalloc(sizeof(*up), GFP_KERNEL);
1674         if (!up)
1675                 return -ENOMEM;
1676         
1677         up->args.fh = NFS_FH(dir->d_inode);
1678         up->args.name = name;
1679         up->args.bitmask = server->attr_bitmask;
1680         up->res.server = server;
1681         up->res.dir_attr = &up->dir_attr;
1682         
1683         msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
1684         msg->rpc_argp = &up->args;
1685         msg->rpc_resp = &up->res;
1686         return 0;
1687 }
1688
1689 static int nfs4_proc_unlink_done(struct dentry *dir, struct rpc_task *task)
1690 {
1691         struct rpc_message *msg = &task->tk_msg;
1692         struct unlink_desc *up;
1693         
1694         if (msg->rpc_resp != NULL) {
1695                 up = container_of(msg->rpc_resp, struct unlink_desc, res);
1696                 update_changeattr(dir->d_inode, &up->res.cinfo);
1697                 nfs_post_op_update_inode(dir->d_inode, up->res.dir_attr);
1698                 kfree(up);
1699                 msg->rpc_resp = NULL;
1700                 msg->rpc_argp = NULL;
1701         }
1702         return 0;
1703 }
1704
1705 static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
1706                 struct inode *new_dir, struct qstr *new_name)
1707 {
1708         struct nfs_server *server = NFS_SERVER(old_dir);
1709         struct nfs4_rename_arg arg = {
1710                 .old_dir = NFS_FH(old_dir),
1711                 .new_dir = NFS_FH(new_dir),
1712                 .old_name = old_name,
1713                 .new_name = new_name,
1714                 .bitmask = server->attr_bitmask,
1715         };
1716         struct nfs_fattr old_fattr, new_fattr;
1717         struct nfs4_rename_res res = {
1718                 .server = server,
1719                 .old_fattr = &old_fattr,
1720                 .new_fattr = &new_fattr,
1721         };
1722         struct rpc_message msg = {
1723                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME],
1724                 .rpc_argp = &arg,
1725                 .rpc_resp = &res,
1726         };
1727         int                     status;
1728         
1729         nfs_fattr_init(res.old_fattr);
1730         nfs_fattr_init(res.new_fattr);
1731         status = rpc_call_sync(server->client, &msg, 0);
1732
1733         if (!status) {
1734                 update_changeattr(old_dir, &res.old_cinfo);
1735                 nfs_post_op_update_inode(old_dir, res.old_fattr);
1736                 update_changeattr(new_dir, &res.new_cinfo);
1737                 nfs_post_op_update_inode(new_dir, res.new_fattr);
1738         }
1739         return status;
1740 }
1741
1742 static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
1743                 struct inode *new_dir, struct qstr *new_name)
1744 {
1745         struct nfs4_exception exception = { };
1746         int err;
1747         do {
1748                 err = nfs4_handle_exception(NFS_SERVER(old_dir),
1749                                 _nfs4_proc_rename(old_dir, old_name,
1750                                         new_dir, new_name),
1751                                 &exception);
1752         } while (exception.retry);
1753         return err;
1754 }
1755
1756 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
1757 {
1758         struct nfs_server *server = NFS_SERVER(inode);
1759         struct nfs4_link_arg arg = {
1760                 .fh     = NFS_FH(inode),
1761                 .dir_fh = NFS_FH(dir),
1762                 .name   = name,
1763                 .bitmask = server->attr_bitmask,
1764         };
1765         struct nfs_fattr fattr, dir_attr;
1766         struct nfs4_link_res res = {
1767                 .server = server,
1768                 .fattr = &fattr,
1769                 .dir_attr = &dir_attr,
1770         };
1771         struct rpc_message msg = {
1772                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
1773                 .rpc_argp = &arg,
1774                 .rpc_resp = &res,
1775         };
1776         int                     status;
1777
1778         nfs_fattr_init(res.fattr);
1779         nfs_fattr_init(res.dir_attr);
1780         status = rpc_call_sync(server->client, &msg, 0);
1781         if (!status) {
1782                 update_changeattr(dir, &res.cinfo);
1783                 nfs_post_op_update_inode(dir, res.dir_attr);
1784                 nfs_refresh_inode(inode, res.fattr);
1785         }
1786
1787         return status;
1788 }
1789
1790 static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
1791 {
1792         struct nfs4_exception exception = { };
1793         int err;
1794         do {
1795                 err = nfs4_handle_exception(NFS_SERVER(inode),
1796                                 _nfs4_proc_link(inode, dir, name),
1797                                 &exception);
1798         } while (exception.retry);
1799         return err;
1800 }
1801
1802 static int _nfs4_proc_symlink(struct inode *dir, struct qstr *name,
1803                 struct qstr *path, struct iattr *sattr, struct nfs_fh *fhandle,
1804                 struct nfs_fattr *fattr)
1805 {
1806         struct nfs_server *server = NFS_SERVER(dir);
1807         struct nfs_fattr dir_fattr;
1808         struct nfs4_create_arg arg = {
1809                 .dir_fh = NFS_FH(dir),
1810                 .server = server,
1811                 .name = name,
1812                 .attrs = sattr,
1813                 .ftype = NF4LNK,
1814                 .bitmask = server->attr_bitmask,
1815         };
1816         struct nfs4_create_res res = {
1817                 .server = server,
1818                 .fh = fhandle,
1819                 .fattr = fattr,
1820                 .dir_fattr = &dir_fattr,
1821         };
1822         struct rpc_message msg = {
1823                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK],
1824                 .rpc_argp = &arg,
1825                 .rpc_resp = &res,
1826         };
1827         int                     status;
1828
1829         if (path->len > NFS4_MAXPATHLEN)
1830                 return -ENAMETOOLONG;
1831         arg.u.symlink = path;
1832         nfs_fattr_init(fattr);
1833         nfs_fattr_init(&dir_fattr);
1834         
1835         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
1836         if (!status)
1837                 update_changeattr(dir, &res.dir_cinfo);
1838         nfs_post_op_update_inode(dir, res.dir_fattr);
1839         return status;
1840 }
1841
1842 static int nfs4_proc_symlink(struct inode *dir, struct qstr *name,
1843                 struct qstr *path, struct iattr *sattr, struct nfs_fh *fhandle,
1844                 struct nfs_fattr *fattr)
1845 {
1846         struct nfs4_exception exception = { };
1847         int err;
1848         do {
1849                 err = nfs4_handle_exception(NFS_SERVER(dir),
1850                                 _nfs4_proc_symlink(dir, name, path, sattr,
1851                                         fhandle, fattr),
1852                                 &exception);
1853         } while (exception.retry);
1854         return err;
1855 }
1856
1857 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
1858                 struct iattr *sattr)
1859 {
1860         struct nfs_server *server = NFS_SERVER(dir);
1861         struct nfs_fh fhandle;
1862         struct nfs_fattr fattr, dir_fattr;
1863         struct nfs4_create_arg arg = {
1864                 .dir_fh = NFS_FH(dir),
1865                 .server = server,
1866                 .name = &dentry->d_name,
1867                 .attrs = sattr,
1868                 .ftype = NF4DIR,
1869                 .bitmask = server->attr_bitmask,
1870         };
1871         struct nfs4_create_res res = {
1872                 .server = server,
1873                 .fh = &fhandle,
1874                 .fattr = &fattr,
1875                 .dir_fattr = &dir_fattr,
1876         };
1877         struct rpc_message msg = {
1878                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE],
1879                 .rpc_argp = &arg,
1880                 .rpc_resp = &res,
1881         };
1882         int                     status;
1883
1884         nfs_fattr_init(&fattr);
1885         nfs_fattr_init(&dir_fattr);
1886         
1887         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
1888         if (!status) {
1889                 update_changeattr(dir, &res.dir_cinfo);
1890                 nfs_post_op_update_inode(dir, res.dir_fattr);
1891                 status = nfs_instantiate(dentry, &fhandle, &fattr);
1892         }
1893         return status;
1894 }
1895
1896 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
1897                 struct iattr *sattr)
1898 {
1899         struct nfs4_exception exception = { };
1900         int err;
1901         do {
1902                 err = nfs4_handle_exception(NFS_SERVER(dir),
1903                                 _nfs4_proc_mkdir(dir, dentry, sattr),
1904                                 &exception);
1905         } while (exception.retry);
1906         return err;
1907 }
1908
1909 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
1910                   u64 cookie, struct page *page, unsigned int count, int plus)
1911 {
1912         struct inode            *dir = dentry->d_inode;
1913         struct nfs4_readdir_arg args = {
1914                 .fh = NFS_FH(dir),
1915                 .pages = &page,
1916                 .pgbase = 0,
1917                 .count = count,
1918                 .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
1919         };
1920         struct nfs4_readdir_res res;
1921         struct rpc_message msg = {
1922                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
1923                 .rpc_argp = &args,
1924                 .rpc_resp = &res,
1925                 .rpc_cred = cred,
1926         };
1927         int                     status;
1928
1929         dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __FUNCTION__,
1930                         dentry->d_parent->d_name.name,
1931                         dentry->d_name.name,
1932                         (unsigned long long)cookie);
1933         lock_kernel();
1934         nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args);
1935         res.pgbase = args.pgbase;
1936         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
1937         if (status == 0)
1938                 memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE);
1939         unlock_kernel();
1940         dprintk("%s: returns %d\n", __FUNCTION__, status);
1941         return status;
1942 }
1943
1944 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
1945                   u64 cookie, struct page *page, unsigned int count, int plus)
1946 {
1947         struct nfs4_exception exception = { };
1948         int err;
1949         do {
1950                 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode),
1951                                 _nfs4_proc_readdir(dentry, cred, cookie,
1952                                         page, count, plus),
1953                                 &exception);
1954         } while (exception.retry);
1955         return err;
1956 }
1957
1958 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
1959                 struct iattr *sattr, dev_t rdev)
1960 {
1961         struct nfs_server *server = NFS_SERVER(dir);
1962         struct nfs_fh fh;
1963         struct nfs_fattr fattr, dir_fattr;
1964         struct nfs4_create_arg arg = {
1965                 .dir_fh = NFS_FH(dir),
1966                 .server = server,
1967                 .name = &dentry->d_name,
1968                 .attrs = sattr,
1969                 .bitmask = server->attr_bitmask,
1970         };
1971         struct nfs4_create_res res = {
1972                 .server = server,
1973                 .fh = &fh,
1974                 .fattr = &fattr,
1975                 .dir_fattr = &dir_fattr,
1976         };
1977         struct rpc_message msg = {
1978                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE],
1979                 .rpc_argp = &arg,
1980                 .rpc_resp = &res,
1981         };
1982         int                     status;
1983         int                     mode = sattr->ia_mode;
1984
1985         nfs_fattr_init(&fattr);
1986         nfs_fattr_init(&dir_fattr);
1987
1988         BUG_ON(!(sattr->ia_valid & ATTR_MODE));
1989         BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode));
1990         if (S_ISFIFO(mode))
1991                 arg.ftype = NF4FIFO;
1992         else if (S_ISBLK(mode)) {
1993                 arg.ftype = NF4BLK;
1994                 arg.u.device.specdata1 = MAJOR(rdev);
1995                 arg.u.device.specdata2 = MINOR(rdev);
1996         }
1997         else if (S_ISCHR(mode)) {
1998                 arg.ftype = NF4CHR;
1999                 arg.u.device.specdata1 = MAJOR(rdev);
2000                 arg.u.device.specdata2 = MINOR(rdev);
2001         }
2002         else
2003                 arg.ftype = NF4SOCK;
2004         
2005         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
2006         if (status == 0) {
2007                 update_changeattr(dir, &res.dir_cinfo);
2008                 nfs_post_op_update_inode(dir, res.dir_fattr);
2009                 status = nfs_instantiate(dentry, &fh, &fattr);
2010         }
2011         return status;
2012 }
2013
2014 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
2015                 struct iattr *sattr, dev_t rdev)
2016 {
2017         struct nfs4_exception exception = { };
2018         int err;
2019         do {
2020                 err = nfs4_handle_exception(NFS_SERVER(dir),
2021                                 _nfs4_proc_mknod(dir, dentry, sattr, rdev),
2022                                 &exception);
2023         } while (exception.retry);
2024         return err;
2025 }
2026
2027 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
2028                  struct nfs_fsstat *fsstat)
2029 {
2030         struct nfs4_statfs_arg args = {
2031                 .fh = fhandle,
2032                 .bitmask = server->attr_bitmask,
2033         };
2034         struct rpc_message msg = {
2035                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
2036                 .rpc_argp = &args,
2037                 .rpc_resp = fsstat,
2038         };
2039
2040         nfs_fattr_init(fsstat->fattr);
2041         return rpc_call_sync(server->client, &msg, 0);
2042 }
2043
2044 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
2045 {
2046         struct nfs4_exception exception = { };
2047         int err;
2048         do {
2049                 err = nfs4_handle_exception(server,
2050                                 _nfs4_proc_statfs(server, fhandle, fsstat),
2051                                 &exception);
2052         } while (exception.retry);
2053         return err;
2054 }
2055
2056 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
2057                 struct nfs_fsinfo *fsinfo)
2058 {
2059         struct nfs4_fsinfo_arg args = {
2060                 .fh = fhandle,
2061                 .bitmask = server->attr_bitmask,
2062         };
2063         struct rpc_message msg = {
2064                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
2065                 .rpc_argp = &args,
2066                 .rpc_resp = fsinfo,
2067         };
2068
2069         return rpc_call_sync(server->client, &msg, 0);
2070 }
2071
2072 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
2073 {
2074         struct nfs4_exception exception = { };
2075         int err;
2076
2077         do {
2078                 err = nfs4_handle_exception(server,
2079                                 _nfs4_do_fsinfo(server, fhandle, fsinfo),
2080                                 &exception);
2081         } while (exception.retry);
2082         return err;
2083 }
2084
2085 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
2086 {
2087         nfs_fattr_init(fsinfo->fattr);
2088         return nfs4_do_fsinfo(server, fhandle, fsinfo);
2089 }
2090
2091 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
2092                 struct nfs_pathconf *pathconf)
2093 {
2094         struct nfs4_pathconf_arg args = {
2095                 .fh = fhandle,
2096                 .bitmask = server->attr_bitmask,
2097         };
2098         struct rpc_message msg = {
2099                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
2100                 .rpc_argp = &args,
2101                 .rpc_resp = pathconf,
2102         };
2103
2104         /* None of the pathconf attributes are mandatory to implement */
2105         if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
2106                 memset(pathconf, 0, sizeof(*pathconf));
2107                 return 0;
2108         }
2109
2110         nfs_fattr_init(pathconf->fattr);
2111         return rpc_call_sync(server->client, &msg, 0);
2112 }
2113
2114 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
2115                 struct nfs_pathconf *pathconf)
2116 {
2117         struct nfs4_exception exception = { };
2118         int err;
2119
2120         do {
2121                 err = nfs4_handle_exception(server,
2122                                 _nfs4_proc_pathconf(server, fhandle, pathconf),
2123                                 &exception);
2124         } while (exception.retry);
2125         return err;
2126 }
2127
2128 static void
2129 nfs4_read_done(struct rpc_task *task)
2130 {
2131         struct nfs_read_data *data = (struct nfs_read_data *) task->tk_calldata;
2132         struct inode *inode = data->inode;
2133
2134         if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {
2135                 rpc_restart_call(task);
2136                 return;
2137         }
2138         if (task->tk_status > 0)
2139                 renew_lease(NFS_SERVER(inode), data->timestamp);
2140         /* Call back common NFS readpage processing */
2141         nfs_readpage_result(task);
2142 }
2143
2144 static void
2145 nfs4_proc_read_setup(struct nfs_read_data *data)
2146 {
2147         struct rpc_task *task = &data->task;
2148         struct rpc_message msg = {
2149                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ],
2150                 .rpc_argp = &data->args,
2151                 .rpc_resp = &data->res,
2152                 .rpc_cred = data->cred,
2153         };
2154         struct inode *inode = data->inode;
2155         int flags;
2156
2157         data->timestamp   = jiffies;
2158
2159         /* N.B. Do we need to test? Never called for swapfile inode */
2160         flags = RPC_TASK_ASYNC | (IS_SWAPFILE(inode)? NFS_RPC_SWAPFLAGS : 0);
2161
2162         /* Finalize the task. */
2163         rpc_init_task(task, NFS_CLIENT(inode), nfs4_read_done, flags);
2164         rpc_call_setup(task, &msg, 0);
2165 }
2166
2167 static void
2168 nfs4_write_done(struct rpc_task *task)
2169 {
2170         struct nfs_write_data *data = (struct nfs_write_data *) task->tk_calldata;
2171         struct inode *inode = data->inode;
2172         
2173         if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {
2174                 rpc_restart_call(task);
2175                 return;
2176         }
2177         if (task->tk_status >= 0) {
2178                 renew_lease(NFS_SERVER(inode), data->timestamp);
2179                 nfs_post_op_update_inode(inode, data->res.fattr);
2180         }
2181         /* Call back common NFS writeback processing */
2182         nfs_writeback_done(task);
2183 }
2184
2185 static void
2186 nfs4_proc_write_setup(struct nfs_write_data *data, int how)
2187 {
2188         struct rpc_task *task = &data->task;
2189         struct rpc_message msg = {
2190                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE],
2191                 .rpc_argp = &data->args,
2192                 .rpc_resp = &data->res,
2193                 .rpc_cred = data->cred,
2194         };
2195         struct inode *inode = data->inode;
2196         struct nfs_server *server = NFS_SERVER(inode);
2197         int stable;
2198         int flags;
2199         
2200         if (how & FLUSH_STABLE) {
2201                 if (!NFS_I(inode)->ncommit)
2202                         stable = NFS_FILE_SYNC;
2203                 else
2204                         stable = NFS_DATA_SYNC;
2205         } else
2206                 stable = NFS_UNSTABLE;
2207         data->args.stable = stable;
2208         data->args.bitmask = server->attr_bitmask;
2209         data->res.server = server;
2210
2211         data->timestamp   = jiffies;
2212
2213         /* Set the initial flags for the task.  */
2214         flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
2215
2216         /* Finalize the task. */
2217         rpc_init_task(task, NFS_CLIENT(inode), nfs4_write_done, flags);
2218         rpc_call_setup(task, &msg, 0);
2219 }
2220
2221 static void
2222 nfs4_commit_done(struct rpc_task *task)
2223 {
2224         struct nfs_write_data *data = (struct nfs_write_data *) task->tk_calldata;
2225         struct inode *inode = data->inode;
2226         
2227         if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {
2228                 rpc_restart_call(task);
2229                 return;
2230         }
2231         if (task->tk_status >= 0)
2232                 nfs_post_op_update_inode(inode, data->res.fattr);
2233         /* Call back common NFS writeback processing */
2234         nfs_commit_done(task);
2235 }
2236
2237 static void
2238 nfs4_proc_commit_setup(struct nfs_write_data *data, int how)
2239 {
2240         struct rpc_task *task = &data->task;
2241         struct rpc_message msg = {
2242                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT],
2243                 .rpc_argp = &data->args,
2244                 .rpc_resp = &data->res,
2245                 .rpc_cred = data->cred,
2246         };      
2247         struct inode *inode = data->inode;
2248         struct nfs_server *server = NFS_SERVER(inode);
2249         int flags;
2250         
2251         data->args.bitmask = server->attr_bitmask;
2252         data->res.server = server;
2253
2254         /* Set the initial flags for the task.  */
2255         flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
2256
2257         /* Finalize the task. */
2258         rpc_init_task(task, NFS_CLIENT(inode), nfs4_commit_done, flags);
2259         rpc_call_setup(task, &msg, 0);  
2260 }
2261
2262 /*
2263  * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
2264  * standalone procedure for queueing an asynchronous RENEW.
2265  */
2266 static void
2267 renew_done(struct rpc_task *task)
2268 {
2269         struct nfs4_client *clp = (struct nfs4_client *)task->tk_msg.rpc_argp;
2270         unsigned long timestamp = (unsigned long)task->tk_calldata;
2271
2272         if (task->tk_status < 0) {
2273                 switch (task->tk_status) {
2274                         case -NFS4ERR_STALE_CLIENTID:
2275                         case -NFS4ERR_EXPIRED:
2276                         case -NFS4ERR_CB_PATH_DOWN:
2277                                 nfs4_schedule_state_recovery(clp);
2278                 }
2279                 return;
2280         }
2281         spin_lock(&clp->cl_lock);
2282         if (time_before(clp->cl_last_renewal,timestamp))
2283                 clp->cl_last_renewal = timestamp;
2284         spin_unlock(&clp->cl_lock);
2285 }
2286
2287 int
2288 nfs4_proc_async_renew(struct nfs4_client *clp)
2289 {
2290         struct rpc_message msg = {
2291                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
2292                 .rpc_argp       = clp,
2293                 .rpc_cred       = clp->cl_cred,
2294         };
2295
2296         return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT,
2297                         renew_done, (void *)jiffies);
2298 }
2299
2300 int
2301 nfs4_proc_renew(struct nfs4_client *clp)
2302 {
2303         struct rpc_message msg = {
2304                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
2305                 .rpc_argp       = clp,
2306                 .rpc_cred       = clp->cl_cred,
2307         };
2308         unsigned long now = jiffies;
2309         int status;
2310
2311         status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
2312         if (status < 0)
2313                 return status;
2314         spin_lock(&clp->cl_lock);
2315         if (time_before(clp->cl_last_renewal,now))
2316                 clp->cl_last_renewal = now;
2317         spin_unlock(&clp->cl_lock);
2318         return 0;
2319 }
2320
2321 static inline int nfs4_server_supports_acls(struct nfs_server *server)
2322 {
2323         return (server->caps & NFS_CAP_ACLS)
2324                 && (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
2325                 && (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL);
2326 }
2327
2328 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_CACHE_SIZE, and that
2329  * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_CACHE_SIZE) bytes on
2330  * the stack.
2331  */
2332 #define NFS4ACL_MAXPAGES (XATTR_SIZE_MAX >> PAGE_CACHE_SHIFT)
2333
2334 static void buf_to_pages(const void *buf, size_t buflen,
2335                 struct page **pages, unsigned int *pgbase)
2336 {
2337         const void *p = buf;
2338
2339         *pgbase = offset_in_page(buf);
2340         p -= *pgbase;
2341         while (p < buf + buflen) {
2342                 *(pages++) = virt_to_page(p);
2343                 p += PAGE_CACHE_SIZE;
2344         }
2345 }
2346
2347 struct nfs4_cached_acl {
2348         int cached;
2349         size_t len;
2350         char data[0];
2351 };
2352
2353 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
2354 {
2355         struct nfs_inode *nfsi = NFS_I(inode);
2356
2357         spin_lock(&inode->i_lock);
2358         kfree(nfsi->nfs4_acl);
2359         nfsi->nfs4_acl = acl;
2360         spin_unlock(&inode->i_lock);
2361 }
2362
2363 static void nfs4_zap_acl_attr(struct inode *inode)
2364 {
2365         nfs4_set_cached_acl(inode, NULL);
2366 }
2367
2368 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
2369 {
2370         struct nfs_inode *nfsi = NFS_I(inode);
2371         struct nfs4_cached_acl *acl;
2372         int ret = -ENOENT;
2373
2374         spin_lock(&inode->i_lock);
2375         acl = nfsi->nfs4_acl;
2376         if (acl == NULL)
2377                 goto out;
2378         if (buf == NULL) /* user is just asking for length */
2379                 goto out_len;
2380         if (acl->cached == 0)
2381                 goto out;
2382         ret = -ERANGE; /* see getxattr(2) man page */
2383         if (acl->len > buflen)
2384                 goto out;
2385         memcpy(buf, acl->data, acl->len);
2386 out_len:
2387         ret = acl->len;
2388 out:
2389         spin_unlock(&inode->i_lock);
2390         return ret;
2391 }
2392
2393 static void nfs4_write_cached_acl(struct inode *inode, const char *buf, size_t acl_len)
2394 {
2395         struct nfs4_cached_acl *acl;
2396
2397         if (buf && acl_len <= PAGE_SIZE) {
2398                 acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL);
2399                 if (acl == NULL)
2400                         goto out;
2401                 acl->cached = 1;
2402                 memcpy(acl->data, buf, acl_len);
2403         } else {
2404                 acl = kmalloc(sizeof(*acl), GFP_KERNEL);
2405                 if (acl == NULL)
2406                         goto out;
2407                 acl->cached = 0;
2408         }
2409         acl->len = acl_len;
2410 out:
2411         nfs4_set_cached_acl(inode, acl);
2412 }
2413
2414 static inline ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
2415 {
2416         struct page *pages[NFS4ACL_MAXPAGES];
2417         struct nfs_getaclargs args = {
2418                 .fh = NFS_FH(inode),
2419                 .acl_pages = pages,
2420                 .acl_len = buflen,
2421         };
2422         size_t resp_len = buflen;
2423         void *resp_buf;
2424         struct rpc_message msg = {
2425                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
2426                 .rpc_argp = &args,
2427                 .rpc_resp = &resp_len,
2428         };
2429         struct page *localpage = NULL;
2430         int ret;
2431
2432         if (buflen < PAGE_SIZE) {
2433                 /* As long as we're doing a round trip to the server anyway,
2434                  * let's be prepared for a page of acl data. */
2435                 localpage = alloc_page(GFP_KERNEL);
2436                 resp_buf = page_address(localpage);
2437                 if (localpage == NULL)
2438                         return -ENOMEM;
2439                 args.acl_pages[0] = localpage;
2440                 args.acl_pgbase = 0;
2441                 resp_len = args.acl_len = PAGE_SIZE;
2442         } else {
2443                 resp_buf = buf;
2444                 buf_to_pages(buf, buflen, args.acl_pages, &args.acl_pgbase);
2445         }
2446         ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
2447         if (ret)
2448                 goto out_free;
2449         if (resp_len > args.acl_len)
2450                 nfs4_write_cached_acl(inode, NULL, resp_len);
2451         else
2452                 nfs4_write_cached_acl(inode, resp_buf, resp_len);
2453         if (buf) {
2454                 ret = -ERANGE;
2455                 if (resp_len > buflen)
2456                         goto out_free;
2457                 if (localpage)
2458                         memcpy(buf, resp_buf, resp_len);
2459         }
2460         ret = resp_len;
2461 out_free:
2462         if (localpage)
2463                 __free_page(localpage);
2464         return ret;
2465 }
2466
2467 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
2468 {
2469         struct nfs_server *server = NFS_SERVER(inode);
2470         int ret;
2471
2472         if (!nfs4_server_supports_acls(server))
2473                 return -EOPNOTSUPP;
2474         ret = nfs_revalidate_inode(server, inode);
2475         if (ret < 0)
2476                 return ret;
2477         ret = nfs4_read_cached_acl(inode, buf, buflen);
2478         if (ret != -ENOENT)
2479                 return ret;
2480         return nfs4_get_acl_uncached(inode, buf, buflen);
2481 }
2482
2483 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
2484 {
2485         struct nfs_server *server = NFS_SERVER(inode);
2486         struct page *pages[NFS4ACL_MAXPAGES];
2487         struct nfs_setaclargs arg = {
2488                 .fh             = NFS_FH(inode),
2489                 .acl_pages      = pages,
2490                 .acl_len        = buflen,
2491         };
2492         struct rpc_message msg = {
2493                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
2494                 .rpc_argp       = &arg,
2495                 .rpc_resp       = NULL,
2496         };
2497         int ret;
2498
2499         if (!nfs4_server_supports_acls(server))
2500                 return -EOPNOTSUPP;
2501         nfs_inode_return_delegation(inode);
2502         buf_to_pages(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
2503         ret = rpc_call_sync(NFS_SERVER(inode)->client, &msg, 0);
2504         if (ret == 0)
2505                 nfs4_write_cached_acl(inode, buf, buflen);
2506         return ret;
2507 }
2508
2509 static int
2510 nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server)
2511 {
2512         struct nfs4_client *clp = server->nfs4_state;
2513
2514         if (!clp || task->tk_status >= 0)
2515                 return 0;
2516         switch(task->tk_status) {
2517                 case -NFS4ERR_STALE_CLIENTID:
2518                 case -NFS4ERR_STALE_STATEID:
2519                 case -NFS4ERR_EXPIRED:
2520                         rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL, NULL);
2521                         nfs4_schedule_state_recovery(clp);
2522                         if (test_bit(NFS4CLNT_OK, &clp->cl_state))
2523                                 rpc_wake_up_task(task);
2524                         task->tk_status = 0;
2525                         return -EAGAIN;
2526                 case -NFS4ERR_GRACE:
2527                 case -NFS4ERR_DELAY:
2528                         rpc_delay(task, NFS4_POLL_RETRY_MAX);
2529                         task->tk_status = 0;
2530                         return -EAGAIN;
2531                 case -NFS4ERR_OLD_STATEID:
2532                         task->tk_status = 0;
2533                         return -EAGAIN;
2534         }
2535         task->tk_status = nfs4_map_errors(task->tk_status);
2536         return 0;
2537 }
2538
2539 static int nfs4_wait_clnt_recover(struct rpc_clnt *clnt, struct nfs4_client *clp)
2540 {
2541         DEFINE_WAIT(wait);
2542         sigset_t oldset;
2543         int interruptible, res = 0;
2544
2545         might_sleep();
2546
2547         rpc_clnt_sigmask(clnt, &oldset);
2548         interruptible = TASK_UNINTERRUPTIBLE;
2549         if (clnt->cl_intr)
2550                 interruptible = TASK_INTERRUPTIBLE;
2551         prepare_to_wait(&clp->cl_waitq, &wait, interruptible);
2552         nfs4_schedule_state_recovery(clp);
2553         if (clnt->cl_intr && signalled())
2554                 res = -ERESTARTSYS;
2555         else if (!test_bit(NFS4CLNT_OK, &clp->cl_state))
2556                 schedule();
2557         finish_wait(&clp->cl_waitq, &wait);
2558         rpc_clnt_sigunmask(clnt, &oldset);
2559         return res;
2560 }
2561
2562 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
2563 {
2564         sigset_t oldset;
2565         int res = 0;
2566
2567         might_sleep();
2568
2569         if (*timeout <= 0)
2570                 *timeout = NFS4_POLL_RETRY_MIN;
2571         if (*timeout > NFS4_POLL_RETRY_MAX)
2572                 *timeout = NFS4_POLL_RETRY_MAX;
2573         rpc_clnt_sigmask(clnt, &oldset);
2574         if (clnt->cl_intr) {
2575                 schedule_timeout_interruptible(*timeout);
2576                 if (signalled())
2577                         res = -ERESTARTSYS;
2578         } else
2579                 schedule_timeout_uninterruptible(*timeout);
2580         rpc_clnt_sigunmask(clnt, &oldset);
2581         *timeout <<= 1;
2582         return res;
2583 }
2584
2585 /* This is the error handling routine for processes that are allowed
2586  * to sleep.
2587  */
2588 int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
2589 {
2590         struct nfs4_client *clp = server->nfs4_state;
2591         int ret = errorcode;
2592
2593         exception->retry = 0;
2594         switch(errorcode) {
2595                 case 0:
2596                         return 0;
2597                 case -NFS4ERR_STALE_CLIENTID:
2598                 case -NFS4ERR_STALE_STATEID:
2599                 case -NFS4ERR_EXPIRED:
2600                         ret = nfs4_wait_clnt_recover(server->client, clp);
2601                         if (ret == 0)
2602                                 exception->retry = 1;
2603                         break;
2604                 case -NFS4ERR_GRACE:
2605                 case -NFS4ERR_DELAY:
2606                         ret = nfs4_delay(server->client, &exception->timeout);
2607                         if (ret != 0)
2608                                 break;
2609                 case -NFS4ERR_OLD_STATEID:
2610                         exception->retry = 1;
2611         }
2612         /* We failed to handle the error */
2613         return nfs4_map_errors(ret);
2614 }
2615
2616 int nfs4_proc_setclientid(struct nfs4_client *clp, u32 program, unsigned short port)
2617 {
2618         nfs4_verifier sc_verifier;
2619         struct nfs4_setclientid setclientid = {
2620                 .sc_verifier = &sc_verifier,
2621                 .sc_prog = program,
2622         };
2623         struct rpc_message msg = {
2624                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
2625                 .rpc_argp = &setclientid,
2626                 .rpc_resp = clp,
2627                 .rpc_cred = clp->cl_cred,
2628         };
2629         u32 *p;
2630         int loop = 0;
2631         int status;
2632
2633         p = (u32*)sc_verifier.data;
2634         *p++ = htonl((u32)clp->cl_boot_time.tv_sec);
2635         *p = htonl((u32)clp->cl_boot_time.tv_nsec);
2636
2637         for(;;) {
2638                 setclientid.sc_name_len = scnprintf(setclientid.sc_name,
2639                                 sizeof(setclientid.sc_name), "%s/%u.%u.%u.%u %s %u",
2640                                 clp->cl_ipaddr, NIPQUAD(clp->cl_addr.s_addr),
2641                                 clp->cl_cred->cr_ops->cr_name,
2642                                 clp->cl_id_uniquifier);
2643                 setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
2644                                 sizeof(setclientid.sc_netid), "tcp");
2645                 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
2646                                 sizeof(setclientid.sc_uaddr), "%s.%d.%d",
2647                                 clp->cl_ipaddr, port >> 8, port & 255);
2648
2649                 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
2650                 if (status != -NFS4ERR_CLID_INUSE)
2651                         break;
2652                 if (signalled())
2653                         break;
2654                 if (loop++ & 1)
2655                         ssleep(clp->cl_lease_time + 1);
2656                 else
2657                         if (++clp->cl_id_uniquifier == 0)
2658                                 break;
2659         }
2660         return status;
2661 }
2662
2663 int
2664 nfs4_proc_setclientid_confirm(struct nfs4_client *clp)
2665 {
2666         struct nfs_fsinfo fsinfo;
2667         struct rpc_message msg = {
2668                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
2669                 .rpc_argp = clp,
2670                 .rpc_resp = &fsinfo,
2671                 .rpc_cred = clp->cl_cred,
2672         };
2673         unsigned long now;
2674         int status;
2675
2676         now = jiffies;
2677         status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
2678         if (status == 0) {
2679                 spin_lock(&clp->cl_lock);
2680                 clp->cl_lease_time = fsinfo.lease_time * HZ;
2681                 clp->cl_last_renewal = now;
2682                 spin_unlock(&clp->cl_lock);
2683         }
2684         return status;
2685 }
2686
2687 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid)
2688 {
2689         struct nfs4_delegreturnargs args = {
2690                 .fhandle = NFS_FH(inode),
2691                 .stateid = stateid,
2692         };
2693         struct rpc_message msg = {
2694                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
2695                 .rpc_argp = &args,
2696                 .rpc_cred = cred,
2697         };
2698
2699         return rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
2700 }
2701
2702 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid)
2703 {
2704         struct nfs_server *server = NFS_SERVER(inode);
2705         struct nfs4_exception exception = { };
2706         int err;
2707         do {
2708                 err = _nfs4_proc_delegreturn(inode, cred, stateid);
2709                 switch (err) {
2710                         case -NFS4ERR_STALE_STATEID:
2711                         case -NFS4ERR_EXPIRED:
2712                                 nfs4_schedule_state_recovery(server->nfs4_state);
2713                         case 0:
2714                                 return 0;
2715                 }
2716                 err = nfs4_handle_exception(server, err, &exception);
2717         } while (exception.retry);
2718         return err;
2719 }
2720
2721 #define NFS4_LOCK_MINTIMEOUT (1 * HZ)
2722 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
2723
2724 /* 
2725  * sleep, with exponential backoff, and retry the LOCK operation. 
2726  */
2727 static unsigned long
2728 nfs4_set_lock_task_retry(unsigned long timeout)
2729 {
2730         schedule_timeout_interruptible(timeout);
2731         timeout <<= 1;
2732         if (timeout > NFS4_LOCK_MAXTIMEOUT)
2733                 return NFS4_LOCK_MAXTIMEOUT;
2734         return timeout;
2735 }
2736
2737 static inline int
2738 nfs4_lck_type(int cmd, struct file_lock *request)
2739 {
2740         /* set lock type */
2741         switch (request->fl_type) {
2742                 case F_RDLCK:
2743                         return IS_SETLKW(cmd) ? NFS4_READW_LT : NFS4_READ_LT;
2744                 case F_WRLCK:
2745                         return IS_SETLKW(cmd) ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
2746                 case F_UNLCK:
2747                         return NFS4_WRITE_LT; 
2748         }
2749         BUG();
2750         return 0;
2751 }
2752
2753 static inline uint64_t
2754 nfs4_lck_length(struct file_lock *request)
2755 {
2756         if (request->fl_end == OFFSET_MAX)
2757                 return ~(uint64_t)0;
2758         return request->fl_end - request->fl_start + 1;
2759 }
2760
2761 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
2762 {
2763         struct inode *inode = state->inode;
2764         struct nfs_server *server = NFS_SERVER(inode);
2765         struct nfs4_client *clp = server->nfs4_state;
2766         struct nfs_lockargs arg = {
2767                 .fh = NFS_FH(inode),
2768                 .type = nfs4_lck_type(cmd, request),
2769                 .offset = request->fl_start,
2770                 .length = nfs4_lck_length(request),
2771         };
2772         struct nfs_lockres res = {
2773                 .server = server,
2774         };
2775         struct rpc_message msg = {
2776                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
2777                 .rpc_argp       = &arg,
2778                 .rpc_resp       = &res,
2779                 .rpc_cred       = state->owner->so_cred,
2780         };
2781         struct nfs_lowner nlo;
2782         struct nfs4_lock_state *lsp;
2783         int status;
2784
2785         down_read(&clp->cl_sem);
2786         nlo.clientid = clp->cl_clientid;
2787         status = nfs4_set_lock_state(state, request);
2788         if (status != 0)
2789                 goto out;
2790         lsp = request->fl_u.nfs4_fl.owner;
2791         nlo.id = lsp->ls_id; 
2792         arg.u.lockt = &nlo;
2793         status = rpc_call_sync(server->client, &msg, 0);
2794         if (!status) {
2795                 request->fl_type = F_UNLCK;
2796         } else if (status == -NFS4ERR_DENIED) {
2797                 int64_t len, start, end;
2798                 start = res.u.denied.offset;
2799                 len = res.u.denied.length;
2800                 end = start + len - 1;
2801                 if (end < 0 || len == 0)
2802                         request->fl_end = OFFSET_MAX;
2803                 else
2804                         request->fl_end = (loff_t)end;
2805                 request->fl_start = (loff_t)start;
2806                 request->fl_type = F_WRLCK;
2807                 if (res.u.denied.type & 1)
2808                         request->fl_type = F_RDLCK;
2809                 request->fl_pid = 0;
2810                 status = 0;
2811         }
2812 out:
2813         up_read(&clp->cl_sem);
2814         return status;
2815 }
2816
2817 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
2818 {
2819         struct nfs4_exception exception = { };
2820         int err;
2821
2822         do {
2823                 err = nfs4_handle_exception(NFS_SERVER(state->inode),
2824                                 _nfs4_proc_getlk(state, cmd, request),
2825                                 &exception);
2826         } while (exception.retry);
2827         return err;
2828 }
2829
2830 static int do_vfs_lock(struct file *file, struct file_lock *fl)
2831 {
2832         int res = 0;
2833         switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
2834                 case FL_POSIX:
2835                         res = posix_lock_file_wait(file, fl);
2836                         break;
2837                 case FL_FLOCK:
2838                         res = flock_lock_file_wait(file, fl);
2839                         break;
2840                 default:
2841                         BUG();
2842         }
2843         if (res < 0)
2844                 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n",
2845                                 __FUNCTION__);
2846         return res;
2847 }
2848
2849 struct nfs4_unlockdata {
2850         struct nfs_lockargs arg;
2851         struct nfs_locku_opargs luargs;
2852         struct nfs_lockres res;
2853         struct nfs4_lock_state *lsp;
2854         struct nfs_open_context *ctx;
2855         atomic_t refcount;
2856         struct completion completion;
2857 };
2858
2859 static void nfs4_locku_release_calldata(struct nfs4_unlockdata *calldata)
2860 {
2861         if (atomic_dec_and_test(&calldata->refcount)) {
2862                 nfs_free_seqid(calldata->luargs.seqid);
2863                 nfs4_put_lock_state(calldata->lsp);
2864                 put_nfs_open_context(calldata->ctx);
2865                 kfree(calldata);
2866         }
2867 }
2868
2869 static void nfs4_locku_complete(struct nfs4_unlockdata *calldata)
2870 {
2871         complete(&calldata->completion);
2872         nfs4_locku_release_calldata(calldata);
2873 }
2874
2875 static void nfs4_locku_done(struct rpc_task *task)
2876 {
2877         struct nfs4_unlockdata *calldata = (struct nfs4_unlockdata *)task->tk_calldata;
2878
2879         nfs_increment_lock_seqid(task->tk_status, calldata->luargs.seqid);
2880         switch (task->tk_status) {
2881                 case 0:
2882                         memcpy(calldata->lsp->ls_stateid.data,
2883                                         calldata->res.u.stateid.data,
2884                                         sizeof(calldata->lsp->ls_stateid.data));
2885                         break;
2886                 case -NFS4ERR_STALE_STATEID:
2887                 case -NFS4ERR_EXPIRED:
2888                         nfs4_schedule_state_recovery(calldata->res.server->nfs4_state);
2889                         break;
2890                 default:
2891                         if (nfs4_async_handle_error(task, calldata->res.server) == -EAGAIN) {
2892                                 rpc_restart_call(task);
2893                                 return;
2894                         }
2895         }
2896         nfs4_locku_complete(calldata);
2897 }
2898
2899 static void nfs4_locku_begin(struct rpc_task *task)
2900 {
2901         struct nfs4_unlockdata *calldata = (struct nfs4_unlockdata *)task->tk_calldata;
2902         struct rpc_message msg = {
2903                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
2904                 .rpc_argp       = &calldata->arg,
2905                 .rpc_resp       = &calldata->res,
2906                 .rpc_cred       = calldata->lsp->ls_state->owner->so_cred,
2907         };
2908         int status;
2909
2910         status = nfs_wait_on_sequence(calldata->luargs.seqid, task);
2911         if (status != 0)
2912                 return;
2913         if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) {
2914                 nfs4_locku_complete(calldata);
2915                 task->tk_exit = NULL;
2916                 rpc_exit(task, 0);
2917                 return;
2918         }
2919         rpc_call_setup(task, &msg, 0);
2920 }
2921
2922 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
2923 {
2924         struct nfs4_unlockdata *calldata;
2925         struct inode *inode = state->inode;
2926         struct nfs_server *server = NFS_SERVER(inode);
2927         struct nfs4_lock_state *lsp;
2928         int status;
2929
2930         /* Is this a delegated lock? */
2931         if (test_bit(NFS_DELEGATED_STATE, &state->flags))
2932                 return do_vfs_lock(request->fl_file, request);
2933
2934         status = nfs4_set_lock_state(state, request);
2935         if (status != 0)
2936                 return status;
2937         lsp = request->fl_u.nfs4_fl.owner;
2938         /* We might have lost the locks! */
2939         if ((lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0)
2940                 return 0;
2941         calldata = kmalloc(sizeof(*calldata), GFP_KERNEL);
2942         if (calldata == NULL)
2943                 return -ENOMEM;
2944         calldata->luargs.seqid = nfs_alloc_seqid(&lsp->ls_seqid);
2945         if (calldata->luargs.seqid == NULL) {
2946                 kfree(calldata);
2947                 return -ENOMEM;
2948         }
2949         calldata->luargs.stateid = &lsp->ls_stateid;
2950         calldata->arg.fh = NFS_FH(inode);
2951         calldata->arg.type = nfs4_lck_type(cmd, request);
2952         calldata->arg.offset = request->fl_start;
2953         calldata->arg.length = nfs4_lck_length(request);
2954         calldata->arg.u.locku = &calldata->luargs;
2955         calldata->res.server = server;
2956         calldata->lsp = lsp;
2957         atomic_inc(&lsp->ls_count);
2958
2959         /* Ensure we don't close file until we're done freeing locks! */
2960         calldata->ctx = get_nfs_open_context((struct nfs_open_context*)request->fl_file->private_data);
2961
2962         atomic_set(&calldata->refcount, 2);
2963         init_completion(&calldata->completion);
2964
2965         status = nfs4_call_async(NFS_SERVER(inode)->client, nfs4_locku_begin,
2966                         nfs4_locku_done, calldata);
2967         if (status == 0)
2968                 wait_for_completion_interruptible(&calldata->completion);
2969         do_vfs_lock(request->fl_file, request);
2970         nfs4_locku_release_calldata(calldata);
2971         return status;
2972 }
2973
2974 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *request, int reclaim)
2975 {
2976         struct inode *inode = state->inode;
2977         struct nfs_server *server = NFS_SERVER(inode);
2978         struct nfs4_lock_state *lsp = request->fl_u.nfs4_fl.owner;
2979         struct nfs_lock_opargs largs = {
2980                 .lock_stateid = &lsp->ls_stateid,
2981                 .open_stateid = &state->stateid,
2982                 .lock_owner = {
2983                         .clientid = server->nfs4_state->cl_clientid,
2984                         .id = lsp->ls_id,
2985                 },
2986                 .reclaim = reclaim,
2987         };
2988         struct nfs_lockargs arg = {
2989                 .fh = NFS_FH(inode),
2990                 .type = nfs4_lck_type(cmd, request),
2991                 .offset = request->fl_start,
2992                 .length = nfs4_lck_length(request),
2993                 .u = {
2994                         .lock = &largs,
2995                 },
2996         };
2997         struct nfs_lockres res = {
2998                 .server = server,
2999         };
3000         struct rpc_message msg = {
3001                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
3002                 .rpc_argp       = &arg,
3003                 .rpc_resp       = &res,
3004                 .rpc_cred       = state->owner->so_cred,
3005         };
3006         int status = -ENOMEM;
3007
3008         largs.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid);
3009         if (largs.lock_seqid == NULL)
3010                 return -ENOMEM;
3011         if (!(lsp->ls_seqid.flags & NFS_SEQID_CONFIRMED)) {
3012                 struct nfs4_state_owner *owner = state->owner;
3013
3014                 largs.open_seqid = nfs_alloc_seqid(&owner->so_seqid);
3015                 if (largs.open_seqid == NULL)
3016                         goto out;
3017                 largs.new_lock_owner = 1;
3018                 status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
3019                 /* increment open seqid on success, and seqid mutating errors */
3020                 if (largs.new_lock_owner != 0) {
3021                         nfs_increment_open_seqid(status, largs.open_seqid);
3022                         if (status == 0)
3023                                 nfs_confirm_seqid(&lsp->ls_seqid, 0);
3024                 }
3025                 nfs_free_seqid(largs.open_seqid);
3026         } else
3027                 status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
3028         /* increment lock seqid on success, and seqid mutating errors*/
3029         nfs_increment_lock_seqid(status, largs.lock_seqid);
3030         /* save the returned stateid. */
3031         if (status == 0) {
3032                 memcpy(lsp->ls_stateid.data, res.u.stateid.data,
3033                                 sizeof(lsp->ls_stateid.data));
3034                 lsp->ls_flags |= NFS_LOCK_INITIALIZED;
3035         } else if (status == -NFS4ERR_DENIED)
3036                 status = -EAGAIN;
3037 out:
3038         nfs_free_seqid(largs.lock_seqid);
3039         return status;
3040 }
3041
3042 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
3043 {
3044         struct nfs_server *server = NFS_SERVER(state->inode);
3045         struct nfs4_exception exception = { };
3046         int err;
3047
3048         /* Cache the lock if possible... */
3049         if (test_bit(NFS_DELEGATED_STATE, &state->flags))
3050                 return 0;
3051         do {
3052                 err = _nfs4_do_setlk(state, F_SETLK, request, 1);
3053                 if (err != -NFS4ERR_DELAY)
3054                         break;
3055                 nfs4_handle_exception(server, err, &exception);
3056         } while (exception.retry);
3057         return err;
3058 }
3059
3060 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
3061 {
3062         struct nfs_server *server = NFS_SERVER(state->inode);
3063         struct nfs4_exception exception = { };
3064         int err;
3065
3066         err = nfs4_set_lock_state(state, request);
3067         if (err != 0)
3068                 return err;
3069         do {
3070                 err = _nfs4_do_setlk(state, F_SETLK, request, 0);
3071                 if (err != -NFS4ERR_DELAY)
3072                         break;
3073                 nfs4_handle_exception(server, err, &exception);
3074         } while (exception.retry);
3075         return err;
3076 }
3077
3078 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3079 {
3080         struct nfs4_client *clp = state->owner->so_client;
3081         int status;
3082
3083         /* Is this a delegated open? */
3084         if (NFS_I(state->inode)->delegation_state != 0) {
3085                 /* Yes: cache locks! */
3086                 status = do_vfs_lock(request->fl_file, request);
3087                 /* ...but avoid races with delegation recall... */
3088                 if (status < 0 || test_bit(NFS_DELEGATED_STATE, &state->flags))
3089                         return status;
3090         }
3091         down_read(&clp->cl_sem);
3092         status = nfs4_set_lock_state(state, request);
3093         if (status != 0)
3094                 goto out;
3095         status = _nfs4_do_setlk(state, cmd, request, 0);
3096         if (status != 0)
3097                 goto out;
3098         /* Note: we always want to sleep here! */
3099         request->fl_flags |= FL_SLEEP;
3100         if (do_vfs_lock(request->fl_file, request) < 0)
3101                 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __FUNCTION__);
3102 out:
3103         up_read(&clp->cl_sem);
3104         return status;
3105 }
3106
3107 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3108 {
3109         struct nfs4_exception exception = { };
3110         int err;
3111
3112         do {
3113                 err = nfs4_handle_exception(NFS_SERVER(state->inode),
3114                                 _nfs4_proc_setlk(state, cmd, request),
3115                                 &exception);
3116         } while (exception.retry);
3117         return err;
3118 }
3119
3120 static int
3121 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
3122 {
3123         struct nfs_open_context *ctx;
3124         struct nfs4_state *state;
3125         unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
3126         int status;
3127
3128         /* verify open state */
3129         ctx = (struct nfs_open_context *)filp->private_data;
3130         state = ctx->state;
3131
3132         if (request->fl_start < 0 || request->fl_end < 0)
3133                 return -EINVAL;
3134
3135         if (IS_GETLK(cmd))
3136                 return nfs4_proc_getlk(state, F_GETLK, request);
3137
3138         if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
3139                 return -EINVAL;
3140
3141         if (request->fl_type == F_UNLCK)
3142                 return nfs4_proc_unlck(state, cmd, request);
3143
3144         do {
3145                 status = nfs4_proc_setlk(state, cmd, request);
3146                 if ((status != -EAGAIN) || IS_SETLK(cmd))
3147                         break;
3148                 timeout = nfs4_set_lock_task_retry(timeout);
3149                 status = -ERESTARTSYS;
3150                 if (signalled())
3151                         break;
3152         } while(status < 0);
3153         return status;
3154 }
3155
3156 int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl)
3157 {
3158         struct nfs_server *server = NFS_SERVER(state->inode);
3159         struct nfs4_exception exception = { };
3160         int err;
3161
3162         err = nfs4_set_lock_state(state, fl);
3163         if (err != 0)
3164                 goto out;
3165         do {
3166                 err = _nfs4_do_setlk(state, F_SETLK, fl, 0);
3167                 if (err != -NFS4ERR_DELAY)
3168                         break;
3169                 err = nfs4_handle_exception(server, err, &exception);
3170         } while (exception.retry);
3171 out:
3172         return err;
3173 }
3174
3175 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
3176
3177 int nfs4_setxattr(struct dentry *dentry, const char *key, const void *buf,
3178                 size_t buflen, int flags)
3179 {
3180         struct inode *inode = dentry->d_inode;
3181
3182         if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0)
3183                 return -EOPNOTSUPP;
3184
3185         if (!S_ISREG(inode->i_mode) &&
3186             (!S_ISDIR(inode->i_mode) || inode->i_mode & S_ISVTX))
3187                 return -EPERM;
3188
3189         return nfs4_proc_set_acl(inode, buf, buflen);
3190 }
3191
3192 /* The getxattr man page suggests returning -ENODATA for unknown attributes,
3193  * and that's what we'll do for e.g. user attributes that haven't been set.
3194  * But we'll follow ext2/ext3's lead by returning -EOPNOTSUPP for unsupported
3195  * attributes in kernel-managed attribute namespaces. */
3196 ssize_t nfs4_getxattr(struct dentry *dentry, const char *key, void *buf,
3197                 size_t buflen)
3198 {
3199         struct inode *inode = dentry->d_inode;
3200
3201         if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0)
3202                 return -EOPNOTSUPP;
3203
3204         return nfs4_proc_get_acl(inode, buf, buflen);
3205 }
3206
3207 ssize_t nfs4_listxattr(struct dentry *dentry, char *buf, size_t buflen)
3208 {
3209         size_t len = strlen(XATTR_NAME_NFSV4_ACL) + 1;
3210
3211         if (buf && buflen < len)
3212                 return -ERANGE;
3213         if (buf)
3214                 memcpy(buf, XATTR_NAME_NFSV4_ACL, len);
3215         return len;
3216 }
3217
3218 struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = {
3219         .recover_open   = nfs4_open_reclaim,
3220         .recover_lock   = nfs4_lock_reclaim,
3221 };
3222
3223 struct nfs4_state_recovery_ops nfs4_network_partition_recovery_ops = {
3224         .recover_open   = nfs4_open_expired,
3225         .recover_lock   = nfs4_lock_expired,
3226 };
3227
3228 static struct inode_operations nfs4_file_inode_operations = {
3229         .permission     = nfs_permission,
3230         .getattr        = nfs_getattr,
3231         .setattr        = nfs_setattr,
3232         .getxattr       = nfs4_getxattr,
3233         .setxattr       = nfs4_setxattr,
3234         .listxattr      = nfs4_listxattr,
3235 };
3236
3237 struct nfs_rpc_ops      nfs_v4_clientops = {
3238         .version        = 4,                    /* protocol version */
3239         .dentry_ops     = &nfs4_dentry_operations,
3240         .dir_inode_ops  = &nfs4_dir_inode_operations,
3241         .file_inode_ops = &nfs4_file_inode_operations,
3242         .getroot        = nfs4_proc_get_root,
3243         .getattr        = nfs4_proc_getattr,
3244         .setattr        = nfs4_proc_setattr,
3245         .lookup         = nfs4_proc_lookup,
3246         .access         = nfs4_proc_access,
3247         .readlink       = nfs4_proc_readlink,
3248         .read           = nfs4_proc_read,
3249         .write          = nfs4_proc_write,
3250         .commit         = nfs4_proc_commit,
3251         .create         = nfs4_proc_create,
3252         .remove         = nfs4_proc_remove,
3253         .unlink_setup   = nfs4_proc_unlink_setup,
3254         .unlink_done    = nfs4_proc_unlink_done,
3255         .rename         = nfs4_proc_rename,
3256         .link           = nfs4_proc_link,
3257         .symlink        = nfs4_proc_symlink,
3258         .mkdir          = nfs4_proc_mkdir,
3259         .rmdir          = nfs4_proc_remove,
3260         .readdir        = nfs4_proc_readdir,
3261         .mknod          = nfs4_proc_mknod,
3262         .statfs         = nfs4_proc_statfs,
3263         .fsinfo         = nfs4_proc_fsinfo,
3264         .pathconf       = nfs4_proc_pathconf,
3265         .decode_dirent  = nfs4_decode_dirent,
3266         .read_setup     = nfs4_proc_read_setup,
3267         .write_setup    = nfs4_proc_write_setup,
3268         .commit_setup   = nfs4_proc_commit_setup,
3269         .file_open      = nfs_open,
3270         .file_release   = nfs_release,
3271         .lock           = nfs4_proc_lock,
3272         .clear_acl_cache = nfs4_zap_acl_attr,
3273 };
3274
3275 /*
3276  * Local variables:
3277  *  c-basic-offset: 8
3278  * End:
3279  */