fs/ceph/export.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/ceph/ceph_debug.h>
   3
   4 #include <linux/exportfs.h>
   5 #include <linux/slab.h>
   6 #include <asm/unaligned.h>
   7
   8 #include "super.h"
   9 #include "mds_client.h"
  10
  11 /*
  12  * Basic fh
  13  */
  14 struct ceph_nfs_fh {
  15         u64 ino;
  16 } __attribute__ ((packed));
  17
  18 /*
  19  * Larger fh that includes parent ino.
  20  */
  21 struct ceph_nfs_confh {
  22         u64 ino, parent_ino;
  23 } __attribute__ ((packed));
  24
  25 /*
  26  * fh for snapped inode
  27  */
  28 struct ceph_nfs_snapfh {
  29         u64 ino;
  30         u64 snapid;
  31         u64 parent_ino;
  32         u32 hash;
  33 } __attribute__ ((packed));
  34
  35 static int ceph_encode_snapfh(struct inode *inode, u32 *rawfh, int *max_len,
  36                               struct inode *parent_inode)
  37 {
  38         static const int snap_handle_length =
  39                 sizeof(struct ceph_nfs_snapfh) >> 2;
  40         struct ceph_nfs_snapfh *sfh = (void *)rawfh;
  41         u64 snapid = ceph_snap(inode);
  42         int ret;
  43         bool no_parent = true;
  44
  45         if (*max_len < snap_handle_length) {
  46                 *max_len = snap_handle_length;
  47                 ret = FILEID_INVALID;
  48                 goto out;
  49         }
  50
  51         ret =  -EINVAL;
  52         if (snapid != CEPH_SNAPDIR) {
  53                 struct inode *dir;
  54                 struct dentry *dentry = d_find_alias(inode);
  55                 if (!dentry)
  56                         goto out;
  57
  58                 rcu_read_lock();
  59                 dir = d_inode_rcu(dentry->d_parent);
  60                 if (ceph_snap(dir) != CEPH_SNAPDIR) {
  61                         sfh->parent_ino = ceph_ino(dir);
  62                         sfh->hash = ceph_dentry_hash(dir, dentry);
  63                         no_parent = false;
  64                 }
  65                 rcu_read_unlock();
  66                 dput(dentry);
  67         }
  68
  69         if (no_parent) {
  70                 if (!S_ISDIR(inode->i_mode))
  71                         goto out;
  72                 sfh->parent_ino = sfh->ino;
  73                 sfh->hash = 0;
  74         }
  75         sfh->ino = ceph_ino(inode);
  76         sfh->snapid = snapid;
  77
  78         *max_len = snap_handle_length;
  79         ret = FILEID_BTRFS_WITH_PARENT;
  80 out:
  81         dout("encode_snapfh %llx.%llx ret=%d\n", ceph_vinop(inode), ret);
  82         return ret;
  83 }
  84
  85 static int ceph_encode_fh(struct inode *inode, u32 *rawfh, int *max_len,
  86                           struct inode *parent_inode)
  87 {
  88         static const int handle_length =
  89                 sizeof(struct ceph_nfs_fh) >> 2;
  90         static const int connected_handle_length =
  91                 sizeof(struct ceph_nfs_confh) >> 2;
  92         int type;
  93
  94         if (ceph_snap(inode) != CEPH_NOSNAP)
  95                 return ceph_encode_snapfh(inode, rawfh, max_len, parent_inode);
  96
  97         if (parent_inode && (*max_len < connected_handle_length)) {
  98                 *max_len = connected_handle_length;
  99                 return FILEID_INVALID;
 100         } else if (*max_len < handle_length) {
 101                 *max_len = handle_length;
 102                 return FILEID_INVALID;
 103         }
 104
 105         if (parent_inode) {
 106                 struct ceph_nfs_confh *cfh = (void *)rawfh;
 107                 dout("encode_fh %llx with parent %llx\n",
 108                      ceph_ino(inode), ceph_ino(parent_inode));
 109                 cfh->ino = ceph_ino(inode);
 110                 cfh->parent_ino = ceph_ino(parent_inode);
 111                 *max_len = connected_handle_length;
 112                 type = FILEID_INO32_GEN_PARENT;
 113         } else {
 114                 struct ceph_nfs_fh *fh = (void *)rawfh;
 115                 dout("encode_fh %llx\n", ceph_ino(inode));
 116                 fh->ino = ceph_ino(inode);
 117                 *max_len = handle_length;
 118                 type = FILEID_INO32_GEN;
 119         }
 120         return type;
 121 }
 122
 123 static struct inode *__lookup_inode(struct super_block *sb, u64 ino)
 124 {
 125         struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
 126         struct inode *inode;
 127         struct ceph_vino vino;
 128         int err;
 129
 130         vino.ino = ino;
 131         vino.snap = CEPH_NOSNAP;
 132
 133         if (ceph_vino_is_reserved(vino))
 134                 return ERR_PTR(-ESTALE);
 135
 136         inode = ceph_find_inode(sb, vino);
 137         if (!inode) {
 138                 struct ceph_mds_request *req;
 139                 int mask;
 140
 141                 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPINO,
 142                                                USE_ANY_MDS);
 143                 if (IS_ERR(req))
 144                         return ERR_CAST(req);
 145
 146                 mask = CEPH_STAT_CAP_INODE;
 147                 if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
 148                         mask |= CEPH_CAP_XATTR_SHARED;
 149                 req->r_args.lookupino.mask = cpu_to_le32(mask);
 150
 151                 req->r_ino1 = vino;
 152                 req->r_num_caps = 1;
 153                 err = ceph_mdsc_do_request(mdsc, NULL, req);
 154                 inode = req->r_target_inode;
 155                 if (inode)
 156                         ihold(inode);
 157                 ceph_mdsc_put_request(req);
 158                 if (!inode)
 159                         return err < 0 ? ERR_PTR(err) : ERR_PTR(-ESTALE);
 160         } else {
 161                 if (ceph_inode_is_shutdown(inode)) {
 162                         iput(inode);
 163                         return ERR_PTR(-ESTALE);
 164                 }
 165         }
 166         return inode;
 167 }
 168
 169 struct inode *ceph_lookup_inode(struct super_block *sb, u64 ino)
 170 {
 171         struct inode *inode = __lookup_inode(sb, ino);
 172         if (IS_ERR(inode))
 173                 return inode;
 174         if (inode->i_nlink == 0) {
 175                 iput(inode);
 176                 return ERR_PTR(-ESTALE);
 177         }
 178         return inode;
 179 }
 180
 181 static struct dentry *__fh_to_dentry(struct super_block *sb, u64 ino)
 182 {
 183         struct inode *inode = __lookup_inode(sb, ino);
 184         struct ceph_inode_info *ci = ceph_inode(inode);
 185         int err;
 186
 187         if (IS_ERR(inode))
 188                 return ERR_CAST(inode);
 189         /* We need LINK caps to reliably check i_nlink */
 190         err = ceph_do_getattr(inode, CEPH_CAP_LINK_SHARED, false);
 191         if (err) {
 192                 iput(inode);
 193                 return ERR_PTR(err);
 194         }
 195         /* -ESTALE if inode as been unlinked and no file is open */
 196         if ((inode->i_nlink == 0) && !__ceph_is_file_opened(ci)) {
 197                 iput(inode);
 198                 return ERR_PTR(-ESTALE);
 199         }
 200         return d_obtain_alias(inode);
 201 }
 202
 203 static struct dentry *__snapfh_to_dentry(struct super_block *sb,
 204                                           struct ceph_nfs_snapfh *sfh,
 205                                           bool want_parent)
 206 {
 207         struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
 208         struct ceph_mds_request *req;
 209         struct inode *inode;
 210         struct ceph_vino vino;
 211         int mask;
 212         int err;
 213         bool unlinked = false;
 214
 215         if (want_parent) {
 216                 vino.ino = sfh->parent_ino;
 217                 if (sfh->snapid == CEPH_SNAPDIR)
 218                         vino.snap = CEPH_NOSNAP;
 219                 else if (sfh->ino == sfh->parent_ino)
 220                         vino.snap = CEPH_SNAPDIR;
 221                 else
 222                         vino.snap = sfh->snapid;
 223         } else {
 224                 vino.ino = sfh->ino;
 225                 vino.snap = sfh->snapid;
 226         }
 227
 228         if (ceph_vino_is_reserved(vino))
 229                 return ERR_PTR(-ESTALE);
 230
 231         inode = ceph_find_inode(sb, vino);
 232         if (inode) {
 233                 if (ceph_inode_is_shutdown(inode)) {
 234                         iput(inode);
 235                         return ERR_PTR(-ESTALE);
 236                 }
 237                 return d_obtain_alias(inode);
 238         }
 239
 240         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPINO,
 241                                        USE_ANY_MDS);
 242         if (IS_ERR(req))
 243                 return ERR_CAST(req);
 244
 245         mask = CEPH_STAT_CAP_INODE;
 246         if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
 247                 mask |= CEPH_CAP_XATTR_SHARED;
 248         req->r_args.lookupino.mask = cpu_to_le32(mask);
 249         if (vino.snap < CEPH_NOSNAP) {
 250                 req->r_args.lookupino.snapid = cpu_to_le64(vino.snap);
 251                 if (!want_parent && sfh->ino != sfh->parent_ino) {
 252                         req->r_args.lookupino.parent =
 253                                         cpu_to_le64(sfh->parent_ino);
 254                         req->r_args.lookupino.hash =
 255                                         cpu_to_le32(sfh->hash);
 256                 }
 257         }
 258
 259         req->r_ino1 = vino;
 260         req->r_num_caps = 1;
 261         err = ceph_mdsc_do_request(mdsc, NULL, req);
 262         inode = req->r_target_inode;
 263         if (inode) {
 264                 if (vino.snap == CEPH_SNAPDIR) {
 265                         if (inode->i_nlink == 0)
 266                                 unlinked = true;
 267                         inode = ceph_get_snapdir(inode);
 268                 } else if (ceph_snap(inode) == vino.snap) {
 269                         ihold(inode);
 270                 } else {
 271                         /* mds does not support lookup snapped inode */
 272                         inode = ERR_PTR(-EOPNOTSUPP);
 273                 }
 274         } else {
 275                 inode = ERR_PTR(-ESTALE);
 276         }
 277         ceph_mdsc_put_request(req);
 278
 279         if (want_parent) {
 280                 dout("snapfh_to_parent %llx.%llx\n err=%d\n",
 281                      vino.ino, vino.snap, err);
 282         } else {
 283                 dout("snapfh_to_dentry %llx.%llx parent %llx hash %x err=%d",
 284                       vino.ino, vino.snap, sfh->parent_ino, sfh->hash, err);
 285         }
 286         if (IS_ERR(inode))
 287                 return ERR_CAST(inode);
 288         /* see comments in ceph_get_parent() */
 289         return unlinked ? d_obtain_root(inode) : d_obtain_alias(inode);
 290 }
 291
 292 /*
 293  * convert regular fh to dentry
 294  */
 295 static struct dentry *ceph_fh_to_dentry(struct super_block *sb,
 296                                         struct fid *fid,
 297                                         int fh_len, int fh_type)
 298 {
 299         struct ceph_nfs_fh *fh = (void *)fid->raw;
 300
 301         if (fh_type == FILEID_BTRFS_WITH_PARENT) {
 302                 struct ceph_nfs_snapfh *sfh = (void *)fid->raw;
 303                 return __snapfh_to_dentry(sb, sfh, false);
 304         }
 305
 306         if (fh_type != FILEID_INO32_GEN  &&
 307             fh_type != FILEID_INO32_GEN_PARENT)
 308                 return NULL;
 309         if (fh_len < sizeof(*fh) / 4)
 310                 return NULL;
 311
 312         dout("fh_to_dentry %llx\n", fh->ino);
 313         return __fh_to_dentry(sb, fh->ino);
 314 }
 315
 316 static struct dentry *__get_parent(struct super_block *sb,
 317                                    struct dentry *child, u64 ino)
 318 {
 319         struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
 320         struct ceph_mds_request *req;
 321         struct inode *inode;
 322         int mask;
 323         int err;
 324
 325         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPPARENT,
 326                                        USE_ANY_MDS);
 327         if (IS_ERR(req))
 328                 return ERR_CAST(req);
 329
 330         if (child) {
 331                 req->r_inode = d_inode(child);
 332                 ihold(d_inode(child));
 333         } else {
 334                 req->r_ino1 = (struct ceph_vino) {
 335                         .ino = ino,
 336                         .snap = CEPH_NOSNAP,
 337                 };
 338         }
 339
 340         mask = CEPH_STAT_CAP_INODE;
 341         if (ceph_security_xattr_wanted(d_inode(sb->s_root)))
 342                 mask |= CEPH_CAP_XATTR_SHARED;
 343         req->r_args.getattr.mask = cpu_to_le32(mask);
 344
 345         req->r_num_caps = 1;
 346         err = ceph_mdsc_do_request(mdsc, NULL, req);
 347         if (err) {
 348                 ceph_mdsc_put_request(req);
 349                 return ERR_PTR(err);
 350         }
 351
 352         inode = req->r_target_inode;
 353         if (inode)
 354                 ihold(inode);
 355         ceph_mdsc_put_request(req);
 356         if (!inode)
 357                 return ERR_PTR(-ENOENT);
 358
 359         return d_obtain_alias(inode);
 360 }
 361
 362 static struct dentry *ceph_get_parent(struct dentry *child)
 363 {
 364         struct inode *inode = d_inode(child);
 365         struct dentry *dn;
 366
 367         if (ceph_snap(inode) != CEPH_NOSNAP) {
 368                 struct inode* dir;
 369                 bool unlinked = false;
 370                 /* do not support non-directory */
 371                 if (!d_is_dir(child)) {
 372                         dn = ERR_PTR(-EINVAL);
 373                         goto out;
 374                 }
 375                 dir = __lookup_inode(inode->i_sb, ceph_ino(inode));
 376                 if (IS_ERR(dir)) {
 377                         dn = ERR_CAST(dir);
 378                         goto out;
 379                 }
 380                 /* There can be multiple paths to access snapped inode.
 381                  * For simplicity, treat snapdir of head inode as parent */
 382                 if (ceph_snap(inode) != CEPH_SNAPDIR) {
 383                         struct inode *snapdir = ceph_get_snapdir(dir);
 384                         if (dir->i_nlink == 0)
 385                                 unlinked = true;
 386                         iput(dir);
 387                         if (IS_ERR(snapdir)) {
 388                                 dn = ERR_CAST(snapdir);
 389                                 goto out;
 390                         }
 391                         dir = snapdir;
 392                 }
 393                 /* If directory has already been deleted, futher get_parent
 394                  * will fail. Do not mark snapdir dentry as disconnected,
 395                  * this prevent exportfs from doing futher get_parent. */
 396                 if (unlinked)
 397                         dn = d_obtain_root(dir);
 398                 else
 399                         dn = d_obtain_alias(dir);
 400         } else {
 401                 dn = __get_parent(child->d_sb, child, 0);
 402         }
 403 out:
 404         dout("get_parent %p ino %llx.%llx err=%ld\n",
 405              child, ceph_vinop(inode), (long)PTR_ERR_OR_ZERO(dn));
 406         return dn;
 407 }
 408
 409 /*
 410  * convert regular fh to parent
 411  */
 412 static struct dentry *ceph_fh_to_parent(struct super_block *sb,
 413                                         struct fid *fid,
 414                                         int fh_len, int fh_type)
 415 {
 416         struct ceph_nfs_confh *cfh = (void *)fid->raw;
 417         struct dentry *dentry;
 418
 419         if (fh_type == FILEID_BTRFS_WITH_PARENT) {
 420                 struct ceph_nfs_snapfh *sfh = (void *)fid->raw;
 421                 return __snapfh_to_dentry(sb, sfh, true);
 422         }
 423
 424         if (fh_type != FILEID_INO32_GEN_PARENT)
 425                 return NULL;
 426         if (fh_len < sizeof(*cfh) / 4)
 427                 return NULL;
 428
 429         dout("fh_to_parent %llx\n", cfh->parent_ino);
 430         dentry = __get_parent(sb, NULL, cfh->ino);
 431         if (unlikely(dentry == ERR_PTR(-ENOENT)))
 432                 dentry = __fh_to_dentry(sb, cfh->parent_ino);
 433         return dentry;
 434 }
 435
 436 static int __get_snap_name(struct dentry *parent, char *name,
 437                            struct dentry *child)
 438 {
 439         struct inode *inode = d_inode(child);
 440         struct inode *dir = d_inode(parent);
 441         struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
 442         struct ceph_mds_request *req = NULL;
 443         char *last_name = NULL;
 444         unsigned next_offset = 2;
 445         int err = -EINVAL;
 446
 447         if (ceph_ino(inode) != ceph_ino(dir))
 448                 goto out;
 449         if (ceph_snap(inode) == CEPH_SNAPDIR) {
 450                 if (ceph_snap(dir) == CEPH_NOSNAP) {
 451                         strcpy(name, fsc->mount_options->snapdir_name);
 452                         err = 0;
 453                 }
 454                 goto out;
 455         }
 456         if (ceph_snap(dir) != CEPH_SNAPDIR)
 457                 goto out;
 458
 459         while (1) {
 460                 struct ceph_mds_reply_info_parsed *rinfo;
 461                 struct ceph_mds_reply_dir_entry *rde;
 462                 int i;
 463
 464                 req = ceph_mdsc_create_request(fsc->mdsc, CEPH_MDS_OP_LSSNAP,
 465                                                USE_AUTH_MDS);
 466                 if (IS_ERR(req)) {
 467                         err = PTR_ERR(req);
 468                         req = NULL;
 469                         goto out;
 470                 }
 471                 err = ceph_alloc_readdir_reply_buffer(req, inode);
 472                 if (err)
 473                         goto out;
 474
 475                 req->r_direct_mode = USE_AUTH_MDS;
 476                 req->r_readdir_offset = next_offset;
 477                 req->r_args.readdir.flags =
 478                                 cpu_to_le16(CEPH_READDIR_REPLY_BITFLAGS);
 479                 if (last_name) {
 480                         req->r_path2 = last_name;
 481                         last_name = NULL;
 482                 }
 483
 484                 req->r_inode = dir;
 485                 ihold(dir);
 486                 req->r_dentry = dget(parent);
 487
 488                 inode_lock(dir);
 489                 err = ceph_mdsc_do_request(fsc->mdsc, NULL, req);
 490                 inode_unlock(dir);
 491
 492                 if (err < 0)
 493                         goto out;
 494
 495                 rinfo = &req->r_reply_info;
 496                 for (i = 0; i < rinfo->dir_nr; i++) {
 497                         rde = rinfo->dir_entries + i;
 498                         BUG_ON(!rde->inode.in);
 499                         if (ceph_snap(inode) ==
 500                             le64_to_cpu(rde->inode.in->snapid)) {
 501                                 memcpy(name, rde->name, rde->name_len);
 502                                 name[rde->name_len] = '\0';
 503                                 err = 0;
 504                                 goto out;
 505                         }
 506                 }
 507
 508                 if (rinfo->dir_end)
 509                         break;
 510
 511                 BUG_ON(rinfo->dir_nr <= 0);
 512                 rde = rinfo->dir_entries + (rinfo->dir_nr - 1);
 513                 next_offset += rinfo->dir_nr;
 514                 last_name = kstrndup(rde->name, rde->name_len, GFP_KERNEL);
 515                 if (!last_name) {
 516                         err = -ENOMEM;
 517                         goto out;
 518                 }
 519
 520                 ceph_mdsc_put_request(req);
 521                 req = NULL;
 522         }
 523         err = -ENOENT;
 524 out:
 525         if (req)
 526                 ceph_mdsc_put_request(req);
 527         kfree(last_name);
 528         dout("get_snap_name %p ino %llx.%llx err=%d\n",
 529              child, ceph_vinop(inode), err);
 530         return err;
 531 }
 532
 533 static int ceph_get_name(struct dentry *parent, char *name,
 534                          struct dentry *child)
 535 {
 536         struct ceph_mds_client *mdsc;
 537         struct ceph_mds_request *req;
 538         struct inode *inode = d_inode(child);
 539         int err;
 540
 541         if (ceph_snap(inode) != CEPH_NOSNAP)
 542                 return __get_snap_name(parent, name, child);
 543
 544         mdsc = ceph_inode_to_client(inode)->mdsc;
 545         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPNAME,
 546                                        USE_ANY_MDS);
 547         if (IS_ERR(req))
 548                 return PTR_ERR(req);
 549
 550         inode_lock(d_inode(parent));
 551
 552         req->r_inode = inode;
 553         ihold(inode);
 554         req->r_ino2 = ceph_vino(d_inode(parent));
 555         req->r_parent = d_inode(parent);
 556         ihold(req->r_parent);
 557         set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags);
 558         req->r_num_caps = 2;
 559         err = ceph_mdsc_do_request(mdsc, NULL, req);
 560
 561         inode_unlock(d_inode(parent));
 562
 563         if (!err) {
 564                 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
 565                 memcpy(name, rinfo->dname, rinfo->dname_len);
 566                 name[rinfo->dname_len] = 0;
 567                 dout("get_name %p ino %llx.%llx name %s\n",
 568                      child, ceph_vinop(inode), name);
 569         } else {
 570                 dout("get_name %p ino %llx.%llx err %d\n",
 571                      child, ceph_vinop(inode), err);
 572         }
 573
 574         ceph_mdsc_put_request(req);
 575         return err;
 576 }
 577
 578 const struct export_operations ceph_export_ops = {
 579         .encode_fh = ceph_encode_fh,
 580         .fh_to_dentry = ceph_fh_to_dentry,
 581         .fh_to_parent = ceph_fh_to_parent,
 582         .get_parent = ceph_get_parent,
 583         .get_name = ceph_get_name,
 584 };