]> bbs.cooldavid.org Git - net-next-2.6.git/blame - fs/nfs/nfs4proc.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NFSv4: 'constify' lookup arguments.
[net-next-2.6.git] / fs / nfs / nfs4proc.c
CommitLineData
1da177e4
LT		 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>
02a913a7 50#include <linux/mount.h>
1da177e4 51
4ce79717 52#include "nfs4_fs.h"
1da177e4 53#include "delegation.h"
006ea73e 54#include "iostat.h"
1da177e4
LT		 55
56#define NFSDBG_FACILITY NFSDBG_PROC
57
2066fe89 58#define NFS4_POLL_RETRY_MIN (HZ/10)
1da177e4
LT		 59#define NFS4_POLL_RETRY_MAX (15*HZ)
60
cdd4e68b 61struct nfs4_opendata;
864472e9 62static int _nfs4_proc_open(struct nfs4_opendata *data);
1da177e4 63static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
faf5f49c 64static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *);
1da177e4 65static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry);
faf5f49c 66static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception);
adfa6f98 67static int nfs4_wait_clnt_recover(struct rpc_clnt *clnt, struct nfs_client *clp);
aac00a8d 68static int _nfs4_do_access(struct inode *inode, struct rpc_cred *cred, int openflags);
1da177e4 69
1da177e4
LT		 70/* Prevent leaks of NFSv4 errors into userland */
71int nfs4_map_errors(int err)
72{
73 if (err < -1000) {
74 dprintk("%s could not handle NFSv4 error %d\n",
75 __FUNCTION__, -err);
76 return -EIO;
77 }
78 return err;
79}
80
81/*
82 * This is our standard bitmap for GETATTR requests.
83 */
84const u32 nfs4_fattr_bitmap[2] = {
85 FATTR4_WORD0_TYPE
86 | FATTR4_WORD0_CHANGE
87 | FATTR4_WORD0_SIZE
88 | FATTR4_WORD0_FSID
89 | FATTR4_WORD0_FILEID,
90 FATTR4_WORD1_MODE
91 | FATTR4_WORD1_NUMLINKS
92 | FATTR4_WORD1_OWNER
93 | FATTR4_WORD1_OWNER_GROUP
94 | FATTR4_WORD1_RAWDEV
95 | FATTR4_WORD1_SPACE_USED
96 | FATTR4_WORD1_TIME_ACCESS
97 | FATTR4_WORD1_TIME_METADATA
98 | FATTR4_WORD1_TIME_MODIFY
99};
100
101const u32 nfs4_statfs_bitmap[2] = {
102 FATTR4_WORD0_FILES_AVAIL
103 | FATTR4_WORD0_FILES_FREE
104 | FATTR4_WORD0_FILES_TOTAL,
105 FATTR4_WORD1_SPACE_AVAIL
106 | FATTR4_WORD1_SPACE_FREE
107 | FATTR4_WORD1_SPACE_TOTAL
108};
109
4ce79717 110const u32 nfs4_pathconf_bitmap[2] = {
1da177e4
LT		 111 FATTR4_WORD0_MAXLINK
112 | FATTR4_WORD0_MAXNAME,
113 0
114};
115
116const u32 nfs4_fsinfo_bitmap[2] = { FATTR4_WORD0_MAXFILESIZE
117 | FATTR4_WORD0_MAXREAD
118 | FATTR4_WORD0_MAXWRITE
119 | FATTR4_WORD0_LEASE_TIME,
120 0
121};
122
830b8e33
MN		 123const u32 nfs4_fs_locations_bitmap[2] = {
124 FATTR4_WORD0_TYPE
125 | FATTR4_WORD0_CHANGE
126 | FATTR4_WORD0_SIZE
127 | FATTR4_WORD0_FSID
128 | FATTR4_WORD0_FILEID
129 | FATTR4_WORD0_FS_LOCATIONS,
130 FATTR4_WORD1_MODE
131 | FATTR4_WORD1_NUMLINKS
132 | FATTR4_WORD1_OWNER
133 | FATTR4_WORD1_OWNER_GROUP
134 | FATTR4_WORD1_RAWDEV
135 | FATTR4_WORD1_SPACE_USED
136 | FATTR4_WORD1_TIME_ACCESS
137 | FATTR4_WORD1_TIME_METADATA
138 | FATTR4_WORD1_TIME_MODIFY
139 | FATTR4_WORD1_MOUNTED_ON_FILEID
140};
141
bc4785cd 142static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
1da177e4
LT		 143 struct nfs4_readdir_arg *readdir)
144{
0dbb4c67 145 __be32 *start, *p;
1da177e4
LT		 146
147 BUG_ON(readdir->count < 80);
148 if (cookie > 2) {
b7ef1956 149 readdir->cookie = cookie;
1da177e4
LT		 150 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
151 return;
152 }
153
154 readdir->cookie = 0;
155 memset(&readdir->verifier, 0, sizeof(readdir->verifier));
156 if (cookie == 2)
157 return;
158
159 /*
160 * NFSv4 servers do not return entries for '.' and '..'
161 * Therefore, we fake these entries here. We let '.'
162 * have cookie 0 and '..' have cookie 1. Note that
163 * when talking to the server, we always send cookie 0
164 * instead of 1 or 2.
165 */
0dbb4c67 166 start = p = kmap_atomic(*readdir->pages, KM_USER0);
1da177e4
LT		 167
168 if (cookie == 0) {
169 *p++ = xdr_one; /* next */
170 *p++ = xdr_zero; /* cookie, first word */
171 *p++ = xdr_one; /* cookie, second word */
172 *p++ = xdr_one; /* entry len */
173 memcpy(p, ".\0\0\0", 4); /* entry */
174 p++;
175 *p++ = xdr_one; /* bitmap length */
176 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
177 *p++ = htonl(8); /* attribute buffer length */
178 p = xdr_encode_hyper(p, dentry->d_inode->i_ino);
179 }
180
181 *p++ = xdr_one; /* next */
182 *p++ = xdr_zero; /* cookie, first word */
183 *p++ = xdr_two; /* cookie, second word */
184 *p++ = xdr_two; /* entry len */
185 memcpy(p, "..\0\0", 4); /* entry */
186 p++;
187 *p++ = xdr_one; /* bitmap length */
188 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
189 *p++ = htonl(8); /* attribute buffer length */
190 p = xdr_encode_hyper(p, dentry->d_parent->d_inode->i_ino);
191
192 readdir->pgbase = (char *)p - (char *)start;
193 readdir->count -= readdir->pgbase;
194 kunmap_atomic(start, KM_USER0);
195}
196
26e976a8 197static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
1da177e4 198{
7539bbab 199 struct nfs_client *clp = server->nfs_client;
1da177e4
LT		 200 spin_lock(&clp->cl_lock);
201 if (time_before(clp->cl_last_renewal,timestamp))
202 clp->cl_last_renewal = timestamp;
203 spin_unlock(&clp->cl_lock);
204}
205
38478b24 206static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
1da177e4 207{
38478b24 208 struct nfs_inode *nfsi = NFS_I(dir);
1da177e4 209
38478b24
TM		 210 spin_lock(&dir->i_lock);
211 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA;
1da177e4
LT		 212 if (cinfo->before == nfsi->change_attr && cinfo->atomic)
213 nfsi->change_attr = cinfo->after;
38478b24 214 spin_unlock(&dir->i_lock);
1da177e4
LT		 215}
216
e56e0b78 217struct nfs4_opendata {
c6d00e63 218 struct kref kref;
e56e0b78
TM		 219 struct nfs_openargs o_arg;
220 struct nfs_openres o_res;
cdd4e68b
TM		 221 struct nfs_open_confirmargs c_arg;
222 struct nfs_open_confirmres c_res;
e56e0b78
TM		 223 struct nfs_fattr f_attr;
224 struct nfs_fattr dir_attr;
ad389da7 225 struct path path;
e56e0b78
TM		 226 struct dentry *dir;
227 struct nfs4_state_owner *owner;
aac00a8d 228 struct nfs4_state *state;
e56e0b78 229 struct iattr attrs;
26e976a8 230 unsigned long timestamp;
3e309914 231 unsigned int rpc_done : 1;
24ac23ab
TM		 232 int rpc_status;
233 int cancelled;
e56e0b78
TM		 234};
235
2ced46c2
TM		 236
237static void nfs4_init_opendata_res(struct nfs4_opendata *p)
238{
239 p->o_res.f_attr = &p->f_attr;
240 p->o_res.dir_attr = &p->dir_attr;
241 p->o_res.server = p->o_arg.server;
242 nfs_fattr_init(&p->f_attr);
243 nfs_fattr_init(&p->dir_attr);
244}
245
ad389da7 246static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path,
e56e0b78
TM		 247 struct nfs4_state_owner *sp, int flags,
248 const struct iattr *attrs)
249{
ad389da7 250 struct dentry *parent = dget_parent(path->dentry);
e56e0b78
TM		 251 struct inode *dir = parent->d_inode;
252 struct nfs_server *server = NFS_SERVER(dir);
253 struct nfs4_opendata *p;
254
255 p = kzalloc(sizeof(*p), GFP_KERNEL);
256 if (p == NULL)
257 goto err;
258 p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
259 if (p->o_arg.seqid == NULL)
260 goto err_free;
ad389da7
TM		 261 p->path.mnt = mntget(path->mnt);
262 p->path.dentry = dget(path->dentry);
e56e0b78
TM		 263 p->dir = parent;
264 p->owner = sp;
265 atomic_inc(&sp->so_count);
266 p->o_arg.fh = NFS_FH(dir);
267 p->o_arg.open_flags = flags,
7539bbab 268 p->o_arg.clientid = server->nfs_client->cl_clientid;
9f958ab8 269 p->o_arg.id = sp->so_owner_id.id;
ad389da7 270 p->o_arg.name = &p->path.dentry->d_name;
e56e0b78
TM		 271 p->o_arg.server = server;
272 p->o_arg.bitmask = server->attr_bitmask;
273 p->o_arg.claim = NFS4_OPEN_CLAIM_NULL;
e56e0b78
TM		 274 if (flags & O_EXCL) {
275 u32 *s = (u32 *) p->o_arg.u.verifier.data;
276 s[0] = jiffies;
277 s[1] = current->pid;
278 } else if (flags & O_CREAT) {
279 p->o_arg.u.attrs = &p->attrs;
280 memcpy(&p->attrs, attrs, sizeof(p->attrs));
281 }
cdd4e68b
TM		 282 p->c_arg.fh = &p->o_res.fh;
283 p->c_arg.stateid = &p->o_res.stateid;
284 p->c_arg.seqid = p->o_arg.seqid;
2ced46c2 285 nfs4_init_opendata_res(p);
c6d00e63 286 kref_init(&p->kref);
e56e0b78
TM		 287 return p;
288err_free:
289 kfree(p);
290err:
291 dput(parent);
292 return NULL;
293}
294
c6d00e63 295static void nfs4_opendata_free(struct kref *kref)
e56e0b78 296{
c6d00e63
TM		 297 struct nfs4_opendata *p = container_of(kref,
298 struct nfs4_opendata, kref);
299
300 nfs_free_seqid(p->o_arg.seqid);
aac00a8d
TM		 301 if (p->state != NULL)
302 nfs4_put_open_state(p->state);
c6d00e63
TM		 303 nfs4_put_state_owner(p->owner);
304 dput(p->dir);
305 dput(p->path.dentry);
306 mntput(p->path.mnt);
307 kfree(p);
308}
309
310static void nfs4_opendata_put(struct nfs4_opendata *p)
311{
312 if (p != NULL)
313 kref_put(&p->kref, nfs4_opendata_free);
e56e0b78
TM		 314}
315
06f814a3
TM		 316static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
317{
318 sigset_t oldset;
319 int ret;
320
321 rpc_clnt_sigmask(task->tk_client, &oldset);
322 ret = rpc_wait_for_completion_task(task);
323 rpc_clnt_sigunmask(task->tk_client, &oldset);
324 return ret;
325}
326
6ee41268
TM		 327static int can_open_cached(struct nfs4_state *state, int mode)
328{
329 int ret = 0;
330 switch (mode & (FMODE_READ|FMODE_WRITE|O_EXCL)) {
331 case FMODE_READ:
332 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0;
333 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0;
334 break;
335 case FMODE_WRITE:
336 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0;
337 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0;
338 break;
339 case FMODE_READ|FMODE_WRITE:
340 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0;
341 }
342 return ret;
343}
344
aac00a8d
TM		 345static int can_open_delegated(struct nfs_delegation *delegation, mode_t open_flags)
346{
347 if ((delegation->type & open_flags) != open_flags)
348 return 0;
349 if (delegation->flags & NFS_DELEGATION_NEED_RECLAIM)
350 return 0;
351 return 1;
352}
353
003707c7 354static void update_open_stateflags(struct nfs4_state *state, mode_t open_flags)
e7616923
TM		 355{
356 switch (open_flags) {
357 case FMODE_WRITE:
358 state->n_wronly++;
359 break;
360 case FMODE_READ:
361 state->n_rdonly++;
362 break;
363 case FMODE_READ|FMODE_WRITE:
364 state->n_rdwr++;
365 }
003707c7
TM		 366 nfs4_state_set_mode_locked(state, state->state | open_flags);
367}
368
369static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
370{
371 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
372 memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data));
373 memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data));
374 switch (open_flags) {
375 case FMODE_READ:
376 set_bit(NFS_O_RDONLY_STATE, &state->flags);
377 break;
378 case FMODE_WRITE:
379 set_bit(NFS_O_WRONLY_STATE, &state->flags);
380 break;
381 case FMODE_READ|FMODE_WRITE:
382 set_bit(NFS_O_RDWR_STATE, &state->flags);
383 }
e7616923
TM		 384}
385
003707c7
TM		 386static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
387{
8bda4e4c 388 write_seqlock(&state->seqlock);
003707c7 389 nfs_set_open_stateid_locked(state, stateid, open_flags);
8bda4e4c 390 write_sequnlock(&state->seqlock);
003707c7
TM		 391}
392
393static void update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *deleg_stateid, int open_flags)
1da177e4 394{
1da177e4 395 open_flags &= (FMODE_READ|FMODE_WRITE);
8bda4e4c
TM		 396 /*
397 * Protect the call to nfs4_state_set_mode_locked and
398 * serialise the stateid update
399 */
400 write_seqlock(&state->seqlock);
003707c7
TM		 401 if (deleg_stateid != NULL) {
402 memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data));
403 set_bit(NFS_DELEGATED_STATE, &state->flags);
404 }
405 if (open_stateid != NULL)
406 nfs_set_open_stateid_locked(state, open_stateid, open_flags);
8bda4e4c
TM		 407 write_sequnlock(&state->seqlock);
408 spin_lock(&state->owner->so_lock);
e7616923 409 update_open_stateflags(state, open_flags);
ec073428 410 spin_unlock(&state->owner->so_lock);
1da177e4
LT		 411}
412
aac00a8d
TM		 413static void nfs4_return_incompatible_delegation(struct inode *inode, mode_t open_flags)
414{
415 struct nfs_delegation *delegation;
416
417 rcu_read_lock();
418 delegation = rcu_dereference(NFS_I(inode)->delegation);
419 if (delegation == NULL || (delegation->type & open_flags) == open_flags) {
420 rcu_read_unlock();
421 return;
422 }
423 rcu_read_unlock();
424 nfs_inode_return_delegation(inode);
425}
426
6ee41268 427static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
aac00a8d
TM		 428{
429 struct nfs4_state *state = opendata->state;
430 struct nfs_inode *nfsi = NFS_I(state->inode);
431 struct nfs_delegation *delegation;
432 int open_mode = opendata->o_arg.open_flags & (FMODE_READ|FMODE_WRITE|O_EXCL);
433 nfs4_stateid stateid;
434 int ret = -EAGAIN;
435
436 rcu_read_lock();
437 delegation = rcu_dereference(nfsi->delegation);
aac00a8d 438 for (;;) {
6ee41268
TM		 439 if (can_open_cached(state, open_mode)) {
440 spin_lock(&state->owner->so_lock);
441 if (can_open_cached(state, open_mode)) {
442 update_open_stateflags(state, open_mode);
443 spin_unlock(&state->owner->so_lock);
444 rcu_read_unlock();
445 goto out_return_state;
446 }
447 spin_unlock(&state->owner->so_lock);
448 }
449 if (delegation == NULL)
450 break;
aac00a8d
TM		 451 if (!can_open_delegated(delegation, open_mode))
452 break;
453 /* Save the delegation */
454 memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data));
455 rcu_read_unlock();
456 lock_kernel();
457 ret = _nfs4_do_access(state->inode, state->owner->so_cred, open_mode);
458 unlock_kernel();
459 if (ret != 0)
460 goto out;
461 ret = -EAGAIN;
462 rcu_read_lock();
463 delegation = rcu_dereference(nfsi->delegation);
6ee41268 464 /* If no delegation, try a cached open */
aac00a8d 465 if (delegation == NULL)
6ee41268 466 continue;
aac00a8d
TM		 467 /* Is the delegation still valid? */
468 if (memcmp(stateid.data, delegation->stateid.data, sizeof(stateid.data)) != 0)
469 continue;
470 rcu_read_unlock();
471 update_open_stateid(state, NULL, &stateid, open_mode);
472 goto out_return_state;
473 }
aac00a8d
TM		 474 rcu_read_unlock();
475out:
476 return ERR_PTR(ret);
477out_return_state:
478 atomic_inc(&state->count);
479 return state;
480}
481
24ac23ab
TM		 482static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
483{
484 struct inode *inode;
485 struct nfs4_state *state = NULL;
003707c7
TM		 486 struct nfs_delegation *delegation;
487 nfs4_stateid *deleg_stateid = NULL;
1b370bc2 488 int ret;
24ac23ab 489
aac00a8d 490 if (!data->rpc_done) {
6ee41268 491 state = nfs4_try_open_cached(data);
aac00a8d
TM		 492 goto out;
493 }
494
1b370bc2 495 ret = -EAGAIN;
24ac23ab 496 if (!(data->f_attr.valid & NFS_ATTR_FATTR))
1b370bc2 497 goto err;
24ac23ab 498 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);
1b370bc2 499 ret = PTR_ERR(inode);
03f28e3a 500 if (IS_ERR(inode))
1b370bc2
TM		 501 goto err;
502 ret = -ENOMEM;
24ac23ab
TM		 503 state = nfs4_get_open_state(inode, data->owner);
504 if (state == NULL)
1b370bc2 505 goto err_put_inode;
549d6ed5 506 if (data->o_res.delegation_type != 0) {
549d6ed5
TM		 507 int delegation_flags = 0;
508
003707c7
TM		 509 rcu_read_lock();
510 delegation = rcu_dereference(NFS_I(inode)->delegation);
511 if (delegation)
512 delegation_flags = delegation->flags;
513 rcu_read_unlock();
549d6ed5
TM		 514 if (!(delegation_flags & NFS_DELEGATION_NEED_RECLAIM))
515 nfs_inode_set_delegation(state->inode,
516 data->owner->so_cred,
517 &data->o_res);
518 else
519 nfs_inode_reclaim_delegation(state->inode,
520 data->owner->so_cred,
521 &data->o_res);
522 }
003707c7
TM		 523 rcu_read_lock();
524 delegation = rcu_dereference(NFS_I(inode)->delegation);
525 if (delegation != NULL)
526 deleg_stateid = &delegation->stateid;
527 update_open_stateid(state, &data->o_res.stateid, deleg_stateid, data->o_arg.open_flags);
528 rcu_read_unlock();
24ac23ab 529 iput(inode);
aac00a8d 530out:
24ac23ab 531 return state;
1b370bc2
TM		 532err_put_inode:
533 iput(inode);
534err:
535 return ERR_PTR(ret);
24ac23ab
TM		 536}
537
864472e9
TM		 538static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
539{
540 struct nfs_inode *nfsi = NFS_I(state->inode);
541 struct nfs_open_context *ctx;
542
543 spin_lock(&state->inode->i_lock);
544 list_for_each_entry(ctx, &nfsi->open_files, list) {
545 if (ctx->state != state)
546 continue;
547 get_nfs_open_context(ctx);
548 spin_unlock(&state->inode->i_lock);
549 return ctx;
550 }
551 spin_unlock(&state->inode->i_lock);
552 return ERR_PTR(-ENOENT);
553}
554
6f220ed5
TM		 555static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx, struct nfs4_state *state)
556{
557 struct nfs4_opendata *opendata;
558
559 opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL);
560 if (opendata == NULL)
561 return ERR_PTR(-ENOMEM);
562 opendata->state = state;
563 atomic_inc(&state->count);
564 return opendata;
565}
566
2ced46c2 567static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, mode_t openflags, struct nfs4_state **res)
864472e9 568{
2ced46c2 569 struct nfs4_state *newstate;
864472e9
TM		 570 int ret;
571
572 opendata->o_arg.open_flags = openflags;
2ced46c2
TM		 573 memset(&opendata->o_res, 0, sizeof(opendata->o_res));
574 memset(&opendata->c_res, 0, sizeof(opendata->c_res));
575 nfs4_init_opendata_res(opendata);
864472e9
TM		 576 ret = _nfs4_proc_open(opendata);
577 if (ret != 0)
578 return ret;
2ced46c2 579 newstate = nfs4_opendata_to_nfs4_state(opendata);
1b370bc2
TM		 580 if (IS_ERR(newstate))
581 return PTR_ERR(newstate);
582 nfs4_close_state(&opendata->path, newstate, openflags);
2ced46c2 583 *res = newstate;
864472e9
TM		 584 return 0;
585}
586
587static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
588{
864472e9 589 struct nfs4_state *newstate;
864472e9
TM		 590 int ret;
591
592 /* memory barrier prior to reading state->n_* */
2ced46c2 593 clear_bit(NFS_DELEGATED_STATE, &state->flags);
864472e9
TM		 594 smp_rmb();
595 if (state->n_rdwr != 0) {
2ced46c2 596 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);
864472e9
TM		 597 if (ret != 0)
598 return ret;
2ced46c2
TM		 599 if (newstate != state)
600 return -ESTALE;
864472e9
TM		 601 }
602 if (state->n_wronly != 0) {
2ced46c2 603 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);
864472e9
TM		 604 if (ret != 0)
605 return ret;
2ced46c2
TM		 606 if (newstate != state)
607 return -ESTALE;
864472e9
TM		 608 }
609 if (state->n_rdonly != 0) {
2ced46c2 610 ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);
864472e9
TM		 611 if (ret != 0)
612 return ret;
2ced46c2
TM		 613 if (newstate != state)
614 return -ESTALE;
864472e9 615 }
1ac7e2fd
TM		 616 /*
617 * We may have performed cached opens for all three recoveries.
618 * Check if we need to update the current stateid.
619 */
620 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
621 memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) {
8bda4e4c 622 write_seqlock(&state->seqlock);
1ac7e2fd
TM		 623 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
624 memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data));
8bda4e4c 625 write_sequnlock(&state->seqlock);
1ac7e2fd 626 }
864472e9
TM		 627 return 0;
628}
629
1da177e4
LT		 630/*
631 * OPEN_RECLAIM:
632 * reclaim state on the server after a reboot.
1da177e4 633 */
539cd03a 634static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1da177e4 635{
1ac7e2fd 636 struct nfs_delegation *delegation;
864472e9
TM		 637 struct nfs4_opendata *opendata;
638 int delegation_type = 0;
1da177e4
LT		 639 int status;
640
6f220ed5
TM		 641 opendata = nfs4_open_recoverdata_alloc(ctx, state);
642 if (IS_ERR(opendata))
643 return PTR_ERR(opendata);
864472e9
TM		 644 opendata->o_arg.claim = NFS4_OPEN_CLAIM_PREVIOUS;
645 opendata->o_arg.fh = NFS_FH(state->inode);
1ac7e2fd
TM		 646 rcu_read_lock();
647 delegation = rcu_dereference(NFS_I(state->inode)->delegation);
648 if (delegation != NULL && (delegation->flags & NFS_DELEGATION_NEED_RECLAIM) != 0)
649 delegation_type = delegation->flags;
650 rcu_read_unlock();
864472e9
TM		 651 opendata->o_arg.u.delegation_type = delegation_type;
652 status = nfs4_open_recover(opendata, state);
c6d00e63 653 nfs4_opendata_put(opendata);
1da177e4
LT		 654 return status;
655}
656
539cd03a 657static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1da177e4
LT		 658{
659 struct nfs_server *server = NFS_SERVER(state->inode);
660 struct nfs4_exception exception = { };
661 int err;
662 do {
539cd03a 663 err = _nfs4_do_open_reclaim(ctx, state);
202b50dc
TM		 664 if (err != -NFS4ERR_DELAY)
665 break;
666 nfs4_handle_exception(server, err, &exception);
1da177e4
LT		 667 } while (exception.retry);
668 return err;
669}
670
864472e9
TM		 671static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
672{
673 struct nfs_open_context *ctx;
674 int ret;
675
676 ctx = nfs4_state_find_open_context(state);
677 if (IS_ERR(ctx))
678 return PTR_ERR(ctx);
539cd03a 679 ret = nfs4_do_open_reclaim(ctx, state);
864472e9
TM		 680 put_nfs_open_context(ctx);
681 return ret;
682}
683
13437e12 684static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
1da177e4 685{
e56e0b78 686 struct nfs4_opendata *opendata;
864472e9 687 int ret;
1da177e4 688
6f220ed5
TM		 689 opendata = nfs4_open_recoverdata_alloc(ctx, state);
690 if (IS_ERR(opendata))
691 return PTR_ERR(opendata);
e56e0b78 692 opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR;
13437e12 693 memcpy(opendata->o_arg.u.delegation.data, stateid->data,
e56e0b78 694 sizeof(opendata->o_arg.u.delegation.data));
864472e9 695 ret = nfs4_open_recover(opendata, state);
c6d00e63 696 nfs4_opendata_put(opendata);
864472e9 697 return ret;
1da177e4
LT		 698}
699
13437e12 700int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
1da177e4
LT		 701{
702 struct nfs4_exception exception = { };
539cd03a 703 struct nfs_server *server = NFS_SERVER(state->inode);
1da177e4
LT		 704 int err;
705 do {
13437e12 706 err = _nfs4_open_delegation_recall(ctx, state, stateid);
1da177e4
LT		 707 switch (err) {
708 case 0:
709 return err;
710 case -NFS4ERR_STALE_CLIENTID:
711 case -NFS4ERR_STALE_STATEID:
712 case -NFS4ERR_EXPIRED:
713 /* Don't recall a delegation if it was lost */
7539bbab 714 nfs4_schedule_state_recovery(server->nfs_client);
1da177e4
LT		 715 return err;
716 }
717 err = nfs4_handle_exception(server, err, &exception);
718 } while (exception.retry);
719 return err;
720}
721
cdd4e68b 722static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata)
1da177e4 723{
cdd4e68b
TM		 724 struct nfs4_opendata *data = calldata;
725 struct rpc_message msg = {
726 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
727 .rpc_argp = &data->c_arg,
728 .rpc_resp = &data->c_res,
729 .rpc_cred = data->owner->so_cred,
1da177e4 730 };
26e976a8 731 data->timestamp = jiffies;
cdd4e68b
TM		 732 rpc_call_setup(task, &msg, 0);
733}
734
735static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
736{
737 struct nfs4_opendata *data = calldata;
738
739 data->rpc_status = task->tk_status;
740 if (RPC_ASSASSINATED(task))
741 return;
26e976a8 742 if (data->rpc_status == 0) {
cdd4e68b
TM		 743 memcpy(data->o_res.stateid.data, data->c_res.stateid.data,
744 sizeof(data->o_res.stateid.data));
26e976a8 745 renew_lease(data->o_res.server, data->timestamp);
3e309914 746 data->rpc_done = 1;
26e976a8 747 }
cdd4e68b 748 nfs_confirm_seqid(&data->owner->so_seqid, data->rpc_status);
0f9f95e0 749 nfs_increment_open_seqid(data->rpc_status, data->c_arg.seqid);
cdd4e68b
TM		 750}
751
752static void nfs4_open_confirm_release(void *calldata)
753{
754 struct nfs4_opendata *data = calldata;
755 struct nfs4_state *state = NULL;
756
757 /* If this request hasn't been cancelled, do nothing */
758 if (data->cancelled == 0)
759 goto out_free;
760 /* In case of error, no cleanup! */
3e309914 761 if (!data->rpc_done)
cdd4e68b
TM		 762 goto out_free;
763 nfs_confirm_seqid(&data->owner->so_seqid, 0);
764 state = nfs4_opendata_to_nfs4_state(data);
1b370bc2 765 if (!IS_ERR(state))
4a35bd41 766 nfs4_close_state(&data->path, state, data->o_arg.open_flags);
cdd4e68b 767out_free:
c6d00e63 768 nfs4_opendata_put(data);
cdd4e68b
TM		 769}
770
771static const struct rpc_call_ops nfs4_open_confirm_ops = {
772 .rpc_call_prepare = nfs4_open_confirm_prepare,
773 .rpc_call_done = nfs4_open_confirm_done,
774 .rpc_release = nfs4_open_confirm_release,
775};
776
777/*
778 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
779 */
780static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
781{
782 struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
783 struct rpc_task *task;
1da177e4
LT		 784 int status;
785
c6d00e63 786 kref_get(&data->kref);
3e309914
TM		 787 data->rpc_done = 0;
788 data->rpc_status = 0;
cdd4e68b 789 task = rpc_run_task(server->client, RPC_TASK_ASYNC, &nfs4_open_confirm_ops, data);
7a1218a2 790 if (IS_ERR(task))
cdd4e68b 791 return PTR_ERR(task);
cdd4e68b
TM		 792 status = nfs4_wait_for_completion_rpc_task(task);
793 if (status != 0) {
794 data->cancelled = 1;
795 smp_wmb();
796 } else
797 status = data->rpc_status;
e6b3c4db 798 rpc_put_task(task);
1da177e4
LT		 799 return status;
800}
801
24ac23ab 802static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
1da177e4 803{
24ac23ab
TM		 804 struct nfs4_opendata *data = calldata;
805 struct nfs4_state_owner *sp = data->owner;
1da177e4
LT		 806 struct rpc_message msg = {
807 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
24ac23ab
TM		 808 .rpc_argp = &data->o_arg,
809 .rpc_resp = &data->o_res,
1da177e4
LT		 810 .rpc_cred = sp->so_cred,
811 };
24ac23ab
TM		 812
813 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
814 return;
aac00a8d
TM		 815 /*
816 * Check if we still need to send an OPEN call, or if we can use
817 * a delegation instead.
818 */
819 if (data->state != NULL) {
820 struct nfs_delegation *delegation;
821
6ee41268
TM		 822 if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ|FMODE_WRITE|O_EXCL)))
823 goto out_no_action;
aac00a8d
TM		 824 rcu_read_lock();
825 delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
826 if (delegation != NULL &&
827 (delegation->flags & NFS_DELEGATION_NEED_RECLAIM) == 0) {
828 rcu_read_unlock();
6ee41268 829 goto out_no_action;
aac00a8d
TM		 830 }
831 rcu_read_unlock();
832 }
24ac23ab 833 /* Update sequence id. */
9f958ab8 834 data->o_arg.id = sp->so_owner_id.id;
24ac23ab 835 data->o_arg.clientid = sp->so_client->cl_clientid;
6f220ed5 836 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) {
864472e9 837 msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
6f220ed5
TM		 838 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
839 }
26e976a8 840 data->timestamp = jiffies;
24ac23ab 841 rpc_call_setup(task, &msg, 0);
6ee41268
TM		 842 return;
843out_no_action:
844 task->tk_action = NULL;
845
24ac23ab 846}
1da177e4 847
24ac23ab
TM		 848static void nfs4_open_done(struct rpc_task *task, void *calldata)
849{
850 struct nfs4_opendata *data = calldata;
1da177e4 851
24ac23ab
TM		 852 data->rpc_status = task->tk_status;
853 if (RPC_ASSASSINATED(task))
854 return;
855 if (task->tk_status == 0) {
856 switch (data->o_res.f_attr->mode & S_IFMT) {
6f926b5b
TM		 857 case S_IFREG:
858 break;
859 case S_IFLNK:
24ac23ab 860 data->rpc_status = -ELOOP;
6f926b5b
TM		 861 break;
862 case S_IFDIR:
24ac23ab 863 data->rpc_status = -EISDIR;
6f926b5b
TM		 864 break;
865 default:
24ac23ab 866 data->rpc_status = -ENOTDIR;
6f926b5b 867 }
26e976a8 868 renew_lease(data->o_res.server, data->timestamp);
0f9f95e0
TM		 869 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
870 nfs_confirm_seqid(&data->owner->so_seqid, 0);
6f926b5b 871 }
24ac23ab 872 nfs_increment_open_seqid(data->rpc_status, data->o_arg.seqid);
3e309914 873 data->rpc_done = 1;
24ac23ab 874}
6f926b5b 875
24ac23ab
TM		 876static void nfs4_open_release(void *calldata)
877{
878 struct nfs4_opendata *data = calldata;
879 struct nfs4_state *state = NULL;
880
881 /* If this request hasn't been cancelled, do nothing */
882 if (data->cancelled == 0)
883 goto out_free;
884 /* In case of error, no cleanup! */
3e309914 885 if (data->rpc_status != 0 || !data->rpc_done)
24ac23ab
TM		 886 goto out_free;
887 /* In case we need an open_confirm, no cleanup! */
888 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
889 goto out_free;
890 nfs_confirm_seqid(&data->owner->so_seqid, 0);
891 state = nfs4_opendata_to_nfs4_state(data);
1b370bc2 892 if (!IS_ERR(state))
4a35bd41 893 nfs4_close_state(&data->path, state, data->o_arg.open_flags);
24ac23ab 894out_free:
c6d00e63 895 nfs4_opendata_put(data);
24ac23ab
TM		 896}
897
898static const struct rpc_call_ops nfs4_open_ops = {
899 .rpc_call_prepare = nfs4_open_prepare,
900 .rpc_call_done = nfs4_open_done,
901 .rpc_release = nfs4_open_release,
902};
903
904/*
905 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
906 */
907static int _nfs4_proc_open(struct nfs4_opendata *data)
908{
909 struct inode *dir = data->dir->d_inode;
910 struct nfs_server *server = NFS_SERVER(dir);
911 struct nfs_openargs *o_arg = &data->o_arg;
912 struct nfs_openres *o_res = &data->o_res;
913 struct rpc_task *task;
914 int status;
915
c6d00e63 916 kref_get(&data->kref);
3e309914
TM		 917 data->rpc_done = 0;
918 data->rpc_status = 0;
2ced46c2 919 data->cancelled = 0;
24ac23ab 920 task = rpc_run_task(server->client, RPC_TASK_ASYNC, &nfs4_open_ops, data);
7a1218a2 921 if (IS_ERR(task))
24ac23ab 922 return PTR_ERR(task);
24ac23ab
TM		 923 status = nfs4_wait_for_completion_rpc_task(task);
924 if (status != 0) {
925 data->cancelled = 1;
926 smp_wmb();
927 } else
928 status = data->rpc_status;
e6b3c4db 929 rpc_put_task(task);
3e309914 930 if (status != 0 || !data->rpc_done)
24ac23ab
TM		 931 return status;
932
56ae19f3
TM		 933 if (o_arg->open_flags & O_CREAT) {
934 update_changeattr(dir, &o_res->cinfo);
935 nfs_post_op_update_inode(dir, o_res->dir_attr);
936 } else
937 nfs_refresh_inode(dir, o_res->dir_attr);
1da177e4 938 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
cdd4e68b 939 status = _nfs4_proc_open_confirm(data);
1da177e4 940 if (status != 0)
24ac23ab 941 return status;
1da177e4
LT		 942 }
943 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
8fa5c000 944 return server->nfs_client->rpc_ops->getattr(server, &o_res->fh, o_res->f_attr);
24ac23ab 945 return 0;
1da177e4
LT		 946}
947
948static int _nfs4_do_access(struct inode *inode, struct rpc_cred *cred, int openflags)
949{
950 struct nfs_access_entry cache;
951 int mask = 0;
952 int status;
953
954 if (openflags & FMODE_READ)
955 mask |= MAY_READ;
956 if (openflags & FMODE_WRITE)
957 mask |= MAY_WRITE;
1b45c46c
TM		 958 if (openflags & FMODE_EXEC)
959 mask |= MAY_EXEC;
1da177e4
LT		 960 status = nfs_access_get_cached(inode, cred, &cache);
961 if (status == 0)
962 goto out;
963
964 /* Be clever: ask server to check for all possible rights */
965 cache.mask = MAY_EXEC | MAY_WRITE | MAY_READ;
966 cache.cred = cred;
967 cache.jiffies = jiffies;
968 status = _nfs4_proc_access(inode, &cache);
969 if (status != 0)
970 return status;
971 nfs_access_add_cache(inode, &cache);
972out:
973 if ((cache.mask & mask) == mask)
974 return 0;
975 return -EACCES;
976}
977
10afec90 978static int nfs4_recover_expired_lease(struct nfs_server *server)
58d9714a 979{
7539bbab 980 struct nfs_client *clp = server->nfs_client;
6b30954e 981 int ret;
58d9714a 982
6b30954e
TM		 983 for (;;) {
984 ret = nfs4_wait_clnt_recover(server->client, clp);
985 if (ret != 0)
986 return ret;
987 if (!test_and_clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
988 break;
58d9714a 989 nfs4_schedule_state_recovery(clp);
6b30954e
TM		 990 }
991 return 0;
58d9714a
TM		 992}
993
1da177e4
LT		 994/*
995 * OPEN_EXPIRED:
996 * reclaim state on the server after a network partition.
997 * Assumes caller holds the appropriate lock
998 */
539cd03a 999static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
1da177e4 1000{
e56e0b78 1001 struct nfs4_opendata *opendata;
864472e9 1002 int ret;
1da177e4 1003
6f220ed5
TM		 1004 opendata = nfs4_open_recoverdata_alloc(ctx, state);
1005 if (IS_ERR(opendata))
1006 return PTR_ERR(opendata);
864472e9
TM		 1007 ret = nfs4_open_recover(opendata, state);
1008 if (ret == -ESTALE) {
1009 /* Invalidate the state owner so we don't ever use it again */
539cd03a
TM		 1010 nfs4_drop_state_owner(state->owner);
1011 d_drop(ctx->path.dentry);
1da177e4 1012 }
c6d00e63 1013 nfs4_opendata_put(opendata);
864472e9 1014 return ret;
1da177e4
LT		 1015}
1016
539cd03a 1017static inline int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
202b50dc 1018{
539cd03a 1019 struct nfs_server *server = NFS_SERVER(state->inode);
202b50dc
TM		 1020 struct nfs4_exception exception = { };
1021 int err;
1022
1023 do {
539cd03a 1024 err = _nfs4_open_expired(ctx, state);
202b50dc
TM		 1025 if (err == -NFS4ERR_DELAY)
1026 nfs4_handle_exception(server, err, &exception);
1027 } while (exception.retry);
1028 return err;
1029}
1030
1da177e4
LT		 1031static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
1032{
1da177e4 1033 struct nfs_open_context *ctx;
864472e9 1034 int ret;
1da177e4 1035
864472e9
TM		 1036 ctx = nfs4_state_find_open_context(state);
1037 if (IS_ERR(ctx))
1038 return PTR_ERR(ctx);
539cd03a 1039 ret = nfs4_do_open_expired(ctx, state);
864472e9
TM		 1040 put_nfs_open_context(ctx);
1041 return ret;
1da177e4
LT		 1042}
1043
aa53ed54
JL		 1044/*
1045 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
1046 * fields corresponding to attributes that were used to store the verifier.
1047 * Make sure we clobber those fields in the later setattr call
1048 */
1049static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)
1050{
1051 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
1052 !(sattr->ia_valid & ATTR_ATIME_SET))
1053 sattr->ia_valid |= ATTR_ATIME;
1054
1055 if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
1056 !(sattr->ia_valid & ATTR_MTIME_SET))
1057 sattr->ia_valid |= ATTR_MTIME;
1058}
1059
1da177e4 1060/*
24ac23ab 1061 * Returns a referenced nfs4_state
1da177e4 1062 */
ad389da7 1063static int _nfs4_do_open(struct inode *dir, struct path *path, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
1da177e4
LT		 1064{
1065 struct nfs4_state_owner *sp;
1066 struct nfs4_state *state = NULL;
1067 struct nfs_server *server = NFS_SERVER(dir);
7539bbab 1068 struct nfs_client *clp = server->nfs_client;
e56e0b78 1069 struct nfs4_opendata *opendata;
aac00a8d 1070 int status;
1da177e4
LT		 1071
1072 /* Protect against reboot recovery conflicts */
1da177e4
LT		 1073 status = -ENOMEM;
1074 if (!(sp = nfs4_get_state_owner(server, cred))) {
1075 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
1076 goto out_err;
1077 }
58d9714a
TM		 1078 status = nfs4_recover_expired_lease(server);
1079 if (status != 0)
b4454fe1 1080 goto err_put_state_owner;
aac00a8d
TM		 1081 if (path->dentry->d_inode != NULL)
1082 nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ|FMODE_WRITE));
58d9714a
TM		 1083 down_read(&clp->cl_sem);
1084 status = -ENOMEM;
ad389da7 1085 opendata = nfs4_opendata_alloc(path, sp, flags, sattr);
e56e0b78 1086 if (opendata == NULL)
76723de0 1087 goto err_release_rwsem;
1da177e4 1088
aac00a8d
TM		 1089 if (path->dentry->d_inode != NULL)
1090 opendata->state = nfs4_get_open_state(path->dentry->d_inode, sp);
1091
24ac23ab 1092 status = _nfs4_proc_open(opendata);
1da177e4 1093 if (status != 0)
c6d00e63 1094 goto err_opendata_put;
1da177e4 1095
aa53ed54
JL		 1096 if (opendata->o_arg.open_flags & O_EXCL)
1097 nfs4_exclusive_attrset(opendata, sattr);
1098
24ac23ab 1099 state = nfs4_opendata_to_nfs4_state(opendata);
1b370bc2
TM		 1100 status = PTR_ERR(state);
1101 if (IS_ERR(state))
c6d00e63 1102 goto err_opendata_put;
c6d00e63 1103 nfs4_opendata_put(opendata);
1da177e4
LT		 1104 nfs4_put_state_owner(sp);
1105 up_read(&clp->cl_sem);
1106 *res = state;
1107 return 0;
c6d00e63
TM		 1108err_opendata_put:
1109 nfs4_opendata_put(opendata);
76723de0
TM		 1110err_release_rwsem:
1111 up_read(&clp->cl_sem);
e56e0b78
TM		 1112err_put_state_owner:
1113 nfs4_put_state_owner(sp);
1da177e4 1114out_err:
1da177e4
LT		 1115 *res = NULL;
1116 return status;
1117}
1118
1119
ad389da7 1120static struct nfs4_state *nfs4_do_open(struct inode *dir, struct path *path, int flags, struct iattr *sattr, struct rpc_cred *cred)
1da177e4
LT		 1121{
1122 struct nfs4_exception exception = { };
1123 struct nfs4_state *res;
1124 int status;
1125
1126 do {
ad389da7 1127 status = _nfs4_do_open(dir, path, flags, sattr, cred, &res);
1da177e4
LT		 1128 if (status == 0)
1129 break;
1130 /* NOTE: BAD_SEQID means the server and client disagree about the
1131 * book-keeping w.r.t. state-changing operations
1132 * (OPEN/CLOSE/LOCK/LOCKU...)
1133 * It is actually a sign of a bug on the client or on the server.
1134 *
1135 * If we receive a BAD_SEQID error in the particular case of
cee54fc9 1136 * doing an OPEN, we assume that nfs_increment_open_seqid() will
1da177e4
LT		 1137 * have unhashed the old state_owner for us, and that we can
1138 * therefore safely retry using a new one. We should still warn
1139 * the user though...
1140 */
1141 if (status == -NFS4ERR_BAD_SEQID) {
6f43ddcc
TM		 1142 printk(KERN_WARNING "NFS: v4 server %s "
1143 " returned a bad sequence-id error!\n",
1144 NFS_SERVER(dir)->nfs_client->cl_hostname);
1da177e4
LT		 1145 exception.retry = 1;
1146 continue;
1147 }
550f5747
TM		 1148 /*
1149 * BAD_STATEID on OPEN means that the server cancelled our
1150 * state before it received the OPEN_CONFIRM.
1151 * Recover by retrying the request as per the discussion
1152 * on Page 181 of RFC3530.
1153 */
1154 if (status == -NFS4ERR_BAD_STATEID) {
1155 exception.retry = 1;
1156 continue;
1157 }
aac00a8d
TM		 1158 if (status == -EAGAIN) {
1159 /* We must have found a delegation */
1160 exception.retry = 1;
1161 continue;
1162 }
1da177e4
LT		 1163 res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir),
1164 status, &exception));
1165 } while (exception.retry);
1166 return res;
1167}
1168
3e4f6290
TM		 1169static int _nfs4_do_setattr(struct inode *inode, struct nfs_fattr *fattr,
1170 struct iattr *sattr, struct nfs4_state *state)
1da177e4 1171{
3e4f6290 1172 struct nfs_server *server = NFS_SERVER(inode);
1da177e4 1173 struct nfs_setattrargs arg = {
3e4f6290 1174 .fh = NFS_FH(inode),
1da177e4
LT		 1175 .iap = sattr,
1176 .server = server,
1177 .bitmask = server->attr_bitmask,
1178 };
1179 struct nfs_setattrres res = {
1180 .fattr = fattr,
1181 .server = server,
1182 };
1183 struct rpc_message msg = {
1184 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
1185 .rpc_argp = &arg,
1186 .rpc_resp = &res,
1187 };
26e976a8 1188 unsigned long timestamp = jiffies;
65e4308d 1189 int status;
1da177e4 1190
0e574af1 1191 nfs_fattr_init(fattr);
1da177e4 1192
3e4f6290
TM		 1193 if (nfs4_copy_delegation_stateid(&arg.stateid, inode)) {
1194 /* Use that stateid */
1195 } else if (state != NULL) {
1da177e4 1196 msg.rpc_cred = state->owner->so_cred;
08e9eac4
TM		 1197 nfs4_copy_stateid(&arg.stateid, state, current->files);
1198 } else
1da177e4
LT		 1199 memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid));
1200
65e4308d 1201 status = rpc_call_sync(server->client, &msg, 0);
26e976a8
TM		 1202 if (status == 0 && state != NULL)
1203 renew_lease(server, timestamp);
65e4308d 1204 return status;
1da177e4
LT		 1205}
1206
3e4f6290
TM		 1207static int nfs4_do_setattr(struct inode *inode, struct nfs_fattr *fattr,
1208 struct iattr *sattr, struct nfs4_state *state)
1da177e4 1209{
3e4f6290 1210 struct nfs_server *server = NFS_SERVER(inode);
1da177e4
LT		 1211 struct nfs4_exception exception = { };
1212 int err;
1213 do {
1214 err = nfs4_handle_exception(server,
3e4f6290 1215 _nfs4_do_setattr(inode, fattr, sattr, state),
1da177e4
LT		 1216 &exception);
1217 } while (exception.retry);
1218 return err;
1219}
1220
1221struct nfs4_closedata {
4a35bd41 1222 struct path path;
1da177e4
LT		 1223 struct inode *inode;
1224 struct nfs4_state *state;
1225 struct nfs_closeargs arg;
1226 struct nfs_closeres res;
516a6af6 1227 struct nfs_fattr fattr;
26e976a8 1228 unsigned long timestamp;
1da177e4
LT		 1229};
1230
963d8fe5 1231static void nfs4_free_closedata(void *data)
9512135d 1232{
963d8fe5
TM		 1233 struct nfs4_closedata *calldata = data;
1234 struct nfs4_state_owner *sp = calldata->state->owner;
9512135d
TM		 1235
1236 nfs4_put_open_state(calldata->state);
1237 nfs_free_seqid(calldata->arg.seqid);
9512135d 1238 nfs4_put_state_owner(sp);
4a35bd41
TM		 1239 dput(calldata->path.dentry);
1240 mntput(calldata->path.mnt);
9512135d
TM		 1241 kfree(calldata);
1242}
1243
963d8fe5 1244static void nfs4_close_done(struct rpc_task *task, void *data)
1da177e4 1245{
963d8fe5 1246 struct nfs4_closedata *calldata = data;
1da177e4 1247 struct nfs4_state *state = calldata->state;
1da177e4
LT		 1248 struct nfs_server *server = NFS_SERVER(calldata->inode);
1249
4ce70ada
TM		 1250 if (RPC_ASSASSINATED(task))
1251 return;
1da177e4
LT		 1252 /* hmm. we are done with the inode, and in the process of freeing
1253 * the state_owner. we keep this around to process errors
1254 */
cee54fc9 1255 nfs_increment_open_seqid(task->tk_status, calldata->arg.seqid);
1da177e4
LT		 1256 switch (task->tk_status) {
1257 case 0:
003707c7 1258 nfs_set_open_stateid(state, &calldata->res.stateid, calldata->arg.open_flags);
26e976a8 1259 renew_lease(server, calldata->timestamp);
1da177e4
LT		 1260 break;
1261 case -NFS4ERR_STALE_STATEID:
1262 case -NFS4ERR_EXPIRED:
1da177e4
LT		 1263 break;
1264 default:
1265 if (nfs4_async_handle_error(task, server) == -EAGAIN) {
1266 rpc_restart_call(task);
1267 return;
1268 }
1269 }
516a6af6 1270 nfs_refresh_inode(calldata->inode, calldata->res.fattr);
1da177e4
LT		 1271}
1272
4ce70ada 1273static void nfs4_close_prepare(struct rpc_task *task, void *data)
1da177e4 1274{
4ce70ada 1275 struct nfs4_closedata *calldata = data;
9512135d 1276 struct nfs4_state *state = calldata->state;
1da177e4
LT		 1277 struct rpc_message msg = {
1278 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
1279 .rpc_argp = &calldata->arg,
1280 .rpc_resp = &calldata->res,
9512135d 1281 .rpc_cred = state->owner->so_cred,
1da177e4 1282 };
003707c7
TM		 1283 int clear_rd, clear_wr, clear_rdwr;
1284 int mode;
9512135d 1285
963d8fe5 1286 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
9512135d 1287 return;
003707c7
TM		 1288
1289 mode = FMODE_READ|FMODE_WRITE;
1290 clear_rd = clear_wr = clear_rdwr = 0;
4cecb76f 1291 spin_lock(&state->owner->so_lock);
003707c7 1292 /* Calculate the change in open mode */
e7616923 1293 if (state->n_rdwr == 0) {
003707c7 1294 if (state->n_rdonly == 0) {
e7616923 1295 mode &= ~FMODE_READ;
003707c7
TM		 1296 clear_rd |= test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1297 clear_rdwr |= test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags);
1298 }
1299 if (state->n_wronly == 0) {
e7616923 1300 mode &= ~FMODE_WRITE;
003707c7
TM		 1301 clear_wr |= test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1302 clear_rdwr |= test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags);
1303 }
e7616923 1304 }
4cecb76f 1305 spin_unlock(&state->owner->so_lock);
003707c7 1306 if (!clear_rd && !clear_wr && !clear_rdwr) {
963d8fe5
TM		 1307 /* Note: exit _without_ calling nfs4_close_done */
1308 task->tk_action = NULL;
9512135d
TM		 1309 return;
1310 }
516a6af6 1311 nfs_fattr_init(calldata->res.fattr);
9512135d 1312 if (mode != 0)
1da177e4 1313 msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
9512135d 1314 calldata->arg.open_flags = mode;
26e976a8 1315 calldata->timestamp = jiffies;
9512135d 1316 rpc_call_setup(task, &msg, 0);
1da177e4
LT		 1317}
1318
963d8fe5 1319static const struct rpc_call_ops nfs4_close_ops = {
4ce70ada 1320 .rpc_call_prepare = nfs4_close_prepare,
963d8fe5
TM		 1321 .rpc_call_done = nfs4_close_done,
1322 .rpc_release = nfs4_free_closedata,
1323};
1324
1da177e4
LT		 1325/*
1326 * It is possible for data to be read/written from a mem-mapped file
1327 * after the sys_close call (which hits the vfs layer as a flush).
1328 * This means that we can't safely call nfsv4 close on a file until
1329 * the inode is cleared. This in turn means that we are not good
1330 * NFSv4 citizens - we do not indicate to the server to update the file's
1331 * share state even when we are done with one of the three share
1332 * stateid's in the inode.
1333 *
1334 * NOTE: Caller must be holding the sp->so_owner semaphore!
1335 */
4a35bd41 1336int nfs4_do_close(struct path *path, struct nfs4_state *state)
1da177e4 1337{
4a35bd41 1338 struct nfs_server *server = NFS_SERVER(state->inode);
1da177e4 1339 struct nfs4_closedata *calldata;
b39e625b
TM		 1340 struct nfs4_state_owner *sp = state->owner;
1341 struct rpc_task *task;
9512135d 1342 int status = -ENOMEM;
1da177e4 1343
9512135d 1344 calldata = kmalloc(sizeof(*calldata), GFP_KERNEL);
1da177e4 1345 if (calldata == NULL)
9512135d 1346 goto out;
4a35bd41 1347 calldata->inode = state->inode;
1da177e4 1348 calldata->state = state;
4a35bd41 1349 calldata->arg.fh = NFS_FH(state->inode);
003707c7 1350 calldata->arg.stateid = &state->open_stateid;
1da177e4 1351 /* Serialization for the sequence id */
cee54fc9 1352 calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid);
9512135d
TM		 1353 if (calldata->arg.seqid == NULL)
1354 goto out_free_calldata;
516a6af6
TM		 1355 calldata->arg.bitmask = server->attr_bitmask;
1356 calldata->res.fattr = &calldata->fattr;
1357 calldata->res.server = server;
4a35bd41
TM		 1358 calldata->path.mnt = mntget(path->mnt);
1359 calldata->path.dentry = dget(path->dentry);
9512135d 1360
b39e625b
TM		 1361 task = rpc_run_task(server->client, RPC_TASK_ASYNC, &nfs4_close_ops, calldata);
1362 if (IS_ERR(task))
1363 return PTR_ERR(task);
1364 rpc_put_task(task);
1365 return 0;
9512135d
TM		 1366out_free_calldata:
1367 kfree(calldata);
1368out:
b39e625b
TM		 1369 nfs4_put_open_state(state);
1370 nfs4_put_state_owner(sp);
9512135d 1371 return status;
1da177e4
LT		 1372}
1373
4a35bd41 1374static int nfs4_intent_set_file(struct nameidata *nd, struct path *path, struct nfs4_state *state)
02a913a7
TM		 1375{
1376 struct file *filp;
1b45c46c 1377 int ret;
02a913a7 1378
1b45c46c
TM		 1379 /* If the open_intent is for execute, we have an extra check to make */
1380 if (nd->intent.open.flags & FMODE_EXEC) {
1381 ret = _nfs4_do_access(state->inode,
1382 state->owner->so_cred,
1383 nd->intent.open.flags);
1384 if (ret < 0)
1385 goto out_close;
1386 }
4a35bd41 1387 filp = lookup_instantiate_filp(nd, path->dentry, NULL);
02a913a7
TM		 1388 if (!IS_ERR(filp)) {
1389 struct nfs_open_context *ctx;
1390 ctx = (struct nfs_open_context *)filp->private_data;
1391 ctx->state = state;
95cf959b
TM		 1392 return 0;
1393 }
1b45c46c
TM		 1394 ret = PTR_ERR(filp);
1395out_close:
4a35bd41 1396 nfs4_close_state(path, state, nd->intent.open.flags);
1b45c46c 1397 return ret;
02a913a7
TM		 1398}
1399
1400struct dentry *
1da177e4
LT		 1401nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
1402{
ad389da7
TM		 1403 struct path path = {
1404 .mnt = nd->mnt,
1405 .dentry = dentry,
1406 };
1da177e4
LT		 1407 struct iattr attr;
1408 struct rpc_cred *cred;
1409 struct nfs4_state *state;
02a913a7 1410 struct dentry *res;
1da177e4
LT		 1411
1412 if (nd->flags & LOOKUP_CREATE) {
1413 attr.ia_mode = nd->intent.open.create_mode;
1414 attr.ia_valid = ATTR_MODE;
1415 if (!IS_POSIXACL(dir))
1416 attr.ia_mode &= ~current->fs->umask;
1417 } else {
1418 attr.ia_valid = 0;
1419 BUG_ON(nd->intent.open.flags & O_CREAT);
1420 }
1421
1f163415 1422 cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0);
1da177e4 1423 if (IS_ERR(cred))
02a913a7 1424 return (struct dentry *)cred;
ad389da7 1425 state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred);
1da177e4 1426 put_rpccred(cred);
02a913a7
TM		 1427 if (IS_ERR(state)) {
1428 if (PTR_ERR(state) == -ENOENT)
1429 d_add(dentry, NULL);
1430 return (struct dentry *)state;
1431 }
24ac23ab 1432 res = d_add_unique(dentry, igrab(state->inode));
02a913a7
TM		 1433 if (res != NULL)
1434 dentry = res;
4a35bd41 1435 nfs4_intent_set_file(nd, &path, state);
02a913a7 1436 return res;
1da177e4
LT		 1437}
1438
1439int
02a913a7 1440nfs4_open_revalidate(struct inode *dir, struct dentry *dentry, int openflags, struct nameidata *nd)
1da177e4 1441{
ad389da7
TM		 1442 struct path path = {
1443 .mnt = nd->mnt,
1444 .dentry = dentry,
1445 };
1da177e4
LT		 1446 struct rpc_cred *cred;
1447 struct nfs4_state *state;
1da177e4 1448
1f163415 1449 cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0);
1da177e4
LT		 1450 if (IS_ERR(cred))
1451 return PTR_ERR(cred);
aac00a8d 1452 state = nfs4_do_open(dir, &path, openflags, NULL, cred);
1da177e4 1453 put_rpccred(cred);
02a913a7
TM		 1454 if (IS_ERR(state)) {
1455 switch (PTR_ERR(state)) {
1456 case -EPERM:
1457 case -EACCES:
1458 case -EDQUOT:
1459 case -ENOSPC:
1460 case -EROFS:
1461 lookup_instantiate_filp(nd, (struct dentry *)state, NULL);
1462 return 1;
b87c0adf
CL		 1463 default:
1464 goto out_drop;
02a913a7 1465 }
02a913a7 1466 }
24ac23ab 1467 if (state->inode == dentry->d_inode) {
4a35bd41 1468 nfs4_intent_set_file(nd, &path, state);
1da177e4
LT		 1469 return 1;
1470 }
4a35bd41 1471 nfs4_close_state(&path, state, openflags);
02a913a7
TM		 1472out_drop:
1473 d_drop(dentry);
1da177e4
LT		 1474 return 0;
1475}
1476
1477
1478static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
1479{
1480 struct nfs4_server_caps_res res = {};
1481 struct rpc_message msg = {
1482 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
1483 .rpc_argp = fhandle,
1484 .rpc_resp = &res,
1485 };
1486 int status;
1487
1488 status = rpc_call_sync(server->client, &msg, 0);
1489 if (status == 0) {
1490 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
1491 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL)
1492 server->caps |= NFS_CAP_ACLS;
1493 if (res.has_links != 0)
1494 server->caps |= NFS_CAP_HARDLINKS;
1495 if (res.has_symlinks != 0)
1496 server->caps |= NFS_CAP_SYMLINKS;
1497 server->acl_bitmask = res.acl_bitmask;
1498 }
1499 return status;
1500}
1501
55a97593 1502int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
1da177e4
LT		 1503{
1504 struct nfs4_exception exception = { };
1505 int err;
1506 do {
1507 err = nfs4_handle_exception(server,
1508 _nfs4_server_capabilities(server, fhandle),
1509 &exception);
1510 } while (exception.retry);
1511 return err;
1512}
1513
1514static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
1515 struct nfs_fsinfo *info)
1516{
1da177e4
LT		 1517 struct nfs4_lookup_root_arg args = {
1518 .bitmask = nfs4_fattr_bitmap,
1519 };
1520 struct nfs4_lookup_res res = {
1521 .server = server,
0e574af1 1522 .fattr = info->fattr,
1da177e4
LT		 1523 .fh = fhandle,
1524 };
1525 struct rpc_message msg = {
1526 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
1527 .rpc_argp = &args,
1528 .rpc_resp = &res,
1529 };
0e574af1 1530 nfs_fattr_init(info->fattr);
1da177e4
LT		 1531 return rpc_call_sync(server->client, &msg, 0);
1532}
1533
1534static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
1535 struct nfs_fsinfo *info)
1536{
1537 struct nfs4_exception exception = { };
1538 int err;
1539 do {
1540 err = nfs4_handle_exception(server,
1541 _nfs4_lookup_root(server, fhandle, info),
1542 &exception);
1543 } while (exception.retry);
1544 return err;
1545}
1546
54ceac45
DH		 1547/*
1548 * get the file handle for the "/" directory on the server
1549 */
1da177e4 1550static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
54ceac45 1551 struct nfs_fsinfo *info)
1da177e4 1552{
1da177e4
LT		 1553 int status;
1554
1da177e4 1555 status = nfs4_lookup_root(server, fhandle, info);
1da177e4
LT		 1556 if (status == 0)
1557 status = nfs4_server_capabilities(server, fhandle);
1558 if (status == 0)
1559 status = nfs4_do_fsinfo(server, fhandle, info);
c12e87f4 1560 return nfs4_map_errors(status);
1da177e4
LT		 1561}
1562
6b97fd3d
MN		 1563/*
1564 * Get locations and (maybe) other attributes of a referral.
1565 * Note that we'll actually follow the referral later when
1566 * we detect fsid mismatch in inode revalidation
1567 */
56659e99 1568static int nfs4_get_referral(struct inode *dir, const struct qstr *name, struct nfs_fattr *fattr, struct nfs_fh *fhandle)
6b97fd3d
MN		 1569{
1570 int status = -ENOMEM;
1571 struct page *page = NULL;
1572 struct nfs4_fs_locations *locations = NULL;
6b97fd3d
MN		 1573
1574 page = alloc_page(GFP_KERNEL);
1575 if (page == NULL)
1576 goto out;
1577 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
1578 if (locations == NULL)
1579 goto out;
1580
c228fd3a 1581 status = nfs4_proc_fs_locations(dir, name, locations, page);
6b97fd3d
MN		 1582 if (status != 0)
1583 goto out;
1584 /* Make sure server returned a different fsid for the referral */
1585 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
1586 dprintk("%s: server did not return a different fsid for a referral at %s\n", __FUNCTION__, name->name);
1587 status = -EIO;
1588 goto out;
1589 }
1590
1591 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
1592 fattr->valid |= NFS_ATTR_FATTR_V4_REFERRAL;
1593 if (!fattr->mode)
1594 fattr->mode = S_IFDIR;
1595 memset(fhandle, 0, sizeof(struct nfs_fh));
1596out:
1597 if (page)
1598 __free_page(page);
1599 if (locations)
1600 kfree(locations);
1601 return status;
1602}
1603
1da177e4
LT		 1604static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1605{
1606 struct nfs4_getattr_arg args = {
1607 .fh = fhandle,
1608 .bitmask = server->attr_bitmask,
1609 };
1610 struct nfs4_getattr_res res = {
1611 .fattr = fattr,
1612 .server = server,
1613 };
1614 struct rpc_message msg = {
1615 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
1616 .rpc_argp = &args,
1617 .rpc_resp = &res,
1618 };
1619
0e574af1 1620 nfs_fattr_init(fattr);
1da177e4
LT		 1621 return rpc_call_sync(server->client, &msg, 0);
1622}
1623
1624static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1625{
1626 struct nfs4_exception exception = { };
1627 int err;
1628 do {
1629 err = nfs4_handle_exception(server,
1630 _nfs4_proc_getattr(server, fhandle, fattr),
1631 &exception);
1632 } while (exception.retry);
1633 return err;
1634}
1635
1636/*
1637 * The file is not closed if it is opened due to the a request to change
1638 * the size of the file. The open call will not be needed once the
1639 * VFS layer lookup-intents are implemented.
1640 *
1641 * Close is called when the inode is destroyed.
1642 * If we haven't opened the file for O_WRONLY, we
1643 * need to in the size_change case to obtain a stateid.
1644 *
1645 * Got race?
1646 * Because OPEN is always done by name in nfsv4, it is
1647 * possible that we opened a different file by the same
1648 * name. We can recognize this race condition, but we
1649 * can't do anything about it besides returning an error.
1650 *
1651 * This will be fixed with VFS changes (lookup-intent).
1652 */
1653static int
1654nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
1655 struct iattr *sattr)
1656{
08e9eac4
TM		 1657 struct rpc_cred *cred;
1658 struct inode *inode = dentry->d_inode;
d530838b
TM		 1659 struct nfs_open_context *ctx;
1660 struct nfs4_state *state = NULL;
1da177e4
LT		 1661 int status;
1662
0e574af1 1663 nfs_fattr_init(fattr);
1da177e4 1664
1f163415 1665 cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
08e9eac4
TM		 1666 if (IS_ERR(cred))
1667 return PTR_ERR(cred);
d530838b
TM		 1668
1669 /* Search for an existing open(O_WRITE) file */
1670 ctx = nfs_find_open_context(inode, cred, FMODE_WRITE);
1671 if (ctx != NULL)
1672 state = ctx->state;
08e9eac4 1673
3e4f6290 1674 status = nfs4_do_setattr(inode, fattr, sattr, state);
65e4308d
TM		 1675 if (status == 0)
1676 nfs_setattr_update_inode(inode, sattr);
d530838b
TM		 1677 if (ctx != NULL)
1678 put_nfs_open_context(ctx);
08e9eac4 1679 put_rpccred(cred);
1da177e4
LT		 1680 return status;
1681}
1682
56659e99
TM		 1683static int _nfs4_proc_lookupfh(struct nfs_server *server, const struct nfs_fh *dirfh,
1684 const struct qstr *name, struct nfs_fh *fhandle,
2b3de441
DH		 1685 struct nfs_fattr *fattr)
1686{
1687 int status;
1688 struct nfs4_lookup_arg args = {
1689 .bitmask = server->attr_bitmask,
1690 .dir_fh = dirfh,
1691 .name = name,
1692 };
1693 struct nfs4_lookup_res res = {
1694 .server = server,
1695 .fattr = fattr,
1696 .fh = fhandle,
1697 };
1698 struct rpc_message msg = {
1699 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
1700 .rpc_argp = &args,
1701 .rpc_resp = &res,
1702 };
1703
1704 nfs_fattr_init(fattr);
1705
1706 dprintk("NFS call lookupfh %s\n", name->name);
1707 status = rpc_call_sync(server->client, &msg, 0);
1708 dprintk("NFS reply lookupfh: %d\n", status);
2b3de441
DH		 1709 return status;
1710}
1711
1712static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh,
1713 struct qstr *name, struct nfs_fh *fhandle,
1714 struct nfs_fattr *fattr)
1715{
1716 struct nfs4_exception exception = { };
1717 int err;
1718 do {
4e56e082
TM		 1719 err = _nfs4_proc_lookupfh(server, dirfh, name, fhandle, fattr);
1720 /* FIXME: !!!! */
1721 if (err == -NFS4ERR_MOVED) {
1722 err = -EREMOTE;
1723 break;
1724 }
1725 err = nfs4_handle_exception(server, err, &exception);
2b3de441
DH		 1726 } while (exception.retry);
1727 return err;
1728}
1729
56659e99 1730static int _nfs4_proc_lookup(struct inode *dir, const struct qstr *name,
1da177e4
LT		 1731 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1732{
4e56e082 1733 int status;
1da177e4
LT		 1734
1735 dprintk("NFS call lookup %s\n", name->name);
4e56e082 1736 status = _nfs4_proc_lookupfh(NFS_SERVER(dir), NFS_FH(dir), name, fhandle, fattr);
6b97fd3d
MN		 1737 if (status == -NFS4ERR_MOVED)
1738 status = nfs4_get_referral(dir, name, fattr, fhandle);
1da177e4
LT		 1739 dprintk("NFS reply lookup: %d\n", status);
1740 return status;
1741}
1742
1743static int nfs4_proc_lookup(struct inode *dir, struct qstr *name, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
1744{
1745 struct nfs4_exception exception = { };
1746 int err;
1747 do {
1748 err = nfs4_handle_exception(NFS_SERVER(dir),
1749 _nfs4_proc_lookup(dir, name, fhandle, fattr),
1750 &exception);
1751 } while (exception.retry);
1752 return err;
1753}
1754
1755static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
1756{
1757 struct nfs4_accessargs args = {
1758 .fh = NFS_FH(inode),
1759 };
1760 struct nfs4_accessres res = { 0 };
1761 struct rpc_message msg = {
1762 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
1763 .rpc_argp = &args,
1764 .rpc_resp = &res,
1765 .rpc_cred = entry->cred,
1766 };
1767 int mode = entry->mask;
1768 int status;
1769
1770 /*
1771 * Determine which access bits we want to ask for...
1772 */
1773 if (mode & MAY_READ)
1774 args.access |= NFS4_ACCESS_READ;
1775 if (S_ISDIR(inode->i_mode)) {
1776 if (mode & MAY_WRITE)
1777 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
1778 if (mode & MAY_EXEC)
1779 args.access |= NFS4_ACCESS_LOOKUP;
1780 } else {
1781 if (mode & MAY_WRITE)
1782 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
1783 if (mode & MAY_EXEC)
1784 args.access |= NFS4_ACCESS_EXECUTE;
1785 }
1786 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
1787 if (!status) {
1788 entry->mask = 0;
1789 if (res.access & NFS4_ACCESS_READ)
1790 entry->mask |= MAY_READ;
1791 if (res.access & (NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE))
1792 entry->mask |= MAY_WRITE;
1793 if (res.access & (NFS4_ACCESS_LOOKUP|NFS4_ACCESS_EXECUTE))
1794 entry->mask |= MAY_EXEC;
1795 }
1796 return status;
1797}
1798
1799static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
1800{
1801 struct nfs4_exception exception = { };
1802 int err;
1803 do {
1804 err = nfs4_handle_exception(NFS_SERVER(inode),
1805 _nfs4_proc_access(inode, entry),
1806 &exception);
1807 } while (exception.retry);
1808 return err;
1809}
1810
1811/*
1812 * TODO: For the time being, we don't try to get any attributes
1813 * along with any of the zero-copy operations READ, READDIR,
1814 * READLINK, WRITE.
1815 *
1816 * In the case of the first three, we want to put the GETATTR
1817 * after the read-type operation -- this is because it is hard
1818 * to predict the length of a GETATTR response in v4, and thus
1819 * align the READ data correctly. This means that the GETATTR
1820 * may end up partially falling into the page cache, and we should
1821 * shift it into the 'tail' of the xdr_buf before processing.
1822 * To do this efficiently, we need to know the total length
1823 * of data received, which doesn't seem to be available outside
1824 * of the RPC layer.
1825 *
1826 * In the case of WRITE, we also want to put the GETATTR after
1827 * the operation -- in this case because we want to make sure
1828 * we get the post-operation mtime and size. This means that
1829 * we can't use xdr_encode_pages() as written: we need a variant
1830 * of it which would leave room in the 'tail' iovec.
1831 *
1832 * Both of these changes to the XDR layer would in fact be quite
1833 * minor, but I decided to leave them for a subsequent patch.
1834 */
1835static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
1836 unsigned int pgbase, unsigned int pglen)
1837{
1838 struct nfs4_readlink args = {
1839 .fh = NFS_FH(inode),
1840 .pgbase = pgbase,
1841 .pglen = pglen,
1842 .pages = &page,
1843 };
1844 struct rpc_message msg = {
1845 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
1846 .rpc_argp = &args,
1847 .rpc_resp = NULL,
1848 };
1849
1850 return rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
1851}
1852
1853static int nfs4_proc_readlink(struct inode *inode, struct page *page,
1854 unsigned int pgbase, unsigned int pglen)
1855{
1856 struct nfs4_exception exception = { };
1857 int err;
1858 do {
1859 err = nfs4_handle_exception(NFS_SERVER(inode),
1860 _nfs4_proc_readlink(inode, page, pgbase, pglen),
1861 &exception);
1862 } while (exception.retry);
1863 return err;
1864}
1865
1da177e4
LT		 1866/*
1867 * Got race?
1868 * We will need to arrange for the VFS layer to provide an atomic open.
1869 * Until then, this create/open method is prone to inefficiency and race
1870 * conditions due to the lookup, create, and open VFS calls from sys_open()
1871 * placed on the wire.
1872 *
1873 * Given the above sorry state of affairs, I'm simply sending an OPEN.
1874 * The file will be opened again in the subsequent VFS open call
1875 * (nfs4_proc_file_open).
1876 *
1877 * The open for read will just hang around to be used by any process that
1878 * opens the file O_RDONLY. This will all be resolved with the VFS changes.
1879 */
1880
1881static int
1882nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
02a913a7 1883 int flags, struct nameidata *nd)
1da177e4 1884{
ad389da7
TM		 1885 struct path path = {
1886 .mnt = nd->mnt,
1887 .dentry = dentry,
1888 };
1da177e4
LT		 1889 struct nfs4_state *state;
1890 struct rpc_cred *cred;
1891 int status = 0;
1892
1f163415 1893 cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0);
1da177e4
LT		 1894 if (IS_ERR(cred)) {
1895 status = PTR_ERR(cred);
1896 goto out;
1897 }
ad389da7 1898 state = nfs4_do_open(dir, &path, flags, sattr, cred);
1da177e4
LT		 1899 put_rpccred(cred);
1900 if (IS_ERR(state)) {
1901 status = PTR_ERR(state);
1902 goto out;
1903 }
24ac23ab 1904 d_instantiate(dentry, igrab(state->inode));
1da177e4
LT		 1905 if (flags & O_EXCL) {
1906 struct nfs_fattr fattr;
3e4f6290 1907 status = nfs4_do_setattr(state->inode, &fattr, sattr, state);
02a913a7 1908 if (status == 0)
65e4308d 1909 nfs_setattr_update_inode(state->inode, sattr);
aa53ed54 1910 nfs_post_op_update_inode(state->inode, &fattr);
02a913a7 1911 }
ad389da7 1912 if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0)
4a35bd41 1913 status = nfs4_intent_set_file(nd, &path, state);
02a913a7 1914 else
4a35bd41 1915 nfs4_close_state(&path, state, flags);
1da177e4
LT		 1916out:
1917 return status;
1918}
1919
1920static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
1921{
16e42959 1922 struct nfs_server *server = NFS_SERVER(dir);
1da177e4
LT		 1923 struct nfs4_remove_arg args = {
1924 .fh = NFS_FH(dir),
1925 .name = name,
16e42959
TM		 1926 .bitmask = server->attr_bitmask,
1927 };
1928 struct nfs_fattr dir_attr;
1929 struct nfs4_remove_res res = {
1930 .server = server,
1931 .dir_attr = &dir_attr,
1da177e4 1932 };
1da177e4
LT		 1933 struct rpc_message msg = {
1934 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
1935 .rpc_argp = &args,
1936 .rpc_resp = &res,
1937 };
1938 int status;
1939
16e42959
TM		 1940 nfs_fattr_init(res.dir_attr);
1941 status = rpc_call_sync(server->client, &msg, 0);
1942 if (status == 0) {
1943 update_changeattr(dir, &res.cinfo);
1944 nfs_post_op_update_inode(dir, res.dir_attr);
1945 }
1da177e4
LT		 1946 return status;
1947}
1948
1949static int nfs4_proc_remove(struct inode *dir, struct qstr *name)
1950{
1951 struct nfs4_exception exception = { };
1952 int err;
1953 do {
1954 err = nfs4_handle_exception(NFS_SERVER(dir),
1955 _nfs4_proc_remove(dir, name),
1956 &exception);
1957 } while (exception.retry);
1958 return err;
1959}
1960
1961struct unlink_desc {
1962 struct nfs4_remove_arg args;
16e42959
TM		 1963 struct nfs4_remove_res res;
1964 struct nfs_fattr dir_attr;
1da177e4
LT		 1965};
1966
1967static int nfs4_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir,
1968 struct qstr *name)
1969{
16e42959 1970 struct nfs_server *server = NFS_SERVER(dir->d_inode);
1da177e4
LT		 1971 struct unlink_desc *up;
1972
5cbded58 1973 up = kmalloc(sizeof(*up), GFP_KERNEL);
1da177e4
LT		 1974 if (!up)
1975 return -ENOMEM;
1976
1977 up->args.fh = NFS_FH(dir->d_inode);
1978 up->args.name = name;
16e42959
TM		 1979 up->args.bitmask = server->attr_bitmask;
1980 up->res.server = server;
1981 up->res.dir_attr = &up->dir_attr;
1da177e4
LT		 1982
1983 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
1984 msg->rpc_argp = &up->args;
1985 msg->rpc_resp = &up->res;
1986 return 0;
1987}
1988
1989static int nfs4_proc_unlink_done(struct dentry *dir, struct rpc_task *task)
1990{
1991 struct rpc_message *msg = &task->tk_msg;
1992 struct unlink_desc *up;
1993
1994 if (msg->rpc_resp != NULL) {
1995 up = container_of(msg->rpc_resp, struct unlink_desc, res);
16e42959
TM		 1996 update_changeattr(dir->d_inode, &up->res.cinfo);
1997 nfs_post_op_update_inode(dir->d_inode, up->res.dir_attr);
1da177e4
LT		 1998 kfree(up);
1999 msg->rpc_resp = NULL;
2000 msg->rpc_argp = NULL;
2001 }
2002 return 0;
2003}
2004
2005static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
2006 struct inode *new_dir, struct qstr *new_name)
2007{
6caf2c82 2008 struct nfs_server *server = NFS_SERVER(old_dir);
1da177e4
LT		 2009 struct nfs4_rename_arg arg = {
2010 .old_dir = NFS_FH(old_dir),
2011 .new_dir = NFS_FH(new_dir),
2012 .old_name = old_name,
2013 .new_name = new_name,
6caf2c82
TM		 2014 .bitmask = server->attr_bitmask,
2015 };
2016 struct nfs_fattr old_fattr, new_fattr;
2017 struct nfs4_rename_res res = {
2018 .server = server,
2019 .old_fattr = &old_fattr,
2020 .new_fattr = &new_fattr,
1da177e4 2021 };
1da177e4
LT		 2022 struct rpc_message msg = {
2023 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME],
2024 .rpc_argp = &arg,
2025 .rpc_resp = &res,
2026 };
2027 int status;
2028
6caf2c82
TM		 2029 nfs_fattr_init(res.old_fattr);
2030 nfs_fattr_init(res.new_fattr);
2031 status = rpc_call_sync(server->client, &msg, 0);
1da177e4
LT		 2032
2033 if (!status) {
2034 update_changeattr(old_dir, &res.old_cinfo);
6caf2c82 2035 nfs_post_op_update_inode(old_dir, res.old_fattr);
1da177e4 2036 update_changeattr(new_dir, &res.new_cinfo);
6caf2c82 2037 nfs_post_op_update_inode(new_dir, res.new_fattr);
1da177e4
LT		 2038 }
2039 return status;
2040}
2041
2042static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
2043 struct inode *new_dir, struct qstr *new_name)
2044{
2045 struct nfs4_exception exception = { };
2046 int err;
2047 do {
2048 err = nfs4_handle_exception(NFS_SERVER(old_dir),
2049 _nfs4_proc_rename(old_dir, old_name,
2050 new_dir, new_name),
2051 &exception);
2052 } while (exception.retry);
2053 return err;
2054}
2055
2056static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
2057{
91ba2eee 2058 struct nfs_server *server = NFS_SERVER(inode);
1da177e4
LT		 2059 struct nfs4_link_arg arg = {
2060 .fh = NFS_FH(inode),
2061 .dir_fh = NFS_FH(dir),
2062 .name = name,
91ba2eee
TM		 2063 .bitmask = server->attr_bitmask,
2064 };
2065 struct nfs_fattr fattr, dir_attr;
2066 struct nfs4_link_res res = {
2067 .server = server,
2068 .fattr = &fattr,
2069 .dir_attr = &dir_attr,
1da177e4 2070 };
1da177e4
LT		 2071 struct rpc_message msg = {
2072 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
2073 .rpc_argp = &arg,
91ba2eee 2074 .rpc_resp = &res,
1da177e4
LT		 2075 };
2076 int status;
2077
91ba2eee
TM		 2078 nfs_fattr_init(res.fattr);
2079 nfs_fattr_init(res.dir_attr);
2080 status = rpc_call_sync(server->client, &msg, 0);
2081 if (!status) {
2082 update_changeattr(dir, &res.cinfo);
2083 nfs_post_op_update_inode(dir, res.dir_attr);
73a3d07c 2084 nfs_post_op_update_inode(inode, res.fattr);
91ba2eee 2085 }
1da177e4
LT		 2086
2087 return status;
2088}
2089
2090static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
2091{
2092 struct nfs4_exception exception = { };
2093 int err;
2094 do {
2095 err = nfs4_handle_exception(NFS_SERVER(inode),
2096 _nfs4_proc_link(inode, dir, name),
2097 &exception);
2098 } while (exception.retry);
2099 return err;
2100}
2101
4f390c15 2102static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
94a6d753 2103 struct page *page, unsigned int len, struct iattr *sattr)
1da177e4
LT		 2104{
2105 struct nfs_server *server = NFS_SERVER(dir);
4f390c15
CL		 2106 struct nfs_fh fhandle;
2107 struct nfs_fattr fattr, dir_fattr;
1da177e4
LT		 2108 struct nfs4_create_arg arg = {
2109 .dir_fh = NFS_FH(dir),
2110 .server = server,
4f390c15 2111 .name = &dentry->d_name,
1da177e4
LT		 2112 .attrs = sattr,
2113 .ftype = NF4LNK,
2114 .bitmask = server->attr_bitmask,
2115 };
2116 struct nfs4_create_res res = {
2117 .server = server,
4f390c15
CL		 2118 .fh = &fhandle,
2119 .fattr = &fattr,
56ae19f3 2120 .dir_fattr = &dir_fattr,
1da177e4
LT		 2121 };
2122 struct rpc_message msg = {
2123 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK],
2124 .rpc_argp = &arg,
2125 .rpc_resp = &res,
2126 };
2127 int status;
2128
94a6d753 2129 if (len > NFS4_MAXPATHLEN)
1da177e4 2130 return -ENAMETOOLONG;
4f390c15 2131
94a6d753
CL		 2132 arg.u.symlink.pages = &page;
2133 arg.u.symlink.len = len;
4f390c15 2134 nfs_fattr_init(&fattr);
56ae19f3 2135 nfs_fattr_init(&dir_fattr);
1da177e4
LT		 2136
2137 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
4f390c15 2138 if (!status) {
1da177e4 2139 update_changeattr(dir, &res.dir_cinfo);
4f390c15
CL		 2140 nfs_post_op_update_inode(dir, res.dir_fattr);
2141 status = nfs_instantiate(dentry, &fhandle, &fattr);
2142 }
1da177e4
LT		 2143 return status;
2144}
2145
4f390c15 2146static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
94a6d753 2147 struct page *page, unsigned int len, struct iattr *sattr)
1da177e4
LT		 2148{
2149 struct nfs4_exception exception = { };
2150 int err;
2151 do {
2152 err = nfs4_handle_exception(NFS_SERVER(dir),
94a6d753
CL		 2153 _nfs4_proc_symlink(dir, dentry, page,
2154 len, sattr),
1da177e4
LT		 2155 &exception);
2156 } while (exception.retry);
2157 return err;
2158}
2159
2160static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
2161 struct iattr *sattr)
2162{
2163 struct nfs_server *server = NFS_SERVER(dir);
2164 struct nfs_fh fhandle;
56ae19f3 2165 struct nfs_fattr fattr, dir_fattr;
1da177e4
LT		 2166 struct nfs4_create_arg arg = {
2167 .dir_fh = NFS_FH(dir),
2168 .server = server,
2169 .name = &dentry->d_name,
2170 .attrs = sattr,
2171 .ftype = NF4DIR,
2172 .bitmask = server->attr_bitmask,
2173 };
2174 struct nfs4_create_res res = {
2175 .server = server,
2176 .fh = &fhandle,
2177 .fattr = &fattr,
56ae19f3 2178 .dir_fattr = &dir_fattr,
1da177e4
LT		 2179 };
2180 struct rpc_message msg = {
2181 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE],
2182 .rpc_argp = &arg,
2183 .rpc_resp = &res,
2184 };
2185 int status;
2186
0e574af1 2187 nfs_fattr_init(&fattr);
56ae19f3 2188 nfs_fattr_init(&dir_fattr);
1da177e4
LT		 2189
2190 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
2191 if (!status) {
2192 update_changeattr(dir, &res.dir_cinfo);
56ae19f3 2193 nfs_post_op_update_inode(dir, res.dir_fattr);
1da177e4
LT		 2194 status = nfs_instantiate(dentry, &fhandle, &fattr);
2195 }
2196 return status;
2197}
2198
2199static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
2200 struct iattr *sattr)
2201{
2202 struct nfs4_exception exception = { };
2203 int err;
2204 do {
2205 err = nfs4_handle_exception(NFS_SERVER(dir),
2206 _nfs4_proc_mkdir(dir, dentry, sattr),
2207 &exception);
2208 } while (exception.retry);
2209 return err;
2210}
2211
2212static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
2213 u64 cookie, struct page *page, unsigned int count, int plus)
2214{
2215 struct inode *dir = dentry->d_inode;
2216 struct nfs4_readdir_arg args = {
2217 .fh = NFS_FH(dir),
2218 .pages = &page,
2219 .pgbase = 0,
2220 .count = count,
2221 .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
2222 };
2223 struct nfs4_readdir_res res;
2224 struct rpc_message msg = {
2225 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
2226 .rpc_argp = &args,
2227 .rpc_resp = &res,
2228 .rpc_cred = cred,
2229 };
2230 int status;
2231
eadf4598
TM		 2232 dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __FUNCTION__,
2233 dentry->d_parent->d_name.name,
2234 dentry->d_name.name,
2235 (unsigned long long)cookie);
1da177e4
LT		 2236 nfs4_setup_readdir(cookie, NFS_COOKIEVERF(dir), dentry, &args);
2237 res.pgbase = args.pgbase;
2238 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
2239 if (status == 0)
2240 memcpy(NFS_COOKIEVERF(dir), res.verifier.data, NFS4_VERIFIER_SIZE);
eadf4598 2241 dprintk("%s: returns %d\n", __FUNCTION__, status);
1da177e4
LT		 2242 return status;
2243}
2244
2245static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
2246 u64 cookie, struct page *page, unsigned int count, int plus)
2247{
2248 struct nfs4_exception exception = { };
2249 int err;
2250 do {
2251 err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode),
2252 _nfs4_proc_readdir(dentry, cred, cookie,
2253 page, count, plus),
2254 &exception);
2255 } while (exception.retry);
2256 return err;
2257}
2258
2259static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
2260 struct iattr *sattr, dev_t rdev)
2261{
2262 struct nfs_server *server = NFS_SERVER(dir);
2263 struct nfs_fh fh;
56ae19f3 2264 struct nfs_fattr fattr, dir_fattr;
1da177e4
LT		 2265 struct nfs4_create_arg arg = {
2266 .dir_fh = NFS_FH(dir),
2267 .server = server,
2268 .name = &dentry->d_name,
2269 .attrs = sattr,
2270 .bitmask = server->attr_bitmask,
2271 };
2272 struct nfs4_create_res res = {
2273 .server = server,
2274 .fh = &fh,
2275 .fattr = &fattr,
56ae19f3 2276 .dir_fattr = &dir_fattr,
1da177e4
LT		 2277 };
2278 struct rpc_message msg = {
2279 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE],
2280 .rpc_argp = &arg,
2281 .rpc_resp = &res,
2282 };
2283 int status;
2284 int mode = sattr->ia_mode;
2285
0e574af1 2286 nfs_fattr_init(&fattr);
56ae19f3 2287 nfs_fattr_init(&dir_fattr);
1da177e4
LT		 2288
2289 BUG_ON(!(sattr->ia_valid & ATTR_MODE));
2290 BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode));
2291 if (S_ISFIFO(mode))
2292 arg.ftype = NF4FIFO;
2293 else if (S_ISBLK(mode)) {
2294 arg.ftype = NF4BLK;
2295 arg.u.device.specdata1 = MAJOR(rdev);
2296 arg.u.device.specdata2 = MINOR(rdev);
2297 }
2298 else if (S_ISCHR(mode)) {
2299 arg.ftype = NF4CHR;
2300 arg.u.device.specdata1 = MAJOR(rdev);
2301 arg.u.device.specdata2 = MINOR(rdev);
2302 }
2303 else
2304 arg.ftype = NF4SOCK;
2305
2306 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
2307 if (status == 0) {
2308 update_changeattr(dir, &res.dir_cinfo);
56ae19f3 2309 nfs_post_op_update_inode(dir, res.dir_fattr);
1da177e4
LT		 2310 status = nfs_instantiate(dentry, &fh, &fattr);
2311 }
2312 return status;
2313}
2314
2315static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
2316 struct iattr *sattr, dev_t rdev)
2317{
2318 struct nfs4_exception exception = { };
2319 int err;
2320 do {
2321 err = nfs4_handle_exception(NFS_SERVER(dir),
2322 _nfs4_proc_mknod(dir, dentry, sattr, rdev),
2323 &exception);
2324 } while (exception.retry);
2325 return err;
2326}
2327
2328static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
2329 struct nfs_fsstat *fsstat)
2330{
2331 struct nfs4_statfs_arg args = {
2332 .fh = fhandle,
2333 .bitmask = server->attr_bitmask,
2334 };
2335 struct rpc_message msg = {
2336 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
2337 .rpc_argp = &args,
2338 .rpc_resp = fsstat,
2339 };
2340
0e574af1 2341 nfs_fattr_init(fsstat->fattr);
1da177e4
LT		 2342 return rpc_call_sync(server->client, &msg, 0);
2343}
2344
2345static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
2346{
2347 struct nfs4_exception exception = { };
2348 int err;
2349 do {
2350 err = nfs4_handle_exception(server,
2351 _nfs4_proc_statfs(server, fhandle, fsstat),
2352 &exception);
2353 } while (exception.retry);
2354 return err;
2355}
2356
2357static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
2358 struct nfs_fsinfo *fsinfo)
2359{
2360 struct nfs4_fsinfo_arg args = {
2361 .fh = fhandle,
2362 .bitmask = server->attr_bitmask,
2363 };
2364 struct rpc_message msg = {
2365 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
2366 .rpc_argp = &args,
2367 .rpc_resp = fsinfo,
2368 };
2369
2370 return rpc_call_sync(server->client, &msg, 0);
2371}
2372
2373static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
2374{
2375 struct nfs4_exception exception = { };
2376 int err;
2377
2378 do {
2379 err = nfs4_handle_exception(server,
2380 _nfs4_do_fsinfo(server, fhandle, fsinfo),
2381 &exception);
2382 } while (exception.retry);
2383 return err;
2384}
2385
2386static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
2387{
0e574af1 2388 nfs_fattr_init(fsinfo->fattr);
1da177e4
LT		 2389 return nfs4_do_fsinfo(server, fhandle, fsinfo);
2390}
2391
2392static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
2393 struct nfs_pathconf *pathconf)
2394{
2395 struct nfs4_pathconf_arg args = {
2396 .fh = fhandle,
2397 .bitmask = server->attr_bitmask,
2398 };
2399 struct rpc_message msg = {
2400 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
2401 .rpc_argp = &args,
2402 .rpc_resp = pathconf,
2403 };
2404
2405 /* None of the pathconf attributes are mandatory to implement */
2406 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
2407 memset(pathconf, 0, sizeof(*pathconf));
2408 return 0;
2409 }
2410
0e574af1 2411 nfs_fattr_init(pathconf->fattr);
1da177e4
LT		 2412 return rpc_call_sync(server->client, &msg, 0);
2413}
2414
2415static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
2416 struct nfs_pathconf *pathconf)
2417{
2418 struct nfs4_exception exception = { };
2419 int err;
2420
2421 do {
2422 err = nfs4_handle_exception(server,
2423 _nfs4_proc_pathconf(server, fhandle, pathconf),
2424 &exception);
2425 } while (exception.retry);
2426 return err;
2427}
2428
ec06c096 2429static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)
1da177e4 2430{
ec06c096 2431 struct nfs_server *server = NFS_SERVER(data->inode);
1da177e4 2432
ec06c096 2433 if (nfs4_async_handle_error(task, server) == -EAGAIN) {
1da177e4 2434 rpc_restart_call(task);
ec06c096 2435 return -EAGAIN;
1da177e4
LT		 2436 }
2437 if (task->tk_status > 0)
ec06c096
TM		 2438 renew_lease(server, data->timestamp);
2439 return 0;
1da177e4
LT		 2440}
2441
ec06c096 2442static void nfs4_proc_read_setup(struct nfs_read_data *data)
1da177e4 2443{
1da177e4
LT		 2444 struct rpc_message msg = {
2445 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ],
2446 .rpc_argp = &data->args,
2447 .rpc_resp = &data->res,
2448 .rpc_cred = data->cred,
2449 };
1da177e4
LT		 2450
2451 data->timestamp = jiffies;
2452
ec06c096 2453 rpc_call_setup(&data->task, &msg, 0);
1da177e4
LT		 2454}
2455
788e7a89 2456static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)
1da177e4 2457{
1da177e4
LT		 2458 struct inode *inode = data->inode;
2459
2460 if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {
2461 rpc_restart_call(task);
788e7a89 2462 return -EAGAIN;
1da177e4 2463 }
4f9838c7 2464 if (task->tk_status >= 0) {
1da177e4 2465 renew_lease(NFS_SERVER(inode), data->timestamp);
4f9838c7
TM		 2466 nfs_post_op_update_inode(inode, data->res.fattr);
2467 }
788e7a89 2468 return 0;
1da177e4
LT		 2469}
2470
788e7a89 2471static void nfs4_proc_write_setup(struct nfs_write_data *data, int how)
1da177e4 2472{
1da177e4
LT		 2473 struct rpc_message msg = {
2474 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE],
2475 .rpc_argp = &data->args,
2476 .rpc_resp = &data->res,
2477 .rpc_cred = data->cred,
2478 };
2479 struct inode *inode = data->inode;
4f9838c7 2480 struct nfs_server *server = NFS_SERVER(inode);
1da177e4 2481 int stable;
1da177e4
LT		 2482
2483 if (how & FLUSH_STABLE) {
2484 if (!NFS_I(inode)->ncommit)
2485 stable = NFS_FILE_SYNC;
2486 else
2487 stable = NFS_DATA_SYNC;
2488 } else
2489 stable = NFS_UNSTABLE;
2490 data->args.stable = stable;
4f9838c7
TM		 2491 data->args.bitmask = server->attr_bitmask;
2492 data->res.server = server;
1da177e4
LT		 2493
2494 data->timestamp = jiffies;
2495
1da177e4 2496 /* Finalize the task. */
788e7a89 2497 rpc_call_setup(&data->task, &msg, 0);
1da177e4
LT		 2498}
2499
788e7a89 2500static int nfs4_commit_done(struct rpc_task *task, struct nfs_write_data *data)
1da177e4 2501{
1da177e4
LT		 2502 struct inode *inode = data->inode;
2503
2504 if (nfs4_async_handle_error(task, NFS_SERVER(inode)) == -EAGAIN) {
2505 rpc_restart_call(task);
788e7a89 2506 return -EAGAIN;
1da177e4 2507 }
4f9838c7
TM		 2508 if (task->tk_status >= 0)
2509 nfs_post_op_update_inode(inode, data->res.fattr);
788e7a89 2510 return 0;
1da177e4
LT		 2511}
2512
788e7a89 2513static void nfs4_proc_commit_setup(struct nfs_write_data *data, int how)
1da177e4 2514{
1da177e4
LT		 2515 struct rpc_message msg = {
2516 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT],
2517 .rpc_argp = &data->args,
2518 .rpc_resp = &data->res,
2519 .rpc_cred = data->cred,
2520 };
788e7a89 2521 struct nfs_server *server = NFS_SERVER(data->inode);
1da177e4 2522
4f9838c7
TM		 2523 data->args.bitmask = server->attr_bitmask;
2524 data->res.server = server;
2525
788e7a89 2526 rpc_call_setup(&data->task, &msg, 0);
1da177e4
LT		 2527}
2528
2529/*
2530 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
2531 * standalone procedure for queueing an asynchronous RENEW.
2532 */
963d8fe5 2533static void nfs4_renew_done(struct rpc_task *task, void *data)
1da177e4 2534{
adfa6f98 2535 struct nfs_client *clp = (struct nfs_client *)task->tk_msg.rpc_argp;
963d8fe5 2536 unsigned long timestamp = (unsigned long)data;
1da177e4
LT		 2537
2538 if (task->tk_status < 0) {
2539 switch (task->tk_status) {
2540 case -NFS4ERR_STALE_CLIENTID:
2541 case -NFS4ERR_EXPIRED:
2542 case -NFS4ERR_CB_PATH_DOWN:
2543 nfs4_schedule_state_recovery(clp);
2544 }
2545 return;
2546 }
2547 spin_lock(&clp->cl_lock);
2548 if (time_before(clp->cl_last_renewal,timestamp))
2549 clp->cl_last_renewal = timestamp;
2550 spin_unlock(&clp->cl_lock);
2551}
2552
963d8fe5
TM		 2553static const struct rpc_call_ops nfs4_renew_ops = {
2554 .rpc_call_done = nfs4_renew_done,
2555};
2556
adfa6f98 2557int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred)
1da177e4
LT		 2558{
2559 struct rpc_message msg = {
2560 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
2561 .rpc_argp = clp,
b4454fe1 2562 .rpc_cred = cred,
1da177e4
LT		 2563 };
2564
2565 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_SOFT,
963d8fe5 2566 &nfs4_renew_ops, (void *)jiffies);
1da177e4
LT		 2567}
2568
adfa6f98 2569int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
1da177e4
LT		 2570{
2571 struct rpc_message msg = {
2572 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
2573 .rpc_argp = clp,
b4454fe1 2574 .rpc_cred = cred,
1da177e4
LT		 2575 };
2576 unsigned long now = jiffies;
2577 int status;
2578
2579 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
2580 if (status < 0)
2581 return status;
2582 spin_lock(&clp->cl_lock);
2583 if (time_before(clp->cl_last_renewal,now))
2584 clp->cl_last_renewal = now;
2585 spin_unlock(&clp->cl_lock);
2586 return 0;
2587}
2588
aa1870af
BF		 2589static inline int nfs4_server_supports_acls(struct nfs_server *server)
2590{
2591 return (server->caps & NFS_CAP_ACLS)
2592 && (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
2593 && (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL);
2594}
2595
2596/* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_CACHE_SIZE, and that
2597 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_CACHE_SIZE) bytes on
2598 * the stack.
2599 */
2600#define NFS4ACL_MAXPAGES (XATTR_SIZE_MAX >> PAGE_CACHE_SHIFT)
2601
2602static void buf_to_pages(const void *buf, size_t buflen,
2603 struct page **pages, unsigned int *pgbase)
2604{
2605 const void *p = buf;
2606
2607 *pgbase = offset_in_page(buf);
2608 p -= *pgbase;
2609 while (p < buf + buflen) {
2610 *(pages++) = virt_to_page(p);
2611 p += PAGE_CACHE_SIZE;
2612 }
2613}
2614
e50a1c2e
BF		 2615struct nfs4_cached_acl {
2616 int cached;
2617 size_t len;
3e9d4154 2618 char data[0];
e50a1c2e
BF		 2619};
2620
2621static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
2622{
2623 struct nfs_inode *nfsi = NFS_I(inode);
2624
2625 spin_lock(&inode->i_lock);
2626 kfree(nfsi->nfs4_acl);
2627 nfsi->nfs4_acl = acl;
2628 spin_unlock(&inode->i_lock);
2629}
2630
2631static void nfs4_zap_acl_attr(struct inode *inode)
2632{
2633 nfs4_set_cached_acl(inode, NULL);
2634}
2635
2636static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
2637{
2638 struct nfs_inode *nfsi = NFS_I(inode);
2639 struct nfs4_cached_acl *acl;
2640 int ret = -ENOENT;
2641
2642 spin_lock(&inode->i_lock);
2643 acl = nfsi->nfs4_acl;
2644 if (acl == NULL)
2645 goto out;
2646 if (buf == NULL) /* user is just asking for length */
2647 goto out_len;
2648 if (acl->cached == 0)
2649 goto out;
2650 ret = -ERANGE; /* see getxattr(2) man page */
2651 if (acl->len > buflen)
2652 goto out;
2653 memcpy(buf, acl->data, acl->len);
2654out_len:
2655 ret = acl->len;
2656out:
2657 spin_unlock(&inode->i_lock);
2658 return ret;
2659}
2660
2661static void nfs4_write_cached_acl(struct inode *inode, const char *buf, size_t acl_len)
2662{
2663 struct nfs4_cached_acl *acl;
2664
2665 if (buf && acl_len <= PAGE_SIZE) {
2666 acl = kmalloc(sizeof(*acl) + acl_len, GFP_KERNEL);
2667 if (acl == NULL)
2668 goto out;
2669 acl->cached = 1;
2670 memcpy(acl->data, buf, acl_len);
2671 } else {
2672 acl = kmalloc(sizeof(*acl), GFP_KERNEL);
2673 if (acl == NULL)
2674 goto out;
2675 acl->cached = 0;
2676 }
2677 acl->len = acl_len;
2678out:
2679 nfs4_set_cached_acl(inode, acl);
2680}
2681
16b4289c 2682static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
aa1870af 2683{
aa1870af
BF		 2684 struct page *pages[NFS4ACL_MAXPAGES];
2685 struct nfs_getaclargs args = {
2686 .fh = NFS_FH(inode),
2687 .acl_pages = pages,
2688 .acl_len = buflen,
2689 };
2690 size_t resp_len = buflen;
e50a1c2e 2691 void *resp_buf;
aa1870af
BF		 2692 struct rpc_message msg = {
2693 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
2694 .rpc_argp = &args,
2695 .rpc_resp = &resp_len,
2696 };
e50a1c2e 2697 struct page *localpage = NULL;
aa1870af
BF		 2698 int ret;
2699
e50a1c2e
BF		 2700 if (buflen < PAGE_SIZE) {
2701 /* As long as we're doing a round trip to the server anyway,
2702 * let's be prepared for a page of acl data. */
2703 localpage = alloc_page(GFP_KERNEL);
2704 resp_buf = page_address(localpage);
2705 if (localpage == NULL)
2706 return -ENOMEM;
2707 args.acl_pages[0] = localpage;
2708 args.acl_pgbase = 0;
1d95db8e 2709 resp_len = args.acl_len = PAGE_SIZE;
e50a1c2e
BF		 2710 } else {
2711 resp_buf = buf;
2712 buf_to_pages(buf, buflen, args.acl_pages, &args.acl_pgbase);
2713 }
aa1870af 2714 ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
e50a1c2e
BF		 2715 if (ret)
2716 goto out_free;
2717 if (resp_len > args.acl_len)
2718 nfs4_write_cached_acl(inode, NULL, resp_len);
2719 else
2720 nfs4_write_cached_acl(inode, resp_buf, resp_len);
2721 if (buf) {
2722 ret = -ERANGE;
2723 if (resp_len > buflen)
2724 goto out_free;
2725 if (localpage)
2726 memcpy(buf, resp_buf, resp_len);
2727 }
2728 ret = resp_len;
2729out_free:
2730 if (localpage)
2731 __free_page(localpage);
aa1870af
BF		 2732 return ret;
2733}
2734
16b4289c
TM		 2735static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
2736{
2737 struct nfs4_exception exception = { };
2738 ssize_t ret;
2739 do {
2740 ret = __nfs4_get_acl_uncached(inode, buf, buflen);
2741 if (ret >= 0)
2742 break;
2743 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
2744 } while (exception.retry);
2745 return ret;
2746}
2747
e50a1c2e
BF		 2748static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
2749{
2750 struct nfs_server *server = NFS_SERVER(inode);
2751 int ret;
2752
2753 if (!nfs4_server_supports_acls(server))
2754 return -EOPNOTSUPP;
2755 ret = nfs_revalidate_inode(server, inode);
2756 if (ret < 0)
2757 return ret;
2758 ret = nfs4_read_cached_acl(inode, buf, buflen);
2759 if (ret != -ENOENT)
2760 return ret;
2761 return nfs4_get_acl_uncached(inode, buf, buflen);
2762}
2763
16b4289c 2764static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
4b580ee3
BF		 2765{
2766 struct nfs_server *server = NFS_SERVER(inode);
2767 struct page *pages[NFS4ACL_MAXPAGES];
2768 struct nfs_setaclargs arg = {
2769 .fh = NFS_FH(inode),
2770 .acl_pages = pages,
2771 .acl_len = buflen,
2772 };
2773 struct rpc_message msg = {
2774 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
2775 .rpc_argp = &arg,
2776 .rpc_resp = NULL,
2777 };
2778 int ret;
2779
2780 if (!nfs4_server_supports_acls(server))
2781 return -EOPNOTSUPP;
642ac549 2782 nfs_inode_return_delegation(inode);
4b580ee3 2783 buf_to_pages(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
1f163415 2784 ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
08efa202 2785 nfs_zap_caches(inode);
4b580ee3
BF		 2786 return ret;
2787}
2788
16b4289c
TM		 2789static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
2790{
2791 struct nfs4_exception exception = { };
2792 int err;
2793 do {
2794 err = nfs4_handle_exception(NFS_SERVER(inode),
2795 __nfs4_proc_set_acl(inode, buf, buflen),
2796 &exception);
2797 } while (exception.retry);
2798 return err;
2799}
2800
1da177e4 2801static int
faf5f49c 2802nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server)
1da177e4 2803{
7539bbab 2804 struct nfs_client *clp = server->nfs_client;
1da177e4
LT		 2805
2806 if (!clp || task->tk_status >= 0)
2807 return 0;
2808 switch(task->tk_status) {
2809 case -NFS4ERR_STALE_CLIENTID:
2810 case -NFS4ERR_STALE_STATEID:
2811 case -NFS4ERR_EXPIRED:
2812 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL, NULL);
2813 nfs4_schedule_state_recovery(clp);
433fbe4c 2814 if (test_bit(NFS4CLNT_STATE_RECOVER, &clp->cl_state) == 0)
1da177e4
LT		 2815 rpc_wake_up_task(task);
2816 task->tk_status = 0;
2817 return -EAGAIN;
1da177e4 2818 case -NFS4ERR_DELAY:
006ea73e
CL		 2819 nfs_inc_server_stats((struct nfs_server *) server,
2820 NFSIOS_DELAY);
2821 case -NFS4ERR_GRACE:
1da177e4
LT		 2822 rpc_delay(task, NFS4_POLL_RETRY_MAX);
2823 task->tk_status = 0;
2824 return -EAGAIN;
2825 case -NFS4ERR_OLD_STATEID:
2826 task->tk_status = 0;
2827 return -EAGAIN;
2828 }
2829 task->tk_status = nfs4_map_errors(task->tk_status);
2830 return 0;
2831}
2832
433fbe4c
TM		 2833static int nfs4_wait_bit_interruptible(void *word)
2834{
2835 if (signal_pending(current))
2836 return -ERESTARTSYS;
2837 schedule();
2838 return 0;
2839}
2840
adfa6f98 2841static int nfs4_wait_clnt_recover(struct rpc_clnt *clnt, struct nfs_client *clp)
1da177e4 2842{
1da177e4 2843 sigset_t oldset;
433fbe4c 2844 int res;
1da177e4
LT		 2845
2846 might_sleep();
2847
e148582e
TM		 2848 rwsem_acquire(&clp->cl_sem.dep_map, 0, 0, _RET_IP_);
2849
1da177e4 2850 rpc_clnt_sigmask(clnt, &oldset);
433fbe4c
TM		 2851 res = wait_on_bit(&clp->cl_state, NFS4CLNT_STATE_RECOVER,
2852 nfs4_wait_bit_interruptible,
2853 TASK_INTERRUPTIBLE);
1da177e4 2854 rpc_clnt_sigunmask(clnt, &oldset);
e148582e
TM		 2855
2856 rwsem_release(&clp->cl_sem.dep_map, 1, _RET_IP_);
1da177e4
LT		 2857 return res;
2858}
2859
2860static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
2861{
2862 sigset_t oldset;
2863 int res = 0;
2864
2865 might_sleep();
2866
2867 if (*timeout <= 0)
2868 *timeout = NFS4_POLL_RETRY_MIN;
2869 if (*timeout > NFS4_POLL_RETRY_MAX)
2870 *timeout = NFS4_POLL_RETRY_MAX;
2871 rpc_clnt_sigmask(clnt, &oldset);
2872 if (clnt->cl_intr) {
041e0e3b 2873 schedule_timeout_interruptible(*timeout);
1da177e4
LT		 2874 if (signalled())
2875 res = -ERESTARTSYS;
041e0e3b
NA		 2876 } else
2877 schedule_timeout_uninterruptible(*timeout);
1da177e4
LT		 2878 rpc_clnt_sigunmask(clnt, &oldset);
2879 *timeout <<= 1;
2880 return res;
2881}
2882
2883/* This is the error handling routine for processes that are allowed
2884 * to sleep.
2885 */
10afec90 2886static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
1da177e4 2887{
7539bbab 2888 struct nfs_client *clp = server->nfs_client;
1da177e4
LT		 2889 int ret = errorcode;
2890
2891 exception->retry = 0;
2892 switch(errorcode) {
2893 case 0:
2894 return 0;
2895 case -NFS4ERR_STALE_CLIENTID:
2896 case -NFS4ERR_STALE_STATEID:
2897 case -NFS4ERR_EXPIRED:
433fbe4c 2898 nfs4_schedule_state_recovery(clp);
1da177e4
LT		 2899 ret = nfs4_wait_clnt_recover(server->client, clp);
2900 if (ret == 0)
2901 exception->retry = 1;
2902 break;
c514983d 2903 case -NFS4ERR_FILE_OPEN:
1da177e4
LT		 2904 case -NFS4ERR_GRACE:
2905 case -NFS4ERR_DELAY:
2906 ret = nfs4_delay(server->client, &exception->timeout);
2c56617d
TM		 2907 if (ret != 0)
2908 break;
1da177e4 2909 case -NFS4ERR_OLD_STATEID:
2c56617d 2910 exception->retry = 1;
1da177e4
LT		 2911 }
2912 /* We failed to handle the error */
2913 return nfs4_map_errors(ret);
2914}
2915
adfa6f98 2916int nfs4_proc_setclientid(struct nfs_client *clp, u32 program, unsigned short port, struct rpc_cred *cred)
1da177e4
LT		 2917{
2918 nfs4_verifier sc_verifier;
2919 struct nfs4_setclientid setclientid = {
2920 .sc_verifier = &sc_verifier,
2921 .sc_prog = program,
2922 };
2923 struct rpc_message msg = {
2924 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
2925 .rpc_argp = &setclientid,
2926 .rpc_resp = clp,
286d7d6a 2927 .rpc_cred = cred,
1da177e4 2928 };
bc4785cd 2929 __be32 *p;
1da177e4
LT		 2930 int loop = 0;
2931 int status;
2932
bc4785cd 2933 p = (__be32*)sc_verifier.data;
1da177e4
LT		 2934 *p++ = htonl((u32)clp->cl_boot_time.tv_sec);
2935 *p = htonl((u32)clp->cl_boot_time.tv_nsec);
2936
2937 for(;;) {
2938 setclientid.sc_name_len = scnprintf(setclientid.sc_name,
2939 sizeof(setclientid.sc_name), "%s/%u.%u.%u.%u %s %u",
24c8dbbb 2940 clp->cl_ipaddr, NIPQUAD(clp->cl_addr.sin_addr),
286d7d6a 2941 cred->cr_ops->cr_name,
1da177e4
LT		 2942 clp->cl_id_uniquifier);
2943 setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
2944 sizeof(setclientid.sc_netid), "tcp");
2945 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
2946 sizeof(setclientid.sc_uaddr), "%s.%d.%d",
2947 clp->cl_ipaddr, port >> 8, port & 255);
2948
2949 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
2950 if (status != -NFS4ERR_CLID_INUSE)
2951 break;
2952 if (signalled())
2953 break;
2954 if (loop++ & 1)
2955 ssleep(clp->cl_lease_time + 1);
2956 else
2957 if (++clp->cl_id_uniquifier == 0)
2958 break;
2959 }
2960 return status;
2961}
2962
adfa6f98 2963static int _nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred)
1da177e4
LT		 2964{
2965 struct nfs_fsinfo fsinfo;
2966 struct rpc_message msg = {
2967 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
2968 .rpc_argp = clp,
2969 .rpc_resp = &fsinfo,
286d7d6a 2970 .rpc_cred = cred,
1da177e4
LT		 2971 };
2972 unsigned long now;
2973 int status;
2974
2975 now = jiffies;
2976 status = rpc_call_sync(clp->cl_rpcclient, &msg, 0);
2977 if (status == 0) {
2978 spin_lock(&clp->cl_lock);
2979 clp->cl_lease_time = fsinfo.lease_time * HZ;
2980 clp->cl_last_renewal = now;
58d9714a 2981 clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1da177e4
LT		 2982 spin_unlock(&clp->cl_lock);
2983 }
2984 return status;
2985}
2986
adfa6f98 2987int nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred)
51581f3b
TM		 2988{
2989 long timeout;
2990 int err;
2991 do {
2992 err = _nfs4_proc_setclientid_confirm(clp, cred);
2993 switch (err) {
2994 case 0:
2995 return err;
2996 case -NFS4ERR_RESOURCE:
2997 /* The IBM lawyers misread another document! */
2998 case -NFS4ERR_DELAY:
2999 err = nfs4_delay(clp->cl_rpcclient, &timeout);
3000 }
3001 } while (err == 0);
3002 return err;
3003}
3004
fe650407
TM		 3005struct nfs4_delegreturndata {
3006 struct nfs4_delegreturnargs args;
fa178f29 3007 struct nfs4_delegreturnres res;
fe650407
TM		 3008 struct nfs_fh fh;
3009 nfs4_stateid stateid;
3010 struct rpc_cred *cred;
26e976a8 3011 unsigned long timestamp;
fa178f29 3012 struct nfs_fattr fattr;
fe650407
TM		 3013 int rpc_status;
3014};
3015
3016static void nfs4_delegreturn_prepare(struct rpc_task *task, void *calldata)
1da177e4 3017{
fe650407 3018 struct nfs4_delegreturndata *data = calldata;
1da177e4
LT		 3019 struct rpc_message msg = {
3020 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
fe650407 3021 .rpc_argp = &data->args,
fa178f29 3022 .rpc_resp = &data->res,
fe650407 3023 .rpc_cred = data->cred,
1da177e4 3024 };
fa178f29 3025 nfs_fattr_init(data->res.fattr);
fe650407
TM		 3026 rpc_call_setup(task, &msg, 0);
3027}
1da177e4 3028
fe650407
TM		 3029static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
3030{
3031 struct nfs4_delegreturndata *data = calldata;
3032 data->rpc_status = task->tk_status;
26e976a8 3033 if (data->rpc_status == 0)
fa178f29 3034 renew_lease(data->res.server, data->timestamp);
fe650407
TM		 3035}
3036
3037static void nfs4_delegreturn_release(void *calldata)
3038{
3039 struct nfs4_delegreturndata *data = calldata;
3040
3041 put_rpccred(data->cred);
3042 kfree(calldata);
3043}
3044
c8d149f3 3045static const struct rpc_call_ops nfs4_delegreturn_ops = {
fe650407
TM		 3046 .rpc_call_prepare = nfs4_delegreturn_prepare,
3047 .rpc_call_done = nfs4_delegreturn_done,
3048 .rpc_release = nfs4_delegreturn_release,
3049};
3050
3051static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid)
3052{
3053 struct nfs4_delegreturndata *data;
fa178f29 3054 struct nfs_server *server = NFS_SERVER(inode);
fe650407
TM		 3055 struct rpc_task *task;
3056 int status;
3057
3058 data = kmalloc(sizeof(*data), GFP_KERNEL);
3059 if (data == NULL)
3060 return -ENOMEM;
3061 data->args.fhandle = &data->fh;
3062 data->args.stateid = &data->stateid;
fa178f29 3063 data->args.bitmask = server->attr_bitmask;
fe650407
TM		 3064 nfs_copy_fh(&data->fh, NFS_FH(inode));
3065 memcpy(&data->stateid, stateid, sizeof(data->stateid));
fa178f29
TM		 3066 data->res.fattr = &data->fattr;
3067 data->res.server = server;
fe650407 3068 data->cred = get_rpccred(cred);
26e976a8 3069 data->timestamp = jiffies;
fe650407
TM		 3070 data->rpc_status = 0;
3071
3072 task = rpc_run_task(NFS_CLIENT(inode), RPC_TASK_ASYNC, &nfs4_delegreturn_ops, data);
7a1218a2 3073 if (IS_ERR(task))
fe650407 3074 return PTR_ERR(task);
fe650407 3075 status = nfs4_wait_for_completion_rpc_task(task);
fa178f29 3076 if (status == 0) {
fe650407 3077 status = data->rpc_status;
fa178f29
TM		 3078 if (status == 0)
3079 nfs_post_op_update_inode(inode, &data->fattr);
3080 }
e6b3c4db 3081 rpc_put_task(task);
fe650407 3082 return status;
1da177e4
LT		 3083}
3084
3085int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid)
3086{
3087 struct nfs_server *server = NFS_SERVER(inode);
3088 struct nfs4_exception exception = { };
3089 int err;
3090 do {
3091 err = _nfs4_proc_delegreturn(inode, cred, stateid);
3092 switch (err) {
3093 case -NFS4ERR_STALE_STATEID:
3094 case -NFS4ERR_EXPIRED:
1da177e4
LT		 3095 case 0:
3096 return 0;
3097 }
3098 err = nfs4_handle_exception(server, err, &exception);
3099 } while (exception.retry);
3100 return err;
3101}
3102
3103#define NFS4_LOCK_MINTIMEOUT (1 * HZ)
3104#define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
3105
3106/*
3107 * sleep, with exponential backoff, and retry the LOCK operation.
3108 */
3109static unsigned long
3110nfs4_set_lock_task_retry(unsigned long timeout)
3111{
041e0e3b 3112 schedule_timeout_interruptible(timeout);
1da177e4
LT		 3113 timeout <<= 1;
3114 if (timeout > NFS4_LOCK_MAXTIMEOUT)
3115 return NFS4_LOCK_MAXTIMEOUT;
3116 return timeout;
3117}
3118
1da177e4
LT		 3119static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3120{
3121 struct inode *inode = state->inode;
3122 struct nfs_server *server = NFS_SERVER(inode);
7539bbab 3123 struct nfs_client *clp = server->nfs_client;
911d1aaf 3124 struct nfs_lockt_args arg = {
1da177e4 3125 .fh = NFS_FH(inode),
911d1aaf 3126 .fl = request,
1da177e4 3127 };
911d1aaf
TM		 3128 struct nfs_lockt_res res = {
3129 .denied = request,
1da177e4
LT		 3130 };
3131 struct rpc_message msg = {
3132 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
3133 .rpc_argp = &arg,
3134 .rpc_resp = &res,
3135 .rpc_cred = state->owner->so_cred,
3136 };
1da177e4
LT		 3137 struct nfs4_lock_state *lsp;
3138 int status;
3139
3140 down_read(&clp->cl_sem);
911d1aaf 3141 arg.lock_owner.clientid = clp->cl_clientid;
8d0a8a9d
TM		 3142 status = nfs4_set_lock_state(state, request);
3143 if (status != 0)
3144 goto out;
3145 lsp = request->fl_u.nfs4_fl.owner;
9f958ab8 3146 arg.lock_owner.id = lsp->ls_id.id;
1da177e4 3147 status = rpc_call_sync(server->client, &msg, 0);
911d1aaf
TM		 3148 switch (status) {
3149 case 0:
3150 request->fl_type = F_UNLCK;
3151 break;
3152 case -NFS4ERR_DENIED:
3153 status = 0;
1da177e4 3154 }
70cc6487 3155 request->fl_ops->fl_release_private(request);
8d0a8a9d 3156out:
1da177e4
LT		 3157 up_read(&clp->cl_sem);
3158 return status;
3159}
3160
3161static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3162{
3163 struct nfs4_exception exception = { };
3164 int err;
3165
3166 do {
3167 err = nfs4_handle_exception(NFS_SERVER(state->inode),
3168 _nfs4_proc_getlk(state, cmd, request),
3169 &exception);
3170 } while (exception.retry);
3171 return err;
3172}
3173
3174static int do_vfs_lock(struct file *file, struct file_lock *fl)
3175{
3176 int res = 0;
3177 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
3178 case FL_POSIX:
3179 res = posix_lock_file_wait(file, fl);
3180 break;
3181 case FL_FLOCK:
3182 res = flock_lock_file_wait(file, fl);
3183 break;
3184 default:
3185 BUG();
3186 }
1da177e4
LT		 3187 return res;
3188}
3189
faf5f49c 3190struct nfs4_unlockdata {
911d1aaf
TM		 3191 struct nfs_locku_args arg;
3192 struct nfs_locku_res res;
faf5f49c
TM		 3193 struct nfs4_lock_state *lsp;
3194 struct nfs_open_context *ctx;
911d1aaf
TM		 3195 struct file_lock fl;
3196 const struct nfs_server *server;
26e976a8 3197 unsigned long timestamp;
faf5f49c
TM		 3198};
3199
911d1aaf
TM		 3200static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
3201 struct nfs_open_context *ctx,
3202 struct nfs4_lock_state *lsp,
3203 struct nfs_seqid *seqid)
3204{
3205 struct nfs4_unlockdata *p;
3206 struct inode *inode = lsp->ls_state->inode;
3207
3208 p = kmalloc(sizeof(*p), GFP_KERNEL);
3209 if (p == NULL)
3210 return NULL;
3211 p->arg.fh = NFS_FH(inode);
3212 p->arg.fl = &p->fl;
3213 p->arg.seqid = seqid;
3214 p->arg.stateid = &lsp->ls_stateid;
3215 p->lsp = lsp;
3216 atomic_inc(&lsp->ls_count);
3217 /* Ensure we don't close file until we're done freeing locks! */
3218 p->ctx = get_nfs_open_context(ctx);
3219 memcpy(&p->fl, fl, sizeof(p->fl));
3220 p->server = NFS_SERVER(inode);
3221 return p;
3222}
3223
06f814a3 3224static void nfs4_locku_release_calldata(void *data)
faf5f49c 3225{
963d8fe5 3226 struct nfs4_unlockdata *calldata = data;
911d1aaf 3227 nfs_free_seqid(calldata->arg.seqid);
06f814a3
TM		 3228 nfs4_put_lock_state(calldata->lsp);
3229 put_nfs_open_context(calldata->ctx);
3230 kfree(calldata);
faf5f49c
TM		 3231}
3232
963d8fe5 3233static void nfs4_locku_done(struct rpc_task *task, void *data)
faf5f49c 3234{
963d8fe5 3235 struct nfs4_unlockdata *calldata = data;
faf5f49c 3236
06f814a3
TM		 3237 if (RPC_ASSASSINATED(task))
3238 return;
911d1aaf 3239 nfs_increment_lock_seqid(task->tk_status, calldata->arg.seqid);
faf5f49c
TM		 3240 switch (task->tk_status) {
3241 case 0:
3242 memcpy(calldata->lsp->ls_stateid.data,
911d1aaf 3243 calldata->res.stateid.data,
faf5f49c 3244 sizeof(calldata->lsp->ls_stateid.data));
26e976a8 3245 renew_lease(calldata->server, calldata->timestamp);
faf5f49c
TM		 3246 break;
3247 case -NFS4ERR_STALE_STATEID:
3248 case -NFS4ERR_EXPIRED:
faf5f49c
TM		 3249 break;
3250 default:
a6a352e9 3251 if (nfs4_async_handle_error(task, calldata->server) == -EAGAIN)
faf5f49c 3252 rpc_restart_call(task);
faf5f49c 3253 }
faf5f49c
TM		 3254}
3255
4ce70ada 3256static void nfs4_locku_prepare(struct rpc_task *task, void *data)
faf5f49c 3257{
4ce70ada 3258 struct nfs4_unlockdata *calldata = data;
1da177e4
LT		 3259 struct rpc_message msg = {
3260 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
faf5f49c
TM		 3261 .rpc_argp = &calldata->arg,
3262 .rpc_resp = &calldata->res,
3263 .rpc_cred = calldata->lsp->ls_state->owner->so_cred,
1da177e4 3264 };
faf5f49c 3265
911d1aaf 3266 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
faf5f49c
TM		 3267 return;
3268 if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) {
963d8fe5
TM		 3269 /* Note: exit _without_ running nfs4_locku_done */
3270 task->tk_action = NULL;
faf5f49c
TM		 3271 return;
3272 }
26e976a8 3273 calldata->timestamp = jiffies;
faf5f49c
TM		 3274 rpc_call_setup(task, &msg, 0);
3275}
3276
963d8fe5 3277static const struct rpc_call_ops nfs4_locku_ops = {
4ce70ada 3278 .rpc_call_prepare = nfs4_locku_prepare,
963d8fe5 3279 .rpc_call_done = nfs4_locku_done,
06f814a3 3280 .rpc_release = nfs4_locku_release_calldata,
963d8fe5
TM		 3281};
3282
a5d16a4d
TM		 3283static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
3284 struct nfs_open_context *ctx,
3285 struct nfs4_lock_state *lsp,
3286 struct nfs_seqid *seqid)
3287{
3288 struct nfs4_unlockdata *data;
a5d16a4d 3289
137d6aca
FF		 3290 /* Ensure this is an unlock - when canceling a lock, the
3291 * canceled lock is passed in, and it won't be an unlock.
3292 */
3293 fl->fl_type = F_UNLCK;
3294
a5d16a4d
TM		 3295 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
3296 if (data == NULL) {
3297 nfs_free_seqid(seqid);
3298 return ERR_PTR(-ENOMEM);
3299 }
3300
7a1218a2 3301 return rpc_run_task(NFS_CLIENT(lsp->ls_state->inode), RPC_TASK_ASYNC, &nfs4_locku_ops, data);
a5d16a4d
TM		 3302}
3303
faf5f49c
TM		 3304static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
3305{
911d1aaf 3306 struct nfs_seqid *seqid;
1da177e4 3307 struct nfs4_lock_state *lsp;
06f814a3
TM		 3308 struct rpc_task *task;
3309 int status = 0;
faf5f49c 3310
8d0a8a9d 3311 status = nfs4_set_lock_state(state, request);
9b073574
TM		 3312 /* Unlock _before_ we do the RPC call */
3313 request->fl_flags |= FL_EXISTS;
3314 if (do_vfs_lock(request->fl_file, request) == -ENOENT)
3315 goto out;
8d0a8a9d 3316 if (status != 0)
9b073574
TM		 3317 goto out;
3318 /* Is this a delegated lock? */
3319 if (test_bit(NFS_DELEGATED_STATE, &state->flags))
3320 goto out;
8d0a8a9d 3321 lsp = request->fl_u.nfs4_fl.owner;
911d1aaf 3322 seqid = nfs_alloc_seqid(&lsp->ls_seqid);
9b073574 3323 status = -ENOMEM;
911d1aaf 3324 if (seqid == NULL)
9b073574 3325 goto out;
a5d16a4d
TM		 3326 task = nfs4_do_unlck(request, request->fl_file->private_data, lsp, seqid);
3327 status = PTR_ERR(task);
3328 if (IS_ERR(task))
9b073574 3329 goto out;
a5d16a4d 3330 status = nfs4_wait_for_completion_rpc_task(task);
e6b3c4db 3331 rpc_put_task(task);
9b073574 3332out:
1da177e4
LT		 3333 return status;
3334}
3335
a5d16a4d
TM		 3336struct nfs4_lockdata {
3337 struct nfs_lock_args arg;
3338 struct nfs_lock_res res;
3339 struct nfs4_lock_state *lsp;
3340 struct nfs_open_context *ctx;
3341 struct file_lock fl;
26e976a8 3342 unsigned long timestamp;
a5d16a4d
TM		 3343 int rpc_status;
3344 int cancelled;
3345};
3346
3347static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
3348 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp)
1da177e4 3349{
a5d16a4d
TM		 3350 struct nfs4_lockdata *p;
3351 struct inode *inode = lsp->ls_state->inode;
1da177e4 3352 struct nfs_server *server = NFS_SERVER(inode);
a5d16a4d
TM		 3353
3354 p = kzalloc(sizeof(*p), GFP_KERNEL);
3355 if (p == NULL)
3356 return NULL;
3357
3358 p->arg.fh = NFS_FH(inode);
3359 p->arg.fl = &p->fl;
3360 p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid);
3361 if (p->arg.lock_seqid == NULL)
3362 goto out_free;
3363 p->arg.lock_stateid = &lsp->ls_stateid;
7539bbab 3364 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
9f958ab8 3365 p->arg.lock_owner.id = lsp->ls_id.id;
a5d16a4d
TM		 3366 p->lsp = lsp;
3367 atomic_inc(&lsp->ls_count);
3368 p->ctx = get_nfs_open_context(ctx);
3369 memcpy(&p->fl, fl, sizeof(p->fl));
3370 return p;
3371out_free:
3372 kfree(p);
3373 return NULL;
3374}
3375
3376static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
3377{
3378 struct nfs4_lockdata *data = calldata;
3379 struct nfs4_state *state = data->lsp->ls_state;
3380 struct nfs4_state_owner *sp = state->owner;
1da177e4 3381 struct rpc_message msg = {
a5d16a4d
TM		 3382 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
3383 .rpc_argp = &data->arg,
3384 .rpc_resp = &data->res,
3385 .rpc_cred = sp->so_cred,
1da177e4 3386 };
06735b34 3387
a5d16a4d
TM		 3388 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
3389 return;
3390 dprintk("%s: begin!\n", __FUNCTION__);
3391 /* Do we need to do an open_to_lock_owner? */
3392 if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) {
3393 data->arg.open_seqid = nfs_alloc_seqid(&sp->so_seqid);
3394 if (data->arg.open_seqid == NULL) {
3395 data->rpc_status = -ENOMEM;
3396 task->tk_action = NULL;
06735b34 3397 goto out;
8d0a8a9d 3398 }
a5d16a4d
TM		 3399 data->arg.open_stateid = &state->stateid;
3400 data->arg.new_lock_owner = 1;
3401 }
26e976a8 3402 data->timestamp = jiffies;
a5d16a4d 3403 rpc_call_setup(task, &msg, 0);
06735b34 3404out:
a5d16a4d
TM		 3405 dprintk("%s: done!, ret = %d\n", __FUNCTION__, data->rpc_status);
3406}
3407
3408static void nfs4_lock_done(struct rpc_task *task, void *calldata)
3409{
3410 struct nfs4_lockdata *data = calldata;
3411
3412 dprintk("%s: begin!\n", __FUNCTION__);
3413
3414 data->rpc_status = task->tk_status;
3415 if (RPC_ASSASSINATED(task))
3416 goto out;
3417 if (data->arg.new_lock_owner != 0) {
3418 nfs_increment_open_seqid(data->rpc_status, data->arg.open_seqid);
3419 if (data->rpc_status == 0)
3420 nfs_confirm_seqid(&data->lsp->ls_seqid, 0);
3421 else
3422 goto out;
3423 }
3424 if (data->rpc_status == 0) {
3425 memcpy(data->lsp->ls_stateid.data, data->res.stateid.data,
3426 sizeof(data->lsp->ls_stateid.data));
3427 data->lsp->ls_flags |= NFS_LOCK_INITIALIZED;
88be9f99 3428 renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp);
a5d16a4d
TM		 3429 }
3430 nfs_increment_lock_seqid(data->rpc_status, data->arg.lock_seqid);
3431out:
3432 dprintk("%s: done, ret = %d!\n", __FUNCTION__, data->rpc_status);
3433}
3434
3435static void nfs4_lock_release(void *calldata)
3436{
3437 struct nfs4_lockdata *data = calldata;
3438
3439 dprintk("%s: begin!\n", __FUNCTION__);
3440 if (data->arg.open_seqid != NULL)
3441 nfs_free_seqid(data->arg.open_seqid);
3442 if (data->cancelled != 0) {
3443 struct rpc_task *task;
3444 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
3445 data->arg.lock_seqid);
3446 if (!IS_ERR(task))
e6b3c4db 3447 rpc_put_task(task);
a5d16a4d
TM		 3448 dprintk("%s: cancelling lock!\n", __FUNCTION__);
3449 } else
3450 nfs_free_seqid(data->arg.lock_seqid);
3451 nfs4_put_lock_state(data->lsp);
3452 put_nfs_open_context(data->ctx);
3453 kfree(data);
3454 dprintk("%s: done!\n", __FUNCTION__);
3455}
3456
3457static const struct rpc_call_ops nfs4_lock_ops = {
3458 .rpc_call_prepare = nfs4_lock_prepare,
3459 .rpc_call_done = nfs4_lock_done,
3460 .rpc_release = nfs4_lock_release,
3461};
3462
3463static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int reclaim)
3464{
3465 struct nfs4_lockdata *data;
3466 struct rpc_task *task;
3467 int ret;
3468
3469 dprintk("%s: begin!\n", __FUNCTION__);
3470 data = nfs4_alloc_lockdata(fl, fl->fl_file->private_data,
3471 fl->fl_u.nfs4_fl.owner);
3472 if (data == NULL)
3473 return -ENOMEM;
3474 if (IS_SETLKW(cmd))
3475 data->arg.block = 1;
3476 if (reclaim != 0)
3477 data->arg.reclaim = 1;
3478 task = rpc_run_task(NFS_CLIENT(state->inode), RPC_TASK_ASYNC,
3479 &nfs4_lock_ops, data);
7a1218a2 3480 if (IS_ERR(task))
a5d16a4d 3481 return PTR_ERR(task);
a5d16a4d
TM		 3482 ret = nfs4_wait_for_completion_rpc_task(task);
3483 if (ret == 0) {
3484 ret = data->rpc_status;
3485 if (ret == -NFS4ERR_DENIED)
3486 ret = -EAGAIN;
3487 } else
3488 data->cancelled = 1;
e6b3c4db 3489 rpc_put_task(task);
a5d16a4d
TM		 3490 dprintk("%s: done, ret = %d!\n", __FUNCTION__, ret);
3491 return ret;
1da177e4
LT		 3492}
3493
3494static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
3495{
202b50dc
TM		 3496 struct nfs_server *server = NFS_SERVER(state->inode);
3497 struct nfs4_exception exception = { };
3498 int err;
3499
3500 do {
42a2d13e
TM		 3501 /* Cache the lock if possible... */
3502 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
3503 return 0;
202b50dc
TM		 3504 err = _nfs4_do_setlk(state, F_SETLK, request, 1);
3505 if (err != -NFS4ERR_DELAY)
3506 break;
3507 nfs4_handle_exception(server, err, &exception);
3508 } while (exception.retry);
3509 return err;
1da177e4
LT		 3510}
3511
3512static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
3513{
202b50dc
TM		 3514 struct nfs_server *server = NFS_SERVER(state->inode);
3515 struct nfs4_exception exception = { };
3516 int err;
3517
6bfc93ef
TM		 3518 err = nfs4_set_lock_state(state, request);
3519 if (err != 0)
3520 return err;
202b50dc 3521 do {
42a2d13e
TM		 3522 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
3523 return 0;
202b50dc
TM		 3524 err = _nfs4_do_setlk(state, F_SETLK, request, 0);
3525 if (err != -NFS4ERR_DELAY)
3526 break;
3527 nfs4_handle_exception(server, err, &exception);
3528 } while (exception.retry);
3529 return err;
1da177e4
LT		 3530}
3531
3532static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3533{
adfa6f98 3534 struct nfs_client *clp = state->owner->so_client;
01c3b861 3535 unsigned char fl_flags = request->fl_flags;
1da177e4
LT		 3536 int status;
3537
6bfc93ef 3538 /* Is this a delegated open? */
6bfc93ef
TM		 3539 status = nfs4_set_lock_state(state, request);
3540 if (status != 0)
3541 goto out;
01c3b861
TM		 3542 request->fl_flags |= FL_ACCESS;
3543 status = do_vfs_lock(request->fl_file, request);
3544 if (status < 0)
3545 goto out;
3546 down_read(&clp->cl_sem);
3547 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
3548 struct nfs_inode *nfsi = NFS_I(state->inode);
3549 /* Yes: cache locks! */
3550 down_read(&nfsi->rwsem);
3551 /* ...but avoid races with delegation recall... */
3552 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
3553 request->fl_flags = fl_flags & ~FL_SLEEP;
3554 status = do_vfs_lock(request->fl_file, request);
3555 up_read(&nfsi->rwsem);
3556 goto out_unlock;
3557 }
3558 up_read(&nfsi->rwsem);
3559 }
6bfc93ef
TM		 3560 status = _nfs4_do_setlk(state, cmd, request, 0);
3561 if (status != 0)
01c3b861 3562 goto out_unlock;
6bfc93ef 3563 /* Note: we always want to sleep here! */
01c3b861 3564 request->fl_flags = fl_flags | FL_SLEEP;
6bfc93ef
TM		 3565 if (do_vfs_lock(request->fl_file, request) < 0)
3566 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __FUNCTION__);
01c3b861 3567out_unlock:
1da177e4 3568 up_read(&clp->cl_sem);
01c3b861
TM		 3569out:
3570 request->fl_flags = fl_flags;
1da177e4
LT		 3571 return status;
3572}
3573
3574static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
3575{
3576 struct nfs4_exception exception = { };
3577 int err;
3578
3579 do {
3580 err = nfs4_handle_exception(NFS_SERVER(state->inode),
3581 _nfs4_proc_setlk(state, cmd, request),
3582 &exception);
3583 } while (exception.retry);
3584 return err;
3585}
3586
3587static int
3588nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
3589{
3590 struct nfs_open_context *ctx;
3591 struct nfs4_state *state;
3592 unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
3593 int status;
3594
3595 /* verify open state */
3596 ctx = (struct nfs_open_context *)filp->private_data;
3597 state = ctx->state;
3598
3599 if (request->fl_start < 0 || request->fl_end < 0)
3600 return -EINVAL;
3601
3602 if (IS_GETLK(cmd))
3603 return nfs4_proc_getlk(state, F_GETLK, request);
3604
3605 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
3606 return -EINVAL;
3607
3608 if (request->fl_type == F_UNLCK)
3609 return nfs4_proc_unlck(state, cmd, request);
3610
3611 do {
3612 status = nfs4_proc_setlk(state, cmd, request);
3613 if ((status != -EAGAIN) || IS_SETLK(cmd))
3614 break;
3615 timeout = nfs4_set_lock_task_retry(timeout);
3616 status = -ERESTARTSYS;
3617 if (signalled())
3618 break;
3619 } while(status < 0);
1da177e4
LT		 3620 return status;
3621}
3622
888e694c
TM		 3623int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl)
3624{
3625 struct nfs_server *server = NFS_SERVER(state->inode);
3626 struct nfs4_exception exception = { };
3627 int err;
3628
3629 err = nfs4_set_lock_state(state, fl);
3630 if (err != 0)
3631 goto out;
3632 do {
3633 err = _nfs4_do_setlk(state, F_SETLK, fl, 0);
3634 if (err != -NFS4ERR_DELAY)
3635 break;
3636 err = nfs4_handle_exception(server, err, &exception);
3637 } while (exception.retry);
3638out:
3639 return err;
3640}
6b3b5496 3641
aa1870af
BF		 3642#define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
3643
6b3b5496
BF		 3644int nfs4_setxattr(struct dentry *dentry, const char *key, const void *buf,
3645 size_t buflen, int flags)
3646{
4b580ee3
BF		 3647 struct inode *inode = dentry->d_inode;
3648
3649 if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0)
3650 return -EOPNOTSUPP;
3651
3652 if (!S_ISREG(inode->i_mode) &&
3653 (!S_ISDIR(inode->i_mode) || inode->i_mode & S_ISVTX))
3654 return -EPERM;
3655
3656 return nfs4_proc_set_acl(inode, buf, buflen);
6b3b5496
BF		 3657}
3658
3659/* The getxattr man page suggests returning -ENODATA for unknown attributes,
3660 * and that's what we'll do for e.g. user attributes that haven't been set.
3661 * But we'll follow ext2/ext3's lead by returning -EOPNOTSUPP for unsupported
3662 * attributes in kernel-managed attribute namespaces. */
3663ssize_t nfs4_getxattr(struct dentry *dentry, const char *key, void *buf,
3664 size_t buflen)
3665{
aa1870af
BF		 3666 struct inode *inode = dentry->d_inode;
3667
3668 if (strcmp(key, XATTR_NAME_NFSV4_ACL) != 0)
3669 return -EOPNOTSUPP;
3670
3671 return nfs4_proc_get_acl(inode, buf, buflen);
6b3b5496
BF		 3672}
3673
3674ssize_t nfs4_listxattr(struct dentry *dentry, char *buf, size_t buflen)
3675{
aa1870af 3676 size_t len = strlen(XATTR_NAME_NFSV4_ACL) + 1;
6b3b5496 3677
096455a2
BF		 3678 if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))
3679 return 0;
6b3b5496
BF		 3680 if (buf && buflen < len)
3681 return -ERANGE;
3682 if (buf)
aa1870af
BF		 3683 memcpy(buf, XATTR_NAME_NFSV4_ACL, len);
3684 return len;
6b3b5496
BF		 3685}
3686
56659e99 3687int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
7aaa0b3b 3688 struct nfs4_fs_locations *fs_locations, struct page *page)
683b57b4
TM		 3689{
3690 struct nfs_server *server = NFS_SERVER(dir);
3691 u32 bitmask[2] = {
361e624f
MN		 3692 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
3693 [1] = FATTR4_WORD1_MOUNTED_ON_FILEID,
683b57b4
TM		 3694 };
3695 struct nfs4_fs_locations_arg args = {
3696 .dir_fh = NFS_FH(dir),
c228fd3a 3697 .name = name,
683b57b4
TM		 3698 .page = page,
3699 .bitmask = bitmask,
3700 };
3701 struct rpc_message msg = {
3702 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
3703 .rpc_argp = &args,
7aaa0b3b 3704 .rpc_resp = fs_locations,
683b57b4
TM		 3705 };
3706 int status;
3707
3708 dprintk("%s: start\n", __FUNCTION__);
c228fd3a 3709 nfs_fattr_init(&fs_locations->fattr);
683b57b4 3710 fs_locations->server = server;
830b8e33 3711 fs_locations->nlocations = 0;
683b57b4
TM		 3712 status = rpc_call_sync(server->client, &msg, 0);
3713 dprintk("%s: returned status = %d\n", __FUNCTION__, status);
3714 return status;
3715}
3716
1da177e4
LT		 3717struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = {
3718 .recover_open = nfs4_open_reclaim,
3719 .recover_lock = nfs4_lock_reclaim,
3720};
3721
3722struct nfs4_state_recovery_ops nfs4_network_partition_recovery_ops = {
3723 .recover_open = nfs4_open_expired,
3724 .recover_lock = nfs4_lock_expired,
3725};
3726
92e1d5be 3727static const struct inode_operations nfs4_file_inode_operations = {
6b3b5496
BF		 3728 .permission = nfs_permission,
3729 .getattr = nfs_getattr,
3730 .setattr = nfs_setattr,
3731 .getxattr = nfs4_getxattr,
3732 .setxattr = nfs4_setxattr,
3733 .listxattr = nfs4_listxattr,
3734};
3735
509de811 3736const struct nfs_rpc_ops nfs_v4_clientops = {
1da177e4
LT		 3737 .version = 4, /* protocol version */
3738 .dentry_ops = &nfs4_dentry_operations,
3739 .dir_inode_ops = &nfs4_dir_inode_operations,
6b3b5496 3740 .file_inode_ops = &nfs4_file_inode_operations,
1da177e4
LT		 3741 .getroot = nfs4_proc_get_root,
3742 .getattr = nfs4_proc_getattr,
3743 .setattr = nfs4_proc_setattr,
2b3de441 3744 .lookupfh = nfs4_proc_lookupfh,
1da177e4
LT		 3745 .lookup = nfs4_proc_lookup,
3746 .access = nfs4_proc_access,
3747 .readlink = nfs4_proc_readlink,
1da177e4
LT		 3748 .create = nfs4_proc_create,
3749 .remove = nfs4_proc_remove,
3750 .unlink_setup = nfs4_proc_unlink_setup,
3751 .unlink_done = nfs4_proc_unlink_done,
3752 .rename = nfs4_proc_rename,
3753 .link = nfs4_proc_link,
3754 .symlink = nfs4_proc_symlink,
3755 .mkdir = nfs4_proc_mkdir,
3756 .rmdir = nfs4_proc_remove,
3757 .readdir = nfs4_proc_readdir,
3758 .mknod = nfs4_proc_mknod,
3759 .statfs = nfs4_proc_statfs,
3760 .fsinfo = nfs4_proc_fsinfo,
3761 .pathconf = nfs4_proc_pathconf,
e9326dca 3762 .set_capabilities = nfs4_server_capabilities,
1da177e4
LT		 3763 .decode_dirent = nfs4_decode_dirent,
3764 .read_setup = nfs4_proc_read_setup,
ec06c096 3765 .read_done = nfs4_read_done,
1da177e4 3766 .write_setup = nfs4_proc_write_setup,
788e7a89 3767 .write_done = nfs4_write_done,
1da177e4 3768 .commit_setup = nfs4_proc_commit_setup,
788e7a89 3769 .commit_done = nfs4_commit_done,
02a913a7
TM		 3770 .file_open = nfs_open,
3771 .file_release = nfs_release,
1da177e4 3772 .lock = nfs4_proc_lock,
e50a1c2e 3773 .clear_acl_cache = nfs4_zap_acl_attr,
1da177e4
LT		 3774};
3775
3776/*
3777 * Local variables:
3778 * c-basic-offset: 8
3779 * End:
3780 */
Clone of davem's net-next-2.6 tree