Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit daaadd22 authored by Trond Myklebust's avatar Trond Myklebust
Browse files

Merge branch 'bugfixes' 

* bugfixes:
  SUNRPC: Fixup socket wait for memory
  SUNRPC: Fix a missing break in rpc_anyaddr()
  pNFS/flexfiles: Fix an Oopsable typo in ff_mirror_match_fh()
  NFS: Fix attribute cache revalidation
  NFS: Ensure we revalidate attributes before using execute_ok()
  NFS: Flush reclaim writes using FLUSH_COND_STABLE
  NFS: Background flush should not be low priority
  NFSv4.1/pnfs: Fixup an lo->plh_block_lgets imbalance in layoutreturn
  NFSv4: Don't perform cached access checks before we've OPENed the file
  NFS: Allow the combination pNFS and labeled NFS
  NFS42: handle layoutstats stateid error
  nfs: Fix race in __update_open_stateid()
  nfs: fix missing assignment in nfs4_sequence_done tracepoint
parents 210c7c17 13331a55

fs/nfs/dir.c

+19 −2
Original line number Diff line number Diff line
@@ -2432,6 +2432,20 @@ int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags) 
}

EXPORT_SYMBOL_GPL(nfs_may_open);



static int nfs_execute_ok(struct inode *inode, int mask)

{

	struct nfs_server *server = NFS_SERVER(inode);

	int ret;



	if (mask & MAY_NOT_BLOCK)

		ret = nfs_revalidate_inode_rcu(server, inode);

	else

		ret = nfs_revalidate_inode(server, inode);

	if (ret == 0 && !execute_ok(inode))

		ret = -EACCES;

	return ret;

}



int nfs_permission(struct inode *inode, int mask)

{

	struct rpc_cred *cred;
@@ -2449,6 +2463,9 @@ int nfs_permission(struct inode *inode, int mask) 
		case S_IFLNK:

			goto out;

		case S_IFREG:

			if ((mask & MAY_OPEN) &&

			   nfs_server_capable(inode, NFS_CAP_ATOMIC_OPEN))

				return 0;

			break;

		case S_IFDIR:

			/*
@@ -2481,8 +2498,8 @@ int nfs_permission(struct inode *inode, int mask) 
			res = PTR_ERR(cred);

	}

out:

	if (!res && (mask & MAY_EXEC) && !execute_ok(inode))

		res = -EACCES;

	if (!res && (mask & MAY_EXEC))

		res = nfs_execute_ok(inode, mask);



	dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n",

		inode->i_sb->s_id, inode->i_ino, mask, res);

fs/nfs/flexfilelayout/flexfilelayout.c

+1 −1
Original line number Diff line number Diff line
@@ -145,7 +145,7 @@ static bool ff_mirror_match_fh(const struct nfs4_ff_layout_mirror *m1, 
		return false;

	for (i = 0; i < m1->fh_versions_cnt; i++) {

		bool found_fh = false;

		for (j = 0; j < m2->fh_versions_cnt; i++) {

		for (j = 0; j < m2->fh_versions_cnt; j++) {

			if (nfs_compare_fh(&m1->fh_versions[i],

					&m2->fh_versions[j]) == 0) {

				found_fh = true;

fs/nfs/inode.c

+39 −15
Original line number Diff line number Diff line
@@ -1653,6 +1653,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
	unsigned long invalid = 0;

	unsigned long now = jiffies;

	unsigned long save_cache_validity;

	bool cache_revalidated = true;



	dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%x)\n",

			__func__, inode->i_sb->s_id, inode->i_ino,
@@ -1714,22 +1715,28 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
				nfs_force_lookup_revalidate(inode);

			inode->i_version = fattr->change_attr;

		}

	} else

	} else {

		nfsi->cache_validity |= save_cache_validity;

		cache_revalidated = false;

	}



	if (fattr->valid & NFS_ATTR_FATTR_MTIME) {

		memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));

	} else if (server->caps & NFS_CAP_MTIME)

	} else if (server->caps & NFS_CAP_MTIME) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}



	if (fattr->valid & NFS_ATTR_FATTR_CTIME) {

		memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));

	} else if (server->caps & NFS_CAP_CTIME)

	} else if (server->caps & NFS_CAP_CTIME) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}



	/* Check if our cached file size is stale */

	if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
@@ -1749,19 +1756,23 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
					(long long)cur_isize,

					(long long)new_isize);

		}

	} else

	} else {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				| NFS_INO_REVAL_PAGECACHE

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}





	if (fattr->valid & NFS_ATTR_FATTR_ATIME)

		memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));

	else if (server->caps & NFS_CAP_ATIME)

	else if (server->caps & NFS_CAP_ATIME) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATIME

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}



	if (fattr->valid & NFS_ATTR_FATTR_MODE) {

		if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
@@ -1770,36 +1781,42 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
			inode->i_mode = newmode;

			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;

		}

	} else if (server->caps & NFS_CAP_MODE)

	} else if (server->caps & NFS_CAP_MODE) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				| NFS_INO_INVALID_ACCESS

				| NFS_INO_INVALID_ACL

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}



	if (fattr->valid & NFS_ATTR_FATTR_OWNER) {

		if (!uid_eq(inode->i_uid, fattr->uid)) {

			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;

			inode->i_uid = fattr->uid;

		}

	} else if (server->caps & NFS_CAP_OWNER)

	} else if (server->caps & NFS_CAP_OWNER) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				| NFS_INO_INVALID_ACCESS

				| NFS_INO_INVALID_ACL

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}



	if (fattr->valid & NFS_ATTR_FATTR_GROUP) {

		if (!gid_eq(inode->i_gid, fattr->gid)) {

			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;

			inode->i_gid = fattr->gid;

		}

	} else if (server->caps & NFS_CAP_OWNER_GROUP)

	} else if (server->caps & NFS_CAP_OWNER_GROUP) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				| NFS_INO_INVALID_ACCESS

				| NFS_INO_INVALID_ACL

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}



	if (fattr->valid & NFS_ATTR_FATTR_NLINK) {

		if (inode->i_nlink != fattr->nlink) {
@@ -1808,19 +1825,22 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
				invalid |= NFS_INO_INVALID_DATA;

			set_nlink(inode, fattr->nlink);

		}

	} else if (server->caps & NFS_CAP_NLINK)

	} else if (server->caps & NFS_CAP_NLINK) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}



	if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {

		/*

		 * report the blocks in 512byte units

		 */

		inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);

 	}

	if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)

	} else if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)

		inode->i_blocks = fattr->du.nfs2.blocks;

	else

		cache_revalidated = false;



	/* Update attrtimeo value if we're out of the unstable period */

	if (invalid & NFS_INO_INVALID_ATTR) {
@@ -1830,9 +1850,13 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
		/* Set barrier to be more recent than all outstanding updates */

		nfsi->attr_gencount = nfs_inc_attr_generation_counter();

	} else {

		if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {

			if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))

		if (cache_revalidated) {

			if (!time_in_range_open(now, nfsi->attrtimeo_timestamp,

				nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {

				nfsi->attrtimeo <<= 1;

				if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode))

					nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);

			}

			nfsi->attrtimeo_timestamp = now;

		}

		/* Set the barrier to be more recent than this fattr */
