int sock_tcp_acceptnewconn (int mainfd) { int newfd; struct sockaddr_in clientaddr; int clientaddrlen = sizeof (struct sockaddr_in); int ret; /* printf ("off to accept\n"); */ StaticAssert (sizeof (struct sockaddr_in) >= sizeof (struct sockaddr)); if ((newfd = accept (mainfd, (struct sockaddr *) &clientaddr, &clientaddrlen)) == -1) { perror ("Failed to accept new connection"); exit(0); } /* printf ("accepted %d\n", newfd); */ if (((ret = fcntl (newfd, F_GETFL, 0)) < 0) || (fcntl (newfd, F_SETFL, (ret | O_NONBLOCK)) < 0)) { printf ("sock_tcp_acceptnewconn: Unable to make it nonblocking (errno %d)\n", errno); exit (0); } ret = 16384; if (setsockopt (newfd, SOL_SOCKET, SO_RCVBUF, &ret, sizeof (int)) < 0) { printf ("sock_tcp_acceptnewconn: failed to set SO_RCVBUF: %s\n", strerror (errno)); exit (0); } if (setsockopt (newfd, SOL_SOCKET, SO_SNDBUF, &ret, sizeof (int)) < 0) { printf ("sock_tcp_acceptnewconn: failed to set SO_SNDBUF: %s\n", strerror (errno)); exit (0); } return (newfd); }
void v3m_batch_info::Dbg_Print() { const UINT sizeInDWords = 56/4; StaticAssert( sizeof *this == sizeInDWords * sizeof U4 ); DEVOUT("=== Model batch header: ===\n"); for( UINT i=0; i < sizeInDWords; i++ ) { const U4 x = (c_cast(const U4*) this) [i]; DEVOUT("0x%X ", x); } DEVOUT("\n"); }
int pty_init(void) { int i; int status; struct pty *ptyp; #ifdef AEGIS tmp_putchr = putchr; putchr = ae_putc; #endif /* AEGIS */ DPRINTF(CLUHELP_LEVEL,("pty_init")); status = fd_shm_alloc(FD_SHM_OFFSET + PTY_TYPE, (sizeof(struct pty_shared_data)), (char *)PTY_SHARED_REGION); StaticAssert((sizeof(struct pty_shared_data)) <= PTY_SHARED_REGION_SZ); pty_shared_data = (struct pty_shared_data *) PTY_SHARED_REGION; demand(pty_shared_data, pty_shared_data getting bad pointer); if (status == -1) { demand(0, problems attaching shm); return -1; } if (status) { #ifdef AEGIS ae_putc('P'); ae_putc('I'); #endif /* AEGIS */ init_pty_shared_lock(); for (i = 0; i < NR_PTY; i++) { ptyp = MAKEPTYP(i); init_lock_pty(ptyp); CLR_PTY_INUSE(0,ptyp); CLR_PTY_INUSE(1,ptyp); } } else { /*printf("This is not first process, just attaching memory\n"); */ } register_file_ops((struct file_ops *)&pty_file_ops, PTY_TYPE); #ifdef AEGIS putchr = tmp_putchr; #endif /* AEGIS */ return 0; }
void io_initialize (int standalone) { if (disksim->iosim_info == NULL) { iosim_initialize_iosim_info (); } bus_set_depths(); // fprintf (outputfile, "Back from bus_set_depths\n"); StaticAssert (sizeof(ioreq_event) <= DISKSIM_EVENT_SIZE); device_initialize(); bus_initialize(); controller_initialize(); iodriver_initialize(standalone); }
static void allocateextra () { int i; event *temp = NULL; StaticAssert (sizeof(event) == DISKSIM_EVENT_SIZE); if ((temp = (event *)DISKSIM_malloc(ALLOCSIZE)) == NULL) { fprintf (stderr, "*** error: failed to allocate space for events\n"); exit(1); } for (i=0; i<((ALLOCSIZE/DISKSIM_EVENT_SIZE)-1); i++) { temp[i].next = &temp[i+1]; } temp[((ALLOCSIZE/DISKSIM_EVENT_SIZE)-1)].next = disksim->extraq; disksim->extraq = temp; disksim->extraqlen = ALLOCSIZE / DISKSIM_EVENT_SIZE; }
static void cachedev_initialize (struct cache_if *c, void (**issuefunc)(void *,ioreq_event *), void *issueparam, struct ioq * (**queuefind)(void *,int), void *queuefindparam, void (**wakeupfunc)(void *, struct cacheevent *), void *wakeupparam, int numdevs) { struct cache_dev *cache = (struct cache_dev *)c; StaticAssert (sizeof(struct cache_dev_event) <= DISKSIM_EVENT_SIZE); #ifdef DEBUG_CACHEDEV fprintf (outputfile, "*** %f: Entered cachedev::cachedev_initialize\n", simtime ); #endif cache->issuefunc = issuefunc; cache->issueparam = issueparam; cache->queuefind = queuefind; cache->queuefindparam = queuefindparam; cache->wakeupfunc = wakeupfunc; cache->wakeupparam = wakeupparam; cache->bufferspace = 0; cache->ongoing_requests = NULL; bzero (cache->validmap, bitstr_size(cache->size)); bzero (cache->dirtymap, bitstr_size(cache->size)); cachedev_resetstats(c); if (cache->flush_idledelay > 0.0) { struct ioq *queue = (*queuefind)(queuefindparam,cache->real_devno); ASSERT (queue != NULL); ioqueue_set_idlework_function (queue, &disksim->idlework_cachedev, cache, cache->flush_idledelay); } if (device_get_number_of_blocks(cache->cache_devno) < cache->size) { fprintf (stderr, "Size of cachedev exceeds that of actual cache device (devno %d): %d > %d\n", cache->cache_devno, cache->size, device_get_number_of_blocks(cache->cache_devno)); ddbg_assert(0); } }
int synch_init(void) { int status; int i; hz = 1000000 / __sysinfo.si_rate; status = fd_shm_alloc(SYNCH_SHM_OFFSET, sizeof(struct synch_table), (char *)SYNCH_SHARED_REGION); StaticAssert((sizeof(struct synch_table)) <= SYNCH_SHARED_REGION_SZ); if (status == -1) demand(0, problems attaching shm); synch_table = (struct synch_table *)SYNCH_SHARED_REGION; if (status) { /* first process */ for (i = 0; i < NENV; i++) synch_table->wchan[i] = NULL; } return 0; }
int npty_init(void) { int status,i; DPRINTF(CLUHELP_LEVEL,("pty_init")); status = fd_shm_alloc(FD_SHM_OFFSET + NPTY_TYPE + 990, (sizeof(struct npty_shared_data)), (char *)NPTY_SHARED_REGION); demand(npty_shared_data != 0, pty_shared_data getting bad pointer); StaticAssert((sizeof(struct npty_shared_data)) <= NPTY_SHARED_REGION_SZ); if (status == -1) { demand(0, problems attaching shm); return -1; } if (status) { k1printf("npty_init first %d\n",NPTY_TYPE); bzero(npty_shared_data,(sizeof(struct npty_shared_data))); npty_tty_init(); /* initialize tty, clists */ pt_softc_init(1); init_npty_shared_lock(); for (i = 0; i < NPTY; i++) { init_lock_pty(i); npty_shared_data->refcount[0][i] = 0; npty_shared_data->refcount[1][i] = 0; } //npty_sched_init(1); } else { k1printf("npty_init second+ %d\n",NPTY_TYPE); //npty_sched_init(0); pt_softc_init(0); } k1printf("pty_init: envid: %d\n",__envid); register_file_ops((struct file_ops *)&pty_file_ops, NPTY_TYPE); return 0; }
void ExosLocksInit() { int Segment; int NeedsInit = 0; StaticAssert(EXOS_LOCKS_SHM_SZ < EXOS_LOCKS_SHARED_REGION_SZ); /* see if the shared segment already created */ Segment = shmget(EXOS_LOCKS_SHM_OFFSET, EXOS_LOCKS_SHM_SZ, 0); /* if not, create it */ if (Segment == -1) { if (errno == ENOENT) { /* create shared segment */ Segment = shmget(EXOS_LOCKS_SHM_OFFSET, EXOS_LOCKS_SHM_SZ, IPC_CREAT); NeedsInit = 1; } if (Segment == -1) { panic ("ExosLocksInit: Could not create shared segment for MP locks"); } } if ((global_lock = (exos_lock_t*) shmat(Segment, (char*)EXOS_LOCKS_SHARED_REGION, 0)) == (exos_lock_t*)-1) { global_lock = (exos_lock_t*) 0; panic("ExosLocksInit: Could not attach global_lock"); } if (NeedsInit) /* if we just created the lock, initialize it */ { exos_lock_init(global_lock); } #ifdef __LOCKS_DEBUG__ exos_locks_debug_init(); #endif dprintf("ExosLocksInit: SHM obtained\n"); }
int arp_init(void) { int status; status = fd_shm_alloc(ARP_SHM_OFFSET, sizeof(arp_table_t), (char *)ARP_SHARED_REGION); arp_table = (arp_table_p)ARP_SHARED_REGION; StaticAssert((sizeof(arp_table_t)) <= ARP_SHARED_REGION_SZ); if (status == -1) { demand(0, problems attaching shm); return -1; } if (status) { arp_init_table(); } protect_arp_table(); return 0; }
int ip_init() { int status; status = fd_shm_alloc(IP_SHM_OFFSET, sizeof(ip_table_t), (char *)IP_SHARED_REGION); ip_table = (ip_table_p)IP_SHARED_REGION; StaticAssert((sizeof(ip_table_t)) <= IP_SHARED_REGION_SZ); if (status == -1) { demand(0, problems attaching shm); return -1; } if (status) { ip_init_table(); } mk_ip_table_ro(); return 0; }
bool F_Compose_File_Path(PCHARS szProjFilePath, PCHARS fileExtensionWithDot, ANSICHAR (&destBuf)[BUF_SIZE]) { AssertPtr( szProjFilePath ); AssertPtr( destBuf ); StaticAssert( BUF_SIZE > 0 ); // pure name (e.g. "MyProject") ANSICHAR projName[ 128 ]; V_FileBase( szProjFilePath, projName, NUMBER_OF(projName) ); // path relative to exe (e.g. "Projects/MyProject/") ANSICHAR projFilePath[ FS_MAX_PATH ]; VRET_FALSE_IF_NOT( V_ExtractFilePath( szProjFilePath, projFilePath, NUMBER_OF(projFilePath) ) ); // path to .INI file relative to exe (e.g. "Projects/MyProject/MyProject.INI") ANSICHAR outFilePath[ FS_MAX_PATH ]; V_ComposeFileName( projFilePath, projName, outFilePath, NUMBER_OF(outFilePath) ); V_SetExtension( outFilePath, fileExtensionWithDot, NUMBER_OF(outFilePath) ); mxStrCpyNAnsi( destBuf, outFilePath, NUMBER_OF(destBuf) ); return true; }
// int cffsd_fsupdate_dinode (u_int sn, int action, struct dinode *d, u_int param1, u_int param2, u_int param3) int serv_fsupdate_dinode (u_int client_eid, int action, struct cffsd_fsupdate_dinode_arg *arg) { int i; char *indirblock; struct dinode *d; u_int param1 = arg->param1; u_int param2 = arg->param2; u_int param3 = arg->param3; dinode_t *dinode; debug_request = 1; dinode = d = translate_address (&arg->dinode); if (dinode == NULL) { kprintf ("sys_fsupdate_dinode: bad address supplied\n"); return (-E_INVAL); } StaticAssert (sizeof(dinode_t) == CFFS_DINODE_SIZE); /* printf ("sys_fsupdate_dinode: action %d, param1 %d (%x), param2 %d\n", action, param1, param1, (u_int)param2); printf ("dinodeNum %d\n", dinode->dinodeNum); */ switch (action) { case CFFS_DINODE_SETMASK: cffs_dinode_setMask (dinode, (mode_t)param1); break; case CFFS_DINODE_SETUID: cffs_dinode_setUid (dinode, (uid_t)param1); break; case CFFS_DINODE_SETGID: cffs_dinode_setGid (dinode, (gid_t)param1); break; case CFFS_DINODE_SETACCTIME: cffs_dinode_setAccTime (dinode, param1); break; case CFFS_DINODE_SETMODTIME: cffs_dinode_setModTime (dinode, param1); break; case CFFS_DINODE_SETCRETIME: cffs_dinode_setCreTime (dinode, param1); break; case CFFS_DINODE_SETLENGTH: cffs_dinode_setLength (dinode, param2); assert (dinode->length == param2); break; case CFFS_DINODE_SETTYPE: if (dinode->type == param1) { return (0); } if ((dinode->dinodeNum != 0) && ((cffs_dinode_isDir(dinode)) || (param1 == S_IFDIR))) { printf ("sys_fsupdate_dinode (%d): trying to change type to or from directory (%d -> %d)\n", action, dinode->type, param1); return (-E_INVAL); } cffs_dinode_setType (dinode, (u_int16_t)param1); break; case CFFS_DINODE_SETLINKCOUNT: if ((dinode->dinodeNum != 0) && (dinode->linkCount != param1)) { printf ("sys_fsupdate_dinode (%d): changing link count directly (%d -> %d)\n", action, dinode->linkCount, param1); //return (-E_INVAL); } cffs_dinode_setLinkCount (dinode, (nlink_t)param1); break; case CFFS_DINODE_SETOPENCOUNT: cffs_dinode_setOpenCount (dinode, param1); break; case CFFS_DINODE_SETDIRNUM: if (cffs_dinode_isDir(dinode)) { printf ("sys_fsupdate_dinode (%d): trying to change dirNum of directory directly (%d -> %d) requested\n", action, dinode->dirNum, param1); return (-E_INVAL); } cffs_dinode_setDirNum (dinode, param1); break; case CFFS_DINODE_SETDIRECT: cffs_dinode_setDirect (dinode, param1, (u_int)param2); break; case CFFS_DINODE_SETINDIRECT: cffs_dinode_setIndirect (dinode, param1, (u_int)param2); break; case CFFS_DINODE_SETGROUPSTART: cffs_dinode_setGroupstart (dinode, param1); break; case CFFS_DINODE_SETGROUPSIZE: cffs_dinode_setGroupsize (dinode, param1); break; case CFFS_DINODE_CLEARBLOCKPOINTERS: cffs_dinode_clearBlockPointers(dinode, param2); break; case CFFS_DINODE_DELAYEDFREE: if ((dinode->linkCount > (cffs_dinode_isDir(dinode))) || (dinode->openCount != 0)) { printf ("sys_fsupdate_dinode (%d): can't free dinode with links or opens (%d, %d) requested\n", action, dinode->linkCount, dinode->openCount); return (-E_INVAL); } for (i=0; i<NUM_DIRECT; i++) { if (dinode->directBlocks[i] != 0) { printf ("sys_fsupdate_dinode (%d): can't free dinode with direct blocks (%d == %d) requested\n", action, i, dinode->directBlocks[i]); return (-E_INVAL); } } for (i=0; i<NUM_INDIRECT; i++) { if (dinode->indirectBlocks[i] != 0) { printf ("sys_fsupdate_dinode (%d): can't free dinode with indirect blocks (%d == %d) requested\n", action, i, dinode->indirectBlocks[i]); return (-E_INVAL); } } /* In the real system, this wants to occur only after the block is written (unless it is not dirty) */ dinode->dinodeNum = 0; break; case CFFS_DINODE_INITINDIRBLOCK: indirblock = (char *) dinode; /* XXX % */ if ((indirblock == NULL) || ((u_int)indirblock % BLOCK_SIZE)) { printf ("sys_fsupdate_dinode (%d): bad indirblock address supplied (%p)\n", action, indirblock); return (-E_INVAL); } bzero (indirblock, BLOCK_SIZE); break; case CFFS_DINODE_INITDINODE: bzero ((char *)dinode, CFFS_DINODE_SIZE); dinode->memory_sanity = CFFS_DINODE_MEMORYSANITY; dinode->type = param1; dinode->linkCount = (cffs_dinode_isDir(dinode)) ? 2 : 1; dinode->dinodeNum = param2; dinode->dirNum = param3; break; default: printf ("sys_fsupdate_dinode: unknown action (%d) requested\n", action); return (-E_INVAL); } return (0); }
// int cffsd_fsupdate_superblock (u_int sn, int action, struct superblock *superblock, u_int param1, u_int param2) int serv_fsupdate_superblock (u_int client_eid, int action, struct cffsd_fsupdate_superblock_arg *arg) { struct superblock *superblock; u_int param1 = arg->param1; u_int param2 = arg->param2; debug_request = 2; superblock = translate_address (&arg->superblock); StaticAssert (sizeof(struct superblock) == NBPG); StaticAssert (BLOCK_SIZE == NBPG); // superblock = (struct superblock *) translate_address ((uint)superblock, NBPG); if (superblock == NULL) { return (-E_INVAL); } if (action == CFFS_SUPERBLOCK_SETDIRTY) { /* allow anyone to set dirty to a non-zero value at any time. */ /* However, must verify that there are no dirty blocks from this */ /* file system before allowing anyone to set dirty to 0. */ superblock->dirty = param1; } else if (action == CFFS_SUPERBLOCK_SETROOTDINODENUM) { /* verify that the provided rootDInodeNum is in fact the correct */ /* system value -- we should know this based on the superblocks addr */ superblock->rootDInodeNum = param1; } else if (action == CFFS_SUPERBLOCK_SETFSNAME) { /* verify that the provided fsname is in fact the correct value */ /* -- should match XN's expectation... */ /* Also, don't allow it to go out of bounds in superblock... */ // char *str = (char *) trup(param1); /* XXX */ strcpy (superblock->fsname, CFFS_FSNAME); } else if (action == CFFS_SUPERBLOCK_DELETE) { superblock->fsname[0] = 0; /* just clear the name for now */ } else if (action == CFFS_SUPERBLOCK_SETFSDEV) { /* verify that the provided fsdev is in fact the correct system value */ /* -- XN should certainly know this... */ superblock->fsdev = param1; } else if (action == CFFS_SUPERBLOCK_SETALLOCMAP) { /* this is a totally temporary call. This field should be maintained */ /* solely by XN... */ superblock->allocMap = param1; } else if (action == CFFS_SUPERBLOCK_SETNUMBLOCKS) { /* this is a totally temporary call. This field should be maintained */ /* solely by XN... */ superblock->numblocks = param1; } else if (action == CFFS_SUPERBLOCK_SETSIZE) { /* this is a totally temporary call. This field should be maintained */ /* solely by XN... */ superblock->size = param1; } else if (action == CFFS_SUPERBLOCK_SETNUMALLOCED) { /* this is a totally temporary call. This field should be maintained */ /* by the ALLOCATE and DEALLOCATE methods... */ superblock->numalloced = param1; } else if (action == CFFS_SUPERBLOCK_SETXNTYPE) { /* this is a totally temporary call. This field should be maintained */ /* and updated only by newfs!!... */ if ((param1 < 0) || (param1 >= CFFS_MAX_XNTYPES)) { printf ("sys_fsupdate_superblock (%d): bad typeno %d (NUM %d)\n", action, param1, CFFS_MAX_XNTYPES); return -E_INVAL; } superblock->xntypes[param1] = param2; } else if (action == CFFS_SUPERBLOCK_INIT) { /* this is a totally temporary call. Just for when not using XN */ bzero (superblock, BLOCK_SIZE); } else if (action == CFFS_SUPERBLOCK_SETBLK) { superblock->blk = param1; } else if (action == CFFS_SUPERBLOCK_SETQUOTA) { if (param1 > superblock->numblocks) { printf ("sys_fsupdate_superblock (%d): quota (%d) is bigger than available space (%d)\n", action, param1, superblock->numblocks); return -E_INVAL; } superblock->quota = param1; } else { printf ("sys_fsupdate_superblock: unknown action requested (%d)\n", action); return (-E_INVAL); } return (0); }
int fd_fast_tcp_init(void) { int i; int status; START(fd_op[TCP_SOCKET_TYPE],init); DPRINTF(CLUHELP_LEVEL,("tcp_socket_init\n")); #if 0 printf("tcpsocket_init: just to test the memory, but tcp\n" "uses its own static structures\n"); #endif #ifdef AEGIS status = fd_shm_alloc(FD_SHM_OFFSET + TCP_SOCKET_TYPE, (sizeof(struct tcp_shared_data)), (char *)TCP_SHARED_REGION); StaticAssert((sizeof(struct tcp_shared_data)) <= TCP_SHARED_REGION_SZ); tcp_shared_data = (struct tcp_shared_data *) TCP_SHARED_REGION; #endif /* AEGIS */ #ifdef EXOPC status = 1; tcp_shared_data = (struct tcp_shared_data *) malloc(sizeof(struct tcp_shared_data)); assert(tcp_shared_data); #endif /* EXOPC */ if (status == -1) { demand(0, problems attaching shm); STOP(fd_op[TCP_SOCKET_TYPE],init); return -1; } if (status) { /* printf("Initializing tcp shared data structture\n"); */ assert(sizeof(struct tcp_socket_data) <= FILE_DATA_SIZE); for (i = 0; i < NR_SOCKETS; i++) tcp_shared_data->used_ports[i] = 0; #if 0 /* Using local structures */ for (i = 0; i < MAX_CONNECTION; i++) tcb_release(&(tcp_shared_data->connection[i])); #endif tcp_shared_data->next_port = (getpid() << 9) | random(); } else { /* printf("This is not first process, just attaching memory\n"); */ } /* AF_UNIX, SOCK_STREAM, TCP */ register_family_type_protocol(2,1,6,tcp_socket); /* AF_UNIX, SOCK_STREAM, IP */ register_family_type_protocol(2,1,0,tcp_socket); register_file_ops(&tcp_file_ops, TCP_SOCKET_TYPE); #if 0 /* commented out for now */ init_handoff(); #endif STOP(fd_op[TCP_SOCKET_TYPE],init); return 0; }