go
/
gvisor
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge release-20201216.0-82-g4c4de6644 (automated)

This commit is contained in:
gVisor bot 2021-01-11 21:27:53 +00:00
parent 3ff3110fcd 4c4de66443
commit e524c21569
37 changed files with 1036 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
pkg/buffer/buffer_list.go
View File

@ -38,16 +38,22 @@ func (l *bufferList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *bufferList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *bufferList) Front() *buffer {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *bufferList) Back() *buffer {
return l.tail
}
@ -55,6 +61,8 @@ func (l *bufferList) Back() *buffer {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *bufferList) Len() (count int) {
for e := l.Front(); e != nil; e = (bufferElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *bufferList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *bufferList) PushFront(e *buffer) {
linker := bufferElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *bufferList) PushFront(e *buffer) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *bufferList) PushBack(e *buffer) {
linker := bufferElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *bufferList) PushBack(e *buffer) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *bufferList) PushBackList(m *bufferList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *bufferList) PushBackList(m *bufferList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *bufferList) InsertAfter(b, e *buffer) {
bLinker := bufferElementMapper{}.linkerFor(b)
eLinker := bufferElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *bufferList) InsertAfter(b, e *buffer) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *bufferList) InsertBefore(a, e *buffer) {
aLinker := bufferElementMapper{}.linkerFor(a)
eLinker := bufferElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *bufferList) InsertBefore(a, e *buffer) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *bufferList) Remove(e *buffer) {
linker := bufferElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type bufferEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *bufferEntry) Next() *buffer {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *bufferEntry) Prev() *buffer {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *bufferEntry) SetNext(elem *buffer) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *bufferEntry) SetPrev(elem *buffer) {
e.prev = elem
}

28
pkg/ilist/interface_list.go
View File

@ -57,16 +57,22 @@ func (l *List) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *List) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *List) Front() Element {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *List) Back() Element {
return l.tail
}
@ -74,6 +80,8 @@ func (l *List) Back() Element {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *List) Len() (count int) {
for e := l.Front(); e != nil; e = (ElementMapper{}.linkerFor(e)).Next() {
count++
@ -82,6 +90,8 @@ func (l *List) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *List) PushFront(e Element) {
linker := ElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -96,6 +106,8 @@ func (l *List) PushFront(e Element) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *List) PushBack(e Element) {
linker := ElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -110,6 +122,8 @@ func (l *List) PushBack(e Element) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *List) PushBackList(m *List) {
if l.head == nil {
l.head = m.head
@ -125,6 +139,8 @@ func (l *List) PushBackList(m *List) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *List) InsertAfter(b, e Element) {
bLinker := ElementMapper{}.linkerFor(b)
eLinker := ElementMapper{}.linkerFor(e)
@ -143,6 +159,8 @@ func (l *List) InsertAfter(b, e Element) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *List) InsertBefore(a, e Element) {
aLinker := ElementMapper{}.linkerFor(a)
eLinker := ElementMapper{}.linkerFor(e)
@ -160,6 +178,8 @@ func (l *List) InsertBefore(a, e Element) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *List) Remove(e Element) {
linker := ElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -192,21 +212,29 @@ type Entry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *Entry) Next() Element {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *Entry) Prev() Element {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *Entry) SetNext(elem Element) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *Entry) SetPrev(elem Element) {
e.prev = elem
}

28
pkg/refs/weak_ref_list.go
View File

@ -38,16 +38,22 @@ func (l *weakRefList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *weakRefList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *weakRefList) Front() *WeakRef {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *weakRefList) Back() *WeakRef {
return l.tail
}
@ -55,6 +61,8 @@ func (l *weakRefList) Back() *WeakRef {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *weakRefList) Len() (count int) {
for e := l.Front(); e != nil; e = (weakRefElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *weakRefList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *weakRefList) PushFront(e *WeakRef) {
linker := weakRefElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *weakRefList) PushFront(e *WeakRef) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *weakRefList) PushBack(e *WeakRef) {
linker := weakRefElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *weakRefList) PushBack(e *WeakRef) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *weakRefList) PushBackList(m *weakRefList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *weakRefList) PushBackList(m *weakRefList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *weakRefList) InsertAfter(b, e *WeakRef) {
bLinker := weakRefElementMapper{}.linkerFor(b)
eLinker := weakRefElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *weakRefList) InsertAfter(b, e *WeakRef) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *weakRefList) InsertBefore(a, e *WeakRef) {
aLinker := weakRefElementMapper{}.linkerFor(a)
eLinker := weakRefElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *weakRefList) InsertBefore(a, e *WeakRef) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *weakRefList) Remove(e *WeakRef) {
linker := weakRefElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type weakRefEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *weakRefEntry) Next() *WeakRef {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *weakRefEntry) Prev() *WeakRef {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *weakRefEntry) SetNext(elem *WeakRef) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *weakRefEntry) SetPrev(elem *WeakRef) {
e.prev = elem
}

28
pkg/sentry/fs/dirent_list.go
View File

@ -38,16 +38,22 @@ func (l *direntList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *direntList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *direntList) Front() *Dirent {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *direntList) Back() *Dirent {
return l.tail
}
@ -55,6 +61,8 @@ func (l *direntList) Back() *Dirent {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *direntList) Len() (count int) {
for e := l.Front(); e != nil; e = (direntElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *direntList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *direntList) PushFront(e *Dirent) {
linker := direntElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *direntList) PushFront(e *Dirent) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *direntList) PushBack(e *Dirent) {
linker := direntElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *direntList) PushBack(e *Dirent) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *direntList) PushBackList(m *direntList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *direntList) PushBackList(m *direntList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *direntList) InsertAfter(b, e *Dirent) {
bLinker := direntElementMapper{}.linkerFor(b)
eLinker := direntElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *direntList) InsertAfter(b, e *Dirent) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *direntList) InsertBefore(a, e *Dirent) {
aLinker := direntElementMapper{}.linkerFor(a)
eLinker := direntElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *direntList) InsertBefore(a, e *Dirent) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *direntList) Remove(e *Dirent) {
linker := direntElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type direntEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *direntEntry) Next() *Dirent {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *direntEntry) Prev() *Dirent {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *direntEntry) SetNext(elem *Dirent) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *direntEntry) SetPrev(elem *Dirent) {
e.prev = elem
}

28
pkg/sentry/fs/event_list.go
View File

@ -38,16 +38,22 @@ func (l *eventList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *eventList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *eventList) Front() *Event {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *eventList) Back() *Event {
return l.tail
}
@ -55,6 +61,8 @@ func (l *eventList) Back() *Event {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *eventList) Len() (count int) {
for e := l.Front(); e != nil; e = (eventElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *eventList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *eventList) PushFront(e *Event) {
linker := eventElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *eventList) PushFront(e *Event) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *eventList) PushBack(e *Event) {
linker := eventElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *eventList) PushBack(e *Event) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *eventList) PushBackList(m *eventList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *eventList) PushBackList(m *eventList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *eventList) InsertAfter(b, e *Event) {
bLinker := eventElementMapper{}.linkerFor(b)
eLinker := eventElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *eventList) InsertAfter(b, e *Event) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *eventList) InsertBefore(a, e *Event) {
aLinker := eventElementMapper{}.linkerFor(a)
eLinker := eventElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *eventList) InsertBefore(a, e *Event) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *eventList) Remove(e *Event) {
linker := eventElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type eventEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *eventEntry) Next() *Event {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *eventEntry) Prev() *Event {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *eventEntry) SetNext(elem *Event) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *eventEntry) SetPrev(elem *Event) {
e.prev = elem
}

