perform read from shared file descriptor

Valenti Alessandro · *nix forums beginner Joined: 23 Feb 2006 Posts: 2

In my opinion the read function should also move the file offset
"exactly" for the amount of read characters but also the Posix
specification says nothing about the required behaviour.
I know that probably no one needs to read from a shared file descriptor,
but it is interesting for me understand why some OS protects the file
offset change and why some others does not.

Many thanks to Paul for the detailed explaination of Linux model.

Bye

Paul Pluzhnikov wrote:
....

Paul Pluzhnikov · *nix forums Guru Joined: 25 Mar 2005 Posts: 512

Valenti Alessandro <avalenti@unimo.it> writes:

Valenti Alessandro · *nix forums beginner Joined: 23 Feb 2006 Posts: 2

Dear all,
I'm experiencing a strange behaviour using standard unix processes. I
was working on a simple example for my students as to show them what
happens when You perform concurrent read operation from two different
processes (child and father) on a file opened before of the fork().

This should be, at least in my intentions, a trivial example about "how
to not use" file descriptors" by showing to my students that if the
child reads some character from a file, then the same characters will
not be read from the father and vice versa.
When I start running the executable on a medium sized file (e.g.
/bin/bash), I've seen that the sum of the number of read characters does
not match the file size but it is sometimes a little bigger on Solaris
or very greater on Linux 2.4 and 2.6.

Here my trivial code:

/* file: es71.c
* job: uso della fork
*/
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
char msg[256];
int fd;
int main(int argc, char **argv) {
pid_t fr; /* fork return value */
int st; /* spazio per l'exit value */
int count; /* contatore di read */
char ch; /* spazio per la read */
fd=open(argv[1],O_RDONLY);
if (fd<0) return(-1);
fr=fork();
switch (fr) {
case 0: /* figlio */
count=0;
for (; Wink

{
switch (read(fd,&ch,1)) {
case 1:
count++;
break;
case 0:

snprintf(msg,sizeof(msg),"Figlio conta %d\n",count);
write(1,msg,strlen(msg));
return(4); /* exit
value del figlio */
default:

snprintf(msg,sizeof(msg),"Errore figlio");
write(1,msg,strlen(msg));
return(4); /* exit
value del figlio */
}
}
break;
case -1: /* errore, nessun nuovo processo */
snprintf(msg,sizeof(msg),"Errore in fork\n");
write(1,msg,strlen(msg));
break;
default: /* padre */
count=0;
for (; Wink

{
switch (read(fd,&ch,1)) {
case 1:
count++;
break;
case 0:

snprintf(msg,sizeof(msg),"Padre conta %d\n",count);
write(1,msg,strlen(msg));
return(4); /* exit
value del figlio */
default:

snprintf(msg,sizeof(msg),"Errore padre");
write(1,msg,strlen(msg));
return(4); /* exit
value del figlio */
}
}
}
return(0);
}
/* end */

Any opinion should be appreciated.

Google