sys/vfs/hammer2/hammer2_xops.c

   1 /*
   2  * Copyright (c) 2011-2015 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  * by Daniel Flores (GSOC 2013 - mentored by Matthew Dillon, compression)
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  * 3. Neither the name of The DragonFly Project nor the names of its
  20  *    contributors may be used to endorse or promote products derived
  21  *    from this software without specific, prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  26  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  27  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  28  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  29  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  30  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  31  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  32  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  33  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  */
  36 /*
  37  * Per-node backend for kernel filesystem interface.
  38  *
  39  * This executes a VOP concurrently on multiple nodes, each node via its own
  40  * thread, and competes to advance the original request.  The original
  41  * request is retired the moment all requirements are met, even if the
  42  * operation is still in-progress on some nodes.
  43  */
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46 #include <sys/kernel.h>
  47 #include <sys/fcntl.h>
  48 #include <sys/buf.h>
  49 #include <sys/proc.h>
  50 #include <sys/namei.h>
  51 #include <sys/mount.h>
  52 #include <sys/vnode.h>
  53 #include <sys/mountctl.h>
  54 #include <sys/dirent.h>
  55 #include <sys/uio.h>
  56 #include <sys/objcache.h>
  57 #include <sys/event.h>
  58 #include <sys/file.h>
  59 #include <vfs/fifofs/fifo.h>
  60
  61 #include "hammer2.h"
  62
  63 /*
  64  * Determine if the specified directory is empty.  Returns 0 on success.
  65  */
  66 static
  67 int
  68 checkdirempty(hammer2_chain_t *orig_parent)
  69 {
  70         hammer2_chain_t *parent;
  71         hammer2_chain_t *chain;
  72         hammer2_key_t key_next;
  73         int cache_index = -1;
  74         int error;
  75
  76         parent = hammer2_chain_lookup_init(orig_parent, 0);
  77         chain = hammer2_chain_lookup(&parent, &key_next,
  78                                      HAMMER2_DIRHASH_VISIBLE,
  79                                      HAMMER2_KEY_MAX,
  80                                      &cache_index, 0);
  81         error = chain ? ENOTEMPTY : 0;
  82         if (chain) {
  83                 hammer2_chain_unlock(chain);
  84                 hammer2_chain_drop(chain);
  85         }
  86         hammer2_chain_lookup_done(parent);
  87
  88         return error;
  89 }
  90
  91 /*
  92  * Backend for hammer2_vfs_root()
  93  *
  94  * This is called when a newly mounted PFS has not yet synchronized
  95  * to the inode_tid and modify_tid.
  96  */
  97 void
  98 hammer2_xop_ipcluster(hammer2_xop_t *arg, int clindex)
  99 {
 100         hammer2_xop_ipcluster_t *xop = &arg->xop_ipcluster;
 101         hammer2_chain_t *chain;
 102         int error;
 103
 104         chain = hammer2_inode_chain(xop->head.ip1, clindex,
 105                                     HAMMER2_RESOLVE_ALWAYS |
 106                                     HAMMER2_RESOLVE_SHARED);
 107         if (chain)
 108                 error = chain->error;
 109         else
 110                 error = EIO;
 111
 112         hammer2_xop_feed(&xop->head, chain, clindex, error);
 113         if (chain) {
 114                 hammer2_chain_unlock(chain);
 115                 hammer2_chain_drop(chain);
 116         }
 117 }
 118
 119 /*
 120  * Backend for hammer2_vop_readdir()
 121  */
 122 void
 123 hammer2_xop_readdir(hammer2_xop_t *arg, int clindex)
 124 {
 125         hammer2_xop_readdir_t *xop = &arg->xop_readdir;
 126         hammer2_chain_t *parent;
 127         hammer2_chain_t *chain;
 128         hammer2_key_t key_next;
 129         hammer2_key_t lkey;
 130         int cache_index = -1;
 131         int error = 0;
 132
 133         lkey = xop->lkey;
 134         if (hammer2_debug & 0x0020)
 135                 kprintf("xop_readdir %p lkey=%016jx\n", xop, lkey);
 136
 137         /*
 138          * The inode's chain is the iterator.  If we cannot acquire it our
 139          * contribution ends here.
 140          */
 141         parent = hammer2_inode_chain(xop->head.ip1, clindex,
 142                                      HAMMER2_RESOLVE_ALWAYS |
 143                                      HAMMER2_RESOLVE_SHARED);
 144         if (parent == NULL) {
 145                 kprintf("xop_readdir: NULL parent\n");
 146                 goto done;
 147         }
 148
 149         /*
 150          * Directory scan [re]start and loop, the feed inherits the chain's
 151          * lock so do not unlock it on the iteration.
 152          */
 153         chain = hammer2_chain_lookup(&parent, &key_next, lkey, lkey,
 154                                      &cache_index, HAMMER2_LOOKUP_SHARED);
 155         if (chain == NULL) {
 156                 chain = hammer2_chain_lookup(&parent, &key_next,
 157                                              lkey, HAMMER2_KEY_MAX,
 158                                              &cache_index,
 159                                              HAMMER2_LOOKUP_SHARED);
 160         }
 161         while (chain) {
 162                 error = hammer2_xop_feed(&xop->head, chain, clindex, 0);
 163                 if (error)
 164                         break;
 165                 chain = hammer2_chain_next(&parent, chain, &key_next,
 166                                            key_next, HAMMER2_KEY_MAX,
 167                                            &cache_index,
 168                                            HAMMER2_LOOKUP_SHARED);
 169         }
 170         if (chain) {
 171                 hammer2_chain_unlock(chain);
 172                 hammer2_chain_drop(chain);
 173         }
 174         hammer2_chain_unlock(parent);
 175         hammer2_chain_drop(parent);
 176 done:
 177         hammer2_xop_feed(&xop->head, NULL, clindex, error);
 178 }
 179
 180 /*
 181  * Backend for hammer2_vop_nresolve()
 182  */
 183 void
 184 hammer2_xop_nresolve(hammer2_xop_t *arg, int clindex)
 185 {
 186         hammer2_xop_nresolve_t *xop = &arg->xop_nresolve;
 187         hammer2_chain_t *parent;
 188         hammer2_chain_t *chain;
 189         const hammer2_inode_data_t *ripdata;
 190         const char *name;
 191         size_t name_len;
 192         hammer2_key_t key_next;
 193         hammer2_key_t lhc;
 194         int cache_index = -1;   /* XXX */
 195         int error;
 196
 197         parent = hammer2_inode_chain(xop->head.ip1, clindex,
 198                                      HAMMER2_RESOLVE_ALWAYS |
 199                                      HAMMER2_RESOLVE_SHARED);
 200         if (parent == NULL) {
 201                 kprintf("xop_nresolve: NULL parent\n");
 202                 chain = NULL;
 203                 error = EIO;
 204                 goto done;
 205         }
 206         name = xop->head.name1;
 207         name_len = xop->head.name1_len;
 208
 209         /*
 210          * Lookup the directory entry
 211          */
 212         lhc = hammer2_dirhash(name, name_len);
 213         chain = hammer2_chain_lookup(&parent, &key_next,
 214                                      lhc, lhc + HAMMER2_DIRHASH_LOMASK,
 215                                      &cache_index,
 216                                      HAMMER2_LOOKUP_ALWAYS |
 217                                      HAMMER2_LOOKUP_SHARED);
 218         while (chain) {
 219                 ripdata = &chain->data->ipdata;
 220                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE &&
 221                     ripdata->meta.name_len == name_len &&
 222                     bcmp(ripdata->filename, name, name_len) == 0) {
 223                         break;
 224                 }
 225                 chain = hammer2_chain_next(&parent, chain, &key_next,
 226                                            key_next,
 227                                            lhc + HAMMER2_DIRHASH_LOMASK,
 228                                            &cache_index,
 229                                            HAMMER2_LOOKUP_ALWAYS |
 230                                            HAMMER2_LOOKUP_SHARED);
 231         }
 232
 233         /*
 234          * If the entry is a hardlink pointer, resolve it.
 235          */
 236         error = 0;
 237         if (chain) {
 238                 if (chain->data->ipdata.meta.type == HAMMER2_OBJTYPE_HARDLINK) {
 239                         error = hammer2_chain_hardlink_find(
 240                                                 xop->head.ip1,
 241                                                 &parent, &chain,
 242                                                 HAMMER2_LOOKUP_SHARED);
 243                 }
 244         }
 245 done:
 246         error = hammer2_xop_feed(&xop->head, chain, clindex, error);
 247         if (chain) {
 248                 hammer2_chain_unlock(chain);
 249                 hammer2_chain_drop(chain);
 250         }
 251         if (parent) {
 252                 hammer2_chain_unlock(parent);
 253                 hammer2_chain_drop(parent);
 254         }
 255 }
 256
 257 /*
 258  * Backend for hammer2_vop_nremove(), hammer2_vop_nrmdir(), and helper
 259  * for hammer2_vop_nrename().
 260  *
 261  * This function locates and removes the directory entry.  If the
 262  * entry is a hardlink pointer, this function will also remove the
 263  * hardlink target if the target's nlinks is 1.
 264  *
 265  * The frontend is responsible for moving open inodes to the hidden directory
 266  * and for decrementing nlinks.
 267  */
 268 void
 269 hammer2_xop_unlink(hammer2_xop_t *arg, int clindex)
 270 {
 271         hammer2_xop_unlink_t *xop = &arg->xop_unlink;
 272         hammer2_chain_t *parent;
 273         hammer2_chain_t *chain;
 274         const hammer2_inode_data_t *ripdata;
 275         const char *name;
 276         size_t name_len;
 277         hammer2_key_t key_next;
 278         hammer2_key_t lhc;
 279         int cache_index = -1;   /* XXX */
 280         int error;
 281
 282         /*
 283          * Requires exclusive lock
 284          */
 285         parent = hammer2_inode_chain(xop->head.ip1, clindex,
 286                                      HAMMER2_RESOLVE_ALWAYS);
 287         chain = NULL;
 288         if (parent == NULL) {
 289                 kprintf("xop_nresolve: NULL parent\n");
 290                 error = EIO;
 291                 goto done;
 292         }
 293         name = xop->head.name1;
 294         name_len = xop->head.name1_len;
 295
 296         /*
 297          * Lookup the directory entry
 298          */
 299         lhc = hammer2_dirhash(name, name_len);
 300         chain = hammer2_chain_lookup(&parent, &key_next,
 301                                      lhc, lhc + HAMMER2_DIRHASH_LOMASK,
 302                                      &cache_index,
 303                                      HAMMER2_LOOKUP_ALWAYS);
 304         while (chain) {
 305                 ripdata = &chain->data->ipdata;
 306                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE &&
 307                     ripdata->meta.name_len == name_len &&
 308                     bcmp(ripdata->filename, name, name_len) == 0) {
 309                         break;
 310                 }
 311                 chain = hammer2_chain_next(&parent, chain, &key_next,
 312                                            key_next,
 313                                            lhc + HAMMER2_DIRHASH_LOMASK,
 314                                            &cache_index,
 315                                            HAMMER2_LOOKUP_ALWAYS);
 316         }
 317
 318         /*
 319          * If the directory entry is a HARDLINK pointer then obtain the
 320          * underlying file type for the directory typing tests and delete
 321          * the HARDLINK pointer chain permanently.  The frontend is left
 322          * responsible for handling nlinks on and deleting the actual inode.
 323          *
 324          * If the directory entry is the actual inode then use its type
 325          * for the directory typing tests and delete the chain, permanency
 326          * depends on whether the inode is open or not.
 327          *
 328          * Check directory typing and delete the entry.  Note that
 329          * nlinks adjustments are made on the real inode by the frontend,
 330          * not here.
 331          */
 332         error = 0;
 333         if (chain) {
 334                 int dopermanent = xop->dopermanent;
 335                 uint8_t type;
 336
 337                 type = chain->data->ipdata.meta.type;
 338                 if (type == HAMMER2_OBJTYPE_HARDLINK) {
 339                         type = chain->data->ipdata.meta.target_type;
 340                         dopermanent |= HAMMER2_DELETE_PERMANENT;
 341                 }
 342
 343                 if (type == HAMMER2_OBJTYPE_DIRECTORY &&
 344                     checkdirempty(chain) != 0) {
 345                         error = ENOTEMPTY;
 346                 } else if (type == HAMMER2_OBJTYPE_DIRECTORY &&
 347                     xop->isdir == 0) {
 348                         error = ENOTDIR;
 349                 } else
 350                 if (type != HAMMER2_OBJTYPE_DIRECTORY &&
 351                     xop->isdir >= 1) {
 352                         error = EISDIR;
 353                 } else {
 354                         /*
 355                          * This deletes the directory entry itself, which is
 356                          * also the inode when nlinks == 1.  Hardlink targets
 357                          * are handled in the next conditional.
 358                          */
 359                         error = chain->error;
 360                         hammer2_chain_delete(parent, chain,
 361                                              xop->head.mtid, dopermanent);
 362                 }
 363         }
 364
 365         /*
 366          * If the entry is a hardlink pointer, resolve it.  If this is the
 367          * last link, delete it.  The frontend has the master copy of nlinks
 368          * but we still have to make adjustments here to synchronize with it.
 369          *
 370          * On delete / adjust nlinks if there is no error.  But we still need
 371          * to resolve the hardlink to feed the inode's real chain back to
 372          * the frontend.
 373          *
 374          * XXX we are basically tracking the nlinks count by doing a delta
 375          *     adjustment instead of having the frontend pass the absolute
 376          *     value down.  We really need to have the frontend pass the
 377          *     absolute value down (difficult because there might not be
 378          *     an 'ip').  See also hammer2_xop_nlink().
 379          */
 380         if (chain &&
 381             chain->data->ipdata.meta.type == HAMMER2_OBJTYPE_HARDLINK) {
 382                 int error2;
 383
 384                 error2 = hammer2_chain_hardlink_find(xop->head.ip1,
 385                                                      &parent, &chain, 0);
 386                 if (chain && error == 0 && error2 == 0 &&
 387                     (int64_t)chain->data->ipdata.meta.nlinks <= 1) {
 388                         hammer2_chain_delete(parent, chain,
 389                                              xop->head.mtid,
 390                                              xop->dopermanent);
 391                 } else if (chain && error == 0 && error2 == 0) {
 392                         hammer2_chain_modify(chain, xop->head.mtid, 0, 0);
 393                         --chain->data->ipdata.meta.nlinks;
 394                 }
 395                 if (error == 0)
 396                         error = error2;
 397         }
 398
 399         /*
 400          * We always return the hardlink target (the real inode) for
 401          * further action.
 402          */
 403 done:
 404         hammer2_xop_feed(&xop->head, chain, clindex, error);
 405         if (chain) {
 406                 hammer2_chain_unlock(chain);
 407                 hammer2_chain_drop(chain);
 408                 chain = NULL;
 409         }
 410         if (parent) {
 411                 hammer2_chain_unlock(parent);
 412                 hammer2_chain_drop(parent);
 413                 parent = NULL;
 414         }
 415 }
 416
 417 #if 0
 418 /*
 419  * Backend for hammer2_vop_nlink() and hammer2_vop_nrename()
 420  *
 421  * ip1 - fdip
 422  * ip2 - ip
 423  * ip3 - cdip
 424  *
 425  * If a hardlink pointer:
 426  *      The existing hardlink target {fdip,ip} must be moved to another
 427  *      directory {cdip,ip}
 428  *
 429  * If not a hardlink pointer:
 430  *      Convert the target {fdip,ip} to a hardlink target {cdip,ip} and
 431  *      replace the original namespace {fdip,name} with a hardlink pointer.
 432  */
 433 void
 434 hammer2_xop_nlink(hammer2_xop_t *arg, int clindex)
 435 {
 436         hammer2_xop_nlink_t *xop = &arg->xop_nlink;
 437         hammer2_pfs_t *pmp;
 438         hammer2_inode_data_t *wipdata;
 439         hammer2_chain_t *parent;
 440         hammer2_chain_t *chain;
 441         hammer2_chain_t *tmp;
 442         hammer2_inode_t *ip;
 443         hammer2_key_t key_dummy;
 444         int cache_index = -1;
 445         int error;
 446         int did_delete = 0;
 447
 448         /*
 449          * We need the precise parent chain to issue the deletion.
 450          */
 451         ip = xop->head.ip2;
 452         pmp = ip->pmp;
 453         parent = hammer2_inode_chain(ip, clindex, HAMMER2_RESOLVE_ALWAYS);
 454         if (parent)
 455                 hammer2_chain_getparent(&parent, HAMMER2_RESOLVE_ALWAYS);
 456         if (parent == NULL) {
 457                 chain = NULL;
 458                 error = EIO;
 459                 goto done;
 460         }
 461         chain = hammer2_inode_chain(ip, clindex, HAMMER2_RESOLVE_ALWAYS);
 462         if (chain == NULL) {
 463                 error = EIO;
 464                 goto done;
 465         }
 466         KKASSERT(chain->parent == parent);
 467
 468         if (chain->data->ipdata.meta.name_key & HAMMER2_DIRHASH_VISIBLE) {
 469                 /*
 470                  * Delete the original chain and hold onto it for the move
 471                  * to cdir.
 472                  *
 473                  * Replace the namespace with a hardlink pointer if the
 474                  * chain being moved is not already a hardlink target.
 475                  */
 476                 hammer2_chain_delete(parent, chain, xop->head.mtid, 0);
 477                 did_delete = 1;
 478
 479                 tmp = NULL;
 480                 error = hammer2_chain_create(&parent, &tmp, pmp,
 481                                              chain->bref.key, 0,
 482                                              HAMMER2_BREF_TYPE_INODE,
 483                                              HAMMER2_INODE_BYTES,
 484                                              xop->head.mtid, 0, 0);
 485                 if (error)
 486                         goto done;
 487                 hammer2_chain_modify(tmp, xop->head.mtid, 0, 0);
 488                 wipdata = &tmp->data->ipdata;
 489                 bzero(wipdata, sizeof(*wipdata));
 490                 wipdata->meta.name_key = chain->data->ipdata.meta.name_key;
 491                 wipdata->meta.name_len = chain->data->ipdata.meta.name_len;
 492                 bcopy(chain->data->ipdata.filename, wipdata->filename,
 493                       chain->data->ipdata.meta.name_len);
 494                 wipdata->meta.target_type = chain->data->ipdata.meta.type;
 495                 wipdata->meta.type = HAMMER2_OBJTYPE_HARDLINK;
 496                 wipdata->meta.inum = ip->meta.inum;
 497                 wipdata->meta.version = HAMMER2_INODE_VERSION_ONE;
 498                 wipdata->meta.nlinks = 1;
 499                 wipdata->meta.op_flags = HAMMER2_OPFLAG_DIRECTDATA;
 500
 501                 hammer2_chain_unlock(tmp);
 502                 hammer2_chain_drop(tmp);
 503         } else if (xop->head.ip1 != xop->head.ip3) {
 504                 /*
 505                  * Delete the hardlink target so it can be moved
 506                  * to cdir.
 507                  */
 508                 hammer2_chain_delete(parent, chain, xop->head.mtid, 0);
 509                 did_delete = 1;
 510         } else {
 511                 /*
 512                  * Deletion not necessary (just a nlinks update).
 513                  */
 514                 did_delete = 0;
 515         }
 516
 517         hammer2_chain_unlock(parent);
 518         hammer2_chain_drop(parent);
 519         parent = NULL;
 520
 521         /*
 522          * Ok, back to the deleted chain.  We must reconnect this chain
 523          * as a hardlink target to cdir (ip3).
 524          *
 525          * WARNING! Frontend assumes filename length is 18 bytes.
 526          */
 527         if (did_delete) {
 528                 hammer2_chain_modify(chain, xop->head.mtid, 0, 0);
 529                 wipdata = &chain->data->ipdata;
 530                 ksnprintf(wipdata->filename, sizeof(wipdata->filename),
 531                           "0x%016jx", (intmax_t)ip->meta.inum);
 532                 wipdata->meta.name_len = strlen(wipdata->filename);
 533                 wipdata->meta.name_key = ip->meta.inum;
 534
 535                 /*
 536                  * We must seek parent properly for the create to reattach
 537                  * chain.  XXX just use chain->parent or
 538                  * inode_chain_and_parent() ?
 539                  */
 540                 parent = hammer2_inode_chain(xop->head.ip3, clindex,
 541                                              HAMMER2_RESOLVE_ALWAYS);
 542                 if (parent == NULL) {
 543                         error = EIO;
 544                         goto done;
 545                 }
 546                 tmp = hammer2_chain_lookup(&parent, &key_dummy,
 547                                            ip->meta.inum, ip->meta.inum,
 548                                            &cache_index, 0);
 549                 if (tmp) {
 550                         hammer2_chain_unlock(tmp);
 551                         hammer2_chain_drop(tmp);
 552                         error = EEXIST;
 553                         goto done;
 554                 }
 555                 error = hammer2_chain_create(&parent, &chain, pmp,
 556                                              wipdata->meta.name_key, 0,
 557                                              HAMMER2_BREF_TYPE_INODE,
 558                                              HAMMER2_INODE_BYTES,
 559                                              xop->head.mtid, 0, 0);
 560         } else {
 561                 error = 0;
 562         }
 563
 564         /*
 565          * Bump nlinks to synchronize with frontend.
 566          */
 567         if (xop->nlinks_delta) {
 568                 hammer2_chain_modify(chain, xop->head.mtid, 0, 0);
 569                 chain->data->ipdata.meta.nlinks += xop->nlinks_delta;
 570         }
 571
 572         /*
 573          * To avoid having to scan the collision space we can simply
 574          * reuse the inode's original name_key.  But ip->meta.name_key
 575          * may have already been updated by the front-end, so use xop->lhc.
 576          *
 577          * (frontend is responsible for fixing up ip->pip).
 578          */
 579 done:
 580         hammer2_xop_feed(&xop->head, NULL, clindex, error);
 581         if (parent) {
 582                 hammer2_chain_unlock(parent);
 583                 hammer2_chain_drop(parent);
 584         }
 585         if (chain) {
 586                 hammer2_chain_unlock(chain);
 587                 hammer2_chain_drop(chain);
 588         }
 589 }
 590 #endif
 591
 592 /*
 593  * Backend for hammer2_vop_nrename()
 594  *
 595  * This handles the final step of renaming, either renaming the
 596  * actual inode or renaming the hardlink pointer.
 597  */
 598 void
 599 hammer2_xop_nrename(hammer2_xop_t *arg, int clindex)
 600 {
 601         hammer2_xop_nrename_t *xop = &arg->xop_nrename;
 602         hammer2_pfs_t *pmp;
 603         hammer2_chain_t *parent;
 604         hammer2_chain_t *chain;
 605         hammer2_chain_t *tmp;
 606         hammer2_inode_t *ip;
 607         hammer2_key_t key_dummy;
 608         int cache_index = -1;
 609         int error;
 610
 611         /*
 612          * We need the precise parent chain to issue the deletion.
 613          *
 614          * If this is not a hardlink target we can act on the inode,
 615          * otherwise we have to locate the hardlink pointer.
 616          */
 617         ip = xop->head.ip2;
 618         pmp = ip->pmp;
 619         chain = NULL;
 620
 621         if (xop->ip_key & HAMMER2_DIRHASH_VISIBLE) {
 622                 /*
 623                  * Find ip's direct parent chain.
 624                  */
 625                 parent = hammer2_inode_chain(ip, clindex,
 626                                              HAMMER2_RESOLVE_ALWAYS);
 627                 if (parent)
 628                         hammer2_chain_getparent(&parent,
 629                                                 HAMMER2_RESOLVE_ALWAYS);
 630                 if (parent == NULL) {
 631                         error = EIO;
 632                         goto done;
 633                 }
 634                 chain = hammer2_inode_chain(ip, clindex,
 635                                             HAMMER2_RESOLVE_ALWAYS);
 636                 if (chain == NULL) {
 637                         error = EIO;
 638                         goto done;
 639                 }
 640         } else {
 641                 /*
 642                  * The hardlink pointer for the head.ip1 hardlink target
 643                  * is in fdip, do a namespace search.
 644                  */
 645                 const hammer2_inode_data_t *ripdata;
 646                 hammer2_key_t lhc;
 647                 hammer2_key_t key_next;
 648                 const char *name;
 649                 size_t name_len;
 650
 651                 parent = hammer2_inode_chain(xop->head.ip1, clindex,
 652                                              HAMMER2_RESOLVE_ALWAYS);
 653                 if (parent == NULL) {
 654                         kprintf("xop_nrename: NULL parent\n");
 655                         error = EIO;
 656                         goto done;
 657                 }
 658                 name = xop->head.name1;
 659                 name_len = xop->head.name1_len;
 660
 661                 /*
 662                  * Lookup the directory entry
 663                  */
 664                 lhc = hammer2_dirhash(name, name_len);
 665                 chain = hammer2_chain_lookup(&parent, &key_next,
 666                                              lhc, lhc + HAMMER2_DIRHASH_LOMASK,
 667                                              &cache_index,
 668                                              HAMMER2_LOOKUP_ALWAYS);
 669                 while (chain) {
 670                         ripdata = &chain->data->ipdata;
 671                         if (chain->bref.type == HAMMER2_BREF_TYPE_INODE &&
 672                             ripdata->meta.name_len == name_len &&
 673                             bcmp(ripdata->filename, name, name_len) == 0) {
 674                                 break;
 675                         }
 676                         chain = hammer2_chain_next(&parent, chain, &key_next,
 677                                                    key_next,
 678                                                    lhc + HAMMER2_DIRHASH_LOMASK,
 679                                                    &cache_index,
 680                                                    HAMMER2_LOOKUP_ALWAYS);
 681                 }
 682         }
 683
 684         if (chain == NULL) {
 685                 /* XXX shouldn't happen, but does under fsstress */
 686                 kprintf("hammer2_xop_rename: \"%s\" -> \"%s\"  ENOENT\n",
 687                         xop->head.name1,
 688                         xop->head.name2);
 689                 error = ENOENT;
 690                 goto done;
 691         }
 692
 693         /*
 694          * Delete it, then create it in the new namespace.
 695          */
 696         hammer2_chain_delete(parent, chain, xop->head.mtid, 0);
 697         hammer2_chain_unlock(parent);
 698         hammer2_chain_drop(parent);
 699         parent = NULL;          /* safety */
 700
 701         /*
 702          * Ok, back to the deleted chain.  We must reconnect this chain
 703          * to tdir (ip3).  The chain (a real inode or a hardlink pointer)
 704          * is not otherwise modified.
 705          *
 706          * Frontend is expected to replicate the same inode meta data
 707          * modifications.
 708          *
 709          * NOTE!  This chain may not represent the actual inode, it
 710          *        can be a hardlink pointer.
 711          *
 712          * XXX in-inode parent directory specification?
 713          */
 714         if (chain->data->ipdata.meta.name_key != xop->lhc ||
 715             xop->head.name1_len != xop->head.name2_len ||
 716             bcmp(xop->head.name1, xop->head.name2, xop->head.name1_len) != 0) {
 717                 hammer2_inode_data_t *wipdata;
 718
 719                 hammer2_chain_modify(chain, xop->head.mtid, 0, 0);
 720                 wipdata = &chain->data->ipdata;
 721
 722                 bzero(wipdata->filename, sizeof(wipdata->filename));
 723                 bcopy(xop->head.name2, wipdata->filename, xop->head.name2_len);
 724                 wipdata->meta.name_key = xop->lhc;
 725                 wipdata->meta.name_len = xop->head.name2_len;
 726         }
 727
 728         /*
 729          * We must seek parent properly for the create.
 730          */
 731         parent = hammer2_inode_chain(xop->head.ip3, clindex,
 732                                      HAMMER2_RESOLVE_ALWAYS);
 733         if (parent == NULL) {
 734                 error = EIO;
 735                 goto done;
 736         }
 737         tmp = hammer2_chain_lookup(&parent, &key_dummy,
 738                                    xop->lhc, xop->lhc,
 739                                    &cache_index, 0);
 740         if (tmp) {
 741                 hammer2_chain_unlock(tmp);
 742                 hammer2_chain_drop(tmp);
 743                 error = EEXIST;
 744                 goto done;
 745         }
 746
 747         error = hammer2_chain_create(&parent, &chain, pmp,
 748                                      xop->lhc, 0,
 749                                      HAMMER2_BREF_TYPE_INODE,
 750                                      HAMMER2_INODE_BYTES,
 751                                      xop->head.mtid, 0, 0);
 752         /*
 753          * (frontend is responsible for fixing up ip->pip).
 754          */
 755 done:
 756         hammer2_xop_feed(&xop->head, NULL, clindex, error);
 757         if (parent) {
 758                 hammer2_chain_unlock(parent);
 759                 hammer2_chain_drop(parent);
 760         }
 761         if (chain) {
 762                 hammer2_chain_unlock(chain);
 763                 hammer2_chain_drop(chain);
 764         }
 765 }
 766
 767 /*
 768  * Directory collision resolver scan helper (backend, threaded).
 769  *
 770  * Used by the inode create code to locate an unused lhc.
 771  */
 772 void
 773 hammer2_xop_scanlhc(hammer2_xop_t *arg, int clindex)
 774 {
 775         hammer2_xop_scanlhc_t *xop = &arg->xop_scanlhc;
 776         hammer2_chain_t *parent;
 777         hammer2_chain_t *chain;
 778         hammer2_key_t key_next;
 779         int cache_index = -1;   /* XXX */
 780         int error = 0;
 781
 782         parent = hammer2_inode_chain(xop->head.ip1, clindex,
 783                                      HAMMER2_RESOLVE_ALWAYS |
 784                                      HAMMER2_RESOLVE_SHARED);
 785         if (parent == NULL) {
 786                 kprintf("xop_nresolve: NULL parent\n");
 787                 chain = NULL;
 788                 error = EIO;
 789                 goto done;
 790         }
 791
 792         /*
 793          * Lookup all possibly conflicting directory entries, the feed
 794          * inherits the chain's lock so do not unlock it on the iteration.
 795          */
 796         chain = hammer2_chain_lookup(&parent, &key_next,
 797                                      xop->lhc,
 798                                      xop->lhc + HAMMER2_DIRHASH_LOMASK,
 799                                      &cache_index,
 800                                      HAMMER2_LOOKUP_ALWAYS |
 801                                      HAMMER2_LOOKUP_SHARED);
 802         while (chain) {
 803                 error = hammer2_xop_feed(&xop->head, chain, clindex,
 804                                          chain->error);
 805                 if (error) {
 806                         hammer2_chain_unlock(chain);
 807                         hammer2_chain_drop(chain);
 808                         chain = NULL;   /* safety */
 809                         break;
 810                 }
 811                 chain = hammer2_chain_next(&parent, chain, &key_next,
 812                                            key_next,
 813                                            xop->lhc + HAMMER2_DIRHASH_LOMASK,
 814                                            &cache_index,
 815                                            HAMMER2_LOOKUP_ALWAYS |
 816                                            HAMMER2_LOOKUP_SHARED);
 817         }
 818 done:
 819         hammer2_xop_feed(&xop->head, NULL, clindex, error);
 820         if (parent) {
 821                 hammer2_chain_unlock(parent);
 822                 hammer2_chain_drop(parent);
 823         }
 824 }
 825
 826 /*
 827  * Generic lookup of a specific key.
 828  *
 829  * Used by the inode hidden directory code to find the hidden directory.
 830  */
 831 void
 832 hammer2_xop_lookup(hammer2_xop_t *arg, int clindex)
 833 {
 834         hammer2_xop_scanlhc_t *xop = &arg->xop_scanlhc;
 835         hammer2_chain_t *parent;
 836         hammer2_chain_t *chain;
 837         hammer2_key_t key_next;
 838         int cache_index = -1;   /* XXX */
 839         int error = 0;
 840
 841         parent = hammer2_inode_chain(xop->head.ip1, clindex,
 842                                      HAMMER2_RESOLVE_ALWAYS |
 843                                      HAMMER2_RESOLVE_SHARED);
 844         chain = NULL;
 845         if (parent == NULL) {
 846                 error = EIO;
 847                 goto done;
 848         }
 849
 850         /*
 851          * Lookup all possibly conflicting directory entries, the feed
 852          * inherits the chain's lock so do not unlock it on the iteration.
 853          */
 854         chain = hammer2_chain_lookup(&parent, &key_next,
 855                                      xop->lhc, xop->lhc,
 856                                      &cache_index,
 857                                      HAMMER2_LOOKUP_ALWAYS |
 858                                      HAMMER2_LOOKUP_SHARED);
 859         if (chain)
 860                 hammer2_xop_feed(&xop->head, chain, clindex, chain->error);
 861         else
 862                 hammer2_xop_feed(&xop->head, NULL, clindex, ENOENT);
 863
 864 done:
 865         if (chain) {
 866                 hammer2_chain_unlock(chain);
 867                 hammer2_chain_drop(chain);
 868         }
 869         if (parent) {
 870                 hammer2_chain_unlock(parent);
 871                 hammer2_chain_drop(parent);
 872         }
 873 }
 874
 875 /*
 876  * Generic scan
 877  *
 878  * WARNING! Fed chains must be locked shared so ownership can be transfered
 879  *          and to prevent frontend/backend stalls that would occur with an
 880  *          exclusive lock.  The shared lock also allows chain->data to be
 881  *          retained.
 882  */
 883 void
 884 hammer2_xop_scanall(hammer2_xop_t *arg, int clindex)
 885 {
 886         hammer2_xop_scanall_t *xop = &arg->xop_scanall;
 887         hammer2_chain_t *parent;
 888         hammer2_chain_t *chain;
 889         hammer2_key_t key_next;
 890         int cache_index = -1;
 891         int error = 0;
 892
 893         /*
 894          * Assert required flags.
 895          */
 896         KKASSERT(xop->resolve_flags & HAMMER2_RESOLVE_SHARED);
 897         KKASSERT(xop->lookup_flags & HAMMER2_LOOKUP_SHARED);
 898
 899         /*
 900          * The inode's chain is the iterator.  If we cannot acquire it our
 901          * contribution ends here.
 902          */
 903         parent = hammer2_inode_chain(xop->head.ip1, clindex,
 904                                      xop->resolve_flags);
 905         if (parent == NULL) {
 906                 kprintf("xop_readdir: NULL parent\n");
 907                 goto done;
 908         }
 909
 910         /*
 911          * Generic scan of exact records.  Note that indirect blocks are
 912          * automatically recursed and will not be returned.
 913          */
 914         chain = hammer2_chain_lookup(&parent, &key_next,
 915                                      xop->key_beg, xop->key_end,
 916                                      &cache_index, xop->lookup_flags);
 917         while (chain) {
 918                 error = hammer2_xop_feed(&xop->head, chain, clindex, 0);
 919                 if (error)
 920                         break;
 921                 chain = hammer2_chain_next(&parent, chain, &key_next,
 922                                            key_next, xop->key_end,
 923                                            &cache_index, xop->lookup_flags);
 924         }
 925         if (chain) {
 926                 hammer2_chain_unlock(chain);
 927                 hammer2_chain_drop(chain);
 928         }
 929         hammer2_chain_unlock(parent);
 930         hammer2_chain_drop(parent);
 931 done:
 932         hammer2_xop_feed(&xop->head, NULL, clindex, error);
 933 }