In what order does user space code execute?

Question

Hi I'm writting a char driver that reads and writes to a particular device. Since I'm a noob, this is a very simple and easy char drive that only utilizes the simplest of protocols such as open, read, write, and release. To test my driver I am using the following program ... bellow is the source for my user-space program.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <signal.h>
#include <poll.h>

int main(void){
int num;
char *buff;
FILE *fd = fopen("/dev/hi","a+");
num = fprintf(fd,"this is sentence 1 !!");
num = fprintf(fd,"this is sentence 2 !!");
num = fprintf(fd,"this is sentence 3 !!");
num = fprintf(fd,"this is sentence 4 !!");
num = fprintf(fd,"this is sentence 5 !!");
buff = malloc(sizeof(char) * num+1);
fread(buff,sizeof(char),num+1,fd);
printf("%s\n",buff);
fread(buff,sizeof(char),num+1,fd);
printf("%s\n",buff);
fread(buff,sizeof(char),num+1,fd);
printf("%s\n",buff);
fread(buff,sizeof(char),num+1,fd);
printf("%s\n",buff);
fread(buff,sizeof(char),num+1,fd);
printf("%s\n",buff);
free(buff);
close(fd);
return 0;
}

Now its not important how my driver works but, in what order that I call my read and write methods. Ideally, it would be nice if the driver was being written to in the order that I've written my code and read from in the order that I've wrote my code. However I've noticed that if I have written my code like ...

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <signal.h>
#include <poll.h>

int main(void){
int num;
char *buff;
FILE *fd = fopen("/dev/hi","w");
num = fprintf(fd,"this is sentence 1 !!");
num = fprintf(fd,"this is sentence 2 !!");
num = fprintf(fd,"this is sentence 3 !!");
num = fprintf(fd,"this is sentence 4 !!");
num = fprintf(fd,"this is sentence 5 !!");
    close(fd);
    fd = fopen("/dev/hi","r");
buff = malloc(sizeof(char) * num+1);
fread(buff,sizeof(char),num+1,fd);
printf("%s\n",buff);
fread(buff,sizeof(char),num+1,fd);
printf("%s\n",buff);
fread(buff,sizeof(char),num+1,fd);
printf("%s\n",buff);
fread(buff,sizeof(char),num+1,fd);
printf("%s\n",buff);
fread(buff,sizeof(char),num+1,fd);
printf("%s\n",buff);
free(buff);
close(fd);
return 0;
}

I notice that fprintf() only writes when I close the file descriptor and worst yet, executes after I read from my device. Of course I want to write to my device and then read from it but it doesn't happen in order that. This gives me the impression that many things in user-space execute at the same time which baffles me. How do I know the order of which my device functions get called when dealing with user space. Sorry if this seems vague, I'll elaborate on anything that is mirky.

Thanks for any replies!!

I would use the system call `write`, not the `fprintf` or `fputs` from the standard library. Or at least call `fflush` very often. — Basile Starynkevitch, Mar 27 '12 at 05:37

score 4 · Accepted Answer · answered Mar 27 '12 at 05:41

4

Your writes to 'fd' are being cached and only written to the device driver after you close it. This is normal and done to reduce the number of system calls.

If you really need each write to be sent to the device try adding a call to fsync() after each write. Alternatively, since it's a char driver it is most likely being line buffered, try adding a '\n' at the end of each line.

answered Mar 27 '12 at 05:41

Kristof Provost

26,018
2
26
28

2

The fsync wont do it, as he uses FILE* (and calls them fds ;-), but fflush should do it. – flolo Mar 27 '12 at 06:03
I think adding newlines would prevent the buffering too. – ugoren Mar 28 '12 at 14:01

score 2 · Answer 2 · answered Mar 27 '12 at 05:42

The code in user-space is executed in order (except you work explicit with parallelism or some other concept that mixes up the order).

I suspect that, what you interpret as "mirky" comes from the buffering of the fprintf.

You can flush the buffers by calling fflush(fd) after each fprintf. And you can disable it complete when you call beforehand setbuf(fd, NULL).

score 1 · Answer 3 · answered Mar 27 '12 at 05:41

1

Look into fflush or fsync to flush out buffered output, and commit writes before doing your reads.

answered Mar 27 '12 at 05:41

abelenky

63,815
23
109
159

Note that fflush takes a FILE* as argument, not a file descriptor. He'll want fsync instead. – Kristof Provost Mar 27 '12 at 05:42
1

@KristofProvost: no fflush is right, the confusion comes from the fact that the original poster uses a FILE* and calls it fd. – flolo Mar 27 '12 at 06:02
Oh right you are. I really should know better than to expect a variable called fd to contain a file descriptor. – Kristof Provost Mar 27 '12 at 06:09

Thomas Padron-McCarthy · Answer 4 · 2012-03-27T06:10:29.350

As others have said, it's about buffering, and not some strange execution order effects. Use fflush to flush the stream and actually write the data, or use the lower-level open, write etc calls.

But another thing that I think should be pointed out:

You seem to have some confusion going on about streams and file descriptors. You call your FILE* "fd", and then say it's a file descriptor. But a FILE* is a stream, not a file descriptor. A file descriptor is a lower-level thing, which is hidden by the stdio library.

Linux provides file descriptors, which you get by calling open, and then you can use write to write to that file descriptor, and close it with close. The stdio library adds another level, with its own calls (fopen, fwrite, fprintf, fclose etc), and its own buffering, on top of the file descriptors.

Also note that you should use fclose to close the stream, not close.

In what order does user space code execute?

4 Answers4