äúåëðéåú äáàåú îîçéùåú ùéîåù áäåãòåú IPC

 

#include <sys/types.h>

 #include <sys/ipc.h>

 #include <sys/msg.h>

 

 

 int msgget(key_t key, int msgflg);

 

 

 int msgsnd(int msqid, struct msgbuf *msgp,

                               size_t msgsz, int msgflg);

 

 

 ssize_t  msgrcv(int msqid, struct msgbuf *msgp, size_t msgsz,

        long msg-typ, int msgflg);

 

 

 int msgctl(int msqid, int cmd, struct msqid_ds *buf);

 

/* msgp1a.c - Use System V messages */

 

#include <stdio.h>

#include <sys/ipc.h>

#include <sys/types.h>

#include <sys/msg.h>

 

void sys_err(char s[])

{

   perror(s);

   exit(1);

}

 

long int mesgq;

int sid;

struct msqid_ds buff;

 

receiver()

{

 struct msgbuf msg;

 char text[30] = {'\0'};

 int i = 0;

 

  do {

    int n;

    n = msgrcv(mesgq, &msg, 1, 722L , MSG_NOERROR);

    if ( n < 1 )

     sys_err("msgrcv error");

 

    text[i++] = msg.mtext[0];

 

  } while ( msg.mtext[0] != '\0');

 

  printf("Received:  %s \n",text);

 

  if ( msgctl(mesgq, IPC_RMID, &buff) < 0)

     sys_err("Cannot remove message queue");

 

} /* receiver */

 

sender()

{

  int i;

  struct msgbuf msg[14] = { {722,'H'},{722,'e'},{722,'l'},{722,'l'},{722,'o'},

                            {722,' '},{722,'W'},{722,'o'},{722,'r'},{722,'l'},

                            {722,'d'},{722,'!'},{722,'\n'},{722,'\0'} };

 

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

    if ( msgsnd(mesgq, &msg[i], 1, IPC_NOWAIT) < 0 )

        sys_err("msgsnd error");

 

} /* sender */

 

int main()

{

 

 

  if ( (mesgq = msgget(IPC_PRIVATE, 0666)) < 0)

       sys_err("Cannot msgget");

 

  printf("mesgq == %ld\n", mesgq);

 

  if (sid = fork())

     sender();

  else

     receiver();

 

  return 0;

} /* main */

 

____________________________________________

 

 

% cc msgp1a.c

% ./a.out

mesgq == 65536

Received:  Hello World!

 

%

 

/* msgprog1.c - Use System V messages */

 

#include <stdio.h>

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/msg.h>

 

 

typedef struct mymsgbuf {

                  long int mtype;

                  char text[14];

                  } MYMSGBUF;

 

long int mesgq;

int sid;

struct msqid_ds buff;

 

 

void sys_err(char s[])

{

   perror(s);

   exit(1);

}

 

receiver()

{

 

  MYMSGBUF msg;

  int n;

 

  n = msgrcv(mesgq, (struct msgbuf *)&msg, 14, 722L , MSG_NOERROR);

 

  /* In THIS program, the message is known to be 14 bytes */

  if (n < 14)

    sys_err("msgrcv error");

 

 

  printf("Received:  %s \n",msg.text);

 

  if ( msgctl(mesgq, IPC_RMID, &buff) < 0)

     sys_err("Cannot remove message queue");

 

 

}  /* receiver */

 

sender()

{

  int i;

 

    MYMSGBUF msg1 = {722, "Hello World!"};

 

    if ( msgsnd(mesgq, (struct msgbuf *)&msg1, 14, IPC_NOWAIT) < 0 )

        sys_err("msgsnd error");

 

} /* sender */

 

int main()

{

 

  if ( (mesgq = msgget(IPC_PRIVATE, 0666)) < 0)

       sys_err("Cannot msgget");

 

  printf("mesgq == %ld\n", mesgq);

 

  if (sid = fork())

     sender();

  else

     receiver();

 

  return 0;

} /* main */

 

___________________________________________

 

 

% cc msgprog1.c

% ./a.out

mesgq == 163840

Received:  Hello World!

%

 

 

äúåëðéú äáàä îîçéùä ùéîåù áñîôåøéí ùì IPC åâí ñâîðèéí îùåúôéí.

 

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

 

