The file descriptor table now allows reserving room for multiple file descriptors without assigning their numbers. This functionality means any error conditions happen up front and the subsequent number assignment will never fail. This change uses the new functionality to fix troublesome error handling when allocating multiple file descriptors. One pty allocation error path was even wrong. There were subtle race conditions where one (kernel) thread may have allocated one file descriptor, and another thread spuciously replaces it with something else, and then the second file descriptor allocation failed in the first thread, and it closes the first file descriptor now pointing to a different file description. This case seems harmless but it's not a great class of bugs to exist in the first place. The new behavior means the file descriptions appear in the file descriptor table without fail and never needs to be cleaned up midway and is certainly immune to shenangians from other threads. Reviewed-by: Pedro Falcato <pedro.falcato@gmail.com>
359 lines
9.2 KiB
C++
359 lines
9.2 KiB
C++
/*
|
|
* Copyright (c) 2011-2016, 2021 Jonas 'Sortie' Termansen.
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* dtable.cpp
|
|
* Table of file descriptors.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <limits.h>
|
|
#include <string.h>
|
|
|
|
#include <sortix/fcntl.h>
|
|
|
|
#include <sortix/kernel/descriptor.h>
|
|
#include <sortix/kernel/dtable.h>
|
|
#include <sortix/kernel/kernel.h>
|
|
#include <sortix/kernel/kthread.h>
|
|
#include <sortix/kernel/process.h>
|
|
#include <sortix/kernel/refcount.h>
|
|
|
|
namespace Sortix {
|
|
|
|
struct DescriptorEntry
|
|
{
|
|
Ref<Descriptor> desc;
|
|
int flags;
|
|
};
|
|
|
|
DescriptorTable::DescriptorTable()
|
|
{
|
|
dtablelock = KTHREAD_MUTEX_INITIALIZER;
|
|
entries = NULL;
|
|
entries_used = 0;
|
|
entries_length = 0;
|
|
reserved_count = 0;
|
|
first_not_taken = 0;
|
|
}
|
|
|
|
DescriptorTable::~DescriptorTable()
|
|
{
|
|
for ( int i = 0; i < entries_length; i++ )
|
|
if ( entries[i].desc )
|
|
entries[i].desc.Reset();
|
|
delete[] entries;
|
|
}
|
|
|
|
bool DescriptorTable::IsGoodEntry(int i) // dtablelock locked
|
|
{
|
|
return 0 <= i && i < entries_length && entries[i].desc;
|
|
}
|
|
|
|
Ref<DescriptorTable> DescriptorTable::Fork()
|
|
{
|
|
ScopedLock lock(&dtablelock);
|
|
Ref<DescriptorTable> ret(new DescriptorTable);
|
|
if ( !ret )
|
|
return Ref<DescriptorTable>(NULL);
|
|
ret->entries = new DescriptorEntry[entries_length];
|
|
if ( !ret->entries )
|
|
return Ref<DescriptorTable>(NULL);
|
|
// Copy all the file descriptors except ones closed on fork.
|
|
ret->entries_length = entries_length;
|
|
for ( int i = 0; i < entries_length; i++ )
|
|
{
|
|
if ( !entries[i].desc || entries[i].flags & FD_CLOFORK )
|
|
{
|
|
//ret->entries[i].desc = NULL; // Constructor did this already.
|
|
ret->entries[i].flags = 0;
|
|
continue;
|
|
}
|
|
ret->entries[i] = entries[i];
|
|
ret->entries_used++;
|
|
if ( ret->first_not_taken == i )
|
|
ret->first_not_taken = i + 1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Ref<Descriptor> DescriptorTable::Get(int index)
|
|
{
|
|
ScopedLock lock(&dtablelock);
|
|
if ( !IsGoodEntry(index) )
|
|
return errno = EBADF, Ref<Descriptor>(NULL);
|
|
return entries[index].desc;
|
|
}
|
|
|
|
// Expands the table to have at least need_entries entries and at least
|
|
// need_unused unused entries.
|
|
bool DescriptorTable::Enlargen(int need_entries,
|
|
int need_unused) // dtablelock taken
|
|
{
|
|
// Figure out how many entries are needed to satisfy the need for unused
|
|
// entries and grow the entries to that size if larger than need_entries.
|
|
if ( __builtin_add_overflow(need_unused, entries_used, &need_unused) ||
|
|
__builtin_add_overflow(need_unused, reserved_count, &need_unused) )
|
|
return errno = EMFILE, false;
|
|
if ( need_entries < need_unused )
|
|
need_entries = need_unused;
|
|
if ( need_entries <= entries_length )
|
|
return true;
|
|
if ( entries_length == INT_MAX )
|
|
return errno = EMFILE, false;
|
|
// At least double the size of the table but maybe more entries are needed.
|
|
int new_entries_length = 8;
|
|
if ( entries_length &&
|
|
__builtin_mul_overflow(2, entries_length, &new_entries_length) )
|
|
new_entries_length = INT_MAX;
|
|
if ( new_entries_length < need_entries )
|
|
new_entries_length = need_entries;
|
|
DescriptorEntry* new_entries = new DescriptorEntry[new_entries_length];
|
|
if ( !new_entries )
|
|
return false;
|
|
for ( int i = 0; i < entries_length; i++ )
|
|
{
|
|
new_entries[i] = entries[i];
|
|
entries[i].desc.Reset();
|
|
}
|
|
for ( int i = entries_length; i < new_entries_length; i++ )
|
|
{
|
|
//new_entries[i].desc = NULL; // Constructor did this already.
|
|
new_entries[i].flags = 0;
|
|
}
|
|
delete[] entries;
|
|
entries = new_entries;
|
|
entries_length = new_entries_length;
|
|
return true;
|
|
}
|
|
|
|
bool DescriptorTable::Reserve(int count, int* reservation)
|
|
{
|
|
assert(0 <= count);
|
|
if ( !Enlargen(0, count) )
|
|
return false;
|
|
assert(reserved_count <= entries_length - entries_used);
|
|
assert(reserved_count + count <= entries_length - entries_used);
|
|
reserved_count += count;
|
|
*reservation = count;
|
|
return true;
|
|
}
|
|
|
|
void DescriptorTable::Unreserve(int* reservation)
|
|
{
|
|
assert(0 <= *reservation);
|
|
assert(*reservation <= reserved_count);
|
|
reserved_count -= *reservation;
|
|
*reservation = 0;
|
|
}
|
|
|
|
int DescriptorTable::AllocateInternal(Ref<Descriptor> desc,
|
|
int flags,
|
|
int min_index,
|
|
int* reservation) // dtablelock locked
|
|
{
|
|
assert(!reservation || 1 <= *reservation);
|
|
assert(!reservation || !min_index);
|
|
if ( flags & ~__FD_ALLOWED_FLAGS )
|
|
return errno = EINVAL, -1;
|
|
if ( min_index < 0 )
|
|
return errno = EINVAL, -1;
|
|
if ( min_index < first_not_taken )
|
|
min_index = first_not_taken;
|
|
int first_available = min_index;
|
|
for ( int i = min_index; i < entries_length; i++ )
|
|
{
|
|
if ( entries[i].desc )
|
|
{
|
|
if ( first_available == i )
|
|
first_available = i + 1;
|
|
if ( first_not_taken == i )
|
|
first_not_taken = i + 1;
|
|
continue;
|
|
}
|
|
if ( !reservation && entries_length - reserved_count <= i )
|
|
break;
|
|
entries[i].desc = desc;
|
|
entries[i].flags = flags;
|
|
entries_used++;
|
|
if ( reservation )
|
|
{
|
|
assert(reserved_count);
|
|
(*reservation)--;
|
|
reserved_count--;
|
|
}
|
|
if ( first_not_taken == i )
|
|
first_not_taken = i + 1;
|
|
return i;
|
|
}
|
|
assert(!reservation);
|
|
if ( !Enlargen(first_available + 1, 1) )
|
|
return -1;
|
|
entries[first_available].desc = desc;
|
|
entries[first_available].flags = flags;
|
|
entries_used++;
|
|
if ( first_not_taken == first_available )
|
|
first_not_taken = first_available + 1;
|
|
return first_available;
|
|
}
|
|
|
|
int DescriptorTable::Allocate(Ref<Descriptor> desc, int flags, int min_index,
|
|
int* reservation)
|
|
{
|
|
ScopedLock lock(&dtablelock);
|
|
return AllocateInternal(desc, flags, min_index, reservation);
|
|
}
|
|
|
|
int DescriptorTable::Allocate(int src_index, int flags, int min_index,
|
|
int* reservation)
|
|
{
|
|
ScopedLock lock(&dtablelock);
|
|
if ( !IsGoodEntry(src_index) )
|
|
return errno = EBADF, -1;
|
|
return AllocateInternal(entries[src_index].desc, flags, min_index,
|
|
reservation);
|
|
}
|
|
|
|
int DescriptorTable::Copy(int from, int to, int flags)
|
|
{
|
|
if ( flags & ~__FD_ALLOWED_FLAGS )
|
|
return errno = EINVAL, -1;
|
|
ScopedLock lock(&dtablelock);
|
|
if ( from < 0 || to < 0 )
|
|
return errno = EINVAL, -1;
|
|
if ( !IsGoodEntry(from) )
|
|
return errno = EBADF, -1;
|
|
if ( from == to )
|
|
return errno = EINVAL, -1;
|
|
if ( to == INT_MAX )
|
|
return errno = EBADF, -1;
|
|
if ( !IsGoodEntry(to) && !Enlargen(to + 1, 1) )
|
|
return -1;
|
|
if ( entries[to].desc != entries[from].desc )
|
|
{
|
|
if ( !entries[to].desc )
|
|
entries_used++;
|
|
entries[to].desc = entries[from].desc;
|
|
}
|
|
entries[to].flags = flags;
|
|
if ( first_not_taken == to )
|
|
first_not_taken = to + 1;
|
|
return to;
|
|
}
|
|
|
|
Ref<Descriptor> DescriptorTable::FreeKeepInternal(int index)
|
|
// dtablelock locked
|
|
{
|
|
if ( !IsGoodEntry(index) )
|
|
return errno = EBADF, Ref<Descriptor>(NULL);
|
|
Ref<Descriptor> ret = entries[index].desc;
|
|
entries[index].desc.Reset();
|
|
entries[index].flags = 0;
|
|
entries_used--;
|
|
if ( index < first_not_taken )
|
|
first_not_taken = index;
|
|
return ret;
|
|
}
|
|
|
|
Ref<Descriptor> DescriptorTable::FreeKeep(int index)
|
|
{
|
|
ScopedLock lock(&dtablelock);
|
|
return FreeKeepInternal(index);
|
|
}
|
|
|
|
void DescriptorTable::Free(int index)
|
|
{
|
|
FreeKeep(index);
|
|
}
|
|
|
|
void DescriptorTable::OnExecute()
|
|
{
|
|
ScopedLock lock(&dtablelock);
|
|
for ( int i = 0; i < entries_length; i++ )
|
|
{
|
|
if ( !entries[i].desc )
|
|
continue;
|
|
if ( !(entries[i].flags & FD_CLOEXEC) )
|
|
continue;
|
|
entries[i].desc.Reset();
|
|
if ( i < first_not_taken )
|
|
first_not_taken = i;
|
|
entries_used--;
|
|
}
|
|
}
|
|
|
|
bool DescriptorTable::SetFlags(int index, int flags)
|
|
{
|
|
if ( flags & ~__FD_ALLOWED_FLAGS )
|
|
return errno = EINVAL, false;
|
|
ScopedLock lock(&dtablelock);
|
|
if ( !IsGoodEntry(index) )
|
|
return errno = EBADF, false;
|
|
entries[index].flags = flags;
|
|
return true;
|
|
}
|
|
|
|
int DescriptorTable::GetFlags(int index)
|
|
{
|
|
ScopedLock lock(&dtablelock);
|
|
if ( !IsGoodEntry(index) )
|
|
return errno = EBADF, -1;
|
|
return entries[index].flags;
|
|
}
|
|
|
|
int DescriptorTable::Previous(int index)
|
|
{
|
|
ScopedLock lock(&dtablelock);
|
|
if ( index < 0 )
|
|
index = entries_length;
|
|
do index--;
|
|
while ( 0 <= index && !IsGoodEntry(index) );
|
|
if ( index < 0 )
|
|
return errno = EBADF, -1;
|
|
return index;
|
|
}
|
|
|
|
int DescriptorTable::Next(int index)
|
|
{
|
|
ScopedLock lock(&dtablelock);
|
|
if ( index < 0 )
|
|
index = -1;
|
|
if ( entries_length <= index )
|
|
return errno = EBADF, -1;
|
|
do index++;
|
|
while ( index < entries_length && !IsGoodEntry(index) );
|
|
if ( entries_length <= index )
|
|
return errno = EBADF, -1;
|
|
return index;
|
|
}
|
|
|
|
int DescriptorTable::CloseFrom(int index)
|
|
{
|
|
if ( index < 0 )
|
|
return errno = EBADF, -1;
|
|
ScopedLock lock(&dtablelock);
|
|
bool any = false;
|
|
for ( ; index < entries_length; index++ )
|
|
{
|
|
if ( !IsGoodEntry(index) )
|
|
continue;
|
|
FreeKeepInternal(index);
|
|
any = true;
|
|
}
|
|
return any ? 0 : (errno = EBADF, -1);
|
|
}
|
|
|
|
} // namespace Sortix
|