git.sesse.net Git - bcachefs-tools-debian/blob - bch_bindgen/src/btree.rs

   1 use crate::SPOS_MAX;
   2 use crate::c;
   3 use crate::bkey::BkeySC;
   4 use crate::fs::Fs;
   5 use crate::errcode::{bch_errcode, errptr_to_result_c};
   6 use crate::printbuf_to_formatter;
   7 use std::fmt;
   8 use std::marker::PhantomData;
   9 use std::mem::MaybeUninit;
  10 use bitflags::bitflags;
  11
  12 pub struct BtreeTrans<'f> {
  13     raw:    *mut c::btree_trans,
  14     fs:     PhantomData<&'f Fs>
  15 }
  16
  17 impl<'f> BtreeTrans<'f> {
  18     pub fn new(fs: &'f Fs) -> BtreeTrans {
  19         unsafe {
  20             BtreeTrans { raw: &mut *c::__bch2_trans_get(fs.raw, 0), fs: PhantomData }
  21         }
  22     }
  23 }
  24
  25 impl<'f> Drop for BtreeTrans<'f> {
  26     fn drop(&mut self) {
  27         unsafe { c::bch2_trans_put(&mut *self.raw) }
  28     }
  29 }
  30
  31 bitflags! {
  32     pub struct BtreeIterFlags: u16 {
  33         const SLOTS = c::BTREE_ITER_SLOTS as u16;
  34         const INTENT = c::BTREE_ITER_INTENT      as u16;
  35         const PREFETCH = c::BTREE_ITER_PREFETCH as u16;
  36         const IS_EXTENTS = c::BTREE_ITER_IS_EXTENTS as u16;
  37         const NOT_EXTENTS = c::BTREE_ITER_NOT_EXTENTS as u16;
  38         const CACHED = c::BTREE_ITER_CACHED     as u16;
  39         const KEY_CACHED = c::BTREE_ITER_WITH_KEY_CACHE as u16;
  40         const WITH_UPDATES = c::BTREE_ITER_WITH_UPDATES as u16;
  41         const WITH_JOURNAL = c::BTREE_ITER_WITH_JOURNAL as u16;
  42         const __ALL_SNAPSHOTS = c::__BTREE_ITER_ALL_SNAPSHOTS as u16;
  43         const ALL_SNAPSHOTS = c::BTREE_ITER_ALL_SNAPSHOTS as u16;
  44         const FILTER_SNAPSHOTS = c::BTREE_ITER_FILTER_SNAPSHOTS as u16;
  45         const NOPRESERVE = c::BTREE_ITER_NOPRESERVE as u16;
  46         const CACHED_NOFILL = c::BTREE_ITER_CACHED_NOFILL as u16;
  47         const KEY_CACHE_FILL = c::BTREE_ITER_KEY_CACHE_FILL as u16;
  48     }
  49 }
  50
  51 pub struct BtreeIter<'t> {
  52     raw:    c::btree_iter,
  53     trans:  PhantomData<&'t BtreeTrans<'t>>,
  54 }
  55
  56 impl<'t> BtreeIter<'t> {
  57     pub fn new(trans: &'t BtreeTrans<'t>, btree: c::btree_id, pos: c::bpos, flags: BtreeIterFlags) -> BtreeIter<'t> {
  58         unsafe {
  59             let mut iter: MaybeUninit<c::btree_iter> = MaybeUninit::uninit();
  60
  61             c::bch2_trans_iter_init_outlined(
  62                 trans.raw,
  63                 iter.as_mut_ptr(),
  64                 btree,
  65                 pos,
  66                 flags.bits as u32);
  67
  68             BtreeIter { raw: iter.assume_init(), trans: PhantomData }
  69         }
  70     }
  71
  72     pub fn peek_upto<'i>(&'i mut self, end: c::bpos) -> Result<Option<BkeySC>, bch_errcode> {
  73         unsafe {
  74             let k = c::bch2_btree_iter_peek_upto(&mut self.raw, end);
  75             errptr_to_result_c(k.k)
  76                 .map(|_| if !k.k.is_null() { Some(BkeySC { k: &*k.k, v: &*k.v, iter: PhantomData }) } else { None } )
  77         }
  78     }
  79
  80     pub fn peek(&mut self) -> Result<Option<BkeySC>, bch_errcode> {
  81         self.peek_upto(SPOS_MAX)
  82     }
  83
  84     pub fn peek_and_restart(&mut self) -> Result<Option<BkeySC>, bch_errcode> {
  85         unsafe {
  86             let k = c::bch2_btree_iter_peek_and_restart_outlined(&mut self.raw);
  87
  88             errptr_to_result_c(k.k)
  89                 .map(|_| if !k.k.is_null() { Some(BkeySC{ k: &*k.k, v: &*k.v, iter: PhantomData }) } else { None } )
  90         }
  91     }
  92
  93     pub fn advance(&mut self) {
  94         unsafe {
  95             c::bch2_btree_iter_advance(&mut self.raw);
  96         }
  97     }
  98 }
  99
 100 impl<'t> Drop for BtreeIter<'t> {
 101     fn drop(&mut self) {
 102         unsafe { c::bch2_trans_iter_exit(self.raw.trans, &mut self.raw) }
 103     }
 104 }
 105
 106 pub struct BtreeNodeIter<'t> {
 107     raw:    c::btree_iter,
 108     trans:  PhantomData<&'t BtreeTrans<'t>>,
 109 }
 110
 111 impl<'t> BtreeNodeIter<'t> {
 112     pub fn new(trans: &'t BtreeTrans<'t>,
 113         btree:      c::btree_id,
 114         pos:        c::bpos,
 115         locks_want: u32,
 116         depth:      u32,
 117         flags: BtreeIterFlags) -> BtreeNodeIter {
 118         unsafe {
 119             let mut iter: MaybeUninit<c::btree_iter> = MaybeUninit::uninit();
 120             c::bch2_trans_node_iter_init(
 121                 trans.raw,
 122                 iter.as_mut_ptr(),
 123                 btree,
 124                 pos,
 125                 locks_want,
 126                 depth,
 127                 flags.bits as u32);
 128
 129             BtreeNodeIter { raw: iter.assume_init(), trans: PhantomData }
 130         }
 131     }
 132
 133     pub fn peek<'i>(&'i mut self) -> Result<Option<&'i c::btree>, bch_errcode> {
 134         unsafe {
 135             let b = c::bch2_btree_iter_peek_node(&mut self.raw);
 136             errptr_to_result_c(b).map(|b| if !b.is_null() { Some(&*b) } else { None })
 137         }
 138     }
 139
 140     pub fn peek_and_restart<'i>(&'i mut self) -> Result<Option<&'i c::btree>, bch_errcode> {
 141         unsafe {
 142             let b = c::bch2_btree_iter_peek_node_and_restart(&mut self.raw);
 143             errptr_to_result_c(b).map(|b| if !b.is_null() { Some(&*b) } else { None })
 144         }
 145     }
 146
 147     pub fn advance<'i>(&'i mut self) {
 148         unsafe {
 149             c::bch2_btree_iter_next_node(&mut self.raw);
 150         }
 151     }
 152
 153     pub fn next<'i>(&'i mut self) -> Result<Option<&'i c::btree>, bch_errcode> {
 154         unsafe {
 155             let b = c::bch2_btree_iter_next_node(&mut self.raw);
 156             errptr_to_result_c(b).map(|b| if !b.is_null() { Some(&*b) } else { None })
 157         }
 158     }
 159 }
 160
 161 impl<'t> Drop for BtreeNodeIter<'t> {
 162     fn drop(&mut self) {
 163         unsafe { c::bch2_trans_iter_exit(self.raw.trans, &mut self.raw) }
 164     }
 165 }
 166
 167 impl<'b, 'f> c::btree {
 168     pub fn to_text(&'b self, fs: &'f Fs) -> BtreeNodeToText<'b, 'f> {
 169         BtreeNodeToText { b: &self, fs }
 170     }
 171
 172     pub fn ondisk_to_text(&'b self, fs: &'f Fs) -> BtreeNodeOndiskToText<'b, 'f> {
 173         BtreeNodeOndiskToText { b: &self, fs }
 174     }
 175 }
 176
 177 pub struct BtreeNodeToText<'b, 'f> {
 178     b:      &'b c::btree,
 179     fs:     &'f Fs,
 180 }
 181
 182 impl<'b, 'f> fmt::Display for BtreeNodeToText<'b, 'f> {
 183     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 184         printbuf_to_formatter(f, |buf| unsafe { c::bch2_btree_node_to_text(buf, self.fs.raw, self.b) })
 185     }
 186 }
 187
 188 pub struct BtreeNodeOndiskToText<'b, 'f> {
 189     b:      &'b c::btree,
 190     fs:     &'f Fs,
 191 }
 192
 193 impl<'b, 'f> fmt::Display for BtreeNodeOndiskToText<'b, 'f> {
 194     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 195         printbuf_to_formatter(f, |buf| unsafe { c::bch2_btree_node_ondisk_to_text(buf, self.fs.raw, self.b) })
 196     }
 197 }