sys/vfs/hammer/hammer_vnops.c

   1 /*
   2  * Copyright (c) 2007-2008 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $DragonFly: src/sys/vfs/hammer/hammer_vnops.c,v 1.44 2008/05/02 06:51:57 dillon Exp $
  35  */
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/fcntl.h>
  41 #include <sys/namecache.h>
  42 #include <sys/vnode.h>
  43 #include <sys/lockf.h>
  44 #include <sys/event.h>
  45 #include <sys/stat.h>
  46 #include <sys/dirent.h>
  47 #include <vm/vm_extern.h>
  48 #include <vfs/fifofs/fifo.h>
  49 #include "hammer.h"
  50
  51 /*
  52  * USERFS VNOPS
  53  */
  54 /*static int hammer_vop_vnoperate(struct vop_generic_args *);*/
  55 static int hammer_vop_fsync(struct vop_fsync_args *);
  56 static int hammer_vop_read(struct vop_read_args *);
  57 static int hammer_vop_write(struct vop_write_args *);
  58 static int hammer_vop_access(struct vop_access_args *);
  59 static int hammer_vop_advlock(struct vop_advlock_args *);
  60 static int hammer_vop_close(struct vop_close_args *);
  61 static int hammer_vop_ncreate(struct vop_ncreate_args *);
  62 static int hammer_vop_getattr(struct vop_getattr_args *);
  63 static int hammer_vop_nresolve(struct vop_nresolve_args *);
  64 static int hammer_vop_nlookupdotdot(struct vop_nlookupdotdot_args *);
  65 static int hammer_vop_nlink(struct vop_nlink_args *);
  66 static int hammer_vop_nmkdir(struct vop_nmkdir_args *);
  67 static int hammer_vop_nmknod(struct vop_nmknod_args *);
  68 static int hammer_vop_open(struct vop_open_args *);
  69 static int hammer_vop_pathconf(struct vop_pathconf_args *);
  70 static int hammer_vop_print(struct vop_print_args *);
  71 static int hammer_vop_readdir(struct vop_readdir_args *);
  72 static int hammer_vop_readlink(struct vop_readlink_args *);
  73 static int hammer_vop_nremove(struct vop_nremove_args *);
  74 static int hammer_vop_nrename(struct vop_nrename_args *);
  75 static int hammer_vop_nrmdir(struct vop_nrmdir_args *);
  76 static int hammer_vop_setattr(struct vop_setattr_args *);
  77 static int hammer_vop_strategy(struct vop_strategy_args *);
  78 static int hammer_vop_nsymlink(struct vop_nsymlink_args *);
  79 static int hammer_vop_nwhiteout(struct vop_nwhiteout_args *);
  80 static int hammer_vop_ioctl(struct vop_ioctl_args *);
  81 static int hammer_vop_mountctl(struct vop_mountctl_args *);
  82
  83 static int hammer_vop_fifoclose (struct vop_close_args *);
  84 static int hammer_vop_fiforead (struct vop_read_args *);
  85 static int hammer_vop_fifowrite (struct vop_write_args *);
  86
  87 static int hammer_vop_specclose (struct vop_close_args *);
  88 static int hammer_vop_specread (struct vop_read_args *);
  89 static int hammer_vop_specwrite (struct vop_write_args *);
  90
  91 struct vop_ops hammer_vnode_vops = {
  92         .vop_default =          vop_defaultop,
  93         .vop_fsync =            hammer_vop_fsync,
  94         .vop_getpages =         vop_stdgetpages,
  95         .vop_putpages =         vop_stdputpages,
  96         .vop_read =             hammer_vop_read,
  97         .vop_write =            hammer_vop_write,
  98         .vop_access =           hammer_vop_access,
  99         .vop_advlock =          hammer_vop_advlock,
 100         .vop_close =            hammer_vop_close,
 101         .vop_ncreate =          hammer_vop_ncreate,
 102         .vop_getattr =          hammer_vop_getattr,
 103         .vop_inactive =         hammer_vop_inactive,
 104         .vop_reclaim =          hammer_vop_reclaim,
 105         .vop_nresolve =         hammer_vop_nresolve,
 106         .vop_nlookupdotdot =    hammer_vop_nlookupdotdot,
 107         .vop_nlink =            hammer_vop_nlink,
 108         .vop_nmkdir =           hammer_vop_nmkdir,
 109         .vop_nmknod =           hammer_vop_nmknod,
 110         .vop_open =             hammer_vop_open,
 111         .vop_pathconf =         hammer_vop_pathconf,
 112         .vop_print =            hammer_vop_print,
 113         .vop_readdir =          hammer_vop_readdir,
 114         .vop_readlink =         hammer_vop_readlink,
 115         .vop_nremove =          hammer_vop_nremove,
 116         .vop_nrename =          hammer_vop_nrename,
 117         .vop_nrmdir =           hammer_vop_nrmdir,
 118         .vop_setattr =          hammer_vop_setattr,
 119         .vop_strategy =         hammer_vop_strategy,
 120         .vop_nsymlink =         hammer_vop_nsymlink,
 121         .vop_nwhiteout =        hammer_vop_nwhiteout,
 122         .vop_ioctl =            hammer_vop_ioctl,
 123         .vop_mountctl =         hammer_vop_mountctl
 124 };
 125
 126 struct vop_ops hammer_spec_vops = {
 127         .vop_default =          spec_vnoperate,
 128         .vop_fsync =            hammer_vop_fsync,
 129         .vop_read =             hammer_vop_specread,
 130         .vop_write =            hammer_vop_specwrite,
 131         .vop_access =           hammer_vop_access,
 132         .vop_close =            hammer_vop_specclose,
 133         .vop_getattr =          hammer_vop_getattr,
 134         .vop_inactive =         hammer_vop_inactive,
 135         .vop_reclaim =          hammer_vop_reclaim,
 136         .vop_setattr =          hammer_vop_setattr
 137 };
 138
 139 struct vop_ops hammer_fifo_vops = {
 140         .vop_default =          fifo_vnoperate,
 141         .vop_fsync =            hammer_vop_fsync,
 142         .vop_read =             hammer_vop_fiforead,
 143         .vop_write =            hammer_vop_fifowrite,
 144         .vop_access =           hammer_vop_access,
 145         .vop_close =            hammer_vop_fifoclose,
 146         .vop_getattr =          hammer_vop_getattr,
 147         .vop_inactive =         hammer_vop_inactive,
 148         .vop_reclaim =          hammer_vop_reclaim,
 149         .vop_setattr =          hammer_vop_setattr
 150 };
 151
 152 static int hammer_dounlink(hammer_transaction_t trans, struct nchandle *nch,
 153                            struct vnode *dvp, struct ucred *cred, int flags);
 154 static int hammer_vop_strategy_read(struct vop_strategy_args *ap);
 155 static int hammer_vop_strategy_write(struct vop_strategy_args *ap);
 156
 157 #if 0
 158 static
 159 int
 160 hammer_vop_vnoperate(struct vop_generic_args *)
 161 {
 162         return (VOCALL(&hammer_vnode_vops, ap));
 163 }
 164 #endif
 165
 166 /*
 167  * hammer_vop_fsync { vp, waitfor }
 168  */
 169 static
 170 int
 171 hammer_vop_fsync(struct vop_fsync_args *ap)
 172 {
 173         hammer_inode_t ip = VTOI(ap->a_vp);
 174
 175         hammer_flush_inode(ip, HAMMER_FLUSH_SIGNAL);
 176         if (ap->a_waitfor == MNT_WAIT)
 177                 hammer_wait_inode(ip);
 178         return (ip->error);
 179 }
 180
 181 /*
 182  * hammer_vop_read { vp, uio, ioflag, cred }
 183  */
 184 static
 185 int
 186 hammer_vop_read(struct vop_read_args *ap)
 187 {
 188         struct hammer_transaction trans;
 189         hammer_inode_t ip;
 190         off_t offset;
 191         struct buf *bp;
 192         struct uio *uio;
 193         int error;
 194         int n;
 195         int seqcount;
 196
 197         if (ap->a_vp->v_type != VREG)
 198                 return (EINVAL);
 199         ip = VTOI(ap->a_vp);
 200         error = 0;
 201         seqcount = ap->a_ioflag >> 16;
 202
 203         hammer_start_transaction(&trans, ip->hmp);
 204
 205         /*
 206          * Access the data in HAMMER_BUFSIZE blocks via the buffer cache.
 207          */
 208         uio = ap->a_uio;
 209         while (uio->uio_resid > 0 && uio->uio_offset < ip->ino_rec.ino_size) {
 210                 offset = uio->uio_offset & HAMMER_BUFMASK;
 211 #if 0
 212                 error = cluster_read(ap->a_vp, ip->ino_rec.ino_size,
 213                                      uio->uio_offset - offset, HAMMER_BUFSIZE,
 214                                      MAXBSIZE, seqcount, &bp);
 215 #endif
 216                 error = bread(ap->a_vp, uio->uio_offset - offset,
 217                               HAMMER_BUFSIZE, &bp);
 218                 if (error) {
 219                         brelse(bp);
 220                         break;
 221                 }
 222                 /* bp->b_flags |= B_CLUSTEROK; temporarily disabled */
 223                 n = HAMMER_BUFSIZE - offset;
 224                 if (n > uio->uio_resid)
 225                         n = uio->uio_resid;
 226                 if (n > ip->ino_rec.ino_size - uio->uio_offset)
 227                         n = (int)(ip->ino_rec.ino_size - uio->uio_offset);
 228                 error = uiomove((char *)bp->b_data + offset, n, uio);
 229                 if (error) {
 230                         bqrelse(bp);
 231                         break;
 232                 }
 233                 bqrelse(bp);
 234         }
 235         if ((ip->flags & HAMMER_INODE_RO) == 0 &&
 236             (ip->hmp->mp->mnt_flag & MNT_NOATIME) == 0) {
 237                 ip->ino_rec.ino_atime = trans.time;
 238                 hammer_modify_inode(&trans, ip, HAMMER_INODE_ITIMES);
 239         }
 240         hammer_done_transaction(&trans);
 241         return (error);
 242 }
 243
 244 /*
 245  * hammer_vop_write { vp, uio, ioflag, cred }
 246  */
 247 static
 248 int
 249 hammer_vop_write(struct vop_write_args *ap)
 250 {
 251         struct hammer_transaction trans;
 252         struct hammer_inode *ip;
 253         struct uio *uio;
 254         off_t offset;
 255         struct buf *bp;
 256         int error;
 257         int n;
 258         int flags;
 259         int count;
 260
 261         if (ap->a_vp->v_type != VREG)
 262                 return (EINVAL);
 263         ip = VTOI(ap->a_vp);
 264         error = 0;
 265
 266         if (ip->flags & HAMMER_INODE_RO)
 267                 return (EROFS);
 268
 269         /*
 270          * Create a transaction to cover the operations we perform.
 271          */
 272         hammer_start_transaction(&trans, ip->hmp);
 273         uio = ap->a_uio;
 274
 275         /*
 276          * Check append mode
 277          */
 278         if (ap->a_ioflag & IO_APPEND)
 279                 uio->uio_offset = ip->ino_rec.ino_size;
 280
 281         /*
 282          * Check for illegal write offsets.  Valid range is 0...2^63-1
 283          */
 284         if (uio->uio_offset < 0 || uio->uio_offset + uio->uio_resid <= 0) {
 285                 hammer_done_transaction(&trans);
 286                 return (EFBIG);
 287         }
 288
 289         /*
 290          * Access the data in HAMMER_BUFSIZE blocks via the buffer cache.
 291          */
 292         count = 0;
 293         while (uio->uio_resid > 0) {
 294                 int fixsize = 0;
 295
 296                 /*
 297                  * Do not allow huge writes to deadlock the buffer cache
 298                  */
 299                 if ((++count & 15) == 0) {
 300                         vn_unlock(ap->a_vp);
 301                         if ((ap->a_ioflag & IO_NOBWILL) == 0)
 302                                 bwillwrite();
 303                         vn_lock(ap->a_vp, LK_EXCLUSIVE|LK_RETRY);
 304                 }
 305
 306                 offset = uio->uio_offset & HAMMER_BUFMASK;
 307                 n = HAMMER_BUFSIZE - offset;
 308                 if (n > uio->uio_resid)
 309                         n = uio->uio_resid;
 310                 if (uio->uio_offset + n > ip->ino_rec.ino_size) {
 311                         vnode_pager_setsize(ap->a_vp, uio->uio_offset + n);
 312                         fixsize = 1;
 313                 }
 314
 315                 if (uio->uio_segflg == UIO_NOCOPY) {
 316                         /*
 317                          * Issuing a write with the same data backing the
 318                          * buffer.  Instantiate the buffer to collect the
 319                          * backing vm pages, then read-in any missing bits.
 320                          *
 321                          * This case is used by vop_stdputpages().
 322                          */
 323                         bp = getblk(ap->a_vp, uio->uio_offset - offset,
 324                                     HAMMER_BUFSIZE, GETBLK_BHEAVY, 0);
 325                         if ((bp->b_flags & B_CACHE) == 0) {
 326                                 bqrelse(bp);
 327                                 error = bread(ap->a_vp,
 328                                               uio->uio_offset - offset,
 329                                               HAMMER_BUFSIZE, &bp);
 330                         }
 331                 } else if (offset == 0 && uio->uio_resid >= HAMMER_BUFSIZE) {
 332                         /*
 333                          * Even though we are entirely overwriting the buffer
 334                          * we may still have to zero it out to avoid a
 335                          * mmap/write visibility issue.
 336                          */
 337                         bp = getblk(ap->a_vp, uio->uio_offset - offset,
 338                                     HAMMER_BUFSIZE, GETBLK_BHEAVY, 0);
 339                         if ((bp->b_flags & B_CACHE) == 0)
 340                                 vfs_bio_clrbuf(bp);
 341                 } else if (uio->uio_offset - offset >= ip->ino_rec.ino_size) {
 342                         /*
 343                          * If the base offset of the buffer is beyond the
 344                          * file EOF, we don't have to issue a read.
 345                          */
 346                         bp = getblk(ap->a_vp, uio->uio_offset - offset,
 347                                     HAMMER_BUFSIZE, GETBLK_BHEAVY, 0);
 348                         vfs_bio_clrbuf(bp);
 349                 } else {
 350                         /*
 351                          * Partial overwrite, read in any missing bits then
 352                          * replace the portion being written.
 353                          */
 354                         error = bread(ap->a_vp, uio->uio_offset - offset,
 355                                       HAMMER_BUFSIZE, &bp);
 356                         if (error == 0)
 357                                 bheavy(bp);
 358                 }
 359                 if (error == 0)
 360                         error = uiomove((char *)bp->b_data + offset, n, uio);
 361
 362                 /*
 363                  * If we screwed up we have to undo any VM size changes we
 364                  * made.
 365                  */
 366                 if (error) {
 367                         brelse(bp);
 368                         if (fixsize) {
 369                                 vtruncbuf(ap->a_vp, ip->ino_rec.ino_size,
 370                                           HAMMER_BUFSIZE);
 371                         }
 372                         break;
 373                 }
 374                 /* bp->b_flags |= B_CLUSTEROK; temporarily disabled */
 375                 hammer_lock_sh(&ip->lock);
 376                 if (ip->ino_rec.ino_size < uio->uio_offset) {
 377                         ip->ino_rec.ino_size = uio->uio_offset;
 378                         flags = HAMMER_INODE_RDIRTY;
 379                         vnode_pager_setsize(ap->a_vp, ip->ino_rec.ino_size);
 380                 } else {
 381                         flags = 0;
 382                 }
 383                 ip->ino_rec.ino_mtime = trans.time;
 384                 flags |= HAMMER_INODE_ITIMES | HAMMER_INODE_BUFS;
 385                 hammer_modify_inode(&trans, ip, flags);
 386                 hammer_unlock(&ip->lock);
 387
 388                 if (ap->a_ioflag & IO_SYNC) {
 389                         bwrite(bp);
 390                 } else if (ap->a_ioflag & IO_DIRECT) {
 391                         bawrite(bp);
 392 #if 0
 393                 } else if ((ap->a_ioflag >> 16) == IO_SEQMAX &&
 394                            (uio->uio_offset & HAMMER_BUFMASK) == 0) {
 395                         /*
 396                          * XXX HAMMER can only fsync the whole inode,
 397                          * doing it on every buffer would be a bad idea.
 398                          */
 399                         /*
 400                          * If seqcount indicates sequential operation and
 401                          * we just finished filling a buffer, push it out
 402                          * now to prevent the buffer cache from becoming
 403                          * too full, which would trigger non-optimal
 404                          * flushes.
 405                          */
 406                         bdwrite(bp);
 407 #endif
 408                 } else {
 409                         bdwrite(bp);
 410                 }
 411         }
 412         hammer_done_transaction(&trans);
 413         return (error);
 414 }
 415
 416 /*
 417  * hammer_vop_access { vp, mode, cred }
 418  */
 419 static
 420 int
 421 hammer_vop_access(struct vop_access_args *ap)
 422 {
 423         struct hammer_inode *ip = VTOI(ap->a_vp);
 424         uid_t uid;
 425         gid_t gid;
 426         int error;
 427
 428         uid = hammer_to_unix_xid(&ip->ino_data.uid);
 429         gid = hammer_to_unix_xid(&ip->ino_data.gid);
 430
 431         error = vop_helper_access(ap, uid, gid, ip->ino_data.mode,
 432                                   ip->ino_data.uflags);
 433         return (error);
 434 }
 435
 436 /*
 437  * hammer_vop_advlock { vp, id, op, fl, flags }
 438  */
 439 static
 440 int
 441 hammer_vop_advlock(struct vop_advlock_args *ap)
 442 {
 443         struct hammer_inode *ip = VTOI(ap->a_vp);
 444
 445         return (lf_advlock(ap, &ip->advlock, ip->ino_rec.ino_size));
 446 }
 447
 448 /*
 449  * hammer_vop_close { vp, fflag }
 450  */
 451 static
 452 int
 453 hammer_vop_close(struct vop_close_args *ap)
 454 {
 455         return (vop_stdclose(ap));
 456 }
 457
 458 /*
 459  * hammer_vop_ncreate { nch, dvp, vpp, cred, vap }
 460  *
 461  * The operating system has already ensured that the directory entry
 462  * does not exist and done all appropriate namespace locking.
 463  */
 464 static
 465 int
 466 hammer_vop_ncreate(struct vop_ncreate_args *ap)
 467 {
 468         struct hammer_transaction trans;
 469         struct hammer_inode *dip;
 470         struct hammer_inode *nip;
 471         struct nchandle *nch;
 472         int error;
 473
 474         nch = ap->a_nch;
 475         dip = VTOI(ap->a_dvp);
 476
 477         if (dip->flags & HAMMER_INODE_RO)
 478                 return (EROFS);
 479
 480         /*
 481          * Create a transaction to cover the operations we perform.
 482          */
 483         hammer_start_transaction(&trans, dip->hmp);
 484
 485         /*
 486          * Create a new filesystem object of the requested type.  The
 487          * returned inode will be referenced and shared-locked to prevent
 488          * it from being moved to the flusher.
 489          */
 490
 491         error = hammer_create_inode(&trans, ap->a_vap, ap->a_cred, dip, &nip);
 492         if (error) {
 493                 kprintf("hammer_create_inode error %d\n", error);
 494                 hammer_done_transaction(&trans);
 495                 *ap->a_vpp = NULL;
 496                 return (error);
 497         }
 498         hammer_lock_sh(&nip->lock);
 499         hammer_lock_sh(&dip->lock);
 500
 501         /*
 502          * Add the new filesystem object to the directory.  This will also
 503          * bump the inode's link count.
 504          */
 505         error = hammer_ip_add_directory(&trans, dip, nch->ncp, nip);
 506         if (error)
 507                 kprintf("hammer_ip_add_directory error %d\n", error);
 508         hammer_unlock(&dip->lock);
 509         hammer_unlock(&nip->lock);
 510
 511         /*
 512          * Finish up.
 513          */
 514         if (error) {
 515                 hammer_rel_inode(nip, 0);
 516                 hammer_done_transaction(&trans);
 517                 *ap->a_vpp = NULL;
 518         } else {
 519                 error = hammer_get_vnode(nip, LK_EXCLUSIVE, ap->a_vpp);
 520                 hammer_done_transaction(&trans);
 521                 hammer_rel_inode(nip, 0);
 522                 if (error == 0) {
 523                         cache_setunresolved(ap->a_nch);
 524                         cache_setvp(ap->a_nch, *ap->a_vpp);
 525                 }
 526         }
 527         return (error);
 528 }
 529
 530 /*
 531  * hammer_vop_getattr { vp, vap }
 532  */
 533 static
 534 int
 535 hammer_vop_getattr(struct vop_getattr_args *ap)
 536 {
 537         struct hammer_inode *ip = VTOI(ap->a_vp);
 538         struct vattr *vap = ap->a_vap;
 539
 540 #if 0
 541         if (cache_check_fsmid_vp(ap->a_vp, &ip->fsmid) &&
 542             (vp->v_mount->mnt_flag & MNT_RDONLY) == 0 &&
 543             ip->obj_asof == XXX
 544         ) {
 545                 /* LAZYMOD XXX */
 546         }
 547         hammer_itimes(ap->a_vp);
 548 #endif
 549
 550         vap->va_fsid = ip->hmp->fsid_udev;
 551         vap->va_fileid = ip->ino_rec.base.base.obj_id;
 552         vap->va_mode = ip->ino_data.mode;
 553         vap->va_nlink = ip->ino_rec.ino_nlinks;
 554         vap->va_uid = hammer_to_unix_xid(&ip->ino_data.uid);
 555         vap->va_gid = hammer_to_unix_xid(&ip->ino_data.gid);
 556         vap->va_rmajor = 0;
 557         vap->va_rminor = 0;
 558         vap->va_size = ip->ino_rec.ino_size;
 559         hammer_to_timespec(ip->ino_rec.ino_atime, &vap->va_atime);
 560         hammer_to_timespec(ip->ino_rec.ino_mtime, &vap->va_mtime);
 561         hammer_to_timespec(ip->ino_data.ctime, &vap->va_ctime);
 562         vap->va_flags = ip->ino_data.uflags;
 563         vap->va_gen = 1;        /* hammer inums are unique for all time */
 564         vap->va_blocksize = HAMMER_BUFSIZE;
 565         vap->va_bytes = (ip->ino_rec.ino_size + 63) & ~63;
 566         vap->va_type = hammer_get_vnode_type(ip->ino_rec.base.base.obj_type);
 567         vap->va_filerev = 0;    /* XXX */
 568         /* mtime uniquely identifies any adjustments made to the file */
 569         vap->va_fsmid = ip->ino_rec.ino_mtime;
 570         vap->va_uid_uuid = ip->ino_data.uid;
 571         vap->va_gid_uuid = ip->ino_data.gid;
 572         vap->va_fsid_uuid = ip->hmp->fsid;
 573         vap->va_vaflags = VA_UID_UUID_VALID | VA_GID_UUID_VALID |
 574                           VA_FSID_UUID_VALID;
 575
 576         switch (ip->ino_rec.base.base.obj_type) {
 577         case HAMMER_OBJTYPE_CDEV:
 578         case HAMMER_OBJTYPE_BDEV:
 579                 vap->va_rmajor = ip->ino_data.rmajor;
 580                 vap->va_rminor = ip->ino_data.rminor;
 581                 break;
 582         default:
 583                 break;
 584         }
 585
 586         return(0);
 587 }
 588
 589 /*
 590  * hammer_vop_nresolve { nch, dvp, cred }
 591  *
 592  * Locate the requested directory entry.
 593  */
 594 static
 595 int
 596 hammer_vop_nresolve(struct vop_nresolve_args *ap)
 597 {
 598         struct hammer_transaction trans;
 599         struct namecache *ncp;
 600         hammer_inode_t dip;
 601         hammer_inode_t ip;
 602         hammer_tid_t asof;
 603         struct hammer_cursor cursor;
 604         union hammer_record_ondisk *rec;
 605         struct vnode *vp;
 606         int64_t namekey;
 607         int error;
 608         int i;
 609         int nlen;
 610         int flags;
 611         u_int64_t obj_id;
 612
 613         /*
 614          * Misc initialization, plus handle as-of name extensions.  Look for
 615          * the '@@' extension.  Note that as-of files and directories cannot
 616          * be modified.
 617          */
 618         dip = VTOI(ap->a_dvp);
 619         ncp = ap->a_nch->ncp;
 620         asof = dip->obj_asof;
 621         nlen = ncp->nc_nlen;
 622         flags = dip->flags;
 623
 624         hammer_simple_transaction(&trans, dip->hmp);
 625
 626         for (i = 0; i < nlen; ++i) {
 627                 if (ncp->nc_name[i] == '@' && ncp->nc_name[i+1] == '@') {
 628                         asof = hammer_str_to_tid(ncp->nc_name + i + 2);
 629                         flags |= HAMMER_INODE_RO;
 630                         break;
 631                 }
 632         }
 633         nlen = i;
 634
 635         /*
 636          * If there is no path component the time extension is relative to
 637          * dip.
 638          */
 639         if (nlen == 0) {
 640                 ip = hammer_get_inode(&trans, &dip->cache[1], dip->obj_id,
 641                                       asof, flags, &error);
 642                 if (error == 0) {
 643                         error = hammer_get_vnode(ip, LK_EXCLUSIVE, &vp);
 644                         hammer_rel_inode(ip, 0);
 645                 } else {
 646                         vp = NULL;
 647                 }
 648                 if (error == 0) {
 649                         vn_unlock(vp);
 650                         cache_setvp(ap->a_nch, vp);
 651                         vrele(vp);
 652                 }
 653                 goto done;
 654         }
 655
 656         /*
 657          * Calculate the namekey and setup the key range for the scan.  This
 658          * works kinda like a chained hash table where the lower 32 bits
 659          * of the namekey synthesize the chain.
 660          *
 661          * The key range is inclusive of both key_beg and key_end.
 662          */
 663         namekey = hammer_directory_namekey(ncp->nc_name, nlen);
 664
 665         error = hammer_init_cursor(&trans, &cursor, &dip->cache[0]);
 666         cursor.key_beg.obj_id = dip->obj_id;
 667         cursor.key_beg.key = namekey;
 668         cursor.key_beg.create_tid = 0;
 669         cursor.key_beg.delete_tid = 0;
 670         cursor.key_beg.rec_type = HAMMER_RECTYPE_DIRENTRY;
 671         cursor.key_beg.obj_type = 0;
 672
 673         cursor.key_end = cursor.key_beg;
 674         cursor.key_end.key |= 0xFFFFFFFFULL;
 675         cursor.asof = asof;
 676         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE | HAMMER_CURSOR_ASOF;
 677
 678         /*
 679          * Scan all matching records (the chain), locate the one matching
 680          * the requested path component.
 681          *
 682          * The hammer_ip_*() functions merge in-memory records with on-disk
 683          * records for the purposes of the search.
 684          */
 685         if (error == 0)
 686                 error = hammer_ip_first(&cursor, dip);
 687
 688         rec = NULL;
 689         obj_id = 0;
 690
 691         while (error == 0) {
 692                 error = hammer_ip_resolve_data(&cursor);
 693                 if (error)
 694                         break;
 695                 rec = cursor.record;
 696                 if (nlen == rec->entry.base.data_len &&
 697                     bcmp(ncp->nc_name, cursor.data, nlen) == 0) {
 698                         obj_id = rec->entry.obj_id;
 699                         break;
 700                 }
 701                 error = hammer_ip_next(&cursor);
 702         }
 703         hammer_done_cursor(&cursor);
 704         if (error == 0) {
 705                 ip = hammer_get_inode(&trans, &dip->cache[1],
 706                                       obj_id, asof, flags, &error);
 707                 if (error == 0) {
 708                         error = hammer_get_vnode(ip, LK_EXCLUSIVE, &vp);
 709                         hammer_rel_inode(ip, 0);
 710                 } else {
 711                         vp = NULL;
 712                 }
 713                 if (error == 0) {
 714                         vn_unlock(vp);
 715                         cache_setvp(ap->a_nch, vp);
 716                         vrele(vp);
 717                 }
 718         } else if (error == ENOENT) {
 719                 cache_setvp(ap->a_nch, NULL);
 720         }
 721 done:
 722         hammer_done_transaction(&trans);
 723         return (error);
 724 }
 725
 726 /*
 727  * hammer_vop_nlookupdotdot { dvp, vpp, cred }
 728  *
 729  * Locate the parent directory of a directory vnode.
 730  *
 731  * dvp is referenced but not locked.  *vpp must be returned referenced and
 732  * locked.  A parent_obj_id of 0 does not necessarily indicate that we are
 733  * at the root, instead it could indicate that the directory we were in was
 734  * removed.
 735  *
 736  * NOTE: as-of sequences are not linked into the directory structure.  If
 737  * we are at the root with a different asof then the mount point, reload
 738  * the same directory with the mount point's asof.   I'm not sure what this
 739  * will do to NFS.  We encode ASOF stamps in NFS file handles so it might not
 740  * get confused, but it hasn't been tested.
 741  */
 742 static
 743 int
 744 hammer_vop_nlookupdotdot(struct vop_nlookupdotdot_args *ap)
 745 {
 746         struct hammer_transaction trans;
 747         struct hammer_inode *dip;
 748         struct hammer_inode *ip;
 749         int64_t parent_obj_id;
 750         hammer_tid_t asof;
 751         int error;
 752
 753         dip = VTOI(ap->a_dvp);
 754         asof = dip->obj_asof;
 755         parent_obj_id = dip->ino_data.parent_obj_id;
 756
 757         if (parent_obj_id == 0) {
 758                 if (dip->obj_id == HAMMER_OBJID_ROOT &&
 759                    asof != dip->hmp->asof) {
 760                         parent_obj_id = dip->obj_id;
 761                         asof = dip->hmp->asof;
 762                         *ap->a_fakename = kmalloc(19, M_TEMP, M_WAITOK);
 763                         ksnprintf(*ap->a_fakename, 19, "0x%016llx",
 764                                    dip->obj_asof);
 765                 } else {
 766                         *ap->a_vpp = NULL;
 767                         return ENOENT;
 768                 }
 769         }
 770
 771         hammer_simple_transaction(&trans, dip->hmp);
 772
 773         ip = hammer_get_inode(&trans, &dip->cache[1], parent_obj_id,
 774                               asof, dip->flags, &error);
 775         if (ip) {
 776                 error = hammer_get_vnode(ip, LK_EXCLUSIVE, ap->a_vpp);
 777                 hammer_rel_inode(ip, 0);
 778         } else {
 779                 *ap->a_vpp = NULL;
 780         }
 781         hammer_done_transaction(&trans);
 782         return (error);
 783 }
 784
 785 /*
 786  * hammer_vop_nlink { nch, dvp, vp, cred }
 787  */
 788 static
 789 int
 790 hammer_vop_nlink(struct vop_nlink_args *ap)
 791 {
 792         struct hammer_transaction trans;
 793         struct hammer_inode *dip;
 794         struct hammer_inode *ip;
 795         struct nchandle *nch;
 796         int error;
 797
 798         nch = ap->a_nch;
 799         dip = VTOI(ap->a_dvp);
 800         ip = VTOI(ap->a_vp);
 801
 802         if (dip->flags & HAMMER_INODE_RO)
 803                 return (EROFS);
 804         if (ip->flags & HAMMER_INODE_RO)
 805                 return (EROFS);
 806
 807         /*
 808          * Create a transaction to cover the operations we perform.
 809          */
 810         hammer_start_transaction(&trans, dip->hmp);
 811
 812         /*
 813          * Add the filesystem object to the directory.  Note that neither
 814          * dip nor ip are referenced or locked, but their vnodes are
 815          * referenced.  This function will bump the inode's link count.
 816          */
 817         hammer_lock_sh(&ip->lock);
 818         hammer_lock_sh(&dip->lock);
 819         error = hammer_ip_add_directory(&trans, dip, nch->ncp, ip);
 820         hammer_unlock(&dip->lock);
 821         hammer_unlock(&ip->lock);
 822
 823         /*
 824          * Finish up.
 825          */
 826         if (error == 0) {
 827                 cache_setunresolved(nch);
 828                 cache_setvp(nch, ap->a_vp);
 829         }
 830         hammer_done_transaction(&trans);
 831         return (error);
 832 }
 833
 834 /*
 835  * hammer_vop_nmkdir { nch, dvp, vpp, cred, vap }
 836  *
 837  * The operating system has already ensured that the directory entry
 838  * does not exist and done all appropriate namespace locking.
 839  */
 840 static
 841 int
 842 hammer_vop_nmkdir(struct vop_nmkdir_args *ap)
 843 {
 844         struct hammer_transaction trans;
 845         struct hammer_inode *dip;
 846         struct hammer_inode *nip;
 847         struct nchandle *nch;
 848         int error;
 849
 850         nch = ap->a_nch;
 851         dip = VTOI(ap->a_dvp);
 852
 853         if (dip->flags & HAMMER_INODE_RO)
 854                 return (EROFS);
 855
 856         /*
 857          * Create a transaction to cover the operations we perform.
 858          */
 859         hammer_start_transaction(&trans, dip->hmp);
 860
 861         /*
 862          * Create a new filesystem object of the requested type.  The
 863          * returned inode will be referenced but not locked.
 864          */
 865         error = hammer_create_inode(&trans, ap->a_vap, ap->a_cred, dip, &nip);
 866         if (error) {
 867                 kprintf("hammer_mkdir error %d\n", error);
 868                 hammer_done_transaction(&trans);
 869                 *ap->a_vpp = NULL;
 870                 return (error);
 871         }
 872         /*
 873          * Add the new filesystem object to the directory.  This will also
 874          * bump the inode's link count.
 875          */
 876         hammer_lock_sh(&nip->lock);
 877         hammer_lock_sh(&dip->lock);
 878         error = hammer_ip_add_directory(&trans, dip, nch->ncp, nip);
 879         hammer_unlock(&dip->lock);
 880         hammer_unlock(&nip->lock);
 881         if (error)
 882                 kprintf("hammer_mkdir (add) error %d\n", error);
 883
 884         /*
 885          * Finish up.
 886          */
 887         if (error) {
 888                 hammer_rel_inode(nip, 0);
 889                 *ap->a_vpp = NULL;
 890         } else {
 891                 error = hammer_get_vnode(nip, LK_EXCLUSIVE, ap->a_vpp);
 892                 hammer_rel_inode(nip, 0);
 893                 if (error == 0) {
 894                         cache_setunresolved(ap->a_nch);
 895                         cache_setvp(ap->a_nch, *ap->a_vpp);
 896                 }
 897         }
 898         hammer_done_transaction(&trans);
 899         return (error);
 900 }
 901
 902 /*
 903  * hammer_vop_nmknod { nch, dvp, vpp, cred, vap }
 904  *
 905  * The operating system has already ensured that the directory entry
 906  * does not exist and done all appropriate namespace locking.
 907  */
 908 static
 909 int
 910 hammer_vop_nmknod(struct vop_nmknod_args *ap)
 911 {
 912         struct hammer_transaction trans;
 913         struct hammer_inode *dip;
 914         struct hammer_inode *nip;
 915         struct nchandle *nch;
 916         int error;
 917
 918         nch = ap->a_nch;
 919         dip = VTOI(ap->a_dvp);
 920
 921         if (dip->flags & HAMMER_INODE_RO)
 922                 return (EROFS);
 923
 924         /*
 925          * Create a transaction to cover the operations we perform.
 926          */
 927         hammer_start_transaction(&trans, dip->hmp);
 928
 929         /*
 930          * Create a new filesystem object of the requested type.  The
 931          * returned inode will be referenced but not locked.
 932          */
 933         error = hammer_create_inode(&trans, ap->a_vap, ap->a_cred, dip, &nip);
 934         if (error) {
 935                 hammer_done_transaction(&trans);
 936                 *ap->a_vpp = NULL;
 937                 return (error);
 938         }
 939
 940         /*
 941          * Add the new filesystem object to the directory.  This will also
 942          * bump the inode's link count.
 943          */
 944         hammer_lock_sh(&nip->lock);
 945         hammer_lock_sh(&dip->lock);
 946         error = hammer_ip_add_directory(&trans, dip, nch->ncp, nip);
 947         hammer_unlock(&dip->lock);
 948         hammer_unlock(&nip->lock);
 949
 950         /*
 951          * Finish up.
 952          */
 953         if (error) {
 954                 hammer_rel_inode(nip, 0);
 955                 *ap->a_vpp = NULL;
 956         } else {
 957                 error = hammer_get_vnode(nip, LK_EXCLUSIVE, ap->a_vpp);
 958                 hammer_rel_inode(nip, 0);
 959                 if (error == 0) {
 960                         cache_setunresolved(ap->a_nch);
 961                         cache_setvp(ap->a_nch, *ap->a_vpp);
 962                 }
 963         }
 964         hammer_done_transaction(&trans);
 965         return (error);
 966 }
 967
 968 /*
 969  * hammer_vop_open { vp, mode, cred, fp }
 970  */
 971 static
 972 int
 973 hammer_vop_open(struct vop_open_args *ap)
 974 {
 975         if ((ap->a_mode & FWRITE) && (VTOI(ap->a_vp)->flags & HAMMER_INODE_RO))
 976                 return (EROFS);
 977
 978         return(vop_stdopen(ap));
 979 }
 980
 981 /*
 982  * hammer_vop_pathconf { vp, name, retval }
 983  */
 984 static
 985 int
 986 hammer_vop_pathconf(struct vop_pathconf_args *ap)
 987 {
 988         return EOPNOTSUPP;
 989 }
 990
 991 /*
 992  * hammer_vop_print { vp }
 993  */
 994 static
 995 int
 996 hammer_vop_print(struct vop_print_args *ap)
 997 {
 998         return EOPNOTSUPP;
 999 }
