aboutsummaryrefslogtreecommitdiffstats
path: root/fs/nfs
diff options
context:
space:
mode:
authorTrond Myklebust <Trond.Myklebust@netapp.com>2008-07-15 18:34:16 -0400
committerTrond Myklebust <Trond.Myklebust@netapp.com>2008-07-15 18:34:16 -0400
commite89e896d31b11a51a54ddcd3f72a76bd286dd86c (patch)
tree105a9a93a4021caeeba76e479778ad2dd2b87b57 /fs/nfs
parent3a628b0fd42f7eaf9d052447784d48ceae9ffb8e (diff)
parentd67d1c7bf948341fd8678c8e337ec27f4b46b206 (diff)
Merge branch 'devel' into next
Conflicts: fs/nfs/file.c Fix up the conflict with Jon Corbet's bkl-removal tree
Diffstat (limited to 'fs/nfs')
-rw-r--r--fs/nfs/callback.c34
-rw-r--r--fs/nfs/client.c13
-rw-r--r--fs/nfs/dir.c26
-rw-r--r--fs/nfs/direct.c4
-rw-r--r--fs/nfs/file.c151
-rw-r--r--fs/nfs/inode.c8
-rw-r--r--fs/nfs/internal.h1
-rw-r--r--fs/nfs/iostat.h119
-rw-r--r--fs/nfs/nfs3acl.c9
-rw-r--r--fs/nfs/nfs3proc.c275
-rw-r--r--fs/nfs/nfs4proc.c263
-rw-r--r--fs/nfs/nfsroot.c10
-rw-r--r--fs/nfs/proc.c28
-rw-r--r--fs/nfs/super.c878
-rw-r--r--fs/nfs/write.c307
15 files changed, 1237 insertions, 889 deletions
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index c1e7c8300629..f447f4b4476c 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -27,7 +27,7 @@
27 27
28struct nfs_callback_data { 28struct nfs_callback_data {
29 unsigned int users; 29 unsigned int users;
30 struct svc_serv *serv; 30 struct svc_rqst *rqst;
31 struct task_struct *task; 31 struct task_struct *task;
32}; 32};
33 33
@@ -91,21 +91,17 @@ nfs_callback_svc(void *vrqstp)
91 svc_process(rqstp); 91 svc_process(rqstp);
92 } 92 }
93 unlock_kernel(); 93 unlock_kernel();
94 nfs_callback_info.task = NULL;
95 svc_exit_thread(rqstp);
96 return 0; 94 return 0;
97} 95}
98 96
99/* 97/*
100 * Bring up the server process if it is not already up. 98 * Bring up the callback thread if it is not already up.
101 */ 99 */
102int nfs_callback_up(void) 100int nfs_callback_up(void)
103{ 101{
104 struct svc_serv *serv = NULL; 102 struct svc_serv *serv = NULL;
105 struct svc_rqst *rqstp;
106 int ret = 0; 103 int ret = 0;
107 104
108 lock_kernel();
109 mutex_lock(&nfs_callback_mutex); 105 mutex_lock(&nfs_callback_mutex);
110 if (nfs_callback_info.users++ || nfs_callback_info.task != NULL) 106 if (nfs_callback_info.users++ || nfs_callback_info.task != NULL)
111 goto out; 107 goto out;
@@ -121,22 +117,23 @@ int nfs_callback_up(void)
121 nfs_callback_tcpport = ret; 117 nfs_callback_tcpport = ret;
122 dprintk("Callback port = 0x%x\n", nfs_callback_tcpport); 118 dprintk("Callback port = 0x%x\n", nfs_callback_tcpport);
123 119
124 rqstp = svc_prepare_thread(serv, &serv->sv_pools[0]); 120 nfs_callback_info.rqst = svc_prepare_thread(serv, &serv->sv_pools[0]);
125 if (IS_ERR(rqstp)) { 121 if (IS_ERR(nfs_callback_info.rqst)) {
126 ret = PTR_ERR(rqstp); 122 ret = PTR_ERR(nfs_callback_info.rqst);
123 nfs_callback_info.rqst = NULL;
127 goto out_err; 124 goto out_err;
128 } 125 }
129 126
130 svc_sock_update_bufs(serv); 127 svc_sock_update_bufs(serv);
131 nfs_callback_info.serv = serv;
132 128
133 nfs_callback_info.task = kthread_run(nfs_callback_svc, rqstp, 129 nfs_callback_info.task = kthread_run(nfs_callback_svc,
130 nfs_callback_info.rqst,
134 "nfsv4-svc"); 131 "nfsv4-svc");
135 if (IS_ERR(nfs_callback_info.task)) { 132 if (IS_ERR(nfs_callback_info.task)) {
136 ret = PTR_ERR(nfs_callback_info.task); 133 ret = PTR_ERR(nfs_callback_info.task);
137 nfs_callback_info.serv = NULL; 134 svc_exit_thread(nfs_callback_info.rqst);
135 nfs_callback_info.rqst = NULL;
138 nfs_callback_info.task = NULL; 136 nfs_callback_info.task = NULL;
139 svc_exit_thread(rqstp);
140 goto out_err; 137 goto out_err;
141 } 138 }
142out: 139out:
@@ -149,7 +146,6 @@ out:
149 if (serv) 146 if (serv)
150 svc_destroy(serv); 147 svc_destroy(serv);
151 mutex_unlock(&nfs_callback_mutex); 148 mutex_unlock(&nfs_callback_mutex);
152 unlock_kernel();
153 return ret; 149 return ret;
154out_err: 150out_err:
155 dprintk("Couldn't create callback socket or server thread; err = %d\n", 151 dprintk("Couldn't create callback socket or server thread; err = %d\n",
@@ -159,17 +155,19 @@ out_err:
159} 155}
160 156
161/* 157/*
162 * Kill the server process if it is not already down. 158 * Kill the callback thread if it's no longer being used.
163 */ 159 */
164void nfs_callback_down(void) 160void nfs_callback_down(void)
165{ 161{
166 lock_kernel();
167 mutex_lock(&nfs_callback_mutex); 162 mutex_lock(&nfs_callback_mutex);
168 nfs_callback_info.users--; 163 nfs_callback_info.users--;
169 if (nfs_callback_info.users == 0 && nfs_callback_info.task != NULL) 164 if (nfs_callback_info.users == 0 && nfs_callback_info.task != NULL) {
170 kthread_stop(nfs_callback_info.task); 165 kthread_stop(nfs_callback_info.task);
166 svc_exit_thread(nfs_callback_info.rqst);
167 nfs_callback_info.rqst = NULL;
168 nfs_callback_info.task = NULL;
169 }
171 mutex_unlock(&nfs_callback_mutex); 170 mutex_unlock(&nfs_callback_mutex);
172 unlock_kernel();
173} 171}
174 172
175static int nfs_callback_authenticate(struct svc_rqst *rqstp) 173static int nfs_callback_authenticate(struct svc_rqst *rqstp)
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index f2a092ca69b5..5ee23e7058b3 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -431,14 +431,14 @@ static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
431{ 431{
432 to->to_initval = timeo * HZ / 10; 432 to->to_initval = timeo * HZ / 10;
433 to->to_retries = retrans; 433 to->to_retries = retrans;
434 if (!to->to_retries)
435 to->to_retries = 2;
436 434
437 switch (proto) { 435 switch (proto) {
438 case XPRT_TRANSPORT_TCP: 436 case XPRT_TRANSPORT_TCP:
439 case XPRT_TRANSPORT_RDMA: 437 case XPRT_TRANSPORT_RDMA:
438 if (to->to_retries == 0)
439 to->to_retries = NFS_DEF_TCP_RETRANS;
440 if (to->to_initval == 0) 440 if (to->to_initval == 0)
441 to->to_initval = 60 * HZ; 441 to->to_initval = NFS_DEF_TCP_TIMEO * HZ / 10;
442 if (to->to_initval > NFS_MAX_TCP_TIMEOUT) 442 if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
443 to->to_initval = NFS_MAX_TCP_TIMEOUT; 443 to->to_initval = NFS_MAX_TCP_TIMEOUT;
444 to->to_increment = to->to_initval; 444 to->to_increment = to->to_initval;
@@ -450,14 +450,17 @@ static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
450 to->to_exponential = 0; 450 to->to_exponential = 0;
451 break; 451 break;
452 case XPRT_TRANSPORT_UDP: 452 case XPRT_TRANSPORT_UDP:
453 default: 453 if (to->to_retries == 0)
454 to->to_retries = NFS_DEF_UDP_RETRANS;
454 if (!to->to_initval) 455 if (!to->to_initval)
455 to->to_initval = 11 * HZ / 10; 456 to->to_initval = NFS_DEF_UDP_TIMEO * HZ / 10;
456 if (to->to_initval > NFS_MAX_UDP_TIMEOUT) 457 if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
457 to->to_initval = NFS_MAX_UDP_TIMEOUT; 458 to->to_initval = NFS_MAX_UDP_TIMEOUT;
458 to->to_maxval = NFS_MAX_UDP_TIMEOUT; 459 to->to_maxval = NFS_MAX_UDP_TIMEOUT;
459 to->to_exponential = 1; 460 to->to_exponential = 1;
460 break; 461 break;
462 default:
463 BUG();
461 } 464 }
462} 465}
463 466
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 982a2064fe4c..b1940660502f 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -133,8 +133,11 @@ nfs_opendir(struct inode *inode, struct file *filp)
133{ 133{
134 int res; 134 int res;
135 135
136 dfprintk(VFS, "NFS: opendir(%s/%ld)\n", 136 dfprintk(FILE, "NFS: open dir(%s/%s)\n",
137 inode->i_sb->s_id, inode->i_ino); 137 filp->f_path.dentry->d_parent->d_name.name,
138 filp->f_path.dentry->d_name.name);
139
140 nfs_inc_stats(inode, NFSIOS_VFSOPEN);
138 141
139 lock_kernel(); 142 lock_kernel();
140 /* Call generic open code in order to cache credentials */ 143 /* Call generic open code in order to cache credentials */
@@ -528,7 +531,7 @@ static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
528 struct nfs_fattr fattr; 531 struct nfs_fattr fattr;
529 long res; 532 long res;
530 533
531 dfprintk(VFS, "NFS: readdir(%s/%s) starting at cookie %Lu\n", 534 dfprintk(FILE, "NFS: readdir(%s/%s) starting at cookie %llu\n",
532 dentry->d_parent->d_name.name, dentry->d_name.name, 535 dentry->d_parent->d_name.name, dentry->d_name.name,
533 (long long)filp->f_pos); 536 (long long)filp->f_pos);
534 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS); 537 nfs_inc_stats(inode, NFSIOS_VFSGETDENTS);
@@ -595,7 +598,7 @@ out:
595 unlock_kernel(); 598 unlock_kernel();
596 if (res > 0) 599 if (res > 0)
597 res = 0; 600 res = 0;
598 dfprintk(VFS, "NFS: readdir(%s/%s) returns %ld\n", 601 dfprintk(FILE, "NFS: readdir(%s/%s) returns %ld\n",
599 dentry->d_parent->d_name.name, dentry->d_name.name, 602 dentry->d_parent->d_name.name, dentry->d_name.name,
600 res); 603 res);
601 return res; 604 return res;
@@ -603,7 +606,15 @@ out:
603 606
604static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin) 607static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
605{ 608{
606 mutex_lock(&filp->f_path.dentry->d_inode->i_mutex); 609 struct dentry *dentry = filp->f_path.dentry;
610 struct inode *inode = dentry->d_inode;
611
612 dfprintk(FILE, "NFS: llseek dir(%s/%s, %lld, %d)\n",
613 dentry->d_parent->d_name.name,
614 dentry->d_name.name,
615 offset, origin);
616
617 mutex_lock(&inode->i_mutex);
607 switch (origin) { 618 switch (origin) {
608 case 1: 619 case 1:
609 offset += filp->f_pos; 620 offset += filp->f_pos;
@@ -619,7 +630,7 @@ static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
619 nfs_file_open_context(filp)->dir_cookie = 0; 630 nfs_file_open_context(filp)->dir_cookie = 0;
620 } 631 }
621out: 632out:
622 mutex_unlock(&filp->f_path.dentry->d_inode->i_mutex); 633 mutex_unlock(&inode->i_mutex);
623 return offset; 634 return offset;
624} 635}
625 636
@@ -629,10 +640,11 @@ out:
629 */ 640 */
630static int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync) 641static int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync)
631{ 642{
632 dfprintk(VFS, "NFS: fsync_dir(%s/%s) datasync %d\n", 643 dfprintk(FILE, "NFS: fsync dir(%s/%s) datasync %d\n",
633 dentry->d_parent->d_name.name, dentry->d_name.name, 644 dentry->d_parent->d_name.name, dentry->d_name.name,
634 datasync); 645 datasync);
635 646
647 nfs_inc_stats(dentry->d_inode, NFSIOS_VFSFSYNC);
636 return 0; 648 return 0;
637} 649}
638 650
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 4757a2b326a1..08f6b040d289 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -890,7 +890,7 @@ ssize_t nfs_file_direct_read(struct kiocb *iocb, const struct iovec *iov,
890 count = iov_length(iov, nr_segs); 890 count = iov_length(iov, nr_segs);
891 nfs_add_stats(mapping->host, NFSIOS_DIRECTREADBYTES, count); 891 nfs_add_stats(mapping->host, NFSIOS_DIRECTREADBYTES, count);
892 892
893 dprintk("nfs: direct read(%s/%s, %zd@%Ld)\n", 893 dfprintk(FILE, "NFS: direct read(%s/%s, %zd@%Ld)\n",
894 file->f_path.dentry->d_parent->d_name.name, 894 file->f_path.dentry->d_parent->d_name.name,
895 file->f_path.dentry->d_name.name, 895 file->f_path.dentry->d_name.name,
896 count, (long long) pos); 896 count, (long long) pos);
@@ -947,7 +947,7 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, const struct iovec *iov,
947 count = iov_length(iov, nr_segs); 947 count = iov_length(iov, nr_segs);
948 nfs_add_stats(mapping->host, NFSIOS_DIRECTWRITTENBYTES, count); 948 nfs_add_stats(mapping->host, NFSIOS_DIRECTWRITTENBYTES, count);
949 949
950 dfprintk(VFS, "nfs: direct write(%s/%s, %zd@%Ld)\n", 950 dfprintk(FILE, "NFS: direct write(%s/%s, %zd@%Ld)\n",
951 file->f_path.dentry->d_parent->d_name.name, 951 file->f_path.dentry->d_parent->d_name.name,
952 file->f_path.dentry->d_name.name, 952 file->f_path.dentry->d_name.name,
953 count, (long long) pos); 953 count, (long long) pos);
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 4e98a56a1777..43164fe86069 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -50,7 +50,7 @@ static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
50static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov, 50static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
51 unsigned long nr_segs, loff_t pos); 51 unsigned long nr_segs, loff_t pos);
52static int nfs_file_flush(struct file *, fl_owner_t id); 52static int nfs_file_flush(struct file *, fl_owner_t id);
53static int nfs_fsync(struct file *, struct dentry *dentry, int datasync); 53static int nfs_file_fsync(struct file *, struct dentry *dentry, int datasync);
54static int nfs_check_flags(int flags); 54static int nfs_check_flags(int flags);
55static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl); 55static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl);
56static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl); 56static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl);
@@ -72,7 +72,7 @@ const struct file_operations nfs_file_operations = {
72 .open = nfs_file_open, 72 .open = nfs_file_open,
73 .flush = nfs_file_flush, 73 .flush = nfs_file_flush,
74 .release = nfs_file_release, 74 .release = nfs_file_release,
75 .fsync = nfs_fsync, 75 .fsync = nfs_file_fsync,
76 .lock = nfs_lock, 76 .lock = nfs_lock,
77 .flock = nfs_flock, 77 .flock = nfs_flock,
78 .splice_read = nfs_file_splice_read, 78 .splice_read = nfs_file_splice_read,
@@ -119,13 +119,17 @@ nfs_file_open(struct inode *inode, struct file *filp)
119{ 119{
120 int res; 120 int res;
121 121
122 dprintk("NFS: open file(%s/%s)\n",
123 filp->f_path.dentry->d_parent->d_name.name,
124 filp->f_path.dentry->d_name.name);
125
122 res = nfs_check_flags(filp->f_flags); 126 res = nfs_check_flags(filp->f_flags);
123 if (res) 127 if (res)
124 return res; 128 return res;
125 129
126 nfs_inc_stats(inode, NFSIOS_VFSOPEN); 130 nfs_inc_stats(inode, NFSIOS_VFSOPEN);
127 lock_kernel(); 131 lock_kernel();
128 res = NFS_PROTO(inode)->file_open(inode, filp); 132 res = nfs_open(inode, filp);
129 unlock_kernel(); 133 unlock_kernel();
130 return res; 134 return res;
131} 135}
@@ -133,11 +137,17 @@ nfs_file_open(struct inode *inode, struct file *filp)
133static int 137static int
134nfs_file_release(struct inode *inode, struct file *filp) 138nfs_file_release(struct inode *inode, struct file *filp)
135{ 139{
140 struct dentry *dentry = filp->f_path.dentry;
141
142 dprintk("NFS: release(%s/%s)\n",
143 dentry->d_parent->d_name.name,
144 dentry->d_name.name);
145
136 /* Ensure that dirty pages are flushed out with the right creds */ 146 /* Ensure that dirty pages are flushed out with the right creds */
137 if (filp->f_mode & FMODE_WRITE) 147 if (filp->f_mode & FMODE_WRITE)
138 nfs_wb_all(filp->f_path.dentry->d_inode); 148 nfs_wb_all(dentry->d_inode);
139 nfs_inc_stats(inode, NFSIOS_VFSRELEASE); 149 nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
140 return NFS_PROTO(inode)->file_release(inode, filp); 150 return nfs_release(inode, filp);
141} 151}
142 152
143/** 153/**
@@ -171,6 +181,12 @@ force_reval:
171static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin) 181static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
172{ 182{
173 loff_t loff; 183 loff_t loff;
184
185 dprintk("NFS: llseek file(%s/%s, %lld, %d)\n",
186 filp->f_path.dentry->d_parent->d_name.name,
187 filp->f_path.dentry->d_name.name,
188 offset, origin);
189
174 /* origin == SEEK_END => we must revalidate the cached file length */ 190 /* origin == SEEK_END => we must revalidate the cached file length */
175 if (origin == SEEK_END) { 191 if (origin == SEEK_END) {
176 struct inode *inode = filp->f_mapping->host; 192 struct inode *inode = filp->f_mapping->host;
@@ -185,7 +201,7 @@ static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
185} 201}
186 202
187/* 203/*
188 * Helper for nfs_file_flush() and nfs_fsync() 204 * Helper for nfs_file_flush() and nfs_file_fsync()
189 * 205 *
190 * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to 206 * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to
191 * disk, but it retrieves and clears ctx->error after synching, despite 207 * disk, but it retrieves and clears ctx->error after synching, despite
@@ -211,16 +227,18 @@ static int nfs_do_fsync(struct nfs_open_context *ctx, struct inode *inode)
211 227
212/* 228/*
213 * Flush all dirty pages, and check for write errors. 229 * Flush all dirty pages, and check for write errors.
214 *
215 */ 230 */
216static int 231static int
217nfs_file_flush(struct file *file, fl_owner_t id) 232nfs_file_flush(struct file *file, fl_owner_t id)
218{ 233{
219 struct nfs_open_context *ctx = nfs_file_open_context(file); 234 struct nfs_open_context *ctx = nfs_file_open_context(file);
220 struct inode *inode = file->f_path.dentry->d_inode; 235 struct dentry *dentry = file->f_path.dentry;
236 struct inode *inode = dentry->d_inode;
221 int status; 237 int status;
222 238
223 dfprintk(VFS, "nfs: flush(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino); 239 dprintk("NFS: flush(%s/%s)\n",
240 dentry->d_parent->d_name.name,
241 dentry->d_name.name);
224 242
225 if ((file->f_mode & FMODE_WRITE) == 0) 243 if ((file->f_mode & FMODE_WRITE) == 0)
226 return 0; 244 return 0;
@@ -245,7 +263,7 @@ nfs_file_read(struct kiocb *iocb, const struct iovec *iov,
245 if (iocb->ki_filp->f_flags & O_DIRECT) 263 if (iocb->ki_filp->f_flags & O_DIRECT)
246 return nfs_file_direct_read(iocb, iov, nr_segs, pos); 264 return nfs_file_direct_read(iocb, iov, nr_segs, pos);
247 265
248 dfprintk(VFS, "nfs: read(%s/%s, %lu@%lu)\n", 266 dprintk("NFS: read(%s/%s, %lu@%lu)\n",
249 dentry->d_parent->d_name.name, dentry->d_name.name, 267 dentry->d_parent->d_name.name, dentry->d_name.name,
250 (unsigned long) count, (unsigned long) pos); 268 (unsigned long) count, (unsigned long) pos);
251 269
@@ -265,7 +283,7 @@ nfs_file_splice_read(struct file *filp, loff_t *ppos,
265 struct inode *inode = dentry->d_inode; 283 struct inode *inode = dentry->d_inode;
266 ssize_t res; 284 ssize_t res;
267 285
268 dfprintk(VFS, "nfs: splice_read(%s/%s, %lu@%Lu)\n", 286 dprintk("NFS: splice_read(%s/%s, %lu@%Lu)\n",
269 dentry->d_parent->d_name.name, dentry->d_name.name, 287 dentry->d_parent->d_name.name, dentry->d_name.name,
270 (unsigned long) count, (unsigned long long) *ppos); 288 (unsigned long) count, (unsigned long long) *ppos);
271 289
@@ -282,7 +300,7 @@ nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
282 struct inode *inode = dentry->d_inode; 300 struct inode *inode = dentry->d_inode;
283 int status; 301 int status;
284 302
285 dfprintk(VFS, "nfs: mmap(%s/%s)\n", 303 dprintk("NFS: mmap(%s/%s)\n",
286 dentry->d_parent->d_name.name, dentry->d_name.name); 304 dentry->d_parent->d_name.name, dentry->d_name.name);
287 305
288 status = nfs_revalidate_mapping(inode, file->f_mapping); 306 status = nfs_revalidate_mapping(inode, file->f_mapping);
@@ -300,12 +318,14 @@ nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
300 * whether any write errors occurred for this process. 318 * whether any write errors occurred for this process.
301 */ 319 */
302static int 320static int
303nfs_fsync(struct file *file, struct dentry *dentry, int datasync) 321nfs_file_fsync(struct file *file, struct dentry *dentry, int datasync)
304{ 322{
305 struct nfs_open_context *ctx = nfs_file_open_context(file); 323 struct nfs_open_context *ctx = nfs_file_open_context(file);
306 struct inode *inode = dentry->d_inode; 324 struct inode *inode = dentry->d_inode;
307 325
308 dfprintk(VFS, "nfs: fsync(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino); 326 dprintk("NFS: fsync file(%s/%s) datasync %d\n",
327 dentry->d_parent->d_name.name, dentry->d_name.name,
328 datasync);
309 329
310 nfs_inc_stats(inode, NFSIOS_VFSFSYNC); 330 nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
311 return nfs_do_fsync(ctx, inode); 331 return nfs_do_fsync(ctx, inode);
@@ -328,6 +348,11 @@ static int nfs_write_begin(struct file *file, struct address_space *mapping,
328 struct page *page; 348 struct page *page;
329 index = pos >> PAGE_CACHE_SHIFT; 349 index = pos >> PAGE_CACHE_SHIFT;
330 350
351 dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n",
352 file->f_path.dentry->d_parent->d_name.name,
353 file->f_path.dentry->d_name.name,
354 mapping->host->i_ino, len, (long long) pos);
355
331 page = __grab_cache_page(mapping, index); 356 page = __grab_cache_page(mapping, index);
332 if (!page) 357 if (!page)
333 return -ENOMEM; 358 return -ENOMEM;
@@ -348,6 +373,31 @@ static int nfs_write_end(struct file *file, struct address_space *mapping,
348 unsigned offset = pos & (PAGE_CACHE_SIZE - 1); 373 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
349 int status; 374 int status;
350 375
376 dfprintk(PAGECACHE, "NFS: write_end(%s/%s(%ld), %u@%lld)\n",
377 file->f_path.dentry->d_parent->d_name.name,
378 file->f_path.dentry->d_name.name,
379 mapping->host->i_ino, len, (long long) pos);
380
381 /*
382 * Zero any uninitialised parts of the page, and then mark the page
383 * as up to date if it turns out that we're extending the file.
384 */
385 if (!PageUptodate(page)) {
386 unsigned pglen = nfs_page_length(page);
387 unsigned end = offset + len;
388
389 if (pglen == 0) {
390 zero_user_segments(page, 0, offset,
391 end, PAGE_CACHE_SIZE);
392 SetPageUptodate(page);
393 } else if (end >= pglen) {
394 zero_user_segment(page, end, PAGE_CACHE_SIZE);
395 if (offset == 0)
396 SetPageUptodate(page);
397 } else
398 zero_user_segment(page, pglen, PAGE_CACHE_SIZE);
399 }
400
351 lock_kernel(); 401 lock_kernel();
352 status = nfs_updatepage(file, page, offset, copied); 402 status = nfs_updatepage(file, page, offset, copied);
353 unlock_kernel(); 403 unlock_kernel();
@@ -362,6 +412,8 @@ static int nfs_write_end(struct file *file, struct address_space *mapping,
362 412
363static void nfs_invalidate_page(struct page *page, unsigned long offset) 413static void nfs_invalidate_page(struct page *page, unsigned long offset)
364{ 414{
415 dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %lu)\n", page, offset);
416
365 if (offset != 0) 417 if (offset != 0)
366 return; 418 return;
367 /* Cancel any unstarted writes on this page */ 419 /* Cancel any unstarted writes on this page */
@@ -370,13 +422,20 @@ static void nfs_invalidate_page(struct page *page, unsigned long offset)
370 422
371static int nfs_release_page(struct page *page, gfp_t gfp) 423static int nfs_release_page(struct page *page, gfp_t gfp)
372{ 424{
425 dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);
426
373 /* If PagePrivate() is set, then the page is not freeable */ 427 /* If PagePrivate() is set, then the page is not freeable */
374 return 0; 428 return 0;
375} 429}
376 430
377static int nfs_launder_page(struct page *page) 431static int nfs_launder_page(struct page *page)
378{ 432{
379 return nfs_wb_page(page->mapping->host, page); 433 struct inode *inode = page->mapping->host;
434
435 dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
436 inode->i_ino, (long long)page_offset(page));
437
438 return nfs_wb_page(inode, page);
380} 439}
381 440
382const struct address_space_operations nfs_file_aops = { 441const struct address_space_operations nfs_file_aops = {
@@ -396,13 +455,19 @@ const struct address_space_operations nfs_file_aops = {
396static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct page *page) 455static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct page *page)
397{ 456{
398 struct file *filp = vma->vm_file; 457 struct file *filp = vma->vm_file;
458 struct dentry *dentry = filp->f_path.dentry;
399 unsigned pagelen; 459 unsigned pagelen;
400 int ret = -EINVAL; 460 int ret = -EINVAL;
401 struct address_space *mapping; 461 struct address_space *mapping;
402 462
463 dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n",
464 dentry->d_parent->d_name.name, dentry->d_name.name,
465 filp->f_mapping->host->i_ino,
466 (long long)page_offset(page));
467
403 lock_page(page); 468 lock_page(page);
404 mapping = page->mapping; 469 mapping = page->mapping;
405 if (mapping != vma->vm_file->f_path.dentry->d_inode->i_mapping) 470 if (mapping != dentry->d_inode->i_mapping)
406 goto out_unlock; 471 goto out_unlock;
407 472
408 ret = 0; 473 ret = 0;
@@ -450,9 +515,9 @@ static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
450 if (iocb->ki_filp->f_flags & O_DIRECT) 515 if (iocb->ki_filp->f_flags & O_DIRECT)
451 return nfs_file_direct_write(iocb, iov, nr_segs, pos); 516 return nfs_file_direct_write(iocb, iov, nr_segs, pos);
452 517
453 dfprintk(VFS, "nfs: write(%s/%s(%ld), %lu@%Ld)\n", 518 dprintk("NFS: write(%s/%s, %lu@%Ld)\n",
454 dentry->d_parent->d_name.name, dentry->d_name.name, 519 dentry->d_parent->d_name.name, dentry->d_name.name,
455 inode->i_ino, (unsigned long) count, (long long) pos); 520 (unsigned long) count, (long long) pos);
456 521
457 result = -EBUSY; 522 result = -EBUSY;
458 if (IS_SWAPFILE(inode)) 523 if (IS_SWAPFILE(inode))
@@ -586,7 +651,8 @@ static int do_setlk(struct file *filp, int cmd, struct file_lock *fl)
586 * This makes locking act as a cache coherency point. 651 * This makes locking act as a cache coherency point.
587 */ 652 */
588 nfs_sync_mapping(filp->f_mapping); 653 nfs_sync_mapping(filp->f_mapping);
589 nfs_zap_caches(inode); 654 if (!nfs_have_delegation(inode, FMODE_READ))
655 nfs_zap_caches(inode);
590out: 656out:
591 return status; 657 return status;
592} 658}
@@ -596,23 +662,35 @@ out:
596 */ 662 */
597static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl) 663static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
598{ 664{
599 struct inode * inode = filp->f_mapping->host; 665 struct inode *inode = filp->f_mapping->host;
666 int ret = -ENOLCK;
600 667
601 dprintk("NFS: nfs_lock(f=%s/%ld, t=%x, fl=%x, r=%Ld:%Ld)\n", 668 dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n",
602 inode->i_sb->s_id, inode->i_ino, 669 filp->f_path.dentry->d_parent->d_name.name,
670 filp->f_path.dentry->d_name.name,
603 fl->fl_type, fl->fl_flags, 671 fl->fl_type, fl->fl_flags,
604 (long long)fl->fl_start, (long long)fl->fl_end); 672 (long long)fl->fl_start, (long long)fl->fl_end);
673
605 nfs_inc_stats(inode, NFSIOS_VFSLOCK); 674 nfs_inc_stats(inode, NFSIOS_VFSLOCK);
606 675
607 /* No mandatory locks over NFS */ 676 /* No mandatory locks over NFS */
608 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK) 677 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
609 return -ENOLCK; 678 goto out_err;
679
680 if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
681 ret = NFS_PROTO(inode)->lock_check_bounds(fl);
682 if (ret < 0)
683 goto out_err;
684 }
610 685
611 if (IS_GETLK(cmd)) 686 if (IS_GETLK(cmd))
612 return do_getlk(filp, cmd, fl); 687 ret = do_getlk(filp, cmd, fl);
613 if (fl->fl_type == F_UNLCK) 688 else if (fl->fl_type == F_UNLCK)
614 return do_unlk(filp, cmd, fl); 689 ret = do_unlk(filp, cmd, fl);
615 return do_setlk(filp, cmd, fl); 690 else
691 ret = do_setlk(filp, cmd, fl);
692out_err:
693 return ret;
616} 694}
617 695
618/* 696/*
@@ -620,9 +698,9 @@ static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
620 */ 698 */
621static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl) 699static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
622{ 700{
623 dprintk("NFS: nfs_flock(f=%s/%ld, t=%x, fl=%x)\n", 701 dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n",
624 filp->f_path.dentry->d_inode->i_sb->s_id, 702 filp->f_path.dentry->d_parent->d_name.name,
625 filp->f_path.dentry->d_inode->i_ino, 703 filp->f_path.dentry->d_name.name,
626 fl->fl_type, fl->fl_flags); 704 fl->fl_type, fl->fl_flags);
627 705
628 /* 706 /*
@@ -645,12 +723,15 @@ static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
645 return do_setlk(filp, cmd, fl); 723 return do_setlk(filp, cmd, fl);
646} 724}
647 725
726/*
727 * There is no protocol support for leases, so we have no way to implement
728 * them correctly in the face of opens by other clients.
729 */
648static int nfs_setlease(struct file *file, long arg, struct file_lock **fl) 730static int nfs_setlease(struct file *file, long arg, struct file_lock **fl)
649{ 731{
650 /* 732 dprintk("NFS: setlease(%s/%s, arg=%ld)\n",
651 * There is no protocol support for leases, so we have no way 733 file->f_path.dentry->d_parent->d_name.name,
652 * to implement them correctly in the face of opens by other 734 file->f_path.dentry->d_name.name, arg);
653 * clients. 735
654 */
655 return -EINVAL; 736 return -EINVAL;
656} 737}
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 596c5d8e86f4..2c23d067e2a6 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -57,8 +57,6 @@ static int enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
57static void nfs_invalidate_inode(struct inode *); 57static void nfs_invalidate_inode(struct inode *);
58static int nfs_update_inode(struct inode *, struct nfs_fattr *); 58static int nfs_update_inode(struct inode *, struct nfs_fattr *);
59 59
60static void nfs_zap_acl_cache(struct inode *);
61
62static struct kmem_cache * nfs_inode_cachep; 60static struct kmem_cache * nfs_inode_cachep;
63 61
64static inline unsigned long 62static inline unsigned long
@@ -167,7 +165,7 @@ void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
167 } 165 }
168} 166}
169 167
170static void nfs_zap_acl_cache(struct inode *inode) 168void nfs_zap_acl_cache(struct inode *inode)
171{ 169{
172 void (*clear_acl_cache)(struct inode *); 170 void (*clear_acl_cache)(struct inode *);
173 171
@@ -347,7 +345,7 @@ out_no_inode:
347 goto out; 345 goto out;
348} 346}
349 347
350#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET) 348#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE)
351 349
352int 350int
353nfs_setattr(struct dentry *dentry, struct iattr *attr) 351nfs_setattr(struct dentry *dentry, struct iattr *attr)
@@ -369,7 +367,7 @@ nfs_setattr(struct dentry *dentry, struct iattr *attr)
369 367
370 /* Optimization: if the end result is no change, don't RPC */ 368 /* Optimization: if the end result is no change, don't RPC */
371 attr->ia_valid &= NFS_VALID_ATTRS; 369 attr->ia_valid &= NFS_VALID_ATTRS;
372 if (attr->ia_valid == 0) 370 if ((attr->ia_valid & ~ATTR_FILE) == 0)
373 return 0; 371 return 0;
374 372
375 lock_kernel(); 373 lock_kernel();
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 04ae867dddba..24241fcbb98d 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -150,6 +150,7 @@ extern void nfs_clear_inode(struct inode *);
150#ifdef CONFIG_NFS_V4 150#ifdef CONFIG_NFS_V4
151extern void nfs4_clear_inode(struct inode *); 151extern void nfs4_clear_inode(struct inode *);
152#endif 152#endif
153void nfs_zap_acl_cache(struct inode *inode);
153 154
154/* super.c */ 155/* super.c */
155extern struct file_system_type nfs_xdev_fs_type; 156extern struct file_system_type nfs_xdev_fs_type;
diff --git a/fs/nfs/iostat.h b/fs/nfs/iostat.h
index 6350ecbde589..a36952810032 100644
--- a/fs/nfs/iostat.h
+++ b/fs/nfs/iostat.h
@@ -5,135 +5,41 @@
5 * 5 *
6 * Copyright (C) 2005, 2006 Chuck Lever <cel@netapp.com> 6 * Copyright (C) 2005, 2006 Chuck Lever <cel@netapp.com>
7 * 7 *
8 * NFS client per-mount statistics provide information about the health of
9 * the NFS client and the health of each NFS mount point. Generally these
10 * are not for detailed problem diagnosis, but simply to indicate that there
11 * is a problem.
12 *
13 * These counters are not meant to be human-readable, but are meant to be
14 * integrated into system monitoring tools such as "sar" and "iostat". As
15 * such, the counters are sampled by the tools over time, and are never
16 * zeroed after a file system is mounted. Moving averages can be computed
17 * by the tools by taking the difference between two instantaneous samples
18 * and dividing that by the time between the samples.
19 */ 8 */
20 9
21#ifndef _NFS_IOSTAT 10#ifndef _NFS_IOSTAT
22#define _NFS_IOSTAT 11#define _NFS_IOSTAT
23 12
24#define NFS_IOSTAT_VERS "1.0"
25
26/*
27 * NFS byte counters
28 *
29 * 1. SERVER - the number of payload bytes read from or written to the
30 * server by the NFS client via an NFS READ or WRITE request.
31 *
32 * 2. NORMAL - the number of bytes read or written by applications via
33 * the read(2) and write(2) system call interfaces.
34 *
35 * 3. DIRECT - the number of bytes read or written from files opened
36 * with the O_DIRECT flag.
37 *
38 * These counters give a view of the data throughput into and out of the NFS
39 * client. Comparing the number of bytes requested by an application with the
40 * number of bytes the client requests from the server can provide an
41 * indication of client efficiency (per-op, cache hits, etc).
42 *
43 * These counters can also help characterize which access methods are in
44 * use. DIRECT by itself shows whether there is any O_DIRECT traffic.
45 * NORMAL + DIRECT shows how much data is going through the system call
46 * interface. A large amount of SERVER traffic without much NORMAL or
47 * DIRECT traffic shows that applications are using mapped files.
48 *
49 * NFS page counters
50 *
51 * These count the number of pages read or written via nfs_readpage(),
52 * nfs_readpages(), or their write equivalents.
53 */
54enum nfs_stat_bytecounters {
55 NFSIOS_NORMALREADBYTES = 0,
56 NFSIOS_NORMALWRITTENBYTES,
57 NFSIOS_DIRECTREADBYTES,
58 NFSIOS_DIRECTWRITTENBYTES,
59 NFSIOS_SERVERREADBYTES,
60 NFSIOS_SERVERWRITTENBYTES,
61 NFSIOS_READPAGES,
62 NFSIOS_WRITEPAGES,
63 __NFSIOS_BYTESMAX,
64};
65
66/*
67 * NFS event counters
68 *
69 * These counters provide a low-overhead way of monitoring client activity
70 * without enabling NFS trace debugging. The counters show the rate at
71 * which VFS requests are made, and how often the client invalidates its
72 * data and attribute caches. This allows system administrators to monitor
73 * such things as how close-to-open is working, and answer questions such
74 * as "why are there so many GETATTR requests on the wire?"
75 *
76 * They also count anamolous events such as short reads and writes, silly
77 * renames due to close-after-delete, and operations that change the size
78 * of a file (such operations can often be the source of data corruption
79 * if applications aren't using file locking properly).
80 */
81enum nfs_stat_eventcounters {
82 NFSIOS_INODEREVALIDATE = 0,
83 NFSIOS_DENTRYREVALIDATE,
84 NFSIOS_DATAINVALIDATE,
85 NFSIOS_ATTRINVALIDATE,
86 NFSIOS_VFSOPEN,
87 NFSIOS_VFSLOOKUP,
88 NFSIOS_VFSACCESS,
89 NFSIOS_VFSUPDATEPAGE,
90 NFSIOS_VFSREADPAGE,
91 NFSIOS_VFSREADPAGES,
92 NFSIOS_VFSWRITEPAGE,
93 NFSIOS_VFSWRITEPAGES,
94 NFSIOS_VFSGETDENTS,
95 NFSIOS_VFSSETATTR,
96 NFSIOS_VFSFLUSH,
97 NFSIOS_VFSFSYNC,
98 NFSIOS_VFSLOCK,
99 NFSIOS_VFSRELEASE,
100 NFSIOS_CONGESTIONWAIT,
101 NFSIOS_SETATTRTRUNC,
102 NFSIOS_EXTENDWRITE,
103 NFSIOS_SILLYRENAME,
104 NFSIOS_SHORTREAD,
105 NFSIOS_SHORTWRITE,
106 NFSIOS_DELAY,
107 __NFSIOS_COUNTSMAX,
108};
109
110#ifdef __KERNEL__
111
112#include <linux/percpu.h> 13#include <linux/percpu.h>
113#include <linux/cache.h> 14#include <linux/cache.h>
15#include <linux/nfs_iostat.h>
114 16
115struct nfs_iostats { 17struct nfs_iostats {
116 unsigned long long bytes[__NFSIOS_BYTESMAX]; 18 unsigned long long bytes[__NFSIOS_BYTESMAX];
117 unsigned long events[__NFSIOS_COUNTSMAX]; 19 unsigned long events[__NFSIOS_COUNTSMAX];
118} ____cacheline_aligned; 20} ____cacheline_aligned;
119 21
120static inline void nfs_inc_server_stats(struct nfs_server *server, enum nfs_stat_eventcounters stat) 22static inline void nfs_inc_server_stats(const struct nfs_server *server,
23 enum nfs_stat_eventcounters stat)
121{ 24{
122 struct nfs_iostats *iostats; 25 struct nfs_iostats *iostats;
123 int cpu; 26 int cpu;
124 27
125 cpu = get_cpu(); 28 cpu = get_cpu();
126 iostats = per_cpu_ptr(server->io_stats, cpu); 29 iostats = per_cpu_ptr(server->io_stats, cpu);
127 iostats->events[stat] ++; 30 iostats->events[stat]++;
128 put_cpu_no_resched(); 31 put_cpu_no_resched();
129} 32}
130 33
131static inline void nfs_inc_stats(struct inode *inode, enum nfs_stat_eventcounters stat) 34static inline void nfs_inc_stats(const struct inode *inode,
35 enum nfs_stat_eventcounters stat)
132{ 36{
133 nfs_inc_server_stats(NFS_SERVER(inode), stat); 37 nfs_inc_server_stats(NFS_SERVER(inode), stat);
134} 38}
135 39
136static inline void nfs_add_server_stats(struct nfs_server *server, enum nfs_stat_bytecounters stat, unsigned long addend) 40static inline void nfs_add_server_stats(const struct nfs_server *server,
41 enum nfs_stat_bytecounters stat,
42 unsigned long addend)
137{ 43{
138 struct nfs_iostats *iostats; 44 struct nfs_iostats *iostats;
139 int cpu; 45 int cpu;
@@ -144,7 +50,9 @@ static inline void nfs_add_server_stats(struct nfs_server *server, enum nfs_stat
144 put_cpu_no_resched(); 50 put_cpu_no_resched();
145} 51}
146 52
147static inline void nfs_add_stats(struct inode *inode, enum nfs_stat_bytecounters stat, unsigned long addend) 53static inline void nfs_add_stats(const struct inode *inode,
54 enum nfs_stat_bytecounters stat,
55 unsigned long addend)
148{ 56{
149 nfs_add_server_stats(NFS_SERVER(inode), stat, addend); 57 nfs_add_server_stats(NFS_SERVER(inode), stat, addend);
150} 58}
@@ -160,5 +68,4 @@ static inline void nfs_free_iostats(struct nfs_iostats *stats)
160 free_percpu(stats); 68 free_percpu(stats);
161} 69}
162 70
163#endif 71#endif /* _NFS_IOSTAT */
164#endif
diff --git a/fs/nfs/nfs3acl.c b/fs/nfs/nfs3acl.c
index 9b7362565c0c..423842f51ac9 100644
--- a/fs/nfs/nfs3acl.c
+++ b/fs/nfs/nfs3acl.c
@@ -5,6 +5,8 @@
5#include <linux/posix_acl_xattr.h> 5#include <linux/posix_acl_xattr.h>
6#include <linux/nfsacl.h> 6#include <linux/nfsacl.h>
7 7
8#include "internal.h"
9
8#define NFSDBG_FACILITY NFSDBG_PROC 10#define NFSDBG_FACILITY NFSDBG_PROC
9 11
10ssize_t nfs3_listxattr(struct dentry *dentry, char *buffer, size_t size) 12ssize_t nfs3_listxattr(struct dentry *dentry, char *buffer, size_t size)
@@ -205,6 +207,8 @@ struct posix_acl *nfs3_proc_getacl(struct inode *inode, int type)
205 status = nfs_revalidate_inode(server, inode); 207 status = nfs_revalidate_inode(server, inode);
206 if (status < 0) 208 if (status < 0)
207 return ERR_PTR(status); 209 return ERR_PTR(status);
210 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
211 nfs_zap_acl_cache(inode);
208 acl = nfs3_get_cached_acl(inode, type); 212 acl = nfs3_get_cached_acl(inode, type);
209 if (acl != ERR_PTR(-EAGAIN)) 213 if (acl != ERR_PTR(-EAGAIN))
210 return acl; 214 return acl;
@@ -319,9 +323,8 @@ static int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
319 dprintk("NFS call setacl\n"); 323 dprintk("NFS call setacl\n");
320 msg.rpc_proc = &server->client_acl->cl_procinfo[ACLPROC3_SETACL]; 324 msg.rpc_proc = &server->client_acl->cl_procinfo[ACLPROC3_SETACL];
321 status = rpc_call_sync(server->client_acl, &msg, 0); 325 status = rpc_call_sync(server->client_acl, &msg, 0);
322 spin_lock(&inode->i_lock); 326 nfs_access_zap_cache(inode);
323 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS; 327 nfs_zap_acl_cache(inode);
324 spin_unlock(&inode->i_lock);
325 dprintk("NFS reply setacl: %d\n", status); 328 dprintk("NFS reply setacl: %d\n", status);
326 329
327 /* pages may have been allocated at the xdr layer. */ 330 /* pages may have been allocated at the xdr layer. */
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index c3523ad03ed1..1e750e4574a9 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -129,6 +129,8 @@ nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
129 int status; 129 int status;
130 130
131 dprintk("NFS call setattr\n"); 131 dprintk("NFS call setattr\n");
132 if (sattr->ia_valid & ATTR_FILE)
133 msg.rpc_cred = nfs_file_cred(sattr->ia_file);
132 nfs_fattr_init(fattr); 134 nfs_fattr_init(fattr);
133 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 135 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
134 if (status == 0) 136 if (status == 0)
@@ -248,6 +250,53 @@ static int nfs3_proc_readlink(struct inode *inode, struct page *page,
248 return status; 250 return status;
249} 251}
250 252
253struct nfs3_createdata {
254 struct rpc_message msg;
255 union {
256 struct nfs3_createargs create;
257 struct nfs3_mkdirargs mkdir;
258 struct nfs3_symlinkargs symlink;
259 struct nfs3_mknodargs mknod;
260 } arg;
261 struct nfs3_diropres res;
262 struct nfs_fh fh;
263 struct nfs_fattr fattr;
264 struct nfs_fattr dir_attr;
265};
266
267static struct nfs3_createdata *nfs3_alloc_createdata(void)
268{
269 struct nfs3_createdata *data;
270
271 data = kzalloc(sizeof(*data), GFP_KERNEL);
272 if (data != NULL) {
273 data->msg.rpc_argp = &data->arg;
274 data->msg.rpc_resp = &data->res;
275 data->res.fh = &data->fh;
276 data->res.fattr = &data->fattr;
277 data->res.dir_attr = &data->dir_attr;
278 nfs_fattr_init(data->res.fattr);
279 nfs_fattr_init(data->res.dir_attr);
280 }
281 return data;
282}
283
284static int nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data)
285{
286 int status;
287
288 status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
289 nfs_post_op_update_inode(dir, data->res.dir_attr);
290 if (status == 0)
291 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
292 return status;
293}
294
295static void nfs3_free_createdata(struct nfs3_createdata *data)
296{
297 kfree(data);
298}
299
251/* 300/*
252 * Create a regular file. 301 * Create a regular file.
253 * For now, we don't implement O_EXCL. 302 * For now, we don't implement O_EXCL.
@@ -256,70 +305,60 @@ static int
256nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 305nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
257 int flags, struct nameidata *nd) 306 int flags, struct nameidata *nd)
258{ 307{
259 struct nfs_fh fhandle; 308 struct nfs3_createdata *data;
260 struct nfs_fattr fattr;
261 struct nfs_fattr dir_attr;
262 struct nfs3_createargs arg = {
263 .fh = NFS_FH(dir),
264 .name = dentry->d_name.name,
265 .len = dentry->d_name.len,
266 .sattr = sattr,
267 };
268 struct nfs3_diropres res = {
269 .dir_attr = &dir_attr,
270 .fh = &fhandle,
271 .fattr = &fattr
272 };
273 struct rpc_message msg = {
274 .rpc_proc = &nfs3_procedures[NFS3PROC_CREATE],
275 .rpc_argp = &arg,
276 .rpc_resp = &res,
277 };
278 mode_t mode = sattr->ia_mode; 309 mode_t mode = sattr->ia_mode;
279 int status; 310 int status = -ENOMEM;
280 311
281 dprintk("NFS call create %s\n", dentry->d_name.name); 312 dprintk("NFS call create %s\n", dentry->d_name.name);
282 arg.createmode = NFS3_CREATE_UNCHECKED; 313
314 data = nfs3_alloc_createdata();
315 if (data == NULL)
316 goto out;
317
318 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE];
319 data->arg.create.fh = NFS_FH(dir);
320 data->arg.create.name = dentry->d_name.name;
321 data->arg.create.len = dentry->d_name.len;
322 data->arg.create.sattr = sattr;
323
324 data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
283 if (flags & O_EXCL) { 325 if (flags & O_EXCL) {
284 arg.createmode = NFS3_CREATE_EXCLUSIVE; 326 data->arg.create.createmode = NFS3_CREATE_EXCLUSIVE;
285 arg.verifier[0] = jiffies; 327 data->arg.create.verifier[0] = jiffies;
286 arg.verifier[1] = current->pid; 328 data->arg.create.verifier[1] = current->pid;
287 } 329 }
288 330
289 sattr->ia_mode &= ~current->fs->umask; 331 sattr->ia_mode &= ~current->fs->umask;
290 332
291again: 333 for (;;) {
292 nfs_fattr_init(&dir_attr); 334 status = nfs3_do_create(dir, dentry, data);
293 nfs_fattr_init(&fattr);
294 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
295 nfs_refresh_inode(dir, &dir_attr);
296 335
297 /* If the server doesn't support the exclusive creation semantics, 336 if (status != -ENOTSUPP)
298 * try again with simple 'guarded' mode. */ 337 break;
299 if (status == -ENOTSUPP) { 338 /* If the server doesn't support the exclusive creation
300 switch (arg.createmode) { 339 * semantics, try again with simple 'guarded' mode. */
340 switch (data->arg.create.createmode) {
301 case NFS3_CREATE_EXCLUSIVE: 341 case NFS3_CREATE_EXCLUSIVE:
302 arg.createmode = NFS3_CREATE_GUARDED; 342 data->arg.create.createmode = NFS3_CREATE_GUARDED;
303 break; 343 break;
304 344
305 case NFS3_CREATE_GUARDED: 345 case NFS3_CREATE_GUARDED:
306 arg.createmode = NFS3_CREATE_UNCHECKED; 346 data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
307 break; 347 break;
308 348
309 case NFS3_CREATE_UNCHECKED: 349 case NFS3_CREATE_UNCHECKED:
310 goto out; 350 goto out;
311 } 351 }
312 goto again; 352 nfs_fattr_init(data->res.dir_attr);
353 nfs_fattr_init(data->res.fattr);
313 } 354 }
314 355
315 if (status == 0)
316 status = nfs_instantiate(dentry, &fhandle, &fattr);
317 if (status != 0) 356 if (status != 0)
318 goto out; 357 goto out;
319 358
320 /* When we created the file with exclusive semantics, make 359 /* When we created the file with exclusive semantics, make
321 * sure we set the attributes afterwards. */ 360 * sure we set the attributes afterwards. */
322 if (arg.createmode == NFS3_CREATE_EXCLUSIVE) { 361 if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) {
323 dprintk("NFS call setattr (post-create)\n"); 362 dprintk("NFS call setattr (post-create)\n");
324 363
325 if (!(sattr->ia_valid & ATTR_ATIME_SET)) 364 if (!(sattr->ia_valid & ATTR_ATIME_SET))
@@ -330,14 +369,15 @@ again:
330 /* Note: we could use a guarded setattr here, but I'm 369 /* Note: we could use a guarded setattr here, but I'm
331 * not sure this buys us anything (and I'd have 370 * not sure this buys us anything (and I'd have
332 * to revamp the NFSv3 XDR code) */ 371 * to revamp the NFSv3 XDR code) */
333 status = nfs3_proc_setattr(dentry, &fattr, sattr); 372 status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
334 nfs_post_op_update_inode(dentry->d_inode, &fattr); 373 nfs_post_op_update_inode(dentry->d_inode, data->res.fattr);
335 dprintk("NFS reply setattr (post-create): %d\n", status); 374 dprintk("NFS reply setattr (post-create): %d\n", status);
375 if (status != 0)
376 goto out;
336 } 377 }
337 if (status != 0)
338 goto out;
339 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 378 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
340out: 379out:
380 nfs3_free_createdata(data);
341 dprintk("NFS reply create: %d\n", status); 381 dprintk("NFS reply create: %d\n", status);
342 return status; 382 return status;
343} 383}
@@ -452,40 +492,28 @@ static int
452nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, 492nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
453 unsigned int len, struct iattr *sattr) 493 unsigned int len, struct iattr *sattr)
454{ 494{
455 struct nfs_fh fhandle; 495 struct nfs3_createdata *data;
456 struct nfs_fattr fattr, dir_attr; 496 int status = -ENOMEM;
457 struct nfs3_symlinkargs arg = {
458 .fromfh = NFS_FH(dir),
459 .fromname = dentry->d_name.name,
460 .fromlen = dentry->d_name.len,
461 .pages = &page,
462 .pathlen = len,
463 .sattr = sattr
464 };
465 struct nfs3_diropres res = {
466 .dir_attr = &dir_attr,
467 .fh = &fhandle,
468 .fattr = &fattr
469 };
470 struct rpc_message msg = {
471 .rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK],
472 .rpc_argp = &arg,
473 .rpc_resp = &res,
474 };
475 int status;
476 497
477 if (len > NFS3_MAXPATHLEN) 498 if (len > NFS3_MAXPATHLEN)
478 return -ENAMETOOLONG; 499 return -ENAMETOOLONG;
479 500
480 dprintk("NFS call symlink %s\n", dentry->d_name.name); 501 dprintk("NFS call symlink %s\n", dentry->d_name.name);
481 502
482 nfs_fattr_init(&dir_attr); 503 data = nfs3_alloc_createdata();
483 nfs_fattr_init(&fattr); 504 if (data == NULL)
484 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
485 nfs_post_op_update_inode(dir, &dir_attr);
486 if (status != 0)
487 goto out; 505 goto out;
488 status = nfs_instantiate(dentry, &fhandle, &fattr); 506 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK];
507 data->arg.symlink.fromfh = NFS_FH(dir);
508 data->arg.symlink.fromname = dentry->d_name.name;
509 data->arg.symlink.fromlen = dentry->d_name.len;
510 data->arg.symlink.pages = &page;
511 data->arg.symlink.pathlen = len;
512 data->arg.symlink.sattr = sattr;
513
514 status = nfs3_do_create(dir, dentry, data);
515
516 nfs3_free_createdata(data);
489out: 517out:
490 dprintk("NFS reply symlink: %d\n", status); 518 dprintk("NFS reply symlink: %d\n", status);
491 return status; 519 return status;
@@ -494,42 +522,31 @@ out:
494static int 522static int
495nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) 523nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
496{ 524{
497 struct nfs_fh fhandle; 525 struct nfs3_createdata *data;
498 struct nfs_fattr fattr, dir_attr;
499 struct nfs3_mkdirargs arg = {
500 .fh = NFS_FH(dir),
501 .name = dentry->d_name.name,
502 .len = dentry->d_name.len,
503 .sattr = sattr
504 };
505 struct nfs3_diropres res = {
506 .dir_attr = &dir_attr,
507 .fh = &fhandle,
508 .fattr = &fattr
509 };
510 struct rpc_message msg = {
511 .rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR],
512 .rpc_argp = &arg,
513 .rpc_resp = &res,
514 };
515 int mode = sattr->ia_mode; 526 int mode = sattr->ia_mode;
516 int status; 527 int status = -ENOMEM;
517 528
518 dprintk("NFS call mkdir %s\n", dentry->d_name.name); 529 dprintk("NFS call mkdir %s\n", dentry->d_name.name);
519 530
520 sattr->ia_mode &= ~current->fs->umask; 531 sattr->ia_mode &= ~current->fs->umask;
521 532
522 nfs_fattr_init(&dir_attr); 533 data = nfs3_alloc_createdata();
523 nfs_fattr_init(&fattr); 534 if (data == NULL)
524 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
525 nfs_post_op_update_inode(dir, &dir_attr);
526 if (status != 0)
527 goto out; 535 goto out;
528 status = nfs_instantiate(dentry, &fhandle, &fattr); 536
537 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR];
538 data->arg.mkdir.fh = NFS_FH(dir);
539 data->arg.mkdir.name = dentry->d_name.name;
540 data->arg.mkdir.len = dentry->d_name.len;
541 data->arg.mkdir.sattr = sattr;
542
543 status = nfs3_do_create(dir, dentry, data);
529 if (status != 0) 544 if (status != 0)
530 goto out; 545 goto out;
546
531 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 547 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
532out: 548out:
549 nfs3_free_createdata(data);
533 dprintk("NFS reply mkdir: %d\n", status); 550 dprintk("NFS reply mkdir: %d\n", status);
534 return status; 551 return status;
535} 552}
@@ -615,52 +632,50 @@ static int
615nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 632nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
616 dev_t rdev) 633 dev_t rdev)
617{ 634{
618 struct nfs_fh fh; 635 struct nfs3_createdata *data;
619 struct nfs_fattr fattr, dir_attr;
620 struct nfs3_mknodargs arg = {
621 .fh = NFS_FH(dir),
622 .name = dentry->d_name.name,
623 .len = dentry->d_name.len,
624 .sattr = sattr,
625 .rdev = rdev
626 };
627 struct nfs3_diropres res = {
628 .dir_attr = &dir_attr,
629 .fh = &fh,
630 .fattr = &fattr
631 };
632 struct rpc_message msg = {
633 .rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD],
634 .rpc_argp = &arg,
635 .rpc_resp = &res,
636 };
637 mode_t mode = sattr->ia_mode; 636 mode_t mode = sattr->ia_mode;
638 int status; 637 int status = -ENOMEM;
639
640 switch (sattr->ia_mode & S_IFMT) {
641 case S_IFBLK: arg.type = NF3BLK; break;
642 case S_IFCHR: arg.type = NF3CHR; break;
643 case S_IFIFO: arg.type = NF3FIFO; break;
644 case S_IFSOCK: arg.type = NF3SOCK; break;
645 default: return -EINVAL;
646 }
647 638
648 dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name, 639 dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name,
649 MAJOR(rdev), MINOR(rdev)); 640 MAJOR(rdev), MINOR(rdev));
650 641
651 sattr->ia_mode &= ~current->fs->umask; 642 sattr->ia_mode &= ~current->fs->umask;
652 643
653 nfs_fattr_init(&dir_attr); 644 data = nfs3_alloc_createdata();
654 nfs_fattr_init(&fattr); 645 if (data == NULL)
655 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
656 nfs_post_op_update_inode(dir, &dir_attr);
657 if (status != 0)
658 goto out; 646 goto out;
659 status = nfs_instantiate(dentry, &fh, &fattr); 647
648 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD];
649 data->arg.mknod.fh = NFS_FH(dir);
650 data->arg.mknod.name = dentry->d_name.name;
651 data->arg.mknod.len = dentry->d_name.len;
652 data->arg.mknod.sattr = sattr;
653 data->arg.mknod.rdev = rdev;
654
655 switch (sattr->ia_mode & S_IFMT) {
656 case S_IFBLK:
657 data->arg.mknod.type = NF3BLK;
658 break;
659 case S_IFCHR:
660 data->arg.mknod.type = NF3CHR;
661 break;
662 case S_IFIFO:
663 data->arg.mknod.type = NF3FIFO;
664 break;
665 case S_IFSOCK:
666 data->arg.mknod.type = NF3SOCK;
667 break;
668 default:
669 status = -EINVAL;
670 goto out;
671 }
672
673 status = nfs3_do_create(dir, dentry, data);
660 if (status != 0) 674 if (status != 0)
661 goto out; 675 goto out;
662 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 676 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
663out: 677out:
678 nfs3_free_createdata(data);
664 dprintk("NFS reply mknod: %d\n", status); 679 dprintk("NFS reply mknod: %d\n", status);
665 return status; 680 return status;
666} 681}
@@ -801,8 +816,6 @@ const struct nfs_rpc_ops nfs_v3_clientops = {
801 .write_done = nfs3_write_done, 816 .write_done = nfs3_write_done,
802 .commit_setup = nfs3_proc_commit_setup, 817 .commit_setup = nfs3_proc_commit_setup,
803 .commit_done = nfs3_commit_done, 818 .commit_done = nfs3_commit_done,
804 .file_open = nfs_open,
805 .file_release = nfs_release,
806 .lock = nfs3_proc_lock, 819 .lock = nfs3_proc_lock,
807 .clear_acl_cache = nfs3_forget_cached_acls, 820 .clear_acl_cache = nfs3_forget_cached_acls,
808}; 821};
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 1293e0acd82b..4451287a81d1 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -1139,8 +1139,9 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir, struct path *path, int
1139 return res; 1139 return res;
1140} 1140}
1141 1141
1142static int _nfs4_do_setattr(struct inode *inode, struct nfs_fattr *fattr, 1142static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
1143 struct iattr *sattr, struct nfs4_state *state) 1143 struct nfs_fattr *fattr, struct iattr *sattr,
1144 struct nfs4_state *state)
1144{ 1145{
1145 struct nfs_server *server = NFS_SERVER(inode); 1146 struct nfs_server *server = NFS_SERVER(inode);
1146 struct nfs_setattrargs arg = { 1147 struct nfs_setattrargs arg = {
@@ -1154,9 +1155,10 @@ static int _nfs4_do_setattr(struct inode *inode, struct nfs_fattr *fattr,
1154 .server = server, 1155 .server = server,
1155 }; 1156 };
1156 struct rpc_message msg = { 1157 struct rpc_message msg = {
1157 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR], 1158 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
1158 .rpc_argp = &arg, 1159 .rpc_argp = &arg,
1159 .rpc_resp = &res, 1160 .rpc_resp = &res,
1161 .rpc_cred = cred,
1160 }; 1162 };
1161 unsigned long timestamp = jiffies; 1163 unsigned long timestamp = jiffies;
1162 int status; 1164 int status;
@@ -1166,7 +1168,6 @@ static int _nfs4_do_setattr(struct inode *inode, struct nfs_fattr *fattr,
1166 if (nfs4_copy_delegation_stateid(&arg.stateid, inode)) { 1168 if (nfs4_copy_delegation_stateid(&arg.stateid, inode)) {
1167 /* Use that stateid */ 1169 /* Use that stateid */
1168 } else if (state != NULL) { 1170 } else if (state != NULL) {
1169 msg.rpc_cred = state->owner->so_cred;
1170 nfs4_copy_stateid(&arg.stateid, state, current->files); 1171 nfs4_copy_stateid(&arg.stateid, state, current->files);
1171 } else 1172 } else
1172 memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid)); 1173 memcpy(&arg.stateid, &zero_stateid, sizeof(arg.stateid));
@@ -1177,15 +1178,16 @@ static int _nfs4_do_setattr(struct inode *inode, struct nfs_fattr *fattr,
1177 return status; 1178 return status;
1178} 1179}
1179 1180
1180static int nfs4_do_setattr(struct inode *inode, struct nfs_fattr *fattr, 1181static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
1181 struct iattr *sattr, struct nfs4_state *state) 1182 struct nfs_fattr *fattr, struct iattr *sattr,
1183 struct nfs4_state *state)
1182{ 1184{
1183 struct nfs_server *server = NFS_SERVER(inode); 1185 struct nfs_server *server = NFS_SERVER(inode);
1184 struct nfs4_exception exception = { }; 1186 struct nfs4_exception exception = { };
1185 int err; 1187 int err;
1186 do { 1188 do {
1187 err = nfs4_handle_exception(server, 1189 err = nfs4_handle_exception(server,
1188 _nfs4_do_setattr(inode, fattr, sattr, state), 1190 _nfs4_do_setattr(inode, cred, fattr, sattr, state),
1189 &exception); 1191 &exception);
1190 } while (exception.retry); 1192 } while (exception.retry);
1191 return err; 1193 return err;
@@ -1647,29 +1649,25 @@ static int
1647nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 1649nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
1648 struct iattr *sattr) 1650 struct iattr *sattr)
1649{ 1651{
1650 struct rpc_cred *cred;
1651 struct inode *inode = dentry->d_inode; 1652 struct inode *inode = dentry->d_inode;
1652 struct nfs_open_context *ctx; 1653 struct rpc_cred *cred = NULL;
1653 struct nfs4_state *state = NULL; 1654 struct nfs4_state *state = NULL;
1654 int status; 1655 int status;
1655 1656
1656 nfs_fattr_init(fattr); 1657 nfs_fattr_init(fattr);
1657 1658
1658 cred = rpc_lookup_cred();
1659 if (IS_ERR(cred))
1660 return PTR_ERR(cred);
1661
1662 /* Search for an existing open(O_WRITE) file */ 1659 /* Search for an existing open(O_WRITE) file */
1663 ctx = nfs_find_open_context(inode, cred, FMODE_WRITE); 1660 if (sattr->ia_valid & ATTR_FILE) {
1664 if (ctx != NULL) 1661 struct nfs_open_context *ctx;
1662
1663 ctx = nfs_file_open_context(sattr->ia_file);
1664 cred = ctx->cred;
1665 state = ctx->state; 1665 state = ctx->state;
1666 }
1666 1667
1667 status = nfs4_do_setattr(inode, fattr, sattr, state); 1668 status = nfs4_do_setattr(inode, cred, fattr, sattr, state);
1668 if (status == 0) 1669 if (status == 0)
1669 nfs_setattr_update_inode(inode, sattr); 1670 nfs_setattr_update_inode(inode, sattr);
1670 if (ctx != NULL)
1671 put_nfs_open_context(ctx);
1672 put_rpccred(cred);
1673 return status; 1671 return status;
1674} 1672}
1675 1673
@@ -1897,17 +1895,16 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
1897 goto out; 1895 goto out;
1898 } 1896 }
1899 state = nfs4_do_open(dir, &path, flags, sattr, cred); 1897 state = nfs4_do_open(dir, &path, flags, sattr, cred);
1900 put_rpccred(cred);
1901 d_drop(dentry); 1898 d_drop(dentry);
1902 if (IS_ERR(state)) { 1899 if (IS_ERR(state)) {
1903 status = PTR_ERR(state); 1900 status = PTR_ERR(state);
1904 goto out; 1901 goto out_putcred;
1905 } 1902 }
1906 d_add(dentry, igrab(state->inode)); 1903 d_add(dentry, igrab(state->inode));
1907 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 1904 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1908 if (flags & O_EXCL) { 1905 if (flags & O_EXCL) {
1909 struct nfs_fattr fattr; 1906 struct nfs_fattr fattr;
1910 status = nfs4_do_setattr(state->inode, &fattr, sattr, state); 1907 status = nfs4_do_setattr(state->inode, cred, &fattr, sattr, state);
1911 if (status == 0) 1908 if (status == 0)
1912 nfs_setattr_update_inode(state->inode, sattr); 1909 nfs_setattr_update_inode(state->inode, sattr);
1913 nfs_post_op_update_inode(state->inode, &fattr); 1910 nfs_post_op_update_inode(state->inode, &fattr);
@@ -1916,6 +1913,8 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
1916 status = nfs4_intent_set_file(nd, &path, state); 1913 status = nfs4_intent_set_file(nd, &path, state);
1917 else 1914 else
1918 nfs4_close_sync(&path, state, flags); 1915 nfs4_close_sync(&path, state, flags);
1916out_putcred:
1917 put_rpccred(cred);
1919out: 1918out:
1920 return status; 1919 return status;
1921} 1920}
@@ -2079,47 +2078,81 @@ static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *n
2079 return err; 2078 return err;
2080} 2079}
2081 2080
2081struct nfs4_createdata {
2082 struct rpc_message msg;
2083 struct nfs4_create_arg arg;
2084 struct nfs4_create_res res;
2085 struct nfs_fh fh;
2086 struct nfs_fattr fattr;
2087 struct nfs_fattr dir_fattr;
2088};
2089
2090static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
2091 struct qstr *name, struct iattr *sattr, u32 ftype)
2092{
2093 struct nfs4_createdata *data;
2094
2095 data = kzalloc(sizeof(*data), GFP_KERNEL);
2096 if (data != NULL) {
2097 struct nfs_server *server = NFS_SERVER(dir);
2098
2099 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
2100 data->msg.rpc_argp = &data->arg;
2101 data->msg.rpc_resp = &data->res;
2102 data->arg.dir_fh = NFS_FH(dir);
2103 data->arg.server = server;
2104 data->arg.name = name;
2105 data->arg.attrs = sattr;
2106 data->arg.ftype = ftype;
2107 data->arg.bitmask = server->attr_bitmask;
2108 data->res.server = server;
2109 data->res.fh = &data->fh;
2110 data->res.fattr = &data->fattr;
2111 data->res.dir_fattr = &data->dir_fattr;
2112 nfs_fattr_init(data->res.fattr);
2113 nfs_fattr_init(data->res.dir_fattr);
2114 }
2115 return data;
2116}
2117
2118static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
2119{
2120 int status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
2121 if (status == 0) {
2122 update_changeattr(dir, &data->res.dir_cinfo);
2123 nfs_post_op_update_inode(dir, data->res.dir_fattr);
2124 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
2125 }
2126 return status;
2127}
2128
2129static void nfs4_free_createdata(struct nfs4_createdata *data)
2130{
2131 kfree(data);
2132}
2133
2082static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry, 2134static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
2083 struct page *page, unsigned int len, struct iattr *sattr) 2135 struct page *page, unsigned int len, struct iattr *sattr)
2084{ 2136{
2085 struct nfs_server *server = NFS_SERVER(dir); 2137 struct nfs4_createdata *data;
2086 struct nfs_fh fhandle; 2138 int status = -ENAMETOOLONG;
2087 struct nfs_fattr fattr, dir_fattr;
2088 struct nfs4_create_arg arg = {
2089 .dir_fh = NFS_FH(dir),
2090 .server = server,
2091 .name = &dentry->d_name,
2092 .attrs = sattr,
2093 .ftype = NF4LNK,
2094 .bitmask = server->attr_bitmask,
2095 };
2096 struct nfs4_create_res res = {
2097 .server = server,
2098 .fh = &fhandle,
2099 .fattr = &fattr,
2100 .dir_fattr = &dir_fattr,
2101 };
2102 struct rpc_message msg = {
2103 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK],
2104 .rpc_argp = &arg,
2105 .rpc_resp = &res,
2106 };
2107 int status;
2108 2139
2109 if (len > NFS4_MAXPATHLEN) 2140 if (len > NFS4_MAXPATHLEN)
2110 return -ENAMETOOLONG; 2141 goto out;
2111 2142
2112 arg.u.symlink.pages = &page; 2143 status = -ENOMEM;
2113 arg.u.symlink.len = len; 2144 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
2114 nfs_fattr_init(&fattr); 2145 if (data == NULL)
2115 nfs_fattr_init(&dir_fattr); 2146 goto out;
2147
2148 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
2149 data->arg.u.symlink.pages = &page;
2150 data->arg.u.symlink.len = len;
2116 2151
2117 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 2152 status = nfs4_do_create(dir, dentry, data);
2118 if (!status) { 2153
2119 update_changeattr(dir, &res.dir_cinfo); 2154 nfs4_free_createdata(data);
2120 nfs_post_op_update_inode(dir, res.dir_fattr); 2155out:
2121 status = nfs_instantiate(dentry, &fhandle, &fattr);
2122 }
2123 return status; 2156 return status;
2124} 2157}
2125 2158
@@ -2140,39 +2173,17 @@ static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
2140static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry, 2173static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
2141 struct iattr *sattr) 2174 struct iattr *sattr)
2142{ 2175{
2143 struct nfs_server *server = NFS_SERVER(dir); 2176 struct nfs4_createdata *data;
2144 struct nfs_fh fhandle; 2177 int status = -ENOMEM;
2145 struct nfs_fattr fattr, dir_fattr;
2146 struct nfs4_create_arg arg = {
2147 .dir_fh = NFS_FH(dir),
2148 .server = server,
2149 .name = &dentry->d_name,
2150 .attrs = sattr,
2151 .ftype = NF4DIR,
2152 .bitmask = server->attr_bitmask,
2153 };
2154 struct nfs4_create_res res = {
2155 .server = server,
2156 .fh = &fhandle,
2157 .fattr = &fattr,
2158 .dir_fattr = &dir_fattr,
2159 };
2160 struct rpc_message msg = {
2161 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE],
2162 .rpc_argp = &arg,
2163 .rpc_resp = &res,
2164 };
2165 int status;
2166 2178
2167 nfs_fattr_init(&fattr); 2179 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
2168 nfs_fattr_init(&dir_fattr); 2180 if (data == NULL)
2169 2181 goto out;
2170 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 2182
2171 if (!status) { 2183 status = nfs4_do_create(dir, dentry, data);
2172 update_changeattr(dir, &res.dir_cinfo); 2184
2173 nfs_post_op_update_inode(dir, res.dir_fattr); 2185 nfs4_free_createdata(data);
2174 status = nfs_instantiate(dentry, &fhandle, &fattr); 2186out:
2175 }
2176 return status; 2187 return status;
2177} 2188}
2178 2189
@@ -2242,56 +2253,34 @@ static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
2242static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry, 2253static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
2243 struct iattr *sattr, dev_t rdev) 2254 struct iattr *sattr, dev_t rdev)
2244{ 2255{
2245 struct nfs_server *server = NFS_SERVER(dir); 2256 struct nfs4_createdata *data;
2246 struct nfs_fh fh; 2257 int mode = sattr->ia_mode;
2247 struct nfs_fattr fattr, dir_fattr; 2258 int status = -ENOMEM;
2248 struct nfs4_create_arg arg = {
2249 .dir_fh = NFS_FH(dir),
2250 .server = server,
2251 .name = &dentry->d_name,
2252 .attrs = sattr,
2253 .bitmask = server->attr_bitmask,
2254 };
2255 struct nfs4_create_res res = {
2256 .server = server,
2257 .fh = &fh,
2258 .fattr = &fattr,
2259 .dir_fattr = &dir_fattr,
2260 };
2261 struct rpc_message msg = {
2262 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE],
2263 .rpc_argp = &arg,
2264 .rpc_resp = &res,
2265 };
2266 int status;
2267 int mode = sattr->ia_mode;
2268
2269 nfs_fattr_init(&fattr);
2270 nfs_fattr_init(&dir_fattr);
2271 2259
2272 BUG_ON(!(sattr->ia_valid & ATTR_MODE)); 2260 BUG_ON(!(sattr->ia_valid & ATTR_MODE));
2273 BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode)); 2261 BUG_ON(!S_ISFIFO(mode) && !S_ISBLK(mode) && !S_ISCHR(mode) && !S_ISSOCK(mode));
2262
2263 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
2264 if (data == NULL)
2265 goto out;
2266
2274 if (S_ISFIFO(mode)) 2267 if (S_ISFIFO(mode))
2275 arg.ftype = NF4FIFO; 2268 data->arg.ftype = NF4FIFO;
2276 else if (S_ISBLK(mode)) { 2269 else if (S_ISBLK(mode)) {
2277 arg.ftype = NF4BLK; 2270 data->arg.ftype = NF4BLK;
2278 arg.u.device.specdata1 = MAJOR(rdev); 2271 data->arg.u.device.specdata1 = MAJOR(rdev);
2279 arg.u.device.specdata2 = MINOR(rdev); 2272 data->arg.u.device.specdata2 = MINOR(rdev);
2280 } 2273 }
2281 else if (S_ISCHR(mode)) { 2274 else if (S_ISCHR(mode)) {
2282 arg.ftype = NF4CHR; 2275 data->arg.ftype = NF4CHR;
2283 arg.u.device.specdata1 = MAJOR(rdev); 2276 data->arg.u.device.specdata1 = MAJOR(rdev);
2284 arg.u.device.specdata2 = MINOR(rdev); 2277 data->arg.u.device.specdata2 = MINOR(rdev);
2285 } 2278 }
2286 else
2287 arg.ftype = NF4SOCK;
2288 2279
2289 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 2280 status = nfs4_do_create(dir, dentry, data);
2290 if (status == 0) { 2281
2291 update_changeattr(dir, &res.dir_cinfo); 2282 nfs4_free_createdata(data);
2292 nfs_post_op_update_inode(dir, res.dir_fattr); 2283out:
2293 status = nfs_instantiate(dentry, &fh, &fattr);
2294 }
2295 return status; 2284 return status;
2296} 2285}
2297 2286
@@ -2706,6 +2695,8 @@ static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
2706 ret = nfs_revalidate_inode(server, inode); 2695 ret = nfs_revalidate_inode(server, inode);
2707 if (ret < 0) 2696 if (ret < 0)
2708 return ret; 2697 return ret;
2698 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
2699 nfs_zap_acl_cache(inode);
2709 ret = nfs4_read_cached_acl(inode, buf, buflen); 2700 ret = nfs4_read_cached_acl(inode, buf, buflen);
2710 if (ret != -ENOENT) 2701 if (ret != -ENOENT)
2711 return ret; 2702 return ret;
@@ -2733,7 +2724,8 @@ static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t bufl
2733 nfs_inode_return_delegation(inode); 2724 nfs_inode_return_delegation(inode);
2734 buf_to_pages(buf, buflen, arg.acl_pages, &arg.acl_pgbase); 2725 buf_to_pages(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
2735 ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 2726 ret = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
2736 nfs_zap_caches(inode); 2727 nfs_access_zap_cache(inode);
2728 nfs_zap_acl_cache(inode);
2737 return ret; 2729 return ret;
2738} 2730}
2739 2731
@@ -2767,8 +2759,7 @@ nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server)
2767 task->tk_status = 0; 2759 task->tk_status = 0;
2768 return -EAGAIN; 2760 return -EAGAIN;
2769 case -NFS4ERR_DELAY: 2761 case -NFS4ERR_DELAY:
2770 nfs_inc_server_stats((struct nfs_server *) server, 2762 nfs_inc_server_stats(server, NFSIOS_DELAY);
2771 NFSIOS_DELAY);
2772 case -NFS4ERR_GRACE: 2763 case -NFS4ERR_GRACE:
2773 rpc_delay(task, NFS4_POLL_RETRY_MAX); 2764 rpc_delay(task, NFS4_POLL_RETRY_MAX);
2774 task->tk_status = 0; 2765 task->tk_status = 0;
@@ -2933,7 +2924,7 @@ static int _nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cre
2933 2924
2934int nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred) 2925int nfs4_proc_setclientid_confirm(struct nfs_client *clp, struct rpc_cred *cred)
2935{ 2926{
2936 long timeout; 2927 long timeout = 0;
2937 int err; 2928 int err;
2938 do { 2929 do {
2939 err = _nfs4_proc_setclientid_confirm(clp, cred); 2930 err = _nfs4_proc_setclientid_confirm(clp, cred);
@@ -3725,8 +3716,6 @@ const struct nfs_rpc_ops nfs_v4_clientops = {
3725 .write_done = nfs4_write_done, 3716 .write_done = nfs4_write_done,
3726 .commit_setup = nfs4_proc_commit_setup, 3717 .commit_setup = nfs4_proc_commit_setup,
3727 .commit_done = nfs4_commit_done, 3718 .commit_done = nfs4_commit_done,
3728 .file_open = nfs_open,
3729 .file_release = nfs_release,
3730 .lock = nfs4_proc_lock, 3719 .lock = nfs4_proc_lock,
3731 .clear_acl_cache = nfs4_zap_acl_attr, 3720 .clear_acl_cache = nfs4_zap_acl_attr,
3732}; 3721};
diff --git a/fs/nfs/nfsroot.c b/fs/nfs/nfsroot.c
index 531379d36823..46763d1cd397 100644
--- a/fs/nfs/nfsroot.c
+++ b/fs/nfs/nfsroot.c
@@ -1,6 +1,4 @@
1/* 1/*
2 * $Id: nfsroot.c,v 1.45 1998/03/07 10:44:46 mj Exp $
3 *
4 * Copyright (C) 1995, 1996 Gero Kuhlmann <gero@gkminix.han.de> 2 * Copyright (C) 1995, 1996 Gero Kuhlmann <gero@gkminix.han.de>
5 * 3 *
6 * Allow an NFS filesystem to be mounted as root. The way this works is: 4 * Allow an NFS filesystem to be mounted as root. The way this works is:
@@ -297,10 +295,10 @@ static int __init root_nfs_name(char *name)
297 nfs_data.flags = NFS_MOUNT_NONLM; /* No lockd in nfs root yet */ 295 nfs_data.flags = NFS_MOUNT_NONLM; /* No lockd in nfs root yet */
298 nfs_data.rsize = NFS_DEF_FILE_IO_SIZE; 296 nfs_data.rsize = NFS_DEF_FILE_IO_SIZE;
299 nfs_data.wsize = NFS_DEF_FILE_IO_SIZE; 297 nfs_data.wsize = NFS_DEF_FILE_IO_SIZE;
300 nfs_data.acregmin = 3; 298 nfs_data.acregmin = NFS_DEF_ACREGMIN;
301 nfs_data.acregmax = 60; 299 nfs_data.acregmax = NFS_DEF_ACREGMAX;
302 nfs_data.acdirmin = 30; 300 nfs_data.acdirmin = NFS_DEF_ACDIRMIN;
303 nfs_data.acdirmax = 60; 301 nfs_data.acdirmax = NFS_DEF_ACDIRMAX;
304 strcpy(buf, NFS_ROOT); 302 strcpy(buf, NFS_ROOT);
305 303
306 /* Process options received from the remote server */ 304 /* Process options received from the remote server */
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index 03599bfe81cf..4dbb84df1b68 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -129,6 +129,8 @@ nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
129 sattr->ia_mode &= S_IALLUGO; 129 sattr->ia_mode &= S_IALLUGO;
130 130
131 dprintk("NFS call setattr\n"); 131 dprintk("NFS call setattr\n");
132 if (sattr->ia_valid & ATTR_FILE)
133 msg.rpc_cred = nfs_file_cred(sattr->ia_file);
132 nfs_fattr_init(fattr); 134 nfs_fattr_init(fattr);
133 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 135 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
134 if (status == 0) 136 if (status == 0)
@@ -598,6 +600,29 @@ nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
598 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl); 600 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
599} 601}
600 602
603/* Helper functions for NFS lock bounds checking */
604#define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
605static int nfs_lock_check_bounds(const struct file_lock *fl)
606{
607 __s32 start, end;
608
609 start = (__s32)fl->fl_start;
610 if ((loff_t)start != fl->fl_start)
611 goto out_einval;
612
613 if (fl->fl_end != OFFSET_MAX) {
614 end = (__s32)fl->fl_end;
615 if ((loff_t)end != fl->fl_end)
616 goto out_einval;
617 } else
618 end = NFS_LOCK32_OFFSET_MAX;
619
620 if (start < 0 || start > end)
621 goto out_einval;
622 return 0;
623out_einval:
624 return -EINVAL;
625}
601 626
602const struct nfs_rpc_ops nfs_v2_clientops = { 627const struct nfs_rpc_ops nfs_v2_clientops = {
603 .version = 2, /* protocol version */ 628 .version = 2, /* protocol version */
@@ -630,7 +655,6 @@ const struct nfs_rpc_ops nfs_v2_clientops = {
630 .write_setup = nfs_proc_write_setup, 655 .write_setup = nfs_proc_write_setup,
631 .write_done = nfs_write_done, 656 .write_done = nfs_write_done,
632 .commit_setup = nfs_proc_commit_setup, 657 .commit_setup = nfs_proc_commit_setup,
633 .file_open = nfs_open,
634 .file_release = nfs_release,
635 .lock = nfs_proc_lock, 658 .lock = nfs_proc_lock,
659 .lock_check_bounds = nfs_lock_check_bounds,
636}; 660};
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 614efeed5437..47cf83e917be 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -47,6 +47,7 @@
47#include <linux/inet.h> 47#include <linux/inet.h>
48#include <linux/in6.h> 48#include <linux/in6.h>
49#include <net/ipv6.h> 49#include <net/ipv6.h>
50#include <linux/netdevice.h>
50#include <linux/nfs_xdr.h> 51#include <linux/nfs_xdr.h>
51#include <linux/magic.h> 52#include <linux/magic.h>
52#include <linux/parser.h> 53#include <linux/parser.h>
@@ -65,7 +66,6 @@
65enum { 66enum {
66 /* Mount options that take no arguments */ 67 /* Mount options that take no arguments */
67 Opt_soft, Opt_hard, 68 Opt_soft, Opt_hard,
68 Opt_intr, Opt_nointr,
69 Opt_posix, Opt_noposix, 69 Opt_posix, Opt_noposix,
70 Opt_cto, Opt_nocto, 70 Opt_cto, Opt_nocto,
71 Opt_ac, Opt_noac, 71 Opt_ac, Opt_noac,
@@ -92,8 +92,8 @@ enum {
92 Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost, 92 Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,
93 Opt_addr, Opt_mountaddr, Opt_clientaddr, 93 Opt_addr, Opt_mountaddr, Opt_clientaddr,
94 94
95 /* Mount options that are ignored */ 95 /* Special mount options */
96 Opt_userspace, Opt_deprecated, 96 Opt_userspace, Opt_deprecated, Opt_sloppy,
97 97
98 Opt_err 98 Opt_err
99}; 99};
@@ -101,10 +101,14 @@ enum {
101static match_table_t nfs_mount_option_tokens = { 101static match_table_t nfs_mount_option_tokens = {
102 { Opt_userspace, "bg" }, 102 { Opt_userspace, "bg" },
103 { Opt_userspace, "fg" }, 103 { Opt_userspace, "fg" },
104 { Opt_userspace, "retry=%s" },
105
106 { Opt_sloppy, "sloppy" },
107
104 { Opt_soft, "soft" }, 108 { Opt_soft, "soft" },
105 { Opt_hard, "hard" }, 109 { Opt_hard, "hard" },
106 { Opt_intr, "intr" }, 110 { Opt_deprecated, "intr" },
107 { Opt_nointr, "nointr" }, 111 { Opt_deprecated, "nointr" },
108 { Opt_posix, "posix" }, 112 { Opt_posix, "posix" },
109 { Opt_noposix, "noposix" }, 113 { Opt_noposix, "noposix" },
110 { Opt_cto, "cto" }, 114 { Opt_cto, "cto" },
@@ -136,7 +140,6 @@ static match_table_t nfs_mount_option_tokens = {
136 { Opt_acdirmin, "acdirmin=%u" }, 140 { Opt_acdirmin, "acdirmin=%u" },
137 { Opt_acdirmax, "acdirmax=%u" }, 141 { Opt_acdirmax, "acdirmax=%u" },
138 { Opt_actimeo, "actimeo=%u" }, 142 { Opt_actimeo, "actimeo=%u" },
139 { Opt_userspace, "retry=%u" },
140 { Opt_namelen, "namlen=%u" }, 143 { Opt_namelen, "namlen=%u" },
141 { Opt_mountport, "mountport=%u" }, 144 { Opt_mountport, "mountport=%u" },
142 { Opt_mountvers, "mountvers=%u" }, 145 { Opt_mountvers, "mountvers=%u" },
@@ -207,6 +210,7 @@ static int nfs_xdev_get_sb(struct file_system_type *fs_type,
207 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt); 210 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt);
208static void nfs_kill_super(struct super_block *); 211static void nfs_kill_super(struct super_block *);
209static void nfs_put_super(struct super_block *); 212static void nfs_put_super(struct super_block *);
213static int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
210 214
211static struct file_system_type nfs_fs_type = { 215static struct file_system_type nfs_fs_type = {
212 .owner = THIS_MODULE, 216 .owner = THIS_MODULE,
@@ -234,6 +238,7 @@ static const struct super_operations nfs_sops = {
234 .umount_begin = nfs_umount_begin, 238 .umount_begin = nfs_umount_begin,
235 .show_options = nfs_show_options, 239 .show_options = nfs_show_options,
236 .show_stats = nfs_show_stats, 240 .show_stats = nfs_show_stats,
241 .remount_fs = nfs_remount,
237}; 242};
238 243
239#ifdef CONFIG_NFS_V4 244#ifdef CONFIG_NFS_V4
@@ -278,6 +283,7 @@ static const struct super_operations nfs4_sops = {
278 .umount_begin = nfs_umount_begin, 283 .umount_begin = nfs_umount_begin,
279 .show_options = nfs_show_options, 284 .show_options = nfs_show_options,
280 .show_stats = nfs_show_stats, 285 .show_stats = nfs_show_stats,
286 .remount_fs = nfs_remount,
281}; 287};
282#endif 288#endif
283 289
@@ -514,13 +520,13 @@ static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
514 if (nfss->bsize != 0) 520 if (nfss->bsize != 0)
515 seq_printf(m, ",bsize=%u", nfss->bsize); 521 seq_printf(m, ",bsize=%u", nfss->bsize);
516 seq_printf(m, ",namlen=%u", nfss->namelen); 522 seq_printf(m, ",namlen=%u", nfss->namelen);
517 if (nfss->acregmin != 3*HZ || showdefaults) 523 if (nfss->acregmin != NFS_DEF_ACREGMIN*HZ || showdefaults)
518 seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ); 524 seq_printf(m, ",acregmin=%u", nfss->acregmin/HZ);
519 if (nfss->acregmax != 60*HZ || showdefaults) 525 if (nfss->acregmax != NFS_DEF_ACREGMAX*HZ || showdefaults)
520 seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ); 526 seq_printf(m, ",acregmax=%u", nfss->acregmax/HZ);
521 if (nfss->acdirmin != 30*HZ || showdefaults) 527 if (nfss->acdirmin != NFS_DEF_ACDIRMIN*HZ || showdefaults)
522 seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ); 528 seq_printf(m, ",acdirmin=%u", nfss->acdirmin/HZ);
523 if (nfss->acdirmax != 60*HZ || showdefaults) 529 if (nfss->acdirmax != NFS_DEF_ACDIRMAX*HZ || showdefaults)
524 seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ); 530 seq_printf(m, ",acdirmax=%u", nfss->acdirmax/HZ);
525 for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) { 531 for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
526 if (nfss->flags & nfs_infop->flag) 532 if (nfss->flags & nfs_infop->flag)
@@ -702,49 +708,233 @@ static int nfs_verify_server_address(struct sockaddr *addr)
702 return 0; 708 return 0;
703} 709}
704 710
711static void nfs_parse_ipv4_address(char *string, size_t str_len,
712 struct sockaddr *sap, size_t *addr_len)
713{
714 struct sockaddr_in *sin = (struct sockaddr_in *)sap;
715 u8 *addr = (u8 *)&sin->sin_addr.s_addr;
716
717 if (str_len <= INET_ADDRSTRLEN) {
718 dfprintk(MOUNT, "NFS: parsing IPv4 address %*s\n",
719 (int)str_len, string);
720
721 sin->sin_family = AF_INET;
722 *addr_len = sizeof(*sin);
723 if (in4_pton(string, str_len, addr, '\0', NULL))
724 return;
725 }
726
727 sap->sa_family = AF_UNSPEC;
728 *addr_len = 0;
729}
730
731#define IPV6_SCOPE_DELIMITER '%'
732
733#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
734static void nfs_parse_ipv6_scope_id(const char *string, const size_t str_len,
735 const char *delim,
736 struct sockaddr_in6 *sin6)
737{
738 char *p;
739 size_t len;
740
741 if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
742 return ;
743 if (*delim != IPV6_SCOPE_DELIMITER)
744 return;
745
746 len = (string + str_len) - delim - 1;
747 p = kstrndup(delim + 1, len, GFP_KERNEL);
748 if (p) {
749 unsigned long scope_id = 0;
750 struct net_device *dev;
751
752 dev = dev_get_by_name(&init_net, p);
753 if (dev != NULL) {
754 scope_id = dev->ifindex;
755 dev_put(dev);
756 } else {
757 /* scope_id is set to zero on error */
758 strict_strtoul(p, 10, &scope_id);
759 }
760
761 kfree(p);
762 sin6->sin6_scope_id = scope_id;
763 dfprintk(MOUNT, "NFS: IPv6 scope ID = %lu\n", scope_id);
764 }
765}
766
767static void nfs_parse_ipv6_address(char *string, size_t str_len,
768 struct sockaddr *sap, size_t *addr_len)
769{
770 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
771 u8 *addr = (u8 *)&sin6->sin6_addr.in6_u;
772 const char *delim;
773
774 if (str_len <= INET6_ADDRSTRLEN) {
775 dfprintk(MOUNT, "NFS: parsing IPv6 address %*s\n",
776 (int)str_len, string);
777
778 sin6->sin6_family = AF_INET6;
779 *addr_len = sizeof(*sin6);
780 if (in6_pton(string, str_len, addr, IPV6_SCOPE_DELIMITER, &delim)) {
781 nfs_parse_ipv6_scope_id(string, str_len, delim, sin6);
782 return;
783 }
784 }
785
786 sap->sa_family = AF_UNSPEC;
787 *addr_len = 0;
788}
789#else
790static void nfs_parse_ipv6_address(char *string, size_t str_len,
791 struct sockaddr *sap, size_t *addr_len)
792{
793 sap->sa_family = AF_UNSPEC;
794 *addr_len = 0;
795}
796#endif
797
705/* 798/*
706 * Parse string addresses passed in via a mount option, 799 * Construct a sockaddr based on the contents of a string that contains
707 * and construct a sockaddr based on the result. 800 * an IP address in presentation format.
708 * 801 *
709 * If address parsing fails, set the sockaddr's address 802 * If there is a problem constructing the new sockaddr, set the address
710 * family to AF_UNSPEC to force nfs_verify_server_address() 803 * family to AF_UNSPEC.
711 * to punt the mount.
712 */ 804 */
713static void nfs_parse_server_address(char *value, 805static void nfs_parse_ip_address(char *string, size_t str_len,
714 struct sockaddr *sap, 806 struct sockaddr *sap, size_t *addr_len)
715 size_t *len)
716{ 807{
717 if (strchr(value, ':')) { 808 unsigned int i, colons;
718 struct sockaddr_in6 *ap = (struct sockaddr_in6 *)sap;
719 u8 *addr = (u8 *)&ap->sin6_addr.in6_u;
720 809
721 ap->sin6_family = AF_INET6; 810 colons = 0;
722 *len = sizeof(*ap); 811 for (i = 0; i < str_len; i++)
723 if (in6_pton(value, -1, addr, '\0', NULL)) 812 if (string[i] == ':')
724 return; 813 colons++;
725 } else {
726 struct sockaddr_in *ap = (struct sockaddr_in *)sap;
727 u8 *addr = (u8 *)&ap->sin_addr.s_addr;
728 814
729 ap->sin_family = AF_INET; 815 if (colons >= 2)
730 *len = sizeof(*ap); 816 nfs_parse_ipv6_address(string, str_len, sap, addr_len);
731 if (in4_pton(value, -1, addr, '\0', NULL)) 817 else
818 nfs_parse_ipv4_address(string, str_len, sap, addr_len);
819}
820
821/*
822 * Sanity check the NFS transport protocol.
823 *
824 */
825static void nfs_validate_transport_protocol(struct nfs_parsed_mount_data *mnt)
826{
827 switch (mnt->nfs_server.protocol) {
828 case XPRT_TRANSPORT_UDP:
829 case XPRT_TRANSPORT_TCP:
830 case XPRT_TRANSPORT_RDMA:
831 break;
832 default:
833 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
834 }
835}
836
837/*
838 * For text based NFSv2/v3 mounts, the mount protocol transport default
839 * settings should depend upon the specified NFS transport.
840 */
841static void nfs_set_mount_transport_protocol(struct nfs_parsed_mount_data *mnt)
842{
843 nfs_validate_transport_protocol(mnt);
844
845 if (mnt->mount_server.protocol == XPRT_TRANSPORT_UDP ||
846 mnt->mount_server.protocol == XPRT_TRANSPORT_TCP)
732 return; 847 return;
848 switch (mnt->nfs_server.protocol) {
849 case XPRT_TRANSPORT_UDP:
850 mnt->mount_server.protocol = XPRT_TRANSPORT_UDP;
851 break;
852 case XPRT_TRANSPORT_TCP:
853 case XPRT_TRANSPORT_RDMA:
854 mnt->mount_server.protocol = XPRT_TRANSPORT_TCP;
733 } 855 }
856}
734 857
735 sap->sa_family = AF_UNSPEC; 858/*
736 *len = 0; 859 * Parse the value of the 'sec=' option.
860 *
861 * The flavor_len setting is for v4 mounts.
862 */
863static int nfs_parse_security_flavors(char *value,
864 struct nfs_parsed_mount_data *mnt)
865{
866 substring_t args[MAX_OPT_ARGS];
867
868 dfprintk(MOUNT, "NFS: parsing sec=%s option\n", value);
869
870 switch (match_token(value, nfs_secflavor_tokens, args)) {
871 case Opt_sec_none:
872 mnt->auth_flavor_len = 0;
873 mnt->auth_flavors[0] = RPC_AUTH_NULL;
874 break;
875 case Opt_sec_sys:
876 mnt->auth_flavor_len = 0;
877 mnt->auth_flavors[0] = RPC_AUTH_UNIX;
878 break;
879 case Opt_sec_krb5:
880 mnt->auth_flavor_len = 1;
881 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5;
882 break;
883 case Opt_sec_krb5i:
884 mnt->auth_flavor_len = 1;
885 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I;
886 break;
887 case Opt_sec_krb5p:
888 mnt->auth_flavor_len = 1;
889 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P;
890 break;
891 case Opt_sec_lkey:
892 mnt->auth_flavor_len = 1;
893 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY;
894 break;
895 case Opt_sec_lkeyi:
896 mnt->auth_flavor_len = 1;
897 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI;
898 break;
899 case Opt_sec_lkeyp:
900 mnt->auth_flavor_len = 1;
901 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP;
902 break;
903 case Opt_sec_spkm:
904 mnt->auth_flavor_len = 1;
905 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM;
906 break;
907 case Opt_sec_spkmi:
908 mnt->auth_flavor_len = 1;
909 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI;
910 break;
911 case Opt_sec_spkmp:
912 mnt->auth_flavor_len = 1;
913 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP;
914 break;
915 default:
916 return 0;
917 }
918
919 return 1;
920}
921
922static void nfs_parse_invalid_value(const char *option)
923{
924 dfprintk(MOUNT, "NFS: bad value specified for %s option\n", option);
737} 925}
738 926
739/* 927/*
740 * Error-check and convert a string of mount options from user space into 928 * Error-check and convert a string of mount options from user space into
741 * a data structure 929 * a data structure. The whole mount string is processed; bad options are
930 * skipped as they are encountered. If there were no errors, return 1;
931 * otherwise return 0 (zero).
742 */ 932 */
743static int nfs_parse_mount_options(char *raw, 933static int nfs_parse_mount_options(char *raw,
744 struct nfs_parsed_mount_data *mnt) 934 struct nfs_parsed_mount_data *mnt)
745{ 935{
746 char *p, *string, *secdata; 936 char *p, *string, *secdata;
747 int rc; 937 int rc, sloppy = 0, errors = 0;
748 938
749 if (!raw) { 939 if (!raw) {
750 dfprintk(MOUNT, "NFS: mount options string was NULL.\n"); 940 dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
@@ -777,15 +967,16 @@ static int nfs_parse_mount_options(char *raw,
777 967
778 token = match_token(p, nfs_mount_option_tokens, args); 968 token = match_token(p, nfs_mount_option_tokens, args);
779 switch (token) { 969 switch (token) {
970
971 /*
972 * boolean options: foo/nofoo
973 */
780 case Opt_soft: 974 case Opt_soft:
781 mnt->flags |= NFS_MOUNT_SOFT; 975 mnt->flags |= NFS_MOUNT_SOFT;
782 break; 976 break;
783 case Opt_hard: 977 case Opt_hard:
784 mnt->flags &= ~NFS_MOUNT_SOFT; 978 mnt->flags &= ~NFS_MOUNT_SOFT;
785 break; 979 break;
786 case Opt_intr:
787 case Opt_nointr:
788 break;
789 case Opt_posix: 980 case Opt_posix:
790 mnt->flags |= NFS_MOUNT_POSIX; 981 mnt->flags |= NFS_MOUNT_POSIX;
791 break; 982 break;
@@ -819,20 +1010,14 @@ static int nfs_parse_mount_options(char *raw,
819 case Opt_udp: 1010 case Opt_udp:
820 mnt->flags &= ~NFS_MOUNT_TCP; 1011 mnt->flags &= ~NFS_MOUNT_TCP;
821 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP; 1012 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
822 mnt->timeo = 7;
823 mnt->retrans = 5;
824 break; 1013 break;
825 case Opt_tcp: 1014 case Opt_tcp:
826 mnt->flags |= NFS_MOUNT_TCP; 1015 mnt->flags |= NFS_MOUNT_TCP;
827 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP; 1016 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
828 mnt->timeo = 600;
829 mnt->retrans = 2;
830 break; 1017 break;
831 case Opt_rdma: 1018 case Opt_rdma:
832 mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */ 1019 mnt->flags |= NFS_MOUNT_TCP; /* for side protocols */
833 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA; 1020 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
834 mnt->timeo = 600;
835 mnt->retrans = 2;
836 break; 1021 break;
837 case Opt_acl: 1022 case Opt_acl:
838 mnt->flags &= ~NFS_MOUNT_NOACL; 1023 mnt->flags &= ~NFS_MOUNT_NOACL;
@@ -853,165 +1038,144 @@ static int nfs_parse_mount_options(char *raw,
853 mnt->flags |= NFS_MOUNT_UNSHARED; 1038 mnt->flags |= NFS_MOUNT_UNSHARED;
854 break; 1039 break;
855 1040
1041 /*
1042 * options that take numeric values
1043 */
856 case Opt_port: 1044 case Opt_port:
857 if (match_int(args, &option)) 1045 if (match_int(args, &option) ||
858 return 0; 1046 option < 0 || option > USHORT_MAX) {
859 if (option < 0 || option > 65535) 1047 errors++;
860 return 0; 1048 nfs_parse_invalid_value("port");
861 mnt->nfs_server.port = option; 1049 } else
1050 mnt->nfs_server.port = option;
862 break; 1051 break;
863 case Opt_rsize: 1052 case Opt_rsize:
864 if (match_int(args, &mnt->rsize)) 1053 if (match_int(args, &option) || option < 0) {
865 return 0; 1054 errors++;
1055 nfs_parse_invalid_value("rsize");
1056 } else
1057 mnt->rsize = option;
866 break; 1058 break;
867 case Opt_wsize: 1059 case Opt_wsize:
868 if (match_int(args, &mnt->wsize)) 1060 if (match_int(args, &option) || option < 0) {
869 return 0; 1061 errors++;
1062 nfs_parse_invalid_value("wsize");
1063 } else
1064 mnt->wsize = option;
870 break; 1065 break;
871 case Opt_bsize: 1066 case Opt_bsize:
872 if (match_int(args, &option)) 1067 if (match_int(args, &option) || option < 0) {
873 return 0; 1068 errors++;
874 if (option < 0) 1069 nfs_parse_invalid_value("bsize");
875 return 0; 1070 } else
876 mnt->bsize = option; 1071 mnt->bsize = option;
877 break; 1072 break;
878 case Opt_timeo: 1073 case Opt_timeo:
879 if (match_int(args, &mnt->timeo)) 1074 if (match_int(args, &option) || option <= 0) {
880 return 0; 1075 errors++;
1076 nfs_parse_invalid_value("timeo");
1077 } else
1078 mnt->timeo = option;
881 break; 1079 break;
882 case Opt_retrans: 1080 case Opt_retrans:
883 if (match_int(args, &mnt->retrans)) 1081 if (match_int(args, &option) || option <= 0) {
884 return 0; 1082 errors++;
1083 nfs_parse_invalid_value("retrans");
1084 } else
1085 mnt->retrans = option;
885 break; 1086 break;
886 case Opt_acregmin: 1087 case Opt_acregmin:
887 if (match_int(args, &mnt->acregmin)) 1088 if (match_int(args, &option) || option < 0) {
888 return 0; 1089 errors++;
1090 nfs_parse_invalid_value("acregmin");
1091 } else
1092 mnt->acregmin = option;
889 break; 1093 break;
890 case Opt_acregmax: 1094 case Opt_acregmax:
891 if (match_int(args, &mnt->acregmax)) 1095 if (match_int(args, &option) || option < 0) {
892 return 0; 1096 errors++;
1097 nfs_parse_invalid_value("acregmax");
1098 } else
1099 mnt->acregmax = option;
893 break; 1100 break;
894 case Opt_acdirmin: 1101 case Opt_acdirmin:
895 if (match_int(args, &mnt->acdirmin)) 1102 if (match_int(args, &option) || option < 0) {
896 return 0; 1103 errors++;
1104 nfs_parse_invalid_value("acdirmin");
1105 } else
1106 mnt->acdirmin = option;
897 break; 1107 break;
898 case Opt_acdirmax: 1108 case Opt_acdirmax:
899 if (match_int(args, &mnt->acdirmax)) 1109 if (match_int(args, &option) || option < 0) {
900 return 0; 1110 errors++;
1111 nfs_parse_invalid_value("acdirmax");
1112 } else
1113 mnt->acdirmax = option;
901 break; 1114 break;
902 case Opt_actimeo: 1115 case Opt_actimeo:
903 if (match_int(args, &option)) 1116 if (match_int(args, &option) || option < 0) {
904 return 0; 1117 errors++;
905 if (option < 0) 1118 nfs_parse_invalid_value("actimeo");
906 return 0; 1119 } else
907 mnt->acregmin = 1120 mnt->acregmin = mnt->acregmax =
908 mnt->acregmax = 1121 mnt->acdirmin = mnt->acdirmax = option;
909 mnt->acdirmin =
910 mnt->acdirmax = option;
911 break; 1122 break;
912 case Opt_namelen: 1123 case Opt_namelen:
913 if (match_int(args, &mnt->namlen)) 1124 if (match_int(args, &option) || option < 0) {
914 return 0; 1125 errors++;
1126 nfs_parse_invalid_value("namlen");
1127 } else
1128 mnt->namlen = option;
915 break; 1129 break;
916 case Opt_mountport: 1130 case Opt_mountport:
917 if (match_int(args, &option)) 1131 if (match_int(args, &option) ||
918 return 0; 1132 option < 0 || option > USHORT_MAX) {
919 if (option < 0 || option > 65535) 1133 errors++;
920 return 0; 1134 nfs_parse_invalid_value("mountport");
921 mnt->mount_server.port = option; 1135 } else
1136 mnt->mount_server.port = option;
922 break; 1137 break;
923 case Opt_mountvers: 1138 case Opt_mountvers:
924 if (match_int(args, &option)) 1139 if (match_int(args, &option) ||
925 return 0; 1140 option < NFS_MNT_VERSION ||
926 if (option < 0) 1141 option > NFS_MNT3_VERSION) {
927 return 0; 1142 errors++;
928 mnt->mount_server.version = option; 1143 nfs_parse_invalid_value("mountvers");
1144 } else
1145 mnt->mount_server.version = option;
929 break; 1146 break;
930 case Opt_nfsvers: 1147 case Opt_nfsvers:
931 if (match_int(args, &option)) 1148 if (match_int(args, &option)) {
932 return 0; 1149 errors++;
1150 nfs_parse_invalid_value("nfsvers");
1151 break;
1152 }
933 switch (option) { 1153 switch (option) {
934 case 2: 1154 case NFS2_VERSION:
935 mnt->flags &= ~NFS_MOUNT_VER3; 1155 mnt->flags &= ~NFS_MOUNT_VER3;
936 break; 1156 break;
937 case 3: 1157 case NFS3_VERSION:
938 mnt->flags |= NFS_MOUNT_VER3; 1158 mnt->flags |= NFS_MOUNT_VER3;
939 break; 1159 break;
940 default: 1160 default:
941 goto out_unrec_vers; 1161 errors++;
1162 nfs_parse_invalid_value("nfsvers");
942 } 1163 }
943 break; 1164 break;
944 1165
1166 /*
1167 * options that take text values
1168 */
945 case Opt_sec: 1169 case Opt_sec:
946 string = match_strdup(args); 1170 string = match_strdup(args);
947 if (string == NULL) 1171 if (string == NULL)
948 goto out_nomem; 1172 goto out_nomem;
949 token = match_token(string, nfs_secflavor_tokens, args); 1173 rc = nfs_parse_security_flavors(string, mnt);
950 kfree(string); 1174 kfree(string);
951 1175 if (!rc) {
952 /* 1176 errors++;
953 * The flags setting is for v2/v3. The flavor_len 1177 dfprintk(MOUNT, "NFS: unrecognized "
954 * setting is for v4. v2/v3 also need to know the 1178 "security flavor\n");
955 * difference between NULL and UNIX.
956 */
957 switch (token) {
958 case Opt_sec_none:
959 mnt->flags &= ~NFS_MOUNT_SECFLAVOUR;
960 mnt->auth_flavor_len = 0;
961 mnt->auth_flavors[0] = RPC_AUTH_NULL;
962 break;
963 case Opt_sec_sys:
964 mnt->flags &= ~NFS_MOUNT_SECFLAVOUR;
965 mnt->auth_flavor_len = 0;
966 mnt->auth_flavors[0] = RPC_AUTH_UNIX;
967 break;
968 case Opt_sec_krb5:
969 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
970 mnt->auth_flavor_len = 1;
971 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5;
972 break;
973 case Opt_sec_krb5i:
974 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
975 mnt->auth_flavor_len = 1;
976 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I;
977 break;
978 case Opt_sec_krb5p:
979 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
980 mnt->auth_flavor_len = 1;
981 mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P;
982 break;
983 case Opt_sec_lkey:
984 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
985 mnt->auth_flavor_len = 1;
986 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY;
987 break;
988 case Opt_sec_lkeyi:
989 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
990 mnt->auth_flavor_len = 1;
991 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI;
992 break;
993 case Opt_sec_lkeyp:
994 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
995 mnt->auth_flavor_len = 1;
996 mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP;
997 break;
998 case Opt_sec_spkm:
999 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
1000 mnt->auth_flavor_len = 1;
1001 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM;
1002 break;
1003 case Opt_sec_spkmi:
1004 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
1005 mnt->auth_flavor_len = 1;
1006 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI;
1007 break;
1008 case Opt_sec_spkmp:
1009 mnt->flags |= NFS_MOUNT_SECFLAVOUR;
1010 mnt->auth_flavor_len = 1;
1011 mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP;
1012 break;
1013 default:
1014 goto out_unrec_sec;
1015 } 1179 }
1016 break; 1180 break;
1017 case Opt_proto: 1181 case Opt_proto:
@@ -1026,24 +1190,20 @@ static int nfs_parse_mount_options(char *raw,
1026 case Opt_xprt_udp: 1190 case Opt_xprt_udp:
1027 mnt->flags &= ~NFS_MOUNT_TCP; 1191 mnt->flags &= ~NFS_MOUNT_TCP;
1028 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP; 1192 mnt->nfs_server.protocol = XPRT_TRANSPORT_UDP;
1029 mnt->timeo = 7;
1030 mnt->retrans = 5;
1031 break; 1193 break;
1032 case Opt_xprt_tcp: 1194 case Opt_xprt_tcp:
1033 mnt->flags |= NFS_MOUNT_TCP; 1195 mnt->flags |= NFS_MOUNT_TCP;
1034 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP; 1196 mnt->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1035 mnt->timeo = 600;
1036 mnt->retrans = 2;
1037 break; 1197 break;
1038 case Opt_xprt_rdma: 1198 case Opt_xprt_rdma:
1039 /* vector side protocols to TCP */ 1199 /* vector side protocols to TCP */
1040 mnt->flags |= NFS_MOUNT_TCP; 1200 mnt->flags |= NFS_MOUNT_TCP;
1041 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA; 1201 mnt->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
1042 mnt->timeo = 600;
1043 mnt->retrans = 2;
1044 break; 1202 break;
1045 default: 1203 default:
1046 goto out_unrec_xprt; 1204 errors++;
1205 dfprintk(MOUNT, "NFS: unrecognized "
1206 "transport protocol\n");
1047 } 1207 }
1048 break; 1208 break;
1049 case Opt_mountproto: 1209 case Opt_mountproto:
@@ -1063,16 +1223,19 @@ static int nfs_parse_mount_options(char *raw,
1063 break; 1223 break;
1064 case Opt_xprt_rdma: /* not used for side protocols */ 1224 case Opt_xprt_rdma: /* not used for side protocols */
1065 default: 1225 default:
1066 goto out_unrec_xprt; 1226 errors++;
1227 dfprintk(MOUNT, "NFS: unrecognized "
1228 "transport protocol\n");
1067 } 1229 }
1068 break; 1230 break;
1069 case Opt_addr: 1231 case Opt_addr:
1070 string = match_strdup(args); 1232 string = match_strdup(args);
1071 if (string == NULL) 1233 if (string == NULL)
1072 goto out_nomem; 1234 goto out_nomem;
1073 nfs_parse_server_address(string, (struct sockaddr *) 1235 nfs_parse_ip_address(string, strlen(string),
1074 &mnt->nfs_server.address, 1236 (struct sockaddr *)
1075 &mnt->nfs_server.addrlen); 1237 &mnt->nfs_server.address,
1238 &mnt->nfs_server.addrlen);
1076 kfree(string); 1239 kfree(string);
1077 break; 1240 break;
1078 case Opt_clientaddr: 1241 case Opt_clientaddr:
@@ -1093,24 +1256,33 @@ static int nfs_parse_mount_options(char *raw,
1093 string = match_strdup(args); 1256 string = match_strdup(args);
1094 if (string == NULL) 1257 if (string == NULL)
1095 goto out_nomem; 1258 goto out_nomem;
1096 nfs_parse_server_address(string, (struct sockaddr *) 1259 nfs_parse_ip_address(string, strlen(string),
1097 &mnt->mount_server.address, 1260 (struct sockaddr *)
1098 &mnt->mount_server.addrlen); 1261 &mnt->mount_server.address,
1262 &mnt->mount_server.addrlen);
1099 kfree(string); 1263 kfree(string);
1100 break; 1264 break;
1101 1265
1266 /*
1267 * Special options
1268 */
1269 case Opt_sloppy:
1270 sloppy = 1;
1271 dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
1272 break;
1102 case Opt_userspace: 1273 case Opt_userspace:
1103 case Opt_deprecated: 1274 case Opt_deprecated:
1275 dfprintk(MOUNT, "NFS: ignoring mount option "
1276 "'%s'\n", p);
1104 break; 1277 break;
1105 1278
1106 default: 1279 default:
1107 goto out_unknown; 1280 errors++;
1281 dfprintk(MOUNT, "NFS: unrecognized mount option "
1282 "'%s'\n", p);
1108 } 1283 }
1109 } 1284 }
1110 1285
1111 nfs_set_port((struct sockaddr *)&mnt->nfs_server.address,
1112 mnt->nfs_server.port);
1113
1114 return 1; 1286 return 1;
1115 1287
1116out_nomem: 1288out_nomem:
@@ -1120,21 +1292,6 @@ out_security_failure:
1120 free_secdata(secdata); 1292 free_secdata(secdata);
1121 printk(KERN_INFO "NFS: security options invalid: %d\n", rc); 1293 printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
1122 return 0; 1294 return 0;
1123out_unrec_vers:
1124 printk(KERN_INFO "NFS: unrecognized NFS version number\n");
1125 return 0;
1126
1127out_unrec_xprt:
1128 printk(KERN_INFO "NFS: unrecognized transport protocol\n");
1129 return 0;
1130
1131out_unrec_sec:
1132 printk(KERN_INFO "NFS: unrecognized security flavor\n");
1133 return 0;
1134
1135out_unknown:
1136 printk(KERN_INFO "NFS: unknown mount option: %s\n", p);
1137 return 0;
1138} 1295}
1139 1296
1140/* 1297/*
@@ -1188,11 +1345,146 @@ static int nfs_try_mount(struct nfs_parsed_mount_data *args,
1188 if (status == 0) 1345 if (status == 0)
1189 return 0; 1346 return 0;
1190 1347
1191 dfprintk(MOUNT, "NFS: unable to mount server %s, error %d", 1348 dfprintk(MOUNT, "NFS: unable to mount server %s, error %d\n",
1192 hostname, status); 1349 hostname, status);
1193 return status; 1350 return status;
1194} 1351}
1195 1352
1353static int nfs_parse_simple_hostname(const char *dev_name,
1354 char **hostname, size_t maxnamlen,
1355 char **export_path, size_t maxpathlen)
1356{
1357 size_t len;
1358 char *colon, *comma;
1359
1360 colon = strchr(dev_name, ':');
1361 if (colon == NULL)
1362 goto out_bad_devname;
1363
1364 len = colon - dev_name;
1365 if (len > maxnamlen)
1366 goto out_hostname;
1367
1368 /* N.B. caller will free nfs_server.hostname in all cases */
1369 *hostname = kstrndup(dev_name, len, GFP_KERNEL);
1370 if (!*hostname)
1371 goto out_nomem;
1372
1373 /* kill possible hostname list: not supported */
1374 comma = strchr(*hostname, ',');
1375 if (comma != NULL) {
1376 if (comma == *hostname)
1377 goto out_bad_devname;
1378 *comma = '\0';
1379 }
1380
1381 colon++;
1382 len = strlen(colon);
1383 if (len > maxpathlen)
1384 goto out_path;
1385 *export_path = kstrndup(colon, len, GFP_KERNEL);
1386 if (!*export_path)
1387 goto out_nomem;
1388
1389 dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *export_path);
1390 return 0;
1391
1392out_bad_devname:
1393 dfprintk(MOUNT, "NFS: device name not in host:path format\n");
1394 return -EINVAL;
1395
1396out_nomem:
1397 dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
1398 return -ENOMEM;
1399
1400out_hostname:
1401 dfprintk(MOUNT, "NFS: server hostname too long\n");
1402 return -ENAMETOOLONG;
1403
1404out_path:
1405 dfprintk(MOUNT, "NFS: export pathname too long\n");
1406 return -ENAMETOOLONG;
1407}
1408
1409/*
1410 * Hostname has square brackets around it because it contains one or
1411 * more colons. We look for the first closing square bracket, and a
1412 * colon must follow it.
1413 */
1414static int nfs_parse_protected_hostname(const char *dev_name,
1415 char **hostname, size_t maxnamlen,
1416 char **export_path, size_t maxpathlen)
1417{
1418 size_t len;
1419 char *start, *end;
1420
1421 start = (char *)(dev_name + 1);
1422
1423 end = strchr(start, ']');
1424 if (end == NULL)
1425 goto out_bad_devname;
1426 if (*(end + 1) != ':')
1427 goto out_bad_devname;
1428
1429 len = end - start;
1430 if (len > maxnamlen)
1431 goto out_hostname;
1432
1433 /* N.B. caller will free nfs_server.hostname in all cases */
1434 *hostname = kstrndup(start, len, GFP_KERNEL);
1435 if (*hostname == NULL)
1436 goto out_nomem;
1437
1438 end += 2;
1439 len = strlen(end);
1440 if (len > maxpathlen)
1441 goto out_path;
1442 *export_path = kstrndup(end, len, GFP_KERNEL);
1443 if (!*export_path)
1444 goto out_nomem;
1445
1446 return 0;
1447
1448out_bad_devname:
1449 dfprintk(MOUNT, "NFS: device name not in host:path format\n");
1450 return -EINVAL;
1451
1452out_nomem:
1453 dfprintk(MOUNT, "NFS: not enough memory to parse device name\n");
1454 return -ENOMEM;
1455
1456out_hostname:
1457 dfprintk(MOUNT, "NFS: server hostname too long\n");
1458 return -ENAMETOOLONG;
1459
1460out_path:
1461 dfprintk(MOUNT, "NFS: export pathname too long\n");
1462 return -ENAMETOOLONG;
1463}
1464
1465/*
1466 * Split "dev_name" into "hostname:export_path".
1467 *
1468 * The leftmost colon demarks the split between the server's hostname
1469 * and the export path. If the hostname starts with a left square
1470 * bracket, then it may contain colons.
1471 *
1472 * Note: caller frees hostname and export path, even on error.
1473 */
1474static int nfs_parse_devname(const char *dev_name,
1475 char **hostname, size_t maxnamlen,
1476 char **export_path, size_t maxpathlen)
1477{
1478 if (*dev_name == '[')
1479 return nfs_parse_protected_hostname(dev_name,
1480 hostname, maxnamlen,
1481 export_path, maxpathlen);
1482
1483 return nfs_parse_simple_hostname(dev_name,
1484 hostname, maxnamlen,
1485 export_path, maxpathlen);
1486}
1487
1196/* 1488/*
1197 * Validate the NFS2/NFS3 mount data 1489 * Validate the NFS2/NFS3 mount data
1198 * - fills in the mount root filehandle 1490 * - fills in the mount root filehandle
@@ -1222,16 +1514,14 @@ static int nfs_validate_mount_data(void *options,
1222 args->flags = (NFS_MOUNT_VER3 | NFS_MOUNT_TCP); 1514 args->flags = (NFS_MOUNT_VER3 | NFS_MOUNT_TCP);
1223 args->rsize = NFS_MAX_FILE_IO_SIZE; 1515 args->rsize = NFS_MAX_FILE_IO_SIZE;
1224 args->wsize = NFS_MAX_FILE_IO_SIZE; 1516 args->wsize = NFS_MAX_FILE_IO_SIZE;
1225 args->timeo = 600; 1517 args->acregmin = NFS_DEF_ACREGMIN;
1226 args->retrans = 2; 1518 args->acregmax = NFS_DEF_ACREGMAX;
1227 args->acregmin = 3; 1519 args->acdirmin = NFS_DEF_ACDIRMIN;
1228 args->acregmax = 60; 1520 args->acdirmax = NFS_DEF_ACDIRMAX;
1229 args->acdirmin = 30;
1230 args->acdirmax = 60;
1231 args->mount_server.port = 0; /* autobind unless user sets port */ 1521 args->mount_server.port = 0; /* autobind unless user sets port */
1232 args->mount_server.protocol = XPRT_TRANSPORT_UDP;
1233 args->nfs_server.port = 0; /* autobind unless user sets port */ 1522 args->nfs_server.port = 0; /* autobind unless user sets port */
1234 args->nfs_server.protocol = XPRT_TRANSPORT_TCP; 1523 args->nfs_server.protocol = XPRT_TRANSPORT_TCP;
1524 args->auth_flavors[0] = RPC_AUTH_UNIX;
1235 1525
1236 switch (data->version) { 1526 switch (data->version) {
1237 case 1: 1527 case 1:
@@ -1289,7 +1579,9 @@ static int nfs_validate_mount_data(void *options,
1289 args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL); 1579 args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
1290 args->namlen = data->namlen; 1580 args->namlen = data->namlen;
1291 args->bsize = data->bsize; 1581 args->bsize = data->bsize;
1292 args->auth_flavors[0] = data->pseudoflavor; 1582
1583 if (data->flags & NFS_MOUNT_SECFLAVOUR)
1584 args->auth_flavors[0] = data->pseudoflavor;
1293 if (!args->nfs_server.hostname) 1585 if (!args->nfs_server.hostname)
1294 goto out_nomem; 1586 goto out_nomem;
1295 1587
@@ -1321,8 +1613,6 @@ static int nfs_validate_mount_data(void *options,
1321 1613
1322 break; 1614 break;
1323 default: { 1615 default: {
1324 unsigned int len;
1325 char *c;
1326 int status; 1616 int status;
1327 1617
1328 if (nfs_parse_mount_options((char *)options, args) == 0) 1618 if (nfs_parse_mount_options((char *)options, args) == 0)
@@ -1332,21 +1622,22 @@ static int nfs_validate_mount_data(void *options,
1332 &args->nfs_server.address)) 1622 &args->nfs_server.address))
1333 goto out_no_address; 1623 goto out_no_address;
1334 1624
1335 c = strchr(dev_name, ':'); 1625 nfs_set_port((struct sockaddr *)&args->nfs_server.address,
1336 if (c == NULL) 1626 args->nfs_server.port);
1337 return -EINVAL;
1338 len = c - dev_name;
1339 /* N.B. caller will free nfs_server.hostname in all cases */
1340 args->nfs_server.hostname = kstrndup(dev_name, len, GFP_KERNEL);
1341 if (!args->nfs_server.hostname)
1342 goto out_nomem;
1343 1627
1344 c++; 1628 nfs_set_mount_transport_protocol(args);
1345 if (strlen(c) > NFS_MAXPATHLEN) 1629
1346 return -ENAMETOOLONG; 1630 status = nfs_parse_devname(dev_name,
1347 args->nfs_server.export_path = c; 1631 &args->nfs_server.hostname,
1632 PAGE_SIZE,
1633 &args->nfs_server.export_path,
1634 NFS_MAXPATHLEN);
1635 if (!status)
1636 status = nfs_try_mount(args, mntfh);
1637
1638 kfree(args->nfs_server.export_path);
1639 args->nfs_server.export_path = NULL;
1348 1640
1349 status = nfs_try_mount(args, mntfh);
1350 if (status) 1641 if (status)
1351 return status; 1642 return status;
1352 1643
@@ -1354,9 +1645,6 @@ static int nfs_validate_mount_data(void *options,
1354 } 1645 }
1355 } 1646 }
1356 1647
1357 if (!(args->flags & NFS_MOUNT_SECFLAVOUR))
1358 args->auth_flavors[0] = RPC_AUTH_UNIX;
1359
1360#ifndef CONFIG_NFS_V3 1648#ifndef CONFIG_NFS_V3
1361 if (args->flags & NFS_MOUNT_VER3) 1649 if (args->flags & NFS_MOUNT_VER3)
1362 goto out_v3_not_compiled; 1650 goto out_v3_not_compiled;
@@ -1396,6 +1684,80 @@ out_invalid_fh:
1396 return -EINVAL; 1684 return -EINVAL;
1397} 1685}
1398 1686
1687static int
1688nfs_compare_remount_data(struct nfs_server *nfss,
1689 struct nfs_parsed_mount_data *data)
1690{
1691 if (data->flags != nfss->flags ||
1692 data->rsize != nfss->rsize ||
1693 data->wsize != nfss->wsize ||
1694 data->retrans != nfss->client->cl_timeout->to_retries ||
1695 data->auth_flavors[0] != nfss->client->cl_auth->au_flavor ||
1696 data->acregmin != nfss->acregmin / HZ ||
1697 data->acregmax != nfss->acregmax / HZ ||
1698 data->acdirmin != nfss->acdirmin / HZ ||
1699 data->acdirmax != nfss->acdirmax / HZ ||
1700 data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
1701 data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
1702 memcmp(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
1703 data->nfs_server.addrlen) != 0)
1704 return -EINVAL;
1705
1706 return 0;
1707}
1708
1709static int
1710nfs_remount(struct super_block *sb, int *flags, char *raw_data)
1711{
1712 int error;
1713 struct nfs_server *nfss = sb->s_fs_info;
1714 struct nfs_parsed_mount_data *data;
1715 struct nfs_mount_data *options = (struct nfs_mount_data *)raw_data;
1716 struct nfs4_mount_data *options4 = (struct nfs4_mount_data *)raw_data;
1717 u32 nfsvers = nfss->nfs_client->rpc_ops->version;
1718
1719 /*
1720 * Userspace mount programs that send binary options generally send
1721 * them populated with default values. We have no way to know which
1722 * ones were explicitly specified. Fall back to legacy behavior and
1723 * just return success.
1724 */
1725 if ((nfsvers == 4 && options4->version == 1) ||
1726 (nfsvers <= 3 && options->version >= 1 &&
1727 options->version <= 6))
1728 return 0;
1729
1730 data = kzalloc(sizeof(*data), GFP_KERNEL);
1731 if (data == NULL)
1732 return -ENOMEM;
1733
1734 /* fill out struct with values from existing mount */
1735 data->flags = nfss->flags;
1736 data->rsize = nfss->rsize;
1737 data->wsize = nfss->wsize;
1738 data->retrans = nfss->client->cl_timeout->to_retries;
1739 data->auth_flavors[0] = nfss->client->cl_auth->au_flavor;
1740 data->acregmin = nfss->acregmin / HZ;
1741 data->acregmax = nfss->acregmax / HZ;
1742 data->acdirmin = nfss->acdirmin / HZ;
1743 data->acdirmax = nfss->acdirmax / HZ;
1744 data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
1745 data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
1746 memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
1747 data->nfs_server.addrlen);
1748
1749 /* overwrite those values with any that were specified */
1750 error = nfs_parse_mount_options((char *)options, data);
1751 if (error < 0)
1752 goto out;
1753
1754 /* compare new mount options with old ones */
1755 error = nfs_compare_remount_data(nfss, data);
1756out:
1757 kfree(data);
1758 return error;
1759}
1760
1399/* 1761/*
1400 * Initialise the common bits of the superblock 1762 * Initialise the common bits of the superblock
1401 */ 1763 */
@@ -1811,14 +2173,13 @@ static int nfs4_validate_mount_data(void *options,
1811 2173
1812 args->rsize = NFS_MAX_FILE_IO_SIZE; 2174 args->rsize = NFS_MAX_FILE_IO_SIZE;
1813 args->wsize = NFS_MAX_FILE_IO_SIZE; 2175 args->wsize = NFS_MAX_FILE_IO_SIZE;
1814 args->timeo = 600; 2176 args->acregmin = NFS_DEF_ACREGMIN;
1815 args->retrans = 2; 2177 args->acregmax = NFS_DEF_ACREGMAX;
1816 args->acregmin = 3; 2178 args->acdirmin = NFS_DEF_ACDIRMIN;
1817 args->acregmax = 60; 2179 args->acdirmax = NFS_DEF_ACDIRMAX;
1818 args->acdirmin = 30;
1819 args->acdirmax = 60;
1820 args->nfs_server.port = NFS_PORT; /* 2049 unless user set port= */ 2180 args->nfs_server.port = NFS_PORT; /* 2049 unless user set port= */
1821 args->nfs_server.protocol = XPRT_TRANSPORT_TCP; 2181 args->auth_flavors[0] = RPC_AUTH_UNIX;
2182 args->auth_flavor_len = 0;
1822 2183
1823 switch (data->version) { 2184 switch (data->version) {
1824 case 1: 2185 case 1:
@@ -1834,18 +2195,13 @@ static int nfs4_validate_mount_data(void *options,
1834 &args->nfs_server.address)) 2195 &args->nfs_server.address))
1835 goto out_no_address; 2196 goto out_no_address;
1836 2197
1837 switch (data->auth_flavourlen) { 2198 if (data->auth_flavourlen) {
1838 case 0: 2199 if (data->auth_flavourlen > 1)
1839 args->auth_flavors[0] = RPC_AUTH_UNIX; 2200 goto out_inval_auth;
1840 break;
1841 case 1:
1842 if (copy_from_user(&args->auth_flavors[0], 2201 if (copy_from_user(&args->auth_flavors[0],
1843 data->auth_flavours, 2202 data->auth_flavours,
1844 sizeof(args->auth_flavors[0]))) 2203 sizeof(args->auth_flavors[0])))
1845 return -EFAULT; 2204 return -EFAULT;
1846 break;
1847 default:
1848 goto out_inval_auth;
1849 } 2205 }
1850 2206
1851 c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN); 2207 c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
@@ -1879,10 +2235,11 @@ static int nfs4_validate_mount_data(void *options,
1879 args->acdirmin = data->acdirmin; 2235 args->acdirmin = data->acdirmin;
1880 args->acdirmax = data->acdirmax; 2236 args->acdirmax = data->acdirmax;
1881 args->nfs_server.protocol = data->proto; 2237 args->nfs_server.protocol = data->proto;
2238 nfs_validate_transport_protocol(args);
1882 2239
1883 break; 2240 break;
1884 default: { 2241 default: {
1885 unsigned int len; 2242 int status;
1886 2243
1887 if (nfs_parse_mount_options((char *)options, args) == 0) 2244 if (nfs_parse_mount_options((char *)options, args) == 0)
1888 return -EINVAL; 2245 return -EINVAL;
@@ -1891,44 +2248,25 @@ static int nfs4_validate_mount_data(void *options,
1891 &args->nfs_server.address)) 2248 &args->nfs_server.address))
1892 return -EINVAL; 2249 return -EINVAL;
1893 2250
1894 switch (args->auth_flavor_len) { 2251 nfs_set_port((struct sockaddr *)&args->nfs_server.address,
1895 case 0: 2252 args->nfs_server.port);
1896 args->auth_flavors[0] = RPC_AUTH_UNIX;
1897 break;
1898 case 1:
1899 break;
1900 default:
1901 goto out_inval_auth;
1902 }
1903 2253
1904 /* 2254 nfs_validate_transport_protocol(args);
1905 * Split "dev_name" into "hostname:mntpath".
1906 */
1907 c = strchr(dev_name, ':');
1908 if (c == NULL)
1909 return -EINVAL;
1910 /* while calculating len, pretend ':' is '\0' */
1911 len = c - dev_name;
1912 if (len > NFS4_MAXNAMLEN)
1913 return -ENAMETOOLONG;
1914 /* N.B. caller will free nfs_server.hostname in all cases */
1915 args->nfs_server.hostname = kstrndup(dev_name, len, GFP_KERNEL);
1916 if (!args->nfs_server.hostname)
1917 goto out_nomem;
1918
1919 c++; /* step over the ':' */
1920 len = strlen(c);
1921 if (len > NFS4_MAXPATHLEN)
1922 return -ENAMETOOLONG;
1923 args->nfs_server.export_path = kstrndup(c, len, GFP_KERNEL);
1924 if (!args->nfs_server.export_path)
1925 goto out_nomem;
1926 2255
1927 dprintk("NFS: MNTPATH: '%s'\n", args->nfs_server.export_path); 2256 if (args->auth_flavor_len > 1)
2257 goto out_inval_auth;
1928 2258
1929 if (args->client_address == NULL) 2259 if (args->client_address == NULL)
1930 goto out_no_client_address; 2260 goto out_no_client_address;
1931 2261
2262 status = nfs_parse_devname(dev_name,
2263 &args->nfs_server.hostname,
2264 NFS4_MAXNAMLEN,
2265 &args->nfs_server.export_path,
2266 NFS4_MAXPATHLEN);
2267 if (status < 0)
2268 return status;
2269
1932 break; 2270 break;
1933 } 2271 }
1934 } 2272 }
@@ -1944,10 +2282,6 @@ out_inval_auth:
1944 data->auth_flavourlen); 2282 data->auth_flavourlen);
1945 return -EINVAL; 2283 return -EINVAL;
1946 2284
1947out_nomem:
1948 dfprintk(MOUNT, "NFS4: not enough memory to handle mount options\n");
1949 return -ENOMEM;
1950
1951out_no_address: 2285out_no_address:
1952 dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n"); 2286 dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
1953 return -EINVAL; 2287 return -EINVAL;
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index f333848fd3be..feca8c648766 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -34,9 +34,6 @@
34/* 34/*
35 * Local function declarations 35 * Local function declarations
36 */ 36 */
37static struct nfs_page * nfs_update_request(struct nfs_open_context*,
38 struct page *,
39 unsigned int, unsigned int);
40static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc, 37static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc,
41 struct inode *inode, int ioflags); 38 struct inode *inode, int ioflags);
42static void nfs_redirty_request(struct nfs_page *req); 39static void nfs_redirty_request(struct nfs_page *req);
@@ -169,29 +166,6 @@ static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int
169 SetPageUptodate(page); 166 SetPageUptodate(page);
170} 167}
171 168
172static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
173 unsigned int offset, unsigned int count)
174{
175 struct nfs_page *req;
176 int ret;
177
178 for (;;) {
179 req = nfs_update_request(ctx, page, offset, count);
180 if (!IS_ERR(req))
181 break;
182 ret = PTR_ERR(req);
183 if (ret != -EBUSY)
184 return ret;
185 ret = nfs_wb_page(page->mapping->host, page);
186 if (ret != 0)
187 return ret;
188 }
189 /* Update file length */
190 nfs_grow_file(page, offset, count);
191 nfs_clear_page_tag_locked(req);
192 return 0;
193}
194
195static int wb_priority(struct writeback_control *wbc) 169static int wb_priority(struct writeback_control *wbc)
196{ 170{
197 if (wbc->for_reclaim) 171 if (wbc->for_reclaim)
@@ -268,12 +242,9 @@ static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
268 return ret; 242 return ret;
269 spin_lock(&inode->i_lock); 243 spin_lock(&inode->i_lock);
270 } 244 }
271 if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) { 245 if (test_bit(PG_CLEAN, &req->wb_flags)) {
272 /* This request is marked for commit */
273 spin_unlock(&inode->i_lock); 246 spin_unlock(&inode->i_lock);
274 nfs_clear_page_tag_locked(req); 247 BUG();
275 nfs_pageio_complete(pgio);
276 return 0;
277 } 248 }
278 if (nfs_set_page_writeback(page) != 0) { 249 if (nfs_set_page_writeback(page) != 0) {
279 spin_unlock(&inode->i_lock); 250 spin_unlock(&inode->i_lock);
@@ -355,11 +326,19 @@ int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
355/* 326/*
356 * Insert a write request into an inode 327 * Insert a write request into an inode
357 */ 328 */
358static void nfs_inode_add_request(struct inode *inode, struct nfs_page *req) 329static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
359{ 330{
360 struct nfs_inode *nfsi = NFS_I(inode); 331 struct nfs_inode *nfsi = NFS_I(inode);
361 int error; 332 int error;
362 333
334 error = radix_tree_preload(GFP_NOFS);
335 if (error != 0)
336 goto out;
337
338 /* Lock the request! */
339 nfs_lock_request_dontget(req);
340
341 spin_lock(&inode->i_lock);
363 error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req); 342 error = radix_tree_insert(&nfsi->nfs_page_tree, req->wb_index, req);
364 BUG_ON(error); 343 BUG_ON(error);
365 if (!nfsi->npages) { 344 if (!nfsi->npages) {
@@ -373,6 +352,10 @@ static void nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
373 kref_get(&req->wb_kref); 352 kref_get(&req->wb_kref);
374 radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index, 353 radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index,
375 NFS_PAGE_TAG_LOCKED); 354 NFS_PAGE_TAG_LOCKED);
355 spin_unlock(&inode->i_lock);
356 radix_tree_preload_end();
357out:
358 return error;
376} 359}
377 360
378/* 361/*
@@ -405,19 +388,6 @@ nfs_mark_request_dirty(struct nfs_page *req)
405 __set_page_dirty_nobuffers(req->wb_page); 388 __set_page_dirty_nobuffers(req->wb_page);
406} 389}
407 390
408/*
409 * Check if a request is dirty
410 */
411static inline int
412nfs_dirty_request(struct nfs_page *req)
413{
414 struct page *page = req->wb_page;
415
416 if (page == NULL || test_bit(PG_NEED_COMMIT, &req->wb_flags))
417 return 0;
418 return !PageWriteback(page);
419}
420
421#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4) 391#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
422/* 392/*
423 * Add a request to the inode's commit list. 393 * Add a request to the inode's commit list.
@@ -430,7 +400,7 @@ nfs_mark_request_commit(struct nfs_page *req)
430 400
431 spin_lock(&inode->i_lock); 401 spin_lock(&inode->i_lock);
432 nfsi->ncommit++; 402 nfsi->ncommit++;
433 set_bit(PG_NEED_COMMIT, &(req)->wb_flags); 403 set_bit(PG_CLEAN, &(req)->wb_flags);
434 radix_tree_tag_set(&nfsi->nfs_page_tree, 404 radix_tree_tag_set(&nfsi->nfs_page_tree,
435 req->wb_index, 405 req->wb_index,
436 NFS_PAGE_TAG_COMMIT); 406 NFS_PAGE_TAG_COMMIT);
@@ -440,6 +410,19 @@ nfs_mark_request_commit(struct nfs_page *req)
440 __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 410 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
441} 411}
442 412
413static int
414nfs_clear_request_commit(struct nfs_page *req)
415{
416 struct page *page = req->wb_page;
417
418 if (test_and_clear_bit(PG_CLEAN, &(req)->wb_flags)) {
419 dec_zone_page_state(page, NR_UNSTABLE_NFS);
420 dec_bdi_stat(page->mapping->backing_dev_info, BDI_RECLAIMABLE);
421 return 1;
422 }
423 return 0;
424}
425
443static inline 426static inline
444int nfs_write_need_commit(struct nfs_write_data *data) 427int nfs_write_need_commit(struct nfs_write_data *data)
445{ 428{
@@ -449,7 +432,7 @@ int nfs_write_need_commit(struct nfs_write_data *data)
449static inline 432static inline
450int nfs_reschedule_unstable_write(struct nfs_page *req) 433int nfs_reschedule_unstable_write(struct nfs_page *req)
451{ 434{
452 if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) { 435 if (test_and_clear_bit(PG_NEED_COMMIT, &req->wb_flags)) {
453 nfs_mark_request_commit(req); 436 nfs_mark_request_commit(req);
454 return 1; 437 return 1;
455 } 438 }
@@ -465,6 +448,12 @@ nfs_mark_request_commit(struct nfs_page *req)
465{ 448{
466} 449}
467 450
451static inline int
452nfs_clear_request_commit(struct nfs_page *req)
453{
454 return 0;
455}
456
468static inline 457static inline
469int nfs_write_need_commit(struct nfs_write_data *data) 458int nfs_write_need_commit(struct nfs_write_data *data)
470{ 459{
@@ -522,11 +511,8 @@ static void nfs_cancel_commit_list(struct list_head *head)
522 511
523 while(!list_empty(head)) { 512 while(!list_empty(head)) {
524 req = nfs_list_entry(head->next); 513 req = nfs_list_entry(head->next);
525 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
526 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
527 BDI_RECLAIMABLE);
528 nfs_list_remove_request(req); 514 nfs_list_remove_request(req);
529 clear_bit(PG_NEED_COMMIT, &(req)->wb_flags); 515 nfs_clear_request_commit(req);
530 nfs_inode_remove_request(req); 516 nfs_inode_remove_request(req);
531 nfs_unlock_request(req); 517 nfs_unlock_request(req);
532 } 518 }
@@ -564,110 +550,124 @@ static inline int nfs_scan_commit(struct inode *inode, struct list_head *dst, pg
564#endif 550#endif
565 551
566/* 552/*
567 * Try to update any existing write request, or create one if there is none. 553 * Search for an existing write request, and attempt to update
568 * In order to match, the request's credentials must match those of 554 * it to reflect a new dirty region on a given page.
569 * the calling process.
570 * 555 *
571 * Note: Should always be called with the Page Lock held! 556 * If the attempt fails, then the existing request is flushed out
557 * to disk.
572 */ 558 */
573static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx, 559static struct nfs_page *nfs_try_to_update_request(struct inode *inode,
574 struct page *page, unsigned int offset, unsigned int bytes) 560 struct page *page,
561 unsigned int offset,
562 unsigned int bytes)
575{ 563{
576 struct address_space *mapping = page->mapping; 564 struct nfs_page *req;
577 struct inode *inode = mapping->host; 565 unsigned int rqend;
578 struct nfs_page *req, *new = NULL; 566 unsigned int end;
579 pgoff_t rqend, end; 567 int error;
568
569 if (!PagePrivate(page))
570 return NULL;
580 571
581 end = offset + bytes; 572 end = offset + bytes;
573 spin_lock(&inode->i_lock);
582 574
583 for (;;) { 575 for (;;) {
584 /* Loop over all inode entries and see if we find 576 req = nfs_page_find_request_locked(page);
585 * A request for the page we wish to update 577 if (req == NULL)
578 goto out_unlock;
579
580 rqend = req->wb_offset + req->wb_bytes;
581 /*
582 * Tell the caller to flush out the request if
583 * the offsets are non-contiguous.
584 * Note: nfs_flush_incompatible() will already
585 * have flushed out requests having wrong owners.
586 */ 586 */
587 if (new) { 587 if (offset > rqend
588 if (radix_tree_preload(GFP_NOFS)) { 588 || end < req->wb_offset)
589 nfs_release_request(new); 589 goto out_flushme;
590 return ERR_PTR(-ENOMEM);
591 }
592 }
593 590
594 spin_lock(&inode->i_lock); 591 if (nfs_set_page_tag_locked(req))
595 req = nfs_page_find_request_locked(page);
596 if (req) {
597 if (!nfs_set_page_tag_locked(req)) {
598 int error;
599
600 spin_unlock(&inode->i_lock);
601 error = nfs_wait_on_request(req);
602 nfs_release_request(req);
603 if (error < 0) {
604 if (new) {
605 radix_tree_preload_end();
606 nfs_release_request(new);
607 }
608 return ERR_PTR(error);
609 }
610 continue;
611 }
612 spin_unlock(&inode->i_lock);
613 if (new) {
614 radix_tree_preload_end();
615 nfs_release_request(new);
616 }
617 break; 592 break;
618 }
619 593
620 if (new) { 594 /* The request is locked, so wait and then retry */
621 nfs_lock_request_dontget(new);
622 nfs_inode_add_request(inode, new);
623 spin_unlock(&inode->i_lock);
624 radix_tree_preload_end();
625 req = new;
626 goto zero_page;
627 }
628 spin_unlock(&inode->i_lock); 595 spin_unlock(&inode->i_lock);
629 596 error = nfs_wait_on_request(req);
630 new = nfs_create_request(ctx, inode, page, offset, bytes); 597 nfs_release_request(req);
631 if (IS_ERR(new)) 598 if (error != 0)
632 return new; 599 goto out_err;
600 spin_lock(&inode->i_lock);
633 } 601 }
634 602
635 /* We have a request for our page. 603 if (nfs_clear_request_commit(req))
636 * If the creds don't match, or the 604 radix_tree_tag_clear(&NFS_I(inode)->nfs_page_tree,
637 * page addresses don't match, 605 req->wb_index, NFS_PAGE_TAG_COMMIT);
638 * tell the caller to wait on the conflicting
639 * request.
640 */
641 rqend = req->wb_offset + req->wb_bytes;
642 if (req->wb_context != ctx
643 || req->wb_page != page
644 || !nfs_dirty_request(req)
645 || offset > rqend || end < req->wb_offset) {
646 nfs_clear_page_tag_locked(req);
647 return ERR_PTR(-EBUSY);
648 }
649 606
650 /* Okay, the request matches. Update the region */ 607 /* Okay, the request matches. Update the region */
651 if (offset < req->wb_offset) { 608 if (offset < req->wb_offset) {
652 req->wb_offset = offset; 609 req->wb_offset = offset;
653 req->wb_pgbase = offset; 610 req->wb_pgbase = offset;
654 req->wb_bytes = max(end, rqend) - req->wb_offset;
655 goto zero_page;
656 } 611 }
657
658 if (end > rqend) 612 if (end > rqend)
659 req->wb_bytes = end - req->wb_offset; 613 req->wb_bytes = end - req->wb_offset;
660 614 else
615 req->wb_bytes = rqend - req->wb_offset;
616out_unlock:
617 spin_unlock(&inode->i_lock);
661 return req; 618 return req;
662zero_page: 619out_flushme:
663 /* If this page might potentially be marked as up to date, 620 spin_unlock(&inode->i_lock);
664 * then we need to zero any uninitalised data. */ 621 nfs_release_request(req);
665 if (req->wb_pgbase == 0 && req->wb_bytes != PAGE_CACHE_SIZE 622 error = nfs_wb_page(inode, page);
666 && !PageUptodate(req->wb_page)) 623out_err:
667 zero_user_segment(req->wb_page, req->wb_bytes, PAGE_CACHE_SIZE); 624 return ERR_PTR(error);
625}
626
627/*
628 * Try to update an existing write request, or create one if there is none.
629 *
630 * Note: Should always be called with the Page Lock held to prevent races
631 * if we have to add a new request. Also assumes that the caller has
632 * already called nfs_flush_incompatible() if necessary.
633 */
634static struct nfs_page * nfs_setup_write_request(struct nfs_open_context* ctx,
635 struct page *page, unsigned int offset, unsigned int bytes)
636{
637 struct inode *inode = page->mapping->host;
638 struct nfs_page *req;
639 int error;
640
641 req = nfs_try_to_update_request(inode, page, offset, bytes);
642 if (req != NULL)
643 goto out;
644 req = nfs_create_request(ctx, inode, page, offset, bytes);
645 if (IS_ERR(req))
646 goto out;
647 error = nfs_inode_add_request(inode, req);
648 if (error != 0) {
649 nfs_release_request(req);
650 req = ERR_PTR(error);
651 }
652out:
668 return req; 653 return req;
669} 654}
670 655
656static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
657 unsigned int offset, unsigned int count)
658{
659 struct nfs_page *req;
660
661 req = nfs_setup_write_request(ctx, page, offset, count);
662 if (IS_ERR(req))
663 return PTR_ERR(req);
664 /* Update file length */
665 nfs_grow_file(page, offset, count);
666 nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
667 nfs_clear_page_tag_locked(req);
668 return 0;
669}
670
671int nfs_flush_incompatible(struct file *file, struct page *page) 671int nfs_flush_incompatible(struct file *file, struct page *page)
672{ 672{
673 struct nfs_open_context *ctx = nfs_file_open_context(file); 673 struct nfs_open_context *ctx = nfs_file_open_context(file);
@@ -685,8 +685,7 @@ int nfs_flush_incompatible(struct file *file, struct page *page)
685 req = nfs_page_find_request(page); 685 req = nfs_page_find_request(page);
686 if (req == NULL) 686 if (req == NULL)
687 return 0; 687 return 0;
688 do_flush = req->wb_page != page || req->wb_context != ctx 688 do_flush = req->wb_page != page || req->wb_context != ctx;
689 || !nfs_dirty_request(req);
690 nfs_release_request(req); 689 nfs_release_request(req);
691 if (!do_flush) 690 if (!do_flush)
692 return 0; 691 return 0;
@@ -721,10 +720,10 @@ int nfs_updatepage(struct file *file, struct page *page,
721 720
722 nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE); 721 nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);
723 722
724 dprintk("NFS: nfs_updatepage(%s/%s %d@%Ld)\n", 723 dprintk("NFS: nfs_updatepage(%s/%s %d@%lld)\n",
725 file->f_path.dentry->d_parent->d_name.name, 724 file->f_path.dentry->d_parent->d_name.name,
726 file->f_path.dentry->d_name.name, count, 725 file->f_path.dentry->d_name.name, count,
727 (long long)(page_offset(page) +offset)); 726 (long long)(page_offset(page) + offset));
728 727
729 /* If we're not using byte range locks, and we know the page 728 /* If we're not using byte range locks, and we know the page
730 * is up to date, it may be more efficient to extend the write 729 * is up to date, it may be more efficient to extend the write
@@ -744,7 +743,7 @@ int nfs_updatepage(struct file *file, struct page *page,
744 else 743 else
745 __set_page_dirty_nobuffers(page); 744 __set_page_dirty_nobuffers(page);
746 745
747 dprintk("NFS: nfs_updatepage returns %d (isize %Ld)\n", 746 dprintk("NFS: nfs_updatepage returns %d (isize %lld)\n",
748 status, (long long)i_size_read(inode)); 747 status, (long long)i_size_read(inode));
749 return status; 748 return status;
750} 749}
@@ -752,12 +751,7 @@ int nfs_updatepage(struct file *file, struct page *page,
752static void nfs_writepage_release(struct nfs_page *req) 751static void nfs_writepage_release(struct nfs_page *req)
753{ 752{
754 753
755 if (PageError(req->wb_page)) { 754 if (PageError(req->wb_page) || !nfs_reschedule_unstable_write(req)) {
756 nfs_end_page_writeback(req->wb_page);
757 nfs_inode_remove_request(req);
758 } else if (!nfs_reschedule_unstable_write(req)) {
759 /* Set the PG_uptodate flag */
760 nfs_mark_uptodate(req->wb_page, req->wb_pgbase, req->wb_bytes);
761 nfs_end_page_writeback(req->wb_page); 755 nfs_end_page_writeback(req->wb_page);
762 nfs_inode_remove_request(req); 756 nfs_inode_remove_request(req);
763 } else 757 } else
@@ -834,7 +828,7 @@ static int nfs_write_rpcsetup(struct nfs_page *req,
834 NFS_PROTO(inode)->write_setup(data, &msg); 828 NFS_PROTO(inode)->write_setup(data, &msg);
835 829
836 dprintk("NFS: %5u initiated write call " 830 dprintk("NFS: %5u initiated write call "
837 "(req %s/%Ld, %u bytes @ offset %Lu)\n", 831 "(req %s/%lld, %u bytes @ offset %llu)\n",
838 data->task.tk_pid, 832 data->task.tk_pid,
839 inode->i_sb->s_id, 833 inode->i_sb->s_id,
840 (long long)NFS_FILEID(inode), 834 (long long)NFS_FILEID(inode),
@@ -978,13 +972,13 @@ static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
978static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata) 972static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
979{ 973{
980 struct nfs_write_data *data = calldata; 974 struct nfs_write_data *data = calldata;
981 struct nfs_page *req = data->req;
982 975
983 dprintk("NFS: write (%s/%Ld %d@%Ld)", 976 dprintk("NFS: %5u write(%s/%lld %d@%lld)",
984 req->wb_context->path.dentry->d_inode->i_sb->s_id, 977 task->tk_pid,
985 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode), 978 data->req->wb_context->path.dentry->d_inode->i_sb->s_id,
986 req->wb_bytes, 979 (long long)
987 (long long)req_offset(req)); 980 NFS_FILEID(data->req->wb_context->path.dentry->d_inode),
981 data->req->wb_bytes, (long long)req_offset(data->req));
988 982
989 nfs_writeback_done(task, data); 983 nfs_writeback_done(task, data);
990} 984}
@@ -1058,7 +1052,8 @@ static void nfs_writeback_release_full(void *calldata)
1058 1052
1059 nfs_list_remove_request(req); 1053 nfs_list_remove_request(req);
1060 1054
1061 dprintk("NFS: write (%s/%Ld %d@%Ld)", 1055 dprintk("NFS: %5u write (%s/%lld %d@%lld)",
1056 data->task.tk_pid,
1062 req->wb_context->path.dentry->d_inode->i_sb->s_id, 1057 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1063 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode), 1058 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
1064 req->wb_bytes, 1059 req->wb_bytes,
@@ -1078,8 +1073,6 @@ static void nfs_writeback_release_full(void *calldata)
1078 dprintk(" marked for commit\n"); 1073 dprintk(" marked for commit\n");
1079 goto next; 1074 goto next;
1080 } 1075 }
1081 /* Set the PG_uptodate flag? */
1082 nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
1083 dprintk(" OK\n"); 1076 dprintk(" OK\n");
1084remove_request: 1077remove_request:
1085 nfs_end_page_writeback(page); 1078 nfs_end_page_writeback(page);
@@ -1133,7 +1126,7 @@ int nfs_writeback_done(struct rpc_task *task, struct nfs_write_data *data)
1133 static unsigned long complain; 1126 static unsigned long complain;
1134 1127
1135 if (time_before(complain, jiffies)) { 1128 if (time_before(complain, jiffies)) {
1136 dprintk("NFS: faulty NFS server %s:" 1129 dprintk("NFS: faulty NFS server %s:"
1137 " (committed = %d) != (stable = %d)\n", 1130 " (committed = %d) != (stable = %d)\n",
1138 NFS_SERVER(data->inode)->nfs_client->cl_hostname, 1131 NFS_SERVER(data->inode)->nfs_client->cl_hostname,
1139 resp->verf->committed, argp->stable); 1132 resp->verf->committed, argp->stable);
@@ -1297,12 +1290,9 @@ static void nfs_commit_release(void *calldata)
1297 while (!list_empty(&data->pages)) { 1290 while (!list_empty(&data->pages)) {
1298 req = nfs_list_entry(data->pages.next); 1291 req = nfs_list_entry(data->pages.next);
1299 nfs_list_remove_request(req); 1292 nfs_list_remove_request(req);
1300 clear_bit(PG_NEED_COMMIT, &(req)->wb_flags); 1293 nfs_clear_request_commit(req);
1301 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
1302 dec_bdi_stat(req->wb_page->mapping->backing_dev_info,
1303 BDI_RECLAIMABLE);
1304 1294
1305 dprintk("NFS: commit (%s/%Ld %d@%Ld)", 1295 dprintk("NFS: commit (%s/%lld %d@%lld)",
1306 req->wb_context->path.dentry->d_inode->i_sb->s_id, 1296 req->wb_context->path.dentry->d_inode->i_sb->s_id,
1307 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode), 1297 (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
1308 req->wb_bytes, 1298 req->wb_bytes,
@@ -1318,9 +1308,6 @@ static void nfs_commit_release(void *calldata)
1318 * returned by the server against all stored verfs. */ 1308 * returned by the server against all stored verfs. */
1319 if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) { 1309 if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) {
1320 /* We have a match */ 1310 /* We have a match */
1321 /* Set the PG_uptodate flag */
1322 nfs_mark_uptodate(req->wb_page, req->wb_pgbase,
1323 req->wb_bytes);
1324 nfs_inode_remove_request(req); 1311 nfs_inode_remove_request(req);
1325 dprintk(" OK\n"); 1312 dprintk(" OK\n");
1326 goto next; 1313 goto next;
@@ -1479,7 +1466,7 @@ int nfs_wb_page_cancel(struct inode *inode, struct page *page)
1479 req = nfs_page_find_request(page); 1466 req = nfs_page_find_request(page);
1480 if (req == NULL) 1467 if (req == NULL)
1481 goto out; 1468 goto out;
1482 if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) { 1469 if (test_bit(PG_CLEAN, &req->wb_flags)) {
1483 nfs_release_request(req); 1470 nfs_release_request(req);
1484 break; 1471 break;
1485 } 1472 }
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-10 16:02:20 -0500