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