1000
1001 /*
1002  * hammer_vop_readdir { vp, uio, cred, *eofflag, *ncookies, off_t **cookies }
1003  */
1004 static
1005 int
1006 hammer_vop_readdir(struct vop_readdir_args *ap)
1007 {
1008         struct hammer_transaction trans;
1009         struct hammer_cursor cursor;
1010         struct hammer_inode *ip;
1011         struct uio *uio;
1012         hammer_record_ondisk_t rec;
1013         hammer_base_elm_t base;
1014         int error;
1015         int cookie_index;
1016         int ncookies;
1017         off_t *cookies;
1018         off_t saveoff;
1019         int r;
1020
1021         ip = VTOI(ap->a_vp);
1022         uio = ap->a_uio;
1023         saveoff = uio->uio_offset;
1024
1025         if (ap->a_ncookies) {
1026                 ncookies = uio->uio_resid / 16 + 1;
1027                 if (ncookies > 1024)
1028                         ncookies = 1024;
1029                 cookies = kmalloc(ncookies * sizeof(off_t), M_TEMP, M_WAITOK);
1030                 cookie_index = 0;
1031         } else {
1032                 ncookies = -1;
1033                 cookies = NULL;
1034                 cookie_index = 0;
1035         }
1036
1037         hammer_simple_transaction(&trans, ip->hmp);
1038
1039         /*
1040          * Handle artificial entries
1041          */
1042         error = 0;
1043         if (saveoff == 0) {
1044                 r = vop_write_dirent(&error, uio, ip->obj_id, DT_DIR, 1, ".");
1045                 if (r)
1046                         goto done;
1047                 if (cookies)
1048                         cookies[cookie_index] = saveoff;
1049                 ++saveoff;
1050                 ++cookie_index;
1051                 if (cookie_index == ncookies)
1052                         goto done;
1053         }
1054         if (saveoff == 1) {
1055                 if (ip->ino_data.parent_obj_id) {
1056                         r = vop_write_dirent(&error, uio,
1057                                              ip->ino_data.parent_obj_id,
1058                                              DT_DIR, 2, "..");
1059                 } else {
1060                         r = vop_write_dirent(&error, uio,
1061                                              ip->obj_id, DT_DIR, 2, "..");
1062                 }
1063                 if (r)
1064                         goto done;
1065                 if (cookies)
1066                         cookies[cookie_index] = saveoff;
1067                 ++saveoff;
1068                 ++cookie_index;
1069                 if (cookie_index == ncookies)
1070                         goto done;
1071         }
1072
1073         /*
1074          * Key range (begin and end inclusive) to scan.  Directory keys
1075          * directly translate to a 64 bit 'seek' position.
1076          */
1077         hammer_init_cursor(&trans, &cursor, &ip->cache[0]);
1078         cursor.key_beg.obj_id = ip->obj_id;
1079         cursor.key_beg.create_tid = 0;
1080         cursor.key_beg.delete_tid = 0;
1081         cursor.key_beg.rec_type = HAMMER_RECTYPE_DIRENTRY;
1082         cursor.key_beg.obj_type = 0;
1083         cursor.key_beg.key = saveoff;
1084
1085         cursor.key_end = cursor.key_beg;
1086         cursor.key_end.key = HAMMER_MAX_KEY;
1087         cursor.asof = ip->obj_asof;
1088         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE | HAMMER_CURSOR_ASOF;
1089
1090         error = hammer_ip_first(&cursor, ip);
1091
1092         while (error == 0) {
1093                 error = hammer_ip_resolve_record_and_data(&cursor);
1094                 if (error)
1095                         break;
1096                 rec = cursor.record;
1097                 base = &rec->base.base;
1098                 saveoff = base->key;
1099
1100                 if (base->obj_id != ip->obj_id)
1101                         panic("readdir: bad record at %p", cursor.node);
1102
1103                 r = vop_write_dirent(
1104                              &error, uio, rec->entry.obj_id,
1105                              hammer_get_dtype(rec->entry.base.base.obj_type),
1106                              rec->entry.base.data_len,
1107                              (void *)cursor.data);
1108                 if (r)
1109                         break;
1110                 ++saveoff;
1111                 if (cookies)
1112                         cookies[cookie_index] = base->key;
1113                 ++cookie_index;
1114                 if (cookie_index == ncookies)
1115                         break;
1116                 error = hammer_ip_next(&cursor);
1117         }
1118         hammer_done_cursor(&cursor);
1119
1120 done:
1121         hammer_done_transaction(&trans);
1122
1123         if (ap->a_eofflag)
1124                 *ap->a_eofflag = (error == ENOENT);
1125         uio->uio_offset = saveoff;
1126         if (error && cookie_index == 0) {
1127                 if (error == ENOENT)
1128                         error = 0;
1129                 if (cookies) {
1130                         kfree(cookies, M_TEMP);
1131                         *ap->a_ncookies = 0;
1132                         *ap->a_cookies = NULL;
1133                 }
1134         } else {
1135                 if (error == ENOENT)
1136                         error = 0;
1137                 if (cookies) {
1138                         *ap->a_ncookies = cookie_index;
1139                         *ap->a_cookies = cookies;
1140                 }
1141         }
1142         return(error);
1143 }
1144
1145 /*
1146  * hammer_vop_readlink { vp, uio, cred }
1147  */
1148 static
1149 int
1150 hammer_vop_readlink(struct vop_readlink_args *ap)
1151 {
1152         struct hammer_transaction trans;
1153         struct hammer_cursor cursor;
1154         struct hammer_inode *ip;
1155         int error;
1156
1157         ip = VTOI(ap->a_vp);
1158
1159         hammer_simple_transaction(&trans, ip->hmp);
1160
1161         hammer_init_cursor(&trans, &cursor, &ip->cache[0]);
1162
1163         /*
1164          * Key range (begin and end inclusive) to scan.  Directory keys
1165          * directly translate to a 64 bit 'seek' position.
1166          */
1167         cursor.key_beg.obj_id = ip->obj_id;
1168         cursor.key_beg.create_tid = 0;
1169         cursor.key_beg.delete_tid = 0;
1170         cursor.key_beg.rec_type = HAMMER_RECTYPE_FIX;
1171         cursor.key_beg.obj_type = 0;
1172         cursor.key_beg.key = HAMMER_FIXKEY_SYMLINK;
1173         cursor.asof = ip->obj_asof;
1174         cursor.flags |= HAMMER_CURSOR_ASOF;
1175
1176         error = hammer_ip_lookup(&cursor, ip);
1177         if (error == 0) {
1178                 error = hammer_ip_resolve_data(&cursor);
1179                 if (error == 0) {
1180                         error = uiomove((char *)cursor.data,
1181                                         cursor.record->base.data_len,
1182                                         ap->a_uio);
1183                 }
1184         }
1185         hammer_done_cursor(&cursor);
1186         hammer_done_transaction(&trans);
1187         return(error);
1188 }
1189
1190 /*
1191  * hammer_vop_nremove { nch, dvp, cred }
1192  */
1193 static
1194 int
1195 hammer_vop_nremove(struct vop_nremove_args *ap)
1196 {
1197         struct hammer_transaction trans;
1198         int error;
1199
1200         hammer_start_transaction(&trans, VTOI(ap->a_dvp)->hmp);
1201         error = hammer_dounlink(&trans, ap->a_nch, ap->a_dvp, ap->a_cred, 0);
1202         hammer_done_transaction(&trans);
1203
1204         return (error);
1205 }
1206
1207 /*
1208  * hammer_vop_nrename { fnch, tnch, fdvp, tdvp, cred }
1209  */
1210 static
1211 int
1212 hammer_vop_nrename(struct vop_nrename_args *ap)
1213 {
1214         struct hammer_transaction trans;
1215         struct namecache *fncp;
1216         struct namecache *tncp;
1217         struct hammer_inode *fdip;
1218         struct hammer_inode *tdip;
1219         struct hammer_inode *ip;
1220         struct hammer_cursor cursor;
1221         union hammer_record_ondisk *rec;
1222         int64_t namekey;
1223         int error;
1224
1225         fdip = VTOI(ap->a_fdvp);
1226         tdip = VTOI(ap->a_tdvp);
1227         fncp = ap->a_fnch->ncp;
1228         tncp = ap->a_tnch->ncp;
1229         ip = VTOI(fncp->nc_vp);
1230         KKASSERT(ip != NULL);
1231
1232         if (fdip->flags & HAMMER_INODE_RO)
1233                 return (EROFS);
1234         if (tdip->flags & HAMMER_INODE_RO)
1235                 return (EROFS);
1236         if (ip->flags & HAMMER_INODE_RO)
1237                 return (EROFS);
1238
1239         hammer_start_transaction(&trans, fdip->hmp);
1240
1241         hammer_lock_sh(&ip->lock);
1242         if (fdip->obj_id < tdip->obj_id) {
1243                 hammer_lock_sh(&fdip->lock);
1244                 hammer_lock_sh(&tdip->lock);
1245         } else {
1246                 hammer_lock_sh(&tdip->lock);
1247                 hammer_lock_sh(&fdip->lock);
1248         }
1249
1250         /*
1251          * Remove tncp from the target directory and then link ip as
1252          * tncp. XXX pass trans to dounlink
1253          *
1254          * Force the inode sync-time to match the transaction so it is
1255          * in-sync with the creation of the target directory entry.
1256          */
1257         error = hammer_dounlink(&trans, ap->a_tnch, ap->a_tdvp, ap->a_cred, 0);
1258         if (error == 0 || error == ENOENT) {
1259                 error = hammer_ip_add_directory(&trans, tdip, tncp, ip);
1260                 if (error == 0) {
1261                         ip->ino_data.parent_obj_id = tdip->obj_id;
1262                         hammer_modify_inode(&trans, ip, HAMMER_INODE_DDIRTY);
1263                 }
1264         }
1265         if (error)
1266                 goto failed; /* XXX */
1267
1268         /*
1269          * Locate the record in the originating directory and remove it.
1270          *
1271          * Calculate the namekey and setup the key range for the scan.  This
1272          * works kinda like a chained hash table where the lower 32 bits
1273          * of the namekey synthesize the chain.
1274          *
1275          * The key range is inclusive of both key_beg and key_end.
1276          */
1277         namekey = hammer_directory_namekey(fncp->nc_name, fncp->nc_nlen);
1278 retry:
1279         hammer_init_cursor(&trans, &cursor, &fdip->cache[0]);
1280         cursor.key_beg.obj_id = fdip->obj_id;
1281         cursor.key_beg.key = namekey;
1282         cursor.key_beg.create_tid = 0;
1283         cursor.key_beg.delete_tid = 0;
1284         cursor.key_beg.rec_type = HAMMER_RECTYPE_DIRENTRY;
1285         cursor.key_beg.obj_type = 0;
1286
1287         cursor.key_end = cursor.key_beg;
1288         cursor.key_end.key |= 0xFFFFFFFFULL;
1289         cursor.asof = fdip->obj_asof;
1290         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE | HAMMER_CURSOR_ASOF;
1291
1292         /*
1293          * Scan all matching records (the chain), locate the one matching
1294          * the requested path component.
1295          *
1296          * The hammer_ip_*() functions merge in-memory records with on-disk
1297          * records for the purposes of the search.
1298          */
1299         error = hammer_ip_first(&cursor, fdip);
1300         while (error == 0) {
1301                 if (hammer_ip_resolve_data(&cursor) != 0)
1302                         break;
1303                 rec = cursor.record;
1304                 if (fncp->nc_nlen == rec->entry.base.data_len &&
1305                     bcmp(fncp->nc_name, cursor.data, fncp->nc_nlen) == 0) {
1306                         break;
1307                 }
1308                 error = hammer_ip_next(&cursor);
1309         }
1310
1311         /*
1312          * If all is ok we have to get the inode so we can adjust nlinks.
1313          *
1314          * WARNING: hammer_ip_del_directory() may have to terminate the
1315          * cursor to avoid a recursion.  It's ok to call hammer_done_cursor()
1316          * twice.
1317          */
1318         if (error == 0)
1319                 error = hammer_ip_del_directory(&trans, &cursor, fdip, ip);
1320
1321         /*
1322          * XXX A deadlock here will break rename's atomicy for the purposes
1323          * of crash recovery.
1324          */
1325         if (error == EDEADLK) {
1326                 hammer_unlock(&ip->lock);
1327                 hammer_unlock(&fdip->lock);
1328                 hammer_unlock(&tdip->lock);
1329                 hammer_done_cursor(&cursor);
1330                 hammer_lock_sh(&ip->lock);
1331                 if (fdip->obj_id < tdip->obj_id) {
1332                         hammer_lock_sh(&fdip->lock);
1333                         hammer_lock_sh(&tdip->lock);
1334                 } else {
1335                         hammer_lock_sh(&tdip->lock);
1336                         hammer_lock_sh(&fdip->lock);
1337                 }
1338                 goto retry;
1339         }
1340
1341         /*
1342          * Cleanup and tell the kernel that the rename succeeded.
1343          */
1344         hammer_done_cursor(&cursor);
1345         if (error == 0)
1346                 cache_rename(ap->a_fnch, ap->a_tnch);
1347
1348 failed:
1349         hammer_unlock(&ip->lock);
1350         hammer_unlock(&fdip->lock);
1351         hammer_unlock(&tdip->lock);
1352         hammer_done_transaction(&trans);
1353         return (error);
1354 }
1355
1356 /*
1357  * hammer_vop_nrmdir { nch, dvp, cred }
1358  */
1359 static
1360 int
1361 hammer_vop_nrmdir(struct vop_nrmdir_args *ap)
1362 {
1363         struct hammer_transaction trans;
1364         int error;
1365
1366         hammer_start_transaction(&trans, VTOI(ap->a_dvp)->hmp);
1367         error = hammer_dounlink(&trans, ap->a_nch, ap->a_dvp, ap->a_cred, 0);
1368         hammer_done_transaction(&trans);
1369
1370         return (error);
1371 }
1372
1373 /*
1374  * hammer_vop_setattr { vp, vap, cred }
1375  */
1376 static
1377 int
1378 hammer_vop_setattr(struct vop_setattr_args *ap)
1379 {
1380         struct hammer_transaction trans;
1381         struct vattr *vap;
1382         struct hammer_inode *ip;
1383         int modflags;
1384         int error;
1385         int truncating;
1386         off_t aligned_size;
1387         u_int32_t flags;
1388         uuid_t uuid;
1389
1390         vap = ap->a_vap;
1391         ip = ap->a_vp->v_data;
1392         modflags = 0;
1393
1394         if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
1395                 return(EROFS);
1396         if (ip->flags & HAMMER_INODE_RO)
1397                 return (EROFS);
1398
1399         hammer_start_transaction(&trans, ip->hmp);
1400         hammer_lock_sh(&ip->lock);
1401         error = 0;
1402
1403         if (vap->va_flags != VNOVAL) {
1404                 flags = ip->ino_data.uflags;
1405                 error = vop_helper_setattr_flags(&flags, vap->va_flags,
1406                                          hammer_to_unix_xid(&ip->ino_data.uid),
1407                                          ap->a_cred);
1408                 if (error == 0) {
1409                         if (ip->ino_data.uflags != flags) {
1410                                 ip->ino_data.uflags = flags;
1411                                 modflags |= HAMMER_INODE_DDIRTY;
1412                         }
1413                         if (ip->ino_data.uflags & (IMMUTABLE | APPEND)) {
1414                                 error = 0;
1415                                 goto done;
1416                         }
1417                 }
1418                 goto done;
1419         }
1420         if (ip->ino_data.uflags & (IMMUTABLE | APPEND)) {
1421                 error = EPERM;
1422                 goto done;
1423         }
1424         if (vap->va_uid != (uid_t)VNOVAL) {
1425                 hammer_guid_to_uuid(&uuid, vap->va_uid);
1426                 if (bcmp(&uuid, &ip->ino_data.uid, sizeof(uuid)) != 0) {
1427                         ip->ino_data.uid = uuid;
1428                         modflags |= HAMMER_INODE_DDIRTY;
1429                 }
1430         }
1431         if (vap->va_gid != (uid_t)VNOVAL) {
1432                 hammer_guid_to_uuid(&uuid, vap->va_gid);
1433                 if (bcmp(&uuid, &ip->ino_data.gid, sizeof(uuid)) != 0) {
1434                         ip->ino_data.gid = uuid;
1435                         modflags |= HAMMER_INODE_DDIRTY;
1436                 }
1437         }
1438         while (vap->va_size != VNOVAL && ip->ino_rec.ino_size != vap->va_size) {
1439                 switch(ap->a_vp->v_type) {
1440                 case VREG:
1441                         if (vap->va_size == ip->ino_rec.ino_size)
1442                                 break;
1443                         /*
1444                          * XXX break atomicy, we can deadlock the backend
1445                          * if we do not release the lock.  Probably not a
1446                          * big deal here.
1447                          */
1448                         hammer_unlock(&ip->lock);
1449                         if (vap->va_size < ip->ino_rec.ino_size) {
1450                                 vtruncbuf(ap->a_vp, vap->va_size,
1451                                           HAMMER_BUFSIZE);
1452                                 truncating = 1;
1453                         } else {
1454                                 vnode_pager_setsize(ap->a_vp, vap->va_size);
1455                                 truncating = 0;
1456                         }
1457                         hammer_lock_sh(&ip->lock);
1458                         ip->ino_rec.ino_size = vap->va_size;
1459                         modflags |= HAMMER_INODE_RDIRTY;
1460                         aligned_size = (vap->va_size + HAMMER_BUFMASK) &
1461                                        ~HAMMER_BUFMASK64;
1462
1463                         /*
1464                          * on-media truncation is cached in the inode until
1465                          * the inode is synchronized.
1466                          */
1467                         if (truncating) {
1468                                 if ((ip->flags & HAMMER_INODE_TRUNCATED) == 0) {
1469                                         ip->flags |= HAMMER_INODE_TRUNCATED;
1470                                         ip->trunc_off = vap->va_size;
1471                                 } else if (ip->trunc_off > vap->va_size) {
1472                                         ip->trunc_off = vap->va_size;
1473                                 }
1474                         }
1475
1476                         /*
1477                          * If truncating we have to clean out a portion of
1478                          * the last block on-disk.  We do this in the
1479                          * front-end buffer cache.
1480                          */
1481                         if (truncating && vap->va_size < aligned_size) {
1482                                 struct buf *bp;
1483                                 int offset;
1484
1485                                 offset = vap->va_size & HAMMER_BUFMASK;
1486                                 error = bread(ap->a_vp,
1487                                               aligned_size - HAMMER_BUFSIZE,
1488                                               HAMMER_BUFSIZE, &bp);
1489                                 if (error == 0) {
1490                                         bzero(bp->b_data + offset,
1491                                               HAMMER_BUFSIZE - offset);
1492                                         bdwrite(bp);
1493                                 } else {
1494                                         brelse(bp);
1495                                 }
1496                         }
1497                         break;
1498                 case VDATABASE:
1499                         if ((ip->flags & HAMMER_INODE_TRUNCATED) == 0) {
1500                                 ip->flags |= HAMMER_INODE_TRUNCATED;
1501                                 ip->trunc_off = vap->va_size;
1502                         } else if (ip->trunc_off > vap->va_size) {
1503                                 ip->trunc_off = vap->va_size;
1504                         }
1505                         ip->ino_rec.ino_size = vap->va_size;
1506                         modflags |= HAMMER_INODE_RDIRTY;
1507                         break;
1508                 default:
1509                         error = EINVAL;
1510                         goto done;
1511                 }
1512                 break;
1513         }
1514         if (vap->va_atime.tv_sec != VNOVAL) {
1515                 ip->ino_rec.ino_atime =
1516                         hammer_timespec_to_transid(&vap->va_atime);
1517                 modflags |= HAMMER_INODE_ITIMES;
1518         }
1519         if (vap->va_mtime.tv_sec != VNOVAL) {
1520                 ip->ino_rec.ino_mtime =
1521                         hammer_timespec_to_transid(&vap->va_mtime);
1522                 modflags |= HAMMER_INODE_ITIMES;
1523         }
1524         if (vap->va_mode != (mode_t)VNOVAL) {
1525                 if (ip->ino_data.mode != vap->va_mode) {
1526                         ip->ino_data.mode = vap->va_mode;
1527                         modflags |= HAMMER_INODE_DDIRTY;
1528                 }
1529         }
1530 done:
1531         if (error == 0)
1532                 hammer_modify_inode(&trans, ip, modflags);
1533         hammer_unlock(&ip->lock);
1534         hammer_done_transaction(&trans);
1535         return (error);
1536 }
1537
1538 /*
1539  * hammer_vop_nsymlink { nch, dvp, vpp, cred, vap, target }
1540  */
1541 static
1542 int
1543 hammer_vop_nsymlink(struct vop_nsymlink_args *ap)
1544 {
1545         struct hammer_transaction trans;
1546         struct hammer_inode *dip;
1547         struct hammer_inode *nip;
1548         struct nchandle *nch;
1549         hammer_record_t record;
1550         int error;
1551         int bytes;
1552
1553         ap->a_vap->va_type = VLNK;
1554
1555         nch = ap->a_nch;
1556         dip = VTOI(ap->a_dvp);
1557
1558         if (dip->flags & HAMMER_INODE_RO)
1559                 return (EROFS);
1560
1561         /*
1562          * Create a transaction to cover the operations we perform.
1563          */
1564         hammer_start_transaction(&trans, dip->hmp);
1565
1566         /*
1567          * Create a new filesystem object of the requested type.  The
1568          * returned inode will be referenced but not locked.
1569          */
1570
1571         error = hammer_create_inode(&trans, ap->a_vap, ap->a_cred, dip, &nip);
1572         if (error) {
1573                 hammer_done_transaction(&trans);
1574                 *ap->a_vpp = NULL;
1575                 return (error);
1576         }
1577
1578         /*
1579          * Add the new filesystem object to the directory.  This will also
1580          * bump the inode's link count.
1581          */
1582         hammer_lock_sh(&nip->lock);
1583         hammer_lock_sh(&dip->lock);
1584
1585         /*
1586          * Add a record representing the symlink.  symlink stores the link
1587          * as pure data, not a string, and is no \0 terminated.
1588          */
1589         if (error == 0) {
1590                 record = hammer_alloc_mem_record(nip);
1591                 bytes = strlen(ap->a_target);
1592
1593                 record->rec.base.base.key = HAMMER_FIXKEY_SYMLINK;
1594                 record->rec.base.base.rec_type = HAMMER_RECTYPE_FIX;
1595                 record->rec.base.data_len = bytes;
1596                 record->data = (void *)ap->a_target;
1597                 /* will be reallocated by routine below */
1598                 error = hammer_ip_add_record(&trans, record);
1599
1600                 /*
1601                  * Set the file size to the length of the link.
1602                  */
1603                 if (error == 0) {
1604                         nip->ino_rec.ino_size = bytes;
1605                         hammer_modify_inode(&trans, nip, HAMMER_INODE_RDIRTY);
1606                 }
1607         }
1608         if (error == 0)
1609                 error = hammer_ip_add_directory(&trans, dip, nch->ncp, nip);
1610         hammer_unlock(&dip->lock);
1611         hammer_unlock(&nip->lock);
1612
1613         /*
1614          * Finish up.
1615          */
1616         if (error) {
1617                 hammer_rel_inode(nip, 0);
1618                 *ap->a_vpp = NULL;
1619         } else {
1620                 error = hammer_get_vnode(nip, LK_EXCLUSIVE, ap->a_vpp);
1621                 hammer_rel_inode(nip, 0);
1622                 if (error == 0) {
1623                         cache_setunresolved(ap->a_nch);
1624                         cache_setvp(ap->a_nch, *ap->a_vpp);
1625                 }
1626         }
1627         hammer_done_transaction(&trans);
1628         return (error);
1629 }
1630
1631 /*
1632  * hammer_vop_nwhiteout { nch, dvp, cred, flags }
1633  */
1634 static
1635 int
1636 hammer_vop_nwhiteout(struct vop_nwhiteout_args *ap)
1637 {
1638         struct hammer_transaction trans;
1639         int error;
1640
1641         hammer_start_transaction(&trans, VTOI(ap->a_dvp)->hmp);
1642         error = hammer_dounlink(&trans, ap->a_nch, ap->a_dvp,
1643                                 ap->a_cred, ap->a_flags);
1644         hammer_done_transaction(&trans);
1645
1646         return (error);
1647 }
1648
1649 /*
1650  * hammer_vop_ioctl { vp, command, data, fflag, cred }
1651  */
1652 static
1653 int
1654 hammer_vop_ioctl(struct vop_ioctl_args *ap)
1655 {
1656         struct hammer_inode *ip = ap->a_vp->v_data;
1657
1658         return(hammer_ioctl(ip, ap->a_command, ap->a_data,
1659                             ap->a_fflag, ap->a_cred));
1660 }
1661
1662 static
1663 int
1664 hammer_vop_mountctl(struct vop_mountctl_args *ap)
1665 {
1666         struct mount *mp;
1667         int error;
1668
1669         mp = ap->a_head.a_ops->head.vv_mount;
1670
1671         switch(ap->a_op) {
1672         case MOUNTCTL_SET_EXPORT:
1673                 if (ap->a_ctllen != sizeof(struct export_args))
1674                         error = EINVAL;
1675                 error = hammer_vfs_export(mp, ap->a_op,
1676                                       (const struct export_args *)ap->a_ctl);
1677                 break;
1678         default:
1679                 error = journal_mountctl(ap);
1680                 break;
1681         }
1682         return(error);
1683 }
1684
1685 /*
1686  * hammer_vop_strategy { vp, bio }
1687  *
1688  * Strategy call, used for regular file read & write only.  Note that the
1689  * bp may represent a cluster.
1690  *
1691  * To simplify operation and allow better optimizations in the future,
1692  * this code does not make any assumptions with regards to buffer alignment
1693  * or size.
1694  */
1695 static
1696 int
1697 hammer_vop_strategy(struct vop_strategy_args *ap)
1698 {
1699         struct buf *bp;
1700         int error;
1701
1702         bp = ap->a_bio->bio_buf;
1703
1704         switch(bp->b_cmd) {
1705         case BUF_CMD_READ:
1706                 error = hammer_vop_strategy_read(ap);
1707                 break;
1708         case BUF_CMD_WRITE:
1709                 error = hammer_vop_strategy_write(ap);
1710                 break;
1711         default:
1712                 bp->b_error = error = EINVAL;
1713                 bp->b_flags |= B_ERROR;
1714                 biodone(ap->a_bio);
1715                 break;
1716         }
1717         return (error);
1718 }
1719
1720 /*
1721  * Read from a regular file.  Iterate the related records and fill in the
1722  * BIO/BUF.  Gaps are zero-filled.
1723  *
1724  * The support code in hammer_object.c should be used to deal with mixed
1725  * in-memory and on-disk records.
1726  *
1727  * XXX atime update
1728  */
1729 static
1730 int
1731 hammer_vop_strategy_read(struct vop_strategy_args *ap)
1732 {
1733         struct hammer_transaction trans;
1734         struct hammer_inode *ip;
1735         struct hammer_cursor cursor;
1736         hammer_record_ondisk_t rec;
1737         hammer_base_elm_t base;
1738         struct bio *bio;
1739         struct buf *bp;
1740         int64_t rec_offset;
1741         int64_t ran_end;
1742         int64_t tmp64;
1743         int error;
1744         int boff;
1745         int roff;
1746         int n;
1747
1748         bio = ap->a_bio;
1749         bp = bio->bio_buf;
1750         ip = ap->a_vp->v_data;
1751
1752         hammer_simple_transaction(&trans, ip->hmp);
1753         hammer_init_cursor(&trans, &cursor, &ip->cache[0]);
1754
1755         /*
1756          * Key range (begin and end inclusive) to scan.  Note that the key's
1757          * stored in the actual records represent BASE+LEN, not BASE.  The
1758          * first record containing bio_offset will have a key > bio_offset.
1759          */
1760         cursor.key_beg.obj_id = ip->obj_id;
1761         cursor.key_beg.create_tid = 0;
1762         cursor.key_beg.delete_tid = 0;
1763         cursor.key_beg.obj_type = 0;
1764         cursor.key_beg.key = bio->bio_offset + 1;
1765         cursor.asof = ip->obj_asof;
1766         cursor.flags |= HAMMER_CURSOR_ASOF | HAMMER_CURSOR_DATAEXTOK;
1767
1768         cursor.key_end = cursor.key_beg;
1769         KKASSERT(ip->ino_rec.base.base.obj_type == HAMMER_OBJTYPE_REGFILE);
1770 #if 0
1771         if (ip->ino_rec.base.base.obj_type == HAMMER_OBJTYPE_DBFILE) {
1772                 cursor.key_beg.rec_type = HAMMER_RECTYPE_DB;
1773                 cursor.key_end.rec_type = HAMMER_RECTYPE_DB;
1774                 cursor.key_end.key = 0x7FFFFFFFFFFFFFFFLL;
1775         } else
1776 #endif
1777         {
1778                 ran_end = bio->bio_offset + bp->b_bufsize;
1779                 cursor.key_beg.rec_type = HAMMER_RECTYPE_DATA;
1780                 cursor.key_end.rec_type = HAMMER_RECTYPE_DATA;
1781                 tmp64 = ran_end + MAXPHYS + 1;  /* work-around GCC-4 bug */
1782                 if (tmp64 < ran_end)
1783                         cursor.key_end.key = 0x7FFFFFFFFFFFFFFFLL;
1784                 else
1785                         cursor.key_end.key = ran_end + MAXPHYS + 1;
1786         }
1787         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE;
1788
1789         error = hammer_ip_first(&cursor, ip);
1790         boff = 0;
1791
1792         while (error == 0) {
1793                 error = hammer_ip_resolve_data(&cursor);
1794                 if (error)
1795                         break;
1796                 rec = cursor.record;
1797                 base = &rec->base.base;
1798
1799                 rec_offset = base->key - rec->data.base.data_len;
1800
1801                 /*
1802                  * Calculate the gap, if any, and zero-fill it.
1803                  */
1804                 n = (int)(rec_offset - (bio->bio_offset + boff));
1805                 if (n > 0) {
1806                         if (n > bp->b_bufsize - boff)
1807                                 n = bp->b_bufsize - boff;
1808                         bzero((char *)bp->b_data + boff, n);
1809                         boff += n;
1810                         n = 0;
1811                 }
1812
1813                 /*
1814                  * Calculate the data offset in the record and the number
1815                  * of bytes we can copy.
1816                  *
1817                  * Note there is a degenerate case here where boff may
1818                  * already be at bp->b_bufsize.
1819                  */
1820                 roff = -n;
1821                 rec_offset += roff;
1822                 n = rec->data.base.data_len - roff;
1823                 KKASSERT(n > 0);
1824                 if (n > bp->b_bufsize - boff)
1825                         n = bp->b_bufsize - boff;
1826
1827                 /*
1828                  * If we cached a truncation point on our front-end the
1829                  * on-disk version may still have physical records beyond
1830                  * that point.  Truncate visibility.
1831                  */
1832                 if (ip->trunc_off <= rec_offset)
1833                         n = 0;
1834                 else if (ip->trunc_off < rec_offset + n)
1835                         n = (int)(ip->trunc_off - rec_offset);
1836
1837                 /*
1838                  * Copy
1839                  */
1840                 if (n) {
1841                         bcopy((char *)cursor.data + roff,
1842                               (char *)bp->b_data + boff, n);
1843                         boff += n;
1844                 }
1845                 if (boff == bp->b_bufsize)
1846                         break;
1847                 error = hammer_ip_next(&cursor);
1848         }
1849         hammer_done_cursor(&cursor);
1850         hammer_done_transaction(&trans);
1851
1852         /*
1853          * There may have been a gap after the last record
1854          */
1855         if (error == ENOENT)
1856                 error = 0;
1857         if (error == 0 && boff != bp->b_bufsize) {
1858                 KKASSERT(boff < bp->b_bufsize);
1859                 bzero((char *)bp->b_data + boff, bp->b_bufsize - boff);
1860                 /* boff = bp->b_bufsize; */
1861         }
1862         bp->b_resid = 0;
1863         bp->b_error = error;
1864         if (error)
1865                 bp->b_flags |= B_ERROR;
1866         biodone(ap->a_bio);
1867         return(error);
1868 }
1869
1870 /*
1871  * Write to a regular file.   Because this is a strategy call the OS is
1872  * trying to actually sync data to the media.   HAMMER can only flush
1873  * the entire inode (so the TID remains properly synchronized).
1874  *
1875  * Basically all we do here is place the bio on the inode's flush queue
1876  * and activate the flusher.
1877  */
1878 static
1879 int
1880 hammer_vop_strategy_write(struct vop_strategy_args *ap)
1881 {
1882         hammer_inode_t ip;
1883         struct bio *bio;
1884         struct buf *bp;
1885
1886         bio = ap->a_bio;
1887         bp = bio->bio_buf;
1888         ip = ap->a_vp->v_data;
1889
1890         if (ip->flags & HAMMER_INODE_RO) {
1891                 bp->b_error = EROFS;
1892                 bp->b_flags |= B_ERROR;
1893                 biodone(ap->a_bio);
1894                 return(EROFS);
1895         }
1896
1897         /*
1898          * If the inode is being flushed we cannot re-queue buffers
1899          * it may have already flushed, or it could result in duplicate
1900          * records in the database.
1901          */
1902         BUF_KERNPROC(bp);
1903         if (ip->flags & HAMMER_INODE_WRITE_ALT)
1904                 TAILQ_INSERT_TAIL(&ip->bio_alt_list, bio, bio_act);
1905         else
1906                 TAILQ_INSERT_TAIL(&ip->bio_list, bio, bio_act);
1907         ++hammer_bio_count;
1908         hammer_modify_inode(NULL, ip, HAMMER_INODE_BUFS);
1909         hammer_flush_inode(ip, HAMMER_FLUSH_FORCE|HAMMER_FLUSH_SIGNAL);
1910         return(0);
1911 }
1912
1913 /*
1914  * Backend code which actually performs the write to the media.  This
1915  * routine is typically called from the flusher.  The bio will be disposed
1916  * of (biodone'd) by this routine.
1917  *
1918  * Iterate the related records and mark for deletion.  If existing edge
1919  * records (left and right side) overlap our write they have to be marked
1920  * deleted and new records created, usually referencing a portion of the
1921  * original data.  Then add a record to represent the buffer.
1922  */
1923 int
1924 hammer_dowrite(hammer_transaction_t trans, hammer_inode_t ip, struct bio *bio)
1925 {
1926         struct buf *bp = bio->bio_buf;
1927         int error;
1928
1929         KKASSERT(ip->flush_state == HAMMER_FST_FLUSH);
1930
1931         /*
1932          * If the inode is going or gone, just throw away any frontend
1933          * buffers.
1934          */
1935         if (ip->flags & HAMMER_INODE_DELETED) {
1936                 bp->b_resid = 0;
1937                 biodone(bio);
1938         }
1939
1940         /*
1941          * Delete any records overlapping our range.  This function will
1942          * (eventually) properly truncate partial overlaps.
1943          */
1944         if (ip->sync_ino_rec.base.base.obj_type == HAMMER_OBJTYPE_DBFILE) {
1945                 error = hammer_ip_delete_range(trans, ip, bio->bio_offset,
1946                                                bio->bio_offset);
1947         } else {
1948                 error = hammer_ip_delete_range(trans, ip, bio->bio_offset,
1949                                                bio->bio_offset +
1950                                                 bp->b_bufsize - 1);
1951         }
1952
1953         /*
1954          * Add a single record to cover the write.  We can write a record
1955          * with only the actual file data - for example, a small 200 byte
1956          * file does not have to write out a 16K record.
1957          *
1958          * While the data size does not have to be aligned, we still do it
1959          * to reduce fragmentation in a future allocation model.
1960          */
1961         if (error == 0) {
1962                 int limit_size;
1963
1964                 if (ip->sync_ino_rec.ino_size - bio->bio_offset >
1965                     bp->b_bufsize) {
1966                             limit_size = bp->b_bufsize;
1967                 } else {
1968                         limit_size = (int)(ip->sync_ino_rec.ino_size -
1969                                            bio->bio_offset);
1970                         KKASSERT(limit_size >= 0);
1971                         limit_size = (limit_size + 63) & ~63;
1972                 }
1973
1974                 error = hammer_ip_sync_data(trans, ip, bio->bio_offset,
1975                                             bp->b_data, limit_size);
1976
1977         }
1978         if (error)
1979                 Debugger("hammer_dowrite: error");
1980
1981         if (error) {
1982                 bp->b_resid = bp->b_bufsize;
1983                 bp->b_error = error;
1984                 bp->b_flags |= B_ERROR;
1985         } else {
1986                 bp->b_resid = 0;
1987         }
1988         biodone(bio);
1989         --hammer_bio_count;
1990         return(error);
1991 }
1992
1993 /*
1994  * dounlink - disconnect a directory entry
1995  *
1996  * XXX whiteout support not really in yet
1997  */
1998 static int
1999 hammer_dounlink(hammer_transaction_t trans, struct nchandle *nch,
2000                 struct vnode *dvp, struct ucred *cred, int flags)
2001 {
2002         struct namecache *ncp;
2003         hammer_inode_t dip;
2004         hammer_inode_t ip;
2005         hammer_record_ondisk_t rec;
2006         struct hammer_cursor cursor;
2007         int64_t namekey;
2008         int error;
2009
2010         /*
2011          * Calculate the namekey and setup the key range for the scan.  This
2012          * works kinda like a chained hash table where the lower 32 bits
2013          * of the namekey synthesize the chain.
2014          *
2015          * The key range is inclusive of both key_beg and key_end.
2016          */
2017         dip = VTOI(dvp);
2018         ncp = nch->ncp;
2019
2020         if (dip->flags & HAMMER_INODE_RO)
2021                 return (EROFS);
2022
2023         namekey = hammer_directory_namekey(ncp->nc_name, ncp->nc_nlen);
2024 retry:
2025         hammer_init_cursor(trans, &cursor, &dip->cache[0]);
2026         cursor.key_beg.obj_id = dip->obj_id;
2027         cursor.key_beg.key = namekey;
2028         cursor.key_beg.create_tid = 0;
2029         cursor.key_beg.delete_tid = 0;
2030         cursor.key_beg.rec_type = HAMMER_RECTYPE_DIRENTRY;
2031         cursor.key_beg.obj_type = 0;
2032
2033         cursor.key_end = cursor.key_beg;
2034         cursor.key_end.key |= 0xFFFFFFFFULL;
2035         cursor.asof = dip->obj_asof;
2036         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE | HAMMER_CURSOR_ASOF;
2037
2038         /*
2039          * Scan all matching records (the chain), locate the one matching
2040          * the requested path component.  info->last_error contains the
2041          * error code on search termination and could be 0, ENOENT, or
2042          * something else.
2043          *
2044          * The hammer_ip_*() functions merge in-memory records with on-disk
2045          * records for the purposes of the search.
2046          */
2047         error = hammer_ip_first(&cursor, dip);
2048         while (error == 0) {
2049                 error = hammer_ip_resolve_data(&cursor);
2050                 if (error)
2051                         break;
2052                 rec = cursor.record;
2053                 if (ncp->nc_nlen == rec->entry.base.data_len &&
2054                     bcmp(ncp->nc_name, cursor.data, ncp->nc_nlen) == 0) {
2055                         break;
2056                 }
2057                 error = hammer_ip_next(&cursor);
2058         }
2059
2060         /*
2061          * If all is ok we have to get the inode so we can adjust nlinks.
2062          *
2063          * If the target is a directory, it must be empty.
2064          */
2065         if (error == 0) {
2066                 ip = hammer_get_inode(trans, &dip->cache[1],
2067                                       rec->entry.obj_id,
2068                                       dip->hmp->asof, 0, &error);
2069                 if (error == ENOENT) {
2070                         kprintf("obj_id %016llx\n", rec->entry.obj_id);
2071                         Debugger("ENOENT unlinking object that should exist");
2072                 }
2073
2074                 /*
2075                  * If we are trying to remove a directory the directory must
2076                  * be empty.
2077                  *
2078                  * WARNING: hammer_ip_check_directory_empty() may have to
2079                  * terminate the cursor to avoid a deadlock.  It is ok to
2080                  * call hammer_done_cursor() twice.
2081                  */
2082                 if (error == 0 && ip->ino_rec.base.base.obj_type ==
2083                                   HAMMER_OBJTYPE_DIRECTORY) {
2084                         error = hammer_ip_check_directory_empty(trans, &cursor,
2085                                                                 ip);
2086                 }
2087
2088                 /*
2089                  * Delete the directory entry.
2090                  *
2091                  * WARNING: hammer_ip_del_directory() may have to terminate
2092                  * the cursor to avoid a deadlock.  It is ok to call
2093                  * hammer_done_cursor() twice.
2094                  */
2095                 if (error == 0) {
2096                         hammer_lock_sh(&ip->lock);
2097                         hammer_lock_sh(&dip->lock);
2098                         error = hammer_ip_del_directory(trans, &cursor,
2099                                                         dip, ip);
2100                         hammer_unlock(&dip->lock);
2101                         hammer_unlock(&ip->lock);
2102                 }
2103                 if (error == 0) {
2104                         cache_setunresolved(nch);
2105                         cache_setvp(nch, NULL);
2106                         /* XXX locking */
2107                         if (ip->vp)
2108                                 cache_inval_vp(ip->vp, CINV_DESTROY);
2109                 }
2110                 hammer_rel_inode(ip, 0);
2111         }
2112         hammer_done_cursor(&cursor);
2113         if (error == EDEADLK)
2114                 goto retry;
2115
2116         return (error);
2117 }
2118
2119 /************************************************************************
2120  *                          FIFO AND SPECFS OPS                         *
2121  ************************************************************************
2122  *
2123  */
2124
2125 static int
2126 hammer_vop_fifoclose (struct vop_close_args *ap)
2127 {
2128         /* XXX update itimes */
2129         return (VOCALL(&fifo_vnode_vops, &ap->a_head));
2130 }
2131
2132 static int
2133 hammer_vop_fiforead (struct vop_read_args *ap)
2134 {
2135         int error;
2136
2137         error = VOCALL(&fifo_vnode_vops, &ap->a_head);
2138         /* XXX update access time */
2139         return (error);
2140 }
2141
2142 static int
2143 hammer_vop_fifowrite (struct vop_write_args *ap)
2144 {
2145         int error;
2146
2147         error = VOCALL(&fifo_vnode_vops, &ap->a_head);
2148         /* XXX update access time */
2149         return (error);
2150 }
2151
2152 static int
2153 hammer_vop_specclose (struct vop_close_args *ap)
2154 {
2155         /* XXX update itimes */
2156         return (VOCALL(&spec_vnode_vops, &ap->a_head));
2157 }
2158
2159 static int
2160 hammer_vop_specread (struct vop_read_args *ap)
2161 {
2162         /* XXX update access time */
2163         return (VOCALL(&spec_vnode_vops, &ap->a_head));
2164 }
2165
2166 static int
2167 hammer_vop_specwrite (struct vop_write_args *ap)
2168 {
2169         /* XXX update last change time */
2170         return (VOCALL(&spec_vnode_vops, &ap->a_head));
2171 }
2172