EmbLogic's Blog

what is name resolution in hosts file in nfs server??

how it works??

this is the simple and conceptual programme on structure, which is used to hold the structure variable in the array of structure.

we can also implement the array if structure as show below:

#include<stdio.h>
struct abc
{
int a;
int b;
}a1,a2,a3[2];

int main()
{
a1.a=3;
a1.b=4;
a2.a=5;
a2.b=6;
a3[0]=a1;
a3[1]=a2;
printf(“%d”,a3[0].a);//print the output as 3 because a1.a=3.
return 0;
}

RCS file: sema.c,v
Working file: sema.c
head: 1.8
branch:
locks: strict
akshat: 1.8
access list:
symbolic names:
keyword substitution: kv
total revisions: 8; selected revisions: 8
description:
This is communication btw 3 clients and central server.
all are sendings requests simultaneously.
using semaphore syncronisation is done.
—————————-
revision 1.8 locked by: akshat;
date: 2014/03/27 04:12:31; author: akshat; state: Exp; lines: +3 -5
file descripter was named incorrect.
semaphore is working
project is working.
—————————-
revision 1.7
date: 2014/03/27 01:45:41; author: akshat; state: Exp; lines: +4 -3
Working fine but with few limitations.
:/
—————————-
revision 1.6
date: 2014/03/27 01:30:59; author: akshat; state: Exp; lines: +48 -68
Answer is going exact same in requesting clients.
but now in server operator is not exactly same printed.
checking for any left file descripter to be closed.
—————————-
revision 1.5
date: 2014/03/27 00:58:46; author: akshat; state: Exp; lines: +14 -1
Without using any wait or sleep statement, result is found to be correct.
Semaphore is working very well
Now from server, with a new fifo, this will be passed to the requsting client.
project is 75% done, without any error.
—————————-
revision 1.4
date: 2014/03/26 19:15:50; author: akshat; state: Exp; lines: +12 -3
its working fine, Processing client is getting all the msgs.
now result has to be passed to server again.
From server result will go back to the requesting client.
—————————-
revision 1.3
date: 2014/03/26 03:59:16; author: akshat; state: Exp; lines: +21 -5
Processing client is not getting the data.
checking.
—————————-
revision 1.2
date: 2014/03/26 03:53:00; author: akshat; state: Exp; lines: +54 -38
Now creating a processing client for same.
nos read will dirctly be sent to processing client for processing.
—————————-
revision 1.1
date: 2014/03/26 03:39:54; author: akshat; state: Exp;
Initial revision
=============================================================================

Semaphore is quiet easy and simple…

Lets take an example from our real life which makes semaphore a simple task for me….

when we are using a printer on lan network and ten’s of computer are connected to the same printer for printout so if anyone wants to get a printout he can give a command and get that but suppose there is a situation in which all the computers execute print command at the same time so how will printer control it so there need to be some protocol implementation to control the sequence otherwise what will happen if printer will access all the commands at the same time imagine yourself, It might be possible that all the picture get on the one paper. so we use some technique to control it. in this example critical condition is when computers are trying to access the printer. So there should be some condition before entering the critical region so that a single process will enter at one time and rest will be in the waiting condition till one is accessing so we implement the semaphore.

While implementing one need to have knowledge of three system calls:

semget();   //it is used to declare semaphore

semctl();    //it is used to initialize semaphore

semop();     // it is used to control condition before entering and leaving the semaphore

so now you need to think where to use what????… so we will implement according to its use as such if semget is for declaration so we need to declare it once and where you want to use semaphore.and also it returns sem_id that is generated by kernel which is required to access the semop command and for using semaphore in future.

and when it comes to semctl() it is used for initializing the semaphore and it will make the clients to see the condition and enter the semaphore so you need to enter it once at time of deceleration but it is not mandatory it may vary according to once need.

and semop() is used to decrease the operator value before executing statement after entering critical region and increment operator value again before leaning the critical region so that other can access it….

