sys/vfs/hammer/hammer_cursor.h

   1 /*
   2  * Copyright (c) 2007 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_cursor.h,v 1.26 2008/08/06 15:38:58 dillon Exp $
  35  */
  36
  37 #ifndef VFS_HAMMER_CURSOR_H_
  38 #define VFS_HAMMER_CURSOR_H_
  39
  40 /*
  41  * The hammer_cursor structure is the primary in-memory management structure
  42  * for B-Tree operations.
  43  *
  44  * The most important issue to make note of is that a hammer_cursor is a
  45  * tracking structure.  Any active hammer_cursor structure will be linked into
  46  * hammer_node based lists and B-Tree operations executed by unrelated
  47  * treads MAY MODIFY YOUR CURSOR when you are not holding an exclusive
  48  * lock on the cursor's nodes.
  49  *
  50  * The cursor module maintains a shared lock on cursor->node and
  51  * cursor->parent.
  52  */
  53 struct hammer_cursor {
  54         /*
  55          * Parent B-Tree node, current B-Tree node, and related element
  56          * indices.
  57          */
  58         hammer_transaction_t trans;
  59         hammer_node_t   parent;
  60         int             parent_index;
  61
  62         hammer_node_t   node;
  63         int             index;
  64
  65         /*
  66          * Set if a deadlock occurs.  hammer_done_cursor() will block on
  67          * this after releasing parent and node, before returning.  See
  68          * also hammer_recover_cursor().
  69          */
  70         TAILQ_ENTRY(hammer_cursor) deadlk_entry;
  71         hammer_node_t deadlk_node;
  72         hammer_record_t deadlk_rec;
  73
  74         /*
  75          * Set along with HAMMER_CURSOR_CREATE_CHECK when doing an as-of
  76          * search.  If ENOENT is returned and the flag is set, the caller
  77          * must iterate with a new delete_tid.
  78          */
  79         hammer_tid_t  create_check;
  80
  81         /*
  82          * Pointer to the current node's bounds.  Typically points to the
  83          * appropriate boundary elements in the parent.
  84          * The right-boundary is range-exclusive.
  85          */
  86         hammer_base_elm_t left_bound;
  87         hammer_base_elm_t right_bound;
  88
  89         /*
  90          * Key or key range governing search.  The cursor code may adjust
  91          * key_beg/key_end if asof is non-zero.
  92          */
  93         struct hammer_base_elm key_beg;
  94         struct hammer_base_elm key_end;
  95         hammer_tid_t    asof;
  96         struct hammer_cmirror *cmirror;
  97
  98         /*
  99          * Related data and record references.  Note that the related buffers
 100          * can be NULL when data and/or record is not, typically indicating
 101          * information referenced via an in-memory record.
 102          */
 103         struct hammer_buffer *data_buffer;      /* extended data */
 104         hammer_btree_leaf_elm_t leaf;
 105         hammer_data_ondisk_t data;
 106
 107         /*
 108          * Iteration and extraction control variables
 109          */
 110         int flags;
 111         int rec_generation;
 112
 113         /*
 114          * Merged in-memory/on-disk iterations also use these fields.
 115          */
 116         hammer_inode_t ip;
 117         struct hammer_record *iprec;
 118 };
 119
 120 typedef struct hammer_cursor *hammer_cursor_t;
 121
 122 #define HAMMER_CURSOR_GET_LEAF          0x0001  /* not used */
 123 #define HAMMER_CURSOR_GET_DATA          0x0002
 124 #define HAMMER_CURSOR_BACKEND           0x0004  /* cursor run by backend */
 125 #define HAMMER_CURSOR_INSERT            0x0008  /* adjust for insert */
 126 #define HAMMER_CURSOR_DELETE_VISIBILITY 0x0010  /* special del-on-disk recs */
 127 #define HAMMER_CURSOR_END_INCLUSIVE     0x0020  /* key_end is inclusive */
 128 #define HAMMER_CURSOR_END_EXCLUSIVE     0x0040  /* key_end is exclusive (def) */
 129
 130 #define HAMMER_CURSOR_ATEDISK           0x0100
 131 #define HAMMER_CURSOR_ATEMEM            0x0200
 132 #define HAMMER_CURSOR_DISKEOF           0x0400
 133 #define HAMMER_CURSOR_MEMEOF            0x0800
 134 #define HAMMER_CURSOR_RETEST            0x1000  /* retest current element */
 135 #define HAMMER_CURSOR_MIRROR_FILTERED   0x2000  /* mirror_tid filter */
 136 #define HAMMER_CURSOR_ASOF              0x4000  /* as-of lookup */
 137 #define HAMMER_CURSOR_CREATE_CHECK      0x8000  /* as-of lookup */
 138
 139 #define HAMMER_CURSOR_PRUNING           0x00010000
 140 #define HAMMER_CURSOR_REBLOCKING        0x00020000
 141 #define HAMMER_CURSOR_TRACKED           0x00040000
 142 #define HAMMER_CURSOR_TRACKED_RIPOUT    0x00080000
 143 #define HAMMER_CURSOR_LASTWASMEM        0x00100000 /* hammer_ip_next logic */
 144 #define HAMMER_CURSOR_ITERATE_CHECK     0x00200000
 145 #define HAMMER_CURSOR_NOSWAPCACHE       0x00400000 /* applies to LARGE_DATA */
 146
 147 /*
 148  * Flags we can clear when reusing a cursor (we can clear all of them)
 149  */
 150 #define HAMMER_CURSOR_INITMASK          (~0)
 151
 152 /*
 153  * Mirror scan extension structure.  Caller sets mirror_tid to restrict
 154  * the scan.  If the iteration is able to skip one or more internal nodes
 155  * it returns an internal node with skip_beg/end set to the skipped range.
 156  *
 157  * If the first element of an internal node is skipped skip_beg will use
 158  * the left_bound inherited from the parent, and the same for the last
 159  * element.  This is because gaps can develop in the bounds.
 160  */
 161 struct hammer_cmirror {
 162         hammer_tid_t    mirror_tid;
 163         struct hammer_base_elm skip_beg;
 164         struct hammer_base_elm skip_end;
 165 };
 166
 167 /*
 168  * NOTE: iprec can be NULL, but the address-of does not indirect through
 169  * it so we are ok.
 170  */
 171 #define hammer_cursor_inmem(cursor)             \
 172                         ((cursor)->leaf == &(cursor)->iprec->leaf)
 173 #define hammer_cursor_ondisk(cursor)            \
 174                         ((cursor)->leaf != &(cursor)->iprec->leaf)
 175
 176 #endif /* !VFS_HAMMER_CURSOR_H_ */