blob: 937fbfc381bbd4746ddf55367df2d920d44dc0fe [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfs/inode.c
3 *
4 * Copyright (C) 1992 Rick Sladkey
5 *
6 * nfs inode and superblock handling functions
7 *
8 * Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
9 * experimental NFS changes. Modularisation taken straight from SYS5 fs.
10 *
11 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
12 * J.S.Peatfield@damtp.cam.ac.uk
13 *
14 */
15
16#include <linux/config.h>
17#include <linux/module.h>
18#include <linux/init.h>
19
20#include <linux/time.h>
21#include <linux/kernel.h>
22#include <linux/mm.h>
23#include <linux/string.h>
24#include <linux/stat.h>
25#include <linux/errno.h>
26#include <linux/unistd.h>
27#include <linux/sunrpc/clnt.h>
28#include <linux/sunrpc/stats.h>
Chuck Lever4ece3a22006-03-20 13:44:22 -050029#include <linux/sunrpc/metrics.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/nfs_fs.h>
31#include <linux/nfs_mount.h>
32#include <linux/nfs4_mount.h>
33#include <linux/lockd/bind.h>
34#include <linux/smp_lock.h>
35#include <linux/seq_file.h>
36#include <linux/mount.h>
37#include <linux/nfs_idmap.h>
38#include <linux/vfs.h>
39
40#include <asm/system.h>
41#include <asm/uaccess.h>
42
Trond Myklebust4ce79712005-06-22 17:16:21 +000043#include "nfs4_fs.h"
Trond Myklebusta72b4422006-01-03 09:55:41 +010044#include "callback.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include "delegation.h"
Chuck Leverd9ef5a82006-03-20 13:44:13 -050046#include "iostat.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
48#define NFSDBG_FACILITY NFSDBG_VFS
49#define NFS_PARANOIA 1
50
51/* Maximum number of readahead requests
52 * FIXME: this should really be a sysctl so that users may tune it to suit
53 * their needs. People that do NFS over a slow network, might for
54 * instance want to reduce it to something closer to 1 for improved
55 * interactive response.
56 */
57#define NFS_MAX_READAHEAD (RPC_DEF_SLOT_TABLE - 1)
58
59static void nfs_invalidate_inode(struct inode *);
Trond Myklebust24aa1fe2005-12-03 15:20:07 -050060static int nfs_update_inode(struct inode *, struct nfs_fattr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62static struct inode *nfs_alloc_inode(struct super_block *sb);
63static void nfs_destroy_inode(struct inode *);
64static int nfs_write_inode(struct inode *,int);
65static void nfs_delete_inode(struct inode *);
66static void nfs_clear_inode(struct inode *);
67static void nfs_umount_begin(struct super_block *);
David Howells726c3342006-06-23 02:02:58 -070068static int nfs_statfs(struct dentry *, struct kstatfs *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069static int nfs_show_options(struct seq_file *, struct vfsmount *);
Chuck Leverd9ef5a82006-03-20 13:44:13 -050070static int nfs_show_stats(struct seq_file *, struct vfsmount *);
Trond Myklebustada70d92005-06-22 17:16:22 +000071static void nfs_zap_acl_cache(struct inode *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73static struct rpc_program nfs_program;
74
75static struct super_operations nfs_sops = {
76 .alloc_inode = nfs_alloc_inode,
77 .destroy_inode = nfs_destroy_inode,
78 .write_inode = nfs_write_inode,
79 .delete_inode = nfs_delete_inode,
80 .statfs = nfs_statfs,
81 .clear_inode = nfs_clear_inode,
82 .umount_begin = nfs_umount_begin,
83 .show_options = nfs_show_options,
Chuck Leverd9ef5a82006-03-20 13:44:13 -050084 .show_stats = nfs_show_stats,
Linus Torvalds1da177e2005-04-16 15:20:36 -070085};
86
87/*
88 * RPC cruft for NFS
89 */
90static struct rpc_stat nfs_rpcstat = {
91 .program = &nfs_program
92};
93static struct rpc_version * nfs_version[] = {
94 NULL,
95 NULL,
96 &nfs_version2,
97#if defined(CONFIG_NFS_V3)
98 &nfs_version3,
99#elif defined(CONFIG_NFS_V4)
100 NULL,
101#endif
102#if defined(CONFIG_NFS_V4)
103 &nfs_version4,
104#endif
105};
106
107static struct rpc_program nfs_program = {
108 .name = "nfs",
109 .number = NFS_PROGRAM,
Tobias Klausere8c96f82006-03-24 03:15:34 -0800110 .nrvers = ARRAY_SIZE(nfs_version),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 .version = nfs_version,
112 .stats = &nfs_rpcstat,
113 .pipe_dir_name = "/nfs",
114};
115
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000116#ifdef CONFIG_NFS_V3_ACL
117static struct rpc_stat nfsacl_rpcstat = { &nfsacl_program };
118static struct rpc_version * nfsacl_version[] = {
119 [3] = &nfsacl_version3,
120};
121
122struct rpc_program nfsacl_program = {
123 .name = "nfsacl",
124 .number = NFS_ACL_PROGRAM,
Tobias Klausere8c96f82006-03-24 03:15:34 -0800125 .nrvers = ARRAY_SIZE(nfsacl_version),
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000126 .version = nfsacl_version,
127 .stats = &nfsacl_rpcstat,
128};
129#endif /* CONFIG_NFS_V3_ACL */
130
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131static inline unsigned long
132nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
133{
134 return nfs_fileid_to_ino_t(fattr->fileid);
135}
136
137static int
138nfs_write_inode(struct inode *inode, int sync)
139{
Trond Myklebustc42de9d2006-03-20 13:44:51 -0500140 int flags = sync ? FLUSH_SYNC : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 int ret;
142
Trond Myklebust3da28eb2005-06-22 17:16:31 +0000143 ret = nfs_commit_inode(inode, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 if (ret < 0)
145 return ret;
146 return 0;
147}
148
149static void
150nfs_delete_inode(struct inode * inode)
151{
152 dprintk("NFS: delete_inode(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino);
153
Mark Fashehfef26652005-09-09 13:01:31 -0700154 truncate_inode_pages(&inode->i_data, 0);
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 nfs_wb_all(inode);
157 /*
158 * The following should never happen...
159 */
160 if (nfs_have_writebacks(inode)) {
161 printk(KERN_ERR "nfs_delete_inode: inode %ld has pending RPC requests\n", inode->i_ino);
162 }
163
164 clear_inode(inode);
165}
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167static void
168nfs_clear_inode(struct inode *inode)
169{
170 struct nfs_inode *nfsi = NFS_I(inode);
171 struct rpc_cred *cred;
172
173 nfs_wb_all(inode);
174 BUG_ON (!list_empty(&nfsi->open_files));
Trond Myklebustada70d92005-06-22 17:16:22 +0000175 nfs_zap_acl_cache(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 cred = nfsi->cache_access.cred;
177 if (cred)
178 put_rpccred(cred);
179 BUG_ON(atomic_read(&nfsi->data_updates) != 0);
180}
181
182void
183nfs_umount_begin(struct super_block *sb)
184{
J. Bruce Fields6a192752005-06-22 17:16:23 +0000185 struct rpc_clnt *rpc = NFS_SB(sb)->client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
187 /* -EIO all pending I/O */
J. Bruce Fields6a192752005-06-22 17:16:23 +0000188 if (!IS_ERR(rpc))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 rpc_killall_tasks(rpc);
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000190 rpc = NFS_SB(sb)->client_acl;
191 if (!IS_ERR(rpc))
192 rpc_killall_tasks(rpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193}
194
195
196static inline unsigned long
197nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp)
198{
199 /* make sure blocksize is a power of two */
200 if ((bsize & (bsize - 1)) || nrbitsp) {
201 unsigned char nrbits;
202
203 for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--)
204 ;
205 bsize = 1 << nrbits;
206 if (nrbitsp)
207 *nrbitsp = nrbits;
208 }
209
210 return bsize;
211}
212
213/*
214 * Calculate the number of 512byte blocks used.
215 */
216static inline unsigned long
217nfs_calc_block_size(u64 tsize)
218{
219 loff_t used = (tsize + 511) >> 9;
220 return (used > ULONG_MAX) ? ULONG_MAX : used;
221}
222
223/*
224 * Compute and set NFS server blocksize
225 */
226static inline unsigned long
227nfs_block_size(unsigned long bsize, unsigned char *nrbitsp)
228{
Chuck Lever40859d72005-11-30 18:09:02 -0500229 if (bsize < NFS_MIN_FILE_IO_SIZE)
230 bsize = NFS_DEF_FILE_IO_SIZE;
231 else if (bsize >= NFS_MAX_FILE_IO_SIZE)
232 bsize = NFS_MAX_FILE_IO_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
234 return nfs_block_bits(bsize, nrbitsp);
235}
236
237/*
238 * Obtain the root inode of the file system.
239 */
240static struct inode *
241nfs_get_root(struct super_block *sb, struct nfs_fh *rootfh, struct nfs_fsinfo *fsinfo)
242{
243 struct nfs_server *server = NFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 int error;
245
246 error = server->rpc_ops->getroot(server, rootfh, fsinfo);
247 if (error < 0) {
248 dprintk("nfs_get_root: getattr error = %d\n", -error);
249 return ERR_PTR(error);
250 }
251
Trond Myklebust03f28e32006-03-20 13:44:48 -0500252 return nfs_fhget(sb, rootfh, fsinfo->fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253}
254
255/*
256 * Do NFS version-independent mount processing, and sanity checking
257 */
258static int
259nfs_sb_init(struct super_block *sb, rpc_authflavor_t authflavor)
260{
261 struct nfs_server *server;
262 struct inode *root_inode;
263 struct nfs_fattr fattr;
264 struct nfs_fsinfo fsinfo = {
265 .fattr = &fattr,
266 };
267 struct nfs_pathconf pathinfo = {
268 .fattr = &fattr,
269 };
270 int no_root_error = 0;
271 unsigned long max_rpc_payload;
272
273 /* We probably want something more informative here */
274 snprintf(sb->s_id, sizeof(sb->s_id), "%x:%x", MAJOR(sb->s_dev), MINOR(sb->s_dev));
275
276 server = NFS_SB(sb);
277
278 sb->s_magic = NFS_SUPER_MAGIC;
279
Trond Myklebust01d0ae82006-03-20 13:44:48 -0500280 server->io_stats = nfs_alloc_iostats();
281 if (server->io_stats == NULL)
282 return -ENOMEM;
283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 root_inode = nfs_get_root(sb, &server->fh, &fsinfo);
285 /* Did getting the root inode fail? */
286 if (IS_ERR(root_inode)) {
287 no_root_error = PTR_ERR(root_inode);
288 goto out_no_root;
289 }
290 sb->s_root = d_alloc_root(root_inode);
291 if (!sb->s_root) {
292 no_root_error = -ENOMEM;
293 goto out_no_root;
294 }
295 sb->s_root->d_op = server->rpc_ops->dentry_ops;
296
Chuck Lever67ec9f42006-03-20 13:44:15 -0500297 /* mount time stamp, in seconds */
298 server->mount_time = jiffies;
299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 /* Get some general file system info */
301 if (server->namelen == 0 &&
302 server->rpc_ops->pathconf(server, &server->fh, &pathinfo) >= 0)
303 server->namelen = pathinfo.max_namelen;
304 /* Work out a lot of parameters */
305 if (server->rsize == 0)
306 server->rsize = nfs_block_size(fsinfo.rtpref, NULL);
307 if (server->wsize == 0)
308 server->wsize = nfs_block_size(fsinfo.wtpref, NULL);
309
310 if (fsinfo.rtmax >= 512 && server->rsize > fsinfo.rtmax)
311 server->rsize = nfs_block_size(fsinfo.rtmax, NULL);
312 if (fsinfo.wtmax >= 512 && server->wsize > fsinfo.wtmax)
313 server->wsize = nfs_block_size(fsinfo.wtmax, NULL);
314
315 max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);
316 if (server->rsize > max_rpc_payload)
317 server->rsize = max_rpc_payload;
Chuck Lever40859d72005-11-30 18:09:02 -0500318 if (server->rsize > NFS_MAX_FILE_IO_SIZE)
319 server->rsize = NFS_MAX_FILE_IO_SIZE;
320 server->rpages = (server->rsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 if (server->wsize > max_rpc_payload)
323 server->wsize = max_rpc_payload;
Chuck Lever40859d72005-11-30 18:09:02 -0500324 if (server->wsize > NFS_MAX_FILE_IO_SIZE)
325 server->wsize = NFS_MAX_FILE_IO_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 server->wpages = (server->wsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328 if (sb->s_blocksize == 0)
329 sb->s_blocksize = nfs_block_bits(server->wsize,
330 &sb->s_blocksize_bits);
331 server->wtmult = nfs_block_bits(fsinfo.wtmult, NULL);
332
333 server->dtsize = nfs_block_size(fsinfo.dtpref, NULL);
334 if (server->dtsize > PAGE_CACHE_SIZE)
335 server->dtsize = PAGE_CACHE_SIZE;
336 if (server->dtsize > server->rsize)
337 server->dtsize = server->rsize;
338
339 if (server->flags & NFS_MOUNT_NOAC) {
340 server->acregmin = server->acregmax = 0;
341 server->acdirmin = server->acdirmax = 0;
342 sb->s_flags |= MS_SYNCHRONOUS;
343 }
344 server->backing_dev_info.ra_pages = server->rpages * NFS_MAX_READAHEAD;
345
346 sb->s_maxbytes = fsinfo.maxfilesize;
347 if (sb->s_maxbytes > MAX_LFS_FILESIZE)
348 sb->s_maxbytes = MAX_LFS_FILESIZE;
349
350 server->client->cl_intr = (server->flags & NFS_MOUNT_INTR) ? 1 : 0;
351 server->client->cl_softrtry = (server->flags & NFS_MOUNT_SOFT) ? 1 : 0;
352
353 /* We're airborne Set socket buffersize */
354 rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
355 return 0;
356 /* Yargs. It didn't work out. */
357out_no_root:
358 dprintk("nfs_sb_init: get root inode failed: errno %d\n", -no_root_error);
359 if (!IS_ERR(root_inode))
360 iput(root_inode);
361 return no_root_error;
362}
363
Chuck Levereab5c082005-08-11 16:25:14 -0400364static void nfs_init_timeout_values(struct rpc_timeout *to, int proto, unsigned int timeo, unsigned int retrans)
365{
366 to->to_initval = timeo * HZ / 10;
367 to->to_retries = retrans;
368 if (!to->to_retries)
369 to->to_retries = 2;
370
371 switch (proto) {
372 case IPPROTO_TCP:
373 if (!to->to_initval)
374 to->to_initval = 60 * HZ;
Chuck Lever03bf4b72005-08-25 16:25:55 -0700375 if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
376 to->to_initval = NFS_MAX_TCP_TIMEOUT;
Chuck Levereab5c082005-08-11 16:25:14 -0400377 to->to_increment = to->to_initval;
378 to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
379 to->to_exponential = 0;
380 break;
381 case IPPROTO_UDP:
382 default:
383 if (!to->to_initval)
384 to->to_initval = 11 * HZ / 10;
Chuck Lever03bf4b72005-08-25 16:25:55 -0700385 if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
386 to->to_initval = NFS_MAX_UDP_TIMEOUT;
387 to->to_maxval = NFS_MAX_UDP_TIMEOUT;
Chuck Levereab5c082005-08-11 16:25:14 -0400388 to->to_exponential = 1;
389 break;
390 }
391}
392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393/*
394 * Create an RPC client handle.
395 */
396static struct rpc_clnt *
397nfs_create_client(struct nfs_server *server, const struct nfs_mount_data *data)
398{
399 struct rpc_timeout timeparms;
400 struct rpc_xprt *xprt = NULL;
401 struct rpc_clnt *clnt = NULL;
Chuck Levereab5c082005-08-11 16:25:14 -0400402 int proto = (data->flags & NFS_MOUNT_TCP) ? IPPROTO_TCP : IPPROTO_UDP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Chuck Levereab5c082005-08-11 16:25:14 -0400404 nfs_init_timeout_values(&timeparms, proto, data->timeo, data->retrans);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
Chuck Lever7a480e22006-03-20 13:44:12 -0500406 server->retrans_timeo = timeparms.to_initval;
407 server->retrans_count = timeparms.to_retries;
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 /* create transport and client */
Chuck Levereab5c082005-08-11 16:25:14 -0400410 xprt = xprt_create_proto(proto, &server->addr, &timeparms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 if (IS_ERR(xprt)) {
Trond Myklebust9085bbc2005-06-22 17:16:20 +0000412 dprintk("%s: cannot create RPC transport. Error = %ld\n",
413 __FUNCTION__, PTR_ERR(xprt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 return (struct rpc_clnt *)xprt;
415 }
416 clnt = rpc_create_client(xprt, server->hostname, &nfs_program,
417 server->rpc_ops->version, data->pseudoflavor);
418 if (IS_ERR(clnt)) {
Trond Myklebust9085bbc2005-06-22 17:16:20 +0000419 dprintk("%s: cannot create RPC client. Error = %ld\n",
420 __FUNCTION__, PTR_ERR(xprt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 goto out_fail;
422 }
423
424 clnt->cl_intr = 1;
425 clnt->cl_softrtry = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
427 return clnt;
428
429out_fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 return clnt;
431}
432
433/*
434 * The way this works is that the mount process passes a structure
435 * in the data argument which contains the server's IP address
436 * and the root file handle obtained from the server's mount
437 * daemon. We stash these away in the private superblock fields.
438 */
439static int
440nfs_fill_super(struct super_block *sb, struct nfs_mount_data *data, int silent)
441{
442 struct nfs_server *server;
443 rpc_authflavor_t authflavor;
444
445 server = NFS_SB(sb);
446 sb->s_blocksize_bits = 0;
447 sb->s_blocksize = 0;
448 if (data->bsize)
449 sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
450 if (data->rsize)
451 server->rsize = nfs_block_size(data->rsize, NULL);
452 if (data->wsize)
453 server->wsize = nfs_block_size(data->wsize, NULL);
454 server->flags = data->flags & NFS_MOUNT_FLAGMASK;
455
456 server->acregmin = data->acregmin*HZ;
457 server->acregmax = data->acregmax*HZ;
458 server->acdirmin = data->acdirmin*HZ;
459 server->acdirmax = data->acdirmax*HZ;
460
461 /* Start lockd here, before we might error out */
462 if (!(server->flags & NFS_MOUNT_NONLM))
463 lockd_up();
464
465 server->namelen = data->namlen;
466 server->hostname = kmalloc(strlen(data->hostname) + 1, GFP_KERNEL);
467 if (!server->hostname)
468 return -ENOMEM;
469 strcpy(server->hostname, data->hostname);
470
471 /* Check NFS protocol revision and initialize RPC op vector
472 * and file handle pool. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473#ifdef CONFIG_NFS_V3
Trond Myklebust9085bbc2005-06-22 17:16:20 +0000474 if (server->flags & NFS_MOUNT_VER3) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 server->rpc_ops = &nfs_v3_clientops;
476 server->caps |= NFS_CAP_READDIRPLUS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 } else {
478 server->rpc_ops = &nfs_v2_clientops;
479 }
Trond Myklebust9085bbc2005-06-22 17:16:20 +0000480#else
481 server->rpc_ops = &nfs_v2_clientops;
482#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 /* Fill in pseudoflavor for mount version < 5 */
485 if (!(data->flags & NFS_MOUNT_SECFLAVOUR))
486 data->pseudoflavor = RPC_AUTH_UNIX;
487 authflavor = data->pseudoflavor; /* save for sb_init() */
488 /* XXX maybe we want to add a server->pseudoflavor field */
489
490 /* Create RPC client handles */
491 server->client = nfs_create_client(server, data);
492 if (IS_ERR(server->client))
493 return PTR_ERR(server->client);
494 /* RFC 2623, sec 2.3.2 */
495 if (authflavor != RPC_AUTH_UNIX) {
J. Bruce Fields6a192752005-06-22 17:16:23 +0000496 struct rpc_auth *auth;
497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 server->client_sys = rpc_clone_client(server->client);
499 if (IS_ERR(server->client_sys))
500 return PTR_ERR(server->client_sys);
J. Bruce Fields6a192752005-06-22 17:16:23 +0000501 auth = rpcauth_create(RPC_AUTH_UNIX, server->client_sys);
502 if (IS_ERR(auth))
503 return PTR_ERR(auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 } else {
505 atomic_inc(&server->client->cl_count);
506 server->client_sys = server->client;
507 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 if (server->flags & NFS_MOUNT_VER3) {
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000509#ifdef CONFIG_NFS_V3_ACL
510 if (!(server->flags & NFS_MOUNT_NOACL)) {
511 server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);
512 /* No errors! Assume that Sun nfsacls are supported */
513 if (!IS_ERR(server->client_acl))
514 server->caps |= NFS_CAP_ACLS;
515 }
516#else
517 server->flags &= ~NFS_MOUNT_NOACL;
518#endif /* CONFIG_NFS_V3_ACL */
Andreas Gruenbacher055ffbe2005-06-22 17:16:27 +0000519 /*
520 * The VFS shouldn't apply the umask to mode bits. We will
521 * do so ourselves when necessary.
522 */
523 sb->s_flags |= MS_POSIXACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
525 server->namelen = NFS3_MAXNAMLEN;
526 sb->s_time_gran = 1;
527 } else {
528 if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
529 server->namelen = NFS2_MAXNAMLEN;
530 }
531
532 sb->s_op = &nfs_sops;
533 return nfs_sb_init(sb, authflavor);
534}
535
536static int
David Howells726c3342006-06-23 02:02:58 -0700537nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538{
David Howells726c3342006-06-23 02:02:58 -0700539 struct super_block *sb = dentry->d_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 struct nfs_server *server = NFS_SB(sb);
541 unsigned char blockbits;
542 unsigned long blockres;
543 struct nfs_fh *rootfh = NFS_FH(sb->s_root->d_inode);
544 struct nfs_fattr fattr;
545 struct nfs_fsstat res = {
546 .fattr = &fattr,
547 };
548 int error;
549
550 lock_kernel();
551
552 error = server->rpc_ops->statfs(server, rootfh, &res);
553 buf->f_type = NFS_SUPER_MAGIC;
554 if (error < 0)
555 goto out_err;
556
557 /*
558 * Current versions of glibc do not correctly handle the
559 * case where f_frsize != f_bsize. Eventually we want to
560 * report the value of wtmult in this field.
561 */
562 buf->f_frsize = sb->s_blocksize;
563
564 /*
565 * On most *nix systems, f_blocks, f_bfree, and f_bavail
566 * are reported in units of f_frsize. Linux hasn't had
567 * an f_frsize field in its statfs struct until recently,
568 * thus historically Linux's sys_statfs reports these
569 * fields in units of f_bsize.
570 */
571 buf->f_bsize = sb->s_blocksize;
572 blockbits = sb->s_blocksize_bits;
573 blockres = (1 << blockbits) - 1;
574 buf->f_blocks = (res.tbytes + blockres) >> blockbits;
575 buf->f_bfree = (res.fbytes + blockres) >> blockbits;
576 buf->f_bavail = (res.abytes + blockres) >> blockbits;
577
578 buf->f_files = res.tfiles;
579 buf->f_ffree = res.afiles;
580
581 buf->f_namelen = server->namelen;
582 out:
583 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 return 0;
585
586 out_err:
Chuck Leverdc20f802005-11-30 18:08:57 -0500587 dprintk("%s: statfs error = %d\n", __FUNCTION__, -error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 buf->f_bsize = buf->f_blocks = buf->f_bfree = buf->f_bavail = -1;
589 goto out;
590
591}
592
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500593static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss, int showdefaults)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594{
595 static struct proc_nfs_info {
596 int flag;
597 char *str;
598 char *nostr;
599 } nfs_info[] = {
600 { NFS_MOUNT_SOFT, ",soft", ",hard" },
601 { NFS_MOUNT_INTR, ",intr", "" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 { NFS_MOUNT_NOCTO, ",nocto", "" },
603 { NFS_MOUNT_NOAC, ",noac", "" },
Chuck Leverc8bded92006-03-20 13:44:13 -0500604 { NFS_MOUNT_NONLM, ",nolock", "" },
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000605 { NFS_MOUNT_NOACL, ",noacl", "" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 { 0, NULL, NULL }
607 };
608 struct proc_nfs_info *nfs_infop;
Trond Myklebust3063d8a2005-08-25 16:25:57 -0700609 char buf[12];
610 char *proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
Chuck Leverc8bded92006-03-20 13:44:13 -0500612 seq_printf(m, ",vers=%d", nfss->rpc_ops->version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 seq_printf(m, ",rsize=%d", nfss->rsize);
614 seq_printf(m, ",wsize=%d", nfss->wsize);
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500615 if (nfss->acregmin != 3*HZ || showdefaults)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 seq_printf(m, ",acregmin=%d", nfss->acregmin/HZ);
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500617 if (nfss->acregmax != 60*HZ || showdefaults)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 seq_printf(m, ",acregmax=%d", nfss->acregmax/HZ);
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500619 if (nfss->acdirmin != 30*HZ || showdefaults)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 seq_printf(m, ",acdirmin=%d", nfss->acdirmin/HZ);
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500621 if (nfss->acdirmax != 60*HZ || showdefaults)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 seq_printf(m, ",acdirmax=%d", nfss->acdirmax/HZ);
623 for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
624 if (nfss->flags & nfs_infop->flag)
625 seq_puts(m, nfs_infop->str);
626 else
627 seq_puts(m, nfs_infop->nostr);
628 }
Trond Myklebust3063d8a2005-08-25 16:25:57 -0700629 switch (nfss->client->cl_xprt->prot) {
630 case IPPROTO_TCP:
631 proto = "tcp";
632 break;
633 case IPPROTO_UDP:
634 proto = "udp";
635 break;
636 default:
637 snprintf(buf, sizeof(buf), "%u", nfss->client->cl_xprt->prot);
638 proto = buf;
639 }
640 seq_printf(m, ",proto=%s", proto);
Chuck Lever7a480e22006-03-20 13:44:12 -0500641 seq_printf(m, ",timeo=%lu", 10U * nfss->retrans_timeo / HZ);
642 seq_printf(m, ",retrans=%u", nfss->retrans_count);
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500643}
644
645static int nfs_show_options(struct seq_file *m, struct vfsmount *mnt)
646{
647 struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
648
649 nfs_show_mount_options(m, nfss, 0);
650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 seq_puts(m, ",addr=");
652 seq_escape(m, nfss->hostname, " \t\n\\");
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500653
654 return 0;
655}
656
657static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt)
658{
659 int i, cpu;
660 struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
661 struct rpc_auth *auth = nfss->client->cl_auth;
662 struct nfs_iostats totals = { };
663
664 seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);
665
666 /*
667 * Display all mount option settings
668 */
669 seq_printf(m, "\n\topts:\t");
670 seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? "ro" : "rw");
671 seq_puts(m, mnt->mnt_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");
672 seq_puts(m, mnt->mnt_sb->s_flags & MS_NOATIME ? ",noatime" : "");
673 seq_puts(m, mnt->mnt_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");
674 nfs_show_mount_options(m, nfss, 1);
675
Chuck Lever67ec9f42006-03-20 13:44:15 -0500676 seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
677
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500678 seq_printf(m, "\n\tcaps:\t");
679 seq_printf(m, "caps=0x%x", nfss->caps);
680 seq_printf(m, ",wtmult=%d", nfss->wtmult);
681 seq_printf(m, ",dtsize=%d", nfss->dtsize);
682 seq_printf(m, ",bsize=%d", nfss->bsize);
683 seq_printf(m, ",namelen=%d", nfss->namelen);
684
685#ifdef CONFIG_NFS_V4
686 if (nfss->rpc_ops->version == 4) {
687 seq_printf(m, "\n\tnfsv4:\t");
688 seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
689 seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
690 seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
691 }
692#endif
693
694 /*
695 * Display security flavor in effect for this mount
696 */
697 seq_printf(m, "\n\tsec:\tflavor=%d", auth->au_ops->au_flavor);
698 if (auth->au_flavor)
699 seq_printf(m, ",pseudoflavor=%d", auth->au_flavor);
700
701 /*
702 * Display superblock I/O counters
703 */
John Hawkesb9d95062006-04-19 13:06:20 -0400704 for_each_possible_cpu(cpu) {
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500705 struct nfs_iostats *stats;
706
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500707 preempt_disable();
708 stats = per_cpu_ptr(nfss->io_stats, cpu);
709
710 for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
711 totals.events[i] += stats->events[i];
712 for (i = 0; i < __NFSIOS_BYTESMAX; i++)
713 totals.bytes[i] += stats->bytes[i];
714
715 preempt_enable();
716 }
717
718 seq_printf(m, "\n\tevents:\t");
719 for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
720 seq_printf(m, "%lu ", totals.events[i]);
721 seq_printf(m, "\n\tbytes:\t");
722 for (i = 0; i < __NFSIOS_BYTESMAX; i++)
723 seq_printf(m, "%Lu ", totals.bytes[i]);
Chuck Lever4ece3a22006-03-20 13:44:22 -0500724 seq_printf(m, "\n");
725
726 rpc_print_iostats(m, nfss->client);
Chuck Leverd9ef5a82006-03-20 13:44:13 -0500727
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 return 0;
729}
730
Trond Myklebust29884df2005-12-13 16:13:54 -0500731/**
732 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
733 */
734int nfs_sync_mapping(struct address_space *mapping)
735{
736 int ret;
737
738 if (mapping->nrpages == 0)
739 return 0;
740 unmap_mapping_range(mapping, 0, 0, 0);
OGAWA Hirofumi28fd1292006-01-08 01:02:14 -0800741 ret = filemap_write_and_wait(mapping);
Trond Myklebust29884df2005-12-13 16:13:54 -0500742 if (ret != 0)
743 goto out;
744 ret = nfs_wb_all(mapping->host);
745out:
746 return ret;
747}
748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749/*
750 * Invalidate the local caches
751 */
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500752static void nfs_zap_caches_locked(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
754 struct nfs_inode *nfsi = NFS_I(inode);
755 int mode = inode->i_mode;
756
Chuck Lever91d5b472006-03-20 13:44:14 -0500757 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 NFS_ATTRTIMEO(inode) = NFS_MINATTRTIMEO(inode);
760 NFS_ATTRTIMEO_UPDATE(inode) = jiffies;
761
762 memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
763 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
Chuck Lever55296802005-08-18 11:24:09 -0700764 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 else
Chuck Lever55296802005-08-18 11:24:09 -0700766 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500767}
Chuck Leverdc592502005-08-18 11:24:12 -0700768
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500769void nfs_zap_caches(struct inode *inode)
770{
771 spin_lock(&inode->i_lock);
772 nfs_zap_caches_locked(inode);
Chuck Leverdc592502005-08-18 11:24:12 -0700773 spin_unlock(&inode->i_lock);
Trond Myklebustada70d92005-06-22 17:16:22 +0000774}
775
776static void nfs_zap_acl_cache(struct inode *inode)
777{
778 void (*clear_acl_cache)(struct inode *);
779
780 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
781 if (clear_acl_cache != NULL)
782 clear_acl_cache(inode);
Chuck Leverdc592502005-08-18 11:24:12 -0700783 spin_lock(&inode->i_lock);
Chuck Lever55296802005-08-18 11:24:09 -0700784 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
Chuck Leverdc592502005-08-18 11:24:12 -0700785 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786}
787
788/*
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500789 * Invalidate, but do not unhash, the inode.
790 * NB: must be called with inode->i_lock held!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 */
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500792static void nfs_invalidate_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793{
Trond Myklebustb37b03b2005-11-25 17:10:06 -0500794 set_bit(NFS_INO_STALE, &NFS_FLAGS(inode));
795 nfs_zap_caches_locked(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796}
797
798struct nfs_find_desc {
799 struct nfs_fh *fh;
800 struct nfs_fattr *fattr;
801};
802
803/*
804 * In NFSv3 we can have 64bit inode numbers. In order to support
805 * this, and re-exported directories (also seen in NFSv2)
806 * we are forced to allow 2 different inodes to have the same
807 * i_ino.
808 */
809static int
810nfs_find_actor(struct inode *inode, void *opaque)
811{
812 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
813 struct nfs_fh *fh = desc->fh;
814 struct nfs_fattr *fattr = desc->fattr;
815
816 if (NFS_FILEID(inode) != fattr->fileid)
817 return 0;
818 if (nfs_compare_fh(NFS_FH(inode), fh))
819 return 0;
820 if (is_bad_inode(inode) || NFS_STALE(inode))
821 return 0;
822 return 1;
823}
824
825static int
826nfs_init_locked(struct inode *inode, void *opaque)
827{
828 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
829 struct nfs_fattr *fattr = desc->fattr;
830
831 NFS_FILEID(inode) = fattr->fileid;
832 nfs_copy_fh(NFS_FH(inode), desc->fh);
833 return 0;
834}
835
836/* Don't use READDIRPLUS on directories that we believe are too large */
837#define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE)
838
839/*
840 * This is our front-end to iget that looks up inodes by file handle
841 * instead of inode number.
842 */
843struct inode *
844nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
845{
846 struct nfs_find_desc desc = {
847 .fh = fh,
848 .fattr = fattr
849 };
Trond Myklebust03f28e32006-03-20 13:44:48 -0500850 struct inode *inode = ERR_PTR(-ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 unsigned long hash;
852
853 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
854 goto out_no_inode;
855
856 if (!fattr->nlink) {
857 printk("NFS: Buggy server - nlink == 0!\n");
858 goto out_no_inode;
859 }
860
861 hash = nfs_fattr_to_ino_t(fattr);
862
Trond Myklebust03f28e32006-03-20 13:44:48 -0500863 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
864 if (inode == NULL) {
865 inode = ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 goto out_no_inode;
Trond Myklebust03f28e32006-03-20 13:44:48 -0500867 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
869 if (inode->i_state & I_NEW) {
870 struct nfs_inode *nfsi = NFS_I(inode);
871
872 /* We set i_ino for the few things that still rely on it,
873 * such as stat(2) */
874 inode->i_ino = hash;
875
876 /* We can't support update_atime(), since the server will reset it */
877 inode->i_flags |= S_NOATIME|S_NOCMTIME;
878 inode->i_mode = fattr->mode;
879 /* Why so? Because we want revalidate for devices/FIFOs, and
880 * that's precisely what we have in nfs_file_inode_operations.
881 */
J. Bruce Fields92cfc622005-06-22 17:16:22 +0000882 inode->i_op = NFS_SB(sb)->rpc_ops->file_inode_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 if (S_ISREG(inode->i_mode)) {
884 inode->i_fop = &nfs_file_operations;
885 inode->i_data.a_ops = &nfs_file_aops;
886 inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
887 } else if (S_ISDIR(inode->i_mode)) {
888 inode->i_op = NFS_SB(sb)->rpc_ops->dir_inode_ops;
889 inode->i_fop = &nfs_dir_operations;
890 if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS)
891 && fattr->size <= NFS_LIMIT_READDIRPLUS)
Chuck Lever412d5822005-08-18 11:24:11 -0700892 set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 } else if (S_ISLNK(inode->i_mode))
894 inode->i_op = &nfs_symlink_inode_operations;
895 else
896 init_special_inode(inode, inode->i_mode, fattr->rdev);
897
Trond Myklebust33801142005-10-27 22:12:39 -0400898 nfsi->read_cache_jiffies = fattr->time_start;
899 nfsi->last_updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 inode->i_atime = fattr->atime;
901 inode->i_mtime = fattr->mtime;
902 inode->i_ctime = fattr->ctime;
903 if (fattr->valid & NFS_ATTR_FATTR_V4)
904 nfsi->change_attr = fattr->change_attr;
905 inode->i_size = nfs_size_to_loff_t(fattr->size);
906 inode->i_nlink = fattr->nlink;
907 inode->i_uid = fattr->uid;
908 inode->i_gid = fattr->gid;
909 if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
910 /*
911 * report the blocks in 512byte units
912 */
913 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
914 inode->i_blksize = inode->i_sb->s_blocksize;
915 } else {
916 inode->i_blocks = fattr->du.nfs2.blocks;
917 inode->i_blksize = fattr->du.nfs2.blocksize;
918 }
919 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
920 nfsi->attrtimeo_timestamp = jiffies;
921 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
922 nfsi->cache_access.cred = NULL;
923
924 unlock_new_inode(inode);
925 } else
926 nfs_refresh_inode(inode, fattr);
927 dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
928 inode->i_sb->s_id,
929 (long long)NFS_FILEID(inode),
930 atomic_read(&inode->i_count));
931
932out:
933 return inode;
934
935out_no_inode:
Trond Myklebust03f28e32006-03-20 13:44:48 -0500936 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 goto out;
938}
939
940#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET)
941
942int
943nfs_setattr(struct dentry *dentry, struct iattr *attr)
944{
945 struct inode *inode = dentry->d_inode;
946 struct nfs_fattr fattr;
947 int error;
948
Chuck Lever91d5b472006-03-20 13:44:14 -0500949 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
950
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 if (attr->ia_valid & ATTR_SIZE) {
952 if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode))
953 attr->ia_valid &= ~ATTR_SIZE;
954 }
955
956 /* Optimization: if the end result is no change, don't RPC */
957 attr->ia_valid &= NFS_VALID_ATTRS;
958 if (attr->ia_valid == 0)
959 return 0;
960
961 lock_kernel();
962 nfs_begin_data_update(inode);
Trond Myklebust755c1e22006-03-20 13:44:06 -0500963 /* Write all dirty data */
964 filemap_write_and_wait(inode->i_mapping);
965 nfs_wb_all(inode);
Trond Myklebust642ac542005-10-18 14:20:19 -0700966 /*
967 * Return any delegations if we're going to change ACLs
968 */
969 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
970 nfs_inode_return_delegation(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 error = NFS_PROTO(inode)->setattr(dentry, &fattr, attr);
Trond Myklebust65e43082005-08-16 11:49:44 -0400972 if (error == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 nfs_refresh_inode(inode, &fattr);
Trond Myklebust65e43082005-08-16 11:49:44 -0400974 nfs_end_data_update(inode);
975 unlock_kernel();
976 return error;
977}
978
979/**
980 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
981 * @inode: pointer to struct inode
982 * @attr: pointer to struct iattr
983 *
984 * Note: we do this in the *proc.c in order to ensure that
985 * it works for things like exclusive creates too.
986 */
987void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
988{
989 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 if ((attr->ia_valid & ATTR_MODE) != 0) {
Trond Myklebust65e43082005-08-16 11:49:44 -0400991 int mode = attr->ia_mode & S_IALLUGO;
992 mode |= inode->i_mode & ~S_IALLUGO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 inode->i_mode = mode;
994 }
995 if ((attr->ia_valid & ATTR_UID) != 0)
996 inode->i_uid = attr->ia_uid;
997 if ((attr->ia_valid & ATTR_GID) != 0)
998 inode->i_gid = attr->ia_gid;
Chuck Leverdc592502005-08-18 11:24:12 -0700999 spin_lock(&inode->i_lock);
Chuck Lever55296802005-08-18 11:24:09 -07001000 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Chuck Leverdc592502005-08-18 11:24:12 -07001001 spin_unlock(&inode->i_lock);
Trond Myklebust65e43082005-08-16 11:49:44 -04001002 }
1003 if ((attr->ia_valid & ATTR_SIZE) != 0) {
Chuck Lever91d5b472006-03-20 13:44:14 -05001004 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
Trond Myklebust65e43082005-08-16 11:49:44 -04001005 inode->i_size = attr->ia_size;
1006 vmtruncate(inode, attr->ia_size);
1007 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008}
1009
Chuck Lever412d5822005-08-18 11:24:11 -07001010static int nfs_wait_schedule(void *word)
1011{
1012 if (signal_pending(current))
1013 return -ERESTARTSYS;
1014 schedule();
1015 return 0;
1016}
1017
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018/*
1019 * Wait for the inode to get unlocked.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 */
Chuck Lever412d5822005-08-18 11:24:11 -07001021static int nfs_wait_on_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022{
1023 struct rpc_clnt *clnt = NFS_CLIENT(inode);
1024 struct nfs_inode *nfsi = NFS_I(inode);
Chuck Lever412d5822005-08-18 11:24:11 -07001025 sigset_t oldmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 int error;
Chuck Lever412d5822005-08-18 11:24:11 -07001027
Chuck Lever412d5822005-08-18 11:24:11 -07001028 rpc_clnt_sigmask(clnt, &oldmask);
1029 error = wait_on_bit_lock(&nfsi->flags, NFS_INO_REVALIDATING,
1030 nfs_wait_schedule, TASK_INTERRUPTIBLE);
1031 rpc_clnt_sigunmask(clnt, &oldmask);
Chuck Lever412d5822005-08-18 11:24:11 -07001032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 return error;
1034}
1035
Chuck Lever412d5822005-08-18 11:24:11 -07001036static void nfs_wake_up_inode(struct inode *inode)
1037{
1038 struct nfs_inode *nfsi = NFS_I(inode);
1039
1040 clear_bit(NFS_INO_REVALIDATING, &nfsi->flags);
1041 smp_mb__after_clear_bit();
1042 wake_up_bit(&nfsi->flags, NFS_INO_REVALIDATING);
1043}
1044
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
1046{
1047 struct inode *inode = dentry->d_inode;
Chuck Lever55296802005-08-18 11:24:09 -07001048 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 int err;
1050
Trond Myklebust70b9ecb2006-01-03 09:55:34 +01001051 /* Flush out writes to the server in order to update c/mtime */
Trond Myklebustc42de9d2006-03-20 13:44:51 -05001052 nfs_sync_inode_wait(inode, 0, 0, FLUSH_NOCOMMIT);
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -08001053
1054 /*
1055 * We may force a getattr if the user cares about atime.
1056 *
1057 * Note that we only have to check the vfsmount flags here:
1058 * - NFS always sets S_NOATIME by so checking it would give a
1059 * bogus result
1060 * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
1061 * no point in checking those.
1062 */
1063 if ((mnt->mnt_flags & MNT_NOATIME) ||
1064 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 need_atime = 0;
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -08001066
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 if (need_atime)
1068 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1069 else
1070 err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
1071 if (!err)
1072 generic_fillattr(inode, stat);
1073 return err;
1074}
1075
Trond Myklebustb92dccf2006-03-20 13:44:03 -05001076static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, struct dentry *dentry, struct rpc_cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077{
1078 struct nfs_open_context *ctx;
1079
1080 ctx = (struct nfs_open_context *)kmalloc(sizeof(*ctx), GFP_KERNEL);
1081 if (ctx != NULL) {
1082 atomic_set(&ctx->count, 1);
1083 ctx->dentry = dget(dentry);
Trond Myklebustb92dccf2006-03-20 13:44:03 -05001084 ctx->vfsmnt = mntget(mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 ctx->cred = get_rpccred(cred);
1086 ctx->state = NULL;
1087 ctx->lockowner = current->files;
1088 ctx->error = 0;
Olivier Galibert00a92642005-06-22 17:16:29 +00001089 ctx->dir_cookie = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 }
1091 return ctx;
1092}
1093
1094struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
1095{
1096 if (ctx != NULL)
1097 atomic_inc(&ctx->count);
1098 return ctx;
1099}
1100
1101void put_nfs_open_context(struct nfs_open_context *ctx)
1102{
1103 if (atomic_dec_and_test(&ctx->count)) {
1104 if (!list_empty(&ctx->list)) {
1105 struct inode *inode = ctx->dentry->d_inode;
1106 spin_lock(&inode->i_lock);
1107 list_del(&ctx->list);
1108 spin_unlock(&inode->i_lock);
1109 }
1110 if (ctx->state != NULL)
1111 nfs4_close_state(ctx->state, ctx->mode);
1112 if (ctx->cred != NULL)
1113 put_rpccred(ctx->cred);
1114 dput(ctx->dentry);
Trond Myklebustb92dccf2006-03-20 13:44:03 -05001115 mntput(ctx->vfsmnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 kfree(ctx);
1117 }
1118}
1119
1120/*
1121 * Ensure that mmap has a recent RPC credential for use when writing out
1122 * shared pages
1123 */
Trond Myklebustb92dccf2006-03-20 13:44:03 -05001124static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125{
1126 struct inode *inode = filp->f_dentry->d_inode;
1127 struct nfs_inode *nfsi = NFS_I(inode);
1128
1129 filp->private_data = get_nfs_open_context(ctx);
1130 spin_lock(&inode->i_lock);
1131 list_add(&ctx->list, &nfsi->open_files);
1132 spin_unlock(&inode->i_lock);
1133}
1134
Trond Myklebustd5308382005-11-04 15:33:38 -05001135/*
1136 * Given an inode, search for an open context with the desired characteristics
1137 */
1138struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139{
1140 struct nfs_inode *nfsi = NFS_I(inode);
1141 struct nfs_open_context *pos, *ctx = NULL;
1142
1143 spin_lock(&inode->i_lock);
1144 list_for_each_entry(pos, &nfsi->open_files, list) {
Trond Myklebustd5308382005-11-04 15:33:38 -05001145 if (cred != NULL && pos->cred != cred)
1146 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 if ((pos->mode & mode) == mode) {
1148 ctx = get_nfs_open_context(pos);
1149 break;
1150 }
1151 }
1152 spin_unlock(&inode->i_lock);
1153 return ctx;
1154}
1155
Trond Myklebustb92dccf2006-03-20 13:44:03 -05001156static void nfs_file_clear_open_context(struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157{
1158 struct inode *inode = filp->f_dentry->d_inode;
1159 struct nfs_open_context *ctx = (struct nfs_open_context *)filp->private_data;
1160
1161 if (ctx) {
1162 filp->private_data = NULL;
1163 spin_lock(&inode->i_lock);
1164 list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
1165 spin_unlock(&inode->i_lock);
1166 put_nfs_open_context(ctx);
1167 }
1168}
1169
1170/*
1171 * These allocate and release file read/write context information.
1172 */
1173int nfs_open(struct inode *inode, struct file *filp)
1174{
1175 struct nfs_open_context *ctx;
1176 struct rpc_cred *cred;
1177
1178 cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
1179 if (IS_ERR(cred))
1180 return PTR_ERR(cred);
Trond Myklebustb92dccf2006-03-20 13:44:03 -05001181 ctx = alloc_nfs_open_context(filp->f_vfsmnt, filp->f_dentry, cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 put_rpccred(cred);
1183 if (ctx == NULL)
1184 return -ENOMEM;
1185 ctx->mode = filp->f_mode;
1186 nfs_file_set_open_context(filp, ctx);
1187 put_nfs_open_context(ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 return 0;
1189}
1190
1191int nfs_release(struct inode *inode, struct file *filp)
1192{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 nfs_file_clear_open_context(filp);
1194 return 0;
1195}
1196
1197/*
1198 * This function is called whenever some part of NFS notices that
1199 * the cached attributes have to be refreshed.
1200 */
1201int
1202__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1203{
1204 int status = -ESTALE;
1205 struct nfs_fattr fattr;
1206 struct nfs_inode *nfsi = NFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
1208 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
1209 inode->i_sb->s_id, (long long)NFS_FILEID(inode));
1210
1211 lock_kernel();
1212 if (!inode || is_bad_inode(inode))
1213 goto out_nowait;
1214 if (NFS_STALE(inode))
1215 goto out_nowait;
1216
Chuck Lever412d5822005-08-18 11:24:11 -07001217 status = nfs_wait_on_inode(inode);
1218 if (status < 0)
1219 goto out;
1220 if (NFS_STALE(inode)) {
1221 status = -ESTALE;
1222 /* Do we trust the cached ESTALE? */
1223 if (NFS_ATTRTIMEO(inode) != 0) {
1224 if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ATIME)) {
1225 /* no */
1226 } else
1227 goto out;
1228 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr);
1232 if (status != 0) {
1233 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
1234 inode->i_sb->s_id,
1235 (long long)NFS_FILEID(inode), status);
1236 if (status == -ESTALE) {
1237 nfs_zap_caches(inode);
1238 if (!S_ISDIR(inode->i_mode))
Chuck Lever412d5822005-08-18 11:24:11 -07001239 set_bit(NFS_INO_STALE, &NFS_FLAGS(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 }
1241 goto out;
1242 }
1243
Trond Myklebust33801142005-10-27 22:12:39 -04001244 spin_lock(&inode->i_lock);
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001245 status = nfs_update_inode(inode, &fattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 if (status) {
Trond Myklebust33801142005-10-27 22:12:39 -04001247 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
1249 inode->i_sb->s_id,
1250 (long long)NFS_FILEID(inode), status);
1251 goto out;
1252 }
Chuck Leverdc592502005-08-18 11:24:12 -07001253 spin_unlock(&inode->i_lock);
Chuck Lever55296802005-08-18 11:24:09 -07001254
Trond Myklebust7d52e862005-06-22 17:16:30 +00001255 nfs_revalidate_mapping(inode, inode->i_mapping);
Chuck Lever55296802005-08-18 11:24:09 -07001256
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001257 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
Trond Myklebustada70d92005-06-22 17:16:22 +00001258 nfs_zap_acl_cache(inode);
Chuck Lever55296802005-08-18 11:24:09 -07001259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
1261 inode->i_sb->s_id,
1262 (long long)NFS_FILEID(inode));
1263
Chuck Lever412d5822005-08-18 11:24:11 -07001264 out:
1265 nfs_wake_up_inode(inode);
1266
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 out_nowait:
1268 unlock_kernel();
1269 return status;
1270}
1271
1272int nfs_attribute_timeout(struct inode *inode)
1273{
1274 struct nfs_inode *nfsi = NFS_I(inode);
1275
1276 if (nfs_have_delegation(inode, FMODE_READ))
1277 return 0;
1278 return time_after(jiffies, nfsi->read_cache_jiffies+nfsi->attrtimeo);
1279}
1280
1281/**
1282 * nfs_revalidate_inode - Revalidate the inode attributes
1283 * @server - pointer to nfs_server struct
1284 * @inode - pointer to inode struct
1285 *
1286 * Updates inode attribute information by retrieving the data from the server.
1287 */
1288int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1289{
Chuck Lever91d5b472006-03-20 13:44:14 -05001290 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
Chuck Lever55296802005-08-18 11:24:09 -07001291 if (!(NFS_I(inode)->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 && !nfs_attribute_timeout(inode))
1293 return NFS_STALE(inode) ? -ESTALE : 0;
1294 return __nfs_revalidate_inode(server, inode);
1295}
1296
1297/**
Trond Myklebust7d52e862005-06-22 17:16:30 +00001298 * nfs_revalidate_mapping - Revalidate the pagecache
1299 * @inode - pointer to host inode
1300 * @mapping - pointer to mapping
1301 */
1302void nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1303{
1304 struct nfs_inode *nfsi = NFS_I(inode);
1305
Chuck Lever55296802005-08-18 11:24:09 -07001306 if (nfsi->cache_validity & NFS_INO_INVALID_DATA) {
Chuck Lever91d5b472006-03-20 13:44:14 -05001307 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
Trond Myklebust29884df2005-12-13 16:13:54 -05001308 if (S_ISREG(inode->i_mode))
1309 nfs_sync_mapping(mapping);
Trond Myklebust7d52e862005-06-22 17:16:30 +00001310 invalidate_inode_pages2(mapping);
Chuck Leverdc592502005-08-18 11:24:12 -07001311
1312 spin_lock(&inode->i_lock);
Chuck Lever55296802005-08-18 11:24:09 -07001313 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
Trond Myklebust7d52e862005-06-22 17:16:30 +00001314 if (S_ISDIR(inode->i_mode)) {
1315 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
1316 /* This ensures we revalidate child dentries */
Trond Myklebust913a70f2005-10-27 22:12:38 -04001317 nfsi->cache_change_attribute = jiffies;
Trond Myklebust7d52e862005-06-22 17:16:30 +00001318 }
Chuck Leverdc592502005-08-18 11:24:12 -07001319 spin_unlock(&inode->i_lock);
1320
Trond Myklebust7d52e862005-06-22 17:16:30 +00001321 dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
1322 inode->i_sb->s_id,
1323 (long long)NFS_FILEID(inode));
1324 }
1325}
1326
1327/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 * nfs_begin_data_update
1329 * @inode - pointer to inode
1330 * Declare that a set of operations will update file data on the server
1331 */
1332void nfs_begin_data_update(struct inode *inode)
1333{
1334 atomic_inc(&NFS_I(inode)->data_updates);
1335}
1336
1337/**
1338 * nfs_end_data_update
1339 * @inode - pointer to inode
1340 * Declare end of the operations that will update file data
1341 * This will mark the inode as immediately needing revalidation
1342 * of its attribute cache.
1343 */
1344void nfs_end_data_update(struct inode *inode)
1345{
1346 struct nfs_inode *nfsi = NFS_I(inode);
1347
1348 if (!nfs_have_delegation(inode, FMODE_READ)) {
Trond Myklebustdecf4912005-10-27 22:12:39 -04001349 /* Directories and symlinks: invalidate page cache */
1350 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) {
1351 spin_lock(&inode->i_lock);
Chuck Lever55296802005-08-18 11:24:09 -07001352 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
Trond Myklebustdecf4912005-10-27 22:12:39 -04001353 spin_unlock(&inode->i_lock);
1354 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 }
Trond Myklebust913a70f2005-10-27 22:12:38 -04001356 nfsi->cache_change_attribute = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 atomic_dec(&nfsi->data_updates);
1358}
1359
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001360static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1361{
1362 struct nfs_inode *nfsi = NFS_I(inode);
1363
1364 if ((fattr->valid & NFS_ATTR_PRE_CHANGE) != 0
1365 && nfsi->change_attr == fattr->pre_change_attr) {
1366 nfsi->change_attr = fattr->change_attr;
1367 nfsi->cache_change_attribute = jiffies;
1368 }
1369
1370 /* If we have atomic WCC data, we may update some attributes */
1371 if ((fattr->valid & NFS_ATTR_WCC) != 0) {
1372 if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
1373 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1374 nfsi->cache_change_attribute = jiffies;
1375 }
1376 if (timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
1377 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1378 nfsi->cache_change_attribute = jiffies;
1379 }
1380 if (inode->i_size == fattr->pre_size && nfsi->npages == 0) {
1381 inode->i_size = fattr->size;
1382 nfsi->cache_change_attribute = jiffies;
1383 }
1384 }
1385}
1386
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387/**
Trond Myklebust33801142005-10-27 22:12:39 -04001388 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 * @inode - pointer to inode
1390 * @fattr - updated attributes
1391 *
1392 * Verifies the attribute cache. If we have just changed the attributes,
1393 * so that fattr carries weak cache consistency data, then it may
1394 * also update the ctime/mtime/change_attribute.
1395 */
Trond Myklebust33801142005-10-27 22:12:39 -04001396static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397{
1398 struct nfs_inode *nfsi = NFS_I(inode);
1399 loff_t cur_size, new_isize;
1400 int data_unstable;
1401
Chuck Leverdc592502005-08-18 11:24:12 -07001402
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001403 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1404 return 0;
1405
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 /* Has the inode gone and changed behind our back? */
1407 if (nfsi->fileid != fattr->fileid
Chuck Leverdc592502005-08-18 11:24:12 -07001408 || (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 return -EIO;
Chuck Leverdc592502005-08-18 11:24:12 -07001410 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411
Trond Myklebustca62b9c2006-03-20 13:44:07 -05001412 /* Are we in the process of updating data on the server? */
1413 data_unstable = nfs_caches_unstable(inode);
1414
1415 /* Do atomic weak cache consistency updates */
1416 nfs_wcc_update_inode(inode, fattr);
1417
1418 if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0) {
1419 if (nfsi->change_attr == fattr->change_attr)
1420 goto out;
1421 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
1422 if (!data_unstable)
1423 nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE;
1424 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 /* Verify a few of the more important attributes */
Trond Myklebustfe51bee2005-06-22 17:16:30 +00001427 if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
Chuck Lever55296802005-08-18 11:24:09 -07001428 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
Trond Myklebustfe51bee2005-06-22 17:16:30 +00001429 if (!data_unstable)
Chuck Lever55296802005-08-18 11:24:09 -07001430 nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE;
Trond Myklebustfe51bee2005-06-22 17:16:30 +00001431 }
Trond Myklebustca62b9c2006-03-20 13:44:07 -05001432
1433 cur_size = i_size_read(inode);
1434 new_isize = nfs_size_to_loff_t(fattr->size);
Trond Myklebustfb374d22006-03-20 13:44:08 -05001435 if (cur_size != new_isize && nfsi->npages == 0)
1436 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437
1438 /* Have any file permissions changed? */
1439 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)
1440 || inode->i_uid != fattr->uid
1441 || inode->i_gid != fattr->gid)
Chuck Lever55296802005-08-18 11:24:09 -07001442 nfsi->cache_validity |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443
1444 /* Has the link count changed? */
1445 if (inode->i_nlink != fattr->nlink)
Chuck Lever55296802005-08-18 11:24:09 -07001446 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
Trond Myklebustca62b9c2006-03-20 13:44:07 -05001448out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 if (!timespec_equal(&inode->i_atime, &fattr->atime))
Chuck Lever55296802005-08-18 11:24:09 -07001450 nfsi->cache_validity |= NFS_INO_INVALID_ATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451
Trond Myklebust33801142005-10-27 22:12:39 -04001452 nfsi->read_cache_jiffies = fattr->time_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 return 0;
1454}
1455
Trond Myklebust33801142005-10-27 22:12:39 -04001456/**
1457 * nfs_refresh_inode - try to update the inode attribute cache
1458 * @inode - pointer to inode
1459 * @fattr - updated attributes
1460 *
1461 * Check that an RPC call that returned attributes has not overlapped with
1462 * other recent updates of the inode metadata, then decide whether it is
1463 * safe to do a full update of the inode attributes, or whether just to
1464 * call nfs_check_inode_attributes.
1465 */
1466int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1467{
1468 struct nfs_inode *nfsi = NFS_I(inode);
1469 int status;
1470
1471 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1472 return 0;
1473 spin_lock(&inode->i_lock);
1474 nfsi->cache_validity &= ~NFS_INO_REVAL_PAGECACHE;
Trond Myklebust33801142005-10-27 22:12:39 -04001475 if (time_after(fattr->time_start, nfsi->last_updated))
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001476 status = nfs_update_inode(inode, fattr);
Trond Myklebust33801142005-10-27 22:12:39 -04001477 else
1478 status = nfs_check_inode_attributes(inode, fattr);
1479
1480 spin_unlock(&inode->i_lock);
1481 return status;
1482}
1483
Trond Myklebustdecf4912005-10-27 22:12:39 -04001484/**
1485 * nfs_post_op_update_inode - try to update the inode attribute cache
1486 * @inode - pointer to inode
1487 * @fattr - updated attributes
1488 *
1489 * After an operation that has changed the inode metadata, mark the
1490 * attribute cache as being invalid, then try to update it.
1491 */
1492int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1493{
1494 struct nfs_inode *nfsi = NFS_I(inode);
1495 int status = 0;
1496
1497 spin_lock(&inode->i_lock);
1498 if (unlikely((fattr->valid & NFS_ATTR_FATTR) == 0)) {
1499 nfsi->cache_validity |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS;
1500 goto out;
1501 }
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001502 status = nfs_update_inode(inode, fattr);
Trond Myklebustdecf4912005-10-27 22:12:39 -04001503out:
1504 spin_unlock(&inode->i_lock);
1505 return status;
1506}
1507
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508/*
1509 * Many nfs protocol calls return the new file attributes after
1510 * an operation. Here we update the inode to reflect the state
1511 * of the server's inode.
1512 *
1513 * This is a bit tricky because we have to make sure all dirty pages
1514 * have been sent off to the server before calling invalidate_inode_pages.
1515 * To make sure no other process adds more write requests while we try
1516 * our best to flush them, we make them sleep during the attribute refresh.
1517 *
1518 * A very similar scenario holds for the dir cache.
1519 */
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001520static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521{
1522 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust951a1432005-06-22 17:16:30 +00001523 loff_t cur_isize, new_isize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 unsigned int invalid = 0;
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001525 int data_stable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526
1527 dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
1528 __FUNCTION__, inode->i_sb->s_id, inode->i_ino,
1529 atomic_read(&inode->i_count), fattr->valid);
1530
1531 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1532 return 0;
1533
Chuck Lever325cfed2005-11-30 18:08:55 -05001534 if (nfsi->fileid != fattr->fileid)
1535 goto out_fileid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536
1537 /*
1538 * Make sure the inode's type hasn't changed.
1539 */
Trond Myklebust33801142005-10-27 22:12:39 -04001540 if ((inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 goto out_changed;
1542
1543 /*
1544 * Update the read time so we don't revalidate too often.
1545 */
Trond Myklebust33801142005-10-27 22:12:39 -04001546 nfsi->read_cache_jiffies = fattr->time_start;
1547 nfsi->last_updated = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548
1549 /* Are we racing with known updates of the metadata on the server? */
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001550 data_stable = nfs_verify_change_attribute(inode, fattr->time_start);
1551 if (data_stable)
1552 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553
Trond Myklebusta895b4a2006-01-03 09:55:40 +01001554 /* Do atomic weak cache consistency updates */
1555 nfs_wcc_update_inode(inode, fattr);
1556
Trond Myklebust951a1432005-06-22 17:16:30 +00001557 /* Check if our cached file size is stale */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 new_isize = nfs_size_to_loff_t(fattr->size);
1559 cur_isize = i_size_read(inode);
Trond Myklebust951a1432005-06-22 17:16:30 +00001560 if (new_isize != cur_isize) {
1561 /* Do we perhaps have any outstanding writes? */
1562 if (nfsi->npages == 0) {
1563 /* No, but did we race with nfs_end_data_update()? */
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001564 if (data_stable) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 inode->i_size = new_isize;
Trond Myklebust951a1432005-06-22 17:16:30 +00001566 invalid |= NFS_INO_INVALID_DATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 }
Trond Myklebust951a1432005-06-22 17:16:30 +00001568 invalid |= NFS_INO_INVALID_ATTR;
1569 } else if (new_isize > cur_isize) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 inode->i_size = new_isize;
1571 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1572 }
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001573 nfsi->cache_change_attribute = jiffies;
Trond Myklebust951a1432005-06-22 17:16:30 +00001574 dprintk("NFS: isize change on server for file %s/%ld\n",
1575 inode->i_sb->s_id, inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 }
1577
Trond Myklebust951a1432005-06-22 17:16:30 +00001578 /* Check if the mtime agrees */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
1580 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
Trond Myklebust951a1432005-06-22 17:16:30 +00001581 dprintk("NFS: mtime change on server for file %s/%ld\n",
1582 inode->i_sb->s_id, inode->i_ino);
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001583 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1584 nfsi->cache_change_attribute = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 }
1586
Trond Myklebustada70d92005-06-22 17:16:22 +00001587 /* If ctime has changed we should definitely clear access+acl caches */
1588 if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) {
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001589 invalid |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Trond Myklebustada70d92005-06-22 17:16:22 +00001590 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001591 nfsi->cache_change_attribute = jiffies;
Trond Myklebustada70d92005-06-22 17:16:22 +00001592 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
1594
1595 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO) ||
1596 inode->i_uid != fattr->uid ||
1597 inode->i_gid != fattr->gid)
Trond Myklebustada70d92005-06-22 17:16:22 +00001598 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
1600 inode->i_mode = fattr->mode;
1601 inode->i_nlink = fattr->nlink;
1602 inode->i_uid = fattr->uid;
1603 inode->i_gid = fattr->gid;
1604
1605 if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
1606 /*
1607 * report the blocks in 512byte units
1608 */
1609 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
1610 inode->i_blksize = inode->i_sb->s_blocksize;
1611 } else {
1612 inode->i_blocks = fattr->du.nfs2.blocks;
1613 inode->i_blksize = fattr->du.nfs2.blocksize;
1614 }
1615
Trond Myklebustca62b9c2006-03-20 13:44:07 -05001616 if ((fattr->valid & NFS_ATTR_FATTR_V4)) {
1617 if (nfsi->change_attr != fattr->change_attr) {
1618 dprintk("NFS: change_attr change on server for file %s/%ld\n",
1619 inode->i_sb->s_id, inode->i_ino);
1620 nfsi->change_attr = fattr->change_attr;
1621 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1622 nfsi->cache_change_attribute = jiffies;
1623 } else
1624 invalid &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA);
1625 }
1626
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 /* Update attrtimeo value if we're out of the unstable period */
1628 if (invalid & NFS_INO_INVALID_ATTR) {
Chuck Lever91d5b472006-03-20 13:44:14 -05001629 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
1631 nfsi->attrtimeo_timestamp = jiffies;
1632 } else if (time_after(jiffies, nfsi->attrtimeo_timestamp+nfsi->attrtimeo)) {
1633 if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
1634 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
1635 nfsi->attrtimeo_timestamp = jiffies;
1636 }
1637 /* Don't invalidate the data if we were to blame */
1638 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
1639 || S_ISLNK(inode->i_mode)))
1640 invalid &= ~NFS_INO_INVALID_DATA;
Trond Myklebust24aa1fe2005-12-03 15:20:07 -05001641 if (data_stable)
1642 invalid &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME|NFS_INO_REVAL_PAGECACHE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 if (!nfs_have_delegation(inode, FMODE_READ))
Chuck Lever55296802005-08-18 11:24:09 -07001644 nfsi->cache_validity |= invalid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645
1646 return 0;
1647 out_changed:
1648 /*
1649 * Big trouble! The inode has become a different object.
1650 */
1651#ifdef NFS_PARANOIA
1652 printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
1653 __FUNCTION__, inode->i_ino, inode->i_mode, fattr->mode);
1654#endif
Trond Myklebustb37b03b2005-11-25 17:10:06 -05001655 out_err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 /*
1657 * No need to worry about unhashing the dentry, as the
1658 * lookup validation will know that the inode is bad.
1659 * (But we fall through to invalidate the caches.)
1660 */
1661 nfs_invalidate_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 return -ESTALE;
Chuck Lever325cfed2005-11-30 18:08:55 -05001663
1664 out_fileid:
1665 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
1666 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
1667 NFS_SERVER(inode)->hostname, inode->i_sb->s_id,
1668 (long long)nfsi->fileid, (long long)fattr->fileid);
1669 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670}
1671
1672/*
1673 * File system information
1674 */
1675
1676static int nfs_set_super(struct super_block *s, void *data)
1677{
1678 s->s_fs_info = data;
1679 return set_anon_super(s, data);
1680}
1681
1682static int nfs_compare_super(struct super_block *sb, void *data)
1683{
1684 struct nfs_server *server = data;
1685 struct nfs_server *old = NFS_SB(sb);
1686
1687 if (old->addr.sin_addr.s_addr != server->addr.sin_addr.s_addr)
1688 return 0;
1689 if (old->addr.sin_port != server->addr.sin_port)
1690 return 0;
1691 return !nfs_compare_fh(&old->fh, &server->fh);
1692}
1693
David Howells454e2392006-06-23 02:02:57 -07001694static int nfs_get_sb(struct file_system_type *fs_type,
1695 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696{
1697 int error;
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001698 struct nfs_server *server = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 struct super_block *s;
1700 struct nfs_fh *root;
1701 struct nfs_mount_data *data = raw_data;
1702
David Howells454e2392006-06-23 02:02:57 -07001703 error = -EINVAL;
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001704 if (data == NULL) {
1705 dprintk("%s: missing data argument\n", __FUNCTION__);
David Howells454e2392006-06-23 02:02:57 -07001706 goto out_err_noserver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 }
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001708 if (data->version <= 0 || data->version > NFS_MOUNT_VERSION) {
1709 dprintk("%s: bad mount version\n", __FUNCTION__);
David Howells454e2392006-06-23 02:02:57 -07001710 goto out_err_noserver;
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001711 }
1712 switch (data->version) {
1713 case 1:
1714 data->namlen = 0;
1715 case 2:
1716 data->bsize = 0;
1717 case 3:
1718 if (data->flags & NFS_MOUNT_VER3) {
1719 dprintk("%s: mount structure version %d does not support NFSv3\n",
1720 __FUNCTION__,
1721 data->version);
David Howells454e2392006-06-23 02:02:57 -07001722 goto out_err_noserver;
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001723 }
1724 data->root.size = NFS2_FHSIZE;
1725 memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
1726 case 4:
1727 if (data->flags & NFS_MOUNT_SECFLAVOUR) {
1728 dprintk("%s: mount structure version %d does not support strong security\n",
1729 __FUNCTION__,
1730 data->version);
David Howells454e2392006-06-23 02:02:57 -07001731 goto out_err_noserver;
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001732 }
1733 case 5:
1734 memset(data->context, 0, sizeof(data->context));
1735 }
1736#ifndef CONFIG_NFS_V3
1737 /* If NFSv3 is not compiled in, return -EPROTONOSUPPORT */
David Howells454e2392006-06-23 02:02:57 -07001738 error = -EPROTONOSUPPORT;
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001739 if (data->flags & NFS_MOUNT_VER3) {
1740 dprintk("%s: NFSv3 not compiled into kernel\n", __FUNCTION__);
David Howells454e2392006-06-23 02:02:57 -07001741 goto out_err_noserver;
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001742 }
1743#endif /* CONFIG_NFS_V3 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744
David Howells454e2392006-06-23 02:02:57 -07001745 error = -ENOMEM;
Eric Sesterhennbd647542006-03-20 13:44:10 -05001746 server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 if (!server)
David Howells454e2392006-06-23 02:02:57 -07001748 goto out_err_noserver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 /* Zero out the NFS state stuff */
1750 init_nfsv4_state(server);
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00001751 server->client = server->client_sys = server->client_acl = ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 root = &server->fh;
1754 if (data->flags & NFS_MOUNT_VER3)
1755 root->size = data->root.size;
1756 else
1757 root->size = NFS2_FHSIZE;
David Howells454e2392006-06-23 02:02:57 -07001758 error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 if (root->size > sizeof(root->data)) {
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001760 dprintk("%s: invalid root filehandle\n", __FUNCTION__);
1761 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 }
1763 memcpy(root->data, data->root.data, root->size);
1764
1765 /* We now require that the mount process passes the remote address */
1766 memcpy(&server->addr, &data->addr, sizeof(server->addr));
1767 if (server->addr.sin_addr.s_addr == INADDR_ANY) {
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001768 dprintk("%s: mount program didn't pass remote address!\n",
1769 __FUNCTION__);
1770 goto out_err;
1771 }
1772
1773 /* Fire up rpciod if not yet running */
David Howells454e2392006-06-23 02:02:57 -07001774 error = rpciod_up();
1775 if (error < 0) {
1776 dprintk("%s: couldn't start rpciod! Error = %d\n",
1777 __FUNCTION__, error);
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001778 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 }
1780
1781 s = sget(fs_type, nfs_compare_super, nfs_set_super, server);
David Howells454e2392006-06-23 02:02:57 -07001782 if (IS_ERR(s)) {
1783 error = PTR_ERR(s);
1784 goto out_err_rpciod;
1785 }
1786
1787 if (s->s_root)
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001788 goto out_rpciod_down;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
1790 s->s_flags = flags;
1791
Theodore Ts'o9b04c992006-03-24 03:15:10 -08001792 error = nfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 if (error) {
1794 up_write(&s->s_umount);
1795 deactivate_super(s);
David Howells454e2392006-06-23 02:02:57 -07001796 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 }
1798 s->s_flags |= MS_ACTIVE;
David Howells454e2392006-06-23 02:02:57 -07001799 return simple_set_mnt(mnt, s);
1800
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001801out_rpciod_down:
1802 rpciod_down();
David Howells454e2392006-06-23 02:02:57 -07001803 kfree(server);
1804 return simple_set_mnt(mnt, s);
1805
1806out_err_rpciod:
1807 rpciod_down();
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001808out_err:
1809 kfree(server);
David Howells454e2392006-06-23 02:02:57 -07001810out_err_noserver:
1811 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812}
1813
1814static void nfs_kill_super(struct super_block *s)
1815{
1816 struct nfs_server *server = NFS_SB(s);
1817
1818 kill_anon_super(s);
1819
J. Bruce Fields6a192752005-06-22 17:16:23 +00001820 if (!IS_ERR(server->client))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 rpc_shutdown_client(server->client);
J. Bruce Fields6a192752005-06-22 17:16:23 +00001822 if (!IS_ERR(server->client_sys))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 rpc_shutdown_client(server->client_sys);
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00001824 if (!IS_ERR(server->client_acl))
1825 rpc_shutdown_client(server->client_acl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826
1827 if (!(server->flags & NFS_MOUNT_NONLM))
1828 lockd_down(); /* release rpc.lockd */
1829
1830 rpciod_down(); /* release rpciod */
1831
Trond Myklebust01d0ae82006-03-20 13:44:48 -05001832 nfs_free_iostats(server->io_stats);
Jesper Juhlf99d49a2005-11-07 01:01:34 -08001833 kfree(server->hostname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 kfree(server);
1835}
1836
1837static struct file_system_type nfs_fs_type = {
1838 .owner = THIS_MODULE,
1839 .name = "nfs",
1840 .get_sb = nfs_get_sb,
1841 .kill_sb = nfs_kill_super,
1842 .fs_flags = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
1843};
1844
1845#ifdef CONFIG_NFS_V4
1846
1847static void nfs4_clear_inode(struct inode *);
1848
1849
1850static struct super_operations nfs4_sops = {
1851 .alloc_inode = nfs_alloc_inode,
1852 .destroy_inode = nfs_destroy_inode,
1853 .write_inode = nfs_write_inode,
1854 .delete_inode = nfs_delete_inode,
1855 .statfs = nfs_statfs,
1856 .clear_inode = nfs4_clear_inode,
1857 .umount_begin = nfs_umount_begin,
1858 .show_options = nfs_show_options,
Chuck Leverd9ef5a82006-03-20 13:44:13 -05001859 .show_stats = nfs_show_stats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860};
1861
1862/*
1863 * Clean out any remaining NFSv4 state that might be left over due
1864 * to open() calls that passed nfs_atomic_lookup, but failed to call
1865 * nfs_open().
1866 */
1867static void nfs4_clear_inode(struct inode *inode)
1868{
1869 struct nfs_inode *nfsi = NFS_I(inode);
1870
1871 /* If we are holding a delegation, return it! */
Trond Myklebustcae7a072005-10-18 14:20:19 -07001872 nfs_inode_return_delegation(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 /* First call standard NFS clear_inode() code */
1874 nfs_clear_inode(inode);
1875 /* Now clear out any remaining state */
1876 while (!list_empty(&nfsi->open_states)) {
1877 struct nfs4_state *state;
1878
1879 state = list_entry(nfsi->open_states.next,
1880 struct nfs4_state,
1881 inode_states);
1882 dprintk("%s(%s/%Ld): found unclaimed NFSv4 state %p\n",
1883 __FUNCTION__,
1884 inode->i_sb->s_id,
1885 (long long)NFS_FILEID(inode),
1886 state);
1887 BUG_ON(atomic_read(&state->count) != 1);
1888 nfs4_close_state(state, state->state);
1889 }
1890}
1891
1892
1893static int nfs4_fill_super(struct super_block *sb, struct nfs4_mount_data *data, int silent)
1894{
1895 struct nfs_server *server;
1896 struct nfs4_client *clp = NULL;
1897 struct rpc_xprt *xprt = NULL;
1898 struct rpc_clnt *clnt = NULL;
1899 struct rpc_timeout timeparms;
1900 rpc_authflavor_t authflavour;
Chuck Levereab5c082005-08-11 16:25:14 -04001901 int err = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902
1903 sb->s_blocksize_bits = 0;
1904 sb->s_blocksize = 0;
1905 server = NFS_SB(sb);
1906 if (data->rsize != 0)
1907 server->rsize = nfs_block_size(data->rsize, NULL);
1908 if (data->wsize != 0)
1909 server->wsize = nfs_block_size(data->wsize, NULL);
1910 server->flags = data->flags & NFS_MOUNT_FLAGMASK;
1911 server->caps = NFS_CAP_ATOMIC_OPEN;
1912
1913 server->acregmin = data->acregmin*HZ;
1914 server->acregmax = data->acregmax*HZ;
1915 server->acdirmin = data->acdirmin*HZ;
1916 server->acdirmax = data->acdirmax*HZ;
1917
1918 server->rpc_ops = &nfs_v4_clientops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919
Chuck Levereab5c082005-08-11 16:25:14 -04001920 nfs_init_timeout_values(&timeparms, data->proto, data->timeo, data->retrans);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921
Chuck Lever7a480e22006-03-20 13:44:12 -05001922 server->retrans_timeo = timeparms.to_initval;
1923 server->retrans_count = timeparms.to_retries;
1924
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 clp = nfs4_get_client(&server->addr.sin_addr);
1926 if (!clp) {
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001927 dprintk("%s: failed to create NFS4 client.\n", __FUNCTION__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 return -EIO;
1929 }
1930
1931 /* Now create transport and client */
1932 authflavour = RPC_AUTH_UNIX;
1933 if (data->auth_flavourlen != 0) {
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001934 if (data->auth_flavourlen != 1) {
1935 dprintk("%s: Invalid number of RPC auth flavours %d.\n",
1936 __FUNCTION__, data->auth_flavourlen);
1937 err = -EINVAL;
1938 goto out_fail;
1939 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 if (copy_from_user(&authflavour, data->auth_flavours, sizeof(authflavour))) {
1941 err = -EFAULT;
1942 goto out_fail;
1943 }
1944 }
1945
1946 down_write(&clp->cl_sem);
J. Bruce Fields6a192752005-06-22 17:16:23 +00001947 if (IS_ERR(clp->cl_rpcclient)) {
Chuck Levereab5c082005-08-11 16:25:14 -04001948 xprt = xprt_create_proto(data->proto, &server->addr, &timeparms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 if (IS_ERR(xprt)) {
1950 up_write(&clp->cl_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 err = PTR_ERR(xprt);
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001952 dprintk("%s: cannot create RPC transport. Error = %d\n",
1953 __FUNCTION__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 goto out_fail;
1955 }
1956 clnt = rpc_create_client(xprt, server->hostname, &nfs_program,
1957 server->rpc_ops->version, authflavour);
1958 if (IS_ERR(clnt)) {
1959 up_write(&clp->cl_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 err = PTR_ERR(clnt);
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001961 dprintk("%s: cannot create RPC client. Error = %d\n",
1962 __FUNCTION__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 goto out_fail;
1964 }
1965 clnt->cl_intr = 1;
1966 clnt->cl_softrtry = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 clp->cl_rpcclient = clnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 memcpy(clp->cl_ipaddr, server->ip_addr, sizeof(clp->cl_ipaddr));
1969 nfs_idmap_new(clp);
1970 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 list_add_tail(&server->nfs4_siblings, &clp->cl_superblocks);
1972 clnt = rpc_clone_client(clp->cl_rpcclient);
1973 if (!IS_ERR(clnt))
1974 server->nfs4_state = clp;
1975 up_write(&clp->cl_sem);
1976 clp = NULL;
1977
1978 if (IS_ERR(clnt)) {
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001979 err = PTR_ERR(clnt);
1980 dprintk("%s: cannot create RPC client. Error = %d\n",
1981 __FUNCTION__, err);
1982 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 }
1984
1985 server->client = clnt;
1986
1987 if (server->nfs4_state->cl_idmap == NULL) {
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001988 dprintk("%s: failed to create idmapper.\n", __FUNCTION__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 return -ENOMEM;
1990 }
1991
1992 if (clnt->cl_auth->au_flavor != authflavour) {
J. Bruce Fields6a192752005-06-22 17:16:23 +00001993 struct rpc_auth *auth;
1994
1995 auth = rpcauth_create(authflavour, clnt);
1996 if (IS_ERR(auth)) {
Trond Myklebust9085bbc2005-06-22 17:16:20 +00001997 dprintk("%s: couldn't create credcache!\n", __FUNCTION__);
J. Bruce Fields6a192752005-06-22 17:16:23 +00001998 return PTR_ERR(auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 }
2000 }
2001
2002 sb->s_time_gran = 1;
2003
2004 sb->s_op = &nfs4_sops;
2005 err = nfs_sb_init(sb, authflavour);
2006 if (err == 0)
2007 return 0;
2008out_fail:
2009 if (clp)
2010 nfs4_put_client(clp);
2011 return err;
2012}
2013
2014static int nfs4_compare_super(struct super_block *sb, void *data)
2015{
2016 struct nfs_server *server = data;
2017 struct nfs_server *old = NFS_SB(sb);
2018
2019 if (strcmp(server->hostname, old->hostname) != 0)
2020 return 0;
2021 if (strcmp(server->mnt_path, old->mnt_path) != 0)
2022 return 0;
2023 return 1;
2024}
2025
2026static void *
2027nfs_copy_user_string(char *dst, struct nfs_string *src, int maxlen)
2028{
2029 void *p = NULL;
2030
2031 if (!src->len)
2032 return ERR_PTR(-EINVAL);
2033 if (src->len < maxlen)
2034 maxlen = src->len;
2035 if (dst == NULL) {
2036 p = dst = kmalloc(maxlen + 1, GFP_KERNEL);
2037 if (p == NULL)
2038 return ERR_PTR(-ENOMEM);
2039 }
2040 if (copy_from_user(dst, src->data, maxlen)) {
Jesper Juhlf99d49a2005-11-07 01:01:34 -08002041 kfree(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 return ERR_PTR(-EFAULT);
2043 }
2044 dst[maxlen] = '\0';
2045 return dst;
2046}
2047
David Howells454e2392006-06-23 02:02:57 -07002048static int nfs4_get_sb(struct file_system_type *fs_type,
2049 int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050{
2051 int error;
2052 struct nfs_server *server;
2053 struct super_block *s;
2054 struct nfs4_mount_data *data = raw_data;
2055 void *p;
2056
Trond Myklebust9085bbc2005-06-22 17:16:20 +00002057 if (data == NULL) {
2058 dprintk("%s: missing data argument\n", __FUNCTION__);
David Howells454e2392006-06-23 02:02:57 -07002059 return -EINVAL;
Trond Myklebust9085bbc2005-06-22 17:16:20 +00002060 }
2061 if (data->version <= 0 || data->version > NFS4_MOUNT_VERSION) {
2062 dprintk("%s: bad mount version\n", __FUNCTION__);
David Howells454e2392006-06-23 02:02:57 -07002063 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 }
2065
Eric Sesterhennbd647542006-03-20 13:44:10 -05002066 server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 if (!server)
David Howells454e2392006-06-23 02:02:57 -07002068 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 /* Zero out the NFS state stuff */
2070 init_nfsv4_state(server);
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00002071 server->client = server->client_sys = server->client_acl = ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 p = nfs_copy_user_string(NULL, &data->hostname, 256);
2074 if (IS_ERR(p))
2075 goto out_err;
2076 server->hostname = p;
2077
2078 p = nfs_copy_user_string(NULL, &data->mnt_path, 1024);
2079 if (IS_ERR(p))
2080 goto out_err;
2081 server->mnt_path = p;
2082
2083 p = nfs_copy_user_string(server->ip_addr, &data->client_addr,
2084 sizeof(server->ip_addr) - 1);
2085 if (IS_ERR(p))
2086 goto out_err;
2087
2088 /* We now require that the mount process passes the remote address */
2089 if (data->host_addrlen != sizeof(server->addr)) {
David Howells454e2392006-06-23 02:02:57 -07002090 error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 goto out_free;
2092 }
2093 if (copy_from_user(&server->addr, data->host_addr, sizeof(server->addr))) {
David Howells454e2392006-06-23 02:02:57 -07002094 error = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 goto out_free;
2096 }
2097 if (server->addr.sin_family != AF_INET ||
2098 server->addr.sin_addr.s_addr == INADDR_ANY) {
Trond Myklebust9085bbc2005-06-22 17:16:20 +00002099 dprintk("%s: mount program didn't pass remote IP address!\n",
2100 __FUNCTION__);
David Howells454e2392006-06-23 02:02:57 -07002101 error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 goto out_free;
2103 }
2104
Trond Myklebust9085bbc2005-06-22 17:16:20 +00002105 /* Fire up rpciod if not yet running */
David Howells454e2392006-06-23 02:02:57 -07002106 error = rpciod_up();
2107 if (error < 0) {
2108 dprintk("%s: couldn't start rpciod! Error = %d\n",
2109 __FUNCTION__, error);
Trond Myklebust9085bbc2005-06-22 17:16:20 +00002110 goto out_free;
2111 }
2112
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 s = sget(fs_type, nfs4_compare_super, nfs_set_super, server);
David Howells454e2392006-06-23 02:02:57 -07002114 if (IS_ERR(s)) {
2115 error = PTR_ERR(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 goto out_free;
David Howells454e2392006-06-23 02:02:57 -07002117 }
2118
2119 if (s->s_root) {
2120 kfree(server->mnt_path);
2121 kfree(server->hostname);
2122 kfree(server);
2123 return simple_set_mnt(mnt, s);
2124 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125
2126 s->s_flags = flags;
2127
Theodore Ts'o9b04c992006-03-24 03:15:10 -08002128 error = nfs4_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 if (error) {
2130 up_write(&s->s_umount);
2131 deactivate_super(s);
David Howells454e2392006-06-23 02:02:57 -07002132 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 }
2134 s->s_flags |= MS_ACTIVE;
David Howells454e2392006-06-23 02:02:57 -07002135 return simple_set_mnt(mnt, s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136out_err:
David Howells454e2392006-06-23 02:02:57 -07002137 error = PTR_ERR(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138out_free:
Jesper Juhlf99d49a2005-11-07 01:01:34 -08002139 kfree(server->mnt_path);
2140 kfree(server->hostname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 kfree(server);
David Howells454e2392006-06-23 02:02:57 -07002142 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143}
2144
2145static void nfs4_kill_super(struct super_block *sb)
2146{
2147 struct nfs_server *server = NFS_SB(sb);
2148
2149 nfs_return_all_delegations(sb);
2150 kill_anon_super(sb);
2151
2152 nfs4_renewd_prepare_shutdown(server);
2153
2154 if (server->client != NULL && !IS_ERR(server->client))
2155 rpc_shutdown_client(server->client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156
2157 destroy_nfsv4_state(server);
2158
Trond Myklebust967b9282006-03-20 13:44:09 -05002159 rpciod_down();
2160
Trond Myklebust01d0ae82006-03-20 13:44:48 -05002161 nfs_free_iostats(server->io_stats);
Jesper Juhlf99d49a2005-11-07 01:01:34 -08002162 kfree(server->hostname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 kfree(server);
2164}
2165
2166static struct file_system_type nfs4_fs_type = {
2167 .owner = THIS_MODULE,
2168 .name = "nfs4",
2169 .get_sb = nfs4_get_sb,
2170 .kill_sb = nfs4_kill_super,
2171 .fs_flags = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
2172};
2173
Trond Myklebusta72b4422006-01-03 09:55:41 +01002174static const int nfs_set_port_min = 0;
2175static const int nfs_set_port_max = 65535;
2176static int param_set_port(const char *val, struct kernel_param *kp)
2177{
2178 char *endp;
2179 int num = simple_strtol(val, &endp, 0);
2180 if (endp == val || *endp || num < nfs_set_port_min || num > nfs_set_port_max)
2181 return -EINVAL;
2182 *((int *)kp->arg) = num;
2183 return 0;
2184}
2185
2186module_param_call(callback_tcpport, param_set_port, param_get_int,
2187 &nfs_callback_set_tcpport, 0644);
2188
Trond Myklebust58df0952006-01-03 09:55:57 +01002189static int param_set_idmap_timeout(const char *val, struct kernel_param *kp)
2190{
2191 char *endp;
2192 int num = simple_strtol(val, &endp, 0);
2193 int jif = num * HZ;
2194 if (endp == val || *endp || num < 0 || jif < num)
2195 return -EINVAL;
2196 *((int *)kp->arg) = jif;
2197 return 0;
2198}
2199
2200module_param_call(idmap_cache_timeout, param_set_idmap_timeout, param_get_int,
2201 &nfs_idmap_cache_timeout, 0644);
2202
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203#define nfs4_init_once(nfsi) \
2204 do { \
2205 INIT_LIST_HEAD(&(nfsi)->open_states); \
2206 nfsi->delegation = NULL; \
2207 nfsi->delegation_state = 0; \
2208 init_rwsem(&nfsi->rwsem); \
2209 } while(0)
Trond Myklebusta72b4422006-01-03 09:55:41 +01002210
2211static inline int register_nfs4fs(void)
2212{
2213 int ret;
2214
2215 ret = nfs_register_sysctl();
2216 if (ret != 0)
2217 return ret;
2218 ret = register_filesystem(&nfs4_fs_type);
2219 if (ret != 0)
2220 nfs_unregister_sysctl();
2221 return ret;
2222}
2223
2224static inline void unregister_nfs4fs(void)
2225{
2226 unregister_filesystem(&nfs4_fs_type);
2227 nfs_unregister_sysctl();
2228}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229#else
2230#define nfs4_init_once(nfsi) \
2231 do { } while (0)
2232#define register_nfs4fs() (0)
2233#define unregister_nfs4fs()
2234#endif
2235
2236extern int nfs_init_nfspagecache(void);
2237extern void nfs_destroy_nfspagecache(void);
2238extern int nfs_init_readpagecache(void);
2239extern void nfs_destroy_readpagecache(void);
2240extern int nfs_init_writepagecache(void);
2241extern void nfs_destroy_writepagecache(void);
2242#ifdef CONFIG_NFS_DIRECTIO
2243extern int nfs_init_directcache(void);
2244extern void nfs_destroy_directcache(void);
2245#endif
2246
2247static kmem_cache_t * nfs_inode_cachep;
2248
2249static struct inode *nfs_alloc_inode(struct super_block *sb)
2250{
2251 struct nfs_inode *nfsi;
2252 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, SLAB_KERNEL);
2253 if (!nfsi)
2254 return NULL;
Chuck Lever55296802005-08-18 11:24:09 -07002255 nfsi->flags = 0UL;
2256 nfsi->cache_validity = 0UL;
Steve Dickson223db122005-11-30 09:25:33 -05002257 nfsi->cache_change_attribute = jiffies;
Trond Myklebust458818e2005-06-22 17:16:27 +00002258#ifdef CONFIG_NFS_V3_ACL
2259 nfsi->acl_access = ERR_PTR(-EAGAIN);
2260 nfsi->acl_default = ERR_PTR(-EAGAIN);
2261#endif
J. Bruce Fieldse50a1c22005-06-22 17:16:23 +00002262#ifdef CONFIG_NFS_V4
2263 nfsi->nfs4_acl = NULL;
2264#endif /* CONFIG_NFS_V4 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 return &nfsi->vfs_inode;
2266}
2267
2268static void nfs_destroy_inode(struct inode *inode)
2269{
2270 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
2271}
2272
2273static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
2274{
2275 struct nfs_inode *nfsi = (struct nfs_inode *) foo;
2276
2277 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
2278 SLAB_CTOR_CONSTRUCTOR) {
2279 inode_init_once(&nfsi->vfs_inode);
2280 spin_lock_init(&nfsi->req_lock);
2281 INIT_LIST_HEAD(&nfsi->dirty);
2282 INIT_LIST_HEAD(&nfsi->commit);
2283 INIT_LIST_HEAD(&nfsi->open_files);
2284 INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
2285 atomic_set(&nfsi->data_updates, 0);
2286 nfsi->ndirty = 0;
2287 nfsi->ncommit = 0;
2288 nfsi->npages = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 nfs4_init_once(nfsi);
2290 }
2291}
2292
Adrian Bunk75c96f82005-05-05 16:16:09 -07002293static int nfs_init_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294{
2295 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
2296 sizeof(struct nfs_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -08002297 0, (SLAB_RECLAIM_ACCOUNT|
2298 SLAB_MEM_SPREAD),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 init_once, NULL);
2300 if (nfs_inode_cachep == NULL)
2301 return -ENOMEM;
2302
2303 return 0;
2304}
2305
Adrian Bunk75c96f82005-05-05 16:16:09 -07002306static void nfs_destroy_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307{
2308 if (kmem_cache_destroy(nfs_inode_cachep))
2309 printk(KERN_INFO "nfs_inode_cache: not all structures were freed\n");
2310}
2311
2312/*
2313 * Initialize NFS
2314 */
2315static int __init init_nfs_fs(void)
2316{
2317 int err;
2318
2319 err = nfs_init_nfspagecache();
2320 if (err)
2321 goto out4;
2322
2323 err = nfs_init_inodecache();
2324 if (err)
2325 goto out3;
2326
2327 err = nfs_init_readpagecache();
2328 if (err)
2329 goto out2;
2330
2331 err = nfs_init_writepagecache();
2332 if (err)
2333 goto out1;
2334
2335#ifdef CONFIG_NFS_DIRECTIO
2336 err = nfs_init_directcache();
2337 if (err)
2338 goto out0;
2339#endif
2340
2341#ifdef CONFIG_PROC_FS
2342 rpc_proc_register(&nfs_rpcstat);
2343#endif
2344 err = register_filesystem(&nfs_fs_type);
2345 if (err)
2346 goto out;
2347 if ((err = register_nfs4fs()) != 0)
2348 goto out;
2349 return 0;
2350out:
2351#ifdef CONFIG_PROC_FS
2352 rpc_proc_unregister("nfs");
2353#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354#ifdef CONFIG_NFS_DIRECTIO
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355 nfs_destroy_directcache();
Chuck Lever6b59a752005-11-30 18:08:19 -05002356out0:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357#endif
Chuck Lever6b59a752005-11-30 18:08:19 -05002358 nfs_destroy_writepagecache();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359out1:
2360 nfs_destroy_readpagecache();
2361out2:
2362 nfs_destroy_inodecache();
2363out3:
2364 nfs_destroy_nfspagecache();
2365out4:
2366 return err;
2367}
2368
2369static void __exit exit_nfs_fs(void)
2370{
2371#ifdef CONFIG_NFS_DIRECTIO
2372 nfs_destroy_directcache();
2373#endif
2374 nfs_destroy_writepagecache();
2375 nfs_destroy_readpagecache();
2376 nfs_destroy_inodecache();
2377 nfs_destroy_nfspagecache();
2378#ifdef CONFIG_PROC_FS
2379 rpc_proc_unregister("nfs");
2380#endif
2381 unregister_filesystem(&nfs_fs_type);
2382 unregister_nfs4fs();
2383}
2384
2385/* Not quite true; I just maintain it */
2386MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2387MODULE_LICENSE("GPL");
2388
2389module_init(init_nfs_fs)
2390module_exit(exit_nfs_fs)