28
pkg/sentry/fsimpl/fuse/request_list.go
View File

@ -38,16 +38,22 @@ func (l *requestList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *requestList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *requestList) Front() *Request {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *requestList) Back() *Request {
return l.tail
}
@ -55,6 +61,8 @@ func (l *requestList) Back() *Request {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *requestList) Len() (count int) {
for e := l.Front(); e != nil; e = (requestElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *requestList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *requestList) PushFront(e *Request) {
linker := requestElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *requestList) PushFront(e *Request) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *requestList) PushBack(e *Request) {
linker := requestElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *requestList) PushBack(e *Request) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *requestList) PushBackList(m *requestList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *requestList) PushBackList(m *requestList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *requestList) InsertAfter(b, e *Request) {
bLinker := requestElementMapper{}.linkerFor(b)
eLinker := requestElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *requestList) InsertAfter(b, e *Request) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *requestList) InsertBefore(a, e *Request) {
aLinker := requestElementMapper{}.linkerFor(a)
eLinker := requestElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *requestList) InsertBefore(a, e *Request) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *requestList) Remove(e *Request) {
linker := requestElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type requestEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *requestEntry) Next() *Request {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *requestEntry) Prev() *Request {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *requestEntry) SetNext(elem *Request) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *requestEntry) SetPrev(elem *Request) {
e.prev = elem
}

28
pkg/sentry/fsimpl/gofer/dentry_list.go
View File

@ -38,16 +38,22 @@ func (l *dentryList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *dentryList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *dentryList) Front() *dentry {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *dentryList) Back() *dentry {
return l.tail
}
@ -55,6 +61,8 @@ func (l *dentryList) Back() *dentry {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *dentryList) Len() (count int) {
for e := l.Front(); e != nil; e = (dentryElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *dentryList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *dentryList) PushFront(e *dentry) {
linker := dentryElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *dentryList) PushFront(e *dentry) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *dentryList) PushBack(e *dentry) {
linker := dentryElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *dentryList) PushBack(e *dentry) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *dentryList) PushBackList(m *dentryList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *dentryList) PushBackList(m *dentryList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *dentryList) InsertAfter(b, e *dentry) {
bLinker := dentryElementMapper{}.linkerFor(b)
eLinker := dentryElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *dentryList) InsertAfter(b, e *dentry) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *dentryList) InsertBefore(a, e *dentry) {
aLinker := dentryElementMapper{}.linkerFor(a)
eLinker := dentryElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *dentryList) InsertBefore(a, e *dentry) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *dentryList) Remove(e *dentry) {
linker := dentryElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type dentryEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *dentryEntry) Next() *dentry {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *dentryEntry) Prev() *dentry {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *dentryEntry) SetNext(elem *dentry) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *dentryEntry) SetPrev(elem *dentry) {
e.prev = elem
}

28
pkg/sentry/fsimpl/kernfs/dentry_list.go
View File

@ -38,16 +38,22 @@ func (l *dentryList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *dentryList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *dentryList) Front() *Dentry {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *dentryList) Back() *Dentry {
return l.tail
}
@ -55,6 +61,8 @@ func (l *dentryList) Back() *Dentry {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *dentryList) Len() (count int) {
for e := l.Front(); e != nil; e = (dentryElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *dentryList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *dentryList) PushFront(e *Dentry) {
linker := dentryElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *dentryList) PushFront(e *Dentry) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *dentryList) PushBack(e *Dentry) {
linker := dentryElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *dentryList) PushBack(e *Dentry) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *dentryList) PushBackList(m *dentryList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *dentryList) PushBackList(m *dentryList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *dentryList) InsertAfter(b, e *Dentry) {
bLinker := dentryElementMapper{}.linkerFor(b)
eLinker := dentryElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *dentryList) InsertAfter(b, e *Dentry) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *dentryList) InsertBefore(a, e *Dentry) {
aLinker := dentryElementMapper{}.linkerFor(a)
eLinker := dentryElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *dentryList) InsertBefore(a, e *Dentry) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *dentryList) Remove(e *Dentry) {
linker := dentryElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type dentryEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *dentryEntry) Next() *Dentry {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *dentryEntry) Prev() *Dentry {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *dentryEntry) SetNext(elem *Dentry) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *dentryEntry) SetPrev(elem *Dentry) {
e.prev = elem
}

28
pkg/sentry/fsimpl/kernfs/slot_list.go
View File

@ -38,16 +38,22 @@ func (l *slotList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *slotList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *slotList) Front() *slot {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *slotList) Back() *slot {
return l.tail
}
@ -55,6 +61,8 @@ func (l *slotList) Back() *slot {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *slotList) Len() (count int) {
for e := l.Front(); e != nil; e = (slotElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *slotList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *slotList) PushFront(e *slot) {
linker := slotElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *slotList) PushFront(e *slot) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *slotList) PushBack(e *slot) {
linker := slotElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *slotList) PushBack(e *slot) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *slotList) PushBackList(m *slotList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *slotList) PushBackList(m *slotList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *slotList) InsertAfter(b, e *slot) {
bLinker := slotElementMapper{}.linkerFor(b)
eLinker := slotElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *slotList) InsertAfter(b, e *slot) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *slotList) InsertBefore(a, e *slot) {
aLinker := slotElementMapper{}.linkerFor(a)
eLinker := slotElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *slotList) InsertBefore(a, e *slot) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *slotList) Remove(e *slot) {
linker := slotElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type slotEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *slotEntry) Next() *slot {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *slotEntry) Prev() *slot {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *slotEntry) SetNext(elem *slot) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *slotEntry) SetPrev(elem *slot) {
e.prev = elem
}

28
pkg/sentry/fsimpl/tmpfs/dentry_list.go
View File

@ -38,16 +38,22 @@ func (l *dentryList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *dentryList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *dentryList) Front() *dentry {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *dentryList) Back() *dentry {
return l.tail
}
@ -55,6 +61,8 @@ func (l *dentryList) Back() *dentry {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *dentryList) Len() (count int) {
for e := l.Front(); e != nil; e = (dentryElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *dentryList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *dentryList) PushFront(e *dentry) {
linker := dentryElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *dentryList) PushFront(e *dentry) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *dentryList) PushBack(e *dentry) {
linker := dentryElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *dentryList) PushBack(e *dentry) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *dentryList) PushBackList(m *dentryList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *dentryList) PushBackList(m *dentryList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *dentryList) InsertAfter(b, e *dentry) {
bLinker := dentryElementMapper{}.linkerFor(b)
eLinker := dentryElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *dentryList) InsertAfter(b, e *dentry) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *dentryList) InsertBefore(a, e *dentry) {
aLinker := dentryElementMapper{}.linkerFor(a)
eLinker := dentryElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *dentryList) InsertBefore(a, e *dentry) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *dentryList) Remove(e *dentry) {
linker := dentryElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type dentryEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *dentryEntry) Next() *dentry {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *dentryEntry) Prev() *dentry {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *dentryEntry) SetNext(elem *dentry) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *dentryEntry) SetPrev(elem *dentry) {
e.prev = elem
}

28
pkg/sentry/kernel/epoll/epoll_list.go
View File

