Merge tag 'nfsd-5.11' of git://git.linux-nfs.org/projects/cel/cel-2.6

    to find potential names, and matches inode numbers to find the correct

    match.

  flags

    Some filesystems may need to be handled differently than others. The

    export_operations struct also includes a flags field that allows the

    filesystem to communicate such information to nfsd. See the Export

    Operations Flags section below for more explanation.

A filehandle fragment consists of an array of 1 or more 4byte words,

together with a one byte "type".

nuls.  Rather, the encode_fh routine should choose a "type" which

indicates the decode_fh how much of the filehandle is valid, and how

it should be interpreted.

Export Operations Flags

-----------------------

In addition to the operation vector pointers, struct export_operations also

contains a "flags" field that allows the filesystem to communicate to nfsd

that it may want to do things differently when dealing with it. The

following flags are defined:

  EXPORT_OP_NOWCC - disable NFSv3 WCC attributes on this filesystem

    RFC 1813 recommends that servers always send weak cache consistency

    (WCC) data to the client after each operation. The server should

    atomically collect attributes about the inode, do an operation on it,

    and then collect the attributes afterward. This allows the client to

    skip issuing GETATTRs in some situations but means that the server

    is calling vfs_getattr for almost all RPCs. On some filesystems

    (particularly those that are clustered or networked) this is expensive

    and atomicity is difficult to guarantee. This flag indicates to nfsd

    that it should skip providing WCC attributes to the client in NFSv3

    replies when doing operations on this filesystem. Consider enabling

    this on filesystems that have an expensive ->getattr inode operation,

    or when atomicity between pre and post operation attribute collection

    is impossible to guarantee.

  EXPORT_OP_NOSUBTREECHK - disallow subtree checking on this fs

    Many NFS operations deal with filehandles, which the server must then

    vet to ensure that they live inside of an exported tree. When the

    export consists of an entire filesystem, this is trivial. nfsd can just

    ensure that the filehandle live on the filesystem. When only part of a

    filesystem is exported however, then nfsd must walk the ancestors of the

    inode to ensure that it's within an exported subtree. This is an

    expensive operation and not all filesystems can support it properly.

    This flag exempts the filesystem from subtree checking and causes

    exportfs to get back an error if it tries to enable subtree checking

    on it.

  EXPORT_OP_CLOSE_BEFORE_UNLINK - always close cached files before unlinking

    On some exportable filesystems (such as NFS) unlinking a file that

    is still open can cause a fair bit of extra work. For instance,

    the NFS client will do a "sillyrename" to ensure that the file

    sticks around while it's still open. When reexporting, that open

    file is held by nfsd so we usually end up doing a sillyrename, and

    then immediately deleting the sillyrenamed file just afterward when

    the link count actually goes to zero. Sometimes this delete can race

    with other operations (for instance an rmdir of the parent directory).

    This flag causes nfsd to close any open files for this inode _before_

    calling into the vfs to do an unlink or a rename that would replace

    an existing file.

}

EXPORT_SYMBOL_GPL(exportfs_encode_fh);

struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,

		int fh_len, int fileid_type,

		int (*acceptable)(void *, struct dentry *), void *context)

struct dentry *

exportfs_decode_fh_raw(struct vfsmount *mnt, struct fid *fid, int fh_len,

		       int fileid_type,

		       int (*acceptable)(void *, struct dentry *),

		       void *context)

{

	const struct export_operations *nop = mnt->mnt_sb->s_export_op;

	struct dentry *result, *alias;

	if (!nop || !nop->fh_to_dentry)

		return ERR_PTR(-ESTALE);

	result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);

	if (PTR_ERR(result) == -ENOMEM)

		return ERR_CAST(result);

	if (IS_ERR_OR_NULL(result))

		return ERR_PTR(-ESTALE);

		return result;

	/*

	 * If no acceptance criteria was specified by caller, a disconnected

 err_result:

	dput(result);

	if (err != -ENOMEM)

		err = -ESTALE;

	return ERR_PTR(err);

}

EXPORT_SYMBOL_GPL(exportfs_decode_fh_raw);

struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,

				  int fh_len, int fileid_type,

				  int (*acceptable)(void *, struct dentry *),

				  void *context)

{

	struct dentry *ret;

	ret = exportfs_decode_fh_raw(mnt, fid, fh_len, fileid_type,

				     acceptable, context);

	if (IS_ERR_OR_NULL(ret)) {

		if (ret == ERR_PTR(-ENOMEM))

			return ret;

		return ERR_PTR(-ESTALE);

	}

	return ret;

}

EXPORT_SYMBOL_GPL(exportfs_decode_fh);

MODULE_LICENSE("GPL");

	xdr_init_decode_pages(&xdr, &buf,

			lgr->layoutp->pages, lgr->layoutp->len);

	xdr_set_scratch_buffer(&xdr, page_address(scratch), PAGE_SIZE);

	xdr_set_scratch_page(&xdr, scratch);

	status = -EIO;

	p = xdr_inline_decode(&xdr, 4);

		goto out;

	xdr_init_decode_pages(&xdr, &buf, pdev->pages, pdev->pglen);

	xdr_set_scratch_buffer(&xdr, page_address(scratch), PAGE_SIZE);

	xdr_set_scratch_page(&xdr, scratch);

	p = xdr_inline_decode(&xdr, sizeof(__be32));

	if (!p)

		goto out_nopages;

	xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);

	xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);

	xdr_set_scratch_page(&stream, scratch);

	do {

		if (entry->label)