1 #include <linux/ceph/ceph_debug.h>
3 #include <linux/exportfs.h>
4 #include <linux/slab.h>
5 #include <asm/unaligned.h>
8 #include "mds_client.h"
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.
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
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.
32 } __attribute__ ((packed
));
35 * Larger 'connectable' fh that includes parent ino and name hash.
36 * Use this whenever possible, as it works more reliably.
38 struct ceph_nfs_confh
{
41 } __attribute__ ((packed
));
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.
51 static int ceph_encode_fh(struct inode
*inode
, u32
*rawfh
, int *max_len
,
52 struct inode
*parent_inode
)
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
;
62 /* don't re-export snaps */
63 if (ceph_snap(inode
) != CEPH_NOSNAP
)
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
,
75 *max_len
= connected_handle_length
;
77 spin_unlock(&dentry
->d_lock
);
78 } else if (*max_len
>= handle_length
) {
80 /* nfsd wants connectable */
81 *max_len
= connected_handle_length
;
84 dout("encode_fh %p\n", dentry
);
85 fh
->ino
= ceph_ino(inode
);
86 *max_len
= handle_length
;
90 *max_len
= handle_length
;
99 * convert regular fh to dentry
101 * FIXME: we should try harder by querying the mds for the ino.
103 static struct dentry
*__fh_to_dentry(struct super_block
*sb
,
104 struct ceph_nfs_fh
*fh
, int fh_len
)
106 struct ceph_mds_client
*mdsc
= ceph_sb_to_client(sb
)->mdsc
;
108 struct dentry
*dentry
;
109 struct ceph_vino vino
;
112 if (fh_len
< sizeof(*fh
) / 4)
113 return ERR_PTR(-ESTALE
);
115 dout("__fh_to_dentry %llx\n", fh
->ino
);
117 vino
.snap
= CEPH_NOSNAP
;
118 inode
= ceph_find_inode(sb
, vino
);
120 struct ceph_mds_request
*req
;
122 req
= ceph_mdsc_create_request(mdsc
, CEPH_MDS_OP_LOOKUPINO
,
125 return ERR_CAST(req
);
129 err
= ceph_mdsc_do_request(mdsc
, NULL
, req
);
130 inode
= req
->r_target_inode
;
133 ceph_mdsc_put_request(req
);
135 return ERR_PTR(-ESTALE
);
138 dentry
= d_obtain_alias(inode
);
139 if (IS_ERR(dentry
)) {
140 pr_err("fh_to_dentry %llx -- inode %p but ENOMEM\n",
145 err
= ceph_init_dentry(dentry
);
150 dout("__fh_to_dentry %llx %p dentry %p\n", fh
->ino
, inode
, dentry
);
155 * convert connectable fh to dentry
157 static struct dentry
*__cfh_to_dentry(struct super_block
*sb
,
158 struct ceph_nfs_confh
*cfh
, int fh_len
)
160 struct ceph_mds_client
*mdsc
= ceph_sb_to_client(sb
)->mdsc
;
162 struct dentry
*dentry
;
163 struct ceph_vino vino
;
166 if (fh_len
< sizeof(*cfh
) / 4)
167 return ERR_PTR(-ESTALE
);
169 dout("__cfh_to_dentry %llx (%llx/%x)\n",
170 cfh
->ino
, cfh
->parent_ino
, cfh
->parent_name_hash
);
173 vino
.snap
= CEPH_NOSNAP
;
174 inode
= ceph_find_inode(sb
, vino
);
176 struct ceph_mds_request
*req
;
178 req
= ceph_mdsc_create_request(mdsc
, CEPH_MDS_OP_LOOKUPHASH
,
181 return ERR_CAST(req
);
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
);
189 err
= ceph_mdsc_do_request(mdsc
, NULL
, req
);
190 inode
= req
->r_target_inode
;
193 ceph_mdsc_put_request(req
);
195 return ERR_PTR(err
? err
: -ESTALE
);
198 dentry
= d_obtain_alias(inode
);
199 if (IS_ERR(dentry
)) {
200 pr_err("cfh_to_dentry %llx -- inode %p but ENOMEM\n",
205 err
= ceph_init_dentry(dentry
);
210 dout("__cfh_to_dentry %llx %p dentry %p\n", cfh
->ino
, inode
, dentry
);
214 static struct dentry
*ceph_fh_to_dentry(struct super_block
*sb
, struct fid
*fid
,
215 int fh_len
, int fh_type
)
218 return __fh_to_dentry(sb
, (struct ceph_nfs_fh
*)fid
->raw
,
221 return __cfh_to_dentry(sb
, (struct ceph_nfs_confh
*)fid
->raw
,
226 * get parent, if possible.
228 * FIXME: we could do better by querying the mds to discover the
231 static struct dentry
*ceph_fh_to_parent(struct super_block
*sb
,
233 int fh_len
, int fh_type
)
235 struct ceph_nfs_confh
*cfh
= (void *)fid
->raw
;
236 struct ceph_vino vino
;
238 struct dentry
*dentry
;
242 return ERR_PTR(-ESTALE
);
243 if (fh_len
< sizeof(*cfh
) / 4)
244 return ERR_PTR(-ESTALE
);
246 pr_debug("fh_to_parent %llx/%d\n", cfh
->parent_ino
,
247 cfh
->parent_name_hash
);
250 vino
.snap
= CEPH_NOSNAP
;
251 inode
= ceph_find_inode(sb
, vino
);
253 return ERR_PTR(-ESTALE
);
255 dentry
= d_obtain_alias(inode
);
256 if (IS_ERR(dentry
)) {
257 pr_err("fh_to_parent %llx -- inode %p but ENOMEM\n",
262 err
= ceph_init_dentry(dentry
);
267 dout("fh_to_parent %llx %p dentry %p\n", cfh
->ino
, inode
, dentry
);
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
,