System V IPC Shared Memory

Each newly created shared memory area is represented by a shmid_ds data structure. These are kept in the shm_segs vector.

The shmid_ds data structure decribes how big the area of shared memory is, how many processes are using it and information about how that shared memory is mapped into their address spaces. It is the creator of the shared memory that controls the access permissions to that memory and whether its key is public or private. If it has enough access rights it may also lock the shared memory into physical memory.

Each process that wishes to share the memory must attach to that virtual memory via a system call. This creates a newvm_area_struct data structure describing the shared memory for this process. The process can choose where in its virtual address space the shared memory goes or it can let Linux choose a free area large enough. The new vm_area_struct structure is put into the list of vm_area_struct pointed at by the shmid_ds. The vm_next_shared and vm_prev_shared pointers are used to link them together. The virtual memory is not actually created during the attachment; it happens when the first process attempts to access it.

The first time that a process accesses one of the pages of the shared virtual memory, a page fault will occur. When Linux fixes up that page fault it finds the vm_area_struct data structure describing it. This contains pointers to handler routines for this type of shared virtual memory. The shared memory page fault handling code looks in the list of page table entries for this shmid_ds to see if one exists for this page of the shared virtual memory. If it does not exist, it will allocate a physical page and create a page table entry for it.

This entry is saved in the current process’ page tables and the shmid_ds.. Consequently, when the next process that attempts to access this memory gets a page fault, the shared memory fault handling code will use this newly created physical page for that process too. So, the first process that accesses a page of the shared memory causes it to be created and thereafter access by the other processes cause that page to be added into their virtual address spaces.

When processes no longer wish to share the virtual memory, they detach from it. So long as other processes are still using the memory the detach only affects the current process. Its vm_area_struct is removed from the shmid_ds data structure and deallocated. The current process’s page tables are updated to invalidate the area of virtual memory that it once shared. When the last process sharing the memory detaches from it, the pages of the shared memory current in physical memory are freed, as is theshmid_ds data structure for this shared memory.

1.1
log
@Initial revision
@
text
@#include”header.h”
int main()
{
void *queue;
int f,r;
f=r=-1;
int ch;
do
{
printf(“1:push\n”);
printf(“2:pop\n”);
printf(“3:display\n”);
printf(“4:exit\n”);
printf(“enter your choice\n”);
scanf(“%d”,&ch);
switch(ch)
{
case 1: push(&queue,&f,&r);
break;
case 2: pop(&queue,&f,&r);
break;
case 3: display(&queue,&f,&r);
break;
default: printf(“wrong choice\n”);
}
}while(ch != 4);
return 0;
}

#include”header.h”
static char ch=1;
int push(void **qa,int *fa,int *ra)
{
if(*ra >= MAX-1)
{
printf(“queue overflow\n”);
return -1;
}
if(*fa ==-1 && *ra == -1)
{
*qa=(char *)malloc(1);
(*fa)++;
(*ra)++;
*(char *)(*qa + *ra)=ch;
ch++;
return 0;
}
*qa=(char *)realloc(*qa, (*ra)+2);
(*ra)++;
*(char *)(*qa + *ra)=ch;
ch++;
return 0;
}

int pop(void **qa,int *fa,int *ra)
{
if(*fa >= MAX)
{
printf(“queue underflow\n”);
return -1;
}
printf(“the %d popped element is %d\n”,*fa, *(char *)(*qa + *fa));
(*fa)++;
return 0;
}
void display(void **qa,int *fa,int *ra)
{
int i;
for(i= *fa; i <= *ra ; i++)
{
printf(“the %d element is %d\n”,i,*(char *)(*qa + i));
}
}

@

1.1
date 2014.03.29.11.10.17; author emblogic; state Exp;
branches;
next ;

desc
@this is a program of stack implementation using poimters
@

1.1
log
@Initial revision
@
text
@#include”header.h”
int main()
{
void *stack;
int ch,top=-1;
do
{
printf(“1: push\n”);
printf(“2: pop\n”);
printf(“3: display\n”);
printf(“enter your choice\n”);
scanf(“%d”,&ch);
switch(ch)
{
case 1:
push(&stack,&top);
break;
case 2:
pop(&stack,&top);
break;
case 3:
display(&stack,&top);
break;
defautl:
printf(“wrong choice\n”);
}
}while(ch != 4);
}

@
@#include”header.h”
int push(void **astack,int *atop)
{
static char ch=1;

if( *atop >= MAX-1)
{
printf(“stack overflow\n”);
return -1;
}
if( *atop < 0)
{
*astack=(char *)malloc(1);
(*atop)++;
*(char *)(*astack + *atop)=ch;
ch++;
return 0;
}
(*atop)++;
*astack=(char *)realloc(*astack, (*atop)+1);
*(char *)(*astack + *atop)=ch;
ch++;

return 0;
}
int pop(void **astack,int *atop)
{
if(*atop=0; i–)
{
printf(“the element at loc %d is = %d\n”,i, *(char *)(*astack + i));
}
}

@

1.1
date 2014.03.25.09.08.55; author Emblogic; state Exp;
branches;
next ;

desc
@this is a program of linked list
to insert the node at beginning,position and end
to delete the node at begining,position,end
to dispay the linked list
@

1.1
log
@Initial revision
@
text
@#include
#include
struct node
{
int data;
struct node *next;
};
struct node * create_node();
struct node * insert_node(struct node *);
struct node * delete_node(struct node *);
void display(struct node *);
struct node * insert_beg(struct node *);
struct node * insert_pos(struct node *);
struct node * insert_end(struct node *);
struct node * delete_beg(struct node *);
struct node * delete_pos(struct node *);
struct node * delete_end(struct node *);

