write() performs differently in two situations - c

Question

So I was required to solve this exercise:
This exercise is designed to demonstrate why the atomicity guaranteed by opening a file with the O_APPEND flag is necessary. Write a program that takes up to three command-line arguments:
$ atomic_append filename num-bytes [x]
This file should open the specified filename (creating it if necessary) and append num-bytes bytes to the file by using write() to write a byte at a time. By default, the program should open the file with the O_APPEND flag, but if a third command-line argument (x) is supplied, then the O_APPEND flag should be omitted, and instead the program should perform an lseek(fd, 0, SEEK_END) call before each write(). Run two instances of this program at the same time without the x argument to write 1 million bytes to the same file:
$ atomic_append f1 1000000 & atomic_append f1 1000000
Repeat the same steps, writing to a different file, but this time specifying the x argument:
$ atomic_append f2 1000000 x & atomic_append f2 1000000 x
List the sizes of the files f1 and f2 using ls –l and explain the difference.
So this is what I wrote:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
int main(int argc, char *argv[]) {
int fd, flags, num_bytes;
if (argc < 3 || strcmp(argv[1], "--help") == 0) {
printf("Usage: %s filename num-bytes [x]\n", argv[0]);
return 1;
}
num_bytes = atoi(argv[2]);
if (argc == 4 && strcmp(argv[3], "x") == 0) {
fd = open(argv[1], O_CREAT | O_WRONLY, 0666);
if (fd == -1)
perror("open");
while (num_bytes-- > 0) {
lseek(fd, 0, SEEK_END);
write(fd, "a", 1);
}
if (close(fd) == -1)
perror("close");
}
else {
fd = open(argv[1], O_CREAT | O_APPEND | O_WRONLY, 0666);
if (fd == -1)
perror("open");
while(num_bytes-- > 0)
write(fd, "a", 1);
if (close(fd) == -1)
perror("close");
}
return 0;
}
Now after I ran it as required:
abhinav#cr33p:~/System/5$ ./a.out f1 1000000 & ./a.out f1 1000000
[1] 4335
[1]+ Done ./a.out f1 1000000
abhinav#cr33p:~/System/5$ ./a.out f2 1000000 x & ./a.out f2 1000000 x
[1] 4352
[1]+ Done ./a.out f2 1000000 x
abhinav#cr33p:~/System/5$ ls f1 f2
f1 f2
abhinav#cr33p:~/System/5$ ls -l f*
-rw-rw-r-- 1 abhinav abhinav 2000000 Dec 10 16:23 f1
-rw-rw-r-- 1 abhinav abhinav 1000593 Dec 10 16:24 f2
Definitely, there is a difference in file sizes I am somewhat unable to clearly understand why? I searched and found somewhere this explanation:
The sizes were definitely different:
-rw------- 1 posborne posborne 1272426 2012-01-15 21:31 test2.txt
-rw------- 1 posborne posborne 2000000 2012-01-15 21:29 test.txt
Where test2.txt was run without O_APPEND. test2.txt is short by the
number of times (or bytes as a result of times) that seeking to the
end of the file did not happen at the same time as the write (quite
frequently).
But it does not seem to make any sense. So why the difference in sizes?

Answer 1

This code, run on a file not opened with O_APPEND:
while (num_bytes-- > 0) {
lseek(fd, 0, SEEK_END);
write(fd, "a", 1);
writes to the location of the end of the file as it was when the call to lseek() was made. The end of the file can change in the time between the lseek() and write() call.
This code, on a file that was opened with O_APPEND:
while(num_bytes-- > 0)
write(fd, "a", 1);
is guaranteed by the standard behavior of write()'ing to a file opened with O_APPEND to write to the end of the file no matter where that end is.
That's the entire point of the O_APPEND flag - lseek() then write() doesn't work.