see figure it will also help you to understand.

FILE *

For C File I/O you need to use a FILE pointer, which will let the program keep track of the file being accessed. (You can think of it as the memory address of the file or the location of the file).

For example:
FILE *fp;

fopen

To open a file you need to use the fopen function, which returns a FILE pointer. Once you’ve opened a file, you can use the FILE pointer to let the compiler perform input and output functions on the file.
FILE *fopen(const char *filename, const char *mode);
In the filename, if you use a string literal as the argument, you need to remember to use double backslashes rather than a single backslash as you otherwise risk an escape character such as \t. Using double backslashes \\ escapes the \ key, so the string works as it is expected.

fopen modes

The allowed modes for fopen are as follows:
r – open for reading
w – open for writing (file need not exist)
a – open for appending (file need not exist)
r+ – open for reading and writing, start at beginning
w+ – open for reading and writing (overwrite file)
a+ – open for reading and writing (append if file exists)
Note that it’s possible for fopen to fail even if your program is perfectly correct: you might try to open a file specified by the user, and that file might not exist (or it might be write-protected). In those cases, fopen will return 0, the NULL pointer.

Here’s a simple example of using fopen:

FILE *fp;
fp=fopen(“c:\\test.txt”, “r”);
This code will open test.txt for reading in text mode. To open a file in a binary mode you must add a b to the end of the mode string; for example, “rb” (for the reading and writing modes, you can add the b either after the plus sign – “r+b” – or before – “rb+”)

fclose

When you’re done working with a file, you should close it using the function
int fclose(FILE *a_file);
fclose returns zero if the file is closed successfully.

An example of fclose is
fclose(fp);
Reading and writing with fprintf, fscanf fputc, and fgetc

To work with text input and output, you use fprintf and fscanf, both of which are similar to their friends printf and scanf except that you must pass the FILE pointer as first argument. For example:
FILE *fp;
fp=fopen(“c:\\test.txt”, “w”);
fprintf(fp, “Testing…\n”);
It is also possible to read (or write) a single character at a time–this can be useful if you wish to perform character-by-character input (for instance, if you need to keep track of every piece of punctuation in a file it would make more sense to read in a single character than to read in a string at a time.) The fgetc function, which takes a file pointer, and returns an int, will let you read a single character from a file:
int fgetc (FILE *fp);
Notice that fgetc returns an int. What this actually means is that when it reads a normal character in the file, it will return a value suitable for storing in an unsigned char (basically, a number in the range 0 to 255). On the other hand, when you’re at the very end of the file, you can’t get a character value–in this case, fgetc will return “EOF”, which is a constant that indicates that you’ve reached the end of the file. To see a full example using fgetc in practice, take a look at the example here.

The fputc function allows you to write a character at a time–you might find this useful if you wanted to copy a file character by character. It looks like this:
int fputc( int c, FILE *fp );
Note that the first argument should be in the range of an unsigned char so that it is a valid character. The second argument is the file to write to. On success, fputc will return the value c, and on failure, it will return EOF.

FILE *

For C File I/O you need to use a FILE pointer, which will let the program keep track of the file being accessed. (You can think of it as the memory address of the file or the location of the file).

For example:
FILE *fp;

fopen

To open a file you need to use the fopen function, which returns a FILE pointer. Once you’ve opened a file, you can use the FILE pointer to let the compiler perform input and output functions on the file.
FILE *fopen(const char *filename, const char *mode);
In the filename, if you use a string literal as the argument, you need to remember to use double backslashes rather than a single backslash as you otherwise risk an escape character such as \t. Using double backslashes \\ escapes the \ key, so the string works as it is expected.

fopen modes

The allowed modes for fopen are as follows:
r – open for reading
w – open for writing (file need not exist)
a – open for appending (file need not exist)
r+ – open for reading and writing, start at beginning
w+ – open for reading and writing (overwrite file)
a+ – open for reading and writing (append if file exists)
Note that it’s possible for fopen to fail even if your program is perfectly correct: you might try to open a file specified by the user, and that file might not exist (or it might be write-protected). In those cases, fopen will return 0, the NULL pointer.