@ -38,16 +38,22 @@ func (l *pollEntryList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *pollEntryList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *pollEntryList) Front() *pollEntry {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *pollEntryList) Back() *pollEntry {
return l.tail
}
@ -55,6 +61,8 @@ func (l *pollEntryList) Back() *pollEntry {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *pollEntryList) Len() (count int) {
for e := l.Front(); e != nil; e = (pollEntryElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *pollEntryList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *pollEntryList) PushFront(e *pollEntry) {
linker := pollEntryElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *pollEntryList) PushFront(e *pollEntry) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *pollEntryList) PushBack(e *pollEntry) {
linker := pollEntryElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *pollEntryList) PushBack(e *pollEntry) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *pollEntryList) PushBackList(m *pollEntryList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *pollEntryList) PushBackList(m *pollEntryList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *pollEntryList) InsertAfter(b, e *pollEntry) {
bLinker := pollEntryElementMapper{}.linkerFor(b)
eLinker := pollEntryElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *pollEntryList) InsertAfter(b, e *pollEntry) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *pollEntryList) InsertBefore(a, e *pollEntry) {
aLinker := pollEntryElementMapper{}.linkerFor(a)
eLinker := pollEntryElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *pollEntryList) InsertBefore(a, e *pollEntry) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *pollEntryList) Remove(e *pollEntry) {
linker := pollEntryElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type pollEntryEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *pollEntryEntry) Next() *pollEntry {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *pollEntryEntry) Prev() *pollEntry {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *pollEntryEntry) SetNext(elem *pollEntry) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *pollEntryEntry) SetPrev(elem *pollEntry) {
e.prev = elem
}

28
pkg/sentry/kernel/futex/waiter_list.go
View File

@ -38,16 +38,22 @@ func (l *waiterList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *waiterList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *waiterList) Front() *Waiter {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *waiterList) Back() *Waiter {
return l.tail
}
@ -55,6 +61,8 @@ func (l *waiterList) Back() *Waiter {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *waiterList) Len() (count int) {
for e := l.Front(); e != nil; e = (waiterElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *waiterList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *waiterList) PushFront(e *Waiter) {
linker := waiterElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *waiterList) PushFront(e *Waiter) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *waiterList) PushBack(e *Waiter) {
linker := waiterElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *waiterList) PushBack(e *Waiter) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *waiterList) PushBackList(m *waiterList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *waiterList) PushBackList(m *waiterList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *waiterList) InsertAfter(b, e *Waiter) {
bLinker := waiterElementMapper{}.linkerFor(b)
eLinker := waiterElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *waiterList) InsertAfter(b, e *Waiter) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *waiterList) InsertBefore(a, e *Waiter) {
aLinker := waiterElementMapper{}.linkerFor(a)
eLinker := waiterElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *waiterList) InsertBefore(a, e *Waiter) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *waiterList) Remove(e *Waiter) {
linker := waiterElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type waiterEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *waiterEntry) Next() *Waiter {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *waiterEntry) Prev() *Waiter {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *waiterEntry) SetNext(elem *Waiter) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *waiterEntry) SetPrev(elem *Waiter) {
e.prev = elem
}

28
pkg/sentry/kernel/pending_signals_list.go
View File

@ -38,16 +38,22 @@ func (l *pendingSignalList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *pendingSignalList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *pendingSignalList) Front() *pendingSignal {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *pendingSignalList) Back() *pendingSignal {
return l.tail
}
@ -55,6 +61,8 @@ func (l *pendingSignalList) Back() *pendingSignal {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *pendingSignalList) Len() (count int) {
for e := l.Front(); e != nil; e = (pendingSignalElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *pendingSignalList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *pendingSignalList) PushFront(e *pendingSignal) {
linker := pendingSignalElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *pendingSignalList) PushFront(e *pendingSignal) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *pendingSignalList) PushBack(e *pendingSignal) {
linker := pendingSignalElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *pendingSignalList) PushBack(e *pendingSignal) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *pendingSignalList) PushBackList(m *pendingSignalList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *pendingSignalList) PushBackList(m *pendingSignalList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *pendingSignalList) InsertAfter(b, e *pendingSignal) {
bLinker := pendingSignalElementMapper{}.linkerFor(b)
eLinker := pendingSignalElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *pendingSignalList) InsertAfter(b, e *pendingSignal) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *pendingSignalList) InsertBefore(a, e *pendingSignal) {
aLinker := pendingSignalElementMapper{}.linkerFor(a)
eLinker := pendingSignalElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *pendingSignalList) InsertBefore(a, e *pendingSignal) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *pendingSignalList) Remove(e *pendingSignal) {
linker := pendingSignalElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type pendingSignalEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *pendingSignalEntry) Next() *pendingSignal {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *pendingSignalEntry) Prev() *pendingSignal {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *pendingSignalEntry) SetNext(elem *pendingSignal) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *pendingSignalEntry) SetPrev(elem *pendingSignal) {
e.prev = elem
}

28
pkg/sentry/kernel/process_group_list.go
View File

@ -38,16 +38,22 @@ func (l *processGroupList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *processGroupList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *processGroupList) Front() *ProcessGroup {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *processGroupList) Back() *ProcessGroup {
return l.tail
}
@ -55,6 +61,8 @@ func (l *processGroupList) Back() *ProcessGroup {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *processGroupList) Len() (count int) {
for e := l.Front(); e != nil; e = (processGroupElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *processGroupList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *processGroupList) PushFront(e *ProcessGroup) {
linker := processGroupElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *processGroupList) PushFront(e *ProcessGroup) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *processGroupList) PushBack(e *ProcessGroup) {
linker := processGroupElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *processGroupList) PushBack(e *ProcessGroup) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *processGroupList) PushBackList(m *processGroupList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *processGroupList) PushBackList(m *processGroupList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *processGroupList) InsertAfter(b, e *ProcessGroup) {
bLinker := processGroupElementMapper{}.linkerFor(b)
eLinker := processGroupElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *processGroupList) InsertAfter(b, e *ProcessGroup) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *processGroupList) InsertBefore(a, e *ProcessGroup) {
aLinker := processGroupElementMapper{}.linkerFor(a)
eLinker := processGroupElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *processGroupList) InsertBefore(a, e *ProcessGroup) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *processGroupList) Remove(e *ProcessGroup) {
linker := processGroupElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type processGroupEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *processGroupEntry) Next() *ProcessGroup {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *processGroupEntry) Prev() *ProcessGroup {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *processGroupEntry) SetNext(elem *ProcessGroup) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *processGroupEntry) SetPrev(elem *ProcessGroup) {
e.prev = elem
}

28
pkg/sentry/kernel/semaphore/waiter_list.go
View File

@ -38,16 +38,22 @@ func (l *waiterList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *waiterList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *waiterList) Front() *waiter {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *waiterList) Back() *waiter {
return l.tail
}
@ -55,6 +61,8 @@ func (l *waiterList) Back() *waiter {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *waiterList) Len() (count int) {
for e := l.Front(); e != nil; e = (waiterElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *waiterList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *waiterList) PushFront(e *waiter) {
linker := waiterElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *waiterList) PushFront(e *waiter) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *waiterList) PushBack(e *waiter) {
linker := waiterElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *waiterList) PushBack(e *waiter) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *waiterList) PushBackList(m *waiterList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *waiterList) PushBackList(m *waiterList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *waiterList) InsertAfter(b, e *waiter) {
bLinker := waiterElementMapper{}.linkerFor(b)
eLinker := waiterElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *waiterList) InsertAfter(b, e *waiter) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *waiterList) InsertBefore(a, e *waiter) {
aLinker := waiterElementMapper{}.linkerFor(a)
eLinker := waiterElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *waiterList) InsertBefore(a, e *waiter) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *waiterList) Remove(e *waiter) {
linker := waiterElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type waiterEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *waiterEntry) Next() *waiter {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *waiterEntry) Prev() *waiter {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *waiterEntry) SetNext(elem *waiter) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *waiterEntry) SetPrev(elem *waiter) {
e.prev = elem
}

28
pkg/sentry/kernel/session_list.go
View File

@ -38,16 +38,22 @@ func (l *sessionList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *sessionList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *sessionList) Front() *Session {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *sessionList) Back() *Session {
return l.tail
}
@ -55,6 +61,8 @@ func (l *sessionList) Back() *Session {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *sessionList) Len() (count int) {
for e := l.Front(); e != nil; e = (sessionElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *sessionList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *sessionList) PushFront(e *Session) {
linker := sessionElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *sessionList) PushFront(e *Session) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *sessionList) PushBack(e *Session) {
linker := sessionElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *sessionList) PushBack(e *Session) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *sessionList) PushBackList(m *sessionList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *sessionList) PushBackList(m *sessionList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *sessionList) InsertAfter(b, e *Session) {
bLinker := sessionElementMapper{}.linkerFor(b)
eLinker := sessionElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *sessionList) InsertAfter(b, e *Session) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *sessionList) InsertBefore(a, e *Session) {
aLinker := sessionElementMapper{}.linkerFor(a)
eLinker := sessionElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *sessionList) InsertBefore(a, e *Session) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *sessionList) Remove(e *Session) {
linker := sessionElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type sessionEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *sessionEntry) Next() *Session {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *sessionEntry) Prev() *Session {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *sessionEntry) SetNext(elem *Session) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *sessionEntry) SetPrev(elem *Session) {
e.prev = elem
}

28
pkg/sentry/kernel/socket_list.go
View File

@ -38,16 +38,22 @@ func (l *socketList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *socketList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *socketList) Front() *SocketRecordVFS1 {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *socketList) Back() *SocketRecordVFS1 {
return l.tail
}
@ -55,6 +61,8 @@ func (l *socketList) Back() *SocketRecordVFS1 {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *socketList) Len() (count int) {
for e := l.Front(); e != nil; e = (socketElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *socketList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *socketList) PushFront(e *SocketRecordVFS1) {
linker := socketElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *socketList) PushFront(e *SocketRecordVFS1) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *socketList) PushBack(e *SocketRecordVFS1) {
linker := socketElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *socketList) PushBack(e *SocketRecordVFS1) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *socketList) PushBackList(m *socketList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *socketList) PushBackList(m *socketList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *socketList) InsertAfter(b, e *SocketRecordVFS1) {
bLinker := socketElementMapper{}.linkerFor(b)
eLinker := socketElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *socketList) InsertAfter(b, e *SocketRecordVFS1) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *socketList) InsertBefore(a, e *SocketRecordVFS1) {
aLinker := socketElementMapper{}.linkerFor(a)
eLinker := socketElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *socketList) InsertBefore(a, e *SocketRecordVFS1) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *socketList) Remove(e *SocketRecordVFS1) {
linker := socketElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type socketEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *socketEntry) Next() *SocketRecordVFS1 {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *socketEntry) Prev() *SocketRecordVFS1 {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *socketEntry) SetNext(elem *SocketRecordVFS1) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *socketEntry) SetPrev(elem *SocketRecordVFS1) {
e.prev = elem
}

28
pkg/sentry/kernel/task_list.go
View File

@ -38,16 +38,22 @@ func (l *taskList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *taskList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *taskList) Front() *Task {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *taskList) Back() *Task {
return l.tail
}
@ -55,6 +61,8 @@ func (l *taskList) Back() *Task {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *taskList) Len() (count int) {
for e := l.Front(); e != nil; e = (taskElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *taskList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *taskList) PushFront(e *Task) {
linker := taskElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *taskList) PushFront(e *Task) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *taskList) PushBack(e *Task) {
linker := taskElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *taskList) PushBack(e *Task) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *taskList) PushBackList(m *taskList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *taskList) PushBackList(m *taskList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *taskList) InsertAfter(b, e *Task) {
bLinker := taskElementMapper{}.linkerFor(b)
eLinker := taskElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *taskList) InsertAfter(b, e *Task) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *taskList) InsertBefore(a, e *Task) {
aLinker := taskElementMapper{}.linkerFor(a)
eLinker := taskElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *taskList) InsertBefore(a, e *Task) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *taskList) Remove(e *Task) {
linker := taskElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type taskEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *taskEntry) Next() *Task {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *taskEntry) Prev() *Task {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *taskEntry) SetNext(elem *Task) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *taskEntry) SetPrev(elem *Task) {
e.prev = elem
}

28
pkg/sentry/mm/io_list.go
View File

@ -38,16 +38,22 @@ func (l *ioList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *ioList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *ioList) Front() *ioResult {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *ioList) Back() *ioResult {
return l.tail
}
@ -55,6 +61,8 @@ func (l *ioList) Back() *ioResult {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *ioList) Len() (count int) {
for e := l.Front(); e != nil; e = (ioElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *ioList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *ioList) PushFront(e *ioResult) {
linker := ioElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *ioList) PushFront(e *ioResult) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *ioList) PushBack(e *ioResult) {
linker := ioElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *ioList) PushBack(e *ioResult) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *ioList) PushBackList(m *ioList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *ioList) PushBackList(m *ioList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *ioList) InsertAfter(b, e *ioResult) {
bLinker := ioElementMapper{}.linkerFor(b)
eLinker := ioElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *ioList) InsertAfter(b, e *ioResult) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *ioList) InsertBefore(a, e *ioResult) {
aLinker := ioElementMapper{}.linkerFor(a)
eLinker := ioElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *ioList) InsertBefore(a, e *ioResult) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *ioList) Remove(e *ioResult) {
linker := ioElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type ioEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *ioEntry) Next() *ioResult {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *ioEntry) Prev() *ioResult {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *ioEntry) SetNext(elem *ioResult) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *ioEntry) SetPrev(elem *ioResult) {
e.prev = elem
}

28
pkg/sentry/socket/unix/transport/transport_message_list.go
View File

@ -38,16 +38,22 @@ func (l *messageList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *messageList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *messageList) Front() *message {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *messageList) Back() *message {
return l.tail
}
@ -55,6 +61,8 @@ func (l *messageList) Back() *message {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *messageList) Len() (count int) {
for e := l.Front(); e != nil; e = (messageElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *messageList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *messageList) PushFront(e *message) {
linker := messageElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *messageList) PushFront(e *message) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *messageList) PushBack(e *message) {
linker := messageElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *messageList) PushBack(e *message) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *messageList) PushBackList(m *messageList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *messageList) PushBackList(m *messageList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *messageList) InsertAfter(b, e *message) {
bLinker := messageElementMapper{}.linkerFor(b)
eLinker := messageElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *messageList) InsertAfter(b, e *message) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *messageList) InsertBefore(a, e *message) {
aLinker := messageElementMapper{}.linkerFor(a)
eLinker := messageElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *messageList) InsertBefore(a, e *message) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *messageList) Remove(e *message) {
linker := messageElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type messageEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *messageEntry) Next() *message {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *messageEntry) Prev() *message {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *messageEntry) SetNext(elem *message) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *messageEntry) SetPrev(elem *message) {
e.prev = elem
}

