~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ceph/export.c

Version: ~ [ linux-5.19-rc3 ] ~ [ linux-5.18.5 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.48 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.123 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.199 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.248 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.284 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.319 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  * Basic fh
 12  */
 13 struct ceph_nfs_fh {
 14         u64 ino;
 15 } __attribute__ ((packed));
 16 
 17 /*
 18  * Larger fh that includes parent ino.
 19  */
 20 struct ceph_nfs_confh {
 21         u64 ino, parent_ino;
 22 } __attribute__ ((packed));
 23 
 24 static int ceph_encode_fh(struct inode *inode, u32 *rawfh, int *max_len,
 25                           struct inode *parent_inode)
 26 {
 27         int type;
 28         struct ceph_nfs_fh *fh = (void *)rawfh;
 29         struct ceph_nfs_confh *cfh = (void *)rawfh;
 30         int connected_handle_length = sizeof(*cfh)/4;
 31         int handle_length = sizeof(*fh)/4;
 32 
 33         /* don't re-export snaps */
 34         if (ceph_snap(inode) != CEPH_NOSNAP)
 35                 return -EINVAL;
 36 
 37         if (parent_inode && (*max_len < connected_handle_length)) {
 38                 *max_len = connected_handle_length;
 39                 return FILEID_INVALID;
 40         } else if (*max_len < handle_length) {
 41                 *max_len = handle_length;
 42                 return FILEID_INVALID;
 43         }
 44 
 45         if (parent_inode) {
 46                 dout("encode_fh %llx with parent %llx\n",
 47                      ceph_ino(inode), ceph_ino(parent_inode));
 48                 cfh->ino = ceph_ino(inode);
 49                 cfh->parent_ino = ceph_ino(parent_inode);
 50                 *max_len = connected_handle_length;
 51                 type = FILEID_INO32_GEN_PARENT;
 52         } else {
 53                 dout("encode_fh %llx\n", ceph_ino(inode));
 54                 fh->ino = ceph_ino(inode);
 55                 *max_len = handle_length;
 56                 type = FILEID_INO32_GEN;
 57         }
 58         return type;
 59 }
 60 
 61 static struct dentry *__fh_to_dentry(struct super_block *sb, u64 ino)
 62 {
 63         struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
 64         struct inode *inode;
 65         struct dentry *dentry;
 66         struct ceph_vino vino;
 67         int err;
 68 
 69         vino.ino = ino;
 70         vino.snap = CEPH_NOSNAP;
 71         inode = ceph_find_inode(sb, vino);
 72         if (!inode) {
 73                 struct ceph_mds_request *req;
 74                 int mask;
 75 
 76                 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPINO,
 77                                                USE_ANY_MDS);
 78                 if (IS_ERR(req))
 79                         return ERR_CAST(req);
 80 
 81                 mask = CEPH_STAT_CAP_INODE;
 82                 if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
 83                         mask |= CEPH_CAP_XATTR_SHARED;
 84                 req->r_args.getattr.mask = cpu_to_le32(mask);
 85 
 86                 req->r_ino1 = vino;
 87                 req->r_num_caps = 1;
 88                 err = ceph_mdsc_do_request(mdsc, NULL, req);
 89                 inode = req->r_target_inode;
 90                 if (inode)
 91                         ihold(inode);
 92                 ceph_mdsc_put_request(req);
 93                 if (!inode)
 94                         return ERR_PTR(-ESTALE);
 95         }
 96 
 97         dentry = d_obtain_alias(inode);
 98         if (IS_ERR(dentry)) {
 99                 iput(inode);
100                 return dentry;
101         }
102         err = ceph_init_dentry(dentry);
103         if (err < 0) {
104                 dput(dentry);
105                 return ERR_PTR(err);
106         }
107         dout("__fh_to_dentry %llx %p dentry %p\n", ino, inode, dentry);
108         return dentry;
109 }
110 
111 /*
112  * convert regular fh to dentry
113  */
114 static struct dentry *ceph_fh_to_dentry(struct super_block *sb,
115                                         struct fid *fid,
116                                         int fh_len, int fh_type)
117 {
118         struct ceph_nfs_fh *fh = (void *)fid->raw;
119 
120         if (fh_type != FILEID_INO32_GEN  &&
121             fh_type != FILEID_INO32_GEN_PARENT)
122                 return NULL;
123         if (fh_len < sizeof(*fh) / 4)
124                 return NULL;
125 
126         dout("fh_to_dentry %llx\n", fh->ino);
127         return __fh_to_dentry(sb, fh->ino);
128 }
129 
130 static struct dentry *__get_parent(struct super_block *sb,
131                                    struct dentry *child, u64 ino)
132 {
133         struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
134         struct ceph_mds_request *req;
135         struct inode *inode;
136         struct dentry *dentry;
137         int mask;
138         int err;
139 
140         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPPARENT,
141                                        USE_ANY_MDS);
142         if (IS_ERR(req))
143                 return ERR_CAST(req);
144 
145         if (child) {
146                 req->r_inode = d_inode(child);
147                 ihold(d_inode(child));
148         } else {
149                 req->r_ino1 = (struct ceph_vino) {
150                         .ino = ino,
151                         .snap = CEPH_NOSNAP,
152                 };
153         }
154 
155         mask = CEPH_STAT_CAP_INODE;
156         if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
157                 mask |= CEPH_CAP_XATTR_SHARED;
158         req->r_args.getattr.mask = cpu_to_le32(mask);
159 
160         req->r_num_caps = 1;
161         err = ceph_mdsc_do_request(mdsc, NULL, req);
162         inode = req->r_target_inode;
163         if (inode)
164                 ihold(inode);
165         ceph_mdsc_put_request(req);
166         if (!inode)
167                 return ERR_PTR(-ENOENT);
168 
169         dentry = d_obtain_alias(inode);
170         if (IS_ERR(dentry)) {
171                 iput(inode);
172                 return dentry;
173         }
174         err = ceph_init_dentry(dentry);
175         if (err < 0) {
176                 dput(dentry);
177                 return ERR_PTR(err);
178         }
179         dout("__get_parent ino %llx parent %p ino %llx.%llx\n",
180              child ? ceph_ino(d_inode(child)) : ino,
181              dentry, ceph_vinop(inode));
182         return dentry;
183 }
184 
185 static struct dentry *ceph_get_parent(struct dentry *child)
186 {
187         /* don't re-export snaps */
188         if (ceph_snap(d_inode(child)) != CEPH_NOSNAP)
189                 return ERR_PTR(-EINVAL);
190 
191         dout("get_parent %p ino %llx.%llx\n",
192              child, ceph_vinop(d_inode(child)));
193         return __get_parent(child->d_sb, child, 0);
194 }
195 
196 /*
197  * convert regular fh to parent
198  */
199 static struct dentry *ceph_fh_to_parent(struct super_block *sb,
200                                         struct fid *fid,
201                                         int fh_len, int fh_type)
202 {
203         struct ceph_nfs_confh *cfh = (void *)fid->raw;
204         struct dentry *dentry;
205 
206         if (fh_type != FILEID_INO32_GEN_PARENT)
207                 return NULL;
208         if (fh_len < sizeof(*cfh) / 4)
209                 return NULL;
210 
211         dout("fh_to_parent %llx\n", cfh->parent_ino);
212         dentry = __get_parent(sb, NULL, cfh->ino);
213         if (IS_ERR(dentry) && PTR_ERR(dentry) == -ENOENT)
214                 dentry = __fh_to_dentry(sb, cfh->parent_ino);
215         return dentry;
216 }
217 
218 static int ceph_get_name(struct dentry *parent, char *name,
219                          struct dentry *child)
220 {
221         struct ceph_mds_client *mdsc;
222         struct ceph_mds_request *req;
223         int err;
224 
225         mdsc = ceph_inode_to_client(d_inode(child))->mdsc;
226         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPNAME,
227                                        USE_ANY_MDS);
228         if (IS_ERR(req))
229                 return PTR_ERR(req);
230 
231         inode_lock(d_inode(parent));
232 
233         req->r_inode = d_inode(child);
234         ihold(d_inode(child));
235         req->r_ino2 = ceph_vino(d_inode(parent));
236         req->r_locked_dir = d_inode(parent);
237         req->r_num_caps = 2;
238         err = ceph_mdsc_do_request(mdsc, NULL, req);
239 
240         inode_unlock(d_inode(parent));
241 
242         if (!err) {
243                 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
244                 memcpy(name, rinfo->dname, rinfo->dname_len);
245                 name[rinfo->dname_len] = 0;
246                 dout("get_name %p ino %llx.%llx name %s\n",
247                      child, ceph_vinop(d_inode(child)), name);
248         } else {
249                 dout("get_name %p ino %llx.%llx err %d\n",
250                      child, ceph_vinop(d_inode(child)), err);
251         }
252 
253         ceph_mdsc_put_request(req);
254         return err;
255 }
256 
257 const struct export_operations ceph_export_ops = {
258         .encode_fh = ceph_encode_fh,
259         .fh_to_dentry = ceph_fh_to_dentry,
260         .fh_to_parent = ceph_fh_to_parent,
261         .get_parent = ceph_get_parent,
262         .get_name = ceph_get_name,
263 };
264 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp