1
0
Fork 0
mirror of https://gitlab.com/sortix/sortix.git synced 2023-02-13 20:55:38 -05:00
sortix--sortix/kernel/segment.cpp

251 lines
6.8 KiB
C++
Raw Normal View History

2013-08-19 20:23:53 -04:00
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2013.
This file is part of Sortix.
Sortix is free software: you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.
Sortix is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
details.
You should have received a copy of the GNU General Public License along with
Sortix. If not, see <http://www.gnu.org/licenses/>.
segment.cpp
Structure representing a segment in a process.
*******************************************************************************/
#include <sys/types.h>
#include <assert.h>
2013-08-19 20:23:53 -04:00
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <sortix/mman.h>
2013-08-19 20:23:53 -04:00
#include <sortix/kernel/decl.h>
#include <sortix/kernel/kernel.h>
2013-08-19 20:23:53 -04:00
#include <sortix/kernel/memorymanagement.h>
#include <sortix/kernel/process.h>
#include <sortix/kernel/segment.h>
#include <sortix/kernel/yielder.h>
2013-08-19 20:23:53 -04:00
namespace Sortix {
bool AreSegmentsOverlapping(const struct segment* a, const struct segment* b)
{
return a->addr < b->addr + b->size && b->addr < a->addr + a->size;
}
bool IsUserspaceSegment(const struct segment* segment)
{
uintptr_t userspace_addr;
size_t userspace_size;
Memory::GetUserVirtualArea(&userspace_addr, &userspace_size);
if ( segment->addr < userspace_addr )
return false;
uintptr_t userspace_end = userspace_addr + userspace_size;
if ( userspace_end - segment->addr < segment->size )
return false;
return true;
}
struct segment* FindOverlappingSegment(Process* process, const struct segment* new_segment)
{
// process->segment_lock is held at this point.
// TODO: Speed up using binary search.
for ( size_t i = 0; i < process->segments_used; i++ )
{
struct segment* segment = &process->segments[i];
if ( AreSegmentsOverlapping(segment, new_segment) )
return segment;
}
return NULL;
}
bool IsSegmentOverlapping(Process* process, const struct segment* new_segment)
{
// process->segment_lock is held at this point.
return FindOverlappingSegment(process, new_segment) != NULL;
}
bool AddSegment(Process* process, const struct segment* new_segment)
{
// process->segment_lock is held at this point.
// assert(!IsSegmentOverlapping(new_segment));
// Check if we need to expand the segment list.
if ( process->segments_used == process->segments_length )
{
size_t new_length = process->segments_length ?
process->segments_length * 2 : 8;
size_t new_size = new_length * sizeof(struct segment);
struct segment* new_segments =
(struct segment*) realloc(process->segments, new_size);
if ( !new_segments )
return false;
process->segments = new_segments;
process->segments_length = new_length;
}
// Add the new segment to the segment list.
process->segments[process->segments_used++] = *new_segment;
// Sort the segment list after address.
qsort(process->segments, process->segments_used, sizeof(struct segment),
segmentcmp);
return true;
}
class segment_gaps
{
typedef yielder_iterator<segment_gaps, struct segment> my_iterator;
public:
segment_gaps(finished_yielder) : process(0) { }
segment_gaps(Process* process) :
process(process),
current_segment_index(0),
checked_leading(false),
checked_trailing(false)
{
Memory::GetUserVirtualArea(&userspace_addr, &userspace_size);
}
bool yield(struct segment* result)
{
// process->segment_lock is held at this point.
// Check if we have finished iterating all the segments.
if ( !process )
return false;
// If the process has no segments at all, our job is really easy.
if ( !process->segments_used )
{
result->addr = userspace_addr;
result->size = userspace_size;
result->prot = 0;
process = NULL;
return true;
}
// Find out whether there is a gap before the first segment.
if ( !checked_leading && (checked_leading = true) &&
process->segments[0].addr != userspace_addr )
{
result->addr = userspace_addr;
result->size = process->segments[0].addr - userspace_addr;
result->prot = 0;
return true;
}
// Search through the segments until a gap follows one.
while ( current_segment_index + 1 < process->segments_used )
{
result->addr = process->segments[current_segment_index].addr +
process->segments[current_segment_index].size;
result->size = process->segments[current_segment_index+1].addr -
result->addr;
result->prot = 0;
current_segment_index++;
if ( result->size )
return true;
}
// Find out if there is a gap after the last segment.
if ( !checked_trailing && (checked_trailing = true) &&
process->segments[process->segments_used-1].addr +
process->segments[process->segments_used-1].size !=
userspace_addr + userspace_size )
{
result->addr = process->segments[process->segments_used-1].addr +
process->segments[process->segments_used-1].size;
result->size = userspace_addr + userspace_size - result->addr;
result->prot = 0;
return true;
}
process = NULL;
return false;
}
my_iterator begin() const
{
return my_iterator(segment_gaps(*this));
}
my_iterator end() const
{
return my_iterator(segment_gaps{finished_yielder{}});
}
private:
Process* process;
uintptr_t userspace_addr;
size_t userspace_size;
size_t current_segment_index;
bool checked_leading;
bool checked_trailing;
};
bool PlaceSegment(struct segment* solution, Process* process, void* addr_ptr,
size_t size, int flags)
{
// process->segment_lock is held at this point.
assert(!(flags & MAP_FIXED));
uintptr_t addr = (uintptr_t) addr_ptr;
bool found_any = false;
size_t best_distance = 0;
struct segment best;
for ( struct segment gap : segment_gaps(process) )
{
if ( gap.size < size )
continue;
if ( gap.addr <= addr && addr + size - gap.addr <= gap.size )
{
solution->addr = addr;
solution->size = size;
solution->prot = 0;
return true;
}
struct segment attempt;
size_t distance;
attempt.addr = gap.addr;
attempt.size = size;
attempt.prot = 0;
distance = addr < attempt.addr ? attempt.addr - addr : addr - attempt.addr;
if ( !found_any|| distance < best_distance )
found_any = true, best_distance = distance, best = attempt;
attempt.addr = gap.addr + gap.size - size;
attempt.size = size;
attempt.prot = 0;
distance = addr < attempt.addr ? attempt.addr - addr : addr - attempt.addr;
if ( !found_any|| distance < best_distance )
found_any = true, best_distance = distance, best = attempt;
}
return *solution = best, found_any;
}
2013-08-19 20:23:53 -04:00
} // namespace Sortix