Here’s a simple example of using fopen:

FILE *fp;
fp=fopen(“c:\\test.txt”, “r”);
This code will open test.txt for reading in text mode. To open a file in a binary mode you must add a b to the end of the mode string; for example, “rb” (for the reading and writing modes, you can add the b either after the plus sign – “r+b” – or before – “rb+”)

fclose

When you’re done working with a file, you should close it using the function
int fclose(FILE *a_file);
fclose returns zero if the file is closed successfully.

An example of fclose is
fclose(fp);
Reading and writing with fprintf, fscanf fputc, and fgetc

To work with text input and output, you use fprintf and fscanf, both of which are similar to their friends printf and scanf except that you must pass the FILE pointer as first argument. For example:
FILE *fp;
fp=fopen(“c:\\test.txt”, “w”);
fprintf(fp, “Testing…\n”);
It is also possible to read (or write) a single character at a time–this can be useful if you wish to perform character-by-character input (for instance, if you need to keep track of every piece of punctuation in a file it would make more sense to read in a single character than to read in a string at a time.) The fgetc function, which takes a file pointer, and returns an int, will let you read a single character from a file:
int fgetc (FILE *fp);
Notice that fgetc returns an int. What this actually means is that when it reads a normal character in the file, it will return a value suitable for storing in an unsigned char (basically, a number in the range 0 to 255). On the other hand, when you’re at the very end of the file, you can’t get a character value–in this case, fgetc will return “EOF”, which is a constant that indicates that you’ve reached the end of the file. To see a full example using fgetc in practice, take a look at the example here.

The fputc function allows you to write a character at a time–you might find this useful if you wanted to copy a file character by character. It looks like this:
int fputc( int c, FILE *fp );
Note that the first argument should be in the range of an unsigned char so that it is a valid character. The second argument is the file to write to. On success, fputc will return the value c, and on failure, it will return EOF.

head 1.1;
access;
symbols;
locks
arjun:1.1; strict;
comment @ * @;

1.1
date 2014.03.21.15.02.57; author arjun; state Exp;
branches;
next ;

desc
@we are making a server which has 3 requesting client and 3 processing client
but right now it has 3 requesting client and 1processing client
we are using different pipe here for all type of client
all requesting client are working properly
bt processing client is not working properly
@

1.1
log
@Initial revision
@
text
@#include
#include
int main()
{
int pid,pfd[2],buf5[4],ret,z;
char a[4],b[4];
ret=pipe(pfd);
sprintf(a,”%d”,pfd[0]);
sprintf(b,”%d”,pfd[1]);
pid=fork();
if(pid>0)
{
printf(“i am parent\n”);
int i,retw,retr,pid1,add_ret,add_retr,add_pfd[2],buf1[3],buf2[3],buf[3],buf3[3];
char c[4],d[4],e[4],f[4],g[4],h[4],k[4],l[4],m[4],n[4];
retr=read(pfd[0],buf2,12);
for(i=0;i<3;i++)
printf("buf2[%d]=%d\n",i,buf2[i]);

add_ret=pipe(add_pfd);
sprintf(c,"%d",add_pfd[0]);
sprintf(d,"%d",add_pfd[1]);
pid1=fork();
if(pid1==0)
{
printf("i am child2\n");
execl("cl2","arjun",c,d,NULL);
}

add_retr=read(add_pfd[0],buf3,12);
for(i=0;i<3;i++)
printf("buf3[%d]=%d\n",i,buf3[i]);

int pid2,mul_pfd[2],mul_retr,mul_ret,buf4[3];
mul_ret=pipe(mul_pfd);
sprintf(e,"%d",mul_pfd[0]);
sprintf(f,"%d",mul_pfd[1]);

pid2=fork();
if(pid2==0)
{
printf("i am child3\n");
execl("cl3","arjun",e,f,NULL);
}

mul_retr=read(mul_pfd[0],buf4,12);
for(i=0;i<3;i++)
printf("buf4[%d]=%d\n",i,buf4[i]);

int pid3,padd_pfd[2],padd_retr,padd_ret,padd_retw,resadd;
padd_ret=pipe(padd_pfd);
sprintf(g,"%d",padd_pfd[0]);
sprintf(h,"%d",padd_pfd[1]);
pid3=fork();
if(pid3==0)
{
padd_retw=write(padd_pfd[1],buf2,12);
printf("i am pchild1\n");
execl("pcl1","arjun",g,h,NULL);
}
/*
printf("padd_retw=%d\n",padd_retw);
padd_retr=read(padd_pfd[0],&resadd,1);
printf("result is =%d",resadd);
*/
}
else
{
printf("i am child1\n");
execl("./cl1","arjun",a,b,NULL);
}

}