int semget(key_t key, int nsems, int semflg);

 

int semop(int semid, struct sembuf *sops, unsigned nsops);

 

int semctl(int semid, int semnum, int cmd, ...);

 

 

struct sembuf

{

  unsigned short int sem_num;   /* semaphore number */

  short int sem_op;             /* semaphore operation */

  short int sem_flg;            /* operation flag */

};

 

/* semaph6.c -  prod2, cons2 */

 

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

#include <sys/shm.h>

 

 

 

volatile int *n;              /* Shared memory variable */

 

 

void sys_err(char s[])

{

   perror(s);

   exit(1);

} /* sys_err */

 

 

int waitsem(sid, indx)

int sid;

int indx;

{

  struct sembuf sb;

 

  sb.sem_num  = indx;

  sb.sem_op = -1;

  sb.sem_flg = 0;

 

  if ( semop(sid, &sb, 1) < 0 )

          sys_err("semop waitsem error");

 

} /* waitsem  */

 

int sigsem(sid,indx)

int sid;

int indx;

{

  struct sembuf sb;

 

  sb.sem_num  = indx;

  sb.sem_op = 1;

  sb.sem_flg = 0;

 

  if ( semop(sid, &sb, 1) < 0)

        sys_err("semop sigsem error");

 

} /* sigsem */

 

/*------------------------------------------------------------------------

 *  main  --  producer and consumer processes synchronized with semaphores

 *------------------------------------------------------------------------

 */

void  main()

{

          int     prod2(), cons2();

          int     semid, shmid;

        int     id;

 

        struct shmid_ds buff;

 

        union semun

           {

                  int val;

                  struct semid_ds *buf;

                  u_short *array;

           }  buff1;

 

 

        if ( (semid =

                semget( IPC_PRIVATE, 2, 0666)) < 0 )

            sys_err("Cannot semget");

 

 

        if ( (shmid =

             shmget(IPC_PRIVATE, sizeof(int), 0666) ) < 0)

               sys_err("Cannot shmget shmid");

        

        if ( (n = (int *)shmat(shmid,0,0)) == (int *) -1)

                 sys_err("Cannot shmat n");

 

        *n = 0; /* Initialize *n */

 

        sigsem(semid, 0);

 

        if ( (id = fork()) )

          /* Parent process    */

           cons2(semid, 0, 1);

        else /* Child process */

         prod2(semid, 1, 0);

 

        if (shmdt((char *)n) < 0)

           sys_err("Cannot shmdt");

 

        if (id) /* Consumer is last to use the shared segment/semaphore */

         {

           int status;

   

           wait(&status); /* consumer is parent */

           if ( semctl(semid, 2, IPC_RMID, &buff1) < 0 )

                 sys_err("Semaphore remove (semctl) error");

           if ( shmctl(shmid, IPC_RMID, &buff) < 0 )

                 sys_err("Segment remove (shmctl) error");

         }

 

 

} /* main */

 

/*-------------------------------------------------------------------

 *  prod2  --  increment n 20 times, waiting for it to be consumed

 *-------------------------------------------------------------------

 */

 

int prod2(semid, indx1, indx2)

int semid, indx1, indx2;

{

          int     i;

 

          for (i=1; i<=20; i++) {

                   waitsem(semid, indx1);

                   (*n)++;

                   sigsem(semid, indx2);

          }

} /* prod2 */

 

/*----------------------------------------------------------------

 *  cons2  --  print n 20 times, waiting for it to be produced

 *----------------------------------------------------------------

 */

 

int cons2(semid, indx1, indx2)

int semid, indx1, indx2;

{

          int     i;

 

 

          for (i=1; i<=20; i++) {

                   waitsem(semid, indx1);

                   printf("n is %d\n", *n);

                   sigsem(semid, indx2);

          }

 

} /* cons2 */

 

 

_________________________________________________

 

 

alpha7:/usr/users/home7/ronn/OS > cc semaph6.c

alpha7:/usr/users/home7/ronn/OS > a.out

n is 0

n is 1

n is 2

n is 3

n is 4

n is 5

n is 6

n is 7

n is 8

n is 9

n is 10

n is 11

n is 12

n is 13

n is 14

n is 15

n is 16

n is 17

n is 18

n is 19

alpha7:/usr/users/home7/ronn/OS >