void CREATE_RSTP_INSTANCE() { int The_EOR; UID_STP_CFG_T uid_cfg; BITMAP_T ports; //init the port number for the bridges and set the bits high for the port creation STP_IN_init(NUMBER_OF_PORTS); BitmapClear(&enabled_ports); BitmapClear(&ports); for (The_EOR = 1; The_EOR <= NUMBER_OF_PORTS; The_EOR++) { BitmapSetBit(&ports, The_EOR - 1); } uid_cfg.field_mask = BR_CFG_STATE; uid_cfg.stp_enabled = STP_ENABLED; //set the init info for my bridge instanse,including creatation of the bridge The_EOR = STP_IN_stpm_set_cfg (VLAN_ID,&ports,&uid_cfg); #ifdef MY_PRINT_RSTP if(The_EOR == STP_OK) printf("Yes! The configuration is done!!!\n"); else printf("No! I'm a litter upset for the set failure!!!\n"); #endif }
int bridge_control (int port_index,UID_CNTRL_BODY_T* cntrl) { switch (cntrl->cmd) { case UID_PORT_CONNECT: #ifdef MY_PRINT_RSTP printf("connected port p%02d\n", port_index); #endif BitmapSetBit(&enabled_ports, port_index - 1); STP_IN_enable_port (port_index, True); break; case UID_PORT_DISCONNECT: #ifdef MY_PRINT_RSTP printf("disconnected port p%02d\n", port_index); #endif BitmapClearBit(&enabled_ports, port_index - 1); STP_IN_enable_port (port_index, False); break; case UID_BRIDGE_SHUTDOWN: #ifdef MY_PRINT_RSTP printf("shutdown from manager :(\n"); #endif return 1; default: printf("Unknown control command <%d> for port %d\n", cntrl->cmd,port_index); } return 0; }
static void MakeDynamicCodePagesVisible(struct NaClApp *nap, uint32_t page_index_min, uint32_t page_index_max, uint8_t *writable_addr) { void *user_addr; uint32_t index; size_t size = (page_index_max - page_index_min) * NACL_MAP_PAGESIZE; for (index = page_index_min; index < page_index_max; index++) { CHECK(!BitmapIsBitSet(nap->dynamic_page_bitmap, index)); BitmapSetBit(nap->dynamic_page_bitmap, index); } user_addr = (void *) NaClUserToSys(nap, nap->dynamic_text_start + page_index_min * NACL_MAP_PAGESIZE); #if NACL_WINDOWS NaClUntrustedThreadsSuspendAll(nap, /* save_registers= */ 0); /* * The VirtualAlloc() call here has two effects: * * 1) It commits the page in the shared memory (SHM) object, * allocating swap space and making the page accessible. This * affects our writable mapping of the shared memory object too. * Before the VirtualAlloc() call, dereferencing writable_addr * would fault. * 2) It changes the page permissions of the mapping to * read+execute. Since this exposes the page in its unsafe, * non-HLT-filled state, this must be done with untrusted * threads suspended. */ { uintptr_t offset; for (offset = 0; offset < size; offset += NACL_MAP_PAGESIZE) { void *user_page_addr = (char *) user_addr + offset; if (VirtualAlloc(user_page_addr, NACL_MAP_PAGESIZE, MEM_COMMIT, PAGE_EXECUTE_READ) != user_page_addr) { NaClLog(LOG_FATAL, "MakeDynamicCodePagesVisible: " "VirtualAlloc() failed -- probably out of swap space\n"); } } } #endif /* Sanity check: Ensure the page is not already in use. */ CHECK(*writable_addr == 0); NaClFillMemoryRegionWithHalt(writable_addr, size); #if NACL_WINDOWS NaClUntrustedThreadsResumeAll(nap); #else if (NaClMprotect(user_addr, size, PROT_READ | PROT_EXEC) != 0) { NaClLog(LOG_FATAL, "MakeDynamicCodePageVisible: NaClMprotect() failed\n"); } #endif }
int bridge_start(void) { BITMAP_T ports; UID_MSG_T msg; UID_STP_CFG_T uid_cfg; register int iii; //rl_callback_handler_install(get_prompt(), rl_read_cli); if (0 != UiD_SocketInit(&uid_socket, UID_REPL_PATH, UID_BIND_AS_CLIENT)) { printf("FATAL: can't init the connection\n"); exit(-3); } /* send HANDSHAKE */ msg.header.sender_pid = my_pid; msg.header.cmd_type = UID_CNTRL; msg.body.cntrl.cmd = UID_BRIDGE_HANDSHAKE; msg.body.cntrl.param1 = NUMBER_OF_PORTS; iii = UiD_SocketSendto(&uid_socket, &msg, sizeof(UID_MSG_T)); if (iii < 0) { printf("can't send HANDSHAKE: %s\n", strerror(errno)); printf("May be 'mngr' is not alive ? :(\n"); return (-4); } stp_cli_init(); STP_IN_init(NUMBER_OF_PORTS); BitmapClear(&enabled_ports); BitmapClear(&ports); for (iii = 1; iii <= NUMBER_OF_PORTS; iii++) { BitmapSetBit(&ports, iii - 1); } uid_cfg.field_mask = BR_CFG_STATE; uid_cfg.stp_enabled = STP_ENABLED; snprintf(uid_cfg.vlan_name, NAME_LEN - 1, "B%ld", (long)my_pid); iii = STP_IN_stpm_set_cfg(0, &ports, &uid_cfg); if (STP_OK != iii) { printf("FATAL: can't enable:%s\n", STP_IN_get_error_explanation (iii)); return (-1); } return 0; }
int fs_creat(byte *path, word mode, word rights) { // otevre se pro cteni zapis MNODE *DirNode; int i,j,MySystemIndex; TaskUArea *Task = GetCurrentTaskUArea(); word MyPackID, CallResult, GetNumber, MyIndex; byte buffer[255],*dir,trunc; byte sector[512]; MNODE *MyNode = (MNODE *) sector; dword Node; word CacheFlag; SyscallActive = 1; CacheFlag = (mode & IO_CACHE_THROUGH) ? FPACK_NOTHING : FPACK_ADD; Task->ErrorLevel = ERR_FS_NO_ERROR; MyIndex = BitmapGetFirstHole(Task->Bmp,MaxOpenedFiles); // for (i=5; i<MaxOpenedFiles; ++i) // if (!Task->OpenFiles[i].Used) { MyIndex = i; break; } if (MyIndex == 0xffff) { Task->ErrorLevel = ERR_TOO_MANY_OPENED_FILES; SyscallActive = 0; return -1; } dir = new byte [strlen(path)+1]; strcpy(dir,path); CutLastPathPart (dir,buffer); CallResult = NAMEN( dir, DirNode, CacheFlag); if ( CallResult != ERR_FS_NO_ERROR) { delete [] dir; Task->ErrorLevel = CallResult; SyscallActive = 0; return -1; } CallResult = SearchDirByName(DirNode, buffer, Node, CacheFlag, 0); if ( CallResult == ERR_DIRREC_NOT_FOUND) { // soubor jeste nexistuje, vypln jeho node trunc = 0; memset(sector,0,512); memcpy(MyNode->MagicWord,FileMagicWord,8); memcpy(MyNode->MagicWordII,FileMagicWord,8); MyNode->OwnerID = Task->ownerID; MyNode->GroupID = Task->groupID; MyNode->Type = NODE_TYPE_FILE; MyNode->Rights = rights; GlobalTime.Get(MyNode->FileAccessed); MyNode->FileModified = MyNode->FileAccessed; MyNode->NODEAccessed = MyNode->FileAccessed; MyNode->NODEModified = MyNode->FileAccessed; MyNode->Size = 0; MyNode->Links = 1; MyNode->Device = DirNode->Device; MyNode->Partition = DirNode->Partition; CallResult = CacheManAllocateSector( MyNode->Device, MyNode->Partition, 0, 1, MyNode->logical,GetNumber, MyPackID, FPACK_CREAT); if (CallResult != ERR_FS_NO_ERROR) { DirNode->Locked.Release(); ActiveNodes->Release(DirNode); delete [] dir; } MyNode->packID = MyPackID; } else if (CallResult == ERR_FS_NO_ERROR) { // soubor uz existuje -> zkrati se na 0 trunc = 1; ActiveNodes->Add(DirNode->Device, DirNode->Partition, Node, MyNode); } else { // chyba pri pristupu k adresari DirNode->Locked.Release(); ActiveNodes->Release(DirNode); delete [] dir; } // DirNode je v tabulce aktivnich nodu zamceny // trunc = 1 MyNode je v tabulce aktivnich nodu odemceny ->nelze ho smazat // trunc = 0 MyNode je vyplnen v pameti // pristup k systemove tabulce, zjisti prvni volnou diru SystemTableSem->Down(); Task->OpenFiles[MyIndex].SystemTabIndex = BitmapGetFirstHole(SystemOpenFilesBmp, MaxOpenedFiles); if (Task->OpenFiles[MyIndex].SystemTabIndex == 0xffff) { SystemTableSem->Up(); DirNode->Locked.Release(); ActiveNodes->Release(DirNode); if (trunc) { ActiveNodes->Release(MyNode); } Task->ErrorLevel = ERR_TOO_MANY_OPENED_FILES; delete [] dir; SyscallActive = 0; return -1; } BitmapSetBit(SystemOpenFilesBmp, Task->OpenFiles[MyIndex].SystemTabIndex); SystemTableSem->Up(); MySystemIndex = Task->OpenFiles[MyIndex].SystemTabIndex; if (trunc) { // soubor se urizne na velikost 0 CallResult = DeleteMNODEData(MyNode, CacheFlag); if (CallResult != ERR_FS_NO_ERROR) { DirNode->Locked.Release(); ActiveNodes->Release(DirNode); ActiveNodes->Release(MyNode); // obnov bitmapu systemove tabulky SystemTableSem->Down(); BitmapClearBit(SystemOpenFilesBmp, MySystemIndex); SystemTableSem->Up(); Task->ErrorLevel = CallResult; delete [] dir; SyscallActive = 0; return -1; } CacheManCommitPackage(MyNode->packID); } else { // ulozi se node a zapise se do direktorare CallResult = CacheManSaveSector(MyNode->Device, MyNode->Partition, MyNode->logical, 1, MyPackID, FPACK_ADD /*CacheFlag*/, MyNode); if (CallResult != ERR_FS_NO_ERROR) { DirNode->Locked.Release(); ActiveNodes->Release(DirNode); // obnov bitmapu systemove tabulky SystemTableSem->Down(); BitmapClearBit(SystemOpenFilesBmp, MySystemIndex); SystemTableSem->Up(); Task->ErrorLevel = CallResult; delete [] dir; SyscallActive = 0; return -1; } // pridej do adresare zaznam o novem souboru CallResult = AddDirectoryEntry( DirNode, MyNode->logical, CacheFlag, buffer, 0); if (CallResult != ERR_FS_NO_ERROR) { DirNode->Locked.Release(); ActiveNodes->Release(DirNode); // obnov bitmapu systemove tabulky SystemTableSem->Down(); BitmapClearBit(SystemOpenFilesBmp, MySystemIndex); SystemTableSem->Up(); Task->ErrorLevel = CallResult; // uvolni sektor, ktery je naalokovan pro node CacheManFreeSector(MyNode->Device, MyNode->Partition, MyNode->logical, 1, MyPackID, FPACK_ADD/*CacheFlag*/); delete [] dir; SyscallActive = 0; return -1; } CacheManCommitPackage(MyNode->packID,FPACK_DELETE); ActiveNodes->Add(MyNode->Device, MyNode->Partition, MyNode->logical, MyNode); } // MyNode je v tabulce aktivnich uzlu odemceny OpenFiles[MySystemIndex].Used = 1; OpenFiles[MySystemIndex].Access = IO_CAN_BOTH; OpenFiles[MySystemIndex].Access |= (CacheFlag == FPACK_NOTHING) ? IO_CACHE_THROUGH : IO_CACHE_ADD; OpenFiles[MySystemIndex].Position = 0; OpenFiles[MySystemIndex].DirtyBuffer = 1; OpenFiles[MySystemIndex].BufferPos = 0; OpenFiles[MySystemIndex].Buffer = new byte[512]; OpenFiles[MySystemIndex].LastPreload = 0; OpenFiles[MySystemIndex].MemNODE = MyNode; Task->OpenFiles[MyIndex].Bitmap = new byte[(MaxOpenedFiles>>3)+1]; memset(Task->OpenFiles[MyIndex].Bitmap,0,(MaxOpenedFiles>>3)+1); // podiva se jestli uz proces neotevrel stejny soubor, // pokud ano do bitmapy si zanese jeho indexy a svuj index // zanese do jeho bitmapy (pokud nejakou ma) if (trunc) for (i=5,j=Task->NrOpenedFiles-5; i<MaxOpenedFiles; ++i) { if (!j) break; if ((i != MyIndex) && (Task->OpenFiles[i].Used)) { if (MyNode == OpenFiles[Task->OpenFiles[i].SystemTabIndex].MemNODE) { if (Task->OpenFiles[i].Bitmap) BitmapSetBit(Task->OpenFiles[i].Bitmap, MyIndex); BitmapSetBit(Task->OpenFiles[MyIndex].Bitmap, i); } j--; } } Task->OpenFiles[MyIndex].Used = 1; Task->NrOpenedFiles++; BitmapSetBit(Task->Bmp,MyIndex); DirNode->Locked.Release(); ActiveNodes->Release(DirNode); delete [] dir; SyscallActive = 0; return MyIndex; }
int fs_open(byte *path, word mode, word rights) { int i,j,MySystemIndex; TaskUArea *Task = GetCurrentTaskUArea(); word CallResult, MyIndex; MNODE *MyNode; // word CacheFlag; SyscallActive = 1; if ((mode & IO_CREAT) || (mode & IO_TRUNC) ) return fs_creat(path, mode, rights); Task->ErrorLevel = ERR_FS_NO_ERROR; // CacheFlag = (mode & IO_CACHE_THROUGH) ? FPACK_NOTHING : FPACK_ADD; MyIndex = BitmapGetFirstHole(Task->Bmp,MaxOpenedFiles); if (MyIndex == 0xffff) { Task->ErrorLevel = ERR_TOO_MANY_OPENED_FILES; SyscallActive = 0; return -1; } CallResult = NAMEN(path, MyNode, FPACK_ADD); if ( CallResult != ERR_FS_NO_ERROR) { Task->ErrorLevel = CallResult; SyscallActive = 0; return -1; } MyNode->Locked.Release(); // MyNode je v tabulce aktivnich nodu odemceny // pristup k systemove tabulce, zjisti prvni volnou diru SystemTableSem->Down(); Task->OpenFiles[MyIndex].SystemTabIndex = BitmapGetFirstHole(SystemOpenFilesBmp, MaxOpenedFiles); if (Task->OpenFiles[MyIndex].SystemTabIndex == 0xffff) { SystemTableSem->Up(); MyNode->Locked.Release(); Task->ErrorLevel = ERR_TOO_MANY_OPENED_FILES; SyscallActive = 0; return -1; } BitmapSetBit(SystemOpenFilesBmp, Task->OpenFiles[MyIndex].SystemTabIndex); SystemTableSem->Up(); MySystemIndex = Task->OpenFiles[MyIndex].SystemTabIndex; OpenFiles[MySystemIndex].Used = 1; OpenFiles[MySystemIndex].Access = mode; if (mode & IO_APPEND) OpenFiles[MySystemIndex].Position = MyNode->Size; OpenFiles[MySystemIndex].Position = 0; OpenFiles[MySystemIndex].DirtyBuffer = 1; OpenFiles[MySystemIndex].BufferPos = 0; OpenFiles[MySystemIndex].Buffer = new byte[512]; OpenFiles[MySystemIndex].LastPreload = 0; OpenFiles[MySystemIndex].MemNODE = MyNode; Task->OpenFiles[MyIndex].Bitmap = new byte[(MaxOpenedFiles>>3)+1]; memset(Task->OpenFiles[MyIndex].Bitmap,0,(MaxOpenedFiles>>3)+1); // podiva se jestli uz proces neotevrel stejny soubor, // pokud ano do bitmapy si zanese jeho indexy a svuj index // zanese do jeho bitmapy (pokud nejakou ma) for (i=5,j=Task->NrOpenedFiles-5; i<MaxOpenedFiles; ++i) { if (!j) break; if ((i != MyIndex) && (Task->OpenFiles[i].Used)) { if (MyNode == OpenFiles[Task->OpenFiles[i].SystemTabIndex].MemNODE) { if (Task->OpenFiles[i].Bitmap) BitmapSetBit(Task->OpenFiles[i].Bitmap, MyIndex); BitmapSetBit(Task->OpenFiles[MyIndex].Bitmap, i); } j--; } } Task->OpenFiles[MyIndex].Used = 1; Task->NrOpenedFiles++; BitmapSetBit(Task->Bmp,MyIndex); SyscallActive = 0; return MyIndex; }