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
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/fcntl.h>
  39 #include <sys/namecache.h>
  40 #include <sys/vnode.h>
  41 #include <sys/lockf.h>
  42 #include <sys/event.h>
  43 #include <sys/stat.h>
  44 #include <sys/dirent.h>
  45 #include <sys/file.h>
  46 #include <vm/vm_extern.h>
  47 #include <vm/swap_pager.h>
  48 #include <vfs/fifofs/fifo.h>
  49
  50 #include "hammer.h"
  51
  52 /*
  53  * USERFS VNOPS
  54  */
  55 /*static int hammer_vop_vnoperate(struct vop_generic_args *);*/
  56 static int hammer_vop_fsync(struct vop_fsync_args *);
  57 static int hammer_vop_read(struct vop_read_args *);
  58 static int hammer_vop_write(struct vop_write_args *);
  59 static int hammer_vop_access(struct vop_access_args *);
  60 static int hammer_vop_advlock(struct vop_advlock_args *);
  61 static int hammer_vop_close(struct vop_close_args *);
  62 static int hammer_vop_ncreate(struct vop_ncreate_args *);
  63 static int hammer_vop_getattr(struct vop_getattr_args *);
  64 static int hammer_vop_nresolve(struct vop_nresolve_args *);
  65 static int hammer_vop_nlookupdotdot(struct vop_nlookupdotdot_args *);
  66 static int hammer_vop_nlink(struct vop_nlink_args *);
  67 static int hammer_vop_nmkdir(struct vop_nmkdir_args *);
  68 static int hammer_vop_nmknod(struct vop_nmknod_args *);
  69 static int hammer_vop_open(struct vop_open_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_markatime(struct vop_markatime_args *);
  77 static int hammer_vop_setattr(struct vop_setattr_args *);
  78 static int hammer_vop_strategy(struct vop_strategy_args *);
  79 static int hammer_vop_bmap(struct vop_bmap_args *ap);
  80 static int hammer_vop_nsymlink(struct vop_nsymlink_args *);
  81 static int hammer_vop_nwhiteout(struct vop_nwhiteout_args *);
  82 static int hammer_vop_ioctl(struct vop_ioctl_args *);
  83 static int hammer_vop_mountctl(struct vop_mountctl_args *);
  84 static int hammer_vop_kqfilter (struct vop_kqfilter_args *);
  85
  86 static int hammer_vop_fifoclose (struct vop_close_args *);
  87 static int hammer_vop_fiforead (struct vop_read_args *);
  88 static int hammer_vop_fifowrite (struct vop_write_args *);
  89 static int hammer_vop_fifokqfilter (struct vop_kqfilter_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 =         vop_stdpathconf,
 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_markatime =        hammer_vop_markatime,
 119         .vop_setattr =          hammer_vop_setattr,
 120         .vop_bmap =             hammer_vop_bmap,
 121         .vop_strategy =         hammer_vop_strategy,
 122         .vop_nsymlink =         hammer_vop_nsymlink,
 123         .vop_nwhiteout =        hammer_vop_nwhiteout,
 124         .vop_ioctl =            hammer_vop_ioctl,
 125         .vop_mountctl =         hammer_vop_mountctl,
 126         .vop_kqfilter =         hammer_vop_kqfilter
 127 };
 128
 129 struct vop_ops hammer_spec_vops = {
 130         .vop_default =          vop_defaultop,
 131         .vop_fsync =            hammer_vop_fsync,
 132         .vop_read =             vop_stdnoread,
 133         .vop_write =            vop_stdnowrite,
 134         .vop_access =           hammer_vop_access,
 135         .vop_close =            hammer_vop_close,
 136         .vop_markatime =        hammer_vop_markatime,
 137         .vop_getattr =          hammer_vop_getattr,
 138         .vop_inactive =         hammer_vop_inactive,
 139         .vop_reclaim =          hammer_vop_reclaim,
 140         .vop_setattr =          hammer_vop_setattr
 141 };
 142
 143 struct vop_ops hammer_fifo_vops = {
 144         .vop_default =          fifo_vnoperate,
 145         .vop_fsync =            hammer_vop_fsync,
 146         .vop_read =             hammer_vop_fiforead,
 147         .vop_write =            hammer_vop_fifowrite,
 148         .vop_access =           hammer_vop_access,
 149         .vop_close =            hammer_vop_fifoclose,
 150         .vop_markatime =        hammer_vop_markatime,
 151         .vop_getattr =          hammer_vop_getattr,
 152         .vop_inactive =         hammer_vop_inactive,
 153         .vop_reclaim =          hammer_vop_reclaim,
 154         .vop_setattr =          hammer_vop_setattr,
 155         .vop_kqfilter =         hammer_vop_fifokqfilter
 156 };
 157
 158 static __inline
 159 void
 160 hammer_knote(struct vnode *vp, int flags)
 161 {
 162         if (flags)
 163                 KNOTE(&vp->v_pollinfo.vpi_kqinfo.ki_note, flags);
 164 }
 165
 166 #ifdef DEBUG_TRUNCATE
 167 struct hammer_inode *HammerTruncIp;
 168 #endif
 169
 170 static int hammer_dounlink(hammer_transaction_t trans, struct nchandle *nch,
 171                            struct vnode *dvp, struct ucred *cred,
 172                            int flags, int isdir);
 173 static int hammer_vop_strategy_read(struct vop_strategy_args *ap);
 174 static int hammer_vop_strategy_write(struct vop_strategy_args *ap);
 175
 176 #if 0
 177 static
 178 int
 179 hammer_vop_vnoperate(struct vop_generic_args *)
 180 {
 181         return (VOCALL(&hammer_vnode_vops, ap));
 182 }
 183 #endif
 184
 185 /*
 186  * hammer_vop_fsync { vp, waitfor }
 187  *
 188  * fsync() an inode to disk and wait for it to be completely committed
 189  * such that the information would not be undone if a crash occured after
 190  * return.
 191  *
 192  * NOTE: HAMMER's fsync()'s are going to remain expensive until we implement
 193  *       a REDO log.  A sysctl is provided to relax HAMMER's fsync()
 194  *       operation.
 195  *
 196  *       Ultimately the combination of a REDO log and use of fast storage
 197  *       to front-end cluster caches will make fsync fast, but it aint
 198  *       here yet.  And, in anycase, we need real transactional
 199  *       all-or-nothing features which are not restricted to a single file.
 200  */
 201 static
 202 int
 203 hammer_vop_fsync(struct vop_fsync_args *ap)
 204 {
 205         hammer_inode_t ip = VTOI(ap->a_vp);
 206         hammer_mount_t hmp = ip->hmp;
 207         int waitfor = ap->a_waitfor;
 208         int mode;
 209
 210         lwkt_gettoken(&hmp->fs_token);
 211
 212         /*
 213          * Fsync rule relaxation (default is either full synchronous flush
 214          * or REDO semantics with synchronous flush).
 215          */
 216         if (ap->a_flags & VOP_FSYNC_SYSCALL) {
 217                 switch(hammer_fsync_mode) {
 218                 case 0:
 219 mode0:
 220                         /* no REDO, full synchronous flush */
 221                         goto skip;
 222                 case 1:
 223 mode1:
 224                         /* no REDO, full asynchronous flush */
 225                         if (waitfor == MNT_WAIT)
 226                                 waitfor = MNT_NOWAIT;
 227                         goto skip;
 228                 case 2:
 229                         /* REDO semantics, synchronous flush */
 230                         if (hmp->version < HAMMER_VOL_VERSION_FOUR)
 231                                 goto mode0;
 232                         mode = HAMMER_FLUSH_UNDOS_AUTO;
 233                         break;
 234                 case 3:
 235                         /* REDO semantics, relaxed asynchronous flush */
 236                         if (hmp->version < HAMMER_VOL_VERSION_FOUR)
 237                                 goto mode1;
 238                         mode = HAMMER_FLUSH_UNDOS_RELAXED;
 239                         if (waitfor == MNT_WAIT)
 240                                 waitfor = MNT_NOWAIT;
 241                         break;
 242                 case 4:
 243                         /* ignore the fsync() system call */
 244                         lwkt_reltoken(&hmp->fs_token);
 245                         return(0);
 246                 default:
 247                         /* we have to do something */
 248                         mode = HAMMER_FLUSH_UNDOS_RELAXED;
 249                         if (waitfor == MNT_WAIT)
 250                                 waitfor = MNT_NOWAIT;
 251                         break;
 252                 }
 253
 254                 /*
 255                  * Fast fsync only needs to flush the UNDO/REDO fifo if
 256                  * HAMMER_INODE_REDO is non-zero and the only modifications
 257                  * made to the file are write or write-extends.
 258                  */
 259                 if ((ip->flags & HAMMER_INODE_REDO) &&
 260                     (ip->flags & HAMMER_INODE_MODMASK_NOREDO) == 0
 261                 ) {
 262                         ++hammer_count_fsyncs;
 263                         hammer_flusher_flush_undos(hmp, mode);
 264                         ip->redo_count = 0;
 265                         if (ip->vp && (ip->flags & HAMMER_INODE_MODMASK) == 0)
 266                                 vclrisdirty(ip->vp);
 267                         lwkt_reltoken(&hmp->fs_token);
 268                         return(0);
 269                 }
 270
 271                 /*
 272                  * REDO is enabled by fsync(), the idea being we really only
 273                  * want to lay down REDO records when programs are using
 274                  * fsync() heavily.  The first fsync() on the file starts
 275                  * the gravy train going and later fsync()s keep it hot by
 276                  * resetting the redo_count.
 277                  *
 278                  * We weren't running REDOs before now so we have to fall
 279                  * through and do a full fsync of what we have.
 280                  */
 281                 if (hmp->version >= HAMMER_VOL_VERSION_FOUR &&
 282                     (hmp->flags & HAMMER_MOUNT_REDO_RECOVERY_RUN) == 0) {
 283                         ip->flags |= HAMMER_INODE_REDO;
 284                         ip->redo_count = 0;
 285                 }
 286         }
 287 skip:
 288
 289         /*
 290          * Do a full flush sequence.
 291          *
 292          * Attempt to release the vnode while waiting for the inode to
 293          * finish flushing.  This can really mess up inactive->reclaim
 294          * sequences so only do it if the vnode is active.
 295          *
 296          * WARNING! The VX lock functions must be used.  vn_lock() will
 297          *          fail when this is part of a VOP_RECLAIM sequence.
 298          */
 299         ++hammer_count_fsyncs;
 300         vfsync(ap->a_vp, waitfor, 1, NULL, NULL);
 301         hammer_flush_inode(ip, HAMMER_FLUSH_SIGNAL);
 302         if (waitfor == MNT_WAIT) {
 303                 int dorelock;
 304
 305                 if ((ap->a_vp->v_flag & VRECLAIMED) == 0) {
 306                         vx_unlock(ap->a_vp);
 307                         dorelock = 1;
 308                 } else {
 309                         dorelock = 0;
 310                 }
 311                 hammer_wait_inode(ip);
 312                 if (dorelock)
 313                         vx_lock(ap->a_vp);
 314         }
 315         if (ip->vp && (ip->flags & HAMMER_INODE_MODMASK) == 0)
 316                 vclrisdirty(ip->vp);
 317         lwkt_reltoken(&hmp->fs_token);
 318         return (ip->error);
 319 }
 320
 321 /*
 322  * hammer_vop_read { vp, uio, ioflag, cred }
 323  *
 324  * MPSAFE (for the cache safe does not require fs_token)
 325  */
 326 static
 327 int
 328 hammer_vop_read(struct vop_read_args *ap)
 329 {
 330         struct hammer_transaction trans;
 331         hammer_inode_t ip;
 332         hammer_mount_t hmp;
 333         off_t offset;
 334         struct buf *bp;
 335         struct uio *uio;
 336         int error;
 337         int n;
 338         int seqcount;
 339         int ioseqcount;
 340         int blksize;
 341         int bigread;
 342         int got_trans;
 343         size_t resid;
 344
 345         if (ap->a_vp->v_type != VREG)
 346                 return (EINVAL);
 347         ip = VTOI(ap->a_vp);
 348         hmp = ip->hmp;
 349         error = 0;
 350         got_trans = 0;
 351         uio = ap->a_uio;
 352
 353         /*
 354          * Attempt to shortcut directly to the VM object using lwbufs.
 355          * This is much faster than instantiating buffer cache buffers.
 356          */
 357         resid = uio->uio_resid;
 358         error = vop_helper_read_shortcut(ap);
 359         hammer_stats_file_read += resid - uio->uio_resid;
 360         if (error)
 361                 return (error);
 362         if (uio->uio_resid == 0)
 363                 goto finished;
 364
 365         /*
 366          * Allow the UIO's size to override the sequential heuristic.
 367          */
 368         blksize = hammer_blocksize(uio->uio_offset);
 369         seqcount = (uio->uio_resid + (BKVASIZE - 1)) / BKVASIZE;
 370         ioseqcount = (ap->a_ioflag >> 16);
 371         if (seqcount < ioseqcount)
 372                 seqcount = ioseqcount;
 373
 374         /*
 375          * If reading or writing a huge amount of data we have to break
 376          * atomicy and allow the operation to be interrupted by a signal
 377          * or it can DOS the machine.
 378          */
 379         bigread = (uio->uio_resid > 100 * 1024 * 1024);
 380
 381         /*
 382          * Access the data typically in HAMMER_BUFSIZE blocks via the
 383          * buffer cache, but HAMMER may use a variable block size based
 384          * on the offset.
 385          *
 386          * XXX Temporary hack, delay the start transaction while we remain
 387          *     MPSAFE.  NOTE: ino_data.size cannot change while vnode is
 388          *     locked-shared.
 389          */
 390         while (uio->uio_resid > 0 && uio->uio_offset < ip->ino_data.size) {
 391                 int64_t base_offset;
 392                 int64_t file_limit;
 393
 394                 blksize = hammer_blocksize(uio->uio_offset);
 395                 offset = (int)uio->uio_offset & (blksize - 1);
 396                 base_offset = uio->uio_offset - offset;
 397
 398                 if (bigread && (error = hammer_signal_check(ip->hmp)) != 0)
 399                         break;
 400
 401                 /*
 402                  * MPSAFE
 403                  */
 404                 bp = getblk(ap->a_vp, base_offset, blksize, 0, 0);
 405                 if ((bp->b_flags & (B_INVAL | B_CACHE | B_RAM)) == B_CACHE) {
 406                         bp->b_flags &= ~B_AGE;
 407                         error = 0;
 408                         goto skip;
 409                 }
 410                 if (ap->a_ioflag & IO_NRDELAY) {
 411                         bqrelse(bp);
 412                         return (EWOULDBLOCK);
 413                 }
 414
 415                 /*
 416                  * MPUNSAFE
 417                  */
 418                 if (got_trans == 0) {
 419                         hammer_start_transaction(&trans, ip->hmp);
 420                         got_trans = 1;
 421                 }
 422
 423                 /*
 424                  * NOTE: A valid bp has already been acquired, but was not
 425                  *       B_CACHE.
 426                  */
 427                 if (hammer_cluster_enable) {
 428                         /*
 429                          * Use file_limit to prevent cluster_read() from
 430                          * creating buffers of the wrong block size past
 431                          * the demarc.
 432                          */
 433                         file_limit = ip->ino_data.size;
 434                         if (base_offset < HAMMER_XDEMARC &&
 435                             file_limit > HAMMER_XDEMARC) {
 436                                 file_limit = HAMMER_XDEMARC;
 437                         }
 438                         error = cluster_readx(ap->a_vp,
 439                                              file_limit, base_offset,
 440                                              blksize, uio->uio_resid,
 441                                              seqcount * BKVASIZE, &bp);
 442                 } else {
 443                         error = breadnx(ap->a_vp, base_offset, blksize,
 444                                         NULL, NULL, 0, &bp);
 445                 }
 446                 if (error) {
 447                         brelse(bp);
 448                         break;
 449                 }
 450 skip:
 451                 if ((hammer_debug_io & 0x0001) && (bp->b_flags & B_IODEBUG)) {
 452                         kprintf("doff %016jx read file %016jx@%016jx\n",
 453                                 (intmax_t)bp->b_bio2.bio_offset,
 454                                 (intmax_t)ip->obj_id,
 455                                 (intmax_t)bp->b_loffset);
 456                 }
 457                 bp->b_flags &= ~B_IODEBUG;
 458                 if (blksize == HAMMER_XBUFSIZE)
 459                         bp->b_flags |= B_CLUSTEROK;
 460
 461                 n = blksize - offset;
 462                 if (n > uio->uio_resid)
 463                         n = uio->uio_resid;
 464                 if (n > ip->ino_data.size - uio->uio_offset)
 465                         n = (int)(ip->ino_data.size - uio->uio_offset);
 466
 467                 /*
 468                  * Set B_AGE, data has a lower priority than meta-data.
 469                  *
 470                  * Use a hold/unlock/drop sequence to run the uiomove
 471                  * with the buffer unlocked, avoiding deadlocks against
 472                  * read()s on mmap()'d spaces.
 473                  */
 474                 bp->b_flags |= B_AGE;
 475                 error = uiomovebp(bp, (char *)bp->b_data + offset, n, uio);
 476                 bqrelse(bp);
 477
 478                 if (error)
 479                         break;
 480                 hammer_stats_file_read += n;
 481         }
 482
 483 finished:
 484
 485         /*
 486          * Try to update the atime with just the inode lock for maximum
 487          * concurrency.  If we can't shortcut it we have to get the full
 488          * blown transaction.
 489          */
 490         if (got_trans == 0 && hammer_update_atime_quick(ip) < 0) {
 491                 hammer_start_transaction(&trans, ip->hmp);
 492                 got_trans = 1;
 493         }
 494
 495         if (got_trans) {
 496                 if ((ip->flags & HAMMER_INODE_RO) == 0 &&
 497                     (ip->hmp->mp->mnt_flag & MNT_NOATIME) == 0) {
 498                         lwkt_gettoken(&hmp->fs_token);
 499                         ip->ino_data.atime = trans.time;
 500                         hammer_modify_inode(&trans, ip, HAMMER_INODE_ATIME);
 501                         hammer_done_transaction(&trans);
 502                         lwkt_reltoken(&hmp->fs_token);
 503                 } else {
 504                         hammer_done_transaction(&trans);
 505                 }
 506         }
 507         return (error);
 508 }
 509
 510 /*
 511  * hammer_vop_write { vp, uio, ioflag, cred }
 512  */
 513 static
 514 int
 515 hammer_vop_write(struct vop_write_args *ap)
 516 {
 517         struct hammer_transaction trans;
 518         struct hammer_inode *ip;
 519         hammer_mount_t hmp;
 520         thread_t td;
 521         struct uio *uio;
 522         int offset;
 523         off_t base_offset;
 524         int64_t cluster_eof;
 525         struct buf *bp;
 526         int kflags;
 527         int error;
 528         int n;
 529         int flags;
 530         int seqcount;
 531         int bigwrite;
 532
 533         if (ap->a_vp->v_type != VREG)
 534                 return (EINVAL);
 535         ip = VTOI(ap->a_vp);
 536         hmp = ip->hmp;
 537         error = 0;
 538         kflags = 0;
 539         seqcount = ap->a_ioflag >> 16;
 540
 541         if (ip->flags & HAMMER_INODE_RO)
 542                 return (EROFS);
 543
 544         /*
 545          * Create a transaction to cover the operations we perform.
 546          */
 547         hammer_start_transaction(&trans, hmp);
 548         uio = ap->a_uio;
 549
 550         /*
 551          * Check append mode
 552          */
 553         if (ap->a_ioflag & IO_APPEND)
 554                 uio->uio_offset = ip->ino_data.size;
 555
 556         /*
 557          * Check for illegal write offsets.  Valid range is 0...2^63-1.
 558          *
 559          * NOTE: the base_off assignment is required to work around what
 560          * I consider to be a GCC-4 optimization bug.
 561          */
 562         if (uio->uio_offset < 0) {
 563                 hammer_done_transaction(&trans);
 564                 return (EFBIG);
 565         }
 566         base_offset = uio->uio_offset + uio->uio_resid; /* work around gcc-4 */
 567         if (uio->uio_resid > 0 && base_offset <= uio->uio_offset) {
 568                 hammer_done_transaction(&trans);
 569                 return (EFBIG);
 570         }
 571
 572         if (uio->uio_resid > 0 && (td = uio->uio_td) != NULL && td->td_proc &&
 573             base_offset > td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
 574                 hammer_done_transaction(&trans);
 575                 lwpsignal(td->td_proc, td->td_lwp, SIGXFSZ);
 576                 return (EFBIG);
 577         }
 578
 579         /*
 580          * If reading or writing a huge amount of data we have to break
 581          * atomicy and allow the operation to be interrupted by a signal
 582          * or it can DOS the machine.
 583          *
 584          * Preset redo_count so we stop generating REDOs earlier if the
 585          * limit is exceeded.
 586          *
 587          * redo_count is heuristical, SMP races are ok
 588          */
 589         bigwrite = (uio->uio_resid > 100 * 1024 * 1024);
 590         if ((ip->flags & HAMMER_INODE_REDO) &&
 591             ip->redo_count < hammer_limit_redo) {
 592                 ip->redo_count += uio->uio_resid;
 593         }
 594
 595         /*
 596          * Access the data typically in HAMMER_BUFSIZE blocks via the
 597          * buffer cache, but HAMMER may use a variable block size based
 598          * on the offset.
 599          */
 600         while (uio->uio_resid > 0) {
 601                 int fixsize = 0;
 602                 int blksize;
 603                 int blkmask;
 604                 int trivial;
 605                 int endofblk;
 606                 off_t nsize;
 607
 608                 if ((error = hammer_checkspace(hmp, HAMMER_CHKSPC_WRITE)) != 0)
 609                         break;
 610                 if (bigwrite && (error = hammer_signal_check(hmp)) != 0)
 611                         break;
 612
 613                 blksize = hammer_blocksize(uio->uio_offset);
 614
 615                 /*
 616                  * Control the number of pending records associated with
 617                  * this inode.  If too many have accumulated start a
 618                  * flush.  Try to maintain a pipeline with the flusher.
 619                  *
 620                  * NOTE: It is possible for other sources to grow the
 621                  *       records but not necessarily issue another flush,
 622                  *       so use a timeout and ensure that a re-flush occurs.
 623                  */
 624                 if (ip->rsv_recs >= hammer_limit_inode_recs) {
 625                         lwkt_gettoken(&hmp->fs_token);
 626                         hammer_flush_inode(ip, HAMMER_FLUSH_SIGNAL);
 627                         while (ip->rsv_recs >= hammer_limit_inode_recs * 2) {
 628                                 ip->flags |= HAMMER_INODE_RECSW;
 629                                 tsleep(&ip->rsv_recs, 0, "hmrwww", hz);
 630                                 hammer_flush_inode(ip, HAMMER_FLUSH_SIGNAL);
 631                         }
 632                         lwkt_reltoken(&hmp->fs_token);
 633                 }
 634
 635                 /*
 636                  * Do not allow HAMMER to blow out the buffer cache.  Very
 637                  * large UIOs can lockout other processes due to bwillwrite()
 638                  * mechanics.
 639                  *
 640                  * The hammer inode is not locked during these operations.
 641                  * The vnode is locked which can interfere with the pageout
 642                  * daemon for non-UIO_NOCOPY writes but should not interfere
 643                  * with the buffer cache.  Even so, we cannot afford to
 644                  * allow the pageout daemon to build up too many dirty buffer
 645                  * cache buffers.
 646                  *
 647                  * Only call this if we aren't being recursively called from
 648                  * a virtual disk device (vn), else we may deadlock.
 649                  */
 650                 if ((ap->a_ioflag & IO_RECURSE) == 0)
 651                         bwillwrite(blksize);
 652
 653                 /*
 654                  * Calculate the blocksize at the current offset and figure
 655                  * out how much we can actually write.
 656                  */
 657                 blkmask = blksize - 1;
 658                 offset = (int)uio->uio_offset & blkmask;
 659                 base_offset = uio->uio_offset & ~(int64_t)blkmask;
 660                 n = blksize - offset;
 661                 if (n > uio->uio_resid) {
 662                         n = uio->uio_resid;
 663                         endofblk = 0;
 664                 } else {
 665                         endofblk = 1;
 666                 }
 667                 nsize = uio->uio_offset + n;
 668                 if (nsize > ip->ino_data.size) {
 669                         if (uio->uio_offset > ip->ino_data.size)
 670                                 trivial = 0;
 671                         else
 672                                 trivial = 1;
 673                         nvextendbuf(ap->a_vp,
 674                                     ip->ino_data.size,
 675                                     nsize,
 676                                     hammer_blocksize(ip->ino_data.size),
 677                                     hammer_blocksize(nsize),
 678                                     hammer_blockoff(ip->ino_data.size),
 679                                     hammer_blockoff(nsize),
 680                                     trivial);
 681                         fixsize = 1;
 682                         kflags |= NOTE_EXTEND;
 683                 }
 684
 685                 if (uio->uio_segflg == UIO_NOCOPY) {
 686                         /*
 687                          * Issuing a write with the same data backing the
 688                          * buffer.  Instantiate the buffer to collect the
 689                          * backing vm pages, then read-in any missing bits.
 690                          *
 691                          * This case is used by vop_stdputpages().
 692                          */
 693                         bp = getblk(ap->a_vp, base_offset,
 694                                     blksize, GETBLK_BHEAVY, 0);
 695                         if ((bp->b_flags & B_CACHE) == 0) {
 696                                 bqrelse(bp);
 697                                 error = bread(ap->a_vp, base_offset,
 698                                               blksize, &bp);
 699                         }
 700                 } else if (offset == 0 && uio->uio_resid >= blksize) {
 701                         /*
 702                          * Even though we are entirely overwriting the buffer
 703                          * we may still have to zero it out to avoid a
 704                          * mmap/write visibility issue.
 705                          */
 706                         bp = getblk(ap->a_vp, base_offset, blksize, GETBLK_BHEAVY, 0);
 707                         if ((bp->b_flags & B_CACHE) == 0)
 708                                 vfs_bio_clrbuf(bp);
 709                 } else if (base_offset >= ip->ino_data.size) {
 710                         /*
 711                          * If the base offset of the buffer is beyond the
 712                          * file EOF, we don't have to issue a read.
 713                          */
 714                         bp = getblk(ap->a_vp, base_offset,
 715                                     blksize, GETBLK_BHEAVY, 0);
 716                         vfs_bio_clrbuf(bp);
 717                 } else {
 718                         /*
 719                          * Partial overwrite, read in any missing bits then
 720                          * replace the portion being written.
 721                          */
 722                         error = bread(ap->a_vp, base_offset, blksize, &bp);
 723                         if (error == 0)
 724                                 bheavy(bp);
 725                 }
 726                 if (error == 0)
 727                         error = uiomovebp(bp, bp->b_data + offset, n, uio);
 728
 729                 lwkt_gettoken(&hmp->fs_token);
 730
 731                 /*
 732                  * Generate REDO records if enabled and redo_count will not
 733                  * exceeded the limit.
 734                  *
 735                  * If redo_count exceeds the limit we stop generating records
 736                  * and clear HAMMER_INODE_REDO.  This will cause the next
 737                  * fsync() to do a full meta-data sync instead of just an
 738                  * UNDO/REDO fifo update.
 739                  *
 740                  * When clearing HAMMER_INODE_REDO any pre-existing REDOs
 741                  * will still be tracked.  The tracks will be terminated
 742                  * when the related meta-data (including possible data
 743                  * modifications which are not tracked via REDO) is
 744                  * flushed.
 745                  */
 746                 if ((ip->flags & HAMMER_INODE_REDO) && error == 0) {
 747                         if (ip->redo_count < hammer_limit_redo) {
 748                                 bp->b_flags |= B_VFSFLAG1;
 749                                 error = hammer_generate_redo(&trans, ip,
 750                                                      base_offset + offset,
 751                                                      HAMMER_REDO_WRITE,
 752                                                      bp->b_data + offset,
 753                                                      (size_t)n);
 754                         } else {
 755                                 ip->flags &= ~HAMMER_INODE_REDO;
 756                         }
 757                 }
 758
 759                 /*
 760                  * If we screwed up we have to undo any VM size changes we
 761                  * made.
 762                  */
 763                 if (error) {
 764                         brelse(bp);
 765                         if (fixsize) {
 766                                 nvtruncbuf(ap->a_vp, ip->ino_data.size,
 767                                           hammer_blocksize(ip->ino_data.size),
 768                                           hammer_blockoff(ip->ino_data.size),
 769                                           0);
 770                         }
 771                         lwkt_reltoken(&hmp->fs_token);
 772                         break;
 773                 }
 774                 kflags |= NOTE_WRITE;
 775                 hammer_stats_file_write += n;
 776                 if (blksize == HAMMER_XBUFSIZE)
 777                         bp->b_flags |= B_CLUSTEROK;
 778                 if (ip->ino_data.size < uio->uio_offset) {
 779                         ip->ino_data.size = uio->uio_offset;
 780                         flags = HAMMER_INODE_SDIRTY;
 781                 } else {
 782                         flags = 0;
 783                 }
 784                 ip->ino_data.mtime = trans.time;
 785                 flags |= HAMMER_INODE_MTIME | HAMMER_INODE_BUFS;
 786                 hammer_modify_inode(&trans, ip, flags);
 787
 788                 /*
 789                  * Once we dirty the buffer any cached zone-X offset
 790                  * becomes invalid.  HAMMER NOTE: no-history mode cannot
 791                  * allow overwriting over the same data sector unless
 792                  * we provide UNDOs for the old data, which we don't.
 793                  */
 794                 bp->b_bio2.bio_offset = NOOFFSET;
 795
 796                 lwkt_reltoken(&hmp->fs_token);
 797
 798                 /*
 799                  * Final buffer disposition.
 800                  *
 801                  * Because meta-data updates are deferred, HAMMER is
 802                  * especially sensitive to excessive bdwrite()s because
 803                  * the I/O stream is not broken up by disk reads.  So the
 804                  * buffer cache simply cannot keep up.
 805                  *
 806                  * WARNING!  blksize is variable.  cluster_write() is
 807                  *           expected to not blow up if it encounters
 808                  *           buffers that do not match the passed blksize.
 809                  *
 810                  * NOTE!  Hammer shouldn't need to bawrite()/cluster_write().
 811                  *        The ip->rsv_recs check should burst-flush the data.
 812                  *        If we queue it immediately the buf could be left
 813                  *        locked on the device queue for a very long time.
 814                  *
 815                  *        However, failing to flush a dirty buffer out when
 816                  *        issued from the pageout daemon can result in a low
 817                  *        memory deadlock against bio_page_alloc(), so we
 818                  *        have to bawrite() on IO_ASYNC as well.
 819                  *
 820                  * NOTE!  To avoid degenerate stalls due to mismatched block
 821                  *        sizes we only honor IO_DIRECT on the write which
 822                  *        abuts the end of the buffer.  However, we must
 823                  *        honor IO_SYNC in case someone is silly enough to
 824                  *        configure a HAMMER file as swap, or when HAMMER
 825                  *        is serving NFS (for commits).  Ick ick.
 826                  */
 827                 bp->b_flags |= B_AGE;
 828                 if (blksize == HAMMER_XBUFSIZE)
 829                         bp->b_flags |= B_CLUSTEROK;
 830
 831                 if (ap->a_ioflag & IO_SYNC) {
 832                         bwrite(bp);
 833                 } else if ((ap->a_ioflag & IO_DIRECT) && endofblk) {
 834                         bawrite(bp);
 835                 } else if (ap->a_ioflag & IO_ASYNC) {
 836                         bawrite(bp);
 837                 } else if (hammer_cluster_enable &&
 838                            !(ap->a_vp->v_mount->mnt_flag & MNT_NOCLUSTERW)) {
 839                         if (base_offset < HAMMER_XDEMARC)
 840                                 cluster_eof = hammer_blockdemarc(base_offset,
 841                                                          ip->ino_data.size);
 842                         else
 843                                 cluster_eof = ip->ino_data.size;
 844                         cluster_write(bp, cluster_eof, blksize, seqcount);
 845                 } else {
 846                         bdwrite(bp);
 847                 }
 848         }
 849         hammer_done_transaction(&trans);
 850         hammer_knote(ap->a_vp, kflags);
 851
 852         return (error);
 853 }
 854
 855 /*
 856  * hammer_vop_access { vp, mode, cred }
 857  *
 858  * MPSAFE - does not require fs_token
 859  */
 860 static
 861 int
 862 hammer_vop_access(struct vop_access_args *ap)
 863 {
 864         struct hammer_inode *ip = VTOI(ap->a_vp);
 865         uid_t uid;
 866         gid_t gid;
 867         int error;
 868
 869         ++hammer_stats_file_iopsr;
 870         uid = hammer_to_unix_xid(&ip->ino_data.uid);
 871         gid = hammer_to_unix_xid(&ip->ino_data.gid);
 872
 873         error = vop_helper_access(ap, uid, gid, ip->ino_data.mode,
 874                                   ip->ino_data.uflags);
 875         return (error);
 876 }
 877
 878 /*
 879  * hammer_vop_advlock { vp, id, op, fl, flags }
 880  *
 881  * MPSAFE - does not require fs_token
 882  */
 883 static
 884 int
 885 hammer_vop_advlock(struct vop_advlock_args *ap)
 886 {
 887         hammer_inode_t ip = VTOI(ap->a_vp);
 888
 889         return (lf_advlock(ap, &ip->advlock, ip->ino_data.size));
 890 }
 891
 892 /*
 893  * hammer_vop_close { vp, fflag }
 894  *
 895  * We can only sync-on-close for normal closes.  XXX disabled for now.
 896  */
 897 static
 898 int
 899 hammer_vop_close(struct vop_close_args *ap)
 900 {
 901 #if 0
 902         struct vnode *vp = ap->a_vp;
 903         hammer_inode_t ip = VTOI(vp);
 904         int waitfor;
 905         if (ip->flags & (HAMMER_INODE_CLOSESYNC|HAMMER_INODE_CLOSEASYNC)) {
 906                 if (vn_islocked(vp) == LK_EXCLUSIVE &&
 907                     (vp->v_flag & (VINACTIVE|VRECLAIMED)) == 0) {
 908                         if (ip->flags & HAMMER_INODE_CLOSESYNC)
 909                                 waitfor = MNT_WAIT;
 910                         else
 911                                 waitfor = MNT_NOWAIT;
 912                         ip->flags &= ~(HAMMER_INODE_CLOSESYNC |
 913                                        HAMMER_INODE_CLOSEASYNC);
 914                         VOP_FSYNC(vp, MNT_NOWAIT, waitfor);
 915                 }
 916         }
 917 #endif
 918         return (vop_stdclose(ap));
 919 }
 920
 921 /*
 922  * hammer_vop_ncreate { nch, dvp, vpp, cred, vap }
 923  *
 924  * The operating system has already ensured that the directory entry
 925  * does not exist and done all appropriate namespace locking.
 926  */
 927 static
 928 int
 929 hammer_vop_ncreate(struct vop_ncreate_args *ap)
 930 {
 931         struct hammer_transaction trans;
 932         struct hammer_inode *dip;
 933         struct hammer_inode *nip;
 934         struct nchandle *nch;
 935         hammer_mount_t hmp;
 936         int error;
 937
 938         nch = ap->a_nch;
 939         dip = VTOI(ap->a_dvp);
 940         hmp = dip->hmp;
 941
 942         if (dip->flags & HAMMER_INODE_RO)
 943                 return (EROFS);
 944         if ((error = hammer_checkspace(hmp, HAMMER_CHKSPC_CREATE)) != 0)
 945                 return (error);
 946
 947         /*
 948          * Create a transaction to cover the operations we perform.
 949          */
 950         lwkt_gettoken(&hmp->fs_token);
 951         hammer_start_transaction(&trans, hmp);
 952         ++hammer_stats_file_iopsw;
 953
 954         /*
 955          * Create a new filesystem object of the requested type.  The
 956          * returned inode will be referenced and shared-locked to prevent
 957          * it from being moved to the flusher.
 958          */
 959         error = hammer_create_inode(&trans, ap->a_vap, ap->a_cred,
 960                                     dip, nch->ncp->nc_name, nch->ncp->nc_nlen,
 961                                     NULL, &nip);
 962         if (error) {
 963                 hkprintf("hammer_create_inode error %d\n", error);
 964                 hammer_done_transaction(&trans);
 965                 *ap->a_vpp = NULL;
 966                 lwkt_reltoken(&hmp->fs_token);
 967                 return (error);
 968         }
 969
 970         /*
 971          * Add the new filesystem object to the directory.  This will also
 972          * bump the inode's link count.
 973          */
 974         error = hammer_ip_add_directory(&trans, dip,
 975                                         nch->ncp->nc_name, nch->ncp->nc_nlen,
 976                                         nip);
 977         if (error)
 978                 hkprintf("hammer_ip_add_directory error %d\n", error);
 979
 980         /*
 981          * Finish up.
 982          */
 983         if (error) {
 984                 hammer_rel_inode(nip, 0);
 985                 hammer_done_transaction(&trans);
 986                 *ap->a_vpp = NULL;
 987         } else {
 988                 error = hammer_get_vnode(nip, ap->a_vpp);
 989                 hammer_done_transaction(&trans);
 990                 hammer_rel_inode(nip, 0);
 991                 if (error == 0) {
 992                         cache_setunresolved(ap->a_nch);
 993                         cache_setvp(ap->a_nch, *ap->a_vpp);
 994                 }
 995                 hammer_knote(ap->a_dvp, NOTE_WRITE);
 996         }
 997         lwkt_reltoken(&hmp->fs_token);
 998         return (error);
 999 }
1000
1001 /*
1002  * hammer_vop_getattr { vp, vap }
1003  *
1004  * Retrieve an inode's attribute information.  When accessing inodes
1005  * historically we fake the atime field to ensure consistent results.
1006  * The atime field is stored in the B-Tree element and allowed to be
1007  * updated without cycling the element.
1008  *
1009  * MPSAFE - does not require fs_token
1010  */
1011 static
1012 int
1013 hammer_vop_getattr(struct vop_getattr_args *ap)
1014 {
1015         struct hammer_inode *ip = VTOI(ap->a_vp);
1016         struct vattr *vap = ap->a_vap;
1017
1018         /*
1019          * We want the fsid to be different when accessing a filesystem
1020          * with different as-of's so programs like diff don't think
1021          * the files are the same.
1022          *
1023          * We also want the fsid to be the same when comparing snapshots,
1024          * or when comparing mirrors (which might be backed by different
1025          * physical devices).  HAMMER fsids are based on the PFS's
1026          * shared_uuid field.
1027          *
1028          * XXX there is a chance of collision here.  The va_fsid reported
1029          * by stat is different from the more involved fsid used in the
1030          * mount structure.
1031          */
1032         ++hammer_stats_file_iopsr;
1033         hammer_lock_sh(&ip->lock);
1034         vap->va_fsid = ip->pfsm->fsid_udev ^ (u_int32_t)ip->obj_asof ^
1035                        (u_int32_t)(ip->obj_asof >> 32);
1036
1037         vap->va_fileid = ip->ino_leaf.base.obj_id;
1038         vap->va_mode = ip->ino_data.mode;
1039         vap->va_nlink = ip->ino_data.nlinks;
1040         vap->va_uid = hammer_to_unix_xid(&ip->ino_data.uid);
1041         vap->va_gid = hammer_to_unix_xid(&ip->ino_data.gid);
1042         vap->va_rmajor = 0;
1043         vap->va_rminor = 0;
1044         vap->va_size = ip->ino_data.size;
1045
1046         /*
1047          * Special case for @@PFS softlinks.  The actual size of the
1048          * expanded softlink is "@@0x%016llx:%05d" == 26 bytes.
1049          * or for MAX_TID is    "@@-1:%05d" == 10 bytes.
1050          *
1051          * Note that userspace hammer command does not allow users to
1052          * create a @@PFS softlink under an existing other PFS (id!=0)
1053          * so the ip localization here for @@PFS softlink is always 0.
1054          */
1055         if (ip->ino_data.obj_type == HAMMER_OBJTYPE_SOFTLINK &&
1056             ip->ino_data.size == 10 &&
1057             ip->obj_asof == HAMMER_MAX_TID &&
1058             ip->obj_localization == 0 &&
1059             strncmp(ip->ino_data.ext.symlink, "@@PFS", 5) == 0) {
1060                     if (ip->pfsm->pfsd.mirror_flags & HAMMER_PFSD_SLAVE)
1061                             vap->va_size = 26;
1062                     else
1063                             vap->va_size = 10;
1064         }
1065
1066         /*
1067          * We must provide a consistent atime and mtime for snapshots
1068          * so people can do a 'tar cf - ... | md5' on them and get
1069          * consistent results.
1070          */
1071         if (ip->flags & HAMMER_INODE_RO) {
1072                 hammer_time_to_timespec(ip->ino_data.ctime, &vap->va_atime);
1073                 hammer_time_to_timespec(ip->ino_data.ctime, &vap->va_mtime);
1074         } else {
1075                 hammer_time_to_timespec(ip->ino_data.atime, &vap->va_atime);
1076                 hammer_time_to_timespec(ip->ino_data.mtime, &vap->va_mtime);
1077         }
1078         hammer_time_to_timespec(ip->ino_data.ctime, &vap->va_ctime);
1079         vap->va_flags = ip->ino_data.uflags;
1080         vap->va_gen = 1;        /* hammer inums are unique for all time */
1081         vap->va_blocksize = HAMMER_BUFSIZE;
1082         if (ip->ino_data.size >= HAMMER_XDEMARC) {
1083                 vap->va_bytes = (ip->ino_data.size + HAMMER_XBUFMASK64) &
1084                                 ~HAMMER_XBUFMASK64;
1085         } else if (ip->ino_data.size > HAMMER_BUFSIZE / 2) {
1086                 vap->va_bytes = (ip->ino_data.size + HAMMER_BUFMASK64) &
1087                                 ~HAMMER_BUFMASK64;
1088         } else {
1089                 vap->va_bytes = (ip->ino_data.size + 15) & ~15;
1090         }
1091
1092         vap->va_type = hammer_get_vnode_type(ip->ino_data.obj_type);
1093         vap->va_filerev = 0;    /* XXX */
1094         vap->va_uid_uuid = ip->ino_data.uid;
1095         vap->va_gid_uuid = ip->ino_data.gid;
1096         vap->va_fsid_uuid = ip->hmp->fsid;
1097         vap->va_vaflags = VA_UID_UUID_VALID | VA_GID_UUID_VALID |
1098                           VA_FSID_UUID_VALID;
1099
1100         switch (ip->ino_data.obj_type) {
1101         case HAMMER_OBJTYPE_CDEV:
1102         case HAMMER_OBJTYPE_BDEV:
1103                 vap->va_rmajor = ip->ino_data.rmajor;
1104                 vap->va_rminor = ip->ino_data.rminor;
1105                 break;
1106         default:
1107                 break;
1108         }
1109         hammer_unlock(&ip->lock);
1110         return(0);
1111 }
1112
1113 /*
1114  * hammer_vop_nresolve { nch, dvp, cred }
1115  *
1116  * Locate the requested directory entry.
1117  */
1118 static
1119 int
1120 hammer_vop_nresolve(struct vop_nresolve_args *ap)
1121 {
1122         struct hammer_transaction trans;
1123         struct namecache *ncp;
1124         hammer_mount_t hmp;
1125         hammer_inode_t dip;
1126         hammer_inode_t ip;
1127         hammer_tid_t asof;
1128         struct hammer_cursor cursor;
1129         struct vnode *vp;
1130         int64_t namekey;
1131         int error;
1132         int i;
1133         int nlen;
1134         int flags;
1135         int ispfs;
1136         int64_t obj_id;
1137         u_int32_t localization;
1138         u_int32_t max_iterations;
1139
1140         /*
1141          * Misc initialization, plus handle as-of name extensions.  Look for
1142          * the '@@' extension.  Note that as-of files and directories cannot
1143          * be modified.
1144          */
1145         dip = VTOI(ap->a_dvp);
1146         ncp = ap->a_nch->ncp;
1147         asof = dip->obj_asof;
1148         localization = dip->obj_localization;   /* for code consistency */
1149         nlen = ncp->nc_nlen;
1150         flags = dip->flags & HAMMER_INODE_RO;
1151         ispfs = 0;
1152         hmp = dip->hmp;
1153
1154         lwkt_gettoken(&hmp->fs_token);
1155         hammer_simple_transaction(&trans, hmp);
1156         ++hammer_stats_file_iopsr;
1157
1158         for (i = 0; i < nlen; ++i) {
1159                 if (ncp->nc_name[i] == '@' && ncp->nc_name[i+1] == '@') {
1160                         error = hammer_str_to_tid(ncp->nc_name + i + 2,
1161                                                   &ispfs, &asof, &localization);
1162                         if (error != 0) {
1163                                 i = nlen;
1164                                 break;
1165                         }
1166                         if (asof != HAMMER_MAX_TID)
1167                                 flags |= HAMMER_INODE_RO;
1168                         break;
1169                 }
1170         }
1171         nlen = i;
1172
1173         /*
1174          * If this is a PFS softlink we dive into the PFS
1175          */
1176         if (ispfs && nlen == 0) {
1177                 ip = hammer_get_inode(&trans, dip, HAMMER_OBJID_ROOT,
1178                                       asof, localization,
1179                                       flags, &error);
1180                 if (error == 0) {
1181                         error = hammer_get_vnode(ip, &vp);
1182                         hammer_rel_inode(ip, 0);
1183                 } else {
1184                         vp = NULL;
1185                 }
1186                 if (error == 0) {
1187                         vn_unlock(vp);
1188                         cache_setvp(ap->a_nch, vp);
1189                         vrele(vp);
1190                 }
1191                 goto done;
1192         }
1193
1194         /*
1195          * If there is no path component the time extension is relative to dip.
1196          * e.g. "fubar/@@<snapshot>"
1197          *
1198          * "." is handled by the kernel, but ".@@<snapshot>" is not.
1199          * e.g. "fubar/.@@<snapshot>"
1200          *
1201          * ".." is handled by the kernel.  We do not currently handle
1202          * "..@<snapshot>".
1203          */
1204         if (nlen == 0 || (nlen == 1 && ncp->nc_name[0] == '.')) {
1205                 ip = hammer_get_inode(&trans, dip, dip->obj_id,
1206                                       asof, dip->obj_localization,
1207                                       flags, &error);
1208                 if (error == 0) {
1209                         error = hammer_get_vnode(ip, &vp);
1210                         hammer_rel_inode(ip, 0);
1211                 } else {
1212                         vp = NULL;
1213                 }
1214                 if (error == 0) {
1215                         vn_unlock(vp);
1216                         cache_setvp(ap->a_nch, vp);
1217                         vrele(vp);
1218                 }
1219                 goto done;
1220         }
1221
1222         /*
1223          * Calculate the namekey and setup the key range for the scan.  This
1224          * works kinda like a chained hash table where the lower 32 bits
1225          * of the namekey synthesize the chain.
1226          *
1227          * The key range is inclusive of both key_beg and key_end.
1228          */
1229         namekey = hammer_directory_namekey(dip, ncp->nc_name, nlen,
1230                                            &max_iterations);
1231
1232         error = hammer_init_cursor(&trans, &cursor, &dip->cache[1], dip);
1233         cursor.key_beg.localization = dip->obj_localization +
1234                                       hammer_dir_localization(dip);
1235         cursor.key_beg.obj_id = dip->obj_id;
1236         cursor.key_beg.key = namekey;
1237         cursor.key_beg.create_tid = 0;
1238         cursor.key_beg.delete_tid = 0;
1239         cursor.key_beg.rec_type = HAMMER_RECTYPE_DIRENTRY;
1240         cursor.key_beg.obj_type = 0;
1241
1242         cursor.key_end = cursor.key_beg;
1243         cursor.key_end.key += max_iterations;
1244         cursor.asof = asof;
1245         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE | HAMMER_CURSOR_ASOF;
1246
1247         /*
1248          * Scan all matching records (the chain), locate the one matching
1249          * the requested path component.
1250          *
1251          * The hammer_ip_*() functions merge in-memory records with on-disk
1252          * records for the purposes of the search.
1253          */
1254         obj_id = 0;
1255         localization = HAMMER_DEF_LOCALIZATION;
1256
1257         if (error == 0) {
1258                 error = hammer_ip_first(&cursor);
1259                 while (error == 0) {
1260                         error = hammer_ip_resolve_data(&cursor);
1261                         if (error)
1262                                 break;
1263                         if (nlen == cursor.leaf->data_len - HAMMER_ENTRY_NAME_OFF &&
1264                             bcmp(ncp->nc_name, cursor.data->entry.name, nlen) == 0) {
1265                                 obj_id = cursor.data->entry.obj_id;
1266                                 localization = cursor.data->entry.localization;
1267                                 break;
1268                         }
1269                         error = hammer_ip_next(&cursor);
1270                 }
1271         }
1272         hammer_done_cursor(&cursor);
1273
1274         /*
1275          * Lookup the obj_id.  This should always succeed.  If it does not
1276          * the filesystem may be damaged and we return a dummy inode.
1277          */
1278         if (error == 0) {
1279                 ip = hammer_get_inode(&trans, dip, obj_id,
1280                                       asof, localization,
1281                                       flags, &error);
1282                 if (error == ENOENT) {
1283                         kprintf("HAMMER: WARNING: Missing "
1284                                 "inode for dirent \"%s\"\n"
1285                                 "\tobj_id = %016llx, asof=%016llx, lo=%08x\n",
1286                                 ncp->nc_name,
1287                                 (long long)obj_id, (long long)asof,
1288                                 localization);
1289                         error = 0;
1290                         ip = hammer_get_dummy_inode(&trans, dip, obj_id,
1291                                                     asof, localization,
1292                                                     flags, &error);
1293                 }
1294                 if (error == 0) {
1295                         error = hammer_get_vnode(ip, &vp);
1296                         hammer_rel_inode(ip, 0);
1297                 } else {
1298                         vp = NULL;
1299                 }
1300                 if (error == 0) {
1301                         vn_unlock(vp);
1302                         cache_setvp(ap->a_nch, vp);
1303                         vrele(vp);
1304                 }
1305         } else if (error == ENOENT) {
1306                 cache_setvp(ap->a_nch, NULL);
1307         }
1308 done:
1309         hammer_done_transaction(&trans);
1310         lwkt_reltoken(&hmp->fs_token);
1311         return (error);
1312 }
1313
1314 /*
1315  * hammer_vop_nlookupdotdot { dvp, vpp, cred }
1316  *
1317  * Locate the parent directory of a directory vnode.
1318  *
1319  * dvp is referenced but not locked.  *vpp must be returned referenced and
1320  * locked.  A parent_obj_id of 0 does not necessarily indicate that we are
1321  * at the root, instead it could indicate that the directory we were in was
1322  * removed.
1323  *
1324  * NOTE: as-of sequences are not linked into the directory structure.  If
1325  * we are at the root with a different asof then the mount point, reload
1326  * the same directory with the mount point's asof.   I'm not sure what this
1327  * will do to NFS.  We encode ASOF stamps in NFS file handles so it might not
1328  * get confused, but it hasn't been tested.
1329  */
1330 static
1331 int
1332 hammer_vop_nlookupdotdot(struct vop_nlookupdotdot_args *ap)
1333 {
1334         struct hammer_transaction trans;
1335         struct hammer_inode *dip;
1336         struct hammer_inode *ip;
1337         hammer_mount_t hmp;
1338         int64_t parent_obj_id;
1339         u_int32_t parent_obj_localization;
1340         hammer_tid_t asof;
1341         int error;
1342
1343         dip = VTOI(ap->a_dvp);
1344         asof = dip->obj_asof;
1345         hmp = dip->hmp;
1346
1347         /*
1348          * Whos are parent?  This could be the root of a pseudo-filesystem
1349          * whos parent is in another localization domain.
1350          */
1351         lwkt_gettoken(&hmp->fs_token);
1352         parent_obj_id = dip->ino_data.parent_obj_id;
1353         if (dip->obj_id == HAMMER_OBJID_ROOT)
1354                 parent_obj_localization = dip->ino_data.ext.obj.parent_obj_localization;
1355         else
1356                 parent_obj_localization = dip->obj_localization;
1357
1358         if (parent_obj_id == 0) {
1359                 if (dip->obj_id == HAMMER_OBJID_ROOT &&
1360                    asof != hmp->asof) {
1361                         parent_obj_id = dip->obj_id;
1362                         asof = hmp->asof;
1363                         *ap->a_fakename = kmalloc(19, M_TEMP, M_WAITOK);
1364                         ksnprintf(*ap->a_fakename, 19, "0x%016llx",
1365                                   (long long)dip->obj_asof);
1366                 } else {
1367                         *ap->a_vpp = NULL;
1368                         lwkt_reltoken(&hmp->fs_token);
1369                         return ENOENT;
1370                 }
1371         }
1372
1373         hammer_simple_transaction(&trans, hmp);
1374         ++hammer_stats_file_iopsr;
1375
1376         ip = hammer_get_inode(&trans, dip, parent_obj_id,
1377                               asof, parent_obj_localization,
1378                               dip->flags, &error);
1379         if (ip) {
1380                 error = hammer_get_vnode(ip, ap->a_vpp);
1381                 hammer_rel_inode(ip, 0);
1382         } else {
1383                 *ap->a_vpp = NULL;
1384         }
1385         hammer_done_transaction(&trans);
1386         lwkt_reltoken(&hmp->fs_token);
1387         return (error);
1388 }
1389
1390 /*
1391  * hammer_vop_nlink { nch, dvp, vp, cred }
1392  */
1393 static
1394 int
1395 hammer_vop_nlink(struct vop_nlink_args *ap)
1396 {
1397         struct hammer_transaction trans;
1398         struct hammer_inode *dip;
1399         struct hammer_inode *ip;
1400         struct nchandle *nch;
1401         hammer_mount_t hmp;
1402         int error;
1403
1404         if (ap->a_dvp->v_mount != ap->a_vp->v_mount)
1405                 return(EXDEV);
1406
1407         nch = ap->a_nch;
1408         dip = VTOI(ap->a_dvp);
1409         ip = VTOI(ap->a_vp);
1410         hmp = dip->hmp;
1411
1412         if (dip->obj_localization != ip->obj_localization)
1413                 return(EXDEV);
1414
1415         if (dip->flags & HAMMER_INODE_RO)
1416                 return (EROFS);
1417         if (ip->flags & HAMMER_INODE_RO)
1418                 return (EROFS);
1419         if ((error = hammer_checkspace(hmp, HAMMER_CHKSPC_CREATE)) != 0)
1420                 return (error);
1421
1422         /*
1423          * Create a transaction to cover the operations we perform.
1424          */
1425         lwkt_gettoken(&hmp->fs_token);
1426         hammer_start_transaction(&trans, hmp);
1427         ++hammer_stats_file_iopsw;
1428
1429         /*
1430          * Add the filesystem object to the directory.  Note that neither
1431          * dip nor ip are referenced or locked, but their vnodes are
1432          * referenced.  This function will bump the inode's link count.
1433          */
1434         error = hammer_ip_add_directory(&trans, dip,
1435                                         nch->ncp->nc_name, nch->ncp->nc_nlen,
1436                                         ip);
1437
1438         /*
1439          * Finish up.
1440          */
1441         if (error == 0) {
1442                 cache_setunresolved(nch);
1443                 cache_setvp(nch, ap->a_vp);
1444         }
1445         hammer_done_transaction(&trans);
1446         hammer_knote(ap->a_vp, NOTE_LINK);
1447         hammer_knote(ap->a_dvp, NOTE_WRITE);
1448         lwkt_reltoken(&hmp->fs_token);
1449         return (error);
1450 }
1451
1452 /*
1453  * hammer_vop_nmkdir { nch, dvp, vpp, cred, vap }
1454  *
1455  * The operating system has already ensured that the directory entry
1456  * does not exist and done all appropriate namespace locking.
1457  */
1458 static
1459 int
1460 hammer_vop_nmkdir(struct vop_nmkdir_args *ap)
1461 {
1462         struct hammer_transaction trans;
1463         struct hammer_inode *dip;
1464         struct hammer_inode *nip;
1465         struct nchandle *nch;
1466         hammer_mount_t hmp;
1467         int error;
1468
1469         nch = ap->a_nch;
1470         dip = VTOI(ap->a_dvp);
1471         hmp = dip->hmp;
1472
1473         if (dip->flags & HAMMER_INODE_RO)
1474                 return (EROFS);
1475         if ((error = hammer_checkspace(hmp, HAMMER_CHKSPC_CREATE)) != 0)
1476                 return (error);
1477
1478         /*
1479          * Create a transaction to cover the operations we perform.
1480          */
1481         lwkt_gettoken(&hmp->fs_token);
1482         hammer_start_transaction(&trans, hmp);
1483         ++hammer_stats_file_iopsw;
1484
1485         /*
1486          * Create a new filesystem object of the requested type.  The
1487          * returned inode will be referenced but not locked.
1488          */
1489         error = hammer_create_inode(&trans, ap->a_vap, ap->a_cred,
1490                                     dip, nch->ncp->nc_name, nch->ncp->nc_nlen,
1491                                     NULL, &nip);
1492         if (error) {
1493                 hkprintf("hammer_mkdir error %d\n", error);
1494                 hammer_done_transaction(&trans);
1495                 *ap->a_vpp = NULL;
1496                 lwkt_reltoken(&hmp->fs_token);
1497                 return (error);
1498         }
1499         /*
1500          * Add the new filesystem object to the directory.  This will also
1501          * bump the inode's link count.
1502          */
1503         error = hammer_ip_add_directory(&trans, dip,
1504                                         nch->ncp->nc_name, nch->ncp->nc_nlen,
1505                                         nip);
1506         if (error)
1507                 hkprintf("hammer_mkdir (add) error %d\n", error);
1508
1509         /*
1510          * Finish up.
1511          */
1512         if (error) {
1513                 hammer_rel_inode(nip, 0);
1514                 *ap->a_vpp = NULL;
1515         } else {
1516                 error = hammer_get_vnode(nip, ap->a_vpp);
1517                 hammer_rel_inode(nip, 0);
1518                 if (error == 0) {
1519                         cache_setunresolved(ap->a_nch);
1520                         cache_setvp(ap->a_nch, *ap->a_vpp);
1521                 }
1522         }
1523         hammer_done_transaction(&trans);
1524         if (error == 0)
1525                 hammer_knote(ap->a_dvp, NOTE_WRITE | NOTE_LINK);
1526         lwkt_reltoken(&hmp->fs_token);
1527         return (error);
1528 }
1529
1530 /*
1531  * hammer_vop_nmknod { nch, dvp, vpp, cred, vap }
1532  *
1533  * The operating system has already ensured that the directory entry
1534  * does not exist and done all appropriate namespace locking.
1535  */
1536 static
1537 int
1538 hammer_vop_nmknod(struct vop_nmknod_args *ap)
1539 {
1540         struct hammer_transaction trans;
1541         struct hammer_inode *dip;
1542         struct hammer_inode *nip;
1543         struct nchandle *nch;
1544         hammer_mount_t hmp;
1545         int error;
1546
1547         nch = ap->a_nch;
1548         dip = VTOI(ap->a_dvp);
1549         hmp = dip->hmp;
1550
1551         if (dip->flags & HAMMER_INODE_RO)
1552                 return (EROFS);
1553         if ((error = hammer_checkspace(hmp, HAMMER_CHKSPC_CREATE)) != 0)
1554                 return (error);
1555
1556         /*
1557          * Create a transaction to cover the operations we perform.
1558          */
1559         lwkt_gettoken(&hmp->fs_token);
1560         hammer_start_transaction(&trans, hmp);
1561         ++hammer_stats_file_iopsw;
1562
1563         /*
1564          * Create a new filesystem object of the requested type.  The
1565          * returned inode will be referenced but not locked.
1566          *
1567          * If mknod specifies a directory a pseudo-fs is created.
1568          */
1569         error = hammer_create_inode(&trans, ap->a_vap, ap->a_cred,
1570                                     dip, nch->ncp->nc_name, nch->ncp->nc_nlen,
1571                                     NULL, &nip);
1572         if (error) {
1573                 hammer_done_transaction(&trans);
1574                 *ap->a_vpp = NULL;
1575                 lwkt_reltoken(&hmp->fs_token);
1576                 return (error);
1577         }
1578
1579         /*
1580          * Add the new filesystem object to the directory.  This will also
1581          * bump the inode's link count.
1582          */
1583         error = hammer_ip_add_directory(&trans, dip,
1584                                         nch->ncp->nc_name, nch->ncp->nc_nlen,
1585                                         nip);
1586
1587         /*
1588          * Finish up.
1589          */
1590         if (error) {
1591                 hammer_rel_inode(nip, 0);
1592                 *ap->a_vpp = NULL;
1593         } else {
1594                 error = hammer_get_vnode(nip, ap->a_vpp);
1595                 hammer_rel_inode(nip, 0);
1596                 if (error == 0) {
1597                         cache_setunresolved(ap->a_nch);
1598                         cache_setvp(ap->a_nch, *ap->a_vpp);
1599                 }
1600         }
1601         hammer_done_transaction(&trans);
1602         if (error == 0)
1603                 hammer_knote(ap->a_dvp, NOTE_WRITE);
1604         lwkt_reltoken(&hmp->fs_token);
1605         return (error);
1606 }
1607
1608 /*
1609  * hammer_vop_open { vp, mode, cred, fp }
1610  *
1611  * MPSAFE (does not require fs_token)
1612  */
1613 static
1614 int
1615 hammer_vop_open(struct vop_open_args *ap)
1616 {
1617         hammer_inode_t ip;
1618
1619         ++hammer_stats_file_iopsr;
1620         ip = VTOI(ap->a_vp);
1621
1622         if ((ap->a_mode & FWRITE) && (ip->flags & HAMMER_INODE_RO))
1623                 return (EROFS);
1624         return(vop_stdopen(ap));
1625 }
1626
1627 /*
1628  * hammer_vop_print { vp }
1629  */
1630 static
1631 int
1632 hammer_vop_print(struct vop_print_args *ap)
1633 {
1634         return EOPNOTSUPP;
1635 }
1636
1637 /*
1638  * hammer_vop_readdir { vp, uio, cred, *eofflag, *ncookies, off_t **cookies }
1639  */
1640 static
1641 int
1642 hammer_vop_readdir(struct vop_readdir_args *ap)
1643 {
1644         struct hammer_transaction trans;
1645         struct hammer_cursor cursor;
1646         struct hammer_inode *ip;
1647         hammer_mount_t hmp;
1648         struct uio *uio;
1649         hammer_base_elm_t base;
1650         int error;
1651         int cookie_index;
1652         int ncookies;
1653         off_t *cookies;
1654         off_t saveoff;
1655         int r;
1656         int dtype;
1657
1658         ++hammer_stats_file_iopsr;
1659         ip = VTOI(ap->a_vp);
1660         uio = ap->a_uio;
1661         saveoff = uio->uio_offset;
1662         hmp = ip->hmp;
1663
1664         if (ap->a_ncookies) {
1665                 ncookies = uio->uio_resid / 16 + 1;
1666                 if (ncookies > 1024)
1667                         ncookies = 1024;
1668                 cookies = kmalloc(ncookies * sizeof(off_t), M_TEMP, M_WAITOK);
1669                 cookie_index = 0;
1670         } else {
1671                 ncookies = -1;
1672                 cookies = NULL;
1673                 cookie_index = 0;
1674         }
1675
1676         lwkt_gettoken(&hmp->fs_token);
1677         hammer_simple_transaction(&trans, hmp);
1678
1679         /*
1680          * Handle artificial entries
1681          *
1682          * It should be noted that the minimum value for a directory
1683          * hash key on-media is 0x0000000100000000, so we can use anything
1684          * less then that to represent our 'special' key space.
1685          */
1686         error = 0;
1687         if (saveoff == 0) {
1688                 r = vop_write_dirent(&error, uio, ip->obj_id, DT_DIR, 1, ".");
1689                 if (r)
1690                         goto done;
1691                 if (cookies)
1692                         cookies[cookie_index] = saveoff;
1693                 ++saveoff;
1694                 ++cookie_index;
1695                 if (cookie_index == ncookies)
1696                         goto done;
1697         }
1698         if (saveoff == 1) {
1699                 if (ip->ino_data.parent_obj_id) {
1700                         r = vop_write_dirent(&error, uio,
1701                                              ip->ino_data.parent_obj_id,
1702                                              DT_DIR, 2, "..");
1703                 } else {
1704                         r = vop_write_dirent(&error, uio,
1705                                              ip->obj_id, DT_DIR, 2, "..");
1706                 }
1707                 if (r)
1708                         goto done;
1709                 if (cookies)
1710                         cookies[cookie_index] = saveoff;
1711                 ++saveoff;
1712                 ++cookie_index;
1713                 if (cookie_index == ncookies)
1714                         goto done;
1715         }
1716
1717         /*
1718          * Key range (begin and end inclusive) to scan.  Directory keys
1719          * directly translate to a 64 bit 'seek' position.
1720          */
1721         hammer_init_cursor(&trans, &cursor, &ip->cache[1], ip);
1722         cursor.key_beg.localization = ip->obj_localization +
1723                                       hammer_dir_localization(ip);
1724         cursor.key_beg.obj_id = ip->obj_id;
1725         cursor.key_beg.create_tid = 0;
1726         cursor.key_beg.delete_tid = 0;
1727         cursor.key_beg.rec_type = HAMMER_RECTYPE_DIRENTRY;
1728         cursor.key_beg.obj_type = 0;
1729         cursor.key_beg.key = saveoff;
1730
1731         cursor.key_end = cursor.key_beg;
1732         cursor.key_end.key = HAMMER_MAX_KEY;
1733         cursor.asof = ip->obj_asof;
1734         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE | HAMMER_CURSOR_ASOF;
1735
1736         error = hammer_ip_first(&cursor);
1737
1738         while (error == 0) {
1739                 error = hammer_ip_resolve_data(&cursor);
1740                 if (error)
1741                         break;
1742                 base = &cursor.leaf->base;
1743                 saveoff = base->key;
1744                 KKASSERT(cursor.leaf->data_len > HAMMER_ENTRY_NAME_OFF);
1745
1746                 if (base->obj_id != ip->obj_id)
1747                         panic("readdir: bad record at %p", cursor.node);
1748
1749                 /*
1750                  * Convert pseudo-filesystems into softlinks
1751                  */
1752                 dtype = hammer_get_dtype(cursor.leaf->base.obj_type);
1753                 r = vop_write_dirent(
1754                              &error, uio, cursor.data->entry.obj_id,
1755                              dtype,
1756                              cursor.leaf->data_len - HAMMER_ENTRY_NAME_OFF ,
1757                              (void *)cursor.data->entry.name);
1758                 if (r)
1759                         break;
1760                 ++saveoff;
1761                 if (cookies)
1762                         cookies[cookie_index] = base->key;
1763                 ++cookie_index;
1764                 if (cookie_index == ncookies)
1765                         break;
1766                 error = hammer_ip_next(&cursor);
1767         }
1768         hammer_done_cursor(&cursor);
1769
1770 done:
1771         hammer_done_transaction(&trans);
1772
1773         if (ap->a_eofflag)
1774                 *ap->a_eofflag = (error == ENOENT);
1775         uio->uio_offset = saveoff;
1776         if (error && cookie_index == 0) {
1777                 if (error == ENOENT)
1778                         error = 0;
1779                 if (cookies) {
1780                         kfree(cookies, M_TEMP);
1781                         *ap->a_ncookies = 0;
1782                         *ap->a_cookies = NULL;
1783                 }
1784         } else {
1785                 if (error == ENOENT)
1786                         error = 0;
1787                 if (cookies) {
1788                         *ap->a_ncookies = cookie_index;
1789                         *ap->a_cookies = cookies;
1790                 }
1791         }
1792         lwkt_reltoken(&hmp->fs_token);
1793         return(error);
1794 }
1795
1796 /*
1797  * hammer_vop_readlink { vp, uio, cred }
1798  */
1799 static
1800 int
1801 hammer_vop_readlink(struct vop_readlink_args *ap)
1802 {
1803         struct hammer_transaction trans;
1804         struct hammer_cursor cursor;
1805         struct hammer_inode *ip;
1806         hammer_mount_t hmp;
1807         char buf[32];
1808         u_int32_t localization;
1809         hammer_pseudofs_inmem_t pfsm;
1810         int error;
1811
1812         ip = VTOI(ap->a_vp);
1813         hmp = ip->hmp;
1814
1815         lwkt_gettoken(&hmp->fs_token);
1816
1817         /*
1818          * Shortcut if the symlink data was stuffed into ino_data.
1819          *
1820          * Also expand special "@@PFS%05d" softlinks (expansion only
1821          * occurs for non-historical (current) accesses made from the
1822          * primary filesystem).
1823          *
1824          * Note that userspace hammer command does not allow users to
1825          * create a @@PFS softlink under an existing other PFS (id!=0)
1826          * so the ip localization here for @@PFS softlink is always 0.
1827          */
1828         if (ip->ino_data.size <= HAMMER_INODE_BASESYMLEN) {
1829                 char *ptr;
1830                 int bytes;
1831
1832                 ptr = ip->ino_data.ext.symlink;
1833                 bytes = (int)ip->ino_data.size;
1834                 if (bytes == 10 &&
1835                     ip->obj_asof == HAMMER_MAX_TID &&
1836                     ip->obj_localization == 0 &&
1837                     strncmp(ptr, "@@PFS", 5) == 0) {
1838                         hammer_simple_transaction(&trans, hmp);
1839                         bcopy(ptr + 5, buf, 5);
1840                         buf[5] = 0;
1841                         localization = strtoul(buf, NULL, 10) << 16;
1842                         pfsm = hammer_load_pseudofs(&trans, localization,
1843                                                     &error);
1844                         if (error == 0) {
1845                                 if (pfsm->pfsd.mirror_flags &
1846                                     HAMMER_PFSD_SLAVE) {
1847                                         /* vap->va_size == 26 */
1848                                         ksnprintf(buf, sizeof(buf),
1849                                                   "@@0x%016llx:%05d",
1850                                                   (long long)pfsm->pfsd.sync_end_tid,
1851                                                   localization >> 16);
1852                                 } else {
1853                                         /* vap->va_size == 10 */
1854                                         ksnprintf(buf, sizeof(buf),
1855                                                   "@@-1:%05d",
1856                                                   localization >> 16);
1857 #if 0
1858                                         ksnprintf(buf, sizeof(buf),
1859                                                   "@@0x%016llx:%05d",
1860                                                   (long long)HAMMER_MAX_TID,
1861                                                   localization >> 16);
1862 #endif
1863                                 }
1864                                 ptr = buf;
1865                                 bytes = strlen(buf);
1866                         }
1867                         if (pfsm)
1868                                 hammer_rel_pseudofs(hmp, pfsm);
1869                         hammer_done_transaction(&trans);
1870                 }
1871                 error = uiomove(ptr, bytes, ap->a_uio);
1872                 lwkt_reltoken(&hmp->fs_token);
1873                 return(error);
1874         }
1875
1876         /*
1877          * Long version
1878          */
1879         hammer_simple_transaction(&trans, hmp);
1880         ++hammer_stats_file_iopsr;
1881         hammer_init_cursor(&trans, &cursor, &ip->cache[1], ip);
1882
1883         /*
1884          * Key range (begin and end inclusive) to scan.  Directory keys
1885          * directly translate to a 64 bit 'seek' position.
1886          */
1887         cursor.key_beg.localization = ip->obj_localization +
1888                                       HAMMER_LOCALIZE_MISC;
1889         cursor.key_beg.obj_id = ip->obj_id;
1890         cursor.key_beg.create_tid = 0;
1891         cursor.key_beg.delete_tid = 0;
1892         cursor.key_beg.rec_type = HAMMER_RECTYPE_FIX;
1893         cursor.key_beg.obj_type = 0;
1894         cursor.key_beg.key = HAMMER_FIXKEY_SYMLINK;
1895         cursor.asof = ip->obj_asof;
1896         cursor.flags |= HAMMER_CURSOR_ASOF;
1897
1898         error = hammer_ip_lookup(&cursor);
1899         if (error == 0) {
1900                 error = hammer_ip_resolve_data(&cursor);
1901                 if (error == 0) {
1902                         KKASSERT(cursor.leaf->data_len >=
1903                                  HAMMER_SYMLINK_NAME_OFF);
1904                         error = uiomove(cursor.data->symlink.name,
1905                                         cursor.leaf->data_len -
1906                                                 HAMMER_SYMLINK_NAME_OFF,
1907                                         ap->a_uio);
1908                 }
1909         }
1910         hammer_done_cursor(&cursor);
1911         hammer_done_transaction(&trans);
1912         lwkt_reltoken(&hmp->fs_token);
1913         return(error);
1914 }
1915
1916 /*
1917  * hammer_vop_nremove { nch, dvp, cred }
1918  */
1919 static
1920 int
1921 hammer_vop_nremove(struct vop_nremove_args *ap)
1922 {
1923         struct hammer_transaction trans;
1924         struct hammer_inode *dip;
1925         hammer_mount_t hmp;
1926         int error;
1927
1928         dip = VTOI(ap->a_dvp);
1929         hmp = dip->hmp;
1930
1931         if (hammer_nohistory(dip) == 0 &&
1932             (error = hammer_checkspace(hmp, HAMMER_CHKSPC_REMOVE)) != 0) {
1933                 return (error);
1934         }
1935
1936         lwkt_gettoken(&hmp->fs_token);
1937         hammer_start_transaction(&trans, hmp);
1938         ++hammer_stats_file_iopsw;
1939         error = hammer_dounlink(&trans, ap->a_nch, ap->a_dvp, ap->a_cred, 0, 0);
1940         hammer_done_transaction(&trans);
1941         if (error == 0)
1942                 hammer_knote(ap->a_dvp, NOTE_WRITE);
1943         lwkt_reltoken(&hmp->fs_token);
1944         return (error);
1945 }
1946
1947 /*
1948  * hammer_vop_nrename { fnch, tnch, fdvp, tdvp, cred }
1949  */
1950 static
1951 int
1952 hammer_vop_nrename(struct vop_nrename_args *ap)
1953 {
1954         struct hammer_transaction trans;
1955         struct namecache *fncp;
1956         struct namecache *tncp;
1957         struct hammer_inode *fdip;
1958         struct hammer_inode *tdip;
1959         struct hammer_inode *ip;
1960         hammer_mount_t hmp;
1961         struct hammer_cursor cursor;
1962         int64_t namekey;
1963         u_int32_t max_iterations;
1964         int nlen, error;
1965
1966         if (ap->a_fdvp->v_mount != ap->a_tdvp->v_mount)
1967                 return(EXDEV);
1968         if (ap->a_fdvp->v_mount != ap->a_fnch->ncp->nc_vp->v_mount)
1969                 return(EXDEV);
1970
1971         fdip = VTOI(ap->a_fdvp);
1972         tdip = VTOI(ap->a_tdvp);
1973         fncp = ap->a_fnch->ncp;
1974         tncp = ap->a_tnch->ncp;
1975         ip = VTOI(fncp->nc_vp);
1976         KKASSERT(ip != NULL);
1977
1978         hmp = ip->hmp;
1979
1980         if (fdip->obj_localization != tdip->obj_localization)
1981                 return(EXDEV);
1982         if (fdip->obj_localization != ip->obj_localization)
1983                 return(EXDEV);
1984
1985         if (fdip->flags & HAMMER_INODE_RO)
1986                 return (EROFS);
1987         if (tdip->flags & HAMMER_INODE_RO)
1988                 return (EROFS);
1989         if (ip->flags & HAMMER_INODE_RO)
1990                 return (EROFS);
1991         if ((error = hammer_checkspace(hmp, HAMMER_CHKSPC_CREATE)) != 0)
1992                 return (error);
1993
1994         lwkt_gettoken(&hmp->fs_token);
1995         hammer_start_transaction(&trans, hmp);
1996         ++hammer_stats_file_iopsw;
1997
1998         /*
1999          * Remove tncp from the target directory and then link ip as
2000          * tncp. XXX pass trans to dounlink
2001          *
2002          * Force the inode sync-time to match the transaction so it is
2003          * in-sync with the creation of the target directory entry.
2004          */
2005         error = hammer_dounlink(&trans, ap->a_tnch, ap->a_tdvp,
2006                                 ap->a_cred, 0, -1);
2007         if (error == 0 || error == ENOENT) {
2008                 error = hammer_ip_add_directory(&trans, tdip,
2009                                                 tncp->nc_name, tncp->nc_nlen,
2010                                                 ip);
2011                 if (error == 0) {
2012                         ip->ino_data.parent_obj_id = tdip->obj_id;
2013                         ip->ino_data.ctime = trans.time;
2014                         hammer_modify_inode(&trans, ip, HAMMER_INODE_DDIRTY);
2015                 }
2016         }
2017         if (error)
2018                 goto failed; /* XXX */
2019
2020         /*
2021          * Locate the record in the originating directory and remove it.
2022          *
2023          * Calculate the namekey and setup the key range for the scan.  This
2024          * works kinda like a chained hash table where the lower 32 bits
2025          * of the namekey synthesize the chain.
2026          *
2027          * The key range is inclusive of both key_beg and key_end.
2028          */
2029         namekey = hammer_directory_namekey(fdip, fncp->nc_name, fncp->nc_nlen,
2030                                            &max_iterations);
2031 retry:
2032         hammer_init_cursor(&trans, &cursor, &fdip->cache[1], fdip);
2033         cursor.key_beg.localization = fdip->obj_localization +
2034                                       hammer_dir_localization(fdip);
2035         cursor.key_beg.obj_id = fdip->obj_id;
2036         cursor.key_beg.key = namekey;
2037         cursor.key_beg.create_tid = 0;
2038         cursor.key_beg.delete_tid = 0;
2039         cursor.key_beg.rec_type = HAMMER_RECTYPE_DIRENTRY;
2040         cursor.key_beg.obj_type = 0;
2041
2042         cursor.key_end = cursor.key_beg;
2043         cursor.key_end.key += max_iterations;
2044         cursor.asof = fdip->obj_asof;
2045         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE | HAMMER_CURSOR_ASOF;
2046
2047         /*
2048          * Scan all matching records (the chain), locate the one matching
2049          * the requested path component.
2050          *
2051          * The hammer_ip_*() functions merge in-memory records with on-disk
2052          * records for the purposes of the search.
2053          */
2054         error = hammer_ip_first(&cursor);
2055         while (error == 0) {
2056                 if (hammer_ip_resolve_data(&cursor) != 0)
2057                         break;
2058                 nlen = cursor.leaf->data_len - HAMMER_ENTRY_NAME_OFF;
2059                 KKASSERT(nlen > 0);
2060                 if (fncp->nc_nlen == nlen &&
2061                     bcmp(fncp->nc_name, cursor.data->entry.name, nlen) == 0) {
2062                         break;
2063                 }
2064                 error = hammer_ip_next(&cursor);
2065         }
2066
2067         /*
2068          * If all is ok we have to get the inode so we can adjust nlinks.
2069          *
2070          * WARNING: hammer_ip_del_directory() may have to terminate the
2071          * cursor to avoid a recursion.  It's ok to call hammer_done_cursor()
2072          * twice.
2073          */
2074         if (error == 0)
2075                 error = hammer_ip_del_directory(&trans, &cursor, fdip, ip);
2076
2077         /*
2078          * XXX A deadlock here will break rename's atomicy for the purposes
2079          * of crash recovery.
2080          */
2081         if (error == EDEADLK) {
2082                 hammer_done_cursor(&cursor);
2083                 goto retry;
2084         }
2085
2086         /*
2087          * Cleanup and tell the kernel that the rename succeeded.
2088          *
2089          * NOTE: ip->vp, if non-NULL, cannot be directly referenced
2090          *       without formally acquiring the vp since the vp might
2091          *       have zero refs on it, or in the middle of a reclaim,
2092          *       etc.
2093          */
2094         hammer_done_cursor(&cursor);
2095         if (error == 0) {
2096                 cache_rename(ap->a_fnch, ap->a_tnch);
2097                 hammer_knote(ap->a_fdvp, NOTE_WRITE);
2098                 hammer_knote(ap->a_tdvp, NOTE_WRITE);
2099                 while (ip->vp) {
2100                         struct vnode *vp;
2101
2102                         error = hammer_get_vnode(ip, &vp);
2103                         if (error == 0 && vp) {
2104                                 vn_unlock(vp);
2105                                 hammer_knote(ip->vp, NOTE_RENAME);
2106                                 vrele(vp);
2107                                 break;
2108                         }
2109                         kprintf("Debug: HAMMER ip/vp race2 avoided\n");
2110                 }
2111         }
2112
2113 failed:
2114         hammer_done_transaction(&trans);
2115         lwkt_reltoken(&hmp->fs_token);
2116         return (error);
2117 }
2118
2119 /*
2120  * hammer_vop_nrmdir { nch, dvp, cred }
2121  */
2122 static
2123 int
2124 hammer_vop_nrmdir(struct vop_nrmdir_args *ap)
2125 {
2126         struct hammer_transaction trans;
2127         struct hammer_inode *dip;
2128         hammer_mount_t hmp;
2129         int error;
2130
2131         dip = VTOI(ap->a_dvp);
2132         hmp = dip->hmp;
2133
2134         if (hammer_nohistory(dip) == 0 &&
2135             (error = hammer_checkspace(hmp, HAMMER_CHKSPC_REMOVE)) != 0) {
2136                 return (error);
2137         }
2138
2139         lwkt_gettoken(&hmp->fs_token);
2140         hammer_start_transaction(&trans, hmp);
2141         ++hammer_stats_file_iopsw;
2142         error = hammer_dounlink(&trans, ap->a_nch, ap->a_dvp, ap->a_cred, 0, 1);
2143         hammer_done_transaction(&trans);
2144         if (error == 0)
2145                 hammer_knote(ap->a_dvp, NOTE_WRITE | NOTE_LINK);
2146         lwkt_reltoken(&hmp->fs_token);
2147         return (error);
2148 }
2149
2150 /*
2151  * hammer_vop_markatime { vp, cred }
2152  */
2153 static
2154 int
2155 hammer_vop_markatime(struct vop_markatime_args *ap)
2156 {
2157         struct hammer_transaction trans;
2158         struct hammer_inode *ip;
2159         hammer_mount_t hmp;
2160
2161         ip = VTOI(ap->a_vp);
2162         if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
2163                 return (EROFS);
2164         if (ip->flags & HAMMER_INODE_RO)
2165                 return (EROFS);
2166         hmp = ip->hmp;
2167         if (hmp->mp->mnt_flag & MNT_NOATIME)
2168                 return (0);
2169         lwkt_gettoken(&hmp->fs_token);
2170         hammer_start_transaction(&trans, hmp);
2171         ++hammer_stats_file_iopsw;
2172
2173         ip->ino_data.atime = trans.time;
2174         hammer_modify_inode(&trans, ip, HAMMER_INODE_ATIME);
2175         hammer_done_transaction(&trans);
2176         hammer_knote(ap->a_vp, NOTE_ATTRIB);
2177         lwkt_reltoken(&hmp->fs_token);
2178         return (0);
2179 }
2180
2181 /*
2182  * hammer_vop_setattr { vp, vap, cred }
2183  */
2184 static
2185 int
2186 hammer_vop_setattr(struct vop_setattr_args *ap)
2187 {
2188         struct hammer_transaction trans;
2189         struct hammer_inode *ip;
2190         struct vattr *vap;
2191         hammer_mount_t hmp;
2192         int modflags;
2193         int error;
2194         int truncating;
2195         int blksize;
2196         int kflags;
2197 #if 0
2198         int64_t aligned_size;
2199 #endif
2200         u_int32_t flags;
2201
2202         vap = ap->a_vap;
2203         ip = ap->a_vp->v_data;
2204         modflags = 0;
2205         kflags = 0;
2206         hmp = ip->hmp;
2207
2208         if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
2209                 return(EROFS);
2210         if (ip->flags & HAMMER_INODE_RO)
2211                 return (EROFS);
2212         if (hammer_nohistory(ip) == 0 &&
2213             (error = hammer_checkspace(hmp, HAMMER_CHKSPC_REMOVE)) != 0) {
2214                 return (error);
2215         }
2216
2217         lwkt_gettoken(&hmp->fs_token);
2218         hammer_start_transaction(&trans, hmp);
2219         ++hammer_stats_file_iopsw;
2220         error = 0;
2221
2222         if (vap->va_flags != VNOVAL) {
2223                 flags = ip->ino_data.uflags;
2224                 error = vop_helper_setattr_flags(&flags, vap->va_flags,
2225                                          hammer_to_unix_xid(&ip->ino_data.uid),
2226                                          ap->a_cred);
2227                 if (error == 0) {
2228                         if (ip->ino_data.uflags != flags) {
2229                                 ip->ino_data.uflags = flags;
2230                                 ip->ino_data.ctime = trans.time;
2231                                 modflags |= HAMMER_INODE_DDIRTY;
2232                                 kflags |= NOTE_ATTRIB;
2233                         }
2234                         if (ip->ino_data.uflags & (IMMUTABLE | APPEND)) {
2235                                 error = 0;
2236                                 goto done;
2237                         }
2238                 }
2239                 goto done;
2240         }
2241         if (ip->ino_data.uflags & (IMMUTABLE | APPEND)) {
2242                 error = EPERM;
2243                 goto done;
2244         }
2245         if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
2246                 mode_t cur_mode = ip->ino_data.mode;
2247                 uid_t cur_uid = hammer_to_unix_xid(&ip->ino_data.uid);
2248                 gid_t cur_gid = hammer_to_unix_xid(&ip->ino_data.gid);
2249                 uuid_t uuid_uid;
2250                 uuid_t uuid_gid;
2251
2252                 error = vop_helper_chown(ap->a_vp, vap->va_uid, vap->va_gid,
2253                                          ap->a_cred,
2254                                          &cur_uid, &cur_gid, &cur_mode);
2255                 if (error == 0) {
2256                         hammer_guid_to_uuid(&uuid_uid, cur_uid);
2257                         hammer_guid_to_uuid(&uuid_gid, cur_gid);
2258                         if (bcmp(&uuid_uid, &ip->ino_data.uid,
2259                                  sizeof(uuid_uid)) ||
2260                             bcmp(&uuid_gid, &ip->ino_data.gid,
2261                                  sizeof(uuid_gid)) ||
2262                             ip->ino_data.mode != cur_mode
2263                         ) {
2264                                 ip->ino_data.uid = uuid_uid;
2265                                 ip->ino_data.gid = uuid_gid;
2266                                 ip->ino_data.mode = cur_mode;
2267                                 ip->ino_data.ctime = trans.time;
2268                                 modflags |= HAMMER_INODE_DDIRTY;
2269                         }
2270                         kflags |= NOTE_ATTRIB;
2271                 }
2272         }
2273         while (vap->va_size != VNOVAL && ip->ino_data.size != vap->va_size) {
2274                 switch(ap->a_vp->v_type) {
2275                 case VREG:
2276                         if (vap->va_size == ip->ino_data.size)
2277                                 break;
2278
2279                         /*
2280                          * Log the operation if in fast-fsync mode or if
2281                          * there are unterminated redo write records present.
2282                          *
2283                          * The second check is needed so the recovery code
2284                          * properly truncates write redos even if nominal
2285                          * REDO operations is turned off due to excessive
2286                          * writes, because the related records might be
2287                          * destroyed and never lay down a TERM_WRITE.
2288                          */
2289                         if ((ip->flags & HAMMER_INODE_REDO) ||
2290                             (ip->flags & HAMMER_INODE_RDIRTY)) {
2291                                 error = hammer_generate_redo(&trans, ip,
2292                                                              vap->va_size,
2293                                                              HAMMER_REDO_TRUNC,
2294                                                              NULL, 0);
2295                         }
2296                         blksize = hammer_blocksize(vap->va_size);
2297
2298                         /*
2299                          * XXX break atomicy, we can deadlock the backend
2300                          * if we do not release the lock.  Probably not a
2301                          * big deal here.
2302                          */
2303                         if (vap->va_size < ip->ino_data.size) {
2304                                 nvtruncbuf(ap->a_vp, vap->va_size,
2305                                            blksize,
2306                                            hammer_blockoff(vap->va_size),
2307                                            0);
2308                                 truncating = 1;
2309                                 kflags |= NOTE_WRITE;
2310                         } else {
2311                                 nvextendbuf(ap->a_vp,
2312                                             ip->ino_data.size,
2313                                             vap->va_size,
2314                                             hammer_blocksize(ip->ino_data.size),
2315                                             hammer_blocksize(vap->va_size),
2316                                             hammer_blockoff(ip->ino_data.size),
2317                                             hammer_blockoff(vap->va_size),
2318                                             0);
2319                                 truncating = 0;
2320                                 kflags |= NOTE_WRITE | NOTE_EXTEND;
2321                         }
2322                         ip->ino_data.size = vap->va_size;
2323                         ip->ino_data.mtime = trans.time;
2324                         /* XXX safe to use SDIRTY instead of DDIRTY here? */
2325                         modflags |= HAMMER_INODE_MTIME | HAMMER_INODE_DDIRTY;
2326
2327                         /*
2328                          * On-media truncation is cached in the inode until
2329                          * the inode is synchronized.  We must immediately
2330                          * handle any frontend records.
2331                          */
2332                         if (truncating) {
2333                                 hammer_ip_frontend_trunc(ip, vap->va_size);
2334 #ifdef DEBUG_TRUNCATE
2335                                 if (HammerTruncIp == NULL)
2336                                         HammerTruncIp = ip;
2337 #endif
2338                                 if ((ip->flags & HAMMER_INODE_TRUNCATED) == 0) {
2339                                         ip->flags |= HAMMER_INODE_TRUNCATED;
2340                                         ip->trunc_off = vap->va_size;
2341                                         hammer_inode_dirty(ip);
2342 #ifdef DEBUG_TRUNCATE
2343                                         if (ip == HammerTruncIp)
2344                                         kprintf("truncate1 %016llx\n",
2345                                                 (long long)ip->trunc_off);
2346 #endif
2347                                 } else if (ip->trunc_off > vap->va_size) {
2348                                         ip->trunc_off = vap->va_size;
2349 #ifdef DEBUG_TRUNCATE
2350                                         if (ip == HammerTruncIp)
2351                                         kprintf("truncate2 %016llx\n",
2352                                                 (long long)ip->trunc_off);
2353 #endif
2354                                 } else {
2355 #ifdef DEBUG_TRUNCATE
2356                                         if (ip == HammerTruncIp)
2357                                         kprintf("truncate3 %016llx (ignored)\n",
2358                                                 (long long)vap->va_size);
2359 #endif
2360                                 }
2361                         }
2362
2363 #if 0
2364                         /*
2365                          * When truncating, nvtruncbuf() may have cleaned out
2366                          * a portion of the last block on-disk in the buffer
2367                          * cache.  We must clean out any frontend records
2368                          * for blocks beyond the new last block.
2369                          */
2370                         aligned_size = (vap->va_size + (blksize - 1)) &
2371                                        ~(int64_t)(blksize - 1);
2372                         if (truncating && vap->va_size < aligned_size) {
2373                                 aligned_size -= blksize;
2374                                 hammer_ip_frontend_trunc(ip, aligned_size);
2375                         }
2376 #endif
2377                         break;
2378                 case VDATABASE:
2379                         if ((ip->flags & HAMMER_INODE_TRUNCATED) == 0) {
2380                                 ip->flags |= HAMMER_INODE_TRUNCATED;
2381                                 ip->trunc_off = vap->va_size;
2382                                 hammer_inode_dirty(ip);
2383                         } else if (ip->trunc_off > vap->va_size) {
2384                                 ip->trunc_off = vap->va_size;
2385                         }
2386                         hammer_ip_frontend_trunc(ip, vap->va_size);
2387                         ip->ino_data.size = vap->va_size;
2388                         ip->ino_data.mtime = trans.time;
2389                         modflags |= HAMMER_INODE_MTIME | HAMMER_INODE_DDIRTY;
2390                         kflags |= NOTE_ATTRIB;
2391                         break;
2392                 default:
2393                         error = EINVAL;
2394                         goto done;
2395                 }
2396                 break;
2397         }
2398         if (vap->va_atime.tv_sec != VNOVAL) {
2399                 ip->ino_data.atime = hammer_timespec_to_time(&vap->va_atime);
2400                 modflags |= HAMMER_INODE_ATIME;
2401                 kflags |= NOTE_ATTRIB;
2402         }
2403         if (vap->va_mtime.tv_sec != VNOVAL) {
2404                 ip->ino_data.mtime = hammer_timespec_to_time(&vap->va_mtime);
2405                 modflags |= HAMMER_INODE_MTIME;
2406                 kflags |= NOTE_ATTRIB;
2407         }
2408         if (vap->va_mode != (mode_t)VNOVAL) {
2409                 mode_t   cur_mode = ip->ino_data.mode;
2410                 uid_t cur_uid = hammer_to_unix_xid(&ip->ino_data.uid);
2411                 gid_t cur_gid = hammer_to_unix_xid(&ip->ino_data.gid);
2412
2413                 error = vop_helper_chmod(ap->a_vp, vap->va_mode, ap->a_cred,
2414                                          cur_uid, cur_gid, &cur_mode);
2415                 if (error == 0 && ip->ino_data.mode != cur_mode) {
2416                         ip->ino_data.mode = cur_mode;
2417                         ip->ino_data.ctime = trans.time;
2418                         modflags |= HAMMER_INODE_DDIRTY;
2419                         kflags |= NOTE_ATTRIB;
2420                 }
2421         }
2422 done:
2423         if (error == 0)
2424                 hammer_modify_inode(&trans, ip, modflags);
2425         hammer_done_transaction(&trans);
2426         hammer_knote(ap->a_vp, kflags);
2427         lwkt_reltoken(&hmp->fs_token);
2428         return (error);
2429 }
2430
2431 /*
2432  * hammer_vop_nsymlink { nch, dvp, vpp, cred, vap, target }
2433  */
2434 static
2435 int
2436 hammer_vop_nsymlink(struct vop_nsymlink_args *ap)
2437 {
2438         struct hammer_transaction trans;
2439         struct hammer_inode *dip;
2440         struct hammer_inode *nip;
2441         hammer_record_t record;
2442         struct nchandle *nch;
2443         hammer_mount_t hmp;
2444         int error;
2445         int bytes;
2446
2447         ap->a_vap->va_type = VLNK;
2448
2449         nch = ap->a_nch;
2450         dip = VTOI(ap->a_dvp);
2451         hmp = dip->hmp;
2452
2453         if (dip->flags & HAMMER_INODE_RO)
2454                 return (EROFS);
2455         if ((error = hammer_checkspace(hmp, HAMMER_CHKSPC_CREATE)) != 0)
2456                 return (error);
2457
2458         /*
2459          * Create a transaction to cover the operations we perform.
2460          */
2461         lwkt_gettoken(&hmp->fs_token);
2462         hammer_start_transaction(&trans, hmp);
2463         ++hammer_stats_file_iopsw;
2464
2465         /*
2466          * Create a new filesystem object of the requested type.  The
2467          * returned inode will be referenced but not locked.
2468          */
2469
2470         error = hammer_create_inode(&trans, ap->a_vap, ap->a_cred,
2471                                     dip, nch->ncp->nc_name, nch->ncp->nc_nlen,
2472                                     NULL, &nip);
2473         if (error) {
2474                 hammer_done_transaction(&trans);
2475                 *ap->a_vpp = NULL;
2476                 lwkt_reltoken(&hmp->fs_token);
2477                 return (error);
2478         }
2479
2480         /*
2481          * Add a record representing the symlink.  symlink stores the link
2482          * as pure data, not a string, and is no \0 terminated.
2483          */
2484         if (error == 0) {
2485                 bytes = strlen(ap->a_target);
2486
2487                 if (bytes <= HAMMER_INODE_BASESYMLEN) {
2488                         bcopy(ap->a_target, nip->ino_data.ext.symlink, bytes);
2489                 } else {
2490                         record = hammer_alloc_mem_record(nip, bytes);
2491                         record->type = HAMMER_MEM_RECORD_GENERAL;
2492
2493                         record->leaf.base.localization = nip->obj_localization +
2494                                                          HAMMER_LOCALIZE_MISC;
2495                         record->leaf.base.key = HAMMER_FIXKEY_SYMLINK;
2496                         record->leaf.base.rec_type = HAMMER_RECTYPE_FIX;
2497                         record->leaf.data_len = bytes;
2498                         KKASSERT(HAMMER_SYMLINK_NAME_OFF == 0);
2499                         bcopy(ap->a_target, record->data->symlink.name, bytes);
2500                         error = hammer_ip_add_record(&trans, record);
2501                 }
2502
2503                 /*
2504                  * Set the file size to the length of the link.
2505                  */
2506                 if (error == 0) {
2507                         nip->ino_data.size = bytes;
2508                         hammer_modify_inode(&trans, nip, HAMMER_INODE_DDIRTY);
2509                 }
2510         }
2511         if (error == 0)
2512                 error = hammer_ip_add_directory(&trans, dip, nch->ncp->nc_name,
2513                                                 nch->ncp->nc_nlen, nip);
2514
2515         /*
2516          * Finish up.
2517          */
2518         if (error) {
2519                 hammer_rel_inode(nip, 0);
2520                 *ap->a_vpp = NULL;
2521         } else {
2522                 error = hammer_get_vnode(nip, ap->a_vpp);
2523                 hammer_rel_inode(nip, 0);
2524                 if (error == 0) {
2525                         cache_setunresolved(ap->a_nch);
2526                         cache_setvp(ap->a_nch, *ap->a_vpp);
2527                         hammer_knote(ap->a_dvp, NOTE_WRITE);
2528                 }
2529         }
2530         hammer_done_transaction(&trans);
2531         lwkt_reltoken(&hmp->fs_token);
2532         return (error);
2533 }
2534
2535 /*
2536  * hammer_vop_nwhiteout { nch, dvp, cred, flags }
2537  */
2538 static
2539 int
2540 hammer_vop_nwhiteout(struct vop_nwhiteout_args *ap)
2541 {
2542         struct hammer_transaction trans;
2543         struct hammer_inode *dip;
2544         hammer_mount_t hmp;
2545         int error;
2546
2547         dip = VTOI(ap->a_dvp);
2548         hmp = dip->hmp;
2549
2550         if (hammer_nohistory(dip) == 0 &&
2551             (error = hammer_checkspace(hmp, HAMMER_CHKSPC_CREATE)) != 0) {
2552                 return (error);
2553         }
2554
2555         lwkt_gettoken(&hmp->fs_token);
2556         hammer_start_transaction(&trans, hmp);
2557         ++hammer_stats_file_iopsw;
2558         error = hammer_dounlink(&trans, ap->a_nch, ap->a_dvp,
2559                                 ap->a_cred, ap->a_flags, -1);
2560         hammer_done_transaction(&trans);
2561         lwkt_reltoken(&hmp->fs_token);
2562
2563         return (error);
2564 }
2565
2566 /*
2567  * hammer_vop_ioctl { vp, command, data, fflag, cred }
2568  */
2569 static
2570 int
2571 hammer_vop_ioctl(struct vop_ioctl_args *ap)
2572 {
2573         struct hammer_inode *ip = ap->a_vp->v_data;
2574         hammer_mount_t hmp = ip->hmp;
2575         int error;
2576
2577         ++hammer_stats_file_iopsr;
2578         lwkt_gettoken(&hmp->fs_token);
2579         error = hammer_ioctl(ip, ap->a_command, ap->a_data,
2580                              ap->a_fflag, ap->a_cred);
2581         lwkt_reltoken(&hmp->fs_token);
2582         return (error);
2583 }
2584
2585 static
2586 int
2587 hammer_vop_mountctl(struct vop_mountctl_args *ap)
2588 {
2589         static const struct mountctl_opt extraopt[] = {
2590                 { HMNT_NOHISTORY,       "nohistory" },
2591                 { HMNT_MASTERID,        "master" },
2592                 { 0, NULL}
2593
2594         };
2595         struct hammer_mount *hmp;
2596         struct mount *mp;
2597         int usedbytes;
2598         int error;
2599
2600         error = 0;
2601         usedbytes = 0;
2602         mp = ap->a_head.a_ops->head.vv_mount;
2603         KKASSERT(mp->mnt_data != NULL);
2604         hmp = (struct hammer_mount *)mp->mnt_data;
2605
2606         lwkt_gettoken(&hmp->fs_token);
2607
2608         switch(ap->a_op) {
2609         case MOUNTCTL_SET_EXPORT:
2610                 if (ap->a_ctllen != sizeof(struct export_args))
2611                         error = EINVAL;
2612                 else
2613                         error = hammer_vfs_export(mp, ap->a_op,
2614                                       (const struct export_args *)ap->a_ctl);
2615                 break;
2616         case MOUNTCTL_MOUNTFLAGS:
2617         {
2618                 /*
2619                  * Call standard mountctl VOP function
2620                  * so we get user mount flags.
2621                  */
2622                 error = vop_stdmountctl(ap);
2623                 if (error)
2624                         break;
2625
2626                 usedbytes = *ap->a_res;
2627
2628                 if (usedbytes > 0 && usedbytes < ap->a_buflen) {
2629                         usedbytes += vfs_flagstostr(hmp->hflags, extraopt,
2630                                                     ap->a_buf,
2631                                                     ap->a_buflen - usedbytes,
2632                                                     &error);
2633                 }
2634
2635                 *ap->a_res += usedbytes;
2636                 break;
2637         }
2638         default:
2639                 error = vop_stdmountctl(ap);
2640                 break;
2641         }
2642         lwkt_reltoken(&hmp->fs_token);
2643         return(error);
2644 }
2645
2646 /*
2647  * hammer_vop_strategy { vp, bio }
2648  *
2649  * Strategy call, used for regular file read & write only.  Note that the
2650  * bp may represent a cluster.
2651  *
2652  * To simplify operation and allow better optimizations in the future,
2653  * this code does not make any assumptions with regards to buffer alignment
2654  * or size.
2655  */
2656 static
2657 int
2658 hammer_vop_strategy(struct vop_strategy_args *ap)
2659 {
2660         struct buf *bp;
2661         int error;
2662
2663         bp = ap->a_bio->bio_buf;
2664
2665         switch(bp->b_cmd) {
2666         case BUF_CMD_READ:
2667                 error = hammer_vop_strategy_read(ap);
2668                 break;
2669         case BUF_CMD_WRITE:
2670                 error = hammer_vop_strategy_write(ap);
2671                 break;
2672         default:
2673                 bp->b_error = error = EINVAL;
2674                 bp->b_flags |= B_ERROR;
2675                 biodone(ap->a_bio);
2676                 break;
2677         }
2678
2679         /* hammer_dump_dedup_cache(((hammer_inode_t)ap->a_vp->v_data)->hmp); */
2680
2681         return (error);
2682 }
2683
2684 /*
2685  * Read from a regular file.  Iterate the related records and fill in the
2686  * BIO/BUF.  Gaps are zero-filled.
2687  *
2688  * The support code in hammer_object.c should be used to deal with mixed
2689  * in-memory and on-disk records.
2690  *
2691  * NOTE: Can be called from the cluster code with an oversized buf.
2692  *
2693  * XXX atime update
2694  */
2695 static
2696 int
2697 hammer_vop_strategy_read(struct vop_strategy_args *ap)
2698 {
2699         struct hammer_transaction trans;
2700         struct hammer_inode *ip;
2701         struct hammer_inode *dip;
2702         hammer_mount_t hmp;
2703         struct hammer_cursor cursor;
2704         hammer_base_elm_t base;
2705         hammer_off_t disk_offset;
2706         struct bio *bio;
2707         struct bio *nbio;
2708         struct buf *bp;
2709         int64_t rec_offset;
2710         int64_t ran_end;
2711         int64_t tmp64;
2712         int error;
2713         int boff;
2714         int roff;
2715         int n;
2716         int isdedupable;
2717
2718         bio = ap->a_bio;
2719         bp = bio->bio_buf;
2720         ip = ap->a_vp->v_data;
2721         hmp = ip->hmp;
2722
2723         /*
2724          * The zone-2 disk offset may have been set by the cluster code via
2725          * a BMAP operation, or else should be NOOFFSET.
2726          *
2727          * Checking the high bits for a match against zone-2 should suffice.
2728          *
2729          * In cases where a lot of data duplication is present it may be
2730          * more beneficial to drop through and doubule-buffer through the
2731          * device.
2732          */
2733         nbio = push_bio(bio);
2734         if ((nbio->bio_offset & HAMMER_OFF_ZONE_MASK) ==
2735             HAMMER_ZONE_LARGE_DATA) {
2736                 if (hammer_double_buffer == 0) {
2737                         lwkt_gettoken(&hmp->fs_token);
2738                         error = hammer_io_direct_read(hmp, nbio, NULL);
2739                         lwkt_reltoken(&hmp->fs_token);
2740                         return (error);
2741                 }
2742
2743                 /*
2744                  * Try to shortcut requests for double_buffer mode too.
2745                  * Since this mode runs through the device buffer cache
2746                  * only compatible buffer sizes (meaning those generated
2747                  * by normal filesystem buffers) are legal.
2748                  */
2749                 if (hammer_live_dedup == 0 && (bp->b_flags & B_PAGING) == 0) {
2750                         lwkt_gettoken(&hmp->fs_token);
2751                         error = hammer_io_indirect_read(hmp, nbio, NULL);
2752                         lwkt_reltoken(&hmp->fs_token);
2753                         return (error);
2754                 }
2755         }
2756
2757         /*
2758          * Well, that sucked.  Do it the hard way.  If all the stars are
2759          * aligned we may still be able to issue a direct-read.
2760          */
2761         lwkt_gettoken(&hmp->fs_token);
2762         hammer_simple_transaction(&trans, hmp);
2763         hammer_init_cursor(&trans, &cursor, &ip->cache[1], ip);
2764
2765         /*
2766          * Key range (begin and end inclusive) to scan.  Note that the key's
2767          * stored in the actual records represent BASE+LEN, not BASE.  The
2768          * first record containing bio_offset will have a key > bio_offset.
2769          */
2770         cursor.key_beg.localization = ip->obj_localization +
2771                                       HAMMER_LOCALIZE_MISC;
2772         cursor.key_beg.obj_id = ip->obj_id;
2773         cursor.key_beg.create_tid = 0;
2774         cursor.key_beg.delete_tid = 0;
2775         cursor.key_beg.obj_type = 0;
2776         cursor.key_beg.key = bio->bio_offset + 1;
2777         cursor.asof = ip->obj_asof;
2778         cursor.flags |= HAMMER_CURSOR_ASOF;
2779
2780         cursor.key_end = cursor.key_beg;
2781         KKASSERT(ip->ino_data.obj_type == HAMMER_OBJTYPE_REGFILE);
2782 #if 0
2783         if (ip->ino_data.obj_type == HAMMER_OBJTYPE_DBFILE) {
2784                 cursor.key_beg.rec_type = HAMMER_RECTYPE_DB;
2785                 cursor.key_end.rec_type = HAMMER_RECTYPE_DB;
2786                 cursor.key_end.key = 0x7FFFFFFFFFFFFFFFLL;
2787         } else
2788 #endif
2789         {
2790                 ran_end = bio->bio_offset + bp->b_bufsize;
2791                 cursor.key_beg.rec_type = HAMMER_RECTYPE_DATA;
2792                 cursor.key_end.rec_type = HAMMER_RECTYPE_DATA;
2793                 tmp64 = ran_end + MAXPHYS + 1;  /* work-around GCC-4 bug */
2794                 if (tmp64 < ran_end)
2795                         cursor.key_end.key = 0x7FFFFFFFFFFFFFFFLL;
2796                 else
2797                         cursor.key_end.key = ran_end + MAXPHYS + 1;
2798         }
2799         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE;
2800
2801         /*
2802          * Set NOSWAPCACHE for cursor data extraction if double buffering
2803          * is disabled or (if the file is not marked cacheable via chflags
2804          * and vm.swapcache_use_chflags is enabled).
2805          */
2806         if (hammer_double_buffer == 0 ||
2807             ((ap->a_vp->v_flag & VSWAPCACHE) == 0 &&
2808              vm_swapcache_use_chflags)) {
2809                 cursor.flags |= HAMMER_CURSOR_NOSWAPCACHE;
2810         }
2811
2812         error = hammer_ip_first(&cursor);
2813         boff = 0;
2814
2815         while (error == 0) {
2816                 /*
2817                  * Get the base file offset of the record.  The key for
2818                  * data records is (base + bytes) rather then (base).
2819                  */
2820                 base = &cursor.leaf->base;
2821                 rec_offset = base->key - cursor.leaf->data_len;
2822
2823                 /*
2824                  * Calculate the gap, if any, and zero-fill it.
2825                  *
2826                  * n is the offset of the start of the record verses our
2827                  * current seek offset in the bio.
2828                  */
2829                 n = (int)(rec_offset - (bio->bio_offset + boff));
2830                 if (n > 0) {
2831                         if (n > bp->b_bufsize - boff)
2832                                 n = bp->b_bufsize - boff;
2833                         bzero((char *)bp->b_data + boff, n);
2834                         boff += n;
2835                         n = 0;
2836                 }
2837
2838                 /*
2839                  * Calculate the data offset in the record and the number
2840                  * of bytes we can copy.
2841                  *
2842                  * There are two degenerate cases.  First, boff may already
2843                  * be at bp->b_bufsize.  Secondly, the data offset within
2844                  * the record may exceed the record's size.
2845                  */
2846                 roff = -n;
2847                 rec_offset += roff;
2848                 n = cursor.leaf->data_len - roff;
2849                 if (n <= 0) {
2850                         kprintf("strategy_read: bad n=%d roff=%d\n", n, roff);
2851                         n = 0;
2852                 } else if (n > bp->b_bufsize - boff) {
2853                         n = bp->b_bufsize - boff;
2854                 }
2855
2856                 /*
2857                  * Deal with cached truncations.  This cool bit of code
2858                  * allows truncate()/ftruncate() to avoid having to sync
2859                  * the file.
2860                  *
2861                  * If the frontend is truncated then all backend records are
2862                  * subject to the frontend's truncation.
2863                  *
2864                  * If the backend is truncated then backend records on-disk
2865                  * (but not in-memory) are subject to the backend's
2866                  * truncation.  In-memory records owned by the backend
2867                  * represent data written after the truncation point on the
2868                  * backend and must not be truncated.
2869                  *
2870                  * Truncate operations deal with frontend buffer cache
2871                  * buffers and frontend-owned in-memory records synchronously.
2872                  */
2873                 if (ip->flags & HAMMER_INODE_TRUNCATED) {
2874                         if (hammer_cursor_ondisk(&cursor)/* ||
2875                             cursor.iprec->flush_state == HAMMER_FST_FLUSH*/) {
2876                                 if (ip->trunc_off <= rec_offset)
2877                                         n = 0;
2878                                 else if (ip->trunc_off < rec_offset + n)
2879                                         n = (int)(ip->trunc_off - rec_offset);
2880                         }
2881                 }
2882                 if (ip->sync_flags & HAMMER_INODE_TRUNCATED) {
2883                         if (hammer_cursor_ondisk(&cursor)) {
2884                                 if (ip->sync_trunc_off <= rec_offset)
2885                                         n = 0;
2886                                 else if (ip->sync_trunc_off < rec_offset + n)
2887                                         n = (int)(ip->sync_trunc_off - rec_offset);
2888                         }
2889                 }
2890
2891                 /*
2892                  * Try to issue a direct read into our bio if possible,
2893                  * otherwise resolve the element data into a hammer_buffer
2894                  * and copy.
2895                  *
2896                  * The buffer on-disk should be zerod past any real
2897                  * truncation point, but may not be for any synthesized
2898                  * truncation point from above.
2899                  *
2900                  * NOTE: disk_offset is only valid if the cursor data is
2901                  *       on-disk.
2902                  */
2903                 disk_offset = cursor.leaf->data_offset + roff;
2904                 isdedupable = (boff == 0 && n == bp->b_bufsize &&
2905                                hammer_cursor_ondisk(&cursor) &&
2906                                ((int)disk_offset & HAMMER_BUFMASK) == 0);
2907
2908                 if (isdedupable && hammer_double_buffer == 0) {
2909                         /*
2910                          * Direct read case
2911                          */
2912                         KKASSERT((disk_offset & HAMMER_OFF_ZONE_MASK) ==
2913                                  HAMMER_ZONE_LARGE_DATA);
2914                         nbio->bio_offset = disk_offset;
2915                         error = hammer_io_direct_read(hmp, nbio, cursor.leaf);
2916                         if (hammer_live_dedup && error == 0)
2917                                 hammer_dedup_cache_add(ip, cursor.leaf);
2918                         goto done;
2919                 } else if (isdedupable) {
2920                         /*
2921                          * Async I/O case for reading from backing store
2922                          * and copying the data to the filesystem buffer.
2923                          * live-dedup has to verify the data anyway if it
2924                          * gets a hit later so we can just add the entry
2925                          * now.
2926                          */
2927                         KKASSERT((disk_offset & HAMMER_OFF_ZONE_MASK) ==
2928                                  HAMMER_ZONE_LARGE_DATA);
2929                         nbio->bio_offset = disk_offset;
2930                         if (hammer_live_dedup)
2931                                 hammer_dedup_cache_add(ip, cursor.leaf);
2932                         error = hammer_io_indirect_read(hmp, nbio, cursor.leaf);
2933                         goto done;
2934                 } else if (n) {
2935                         error = hammer_ip_resolve_data(&cursor);
2936                         if (error == 0) {
2937                                 if (hammer_live_dedup && isdedupable)
2938                                         hammer_dedup_cache_add(ip, cursor.leaf);
2939                                 bcopy((char *)cursor.data + roff,
2940                                       (char *)bp->b_data + boff, n);
2941                         }
2942                 }
2943                 if (error)
2944                         break;
2945
2946                 /*
2947                  * We have to be sure that the only elements added to the
2948                  * dedup cache are those which are already on-media.
2949                  */
2950                 if (hammer_live_dedup && hammer_cursor_ondisk(&cursor))
2951                         hammer_dedup_cache_add(ip, cursor.leaf);
2952
2953                 /*
2954                  * Iterate until we have filled the request.
2955                  */
2956                 boff += n;
2957                 if (boff == bp->b_bufsize)
2958                         break;
2959                 error = hammer_ip_next(&cursor);
2960         }
2961
2962         /*
2963          * There may have been a gap after the last record
2964          */
2965         if (error == ENOENT)
2966                 error = 0;
2967         if (error == 0 && boff != bp->b_bufsize) {
2968                 KKASSERT(boff < bp->b_bufsize);
2969                 bzero((char *)bp->b_data + boff, bp->b_bufsize - boff);
2970                 /* boff = bp->b_bufsize; */
2971         }
2972
2973         /*
2974          * Disallow swapcache operation on the vnode buffer if double
2975          * buffering is enabled, the swapcache will get the data via
2976          * the block device buffer.
2977          */
2978         if (hammer_double_buffer)
2979                 bp->b_flags |= B_NOTMETA;
2980
2981         /*
2982          * Cleanup
2983          */
2984         bp->b_resid = 0;
2985         bp->b_error = error;
2986         if (error)
2987                 bp->b_flags |= B_ERROR;
2988         biodone(ap->a_bio);
2989
2990 done:
2991         /*
2992          * Cache the b-tree node for the last data read in cache[1].
2993          *
2994          * If we hit the file EOF then also cache the node in the
2995          * governing director's cache[3], it will be used to initialize
2996          * the inode's cache[1] for any inodes looked up via the directory.
2997          *
2998          * This doesn't reduce disk accesses since the B-Tree chain is
2999          * likely cached, but it does reduce cpu overhead when looking
3000          * up file offsets for cpdup/tar/cpio style iterations.
3001          */
3002         if (cursor.node)
3003                 hammer_cache_node(&ip->cache[1], cursor.node);
3004         if (ran_end >= ip->ino_data.size) {
3005                 dip = hammer_find_inode(&trans, ip->ino_data.parent_obj_id,
3006                                         ip->obj_asof, ip->obj_localization);
3007                 if (dip) {
3008                         hammer_cache_node(&dip->cache[3], cursor.node);
3009                         hammer_rel_inode(dip, 0);
3010                 }
3011         }
3012         hammer_done_cursor(&cursor);
3013         hammer_done_transaction(&trans);
3014         lwkt_reltoken(&hmp->fs_token);
3015         return(error);
3016 }
3017
3018 /*
3019  * BMAP operation - used to support cluster_read() only.
3020  *
3021  * (struct vnode *vp, off_t loffset, off_t *doffsetp, int *runp, int *runb)
3022  *
3023  * This routine may return EOPNOTSUPP if the opration is not supported for
3024  * the specified offset.  The contents of the pointer arguments do not
3025  * need to be initialized in that case.
3026  *
3027  * If a disk address is available and properly aligned return 0 with
3028  * *doffsetp set to the zone-2 address, and *runp / *runb set appropriately
3029  * to the run-length relative to that offset.  Callers may assume that
3030  * *doffsetp is valid if 0 is returned, even if *runp is not sufficiently
3031  * large, so return EOPNOTSUPP if it is not sufficiently large.
3032  */
3033 static
3034 int
3035 hammer_vop_bmap(struct vop_bmap_args *ap)
3036 {
3037         struct hammer_transaction trans;
3038         struct hammer_inode *ip;
3039         hammer_mount_t hmp;
3040         struct hammer_cursor cursor;
3041         hammer_base_elm_t base;
3042         int64_t rec_offset;
3043         int64_t ran_end;
3044         int64_t tmp64;
3045         int64_t base_offset;
3046         int64_t base_disk_offset;
3047         int64_t last_offset;
3048         hammer_off_t last_disk_offset;
3049         hammer_off_t disk_offset;
3050         int     rec_len;
3051         int     error;
3052         int     blksize;
3053
3054         ++hammer_stats_file_iopsr;
3055         ip = ap->a_vp->v_data;
3056         hmp = ip->hmp;
3057
3058         /*
3059          * We can only BMAP regular files.  We can't BMAP database files,
3060          * directories, etc.
3061          */
3062         if (ip->ino_data.obj_type != HAMMER_OBJTYPE_REGFILE)
3063                 return(EOPNOTSUPP);
3064
3065         /*
3066          * bmap is typically called with runp/runb both NULL when used
3067          * for writing.  We do not support BMAP for writing atm.
3068          */
3069         if (ap->a_cmd != BUF_CMD_READ)
3070                 return(EOPNOTSUPP);
3071
3072         /*
3073          * Scan the B-Tree to acquire blockmap addresses, then translate
3074          * to raw addresses.
3075          */
3076         lwkt_gettoken(&hmp->fs_token);
3077         hammer_simple_transaction(&trans, hmp);
3078 #if 0
3079         kprintf("bmap_beg %016llx ip->cache %p\n",
3080                 (long long)ap->a_loffset, ip->cache[1]);
3081 #endif
3082         hammer_init_cursor(&trans, &cursor, &ip->cache[1], ip);
3083
3084         /*
3085          * Key range (begin and end inclusive) to scan.  Note that the key's
3086          * stored in the actual records represent BASE+LEN, not BASE.  The
3087          * first record containing bio_offset will have a key > bio_offset.
3088          */
3089         cursor.key_beg.localization = ip->obj_localization +
3090                                       HAMMER_LOCALIZE_MISC;
3091         cursor.key_beg.obj_id = ip->obj_id;
3092         cursor.key_beg.create_tid = 0;
3093         cursor.key_beg.delete_tid = 0;
3094         cursor.key_beg.obj_type = 0;
3095         if (ap->a_runb)
3096                 cursor.key_beg.key = ap->a_loffset - MAXPHYS + 1;
3097         else
3098                 cursor.key_beg.key = ap->a_loffset + 1;
3099         if (cursor.key_beg.key < 0)
3100                 cursor.key_beg.key = 0;
3101         cursor.asof = ip->obj_asof;
3102         cursor.flags |= HAMMER_CURSOR_ASOF;
3103
3104         cursor.key_end = cursor.key_beg;
3105         KKASSERT(ip->ino_data.obj_type == HAMMER_OBJTYPE_REGFILE);
3106
3107         ran_end = ap->a_loffset + MAXPHYS;
3108         cursor.key_beg.rec_type = HAMMER_RECTYPE_DATA;
3109         cursor.key_end.rec_type = HAMMER_RECTYPE_DATA;
3110         tmp64 = ran_end + MAXPHYS + 1;  /* work-around GCC-4 bug */
3111         if (tmp64 < ran_end)
3112                 cursor.key_end.key = 0x7FFFFFFFFFFFFFFFLL;
3113         else
3114                 cursor.key_end.key = ran_end + MAXPHYS + 1;
3115
3116         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE;
3117
3118         error = hammer_ip_first(&cursor);
3119         base_offset = last_offset = 0;
3120         base_disk_offset = last_disk_offset = 0;
3121
3122         while (error == 0) {
3123                 /*
3124                  * Get the base file offset of the record.  The key for
3125                  * data records is (base + bytes) rather then (base).
3126                  *
3127                  * NOTE: rec_offset + rec_len may exceed the end-of-file.
3128                  * The extra bytes should be zero on-disk and the BMAP op
3129                  * should still be ok.
3130                  */
3131                 base = &cursor.leaf->base;
3132                 rec_offset = base->key - cursor.leaf->data_len;
3133                 rec_len    = cursor.leaf->data_len;
3134
3135                 /*
3136                  * Incorporate any cached truncation.
3137                  *
3138                  * NOTE: Modifications to rec_len based on synthesized
3139                  * truncation points remove the guarantee that any extended
3140                  * data on disk is zero (since the truncations may not have
3141                  * taken place on-media yet).
3142                  */
3143                 if (ip->flags & HAMMER_INODE_TRUNCATED) {
3144                         if (hammer_cursor_ondisk(&cursor) ||
3145                             cursor.iprec->flush_state == HAMMER_FST_FLUSH) {
3146                                 if (ip->trunc_off <= rec_offset)
3147                                         rec_len = 0;
3148                                 else if (ip->trunc_off < rec_offset + rec_len)
3149                                         rec_len = (int)(ip->trunc_off - rec_offset);
3150                         }
3151                 }
3152                 if (ip->sync_flags & HAMMER_INODE_TRUNCATED) {
3153                         if (hammer_cursor_ondisk(&cursor)) {
3154                                 if (ip->sync_trunc_off <= rec_offset)
3155                                         rec_len = 0;
3156                                 else if (ip->sync_trunc_off < rec_offset + rec_len)
3157                                         rec_len = (int)(ip->sync_trunc_off - rec_offset);
3158                         }
3159                 }
3160
3161                 /*
3162                  * Accumulate information.  If we have hit a discontiguous
3163                  * block reset base_offset unless we are already beyond the
3164                  * requested offset.  If we are, that's it, we stop.
3165                  */
3166                 if (error)
3167                         break;
3168                 if (hammer_cursor_ondisk(&cursor)) {
3169                         disk_offset = cursor.leaf->data_offset;
3170                         if (rec_offset != last_offset ||
3171                             disk_offset != last_disk_offset) {
3172                                 if (rec_offset > ap->a_loffset)
3173                                         break;
3174                                 base_offset = rec_offset;
3175                                 base_disk_offset = disk_offset;
3176                         }
3177                         last_offset = rec_offset + rec_len;
3178                         last_disk_offset = disk_offset + rec_len;
3179
3180                         if (hammer_live_dedup)
3181                                 hammer_dedup_cache_add(ip, cursor.leaf);
3182                 }
3183
3184                 error = hammer_ip_next(&cursor);
3185         }
3186
3187 #if 0
3188         kprintf("BMAP %016llx:  %016llx - %016llx\n",
3189                 (long long)ap->a_loffset,
3190                 (long long)base_offset,
3191                 (long long)last_offset);
3192         kprintf("BMAP %16s:  %016llx - %016llx\n", "",
3193                 (long long)base_disk_offset,
3194                 (long long)last_disk_offset);
3195 #endif
3196
3197         if (cursor.node) {
3198                 hammer_cache_node(&ip->cache[1], cursor.node);
3199 #if 0
3200                 kprintf("bmap_end2 %016llx ip->cache %p\n",
3201                         (long long)ap->a_loffset, ip->cache[1]);
3202 #endif
3203         }
3204         hammer_done_cursor(&cursor);
3205         hammer_done_transaction(&trans);
3206         lwkt_reltoken(&hmp->fs_token);
3207
3208         /*
3209          * If we couldn't find any records or the records we did find were
3210          * all behind the requested offset, return failure.  A forward
3211          * truncation can leave a hole w/ no on-disk records.
3212          */
3213         if (last_offset == 0 || last_offset < ap->a_loffset)
3214                 return (EOPNOTSUPP);
3215
3216         /*
3217          * Figure out the block size at the requested offset and adjust
3218          * our limits so the cluster_read() does not create inappropriately
3219          * sized buffer cache buffers.
3220          */
3221         blksize = hammer_blocksize(ap->a_loffset);
3222         if (hammer_blocksize(base_offset) != blksize) {
3223                 base_offset = hammer_blockdemarc(base_offset, ap->a_loffset);
3224         }
3225         if (last_offset != ap->a_loffset &&
3226             hammer_blocksize(last_offset - 1) != blksize) {
3227                 last_offset = hammer_blockdemarc(ap->a_loffset,
3228                                                  last_offset - 1);
3229         }
3230
3231         /*
3232          * Returning EOPNOTSUPP simply prevents the direct-IO optimization
3233          * from occuring.
3234          */
3235         disk_offset = base_disk_offset + (ap->a_loffset - base_offset);
3236
3237         if ((disk_offset & HAMMER_OFF_ZONE_MASK) != HAMMER_ZONE_LARGE_DATA) {
3238                 /*
3239                  * Only large-data zones can be direct-IOd
3240                  */
3241                 error = EOPNOTSUPP;
3242         } else if ((disk_offset & HAMMER_BUFMASK) ||
3243                    (last_offset - ap->a_loffset) < blksize) {
3244                 /*
3245                  * doffsetp is not aligned or the forward run size does
3246                  * not cover a whole buffer, disallow the direct I/O.
3247                  */
3248                 error = EOPNOTSUPP;
3249         } else {
3250                 /*
3251                  * We're good.
3252                  */
3253                 *ap->a_doffsetp = disk_offset;
3254                 if (ap->a_runb) {
3255                         *ap->a_runb = ap->a_loffset - base_offset;
3256                         KKASSERT(*ap->a_runb >= 0);
3257                 }
3258                 if (ap->a_runp) {
3259                         *ap->a_runp = last_offset - ap->a_loffset;
3260                         KKASSERT(*ap->a_runp >= 0);
3261                 }
3262                 error = 0;
3263         }
3264         return(error);
3265 }
3266
3267 /*
3268  * Write to a regular file.   Because this is a strategy call the OS is
3269  * trying to actually get data onto the media.
3270  */
3271 static
3272 int
3273 hammer_vop_strategy_write(struct vop_strategy_args *ap)
3274 {
3275         hammer_record_t record;
3276         hammer_mount_t hmp;
3277         hammer_inode_t ip;
3278         struct bio *bio;
3279         struct buf *bp;
3280         int blksize __debugvar;
3281         int bytes;
3282         int error;
3283
3284         bio = ap->a_bio;
3285         bp = bio->bio_buf;
3286         ip = ap->a_vp->v_data;
3287         hmp = ip->hmp;
3288
3289         blksize = hammer_blocksize(bio->bio_offset);
3290         KKASSERT(bp->b_bufsize == blksize);
3291
3292         if (ip->flags & HAMMER_INODE_RO) {
3293                 bp->b_error = EROFS;
3294                 bp->b_flags |= B_ERROR;
3295                 biodone(ap->a_bio);
3296                 return(EROFS);
3297         }
3298
3299         lwkt_gettoken(&hmp->fs_token);
3300
3301         /*
3302          * Disallow swapcache operation on the vnode buffer if double
3303          * buffering is enabled, the swapcache will get the data via
3304          * the block device buffer.
3305          */
3306         if (hammer_double_buffer)
3307                 bp->b_flags |= B_NOTMETA;
3308
3309         /*
3310          * Interlock with inode destruction (no in-kernel or directory
3311          * topology visibility).  If we queue new IO while trying to
3312          * destroy the inode we can deadlock the vtrunc call in
3313          * hammer_inode_unloadable_check().
3314          *
3315          * Besides, there's no point flushing a bp associated with an
3316          * inode that is being destroyed on-media and has no kernel
3317          * references.
3318          */
3319         if ((ip->flags | ip->sync_flags) &
3320             (HAMMER_INODE_DELETING|HAMMER_INODE_DELETED)) {
3321                 bp->b_resid = 0;
3322                 biodone(ap->a_bio);
3323                 lwkt_reltoken(&hmp->fs_token);
3324                 return(0);
3325         }
3326
3327         /*
3328          * Reserve space and issue a direct-write from the front-end.
3329          * NOTE: The direct_io code will hammer_bread/bcopy smaller
3330          * allocations.
3331          *
3332          * An in-memory record will be installed to reference the storage
3333          * until the flusher can get to it.
3334          *
3335          * Since we own the high level bio the front-end will not try to
3336          * do a direct-read until the write completes.
3337          *
3338          * NOTE: The only time we do not reserve a full-sized buffers
3339          * worth of data is if the file is small.  We do not try to
3340          * allocate a fragment (from the small-data zone) at the end of
3341          * an otherwise large file as this can lead to wildly separated
3342          * data.
3343          */
3344         KKASSERT((bio->bio_offset & HAMMER_BUFMASK) == 0);
3345         KKASSERT(bio->bio_offset < ip->ino_data.size);
3346         if (bio->bio_offset || ip->ino_data.size > HAMMER_BUFSIZE / 2)
3347                 bytes = bp->b_bufsize;
3348         else
3349                 bytes = ((int)ip->ino_data.size + 15) & ~15;
3350
3351         record = hammer_ip_add_bulk(ip, bio->bio_offset, bp->b_data,
3352                                     bytes, &error);
3353
3354         /*
3355          * B_VFSFLAG1 indicates that a REDO_WRITE entry was generated
3356          * in hammer_vop_write().  We must flag the record so the proper
3357          * REDO_TERM_WRITE entry is generated during the flush.
3358          */
3359         if (record) {
3360                 if (bp->b_flags & B_VFSFLAG1) {
3361                         record->flags |= HAMMER_RECF_REDO;
3362                         bp->b_flags &= ~B_VFSFLAG1;
3363                 }
3364                 if (record->flags & HAMMER_RECF_DEDUPED) {
3365                         bp->b_resid = 0;
3366                         hammer_ip_replace_bulk(hmp, record);
3367                         biodone(ap->a_bio);
3368                 } else {
3369                         hammer_io_direct_write(hmp, bio, record);
3370                 }
3371                 if (ip->rsv_recs > 1 && hmp->rsv_recs > hammer_limit_recs)
3372                         hammer_flush_inode(ip, 0);
3373         } else {
3374                 bp->b_bio2.bio_offset = NOOFFSET;
3375                 bp->b_error = error;
3376                 bp->b_flags |= B_ERROR;
3377                 biodone(ap->a_bio);
3378         }
3379         lwkt_reltoken(&hmp->fs_token);
3380         return(error);
3381 }
3382
3383 /*
3384  * dounlink - disconnect a directory entry
3385  *
3386  * XXX whiteout support not really in yet
3387  */
3388 static int
3389 hammer_dounlink(hammer_transaction_t trans, struct nchandle *nch,
3390                 struct vnode *dvp, struct ucred *cred,
3391                 int flags, int isdir)
3392 {
3393         struct namecache *ncp;
3394         hammer_inode_t dip;
3395         hammer_inode_t ip;
3396         hammer_mount_t hmp;
3397         struct hammer_cursor cursor;
3398         int64_t namekey;
3399         u_int32_t max_iterations;
3400         int nlen, error;
3401
3402         /*
3403          * Calculate the namekey and setup the key range for the scan.  This
3404          * works kinda like a chained hash table where the lower 32 bits
3405          * of the namekey synthesize the chain.
3406          *
3407          * The key range is inclusive of both key_beg and key_end.
3408          */
3409         dip = VTOI(dvp);
3410         ncp = nch->ncp;
3411         hmp = dip->hmp;
3412
3413         if (dip->flags & HAMMER_INODE_RO)
3414                 return (EROFS);
3415
3416         namekey = hammer_directory_namekey(dip, ncp->nc_name, ncp->nc_nlen,
3417                                            &max_iterations);
3418 retry:
3419         hammer_init_cursor(trans, &cursor, &dip->cache[1], dip);
3420         cursor.key_beg.localization = dip->obj_localization +
3421                                       hammer_dir_localization(dip);
3422         cursor.key_beg.obj_id = dip->obj_id;
3423         cursor.key_beg.key = namekey;
3424         cursor.key_beg.create_tid = 0;
3425         cursor.key_beg.delete_tid = 0;
3426         cursor.key_beg.rec_type = HAMMER_RECTYPE_DIRENTRY;
3427         cursor.key_beg.obj_type = 0;
3428
3429         cursor.key_end = cursor.key_beg;
3430         cursor.key_end.key += max_iterations;
3431         cursor.asof = dip->obj_asof;
3432         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE | HAMMER_CURSOR_ASOF;
3433
3434         /*
3435          * Scan all matching records (the chain), locate the one matching
3436          * the requested path component.  info->last_error contains the
3437          * error code on search termination and could be 0, ENOENT, or
3438          * something else.
3439          *
3440          * The hammer_ip_*() functions merge in-memory records with on-disk
3441          * records for the purposes of the search.
3442          */
3443         error = hammer_ip_first(&cursor);
3444
3445         while (error == 0) {
3446                 error = hammer_ip_resolve_data(&cursor);
3447                 if (error)
3448                         break;
3449                 nlen = cursor.leaf->data_len - HAMMER_ENTRY_NAME_OFF;
3450                 KKASSERT(nlen > 0);
3451                 if (ncp->nc_nlen == nlen &&
3452                     bcmp(ncp->nc_name, cursor.data->entry.name, nlen) == 0) {
3453                         break;
3454                 }
3455                 error = hammer_ip_next(&cursor);
3456         }
3457
3458         /*
3459          * If all is ok we have to get the inode so we can adjust nlinks.
3460          * To avoid a deadlock with the flusher we must release the inode
3461          * lock on the directory when acquiring the inode for the entry.
3462          *
3463          * If the target is a directory, it must be empty.
3464          */
3465         if (error == 0) {
3466                 hammer_unlock(&cursor.ip->lock);
3467                 ip = hammer_get_inode(trans, dip, cursor.data->entry.obj_id,
3468                                       hmp->asof,
3469                                       cursor.data->entry.localization,
3470                                       0, &error);
3471                 hammer_lock_sh(&cursor.ip->lock);
3472                 if (error == ENOENT) {
3473                         kprintf("HAMMER: WARNING: Removing "
3474                                 "dirent w/missing inode \"%s\"\n"
3475                                 "\tobj_id = %016llx\n",
3476                                 ncp->nc_name,
3477                                 (long long)cursor.data->entry.obj_id);
3478                         error = 0;
3479                 }
3480
3481                 /*
3482                  * If isdir >= 0 we validate that the entry is or is not a
3483                  * directory.  If isdir < 0 we don't care.
3484                  */
3485                 if (error == 0 && isdir >= 0 && ip) {
3486                         if (isdir &&
3487                             ip->ino_data.obj_type != HAMMER_OBJTYPE_DIRECTORY) {
3488                                 error = ENOTDIR;
3489                         } else if (isdir == 0 &&
3490                             ip->ino_data.obj_type == HAMMER_OBJTYPE_DIRECTORY) {
3491                                 error = EISDIR;
3492                         }
3493                 }
3494
3495                 /*
3496                  * If we are trying to remove a directory the directory must
3497                  * be empty.
3498                  *
3499                  * The check directory code can loop and deadlock/retry.  Our
3500                  * own cursor's node locks must be released to avoid a 3-way
3501                  * deadlock with the flusher if the check directory code
3502                  * blocks.
3503                  *
3504                  * If any changes whatsoever have been made to the cursor
3505                  * set EDEADLK and retry.
3506                  *
3507                  * WARNING: See warnings in hammer_unlock_cursor()
3508                  *          function.
3509                  */
3510                 if (error == 0 && ip && ip->ino_data.obj_type ==
3511                                         HAMMER_OBJTYPE_DIRECTORY) {
3512                         hammer_unlock_cursor(&cursor);
3513                         error = hammer_ip_check_directory_empty(trans, ip);
3514                         hammer_lock_cursor(&cursor);
3515                         if (cursor.flags & HAMMER_CURSOR_RETEST) {
3516                                 kprintf("HAMMER: Warning: avoided deadlock "
3517                                         "on rmdir '%s'\n",
3518                                         ncp->nc_name);
3519                                 error = EDEADLK;
3520                         }
3521                 }
3522
3523                 /*
3524                  * Delete the directory entry.
3525                  *
3526                  * WARNING: hammer_ip_del_directory() may have to terminate
3527                  * the cursor to avoid a deadlock.  It is ok to call
3528                  * hammer_done_cursor() twice.
3529                  */
3530                 if (error == 0) {
3531                         error = hammer_ip_del_directory(trans, &cursor,
3532                                                         dip, ip);
3533                 }
3534                 hammer_done_cursor(&cursor);
3535                 if (error == 0) {
3536                         /*
3537                          * Tell the namecache that we are now unlinked.
3538                          */
3539                         cache_unlink(nch);
3540
3541                         /*
3542                          * NOTE: ip->vp, if non-NULL, cannot be directly
3543                          *       referenced without formally acquiring the
3544                          *       vp since the vp might have zero refs on it,
3545                          *       or in the middle of a reclaim, etc.
3546                          *
3547                          * NOTE: The cache_setunresolved() can rip the vp
3548                          *       out from under us since the vp may not have
3549                          *       any refs, in which case ip->vp will be NULL
3550                          *       from the outset.
3551                          */
3552                         while (ip && ip->vp) {
3553                                 struct vnode *vp;
3554
3555                                 error = hammer_get_vnode(ip, &vp);
3556                                 if (error == 0 && vp) {
3557                                         vn_unlock(vp);
3558                                         hammer_knote(ip->vp, NOTE_DELETE);
3559 #if 0
3560                                         /*
3561                                          * Don't do this, it can deadlock
3562                                          * on concurrent rm's of hardlinks.
3563                                          * Shouldn't be needed any more.
3564                                          */
3565                                         cache_inval_vp(ip->vp, CINV_DESTROY);
3566 #endif
3567                                         vrele(vp);
3568                                         break;
3569                                 }
3570                                 kprintf("Debug: HAMMER ip/vp race1 avoided\n");
3571                         }
3572                 }
3573                 if (ip)
3574                         hammer_rel_inode(ip, 0);
3575         } else {
3576                 hammer_done_cursor(&cursor);
3577         }
3578         if (error == EDEADLK)
3579                 goto retry;
3580
3581         return (error);
3582 }
3583
3584 /************************************************************************
3585  *                          FIFO AND SPECFS OPS                         *
3586  ************************************************************************
3587  *
3588  */
3589 static int
3590 hammer_vop_fifoclose (struct vop_close_args *ap)
3591 {
3592         /* XXX update itimes */
3593         return (VOCALL(&fifo_vnode_vops, &ap->a_head));
3594 }
3595
3596 static int
3597 hammer_vop_fiforead (struct vop_read_args *ap)
3598 {
3599         int error;
3600
3601         error = VOCALL(&fifo_vnode_vops, &ap->a_head);
3602         /* XXX update access time */
3603         return (error);
3604 }
3605
3606 static int
3607 hammer_vop_fifowrite (struct vop_write_args *ap)
3608 {
3609         int error;
3610
3611         error = VOCALL(&fifo_vnode_vops, &ap->a_head);
3612         /* XXX update access time */
3613         return (error);
3614 }
3615
3616 static
3617 int
3618 hammer_vop_fifokqfilter(struct vop_kqfilter_args *ap)
3619 {
3620         int error;
3621
3622         error = VOCALL(&fifo_vnode_vops, &ap->a_head);
3623         if (error)
3624                 error = hammer_vop_kqfilter(ap);
3625         return(error);
3626 }
3627
3628 /************************************************************************
3629  *                          KQFILTER OPS                                *
3630  ************************************************************************
3631  *
3632  */
3633 static void filt_hammerdetach(struct knote *kn);
3634 static int filt_hammerread(struct knote *kn, long hint);
3635 static int filt_hammerwrite(struct knote *kn, long hint);
3636 static int filt_hammervnode(struct knote *kn, long hint);
3637
3638 static struct filterops hammerread_filtops =
3639         { FILTEROP_ISFD | FILTEROP_MPSAFE,
3640           NULL, filt_hammerdetach, filt_hammerread };
3641 static struct filterops hammerwrite_filtops =
3642         { FILTEROP_ISFD | FILTEROP_MPSAFE,
3643           NULL, filt_hammerdetach, filt_hammerwrite };
3644 static struct filterops hammervnode_filtops =
3645         { FILTEROP_ISFD | FILTEROP_MPSAFE,
3646           NULL, filt_hammerdetach, filt_hammervnode };
3647
3648 static
3649 int
3650 hammer_vop_kqfilter(struct vop_kqfilter_args *ap)
3651 {
3652         struct vnode *vp = ap->a_vp;
3653         struct knote *kn = ap->a_kn;
3654
3655         switch (kn->kn_filter) {
3656         case EVFILT_READ:
3657                 kn->kn_fop = &hammerread_filtops;
3658                 break;
3659         case EVFILT_WRITE:
3660                 kn->kn_fop = &hammerwrite_filtops;
3661                 break;
3662         case EVFILT_VNODE:
3663                 kn->kn_fop = &hammervnode_filtops;
3664                 break;
3665         default:
3666                 return (EOPNOTSUPP);
3667         }
3668
3669         kn->kn_hook = (caddr_t)vp;
3670
3671         knote_insert(&vp->v_pollinfo.vpi_kqinfo.ki_note, kn);
3672
3673         return(0);
3674 }
3675
3676 static void
3677 filt_hammerdetach(struct knote *kn)
3678 {
3679         struct vnode *vp = (void *)kn->kn_hook;
3680
3681         knote_remove(&vp->v_pollinfo.vpi_kqinfo.ki_note, kn);
3682 }
3683
3684 static int
3685 filt_hammerread(struct knote *kn, long hint)
3686 {
3687         struct vnode *vp = (void *)kn->kn_hook;
3688         hammer_inode_t ip = VTOI(vp);
3689         hammer_mount_t hmp = ip->hmp;
3690         off_t off;
3691
3692         if (hint == NOTE_REVOKE) {
3693                 kn->kn_flags |= (EV_EOF | EV_NODATA | EV_ONESHOT);
3694                 return(1);
3695         }
3696         lwkt_gettoken(&hmp->fs_token);  /* XXX use per-ip-token */
3697         off = ip->ino_data.size - kn->kn_fp->f_offset;
3698         kn->kn_data = (off < INTPTR_MAX) ? off : INTPTR_MAX;
3699         lwkt_reltoken(&hmp->fs_token);
3700         if (kn->kn_sfflags & NOTE_OLDAPI)
3701                 return(1);
3702         return (kn->kn_data != 0);
3703 }
3704
3705 static int
3706 filt_hammerwrite(struct knote *kn, long hint)
3707 {
3708         if (hint == NOTE_REVOKE)
3709                 kn->kn_flags |= (EV_EOF | EV_NODATA | EV_ONESHOT);
3710         kn->kn_data = 0;
3711         return (1);
3712 }
3713
3714 static int
3715 filt_hammervnode(struct knote *kn, long hint)
3716 {
3717         if (kn->kn_sfflags & hint)
3718                 kn->kn_fflags |= hint;
3719         if (hint == NOTE_REVOKE) {
3720                 kn->kn_flags |= (EV_EOF | EV_NODATA);
3721                 return (1);
3722         }
3723         return (kn->kn_fflags != 0);
3724 }
3725