28
pkg/sentry/vfs/epoll_interest_list.go
View File

@ -38,16 +38,22 @@ func (l *epollInterestList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *epollInterestList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *epollInterestList) Front() *epollInterest {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *epollInterestList) Back() *epollInterest {
return l.tail
}
@ -55,6 +61,8 @@ func (l *epollInterestList) Back() *epollInterest {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *epollInterestList) Len() (count int) {
for e := l.Front(); e != nil; e = (epollInterestElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *epollInterestList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *epollInterestList) PushFront(e *epollInterest) {
linker := epollInterestElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *epollInterestList) PushFront(e *epollInterest) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *epollInterestList) PushBack(e *epollInterest) {
linker := epollInterestElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *epollInterestList) PushBack(e *epollInterest) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *epollInterestList) PushBackList(m *epollInterestList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *epollInterestList) PushBackList(m *epollInterestList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *epollInterestList) InsertAfter(b, e *epollInterest) {
bLinker := epollInterestElementMapper{}.linkerFor(b)
eLinker := epollInterestElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *epollInterestList) InsertAfter(b, e *epollInterest) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *epollInterestList) InsertBefore(a, e *epollInterest) {
aLinker := epollInterestElementMapper{}.linkerFor(a)
eLinker := epollInterestElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *epollInterestList) InsertBefore(a, e *epollInterest) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *epollInterestList) Remove(e *epollInterest) {
linker := epollInterestElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type epollInterestEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *epollInterestEntry) Next() *epollInterest {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *epollInterestEntry) Prev() *epollInterest {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *epollInterestEntry) SetNext(elem *epollInterest) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *epollInterestEntry) SetPrev(elem *epollInterest) {
e.prev = elem
}

28
pkg/sentry/vfs/event_list.go
View File

@ -38,16 +38,22 @@ func (l *eventList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *eventList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *eventList) Front() *Event {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *eventList) Back() *Event {
return l.tail
}
@ -55,6 +61,8 @@ func (l *eventList) Back() *Event {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *eventList) Len() (count int) {
for e := l.Front(); e != nil; e = (eventElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *eventList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *eventList) PushFront(e *Event) {
linker := eventElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *eventList) PushFront(e *Event) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *eventList) PushBack(e *Event) {
linker := eventElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *eventList) PushBack(e *Event) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *eventList) PushBackList(m *eventList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *eventList) PushBackList(m *eventList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *eventList) InsertAfter(b, e *Event) {
bLinker := eventElementMapper{}.linkerFor(b)
eLinker := eventElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *eventList) InsertAfter(b, e *Event) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *eventList) InsertBefore(a, e *Event) {
aLinker := eventElementMapper{}.linkerFor(a)
eLinker := eventElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *eventList) InsertBefore(a, e *Event) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *eventList) Remove(e *Event) {
linker := eventElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type eventEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *eventEntry) Next() *Event {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *eventEntry) Prev() *Event {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *eventEntry) SetNext(elem *Event) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *eventEntry) SetPrev(elem *Event) {
e.prev = elem
}

28
pkg/state/complete_list.go
View File

@ -38,16 +38,22 @@ func (l *completeList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *completeList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *completeList) Front() *objectDecodeState {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *completeList) Back() *objectDecodeState {
return l.tail
}
@ -55,6 +61,8 @@ func (l *completeList) Back() *objectDecodeState {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *completeList) Len() (count int) {
for e := l.Front(); e != nil; e = (completeElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *completeList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *completeList) PushFront(e *objectDecodeState) {
linker := completeElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *completeList) PushFront(e *objectDecodeState) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *completeList) PushBack(e *objectDecodeState) {
linker := completeElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *completeList) PushBack(e *objectDecodeState) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *completeList) PushBackList(m *completeList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *completeList) PushBackList(m *completeList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *completeList) InsertAfter(b, e *objectDecodeState) {
bLinker := completeElementMapper{}.linkerFor(b)
eLinker := completeElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *completeList) InsertAfter(b, e *objectDecodeState) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *completeList) InsertBefore(a, e *objectDecodeState) {
aLinker := completeElementMapper{}.linkerFor(a)
eLinker := completeElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *completeList) InsertBefore(a, e *objectDecodeState) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *completeList) Remove(e *objectDecodeState) {
linker := completeElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type completeEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *completeEntry) Next() *objectDecodeState {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *completeEntry) Prev() *objectDecodeState {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *completeEntry) SetNext(elem *objectDecodeState) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *completeEntry) SetPrev(elem *objectDecodeState) {
e.prev = elem
}

28
pkg/state/deferred_list.go
View File

@ -23,16 +23,22 @@ func (l *deferredList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *deferredList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *deferredList) Front() *objectEncodeState {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *deferredList) Back() *objectEncodeState {
return l.tail
}
@ -40,6 +46,8 @@ func (l *deferredList) Back() *objectEncodeState {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *deferredList) Len() (count int) {
for e := l.Front(); e != nil; e = (deferredMapper{}.linkerFor(e)).Next() {
count++
@ -48,6 +56,8 @@ func (l *deferredList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *deferredList) PushFront(e *objectEncodeState) {
linker := deferredMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -62,6 +72,8 @@ func (l *deferredList) PushFront(e *objectEncodeState) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *deferredList) PushBack(e *objectEncodeState) {
linker := deferredMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -76,6 +88,8 @@ func (l *deferredList) PushBack(e *objectEncodeState) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *deferredList) PushBackList(m *deferredList) {
if l.head == nil {
l.head = m.head
@ -91,6 +105,8 @@ func (l *deferredList) PushBackList(m *deferredList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *deferredList) InsertAfter(b, e *objectEncodeState) {
bLinker := deferredMapper{}.linkerFor(b)
eLinker := deferredMapper{}.linkerFor(e)
@ -109,6 +125,8 @@ func (l *deferredList) InsertAfter(b, e *objectEncodeState) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *deferredList) InsertBefore(a, e *objectEncodeState) {
aLinker := deferredMapper{}.linkerFor(a)
eLinker := deferredMapper{}.linkerFor(e)
@ -126,6 +144,8 @@ func (l *deferredList) InsertBefore(a, e *objectEncodeState) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *deferredList) Remove(e *objectEncodeState) {
linker := deferredMapper{}.linkerFor(e)
prev := linker.Prev()
@ -158,21 +178,29 @@ type deferredEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *deferredEntry) Next() *objectEncodeState {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *deferredEntry) Prev() *objectEncodeState {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *deferredEntry) SetNext(elem *objectEncodeState) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *deferredEntry) SetPrev(elem *objectEncodeState) {
e.prev = elem
}

28
pkg/tcpip/network/fragmentation/reassembler_list.go
View File

@ -38,16 +38,22 @@ func (l *reassemblerList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *reassemblerList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *reassemblerList) Front() *reassembler {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *reassemblerList) Back() *reassembler {
return l.tail
}
@ -55,6 +61,8 @@ func (l *reassemblerList) Back() *reassembler {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *reassemblerList) Len() (count int) {
for e := l.Front(); e != nil; e = (reassemblerElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *reassemblerList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *reassemblerList) PushFront(e *reassembler) {
linker := reassemblerElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *reassemblerList) PushFront(e *reassembler) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *reassemblerList) PushBack(e *reassembler) {
linker := reassemblerElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *reassemblerList) PushBack(e *reassembler) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *reassemblerList) PushBackList(m *reassemblerList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *reassemblerList) PushBackList(m *reassemblerList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *reassemblerList) InsertAfter(b, e *reassembler) {
bLinker := reassemblerElementMapper{}.linkerFor(b)
eLinker := reassemblerElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *reassemblerList) InsertAfter(b, e *reassembler) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *reassemblerList) InsertBefore(a, e *reassembler) {
aLinker := reassemblerElementMapper{}.linkerFor(a)
eLinker := reassemblerElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *reassemblerList) InsertBefore(a, e *reassembler) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *reassemblerList) Remove(e *reassembler) {
linker := reassemblerElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type reassemblerEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *reassemblerEntry) Next() *reassembler {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *reassemblerEntry) Prev() *reassembler {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *reassemblerEntry) SetNext(elem *reassembler) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *reassemblerEntry) SetPrev(elem *reassembler) {
e.prev = elem
}

