sys/vfs/hammer2/hammer2_ioctl.c

   1 /*
   2  * Copyright (c) 2011-2018 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@dragonflybsd.org>
   6  * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  * 3. Neither the name of The DragonFly Project nor the names of its
  19  *    contributors may be used to endorse or promote products derived
  20  *    from this software without specific, prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 /*
  36  * Ioctl Functions.
  37  *
  38  * WARNING! The ioctl functions which manipulate the connection state need
  39  *          to be able to run without deadlock on the volume's chain lock.
  40  *          Most of these functions use a separate lock.
  41  */
  42
  43 #include "hammer2.h"
  44
  45 static int hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data);
  46 static int hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data);
  47 static int hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data);
  48 static int hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data);
  49 static int hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data);
  50 static int hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data);
  51 static int hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data);
  52 static int hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data);
  53 static int hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data);
  54 static int hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data);
  55 static int hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data);
  56 static int hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data);
  57 static int hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data);
  58 static int hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data);
  59 static int hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data);
  60 static int hammer2_ioctl_debug_dump(hammer2_inode_t *ip, u_int flags);
  61 //static int hammer2_ioctl_inode_comp_set(hammer2_inode_t *ip, void *data);
  62 //static int hammer2_ioctl_inode_comp_rec_set(hammer2_inode_t *ip, void *data);
  63 //static int hammer2_ioctl_inode_comp_rec_set2(hammer2_inode_t *ip, void *data);
  64 static int hammer2_ioctl_bulkfree_scan(hammer2_inode_t *ip, void *data);
  65 static int hammer2_ioctl_destroy(hammer2_inode_t *ip, void *data);
  66
  67 int
  68 hammer2_ioctl(hammer2_inode_t *ip, u_long com, void *data, int fflag,
  69               struct ucred *cred)
  70 {
  71         int error;
  72
  73         /*
  74          * Standard root cred checks, will be selectively ignored below
  75          * for ioctls that do not require root creds.
  76          */
  77         error = priv_check_cred(cred, PRIV_HAMMER_IOCTL, 0);
  78
  79         switch(com) {
  80         case HAMMER2IOC_VERSION_GET:
  81                 error = hammer2_ioctl_version_get(ip, data);
  82                 break;
  83         case HAMMER2IOC_RECLUSTER:
  84                 if (error == 0)
  85                         error = hammer2_ioctl_recluster(ip, data);
  86                 break;
  87         case HAMMER2IOC_REMOTE_SCAN:
  88                 if (error == 0)
  89                         error = hammer2_ioctl_remote_scan(ip, data);
  90                 break;
  91         case HAMMER2IOC_REMOTE_ADD:
  92                 if (error == 0)
  93                         error = hammer2_ioctl_remote_add(ip, data);
  94                 break;
  95         case HAMMER2IOC_REMOTE_DEL:
  96                 if (error == 0)
  97                         error = hammer2_ioctl_remote_del(ip, data);
  98                 break;
  99         case HAMMER2IOC_REMOTE_REP:
 100                 if (error == 0)
 101                         error = hammer2_ioctl_remote_rep(ip, data);
 102                 break;
 103         case HAMMER2IOC_SOCKET_GET:
 104                 if (error == 0)
 105                         error = hammer2_ioctl_socket_get(ip, data);
 106                 break;
 107         case HAMMER2IOC_SOCKET_SET:
 108                 if (error == 0)
 109                         error = hammer2_ioctl_socket_set(ip, data);
 110                 break;
 111         case HAMMER2IOC_PFS_GET:
 112                 if (error == 0)
 113                         error = hammer2_ioctl_pfs_get(ip, data);
 114                 break;
 115         case HAMMER2IOC_PFS_LOOKUP:
 116                 if (error == 0)
 117                         error = hammer2_ioctl_pfs_lookup(ip, data);
 118                 break;
 119         case HAMMER2IOC_PFS_CREATE:
 120                 if (error == 0)
 121                         error = hammer2_ioctl_pfs_create(ip, data);
 122                 break;
 123         case HAMMER2IOC_PFS_DELETE:
 124                 if (error == 0)
 125                         error = hammer2_ioctl_pfs_delete(ip, data);
 126                 break;
 127         case HAMMER2IOC_PFS_SNAPSHOT:
 128                 if (error == 0)
 129                         error = hammer2_ioctl_pfs_snapshot(ip, data);
 130                 break;
 131         case HAMMER2IOC_INODE_GET:
 132                 error = hammer2_ioctl_inode_get(ip, data);
 133                 break;
 134         case HAMMER2IOC_INODE_SET:
 135                 if (error == 0)
 136                         error = hammer2_ioctl_inode_set(ip, data);
 137                 break;
 138         case HAMMER2IOC_BULKFREE_SCAN:
 139                 error = hammer2_ioctl_bulkfree_scan(ip, data);
 140                 break;
 141         case HAMMER2IOC_BULKFREE_ASYNC:
 142                 error = hammer2_ioctl_bulkfree_scan(ip, NULL);
 143                 break;
 144         /*case HAMMER2IOC_INODE_COMP_SET:
 145                 error = hammer2_ioctl_inode_comp_set(ip, data);
 146                 break;
 147         case HAMMER2IOC_INODE_COMP_REC_SET:
 148                 error = hammer2_ioctl_inode_comp_rec_set(ip, data);
 149                 break;
 150         case HAMMER2IOC_INODE_COMP_REC_SET2:
 151                 error = hammer2_ioctl_inode_comp_rec_set2(ip, data);
 152                 break;*/
 153         case HAMMER2IOC_DESTROY:
 154                 if (error == 0)
 155                         error = hammer2_ioctl_destroy(ip, data);
 156                 break;
 157         case HAMMER2IOC_DEBUG_DUMP:
 158                 error = hammer2_ioctl_debug_dump(ip, *(u_int *)data);
 159                 break;
 160         default:
 161                 error = EOPNOTSUPP;
 162                 break;
 163         }
 164         return (error);
 165 }
 166
 167 /*
 168  * Retrieve version and basic info
 169  */
 170 static int
 171 hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data)
 172 {
 173         hammer2_ioc_version_t *version = data;
 174         hammer2_dev_t *hmp;
 175
 176         hmp = ip->pmp->pfs_hmps[0];
 177         if (hmp)
 178                 version->version = hmp->voldata.version;
 179         else
 180                 version->version = -1;
 181         return 0;
 182 }
 183
 184 static int
 185 hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data)
 186 {
 187         hammer2_ioc_recluster_t *recl = data;
 188         struct vnode *vproot;
 189         struct file *fp;
 190         hammer2_cluster_t *cluster;
 191         int error;
 192
 193         fp = holdfp(curthread, recl->fd, -1);
 194         if (fp) {
 195                 error = VFS_ROOT(ip->pmp->mp, &vproot);
 196                 if (error == 0) {
 197                         cluster = &ip->pmp->iroot->cluster;
 198                         kprintf("reconnect to cluster: nc=%d focus=%p\n",
 199                                 cluster->nchains, cluster->focus);
 200                         if (cluster->nchains != 1 || cluster->focus == NULL) {
 201                                 kprintf("not a local device mount\n");
 202                                 error = EINVAL;
 203                         } else {
 204                                 hammer2_cluster_reconnect(cluster->focus->hmp,
 205                                                           fp);
 206                                 kprintf("ok\n");
 207                                 error = 0;
 208                         }
 209                         vput(vproot);
 210                 }
 211         } else {
 212                 error = EINVAL;
 213         }
 214         return error;
 215 }
 216
 217 /*
 218  * Retrieve information about a remote
 219  */
 220 static int
 221 hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data)
 222 {
 223         hammer2_dev_t *hmp;
 224         hammer2_ioc_remote_t *remote = data;
 225         int copyid = remote->copyid;
 226
 227         hmp = ip->pmp->pfs_hmps[0];
 228         if (hmp == NULL)
 229                 return (EINVAL);
 230
 231         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
 232                 return (EINVAL);
 233
 234         hammer2_voldata_lock(hmp);
 235         remote->copy1 = hmp->voldata.copyinfo[copyid];
 236         hammer2_voldata_unlock(hmp);
 237
 238         /*
 239          * Adjust nextid (GET only)
 240          */
 241         while (++copyid < HAMMER2_COPYID_COUNT &&
 242                hmp->voldata.copyinfo[copyid].copyid == 0) {
 243                 ;
 244         }
 245         if (copyid == HAMMER2_COPYID_COUNT)
 246                 remote->nextid = -1;
 247         else
 248                 remote->nextid = copyid;
 249
 250         return(0);
 251 }
 252
 253 /*
 254  * Add new remote entry
 255  */
 256 static int
 257 hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data)
 258 {
 259         hammer2_ioc_remote_t *remote = data;
 260         hammer2_pfs_t *pmp = ip->pmp;
 261         hammer2_dev_t *hmp;
 262         int copyid = remote->copyid;
 263         int error = 0;
 264
 265         hmp = pmp->pfs_hmps[0];
 266         if (hmp == NULL)
 267                 return (EINVAL);
 268         if (copyid >= HAMMER2_COPYID_COUNT)
 269                 return (EINVAL);
 270
 271         hammer2_voldata_lock(hmp);
 272         if (copyid < 0) {
 273                 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
 274                         if (hmp->voldata.copyinfo[copyid].copyid == 0)
 275                                 break;
 276                 }
 277                 if (copyid == HAMMER2_COPYID_COUNT) {
 278                         error = ENOSPC;
 279                         goto failed;
 280                 }
 281         }
 282         hammer2_voldata_modify(hmp);
 283         remote->copy1.copyid = copyid;
 284         hmp->voldata.copyinfo[copyid] = remote->copy1;
 285         hammer2_volconf_update(hmp, copyid);
 286 failed:
 287         hammer2_voldata_unlock(hmp);
 288         return (error);
 289 }
 290
 291 /*
 292  * Delete existing remote entry
 293  */
 294 static int
 295 hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data)
 296 {
 297         hammer2_ioc_remote_t *remote = data;
 298         hammer2_pfs_t *pmp = ip->pmp;
 299         hammer2_dev_t *hmp;
 300         int copyid = remote->copyid;
 301         int error = 0;
 302
 303         hmp = pmp->pfs_hmps[0];
 304         if (hmp == NULL)
 305                 return (EINVAL);
 306         if (copyid >= HAMMER2_COPYID_COUNT)
 307                 return (EINVAL);
 308         remote->copy1.path[sizeof(remote->copy1.path) - 1] = 0;
 309         hammer2_voldata_lock(hmp);
 310         if (copyid < 0) {
 311                 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
 312                         if (hmp->voldata.copyinfo[copyid].copyid == 0)
 313                                 continue;
 314                         if (strcmp(remote->copy1.path,
 315                             hmp->voldata.copyinfo[copyid].path) == 0) {
 316                                 break;
 317                         }
 318                 }
 319                 if (copyid == HAMMER2_COPYID_COUNT) {
 320                         error = ENOENT;
 321                         goto failed;
 322                 }
 323         }
 324         hammer2_voldata_modify(hmp);
 325         hmp->voldata.copyinfo[copyid].copyid = 0;
 326         hammer2_volconf_update(hmp, copyid);
 327 failed:
 328         hammer2_voldata_unlock(hmp);
 329         return (error);
 330 }
 331
 332 /*
 333  * Replace existing remote entry
 334  */
 335 static int
 336 hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data)
 337 {
 338         hammer2_ioc_remote_t *remote = data;
 339         hammer2_dev_t *hmp;
 340         int copyid = remote->copyid;
 341
 342         hmp = ip->pmp->pfs_hmps[0];
 343         if (hmp == NULL)
 344                 return (EINVAL);
 345         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
 346                 return (EINVAL);
 347
 348         hammer2_voldata_lock(hmp);
 349         hammer2_voldata_modify(hmp);
 350         /*hammer2_volconf_update(hmp, copyid);*/
 351         hammer2_voldata_unlock(hmp);
 352
 353         return(0);
 354 }
 355
 356 /*
 357  * Retrieve communications socket
 358  */
 359 static int
 360 hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data)
 361 {
 362         return (EOPNOTSUPP);
 363 }
 364
 365 /*
 366  * Set communications socket for connection
 367  */
 368 static int
 369 hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data)
 370 {
 371         hammer2_ioc_remote_t *remote = data;
 372         hammer2_dev_t *hmp;
 373         int copyid = remote->copyid;
 374
 375         hmp = ip->pmp->pfs_hmps[0];
 376         if (hmp == NULL)
 377                 return (EINVAL);
 378         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
 379                 return (EINVAL);
 380
 381         hammer2_voldata_lock(hmp);
 382         hammer2_voldata_unlock(hmp);
 383
 384         return(0);
 385 }
 386
 387 /*
 388  * Used to scan and retrieve PFS information.  PFS's are directories under
 389  * the super-root.
 390  *
 391  * To scan PFSs pass name_key=0.  The function will scan for the next
 392  * PFS and set all fields, as well as set name_next to the next key.
 393  * When no PFSs remain, name_next is set to (hammer2_key_t)-1.
 394  *
 395  * To retrieve a particular PFS by key, specify the key but note that
 396  * the ioctl will return the lowest key >= specified_key, so the caller
 397  * must verify the key.
 398  *
 399  * To retrieve the PFS associated with the file descriptor, pass
 400  * name_key set to (hammer2_key_t)-1.
 401  */
 402 static int
 403 hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data)
 404 {
 405         const hammer2_inode_data_t *ripdata;
 406         hammer2_dev_t *hmp;
 407         hammer2_ioc_pfs_t *pfs;
 408         hammer2_chain_t *parent;
 409         hammer2_chain_t *chain;
 410         hammer2_key_t key_next;
 411         hammer2_key_t save_key;
 412         int error;
 413
 414         hmp = ip->pmp->pfs_hmps[0];
 415         if (hmp == NULL)
 416                 return (EINVAL);
 417
 418         pfs = data;
 419         save_key = pfs->name_key;
 420         error = 0;
 421
 422         /*
 423          * Setup
 424          */
 425         if (save_key == (hammer2_key_t)-1) {
 426                 hammer2_inode_lock(ip->pmp->iroot, 0);
 427                 parent = NULL;
 428                 chain = hammer2_inode_chain(ip->pmp->iroot, 0,
 429                                             HAMMER2_RESOLVE_ALWAYS |
 430                                             HAMMER2_RESOLVE_SHARED);
 431         } else {
 432                 hammer2_inode_lock(hmp->spmp->iroot, 0);
 433                 parent = hammer2_inode_chain(hmp->spmp->iroot, 0,
 434                                             HAMMER2_RESOLVE_ALWAYS |
 435                                             HAMMER2_RESOLVE_SHARED);
 436                 chain = hammer2_chain_lookup(&parent, &key_next,
 437                                             pfs->name_key, HAMMER2_KEY_MAX,
 438                                             &error,
 439                                             HAMMER2_LOOKUP_SHARED);
 440         }
 441
 442         /*
 443          * Locate next PFS
 444          */
 445         while (chain) {
 446                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE)
 447                         break;
 448                 if (parent == NULL) {
 449                         hammer2_chain_unlock(chain);
 450                         hammer2_chain_drop(chain);
 451                         chain = NULL;
 452                         break;
 453                 }
 454                 chain = hammer2_chain_next(&parent, chain, &key_next,
 455                                             key_next, HAMMER2_KEY_MAX,
 456                                             &error,
 457                                             HAMMER2_LOOKUP_SHARED);
 458         }
 459         error = hammer2_error_to_errno(error);
 460
 461         /*
 462          * Load the data being returned by the ioctl.
 463          */
 464         if (chain && chain->error == 0) {
 465                 ripdata = &chain->data->ipdata;
 466                 pfs->name_key = ripdata->meta.name_key;
 467                 pfs->pfs_type = ripdata->meta.pfs_type;
 468                 pfs->pfs_subtype = ripdata->meta.pfs_subtype;
 469                 pfs->pfs_clid = ripdata->meta.pfs_clid;
 470                 pfs->pfs_fsid = ripdata->meta.pfs_fsid;
 471                 KKASSERT(ripdata->meta.name_len < sizeof(pfs->name));
 472                 bcopy(ripdata->filename, pfs->name, ripdata->meta.name_len);
 473                 pfs->name[ripdata->meta.name_len] = 0;
 474                 ripdata = NULL; /* safety */
 475
 476                 /*
 477                  * Calculate name_next, if any.  We are only accessing
 478                  * chain->bref so we can ignore chain->error (if the key
 479                  * is used later it will error then).
 480                  */
 481                 if (parent == NULL) {
 482                         pfs->name_next = (hammer2_key_t)-1;
 483                 } else {
 484                         chain = hammer2_chain_next(&parent, chain, &key_next,
 485                                                     key_next, HAMMER2_KEY_MAX,
 486                                                     &error,
 487                                                     HAMMER2_LOOKUP_SHARED);
 488                         if (chain)
 489                                 pfs->name_next = chain->bref.key;
 490                         else
 491                                 pfs->name_next = (hammer2_key_t)-1;
 492                 }
 493         } else {
 494                 pfs->name_next = (hammer2_key_t)-1;
 495                 error = ENOENT;
 496         }
 497
 498         /*
 499          * Cleanup
 500          */
 501         if (chain) {
 502                 hammer2_chain_unlock(chain);
 503                 hammer2_chain_drop(chain);
 504         }
 505         if (parent) {
 506                 hammer2_chain_unlock(parent);
 507                 hammer2_chain_drop(parent);
 508         }
 509         if (save_key == (hammer2_key_t)-1) {
 510                 hammer2_inode_unlock(ip->pmp->iroot);
 511         } else {
 512                 hammer2_inode_unlock(hmp->spmp->iroot);
 513         }
 514
 515         return (error);
 516 }
 517
 518 /*
 519  * Find a specific PFS by name
 520  */
 521 static int
 522 hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data)
 523 {
 524         const hammer2_inode_data_t *ripdata;
 525         hammer2_dev_t *hmp;
 526         hammer2_ioc_pfs_t *pfs;
 527         hammer2_chain_t *parent;
 528         hammer2_chain_t *chain;
 529         hammer2_key_t key_next;
 530         hammer2_key_t lhc;
 531         int error;
 532         size_t len;
 533
 534         hmp = ip->pmp->pfs_hmps[0];
 535         if (hmp == NULL)
 536                 return (EINVAL);
 537
 538         pfs = data;
 539         error = 0;
 540
 541         hammer2_inode_lock(hmp->spmp->iroot, HAMMER2_RESOLVE_SHARED);
 542         parent = hammer2_inode_chain(hmp->spmp->iroot, 0,
 543                                      HAMMER2_RESOLVE_ALWAYS |
 544                                      HAMMER2_RESOLVE_SHARED);
 545
 546         pfs->name[sizeof(pfs->name) - 1] = 0;
 547         len = strlen(pfs->name);
 548         lhc = hammer2_dirhash(pfs->name, len);
 549
 550         chain = hammer2_chain_lookup(&parent, &key_next,
 551                                          lhc, lhc + HAMMER2_DIRHASH_LOMASK,
 552                                          &error, HAMMER2_LOOKUP_SHARED);
 553         while (chain) {
 554                 if (hammer2_chain_dirent_test(chain, pfs->name, len))
 555                         break;
 556                 chain = hammer2_chain_next(&parent, chain, &key_next,
 557                                            key_next,
 558                                            lhc + HAMMER2_DIRHASH_LOMASK,
 559                                            &error, HAMMER2_LOOKUP_SHARED);
 560         }
 561         error = hammer2_error_to_errno(error);
 562
 563         /*
 564          * Load the data being returned by the ioctl.
 565          */
 566         if (chain && chain->error == 0) {
 567                 KKASSERT(chain->bref.type == HAMMER2_BREF_TYPE_INODE);
 568                 ripdata = &chain->data->ipdata;
 569                 pfs->name_key = ripdata->meta.name_key;
 570                 pfs->pfs_type = ripdata->meta.pfs_type;
 571                 pfs->pfs_subtype = ripdata->meta.pfs_subtype;
 572                 pfs->pfs_clid = ripdata->meta.pfs_clid;
 573                 pfs->pfs_fsid = ripdata->meta.pfs_fsid;
 574                 ripdata = NULL;
 575
 576                 hammer2_chain_unlock(chain);
 577                 hammer2_chain_drop(chain);
 578         } else if (error == 0) {
 579                 error = ENOENT;
 580         }
 581         if (parent) {
 582                 hammer2_chain_unlock(parent);
 583                 hammer2_chain_drop(parent);
 584         }
 585         hammer2_inode_unlock(hmp->spmp->iroot);
 586
 587         return (error);
 588 }
 589
 590 /*
 591  * Create a new PFS under the super-root
 592  */
 593 static int
 594 hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data)
 595 {
 596         hammer2_inode_data_t *nipdata;
 597         hammer2_chain_t *nchain;
 598         hammer2_dev_t *hmp;
 599         hammer2_dev_t *force_local;
 600         hammer2_ioc_pfs_t *pfs;
 601         hammer2_inode_t *nip;
 602         hammer2_tid_t mtid;
 603         int error;
 604
 605         hmp = ip->pmp->pfs_hmps[0];     /* XXX */
 606         if (hmp == NULL)
 607                 return (EINVAL);
 608
 609         pfs = data;
 610         nip = NULL;
 611
 612         if (pfs->name[0] == 0)
 613                 return(EINVAL);
 614         pfs->name[sizeof(pfs->name) - 1] = 0;   /* ensure 0-termination */
 615
 616         if (hammer2_ioctl_pfs_lookup(ip, pfs) == 0)
 617                 return(EEXIST);
 618
 619         hammer2_trans_init(hmp->spmp, 0);
 620         mtid = hammer2_trans_sub(hmp->spmp);
 621         nip = hammer2_inode_create(hmp->spmp->iroot, hmp->spmp->iroot,
 622                                    NULL, NULL,
 623                                    pfs->name, strlen(pfs->name), 0,
 624                                    1, HAMMER2_OBJTYPE_DIRECTORY, 0,
 625                                    HAMMER2_INSERT_PFSROOT, &error);
 626         if (error == 0) {
 627                 nip->flags |= HAMMER2_INODE_NOSIDEQ;
 628                 hammer2_inode_modify(nip);
 629                 nchain = hammer2_inode_chain(nip, 0, HAMMER2_RESOLVE_ALWAYS);
 630                 error = hammer2_chain_modify(nchain, mtid, 0, 0);
 631                 KKASSERT(error == 0);
 632                 nipdata = &nchain->data->ipdata;
 633
 634                 nip->meta.pfs_type = pfs->pfs_type;
 635                 nip->meta.pfs_subtype = pfs->pfs_subtype;
 636                 nip->meta.pfs_clid = pfs->pfs_clid;
 637                 nip->meta.pfs_fsid = pfs->pfs_fsid;
 638                 nip->meta.op_flags |= HAMMER2_OPFLAG_PFSROOT;
 639
 640                 /*
 641                  * Set default compression and check algorithm.  This
 642                  * can be changed later.
 643                  *
 644                  * Do not allow compression on PFS's with the special name
 645                  * "boot", the boot loader can't decompress (yet).
 646                  */
 647                 nip->meta.comp_algo =
 648                         HAMMER2_ENC_ALGO(HAMMER2_COMP_NEWFS_DEFAULT);
 649                 nip->meta.check_algo =
 650                         HAMMER2_ENC_ALGO( HAMMER2_CHECK_XXHASH64);
 651
 652                 if (strcasecmp(pfs->name, "boot") == 0) {
 653                         nip->meta.comp_algo =
 654                                 HAMMER2_ENC_ALGO(HAMMER2_COMP_AUTOZERO);
 655                 }
 656
 657                 /*
 658                  * Super-root isn't mounted, fsync it
 659                  */
 660                 hammer2_chain_unlock(nchain);
 661                 hammer2_inode_ref(nip);
 662                 hammer2_inode_unlock(nip);
 663                 hammer2_inode_chain_sync(nip);
 664                 hammer2_inode_chain_flush(nip);
 665                 KKASSERT(nip->refs == 1);
 666                 hammer2_inode_drop(nip);
 667
 668                 /*
 669                  * We still have a ref on the chain, relock and associate
 670                  * with an appropriate PFS.
 671                  */
 672                 force_local = (hmp->hflags & HMNT2_LOCAL) ? hmp : NULL;
 673
 674                 hammer2_chain_lock(nchain, HAMMER2_RESOLVE_ALWAYS);
 675                 nipdata = &nchain->data->ipdata;
 676                 kprintf("ADD LOCAL PFS (IOCTL): %s\n", nipdata->filename);
 677                 hammer2_pfsalloc(nchain, nipdata,
 678                                  nchain->bref.modify_tid, force_local);
 679
 680                 hammer2_chain_unlock(nchain);
 681                 hammer2_chain_drop(nchain);
 682
 683         }
 684         hammer2_trans_done(hmp->spmp, 1);
 685
 686         return (error);
 687 }
 688
 689 /*
 690  * Destroy an existing PFS under the super-root
 691  */
 692 static int
 693 hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data)
 694 {
 695         hammer2_ioc_pfs_t *pfs = data;
 696         hammer2_dev_t   *hmp;
 697         hammer2_pfs_t   *spmp;
 698         hammer2_pfs_t   *pmp;
 699         hammer2_xop_unlink_t *xop;
 700         hammer2_inode_t *dip;
 701         hammer2_inode_t *iroot;
 702         int error;
 703         int i;
 704
 705         /*
 706          * The PFS should be probed, so we should be able to
 707          * locate it.  We only delete the PFS from the
 708          * specific H2 block device (hmp), not all of
 709          * them.  We must remove the PFS from the cluster
 710          * before we can destroy it.
 711          */
 712         hmp = ip->pmp->pfs_hmps[0];
 713         if (hmp == NULL)
 714                 return (EINVAL);
 715
 716         pfs->name[sizeof(pfs->name) - 1] = 0;   /* ensure termination */
 717
 718         lockmgr(&hammer2_mntlk, LK_EXCLUSIVE);
 719
 720         TAILQ_FOREACH(pmp, &hammer2_pfslist, mntentry) {
 721                 for (i = 0; i < HAMMER2_MAXCLUSTER; ++i) {
 722                         if (pmp->pfs_hmps[i] != hmp)
 723                                 continue;
 724                         if (pmp->pfs_names[i] &&
 725                             strcmp(pmp->pfs_names[i], pfs->name) == 0) {
 726                                 break;
 727                         }
 728                 }
 729                 if (i != HAMMER2_MAXCLUSTER)
 730                         break;
 731         }
 732
 733         if (pmp == NULL) {
 734                 lockmgr(&hammer2_mntlk, LK_RELEASE);
 735                 return ENOENT;
 736         }
 737
 738         /*
 739          * Ok, we found the pmp and we have the index.  Permanently remove
 740          * the PFS from the cluster
 741          */
 742         iroot = pmp->iroot;
 743         kprintf("FOUND PFS %s CLINDEX %d\n", pfs->name, i);
 744         hammer2_pfsdealloc(pmp, i, 1);
 745
 746         lockmgr(&hammer2_mntlk, LK_RELEASE);
 747
 748         /*
 749          * Now destroy the PFS under its device using the per-device
 750          * super-root.
 751          */
 752         spmp = hmp->spmp;
 753         dip = spmp->iroot;
 754         hammer2_trans_init(spmp, 0);
 755         hammer2_inode_lock(dip, 0);
 756
 757         xop = hammer2_xop_alloc(dip, HAMMER2_XOP_MODIFYING);
 758         hammer2_xop_setname(&xop->head, pfs->name, strlen(pfs->name));
 759         xop->isdir = 2;
 760         xop->dopermanent = H2DOPERM_PERMANENT | H2DOPERM_FORCE;
 761         hammer2_xop_start(&xop->head, hammer2_xop_unlink);
 762
 763         error = hammer2_xop_collect(&xop->head, 0);
 764
 765         hammer2_inode_unlock(dip);
 766
 767 #if 0
 768         if (error == 0) {
 769                 ip = hammer2_inode_get(dip->pmp, dip, &xop->head, -1);
 770                 hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
 771                 if (ip) {
 772                         hammer2_inode_unlink_finisher(ip, 0);
 773                         hammer2_inode_unlock(ip);
 774                 }
 775         } else {
 776                 hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
 777         }
 778 #endif
 779         hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
 780
 781         hammer2_trans_done(spmp, 1);
 782
 783         return (hammer2_error_to_errno(error));
 784 }
 785
 786 static int
 787 hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data)
 788 {
 789         const hammer2_inode_data_t *ripdata;
 790         hammer2_ioc_pfs_t *pfs = data;
 791         hammer2_dev_t   *hmp;
 792         hammer2_pfs_t   *pmp;
 793         hammer2_chain_t *chain;
 794         hammer2_inode_t *nip;
 795         hammer2_tid_t   mtid;
 796         size_t name_len;
 797         hammer2_key_t lhc;
 798         struct vattr vat;
 799         int error;
 800 #if 0
 801         uuid_t opfs_clid;
 802 #endif
 803
 804         if (pfs->name[0] == 0)
 805                 return(EINVAL);
 806         if (pfs->name[sizeof(pfs->name)-1] != 0)
 807                 return(EINVAL);
 808
 809         pmp = ip->pmp;
 810         ip = pmp->iroot;
 811
 812         hmp = pmp->pfs_hmps[0];
 813         if (hmp == NULL)
 814                 return (EINVAL);
 815
 816         lockmgr(&hmp->bulklk, LK_EXCLUSIVE);
 817
 818         hammer2_vfs_sync(pmp->mp, MNT_WAIT);
 819
 820         hammer2_trans_init(pmp, HAMMER2_TRANS_ISFLUSH);
 821         mtid = hammer2_trans_sub(pmp);
 822         hammer2_inode_lock(ip, 0);
 823         hammer2_inode_modify(ip);
 824         ip->meta.pfs_lsnap_tid = mtid;
 825
 826         /* XXX cluster it! */
 827         chain = hammer2_inode_chain(ip, 0, HAMMER2_RESOLVE_ALWAYS);
 828
 829         name_len = strlen(pfs->name);
 830         lhc = hammer2_dirhash(pfs->name, name_len);
 831
 832         /*
 833          * Get the clid
 834          */
 835         ripdata = &chain->data->ipdata;
 836 #if 0
 837         opfs_clid = ripdata->meta.pfs_clid;
 838 #endif
 839         hmp = chain->hmp;
 840
 841         /*
 842          * Create the snapshot directory under the super-root
 843          *
 844          * Set PFS type, generate a unique filesystem id, and generate
 845          * a cluster id.  Use the same clid when snapshotting a PFS root,
 846          * which theoretically allows the snapshot to be used as part of
 847          * the same cluster (perhaps as a cache).
 848          *
 849          * Copy the (flushed) blockref array.  Theoretically we could use
 850          * chain_duplicate() but it becomes difficult to disentangle
 851          * the shared core so for now just brute-force it.
 852          */
 853         VATTR_NULL(&vat);
 854         vat.va_type = VDIR;
 855         vat.va_mode = 0755;
 856         hammer2_chain_unlock(chain);
 857         nip = hammer2_inode_create(hmp->spmp->iroot, hmp->spmp->iroot,
 858                                    &vat, proc0.p_ucred,
 859                                    pfs->name, name_len, 0,
 860                                    1, 0, 0,
 861                                    HAMMER2_INSERT_PFSROOT, &error);
 862         hammer2_chain_lock(chain, HAMMER2_RESOLVE_ALWAYS);
 863         ripdata = &chain->data->ipdata;
 864
 865         if (nip) {
 866                 hammer2_dev_t *force_local;
 867                 hammer2_chain_t *nchain;
 868                 hammer2_inode_data_t *wipdata;
 869                 hammer2_key_t   starting_inum;
 870
 871                 nip->flags |= HAMMER2_INODE_NOSIDEQ;
 872                 hammer2_inode_modify(nip);
 873                 nchain = hammer2_inode_chain(nip, 0, HAMMER2_RESOLVE_ALWAYS);
 874                 error = hammer2_chain_modify(nchain, mtid, 0, 0);
 875                 KKASSERT(error == 0);
 876                 wipdata = &nchain->data->ipdata;
 877
 878                 starting_inum = ip->pmp->inode_tid + 1;
 879                 nip->meta.pfs_inum = starting_inum;
 880                 nip->meta.pfs_type = HAMMER2_PFSTYPE_MASTER;
 881                 nip->meta.pfs_subtype = HAMMER2_PFSSUBTYPE_SNAPSHOT;
 882                 nip->meta.op_flags |= HAMMER2_OPFLAG_PFSROOT;
 883                 nchain->bref.embed.stats = chain->bref.embed.stats;
 884
 885                 kern_uuidgen(&nip->meta.pfs_fsid, 1);
 886
 887 #if 0
 888                 /*
 889                  * Give the snapshot its own private cluster id.  As a
 890                  * snapshot no further synchronization with the original
 891                  * cluster will be done.
 892                  */
 893                 if (chain->flags & HAMMER2_CHAIN_PFSBOUNDARY)
 894                         nip->meta.pfs_clid = opfs_clid;
 895                 else
 896                         kern_uuidgen(&nip->meta.pfs_clid, 1);
 897 #endif
 898                 kern_uuidgen(&nip->meta.pfs_clid, 1);
 899                 nchain->bref.flags |= HAMMER2_BREF_FLAG_PFSROOT;
 900
 901                 /* XXX hack blockset copy */
 902                 /* XXX doesn't work with real cluster */
 903                 wipdata->meta = nip->meta;
 904                 wipdata->u.blockset = ripdata->u.blockset;
 905
 906                 KKASSERT(wipdata == &nchain->data->ipdata);
 907
 908                 hammer2_chain_unlock(nchain);
 909                 hammer2_inode_ref(nip);
 910                 hammer2_inode_unlock(nip);
 911                 hammer2_inode_chain_sync(nip);
 912                 hammer2_inode_chain_flush(nip);
 913                 KKASSERT(nip->refs == 1);
 914                 hammer2_inode_drop(nip);
 915
 916                 force_local = (hmp->hflags & HMNT2_LOCAL) ? hmp : NULL;
 917
 918                 hammer2_chain_lock(nchain, HAMMER2_RESOLVE_ALWAYS);
 919                 wipdata = &nchain->data->ipdata;
 920                 kprintf("SNAPSHOT LOCAL PFS (IOCTL): %s\n", wipdata->filename);
 921                 hammer2_pfsalloc(nchain, wipdata, nchain->bref.modify_tid,
 922                                  force_local);
 923                 nchain->pmp->inode_tid = starting_inum;
 924
 925                 hammer2_chain_unlock(nchain);
 926                 hammer2_chain_drop(nchain);
 927         }
 928
 929         hammer2_chain_unlock(chain);
 930         hammer2_chain_drop(chain);
 931
 932         hammer2_inode_unlock(ip);
 933         hammer2_trans_done(pmp, 1);
 934
 935         lockmgr(&hmp->bulklk, LK_RELEASE);
 936
 937         return (hammer2_error_to_errno(error));
 938 }
 939
 940 /*
 941  * Retrieve the raw inode structure, non-inclusive of node-specific data.
 942  */
 943 static int
 944 hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data)
 945 {
 946         hammer2_ioc_inode_t *ino;
 947         hammer2_chain_t *chain;
 948         int error;
 949         int i;
 950
 951         ino = data;
 952         error = 0;
 953
 954         hammer2_inode_lock(ip, HAMMER2_RESOLVE_SHARED);
 955         ino->data_count = 0;
 956         ino->inode_count = 0;
 957         for (i = 0; i < ip->cluster.nchains; ++i) {
 958                 if ((chain = ip->cluster.array[i].chain) != NULL) {
 959                         if (ino->data_count <
 960                             chain->bref.embed.stats.data_count) {
 961                                 ino->data_count =
 962                                         chain->bref.embed.stats.data_count;
 963                         }
 964                         if (ino->inode_count <
 965                             chain->bref.embed.stats.inode_count) {
 966                                 ino->inode_count =
 967                                         chain->bref.embed.stats.inode_count;
 968                         }
 969                 }
 970         }
 971         bzero(&ino->ip_data, sizeof(ino->ip_data));
 972         ino->ip_data.meta = ip->meta;
 973         ino->kdata = ip;
 974         hammer2_inode_unlock(ip);
 975
 976         return hammer2_error_to_errno(error);
 977 }
 978
 979 /*
 980  * Set various parameters in an inode which cannot be set through
 981  * normal filesystem VNOPS.
 982  */
 983 static int
 984 hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data)
 985 {
 986         hammer2_ioc_inode_t *ino = data;
 987         int error = 0;
 988
 989         hammer2_trans_init(ip->pmp, 0);
 990         hammer2_inode_lock(ip, 0);
 991
 992         if ((ino->flags & HAMMER2IOC_INODE_FLAG_CHECK) &&
 993             ip->meta.check_algo != ino->ip_data.meta.check_algo) {
 994                 hammer2_inode_modify(ip);
 995                 ip->meta.check_algo = ino->ip_data.meta.check_algo;
 996         }
 997         if ((ino->flags & HAMMER2IOC_INODE_FLAG_COMP) &&
 998             ip->meta.comp_algo != ino->ip_data.meta.comp_algo) {
 999                 hammer2_inode_modify(ip);
1000                 ip->meta.comp_algo = ino->ip_data.meta.comp_algo;
1001         }
1002         ino->kdata = ip;
1003
1004         /* Ignore these flags for now...*/
1005         if ((ino->flags & HAMMER2IOC_INODE_FLAG_IQUOTA) &&
1006             ip->meta.inode_quota != ino->ip_data.meta.inode_quota) {
1007                 hammer2_inode_modify(ip);
1008                 ip->meta.inode_quota = ino->ip_data.meta.inode_quota;
1009         }
1010         if ((ino->flags & HAMMER2IOC_INODE_FLAG_DQUOTA) &&
1011             ip->meta.data_quota != ino->ip_data.meta.data_quota) {
1012                 hammer2_inode_modify(ip);
1013                 ip->meta.data_quota = ino->ip_data.meta.data_quota;
1014         }
1015         if ((ino->flags & HAMMER2IOC_INODE_FLAG_COPIES) &&
1016             ip->meta.ncopies != ino->ip_data.meta.ncopies) {
1017                 hammer2_inode_modify(ip);
1018                 ip->meta.ncopies = ino->ip_data.meta.ncopies;
1019         }
1020         hammer2_inode_unlock(ip);
1021         hammer2_trans_done(ip->pmp, 1);
1022
1023         return (hammer2_error_to_errno(error));
1024 }
1025
1026 static
1027 int
1028 hammer2_ioctl_debug_dump(hammer2_inode_t *ip, u_int flags)
1029 {
1030         hammer2_chain_t *chain;
1031         int count = 100000;
1032         int i;
1033
1034         for (i = 0; i < ip->cluster.nchains; ++i) {
1035                 chain = ip->cluster.array[i].chain;
1036                 if (chain == NULL)
1037                         continue;
1038                 hammer2_dump_chain(chain, 0, &count, 'i', flags);
1039         }
1040         return 0;
1041 }
1042
1043 /*
1044  * Executes one flush/free pass per call.  If trying to recover
1045  * data we just freed up a moment ago it can take up to six passes
1046  * to fully free the blocks.  Note that passes occur automatically based
1047  * on free space as the storage fills up, but manual passes may be needed
1048  * if storage becomes almost completely full.
1049  */
1050 static
1051 int
1052 hammer2_ioctl_bulkfree_scan(hammer2_inode_t *ip, void *data)
1053 {
1054         hammer2_ioc_bulkfree_t *bfi = data;
1055         hammer2_dev_t   *hmp;
1056         hammer2_pfs_t   *pmp;
1057         hammer2_chain_t *vchain;
1058         int error;
1059         int didsnap;
1060
1061         pmp = ip->pmp;
1062         ip = pmp->iroot;
1063
1064         hmp = pmp->pfs_hmps[0];
1065         if (hmp == NULL)
1066                 return (EINVAL);
1067         if (bfi == NULL)
1068                 return (EINVAL);
1069
1070         /*
1071          * Bulkfree has to be serialized to guarantee at least one sync
1072          * inbetween bulkfrees.
1073          */
1074         error = lockmgr(&hmp->bflock, LK_EXCLUSIVE | LK_PCATCH);
1075         if (error)
1076                 return error;
1077
1078         /*
1079          * sync the filesystem and obtain a snapshot of the synchronized
1080          * hmp volume header.  We treat the snapshot as an independent
1081          * entity.
1082          *
1083          * If ENOSPC occurs we should continue, because bulkfree is the only
1084          * way to fix that.  The flush will have flushed everything it could
1085          * and not left any modified chains.  Otherwise an error is fatal.
1086          */
1087         error = hammer2_vfs_sync(pmp->mp, MNT_WAIT);
1088         if (error && error != ENOSPC)
1089                 goto failed;
1090
1091         /*
1092          * If we have an ENOSPC error we have to bulkfree on the live
1093          * topology.  Otherwise we can bulkfree on a snapshot.
1094          */
1095         if (error) {
1096                 kprintf("hammer2: WARNING! Bulkfree forced to use live "
1097                         "topology\n");
1098                 vchain = &hmp->vchain;
1099                 hammer2_chain_ref(vchain);
1100                 didsnap = 0;
1101         } else {
1102                 vchain = hammer2_chain_bulksnap(hmp);
1103                 didsnap = 1;
1104         }
1105
1106         /*
1107          * Bulkfree on a snapshot does not need a transaction, which allows
1108          * it to run concurrently with any operation other than another
1109          * bulkfree.
1110          *
1111          * If we are running bulkfree on the live topology we have to be
1112          * in a FLUSH transaction.
1113          */
1114         if (didsnap == 0)
1115                 hammer2_trans_init(pmp, HAMMER2_TRANS_ISFLUSH);
1116
1117         if (bfi) {
1118                 hammer2_thr_freeze(&hmp->bfthr);
1119                 error = hammer2_bulkfree_pass(hmp, vchain, bfi);
1120                 hammer2_thr_unfreeze(&hmp->bfthr);
1121         }
1122         if (didsnap) {
1123                 hammer2_chain_bulkdrop(vchain);
1124         } else {
1125                 hammer2_chain_drop(vchain);
1126                 hammer2_trans_done(pmp, 1);
1127         }
1128         error = hammer2_error_to_errno(error);
1129
1130 failed:
1131         lockmgr(&hmp->bflock, LK_RELEASE);
1132         return error;
1133 }
1134
1135 /*
1136  * Unconditionally delete meta-data in a hammer2 filesystem
1137  */
1138 static
1139 int
1140 hammer2_ioctl_destroy(hammer2_inode_t *ip, void *data)
1141 {
1142         hammer2_ioc_destroy_t *iocd = data;
1143         hammer2_pfs_t *pmp = ip->pmp;
1144         int error;
1145
1146         if (pmp->ronly) {
1147                 error = EROFS;
1148                 return error;
1149         }
1150
1151         switch(iocd->cmd) {
1152         case HAMMER2_DELETE_FILE:
1153                 /*
1154                  * Destroy a bad directory entry by name.  Caller must
1155                  * pass the directory as fd.
1156                  */
1157                 {
1158                 hammer2_xop_unlink_t *xop;
1159
1160                 if (iocd->path[sizeof(iocd->path)-1]) {
1161                         error = EINVAL;
1162                         break;
1163                 }
1164                 if (ip->meta.type != HAMMER2_OBJTYPE_DIRECTORY) {
1165                         error = EINVAL;
1166                         break;
1167                 }
1168                 hammer2_pfs_memory_wait(ip, 0);
1169                 hammer2_trans_init(pmp, 0);
1170                 hammer2_inode_lock(ip, 0);
1171
1172                 xop = hammer2_xop_alloc(ip, HAMMER2_XOP_MODIFYING);
1173                 hammer2_xop_setname(&xop->head, iocd->path, strlen(iocd->path));
1174                 xop->isdir = -1;
1175                 xop->dopermanent = H2DOPERM_PERMANENT |
1176                                    H2DOPERM_FORCE |
1177                                    H2DOPERM_IGNINO;
1178                 hammer2_xop_start(&xop->head, hammer2_xop_unlink);
1179
1180                 error = hammer2_xop_collect(&xop->head, 0);
1181                 error = hammer2_error_to_errno(error);
1182                 hammer2_inode_unlock(ip);
1183                 hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
1184                 hammer2_trans_done(pmp, 1);
1185                 }
1186                 break;
1187         case HAMMER2_DELETE_INUM:
1188                 /*
1189                  * Destroy a bad inode by inode number.
1190                  */
1191                 {
1192                 hammer2_xop_lookup_t *xop;
1193
1194                 if (iocd->inum < 1) {
1195                         error = EINVAL;
1196                         break;
1197                 }
1198                 hammer2_pfs_memory_wait(ip, 0);
1199                 hammer2_trans_init(pmp, 0);
1200
1201                 xop = hammer2_xop_alloc(pmp->iroot, 0);
1202                 xop->lhc = iocd->inum;
1203                 hammer2_xop_start(&xop->head, hammer2_xop_lookup);
1204                 error = hammer2_xop_collect(&xop->head, 0);
1205                 if (error == 0) {
1206                         ip = hammer2_inode_get(pmp, NULL, &xop->head, -1);
1207                         hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
1208                         if (ip) {
1209                                 ip->meta.nlinks = 1;
1210                                 hammer2_inode_unlink_finisher(ip, 0);
1211                                 hammer2_inode_unlock(ip);
1212                         }
1213                 } else {
1214                         hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
1215                 }
1216                 }
1217                 break;
1218         default:
1219                 error = EINVAL;
1220                 break;
1221         }
1222         return error;
1223 }