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