28
pkg/tcpip/sock_err_list.go
View File

@ -38,16 +38,22 @@ func (l *sockErrorList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *sockErrorList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *sockErrorList) Front() *SockError {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *sockErrorList) Back() *SockError {
return l.tail
}
@ -55,6 +61,8 @@ func (l *sockErrorList) Back() *SockError {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *sockErrorList) Len() (count int) {
for e := l.Front(); e != nil; e = (sockErrorElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *sockErrorList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *sockErrorList) PushFront(e *SockError) {
linker := sockErrorElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *sockErrorList) PushFront(e *SockError) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *sockErrorList) PushBack(e *SockError) {
linker := sockErrorElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *sockErrorList) PushBack(e *SockError) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *sockErrorList) PushBackList(m *sockErrorList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *sockErrorList) PushBackList(m *sockErrorList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *sockErrorList) InsertAfter(b, e *SockError) {
bLinker := sockErrorElementMapper{}.linkerFor(b)
eLinker := sockErrorElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *sockErrorList) InsertAfter(b, e *SockError) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *sockErrorList) InsertBefore(a, e *SockError) {
aLinker := sockErrorElementMapper{}.linkerFor(a)
eLinker := sockErrorElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *sockErrorList) InsertBefore(a, e *SockError) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *sockErrorList) Remove(e *SockError) {
linker := sockErrorElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type sockErrorEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *sockErrorEntry) Next() *SockError {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *sockErrorEntry) Prev() *SockError {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *sockErrorEntry) SetNext(elem *SockError) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *sockErrorEntry) SetPrev(elem *SockError) {
e.prev = elem
}

28
pkg/tcpip/stack/linkaddrentry_list.go
View File

@ -38,16 +38,22 @@ func (l *linkAddrEntryList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *linkAddrEntryList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *linkAddrEntryList) Front() *linkAddrEntry {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *linkAddrEntryList) Back() *linkAddrEntry {
return l.tail
}
@ -55,6 +61,8 @@ func (l *linkAddrEntryList) Back() *linkAddrEntry {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *linkAddrEntryList) Len() (count int) {
for e := l.Front(); e != nil; e = (linkAddrEntryElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *linkAddrEntryList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *linkAddrEntryList) PushFront(e *linkAddrEntry) {
linker := linkAddrEntryElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *linkAddrEntryList) PushFront(e *linkAddrEntry) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *linkAddrEntryList) PushBack(e *linkAddrEntry) {
linker := linkAddrEntryElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *linkAddrEntryList) PushBack(e *linkAddrEntry) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *linkAddrEntryList) PushBackList(m *linkAddrEntryList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *linkAddrEntryList) PushBackList(m *linkAddrEntryList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *linkAddrEntryList) InsertAfter(b, e *linkAddrEntry) {
bLinker := linkAddrEntryElementMapper{}.linkerFor(b)
eLinker := linkAddrEntryElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *linkAddrEntryList) InsertAfter(b, e *linkAddrEntry) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *linkAddrEntryList) InsertBefore(a, e *linkAddrEntry) {
aLinker := linkAddrEntryElementMapper{}.linkerFor(a)
eLinker := linkAddrEntryElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *linkAddrEntryList) InsertBefore(a, e *linkAddrEntry) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *linkAddrEntryList) Remove(e *linkAddrEntry) {
linker := linkAddrEntryElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type linkAddrEntryEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *linkAddrEntryEntry) Next() *linkAddrEntry {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *linkAddrEntryEntry) Prev() *linkAddrEntry {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *linkAddrEntryEntry) SetNext(elem *linkAddrEntry) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *linkAddrEntryEntry) SetPrev(elem *linkAddrEntry) {
e.prev = elem
}

28
pkg/tcpip/stack/neighbor_entry_list.go
View File

@ -38,16 +38,22 @@ func (l *neighborEntryList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *neighborEntryList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *neighborEntryList) Front() *neighborEntry {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *neighborEntryList) Back() *neighborEntry {
return l.tail
}
@ -55,6 +61,8 @@ func (l *neighborEntryList) Back() *neighborEntry {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *neighborEntryList) Len() (count int) {
for e := l.Front(); e != nil; e = (neighborEntryElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *neighborEntryList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *neighborEntryList) PushFront(e *neighborEntry) {
linker := neighborEntryElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *neighborEntryList) PushFront(e *neighborEntry) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *neighborEntryList) PushBack(e *neighborEntry) {
linker := neighborEntryElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *neighborEntryList) PushBack(e *neighborEntry) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *neighborEntryList) PushBackList(m *neighborEntryList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *neighborEntryList) PushBackList(m *neighborEntryList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *neighborEntryList) InsertAfter(b, e *neighborEntry) {
bLinker := neighborEntryElementMapper{}.linkerFor(b)
eLinker := neighborEntryElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *neighborEntryList) InsertAfter(b, e *neighborEntry) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *neighborEntryList) InsertBefore(a, e *neighborEntry) {
aLinker := neighborEntryElementMapper{}.linkerFor(a)
eLinker := neighborEntryElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *neighborEntryList) InsertBefore(a, e *neighborEntry) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *neighborEntryList) Remove(e *neighborEntry) {
linker := neighborEntryElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type neighborEntryEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *neighborEntryEntry) Next() *neighborEntry {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *neighborEntryEntry) Prev() *neighborEntry {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *neighborEntryEntry) SetNext(elem *neighborEntry) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *neighborEntryEntry) SetPrev(elem *neighborEntry) {
e.prev = elem
}

28
pkg/tcpip/stack/packet_buffer_list.go
View File

@ -38,16 +38,22 @@ func (l *PacketBufferList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *PacketBufferList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *PacketBufferList) Front() *PacketBuffer {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *PacketBufferList) Back() *PacketBuffer {
return l.tail
}
@ -55,6 +61,8 @@ func (l *PacketBufferList) Back() *PacketBuffer {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *PacketBufferList) Len() (count int) {
for e := l.Front(); e != nil; e = (PacketBufferElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *PacketBufferList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *PacketBufferList) PushFront(e *PacketBuffer) {
linker := PacketBufferElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *PacketBufferList) PushFront(e *PacketBuffer) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *PacketBufferList) PushBack(e *PacketBuffer) {
linker := PacketBufferElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *PacketBufferList) PushBack(e *PacketBuffer) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *PacketBufferList) PushBackList(m *PacketBufferList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *PacketBufferList) PushBackList(m *PacketBufferList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *PacketBufferList) InsertAfter(b, e *PacketBuffer) {
bLinker := PacketBufferElementMapper{}.linkerFor(b)
eLinker := PacketBufferElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *PacketBufferList) InsertAfter(b, e *PacketBuffer) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *PacketBufferList) InsertBefore(a, e *PacketBuffer) {
aLinker := PacketBufferElementMapper{}.linkerFor(a)
eLinker := PacketBufferElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *PacketBufferList) InsertBefore(a, e *PacketBuffer) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *PacketBufferList) Remove(e *PacketBuffer) {
linker := PacketBufferElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type PacketBufferEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *PacketBufferEntry) Next() *PacketBuffer {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *PacketBufferEntry) Prev() *PacketBuffer {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *PacketBufferEntry) SetNext(elem *PacketBuffer) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *PacketBufferEntry) SetPrev(elem *PacketBuffer) {
e.prev = elem
}

