Race condition not seen while two scripts write to a same file

Question

I have two scripts running parallelly and they are echoing to the same file. One script is echoing +++++++++++++++ to the file while the other script is echoing =========== to the file.

Below is the first script

#!/bin/bash
while [ 1==1 ];
do
    echo "+++++++++++++++" >> log.txt
    # commands
done

Below is the second script

#!/bin/bash
while [ 1==1 ];
do
    echo "===========" >> log.txt
    # commands
done

The log.txt file has around 1400000 lines printed and not a single line has jumbled case like ++== or something like that?

Does Linux prevent this kind of jumbling from happening and if it does then how and why ?

Answer 1

Simply, the echo command triggers one write syscall which is atomic.

Note that write doesn’t guarantee to write all bytes it is given, but in this case (few data), it does.

Then in theory write(fd, buffer, n) can write less than n bytes and return the actual written number of written bytes to enable the program to write bytes at buffer+n.

Such a thing may happen with a pipe since the pipe doesn’t have an infinite capacity.

From write(2)

If the file was open(2)ed with O_APPEND, the file offset is first set to the end of the file before writing. The adjustment of the file offset and the write operation are performed as an atomic step.

According to POSIX.1, if count is greater than SSIZE_MAX, the result is implementation-defined; see NOTES for the upper limit on Linux.

Answer 2

You can try out the limit with this:

#!/bin/bash                                                                                                           

outer() {
    rm log.txt
    inner() {
        a=$(perl -e 'print "'$1'"x'$2'')
        while [ 1==1 ];
        do
            echo $a >> log.txt
            # commands                                                                                                
        done
    }
    export -f inner
    timeout 5 bash -c "inner '-' $1" &
    timeout 5 bash -c "inner '+' $1" &
    wait
    sort -u log.txt
}

replace_repeats() {
    # Replace                                                                                                         
    #   ---                                                                                                           
    # with                                                                                                            
    #  -3                                                                                                             
    perl -pe 's/((.)\2+)/"$2".length$1/e'
}
# This is OK                                                                                                          
outer 10 | replace_repeats
outer 100 | replace_repeats
outer 1000 | replace_repeats
outer 4095 | replace_repeats
# This breaks.                                                                                                        
# It should give:                                                                                                     
# +4096                                                                                                               
# -4096                                                                                                               
outer 4096 | replace_repeats