xref: /openbmc/linux/fs/ceph/export.c (revision 05bcf503)
1 #include <linux/ceph/ceph_debug.h>
2 
3 #include <linux/exportfs.h>
4 #include <linux/slab.h>
5 #include <asm/unaligned.h>
6 
7 #include "super.h"
8 #include "mds_client.h"
9 
10 /*
11  * NFS export support
12  *
13  * NFS re-export of a ceph mount is, at present, only semireliable.
14  * The basic issue is that the Ceph architectures doesn't lend itself
15  * well to generating filehandles that will remain valid forever.
16  *
17  * So, we do our best.  If you're lucky, your inode will be in the
18  * client's cache.  If it's not, and you have a connectable fh, then
19  * the MDS server may be able to find it for you.  Otherwise, you get
20  * ESTALE.
21  *
22  * There are ways to this more reliable, but in the non-connectable fh
23  * case, we won't every work perfectly, and in the connectable case,
24  * some changes are needed on the MDS side to work better.
25  */
26 
27 /*
28  * Basic fh
29  */
30 struct ceph_nfs_fh {
31 	u64 ino;
32 } __attribute__ ((packed));
33 
34 /*
35  * Larger 'connectable' fh that includes parent ino and name hash.
36  * Use this whenever possible, as it works more reliably.
37  */
38 struct ceph_nfs_confh {
39 	u64 ino, parent_ino;
40 	u32 parent_name_hash;
41 } __attribute__ ((packed));
42 
43 /*
44  * The presence of @parent_inode here tells us whether NFS wants a
45  * connectable file handle.  However, we want to make a connectionable
46  * file handle unconditionally so that the MDS gets as much of a hint
47  * as possible.  That means we only use @parent_dentry to indicate
48  * whether nfsd wants a connectable fh, and whether we should indicate
49  * failure from a too-small @max_len.
50  */
51 static int ceph_encode_fh(struct inode *inode, u32 *rawfh, int *max_len,
52 			  struct inode *parent_inode)
53 {
54 	int type;
55 	struct ceph_nfs_fh *fh = (void *)rawfh;
56 	struct ceph_nfs_confh *cfh = (void *)rawfh;
57 	int connected_handle_length = sizeof(*cfh)/4;
58 	int handle_length = sizeof(*fh)/4;
59 	struct dentry *dentry = d_find_alias(inode);
60 	struct dentry *parent;
61 
62 	/* don't re-export snaps */
63 	if (ceph_snap(inode) != CEPH_NOSNAP)
64 		return -EINVAL;
65 
66 	/* if we found an alias, generate a connectable fh */
67 	if (*max_len >= connected_handle_length && dentry) {
68 		dout("encode_fh %p connectable\n", dentry);
69 		spin_lock(&dentry->d_lock);
70 		parent = dentry->d_parent;
71 		cfh->ino = ceph_ino(inode);
72 		cfh->parent_ino = ceph_ino(parent->d_inode);
73 		cfh->parent_name_hash = ceph_dentry_hash(parent->d_inode,
74 							 dentry);
75 		*max_len = connected_handle_length;
76 		type = 2;
77 		spin_unlock(&dentry->d_lock);
78 	} else if (*max_len >= handle_length) {
79 		if (parent_inode) {
80 			/* nfsd wants connectable */
81 			*max_len = connected_handle_length;
82 			type = 255;
83 		} else {
84 			dout("encode_fh %p\n", dentry);
85 			fh->ino = ceph_ino(inode);
86 			*max_len = handle_length;
87 			type = 1;
88 		}
89 	} else {
90 		*max_len = handle_length;
91 		type = 255;
92 	}
93 	if (dentry)
94 		dput(dentry);
95 	return type;
96 }
97 
98 /*
99  * convert regular fh to dentry
100  *
101  * FIXME: we should try harder by querying the mds for the ino.
102  */
103 static struct dentry *__fh_to_dentry(struct super_block *sb,
104 				     struct ceph_nfs_fh *fh, int fh_len)
105 {
106 	struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
107 	struct inode *inode;
108 	struct dentry *dentry;
109 	struct ceph_vino vino;
110 	int err;
111 
112 	if (fh_len < sizeof(*fh) / 4)
113 		return ERR_PTR(-ESTALE);
114 
115 	dout("__fh_to_dentry %llx\n", fh->ino);
116 	vino.ino = fh->ino;
117 	vino.snap = CEPH_NOSNAP;
118 	inode = ceph_find_inode(sb, vino);
119 	if (!inode) {
120 		struct ceph_mds_request *req;
121 
122 		req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPINO,
123 					       USE_ANY_MDS);
124 		if (IS_ERR(req))
125 			return ERR_CAST(req);
126 
127 		req->r_ino1 = vino;
128 		req->r_num_caps = 1;
129 		err = ceph_mdsc_do_request(mdsc, NULL, req);
130 		inode = req->r_target_inode;
131 		if (inode)
132 			ihold(inode);
133 		ceph_mdsc_put_request(req);
134 		if (!inode)
135 			return ERR_PTR(-ESTALE);
136 	}
137 
138 	dentry = d_obtain_alias(inode);
139 	if (IS_ERR(dentry)) {
140 		pr_err("fh_to_dentry %llx -- inode %p but ENOMEM\n",
141 		       fh->ino, inode);
142 		iput(inode);
143 		return dentry;
144 	}
145 	err = ceph_init_dentry(dentry);
146 	if (err < 0) {
147 		iput(inode);
148 		return ERR_PTR(err);
149 	}
150 	dout("__fh_to_dentry %llx %p dentry %p\n", fh->ino, inode, dentry);
151 	return dentry;
152 }
153 
154 /*
155  * convert connectable fh to dentry
156  */
157 static struct dentry *__cfh_to_dentry(struct super_block *sb,
158 				      struct ceph_nfs_confh *cfh, int fh_len)
159 {
160 	struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
161 	struct inode *inode;
162 	struct dentry *dentry;
163 	struct ceph_vino vino;
164 	int err;
165 
166 	if (fh_len < sizeof(*cfh) / 4)
167 		return ERR_PTR(-ESTALE);
168 
169 	dout("__cfh_to_dentry %llx (%llx/%x)\n",
170 	     cfh->ino, cfh->parent_ino, cfh->parent_name_hash);
171 
172 	vino.ino = cfh->ino;
173 	vino.snap = CEPH_NOSNAP;
174 	inode = ceph_find_inode(sb, vino);
175 	if (!inode) {
176 		struct ceph_mds_request *req;
177 
178 		req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPHASH,
179 					       USE_ANY_MDS);
180 		if (IS_ERR(req))
181 			return ERR_CAST(req);
182 
183 		req->r_ino1 = vino;
184 		req->r_ino2.ino = cfh->parent_ino;
185 		req->r_ino2.snap = CEPH_NOSNAP;
186 		req->r_path2 = kmalloc(16, GFP_NOFS);
187 		snprintf(req->r_path2, 16, "%d", cfh->parent_name_hash);
188 		req->r_num_caps = 1;
189 		err = ceph_mdsc_do_request(mdsc, NULL, req);
190 		inode = req->r_target_inode;
191 		if (inode)
192 			ihold(inode);
193 		ceph_mdsc_put_request(req);
194 		if (!inode)
195 			return ERR_PTR(err ? err : -ESTALE);
196 	}
197 
198 	dentry = d_obtain_alias(inode);
199 	if (IS_ERR(dentry)) {
200 		pr_err("cfh_to_dentry %llx -- inode %p but ENOMEM\n",
201 		       cfh->ino, inode);
202 		iput(inode);
203 		return dentry;
204 	}
205 	err = ceph_init_dentry(dentry);
206 	if (err < 0) {
207 		iput(inode);
208 		return ERR_PTR(err);
209 	}
210 	dout("__cfh_to_dentry %llx %p dentry %p\n", cfh->ino, inode, dentry);
211 	return dentry;
212 }
213 
214 static struct dentry *ceph_fh_to_dentry(struct super_block *sb, struct fid *fid,
215 					int fh_len, int fh_type)
216 {
217 	if (fh_type == 1)
218 		return __fh_to_dentry(sb, (struct ceph_nfs_fh *)fid->raw,
219 								fh_len);
220 	else
221 		return __cfh_to_dentry(sb, (struct ceph_nfs_confh *)fid->raw,
222 								fh_len);
223 }
224 
225 /*
226  * get parent, if possible.
227  *
228  * FIXME: we could do better by querying the mds to discover the
229  * parent.
230  */
231 static struct dentry *ceph_fh_to_parent(struct super_block *sb,
232 					 struct fid *fid,
233 					int fh_len, int fh_type)
234 {
235 	struct ceph_nfs_confh *cfh = (void *)fid->raw;
236 	struct ceph_vino vino;
237 	struct inode *inode;
238 	struct dentry *dentry;
239 	int err;
240 
241 	if (fh_type == 1)
242 		return ERR_PTR(-ESTALE);
243 	if (fh_len < sizeof(*cfh) / 4)
244 		return ERR_PTR(-ESTALE);
245 
246 	pr_debug("fh_to_parent %llx/%d\n", cfh->parent_ino,
247 		 cfh->parent_name_hash);
248 
249 	vino.ino = cfh->ino;
250 	vino.snap = CEPH_NOSNAP;
251 	inode = ceph_find_inode(sb, vino);
252 	if (!inode)
253 		return ERR_PTR(-ESTALE);
254 
255 	dentry = d_obtain_alias(inode);
256 	if (IS_ERR(dentry)) {
257 		pr_err("fh_to_parent %llx -- inode %p but ENOMEM\n",
258 		       cfh->ino, inode);
259 		iput(inode);
260 		return dentry;
261 	}
262 	err = ceph_init_dentry(dentry);
263 	if (err < 0) {
264 		iput(inode);
265 		return ERR_PTR(err);
266 	}
267 	dout("fh_to_parent %llx %p dentry %p\n", cfh->ino, inode, dentry);
268 	return dentry;
269 }
270 
271 const struct export_operations ceph_export_ops = {
272 	.encode_fh = ceph_encode_fh,
273 	.fh_to_dentry = ceph_fh_to_dentry,
274 	.fh_to_parent = ceph_fh_to_parent,
275 };
276