@@ -1841,7 +1865,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
	}



	/* Don't declare attrcache up to date if there were no attrs! */

	if (fattr->valid != 0)

	if (cache_revalidated)

		invalid &= ~NFS_INO_INVALID_ATTR;



	/* Don't invalidate the data if we were to blame */

fs/nfs/nfs42proc.c

+27 −2
Original line number Diff line number Diff line
@@ -204,6 +204,8 @@ static void 
nfs42_layoutstat_done(struct rpc_task *task, void *calldata)

{

	struct nfs42_layoutstat_data *data = calldata;

	struct inode *inode = data->inode;

	struct pnfs_layout_hdr *lo;



	if (!nfs4_sequence_done(task, &data->res.seq_res))

		return;
@@ -211,12 +213,35 @@ nfs42_layoutstat_done(struct rpc_task *task, void *calldata) 
	switch (task->tk_status) {

	case 0:

		break;

	case -NFS4ERR_EXPIRED:

	case -NFS4ERR_STALE_STATEID:

	case -NFS4ERR_OLD_STATEID:

	case -NFS4ERR_BAD_STATEID:

		spin_lock(&inode->i_lock);

		lo = NFS_I(inode)->layout;

		if (lo && nfs4_stateid_match(&data->args.stateid,

					     &lo->plh_stateid)) {

			LIST_HEAD(head);



			/*

			 * Mark the bad layout state as invalid, then retry

			 * with the current stateid.

			 */

			set_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags);

			pnfs_mark_matching_lsegs_invalid(lo, &head, NULL);

			spin_unlock(&inode->i_lock);

			pnfs_free_lseg_list(&head);

		} else

			spin_unlock(&inode->i_lock);

		break;

	case -ENOTSUPP:

	case -EOPNOTSUPP:

		NFS_SERVER(data->inode)->caps &= ~NFS_CAP_LAYOUTSTATS;

		NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;

	default:

		dprintk("%s server returns %d\n", __func__, task->tk_status);

		break;

	}



	dprintk("%s server returns %d\n", __func__, task->tk_status);

}



static void

fs/nfs/nfs4proc.c

+4 −2
Original line number Diff line number Diff line
@@ -208,6 +208,9 @@ static const u32 nfs4_pnfs_open_bitmap[3] = { 
	| FATTR4_WORD1_TIME_METADATA

	| FATTR4_WORD1_TIME_MODIFY,

	FATTR4_WORD2_MDSTHRESHOLD

#ifdef CONFIG_NFS_V4_SECURITY_LABEL

	| FATTR4_WORD2_SECURITY_LABEL

#endif

};



static const u32 nfs4_open_noattr_bitmap[3] = {
@@ -1385,6 +1388,7 @@ static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_s 
	 * Protect the call to nfs4_state_set_mode_locked and

	 * serialise the stateid update

	 */

	spin_lock(&state->owner->so_lock);

	write_seqlock(&state->seqlock);

	if (deleg_stateid != NULL) {

		nfs4_stateid_copy(&state->stateid, deleg_stateid);
@@ -1393,7 +1397,6 @@ static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_s 
	if (open_stateid != NULL)

		nfs_set_open_stateid_locked(state, open_stateid, fmode);

	write_sequnlock(&state->seqlock);

	spin_lock(&state->owner->so_lock);

	update_open_stateflags(state, fmode);

	spin_unlock(&state->owner->so_lock);

}
@@ -8079,7 +8082,6 @@ static void nfs4_layoutreturn_release(void *calldata) 
	if (lrp->res.lrs_present)

		pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);

	pnfs_clear_layoutreturn_waitbit(lo);

	lo->plh_block_lgets--;

	spin_unlock(&lo->plh_inode->i_lock);

	pnfs_free_lseg_list(&freeme);

	pnfs_put_layout_hdr(lrp->args.layout);