28
pkg/tcpip/stack/tuple_list.go
View File

@ -38,16 +38,22 @@ func (l *tupleList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *tupleList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *tupleList) Front() *tuple {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *tupleList) Back() *tuple {
return l.tail
}
@ -55,6 +61,8 @@ func (l *tupleList) Back() *tuple {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *tupleList) Len() (count int) {
for e := l.Front(); e != nil; e = (tupleElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *tupleList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *tupleList) PushFront(e *tuple) {
linker := tupleElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *tupleList) PushFront(e *tuple) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *tupleList) PushBack(e *tuple) {
linker := tupleElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *tupleList) PushBack(e *tuple) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *tupleList) PushBackList(m *tupleList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *tupleList) PushBackList(m *tupleList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *tupleList) InsertAfter(b, e *tuple) {
bLinker := tupleElementMapper{}.linkerFor(b)
eLinker := tupleElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *tupleList) InsertAfter(b, e *tuple) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *tupleList) InsertBefore(a, e *tuple) {
aLinker := tupleElementMapper{}.linkerFor(a)
eLinker := tupleElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *tupleList) InsertBefore(a, e *tuple) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *tupleList) Remove(e *tuple) {
linker := tupleElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type tupleEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *tupleEntry) Next() *tuple {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *tupleEntry) Prev() *tuple {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *tupleEntry) SetNext(elem *tuple) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *tupleEntry) SetPrev(elem *tuple) {
e.prev = elem
}

28
pkg/tcpip/transport/icmp/icmp_packet_list.go
View File

@ -38,16 +38,22 @@ func (l *icmpPacketList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *icmpPacketList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *icmpPacketList) Front() *icmpPacket {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *icmpPacketList) Back() *icmpPacket {
return l.tail
}
@ -55,6 +61,8 @@ func (l *icmpPacketList) Back() *icmpPacket {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *icmpPacketList) Len() (count int) {
for e := l.Front(); e != nil; e = (icmpPacketElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *icmpPacketList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *icmpPacketList) PushFront(e *icmpPacket) {
linker := icmpPacketElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *icmpPacketList) PushFront(e *icmpPacket) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *icmpPacketList) PushBack(e *icmpPacket) {
linker := icmpPacketElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *icmpPacketList) PushBack(e *icmpPacket) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *icmpPacketList) PushBackList(m *icmpPacketList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *icmpPacketList) PushBackList(m *icmpPacketList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *icmpPacketList) InsertAfter(b, e *icmpPacket) {
bLinker := icmpPacketElementMapper{}.linkerFor(b)
eLinker := icmpPacketElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *icmpPacketList) InsertAfter(b, e *icmpPacket) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *icmpPacketList) InsertBefore(a, e *icmpPacket) {
aLinker := icmpPacketElementMapper{}.linkerFor(a)
eLinker := icmpPacketElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *icmpPacketList) InsertBefore(a, e *icmpPacket) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *icmpPacketList) Remove(e *icmpPacket) {
linker := icmpPacketElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type icmpPacketEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *icmpPacketEntry) Next() *icmpPacket {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *icmpPacketEntry) Prev() *icmpPacket {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *icmpPacketEntry) SetNext(elem *icmpPacket) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *icmpPacketEntry) SetPrev(elem *icmpPacket) {
e.prev = elem
}

28
pkg/tcpip/transport/packet/packet_list.go
View File

@ -38,16 +38,22 @@ func (l *packetList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *packetList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *packetList) Front() *packet {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *packetList) Back() *packet {
return l.tail
}
@ -55,6 +61,8 @@ func (l *packetList) Back() *packet {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *packetList) Len() (count int) {
for e := l.Front(); e != nil; e = (packetElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *packetList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *packetList) PushFront(e *packet) {
linker := packetElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *packetList) PushFront(e *packet) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *packetList) PushBack(e *packet) {
linker := packetElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *packetList) PushBack(e *packet) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *packetList) PushBackList(m *packetList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *packetList) PushBackList(m *packetList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *packetList) InsertAfter(b, e *packet) {
bLinker := packetElementMapper{}.linkerFor(b)
eLinker := packetElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *packetList) InsertAfter(b, e *packet) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *packetList) InsertBefore(a, e *packet) {
aLinker := packetElementMapper{}.linkerFor(a)
eLinker := packetElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *packetList) InsertBefore(a, e *packet) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *packetList) Remove(e *packet) {
linker := packetElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type packetEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *packetEntry) Next() *packet {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *packetEntry) Prev() *packet {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *packetEntry) SetNext(elem *packet) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *packetEntry) SetPrev(elem *packet) {
e.prev = elem
}

28
pkg/tcpip/transport/raw/raw_packet_list.go
View File

@ -38,16 +38,22 @@ func (l *rawPacketList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *rawPacketList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *rawPacketList) Front() *rawPacket {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *rawPacketList) Back() *rawPacket {
return l.tail
}
@ -55,6 +61,8 @@ func (l *rawPacketList) Back() *rawPacket {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *rawPacketList) Len() (count int) {
for e := l.Front(); e != nil; e = (rawPacketElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *rawPacketList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *rawPacketList) PushFront(e *rawPacket) {
linker := rawPacketElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *rawPacketList) PushFront(e *rawPacket) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *rawPacketList) PushBack(e *rawPacket) {
linker := rawPacketElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *rawPacketList) PushBack(e *rawPacket) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *rawPacketList) PushBackList(m *rawPacketList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *rawPacketList) PushBackList(m *rawPacketList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *rawPacketList) InsertAfter(b, e *rawPacket) {
bLinker := rawPacketElementMapper{}.linkerFor(b)
eLinker := rawPacketElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *rawPacketList) InsertAfter(b, e *rawPacket) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *rawPacketList) InsertBefore(a, e *rawPacket) {
aLinker := rawPacketElementMapper{}.linkerFor(a)
eLinker := rawPacketElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *rawPacketList) InsertBefore(a, e *rawPacket) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *rawPacketList) Remove(e *rawPacket) {
linker := rawPacketElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type rawPacketEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *rawPacketEntry) Next() *rawPacket {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *rawPacketEntry) Prev() *rawPacket {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *rawPacketEntry) SetNext(elem *rawPacket) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *rawPacketEntry) SetPrev(elem *rawPacket) {
e.prev = elem
}

28
pkg/tcpip/transport/tcp/tcp_endpoint_list.go
View File

