Line data Source code
1 : // Copyright 2023 The LevelDB-Go and Pebble Authors. All rights reserved. Use 2 : // of this source code is governed by a BSD-style license that can be found in 3 : // the LICENSE file. 4 : 5 : package invalidating 6 : 7 : import ( 8 : "context" 9 : 10 : "github.com/cockroachdb/pebble/internal/base" 11 : "github.com/cockroachdb/pebble/internal/fastrand" 12 : "github.com/cockroachdb/pebble/internal/invariants" 13 : ) 14 : 15 : // MaybeWrapIfInvariants wraps some iterators with an invalidating iterator. 16 : // MaybeWrapIfInvariants does nothing in non-invariant builds. 17 1 : func MaybeWrapIfInvariants(iter base.InternalIterator) base.InternalIterator { 18 1 : if invariants.Enabled { 19 1 : if fastrand.Uint32n(10) == 1 { 20 1 : return NewIter(iter) 21 1 : } 22 : } 23 1 : return iter 24 : } 25 : 26 : // iter tests unsafe key/value slice reuse by modifying the last 27 : // returned key/value to all 1s. 28 : type iter struct { 29 : iter base.InternalIterator 30 : lastKV *base.InternalKV 31 : ignoreKinds [base.InternalKeyKindMax + 1]bool 32 : err error 33 : } 34 : 35 : // Option configures the behavior of an invalidating iterator. 36 : type Option interface { 37 : apply(*iter) 38 : } 39 : 40 : type funcOpt func(*iter) 41 : 42 1 : func (f funcOpt) apply(i *iter) { f(i) } 43 : 44 : // IgnoreKinds constructs an Option that configures an invalidating iterator to 45 : // skip trashing k/v pairs with the provided key kinds. Some iterators provided 46 : // key stability guarantees for specific key kinds. 47 1 : func IgnoreKinds(kinds ...base.InternalKeyKind) Option { 48 1 : return funcOpt(func(i *iter) { 49 1 : for _, kind := range kinds { 50 1 : i.ignoreKinds[kind] = true 51 1 : } 52 : }) 53 : } 54 : 55 : // NewIter constructs a new invalidating iterator that wraps the provided 56 : // iterator, trashing buffers for previously returned keys. 57 1 : func NewIter(originalIterator base.InternalIterator, opts ...Option) base.TopLevelIterator { 58 1 : i := &iter{iter: originalIterator} 59 1 : for _, opt := range opts { 60 1 : opt.apply(i) 61 1 : } 62 1 : return i 63 : } 64 : 65 1 : func (i *iter) update(kv *base.InternalKV) *base.InternalKV { 66 1 : i.trashLastKV() 67 1 : if kv == nil { 68 1 : i.lastKV = nil 69 1 : return nil 70 1 : } 71 : 72 1 : i.lastKV = &base.InternalKV{ 73 1 : K: kv.K.Clone(), 74 1 : V: base.LazyValue{ 75 1 : ValueOrHandle: append(make([]byte, 0, len(kv.V.ValueOrHandle)), kv.V.ValueOrHandle...), 76 1 : }, 77 1 : } 78 1 : if kv.V.Fetcher != nil { 79 1 : fetcher := new(base.LazyFetcher) 80 1 : *fetcher = *kv.V.Fetcher 81 1 : i.lastKV.V.Fetcher = fetcher 82 1 : } 83 1 : return i.lastKV 84 : } 85 : 86 1 : func (i *iter) trashLastKV() { 87 1 : if i.lastKV == nil { 88 1 : return 89 1 : } 90 1 : if i.ignoreKinds[i.lastKV.Kind()] { 91 1 : return 92 1 : } 93 : 94 1 : if i.lastKV != nil { 95 1 : for j := range i.lastKV.K.UserKey { 96 1 : i.lastKV.K.UserKey[j] = 0xff 97 1 : } 98 1 : i.lastKV.K.Trailer = 0xffffffffffffffff 99 : } 100 1 : for j := range i.lastKV.V.ValueOrHandle { 101 1 : i.lastKV.V.ValueOrHandle[j] = 0xff 102 1 : } 103 1 : if i.lastKV.V.Fetcher != nil { 104 1 : // Not all the LazyFetcher fields are visible, so we zero out the last 105 1 : // value's Fetcher struct entirely. 106 1 : *i.lastKV.V.Fetcher = base.LazyFetcher{} 107 1 : } 108 : } 109 : 110 1 : func (i *iter) SeekGE(key []byte, flags base.SeekGEFlags) *base.InternalKV { 111 1 : return i.update(i.iter.SeekGE(key, flags)) 112 1 : } 113 : 114 1 : func (i *iter) SeekPrefixGE(prefix, key []byte, flags base.SeekGEFlags) *base.InternalKV { 115 1 : return i.update(i.iter.SeekPrefixGE(prefix, key, flags)) 116 1 : } 117 : 118 0 : func (i *iter) SeekPrefixGEStrict(prefix, key []byte, flags base.SeekGEFlags) *base.InternalKV { 119 0 : return i.update(i.iter.SeekPrefixGE(prefix, key, flags)) 120 0 : } 121 : 122 1 : func (i *iter) SeekLT(key []byte, flags base.SeekLTFlags) *base.InternalKV { 123 1 : return i.update(i.iter.SeekLT(key, flags)) 124 1 : } 125 : 126 1 : func (i *iter) First() *base.InternalKV { 127 1 : return i.update(i.iter.First()) 128 1 : } 129 : 130 1 : func (i *iter) Last() *base.InternalKV { 131 1 : return i.update(i.iter.Last()) 132 1 : } 133 : 134 1 : func (i *iter) Next() *base.InternalKV { 135 1 : return i.update(i.iter.Next()) 136 1 : } 137 : 138 1 : func (i *iter) Prev() *base.InternalKV { 139 1 : return i.update(i.iter.Prev()) 140 1 : } 141 : 142 1 : func (i *iter) NextPrefix(succKey []byte) *base.InternalKV { 143 1 : return i.update(i.iter.NextPrefix(succKey)) 144 1 : } 145 : 146 1 : func (i *iter) Error() error { 147 1 : if err := i.iter.Error(); err != nil { 148 1 : return err 149 1 : } 150 1 : return i.err 151 : } 152 : 153 1 : func (i *iter) Close() error { 154 1 : return i.iter.Close() 155 1 : } 156 : 157 1 : func (i *iter) SetBounds(lower, upper []byte) { 158 1 : i.iter.SetBounds(lower, upper) 159 1 : } 160 : 161 0 : func (i *iter) SetContext(ctx context.Context) { 162 0 : i.iter.SetContext(ctx) 163 0 : } 164 : 165 0 : func (i *iter) String() string { 166 0 : return i.iter.String() 167 0 : }