void
os_init_cont(void) {
/* Reset the GDT. Although user processes in Nanos run in Ring 0,
they have their own virtual address space. Therefore, the
old GDT located in physical address 0x7C00 cannot be used again. */
init_segment();
/* Initialize the serial port. After that, you can use printk() */
init_serial();
/* Set up interrupt and exception handlers,
just as we did in the game. */
init_idt();
/* Initialize the intel 8259 PIC. */
init_intr();
/* Initialize processes. You should fill this. */
init_proc();
welcome();
sti();
/* This context now becomes the idle process. */
while (1) {
wait_intr();
}
}
int main() {
mSTAT = mSTAT_RSV_START;
mPc.baud(9600 );
mPc.printf("#Start-main \n");
init_proc();
// int iWait=200;
// int iMode=0; //0=temp, 1=time
int iCt=0;
while(1){
if(mSTAT != mSTAT_DISP){
proc_uart();
wait_ms(5);
}else{
printf("#disp \n" );
string sBuff="";
sBuff=mReceive.substr(2,4);
printf("sBuff=%s \n" ,sBuff.c_str() );
proc_dispTime(sBuff);
wait_ms(100);
display_rgb(iCt );
iCt =iCt +1;
if(iCt >= 9 ){ iCt=0; }
mSTAT =mSTAT_RSV_START;
}
}
}
void init() {
int i;
// Initialize kseg0 & useg3 page table (same for all processes)
init_kernel_pt();
init_useg3_pt();
// Initilize all VM-I/O support level semaphores
swap_semaphore = 1;
memset(uproc_semaphore, 0, sizeof(int) * UPROCMAX); //Private semaphore for delay facility
initADL();
init_del_deamon();
initAVSL();
disk_init();
initSwapPool();
initDMA();
// Init all the u-procs from tape and get the number of u-procs created
uprocess_c = init_proc();
// wait for all uprocs to terminate
SYSCALL(SEMOP,&master_sem,-1,0);
//Terminate Deamon
SYSCALL(TERMINATEPROCESS,3,0,0);
//Terminate the init process (and all his children)
//This should HALT the system
SYSCALL(TERMINATEPROCESS,0,0,0);
fatal("System failed to terminate");
}
//int init_net(int count , char *ip, int port);
//int net_loop();
int main(int argc,char** argv)
{
char ip[10]="127.0.0.1";
int port=10002;
int MAX_EPOLL_CNT=100;
if(init_proc()){
return -1;
}
init_net(MAX_EPOLL_CNT, ip, 10000);
for(int loop=0 ; loop < MAX_PID_CNT ; loop++ ){
int pid=fork();
if( pid>0 ){
std::cout<<"parent start:"<<getpid()<<std::endl;
}else if(pid==0){
std::cout<<"child start"<<" pid: "<<getpid()<<" parent:"<<getppid()<<std::endl;
exit_net();
while(1){
net_loop(0);
}
}else{
exit(-1);
}
}
while(1){
net_loop(1);
}
exit_net();
return 0;
}
static int __init keypad_qxdm_init(void)
{
int retval;
printk(KERN_INFO "%s: keypad_qxdm driver init.\n", __func__);
init_waitqueue_head(&keypad_qxdm_wait);
retval = init_proc();
return 0;
}
static void init_library(HMODULE)
{
#if defined(__AIX__) && defined(__GNUC__)
dlerror(); // Clear the error state.
typedef void (*init_proc_type)();
init_proc_type init_proc =
(init_proc_type)MyGetProcAddress(dll_hand, "_GLOBAL__DI");
if (init_proc)
init_proc();
#endif
}
static void pre_exec(t_env *e, t_proc *proc)
{
if ((proc->inst.size = parsing_instruction(proc, e->mem)) != -1)
proc->pc = (proc->pos + proc->inst.size) % MEM_SIZE;
if (proc->exec == 1)
exe_instruction(proc, e);
else
{
if ((e->verbose & VERBOSE_PC) == VERBOSE_PC)
print_adv(proc, e, 1);
proc->pos = proc->pc;
}
init_proc(proc);
}
int kernel_main()
{
ticks=0;
disp_str("-----kernel_main begins ----\n");
init_proc();
init_clock();
restart();
while(1)
{}
}
int main() {
mSTAT = mSTAT_RSV_START;
mPc.baud(9600 );
mPc.printf("#Start-main \n");
init_proc();
while(1){
float fSen = inSen1;
int reading = int(fSen * 1000);
int iTemP = getTempNum(reading);
printf("reading=%d , iTemP=%d \n" , reading ,iTemP);
proc_display( iTemP);
wait_ms(100);
wait(1);
mSTAT =mSTAT_RSV_START;
}
}
bool Output::execute()
{
init_proc();
//The post-increment operator is slower than the pre-increment, don't use it unless you have a reason
/* Also using a for to increment the counter_ doesn't work, not entirely sure why but it seems
* the increment is not executed when we return to the function after the yield().
*/
while (counter_ < 10)
{
std::cout << name_ << " is executing for the " << ++counter_ << " time" << std::endl;
if (sleep_)
sleep(1);
else
yield();
}
end_proc();
return false;
}
void kernel_main(void)
{
clear();
clear_line(13);
s32_print("memory size", (u8*)(0xb8000+160*13));
//int memsize = memtest(0x00400000, 0xbfffffff) / (1024 * 1024);
// 0x2000000 = 32MB
// because of bochs will alert memory access more than the memory size,
// so limit address to 0x2000000, if use qemu, it works fine.
memsize = memtest(0x00400000, 0x2000000);
int memsize_mb = memsize / (1024 * 1024);
u8 stack_str[10]="y";
u8 *sp = stack_str;
sp = s32_itoa(memsize_mb, stack_str, 10);
clear();
#if 1
clear_line(24);
s32_print("memory size", (u8*)(0xb8000+160*24));
s32_print(sp, (u8*)(0xb8000+160*24 + 12*2));
s32_print("MB", (u8*)(0xb8000+160*24 + 12*2 + 4*2));
#endif
void setup_paging(void);
//setup_paging();
put_irq_handler(CLOCK_IRQ, clock_handler);
enable_irq(CLOCK_IRQ);
ready_process = proc_table;
init_proc();
cur_vb = (u8*)0xb8000+160;
void restart(void);
restart();
s32_print("xxxxxxxxxxx", (u8*)(0xb8000+160*15));
while(1);
}
int glkunix_startup_code(glkunix_startup_t *data)
{
myargc = data->argc;
myargv = data->argv;
os_init_setup ();
os_process_arguments (myargc, myargv);
init_buffer ();
init_err ();
init_memory ();
init_proc ();
init_sound ();
init_text ();
os_init_screen ();
init_undo ();
z_restart ();
return TRUE;
}
int main(int argc,char* argv[]){
/**Initialize signal**/
signal(SIGINT ,_end_server);
signal(SIGUSR1,_end_server);
/**Initialize struct proc**/
init_proc();
init_cons();
/**Process becomes dem**/
pid_t process_id = 0;
pid_t sid = 0;
if(argc >= 2){
process_id = fork();
if(process_id < 0){
printf("fork failed ..\n");
exit(1);
}
if(process_id > 0){
exit(0);
}
umask(0);
sid = setsid();
if(sid < 0){
exit(1);
}
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
}else{
sid = getpid();
}
/**Setup the log file**/
char log[32];
sprintf(log,"log.%u",sid);
// fp = fopen(log,"w+");
/**Start Initialize nvidia management library from Here!!**/
nvmlReturn_t nres;
int i;
nres = nvmlInit();
if(nres != NVML_SUCCESS){
perror("Failed to initialize Nvidia Managerment Library...\n");
exit(-1);
}
nres = nvmlDeviceGetCount(&dem.ndev);
if(nres != NVML_SUCCESS){
perror("Failed to get num of device...\n");
exit(-1);
}
dem.devs = (nvmlDevice_t*)malloc(sizeof(nvmlDevice_t)*dem.ndev);
dem.flags = (dflag*)malloc(sizeof(dflag)*dem.ndev);
MAXPROC = dem.ndev * 4;
for(i = 0 ; i < dem.ndev ; i ++){
nres = nvmlDeviceGetHandleByIndex(i,&dem.devs[i]);
if(nres != NVML_SUCCESS){
perror("Failed to get device handle\n");
exit(-1);
}
dem.flags[i].sd = -1;
dem.flags[i].flag = 0;
dem.flags[i].stayed = 0;
dem.flags[i].reserved = 0;
}
dem.procCounter = 0;
/**Setup the socket**/
int len,rc,on = 1;
int listen_sd,max_sd,new_sd;
int desc_ready;
int close_conn;
struct sockaddr_un addr;
struct timeval timeout;
fd_set master_set,working_set;
listen_sd = socket(AF_UNIX,SOCK_STREAM,0);
if(listen_sd < 0){
perror("socket() failed\n");
exit(-1);
}
rc = setsockopt(listen_sd, SOL_SOCKET, SO_REUSEADDR, (char*)&on,sizeof(on));
if(rc < 0){
perror("setsockopt() failed\n");
exit(-1);
}
unlink("mocu_server");
memset(&addr,0,sizeof(addr));
addr.sun_family = AF_UNIX;
strcpy(addr.sun_path,"mocu_server");
rc = bind(listen_sd,(struct sockaddr*)&addr,sizeof(addr));
if(rc < 0){
perror("bind() failed");
close(listen_sd);
exit(-1);
}
rc = listen(listen_sd,SOMAXCONN);
if(rc < 0){
perror("listen() failed");
close(listen_sd);
exit(-1);
}
FD_ZERO(&master_set);
max_sd = listen_sd;
FD_SET(listen_sd,&master_set);
timeout.tv_sec = 3*60;
timeout.tv_usec = 0;
long counter = 0;
/**Entering main loop**/
proc_data* receivedProc = (proc_data*)malloc(sizeof(proc_data));
mocu_check();
do{
memcpy(&working_set,&master_set,sizeof(master_set));
rc = select(max_sd+1, &working_set, NULL, NULL, NULL);
if(rc < 0){
perror("select() failed\n");
break;
}
if(rc == 0){
printf("select() time out. End program.\n");
break;
}
desc_ready = rc;
for(i = 0 ; i < max_sd+1 && desc_ready > 0 ; ++i){
if(FD_ISSET(i,&working_set)){
desc_ready = -1;
if(i == listen_sd){
new_sd = accept(listen_sd,NULL,NULL);
if(new_sd < 0){
printf("accept() failed");
end_server = TRUE;
}
FD_SET(new_sd,&master_set);
if(new_sd > max_sd){
max_sd = new_sd;
}
}else{
rc = recv(i,receivedProc,sizeof(proc_data),0);
if(rc <= 0){
FD_CLR(i,&master_set);
_FIN(i);
}else{
if(receivedProc->REQUEST == CONNECT){
_CONNECT(i,receivedProc);
}else if(receivedProc->REQUEST == RENEW){
_RENEW(i,receivedProc);
}else if(receivedProc->REQUEST == MIGDONE){
_MIGDONE(i,receivedProc);
}else if(receivedProc->REQUEST == CANRECEIVE){
_CANRECEIVE(i,receivedProc);
}else if(receivedProc->REQUEST == FAILEDTOALLOC){
_FAILEDTOALLOC(i,receivedProc);
exit(-1);//TEST
}else if(receivedProc->REQUEST == MALLOCDONE){
_MALLOCDONE(i,receivedProc);
}else if(receivedProc->REQUEST == CUDAMALLOC){
_CUDAMALLOC(i,receivedProc);
}else if(receivedProc->REQUEST == BACKUPED){
_BACKUPED(i,receivedProc);
}else if(receivedProc->REQUEST == CONTEXT_CHECK){
_CONTEXT_CHECK(i,receivedProc);
}else if(receivedProc->REQUEST == CREATE_CONTEXT){
_CREATE_CONTEXT(i);
}else if(receivedProc->REQUEST == CONSOLE){
_CONSOLE(i);
}else{
printf("Unkown request...\n");
exit(-1);
}
}
}
}
}
mocu_check();
}while(end_server == FALSE);
int closed = 0;
for(i = 0 ; i < max_sd ; i ++){
if(FD_ISSET(i,&master_set)){
close(i);
closed = 1;
}
}
// fclose(fp);
return 0;
}
/*******************************************************************************
MAIN FUNCTION
*******************************************************************************/
int main(int ac, char **av)
{
FILE *fp;
int fd;
int pid;
int i, j, ln, err, kf, dRet;
int init_only_one = 0;
int verbose_flag = 0;
char buf[BUF_SIZE];
char fname[BUF_SIZE];
char block_name[BUF_SIZE];
char tmpbuf[128], errbuf[2048];
signal(SIGHUP, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
signal(SIGQUIT, init_isr);
dRet = dGetUserPermission();
if( dRet == 0 )
{
sprintf(errbuf, "INAVLID USER PERMISSION\n" );
PrintOut(TIFB_FAIL, errbuf);
return 1;
}
dRet = dGetBlocks(FILE_MC_INIT,STR_TSW_COM);
if( dRet < 0 ){
sprintf(errbuf, "FAILED IN McInit\n" );
PrintOut(TIFB_FAIL, errbuf);
return 1;
}
else{
dCurrBlockCnt = dRet;
}
if( init_proc() < 0 ){
exit(0);
}
if (ac == 1) /*** ALL START ********************************************/
{
strcpy(fname, FILE_MC_INIT); /*** "McInit" File ****************************/
}
else if (ac > 3)
{
UsageExit();
}
else
{
for(i = 1;i < ac;i++)
{
if (av[i][0] != '-')
{
UsageExit();
}
else if(av[i][1] == 'b')
{
if( ac < 3 )
{
UsageExit();
}
else /*** ONLY ONE BLOCK START *****************************/
{
++i;
init_only_one = 1;
for(j = 0;j < strlen(av[i]);j++)
block_name[j] = toupper(av[i][j]);
block_name[j] = 0;
}
}
else if( av[i][1] == 'v' ) /*** ALL START ************************/
{
verbose_flag = 1;
}
else if(av[i][1] == 'd') {
/* FOR SYSTEM AUTO RESTART : WAIT BOOTTING COMPLETE */
sleep(300);
verbose_flag = 1;
}
else
{
UsageExit();
}
}
}
//freopen("/dev/null", "w", stdout);
/*** 한개 블럭을 기동 시킴 ************************************************/
if (init_only_one)
{
pid = InitOnlyOneBlock(block_name);
if(pid > 0)
{
sprintf(errbuf, "NEW BLOCK : %s\n PROCESS ID: %d\n", block_name, pid);
PrintOut(TIFB_SUCCESS, errbuf);
for(i=0; i< dCurrBlockCnt; i++)
{
if( STR_TSW_COM[i] == NULL )
continue;
if( !strcasecmp(block_name, STR_TSW_COM[i]) )
{
send_pid_msg(i, pid);
break;
}
}
}
exit(0);
}
/***************************************************************************
READ FIDB_FILE, SET SHARED MEMORY VALUE
***************************************************************************/
if ((fd = open (FILE_FIDB, O_RDONLY, 0666)) < 0)
{
}
else
{
remove( FILE_FIDB );
}
strcpy(fname, FILE_MC_INIT);
if((fp = fopen(fname, "r")) == NULL)
{
sprintf(errbuf, "CAN'T OPEN FILE %s\n", fname);
PrintOut(TIFB_FAIL, errbuf);
exit(1);
}
ln = cntr = 0;
/***************************************************************************
READ McInit File. SET blocks(bname, fname) VALUE
***************************************************************************/
while(fgets(buf, BUF_SIZE, fp) != NULL)
{
ln++;
if (AnalyzeLine(buf) < 0)
{
fclose(fp);
close(fd);
sprintf(errbuf, "SYNTAX ERROR (FILE: %s, LINE: %d)\n", fname, ln);
PrintOut(TIFB_FAIL, errbuf);
exit(1);
}
}
fclose(fp);
/***************************************************************************
WHEN ALL BLOCK IS STARTED, CHECK 2 TIMES
***************************************************************************/
if( verbose_flag == 0 )
{
fprintf(stderr, "\n\tBlocks to initialize are follows.\n");
PrintBlocks();
fprintf(stderr, "\tDo you want initialize (y/n) ? ");
err = GetYorN();
if(err == _NO)
{
sprintf(errbuf, "STOPPED BY USER REQUEST\n");
PrintOut(TIFB_SUCCESS, errbuf);
exit(0);
}
fprintf(stderr, "\n\tDo you really want initialize (y/n) ? ");
err = GetYorN();
if(err == _NO)
{
sprintf(errbuf, "STOPPED BY USER REQUEST\n");
PrintOut(TIFB_SUCCESS, errbuf);
exit(0);
}
}
sprintf(errbuf, "MAIN COMPUTER PROCESSS INITIALIZATION STARTED\n");
PrintOut( TIFB_SUCCESS , errbuf );
signal(SIGINT, init_isr);
/*** 프로세스 기동을 개시함 ***********************************************/
for(i=0; i<cntr; i++)
{
/*** 파일의 존재 및 수행가능성 조사 ***********************************/
if( IsCorrectBlock(i) < 0 )
{
if( verbose_flag == 1 )
{
continue;
}
else
{
sprintf(errbuf, "FILE %s DOES NOT EXIST\n", blocks[i].fname);
PrintOut(TIFB_FAIL, errbuf);
fprintf(stderr, "\n\tDo you want to continue (y/n) ? ");
err = GetYorN();
if(err == _YES)
{
inits[i].isinit = _FALSE;
continue;
}
else
{
final_isr();
}
}
}
/*** 이미 실행중인지 여부를 검사 **************************************/
if ( (pid = GetProcessID(blocks[i].bname)) > 0 )
{
/* 이미 실행중인 경우 */
if( verbose_flag == 1 )
{
err = _YES ;
}
else
{
fprintf(stderr, "\n\tBlock \"%s\" is already running.\n", blocks[i].bname);
fprintf(stderr, "\tDo you want replace block \"%s\" (y/n) ? ", blocks[i].bname);
err = GetYorN();
}
if(err == _NO)
{
inits[i].isinit = _FALSE;
continue;
}
else
{
/* New Version of Killing */
kf = kill(pid, SIGTERM);
if (kf < 0)
{
//sleep(2);
if (kill(pid, SIGTERM) < 0)
{
if (errno == ESRCH)
kf = 0;
}
else
{
kf = 0;
}
}
if ( kf && kill(pid, SIGKILL) < 0)
{
if( verbose_flag == 1 )
{
err = _YES ;
}
else
{
fprintf(stderr, "\tCan't kill process \"%d\"(%s)\n", pid, blocks[i].bname);
fprintf(stderr, "\tDo you want to continue (y/n) ? ");
err = GetYorN();
}
if(err == _YES)
{
inits[i].isinit = _FALSE;
continue;
}
else
{
final_isr();
}
}
else
{
sprintf(errbuf, "PROCESS %s(PID=%d) KILLED\n", blocks[i].fname, pid);
PrintOut(TIFB_SUCCESS, errbuf);
}
}
}
signal(SIGTERM, init_isr);
/***********************************************************************
PROCESS START
***********************************************************************/
err = ProcessStart(i);
if(err == -1)
{
if( verbose_flag == 1 )
{
continue;
}
else
{
sprintf(errbuf, "CAN'T START PROCESS BLOCK: %s\n", blocks[i].bname);
PrintOut(TIFB_FAIL, errbuf);
fprintf(stderr, "\tDo you want to continue (y/n) ? ");
}
}
else if(err == -2)
{
if( verbose_flag == 1 )
{
continue;
}
else
{
sprintf(errbuf, "PROGRAM NAME %s DOES NOT MEET NAME CONVENTION\n", blocks[i].fname);
strcat(errbuf, " ABANDON EXECUTING PROCESS\n");
PrintOut(TIFB_FAIL, errbuf);
fprintf(stderr, "\tDo you want to continue (y/n) ? ");
}
}
if(err < 0)
{
if( verbose_flag == 1 )
{
err = _YES;
}
else
{
err = GetYorN();
}
if(err == _NO)
{
final_isr();
}
else
{
inits[i].isinit = _FALSE;
continue;
}
}
else
{
sprintf(errbuf, "A PROCESS INIAILIZATION SUCCESS\n");
sprintf(tmpbuf, " BLOCK NAME : %s\n", blocks[i].bname);
strcat(errbuf, tmpbuf);
sprintf(tmpbuf, " PROGRAM NAME : %s\n", blocks[i].fname);
strcat(errbuf, tmpbuf);
sprintf(tmpbuf, " PROCESS ID : %d\n", err);
strcat(errbuf, tmpbuf);
PrintOut(TIFB_SUCCESS, errbuf);
sleep(1);
for(j=0; j< dCurrBlockCnt; j++)
{
if( STR_TSW_COM[i] == NULL )
continue;
if( !strcasecmp(blocks[i].bname, STR_TSW_COM[j]) )
{
send_pid_msg(j, err );
break;
}
}
inits[i].isinit = _TRUE;
inits[i].pid = err;
}
}
PrintSuccessBlocks();
printf("UPRESTO co. GTAM\n\n");
exit(1);
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
RETPARAM save_param, save_varchar_tds7_param, save_nvarchar_tds7_param;
char teststr[8000+1], abbrev_data[10+3+1], *output;
char *retname = NULL;
int i, failed = 0;
int rettype = 0, retlen = 0, return_status = 0;
char proc[] = "#t0022";
char *proc_name = proc;
int num_resultset = 0, num_empty_resultset = 0;
int num_params = 6;
static const char dashes30[] = "------------------------------";
static const char *dashes5 = dashes30 + (sizeof(dashes30) - 5),
*dashes20 = dashes30 + (sizeof(dashes30) - 20);
RETCODE erc, row_code;
set_malloc_options();
memset(&save_param, 0, sizeof(save_param));
memset(&save_varchar_tds7_param, 0, sizeof(save_varchar_tds7_param));
memset(&save_nvarchar_tds7_param, 0, sizeof(save_nvarchar_tds7_param));
read_login_info(argc, argv);
printf("Starting %s\n", argv[0]);
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "rpc");
dberrhandle(ignore_err_handler);
DBSETLPACKET(login, -1);
dberrhandle(syb_err_handler);
printf("About to open %s.%s\n", SERVER, DATABASE);
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
printf("Check if server support long identifiers\n");
sql_cmd(dbproc);
i = 103;
dbsetuserdata(dbproc, (BYTE*) &i);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS)
while (dbnextrow(dbproc) != NO_MORE_ROWS)
continue;
dbsetuserdata(dbproc, NULL);
if (i == 0) {
fprintf(stderr, "This server does not support long identifiers\n");
dbexit();
return 0;
}
dberrhandle(ignore_err_handler);
dbmsghandle(ignore_msg_handler);
printf("trying to create a temporary stored procedure\n");
if (FAIL == init_proc(dbproc, proc_name)) {
num_params = 4;
printf("trying to create a permanent stored procedure\n");
if (FAIL == init_proc(dbproc, ++proc_name))
exit(EXIT_FAILURE);
}
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("Created procedure %s\n", proc_name);
/* set up and send the rpc */
printf("executing dbrpcinit\n");
erc = dbrpcinit(dbproc, proc_name, 0); /* no options */
if (erc == FAIL) {
fprintf(stderr, "Failed line %d: dbrpcinit\n", __LINE__);
failed = 1;
}
for (pb = bindings, i = 0; pb < bindings + sizeof(bindings)/sizeof(bindings[0]); pb++, i++) {
printf("executing dbrpcparam for %s\n", pb->name);
if (num_params == 4 && (i == 3 || i == 4))
continue;
if ((erc = dbrpcparam(dbproc, pb->name, pb->status, pb->type, pb->maxlen, pb->datalen, pb->value)) == FAIL) {
fprintf(stderr, "Failed line %d: dbrpcparam\n", __LINE__);
failed++;
}
}
printf("executing dbrpcsend\n");
param_data5 = 0x11223344;
erc = dbrpcsend(dbproc);
if (erc == FAIL) {
fprintf(stderr, "Failed line %d: dbrpcsend\n", __LINE__);
exit(1);
}
/* wait for it to execute */
printf("executing dbsqlok\n");
erc = dbsqlok(dbproc);
if (erc == FAIL) {
fprintf(stderr, "Failed line %d: dbsqlok\n", __LINE__);
exit(1);
}
/* retrieve outputs per usual */
printf("fetching results\n");
while ((erc = dbresults(dbproc)) != NO_MORE_RESULTS) {
printf("fetched resultset %d %s:\n", 1+num_resultset, erc==SUCCEED? "successfully":"unsuccessfully");
if (erc == SUCCEED) {
const int ncol = dbnumcols(dbproc);
int empty_resultset = 1, c;
enum {buflen=1024, nbuf=5};
char bound_buffers[nbuf][buflen] = { "one", "two", "three", "four", "five" };
++num_resultset;
for( c=0; c < ncol && c < nbuf; c++ ) {
printf("column %d (%s) is %d wide, ", c+1, dbcolname(dbproc, c+1), colwidth(dbproc, c+1));
printf("buffer initialized to '%s'\n", bound_buffers[c]);
}
for( c=0; c < ncol && c < nbuf; c++ ) {
erc = dbbind(dbproc, c+1, STRINGBIND, 0, (BYTE *) bound_buffers[c]);
if (erc == FAIL) {
fprintf(stderr, "Failed line %d: dbbind\n", __LINE__);
exit(1);
}
printf("%-*s ", colwidth(dbproc, c+1), dbcolname(dbproc, c+1));
}
printf("\n");
while ((row_code = dbnextrow(dbproc)) != NO_MORE_ROWS) {
empty_resultset = 0;
if (row_code == REG_ROW) {
int c;
for( c=0; c < ncol && c < nbuf; c++ ) {
printf("%-*s ", colwidth(dbproc, c+1), bound_buffers[c]);
}
printf("\n");
} else {
/* not supporting computed rows in this unit test */
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
}
printf("row count %d\n", (int) dbcount(dbproc));
printf("hasretstatus %d\n", dbhasretstat(dbproc));
if (num_resultset == 4 && !dbhasretstat(dbproc)) {
fprintf(stderr, "dbnextrow should have set hasretstatus after last recordset\n");
exit(1);
}
if (empty_resultset)
++num_empty_resultset;
} else {
fprintf(stderr, "Expected a result set.\n");
exit(1);
}
} /* while dbresults */
/* check return status */
printf("retrieving return status...\n");
if (dbhasretstat(dbproc) == TRUE) {
printf("%d\n", return_status = dbretstatus(dbproc));
} else {
printf("none\n");
}
/*
* Check output parameter values
*/
if (dbnumrets(dbproc) != num_params) { /* dbnumrets missed something */
fprintf(stderr, "Expected %d output parameters.\n", num_params);
exit(1);
}
printf("retrieving output parameters...\n");
printf("%-5s %-20s %5s %6s %-30s\n", "param", "name", "type", "length", "data");
printf("%-5s %-20s %5s %5s- %-30s\n", dashes5, dashes20, dashes5, dashes5, dashes30);
for (i = 1; i <= dbnumrets(dbproc); i++) {
retname = dbretname(dbproc, i);
rettype = dbrettype(dbproc, i);
retlen = dbretlen(dbproc, i);
dbconvert(dbproc, rettype, dbretdata(dbproc, i), retlen, SYBVARCHAR, (BYTE*) teststr, -1);
if(retlen <= 10) {
output = teststr;
} else {
memcpy(abbrev_data, teststr, 10);
sprintf(&abbrev_data[10], "...");
output = abbrev_data;
}
printf("%-5d %-20s %5d %6d %-30s\n", i, retname, rettype, retlen, output);
save_retparam(&save_param, retname, teststr, rettype, retlen);
if (i == 4) {
save_retparam(&save_varchar_tds7_param, retname, teststr, rettype, retlen);
}
if (i == 5) {
save_retparam(&save_nvarchar_tds7_param, retname, teststr, rettype, retlen);
}
}
/*
* Test the last parameter for expected outcome
*/
if ((save_param.name == NULL) || strcmp(save_param.name, bindings[5].name)) {
fprintf(stderr, "Expected retname to be '%s', got ", bindings[5].name);
if (save_param.name == NULL)
fprintf(stderr, "<NULL> instead.\n");
else
fprintf(stderr, "'%s' instead.\n", save_param.name);
exit(1);
}
if (strcmp(save_param.value, "3")) {
fprintf(stderr, "Expected retdata to be 3.\n");
exit(1);
}
if (save_param.type != SYBINT4) {
fprintf(stderr, "Expected rettype to be SYBINT4 was %d.\n", save_param.type);
exit(1);
}
if (save_param.len != 4) {
fprintf(stderr, "Expected retlen to be 4.\n");
exit(1);
}
if (num_params == 6) {
/*
* Test name, size, contents of the VARCHAR(8000) output parameter
*/
if ((save_varchar_tds7_param.name == NULL) || strcmp(save_varchar_tds7_param.name, bindings[3].name)) {
fprintf(stderr, "Expected retname to be '%s', got ", bindings[3].name);
if (save_varchar_tds7_param.name == NULL)
fprintf(stderr, "<NULL> instead.\n");
else
fprintf(stderr, "'%s' instead.\n", save_varchar_tds7_param.name);
exit(1);
}
if (save_varchar_tds7_param.type != SYBVARCHAR) {
fprintf(stderr, "Expected rettype to be SYBVARCHAR was %d.\n", save_varchar_tds7_param.type);
exit(1);
}
if (save_varchar_tds7_param.len != 8000) {
fprintf(stderr, "Expected retlen to be 8000 was %d.\n", save_varchar_tds7_param.len);
exit(1);
}
/*
* Test name, size, contents of the NVARCHAR(4000) output parameter
*/
if ((save_nvarchar_tds7_param.name == NULL) || strcmp(save_nvarchar_tds7_param.name, bindings[4].name)) {
fprintf(stderr, "Expected retname to be '%s', got ", bindings[4].name);
if (save_varchar_tds7_param.name == NULL)
fprintf(stderr, "<NULL> instead.\n");
else
fprintf(stderr, "'%s' instead.\n", save_nvarchar_tds7_param.name);
exit(1);
}
if (save_nvarchar_tds7_param.len != 4000) {
fprintf(stderr, "Expected retlen to be 4000 was %d.\n", save_nvarchar_tds7_param.len);
exit(1);
}
}
if(42 != return_status) {
fprintf(stderr, "Expected status to be 42.\n");
exit(1);
}
printf("Good: Got 6 output parameters and 1 return status of %d.\n", return_status);
/* Test number of result sets */
if (num_resultset != 4) {
fprintf(stderr, "Expected 4 resultset got %d.\n", num_resultset);
exit(1);
}
if (num_empty_resultset != 1) {
fprintf(stderr, "Expected an empty resultset got %d.\n", num_empty_resultset);
exit(1);
}
printf("Good: Got %d resultsets and %d empty resultset.\n", num_resultset, num_empty_resultset);
printf("Dropping procedure\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
dbexit();
printf("%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
free_retparam(&save_param);
free_retparam(&save_varchar_tds7_param);
free_retparam(&save_nvarchar_tds7_param);
return failed ? 1 : 0;
}
int
main(int argc, char *argv[])
{
int pctlfd;
int pstatusfd;
char procname[PROCSIZE];
char *command;
char *rdb_commands = NULL;
pid_t cpid;
pstatus_t pstatus;
sysset_t sysset;
int c;
int error = 0;
long oper;
struct iovec piov[2];
extern FILE *yyin;
command = argv[0];
while ((c = getopt(argc, argv, "f:")) != EOF)
switch (c) {
case 'f':
rdb_commands = optarg;
break;
case '?':
break;
}
if (error || (optind == argc)) {
(void) printf("usage: %s [-f file] executable "
"[executable arguments ...]\n", command);
(void) printf("\t-f command file\n");
exit(1);
}
/*
* set up for tracing the child.
*/
init_proc();
/*
* create a child to fork and exec from.
*/
if ((cpid = fork()) == 0) {
(void) execv(argv[optind], &argv[optind]);
perr(argv[1]);
}
if (cpid == -1) /* fork() failure */
perr(command);
/*
* initialize libelf
*/
if (elf_version(EV_CURRENT) == EV_NONE) {
(void) fprintf(stderr, "elf_version() failed: %s\n",
elf_errmsg(0));
exit(1);
}
/*
* initialize librtld_db
*/
if (rd_init(RD_VERSION) != RD_OK) {
(void) fprintf(stderr, "librtld_db::rd_init() failed: version "
"submitted: %d\n", RD_VERSION);
exit(1);
}
/* rd_log(1); */
/*
* Child should now be waiting after the successful
* exec.
*/
(void) snprintf(procname, PROCSIZE, "/proc/%d/ctl", EC_SWORD(cpid));
(void) printf("parent: %d child: %d child procname: %s\n",
EC_SWORD(getpid()), EC_SWORD(cpid), procname);
if ((pctlfd = open(procname, O_WRONLY)) < 0) {
perror(procname);
(void) fprintf(stderr, "%s: can't open child %s\n",
command, procname);
exit(1);
}
/*
* wait for child process.
*/
oper = PCWSTOP;
piov[0].iov_base = (caddr_t)&oper;
piov[0].iov_len = sizeof (oper);
if (writev(pctlfd, piov, 1) == -1)
perr("PCWSTOP");
/*
* open /proc/<cpid>/status
*/
(void) snprintf(procname, PROCSIZE, "/proc/%d/status", EC_SWORD(cpid));
if ((pstatusfd = open(procname, O_RDONLY)) == -1)
perr(procname);
if (read(pstatusfd, &pstatus, sizeof (pstatus)) == -1)
perr("status read failed");
/*
* Make sure that it stopped where we expected.
*/
while ((pstatus.pr_lwp.pr_why == PR_SYSEXIT) &&
(pstatus.pr_lwp.pr_what == SYS_execve)) {
long pflags = 0;
if (!(pstatus.pr_lwp.pr_reg[R_PS] & ERRBIT)) {
/* successfull exec(2) */
break;
}
oper = PCRUN;
piov[1].iov_base = (caddr_t)&pflags;
piov[1].iov_len = sizeof (pflags);
if (writev(pctlfd, piov, 2) == -1)
perr("PCRUN1");
oper = PCWSTOP;
if (writev(pctlfd, piov, 1) == -1)
perr("PCWSTOP");
if (read(pstatusfd, &pstatus, sizeof (pstatus)) == -1)
perr("status read failed");
}
premptyset(&sysset);
oper = PCSEXIT;
piov[1].iov_base = (caddr_t)&sysset;
piov[1].iov_len = sizeof (sysset);
if (writev(pctlfd, piov, 2) == -1)
perr("PIOCSEXIT");
/*
* Did we stop where we expected ?
*/
if ((pstatus.pr_lwp.pr_why != PR_SYSEXIT) ||
(pstatus.pr_lwp.pr_what != SYS_execve)) {
long pflags = 0;
(void) fprintf(stderr, "Didn't catch the exec, why: %d "
"what: %d\n", pstatus.pr_lwp.pr_why,
pstatus.pr_lwp.pr_what);
oper = PCRUN;
piov[1].iov_base = (caddr_t)&pflags;
piov[1].iov_len = sizeof (pflags);
if (writev(pctlfd, piov, 2) == -1)
perr("PCRUN2");
exit(1);
}
(void) ps_init(pctlfd, pstatusfd, cpid, &proch);
if (rdb_commands) {
if ((yyin = fopen(rdb_commands, "r")) == NULL) {
(void) printf("unable to open %s for input\n",
rdb_commands);
perr("fopen");
}
} else {
proch.pp_flags |= FLG_PP_PROMPT;
rdb_prompt();
}
(void) yyparse();
if (proch.pp_flags & FLG_PP_PACT) {
long pflags = PRCFAULT;
(void) printf("\ncontinuing the hung process...\n");
pctlfd = proch.pp_ctlfd;
(void) ps_close(&proch);
oper = PCRUN;
piov[1].iov_base = (caddr_t)&pflags;
piov[1].iov_len = sizeof (pflags);
if (writev(pctlfd, piov, 2) == -1)
perr("PCRUN2");
(void) close(pctlfd);
}
return (0);
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
RETPARAM save_param;
int i, r;
char teststr[1024];
int failed = 0;
char *retname = NULL;
int rettype = 0, retlen = 0;
int return_status = 0;
char proc[] = "#t0022",
param0[] = "@null_input",
param1[] = "@first_type",
param2[] = "@nullout",
param3[] = "@nrows",
param4[] = "@c";
char *proc_name = proc;
char param_data1[64];
int param_data2;
int param_data3;
RETCODE erc, row_code;
int num_resultset = 0;
int num_empty_resultset = 0;
static const char dashes5[] = "-----",
dashes15[] = "---------------",
dashes30[] = "------------------------------";
set_malloc_options();
memset(&save_param, 0, sizeof(save_param));
read_login_info(argc, argv);
fprintf(stdout, "Start\n");
add_bread_crumb();
dbinit();
add_bread_crumb();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
add_bread_crumb();
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "#t0022");
dberrhandle(ignore_err_handler);
DBSETLPACKET(login, -1);
dberrhandle(syb_err_handler);
fprintf(stdout, "About to open %s.%s\n", SERVER, DATABASE);
add_bread_crumb();
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
add_bread_crumb();
dbloginfree(login);
add_bread_crumb();
add_bread_crumb();
dberrhandle(ignore_err_handler);
dbmsghandle(ignore_msg_handler);
printf("trying to create a temporary stored procedure\n");
if (FAIL == init_proc(dbproc, proc_name)) {
printf("trying to create a permanent stored procedure\n");
if (FAIL == init_proc(dbproc, ++proc_name))
exit(EXIT_FAILURE);
}
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "Created procedure %s\n", proc_name);
/* set up and send the rpc */
printf("executing dbrpcinit\n");
erc = dbrpcinit(dbproc, proc_name, 0); /* no options */
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcinit\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param0, DBRPCRETURN, SYBCHAR, /*maxlen= */ -1, /* datlen= */ 0, NULL);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param1, DBRPCRETURN, SYBCHAR, /*maxlen= */ sizeof(param_data1), /* datlen= */ 0, (BYTE *) & param_data1);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param2, DBRPCRETURN, SYBINT4, /*maxlen= */ -1, /* datalen= */ 0, (BYTE *) & param_data2);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param3, DBRPCRETURN, SYBINT4, /*maxlen= */ -1, /* datalen= */ -1, (BYTE *) & param_data3);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
/* test for strange parameters using input */
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param4, 0, SYBVARCHAR, /*maxlen= */ 0, /* datalen= */ 0, NULL);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcsend\n");
param_data3 = 0x11223344;
erc = dbrpcsend(dbproc);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcsend\n");
exit(1);
}
/* wait for it to execute */
printf("executing dbsqlok\n");
erc = dbsqlok(dbproc);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbsqlok\n");
exit(1);
}
add_bread_crumb();
/* retrieve outputs per usual */
r = 0;
while ((erc = dbresults(dbproc)) != NO_MORE_RESULTS) {
if (erc == SUCCEED) {
const int ncols = dbnumcols(dbproc);
int empty_resultset = 1;
++num_resultset;
printf("bound 1 of %d columns ('%s') in result %d.\n", ncols, dbcolname(dbproc, 1), ++r);
dbbind(dbproc, 1, STRINGBIND, 0, (BYTE *) teststr);
printf("\t%s\n\t-----------\n", dbcolname(dbproc, 1));
while ((row_code = dbnextrow(dbproc)) != NO_MORE_ROWS) {
empty_resultset = 0;
if (row_code == REG_ROW) {
printf("\t%s\n", teststr);
} else {
/* not supporting computed rows in this unit test */
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
}
printf("row count %d\n", (int) dbcount(dbproc));
if (empty_resultset)
++num_empty_resultset;
} else {
add_bread_crumb();
fprintf(stderr, "Expected a result set.\n");
exit(1);
}
} /* while dbresults */
/* check return status */
printf("retrieving return status...\n");
if (dbhasretstat(dbproc) == TRUE) {
printf("%d\n", return_status = dbretstatus(dbproc));
} else {
printf("none\n");
}
/*
* Check output parameter values
*/
if (dbnumrets(dbproc) < 4) { /* dbnumrets missed something */
fprintf(stderr, "Expected 4 output parameters.\n");
exit(1);
}
printf("retrieving output parameters...\n");
printf("%-5s %-15s %5s %6s %-30s\n", "param", "name", "type", "length", "data");
printf("%-5s %-15s %5s %5s- %-30s\n", dashes5, dashes15, dashes5, dashes5, dashes30);
for (i = 1; i <= dbnumrets(dbproc); i++) {
add_bread_crumb();
retname = dbretname(dbproc, i);
rettype = dbrettype(dbproc, i);
retlen = dbretlen(dbproc, i);
dbconvert(dbproc, rettype, dbretdata(dbproc, i), retlen, SYBVARCHAR, (BYTE*) teststr, -1);
printf("%-5d %-15s %5d %6d %-30s\n", i, retname, rettype, retlen, teststr);
add_bread_crumb();
save_retparam(&save_param, retname, teststr, rettype, retlen);
}
/*
* Test the last parameter for expected outcome
*/
if ((save_param.name == NULL) || strcmp(save_param.name, param3)) {
fprintf(stderr, "Expected retname to be '%s', got ", param3);
if (save_param.name == NULL)
fprintf(stderr, "<NULL> instead.\n");
else
fprintf(stderr, "'%s' instead.\n", save_param.name);
exit(1);
}
if (strcmp(save_param.value, "3")) {
fprintf(stderr, "Expected retdata to be 3.\n");
exit(1);
}
if (save_param.type != SYBINT4) {
fprintf(stderr, "Expected rettype to be SYBINT4 was %d.\n", save_param.type);
exit(1);
}
if (save_param.len != 4) {
fprintf(stderr, "Expected retlen to be 4.\n");
exit(1);
}
if(42 != return_status) {
fprintf(stderr, "Expected status to be 42.\n");
exit(1);
}
printf("Good: Got 4 output parameters and 1 return status of %d.\n", return_status);
/* Test number of result sets */
if (num_resultset != 3) {
fprintf(stderr, "Expected 3 resultset got %d.\n", num_resultset);
exit(1);
}
if (num_empty_resultset != 1) {
fprintf(stderr, "Expected an empty resultset got %d.\n", num_empty_resultset);
exit(1);
}
printf("Good: Got %d resultsets and %d empty resultset.\n", num_resultset, num_empty_resultset);
add_bread_crumb();
fprintf(stdout, "Dropping procedure\n");
add_bread_crumb();
sprintf(cmd, "DROP PROCEDURE %s", proc_name);
dbcmd(dbproc, cmd);
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
add_bread_crumb();
dbexit();
add_bread_crumb();
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
free_bread_crumb();
free(save_param.name);
free(save_param.value);
return failed ? 1 : 0;
}
void context::load_module(v8::FunctionCallbackInfo<v8::Value> const& args)
{
v8::Isolate* isolate = args.GetIsolate();
v8::EscapableHandleScope scope(isolate);
v8::Local<v8::Value> result;
try
{
std::string const name = from_v8<std::string>(isolate, args[0], "");
if (name.empty())
{
throw std::runtime_error("load_module: require module name string argument");
}
context* ctx = detail::get_external_data<context*>(args.Data());
context::dynamic_modules::iterator it = ctx->modules_.find(name);
// check if module is already loaded
if (it != ctx->modules_.end())
{
result = v8::Local<v8::Value>::New(isolate, it->second.exports);
}
else
{
std::string filename = name;
if (!ctx->lib_path_.empty())
{
filename = ctx->lib_path_ + path_sep + name;
}
std::string const suffix = V8PP_PLUGIN_SUFFIX;
if (filename.size() >= suffix.size()
&& filename.compare(filename.size() - suffix.size(), suffix.size(), suffix) != 0)
{
filename += suffix;
}
dynamic_module module;
#if defined(WIN32)
UINT const prev_error_mode = SetErrorMode(SEM_NOOPENFILEERRORBOX);
module.handle = LoadLibraryA(filename.c_str());
::SetErrorMode(prev_error_mode);
#else
module.handle = dlopen(filename.c_str(), RTLD_LAZY);
#endif
if (!module.handle)
{
throw std::runtime_error("load_module(" + name
+ "): could not load shared library " + filename);
}
#if defined(WIN32)
void *sym = ::GetProcAddress((HMODULE)module.handle,
STRINGIZE(V8PP_PLUGIN_INIT_PROC_NAME));
#else
void *sym = dlsym(module.handle, STRINGIZE(V8PP_PLUGIN_INIT_PROC_NAME));
#endif
if (!sym)
{
throw std::runtime_error("load_module(" + name
+ "): initialization function "
STRINGIZE(V8PP_PLUGIN_INIT_PROC_NAME)
" not found in " + filename);
}
using module_init_proc = v8::Handle<v8::Value>(*)(v8::Isolate*);
module_init_proc init_proc = reinterpret_cast<module_init_proc>(sym);
result = init_proc(isolate);
module.exports.Reset(isolate, result);
ctx->modules_.emplace(name, std::move(module));
}
}
catch (std::exception const& ex)
{
result = throw_ex(isolate, ex.what());
}
args.GetReturnValue().Set(scope.Escape(result));
}
void init_vm(void)
{
int s, i;
static struct memory mem_chunks[NR_MEMS];
static struct boot_image *ip;
extern void __minix_init(void);
multiboot_module_t *mod;
vir_bytes kern_dyn, kern_static;
#if SANITYCHECKS
incheck = nocheck = 0;
#endif
/* Retrieve various crucial boot parameters */
if(OK != (s=sys_getkinfo(&kernel_boot_info))) {
panic("couldn't get bootinfo: %d", s);
}
/* Turn file mmap on? */
env_parse("filemap", "d", 0, &enable_filemap, 0, 1);
/* Sanity check */
assert(kernel_boot_info.mmap_size > 0);
assert(kernel_boot_info.mods_with_kernel > 0);
/* Get chunks of available memory. */
get_mem_chunks(mem_chunks);
/* Set table to 0. This invalidates all slots (clear VMF_INUSE). */
memset(vmproc, 0, sizeof(vmproc));
for(i = 0; i < ELEMENTS(vmproc); i++) {
vmproc[i].vm_slot = i;
}
/* Initialize ACL data structures. */
acl_init();
/* region management initialization. */
map_region_init();
/* Initialize tables to all physical memory. */
mem_init(mem_chunks);
/* Architecture-dependent initialization. */
init_proc(VM_PROC_NR);
pt_init();
/* The kernel's freelist does not include boot-time modules; let
* the allocator know that the total memory is bigger.
*/
for (mod = &kernel_boot_info.module_list[0];
mod < &kernel_boot_info.module_list[kernel_boot_info.mods_with_kernel-1]; mod++) {
phys_bytes len = mod->mod_end-mod->mod_start+1;
len = roundup(len, VM_PAGE_SIZE);
mem_add_total_pages(len/VM_PAGE_SIZE);
}
kern_dyn = kernel_boot_info.kernel_allocated_bytes_dynamic;
kern_static = kernel_boot_info.kernel_allocated_bytes;
kern_static = roundup(kern_static, VM_PAGE_SIZE);
mem_add_total_pages((kern_dyn + kern_static)/VM_PAGE_SIZE);
/* Give these processes their own page table. */
for (ip = &kernel_boot_info.boot_procs[0];
ip < &kernel_boot_info.boot_procs[NR_BOOT_PROCS]; ip++) {
struct vmproc *vmp;
if(ip->proc_nr < 0) continue;
assert(ip->start_addr);
/* VM has already been set up by the kernel and pt_init().
* Any other boot process is already in memory and is set up
* here.
*/
if(ip->proc_nr == VM_PROC_NR) continue;
vmp = init_proc(ip->proc_nr);
exec_bootproc(vmp, ip);
/* Free the file blob */
assert(!(ip->start_addr % VM_PAGE_SIZE));
ip->len = roundup(ip->len, VM_PAGE_SIZE);
free_mem(ABS2CLICK(ip->start_addr), ABS2CLICK(ip->len));
}
/* Set up table of calls. */
#define CALLMAP(code, func) { int i; \
i=CALLNUMBER(code); \
assert(i >= 0); \
assert(i < NR_VM_CALLS); \
vm_calls[i].vmc_func = (func); \
vm_calls[i].vmc_name = #code; \
}
/* Set call table to 0. This invalidates all calls (clear
* vmc_func).
*/
memset(vm_calls, 0, sizeof(vm_calls));
/* Basic VM calls. */
CALLMAP(VM_MMAP, do_mmap);
CALLMAP(VM_MUNMAP, do_munmap);
CALLMAP(VM_MAP_PHYS, do_map_phys);
CALLMAP(VM_UNMAP_PHYS, do_munmap);
/* Calls from PM. */
CALLMAP(VM_EXIT, do_exit);
CALLMAP(VM_FORK, do_fork);
CALLMAP(VM_BRK, do_brk);
CALLMAP(VM_WILLEXIT, do_willexit);
CALLMAP(VM_NOTIFY_SIG, do_notify_sig);
/* Calls from VFS. */
CALLMAP(VM_VFS_REPLY, do_vfs_reply);
CALLMAP(VM_VFS_MMAP, do_vfs_mmap);
/* Calls from RS */
CALLMAP(VM_RS_SET_PRIV, do_rs_set_priv);
CALLMAP(VM_RS_UPDATE, do_rs_update);
CALLMAP(VM_RS_MEMCTL, do_rs_memctl);
/* Calls from RS/VFS */
CALLMAP(VM_PROCCTL, do_procctl);
/* Generic calls. */
CALLMAP(VM_REMAP, do_remap);
CALLMAP(VM_REMAP_RO, do_remap);
CALLMAP(VM_GETPHYS, do_get_phys);
CALLMAP(VM_SHM_UNMAP, do_munmap);
CALLMAP(VM_GETREF, do_get_refcount);
CALLMAP(VM_INFO, do_info);
CALLMAP(VM_QUERY_EXIT, do_query_exit);
CALLMAP(VM_WATCH_EXIT, do_watch_exit);
/* Cache blocks. */
CALLMAP(VM_MAPCACHEPAGE, do_mapcache);
CALLMAP(VM_SETCACHEPAGE, do_setcache);
/* getrusage */
CALLMAP(VM_GETRUSAGE, do_getrusage);
/* Initialize the structures for queryexit */
init_query_exit();
/* Acquire kernel ipc vectors that weren't available
* before VM had determined kernel mappings
*/
__minix_init();
}
void init_vm(void)
{
int s, i;
static struct memory mem_chunks[NR_MEMS];
static struct boot_image *ip;
extern void __minix_init(void);
#if SANITYCHECKS
incheck = nocheck = 0;
#endif
/* Retrieve various crucial boot parameters */
if(OK != (s=sys_getkinfo(&kernel_boot_info))) {
panic("couldn't get bootinfo: %d", s);
}
/* Sanity check */
assert(kernel_boot_info.mmap_size > 0);
assert(kernel_boot_info.mods_with_kernel > 0);
#if SANITYCHECKS
env_parse("vm_sanitychecklevel", "d", 0, &vm_sanitychecklevel, 0, SCL_MAX);
#endif
/* Get chunks of available memory. */
get_mem_chunks(mem_chunks);
/* Set table to 0. This invalidates all slots (clear VMF_INUSE). */
memset(vmproc, 0, sizeof(vmproc));
for(i = 0; i < ELEMENTS(vmproc); i++) {
vmproc[i].vm_slot = i;
}
/* region management initialization. */
map_region_init();
/* Initialize tables to all physical memory. */
mem_init(mem_chunks);
/* Architecture-dependent initialization. */
init_proc(VM_PROC_NR);
pt_init();
/* Give these processes their own page table. */
for (ip = &kernel_boot_info.boot_procs[0];
ip < &kernel_boot_info.boot_procs[NR_BOOT_PROCS]; ip++) {
struct vmproc *vmp;
if(ip->proc_nr < 0) continue;
assert(ip->start_addr);
/* VM has already been set up by the kernel and pt_init().
* Any other boot process is already in memory and is set up
* here.
*/
if(ip->proc_nr == VM_PROC_NR) continue;
vmp = init_proc(ip->proc_nr);
exec_bootproc(vmp, ip);
/* Free the file blob */
assert(!(ip->start_addr % VM_PAGE_SIZE));
ip->len = roundup(ip->len, VM_PAGE_SIZE);
free_mem(ABS2CLICK(ip->start_addr), ABS2CLICK(ip->len));
}
/* Set up table of calls. */
#define CALLMAP(code, func) { int i; \
i=CALLNUMBER(code); \
assert(i >= 0); \
assert(i < NR_VM_CALLS); \
vm_calls[i].vmc_func = (func); \
vm_calls[i].vmc_name = #code; \
}
/* Set call table to 0. This invalidates all calls (clear
* vmc_func).
*/
memset(vm_calls, 0, sizeof(vm_calls));
/* Basic VM calls. */
CALLMAP(VM_MMAP, do_mmap);
CALLMAP(VM_MUNMAP, do_munmap);
CALLMAP(VM_MAP_PHYS, do_map_phys);
CALLMAP(VM_UNMAP_PHYS, do_munmap);
/* Calls from PM. */
CALLMAP(VM_EXIT, do_exit);
CALLMAP(VM_FORK, do_fork);
CALLMAP(VM_BRK, do_brk);
CALLMAP(VM_WILLEXIT, do_willexit);
CALLMAP(VM_NOTIFY_SIG, do_notify_sig);
/* Calls from RS */
CALLMAP(VM_RS_SET_PRIV, do_rs_set_priv);
CALLMAP(VM_RS_UPDATE, do_rs_update);
CALLMAP(VM_RS_MEMCTL, do_rs_memctl);
/* Calls from RS/VFS */
CALLMAP(VM_PROCCTL, do_procctl);
/* Generic calls. */
CALLMAP(VM_REMAP, do_remap);
CALLMAP(VM_REMAP_RO, do_remap);
CALLMAP(VM_GETPHYS, do_get_phys);
CALLMAP(VM_SHM_UNMAP, do_munmap);
CALLMAP(VM_GETREF, do_get_refcount);
CALLMAP(VM_INFO, do_info);
CALLMAP(VM_QUERY_EXIT, do_query_exit);
CALLMAP(VM_WATCH_EXIT, do_watch_exit);
CALLMAP(VM_FORGETBLOCKS, do_forgetblocks);
CALLMAP(VM_FORGETBLOCK, do_forgetblock);
CALLMAP(VM_YIELDBLOCKGETBLOCK, do_yieldblockgetblock);
/* Initialize the structures for queryexit */
init_query_exit();
/* Acquire kernel ipc vectors that weren't available
* before VM had determined kernel mappings
*/
__minix_init();
}
