1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/module.h>
17#include <linux/init.h>
18#include <linux/sched.h>
19#include <linux/time.h>
20#include <linux/kernel.h>
21#include <linux/mm.h>
22#include <linux/string.h>
23#include <linux/stat.h>
24#include <linux/errno.h>
25#include <linux/unistd.h>
26#include <linux/sunrpc/clnt.h>
27#include <linux/sunrpc/stats.h>
28#include <linux/sunrpc/metrics.h>
29#include <linux/nfs_fs.h>
30#include <linux/nfs_mount.h>
31#include <linux/nfs4_mount.h>
32#include <linux/lockd/bind.h>
33#include <linux/seq_file.h>
34#include <linux/mount.h>
35#include <linux/vfs.h>
36#include <linux/inet.h>
37#include <linux/nfs_xdr.h>
38#include <linux/slab.h>
39#include <linux/compat.h>
40#include <linux/freezer.h>
41#include <linux/crc32.h>
42
43#include <asm/uaccess.h>
44
45#include "nfs4_fs.h"
46#include "callback.h"
47#include "delegation.h"
48#include "iostat.h"
49#include "internal.h"
50#include "fscache.h"
51#include "dns_resolve.h"
52#include "pnfs.h"
53#include "nfs.h"
54#include "netns.h"
55
56#define NFSDBG_FACILITY NFSDBG_VFS
57
58#define NFS_64_BIT_INODE_NUMBERS_ENABLED 1
59
60
61static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
62
63static void nfs_invalidate_inode(struct inode *);
64static int nfs_update_inode(struct inode *, struct nfs_fattr *);
65
66static struct kmem_cache * nfs_inode_cachep;
67
68static inline unsigned long
69nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
70{
71 return nfs_fileid_to_ino_t(fattr->fileid);
72}
73
74
75
76
77
78int nfs_wait_bit_killable(void *word)
79{
80 if (fatal_signal_pending(current))
81 return -ERESTARTSYS;
82 freezable_schedule();
83 return 0;
84}
85EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
86
87
88
89
90
91
92
93
94u64 nfs_compat_user_ino64(u64 fileid)
95{
96#ifdef CONFIG_COMPAT
97 compat_ulong_t ino;
98#else
99 unsigned long ino;
100#endif
101
102 if (enable_ino64)
103 return fileid;
104 ino = fileid;
105 if (sizeof(ino) < sizeof(fileid))
106 ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
107 return ino;
108}
109
110int nfs_drop_inode(struct inode *inode)
111{
112 return NFS_STALE(inode) || generic_drop_inode(inode);
113}
114EXPORT_SYMBOL_GPL(nfs_drop_inode);
115
116void nfs_clear_inode(struct inode *inode)
117{
118
119
120
121 WARN_ON_ONCE(nfs_have_writebacks(inode));
122 WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
123 nfs_zap_acl_cache(inode);
124 nfs_access_zap_cache(inode);
125 nfs_fscache_release_inode_cookie(inode);
126}
127EXPORT_SYMBOL_GPL(nfs_clear_inode);
128
129void nfs_evict_inode(struct inode *inode)
130{
131 truncate_inode_pages(&inode->i_data, 0);
132 clear_inode(inode);
133 nfs_clear_inode(inode);
134}
135
136
137
138
139int nfs_sync_mapping(struct address_space *mapping)
140{
141 int ret = 0;
142
143 if (mapping->nrpages != 0) {
144 unmap_mapping_range(mapping, 0, 0, 0);
145 ret = nfs_wb_all(mapping->host);
146 }
147 return ret;
148}
149
150
151
152
153static void nfs_zap_caches_locked(struct inode *inode)
154{
155 struct nfs_inode *nfsi = NFS_I(inode);
156 int mode = inode->i_mode;
157
158 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
159
160 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
161 nfsi->attrtimeo_timestamp = jiffies;
162
163 memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
164 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
165 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
166 nfs_fscache_invalidate(inode);
167 } else {
168 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
169 }
170}
171
172void nfs_zap_caches(struct inode *inode)
173{
174 spin_lock(&inode->i_lock);
175 nfs_zap_caches_locked(inode);
176 spin_unlock(&inode->i_lock);
177}
178
179void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
180{
181 if (mapping->nrpages != 0) {
182 spin_lock(&inode->i_lock);
183 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
184 nfs_fscache_invalidate(inode);
185 spin_unlock(&inode->i_lock);
186 }
187}
188
189void nfs_zap_acl_cache(struct inode *inode)
190{
191 void (*clear_acl_cache)(struct inode *);
192
193 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
194 if (clear_acl_cache != NULL)
195 clear_acl_cache(inode);
196 spin_lock(&inode->i_lock);
197 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
198 spin_unlock(&inode->i_lock);
199}
200EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
201
202void nfs_invalidate_atime(struct inode *inode)
203{
204 spin_lock(&inode->i_lock);
205 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
206 spin_unlock(&inode->i_lock);
207}
208EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
209
210
211
212
213
214static void nfs_invalidate_inode(struct inode *inode)
215{
216 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
217 nfs_zap_caches_locked(inode);
218}
219
220struct nfs_find_desc {
221 struct nfs_fh *fh;
222 struct nfs_fattr *fattr;
223};
224
225
226
227
228
229
230
231static int
232nfs_find_actor(struct inode *inode, void *opaque)
233{
234 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
235 struct nfs_fh *fh = desc->fh;
236 struct nfs_fattr *fattr = desc->fattr;
237
238 if (NFS_FILEID(inode) != fattr->fileid)
239 return 0;
240 if ((S_IFMT & inode->i_mode) != (S_IFMT & fattr->mode))
241 return 0;
242 if (nfs_compare_fh(NFS_FH(inode), fh))
243 return 0;
244 if (is_bad_inode(inode) || NFS_STALE(inode))
245 return 0;
246 return 1;
247}
248
249static int
250nfs_init_locked(struct inode *inode, void *opaque)
251{
252 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
253 struct nfs_fattr *fattr = desc->fattr;
254
255 set_nfs_fileid(inode, fattr->fileid);
256 nfs_copy_fh(NFS_FH(inode), desc->fh);
257 return 0;
258}
259
260
261
262
263
264struct inode *
265nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
266{
267 struct nfs_find_desc desc = {
268 .fh = fh,
269 .fattr = fattr
270 };
271 struct inode *inode = ERR_PTR(-ENOENT);
272 unsigned long hash;
273
274 nfs_attr_check_mountpoint(sb, fattr);
275
276 if (((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0) &&
277 !nfs_attr_use_mounted_on_fileid(fattr))
278 goto out_no_inode;
279 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
280 goto out_no_inode;
281
282 hash = nfs_fattr_to_ino_t(fattr);
283
284 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
285 if (inode == NULL) {
286 inode = ERR_PTR(-ENOMEM);
287 goto out_no_inode;
288 }
289
290 if (inode->i_state & I_NEW) {
291 struct nfs_inode *nfsi = NFS_I(inode);
292 unsigned long now = jiffies;
293
294
295
296 inode->i_ino = hash;
297
298
299 inode->i_flags |= S_NOATIME|S_NOCMTIME;
300 inode->i_mode = fattr->mode;
301 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
302 && nfs_server_capable(inode, NFS_CAP_MODE))
303 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
304
305
306
307 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
308 if (S_ISREG(inode->i_mode)) {
309 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
310 inode->i_data.a_ops = &nfs_file_aops;
311 inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
312 } else if (S_ISDIR(inode->i_mode)) {
313 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
314 inode->i_fop = &nfs_dir_operations;
315 inode->i_data.a_ops = &nfs_dir_aops;
316
317 if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
318 fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
319 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
320 inode->i_op = &nfs_referral_inode_operations;
321 else
322 inode->i_op = &nfs_mountpoint_inode_operations;
323 inode->i_fop = NULL;
324 inode->i_flags |= S_AUTOMOUNT;
325 }
326 } else if (S_ISLNK(inode->i_mode))
327 inode->i_op = &nfs_symlink_inode_operations;
328 else
329 init_special_inode(inode, inode->i_mode, fattr->rdev);
330
331 memset(&inode->i_atime, 0, sizeof(inode->i_atime));
332 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
333 memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
334 inode->i_version = 0;
335 inode->i_size = 0;
336 clear_nlink(inode);
337 inode->i_uid = make_kuid(&init_user_ns, -2);
338 inode->i_gid = make_kgid(&init_user_ns, -2);
339 inode->i_blocks = 0;
340 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
341 nfsi->write_io = 0;
342 nfsi->read_io = 0;
343
344 nfsi->read_cache_jiffies = fattr->time_start;
345 nfsi->attr_gencount = fattr->gencount;
346 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
347 inode->i_atime = fattr->atime;
348 else if (nfs_server_capable(inode, NFS_CAP_ATIME))
349 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
350 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
351 inode->i_mtime = fattr->mtime;
352 else if (nfs_server_capable(inode, NFS_CAP_MTIME))
353 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
354 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
355 inode->i_ctime = fattr->ctime;
356 else if (nfs_server_capable(inode, NFS_CAP_CTIME))
357 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
358 if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
359 inode->i_version = fattr->change_attr;
360 else if (nfs_server_capable(inode, NFS_CAP_CHANGE_ATTR))
361 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
362 if (fattr->valid & NFS_ATTR_FATTR_SIZE)
363 inode->i_size = nfs_size_to_loff_t(fattr->size);
364 else
365 nfsi->cache_validity |= NFS_INO_INVALID_ATTR
366 | NFS_INO_REVAL_PAGECACHE;
367 if (fattr->valid & NFS_ATTR_FATTR_NLINK)
368 set_nlink(inode, fattr->nlink);
369 else if (nfs_server_capable(inode, NFS_CAP_NLINK))
370 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
371 if (fattr->valid & NFS_ATTR_FATTR_OWNER)
372 inode->i_uid = fattr->uid;
373 else if (nfs_server_capable(inode, NFS_CAP_OWNER))
374 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
375 if (fattr->valid & NFS_ATTR_FATTR_GROUP)
376 inode->i_gid = fattr->gid;
377 else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP))
378 nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
379 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
380 inode->i_blocks = fattr->du.nfs2.blocks;
381 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
382
383
384
385 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
386 }
387 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
388 nfsi->attrtimeo_timestamp = now;
389 nfsi->access_cache = RB_ROOT;
390
391 nfs_fscache_init_inode_cookie(inode);
392
393 unlock_new_inode(inode);
394 } else
395 nfs_refresh_inode(inode, fattr);
396 dprintk("NFS: nfs_fhget(%s/%Ld fh_crc=0x%08x ct=%d)\n",
397 inode->i_sb->s_id,
398 (long long)NFS_FILEID(inode),
399 nfs_display_fhandle_hash(fh),
400 atomic_read(&inode->i_count));
401
402out:
403 return inode;
404
405out_no_inode:
406 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
407 goto out;
408}
409EXPORT_SYMBOL_GPL(nfs_fhget);
410
411#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE|ATTR_OPEN)
412
413int
414nfs_setattr(struct dentry *dentry, struct iattr *attr)
415{
416 struct inode *inode = dentry->d_inode;
417 struct nfs_fattr *fattr;
418 int error = -ENOMEM;
419
420 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
421
422
423 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
424 attr->ia_valid &= ~ATTR_MODE;
425
426 if (attr->ia_valid & ATTR_SIZE) {
427 if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode))
428 attr->ia_valid &= ~ATTR_SIZE;
429 }
430
431
432 attr->ia_valid &= NFS_VALID_ATTRS;
433 if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
434 return 0;
435
436
437 if (S_ISREG(inode->i_mode)) {
438 nfs_inode_dio_wait(inode);
439 nfs_wb_all(inode);
440 }
441
442 fattr = nfs_alloc_fattr();
443 if (fattr == NULL)
444 goto out;
445
446
447
448 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
449 NFS_PROTO(inode)->return_delegation(inode);
450 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
451 if (error == 0)
452 nfs_refresh_inode(inode, fattr);
453 nfs_free_fattr(fattr);
454out:
455 return error;
456}
457EXPORT_SYMBOL_GPL(nfs_setattr);
458
459
460
461
462
463
464
465
466
467
468static int nfs_vmtruncate(struct inode * inode, loff_t offset)
469{
470 loff_t oldsize;
471 int err;
472
473 err = inode_newsize_ok(inode, offset);
474 if (err)
475 goto out;
476
477 spin_lock(&inode->i_lock);
478 oldsize = inode->i_size;
479 i_size_write(inode, offset);
480 spin_unlock(&inode->i_lock);
481
482 truncate_pagecache(inode, oldsize, offset);
483out:
484 return err;
485}
486
487
488
489
490
491
492
493
494
495void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
496{
497 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
498 spin_lock(&inode->i_lock);
499 if ((attr->ia_valid & ATTR_MODE) != 0) {
500 int mode = attr->ia_mode & S_IALLUGO;
501 mode |= inode->i_mode & ~S_IALLUGO;
502 inode->i_mode = mode;
503 }
504 if ((attr->ia_valid & ATTR_UID) != 0)
505 inode->i_uid = attr->ia_uid;
506 if ((attr->ia_valid & ATTR_GID) != 0)
507 inode->i_gid = attr->ia_gid;
508 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
509 spin_unlock(&inode->i_lock);
510 }
511 if ((attr->ia_valid & ATTR_SIZE) != 0) {
512 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
513 nfs_vmtruncate(inode, attr->ia_size);
514 }
515}
516EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
517
518int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
519{
520 struct inode *inode = dentry->d_inode;
521 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
522 int err;
523
524
525 if (S_ISREG(inode->i_mode)) {
526 nfs_inode_dio_wait(inode);
527 err = filemap_write_and_wait(inode->i_mapping);
528 if (err)
529 goto out;
530 }
531
532
533
534
535
536
537
538
539
540
541 if ((mnt->mnt_flags & MNT_NOATIME) ||
542 ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
543 need_atime = 0;
544
545 if (need_atime)
546 err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
547 else
548 err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
549 if (!err) {
550 generic_fillattr(inode, stat);
551 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
552 }
553out:
554 return err;
555}
556EXPORT_SYMBOL_GPL(nfs_getattr);
557
558static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
559{
560 atomic_set(&l_ctx->count, 1);
561 l_ctx->lockowner.l_owner = current->files;
562 l_ctx->lockowner.l_pid = current->tgid;
563 INIT_LIST_HEAD(&l_ctx->list);
564 nfs_iocounter_init(&l_ctx->io_count);
565}
566
567static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
568{
569 struct nfs_lock_context *head = &ctx->lock_context;
570 struct nfs_lock_context *pos = head;
571
572 do {
573 if (pos->lockowner.l_owner != current->files)
574 continue;
575 if (pos->lockowner.l_pid != current->tgid)
576 continue;
577 atomic_inc(&pos->count);
578 return pos;
579 } while ((pos = list_entry(pos->list.next, typeof(*pos), list)) != head);
580 return NULL;
581}
582
583struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
584{
585 struct nfs_lock_context *res, *new = NULL;
586 struct inode *inode = ctx->dentry->d_inode;
587
588 spin_lock(&inode->i_lock);
589 res = __nfs_find_lock_context(ctx);
590 if (res == NULL) {
591 spin_unlock(&inode->i_lock);
592 new = kmalloc(sizeof(*new), GFP_KERNEL);
593 if (new == NULL)
594 return ERR_PTR(-ENOMEM);
595 nfs_init_lock_context(new);
596 spin_lock(&inode->i_lock);
597 res = __nfs_find_lock_context(ctx);
598 if (res == NULL) {
599 list_add_tail(&new->list, &ctx->lock_context.list);
600 new->open_context = ctx;
601 res = new;
602 new = NULL;
603 }
604 }
605 spin_unlock(&inode->i_lock);
606 kfree(new);
607 return res;
608}
609
610void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
611{
612 struct nfs_open_context *ctx = l_ctx->open_context;
613 struct inode *inode = ctx->dentry->d_inode;
614
615 if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
616 return;
617 list_del(&l_ctx->list);
618 spin_unlock(&inode->i_lock);
619 kfree(l_ctx);
620}
621
622
623
624
625
626
627
628
629
630void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
631{
632 struct inode *inode;
633 struct nfs_server *server;
634
635 if (!(ctx->mode & FMODE_WRITE))
636 return;
637 if (!is_sync)
638 return;
639 inode = ctx->dentry->d_inode;
640 if (!list_empty(&NFS_I(inode)->open_files))
641 return;
642 server = NFS_SERVER(inode);
643 if (server->flags & NFS_MOUNT_NOCTO)
644 return;
645 nfs_revalidate_inode(server, inode);
646}
647EXPORT_SYMBOL_GPL(nfs_close_context);
648
649struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode)
650{
651 struct nfs_open_context *ctx;
652 struct rpc_cred *cred = rpc_lookup_cred();
653 if (IS_ERR(cred))
654 return ERR_CAST(cred);
655
656 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
657 if (!ctx) {
658 put_rpccred(cred);
659 return ERR_PTR(-ENOMEM);
660 }
661 nfs_sb_active(dentry->d_sb);
662 ctx->dentry = dget(dentry);
663 ctx->cred = cred;
664 ctx->state = NULL;
665 ctx->mode = f_mode;
666 ctx->flags = 0;
667 ctx->error = 0;
668 nfs_init_lock_context(&ctx->lock_context);
669 ctx->lock_context.open_context = ctx;
670 INIT_LIST_HEAD(&ctx->list);
671 ctx->mdsthreshold = NULL;
672 return ctx;
673}
674EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
675
676struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
677{
678 if (ctx != NULL)
679 atomic_inc(&ctx->lock_context.count);
680 return ctx;
681}
682EXPORT_SYMBOL_GPL(get_nfs_open_context);
683
684static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
685{
686 struct inode *inode = ctx->dentry->d_inode;
687 struct super_block *sb = ctx->dentry->d_sb;
688
689 if (!list_empty(&ctx->list)) {
690 if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock))
691 return;
692 list_del(&ctx->list);
693 spin_unlock(&inode->i_lock);
694 } else if (!atomic_dec_and_test(&ctx->lock_context.count))
695 return;
696 if (inode != NULL)
697 NFS_PROTO(inode)->close_context(ctx, is_sync);
698 if (ctx->cred != NULL)
699 put_rpccred(ctx->cred);
700 dput(ctx->dentry);
701 nfs_sb_deactive(sb);
702 kfree(ctx->mdsthreshold);
703 kfree(ctx);
704}
705
706void put_nfs_open_context(struct nfs_open_context *ctx)
707{
708 __put_nfs_open_context(ctx, 0);
709}
710EXPORT_SYMBOL_GPL(put_nfs_open_context);
711
712
713
714
715
716void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
717{
718 struct inode *inode = file_inode(filp);
719 struct nfs_inode *nfsi = NFS_I(inode);
720
721 filp->private_data = get_nfs_open_context(ctx);
722 spin_lock(&inode->i_lock);
723 list_add(&ctx->list, &nfsi->open_files);
724 spin_unlock(&inode->i_lock);
725}
726EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
727
728
729
730
731struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
732{
733 struct nfs_inode *nfsi = NFS_I(inode);
734 struct nfs_open_context *pos, *ctx = NULL;
735
736 spin_lock(&inode->i_lock);
737 list_for_each_entry(pos, &nfsi->open_files, list) {
738 if (cred != NULL && pos->cred != cred)
739 continue;
740 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
741 continue;
742 ctx = get_nfs_open_context(pos);
743 break;
744 }
745 spin_unlock(&inode->i_lock);
746 return ctx;
747}
748
749static void nfs_file_clear_open_context(struct file *filp)
750{
751 struct inode *inode = file_inode(filp);
752 struct nfs_open_context *ctx = nfs_file_open_context(filp);
753
754 if (ctx) {
755 filp->private_data = NULL;
756 spin_lock(&inode->i_lock);
757 list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
758 spin_unlock(&inode->i_lock);
759 __put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1);
760 }
761}
762
763
764
765
766int nfs_open(struct inode *inode, struct file *filp)
767{
768 struct nfs_open_context *ctx;
769
770 ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
771 if (IS_ERR(ctx))
772 return PTR_ERR(ctx);
773 nfs_file_set_open_context(filp, ctx);
774 put_nfs_open_context(ctx);
775 nfs_fscache_set_inode_cookie(inode, filp);
776 return 0;
777}
778
779int nfs_release(struct inode *inode, struct file *filp)
780{
781 nfs_file_clear_open_context(filp);
782 return 0;
783}
784
785
786
787
788
789int
790__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
791{
792 int status = -ESTALE;
793 struct nfs_fattr *fattr = NULL;
794 struct nfs_inode *nfsi = NFS_I(inode);
795
796 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
797 inode->i_sb->s_id, (long long)NFS_FILEID(inode));
798
799 if (is_bad_inode(inode))
800 goto out;
801 if (NFS_STALE(inode))
802 goto out;
803
804 status = -ENOMEM;
805 fattr = nfs_alloc_fattr();
806 if (fattr == NULL)
807 goto out;
808
809 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
810 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr);
811 if (status != 0) {
812 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
813 inode->i_sb->s_id,
814 (long long)NFS_FILEID(inode), status);
815 if (status == -ESTALE) {
816 nfs_zap_caches(inode);
817 if (!S_ISDIR(inode->i_mode))
818 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
819 }
820 goto out;
821 }
822
823 status = nfs_refresh_inode(inode, fattr);
824 if (status) {
825 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
826 inode->i_sb->s_id,
827 (long long)NFS_FILEID(inode), status);
828 goto out;
829 }
830
831 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
832 nfs_zap_acl_cache(inode);
833
834 dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
835 inode->i_sb->s_id,
836 (long long)NFS_FILEID(inode));
837
838 out:
839 nfs_free_fattr(fattr);
840 return status;
841}
842
843int nfs_attribute_timeout(struct inode *inode)
844{
845 struct nfs_inode *nfsi = NFS_I(inode);
846
847 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
848}
849
850static int nfs_attribute_cache_expired(struct inode *inode)
851{
852 if (nfs_have_delegated_attributes(inode))
853 return 0;
854 return nfs_attribute_timeout(inode);
855}
856
857
858
859
860
861
862
863
864int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
865{
866 if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
867 && !nfs_attribute_cache_expired(inode))
868 return NFS_STALE(inode) ? -ESTALE : 0;
869 return __nfs_revalidate_inode(server, inode);
870}
871EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
872
873static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
874{
875 struct nfs_inode *nfsi = NFS_I(inode);
876
877 if (mapping->nrpages != 0) {
878 int ret = invalidate_inode_pages2(mapping);
879 if (ret < 0)
880 return ret;
881 }
882 spin_lock(&inode->i_lock);
883 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
884 if (S_ISDIR(inode->i_mode))
885 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
886 spin_unlock(&inode->i_lock);
887 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
888 nfs_fscache_wait_on_invalidate(inode);
889 dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
890 inode->i_sb->s_id, (long long)NFS_FILEID(inode));
891 return 0;
892}
893
894static bool nfs_mapping_need_revalidate_inode(struct inode *inode)
895{
896 if (nfs_have_delegated_attributes(inode))
897 return false;
898 return (NFS_I(inode)->cache_validity & NFS_INO_REVAL_PAGECACHE)
899 || nfs_attribute_timeout(inode)
900 || NFS_STALE(inode);
901}
902
903
904
905
906
907
908int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
909{
910 struct nfs_inode *nfsi = NFS_I(inode);
911 int ret = 0;
912
913
914 if (IS_SWAPFILE(inode))
915 goto out;
916
917 if (nfs_mapping_need_revalidate_inode(inode)) {
918 ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
919 if (ret < 0)
920 goto out;
921 }
922 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
923 ret = nfs_invalidate_mapping(inode, mapping);
924out:
925 return ret;
926}
927
928static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
929{
930 struct nfs_inode *nfsi = NFS_I(inode);
931 unsigned long ret = 0;
932
933 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
934 && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
935 && inode->i_version == fattr->pre_change_attr) {
936 inode->i_version = fattr->change_attr;
937 if (S_ISDIR(inode->i_mode))
938 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
939 ret |= NFS_INO_INVALID_ATTR;
940 }
941
942 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
943 && (fattr->valid & NFS_ATTR_FATTR_CTIME)
944 && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
945 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
946 ret |= NFS_INO_INVALID_ATTR;
947 }
948
949 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
950 && (fattr->valid & NFS_ATTR_FATTR_MTIME)
951 && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
952 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
953 if (S_ISDIR(inode->i_mode))
954 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
955 ret |= NFS_INO_INVALID_ATTR;
956 }
957 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
958 && (fattr->valid & NFS_ATTR_FATTR_SIZE)
959 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
960 && nfsi->npages == 0) {
961 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
962 ret |= NFS_INO_INVALID_ATTR;
963 }
964
965 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
966 nfs_fscache_invalidate(inode);
967
968 return ret;
969}
970
971
972
973
974
975
976
977
978
979
980static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
981{
982 struct nfs_inode *nfsi = NFS_I(inode);
983 loff_t cur_size, new_isize;
984 unsigned long invalid = 0;
985
986
987 if (nfs_have_delegated_attributes(inode))
988 return 0;
989
990 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
991 return -EIO;
992 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
993 return -EIO;
994
995 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
996 inode->i_version != fattr->change_attr)
997 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
998
999
1000 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
1001 invalid |= NFS_INO_INVALID_ATTR;
1002
1003 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1004 cur_size = i_size_read(inode);
1005 new_isize = nfs_size_to_loff_t(fattr->size);
1006 if (cur_size != new_isize && nfsi->npages == 0)
1007 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
1008 }
1009
1010
1011 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
1012 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
1013 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
1014 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
1015 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
1016 invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
1017
1018
1019 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
1020 invalid |= NFS_INO_INVALID_ATTR;
1021
1022 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
1023 invalid |= NFS_INO_INVALID_ATIME;
1024
1025 if (invalid != 0)
1026 nfsi->cache_validity |= invalid;
1027
1028 nfsi->read_cache_jiffies = fattr->time_start;
1029 return 0;
1030}
1031
1032static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1033{
1034 if (!(fattr->valid & NFS_ATTR_FATTR_CTIME))
1035 return 0;
1036 return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
1037}
1038
1039static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1040{
1041 if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
1042 return 0;
1043 return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
1044}
1045
1046static atomic_long_t nfs_attr_generation_counter;
1047
1048static unsigned long nfs_read_attr_generation_counter(void)
1049{
1050 return atomic_long_read(&nfs_attr_generation_counter);
1051}
1052
1053unsigned long nfs_inc_attr_generation_counter(void)
1054{
1055 return atomic_long_inc_return(&nfs_attr_generation_counter);
1056}
1057
1058void nfs_fattr_init(struct nfs_fattr *fattr)
1059{
1060 fattr->valid = 0;
1061 fattr->time_start = jiffies;
1062 fattr->gencount = nfs_inc_attr_generation_counter();
1063 fattr->owner_name = NULL;
1064 fattr->group_name = NULL;
1065}
1066EXPORT_SYMBOL_GPL(nfs_fattr_init);
1067
1068struct nfs_fattr *nfs_alloc_fattr(void)
1069{
1070 struct nfs_fattr *fattr;
1071
1072 fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
1073 if (fattr != NULL)
1074 nfs_fattr_init(fattr);
1075 return fattr;
1076}
1077EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
1078
1079struct nfs_fh *nfs_alloc_fhandle(void)
1080{
1081 struct nfs_fh *fh;
1082
1083 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
1084 if (fh != NULL)
1085 fh->size = 0;
1086 return fh;
1087}
1088EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
1089
1090#ifdef NFS_DEBUG
1091
1092
1093
1094
1095
1096
1097
1098
1099u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
1100{
1101
1102
1103 return ~crc32(0xFFFFFFFF, &fh->data[0], fh->size);
1104}
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
1115{
1116 unsigned short i;
1117
1118 if (fh == NULL || fh->size == 0) {
1119 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
1120 return;
1121 }
1122
1123 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
1124 caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
1125 for (i = 0; i < fh->size; i += 16) {
1126 __be32 *pos = (__be32 *)&fh->data[i];
1127
1128 switch ((fh->size - i - 1) >> 2) {
1129 case 0:
1130 printk(KERN_DEFAULT " %08x\n",
1131 be32_to_cpup(pos));
1132 break;
1133 case 1:
1134 printk(KERN_DEFAULT " %08x %08x\n",
1135 be32_to_cpup(pos), be32_to_cpup(pos + 1));
1136 break;
1137 case 2:
1138 printk(KERN_DEFAULT " %08x %08x %08x\n",
1139 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1140 be32_to_cpup(pos + 2));
1141 break;
1142 default:
1143 printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
1144 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1145 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
1146 }
1147 }
1148}
1149#endif
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
1171{
1172 const struct nfs_inode *nfsi = NFS_I(inode);
1173
1174 return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
1175 nfs_ctime_need_update(inode, fattr) ||
1176 nfs_size_need_update(inode, fattr) ||
1177 ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
1178}
1179
1180static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1181{
1182 if (nfs_inode_attrs_need_update(inode, fattr))
1183 return nfs_update_inode(inode, fattr);
1184 return nfs_check_inode_attributes(inode, fattr);
1185}
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1198{
1199 int status;
1200
1201 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1202 return 0;
1203 spin_lock(&inode->i_lock);
1204 status = nfs_refresh_inode_locked(inode, fattr);
1205 spin_unlock(&inode->i_lock);
1206
1207 return status;
1208}
1209EXPORT_SYMBOL_GPL(nfs_refresh_inode);
1210
1211static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
1212{
1213 struct nfs_inode *nfsi = NFS_I(inode);
1214
1215 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
1216 if (S_ISDIR(inode->i_mode)) {
1217 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
1218 nfs_fscache_invalidate(inode);
1219 }
1220 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1221 return 0;
1222 return nfs_refresh_inode_locked(inode, fattr);
1223}
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1240{
1241 int status;
1242
1243 spin_lock(&inode->i_lock);
1244 status = nfs_post_op_update_inode_locked(inode, fattr);
1245 spin_unlock(&inode->i_lock);
1246 return status;
1247}
1248EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
1262{
1263 int status;
1264
1265 spin_lock(&inode->i_lock);
1266
1267 if ((fattr->valid & NFS_ATTR_FATTR) == 0 ||
1268 !nfs_inode_attrs_need_update(inode, fattr)) {
1269 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
1270 | NFS_ATTR_FATTR_PRESIZE
1271 | NFS_ATTR_FATTR_PREMTIME
1272 | NFS_ATTR_FATTR_PRECTIME);
1273 goto out_noforce;
1274 }
1275 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1276 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
1277 fattr->pre_change_attr = inode->i_version;
1278 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
1279 }
1280 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
1281 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
1282 memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
1283 fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
1284 }
1285 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
1286 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
1287 memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
1288 fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
1289 }
1290 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
1291 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
1292 fattr->pre_size = i_size_read(inode);
1293 fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
1294 }
1295out_noforce:
1296 status = nfs_post_op_update_inode_locked(inode, fattr);
1297 spin_unlock(&inode->i_lock);
1298 return status;
1299}
1300EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1315{
1316 struct nfs_server *server;
1317 struct nfs_inode *nfsi = NFS_I(inode);
1318 loff_t cur_isize, new_isize;
1319 unsigned long invalid = 0;
1320 unsigned long now = jiffies;
1321 unsigned long save_cache_validity;
1322
1323 dfprintk(VFS, "NFS: %s(%s/%ld fh_crc=0x%08x ct=%d info=0x%x)\n",
1324 __func__, inode->i_sb->s_id, inode->i_ino,
1325 nfs_display_fhandle_hash(NFS_FH(inode)),
1326 atomic_read(&inode->i_count), fattr->valid);
1327
1328 if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) {
1329 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
1330 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
1331 NFS_SERVER(inode)->nfs_client->cl_hostname,
1332 inode->i_sb->s_id, (long long)nfsi->fileid,
1333 (long long)fattr->fileid);
1334 goto out_err;
1335 }
1336
1337
1338
1339
1340 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
1341
1342
1343
1344 printk(KERN_DEBUG "NFS: %s: inode %ld mode changed, %07o to %07o\n",
1345 __func__, inode->i_ino, inode->i_mode, fattr->mode);
1346 goto out_err;
1347 }
1348
1349 server = NFS_SERVER(inode);
1350
1351 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
1352 !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
1353 !IS_AUTOMOUNT(inode))
1354 server->fsid = fattr->fsid;
1355
1356
1357
1358
1359 nfsi->read_cache_jiffies = fattr->time_start;
1360
1361 save_cache_validity = nfsi->cache_validity;
1362 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
1363 | NFS_INO_INVALID_ATIME
1364 | NFS_INO_REVAL_FORCED
1365 | NFS_INO_REVAL_PAGECACHE);
1366
1367
1368 invalid |= nfs_wcc_update_inode(inode, fattr);
1369
1370
1371 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
1372 if (inode->i_version != fattr->change_attr) {
1373 dprintk("NFS: change_attr change on server for file %s/%ld\n",
1374 inode->i_sb->s_id, inode->i_ino);
1375 invalid |= NFS_INO_INVALID_ATTR
1376 | NFS_INO_INVALID_DATA
1377 | NFS_INO_INVALID_ACCESS
1378 | NFS_INO_INVALID_ACL
1379 | NFS_INO_REVAL_PAGECACHE;
1380 if (S_ISDIR(inode->i_mode))
1381 nfs_force_lookup_revalidate(inode);
1382 inode->i_version = fattr->change_attr;
1383 }
1384 } else if (server->caps & NFS_CAP_CHANGE_ATTR)
1385 invalid |= save_cache_validity;
1386
1387 if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
1388 memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
1389 } else if (server->caps & NFS_CAP_MTIME)
1390 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1391 | NFS_INO_REVAL_FORCED);
1392
1393 if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
1394 memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
1395 } else if (server->caps & NFS_CAP_CTIME)
1396 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1397 | NFS_INO_REVAL_FORCED);
1398
1399
1400 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1401 new_isize = nfs_size_to_loff_t(fattr->size);
1402 cur_isize = i_size_read(inode);
1403 if (new_isize != cur_isize) {
1404
1405
1406 if ((nfsi->npages == 0 && !test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) ||
1407 new_isize > cur_isize) {
1408 i_size_write(inode, new_isize);
1409 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1410 }
1411 dprintk("NFS: isize change on server for file %s/%ld "
1412 "(%Ld to %Ld)\n",
1413 inode->i_sb->s_id,
1414 inode->i_ino,
1415 (long long)cur_isize,
1416 (long long)new_isize);
1417 }
1418 } else
1419 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1420 | NFS_INO_REVAL_PAGECACHE
1421 | NFS_INO_REVAL_FORCED);
1422
1423
1424 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
1425 memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
1426 else if (server->caps & NFS_CAP_ATIME)
1427 invalid |= save_cache_validity & (NFS_INO_INVALID_ATIME
1428 | NFS_INO_REVAL_FORCED);
1429
1430 if (fattr->valid & NFS_ATTR_FATTR_MODE) {
1431 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
1432 umode_t newmode = inode->i_mode & S_IFMT;
1433 newmode |= fattr->mode & S_IALLUGO;
1434 inode->i_mode = newmode;
1435 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1436 }
1437 } else if (server->caps & NFS_CAP_MODE)
1438 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1439 | NFS_INO_INVALID_ACCESS
1440 | NFS_INO_INVALID_ACL
1441 | NFS_INO_REVAL_FORCED);
1442
1443 if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
1444 if (!uid_eq(inode->i_uid, fattr->uid)) {
1445 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1446 inode->i_uid = fattr->uid;
1447 }
1448 } else if (server->caps & NFS_CAP_OWNER)
1449 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1450 | NFS_INO_INVALID_ACCESS
1451 | NFS_INO_INVALID_ACL
1452 | NFS_INO_REVAL_FORCED);
1453
1454 if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
1455 if (!gid_eq(inode->i_gid, fattr->gid)) {
1456 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
1457 inode->i_gid = fattr->gid;
1458 }
1459 } else if (server->caps & NFS_CAP_OWNER_GROUP)
1460 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1461 | NFS_INO_INVALID_ACCESS
1462 | NFS_INO_INVALID_ACL
1463 | NFS_INO_REVAL_FORCED);
1464
1465 if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
1466 if (inode->i_nlink != fattr->nlink) {
1467 invalid |= NFS_INO_INVALID_ATTR;
1468 if (S_ISDIR(inode->i_mode))
1469 invalid |= NFS_INO_INVALID_DATA;
1470 set_nlink(inode, fattr->nlink);
1471 }
1472 } else if (server->caps & NFS_CAP_NLINK)
1473 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
1474 | NFS_INO_REVAL_FORCED);
1475
1476 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
1477
1478
1479
1480 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
1481 }
1482 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
1483 inode->i_blocks = fattr->du.nfs2.blocks;
1484
1485
1486 if (invalid & NFS_INO_INVALID_ATTR) {
1487 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
1488 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
1489 nfsi->attrtimeo_timestamp = now;
1490 nfsi->attr_gencount = nfs_inc_attr_generation_counter();
1491 } else {
1492 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
1493 if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
1494 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
1495 nfsi->attrtimeo_timestamp = now;
1496 }
1497 }
1498 invalid &= ~NFS_INO_INVALID_ATTR;
1499
1500 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
1501 || S_ISLNK(inode->i_mode)))
1502 invalid &= ~NFS_INO_INVALID_DATA;
1503 if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) ||
1504 (save_cache_validity & NFS_INO_REVAL_FORCED))
1505 nfsi->cache_validity |= invalid;
1506
1507 if (invalid & NFS_INO_INVALID_DATA)
1508 nfs_fscache_invalidate(inode);
1509
1510 return 0;
1511 out_err:
1512
1513
1514
1515
1516
1517 nfs_invalidate_inode(inode);
1518 return -ESTALE;
1519}
1520
1521struct inode *nfs_alloc_inode(struct super_block *sb)
1522{
1523 struct nfs_inode *nfsi;
1524 nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
1525 if (!nfsi)
1526 return NULL;
1527 nfsi->flags = 0UL;
1528 nfsi->cache_validity = 0UL;
1529#ifdef CONFIG_NFS_V3_ACL
1530 nfsi->acl_access = ERR_PTR(-EAGAIN);
1531 nfsi->acl_default = ERR_PTR(-EAGAIN);
1532#endif
1533#if IS_ENABLED(CONFIG_NFS_V4)
1534 nfsi->nfs4_acl = NULL;
1535#endif
1536 return &nfsi->vfs_inode;
1537}
1538EXPORT_SYMBOL_GPL(nfs_alloc_inode);
1539
1540static void nfs_i_callback(struct rcu_head *head)
1541{
1542 struct inode *inode = container_of(head, struct inode, i_rcu);
1543 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
1544}
1545
1546void nfs_destroy_inode(struct inode *inode)
1547{
1548 call_rcu(&inode->i_rcu, nfs_i_callback);
1549}
1550EXPORT_SYMBOL_GPL(nfs_destroy_inode);
1551
1552static inline void nfs4_init_once(struct nfs_inode *nfsi)
1553{
1554#if IS_ENABLED(CONFIG_NFS_V4)
1555 INIT_LIST_HEAD(&nfsi->open_states);
1556 nfsi->delegation = NULL;
1557 nfsi->delegation_state = 0;
1558 init_rwsem(&nfsi->rwsem);
1559 nfsi->layout = NULL;
1560#endif
1561}
1562
1563static void init_once(void *foo)
1564{
1565 struct nfs_inode *nfsi = (struct nfs_inode *) foo;
1566
1567 inode_init_once(&nfsi->vfs_inode);
1568 INIT_LIST_HEAD(&nfsi->open_files);
1569 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
1570 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
1571 INIT_LIST_HEAD(&nfsi->commit_info.list);
1572 nfsi->npages = 0;
1573 nfsi->commit_info.ncommit = 0;
1574 atomic_set(&nfsi->commit_info.rpcs_out, 0);
1575 atomic_set(&nfsi->silly_count, 1);
1576 INIT_HLIST_HEAD(&nfsi->silly_list);
1577 init_waitqueue_head(&nfsi->waitqueue);
1578 nfs4_init_once(nfsi);
1579}
1580
1581static int __init nfs_init_inodecache(void)
1582{
1583 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
1584 sizeof(struct nfs_inode),
1585 0, (SLAB_RECLAIM_ACCOUNT|
1586 SLAB_MEM_SPREAD),
1587 init_once);
1588 if (nfs_inode_cachep == NULL)
1589 return -ENOMEM;
1590
1591 return 0;
1592}
1593
1594static void nfs_destroy_inodecache(void)
1595{
1596
1597
1598
1599
1600 rcu_barrier();
1601 kmem_cache_destroy(nfs_inode_cachep);
1602}
1603
1604struct workqueue_struct *nfsiod_workqueue;
1605EXPORT_SYMBOL_GPL(nfsiod_workqueue);
1606
1607
1608
1609
1610static int nfsiod_start(void)
1611{
1612 struct workqueue_struct *wq;
1613 dprintk("RPC: creating workqueue nfsiod\n");
1614 wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
1615 if (wq == NULL)
1616 return -ENOMEM;
1617 nfsiod_workqueue = wq;
1618 return 0;
1619}
1620
1621
1622
1623
1624static void nfsiod_stop(void)
1625{
1626 struct workqueue_struct *wq;
1627
1628 wq = nfsiod_workqueue;
1629 if (wq == NULL)
1630 return;
1631 nfsiod_workqueue = NULL;
1632 destroy_workqueue(wq);
1633}
1634
1635int nfs_net_id;
1636EXPORT_SYMBOL_GPL(nfs_net_id);
1637
1638static int nfs_net_init(struct net *net)
1639{
1640 nfs_clients_init(net);
1641 return nfs_dns_resolver_cache_init(net);
1642}
1643
1644static void nfs_net_exit(struct net *net)
1645{
1646 nfs_dns_resolver_cache_destroy(net);
1647 nfs_cleanup_cb_ident_idr(net);
1648}
1649
1650static struct pernet_operations nfs_net_ops = {
1651 .init = nfs_net_init,
1652 .exit = nfs_net_exit,
1653 .id = &nfs_net_id,
1654 .size = sizeof(struct nfs_net),
1655};
1656
1657
1658
1659
1660static int __init init_nfs_fs(void)
1661{
1662 int err;
1663
1664 err = nfs_dns_resolver_init();
1665 if (err < 0)
1666 goto out10;;
1667
1668 err = register_pernet_subsys(&nfs_net_ops);
1669 if (err < 0)
1670 goto out9;
1671
1672 err = nfs_fscache_register();
1673 if (err < 0)
1674 goto out8;
1675
1676 err = nfsiod_start();
1677 if (err)
1678 goto out7;
1679
1680 err = nfs_fs_proc_init();
1681 if (err)
1682 goto out6;
1683
1684 err = nfs_init_nfspagecache();
1685 if (err)
1686 goto out5;
1687
1688 err = nfs_init_inodecache();
1689 if (err)
1690 goto out4;
1691
1692 err = nfs_init_readpagecache();
1693 if (err)
1694 goto out3;
1695
1696 err = nfs_init_writepagecache();
1697 if (err)
1698 goto out2;
1699
1700 err = nfs_init_directcache();
1701 if (err)
1702 goto out1;
1703
1704#ifdef CONFIG_PROC_FS
1705 rpc_proc_register(&init_net, &nfs_rpcstat);
1706#endif
1707 if ((err = register_nfs_fs()) != 0)
1708 goto out0;
1709
1710 return 0;
1711out0:
1712#ifdef CONFIG_PROC_FS
1713 rpc_proc_unregister(&init_net, "nfs");
1714#endif
1715 nfs_destroy_directcache();
1716out1:
1717 nfs_destroy_writepagecache();
1718out2:
1719 nfs_destroy_readpagecache();
1720out3:
1721 nfs_destroy_inodecache();
1722out4:
1723 nfs_destroy_nfspagecache();
1724out5:
1725 nfs_fs_proc_exit();
1726out6:
1727 nfsiod_stop();
1728out7:
1729 nfs_fscache_unregister();
1730out8:
1731 unregister_pernet_subsys(&nfs_net_ops);
1732out9:
1733 nfs_dns_resolver_destroy();
1734out10:
1735 return err;
1736}
1737
1738static void __exit exit_nfs_fs(void)
1739{
1740 nfs_destroy_directcache();
1741 nfs_destroy_writepagecache();
1742 nfs_destroy_readpagecache();
1743 nfs_destroy_inodecache();
1744 nfs_destroy_nfspagecache();
1745 nfs_fscache_unregister();
1746 unregister_pernet_subsys(&nfs_net_ops);
1747 nfs_dns_resolver_destroy();
1748#ifdef CONFIG_PROC_FS
1749 rpc_proc_unregister(&init_net, "nfs");
1750#endif
1751 unregister_nfs_fs();
1752 nfs_fs_proc_exit();
1753 nfsiod_stop();
1754}
1755
1756
1757MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1758MODULE_LICENSE("GPL");
1759module_param(enable_ino64, bool, 0644);
1760
1761module_init(init_nfs_fs)
1762module_exit(exit_nfs_fs)
1763