sys/vfs/hammer/hammer_transaction.c

   1 /*
   2  * Copyright (c) 2007-2008 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $DragonFly: src/sys/vfs/hammer/hammer_transaction.c,v 1.13 2008/04/25 21:49:49 dillon Exp $
  35  */
  36
  37 #include "hammer.h"
  38
  39 /*
  40  * Start a standard transaction.
  41  */
  42 void
  43 hammer_start_transaction(struct hammer_transaction *trans,
  44                          struct hammer_mount *hmp)
  45 {
  46         int error;
  47
  48         trans->type = HAMMER_TRANS_STD;
  49         trans->hmp = hmp;
  50         trans->rootvol = hammer_get_root_volume(hmp, &error);
  51         KKASSERT(error == 0);
  52         trans->tid = 0;
  53         trans->time = hammer_alloc_tid(trans);
  54 }
  55
  56 /*
  57  * Start a simple read-only transaction.  This will not stall.
  58  */
  59 void
  60 hammer_simple_transaction(struct hammer_transaction *trans,
  61                           struct hammer_mount *hmp)
  62 {
  63         int error;
  64
  65         trans->type = HAMMER_TRANS_RO;
  66         trans->hmp = hmp;
  67         trans->rootvol = hammer_get_root_volume(hmp, &error);
  68         KKASSERT(error == 0);
  69         trans->tid = 0;
  70         trans->time = hammer_alloc_tid(trans);
  71 }
  72
  73 /*
  74  * Start a transaction using a particular TID.  Used by the sync code.
  75  * This does not stall.
  76  */
  77 void
  78 hammer_start_transaction_fls(struct hammer_transaction *trans,
  79                              struct hammer_mount *hmp)
  80 {
  81         int error;
  82
  83         trans->type = HAMMER_TRANS_FLS;
  84         trans->hmp = hmp;
  85         trans->rootvol = hammer_get_root_volume(hmp, &error);
  86         KKASSERT(error == 0);
  87         trans->tid = hammer_alloc_tid(trans);
  88         trans->time = trans->tid;
  89 }
  90
  91 void
  92 hammer_done_transaction(struct hammer_transaction *trans)
  93 {
  94         hammer_rel_volume(trans->rootvol, 0);
  95         trans->rootvol = NULL;
  96 }
  97
  98 /*
  99  * Note: Successive transaction ids must be at least 2 apart so the
 100  * B-Tree code can make a separator that does not match either the
 101  * left or right hand sides.
 102  */
 103 hammer_tid_t
 104 hammer_alloc_tid(hammer_transaction_t trans)
 105 {
 106         struct timespec ts;
 107         hammer_tid_t tid;
 108
 109         getnanotime(&ts);
 110         tid = ts.tv_sec * 1000000000LL + ts.tv_nsec;
 111         if (tid < trans->hmp->next_tid)
 112                 tid = trans->hmp->next_tid;
 113 #if 0
 114         hammer_modify_volume(trans, trans->rootvol, NULL, 0);
 115         ondisk = trans->rootvol->ondisk;
 116         if (tid < ondisk->vol0_next_tid)
 117                 tid = ondisk->vol0_next_tid;
 118 #endif
 119         if (tid >= 0xFFFFFFFFFFFFFFF0ULL)
 120                 panic("hammer_start_transaction: Ran out of TIDs!");
 121         if (hammer_debug_tid) {
 122                 kprintf("alloc_tid %016llx (0x%08x)\n",
 123                         tid, (int)(tid / 1000000000LL));
 124         }
 125 #if 0
 126         ondisk->vol0_next_tid = tid + 2;
 127         hammer_modify_volume_done(trans->rootvol);
 128 #endif
 129         trans->hmp->next_tid = tid + 2;
 130         return(tid);
 131 }
 132