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; } } }