Est-ce un bogue dans la fonction temps Linux () ou Linux appels OS?

Question

J'ai écrit un petit programme, qui crée des fichiers à un intervalle de 1 minute. Mais le moment où le fichier est créé et le dernier écrit et la dernière date de modification du fichier comme indiqué par la commande ls diffère de 1 seconde. Le code et la sortie est présenté ci-dessous. s'il vous plaît laissez-moi savoir où pourrait être le 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#

Merci et salutations,

Srinivas

Answer 1

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

Answer 2

Tout d'abord, il y a un problème dans votre code.

• Retirez le open() et write() avant que la boucle, ils ne font rien.
• Déplacer les deux appels close() juste après les appels write().

Cela garantira que les données sont écrites et le fichier fermé avant de regarder son temps de modification à l'aide ls. Sinon, il y a un délai de 1 seconde entre l'écriture () et la fin (). Puisque vous écrivez seulement 5 octets, il se tampon. Donc, quand vous vérifiez le temps après l'écriture () appel, vous avez aucune garantie que les données ont encore été écrit, le fichier peut ne pas avoir été modifié, ce qui peut visser vos résultats.

En second lieu, vous ne pouvez pas assumer un délai de 1 seconde parce que le rapport de time() et ls 1 seconde différence. Puisqu'une seconde est votre plus petite unité, vous devriez vous attendre écart d'arrondi. Et puisque vous utilisez deux méthodes différentes pour obtenir le nombre de secondes depuis Epoch, ils peuvent utiliser différentes règles d'arrondi, ce qui se traduira facilement dans 1 seconde différence. Si l'on ajoute que le système de fichiers qui stockent le temps de modification, vous avez en fait trois acteurs différents qui peuvent influencer vos résultats.

En outre, si vous regardez bien à votre résultat, vous verrez que son time() qui indiquent une seconde plus tard que ls. Donc, vous ne disposez pas d'un retard du tout, vous allez dans le temps! La différence d'arrondi est la raison la plus probable pour cela.

Alors, il n'y a pas de bug dans la fonction du temps Linux () ou Linux OS appelle.

Answer 3

• écrit dans un fichier prend un certain temps.
• appel à la fonction du temps () prend un certain temps
• l'exécution de la logique de la fonction du temps () prend un certain temps.

tous ces résultats dans le délai de 1 sec ..Its pas du tout un bug!