sys/vfs/hammer2/hammer2_inode.c

   1 /*
   2  * Copyright (c) 2011-2014 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 #include <sys/cdefs.h>
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/types.h>
  39 #include <sys/lock.h>
  40 #include <sys/uuid.h>
  41
  42 #include "hammer2.h"
  43
  44 #define INODE_DEBUG     0
  45
  46 static void hammer2_inode_move_to_hidden(hammer2_trans_t *trans,
  47                                          hammer2_cluster_t **cparentp,
  48                                          hammer2_cluster_t **clusterp,
  49                                          hammer2_tid_t inum);
  50
  51 RB_GENERATE2(hammer2_inode_tree, hammer2_inode, rbnode, hammer2_inode_cmp,
  52              hammer2_tid_t, inum);
  53
  54 int
  55 hammer2_inode_cmp(hammer2_inode_t *ip1, hammer2_inode_t *ip2)
  56 {
  57         if (ip1->inum < ip2->inum)
  58                 return(-1);
  59         if (ip1->inum > ip2->inum)
  60                 return(1);
  61         return(0);
  62 }
  63
  64 /*
  65  * HAMMER2 inode locks
  66  *
  67  * HAMMER2 offers shared locks and exclusive locks on inodes.
  68  *
  69  * The inode locking function locks the inode itself, resolves any stale
  70  * chains in the inode's cluster, and allocates a fresh copy of the
  71  * cluster with 1 ref and all the underlying chains locked.  Duplication
  72  * races are handled by this function.
  73  *
  74  * ip->cluster will be stable while the inode is locked.
  75  *
  76  * NOTE: We don't combine the inode/chain lock because putting away an
  77  *       inode would otherwise confuse multiple lock holders of the inode.
  78  *
  79  * NOTE: In-memory inodes always point to hardlink targets (the actual file),
  80  *       and never point to a hardlink pointer.
  81  */
  82 hammer2_cluster_t *
  83 hammer2_inode_lock_ex(hammer2_inode_t *ip)
  84 {
  85         const hammer2_inode_data_t *ipdata;
  86         hammer2_cluster_t *cluster;
  87         hammer2_chain_t *chain;
  88         int i;
  89
  90         hammer2_inode_ref(ip);
  91         ccms_thread_lock(&ip->topo_cst, CCMS_STATE_EXCLUSIVE);
  92         cluster = hammer2_cluster_copy(&ip->cluster,
  93                                        HAMMER2_CLUSTER_COPY_NOCHAINS);
  94
  95         ip->cluster.focus = NULL;
  96         cluster->focus = NULL;
  97
  98         for (i = 0; i < cluster->nchains; ++i) {
  99                 chain = ip->cluster.array[i];
 100                 if (chain == NULL) {
 101                         kprintf("inode_lock: %p: missing chain\n", ip);
 102                         continue;
 103                 }
 104
 105                 hammer2_chain_lock(chain, HAMMER2_RESOLVE_ALWAYS);
 106                 cluster->array[i] = chain;
 107                 if (cluster->focus == NULL)
 108                         cluster->focus = chain;
 109                 if (ip->cluster.focus == NULL)
 110                         ip->cluster.focus = chain;
 111         }
 112
 113         /*
 114          * Returned cluster must resolve hardlink pointers
 115          */
 116         ipdata = &hammer2_cluster_data(cluster)->ipdata;
 117         KKASSERT(ipdata->type != HAMMER2_OBJTYPE_HARDLINK);
 118         /*
 119         if (ipdata->type == HAMMER2_OBJTYPE_HARDLINK &&
 120             (cluster->focus->flags & HAMMER2_CHAIN_DELETED) == 0) {
 121                 error = hammer2_hardlink_find(ip->pip, NULL, cluster);
 122                 KKASSERT(error == 0);
 123         }
 124         */
 125
 126         return (cluster);
 127 }
 128
 129 void
 130 hammer2_inode_unlock_ex(hammer2_inode_t *ip, hammer2_cluster_t *cluster)
 131 {
 132         if (cluster)
 133                 hammer2_cluster_unlock(cluster);
 134         ccms_thread_unlock(&ip->topo_cst);
 135         hammer2_inode_drop(ip);
 136 }
 137
 138 /*
 139  * NOTE: We don't combine the inode/chain lock because putting away an
 140  *       inode would otherwise confuse multiple lock holders of the inode.
 141  *
 142  *       Shared locks are especially sensitive to having too many shared
 143  *       lock counts (from the same thread) on certain paths which might
 144  *       need to upgrade them.  Only one count of a shared lock can be
 145  *       upgraded.
 146  */
 147 hammer2_cluster_t *
 148 hammer2_inode_lock_sh(hammer2_inode_t *ip)
 149 {
 150         const hammer2_inode_data_t *ipdata;
 151         hammer2_cluster_t *cluster;
 152         hammer2_chain_t *chain;
 153         int i;
 154
 155         hammer2_inode_ref(ip);
 156         cluster = hammer2_cluster_copy(&ip->cluster,
 157                                        HAMMER2_CLUSTER_COPY_NOCHAINS);
 158         ccms_thread_lock(&ip->topo_cst, CCMS_STATE_SHARED);
 159
 160         cluster->focus = NULL;
 161
 162         for (i = 0; i < cluster->nchains; ++i) {
 163                 chain = ip->cluster.array[i];
 164
 165                 if (chain == NULL) {
 166                         kprintf("inode_lock: %p: missing chain\n", ip);
 167                         continue;
 168                 }
 169
 170                 hammer2_chain_lock(chain, HAMMER2_RESOLVE_ALWAYS |
 171                                           HAMMER2_RESOLVE_SHARED);
 172                 cluster->array[i] = chain;
 173                 if (cluster->focus == NULL)
 174                         cluster->focus = chain;
 175         }
 176
 177         /*
 178          * Returned cluster must resolve hardlink pointers
 179          */
 180         ipdata = &hammer2_cluster_data(cluster)->ipdata;
 181         KKASSERT(ipdata->type != HAMMER2_OBJTYPE_HARDLINK);
 182         /*
 183         if (ipdata->type == HAMMER2_OBJTYPE_HARDLINK &&
 184             (cluster->focus->flags & HAMMER2_CHAIN_DELETED) == 0) {
 185                 error = hammer2_hardlink_find(ip->pip, NULL, cluster);
 186                 KKASSERT(error == 0);
 187         }
 188         */
 189
 190         return (cluster);
 191 }
 192
 193 void
 194 hammer2_inode_unlock_sh(hammer2_inode_t *ip, hammer2_cluster_t *cluster)
 195 {
 196         if (cluster)
 197                 hammer2_cluster_unlock(cluster);
 198         ccms_thread_unlock(&ip->topo_cst);
 199         hammer2_inode_drop(ip);
 200 }
 201
 202 ccms_state_t
 203 hammer2_inode_lock_temp_release(hammer2_inode_t *ip)
 204 {
 205         return(ccms_thread_lock_temp_release(&ip->topo_cst));
 206 }
 207
 208 void
 209 hammer2_inode_lock_temp_restore(hammer2_inode_t *ip, ccms_state_t ostate)
 210 {
 211         ccms_thread_lock_temp_restore(&ip->topo_cst, ostate);
 212 }
 213
 214 ccms_state_t
 215 hammer2_inode_lock_upgrade(hammer2_inode_t *ip)
 216 {
 217         return(ccms_thread_lock_upgrade(&ip->topo_cst));
 218 }
 219
 220 void
 221 hammer2_inode_lock_downgrade(hammer2_inode_t *ip, ccms_state_t ostate)
 222 {
 223         ccms_thread_lock_downgrade(&ip->topo_cst, ostate);
 224 }
 225
 226 /*
 227  * Lookup an inode by inode number
 228  */
 229 hammer2_inode_t *
 230 hammer2_inode_lookup(hammer2_pfsmount_t *pmp, hammer2_tid_t inum)
 231 {
 232         hammer2_inode_t *ip;
 233
 234         KKASSERT(pmp);
 235         if (pmp->spmp_hmp) {
 236                 ip = NULL;
 237         } else {
 238                 spin_lock(&pmp->inum_spin);
 239                 ip = RB_LOOKUP(hammer2_inode_tree, &pmp->inum_tree, inum);
 240                 if (ip)
 241                         hammer2_inode_ref(ip);
 242                 spin_unlock(&pmp->inum_spin);
 243         }
 244         return(ip);
 245 }
 246
 247 /*
 248  * Adding a ref to an inode is only legal if the inode already has at least
 249  * one ref.
 250  *
 251  * (can be called with spinlock held)
 252  */
 253 void
 254 hammer2_inode_ref(hammer2_inode_t *ip)
 255 {
 256         atomic_add_int(&ip->refs, 1);
 257 }
 258
 259 /*
 260  * Drop an inode reference, freeing the inode when the last reference goes
 261  * away.
 262  */
 263 void
 264 hammer2_inode_drop(hammer2_inode_t *ip)
 265 {
 266         hammer2_pfsmount_t *pmp;
 267         hammer2_inode_t *pip;
 268         u_int refs;
 269
 270         while (ip) {
 271                 refs = ip->refs;
 272                 cpu_ccfence();
 273                 if (refs == 1) {
 274                         /*
 275                          * Transition to zero, must interlock with
 276                          * the inode inumber lookup tree (if applicable).
 277                          */
 278                         pmp = ip->pmp;
 279                         KKASSERT(pmp);
 280                         spin_lock(&pmp->inum_spin);
 281
 282                         if (atomic_cmpset_int(&ip->refs, 1, 0)) {
 283                                 KKASSERT(ip->topo_cst.count == 0);
 284                                 if (ip->flags & HAMMER2_INODE_ONRBTREE) {
 285                                         atomic_clear_int(&ip->flags,
 286                                                      HAMMER2_INODE_ONRBTREE);
 287                                         RB_REMOVE(hammer2_inode_tree,
 288                                                   &pmp->inum_tree, ip);
 289                                 }
 290                                 spin_unlock(&pmp->inum_spin);
 291
 292                                 pip = ip->pip;
 293                                 ip->pip = NULL;
 294                                 ip->pmp = NULL;
 295
 296                                 /*
 297                                  * Cleaning out ip->cluster isn't entirely
 298                                  * trivial.
 299                                  */
 300                                 hammer2_inode_repoint(ip, NULL, NULL);
 301
 302                                 /*
 303                                  * We have to drop pip (if non-NULL) to
 304                                  * dispose of our implied reference from
 305                                  * ip->pip.  We can simply loop on it.
 306                                  */
 307                                 kfree(ip, pmp->minode);
 308                                 atomic_add_long(&pmp->inmem_inodes, -1);
 309                                 ip = pip;
 310                                 /* continue with pip (can be NULL) */
 311                         } else {
 312                                 spin_unlock(&ip->pmp->inum_spin);
 313                         }
 314                 } else {
 315                         /*
 316                          * Non zero transition
 317                          */
 318                         if (atomic_cmpset_int(&ip->refs, refs, refs - 1))
 319                                 break;
 320                 }
 321         }
 322 }
 323
 324 /*
 325  * Get the vnode associated with the given inode, allocating the vnode if
 326  * necessary.  The vnode will be returned exclusively locked.
 327  *
 328  * The caller must lock the inode (shared or exclusive).
 329  *
 330  * Great care must be taken to avoid deadlocks and vnode acquisition/reclaim
 331  * races.
 332  */
 333 struct vnode *
 334 hammer2_igetv(hammer2_inode_t *ip, hammer2_cluster_t *cparent, int *errorp)
 335 {
 336         const hammer2_inode_data_t *ipdata;
 337         hammer2_pfsmount_t *pmp;
 338         struct vnode *vp;
 339         ccms_state_t ostate;
 340
 341         pmp = ip->pmp;
 342         KKASSERT(pmp != NULL);
 343         *errorp = 0;
 344
 345         ipdata = &hammer2_cluster_data(cparent)->ipdata;
 346
 347         for (;;) {
 348                 /*
 349                  * Attempt to reuse an existing vnode assignment.  It is
 350                  * possible to race a reclaim so the vget() may fail.  The
 351                  * inode must be unlocked during the vget() to avoid a
 352                  * deadlock against a reclaim.
 353                  */
 354                 vp = ip->vp;
 355                 if (vp) {
 356                         /*
 357                          * Inode must be unlocked during the vget() to avoid
 358                          * possible deadlocks, but leave the ip ref intact.
 359                          *
 360                          * vnode is held to prevent destruction during the
 361                          * vget().  The vget() can still fail if we lost
 362                          * a reclaim race on the vnode.
 363                          */
 364                         vhold(vp);
 365                         ostate = hammer2_inode_lock_temp_release(ip);
 366                         if (vget(vp, LK_EXCLUSIVE)) {
 367                                 vdrop(vp);
 368                                 hammer2_inode_lock_temp_restore(ip, ostate);
 369                                 continue;
 370                         }
 371                         hammer2_inode_lock_temp_restore(ip, ostate);
 372                         vdrop(vp);
 373                         /* vp still locked and ref from vget */
 374                         if (ip->vp != vp) {
 375                                 kprintf("hammer2: igetv race %p/%p\n",
 376                                         ip->vp, vp);
 377                                 vput(vp);
 378                                 continue;
 379                         }
 380                         *errorp = 0;
 381                         break;
 382                 }
 383
 384                 /*
 385                  * No vnode exists, allocate a new vnode.  Beware of
 386                  * allocation races.  This function will return an
 387                  * exclusively locked and referenced vnode.
 388                  */
 389                 *errorp = getnewvnode(VT_HAMMER2, pmp->mp, &vp, 0, 0);
 390                 if (*errorp) {
 391                         kprintf("hammer2: igetv getnewvnode failed %d\n",
 392                                 *errorp);
 393                         vp = NULL;
 394                         break;
 395                 }
 396
 397                 /*
 398                  * Lock the inode and check for an allocation race.
 399                  */
 400                 ostate = hammer2_inode_lock_upgrade(ip);
 401                 if (ip->vp != NULL) {
 402                         vp->v_type = VBAD;
 403                         vx_put(vp);
 404                         hammer2_inode_lock_downgrade(ip, ostate);
 405                         continue;
 406                 }
 407
 408                 switch (ipdata->type) {
 409                 case HAMMER2_OBJTYPE_DIRECTORY:
 410                         vp->v_type = VDIR;
 411                         break;
 412                 case HAMMER2_OBJTYPE_REGFILE:
 413                         vp->v_type = VREG;
 414                         vinitvmio(vp, ipdata->size,
 415                                   HAMMER2_LBUFSIZE,
 416                                   (int)ipdata->size & HAMMER2_LBUFMASK);
 417                         break;
 418                 case HAMMER2_OBJTYPE_SOFTLINK:
 419                         /*
 420                          * XXX for now we are using the generic file_read
 421                          * and file_write code so we need a buffer cache
 422                          * association.
 423                          */
 424                         vp->v_type = VLNK;
 425                         vinitvmio(vp, ipdata->size,
 426                                   HAMMER2_LBUFSIZE,
 427                                   (int)ipdata->size & HAMMER2_LBUFMASK);
 428                         break;
 429                 case HAMMER2_OBJTYPE_CDEV:
 430                         vp->v_type = VCHR;
 431                         /* fall through */
 432                 case HAMMER2_OBJTYPE_BDEV:
 433                         vp->v_ops = &pmp->mp->mnt_vn_spec_ops;
 434                         if (ipdata->type != HAMMER2_OBJTYPE_CDEV)
 435                                 vp->v_type = VBLK;
 436                         addaliasu(vp, ipdata->rmajor, ipdata->rminor);
 437                         break;
 438                 case HAMMER2_OBJTYPE_FIFO:
 439                         vp->v_type = VFIFO;
 440                         vp->v_ops = &pmp->mp->mnt_vn_fifo_ops;
 441                         break;
 442                 default:
 443                         panic("hammer2: unhandled objtype %d", ipdata->type);
 444                         break;
 445                 }
 446
 447                 if (ip == pmp->iroot)
 448                         vsetflags(vp, VROOT);
 449
 450                 vp->v_data = ip;
 451                 ip->vp = vp;
 452                 hammer2_inode_ref(ip);          /* vp association */
 453                 hammer2_inode_lock_downgrade(ip, ostate);
 454                 break;
 455         }
 456
 457         /*
 458          * Return non-NULL vp and *errorp == 0, or NULL vp and *errorp != 0.
 459          */
 460         if (hammer2_debug & 0x0002) {
 461                 kprintf("igetv vp %p refs 0x%08x aux 0x%08x\n",
 462                         vp, vp->v_refcnt, vp->v_auxrefs);
 463         }
 464         return (vp);
 465 }
 466
 467 /*
 468  * Returns the inode associated with the passed-in cluster, creating the
 469  * inode if necessary and synchronizing it to the passed-in cluster otherwise.
 470  *
 471  * The passed-in chain must be locked and will remain locked on return.
 472  * The returned inode will be locked and the caller may dispose of both
 473  * via hammer2_inode_unlock_ex().  However, if the caller needs to resolve
 474  * a hardlink it must ref/unlock/relock/drop the inode.
 475  *
 476  * The hammer2_inode structure regulates the interface between the high level
 477  * kernel VNOPS API and the filesystem backend (the chains).
 478  */
 479 hammer2_inode_t *
 480 hammer2_inode_get(hammer2_pfsmount_t *pmp, hammer2_inode_t *dip,
 481                   hammer2_cluster_t *cluster)
 482 {
 483         hammer2_inode_t *nip;
 484         const hammer2_inode_data_t *iptmp;
 485         const hammer2_inode_data_t *nipdata;
 486
 487         KKASSERT(hammer2_cluster_type(cluster) == HAMMER2_BREF_TYPE_INODE);
 488         KKASSERT(pmp);
 489
 490         /*
 491          * Interlocked lookup/ref of the inode.  This code is only needed
 492          * when looking up inodes with nlinks != 0 (TODO: optimize out
 493          * otherwise and test for duplicates).
 494          */
 495 again:
 496         for (;;) {
 497                 iptmp = &hammer2_cluster_data(cluster)->ipdata;
 498                 nip = hammer2_inode_lookup(pmp, iptmp->inum);
 499                 if (nip == NULL)
 500                         break;
 501
 502                 ccms_thread_lock(&nip->topo_cst, CCMS_STATE_EXCLUSIVE);
 503
 504                 /*
 505                  * Handle SMP race (not applicable to the super-root spmp
 506                  * which can't index inodes due to duplicative inode numbers).
 507                  */
 508                 if (pmp->spmp_hmp == NULL &&
 509                     (nip->flags & HAMMER2_INODE_ONRBTREE) == 0) {
 510                         ccms_thread_unlock(&nip->topo_cst);
 511                         hammer2_inode_drop(nip);
 512                         continue;
 513                 }
 514                 hammer2_inode_repoint(nip, NULL, cluster);
 515                 return nip;
 516         }
 517
 518         /*
 519          * We couldn't find the inode number, create a new inode.
 520          */
 521         nip = kmalloc(sizeof(*nip), pmp->minode, M_WAITOK | M_ZERO);
 522         atomic_add_long(&pmp->inmem_inodes, 1);
 523         hammer2_pfs_memory_inc(pmp);
 524         hammer2_pfs_memory_wakeup(pmp);
 525         if (pmp->spmp_hmp)
 526                 nip->flags = HAMMER2_INODE_SROOT;
 527
 528         /*
 529          * Initialize nip's cluster
 530          */
 531         nip->cluster.refs = 1;
 532         nip->cluster.pmp = pmp;
 533         nip->cluster.flags |= HAMMER2_CLUSTER_INODE;
 534         hammer2_cluster_replace(&nip->cluster, cluster);
 535
 536         nipdata = &hammer2_cluster_data(cluster)->ipdata;
 537         nip->inum = nipdata->inum;
 538         nip->size = nipdata->size;
 539         nip->mtime = nipdata->mtime;
 540         hammer2_inode_repoint(nip, NULL, cluster);
 541         nip->pip = dip;                         /* can be NULL */
 542         if (dip)
 543                 hammer2_inode_ref(dip); /* ref dip for nip->pip */
 544
 545         nip->pmp = pmp;
 546
 547         /*
 548          * ref and lock on nip gives it state compatible to after a
 549          * hammer2_inode_lock_ex() call.
 550          */
 551         nip->refs = 1;
 552         ccms_cst_init(&nip->topo_cst, &nip->cluster);
 553         ccms_thread_lock(&nip->topo_cst, CCMS_STATE_EXCLUSIVE);
 554         /* combination of thread lock and chain lock == inode lock */
 555
 556         /*
 557          * Attempt to add the inode.  If it fails we raced another inode
 558          * get.  Undo all the work and try again.
 559          */
 560         if (pmp->spmp_hmp == NULL) {
 561                 spin_lock(&pmp->inum_spin);
 562                 if (RB_INSERT(hammer2_inode_tree, &pmp->inum_tree, nip)) {
 563                         spin_unlock(&pmp->inum_spin);
 564                         ccms_thread_unlock(&nip->topo_cst);
 565                         hammer2_inode_drop(nip);
 566                         goto again;
 567                 }
 568                 atomic_set_int(&nip->flags, HAMMER2_INODE_ONRBTREE);
 569                 spin_unlock(&pmp->inum_spin);
 570         }
 571
 572         return (nip);
 573 }
 574
 575 /*
 576  * Create a new inode in the specified directory using the vattr to
 577  * figure out the type of inode.
 578  *
 579  * If no error occurs the new inode with its cluster locked is returned in
 580  * *nipp, otherwise an error is returned and *nipp is set to NULL.
 581  *
 582  * If vap and/or cred are NULL the related fields are not set and the
 583  * inode type defaults to a directory.  This is used when creating PFSs
 584  * under the super-root, so the inode number is set to 1 in this case.
 585  *
 586  * dip is not locked on entry.
 587  *
 588  * NOTE: When used to create a snapshot, the inode is temporarily associated
 589  *       with the super-root spmp. XXX should pass new pmp for snapshot.
 590  */
 591 hammer2_inode_t *
 592 hammer2_inode_create(hammer2_trans_t *trans, hammer2_inode_t *dip,
 593                      struct vattr *vap, struct ucred *cred,
 594                      const uint8_t *name, size_t name_len,
 595                      hammer2_cluster_t **clusterp, int *errorp)
 596 {
 597         const hammer2_inode_data_t *dipdata;
 598         hammer2_inode_data_t *nipdata;
 599         hammer2_cluster_t *cluster;
 600         hammer2_cluster_t *cparent;
 601         hammer2_inode_t *nip;
 602         hammer2_key_t key_dummy;
 603         hammer2_key_t lhc;
 604         int error;
 605         uid_t xuid;
 606         uuid_t dip_uid;
 607         uuid_t dip_gid;
 608         uint32_t dip_mode;
 609         uint8_t dip_comp_algo;
 610         uint8_t dip_check_algo;
 611         int ddflag;
 612
 613         lhc = hammer2_dirhash(name, name_len);
 614         *errorp = 0;
 615
 616         /*
 617          * Locate the inode or indirect block to create the new
 618          * entry in.  At the same time check for key collisions
 619          * and iterate until we don't get one.
 620          *
 621          * NOTE: hidden inodes do not have iterators.
 622          */
 623 retry:
 624         cparent = hammer2_inode_lock_ex(dip);
 625         dipdata = &hammer2_cluster_data(cparent)->ipdata;
 626         dip_uid = dipdata->uid;
 627         dip_gid = dipdata->gid;
 628         dip_mode = dipdata->mode;
 629         dip_comp_algo = dipdata->comp_algo;
 630         dip_check_algo = dipdata->check_algo;
 631
 632         error = 0;
 633         while (error == 0) {
 634                 cluster = hammer2_cluster_lookup(cparent, &key_dummy,
 635                                                  lhc, lhc, 0, &ddflag);
 636                 if (cluster == NULL)
 637                         break;
 638                 if ((lhc & HAMMER2_DIRHASH_VISIBLE) == 0)
 639                         error = ENOSPC;
 640                 if ((lhc & HAMMER2_DIRHASH_LOMASK) == HAMMER2_DIRHASH_LOMASK)
 641                         error = ENOSPC;
 642                 hammer2_cluster_unlock(cluster);
 643                 cluster = NULL;
 644                 ++lhc;
 645         }
 646
 647         if (error == 0) {
 648                 error = hammer2_cluster_create(trans, cparent, &cluster,
 649                                              lhc, 0,
 650                                              HAMMER2_BREF_TYPE_INODE,
 651                                              HAMMER2_INODE_BYTES,
 652                                              0);
 653         }
 654 #if INODE_DEBUG
 655         kprintf("CREATE INODE %*.*s chain=%p\n",
 656                 (int)name_len, (int)name_len, name,
 657                 (cluster ? cluster->focus : NULL));
 658 #endif
 659
 660         /*
 661          * Cleanup and handle retries.
 662          */
 663         if (error == EAGAIN) {
 664                 hammer2_cluster_ref(cparent);
 665                 hammer2_inode_unlock_ex(dip, cparent);
 666                 hammer2_cluster_wait(cparent);
 667                 hammer2_cluster_drop(cparent);
 668                 goto retry;
 669         }
 670         hammer2_inode_unlock_ex(dip, cparent);
 671         cparent = NULL;
 672
 673         if (error) {
 674                 KKASSERT(cluster == NULL);
 675                 *errorp = error;
 676                 return (NULL);
 677         }
 678
 679         /*
 680          * Set up the new inode.
 681          *
 682          * NOTE: *_get() integrates chain's lock into the inode lock.
 683          *
 684          * NOTE: Only one new inode can currently be created per
 685          *       transaction.  If the need arises we can adjust
 686          *       hammer2_trans_init() to allow more.
 687          *
 688          * NOTE: nipdata will have chain's blockset data.
 689          */
 690         KKASSERT(cluster->focus->flags & HAMMER2_CHAIN_MODIFIED);
 691         nipdata = &hammer2_cluster_wdata(cluster)->ipdata;
 692         nipdata->inum = trans->inode_tid;
 693         hammer2_cluster_modsync(cluster);
 694         nip = hammer2_inode_get(dip->pmp, dip, cluster);
 695         nipdata = &hammer2_cluster_wdata(cluster)->ipdata;
 696
 697         if (vap) {
 698                 KKASSERT(trans->inodes_created == 0);
 699                 nipdata->type = hammer2_get_obj_type(vap->va_type);
 700                 nipdata->inum = trans->inode_tid;
 701                 ++trans->inodes_created;
 702
 703                 switch (nipdata->type) {
 704                 case HAMMER2_OBJTYPE_CDEV:
 705                 case HAMMER2_OBJTYPE_BDEV:
 706                         nipdata->rmajor = vap->va_rmajor;
 707                         nipdata->rminor = vap->va_rminor;
 708                         break;
 709                 default:
 710                         break;
 711                 }
 712         } else {
 713                 nipdata->type = HAMMER2_OBJTYPE_DIRECTORY;
 714                 nipdata->inum = 1;
 715         }
 716
 717         /* Inherit parent's inode compression mode. */
 718         nip->comp_heuristic = 0;
 719         nipdata->comp_algo = dip_comp_algo;
 720         nipdata->check_algo = dip_check_algo;
 721         nipdata->version = HAMMER2_INODE_VERSION_ONE;
 722         hammer2_update_time(&nipdata->ctime);
 723         nipdata->mtime = nipdata->ctime;
 724         if (vap)
 725                 nipdata->mode = vap->va_mode;
 726         nipdata->nlinks = 1;
 727         if (vap) {
 728                 if (dip && dip->pmp) {
 729                         xuid = hammer2_to_unix_xid(&dip_uid);
 730                         xuid = vop_helper_create_uid(dip->pmp->mp,
 731                                                      dip_mode,
 732                                                      xuid,
 733                                                      cred,
 734                                                      &vap->va_mode);
 735                 } else {
 736                         /* super-root has no dip and/or pmp */
 737                         xuid = 0;
 738                 }
 739                 if (vap->va_vaflags & VA_UID_UUID_VALID)
 740                         nipdata->uid = vap->va_uid_uuid;
 741                 else if (vap->va_uid != (uid_t)VNOVAL)
 742                         hammer2_guid_to_uuid(&nipdata->uid, vap->va_uid);
 743                 else
 744                         hammer2_guid_to_uuid(&nipdata->uid, xuid);
 745
 746                 if (vap->va_vaflags & VA_GID_UUID_VALID)
 747                         nipdata->gid = vap->va_gid_uuid;
 748                 else if (vap->va_gid != (gid_t)VNOVAL)
 749                         hammer2_guid_to_uuid(&nipdata->gid, vap->va_gid);
 750                 else if (dip)
 751                         nipdata->gid = dip_gid;
 752         }
 753
 754         /*
 755          * Regular files and softlinks allow a small amount of data to be
 756          * directly embedded in the inode.  This flag will be cleared if
 757          * the size is extended past the embedded limit.
 758          */
 759         if (nipdata->type == HAMMER2_OBJTYPE_REGFILE ||
 760             nipdata->type == HAMMER2_OBJTYPE_SOFTLINK) {
 761                 nipdata->op_flags |= HAMMER2_OPFLAG_DIRECTDATA;
 762         }
 763
 764         KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
 765         bcopy(name, nipdata->filename, name_len);
 766         nipdata->name_key = lhc;
 767         nipdata->name_len = name_len;
 768         hammer2_cluster_modsync(cluster);
 769         *clusterp = cluster;
 770
 771         return (nip);
 772 }
 773
 774 /*
 775  * The cluster has been removed from the original directory and replaced
 776  * with a hardlink pointer.  Move the cluster to the specified parent
 777  * directory, change the filename to "0xINODENUMBER", and adjust the key.
 778  * The cluster becomes our invisible hardlink target.
 779  *
 780  * The original cluster must be deleted on entry.
 781  */
 782 static
 783 void
 784 hammer2_hardlink_shiftup(hammer2_trans_t *trans, hammer2_cluster_t *cluster,
 785                         hammer2_inode_t *dip, hammer2_cluster_t *dcluster,
 786                         int nlinks, int *errorp)
 787 {
 788         const hammer2_inode_data_t *iptmp;
 789         hammer2_inode_data_t *nipdata;
 790         hammer2_cluster_t *xcluster;
 791         hammer2_key_t key_dummy;
 792         hammer2_key_t lhc;
 793         hammer2_blockref_t bref;
 794         int ddflag;
 795
 796         iptmp = &hammer2_cluster_data(cluster)->ipdata;
 797         lhc = iptmp->inum;
 798         KKASSERT((lhc & HAMMER2_DIRHASH_VISIBLE) == 0);
 799
 800         /*
 801          * Locate the inode or indirect block to create the new
 802          * entry in.  lhc represents the inode number so there is
 803          * no collision iteration.
 804          *
 805          * There should be no key collisions with invisible inode keys.
 806          *
 807          * WARNING! Must use inode_lock_ex() on dip to handle a stale
 808          *          dip->cluster cache.
 809          */
 810         *errorp = 0;
 811         xcluster = hammer2_cluster_lookup(dcluster, &key_dummy,
 812                                       lhc, lhc, 0, &ddflag);
 813         if (xcluster) {
 814                 kprintf("X3 chain %p dip %p dchain %p dip->chain %p\n",
 815                         xcluster->focus, dip, dcluster->focus,
 816                         dip->cluster.focus);
 817                 hammer2_cluster_unlock(xcluster);
 818                 xcluster = NULL;
 819                 *errorp = ENOSPC;
 820 #if 0
 821                 Debugger("X3");
 822 #endif
 823         }
 824
 825         /*
 826          * Handle the error case
 827          */
 828         if (*errorp) {
 829                 panic("error2");
 830                 KKASSERT(xcluster == NULL);
 831                 return;
 832         }
 833
 834         /*
 835          * Use xcluster as a placeholder for (lhc).  Duplicate cluster to the
 836          * same target bref as xcluster and then delete xcluster.  The
 837          * duplication occurs after xcluster in flush order even though
 838          * xcluster is deleted after the duplication. XXX
 839          *
 840          * WARNING! Duplications (to a different parent) can cause indirect
 841          *          blocks to be inserted, refactor xcluster.
 842          *
 843          * WARNING! Only key and keybits is extracted from a passed-in bref.
 844          */
 845         hammer2_cluster_bref(cluster, &bref);
 846         bref.key = lhc;                 /* invisible dir entry key */
 847         bref.keybits = 0;
 848         hammer2_cluster_rename(trans, &bref, dcluster, cluster, 0);
 849
 850         /*
 851          * cluster is now 'live' again.. adjust the filename.
 852          *
 853          * Directory entries are inodes but this is a hidden hardlink
 854          * target.  The name isn't used but to ease debugging give it
 855          * a name after its inode number.
 856          */
 857         hammer2_cluster_modify(trans, cluster, 0);
 858         nipdata = &hammer2_cluster_wdata(cluster)->ipdata;
 859         ksnprintf(nipdata->filename, sizeof(nipdata->filename),
 860                   "0x%016jx", (intmax_t)nipdata->inum);
 861         nipdata->name_len = strlen(nipdata->filename);
 862         nipdata->name_key = lhc;
 863         nipdata->nlinks += nlinks;
 864         hammer2_cluster_modsync(cluster);
 865 }
 866
 867 /*
 868  * Connect the target inode represented by (cluster) to the media topology
 869  * at (dip, name, len).  The caller can pass a rough *chainp, this function
 870  * will issue lookup()s to position the parent chain properly for the
 871  * chain insertion.
 872  *
 873  * If hlink is TRUE this function creates an OBJTYPE_HARDLINK directory
 874  * entry instead of connecting (cluster).
 875  *
 876  * If hlink is FALSE this function expects (cluster) to be unparented.
 877  */
 878 int
 879 hammer2_inode_connect(hammer2_trans_t *trans,
 880                       hammer2_cluster_t **clusterp, int hlink,
 881                       hammer2_inode_t *dip, hammer2_cluster_t *dcluster,
 882                       const uint8_t *name, size_t name_len,
 883                       hammer2_key_t lhc)
 884 {
 885         hammer2_inode_data_t *wipdata;
 886         hammer2_cluster_t *ocluster;
 887         hammer2_cluster_t *ncluster;
 888         hammer2_key_t key_dummy;
 889         int ddflag;
 890         int error;
 891
 892         /*
 893          * Since ocluster is either disconnected from the topology or
 894          * represents a hardlink terminus which is always a parent of or
 895          * equal to dip, we should be able to safely lock dip->chain for
 896          * our setup.
 897          *
 898          * WARNING! Must use inode_lock_ex() on dip to handle a stale
 899          *          dip->cluster.
 900          *
 901          * If name is non-NULL we calculate lhc, else we use the passed-in
 902          * lhc.
 903          */
 904         ocluster = *clusterp;
 905
 906         if (name) {
 907                 lhc = hammer2_dirhash(name, name_len);
 908
 909                 /*
 910                  * Locate the inode or indirect block to create the new
 911                  * entry in.  At the same time check for key collisions
 912                  * and iterate until we don't get one.
 913                  */
 914                 error = 0;
 915                 while (error == 0) {
 916                         ncluster = hammer2_cluster_lookup(dcluster, &key_dummy,
 917                                                       lhc, lhc,
 918                                                       0, &ddflag);
 919                         if (ncluster == NULL)
 920                                 break;
 921                         if ((lhc & HAMMER2_DIRHASH_LOMASK) ==
 922                             HAMMER2_DIRHASH_LOMASK) {
 923                                 error = ENOSPC;
 924                         }
 925                         hammer2_cluster_unlock(ncluster);
 926                         ncluster = NULL;
 927                         ++lhc;
 928                 }
 929         } else {
 930                 /*
 931                  * Reconnect to specific key (used when moving
 932                  * unlinked-but-open files into the hidden directory).
 933                  */
 934                 ncluster = hammer2_cluster_lookup(dcluster, &key_dummy,
 935                                                   lhc, lhc,
 936                                                   0, &ddflag);
 937                 KKASSERT(ncluster == NULL);
 938         }
 939
 940         if (error == 0) {
 941                 if (hlink) {
 942                         /*
 943                          * Hardlink pointer needed, create totally fresh
 944                          * directory entry.
 945                          *
 946                          * We must refactor ocluster because it might have
 947                          * been shifted into an indirect cluster by the
 948                          * create.
 949                          */
 950                         KKASSERT(ncluster == NULL);
 951                         error = hammer2_cluster_create(trans,
 952                                                        dcluster, &ncluster,
 953                                                        lhc, 0,
 954                                                        HAMMER2_BREF_TYPE_INODE,
 955                                                        HAMMER2_INODE_BYTES,
 956                                                        0);
 957                 } else {
 958                         /*
 959                          * Reconnect the original cluster under the new name.
 960                          * Original cluster must have already been deleted by
 961                          * teh caller.
 962                          *
 963                          * WARNING! Can cause held-over clusters to require a
 964                          *          refactor.  Fortunately we have none (our
 965                          *          locked clusters are passed into and
 966                          *          modified by the call).
 967                          */
 968                         ncluster = ocluster;
 969                         ocluster = NULL;
 970                         error = hammer2_cluster_create(trans,
 971                                                        dcluster, &ncluster,
 972                                                        lhc, 0,
 973                                                        HAMMER2_BREF_TYPE_INODE,
 974                                                        HAMMER2_INODE_BYTES,
 975                                                        0);
 976                 }
 977         }
 978
 979         /*
 980          * Unlock stuff.
 981          */
 982         KKASSERT(error != EAGAIN);
 983
 984         /*
 985          * ncluster should be NULL on error, leave ocluster
 986          * (ocluster == *clusterp) alone.
 987          */
 988         if (error) {
 989                 KKASSERT(ncluster == NULL);
 990                 return (error);
 991         }
 992
 993         /*
 994          * Directory entries are inodes so if the name has changed we have
 995          * to update the inode.
 996          *
 997          * When creating an OBJTYPE_HARDLINK entry remember to unlock the
 998          * cluster, the caller will access the hardlink via the actual hardlink
 999          * target file and not the hardlink pointer entry, so we must still
1000          * return ocluster.
1001          */
1002         if (hlink && hammer2_hardlink_enable >= 0) {
1003                 /*
1004                  * Create the HARDLINK pointer.  oip represents the hardlink
1005                  * target in this situation.
1006                  *
1007                  * We will return ocluster (the hardlink target).
1008                  */
1009                 hammer2_cluster_modify(trans, ncluster, 0);
1010                 KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
1011                 wipdata = &hammer2_cluster_wdata(ncluster)->ipdata;
1012                 bcopy(name, wipdata->filename, name_len);
1013                 wipdata->name_key = lhc;
1014                 wipdata->name_len = name_len;
1015                 wipdata->target_type =
1016                                 hammer2_cluster_data(ocluster)->ipdata.type;
1017                 wipdata->type = HAMMER2_OBJTYPE_HARDLINK;
1018                 wipdata->inum = hammer2_cluster_data(ocluster)->ipdata.inum;
1019                 wipdata->version = HAMMER2_INODE_VERSION_ONE;
1020                 wipdata->nlinks = 1;
1021                 wipdata->op_flags = HAMMER2_OPFLAG_DIRECTDATA;
1022                 hammer2_cluster_modsync(ncluster);
1023                 hammer2_cluster_unlock(ncluster);
1024                 ncluster = ocluster;
1025                 ocluster = NULL;
1026         } else {
1027                 /*
1028                  * ncluster is a duplicate of ocluster at the new location.
1029                  * We must fixup the name stored in the inode data.
1030                  * The bref key has already been adjusted by inode_connect().
1031                  */
1032                 hammer2_cluster_modify(trans, ncluster, 0);
1033                 wipdata = &hammer2_cluster_wdata(ncluster)->ipdata;
1034
1035                 KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
1036                 bcopy(name, wipdata->filename, name_len);
1037                 wipdata->name_key = lhc;
1038                 wipdata->name_len = name_len;
1039                 wipdata->nlinks = 1;
1040                 hammer2_cluster_modsync(ncluster);
1041         }
1042
1043         /*
1044          * We are replacing ocluster with ncluster, unlock ocluster.  In the
1045          * case where ocluster is left unchanged the code above sets
1046          * ncluster to ocluster and ocluster to NULL, resulting in a NOP here.
1047          */
1048         if (ocluster)
1049                 hammer2_cluster_unlock(ocluster);
1050         *clusterp = ncluster;
1051
1052         return (0);
1053 }
1054
1055 /*
1056  * Repoint ip->cluster's chains to cluster's chains.  Caller must hold
1057  * the inode exclusively locked.  cluster may be NULL to clean out any
1058  * chains in ip->cluster.
1059  */
1060 void
1061 hammer2_inode_repoint(hammer2_inode_t *ip, hammer2_inode_t *pip,
1062                       hammer2_cluster_t *cluster)
1063 {
1064         hammer2_chain_t *ochain;
1065         hammer2_chain_t *nchain;
1066         hammer2_inode_t *opip;
1067         int i;
1068
1069         /*
1070          * Replace chains in ip->cluster with chains from cluster and
1071          * adjust the focus if necessary.
1072          *
1073          * NOTE: nchain and/or ochain can be NULL due to gaps
1074          *       in the cluster arrays.
1075          */
1076         ip->cluster.focus = NULL;
1077         for (i = 0; cluster && i < cluster->nchains; ++i) {
1078                 nchain = cluster->array[i];
1079                 if (i < ip->cluster.nchains) {
1080                         ochain = ip->cluster.array[i];
1081                         if (ochain == nchain) {
1082                                 if (ip->cluster.focus == NULL)
1083                                         ip->cluster.focus = nchain;
1084                                 continue;
1085                         }
1086                 } else {
1087                         ochain = NULL;
1088                 }
1089
1090                 /*
1091                  * Make adjustments
1092                  */
1093                 ip->cluster.array[i] = nchain;
1094                 if (ip->cluster.focus == NULL)
1095                         ip->cluster.focus = nchain;
1096                 if (nchain)
1097                         hammer2_chain_ref(nchain);
1098                 if (ochain)
1099                         hammer2_chain_drop(ochain);
1100         }
1101
1102         /*
1103          * Release any left-over chains in ip->cluster.
1104          */
1105         while (i < ip->cluster.nchains) {
1106                 nchain = ip->cluster.array[i];
1107                 if (nchain) {
1108                         ip->cluster.array[i] = NULL;
1109                         hammer2_chain_drop(nchain);
1110                 }
1111                 ++i;
1112         }
1113         ip->cluster.nchains = cluster ? cluster->nchains : 0;
1114
1115         /*
1116          * Repoint ip->pip if requested (non-NULL pip).
1117          */
1118         if (pip && ip->pip != pip) {
1119                 opip = ip->pip;
1120                 hammer2_inode_ref(pip);
1121                 ip->pip = pip;
1122                 if (opip)
1123                         hammer2_inode_drop(opip);
1124         }
1125 }
1126
1127 /*
1128  * Unlink the file from the specified directory inode.  The directory inode
1129  * does not need to be locked.
1130  *
1131  * isdir determines whether a directory/non-directory check should be made.
1132  * No check is made if isdir is set to -1.
1133  *
1134  * isopen specifies whether special unlink-with-open-descriptor handling
1135  * must be performed.  If set to -1 the caller is deleting a PFS and we
1136  * check whether the chain is mounted or not (chain->pmp != NULL).  1 is
1137  * implied if it is mounted.
1138  *
1139  * If isopen is 1 and nlinks drops to 0 this function must move the chain
1140  * to a special hidden directory until last-close occurs on the file.
1141  *
1142  * NOTE!  The underlying file can still be active with open descriptors
1143  *        or if the chain is being manually held (e.g. for rename).
1144  *
1145  *        The caller is responsible for fixing up ip->chain if e.g. a
1146  *        rename occurs (see chain_duplicate()).
1147  *
1148  * NOTE!  The chain is not deleted if it is moved to the hidden directory,
1149  *        but otherwise will be deleted.
1150  */
1151 int
1152 hammer2_unlink_file(hammer2_trans_t *trans, hammer2_inode_t *dip,
1153                     const uint8_t *name, size_t name_len,
1154                     int isdir, int *hlinkp, struct nchandle *nch,
1155                     int nlinks)
1156 {
1157         const hammer2_inode_data_t *ripdata;
1158         hammer2_inode_data_t *wipdata;
1159         hammer2_cluster_t *cparent;
1160         hammer2_cluster_t *hcluster;
1161         hammer2_cluster_t *hparent;
1162         hammer2_cluster_t *cluster;
1163         hammer2_cluster_t *dparent;
1164         hammer2_cluster_t *dcluster;
1165         hammer2_key_t key_dummy;
1166         hammer2_key_t key_next;
1167         hammer2_key_t lhc;
1168         int error;
1169         int ddflag;
1170         int hlink;
1171         uint8_t type;
1172
1173         error = 0;
1174         hlink = 0;
1175         hcluster = NULL;
1176         hparent = NULL;
1177         lhc = hammer2_dirhash(name, name_len);
1178
1179 again:
1180         /*
1181          * Search for the filename in the directory
1182          */
1183         cparent = hammer2_inode_lock_ex(dip);
1184         cluster = hammer2_cluster_lookup(cparent, &key_next,
1185                                      lhc, lhc + HAMMER2_DIRHASH_LOMASK,
1186                                      0, &ddflag);
1187         while (cluster) {
1188                 if (hammer2_cluster_type(cluster) == HAMMER2_BREF_TYPE_INODE) {
1189                         ripdata = &hammer2_cluster_data(cluster)->ipdata;
1190                         if (ripdata->name_len == name_len &&
1191                             bcmp(ripdata->filename, name, name_len) == 0) {
1192                                 break;
1193                         }
1194                 }
1195                 cluster = hammer2_cluster_next(cparent, cluster, &key_next,
1196                                                key_next,
1197                                                lhc + HAMMER2_DIRHASH_LOMASK,
1198                                                0);
1199         }
1200         hammer2_inode_unlock_ex(dip, NULL);     /* retain cparent */
1201
1202         /*
1203          * Not found or wrong type (isdir < 0 disables the type check).
1204          * If a hardlink pointer, type checks use the hardlink target.
1205          */
1206         if (cluster == NULL) {
1207                 error = ENOENT;
1208                 goto done;
1209         }
1210         ripdata = &hammer2_cluster_data(cluster)->ipdata;
1211         type = ripdata->type;
1212         if (type == HAMMER2_OBJTYPE_HARDLINK) {
1213                 hlink = 1;
1214                 type = ripdata->target_type;
1215         }
1216
1217         if (type == HAMMER2_OBJTYPE_DIRECTORY && isdir == 0) {
1218                 error = ENOTDIR;
1219                 goto done;
1220         }
1221         if (type != HAMMER2_OBJTYPE_DIRECTORY && isdir >= 1) {
1222                 error = EISDIR;
1223                 goto done;
1224         }
1225
1226         /*
1227          * Hardlink must be resolved.  We can't hold the parent locked
1228          * while we do this or we could deadlock.  The physical file will
1229          * be located at or above the current directory.
1230          *
1231          * We loop to reacquire the hardlink origination.
1232          *
1233          * NOTE: hammer2_hardlink_find() will locate the hardlink target,
1234          *       returning a modified hparent and hcluster.
1235          */
1236         if (ripdata->type == HAMMER2_OBJTYPE_HARDLINK) {
1237                 if (hcluster == NULL) {
1238                         hcluster = cluster;
1239                         cluster = NULL; /* safety */
1240                         hammer2_cluster_unlock(cparent);
1241                         cparent = NULL; /* safety */
1242                         ripdata = NULL; /* safety (associated w/cparent) */
1243                         error = hammer2_hardlink_find(dip, &hparent, hcluster);
1244
1245                         /*
1246                          * If we couldn't find the hardlink target then some
1247                          * parent directory containing the hardlink pointer
1248                          * probably got renamed to above the original target,
1249                          * a case not yet handled by H2.
1250                          */
1251                         if (error) {
1252                                 kprintf("H2 unlink_file: hardlink target for "
1253                                         "\"%s\" not found\n",
1254                                         name);
1255                                 kprintf("(likely due to known directory "
1256                                         "rename bug)\n");
1257                                 goto done;
1258                         }
1259                         goto again;
1260                 }
1261         }
1262
1263         /*
1264          * If this is a directory the directory must be empty.  However, if
1265          * isdir < 0 we are doing a rename and the directory does not have
1266          * to be empty, and if isdir > 1 we are deleting a PFS/snapshot
1267          * and the directory does not have to be empty.
1268          *
1269          * NOTE: We check the full key range here which covers both visible
1270          *       and invisible entries.  Theoretically there should be no
1271          *       invisible (hardlink target) entries if there are no visible
1272          *       entries.
1273          */
1274         if (type == HAMMER2_OBJTYPE_DIRECTORY && isdir == 1) {
1275                 dparent = hammer2_cluster_lookup_init(cluster, 0);
1276                 dcluster = hammer2_cluster_lookup(dparent, &key_dummy,
1277                                                   0, (hammer2_key_t)-1,
1278                                                   HAMMER2_LOOKUP_NODATA,
1279                                                   &ddflag);
1280                 if (dcluster) {
1281                         hammer2_cluster_unlock(dcluster);
1282                         hammer2_cluster_lookup_done(dparent);
1283                         error = ENOTEMPTY;
1284                         goto done;
1285                 }
1286                 hammer2_cluster_lookup_done(dparent);
1287                 dparent = NULL;
1288                 /* dcluster NULL */
1289         }
1290
1291         /*
1292          * If this was a hardlink then (cparent, cluster) is the hardlink
1293          * pointer, which we can simply destroy outright.  Discard the
1294          * clusters and replace with the hardlink target.
1295          */
1296         if (hcluster) {
1297                 hammer2_cluster_delete(trans, cparent, cluster,
1298                                        HAMMER2_DELETE_PERMANENT);
1299                 hammer2_cluster_unlock(cparent);
1300                 hammer2_cluster_unlock(cluster);
1301                 cparent = hparent;
1302                 cluster = hcluster;
1303                 hparent = NULL;
1304                 hcluster = NULL;
1305         }
1306
1307         /*
1308          * This leaves us with the hardlink target or non-hardlinked file
1309          * or directory in (cparent, cluster).
1310          *
1311          * Delete the target when nlinks reaches 0 with special handling
1312          * if (isopen) is set.
1313          *
1314          * NOTE! In DragonFly the vnops function calls cache_unlink() after
1315          *       calling us here to clean out the namecache association,
1316          *       (which does not represent a ref for the open-test), and to
1317          *       force finalization of the vnode if/when the last ref gets
1318          *       dropped.
1319          *
1320          * NOTE! Files are unlinked by rename and then relinked.  nch will be
1321          *       passed as NULL in this situation.  hammer2_inode_connect()
1322          *       will bump nlinks.
1323          */
1324         KKASSERT(cluster != NULL);
1325         hammer2_cluster_modify(trans, cluster, 0);
1326         wipdata = &hammer2_cluster_wdata(cluster)->ipdata;
1327         ripdata = wipdata;
1328         wipdata->nlinks += nlinks;
1329         if ((int64_t)wipdata->nlinks < 0) {     /* XXX debugging */
1330                 wipdata->nlinks = 0;
1331         }
1332         hammer2_cluster_modsync(cluster);
1333
1334         if (wipdata->nlinks == 0) {
1335                 /*
1336                  * Target nlinks has reached 0, file now unlinked (but may
1337                  * still be open).
1338                  */
1339                 /* XXX need interlock if mounted
1340                 if ((cluster->focus->flags & HAMMER2_CHAIN_PFSROOT) &&
1341                     cluster->pmp) {
1342                         error = EINVAL;
1343                         kprintf("hammer2: PFS \"%s\" cannot be deleted "
1344                                 "while still mounted\n",
1345                                 wipdata->filename);
1346                         goto done;
1347                 }
1348                 */
1349                 if (nch && cache_isopen(nch)) {
1350                         hammer2_inode_move_to_hidden(trans, &cparent, &cluster,
1351                                                      wipdata->inum);
1352                 } else {
1353                         /*
1354                          * This won't get everything if a vnode is still
1355                          * present, but the cache_unlink() call the caller
1356                          * makes will.
1357                          */
1358                         hammer2_cluster_delete(trans, cparent, cluster,
1359                                                HAMMER2_DELETE_PERMANENT);
1360                 }
1361         } else if (hlink == 0) {
1362                 /*
1363                  * In this situation a normal non-hardlinked file (which can
1364                  * only have nlinks == 1) still has a non-zero nlinks, the
1365                  * caller must be doing a RENAME operation and so is passing
1366                  * a nlinks adjustment of 0, and only wishes to remove file
1367                  * in order to be able to reconnect it under a different name.
1368                  *
1369                  * In this situation we do a non-permanent deletion of the
1370                  * chain in order to allow the file to be reconnected in
1371                  * a different location.
1372                  */
1373                 KKASSERT(nlinks == 0);
1374                 hammer2_cluster_delete(trans, cparent, cluster, 0);
1375         }
1376         error = 0;
1377 done:
1378         if (cparent)
1379                 hammer2_cluster_unlock(cparent);
1380         if (cluster)
1381                 hammer2_cluster_unlock(cluster);
1382         if (hparent)
1383                 hammer2_cluster_unlock(hparent);
1384         if (hcluster)
1385                 hammer2_cluster_unlock(hcluster);
1386         if (hlinkp)
1387                 *hlinkp = hlink;
1388
1389         return error;
1390 }
1391
1392 /*
1393  * This is called from the mount code to initialize pmp->ihidden
1394  */
1395 void
1396 hammer2_inode_install_hidden(hammer2_pfsmount_t *pmp)
1397 {
1398         hammer2_trans_t trans;
1399         hammer2_cluster_t *cparent;
1400         hammer2_cluster_t *cluster;
1401         hammer2_cluster_t *scan;
1402         const hammer2_inode_data_t *ripdata;
1403         hammer2_inode_data_t *wipdata;
1404         hammer2_key_t key_dummy;
1405         hammer2_key_t key_next;
1406         int ddflag;
1407         int error;
1408         int count;
1409         int dip_check_algo;
1410         int dip_comp_algo;
1411
1412         if (pmp->ihidden)
1413                 return;
1414
1415         /*
1416          * Find the hidden directory
1417          */
1418         bzero(&key_dummy, sizeof(key_dummy));
1419         hammer2_trans_init(&trans, pmp, 0);
1420
1421         /*
1422          * Setup for lookup, retrieve iroot's check and compression
1423          * algorithm request which was likely generated by newfs_hammer2.
1424          *
1425          * The check/comp fields will probably never be used since inodes
1426          * are renamed into the hidden directory and not created relative to
1427          * the hidden directory, chain creation inherits from bref.methods,
1428          * and data chains inherit from their respective file inode *_algo
1429          * fields.
1430          */
1431         cparent = hammer2_inode_lock_ex(pmp->iroot);
1432         ripdata = &hammer2_cluster_data(cparent)->ipdata;
1433         dip_check_algo = ripdata->check_algo;
1434         dip_comp_algo = ripdata->comp_algo;
1435         ripdata = NULL;
1436
1437         cluster = hammer2_cluster_lookup(cparent, &key_dummy,
1438                                          HAMMER2_INODE_HIDDENDIR,
1439                                          HAMMER2_INODE_HIDDENDIR,
1440                                          0, &ddflag);
1441         if (cluster) {
1442                 pmp->ihidden = hammer2_inode_get(pmp, pmp->iroot, cluster);
1443                 hammer2_inode_ref(pmp->ihidden);
1444
1445                 /*
1446                  * Remove any unlinked files which were left open as-of
1447                  * any system crash.
1448                  *
1449                  * Don't pass NODATA, we need the inode data so the delete
1450                  * can do proper statistics updates.
1451                  */
1452                 count = 0;
1453                 scan = hammer2_cluster_lookup(cluster, &key_next,
1454                                               0, HAMMER2_TID_MAX,
1455                                               0, &ddflag);
1456                 while (scan) {
1457                         if (hammer2_cluster_type(scan) ==
1458                             HAMMER2_BREF_TYPE_INODE) {
1459                                 hammer2_cluster_delete(&trans, cluster, scan,
1460                                                    HAMMER2_DELETE_PERMANENT);
1461                                 ++count;
1462                         }
1463                         scan = hammer2_cluster_next(cluster, scan, &key_next,
1464                                                     0, HAMMER2_TID_MAX, 0);
1465                 }
1466
1467                 hammer2_inode_unlock_ex(pmp->ihidden, cluster);
1468                 hammer2_inode_unlock_ex(pmp->iroot, cparent);
1469                 hammer2_trans_done(&trans);
1470                 kprintf("hammer2: PFS loaded hidden dir, "
1471                         "removed %d dead entries\n", count);
1472                 return;
1473         }
1474
1475         /*
1476          * Create the hidden directory
1477          */
1478         error = hammer2_cluster_create(&trans, cparent, &cluster,
1479                                        HAMMER2_INODE_HIDDENDIR, 0,
1480                                        HAMMER2_BREF_TYPE_INODE,
1481                                        HAMMER2_INODE_BYTES,
1482                                        0);
1483         hammer2_inode_unlock_ex(pmp->iroot, cparent);
1484
1485         hammer2_cluster_modify(&trans, cluster, 0);
1486         wipdata = &hammer2_cluster_wdata(cluster)->ipdata;
1487         wipdata->type = HAMMER2_OBJTYPE_DIRECTORY;
1488         wipdata->inum = HAMMER2_INODE_HIDDENDIR;
1489         wipdata->nlinks = 1;
1490         wipdata->comp_algo = dip_comp_algo;
1491         wipdata->check_algo = dip_check_algo;
1492         hammer2_cluster_modsync(cluster);
1493         kprintf("hammer2: PFS root missing hidden directory, creating\n");
1494
1495         pmp->ihidden = hammer2_inode_get(pmp, pmp->iroot, cluster);
1496         hammer2_inode_ref(pmp->ihidden);
1497         hammer2_inode_unlock_ex(pmp->ihidden, cluster);
1498         hammer2_trans_done(&trans);
1499 }
1500
1501 /*
1502  * If an open file is unlinked H2 needs to retain the file in the topology
1503  * to ensure that its backing store is not recovered by the bulk free scan.
1504  * This also allows us to avoid having to special-case the CHAIN_DELETED flag.
1505  *
1506  * To do this the file is moved to a hidden directory in the PFS root and
1507  * renamed.  The hidden directory must be created if it does not exist.
1508  */
1509 static
1510 void
1511 hammer2_inode_move_to_hidden(hammer2_trans_t *trans,
1512                              hammer2_cluster_t **cparentp,
1513                              hammer2_cluster_t **clusterp,
1514                              hammer2_tid_t inum)
1515 {
1516         hammer2_cluster_t *dcluster;
1517         hammer2_pfsmount_t *pmp;
1518         int error;
1519
1520         pmp = (*clusterp)->pmp;
1521         KKASSERT(pmp != NULL);
1522         KKASSERT(pmp->ihidden != NULL);
1523
1524         hammer2_cluster_delete(trans, *cparentp, *clusterp, 0);
1525         dcluster = hammer2_inode_lock_ex(pmp->ihidden);
1526         error = hammer2_inode_connect(trans, clusterp, 0,
1527                                       pmp->ihidden, dcluster,
1528                                       NULL, 0, inum);
1529         hammer2_inode_unlock_ex(pmp->ihidden, dcluster);
1530         KKASSERT(error == 0);
1531 }
1532
1533 /*
1534  * Given an exclusively locked inode and cluster we consolidate the cluster
1535  * for hardlink creation, adding (nlinks) to the file's link count and
1536  * potentially relocating the inode to (cdip) which is a parent directory
1537  * common to both the current location of the inode and the intended new
1538  * hardlink.
1539  *
1540  * Replaces (*clusterp) if consolidation occurred, unlocking the old cluster
1541  * and returning a new locked cluster.
1542  *
1543  * NOTE!  This function will also replace ip->cluster.
1544  */
1545 int
1546 hammer2_hardlink_consolidate(hammer2_trans_t *trans,
1547                              hammer2_inode_t *ip,
1548                              hammer2_cluster_t **clusterp,
1549                              hammer2_inode_t *cdip,
1550                              hammer2_cluster_t *cdcluster,
1551                              int nlinks)
1552 {
1553         const hammer2_inode_data_t *ripdata;
1554         hammer2_inode_data_t *wipdata;
1555         hammer2_cluster_t *cluster;
1556         hammer2_cluster_t *cparent;
1557         int error;
1558
1559         cluster = *clusterp;
1560         ripdata = &hammer2_cluster_data(cluster)->ipdata;
1561         if (nlinks == 0 &&                      /* no hardlink needed */
1562             (ripdata->name_key & HAMMER2_DIRHASH_VISIBLE)) {
1563                 return (0);
1564         }
1565
1566         if (hammer2_hardlink_enable == 0) {     /* disallow hardlinks */
1567                 hammer2_cluster_unlock(cluster);
1568                 *clusterp = NULL;
1569                 return (ENOTSUP);
1570         }
1571
1572         cparent = NULL;
1573
1574         /*
1575          * If no change in the hardlink's target directory is required and
1576          * this is already a hardlink target, all we need to do is adjust
1577          * the link count.
1578          */
1579         ripdata = &hammer2_cluster_data(cluster)->ipdata;
1580         if (cdip == ip->pip &&
1581             (ripdata->name_key & HAMMER2_DIRHASH_VISIBLE) == 0) {
1582                 if (nlinks) {
1583                         hammer2_cluster_modify(trans, cluster, 0);
1584                         wipdata = &hammer2_cluster_wdata(cluster)->ipdata;
1585                         wipdata->nlinks += nlinks;
1586                         hammer2_cluster_modsync(cluster);
1587                         ripdata = wipdata;
1588                 }
1589                 error = 0;
1590                 goto done;
1591         }
1592
1593         /*
1594          * Cluster is the real inode.  The originating directory is locked
1595          * by the caller so we can manipulate it without worrying about races
1596          * against other lookups.
1597          *
1598          * If cluster is visible we need to delete it from the current
1599          * location and create a hardlink pointer in its place.  If it is
1600          * not visible we need only delete it.  Then later cluster will be
1601          * renamed to a parent directory and converted (if necessary) to
1602          * a hidden inode (via shiftup).
1603          *
1604          * NOTE! We must hold cparent locked through the delete/create/rename
1605          *       operation to ensure that other threads block resolving to
1606          *       the same hardlink, otherwise the other threads may not see
1607          *       the hardlink.
1608          */
1609         KKASSERT((cluster->focus->flags & HAMMER2_CHAIN_DELETED) == 0);
1610         cparent = hammer2_cluster_parent(cluster);
1611
1612         hammer2_cluster_delete(trans, cparent, cluster, 0);
1613
1614         ripdata = &hammer2_cluster_data(cluster)->ipdata;
1615         KKASSERT(ripdata->type != HAMMER2_OBJTYPE_HARDLINK);
1616         if (ripdata->name_key & HAMMER2_DIRHASH_VISIBLE) {
1617                 hammer2_cluster_t *ncluster;
1618                 hammer2_key_t lhc;
1619
1620                 ncluster = NULL;
1621                 lhc = cluster->focus->bref.key;
1622                 error = hammer2_cluster_create(trans, cparent, &ncluster,
1623                                              lhc, 0,
1624                                              HAMMER2_BREF_TYPE_INODE,
1625                                              HAMMER2_INODE_BYTES,
1626                                              0);
1627                 hammer2_cluster_modify(trans, ncluster, 0);
1628                 wipdata = &hammer2_cluster_wdata(ncluster)->ipdata;
1629
1630                 /* wipdata->comp_algo = ripdata->comp_algo; */
1631                 wipdata->comp_algo = 0;
1632                 wipdata->check_algo = 0;
1633                 wipdata->version = HAMMER2_INODE_VERSION_ONE;
1634                 wipdata->inum = ripdata->inum;
1635                 wipdata->target_type = ripdata->type;
1636                 wipdata->type = HAMMER2_OBJTYPE_HARDLINK;
1637                 wipdata->uflags = 0;
1638                 wipdata->rmajor = 0;
1639                 wipdata->rminor = 0;
1640                 wipdata->ctime = 0;
1641                 wipdata->mtime = 0;
1642                 wipdata->atime = 0;
1643                 wipdata->btime = 0;
1644                 bzero(&wipdata->uid, sizeof(wipdata->uid));
1645                 bzero(&wipdata->gid, sizeof(wipdata->gid));
1646                 wipdata->op_flags = HAMMER2_OPFLAG_DIRECTDATA;
1647                 wipdata->cap_flags = 0;
1648                 wipdata->mode = 0;
1649                 wipdata->size = 0;
1650                 wipdata->nlinks = 1;
1651                 wipdata->iparent = 0;   /* XXX */
1652                 wipdata->pfs_type = 0;
1653                 wipdata->pfs_inum = 0;
1654                 bzero(&wipdata->pfs_clid, sizeof(wipdata->pfs_clid));
1655                 bzero(&wipdata->pfs_fsid, sizeof(wipdata->pfs_fsid));
1656                 wipdata->data_quota = 0;
1657                 wipdata->data_count = 0;
1658                 wipdata->inode_quota = 0;
1659                 wipdata->inode_count = 0;
1660                 wipdata->attr_tid = 0;
1661                 wipdata->dirent_tid = 0;
1662                 bzero(&wipdata->u, sizeof(wipdata->u));
1663                 bcopy(ripdata->filename, wipdata->filename, ripdata->name_len);
1664                 wipdata->name_key = ncluster->focus->bref.key;
1665                 wipdata->name_len = ripdata->name_len;
1666                 /* XXX transaction ids */
1667                 hammer2_cluster_modsync(ncluster);
1668                 hammer2_cluster_unlock(ncluster);
1669         }
1670         ripdata = wipdata;
1671
1672         /*
1673          * cluster represents the hardlink target and is now flagged deleted.
1674          * duplicate it to the parent directory and adjust nlinks.
1675          *
1676          * WARNING! The shiftup() call can cause ncluster to be moved into
1677          *          an indirect block, and our ncluster will wind up pointing
1678          *          to the older/original version.
1679          */
1680         KKASSERT(cluster->focus->flags & HAMMER2_CHAIN_DELETED);
1681         hammer2_hardlink_shiftup(trans, cluster, cdip, cdcluster,
1682                                  nlinks, &error);
1683
1684         if (error == 0)
1685                 hammer2_inode_repoint(ip, cdip, cluster);
1686
1687 done:
1688         /*
1689          * Cleanup, cluster/ncluster already dealt with.
1690          *
1691          * Return the shifted cluster in *clusterp.
1692          */
1693         if (cparent)
1694                 hammer2_cluster_unlock(cparent);
1695         *clusterp = cluster;
1696
1697         return (error);
1698 }
1699
1700 /*
1701  * If (*ochainp) is non-NULL it points to the forward OBJTYPE_HARDLINK
1702  * inode while (*chainp) points to the resolved (hidden hardlink
1703  * target) inode.  In this situation when nlinks is 1 we wish to
1704  * deconsolidate the hardlink, moving it back to the directory that now
1705  * represents the only remaining link.
1706  */
1707 int
1708 hammer2_hardlink_deconsolidate(hammer2_trans_t *trans,
1709                                hammer2_inode_t *dip,
1710                                hammer2_chain_t **chainp,
1711                                hammer2_chain_t **ochainp)
1712 {
1713         if (*ochainp == NULL)
1714                 return (0);
1715         /* XXX */
1716         return (0);
1717 }
1718
1719 /*
1720  * The caller presents a locked cluster with an obj_type of
1721  * HAMMER2_OBJTYPE_HARDLINK.  This routine will locate and replace the
1722  * cluster with the target hardlink, also locked.
1723  *
1724  * If cparentp is not NULL a locked cluster representing the hardlink's
1725  * parent is also returned.
1726  *
1727  * If we are unable to locate the hardlink target EIO is returned and
1728  * (*cparentp) is set to NULL.  The passed-in cluster still needs to be
1729  * unlocked by the caller but will be degenerate... not have any chains.
1730  */
1731 int
1732 hammer2_hardlink_find(hammer2_inode_t *dip,
1733                       hammer2_cluster_t **cparentp, hammer2_cluster_t *cluster)
1734 {
1735         const hammer2_inode_data_t *ipdata;
1736         hammer2_cluster_t *cparent;
1737         hammer2_cluster_t *rcluster;
1738         hammer2_inode_t *ip;
1739         hammer2_inode_t *pip;
1740         hammer2_key_t key_dummy;
1741         hammer2_key_t lhc;
1742         int ddflag;
1743
1744         pip = dip;
1745         hammer2_inode_ref(pip);         /* for loop */
1746
1747         /*
1748          * Locate the hardlink.  pip is referenced and not locked.
1749          */
1750         ipdata = &hammer2_cluster_data(cluster)->ipdata;
1751         lhc = ipdata->inum;
1752
1753         /*
1754          * We don't need the cluster's chains, but we need to retain the
1755          * cluster structure itself so we can load the hardlink search
1756          * result into it.
1757          */
1758         KKASSERT(cluster->refs == 1);
1759         atomic_add_int(&cluster->refs, 1);
1760         hammer2_cluster_unlock(cluster);        /* hack */
1761         cluster->nchains = 0;                   /* hack */
1762
1763         rcluster = NULL;
1764         cparent = NULL;
1765
1766         while ((ip = pip) != NULL) {
1767                 cparent = hammer2_inode_lock_ex(ip);
1768                 hammer2_inode_drop(ip);                 /* loop */
1769                 KKASSERT(hammer2_cluster_type(cparent) ==
1770                          HAMMER2_BREF_TYPE_INODE);
1771                 rcluster = hammer2_cluster_lookup(cparent, &key_dummy,
1772                                              lhc, lhc, 0, &ddflag);
1773                 if (rcluster)
1774                         break;
1775                 hammer2_cluster_lookup_done(cparent);   /* discard parent */
1776                 cparent = NULL;                         /* safety */
1777                 pip = ip->pip;          /* safe, ip held locked */
1778                 if (pip)
1779                         hammer2_inode_ref(pip);         /* loop */
1780                 hammer2_inode_unlock_ex(ip, NULL);
1781         }
1782
1783         /*
1784          * chain is locked, ip is locked.  Unlock ip, return the locked
1785          * chain.  *ipp is already set w/a ref count and not locked.
1786          *
1787          * (cparent is already unlocked).
1788          */
1789         if (rcluster) {
1790                 hammer2_cluster_replace(cluster, rcluster);
1791                 hammer2_cluster_drop(rcluster);
1792                 if (cparentp) {
1793                         *cparentp = cparent;
1794                         hammer2_inode_unlock_ex(ip, NULL);
1795                 } else {
1796                         hammer2_inode_unlock_ex(ip, cparent);
1797                 }
1798                 return (0);
1799         } else {
1800                 if (cparentp)
1801                         *cparentp = NULL;
1802                 if (ip)
1803                         hammer2_inode_unlock_ex(ip, cparent);
1804                 return (EIO);
1805         }
1806 }
1807
1808 /*
1809  * Find the directory common to both fdip and tdip.
1810  *
1811  * Returns a held but not locked inode.  Caller typically locks the inode,
1812  * and when through unlocks AND drops it.
1813  */
1814 hammer2_inode_t *
1815 hammer2_inode_common_parent(hammer2_inode_t *fdip, hammer2_inode_t *tdip)
1816 {
1817         hammer2_inode_t *scan1;
1818         hammer2_inode_t *scan2;
1819
1820         /*
1821          * We used to have a depth field but it complicated matters too
1822          * much for directory renames.  So now its ugly.  Check for
1823          * simple cases before giving up and doing it the expensive way.
1824          *
1825          * XXX need a bottom-up topology stability lock
1826          */
1827         if (fdip == tdip || fdip == tdip->pip) {
1828                 hammer2_inode_ref(fdip);
1829                 return(fdip);
1830         }
1831         if (fdip->pip == tdip) {
1832                 hammer2_inode_ref(tdip);
1833                 return(tdip);
1834         }
1835
1836         /*
1837          * XXX not MPSAFE
1838          */
1839         for (scan1 = fdip; scan1->pmp == fdip->pmp; scan1 = scan1->pip) {
1840                 scan2 = tdip;
1841                 while (scan2->pmp == tdip->pmp) {
1842                         if (scan1 == scan2) {
1843                                 hammer2_inode_ref(scan1);
1844                                 return(scan1);
1845                         }
1846                         scan2 = scan2->pip;
1847                         if (scan2 == NULL)
1848                                 break;
1849                 }
1850         }
1851         panic("hammer2_inode_common_parent: no common parent %p %p\n",
1852               fdip, tdip);
1853         /* NOT REACHED */
1854         return(NULL);
1855 }
1856
1857 /*
1858  * Synchronize the inode's frontend state with the chain state prior
1859  * to any explicit flush of the inode or any strategy write call.
1860  *
1861  * Called with a locked inode.
1862  */
1863 void
1864 hammer2_inode_fsync(hammer2_trans_t *trans, hammer2_inode_t *ip,
1865                     hammer2_cluster_t *cparent)
1866 {
1867         const hammer2_inode_data_t *ripdata;
1868         hammer2_inode_data_t *wipdata;
1869         hammer2_cluster_t *dparent;
1870         hammer2_cluster_t *cluster;
1871         hammer2_key_t lbase;
1872         hammer2_key_t key_next;
1873         int dosync = 0;
1874         int ddflag;
1875
1876         ripdata = &hammer2_cluster_data(cparent)->ipdata;    /* target file */
1877
1878         if (ip->flags & HAMMER2_INODE_MTIME) {
1879                 wipdata = hammer2_cluster_modify_ip(trans, ip, cparent, 0);
1880                 atomic_clear_int(&ip->flags, HAMMER2_INODE_MTIME);
1881                 wipdata->mtime = ip->mtime;
1882                 dosync = 1;
1883                 ripdata = wipdata;
1884         }
1885         if ((ip->flags & HAMMER2_INODE_RESIZED) && ip->size < ripdata->size) {
1886                 wipdata = hammer2_cluster_modify_ip(trans, ip, cparent, 0);
1887                 wipdata->size = ip->size;
1888                 dosync = 1;
1889                 ripdata = wipdata;
1890                 atomic_clear_int(&ip->flags, HAMMER2_INODE_RESIZED);
1891
1892                 /*
1893                  * We must delete any chains beyond the EOF.  The chain
1894                  * straddling the EOF will be pending in the bioq.
1895                  */
1896                 lbase = (ripdata->size + HAMMER2_PBUFMASK64) &
1897                         ~HAMMER2_PBUFMASK64;
1898                 dparent = hammer2_cluster_lookup_init(&ip->cluster, 0);
1899                 cluster = hammer2_cluster_lookup(dparent, &key_next,
1900                                                  lbase, (hammer2_key_t)-1,
1901                                                  HAMMER2_LOOKUP_NODATA,
1902                                                  &ddflag);
1903                 while (cluster) {
1904                         /*
1905                          * Degenerate embedded case, nothing to loop on
1906                          */
1907                         switch (hammer2_cluster_type(cluster)) {
1908                         case HAMMER2_BREF_TYPE_INODE:
1909                                 hammer2_cluster_unlock(cluster);
1910                                 cluster = NULL;
1911                                 break;
1912                         case HAMMER2_BREF_TYPE_DATA:
1913                                 hammer2_cluster_delete(trans, dparent, cluster,
1914                                                    HAMMER2_DELETE_PERMANENT);
1915                                 /* fall through */
1916                         default:
1917                                 cluster = hammer2_cluster_next(dparent, cluster,
1918                                                    &key_next,
1919                                                    key_next, (hammer2_key_t)-1,
1920                                                    HAMMER2_LOOKUP_NODATA);
1921                                 break;
1922                         }
1923                 }
1924                 hammer2_cluster_lookup_done(dparent);
1925         } else
1926         if ((ip->flags & HAMMER2_INODE_RESIZED) && ip->size > ripdata->size) {
1927                 wipdata = hammer2_cluster_modify_ip(trans, ip, cparent, 0);
1928                 wipdata->size = ip->size;
1929                 atomic_clear_int(&ip->flags, HAMMER2_INODE_RESIZED);
1930
1931                 /*
1932                  * When resizing larger we may not have any direct-data
1933                  * available.
1934                  */
1935                 if ((wipdata->op_flags & HAMMER2_OPFLAG_DIRECTDATA) &&
1936                     ip->size > HAMMER2_EMBEDDED_BYTES) {
1937                         wipdata->op_flags &= ~HAMMER2_OPFLAG_DIRECTDATA;
1938                         bzero(&wipdata->u.blockset,
1939                               sizeof(wipdata->u.blockset));
1940                 }
1941                 dosync = 1;
1942                 ripdata = wipdata;
1943         }
1944         if (dosync)
1945                 hammer2_cluster_modsync(cparent);
1946 }