@

1 #include<stdio.h>
2 struct distance
3 {
4 int inch;
5 int feet;
6 float meter;
7 float cm;
8 };
9 void input(struct distance *,struct distance *);
10 int addist(struct distance *,struct distance *,struct distance *);
11 void display(struct distance *);
12 void convert(struct distance *);
13 int main()
14 {
15 struct distance d1,d2,d;
16 input(&d1,&d2);
17 addist(&d1,&d2,&d);
18 display(&d);
19 convert(&d);
20 return 0;
21 }
22 void input(struct distance *d1,struct distance *d2)
23 {
24 printf(“enter the distance in feet and inches\n”);
25 printf(“enter the 1st distance\n”);
26 scanf(“%d %d”,&d1->inch,&d1->feet);
27 printf(“enter the 2nd distance\n”);
28 scanf(“%d %d”,&d2->inch,&d2->feet);
29 }
30 int addist(struct distance *d1,struct distance *d2,struct distance *d)
31    {
32 (d->feet)=(d1->feet)+(d2->feet);
33 (d->inch)=(d1->inch)+(d2->inch);
34 if((d->inch)>12)
35 {
36 (d->inch)=(d->inch)-12;
37 (d->feet)=(d->feet)+1;
38 }
39 }
40 void display(struct distance *d)
41 {
42 printf(“sum of two distances in feet and inches\n”);
43 printf(“sum = %d feet %d inches\n”,d->feet,d->inch);
44 }
45 void convert(struct distance *d)
46 {
47 d->meter=(d->feet)/3.28;
48 d->cm=(d->inch)/0.393;
49 printf(“sum in meter and cm\n”);
50 printf(“sum = %f m and %f cm\n”,d->meter,d->cm);
51 }
1,1           Top

Semaphores let processes query or alter status information. They are often used to monitor and control the availability of system resources such as shared memory segments. semaphore set must be initialized using semget(); the semaphore creator can change its ownership or permissions using semctl(); and semaphore operations are performed via the semop() function. These are now discussed below:

INTIALISING A SEMAPHORE:

The function semget() initializes or gains access to a semaphore. It is prototyped by:

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

When the call succeeds, it returns the semaphore ID (semid).

The key argument is a access value associated with the semaphore ID.

The nsems argument specifies the number of elements in a semaphore array. The call fails when nsems is greater than the number of elements in an existing array; when the correct count is not known, supplying 0 for this argument ensures that it will succeed.

The semflg argument specifies the initial access permissions and creation control flags.

CONTROLLING A SEMAPHORE:

semctl() changes permissions and other characteristics of a semaphore set. It is prototyped as follows:

int semctl(int semid, int semnum, int cmd, union semun arg);

It must be called with a valid semaphore ID, semid. The semnum value selects a semaphore within an array by its index.The fourth argument union semun arg is optional, depending upon the operation requested.

SEMAPHORE OPERATION:

semop() performs operations on a semaphore set. It is prototyped by:

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

