Si tratta di un bug in) chiamate di funzione o del sistema operativo Linux tempo Linux (?

Question

Ho scritto un piccolo programma, che crea i file ad un intervallo di 1 minuto. Ma il momento in cui viene creato il file e ultimo scritto e l'ultima data di modifica del file come indicato dal comando ls differisce di 1 secondo. Il codice e l'output è presentato di seguito. per favore fatemelo sapere dove potrebbe essere il bug?

root@new:/home/srinivas# cat b.c
#include <time.h>
#include <stdio.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
int main ()
{
    int fd;
    int i=0;
    time_t initial_time = time(NULL);
    time_t interval = 60;
    time_t curr_time = time(NULL);

    fd=open ("test1.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    write(fd,"abcd1",5);
    while(1)
    {
        curr_time = time(NULL);
        if(curr_time >= initial_time)
        {
            if(i==0)
            {
                close(fd);
                printf("\ntime before test2.txt fileopen= %d\n", time(NULL));
                fd=open ("test2.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
                write(fd,"abcd2",5);
                printf("time after test2.txt filewrite= %d\n", time(NULL));
                system("ls -l --time-style=+%s test2.txt");
                initial_time += interval;
                i=1;
            }
            else
            {
                close(fd);
                printf("\ntime before test1.txt fileopen= %d\n", time(NULL));
                fd=open ("test1.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
                write(fd,"abcd1",5);
                printf("time after test1.txt filewrite= %d\n", time(NULL));
                system("ls -l --time-style=+%s test1.txt");
                initial_time += interval;
                i=0;
            }
        }
        usleep(1000);
    }
    return 0;
}
root@new:/home/srinivas# gcc b.c
root@new:/home/srinivas# ./a.out

time before test2.txt fileopen= 1268203133
time after test2.txt filewrite= 1268203133
-rw-r--r-- 1 root root 5 1268203133 test2.txt

time before test1.txt fileopen= 1268203193
time after test1.txt filewrite= 1268203193
-rw-r--r-- 1 root root 5 1268203192 test1.txt

time before test2.txt fileopen= 1268203253
time after test2.txt filewrite= 1268203253
-rw-r--r-- 1 root root 5 1268203252 test2.txt

time before test1.txt fileopen= 1268203313
time after test1.txt filewrite= 1268203313
-rw-r--r-- 1 root root 5 1268203312 test1.txt

time before test2.txt fileopen= 1268203373
time after test2.txt filewrite= 1268203373
-rw-r--r-- 1 root root 5 1268203372 test2.txt

root@new:/home/srinivas# ls -ltr --time-style=+%s
total 40
-rwxrwxrwx  1 root     root      1095 1268202457 b.c
-rwxr-xr-x  1 root     root     10300 1268202459 a.out
-rw-r--r--  1 root     root         5 1268203312 test1.txt
-rw-r--r--  1 root     root         5 1268203372 test2.txt
root@new:/home/srinivas#

Grazie e saluti,

Srinivas

Answer 1

http://www.spinics.net/lists/kernel/msg1008110.html

Answer 2

In primo luogo, v'è un problema nel codice.

• Rimuovere il open() e write() prima del ciclo, che non stanno facendo nulla.
• Spostare la chiamata due close() subito dopo le chiamate write().

Questo farà sì che i dati vengono scritti e il file chiuso prima di guardare la sua data di modifica utilizzando ls. Altrimenti, c'è un ritardo di 1 secondo tra la scrittura () e la chiusura (). Dal momento che si sta scrivendo solo 5 byte, otterrà tamponata. Così, quando si sta controllando il tempo dopo la chiamata write (), non si ha garanzia che i dati sono stati ancora scritto, in modo che il file non sia stato modificato, che può avvitare i risultati.

In secondo luogo, non si può assumere un ritardo di 1 secondo, perché time() e ls rapporto a 1 seconda differenza. Dal momento che un secondo è l'unità più piccola, si dovrebbe aspettare differenza di arrotondamento. E dal momento che si sta utilizzando due metodi diversi per ottenere il numero di secondi dal Epoch, possono usare diverse regole di arrotondamento, che saranno facilmente tradursi in una seconda differenza 1. Se a questo aggiungiamo che il filesystem che immagazzinano la data di modifica, in realtà hanno tre diversi attori che possono influenzare i risultati.

Inoltre, se si guarda in modo corretto al vostro risultato, si vedrà che la sua time() che indicano un secondo dopo che ls. Quindi, non si dispone di un ritardo a tutti, si sta andando indietro nel tempo! La differenza di arrotondamento è la ragione più probabile per questo.

Quindi, non ci sono bug nel tempo Linux () funzione o Linux OS chiamate.

Answer 3

• la scrittura in un file richiede un certo tempo.
• chiamata alla funzione time () richiede un certo tempo
• l'esecuzione della logica della funzione time () richiede un certo tempo.

Tutto ciò si traduce in ritardo 1 sec non ..its affatto un bug!