sys/vfs/hammer2/hammer2_vnops.c

   1 /*
   2  * Copyright (c) 2011-2012 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/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/fcntl.h>
  39 #include <sys/buf.h>
  40 #include <sys/proc.h>
  41 #include <sys/namei.h>
  42 #include <sys/mount.h>
  43 #include <sys/vnode.h>
  44 #include <sys/mountctl.h>
  45 #include <sys/dirent.h>
  46 #include <sys/uio.h>
  47
  48 #include "hammer2.h"
  49
  50 #define ZFOFFSET        (-2LL)
  51
  52 static int hammer2_read_file(hammer2_inode_t *ip, struct uio *uio,
  53                                 int seqcount);
  54 static int hammer2_write_file(hammer2_inode_t *ip, struct uio *uio, int ioflag,
  55                               int seqcount);
  56 static hammer2_off_t hammer2_assign_physical(hammer2_inode_t *ip,
  57                                 hammer2_key_t lbase, int lblksize, int *errorp);
  58 static void hammer2_extend_file(hammer2_inode_t *ip, hammer2_key_t nsize);
  59 static void hammer2_truncate_file(hammer2_inode_t *ip, hammer2_key_t nsize);
  60 static int hammer2_unlink_file(hammer2_inode_t *dip,
  61                                 const uint8_t *name, size_t name_len,
  62                                 int isdir, int adjlinks);
  63
  64 /*
  65  * Last reference to a vnode is going away but it is still cached.
  66  */
  67 static
  68 int
  69 hammer2_vop_inactive(struct vop_inactive_args *ap)
  70 {
  71         struct vnode *vp;
  72         struct hammer2_inode *ip;
  73 #if 0
  74         struct hammer2_mount *hmp;
  75 #endif
  76
  77         vp = ap->a_vp;
  78         ip = VTOI(vp);
  79
  80         /*
  81          * Degenerate case
  82          */
  83         if (ip == NULL) {
  84                 vrecycle(vp);
  85                 return (0);
  86         }
  87
  88         /*
  89          * Detect updates to the embedded data which may be synchronized by
  90          * the strategy code.  Simply mark the inode modified so it gets
  91          * picked up by our normal flush.
  92          */
  93         if (ip->chain.flags & HAMMER2_CHAIN_DIRTYEMBED) {
  94                 hammer2_inode_lock_ex(ip);
  95                 atomic_clear_int(&ip->chain.flags, HAMMER2_CHAIN_DIRTYEMBED);
  96                 hammer2_chain_modify(ip->hmp, &ip->chain, 0);
  97                 hammer2_inode_unlock_ex(ip);
  98         }
  99
 100         /*
 101          * Check for deleted inodes and recycle immediately.
 102          */
 103         if (ip->chain.flags & HAMMER2_CHAIN_DELETED) {
 104                 vrecycle(vp);
 105         }
 106         return (0);
 107 }
 108
 109 /*
 110  * Reclaim a vnode so that it can be reused; after the inode is
 111  * disassociated, the filesystem must manage it alone.
 112  */
 113 static
 114 int
 115 hammer2_vop_reclaim(struct vop_reclaim_args *ap)
 116 {
 117         struct hammer2_inode *ip;
 118         struct hammer2_mount *hmp;
 119         struct vnode *vp;
 120
 121         vp = ap->a_vp;
 122         ip = VTOI(vp);
 123         if (ip == NULL)
 124                 return(0);
 125         hmp = ip->hmp;
 126
 127         /*
 128          * Set SUBMODIFIED so we can detect and propagate the DESTROYED
 129          * bit in the flush code.
 130          */
 131         hammer2_inode_lock_ex(ip);
 132         vp->v_data = NULL;
 133         ip->vp = NULL;
 134         if (ip->chain.flags & HAMMER2_CHAIN_DELETED) {
 135                 atomic_set_int(&ip->chain.flags, HAMMER2_CHAIN_DESTROYED |
 136                                                  HAMMER2_CHAIN_SUBMODIFIED);
 137         }
 138         hammer2_chain_flush(hmp, &ip->chain);
 139         hammer2_inode_unlock_ex(ip);
 140         hammer2_chain_drop(hmp, &ip->chain);    /* vp ref */
 141
 142         /*
 143          * XXX handle background sync when ip dirty, kernel will no longer
 144          * notify us regarding this inode because there is no longer a
 145          * vnode attached to it.
 146          */
 147
 148         return (0);
 149 }
 150
 151 static
 152 int
 153 hammer2_vop_fsync(struct vop_fsync_args *ap)
 154 {
 155         struct hammer2_inode *ip;
 156         struct hammer2_mount *hmp;
 157         struct vnode *vp;
 158
 159         vp = ap->a_vp;
 160         ip = VTOI(vp);
 161         hmp = ip->hmp;
 162
 163         hammer2_inode_lock_ex(ip);
 164         vfsync(vp, ap->a_waitfor, 1, NULL, NULL);
 165
 166         /*
 167          * Detect updates to the embedded data which may be synchronized by
 168          * the strategy code.  Simply mark the inode modified so it gets
 169          * picked up by our normal flush.
 170          */
 171         if (ip->chain.flags & HAMMER2_CHAIN_DIRTYEMBED) {
 172                 atomic_clear_int(&ip->chain.flags, HAMMER2_CHAIN_DIRTYEMBED);
 173                 hammer2_chain_modify(hmp, &ip->chain, 0);
 174         }
 175
 176         /*
 177          * Calling chain_flush here creates a lot of duplicative
 178          * COW operations due to non-optimal vnode ordering.
 179          *
 180          * Only do it for an actual fsync() syscall.  The other forms
 181          * which call this function will eventually call chain_flush
 182          * on the volume root as a catch-all, which is far more optimal.
 183          */
 184         if (ap->a_flags & VOP_FSYNC_SYSCALL)
 185                 hammer2_chain_flush(hmp, &ip->chain);
 186         hammer2_inode_unlock_ex(ip);
 187         return (0);
 188 }
 189
 190 static
 191 int
 192 hammer2_vop_access(struct vop_access_args *ap)
 193 {
 194         hammer2_inode_t *ip = VTOI(ap->a_vp);
 195         uid_t uid;
 196         gid_t gid;
 197         int error;
 198
 199         uid = hammer2_to_unix_xid(&ip->ip_data.uid);
 200         gid = hammer2_to_unix_xid(&ip->ip_data.gid);
 201
 202         error = vop_helper_access(ap, uid, gid, ip->ip_data.mode,
 203                                   ip->ip_data.uflags);
 204         return (error);
 205 }
 206
 207 static
 208 int
 209 hammer2_vop_getattr(struct vop_getattr_args *ap)
 210 {
 211         hammer2_mount_t *hmp;
 212         hammer2_inode_t *ip;
 213         struct vnode *vp;
 214         struct vattr *vap;
 215
 216         vp = ap->a_vp;
 217         vap = ap->a_vap;
 218
 219         ip = VTOI(vp);
 220         hmp = ip->hmp;
 221
 222         hammer2_inode_lock_sh(ip);
 223
 224         vap->va_fsid = hmp->mp->mnt_stat.f_fsid.val[0];
 225         vap->va_fileid = ip->ip_data.inum;
 226         vap->va_mode = ip->ip_data.mode;
 227         vap->va_nlink = ip->ip_data.nlinks;
 228         vap->va_uid = 0;
 229         vap->va_gid = 0;
 230         vap->va_rmajor = 0;
 231         vap->va_rminor = 0;
 232         vap->va_size = ip->ip_data.size;
 233         vap->va_blocksize = HAMMER2_PBUFSIZE;
 234         vap->va_flags = ip->ip_data.uflags;
 235         hammer2_time_to_timespec(ip->ip_data.ctime, &vap->va_ctime);
 236         hammer2_time_to_timespec(ip->ip_data.mtime, &vap->va_mtime);
 237         hammer2_time_to_timespec(ip->ip_data.mtime, &vap->va_atime);
 238         vap->va_gen = 1;
 239         vap->va_bytes = vap->va_size;   /* XXX */
 240         vap->va_type = hammer2_get_vtype(ip);
 241         vap->va_filerev = 0;
 242         vap->va_uid_uuid = ip->ip_data.uid;
 243         vap->va_gid_uuid = ip->ip_data.gid;
 244         vap->va_vaflags = VA_UID_UUID_VALID | VA_GID_UUID_VALID |
 245                           VA_FSID_UUID_VALID;
 246
 247         hammer2_inode_unlock_sh(ip);
 248
 249         return (0);
 250 }
 251
 252 static
 253 int
 254 hammer2_vop_setattr(struct vop_setattr_args *ap)
 255 {
 256         hammer2_mount_t *hmp;
 257         hammer2_inode_t *ip;
 258         struct vnode *vp;
 259         struct vattr *vap;
 260         int error;
 261         int kflags = 0;
 262         int doctime = 0;
 263         int domtime = 0;
 264
 265         vp = ap->a_vp;
 266         vap = ap->a_vap;
 267
 268         ip = VTOI(vp);
 269         hmp = ip->hmp;
 270
 271         if (hmp->ronly)
 272                 return(EROFS);
 273
 274         hammer2_inode_lock_ex(ip);
 275         error = 0;
 276
 277         if (vap->va_flags != VNOVAL) {
 278                 u_int32_t flags;
 279
 280                 flags = ip->ip_data.uflags;
 281                 error = vop_helper_setattr_flags(&flags, vap->va_flags,
 282                                          hammer2_to_unix_xid(&ip->ip_data.uid),
 283                                          ap->a_cred);
 284                 if (error == 0) {
 285                         if (ip->ip_data.uflags != flags) {
 286                                 hammer2_chain_modify(hmp, &ip->chain, 0);
 287                                 ip->ip_data.uflags = flags;
 288                                 doctime = 1;
 289                                 kflags |= NOTE_ATTRIB;
 290                         }
 291                         if (ip->ip_data.uflags & (IMMUTABLE | APPEND)) {
 292                                 error = 0;
 293                                 goto done;
 294                         }
 295                 }
 296         }
 297
 298         if (ip->ip_data.uflags & (IMMUTABLE | APPEND)) {
 299                 error = EPERM;
 300                 goto done;
 301         }
 302         /* uid, gid */
 303
 304         /*
 305          * Resize the file
 306          */
 307         if (vap->va_size != VNOVAL && ip->ip_data.size != vap->va_size) {
 308                 switch(vp->v_type) {
 309                 case VREG:
 310                         if (vap->va_size == ip->ip_data.size)
 311                                 break;
 312                         if (vap->va_size < ip->ip_data.size) {
 313                                 hammer2_truncate_file(ip, vap->va_size);
 314                         } else {
 315                                 hammer2_extend_file(ip, vap->va_size);
 316                         }
 317                         domtime = 1;
 318                         break;
 319                 default:
 320                         error = EINVAL;
 321                         goto done;
 322                 }
 323         }
 324 done:
 325         hammer2_inode_unlock_ex(ip);
 326         return (error);
 327 }
 328
 329 static
 330 int
 331 hammer2_vop_readdir(struct vop_readdir_args *ap)
 332 {
 333         hammer2_mount_t *hmp;
 334         hammer2_inode_t *ip;
 335         hammer2_inode_t *xip;
 336         hammer2_chain_t *parent;
 337         hammer2_chain_t *chain;
 338         hammer2_key_t lkey;
 339         struct uio *uio;
 340         off_t *cookies;
 341         off_t saveoff;
 342         int cookie_index;
 343         int ncookies;
 344         int error;
 345         int dtype;
 346         int r;
 347
 348         ip = VTOI(ap->a_vp);
 349         hmp = ip->hmp;
 350         uio = ap->a_uio;
 351         saveoff = uio->uio_offset;
 352
 353         /*
 354          * Setup cookies directory entry cookies if requested
 355          */
 356         if (ap->a_ncookies) {
 357                 ncookies = uio->uio_resid / 16 + 1;
 358                 if (ncookies > 1024)
 359                         ncookies = 1024;
 360                 cookies = kmalloc(ncookies * sizeof(off_t), M_TEMP, M_WAITOK);
 361         } else {
 362                 ncookies = -1;
 363                 cookies = NULL;
 364         }
 365         cookie_index = 0;
 366
 367         /*
 368          * Handle artificial entries.  To ensure that only positive 64 bit
 369          * quantities are returned to userland we always strip off bit 63.
 370          * The hash code is designed such that codes 0x0000-0x7FFF are not
 371          * used, allowing us to use these codes for articial entries.
 372          *
 373          * Entry 0 is used for '.' and entry 1 is used for '..'.  Do not
 374          * allow '..' to cross the mount point into (e.g.) the super-root.
 375          */
 376         error = 0;
 377         chain = (void *)(intptr_t)-1;   /* non-NULL for early goto done case */
 378
 379         if (saveoff == 0) {
 380                 r = vop_write_dirent(&error, uio,
 381                                      ip->ip_data.inum &
 382                                         HAMMER2_DIRHASH_USERMSK,
 383                                      DT_DIR, 1, ".");
 384                 if (r)
 385                         goto done;
 386                 if (cookies)
 387                         cookies[cookie_index] = saveoff;
 388                 ++saveoff;
 389                 ++cookie_index;
 390                 if (cookie_index == ncookies)
 391                         goto done;
 392         }
 393         if (saveoff == 1) {
 394                 if (ip->pip == NULL || ip == hmp->iroot)
 395                         xip = ip;
 396                 else
 397                         xip = ip->pip;
 398
 399                 r = vop_write_dirent(&error, uio,
 400                                      xip->ip_data.inum &
 401                                       HAMMER2_DIRHASH_USERMSK,
 402                                      DT_DIR, 2, "..");
 403                 if (r)
 404                         goto done;
 405                 if (cookies)
 406                         cookies[cookie_index] = saveoff;
 407                 ++saveoff;
 408                 ++cookie_index;
 409                 if (cookie_index == ncookies)
 410                         goto done;
 411         }
 412
 413         lkey = saveoff | HAMMER2_DIRHASH_VISIBLE;
 414
 415         parent = &ip->chain;
 416         error = hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
 417         if (error) {
 418                 hammer2_chain_unlock(hmp, parent);
 419                 goto done;
 420         }
 421         chain = hammer2_chain_lookup(hmp, &parent, lkey, lkey, 0);
 422         if (chain == NULL) {
 423                 chain = hammer2_chain_lookup(hmp, &parent,
 424                                              lkey, (hammer2_key_t)-1, 0);
 425         }
 426         while (chain) {
 427                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE) {
 428                         dtype = hammer2_get_dtype(chain->u.ip);
 429                         saveoff = chain->bref.key & HAMMER2_DIRHASH_USERMSK;
 430                         r = vop_write_dirent(&error, uio,
 431                                              chain->u.ip->ip_data.inum &
 432                                               HAMMER2_DIRHASH_USERMSK,
 433                                              dtype, chain->u.ip->ip_data.name_len,
 434                                              chain->u.ip->ip_data.filename);
 435                         if (r)
 436                                 break;
 437                         if (cookies)
 438                                 cookies[cookie_index] = saveoff;
 439                         ++cookie_index;
 440                 } else {
 441                         /* XXX chain error */
 442                         kprintf("bad chain type readdir %d\n",
 443                                 chain->bref.type);
 444                 }
 445
 446                 /*
 447                  * Keys may not be returned in order so once we have a
 448                  * placemarker (chain) the scan must allow the full range
 449                  * or some entries will be missed.
 450                  */
 451                 chain = hammer2_chain_next(hmp, &parent, chain,
 452                                            0, (hammer2_key_t)-1, 0);
 453                 if (chain) {
 454                         saveoff = (chain->bref.key &
 455                                    HAMMER2_DIRHASH_USERMSK) + 1;
 456                 } else {
 457                         saveoff = (hammer2_key_t)-1;
 458                 }
 459                 if (cookie_index == ncookies)
 460                         break;
 461         }
 462         if (chain)
 463                 hammer2_chain_unlock(hmp, chain);
 464         hammer2_chain_unlock(hmp, parent);
 465 done:
 466         if (ap->a_eofflag)
 467                 *ap->a_eofflag = (chain == NULL);
 468         uio->uio_offset = saveoff & ~HAMMER2_DIRHASH_VISIBLE;
 469         if (error && cookie_index == 0) {
 470                 if (cookies) {
 471                         kfree(cookies, M_TEMP);
 472                         *ap->a_ncookies = 0;
 473                         *ap->a_cookies = NULL;
 474                 }
 475         } else {
 476                 if (cookies) {
 477                         *ap->a_ncookies = cookie_index;
 478                         *ap->a_cookies = cookies;
 479                 }
 480         }
 481         return (error);
 482 }
 483
 484 /*
 485  * hammer2_vop_readlink { vp, uio, cred }
 486  */
 487 static
 488 int
 489 hammer2_vop_readlink(struct vop_readlink_args *ap)
 490 {
 491         struct vnode *vp;
 492         hammer2_mount_t *hmp;
 493         hammer2_inode_t *ip;
 494         int error;
 495
 496         vp = ap->a_vp;
 497         if (vp->v_type != VLNK)
 498                 return (EINVAL);
 499         ip = VTOI(vp);
 500         hmp = ip->hmp;
 501
 502         error = hammer2_read_file(ip, ap->a_uio, 0);
 503         return (error);
 504 }
 505
 506 static
 507 int
 508 hammer2_vop_read(struct vop_read_args *ap)
 509 {
 510         struct vnode *vp;
 511         hammer2_mount_t *hmp;
 512         hammer2_inode_t *ip;
 513         struct uio *uio;
 514         int error;
 515         int seqcount;
 516         int bigread;
 517
 518         /*
 519          * Read operations supported on this vnode?
 520          */
 521         vp = ap->a_vp;
 522         if (vp->v_type != VREG)
 523                 return (EINVAL);
 524
 525         /*
 526          * Misc
 527          */
 528         ip = VTOI(vp);
 529         hmp = ip->hmp;
 530         uio = ap->a_uio;
 531         error = 0;
 532
 533         seqcount = ap->a_ioflag >> 16;
 534         bigread = (uio->uio_resid > 100 * 1024 * 1024);
 535
 536         error = hammer2_read_file(ip, uio, seqcount);
 537         return (error);
 538 }
 539
 540 static
 541 int
 542 hammer2_vop_write(struct vop_write_args *ap)
 543 {
 544         thread_t td;
 545         struct vnode *vp;
 546         hammer2_mount_t *hmp;
 547         hammer2_inode_t *ip;
 548         struct uio *uio;
 549         int error;
 550         int seqcount;
 551         int bigwrite;
 552
 553         /*
 554          * Read operations supported on this vnode?
 555          */
 556         vp = ap->a_vp;
 557         if (vp->v_type != VREG)
 558                 return (EINVAL);
 559
 560         /*
 561          * Misc
 562          */
 563         ip = VTOI(vp);
 564         hmp = ip->hmp;
 565         uio = ap->a_uio;
 566         error = 0;
 567         if (hmp->ronly)
 568                 return (EROFS);
 569
 570         seqcount = ap->a_ioflag >> 16;
 571         bigwrite = (uio->uio_resid > 100 * 1024 * 1024);
 572
 573         /*
 574          * Check resource limit
 575          */
 576         if (uio->uio_resid > 0 && (td = uio->uio_td) != NULL && td->td_proc &&
 577             uio->uio_offset + uio->uio_resid >
 578              td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
 579                 lwpsignal(td->td_proc, td->td_lwp, SIGXFSZ);
 580                 return (EFBIG);
 581         }
 582
 583         bigwrite = (uio->uio_resid > 100 * 1024 * 1024);
 584
 585         /*
 586          * ip must be locked if extending the file.
 587          * ip must be locked to avoid racing a truncation.
 588          *
 589          * ip must be marked modified, particularly because the write
 590          * might wind up being copied into the embedded data area.
 591          */
 592         hammer2_inode_lock_ex(ip);
 593         hammer2_chain_modify(hmp, &ip->chain, 0);
 594         error = hammer2_write_file(ip, uio, ap->a_ioflag, seqcount);
 595
 596         hammer2_inode_unlock_ex(ip);
 597         return (error);
 598 }
 599
 600 /*
 601  * Perform read operations on a file or symlink given an UNLOCKED
 602  * inode and uio.
 603  */
 604 static
 605 int
 606 hammer2_read_file(hammer2_inode_t *ip, struct uio *uio, int seqcount)
 607 {
 608         struct buf *bp;
 609         int error;
 610
 611         error = 0;
 612
 613         /*
 614          * UIO read loop
 615          */
 616         while (uio->uio_resid > 0 && uio->uio_offset < ip->ip_data.size) {
 617                 hammer2_key_t lbase;
 618                 hammer2_key_t leof;
 619                 int lblksize;
 620                 int loff;
 621                 int n;
 622
 623                 lblksize = hammer2_calc_logical(ip, uio->uio_offset,
 624                                                 &lbase, &leof);
 625
 626                 error = cluster_read(ip->vp, leof, lbase, lblksize,
 627                                      uio->uio_resid, seqcount * BKVASIZE,
 628                                      &bp);
 629
 630                 if (error)
 631                         break;
 632                 loff = (int)(uio->uio_offset - lbase);
 633                 n = lblksize - loff;
 634                 if (n > uio->uio_resid)
 635                         n = uio->uio_resid;
 636                 if (n > ip->ip_data.size - uio->uio_offset)
 637                         n = (int)(ip->ip_data.size - uio->uio_offset);
 638                 bp->b_flags |= B_AGE;
 639                 uiomove((char *)bp->b_data + loff, n, uio);
 640                 bqrelse(bp);
 641         }
 642         return (error);
 643 }
 644
 645 /*
 646  * Called with a locked (ip) to do the underlying write to a file or
 647  * to build the symlink target.
 648  */
 649 static
 650 int
 651 hammer2_write_file(hammer2_inode_t *ip, struct uio *uio,
 652                    int ioflag, int seqcount)
 653 {
 654         hammer2_key_t old_eof;
 655         struct buf *bp;
 656         int kflags;
 657         int error;
 658
 659         /*
 660          * Setup if append
 661          */
 662         if (ioflag & IO_APPEND)
 663                 uio->uio_offset = ip->ip_data.size;
 664         kflags = 0;
 665         error = 0;
 666
 667         /*
 668          * Extend the file if necessary.  If the write fails at some point
 669          * we will truncate it back down to cover as much as we were able
 670          * to write.
 671          *
 672          * Doing this now makes it easier to calculate buffer sizes in
 673          * the loop.
 674          */
 675         old_eof = ip->ip_data.size;
 676         if (uio->uio_offset + uio->uio_resid > ip->ip_data.size) {
 677                 hammer2_extend_file(ip, uio->uio_offset + uio->uio_resid);
 678                 kflags |= NOTE_EXTEND;
 679         }
 680
 681         /*
 682          * UIO write loop
 683          */
 684         while (uio->uio_resid > 0) {
 685                 hammer2_key_t lbase;
 686                 hammer2_key_t leof;
 687                 int trivial;
 688                 int lblksize;
 689                 int loff;
 690                 int n;
 691
 692                 /*
 693                  * Don't allow the buffer build to blow out the buffer
 694                  * cache.
 695                  */
 696                 if ((ioflag & IO_RECURSE) == 0) {
 697                         /*
 698                          * XXX should try to leave this unlocked through
 699                          *      the whole loop
 700                          */
 701                         hammer2_chain_unlock(ip->hmp, &ip->chain);
 702                         bwillwrite(HAMMER2_PBUFSIZE);
 703                         hammer2_chain_lock(ip->hmp, &ip->chain,
 704                                            HAMMER2_RESOLVE_ALWAYS);
 705                 }
 706
 707                 /* XXX bigwrite & signal check test */
 708
 709                 /*
 710                  * This nominally tells us how much we can cluster and
 711                  * what the logical buffer size needs to be.  Currently
 712                  * we don't try to cluster the write and just handle one
 713                  * block at a time.
 714                  */
 715                 lblksize = hammer2_calc_logical(ip, uio->uio_offset,
 716                                                 &lbase, &leof);
 717                 loff = (int)(uio->uio_offset - lbase);
 718
 719                 /*
 720                  * Calculate bytes to copy this transfer and whether the
 721                  * copy completely covers the buffer or not.
 722                  */
 723                 trivial = 0;
 724                 n = lblksize - loff;
 725                 if (n > uio->uio_resid) {
 726                         n = uio->uio_resid;
 727                         if (uio->uio_offset + n == ip->ip_data.size)
 728                                 trivial = 1;
 729                 } else if (loff == 0) {
 730                         trivial = 1;
 731                 }
 732
 733                 /*
 734                  * Get the buffer
 735                  */
 736                 if (uio->uio_segflg == UIO_NOCOPY) {
 737                         /*
 738                          * Issuing a write with the same data backing the
 739                          * buffer.  Instantiate the buffer to collect the
 740                          * backing vm pages, then read-in any missing bits.
 741                          *
 742                          * This case is used by vop_stdputpages().
 743                          */
 744                         bp = getblk(ip->vp, lbase, lblksize, GETBLK_BHEAVY, 0);
 745                         if ((bp->b_flags & B_CACHE) == 0) {
 746                                 bqrelse(bp);
 747                                 error = bread(ip->vp, lbase, lblksize, &bp);
 748                         }
 749                 } else if (trivial) {
 750                         /*
 751                          * Even though we are entirely overwriting the buffer
 752                          * we may still have to zero it out to avoid a
 753                          * mmap/write visibility issue.
 754                          */
 755                         bp = getblk(ip->vp, lbase, lblksize, GETBLK_BHEAVY, 0);
 756                         if ((bp->b_flags & B_CACHE) == 0)
 757                                 vfs_bio_clrbuf(bp);
 758                 } else {
 759                         /*
 760                          * Partial overwrite, read in any missing bits then
 761                          * replace the portion being written.
 762                          *
 763                          * (The strategy code will detect zero-fill physical
 764                          * blocks for this case).
 765                          */
 766                         error = bread(ip->vp, lbase, lblksize, &bp);
 767                         if (error == 0)
 768                                 bheavy(bp);
 769                 }
 770
 771                 if (error) {
 772                         brelse(bp);
 773                         break;
 774                 }
 775
 776                 /*
 777                  * We have to assign physical storage to the buffer we intend
 778                  * to dirty or write now to avoid deadlocks in the strategy
 779                  * code later.
 780                  *
 781                  * This can return NOOFFSET for inode-embedded data.  The
 782                  * strategy code will take care of it in that case.
 783                  */
 784                 bp->b_bio2.bio_offset =
 785                         hammer2_assign_physical(ip, lbase, lblksize, &error);
 786                 if (error) {
 787                         brelse(bp);
 788                         break;
 789                 }
 790
 791                 /*
 792                  * Ok, copy the data in
 793                  */
 794                 hammer2_chain_unlock(ip->hmp, &ip->chain);
 795                 error = uiomove(bp->b_data + loff, n, uio);
 796                 hammer2_chain_lock(ip->hmp, &ip->chain, HAMMER2_RESOLVE_ALWAYS);
 797                 kflags |= NOTE_WRITE;
 798
 799                 if (error) {
 800                         brelse(bp);
 801                         break;
 802                 }
 803
 804                 /* XXX update ino_data.mtime */
 805
 806                 /*
 807                  * Once we dirty a buffer any cached offset becomes invalid.
 808                  *
 809                  * NOTE: For cluster_write() always use the trailing block
 810                  *       size, which is HAMMER2_PBUFSIZE.  lblksize is the
 811                  *       eof-straddling blocksize and is incorrect.
 812                  */
 813                 bp->b_flags |= B_AGE;
 814                 if (ioflag & IO_SYNC) {
 815                         bwrite(bp);
 816                 } else if ((ioflag & IO_DIRECT) && loff + n == lblksize) {
 817                         bp->b_flags |= B_CLUSTEROK;
 818                         bdwrite(bp);
 819                 } else if (ioflag & IO_ASYNC) {
 820                         bawrite(bp);
 821                 } else if (hammer2_cluster_enable) {
 822                         bp->b_flags |= B_CLUSTEROK;
 823                         cluster_write(bp, leof, HAMMER2_PBUFSIZE, seqcount);
 824                 } else {
 825                         bp->b_flags |= B_CLUSTEROK;
 826                         bdwrite(bp);
 827                 }
 828         }
 829
 830         /*
 831          * Cleanup.  If we extended the file EOF but failed to write through
 832          * the entire write is a failure and we have to back-up.
 833          */
 834         if (error && ip->ip_data.size != old_eof)
 835                 hammer2_truncate_file(ip, old_eof);
 836         /* hammer2_knote(ip->vp, kflags); */
 837         return error;
 838 }
 839
 840 /*
 841  * Assign physical storage to a logical block.
 842  *
 843  * NOOFFSET is returned if the data is inode-embedded.  In this case the
 844  * strategy code will simply bcopy() the data into the inode.
 845  */
 846 static
 847 hammer2_off_t
 848 hammer2_assign_physical(hammer2_inode_t *ip, hammer2_key_t lbase,
 849                         int lblksize, int *errorp)
 850 {
 851         hammer2_mount_t *hmp;
 852         hammer2_chain_t *parent;
 853         hammer2_chain_t *chain;
 854         hammer2_off_t pbase;
 855
 856         *errorp = 0;
 857         hmp = ip->hmp;
 858
 859         /*
 860          * Locate the chain associated with lbase, return a locked chain.
 861          * However, do not instantiate any data reference (which utilizes a
 862          * device buffer) because we will be using direct IO via the
 863          * logical buffer cache buffer.
 864          */
 865         parent = &ip->chain;
 866         hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
 867
 868         chain = hammer2_chain_lookup(hmp, &parent,
 869                                      lbase, lbase,
 870                                      HAMMER2_LOOKUP_NODATA);
 871
 872         if (chain == NULL) {
 873                 /*
 874                  * We found a hole, create a new chain entry.
 875                  *
 876                  * NOTE: DATA chains are created without device backing
 877                  *       store (nor do we want any).
 878                  */
 879                 chain = hammer2_chain_create(hmp, parent, NULL,
 880                                              lbase, HAMMER2_PBUFRADIX,
 881                                              HAMMER2_BREF_TYPE_DATA,
 882                                              lblksize);
 883                 pbase = chain->bref.data_off & ~HAMMER2_OFF_MASK_RADIX;
 884         } else {
 885                 switch (chain->bref.type) {
 886                 case HAMMER2_BREF_TYPE_INODE:
 887                         /*
 888                          * The data is embedded in the inode.  The
 889                          * caller is responsible for marking the inode
 890                          * modified and copying the data to the embedded
 891                          * area.
 892                          */
 893                         pbase = NOOFFSET;
 894                         break;
 895                 case HAMMER2_BREF_TYPE_DATA:
 896                         if (chain->bytes != lblksize) {
 897                                 panic("hammer2_assign_physical: "
 898                                       "size mismatch %d/%d\n",
 899                                       lblksize, chain->bytes);
 900                         }
 901                         hammer2_chain_modify(hmp, chain,
 902                                              HAMMER2_MODIFY_OPTDATA);
 903                         pbase = chain->bref.data_off & ~HAMMER2_OFF_MASK_RADIX;
 904                         break;
 905                 default:
 906                         panic("hammer2_assign_physical: bad type");
 907                         /* NOT REACHED */
 908                         pbase = NOOFFSET;
 909                         break;
 910                 }
 911         }
 912
 913         if (chain)
 914                 hammer2_chain_unlock(hmp, chain);
 915         hammer2_chain_unlock(hmp, parent);
 916
 917         return (pbase);
 918 }
 919
 920 /*
 921  * Truncate the size of a file.
 922  *
 923  * This routine adjusts ip->ip_data.size smaller, destroying any related
 924  * data beyond the new EOF and potentially resizing the block straddling
 925  * the EOF.
 926  *
 927  * The inode must be locked.
 928  */
 929 static
 930 void
 931 hammer2_truncate_file(hammer2_inode_t *ip, hammer2_key_t nsize)
 932 {
 933         hammer2_chain_t *parent;
 934         hammer2_chain_t *chain;
 935         hammer2_mount_t *hmp = ip->hmp;
 936         hammer2_key_t lbase;
 937         hammer2_key_t leof;
 938         struct buf *bp;
 939         int loff;
 940         int error;
 941         int oblksize;
 942         int nblksize;
 943
 944         hammer2_chain_modify(hmp, &ip->chain, 0);
 945         bp = NULL;
 946
 947         /*
 948          * Destroy any logical buffer cache buffers beyond the file EOF.
 949          *
 950          * We call nvtruncbuf() w/ trivial == 1 to prevent it from messing
 951          * around with the buffer straddling EOF, because we need to assign
 952          * a new physical offset to it.
 953          */
 954         if (ip->vp) {
 955                 nvtruncbuf(ip->vp, nsize,
 956                            HAMMER2_PBUFSIZE, (int)nsize & HAMMER2_PBUFMASK,
 957                            1);
 958         }
 959
 960         /*
 961          * Setup for lookup/search
 962          */
 963         parent = &ip->chain;
 964         error = hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
 965         if (error) {
 966                 hammer2_chain_unlock(hmp, parent);
 967                 /* XXX error reporting */
 968                 return;
 969         }
 970
 971         /*
 972          * Handle the case where a chain/logical-buffer straddles the new
 973          * EOF.  We told nvtruncbuf() above not to mess with the logical
 974          * buffer straddling the EOF because we need to reassign its storage
 975          * and can't let the strategy code do it for us.
 976          */
 977         loff = (int)nsize & HAMMER2_PBUFMASK;
 978         if (loff && ip->vp) {
 979                 oblksize = hammer2_calc_logical(ip, nsize, &lbase, &leof);
 980                 error = bread(ip->vp, lbase, oblksize, &bp);
 981                 KKASSERT(error == 0);
 982         }
 983         ip->ip_data.size = nsize;
 984         nblksize = hammer2_calc_logical(ip, nsize, &lbase, &leof);
 985
 986         /*
 987          * Fixup the chain element.  If we have a logical buffer in-hand
 988          * we don't want to create a conflicting device buffer.
 989          */
 990         if (loff && bp) {
 991                 chain = hammer2_chain_lookup(hmp, &parent, lbase, lbase,
 992                                              HAMMER2_LOOKUP_NODATA);
 993                 if (chain) {
 994                         allocbuf(bp, nblksize);
 995                         switch(chain->bref.type) {
 996                         case HAMMER2_BREF_TYPE_DATA:
 997                                 hammer2_chain_resize(hmp, chain,
 998                                              hammer2_bytes_to_radix(nblksize),
 999                                              HAMMER2_MODIFY_OPTDATA);
1000                                 bzero(bp->b_data + loff, nblksize - loff);
1001                                 bp->b_bio2.bio_offset = chain->bref.data_off &
1002                                                         HAMMER2_OFF_MASK;
1003                                 break;
1004                         case HAMMER2_BREF_TYPE_INODE:
1005                                 bzero(bp->b_data + loff, nblksize - loff);
1006                                 bp->b_bio2.bio_offset = NOOFFSET;
1007                                 break;
1008                         default:
1009                                 panic("hammer2_truncate_file: bad type");
1010                                 break;
1011                         }
1012                         hammer2_chain_unlock(hmp, chain);
1013                         bp->b_flags |= B_CLUSTEROK;
1014                         bdwrite(bp);
1015                 } else {
1016                         /*
1017                          * Destroy clean buffer w/ wrong buffer size.  Retain
1018                          * backing store.
1019                          */
1020                         bp->b_flags |= B_RELBUF;
1021                         KKASSERT(bp->b_bio2.bio_offset == NOOFFSET);
1022                         KKASSERT((bp->b_flags & B_DIRTY) == 0);
1023                         bqrelse(bp);
1024                 }
1025         } else if (loff) {
1026                 /*
1027                  * WARNING: This utilizes a device buffer for the data.
1028                  *
1029                  * XXX case should not occur
1030                  */
1031                 panic("hammer2_truncate_file: non-zero truncation, no-vnode");
1032                 chain = hammer2_chain_lookup(hmp, &parent, lbase, lbase, 0);
1033                 if (chain) {
1034                         switch(chain->bref.type) {
1035                         case HAMMER2_BREF_TYPE_DATA:
1036                                 hammer2_chain_resize(hmp, chain,
1037                                              hammer2_bytes_to_radix(nblksize),
1038                                              0);
1039                                 hammer2_chain_modify(hmp, chain, 0);
1040                                 bzero(chain->data->buf + loff, nblksize - loff);
1041                                 break;
1042                         case HAMMER2_BREF_TYPE_INODE:
1043                                 if (loff < HAMMER2_EMBEDDED_BYTES) {
1044                                         hammer2_chain_modify(hmp, chain, 0);
1045                                         bzero(chain->data->ipdata.u.data + loff,
1046                                               HAMMER2_EMBEDDED_BYTES - loff);
1047                                 }
1048                                 break;
1049                         }
1050                         hammer2_chain_unlock(hmp, chain);
1051                 }
1052         }
1053
1054         /*
1055          * Clean up any fragmentory VM pages now that we have properly
1056          * resized the straddling buffer.  These pages are no longer
1057          * part of the buffer.
1058          */
1059         if (ip->vp) {
1060                 nvtruncbuf(ip->vp, nsize,
1061                            nblksize, (int)nsize & (nblksize - 1),
1062                            1);
1063         }
1064
1065         /*
1066          * Destroy any physical blocks after the new EOF point.
1067          */
1068         lbase = (nsize + HAMMER2_PBUFMASK64) & ~HAMMER2_PBUFMASK64;
1069         chain = hammer2_chain_lookup(hmp, &parent,
1070                                      lbase, (hammer2_key_t)-1,
1071                                      HAMMER2_LOOKUP_NODATA);
1072         while (chain) {
1073                 /*
1074                  * Degenerate embedded data case, nothing to loop on.
1075                  */
1076                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE) {
1077                         hammer2_chain_unlock(hmp, chain);
1078                         break;
1079                 }
1080
1081                 /*
1082                  * Delete physical data blocks past the file EOF.
1083                  */
1084                 if (chain->bref.type == HAMMER2_BREF_TYPE_DATA) {
1085                         hammer2_chain_delete(hmp, parent, chain);
1086                 }
1087                 /* XXX check parent if empty indirect block & delete */
1088                 chain = hammer2_chain_next(hmp, &parent, chain,
1089                                            lbase, (hammer2_key_t)-1,
1090                                            HAMMER2_LOOKUP_NODATA);
1091         }
1092         hammer2_chain_unlock(hmp, parent);
1093 }
1094
1095 /*
1096  * Extend the size of a file.  The inode must be locked.
1097  *
1098  * We may have to resize the block straddling the old EOF.
1099  */
1100 static
1101 void
1102 hammer2_extend_file(hammer2_inode_t *ip, hammer2_key_t nsize)
1103 {
1104         hammer2_mount_t *hmp;
1105         hammer2_chain_t *parent;
1106         hammer2_chain_t *chain;
1107         struct buf *bp;
1108         hammer2_key_t osize;
1109         hammer2_key_t obase;
1110         hammer2_key_t nbase;
1111         hammer2_key_t leof;
1112         int oblksize;
1113         int nblksize;
1114         int nradix;
1115         int error;
1116
1117         KKASSERT(ip->vp);
1118         hmp = ip->hmp;
1119
1120         hammer2_chain_modify(hmp, &ip->chain, 0);
1121
1122         /*
1123          * Nothing to do if the direct-data case is still intact
1124          */
1125         if ((ip->ip_data.op_flags & HAMMER2_OPFLAG_DIRECTDATA) &&
1126             nsize <= HAMMER2_EMBEDDED_BYTES) {
1127                 ip->ip_data.size = nsize;
1128                 return;
1129         }
1130
1131         /*
1132          * Calculate the blocksize at the original EOF and resize the block
1133          * if necessary.  Adjust the file size in the inode.
1134          */
1135         osize = ip->ip_data.size;
1136         oblksize = hammer2_calc_logical(ip, osize, &obase, &leof);
1137         ip->ip_data.size = nsize;
1138         nblksize = hammer2_calc_logical(ip, osize, &nbase, &leof);
1139
1140         /*
1141          * Do all required vnode operations, but do not mess with the
1142          * buffer straddling the orignal EOF.
1143          */
1144         nvextendbuf(ip->vp,
1145                     ip->ip_data.size, nsize,
1146                     0, nblksize,
1147                     0, (int)nsize & HAMMER2_PBUFMASK,
1148                     1);
1149
1150         /*
1151          * Early return if we have no more work to do.
1152          */
1153         if (obase == nbase && oblksize == nblksize &&
1154             (ip->ip_data.op_flags & HAMMER2_OPFLAG_DIRECTDATA) == 0) {
1155                 return;
1156         }
1157
1158         /*
1159          * We have work to do, including possibly resizing the buffer
1160          * at the EOF point and turning off DIRECTDATA mode.
1161          */
1162         bp = NULL;
1163         if (((int)osize & HAMMER2_PBUFMASK)) {
1164                 error = bread(ip->vp, obase, oblksize, &bp);
1165                 KKASSERT(error == 0);
1166
1167                 if (obase != nbase) {
1168                         allocbuf(bp, HAMMER2_PBUFSIZE);
1169                 } else {
1170                         allocbuf(bp, nblksize);
1171                 }
1172                 vfs_bio_clrbuf(bp);
1173         }
1174
1175         /*
1176          * Disable direct-data mode by loading up a buffer cache buffer
1177          * with the data, then converting the inode data area into the
1178          * inode indirect block array area.
1179          */
1180         if (ip->ip_data.op_flags & HAMMER2_OPFLAG_DIRECTDATA) {
1181                 ip->ip_data.op_flags &= ~HAMMER2_OPFLAG_DIRECTDATA;
1182                 bzero(&ip->ip_data.u.blockset, sizeof(ip->ip_data.u.blockset));
1183         }
1184
1185         /*
1186          * Resize the chain element at the old EOF.
1187          */
1188         if (((int)osize & HAMMER2_PBUFMASK)) {
1189                 parent = &ip->chain;
1190                 error = hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
1191                 KKASSERT(error == 0);
1192
1193                 nradix = hammer2_bytes_to_radix(nblksize);
1194
1195                 chain = hammer2_chain_lookup(hmp, &parent,
1196                                              obase, obase,
1197                                              HAMMER2_LOOKUP_NODATA);
1198                 if (chain == NULL) {
1199                         chain = hammer2_chain_create(hmp, parent, NULL,
1200                                                      obase, nblksize,
1201                                                      HAMMER2_BREF_TYPE_DATA,
1202                                                      nblksize);
1203                 } else {
1204                         KKASSERT(chain->bref.type == HAMMER2_BREF_TYPE_DATA);
1205                         hammer2_chain_resize(hmp, chain, nradix,
1206                                              HAMMER2_MODIFY_OPTDATA);
1207                 }
1208                 bp->b_bio2.bio_offset = chain->bref.data_off &
1209                                         HAMMER2_OFF_MASK;
1210                 hammer2_chain_unlock(hmp, chain);
1211                 bp->b_flags |= B_CLUSTEROK;
1212                 bdwrite(bp);
1213                 hammer2_chain_unlock(hmp, parent);
1214         }
1215 }
1216
1217 static
1218 int
1219 hammer2_vop_nresolve(struct vop_nresolve_args *ap)
1220 {
1221         hammer2_inode_t *dip;
1222         hammer2_mount_t *hmp;
1223         hammer2_chain_t *parent;
1224         hammer2_chain_t *chain;
1225         struct namecache *ncp;
1226         const uint8_t *name;
1227         size_t name_len;
1228         hammer2_key_t lhc;
1229         int error = 0;
1230         struct vnode *vp;
1231
1232         dip = VTOI(ap->a_dvp);
1233         hmp = dip->hmp;
1234         ncp = ap->a_nch->ncp;
1235         name = ncp->nc_name;
1236         name_len = ncp->nc_nlen;
1237         lhc = hammer2_dirhash(name, name_len);
1238
1239         /*
1240          * Note: In DragonFly the kernel handles '.' and '..'.
1241          */
1242         parent = &dip->chain;
1243         hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
1244         chain = hammer2_chain_lookup(hmp, &parent,
1245                                      lhc, lhc + HAMMER2_DIRHASH_LOMASK,
1246                                      0);
1247         while (chain) {
1248                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE &&
1249                     chain->u.ip &&
1250                     name_len == chain->data->ipdata.name_len &&
1251                     bcmp(name, chain->data->ipdata.filename, name_len) == 0) {
1252                         break;
1253                 }
1254                 chain = hammer2_chain_next(hmp, &parent, chain,
1255                                            lhc, lhc + HAMMER2_DIRHASH_LOMASK,
1256                                            0);
1257         }
1258         hammer2_chain_unlock(hmp, parent);
1259
1260         if (chain) {
1261                 vp = hammer2_igetv(chain->u.ip, &error);
1262                 if (error == 0) {
1263                         vn_unlock(vp);
1264                         cache_setvp(ap->a_nch, vp);
1265                         vrele(vp);
1266                 }
1267                 hammer2_chain_unlock(hmp, chain);
1268         } else {
1269                 error = ENOENT;
1270                 cache_setvp(ap->a_nch, NULL);
1271         }
1272         return error;
1273 }
1274
1275 static
1276 int
1277 hammer2_vop_nlookupdotdot(struct vop_nlookupdotdot_args *ap)
1278 {
1279         hammer2_inode_t *dip;
1280         hammer2_inode_t *ip;
1281         hammer2_mount_t *hmp;
1282         int error;
1283
1284         dip = VTOI(ap->a_dvp);
1285         hmp = dip->hmp;
1286
1287         if ((ip = dip->pip) == NULL) {
1288                 *ap->a_vpp = NULL;
1289                 return ENOENT;
1290         }
1291         hammer2_chain_lock(hmp, &ip->chain, HAMMER2_RESOLVE_ALWAYS);
1292         *ap->a_vpp = hammer2_igetv(ip, &error);
1293         hammer2_chain_unlock(hmp, &ip->chain);
1294
1295         return error;
1296 }
1297
1298 static
1299 int
1300 hammer2_vop_nmkdir(struct vop_nmkdir_args *ap)
1301 {
1302         hammer2_mount_t *hmp;
1303         hammer2_inode_t *dip;
1304         hammer2_inode_t *nip;
1305         struct namecache *ncp;
1306         const uint8_t *name;
1307         size_t name_len;
1308         int error;
1309
1310         dip = VTOI(ap->a_dvp);
1311         hmp = dip->hmp;
1312         if (hmp->ronly)
1313                 return (EROFS);
1314
1315         ncp = ap->a_nch->ncp;
1316         name = ncp->nc_name;
1317         name_len = ncp->nc_nlen;
1318
1319         error = hammer2_inode_create(hmp, ap->a_vap, ap->a_cred,
1320                                      dip, name, name_len, &nip);
1321         if (error) {
1322                 KKASSERT(nip == NULL);
1323                 *ap->a_vpp = NULL;
1324                 return error;
1325         }
1326         *ap->a_vpp = hammer2_igetv(nip, &error);
1327         hammer2_chain_unlock(hmp, &nip->chain);
1328
1329         if (error == 0) {
1330                 cache_setunresolved(ap->a_nch);
1331                 cache_setvp(ap->a_nch, *ap->a_vpp);
1332         }
1333         return error;
1334 }
1335
1336 /*
1337  * Return the largest contiguous physical disk range for the logical
1338  * request.
1339  *
1340  * (struct vnode *vp, off_t loffset, off_t *doffsetp, int *runp, int *runb)
1341  */
1342 static
1343 int
1344 hammer2_vop_bmap(struct vop_bmap_args *ap)
1345 {
1346         struct vnode *vp;
1347         hammer2_mount_t *hmp;
1348         hammer2_inode_t *ip;
1349         hammer2_chain_t *parent;
1350         hammer2_chain_t *chain;
1351         hammer2_key_t lbeg;
1352         hammer2_key_t lend;
1353         hammer2_off_t pbeg;
1354         hammer2_off_t pbytes;
1355         hammer2_off_t array[HAMMER2_BMAP_COUNT][2];
1356         int loff;
1357         int ai;
1358
1359         /*
1360          * Only supported on regular files
1361          *
1362          * Only supported for read operations (required for cluster_read).
1363          * The block allocation is delayed for write operations.
1364          */
1365         vp = ap->a_vp;
1366         if (vp->v_type != VREG)
1367                 return (EOPNOTSUPP);
1368         if (ap->a_cmd != BUF_CMD_READ)
1369                 return (EOPNOTSUPP);
1370
1371         ip = VTOI(vp);
1372         hmp = ip->hmp;
1373         bzero(array, sizeof(array));
1374
1375         /*
1376          * Calculate logical range
1377          */
1378         KKASSERT((ap->a_loffset & HAMMER2_LBUFMASK64) == 0);
1379         lbeg = ap->a_loffset & HAMMER2_OFF_MASK_HI;
1380         lend = lbeg + HAMMER2_BMAP_COUNT * HAMMER2_PBUFSIZE - 1;
1381         if (lend < lbeg)
1382                 lend = lbeg;
1383         loff = ap->a_loffset & HAMMER2_OFF_MASK_LO;
1384
1385         parent = &ip->chain;
1386         hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
1387         chain = hammer2_chain_lookup(hmp, &parent,
1388                                      lbeg, lend,
1389                                      HAMMER2_LOOKUP_NODATA);
1390         if (chain == NULL) {
1391                 *ap->a_doffsetp = ZFOFFSET;
1392                 hammer2_chain_unlock(hmp, parent);
1393                 return (0);
1394         }
1395
1396         while (chain) {
1397                 if (chain->bref.type == HAMMER2_BREF_TYPE_DATA) {
1398                         ai = (chain->bref.key - lbeg) / HAMMER2_PBUFSIZE;
1399                         KKASSERT(ai >= 0 && ai < HAMMER2_BMAP_COUNT);
1400                         array[ai][0] = chain->bref.data_off & HAMMER2_OFF_MASK;
1401                         array[ai][1] = chain->bytes;
1402                 }
1403                 chain = hammer2_chain_next(hmp, &parent, chain,
1404                                            lbeg, lend,
1405                                            HAMMER2_LOOKUP_NODATA);
1406         }
1407         hammer2_chain_unlock(hmp, parent);
1408
1409         /*
1410          * If the requested loffset is not mappable physically we can't
1411          * bmap.  The caller will have to access the file data via a
1412          * device buffer.
1413          */
1414         if (array[0][0] == 0 || array[0][1] < loff + HAMMER2_LBUFSIZE) {
1415                 *ap->a_doffsetp = NOOFFSET;
1416                 return (0);
1417         }
1418
1419         /*
1420          * Calculate the physical disk offset range for array[0]
1421          */
1422         pbeg = array[0][0] + loff;
1423         pbytes = array[0][1] - loff;
1424
1425         for (ai = 1; ai < HAMMER2_BMAP_COUNT; ++ai) {
1426                 if (array[ai][0] != pbeg + pbytes)
1427                         break;
1428                 pbytes += array[ai][1];
1429         }
1430
1431         *ap->a_doffsetp = pbeg;
1432         if (ap->a_runp)
1433                 *ap->a_runp = pbytes;
1434         return (0);
1435 }
1436
1437 static
1438 int
1439 hammer2_vop_open(struct vop_open_args *ap)
1440 {
1441         return vop_stdopen(ap);
1442 }
1443
1444 /*
1445  * hammer2_vop_advlock { vp, id, op, fl, flags }
1446  */
1447 static
1448 int
1449 hammer2_vop_advlock(struct vop_advlock_args *ap)
1450 {
1451         hammer2_inode_t *ip = VTOI(ap->a_vp);
1452
1453         return (lf_advlock(ap, &ip->advlock, ip->ip_data.size));
1454 }
1455
1456
1457 static
1458 int
1459 hammer2_vop_close(struct vop_close_args *ap)
1460 {
1461         return vop_stdclose(ap);
1462 }
1463
1464 /*
1465  * hammer2_vop_nlink { nch, dvp, vp, cred }
1466  *
1467  * Create a hardlink to vp.
1468  */
1469 static
1470 int
1471 hammer2_vop_nlink(struct vop_nlink_args *ap)
1472 {
1473         hammer2_inode_t *dip;
1474         hammer2_inode_t *ip;    /* inode we are hardlinking to */
1475         hammer2_mount_t *hmp;
1476         struct namecache *ncp;
1477         const uint8_t *name;
1478         size_t name_len;
1479         int error;
1480
1481         dip = VTOI(ap->a_dvp);
1482         hmp = dip->hmp;
1483         if (hmp->ronly)
1484                 return (EROFS);
1485
1486         ip = VTOI(ap->a_vp);
1487
1488         ncp = ap->a_nch->ncp;
1489         name = ncp->nc_name;
1490         name_len = ncp->nc_nlen;
1491
1492         error = hammer2_hardlink_create(ip, dip, name, name_len);
1493         if (error == 0) {
1494                 cache_setunresolved(ap->a_nch);
1495                 cache_setvp(ap->a_nch, ap->a_vp);
1496         }
1497         return error;
1498 }
1499
1500 /*
1501  * hammer2_vop_ncreate { nch, dvp, vpp, cred, vap }
1502  *
1503  * The operating system has already ensured that the directory entry
1504  * does not exist and done all appropriate namespace locking.
1505  */
1506 static
1507 int
1508 hammer2_vop_ncreate(struct vop_ncreate_args *ap)
1509 {
1510         hammer2_mount_t *hmp;
1511         hammer2_inode_t *dip;
1512         hammer2_inode_t *nip;
1513         struct namecache *ncp;
1514         const uint8_t *name;
1515         size_t name_len;
1516         int error;
1517
1518         dip = VTOI(ap->a_dvp);
1519         hmp = dip->hmp;
1520         if (hmp->ronly)
1521                 return (EROFS);
1522
1523         ncp = ap->a_nch->ncp;
1524         name = ncp->nc_name;
1525         name_len = ncp->nc_nlen;
1526
1527         error = hammer2_inode_create(hmp, ap->a_vap, ap->a_cred,
1528                                      dip, name, name_len, &nip);
1529         if (error) {
1530                 KKASSERT(nip == NULL);
1531                 *ap->a_vpp = NULL;
1532                 return error;
1533         }
1534         *ap->a_vpp = hammer2_igetv(nip, &error);
1535         hammer2_chain_unlock(hmp, &nip->chain);
1536
1537         if (error == 0) {
1538                 cache_setunresolved(ap->a_nch);
1539                 cache_setvp(ap->a_nch, *ap->a_vpp);
1540         }
1541         return error;
1542 }
1543
1544 /*
1545  * hammer2_vop_nsymlink { nch, dvp, vpp, cred, vap, target }
1546  */
1547 static
1548 int
1549 hammer2_vop_nsymlink(struct vop_nsymlink_args *ap)
1550 {
1551         hammer2_mount_t *hmp;
1552         hammer2_inode_t *dip;
1553         hammer2_inode_t *nip;
1554         struct namecache *ncp;
1555         const uint8_t *name;
1556         size_t name_len;
1557         int error;
1558
1559         dip = VTOI(ap->a_dvp);
1560         hmp = dip->hmp;
1561         if (hmp->ronly)
1562                 return (EROFS);
1563
1564         ncp = ap->a_nch->ncp;
1565         name = ncp->nc_name;
1566         name_len = ncp->nc_nlen;
1567
1568         ap->a_vap->va_type = VLNK;      /* enforce type */
1569
1570         error = hammer2_inode_create(hmp, ap->a_vap, ap->a_cred,
1571                                      dip, name, name_len, &nip);
1572         if (error) {
1573                 KKASSERT(nip == NULL);
1574                 *ap->a_vpp = NULL;
1575                 return error;
1576         }
1577         *ap->a_vpp = hammer2_igetv(nip, &error);
1578
1579         /*
1580          * Build the softlink (~like file data) and finalize the namecache.
1581          */
1582         if (error == 0) {
1583                 size_t bytes;
1584                 struct uio auio;
1585                 struct iovec aiov;
1586
1587                 bytes = strlen(ap->a_target);
1588
1589                 if (bytes <= HAMMER2_EMBEDDED_BYTES) {
1590                         KKASSERT(nip->ip_data.op_flags &
1591                                  HAMMER2_OPFLAG_DIRECTDATA);
1592                         bcopy(ap->a_target, nip->ip_data.u.data, bytes);
1593                         nip->ip_data.size = bytes;
1594                 } else {
1595                         bzero(&auio, sizeof(auio));
1596                         bzero(&aiov, sizeof(aiov));
1597                         auio.uio_iov = &aiov;
1598                         auio.uio_segflg = UIO_SYSSPACE;
1599                         auio.uio_rw = UIO_WRITE;
1600                         auio.uio_resid = bytes;
1601                         auio.uio_iovcnt = 1;
1602                         auio.uio_td = curthread;
1603                         aiov.iov_base = ap->a_target;
1604                         aiov.iov_len = bytes;
1605                         error = hammer2_write_file(nip, &auio, IO_APPEND, 0);
1606                         /* XXX handle error */
1607                         error = 0;
1608                 }
1609         }
1610         hammer2_chain_unlock(hmp, &nip->chain);
1611
1612         /*
1613          * Finalize namecache
1614          */
1615         if (error == 0) {
1616                 cache_setunresolved(ap->a_nch);
1617                 cache_setvp(ap->a_nch, *ap->a_vpp);
1618                 /* hammer2_knote(ap->a_dvp, NOTE_WRITE); */
1619         }
1620         return error;
1621 }
1622
1623 /*
1624  * hammer2_vop_nremove { nch, dvp, cred }
1625  */
1626 static
1627 int
1628 hammer2_vop_nremove(struct vop_nremove_args *ap)
1629 {
1630         hammer2_inode_t *dip;
1631         hammer2_mount_t *hmp;
1632         struct namecache *ncp;
1633         const uint8_t *name;
1634         size_t name_len;
1635         int error;
1636
1637         dip = VTOI(ap->a_dvp);
1638         hmp = dip->hmp;
1639         if (hmp->ronly)
1640                 return(EROFS);
1641
1642         ncp = ap->a_nch->ncp;
1643         name = ncp->nc_name;
1644         name_len = ncp->nc_nlen;
1645
1646         error = hammer2_unlink_file(dip, name, name_len, 0, 1);
1647
1648         if (error == 0) {
1649                 cache_setunresolved(ap->a_nch);
1650                 cache_setvp(ap->a_nch, NULL);
1651         }
1652         return (error);
1653 }
1654
1655 /*
1656  * hammer2_vop_nrmdir { nch, dvp, cred }
1657  */
1658 static
1659 int
1660 hammer2_vop_nrmdir(struct vop_nrmdir_args *ap)
1661 {
1662         hammer2_inode_t *dip;
1663         hammer2_mount_t *hmp;
1664         struct namecache *ncp;
1665         const uint8_t *name;
1666         size_t name_len;
1667         int error;
1668
1669         dip = VTOI(ap->a_dvp);
1670         hmp = dip->hmp;
1671         if (hmp->ronly)
1672                 return(EROFS);
1673
1674         ncp = ap->a_nch->ncp;
1675         name = ncp->nc_name;
1676         name_len = ncp->nc_nlen;
1677
1678         error = hammer2_unlink_file(dip, name, name_len, 1, 1);
1679
1680         if (error == 0) {
1681                 cache_setunresolved(ap->a_nch);
1682                 cache_setvp(ap->a_nch, NULL);
1683         }
1684         return (error);
1685 }
1686
1687 /*
1688  * hammer2_vop_nrename { fnch, tnch, fdvp, tdvp, cred }
1689  */
1690 static
1691 int
1692 hammer2_vop_nrename(struct vop_nrename_args *ap)
1693 {
1694         struct namecache *fncp;
1695         struct namecache *tncp;
1696         hammer2_inode_t *fdip;
1697         hammer2_inode_t *tdip;
1698         hammer2_inode_t *ip;
1699         hammer2_mount_t *hmp;
1700         const uint8_t *fname;
1701         size_t fname_len;
1702         const uint8_t *tname;
1703         size_t tname_len;
1704         int error;
1705
1706         if (ap->a_fdvp->v_mount != ap->a_tdvp->v_mount)
1707                 return(EXDEV);
1708         if (ap->a_fdvp->v_mount != ap->a_fnch->ncp->nc_vp->v_mount)
1709                 return(EXDEV);
1710
1711         fdip = VTOI(ap->a_fdvp);        /* source directory */
1712         tdip = VTOI(ap->a_tdvp);        /* target directory */
1713
1714         hmp = fdip->hmp;                /* check read-only filesystem */
1715         if (hmp->ronly)
1716                 return(EROFS);
1717
1718         fncp = ap->a_fnch->ncp;         /* entry name in source */
1719         fname = fncp->nc_name;
1720         fname_len = fncp->nc_nlen;
1721
1722         tncp = ap->a_tnch->ncp;         /* entry name in target */
1723         tname = tncp->nc_name;
1724         tname_len = tncp->nc_nlen;
1725
1726         ip = VTOI(fncp->nc_vp);         /* inode being moved */
1727
1728         /*
1729          * Keep a tight grip on the inode as removing it should disconnect
1730          * it and we don't want to destroy it.
1731          *
1732          * NOTE: To avoid deadlocks we cannot lock (ip) while we are
1733          *       unlinking elements from their directories.
1734          */
1735         hammer2_chain_ref(hmp, &ip->chain);
1736
1737         /*
1738          * Remove target if it exists
1739          */
1740         error = hammer2_unlink_file(tdip, tname, tname_len, -1, 1);
1741         if (error && error != ENOENT)
1742                 goto done;
1743         cache_setunresolved(ap->a_tnch);
1744         cache_setvp(ap->a_tnch, NULL);
1745
1746         /*
1747          * Disconnect ip from the source directory, do not adjust
1748          * the link count.  Note that rename doesn't need to understand
1749          * whether this is a hardlink or not, we can just rename the
1750          * forwarding entry and don't even have to adjust the related
1751          * hardlink's link count.
1752          */
1753         error = hammer2_unlink_file(fdip, fname, fname_len, -1, 0);
1754         if (error)
1755                 goto done;
1756
1757         if (ip->chain.parent != NULL)
1758                 panic("hammer2_vop_nrename(): rename source != ip!");
1759
1760         /*
1761          * Reconnect ip to target directory.
1762          *
1763          * WARNING: chain locks can lock buffer cache buffers, to avoid
1764          *          deadlocks we want to unlock before issuing a cache_*()
1765          *          op (that might have to lock a vnode).
1766          */
1767         hammer2_chain_lock(hmp, &ip->chain, HAMMER2_RESOLVE_ALWAYS);
1768         error = hammer2_inode_connect(tdip, ip, tname, tname_len);
1769         hammer2_chain_unlock(hmp, &ip->chain);
1770
1771         if (error == 0) {
1772                 cache_rename(ap->a_fnch, ap->a_tnch);
1773         }
1774 done:
1775         hammer2_chain_drop(hmp, &ip->chain);    /* from ref up top */
1776
1777         return (error);
1778 }
1779
1780 /*
1781  * Unlink the file from the specified directory inode.  The directory inode
1782  * does not need to be locked.
1783  *
1784  * isdir determines whether a directory/non-directory check should be made.
1785  * No check is made if isdir is set to -1.
1786  *
1787  * adjlinks tells unlink that we want to adjust the nlinks count of the
1788  * inode.  When removing the last link for a NON forwarding entry we can
1789  * just ignore the link count... no point updating the inode that we are
1790  * about to dereference, it would just result in a lot of wasted I/O.
1791  *
1792  * However, if the entry is a forwarding entry (aka a hardlink), and adjlinks
1793  * is non-zero, we have to locate the hardlink and adjust its nlinks field.
1794  */
1795 static
1796 int
1797 hammer2_unlink_file(hammer2_inode_t *dip, const uint8_t *name, size_t name_len,
1798                     int isdir, int adjlinks)
1799 {
1800         hammer2_mount_t *hmp;
1801         hammer2_chain_t *parent;
1802         hammer2_chain_t *chain;
1803         hammer2_chain_t *dparent;
1804         hammer2_chain_t *dchain;
1805         hammer2_key_t lhc;
1806         int error;
1807
1808         error = 0;
1809
1810         hmp = dip->hmp;
1811         lhc = hammer2_dirhash(name, name_len);
1812
1813         /*
1814          * Search for the filename in the directory
1815          */
1816         parent = &dip->chain;
1817         hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
1818         chain = hammer2_chain_lookup(hmp, &parent,
1819                                      lhc, lhc + HAMMER2_DIRHASH_LOMASK,
1820                                      0);
1821         while (chain) {
1822                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE &&
1823                     chain->u.ip &&
1824                     name_len == chain->data->ipdata.name_len &&
1825                     bcmp(name, chain->data->ipdata.filename, name_len) == 0) {
1826                         break;
1827                 }
1828                 chain = hammer2_chain_next(hmp, &parent, chain,
1829                                            lhc, lhc + HAMMER2_DIRHASH_LOMASK,
1830                                            0);
1831         }
1832
1833         /*
1834          * Not found or wrong type (isdir < 0 disables the type check).
1835          */
1836         if (chain == NULL) {
1837                 hammer2_chain_unlock(hmp, parent);
1838                 return ENOENT;
1839         }
1840         if (chain->data->ipdata.type == HAMMER2_OBJTYPE_DIRECTORY &&
1841             isdir == 0) {
1842                 error = ENOTDIR;
1843                 goto done;
1844         }
1845         if (chain->data->ipdata.type != HAMMER2_OBJTYPE_DIRECTORY &&
1846             isdir == 1) {
1847                 error = EISDIR;
1848                 goto done;
1849         }
1850
1851         /*
1852          * If this is a directory the directory must be empty.  However, if
1853          * isdir < 0 we are doing a rename and the directory does not have
1854          * to be empty.
1855          */
1856         if (chain->data->ipdata.type == HAMMER2_OBJTYPE_DIRECTORY &&
1857             isdir >= 0) {
1858                 dparent = chain;
1859                 hammer2_chain_lock(hmp, dparent, HAMMER2_RESOLVE_ALWAYS);
1860                 dchain = hammer2_chain_lookup(hmp, &dparent,
1861                                               0, (hammer2_key_t)-1,
1862                                               HAMMER2_LOOKUP_NODATA);
1863                 if (dchain) {
1864                         hammer2_chain_unlock(hmp, dchain);
1865                         hammer2_chain_unlock(hmp, dparent);
1866                         error = ENOTEMPTY;
1867                         goto done;
1868                 }
1869                 hammer2_chain_unlock(hmp, dparent);
1870                 dparent = NULL;
1871                 /* dchain NULL */
1872         }
1873
1874 #if 0
1875         /*
1876          * If adjlinks is non-zero this is a real deletion (otherwise it is
1877          * probably a rename).  XXX
1878          */
1879         if (adjlinks) {
1880                 if (chain->data->ipdata.type == HAMMER2_OBJTYPE_HARDLINK) {
1881                         /*hammer2_adjust_hardlink(chain->u.ip, -1);*/
1882                         /* error handling */
1883                 } else {
1884                         waslastlink = 1;
1885                 }
1886         } else {
1887                 waslastlink = 0;
1888         }
1889 #endif
1890
1891         /*
1892          * Found, the chain represents the inode.  Remove the parent reference
1893          * to the chain.  The chain itself is no longer referenced and will
1894          * be marked unmodified by hammer2_chain_delete(), avoiding unnecessary
1895          * I/O.
1896          */
1897         hammer2_chain_delete(hmp, parent, chain);
1898         /* XXX nlinks (hardlink special case) */
1899         /* XXX nlinks (parent directory) */
1900
1901 #if 0
1902         /*
1903          * Destroy any associated vnode, but only if this was the last
1904          * link.  XXX this might not be needed.
1905          */
1906         if (chain->u.ip->vp) {
1907                 struct vnode *vp;
1908                 vp = hammer2_igetv(chain->u.ip, &error);
1909                 if (error == 0) {
1910                         vn_unlock(vp);
1911                         /* hammer2_knote(vp, NOTE_DELETE); */
1912                         cache_inval_vp(vp, CINV_DESTROY);
1913                         vrele(vp);
1914                 }
1915         }
1916 #endif
1917         error = 0;
1918
1919 done:
1920         hammer2_chain_unlock(hmp, chain);
1921         hammer2_chain_unlock(hmp, parent);
1922
1923         return error;
1924 }
1925
1926
1927 static int hammer2_strategy_read(struct vop_strategy_args *ap);
1928 static int hammer2_strategy_write(struct vop_strategy_args *ap);
1929
1930 static
1931 int
1932 hammer2_vop_strategy(struct vop_strategy_args *ap)
1933 {
1934         struct bio *biop;
1935         struct buf *bp;
1936         int error;
1937
1938         biop = ap->a_bio;
1939         bp = biop->bio_buf;
1940
1941         switch(bp->b_cmd) {
1942         case BUF_CMD_READ:
1943                 error = hammer2_strategy_read(ap);
1944                 ++hammer2_iod_file_read;
1945                 break;
1946         case BUF_CMD_WRITE:
1947                 error = hammer2_strategy_write(ap);
1948                 ++hammer2_iod_file_write;
1949                 break;
1950         default:
1951                 bp->b_error = error = EINVAL;
1952                 bp->b_flags |= B_ERROR;
1953                 biodone(biop);
1954                 break;
1955         }
1956
1957         return (error);
1958 }
1959
1960 static
1961 int
1962 hammer2_strategy_read(struct vop_strategy_args *ap)
1963 {
1964         struct buf *bp;
1965         struct bio *bio;
1966         struct bio *nbio;
1967         hammer2_mount_t *hmp;
1968         hammer2_inode_t *ip;
1969         hammer2_chain_t *parent;
1970         hammer2_chain_t *chain;
1971         hammer2_key_t lbase;
1972
1973         bio = ap->a_bio;
1974         bp = bio->bio_buf;
1975         ip = VTOI(ap->a_vp);
1976         hmp = ip->hmp;
1977         nbio = push_bio(bio);
1978
1979         lbase = bio->bio_offset;
1980         chain = NULL;
1981         KKASSERT(((int)lbase & HAMMER2_PBUFMASK) == 0);
1982
1983         /*
1984          * We must characterize the logical->physical translation if it
1985          * has not already been cached.
1986          *
1987          * Physical data references < LBUFSIZE are never cached.  This
1988          * includes both small-block allocations and inode-embedded data.
1989          */
1990         if (nbio->bio_offset == NOOFFSET) {
1991                 parent = &ip->chain;
1992                 hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
1993
1994                 chain = hammer2_chain_lookup(hmp, &parent, lbase, lbase,
1995                                              HAMMER2_LOOKUP_NODATA);
1996                 if (chain == NULL) {
1997                         /*
1998                          * Data is zero-fill
1999                          */
2000                         nbio->bio_offset = ZFOFFSET;
2001                 } else if (chain->bref.type == HAMMER2_BREF_TYPE_INODE) {
2002                         /*
2003                          * Data is embedded in the inode (do nothing)
2004                          */
2005                         KKASSERT(chain == parent);
2006                         hammer2_chain_unlock(hmp, chain);
2007                 } else if (chain->bref.type == HAMMER2_BREF_TYPE_DATA) {
2008                         /*
2009                          * Data is on-media
2010                          */
2011                         KKASSERT(bp->b_bcount == chain->bytes);
2012                         nbio->bio_offset = chain->bref.data_off &
2013                                            HAMMER2_OFF_MASK;
2014                         hammer2_chain_unlock(hmp, chain);
2015                         KKASSERT(nbio->bio_offset != 0);
2016                 } else {
2017                         panic("hammer2_strategy_read: unknown bref type");
2018                 }
2019                 hammer2_chain_unlock(hmp, parent);
2020         }
2021
2022         if (hammer2_debug & 0x0020) {
2023                 kprintf("read %016jx %016jx\n",
2024                         bio->bio_offset, nbio->bio_offset);
2025         }
2026
2027         if (nbio->bio_offset == ZFOFFSET) {
2028                 /*
2029                  * Data is zero-fill
2030                  */
2031                 bp->b_resid = 0;
2032                 bp->b_error = 0;
2033                 bzero(bp->b_data, bp->b_bcount);
2034                 biodone(nbio);
2035         } else if (nbio->bio_offset != NOOFFSET) {
2036                 /*
2037                  * Forward direct IO to the device
2038                  */
2039                 vn_strategy(hmp->devvp, nbio);
2040         } else {
2041                 /*
2042                  * Data is embedded in inode.
2043                  */
2044                 bcopy(chain->data->ipdata.u.data, bp->b_data,
2045                       HAMMER2_EMBEDDED_BYTES);
2046                 bzero(bp->b_data + HAMMER2_EMBEDDED_BYTES,
2047                       bp->b_bcount - HAMMER2_EMBEDDED_BYTES);
2048                 bp->b_resid = 0;
2049                 bp->b_error = 0;
2050                 biodone(nbio);
2051         }
2052         return (0);
2053 }
2054
2055 static
2056 int
2057 hammer2_strategy_write(struct vop_strategy_args *ap)
2058 {
2059         struct buf *bp;
2060         struct bio *bio;
2061         struct bio *nbio;
2062         hammer2_mount_t *hmp;
2063         hammer2_inode_t *ip;
2064
2065         bio = ap->a_bio;
2066         bp = bio->bio_buf;
2067         ip = VTOI(ap->a_vp);
2068         hmp = ip->hmp;
2069         nbio = push_bio(bio);
2070
2071         KKASSERT((bio->bio_offset & HAMMER2_PBUFMASK64) == 0);
2072         KKASSERT(nbio->bio_offset != 0 && nbio->bio_offset != ZFOFFSET);
2073
2074         if (nbio->bio_offset == NOOFFSET) {
2075                 /*
2076                  * Must be embedded in the inode.
2077                  */
2078                 KKASSERT(bio->bio_offset == 0);
2079                 bcopy(bp->b_data, ip->ip_data.u.data, HAMMER2_EMBEDDED_BYTES);
2080                 bp->b_resid = 0;
2081                 bp->b_error = 0;
2082                 biodone(nbio);
2083
2084                 /*
2085                  * This special flag does not follow the normal MODIFY1 rules
2086                  * because we might deadlock on ip.  Instead we depend on
2087                  * VOP_FSYNC() to detect the case.
2088                  */
2089                 atomic_set_int(&ip->chain.flags, HAMMER2_CHAIN_DIRTYEMBED);
2090         } else {
2091                 /*
2092                  * Forward direct IO to the device
2093                  */
2094                 vn_strategy(hmp->devvp, nbio);
2095         }
2096         return (0);
2097 }
2098
2099 static
2100 int
2101 hammer2_vop_mountctl(struct vop_mountctl_args *ap)
2102 {
2103         struct mount *mp;
2104         struct hammer2_mount *hmp;
2105         int rc;
2106
2107         switch (ap->a_op) {
2108         case (MOUNTCTL_SET_EXPORT):
2109                 mp = ap->a_head.a_ops->head.vv_mount;
2110                 hmp = MPTOH2(mp);
2111
2112                 if (ap->a_ctllen != sizeof(struct export_args))
2113                         rc = (EINVAL);
2114                 else
2115                         rc = vfs_export(mp, &hmp->export,
2116                                         (const struct export_args *)ap->a_ctl);
2117                 break;
2118         default:
2119                 rc = vop_stdmountctl(ap);
2120                 break;
2121         }
2122         return (rc);
2123 }
2124
2125 struct vop_ops hammer2_vnode_vops = {
2126         .vop_default    = vop_defaultop,
2127         .vop_fsync      = hammer2_vop_fsync,
2128         .vop_getpages   = vop_stdgetpages,
2129         .vop_putpages   = vop_stdputpages,
2130         .vop_access     = hammer2_vop_access,
2131         .vop_advlock    = hammer2_vop_advlock,
2132         .vop_close      = hammer2_vop_close,
2133         .vop_nlink      = hammer2_vop_nlink,
2134         .vop_ncreate    = hammer2_vop_ncreate,
2135         .vop_nsymlink   = hammer2_vop_nsymlink,
2136         .vop_nremove    = hammer2_vop_nremove,
2137         .vop_nrmdir     = hammer2_vop_nrmdir,
2138         .vop_nrename    = hammer2_vop_nrename,
2139         .vop_getattr    = hammer2_vop_getattr,
2140         .vop_setattr    = hammer2_vop_setattr,
2141         .vop_readdir    = hammer2_vop_readdir,
2142         .vop_readlink   = hammer2_vop_readlink,
2143         .vop_getpages   = vop_stdgetpages,
2144         .vop_putpages   = vop_stdputpages,
2145         .vop_read       = hammer2_vop_read,
2146         .vop_write      = hammer2_vop_write,
2147         .vop_open       = hammer2_vop_open,
2148         .vop_inactive   = hammer2_vop_inactive,
2149         .vop_reclaim    = hammer2_vop_reclaim,
2150         .vop_nresolve   = hammer2_vop_nresolve,
2151         .vop_nlookupdotdot = hammer2_vop_nlookupdotdot,
2152         .vop_nmkdir     = hammer2_vop_nmkdir,
2153         .vop_mountctl   = hammer2_vop_mountctl,
2154         .vop_bmap       = hammer2_vop_bmap,
2155         .vop_strategy   = hammer2_vop_strategy,
2156 };
2157
2158 struct vop_ops hammer2_spec_vops = {
2159
2160 };
2161
2162 struct vop_ops hammer2_fifo_vops = {
2163
2164 };