Merge branch 'next' (6925bac1) · Commits · e / devices / android_kernel_oneplus_sm8150

fs/nfs/client.c

+2 −3

Original line number	Diff line number	Diff line
		@@ -675,7 +675,7 @@ static int nfs_init_server(struct nfs_server *server,
		server->nfs_client = clp;

		/* Initialise the client representation from the mount data */
		server->flags = data->flags & NFS_MOUNT_FLAGMASK;
		server->flags = data->flags;

		if (data->rsize)
		server->rsize = nfs_block_size(data->rsize, NULL);
		@@ -850,7 +850,6 @@ static struct nfs_server *nfs_alloc_server(void)
		INIT_LIST_HEAD(&server->client_link);
		INIT_LIST_HEAD(&server->master_link);

		init_waitqueue_head(&server->active_wq);
		atomic_set(&server->active, 0);

		server->io_stats = nfs_alloc_iostats();
		@@ -1073,7 +1072,7 @@ static int nfs4_init_server(struct nfs_server *server,
		goto error;

		/* Initialise the client representation from the mount data */
		server->flags = data->flags & NFS_MOUNT_FLAGMASK;
		server->flags = data->flags;
		server->caps \|= NFS_CAP_ATOMIC_OPEN;

		if (data->rsize)

fs/nfs/dir.c

+15 −5

Original line number	Diff line number	Diff line
		@@ -156,6 +156,7 @@ typedef struct {
		decode_dirent_t decode;
		int plus;
		unsigned long timestamp;
		unsigned long gencount;
		int timestamp_valid;
		} nfs_readdir_descriptor_t;

		@@ -177,7 +178,7 @@ int nfs_readdir_filler(nfs_readdir_descriptor_t desc, struct page page)
		struct file *file = desc->file;
		struct inode *inode = file->f_path.dentry->d_inode;
		struct rpc_cred *cred = nfs_file_cred(file);
		unsigned long timestamp;
		unsigned long timestamp, gencount;
		int error;

		dfprintk(DIRCACHE, "NFS: %s: reading cookie %Lu into page %lu\n",
		@@ -186,6 +187,7 @@ int nfs_readdir_filler(nfs_readdir_descriptor_t desc, struct page page)

		again:
		timestamp = jiffies;
		gencount = nfs_inc_attr_generation_counter();
		error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, desc->entry->cookie, page,
		NFS_SERVER(inode)->dtsize, desc->plus);
		if (error < 0) {
		@@ -199,6 +201,7 @@ int nfs_readdir_filler(nfs_readdir_descriptor_t desc, struct page page)
		goto error;
		}
		desc->timestamp = timestamp;
		desc->gencount = gencount;
		desc->timestamp_valid = 1;
		SetPageUptodate(page);
		/* Ensure consistent page alignment of the data.
		@@ -224,9 +227,10 @@ int dir_decode(nfs_readdir_descriptor_t *desc)
		if (IS_ERR(p))
		return PTR_ERR(p);
		desc->ptr = p;
		if (desc->timestamp_valid)
		if (desc->timestamp_valid) {
		desc->entry->fattr->time_start = desc->timestamp;
		else
		desc->entry->fattr->gencount = desc->gencount;
		} else
		desc->entry->fattr->valid &= ~NFS_ATTR_FATTR;
		return 0;
		}
		@@ -471,7 +475,7 @@ int uncached_readdir(nfs_readdir_descriptor_t desc, void dirent,
		struct rpc_cred *cred = nfs_file_cred(file);
		struct page *page = NULL;
		int status;
		unsigned long timestamp;
		unsigned long timestamp, gencount;

		dfprintk(DIRCACHE, "NFS: uncached_readdir() searching for cookie %Lu\n",
		(unsigned long long)*desc->dir_cookie);
		@@ -482,6 +486,7 @@ int uncached_readdir(nfs_readdir_descriptor_t desc, void dirent,
		goto out;
		}
		timestamp = jiffies;
		gencount = nfs_inc_attr_generation_counter();
		status = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred,
		*desc->dir_cookie, page,
		NFS_SERVER(inode)->dtsize,
		@@ -490,6 +495,7 @@ int uncached_readdir(nfs_readdir_descriptor_t desc, void dirent,
		desc->ptr = kmap(page); /* matching kunmap in nfs_do_filldir */
		if (status >= 0) {
		desc->timestamp = timestamp;
		desc->gencount = gencount;
		desc->timestamp_valid = 1;
		if ((status = dir_decode(desc)) == 0)
		desc->entry->prev_cookie = *desc->dir_cookie;
		@@ -655,7 +661,7 @@ static int nfs_fsync_dir(struct file filp, struct dentry dentry, int datasync)
		*/
		void nfs_force_lookup_revalidate(struct inode *dir)
		{
		NFS_I(dir)->cache_change_attribute = jiffies;
		NFS_I(dir)->cache_change_attribute++;
		}

		/*
		@@ -667,6 +673,8 @@ static int nfs_check_verifier(struct inode dir, struct dentry dentry)
		{
		if (IS_ROOT(dentry))
		return 1;
		if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)
		return 0;
		if (!nfs_verify_change_attribute(dir, dentry->d_time))
		return 0;
		/* Revalidate nfsi->cache_change_attribute before we declare a match */
		@@ -750,6 +758,8 @@ int nfs_neg_need_reval(struct inode dir, struct dentry dentry,
		/* Don't revalidate a negative dentry if we're creating a new file */
		if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0)
		return 0;
		if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
		return 1;
		return !nfs_check_verifier(dir, dentry);
		}

fs/nfs/file.c

+7 −11

Original line number	Diff line number	Diff line
		@@ -188,13 +188,16 @@ static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
		/* origin == SEEK_END => we must revalidate the cached file length */
		if (origin == SEEK_END) {
		struct inode *inode = filp->f_mapping->host;

		int retval = nfs_revalidate_file_size(inode, filp);
		if (retval < 0)
		return (loff_t)retval;
		}
		lock_kernel(); /* BKL needed? */

		spin_lock(&inode->i_lock);
		loff = generic_file_llseek_unlocked(filp, offset, origin);
		spin_unlock(&inode->i_lock);
		} else
		loff = generic_file_llseek_unlocked(filp, offset, origin);
		unlock_kernel();
		return loff;
		}

		@@ -699,13 +702,6 @@ static int nfs_flock(struct file filp, int cmd, struct file_lock fl)
		filp->f_path.dentry->d_name.name,
		fl->fl_type, fl->fl_flags);

		/*
		* No BSD flocks over NFS allowed.
		* Note: we could try to fake a POSIX lock request here by
		* using ((u32) filp \| 0x80000000) or some such as the pid.
		* Not sure whether that would be unique, though, or whether
		* that would break in other places.
		*/
		if (!(fl->fl_flags & FL_FLOCK))
		return -ENOLCK;

