extern int Write(int fd, void *buf, int size) { /* Create msg to be sent to server. */ struct my_msg *msg_write; struct read_struct write_m; int index = find_fd(fd); /* No match for provided file descriptor number.*/ if(index == -1) { TtyPrintf(0,"\nERROR: Invalid Fd %d",fd); return ERROR; } if(buf==NULL) { TtyPrintf(0,"\nERROR: Invalid memory pointer!"); return ERROR; } char *msg_buf=(char *)malloc(size*sizeof(char)); msg_write = (struct my_msg *)malloc(sizeof(struct my_msg)); memcpy(msg_buf,buf,strlen(buf)); msg_write->type = WRITE; msg_write->data2 = files[index]->inode_num; //msg_write->ptr = (void *)files[index]; msg_write->ptr = &write_m; write_m.offset=files[index]->offset; write_m.len=size; write_m.buff=msg_buf; Send((void *)msg_write,-FILE_SERVER); int result=msg_write->type; if(result==ERROR) { TtyPrintf(0,"\nWrite Unsuccessful"); } else { files[index]->offset+=msg_write->type; TtyPrintf(0,"\nWrite Successfully Completed!"); } free(msg_buf); free(msg_write); return result; }
extern int Read(int fd, void *buf, int size) { struct read_struct read_m; /* Create msg to be sent to server.*/ struct my_msg *msg_read; char *temp_buf; int index = find_fd(fd); /* No match for provided file descriptor number.*/ if(index == -1) { TtyPrintf(0,"\nERROR: Invalid Fd %d",fd); return ERROR; } if(buf==NULL) { TtyPrintf(0,"\nERROR: Invalid memory pointer!"); return ERROR; } msg_read = (struct my_msg *)malloc(sizeof(struct my_msg)); msg_read->type = READ; msg_read->data2 = files[index]->inode_num; printf("\nassigned value is %d\n",msg_read->data2); msg_read->ptr = &read_m; temp_buf=(char *)malloc(size); read_m.offset=files[index]->offset; read_m.len=size; read_m.buff=temp_buf; Send(msg_read,-FILE_SERVER); int result=msg_read->type; if(result==ERROR) { TtyPrintf(0,"\nERROR: Read Unsuccessful!"); } else { memcpy(buf,temp_buf,result); files[index]->offset+=msg_read->type; } free(temp_buf); free(msg_read); return result; }
extern int Create(char *pathname) { int i; /* Check if the length of pathname is legal.*/ if(strlen(pathname) > (MAXPATHNAMELEN - 1)) return ERROR; /* Create a fixed-length buffer to contain pathname for server's using. */ char *path = (char *)malloc(MAXPATHNAMELEN); memcpy(path, pathname, strlen(pathname)+1); /* Tell there's available file descriptor number.*/ int index = find_fd(0); printf("\nval of index is %d\n",index); /* No available file descriptor number.*/ if(index == -1) { return ERROR; } /* Process multiple slashes first */ //reduce_slash(path); /* Create msg to be sent to server.*/ struct my_msg *msg_create; msg_create = (struct my_msg *)malloc(sizeof(struct my_msg)); msg_create->type = CREATE; msg_create->data2 = current_inode_num; msg_create->ptr = (void *)path; /* What the server should do is to check if the named file exsits. if yes, truncate it to 0 and open an empty file. If not, create a new file with the given name and assign it a descriptor number.*/ int res=Send((void *)msg_create,FILE_SERVER); if(msg_create->type == 0) { struct file_info *file; file = (struct file_info *)malloc(sizeof(struct file_info)); file->inode_num = msg_create->data2; // inode number is from server. file->offset = 0; // be initialized as 0 when a file is created. files[index] = file; track_fd[index] = ++fd_counter; // make this file desciptor number valid. return track_fd[index]; } else { TtyPrintf(0,"\nERROR: File %s could not be created!",pathname); return ERROR; } }
int main(int argc, char **argv) { int pids[NUM_TERMINALS]; int i; int status; int pid; for (i = 0; i < NUM_TERMINALS; i++) { pids[i] = StartTerminal(i); if ((i == TTY_CONSOLE) && (pids[TTY_CONSOLE] < 0)) { TtyPrintf(TTY_CONSOLE, "Cannot start Console monitor!\n"); Exit(1); } } while (1) { pid = Wait(&status); if (pid == pids[TTY_CONSOLE]) { TtyPrintf(TTY_CONSOLE, "Halting Yalnix\n"); /* * Halt should normally be a privileged instruction (and * thus not usable from user mode), but the hardware * has been set up to allow it for this project so that * we can shut down Yalnix simply here. */ Halt(); } for (i = 1; i < NUM_TERMINALS; i++) { if (pid == pids[i]) break; } if (i < NUM_TERMINALS) { TtyPrintf(TTY_CONSOLE, "Pid %d exited on terminal %d.\n", pid, i); pids[i] = StartTerminal(i); } else { TtyPrintf(TTY_CONSOLE, "Mystery pid %d returned from Wait!\n", pid); } } }
int StartTerminal(int i) { char *cmd_argv[MAX_ARGC]; char numbuf[128]; /* big enough for %d */ int pid; if (i == TTY_CONSOLE) cmd_argv[0] = "console"; else cmd_argv[0] = "shell"; sprintf(numbuf, "%d", i); cmd_argv[1] = numbuf; cmd_argv[2] = NULL; TracePrintf(0, "Pid %d calling Fork\n", GetPid()); pid = Fork(); TracePrintf(0, "Pid %d got %d from Fork\n", GetPid(), pid); if (pid < 0) { TtyPrintf(TTY_CONSOLE, "Cannot Fork control program for terminal %d.\n", i); return (ERROR); } if (pid == 0) { Exec(cmd_argv[0], cmd_argv); TtyPrintf(TTY_CONSOLE, "Cannot Exec control program for terminal %d.\n", i); Exit(1); } TtyPrintf(TTY_CONSOLE, "Started pid %d on terminal %d\n", pid, i); return (pid); }
extern int Shutdown(void) { /* Create msg sent to file server.*/ struct my_msg *msg_shutdown; msg_shutdown = (struct my_msg *) malloc(sizeof(struct my_msg)); msg_shutdown->type = SHUTDOWN; Send((void *)msg_shutdown, -FILE_SERVER); int result=msg_shutdown->type; if(result==ERROR) { TtyPrintf(0,"\nShutdown Unsuccessful!"); } free(msg_shutdown); return result; }
extern int Sync(void) { /* Create msg sent to file server. */ struct my_msg *msg_sync; msg_sync = (struct my_msg *)malloc(sizeof(struct my_msg)); msg_sync->type = SYNC; Send((void *)msg_sync, -FILE_SERVER); return 0; //Remove when sync is implemented int result=msg_sync->type; if(result==ERROR) { TtyPrintf(0,"\nSync Unsuccessful!"); } free(msg_sync); return result; }
extern int ReadLink(char *pathname, char *buf, int len) { if(pathname==NULL||buf==NULL) return ERROR; if(strlen(pathname) > (MAXPATHNAMELEN-1)) return ERROR; if(len==0) return 0; /* Create a fixed-size buffer for server's using. */ char path[MAXPATHNAMELEN]; memcpy(path, pathname, strlen(pathname)+1); struct readlink *new_read_link; new_read_link = (struct readlink *)malloc(sizeof(struct readlink)); strcpy(new_read_link->pathname, pathname); char *read_buf=(char *)malloc(len); new_read_link->buf = read_buf; new_read_link->len = len; /* Create msg to be sent to server.*/ struct my_msg *msg_readlink; msg_readlink = (struct my_msg *)malloc(sizeof(struct my_msg)); msg_readlink->type = READLINK; msg_readlink->data2 = current_inode_num; msg_readlink->ptr = new_read_link; Send((void *)msg_readlink, -FILE_SERVER); int result=msg_readlink->type; if(result==ERROR) { TtyPrintf(0,"\nUnLink Unsuccessful!"); } else memcpy(buf,read_buf,result); free(msg_readlink); free(read_buf); free(new_read_link); return result; }
extern int Close(int fd) { /* fd is not valid*/ int index=find_fd(fd); if(index== -1) { TtyPrintf(0,"\nERROR: Invalid File Descriptor"); return ERROR; } /* if valid */ else { /* make it invalid.*/ track_fd[index]=0; free(files[index]); return 0; } }
extern int Stat(char *pathname, struct Stat *statbuf) { if(pathname==NULL||statbuf==NULL) return ERROR; if(strlen(pathname) > (MAXPATHNAMELEN-1)) return ERROR; /* Create a fixed-size buffer for server's using. */ char path[MAXPATHNAMELEN]; memcpy(path, pathname, strlen(pathname)); struct stat_struct *stat; stat = (struct stat_struct *)malloc(sizeof(struct stat_struct)); stat->statbuf = statbuf; strcpy(stat->pathname , path); /* Create msg sent to file server. */ struct my_msg *msg_stat; msg_stat = (struct my_msg *)malloc(sizeof(struct my_msg)); msg_stat->type = STAT; msg_stat->data2 = current_inode_num; msg_stat->ptr = stat; Send((void *)msg_stat, -FILE_SERVER); int result=msg_stat->type; if(result==ERROR) { TtyPrintf(0,"\nStat Unsuccessful!"); } free(msg_stat); free(stat); return result; }
extern int ChDir(char *pathname) { if(pathname==NULL) return ERROR; if(strlen(pathname) > (MAXPATHNAMELEN-1)) return ERROR; /* Create a fixed-size buffer for server's using. */ char path[MAXPATHNAMELEN]; memcpy(path, pathname, strlen(pathname)); /* The file pathname must be a directory. Send a msg to server to check if the pathname is valid.*/ struct my_msg *msg_chdir; msg_chdir = (struct my_msg *)malloc(sizeof(struct my_msg)); msg_chdir->type = CHDIR; msg_chdir->data2 = current_inode_num; msg_chdir->ptr = (void *)path; /* Result from file system. */ Send((void *)msg_chdir, -FILE_SERVER); int result=msg_chdir->type; if(result==ERROR) { TtyPrintf(0,"\nChDir Unsuccessful!"); } else if(result == 0) { current_inode_num = msg_chdir->data2; } free(msg_chdir); return result; }
extern int SymLink(char *oldname, char *newname) { struct old_new *name; if(oldname==NULL||newname==NULL) return ERROR; if(strlen(oldname) > (MAXPATHNAMELEN-1) || strlen(newname) > (MAXPATHNAMELEN-1)) return ERROR; /* Process multiple slashes first */ //reduce_slash(oldname); //reduce_slash(newname); name = (struct old_new *)malloc(sizeof(struct old_new)); memcpy(name->oldname, oldname, strlen(oldname)+1); memcpy(name->newname, newname, strlen(newname)+1); /* Create msg to be sent to server.*/ struct my_msg *msg_symlink; msg_symlink = (struct my_msg *)malloc(sizeof(struct my_msg)); msg_symlink->type = SYMLINK; msg_symlink->data2 = current_inode_num; msg_symlink->ptr = name; Send((void *)msg_symlink, -FILE_SERVER); int result=msg_symlink->type; if(result==ERROR) { TtyPrintf(0,"\nSymLink Unsuccessful!"); } free(msg_symlink); free(name); return result; }
int main (int argc, char **argv) { char pname[MAXPATHNAMELEN]; char *temp_buff; int pid; struct my_msg msg; struct read_struct msg_read; struct read_struct msg_write; struct stat_struct msg_stat; struct old_new msg_link; struct Stat res_stat; struct readlink msg_readlink; struct seek_struct msg_seek; printf("\nYFS: Started File Server"); Initialize_Server(); if (Fork() == 0) { printf("\nCHILD\n"); pid=Exec(argv[1],argv); printf("\nval returned by exec is %d",pid); return 0; } else printf("\nPARENT\n"); while(1) { pid=Receive(&msg); //printf("\nInside while"); switch(msg.type) { case CREATE: //for create,type=1,data2=inode of current dir,ptr=ptr to path { printf("\nInside Server Create"); CopyFrom(pid,(void *)pname,msg.ptr,MAXPATHNAMELEN); msg.data2=Server_Create(pname,msg.data2); printf("\nInside Server Returning %d",msg.data2); if(msg.data2!=ERROR) msg.type=0; else msg.type=ERROR; printf("\nInside Server Returning %d",msg.type); Reply(&msg,pid); break; } case OPEN: //for Open,type=1,data2=inode of current dir,ptr=ptr to path { CopyFrom(pid,(void *)pname,msg.ptr,MAXPATHNAMELEN); msg.data2=Server_Open(pname,msg.data2); printf("\nVal returned by open is %d\n",msg.data2); if(msg.data2!=ERROR) msg.type=0; else msg.type=ERROR; printf("\nInside Server Returning %d\n",msg.type); Reply(&msg,pid); break; } case MKDIR: //for MkDir,type=1,data2=inode of current dir,ptr=ptr to path { CopyFrom(pid,(void *)pname,msg.ptr,MAXPATHNAMELEN); msg.data2=Server_MkDir(pname,msg.data2); printf("\nInside Server MkDir with name as %s and curr inode %d\n",pname,msg.data2); if(msg.data2!=ERROR) msg.type=0; else msg.type=ERROR; Reply(&msg,pid); break; } case CHDIR: //for ChDir,type=1,data2=inode of current dir,ptr=ptr to new dir { CopyFrom(pid,(void *)pname,msg.ptr,MAXPATHNAMELEN); printf("\nInside Server ChDir with name as %s and curr inode %d\n",pname,msg.data2); msg.data2=Server_ChDir(pname,msg.data2); if(msg.data2!=ERROR) msg.type=0; else msg.type=ERROR; Reply(&msg,pid); break; } case RMDIR: //for ChDir,type=1,data2=inode of current dir,ptr=ptr to dir { CopyFrom(pid,(void *)pname,msg.ptr,MAXPATHNAMELEN); msg.type=Server_RmDir(pname,msg.data2); Reply((void *)&msg,pid); break; } case READ: { CopyFrom(pid,(void *)&msg_read,msg.ptr,sizeof(struct read_struct)); temp_buff=(char *)malloc(msg_read.len+1); msg.type=Server_Read(msg.data2,msg_read.len,msg_read.offset,temp_buff); CopyTo(pid,msg_read.buff,temp_buff,msg_read.len); printf("\nInside Server ReturningRead %d",msg.type); printf("\n"); Reply((void *)&msg,pid); //free(temp_buff); break; } case WRITE: { printf("\nInside write in while"); CopyFrom(pid,(void *)&msg_write,msg.ptr,sizeof(struct read_struct)); temp_buff=(char *)malloc(msg_write.len+1); temp_buff[msg_write.len]='\0'; CopyFrom(pid,temp_buff,msg_write.buff,msg_write.len); printf("\nData for writing is %s and len =%d",temp_buff,msg_write.len); msg.type=Server_Write(msg.data2,msg_write.len,msg_write.offset,temp_buff); // //free(temp_buff); Reply((void *)&msg,pid); break; } case STAT: { CopyFrom(pid,(void *)&msg_stat,msg.ptr,sizeof(struct stat_struct)); msg.type=Server_Stat(msg.data2,msg_stat.pathname,&res_stat); if(msg.type!=ERROR) CopyTo(pid,(void *)msg_stat.statbuf,(void *)&res_stat,sizeof(struct Stat)); Reply(&msg,pid); break; } case LINK: { CopyFrom(pid,(void *)&msg_link,msg.ptr,sizeof(struct old_new)); msg.data2=Server_Link(msg.data2,msg_link.oldname,msg_link.newname); if(msg.data2==ERROR) msg.type=ERROR; else msg.type=0; Reply(&msg,pid); break; } case UNLINK: { temp_buff=(char *)malloc(MAXPATHNAMELEN*sizeof(char)); CopyFrom(pid,(void *)temp_buff,msg.ptr,MAXPATHNAMELEN); msg.type=Server_UnLink(msg.data2,temp_buff); Reply(&msg,pid); free(temp_buff); break; } case READLINK: { CopyFrom(pid,(void *)&msg_readlink,msg.ptr,sizeof(struct readlink)); temp_buff=(char *)malloc(msg_readlink.len+1); msg.type=Server_ReadLink(msg.data2,msg_readlink.pathname,msg_readlink.len,temp_buff); CopyTo(pid,msg_readlink.buf,temp_buff,msg_readlink.len); Reply(&msg,pid); break; } case SYMLINK: { CopyFrom(pid,(void *)&msg_link,msg.ptr,sizeof(struct old_new)); msg.data2=Server_SymLink(msg.data2,msg_link.oldname,msg_link.newname); if(msg.data2==ERROR) msg.type=ERROR; else msg.type=0; Reply(&msg,pid); break; } case SEEK: { CopyFrom(pid,(void *)&msg_seek,msg.ptr,sizeof(struct stat_struct)); msg.type=Server_Seek(msg.data2,msg_seek.curr_offset,msg_seek.new_offset,msg_seek.whence); Reply(&msg,pid); break; } case SHUTDOWN: { //Server_Sync(); TtyPrintf(0,"\nShutting Down Yalnix File Server!"); msg.type=0; Reply((void *)&msg,pid); Exit(0); break; } case SYNC: { Reply((void *)&msg,pid); //Server_sync(); break; } default: { msg.type=ERROR; Reply(&msg,pid); break; } } Reply(&msg,pid); } printf("\nExiting Yfs"); return 0;; }
int Server_Link(int inode_num,char *oldname,char *newname) { int i,inum; int last_slash=0; int num; int res; int resF; int len=strlen(newname); char *dir_path; struct inode curr_inode; struct inode dir_inode; if(inode_num<1||inode_num>max_inode_num) return ERROR; res=LookUp(oldname,inode_num,0); if((res==0)||(res==ERROR)) return ERROR; GetInode(res,&curr_inode); if((curr_inode.type==INODE_DIRECTORY)||(curr_inode.type==INODE_FREE)) { TtyPrintf(0,"\nERROR: Cannot Link To a Directory!"); return ERROR; } inum=res; printf("\nReached Inside Link with len=%d\n",len); dir_path=(char *)malloc(len+1); for(i=0;i<len;i++) if(newname[i]=='/') last_slash=i; printf("\nReached in Link_file 1"); res=inode_num; if(last_slash!=0) { printf("\nReached in Link_file 2"); strncpy(dir_path,newname,last_slash); dir_path[last_slash]='\0'; res=LookUp(dir_path,inode_num,0); if((res==ERROR)||(res==0)) { printf("\nERROR: Path %s does not exist ",dir_path); free(dir_path); return ERROR; } } printf("\nReached in Link_file 3 with dinode=%d",res); strncpy(dir_path,&newname[last_slash+1],len-last_slash-1); dir_path[len-last_slash-1]=0; printf("\nValue of dir_path is %s",dir_path); resF=LookUp(dir_path,res,0); printf("\nReached in Link_file 4 with resF as %d",resF); if(resF==ERROR) { printf("\nERROR: Path %s does not exist ",dir_path); free(dir_path); return ERROR; } if(resF!=0) { printf("\nERROR: Pathname %s already exists ",newname); free(dir_path); return ERROR; } PutInDir(res,inum,dir_path); curr_inode.nlink+=1; write_inode(inum,&curr_inode); free(dir_path); return inum;; }
main(int argc, char *argv[]) { int pids[MAX_TERMINAL + 1]; char * cmd_argv[MAX_ARGC]; char numbuf[5]; int i; int child_cnt; int status; cmd_argv[1] = numbuf; cmd_argv[2] = NULL; child_cnt = 0; for ( i = 0; i <= MAX_TERMINAL; i++) { sprintf(numbuf, "%d", i); if (i == CONSOLE) { cmd_argv[0] = "src/console"; } else { cmd_argv[0] = "src/shell"; } switch (pids[i] = ForkChild(cmd_argv)) { case NOEXEC: TtyPrintf(CONSOLE," forking to terminal %d, %s %s\n", i, cmd_argv[0], cmd_argv[1]); TtyPrintf(CONSOLE, "Control prog for terminal %d could not be started.\n", i); break; case NOFORK: TtyPrintf(CONSOLE," forking to terminal %d, %s %s\n", i, cmd_argv[0], cmd_argv[1]); TtyPrintf(CONSOLE, "Error in Fork() for terminal %d.\n", i); break; default: TtyPrintf(CONSOLE," forking to terminal %d, %s %s\n", i, cmd_argv[0], cmd_argv[1]); TtyPrintf(CONSOLE, "Starting pid %d in terminal %d\n", pids[i], i); child_cnt++; } } if (pids[CONSOLE] == -1) { TtyPrintf(CONSOLE, "Cannot start Console monitor, halting...\n"); Exit(-1); } while (1) { int pid; if (!child_cnt) { TtyPrintf(CONSOLE, "No terminals could be serviced, halting...\n"); Exit(-2); } TtyPrintf(CONSOLE," waiting....\n"); pid = Wait(&status); TtyPrintf(CONSOLE," returned from wait, pid %d\n", pid); if (pid == pids[CONSOLE]) { TtyPrintf(CONSOLE, "Halting Yalnix\n"); Exit(0); } for (i = 0; i <= MAX_TERMINAL; i++) { if (pid == pids[i]) break; } TtyPrintf(CONSOLE, "Pid %d died at terminal %d.\n", pids[i], i); cmd_argv[0] = "shell"; sprintf(numbuf, "%d", i); pids[i] = ForkChild(cmd_argv); switch (pids[i]) { case NOEXEC: TtyPrintf(CONSOLE, "Shell for terminal %d could not be started.\n", i); child_cnt--; break; case NOFORK: TtyPrintf(CONSOLE, "Error in Fork() for terminal shell %d.\n", i); child_cnt--; break; default: TtyPrintf(CONSOLE, "Started shell with pid %d in terminal %d.\n", pids[i], i); break; } } }
int main(int argc, char **argv) { int pid, i, j, ret; int exit_status; char *exec_argv[] = { "haha", NULL }; int *a = (int *)calloc(3, sizeof(int)); int num_a = 100; char *str; unsigned int delay_ticks = 2; char buf[2 * TERMINAL_MAX_LINE + 2]; char pipe_buf[1025]; int pipe_fd; int lock_fd; int cvar_fd; #ifdef SWAP_TEST free(a); a = (void *)calloc(num_a, PAGESIZE); if (a == NULL) goto loop; if (Fork() == 0) { while (1) { Delay(2); a[0] = 1000; TtyPrintf(CONSOLE, "pid = %u, a[0] = %u\n", GetPid(), a[0]); } } for (i = 0; i < num_a * PAGESIZE / sizeof(int); i += (PAGESIZE / sizeof(int))) a[i] = 100; if (Fork() == 0) { while (1) { Delay(2); a[0] = 2000; TtyPrintf(CONSOLE, "pid = %u, a[0] = %u\n", GetPid(), a[0]); } } for (i = 0; i < num_a * PAGESIZE / sizeof(int); i += (PAGESIZE / sizeof(int))) a[i] = 100; if (Fork() == 0) { while (1) { Delay(2); a[0] = 3000; TtyPrintf(CONSOLE, "pid = %u, a[0] = %u\n", GetPid(), a[0]); } } for (i = 0; i < num_a * PAGESIZE / sizeof(int); i += (PAGESIZE / sizeof(int))) a[i] = 100; if (Fork() == 0) { while (1) { Delay(2); a[0] = 4000; TtyPrintf(CONSOLE, "pid = %u, a[0] = %u\n", GetPid(), a[0]); } } for (i = 0; i < num_a * PAGESIZE / sizeof(int); i += (PAGESIZE / sizeof(int))) a[i] = 100; if (Fork() == 0) { while (1) { Delay(2); a[0] = 5000; TtyPrintf(CONSOLE, "pid = %u, a[0] = %u\n", GetPid(), a[0]); } } for (i = 0; i < num_a * PAGESIZE / sizeof(int); i += (PAGESIZE / sizeof(int))) a[i] = 100; #endif #ifdef PIPE_TEST ret = PipeInit(&pipe_fd); pid = Fork(); bzero(pipe_buf, sizeof(pipe_buf)); if (pid != ERROR && !pid) { TtyPrintf(CONSOLE, "pipe_fd = %u\n", pipe_fd); j = 0; Delay(1); while (1) { for (i = 0; i < sizeof(pipe_buf); i++) pipe_buf[i] = (j % 26) + 'a'; TtyPrintf(CONSOLE, ">>>>>>>>>>> write pipe\n"); ret = PipeWrite(pipe_fd, pipe_buf, sizeof(pipe_buf)); TtyPrintf(CONSOLE, "write pipe ret = %d, pid = %u\n", ret, GetPid()); j++; } Exit(0); } while (1) { bzero(pipe_buf, sizeof(pipe_buf)); TtyPrintf(CONSOLE, ">>>>>>>>>>> read pipe\n"); ret = PipeRead(pipe_fd, pipe_buf, sizeof(pipe_buf) - 7); TtyPrintf(CONSOLE, "<<<<<<<<<<< read pipe ret = %d, pid = %u, %s\n", ret, GetPid(), pipe_buf); } Reclaim(pipe_fd); #endif #ifdef CVAR_TEST ret = LockInit(&lock_fd); ret = CvarInit(&cvar_fd); pid = Custom0(0, 0, 0, 0); if (pid != ERROR && !pid) { Acquire(lock_fd); while (!condition) CvarWait(cvar_fd, lock_fd); Delay(2); Release(lock_fd); Exit(7); } Acquire(lock_fd); condition = 1; CvarSignal(cvar_fd); Release(lock_fd); ret = Reclaim(lock_fd); if (ret) Exit(-1); #endif #ifdef TTY_TEST for (i = 0; i < sizeof(buf) - 1; i++) buf[i] = '9'; buf[i] = '\0'; TtyPrintf(CONSOLE, buf); TtyPrintf(CONSOLE, "\n"); a[0] = 10; a[2] = 100; TtyPrintf(CONSOLE, "Enter somthing:\n"); bzero(buf, sizeof(buf)); ret = TtyRead(CONSOLE, buf, sizeof(buf)); TtyPrintf(CONSOLE, "You just entered: %s (len = %d)\n", buf, ret); #endif #ifdef COW_TEST if (argc == 2) delay_ticks = atoi(argv[1]); pid = Fork(); if (pid == ERROR) { Delay(2); return ERROR; } else if (!pid) { GetPid(); delay_ticks = 5; TtyPrintf(CONSOLE, " delay_ticks = %u, pid = %u\n", delay_ticks, GetPid()); pid = Fork(); if (pid != ERROR && !pid) { GetPid(); delay_ticks = 8; TtyPrintf(CONSOLE, " delay_ticks = %u, pid = %u\n", delay_ticks, GetPid()); Delay(delay_ticks); Exec("exec_test", exec_argv); } pid = Wait(&exit_status); TtyPrintf(CONSOLE, " delay_ticks = %u, pid = %u\n", delay_ticks, GetPid()); TtyPrintf(CONSOLE, " wait child = %u, status = %d\n", pid, exit_status); Delay(delay_ticks); Exit(10); } pid = Fork(); if (pid != ERROR && !pid) { incursive_func(0); GetPid(); delay_ticks = 9; TtyPrintf(CONSOLE, " delay_ticks = %u, pid = %u\n", delay_ticks, GetPid()); Delay(delay_ticks); Exit(100); } TtyPrintf(CONSOLE, " delay_ticks = %u, pid = %u\n", delay_ticks, GetPid()); Delay(delay_ticks); GetPid(); Wait(&exit_status); Wait(&exit_status); GetPid(); #endif loop: while (1) Delay(delay_ticks); return 0; }