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