C - Memory Mapping with Multiple Processes - c

Question

I have an assignment requiring me to write a multi-processed program that works with a memory-mapped file containing a string of characters. After the parent process maps the file to memory, it spawns 2 children processes to modify the file. Child 1 outputs the contents of the file, converts the file's contents to their upper case equivalent, then outputs the file's new contents. Child 2 waits 1 second to let child 1 finish, outputs the file's contents, removes any hyphen " - " characters, then outputs the file's new contents. My problem with both child processes is that after first displaying the file's contents, the processes attempt to modify the contents of the file, but neither child outputs the file's new contents. I get no errors when running or compiling so I can't find out what the problem is. And of course, I'm new to memory mapping so feel free to let me know what I'm doing wrong. Here is my source code:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <signal.h>
#include <string.h>
int main (int argc, char *argv[]) {
struct stat buf;
int fd, length, status, i, j, k;
char *mm_file;
char *string = "this is a lowercase-sentence.";
length = strlen(string);
fd = open(argv[1], O_CREAT | O_RDWR, 0666); //Creates file with name given at command line
write(fd, string, strlen(string)); //Writes the string to be modified to the file
fstat(fd, &buf); //used to determine the size of the file
//Establishes the mapping
if ((mm_file = mmap(0, (size_t) buf.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)) == (caddr_t) - 1) {
fprintf(stderr, "mmap call fails\n");
}
//Initializes child processes
pid_t MC0;
pid_t MC1;
//Creates series of child processes which share the same parent ID
if((MC0 = fork()) == 0) {
printf("Child 1 %d reads: \n %s\n", getpid(), mm_file);
//{convert file content to uppercase string};
for (i = 0; i < length; i++) {
string[i] = toupper(string[i]);
}
//sync the new contents to the file
msync(0, (size_t) buf.st_size, MS_SYNC);
printf("Child 1 %d reads again: \n %s\n", getpid(), mm_file);
exit(EXIT_SUCCESS); //Exits process
} else if ((MC1 = fork()) == 0) {
sleep(1); //so that child 2 will perform its task after child 1 finishes
("Child 2 %d reads: \n %s\n", getpid(), mm_file);
//{remove hyphens}
for (j = 0; j < length; i++) {
if (string[i] == '-') {
string[i] = ' ';
}
}
//sync the new contents to the file
msync(0, (size_t) buf.st_size, MS_SYNC);
printf("Child 2 %d reads again: \n %s\n", getpid(), mm_file);
exit(EXIT_SUCCESS); //Exits process
}
// Waits for all child processes to finish before continuing.
waitpid(MC0, &status, 0);
waitpid(MC1, &status, 0);
return 0;
}
Then my output is as follows:
**virtual-machine:~$** ./testt file
Child 1 3404 reads:
this is a lowercase-sentence.
Child 2 3405 reads:
this is a lowercase-sentence.
All child processes have finished. Now exiting program.
**virtual-machine:~$**
But my desired result would be:
**virtual-machine:~$** ./testt file
Child 1 3404 reads:
this is a lowercase-sentence.
Child 1 3404 reads again:
THIS IS A LOWERCASE-SENTENCE.
Child 2 3405 reads:
THIS IS A LOWERCASE-SENTENCE.
Child 2 3405 reads:
THIS IS A LOWERCASE SENTENCE.
All child processes have finished. Now exiting program.
**virtual-machine:~$**
Any help is greatly appreciated.

Answer 1

There are a few errors here. Firstly, you write into the file and then map it into the memory. The mapping is correct, but the writing not. If the string has n characters, you have to write n+1 characters, since strings in C are null-terminated. Now you only have n, so all C string functions will try to access at least one more byte, which is not good. And if that one extra byte is not null (zero), the functions will go even further. In debug more they might be zeroed, but in optimized code usually not. So you have to use
write(fd, string, strlen(string)+1); //Writes the string to be modified to the file
Then you do this:
for (i = 0; i < length; i++) {
string[i] = toupper(string[i]);
}
This only changes the data that is referred by the pointer string, which has nothing to do with the memory mapped file. You should have:
for (i = 0; i < length; i++) {
mm_file[i] = toupper(mm_file[i]);
}
The same is with the second child process.
Also your msync() call is a bit suspect. You give the memory address as 0, which is not within your memory mapped file, so it will not sync the contents. You need to call msync(mm_file, (size_t) buf.st_size, MS_SYNC);
Also, many compilers will put the constant strings into read-only memory, so you might not even be allowed to change the data referred to by string. In this case it seems you are allowed.
Do also remember, that the length of the file is one byte larger than the length of the string, so use the variables correctly. Currently you do, since you sync the file with file length and handle the string with string length.

Answer 2

You have let mem map get in the way of the logic.
To get this working comment out all mem map stuff and just work on the file.
This will show you that neither child reads from the input file, never mind writing new contents to it.
Under some operating systems, Linux being one if you are mixing reads and writes you need a seek between to keep the write and read pointers in the same position. This may have to be fseek(stream, 0,SEEK_CUR);
Child one should be something like
// Lock file here
rewind(file);
printf ("child 1 reads ");
int ch;
while(1){
ch = fgetc(file);
if(ch == EOF) break;
fputc (Ch,stdout );
}
fputc('\n',stdout );
Rewind(file);
while(1){
ch=fgetc (file);
if(Ch == EOF) break;
fseek(file,-1,SEEK_CUR);
fputc (toupper (Ch),file);
fseek(file,0,SEEK_CUR);
}
Rewind ( file);
Printf (" child 1 reads ");
while(1){
ch=fgetc(file);
if(Ch == EOF) break;
fputc (Ch,file) ;
}
// Unlock file here
Because you have multiple processes acting on the same object you have to implement write locking ( exclusive locks).
Read man pages flock(2), fcntl (2) and lockf(3).
These cooperative locks could be implemented as a semaphore.
With out locking both children may try to write to the same character simultaneously, in this example it shouldn't matter as one child does hyphens and the other letters.
Now it's working uncomment your mem map stuff.