1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2015, Primary Data, Inc. All rights reserved.
  4 *
  5 * Tao Peng <bergwolf@primarydata.com>
  6 */
  7#include <linux/dcache.h>
  8#include <linux/exportfs.h>
  9#include <linux/nfs.h>
 10#include <linux/nfs_fs.h>
 11
 12#include "internal.h"
 13#include "nfstrace.h"
 14
 15#define NFSDBG_FACILITY		NFSDBG_VFS
 16
 17enum {
 18	FILEID_HIGH_OFF = 0,	/* inode fileid high */
 19	FILEID_LOW_OFF,		/* inode fileid low */
 20	FILE_I_TYPE_OFF,	/* inode type */
 21	EMBED_FH_OFF		/* embeded server fh */
 22};
 23
 24
 25static struct nfs_fh *nfs_exp_embedfh(__u32 *p)
 26{
 27	return (struct nfs_fh *)(p + EMBED_FH_OFF);
 28}
 29
 30/*
 31 * Let's break subtree checking for now... otherwise we'll have to embed parent fh
 32 * but there might not be enough space.
 33 */
 34static int
 35nfs_encode_fh(struct inode *inode, __u32 *p, int *max_len, struct inode *parent)
 36{
 37	struct nfs_fh *server_fh = NFS_FH(inode);
 38	struct nfs_fh *clnt_fh = nfs_exp_embedfh(p);
 39	size_t fh_size = offsetof(struct nfs_fh, data) + server_fh->size;
 40	int len = EMBED_FH_OFF + XDR_QUADLEN(fh_size);
 41
 42	dprintk("%s: max fh len %d inode %p parent %p",
 43		__func__, *max_len, inode, parent);
 44
 45	if (*max_len < len || IS_AUTOMOUNT(inode)) {
 46		dprintk("%s: fh len %d too small, required %d\n",
 47			__func__, *max_len, len);
 48		*max_len = len;
 49		return FILEID_INVALID;
 50	}
 51
 52	p[FILEID_HIGH_OFF] = NFS_FILEID(inode) >> 32;
 53	p[FILEID_LOW_OFF] = NFS_FILEID(inode);
 54	p[FILE_I_TYPE_OFF] = inode->i_mode & S_IFMT;
 55	p[len - 1] = 0; /* Padding */
 56	nfs_copy_fh(clnt_fh, server_fh);
 57	*max_len = len;
 58	dprintk("%s: result fh fileid %llu mode %u size %d\n",
 59		__func__, NFS_FILEID(inode), inode->i_mode, *max_len);
 60	return *max_len;
 61}
 62
 63static struct dentry *
 64nfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
 65		 int fh_len, int fh_type)
 66{
 67	struct nfs4_label *label = NULL;
 68	struct nfs_fattr *fattr = NULL;
 69	struct nfs_fh *server_fh = nfs_exp_embedfh(fid->raw);
 70	size_t fh_size = offsetof(struct nfs_fh, data) + server_fh->size;
 71	const struct nfs_rpc_ops *rpc_ops;
 72	struct dentry *dentry;
 73	struct inode *inode;
 74	int len = EMBED_FH_OFF + XDR_QUADLEN(fh_size);
 75	u32 *p = fid->raw;
 76	int ret;
 77
 78	/* NULL translates to ESTALE */
 79	if (fh_len < len || fh_type != len)
 80		return NULL;
 81
 82	fattr = nfs_alloc_fattr();
 83	if (fattr == NULL) {
 84		dentry = ERR_PTR(-ENOMEM);
 85		goto out;
 86	}
 87
 88	fattr->fileid = ((u64)p[FILEID_HIGH_OFF] << 32) + p[FILEID_LOW_OFF];
 89	fattr->mode = p[FILE_I_TYPE_OFF];
 90	fattr->valid |= NFS_ATTR_FATTR_FILEID | NFS_ATTR_FATTR_TYPE;
 91
 92	dprintk("%s: fileid %llu mode %d\n", __func__, fattr->fileid, fattr->mode);
 93
 94	inode = nfs_ilookup(sb, fattr, server_fh);
 95	if (inode)
 96		goto out_found;
 97
 98	label = nfs4_label_alloc(NFS_SB(sb), GFP_KERNEL);
 99	if (IS_ERR(label)) {
100		dentry = ERR_CAST(label);
101		goto out_free_fattr;
102	}
103
104	rpc_ops = NFS_SB(sb)->nfs_client->rpc_ops;
105	ret = rpc_ops->getattr(NFS_SB(sb), server_fh, fattr, label, NULL);
106	if (ret) {
107		dprintk("%s: getattr failed %d\n", __func__, ret);
108		trace_nfs_fh_to_dentry(sb, server_fh, fattr->fileid, ret);
109		dentry = ERR_PTR(ret);
110		goto out_free_label;
111	}
112
113	inode = nfs_fhget(sb, server_fh, fattr, label);
114
115out_found:
116	dentry = d_obtain_alias(inode);
117
118out_free_label:
119	nfs4_label_free(label);
120out_free_fattr:
121	nfs_free_fattr(fattr);
122out:
123	return dentry;
124}
125
126static struct dentry *
127nfs_get_parent(struct dentry *dentry)
128{
129	int ret;
130	struct inode *inode = d_inode(dentry), *pinode;
131	struct super_block *sb = inode->i_sb;
132	struct nfs_server *server = NFS_SB(sb);
133	struct nfs_fattr *fattr = NULL;
134	struct nfs4_label *label = NULL;
135	struct dentry *parent;
136	struct nfs_rpc_ops const *ops = server->nfs_client->rpc_ops;
137	struct nfs_fh fh;
138
139	if (!ops->lookupp)
140		return ERR_PTR(-EACCES);
141
142	fattr = nfs_alloc_fattr();
143	if (fattr == NULL) {
144		parent = ERR_PTR(-ENOMEM);
145		goto out;
146	}
147
148	label = nfs4_label_alloc(server, GFP_KERNEL);
149	if (IS_ERR(label)) {
150		parent = ERR_CAST(label);
151		goto out_free_fattr;
152	}
153
154	ret = ops->lookupp(inode, &fh, fattr, label);
155	if (ret) {
156		parent = ERR_PTR(ret);
157		goto out_free_label;
158	}
159
160	pinode = nfs_fhget(sb, &fh, fattr, label);
161	parent = d_obtain_alias(pinode);
162out_free_label:
163	nfs4_label_free(label);
164out_free_fattr:
165	nfs_free_fattr(fattr);
166out:
167	return parent;
168}
169
170static u64 nfs_fetch_iversion(struct inode *inode)
171{
172	nfs_revalidate_inode(inode, NFS_INO_INVALID_CHANGE);
173	return inode_peek_iversion_raw(inode);
174}
175
176const struct export_operations nfs_export_ops = {
177	.encode_fh = nfs_encode_fh,
178	.fh_to_dentry = nfs_fh_to_dentry,
179	.get_parent = nfs_get_parent,
180	.fetch_iversion = nfs_fetch_iversion,
181	.flags = EXPORT_OP_NOWCC|EXPORT_OP_NOSUBTREECHK|
182		EXPORT_OP_CLOSE_BEFORE_UNLINK|EXPORT_OP_REMOTE_FS|
183		EXPORT_OP_NOATOMIC_ATTR|EXPORT_OP_SYNC_LOCKS,
184};