int main()
{
struct node *start;
int ch;
do
{
printf(“1: create_node\n”);
printf(“2: insert_node\n”);
printf(“3: delete_node\n”);
printf(“4: display\n”);
printf(“5: exit\n”);
printf(“enter your choice\n”);
scanf(“%d”,&ch);
switch(ch)
{
case 1:
start=create_node();
break;
case 2:
start=insert_node(start);
break;
case 3:
start=delete_node(start);
break;
case 4:
display(start);
break;
case 5:
break;
}

}while(ch != 5);

}
struct node * create_node()
{
struct node *start;
start=malloc(sizeof(struct node));
printf(” enter data\n”);
scanf(“%d”,&start->data);
start->next= NULL;
return start;
}

struct node * insert_node(struct node *start)
{
int ch;
printf(“1: insert at begining\n”);
printf(“2: insert at position\n”);
printf(“3: insert at end\n”);
printf(“enter your choice\n”);
scanf(“%d”,&ch);

switch(ch)
{
case 1:
start=insert_beg(start);
break;
case 2:
start=insert_pos(start);
break;
case 3:
start=insert_end(start);
break;
}
return start;

}

struct node * delete_node(struct node *start)
{
int ch;
printf(“1: delete at begining\n”);
printf(“2: delete at position\n”);
printf(“3: delete at end\n”);
printf(“enter your choice\n”);
scanf(“%d”,&ch);

switch(ch)
{
case 1:
start=delete_beg(start);
break;
case 2:
start=delete_pos(start);
break;
case 3:
start=delete_end(start);
break;
}
return start;

}

void display(struct node *start)
{
struct node *temp;
temp=start;
while(temp != NULL)
{
printf(“the data is %d”,temp->data);
temp=temp->next;
}
}

struct node * insert_beg(struct node *start)
{
struct node *temp;
temp=start;
start=create_node();
start->next=temp;
return start;
}
struct node * insert_pos(struct node *start)
{
struct node *temp, *new;
int n,i;
temp=start;
printf(“enter the position\n”);
scanf(“%d”,&n);
for(i=0; i next;
}
new=create_node();
new->next=temp->next;
temp->next=new;
return start;
}
struct node * insert_end(struct node *start)
{
struct node *temp,*new;
temp=start;
while(temp != NULL)
{
temp=temp->next;
}
new=create_node();
temp->next=new;
new->next= NULL;
return start;
}

struct node * delete_beg(struct node *start)
{
struct node *temp;
temp= start;
start=start->next;
free(temp);
return start;
}
struct node * delete_pos(struct node *start)
{
struct node *temp, *prev;
int n,i;
temp=start;
printf(“enter the position\n”);
scanf(“%d”,&n);
for(i=0; i next;
}
prev->next=temp->next;
free(temp);
return start;
}
struct node * delete_end(struct node *start)
{
struct node *temp,*prev;
temp=start;
while(temp->next != NULL)
{
prev=temp;
temp=temp->next;
}
free(temp);
prev->next= NULL;
return start;
}
@

char variables can be byte aligned and appear at any byte boundary

short (2 byte) variables must be 2 byte aligned, they can appear at any even byte boundary. This means that 0×10004567 is not a valid location for a short variable but 0×10004566 is.

long (4 byte) variables must be 4 byte aligned, they can only appear at byte boundarys that are a multiple of 4 bytes. This means that 0×10004566 is not a valid location for a long variable but 0×10004568 is.

Structure padding occurs because the members of the structure must appear at the correect byte boundary, to achieve this the compiler puts in padding bytes (or bits if bit fields are in use) so that the structure members appear in the correct location. Additionally the size of the structure must be such that in an array of the structures all the structures are correctly aligned in memory so there may be padding bytes at the end of the structure too

struct example {

char c1;

short s1;

char c2;

long l1;

char c3;

}

In this structure, assuming the alignment scheme I have previously stated then

c1 can appear at any byte boundary, however s1 must appear at a 2 byte boundary so there is a padding byte between c1 and s1.

c2 can then appear in the available memory location, however l1 must be at a 4 byte boundary so there are 3 padding bytes between c2 and l1

c3 then appear in the available memory location, however because the structure contains a long member the structure must be 4 byte aligned and must be a multiple of 4 bytes in size. Therefore there are 3 padding bytes at the end of the structure. it would appear in memory in this order

c1

padding byte

s1 byte 1

s1 byte 2

c2

padding byte

padding byte

padding byte

l1 byte 1

l1 byte 2

l1 byte 3

l1 byte 4

c3

padding byte

padding byte

padding byte

The structure would be 16 bytes long.

re-written like this

struct example {

long l1;

short s1;

char c1;

char c2;

char c3;

}

Then l1 appears at the correct byte alignment, s1 will be correctly aligned so no need for padding between l1 and s1. c1, c2, c3 can appear at any location. The structure must be a multiple of 4 bytes in size since it contains a long so 3 padding bytes appear after c3

It appears in memory in the order

l1 byte 1

l1 byte 2

l1 byte 3

l1 byte 4

s1 byte 1

s1 byte 2

c1

c2

c3

padding byte

padding byte

padding byte

and is only 12 bytes long.

RCS file: 7p8.c,v
Working file: 7p8.c
head: 1.1
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 1;    selected revisions: 1
description:
this is the program using pointers
in which we count the positive no.s in array and exit when zero is found
there must b atleast one zero in the array
—————————-
revision 1.1
date: 2014/03/08 10:29:51;  author: emblogic;  state: Exp;
Initial revision

RCS file: 7p7.c,v
Working file: 7p7.c
head: 1.1
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 1;    selected revisions: 1
description:
this is a program to print the first byte of each element from an integer array
using pointers
—————————-
revision 1.1
date: 2014/03/08 10:39:55;  author: emblogic;  state: Exp;
Initial revision