The semid argument is the semaphore ID returned by a previous semget() call. The sops argument is a pointer to an array of structures, each containing the following information about a semaphore operation:

• The semaphore number
• The operation to be performed
• Control flags, if any.

The sembuf structure specifies a semaphore operation, as defined in <sys/sem.h>.

struct sembuf {
        ushort_t        sem_num;        /* semaphore number */
        short           sem_op;         /* semaphore operation */
        short           sem_flg;        /* operation flags */
};

The nsops argument specifies the length of the array, the maximum size of which is determined by the SEMOPM configuration option; this is the maximum number of operations allowed by a single semop() call, and is set to 10 by default. The operation to be performed is determined as follows:

• A positive integer increments the semaphore value by that amount.
• A negative integer decrements the semaphore value by that amount. An attempt to set a semaphore to a value less than zero fails or blocks, depending on whether IPC_NOWAIT is in effect.
• A value of zero means to wait for the semaphore value to reach zero.

There are two control flags that can be used with semop():

IPC_NOWAIT

– Can be set for any operations in the array. Makes the function return without changing any semaphore value if any operation for which IPC_NOWAIT is set cannot be performed. The function fails if it tries to decrement a semaphore more than its current value, or tests a nonzero semaphore to be equal to zero.

SEM_UNDO

– Allows individual operations in the array to be undone when the process exits.

This function takes a pointer, sops, to an array of semaphore operation structures. Each structure in the array contains data about an operation to perform on a semaphore. Any process with read permission can test whether a semaphore has a zero value. To increment or decrement a semaphore requires write permission. When an operation fails, none of the semaphores is altered.

The process blocks (unless the IPC_NOWAIT flag is set), and remains blocked until:

• the semaphore operations can all finish, so the call succeeds,
• the process receives a signal, or
• the semaphore set is removed.

Only one process at a time can update a semaphore. Simultaneous requests by different processes are performed in an arbitrary order. When an array of operations is given by a semop() call, no updates are done until all operations on the array can finish successfully.

If a process with exclusive use of a semaphore terminates abnormally and fails to undo the operation or free the semaphore, the semaphore stays locked in memory in the state the process left it. To prevent this, the SEM_UNDO control flag makes semop() allocate an undo structure for each semaphore operation, which contains the operation that returns the semaphore to its previous state. If the process dies, the system applies the operations in the undo structures. This prevents an aborted process from leaving a semaphore set in an inconsistent state. If processes share access to a resource controlled by a semaphore, operations on the semaphore should not be made with SEM_UNDO in effect. If the process that currently has control of the resource terminates abnormally, the resource is presumed to be inconsistent. Another process must be able to recognize this to restore the resource to a consistent state. When performing a semaphore operation with SEM_UNDO in effect, you must also have it in effect for the call that will perform the reversing operation. When the process runs normally, the reversing operation updates the undo structure with a complementary value. This ensures that, unless the process is aborted, the values applied to the undo structure are cancel to zero. When the undo structure reaches zero, it is removed.

the operator for preprocessing is #   (it is already processed)

the steps followed while processin are:-

1.preprocessor – in this .c is converted to—->.i file

In stdio.h there are 3 things

a)stdout   b)stdin  c)stduser

keyboard—————–>program——————>terminal                                                                       stdin                          stdout ,stduser

The .h means=the declaration has to b done. these are called header files .                  they give defination at the execution time.                                                                          The .c means=declaration +defination .The .c is a normal file

2.compilation= in this .i is converted to—->.s file                                                              the .i means=preprocessing file and .s is assembly file.                                                 in this steps are followed like symbol table is made, errors are checked , logical analysis is done  ,assembly language is checked

3.assembler=in this .s is converted to—->.o file .the .o is the object file

4.linker=in this .o is converted to—->a.out file                                                                     GCC has this linker file

5.loader= this is the last step which loads the program on the RAM. loader checks whether space is available on RAM or not