enum status physical_page_remove(phys_addr address) {
enum status status = Error_Absent;
assert(is_aligned(address, Page_Small));
phys_addr original = Physical_Page;
phys_addr current = original;
lock_acquire_writer(&physical_allocator_lock);
while (current != invalid_phys_addr) {
unmap_page(Physical_Page_Stack, false);
status = map_page(Physical_Page_Stack, current, Memory_Writable);
assert_ok(status);
current = Physical_Page_Stack->next;
if (Physical_Page_Stack->next == address) {
unmap_page(Physical_Page_Stack, false);
assert_ok(map_page(Physical_Page_Stack, Physical_Page_Stack->next,
Memory_Writable));
phys_addr next_next = Physical_Page_Stack->next;
unmap_page(Physical_Page_Stack, false);
assert_ok(map_page(Physical_Page_Stack, current, Memory_Writable));
Physical_Page_Stack->next = next_next;
status = Ok;
break;
}
}
unmap_page(Physical_Page_Stack, false);
assert_ok(map_page(Physical_Page_Stack, original, Memory_Writable));
lock_release_writer(&physical_allocator_lock);
return status;
}
int test_access_basic(void) {
/* After implementing credentials test should be extended. */
assert_ok(access("/bin/mandelbrot", R_OK));
assert_ok(access("/bin/mandelbrot", 0));
assert_ok(access("/bin/mandelbrot", R_OK | W_OK | X_OK));
assert_fail(access("/tests/ascii", X_OK), EACCES);
assert_fail(access("/bin/mandelbrot", (R_OK | W_OK | X_OK) + 1), EINVAL);
assert_fail(access("/dont/exist", X_OK), ENOENT);
assert_fail(access("dont/exist", X_OK), ENOENT);
return 0;
}
void physical_stack_debug(void) {
phys_addr original = Physical_Page;
phys_addr current = Physical_Page;
logf(Log_Debug, "physical_stack_debug\n");
lock_acquire_writer(&physical_allocator_lock);
while (current != invalid_phys_addr) {
unmap_page(Physical_Page_Stack, false);
assert_ok(map_page(Physical_Page_Stack, current, Memory_Writable));
logf(Log_Debug, "%lx %zu\n", current, Physical_Page_Stack->length);
current = Physical_Page_Stack->next;
}
logf(Log_Debug, "%lx\n", current);
unmap_page(Physical_Page_Stack, false);
assert_ok(map_page(Physical_Page_Stack, original, Memory_Writable));
lock_release_writer(&physical_allocator_lock);
}
//!-----------------------------------
void insert_in(dataType value, int position, int orientation, header_t *Head)
{
assert_ok(List_ok(Head) == NULL);
assert_ok(position <= Head->ListLen);
listElem_t *work = Head->theFirst;
for (int i = 1; i < position; i++)
{
assert(1 <= i && i < position);
work = work->next;
}
listElem_t *target = ctor();
target->data = value;
if (orientation == LEFT)
{
listElem_t *previous = work->prev;
//printf("previous [0x%p]\n", previous);
if (previous != NULL)
previous->next = target;
if (previous == NULL)
Head->theFirst = target;
target->prev = previous;
target->next = work;
work->prev = target;
Head->ListLen += 1;
}
if (orientation == RIGHT)
{
listElem_t * theNext = work->next;
work->next = target;
target->prev = work;
target->next = theNext;
if (theNext != NULL)
theNext->prev = target;
if (theNext == NULL)
Head->theLast = target;
Head->ListLen += 1;
}
dumpList(Head);
assert_ok(List_ok(Head) == NULL);
}
void
JDirInfo::GoToClosest
(
const JCharacter* origDirName
)
{
const JString dirName = JGetClosestDirectory(origDirName);
const JError err = GoTo(dirName);
assert_ok( err );
}
JError
JDirInfo::BuildInfo()
{
if (!JDirectoryReadable(*itsCWD))
{
return JAccessDenied(*itsCWD);
}
const JString origDir = JGetCurrentDirectory();
JError err = JChangeDirectory(*itsCWD);
if (!err.OK())
{
return err;
}
// clear old information
itsDirEntries->CleanOut();
// update instance variables
JStripTrailingDirSeparator(itsCWD); // keep Windows happy
ACE_stat stbuf;
ACE_OS::stat(*itsCWD, &stbuf);
itsIsValidFlag = kJTrue;
itsIsWritableFlag = JDirectoryWritable(*itsCWD);
itsModTime = stbuf.st_mtime;
itsStatusTime = stbuf.st_ctime;
JAppendDirSeparator(itsCWD);
// process files in the directory
JLatentPG pg(itsContentRegex == NULL ? 100 : 10);
if (itsPG != NULL)
{
pg.SetPG(itsPG, kJFalse);
}
pg.VariableLengthProcessBeginning("Scanning directory...", kJTrue, kJFalse);
BuildInfo1(pg);
pg.ProcessFinished();
err = JChangeDirectory(origDir);
assert_ok( err );
ApplyFilters(kJFalse);
return JNoError();
}
int test_read()
{
char *path = "/hello";
char buf[4096];
int len;
len = ext2_read(path, buf, 80, 0);
assert_true(len > 0);
buf[len] = '\0';
print_info("len: %d\ncontent of file:\n%s\n", len, buf);
assert_ok();
}
//!-----------------------------------
void removeList(header_t *Head)
{
assert_ok(Head != NULL);
listElem_t * work = Head->theFirst;
for (int i = 2; i < Head->ListLen; i++)
{
assert(2 <= i && i <= Head->ListLen);
dtor(work->prev, Head);
work = work->next;
}
work = NULL;
free(Head);
dumpList(Head);
}
JDirInfo::JDirInfo
(
const JCharacter* dirName
)
:
JContainer()
{
AllocateCWD(dirName);
itsIsValidFlag = kJTrue; // see assert() at end of this function
itsSwitchIfInvalidFlag = kJFalse;
itsIsWritableFlag = kJFalse;
itsModTime = 0;
itsStatusTime = 0;
itsShowFilesFlag = kJTrue; // remember to update ResetCSFFilters()
itsShowDirsFlag = kJTrue;
itsShowHiddenFlag = kJFalse;
itsShowVCSDirsFlag = kJTrue;
itsShowOthersFlag = kJFalse;
itsNameRegex = NULL;
itsOwnsNameRegexFlag = kJFalse;
itsInvertNameRegexFlag = kJFalse;
itsFilterDirsFlag = kJFalse;
itsPermFilter = NULL;
itsContentRegex = NULL;
itsPG = NULL;
itsDirEntries = new JPtrArray<JDirEntry>(JPtrArrayT::kDeleteAll);
assert( itsDirEntries != NULL);
itsDirEntries->SetCompareFunction(JDirEntry::CompareNames);
itsDirEntries->SetSortOrder(JOrderedSetT::kSortAscending);
itsVisEntries = new JPtrArray<JDirEntry>(JPtrArrayT::kForgetAll);
assert( itsVisEntries != NULL);
itsAlphaEntries = new JPtrArray<JDirEntry>(JPtrArrayT::kForgetAll);
assert( itsAlphaEntries != NULL);
itsAlphaEntries->SetCompareFunction(JDirEntry::CompareNames);
itsAlphaEntries->SetSortOrder(JOrderedSetT::kSortAscending);
InstallOrderedSet(itsVisEntries);
const JError err = BuildInfo();
assert_ok( err );
}
//!-----------------------------------
void dtor(listElem_t *work, header_t *Head)
{
assert_ok(work != NULL);
if (work->prev == NULL)
{
work->next = NULL;
return;
}
if (work->next == NULL)
{
work->prev = NULL;
return;
}
work->next = NULL;
work->prev = NULL;
work = NULL;
}
//!-----------------------------------
void initiateList(header_t *Head)
{
assert_ok(Head != NULL);
Head->theFirst = (listElem_t *) calloc(1, sizeof(listElem_t));
Head->theLast = (listElem_t *) calloc(1, sizeof(listElem_t));
Head->theFirst->data = NULL;
Head->theFirst->next = Head->theLast;
Head->theFirst->prev = NULL;
Head->theLast->data = NULL;
Head->theLast->next = NULL;
Head->theLast->prev = Head->theFirst;
Head->ListLen = STARTLEN;
assert(List_ok(Head) == NULL);
}
JError
JDirInfo::SetContentFilter
(
const JCharacter* regexStr
)
{
if (itsContentRegex != NULL && regexStr == itsContentRegex->GetPattern())
{
return JNoError();
}
JBoolean hadFilter = kJTrue;
JString prevPattern;
if (itsContentRegex == NULL)
{
hadFilter = kJFalse;
itsContentRegex = new JRegex;
assert( itsContentRegex != NULL );
itsContentRegex->SetSingleLine();
}
else
{
prevPattern = itsContentRegex->GetPattern();
}
JError err = itsContentRegex->SetPattern(regexStr);
if (err.OK())
{
ForceUpdate();
Broadcast(SettingsChanged());
}
else if (hadFilter)
{
err = itsContentRegex->SetPattern(prevPattern);
assert_ok( err );
}
else
{
delete itsContentRegex;
itsContentRegex = NULL;
}
return err;
}
void
CBFileListTable::UpdateFileInfo
(
const JIndex index
)
{
FileInfo info = itsFileInfo->GetElement(index);
info.id = GetUniqueID();
const JString& fileName = *(GetFullNameList().NthElement(index));
const JError err = JGetModificationTime(fileName, &(info.modTime));
assert_ok( err );
itsFileInfo->SetElement(index, info);
if (itsFileUsage != NULL)
{
itsFileUsage->SetElement(index, kJTrue);
}
}
void
CBFileListTable::FilesAdded
(
const JOrderedSetT::ElementsInserted& info
)
{
const JPtrArray<JString>& fileNameList = GetFullNameList();
for (JIndex i = info.GetFirstIndex(); i <= info.GetLastIndex(); i++)
{
time_t t;
const JError err = JGetModificationTime(*(fileNameList.NthElement(i)), &t);
assert_ok( err );
itsFileInfo->InsertElementAtIndex(i, FileInfo(GetUniqueID(), t));
if (itsFileUsage != NULL)
{
itsFileUsage->InsertElementAtIndex(i, kJTrue);
}
}
}
JDirInfo::JDirInfo
(
const JDirInfo& source,
const JCharacter* dirName
)
:
JContainer(source)
{
AllocateCWD(dirName);
itsIsValidFlag = kJTrue; // see assert() at end of this function
itsSwitchIfInvalidFlag = kJFalse;
itsIsWritableFlag = kJFalse;
itsModTime = 0;
itsStatusTime = 0;
JDirInfoX(source);
PrivateCopySettings(source);
InstallOrderedSet(itsVisEntries);
const JError err = BuildInfo();
assert_ok( err );
}
//!-----------------------------------
int List_ok(header_t *Head)
{
assert_ok(Head != NULL);
listElem_t *current = Head->theFirst;
listElem_t *theNext = Head->theFirst->next;
listElem_t *thePrev = 0;
for (int i = 1; i < Head->ListLen; i++)
{
assert(1 <= 1 && i < Head->ListLen);
if (current->prev == NULL)
{
theNext = current->next;
if (theNext->prev != current)
return 1;
current = current->next;
continue;
}
if (current->next == NULL)
{
thePrev = current->prev;
if (thePrev->next != current)
return 1;
}
thePrev = current->prev;
if (thePrev->next != current)
return 1;
theNext = current->next;
if (theNext->prev != current)
return 1;
current = current->next;
}
return 0;
}
static void physical_free_range(phys_addr address, size_t length) {
enum status status;
assert(is_aligned(address, Page_Small));
assert(is_aligned(length, Page_Small));
assert((address & 0xfff) == 0);
assert((length & 0xfff) == 0);
assert(length > 0);
assert((address & 0xffff000000000000) == 0);
assert(((address + length) & 0xffff000000000000) == 0);
phys_addr prev;
lock_acquire_writer(&physical_allocator_lock);
prev = Physical_Page;
unmap_page(Physical_Page_Stack, false);
status = map_page(Physical_Page_Stack, address, Memory_Writable);
assert_ok(status);
Physical_Page_Stack->next = prev;
Physical_Page_Stack->length = length;
Physical_Page = address;
lock_release_writer(&physical_allocator_lock);
}
//!-----------------------------------
void remove_in(int position, int orientation, header_t *Head)
{
assert_ok(List_ok(Head) == NULL);
assert_ok(position <= Head->ListLen);
assert_ok(orientation == LEFT || orientation == RIGHT);
listElem_t *work = Head->theFirst;
for (int i = 1; i < position; i++)
{
assert(1 <= i && i < position);
work = work->next;
}
if (Head->ListLen == 1)
{
printf("Unable to delete!\n");
exit(3);
}
if (orientation == LEFT)
{
if (work->prev == NULL)
{
printf("FAIL! You are trying to delete unexisted element\n");
return;
}
listElem_t *previous = work->prev;
if (previous == Head->theFirst)
{
Head->theFirst = work;
work->prev = NULL;
dtor(previous, Head);
Head->ListLen -= 1;
dumpList(Head);
return;
}
work->prev = previous->prev;
previous->prev->next = work;
dtor(previous, Head);
Head->ListLen -= 1;
}
if (orientation == RIGHT)
{
if (work->next == NULL)
{
printf("ERROR! You are trying to delete unexisted element!\n");
exit(1);
}
listElem_t * theNext = work->next;
if (theNext == Head->theLast)
{
Head->theLast = work;
work->next = NULL;
dtor(theNext, Head);
Head->ListLen -= 1;
dumpList(Head);
return;
}
work->next = theNext->next;
theNext->next->prev = work;
dtor(theNext, Head);
Head->ListLen -= 1;
}
else
{
printf("ERROR! WRONG ORIENTATION!\n");
exit(2);
}
assert_ok(List_ok(Head) == NULL);
dumpList(Head);
}
// When populating the physical allocator, certain addresses are unavailable or
// reserved. The multiboot tables give a sorted list of regions which are
// useable memory, but some of these contain the kernel, modules, or the
// multiboot tables themselves.
static void insert_regions(struct multiboot_info *multiboot_tables) {
struct reserved_region {
phys_addr start;
phys_addr end;
};
enum status status;
size_t modules_index_start;
size_t reserved_count;
bool inserted = false;
uint64_t total = 0;
struct multiboot_mod_list *modules =
(struct multiboot_mod_list *)(uintptr_t)multiboot_tables->mods_addr;
struct multiboot_mmap_entry *mmap =
(struct multiboot_mmap_entry *)(uintptr_t)multiboot_tables->mmap_addr;
uintptr_t mods_list_start = align_as(multiboot_tables->mods_addr,
Page_Small);
uintptr_t mods_list_end = round_next(multiboot_tables->mods_addr +
multiboot_tables->mods_count *
sizeof(struct multiboot_mod_list),
Page_Small);
if (physical_region_contains(Boot_Map_Start, Boot_Map_End,
mods_list_start, mods_list_end)) {
modules_index_start = 1;
reserved_count = multiboot_tables->mods_count + 1;
} else {
modules_index_start = 2;
reserved_count = multiboot_tables->mods_count + 2;
status = map_range(modules, mods_list_start,
(mods_list_end - mods_list_start) / Page_Small,
Memory_No_Attributes);
assert_ok(status);
}
struct reserved_region reserved[reserved_count];
if (modules_index_start == 2) {
if (Boot_Map_Start < mods_list_start) {
reserved[0].start = Boot_Map_Start;
reserved[0].end = Boot_Map_End;
reserved[1].start = mods_list_start;
reserved[1].end = mods_list_end;
} else {
reserved[0].start = mods_list_start;
reserved[0].end = mods_list_end;
reserved[1].start = Boot_Map_Start;
reserved[1].end = Boot_Map_End;
}
} else {
reserved[0].start = Boot_Map_Start;
reserved[0].end = Boot_Map_End;
}
for (size_t i = 0;
i < multiboot_tables->mods_count; ++i) {
reserved[i + modules_index_start].start = modules[i].mod_start;
reserved[i + modules_index_start].end = round_next(modules[i].mod_end,
Page_Small);
}
for (size_t i = 0; i < (multiboot_tables->mmap_length /
sizeof(struct multiboot_mmap_entry)); ++i) {
inserted = false;
if (mmap[i].type == MULTIBOOT_MEMORY_AVAILABLE) {
total += mmap[i].len;
for (size_t j = 0; j < reserved_count; ++j) {
uintptr_t mem_start = mmap[i].addr;
uintptr_t mem_end = mmap[i].addr + mmap[i].len;
if (physical_region_contains(mem_start, mem_end,
reserved[j].start,
reserved[j].end)) {
inserted = true;
if (reserved[j].start > mem_start) {
physical_free_range(mem_start,
reserved[j].start - mem_start);
}
if (j + 1 < reserved_count &&
physical_region_contains(mem_start, mem_end,
reserved[j + 1].start,
reserved[j + 1].end)) {
if (reserved[j].end != reserved[j + 1].start) {
physical_free_range(reserved[j].end,
reserved[j + 1].start -
reserved[j].end);
}
mmap[i].addr = reserved[j + 1].start;
mmap[i].len -= reserved[j + 1].start -
reserved[j].start;
} else if (reserved[j].end < mem_end) {
physical_free_range(reserved[j].end,
mem_end - reserved[j].end);
}
}
}
if (!inserted) {
physical_free_range(mmap[i].addr,
mmap[i].len);
}
}
}
if (modules_index_start == 2) {
unmap_range(modules, (mods_list_end - mods_list_start) / Page_Small,
false);
}
}
JBoolean
JGetTrueName
(
const JCharacter* name,
JString* trueName
)
{
trueName->Clear();
if (!JNameUsed(name))
{
return kJFalse;
}
// check if it is a directory
else if (JDirectoryExists(name))
{
const JString currPath = JGetCurrentDirectory();
JError err = JChangeDirectory(name);
if (!err.OK())
{
return kJFalse;
}
*trueName = JGetCurrentDirectory();
err = JChangeDirectory(currPath);
assert_ok( err );
return kJTrue;
}
// it is a file, socket, fifo, etc.
else
{
JString origPath, fileName;
JSplitPathAndName(name, &origPath, &fileName);
// get true directory
JString truePath;
if (!JGetTrueName(origPath, &truePath))
{
return kJFalse;
}
// resolve symbolic link
JString target;
if ((JGetSymbolicLinkTarget(name, &target)).OK())
{
if (JIsRelativePath(target))
{
target.Prepend(truePath);
}
return JGetTrueName(target, trueName);
}
else
{
*trueName = JCombinePathAndName(truePath, fileName);
return kJTrue;
}
}
}