@ -38,16 +38,22 @@ func (l *endpointList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *endpointList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *endpointList) Front() *endpoint {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *endpointList) Back() *endpoint {
return l.tail
}
@ -55,6 +61,8 @@ func (l *endpointList) Back() *endpoint {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *endpointList) Len() (count int) {
for e := l.Front(); e != nil; e = (endpointElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *endpointList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *endpointList) PushFront(e *endpoint) {
linker := endpointElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *endpointList) PushFront(e *endpoint) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *endpointList) PushBack(e *endpoint) {
linker := endpointElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *endpointList) PushBack(e *endpoint) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *endpointList) PushBackList(m *endpointList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *endpointList) PushBackList(m *endpointList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *endpointList) InsertAfter(b, e *endpoint) {
bLinker := endpointElementMapper{}.linkerFor(b)
eLinker := endpointElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *endpointList) InsertAfter(b, e *endpoint) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *endpointList) InsertBefore(a, e *endpoint) {
aLinker := endpointElementMapper{}.linkerFor(a)
eLinker := endpointElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *endpointList) InsertBefore(a, e *endpoint) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *endpointList) Remove(e *endpoint) {
linker := endpointElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type endpointEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *endpointEntry) Next() *endpoint {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *endpointEntry) Prev() *endpoint {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *endpointEntry) SetNext(elem *endpoint) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *endpointEntry) SetPrev(elem *endpoint) {
e.prev = elem
}

28
pkg/tcpip/transport/tcp/tcp_segment_list.go
View File

@ -38,16 +38,22 @@ func (l *segmentList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *segmentList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *segmentList) Front() *segment {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *segmentList) Back() *segment {
return l.tail
}
@ -55,6 +61,8 @@ func (l *segmentList) Back() *segment {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *segmentList) Len() (count int) {
for e := l.Front(); e != nil; e = (segmentElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *segmentList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *segmentList) PushFront(e *segment) {
linker := segmentElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *segmentList) PushFront(e *segment) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *segmentList) PushBack(e *segment) {
linker := segmentElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *segmentList) PushBack(e *segment) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *segmentList) PushBackList(m *segmentList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *segmentList) PushBackList(m *segmentList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *segmentList) InsertAfter(b, e *segment) {
bLinker := segmentElementMapper{}.linkerFor(b)
eLinker := segmentElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *segmentList) InsertAfter(b, e *segment) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *segmentList) InsertBefore(a, e *segment) {
aLinker := segmentElementMapper{}.linkerFor(a)
eLinker := segmentElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *segmentList) InsertBefore(a, e *segment) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *segmentList) Remove(e *segment) {
linker := segmentElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type segmentEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *segmentEntry) Next() *segment {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *segmentEntry) Prev() *segment {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *segmentEntry) SetNext(elem *segment) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *segmentEntry) SetPrev(elem *segment) {
e.prev = elem
}

28
pkg/tcpip/transport/udp/udp_packet_list.go
View File

@ -38,16 +38,22 @@ func (l *udpPacketList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *udpPacketList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *udpPacketList) Front() *udpPacket {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *udpPacketList) Back() *udpPacket {
return l.tail
}
@ -55,6 +61,8 @@ func (l *udpPacketList) Back() *udpPacket {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *udpPacketList) Len() (count int) {
for e := l.Front(); e != nil; e = (udpPacketElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *udpPacketList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *udpPacketList) PushFront(e *udpPacket) {
linker := udpPacketElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *udpPacketList) PushFront(e *udpPacket) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *udpPacketList) PushBack(e *udpPacket) {
linker := udpPacketElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *udpPacketList) PushBack(e *udpPacket) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *udpPacketList) PushBackList(m *udpPacketList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *udpPacketList) PushBackList(m *udpPacketList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *udpPacketList) InsertAfter(b, e *udpPacket) {
bLinker := udpPacketElementMapper{}.linkerFor(b)
eLinker := udpPacketElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *udpPacketList) InsertAfter(b, e *udpPacket) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *udpPacketList) InsertBefore(a, e *udpPacket) {
aLinker := udpPacketElementMapper{}.linkerFor(a)
eLinker := udpPacketElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *udpPacketList) InsertBefore(a, e *udpPacket) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *udpPacketList) Remove(e *udpPacket) {
linker := udpPacketElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type udpPacketEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *udpPacketEntry) Next() *udpPacket {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *udpPacketEntry) Prev() *udpPacket {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *udpPacketEntry) SetNext(elem *udpPacket) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *udpPacketEntry) SetPrev(elem *udpPacket) {
e.prev = elem
}

28
pkg/waiter/waiter_list.go
View File

@ -38,16 +38,22 @@ func (l *waiterList) Reset() {
}
// Empty returns true iff the list is empty.
//
//go:nosplit
func (l *waiterList) Empty() bool {
return l.head == nil
}
// Front returns the first element of list l or nil.
//
//go:nosplit
func (l *waiterList) Front() *Entry {
return l.head
}
// Back returns the last element of list l or nil.
//
//go:nosplit
func (l *waiterList) Back() *Entry {
return l.tail
}
@ -55,6 +61,8 @@ func (l *waiterList) Back() *Entry {
// Len returns the number of elements in the list.
//
// NOTE: This is an O(n) operation.
//
//go:nosplit
func (l *waiterList) Len() (count int) {
for e := l.Front(); e != nil; e = (waiterElementMapper{}.linkerFor(e)).Next() {
count++
@ -63,6 +71,8 @@ func (l *waiterList) Len() (count int) {
}
// PushFront inserts the element e at the front of list l.
//
//go:nosplit
func (l *waiterList) PushFront(e *Entry) {
linker := waiterElementMapper{}.linkerFor(e)
linker.SetNext(l.head)
@ -77,6 +87,8 @@ func (l *waiterList) PushFront(e *Entry) {
}
// PushBack inserts the element e at the back of list l.
//
//go:nosplit
func (l *waiterList) PushBack(e *Entry) {
linker := waiterElementMapper{}.linkerFor(e)
linker.SetNext(nil)
@ -91,6 +103,8 @@ func (l *waiterList) PushBack(e *Entry) {
}
// PushBackList inserts list m at the end of list l, emptying m.
//
//go:nosplit
func (l *waiterList) PushBackList(m *waiterList) {
if l.head == nil {
l.head = m.head
@ -106,6 +120,8 @@ func (l *waiterList) PushBackList(m *waiterList) {
}
// InsertAfter inserts e after b.
//
//go:nosplit
func (l *waiterList) InsertAfter(b, e *Entry) {
bLinker := waiterElementMapper{}.linkerFor(b)
eLinker := waiterElementMapper{}.linkerFor(e)
@ -124,6 +140,8 @@ func (l *waiterList) InsertAfter(b, e *Entry) {
}
// InsertBefore inserts e before a.
//
//go:nosplit
func (l *waiterList) InsertBefore(a, e *Entry) {
aLinker := waiterElementMapper{}.linkerFor(a)
eLinker := waiterElementMapper{}.linkerFor(e)
@ -141,6 +159,8 @@ func (l *waiterList) InsertBefore(a, e *Entry) {
}
// Remove removes e from l.
//
//go:nosplit
func (l *waiterList) Remove(e *Entry) {
linker := waiterElementMapper{}.linkerFor(e)
prev := linker.Prev()
@ -173,21 +193,29 @@ type waiterEntry struct {
}
// Next returns the entry that follows e in the list.
//
//go:nosplit
func (e *waiterEntry) Next() *Entry {
return e.next
}
// Prev returns the entry that precedes e in the list.
//
//go:nosplit
func (e *waiterEntry) Prev() *Entry {
return e.prev
}
// SetNext assigns 'entry' as the entry that follows e in the list.
//
//go:nosplit
func (e *waiterEntry) SetNext(elem *Entry) {
e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
//
//go:nosplit
func (e *waiterEntry) SetPrev(elem *Entry) {
e.prev = elem
}