fs/nfs/inode.c

+109 −74

Original line number	Diff line number	Diff line
		@@ -305,8 +305,7 @@ nfs_fhget(struct super_block sb, struct nfs_fh fh, struct nfs_fattr *fattr)
		init_special_inode(inode, inode->i_mode, fattr->rdev);

		nfsi->read_cache_jiffies = fattr->time_start;
		nfsi->last_updated = now;
		nfsi->cache_change_attribute = now;
		nfsi->attr_gencount = fattr->gencount;
		inode->i_atime = fattr->atime;
		inode->i_mtime = fattr->mtime;
		inode->i_ctime = fattr->ctime;
		@@ -453,6 +452,7 @@ static int nfs_vmtruncate(struct inode * inode, loff_t offset)
		void nfs_setattr_update_inode(struct inode inode, struct iattr attr)
		{
		if ((attr->ia_valid & (ATTR_MODE\|ATTR_UID\|ATTR_GID)) != 0) {
		spin_lock(&inode->i_lock);
		if ((attr->ia_valid & ATTR_MODE) != 0) {
		int mode = attr->ia_mode & S_IALLUGO;
		mode \|= inode->i_mode & ~S_IALLUGO;
		@@ -462,7 +462,6 @@ void nfs_setattr_update_inode(struct inode inode, struct iattr attr)
		inode->i_uid = attr->ia_uid;
		if ((attr->ia_valid & ATTR_GID) != 0)
		inode->i_gid = attr->ia_gid;
		spin_lock(&inode->i_lock);
		NFS_I(inode)->cache_validity \|= NFS_INO_INVALID_ACCESS\|NFS_INO_INVALID_ACL;
		spin_unlock(&inode->i_lock);
		}
		@@ -472,37 +471,6 @@ void nfs_setattr_update_inode(struct inode inode, struct iattr attr)
		}
		}

		static int nfs_wait_schedule(void *word)
		{
		if (signal_pending(current))
		return -ERESTARTSYS;
		schedule();
		return 0;
		}

		/*
		* Wait for the inode to get unlocked.
		*/
		static int nfs_wait_on_inode(struct inode *inode)
		{
		struct nfs_inode *nfsi = NFS_I(inode);
		int error;

		error = wait_on_bit_lock(&nfsi->flags, NFS_INO_REVALIDATING,
		nfs_wait_schedule, TASK_KILLABLE);

		return error;
		}

		static void nfs_wake_up_inode(struct inode *inode)
		{
		struct nfs_inode *nfsi = NFS_I(inode);

		clear_bit(NFS_INO_REVALIDATING, &nfsi->flags);
		smp_mb__after_clear_bit();
		wake_up_bit(&nfsi->flags, NFS_INO_REVALIDATING);
		}

		int nfs_getattr(struct vfsmount mnt, struct dentry dentry, struct kstat *stat)
		{
		struct inode *inode = dentry->d_inode;
		@@ -697,20 +665,15 @@ __nfs_revalidate_inode(struct nfs_server server, struct inode inode)
		dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
		inode->i_sb->s_id, (long long)NFS_FILEID(inode));

		nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
		if (is_bad_inode(inode))
		goto out_nowait;
		goto out;
		if (NFS_STALE(inode))
		goto out_nowait;

		status = nfs_wait_on_inode(inode);
		if (status < 0)
		goto out;

		status = -ESTALE;
		if (NFS_STALE(inode))
		goto out;

		nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
		status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr);
		if (status != 0) {
		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
		@@ -724,16 +687,13 @@ __nfs_revalidate_inode(struct nfs_server server, struct inode inode)
		goto out;
		}

		spin_lock(&inode->i_lock);
		status = nfs_update_inode(inode, &fattr);
		status = nfs_refresh_inode(inode, &fattr);
		if (status) {
		spin_unlock(&inode->i_lock);
		dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
		inode->i_sb->s_id,
		(long long)NFS_FILEID(inode), status);
		goto out;
		}
		spin_unlock(&inode->i_lock);

		if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
		nfs_zap_acl_cache(inode);
		@@ -743,9 +703,6 @@ __nfs_revalidate_inode(struct nfs_server server, struct inode inode)
		(long long)NFS_FILEID(inode));

		out:
		nfs_wake_up_inode(inode);

		out_nowait:
		return status;
		}

		@@ -908,9 +865,6 @@ static int nfs_check_inode_attributes(struct inode inode, struct nfs_fattr fat
		return -EIO;
		}

		/* Do atomic weak cache consistency updates */
		nfs_wcc_update_inode(inode, fattr);

		if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
		nfsi->change_attr != fattr->change_attr)
		invalid \|= NFS_INO_INVALID_ATTR\|NFS_INO_REVAL_PAGECACHE;
		@@ -939,15 +893,81 @@ static int nfs_check_inode_attributes(struct inode inode, struct nfs_fattr fat

		if (invalid != 0)
		nfsi->cache_validity \|= invalid;
		else
		nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
		\| NFS_INO_INVALID_ATIME
		\| NFS_INO_REVAL_PAGECACHE);

		nfsi->read_cache_jiffies = fattr->time_start;
		return 0;
		}

		static int nfs_ctime_need_update(const struct inode inode, const struct nfs_fattr fattr)
		{
		return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
		}

		static int nfs_size_need_update(const struct inode inode, const struct nfs_fattr fattr)
		{
		return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
		}

		static unsigned long nfs_attr_generation_counter;

		static unsigned long nfs_read_attr_generation_counter(void)
		{
		smp_rmb();
		return nfs_attr_generation_counter;
		}

		unsigned long nfs_inc_attr_generation_counter(void)
		{
		unsigned long ret;
		smp_rmb();
		ret = ++nfs_attr_generation_counter;
		smp_wmb();
		return ret;
		}

		void nfs_fattr_init(struct nfs_fattr *fattr)
		{
		fattr->valid = 0;
		fattr->time_start = jiffies;
		fattr->gencount = nfs_inc_attr_generation_counter();
		}

		/**
		* nfs_inode_attrs_need_update - check if the inode attributes need updating
		* @inode - pointer to inode
		* @fattr - attributes
		*
		* Attempt to divine whether or not an RPC call reply carrying stale
		* attributes got scheduled after another call carrying updated ones.
		*
		* To do so, the function first assumes that a more recent ctime means
		* that the attributes in fattr are newer, however it also attempt to
		* catch the case where ctime either didn't change, or went backwards
		* (if someone reset the clock on the server) by looking at whether
		* or not this RPC call was started after the inode was last updated.
		* Note also the check for wraparound of 'attr_gencount'
		*
		* The function returns 'true' if it thinks the attributes in 'fattr' are
		* more recent than the ones cached in the inode.
		*
		*/
		static int nfs_inode_attrs_need_update(const struct inode inode, const struct nfs_fattr fattr)
		{
		const struct nfs_inode *nfsi = NFS_I(inode);

		return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 \|\|
		nfs_ctime_need_update(inode, fattr) \|\|
		nfs_size_need_update(inode, fattr) \|\|
		((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
		}

		static int nfs_refresh_inode_locked(struct inode inode, struct nfs_fattr fattr)
		{
		if (nfs_inode_attrs_need_update(inode, fattr))
		return nfs_update_inode(inode, fattr);
		return nfs_check_inode_attributes(inode, fattr);
		}

		/**
		* nfs_refresh_inode - try to update the inode attribute cache
		* @inode - pointer to inode
		@@ -960,21 +980,28 @@ static int nfs_check_inode_attributes(struct inode inode, struct nfs_fattr fat
		*/
		int nfs_refresh_inode(struct inode inode, struct nfs_fattr fattr)
		{
		struct nfs_inode *nfsi = NFS_I(inode);
		int status;

		if ((fattr->valid & NFS_ATTR_FATTR) == 0)
		return 0;
		spin_lock(&inode->i_lock);
		if (time_after(fattr->time_start, nfsi->last_updated))
		status = nfs_update_inode(inode, fattr);
		else
		status = nfs_check_inode_attributes(inode, fattr);

		status = nfs_refresh_inode_locked(inode, fattr);
		spin_unlock(&inode->i_lock);
		return status;
		}

		static int nfs_post_op_update_inode_locked(struct inode inode, struct nfs_fattr fattr)
		{
		struct nfs_inode *nfsi = NFS_I(inode);

		nfsi->cache_validity \|= NFS_INO_INVALID_ATTR\|NFS_INO_REVAL_PAGECACHE;
		if (S_ISDIR(inode->i_mode))
		nfsi->cache_validity \|= NFS_INO_INVALID_DATA;
		if ((fattr->valid & NFS_ATTR_FATTR) == 0)
		return 0;
		return nfs_refresh_inode_locked(inode, fattr);
		}

		/**
		* nfs_post_op_update_inode - try to update the inode attribute cache
		* @inode - pointer to inode
		@@ -991,14 +1018,12 @@ int nfs_refresh_inode(struct inode inode, struct nfs_fattr fattr)
		*/
		int nfs_post_op_update_inode(struct inode inode, struct nfs_fattr fattr)
		{
		struct nfs_inode *nfsi = NFS_I(inode);
		int status;

		spin_lock(&inode->i_lock);
		nfsi->cache_validity \|= NFS_INO_INVALID_ATTR\|NFS_INO_REVAL_PAGECACHE;
		if (S_ISDIR(inode->i_mode))
		nfsi->cache_validity \|= NFS_INO_INVALID_DATA;
		status = nfs_post_op_update_inode_locked(inode, fattr);
		spin_unlock(&inode->i_lock);
		return nfs_refresh_inode(inode, fattr);
		return status;
		}

		/**
		@@ -1014,6 +1039,15 @@ int nfs_post_op_update_inode(struct inode inode, struct nfs_fattr fattr)
		*/
		int nfs_post_op_update_inode_force_wcc(struct inode inode, struct nfs_fattr fattr)
		{
		int status;

		spin_lock(&inode->i_lock);
		/* Don't do a WCC update if these attributes are already stale */
		if ((fattr->valid & NFS_ATTR_FATTR) == 0 \|\|
		!nfs_inode_attrs_need_update(inode, fattr)) {
		fattr->valid &= ~(NFS_ATTR_WCC_V4\|NFS_ATTR_WCC);
		goto out_noforce;
		}
		if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
		(fattr->valid & NFS_ATTR_WCC_V4) == 0) {
		fattr->pre_change_attr = NFS_I(inode)->change_attr;
		@@ -1026,7 +1060,10 @@ int nfs_post_op_update_inode_force_wcc(struct inode inode, struct nfs_fattr fa
		fattr->pre_size = i_size_read(inode);
		fattr->valid \|= NFS_ATTR_WCC;
		}
		return nfs_post_op_update_inode(inode, fattr);
		out_noforce:
		status = nfs_post_op_update_inode_locked(inode, fattr);
		spin_unlock(&inode->i_lock);
		return status;
		}

		/*
		@@ -1092,7 +1129,7 @@ static int nfs_update_inode(struct inode inode, struct nfs_fattr fattr)
		}
		/* If ctime has changed we should definitely clear access+acl caches */
		if (!timespec_equal(&inode->i_ctime, &fattr->ctime))
		invalid \|= NFS_INO_INVALID_ACCESS\|NFS_INO_INVALID_ACL;
		invalid \|= NFS_INO_INVALID_ATTR\|NFS_INO_INVALID_ACCESS\|NFS_INO_INVALID_ACL;
		} else if (nfsi->change_attr != fattr->change_attr) {
		dprintk("NFS: change_attr change on server for file %s/%ld\n",
		inode->i_sb->s_id, inode->i_ino);
		@@ -1126,6 +1163,9 @@ static int nfs_update_inode(struct inode inode, struct nfs_fattr fattr)
		inode->i_gid != fattr->gid)
		invalid \|= NFS_INO_INVALID_ATTR\|NFS_INO_INVALID_ACCESS\|NFS_INO_INVALID_ACL;

		if (inode->i_nlink != fattr->nlink)
		invalid \|= NFS_INO_INVALID_ATTR;

		inode->i_mode = fattr->mode;
		inode->i_nlink = fattr->nlink;
		inode->i_uid = fattr->uid;
		@@ -1145,18 +1185,13 @@ static int nfs_update_inode(struct inode inode, struct nfs_fattr fattr)
		nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
		nfsi->attrtimeo_timestamp = now;
		nfsi->last_updated = now;
		nfsi->attr_gencount = nfs_inc_attr_generation_counter();
		} else {
		if (!time_in_range(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
		if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
		nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
		nfsi->attrtimeo_timestamp = now;
		}
		/*
		* Avoid jiffy wraparound issues with nfsi->last_updated
		*/
		if (!time_in_range(nfsi->last_updated, nfsi->read_cache_jiffies, now))
		nfsi->last_updated = nfsi->read_cache_jiffies;
		}
		invalid &= ~NFS_INO_INVALID_ATTR;
		/* Don't invalidate the data if we were to blame */

fs/nfs/internal.h

+23 −2

Original line number	Diff line number	Diff line
		@@ -153,6 +153,7 @@ extern void nfs4_clear_inode(struct inode *);
		void nfs_zap_acl_cache(struct inode *inode);

		/* super.c */
		void nfs_parse_ip_address(char , size_t, struct sockaddr , size_t *);
		extern struct file_system_type nfs_xdev_fs_type;
		#ifdef CONFIG_NFS_V4
		extern struct file_system_type nfs4_xdev_fs_type;
		@@ -163,8 +164,8 @@ extern struct rpc_stat nfs_rpcstat;

		extern int __init register_nfs_fs(void);
		extern void __exit unregister_nfs_fs(void);
		extern void nfs_sb_active(struct nfs_server *server);
		extern void nfs_sb_deactive(struct nfs_server *server);
		extern void nfs_sb_active(struct super_block *sb);
		extern void nfs_sb_deactive(struct super_block *sb);

		/* namespace.c */
		extern char nfs_path(const char base,
		@@ -276,3 +277,23 @@ unsigned int nfs_page_array_len(unsigned int base, size_t len)
		PAGE_SIZE - 1) >> PAGE_SHIFT;
		}

		#define IPV6_SCOPE_DELIMITER '%'

		/*
		* Set the port number in an address. Be agnostic about the address
		* family.
		*/
		static inline void nfs_set_port(struct sockaddr *sap, unsigned short port)
		{
		struct sockaddr_in ap = (struct sockaddr_in )sap;
		struct sockaddr_in6 ap6 = (struct sockaddr_in6 )sap;

		switch (sap->sa_family) {
		case AF_INET:
		ap->sin_port = htons(port);
		break;
		case AF_INET6:
		ap6->sin6_port = htons(port);
		break;
		}
		}