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