Pourquoi flock ne demande pas un FILE* ?

int flock(int fd, int operation);

Sujet résolu

16 juin 2007 à 21:24:02

Hello tout le monde.

Voila je me demande pourquoi flock attend un int en premier paramètre alors que fopen attend un FILE*.
Du coup, je vois pas trop comment l'utiliser, j'ai fait ceci

FILE * pFile = fopen(tempName, "w+");
int fl = flock(pFile, LOCK_EX);
if(fl != 0) return fl;

Mais c++ plante à la compil.

Je vois pas trop commant utiliser flock alors

EDIT : J'ai été demandé à man, et j'ai trouvé un truc, je suis obligé d'utiliser fdopen ?

Antartika

17 juin 2007 à 9:06:22

Je dirais plutot open : http://www.linux-kheops.com/doc/man/manfr/man-html-0.9/man2/open.2.html

gouttegd

17 juin 2007 à 9:55:22

Salut,

Citation : utb_diablo

Voila je me demande pourquoi flock attend un int en premier paramètre alors que fopen attend un FILE*.

Parce que fopen (3) et, de manière générale, toutes les fonctions manipulant des FILE * sont des fonctions de la bibliothèque standard, alors que flock (2) est un appel-système, indépendant de la bibliothèque C. Comme tous les appels-systèmes liés aux fichiers, ils manipulent ceux-ci par l'intermédiaire de leur descripteur de fichier.

Deux possibilités :

- ne pas utiliser les fonctions de flux de la bibliothèque C, et utiliser directement les appels-systèmes. Donc, comme te le suggère Antartika, ouvrir le fichier avec open (2).

- utiliser fileno (3), qui renvoie le descripteur de fichier associé à un flux.

gkaam

17 juin 2007 à 13:18:35

Ah, oui, enfait j'avais choisi trouver la solution d'utiliser open hier soir, mais je n'ai pas eu le temps d'éditer mon message.

Donc, maintenant, mon code se compile bien, mais je ne suis pas sur que flock marche correctment.
En effet, alors que le fichier est supposé être verouiller, j'ai quand meme réussi à l'éditer pendant l'exécution de mon programme, alors que flock est actif.

Donc, je me dis que,
- soit j'utilise mal flock
- soit flock ne sert pas à faire ce que je veux faire.

Mon code

int pFile = open(tempName, O_WRONLY);
flock(pFile, LOCK_SH);

//Actions sur le fichier

flock(pFile, LOCK_UN);
close(pFile);

Ce que je veux, c'est que pendant l'exécution des actions sur le fichier, celui-ci soit innaccessible autant en lecture, qu'en écriture. Un peu comme quand j'essaie d'accéder au fichier /var/lib/mysql/mysqld.sock

[root@Diablo:~]# vi /var/lib/mysql/mysqld.sock
"/var/lib/mysql/mysqld.sock" [Permission refusée]
[root@Diablo:~]#

gouttegd

17 juin 2007 à 16:32:34

Apparemment, par défaut les verrous de fichiers ne sont que des « advisory locks, » ce qui signifie en substance qu'il est tout à fait possible de passer outre ces verrous.

Pour utiliser des « mandatory locks » (des verrous qu'aucun processus ne peut ignorer), regarde du côté du fichier mandatory.txt dans la documentation fournie avec les sources du noyau Linux.

gkaam

17 juin 2007 à 22:15:51

J'arrive pas à utiliser write :honte:

Ca me donne un truc zarb, avec des x00 et des x0a à chaque debut de ligne.

Avec vi

#!/bin/bash
^@txtxt="Loading 'test' : "^@
^@tx    for((X=0;X<100;X++))
^@tx    do
^@tx            echo -en "\r$txt-"^@
^@tx            sleep 0.5
^@tx            echo -en "\r$txt\\"^@           ec
^@tx            sleep 0.5
^@tx            echo -en "\r$txt|"^@
^@tx            sleep 0.5
^@tx            echo -en "\r$txt/"^@    d
^@tx            sleep 0.5
^@tx    done
^@tx

Avec bpe

0x00000000   23 21 2F 62 69 6E 2F 62 61 73 68 0A 00 74 78 74   #!/bin/bash..txt
0x00000010   78 74 3D 22 4C 6F 61 64 69 6E 67 20 27 74 65 73   xt="Loading 'tes
0x00000020   74 27 20 3A 20 22 00 09 0A 00 74 78 09 66 6F 72   t' : "....tx.for
0x00000030   28 28 58 3D 30 3B 58 3C 31 30 30 3B 58 2B 2B 29   ((X=0;X<100;X++)
0x00000040   29 0A 00 74 78 09 64 6F 0A 00 74 78 09 09 65 63   )..tx.do..tx..ec
0x00000050   68 6F 20 2D 65 6E 20 22 5C 72 24 74 78 74 2D 22   ho -en "\r$txt-"
0x00000060   00 09 09 0A 00 74 78 09 09 73 6C 65 65 70 20 30   .....tx..sleep 0
0x00000070   2E 35 0A 00 74 78 09 09 65 63 68 6F 20 2D 65 6E   .5..tx..echo -en
0x00000080   20 22 5C 72 24 74 78 74 5C 5C 22 00 09 09 65 63    "\r$txt\\"...ec
0x00000090   0A 00 74 78 09 09 73 6C 65 65 70 20 30 2E 35 0A   ..tx..sleep 0.5.
0x000000A0   00 74 78 09 09 65 63 68 6F 20 2D 65 6E 20 22 5C   .tx..echo -en "\
0x000000B0   72 24 74 78 74 7C 22 00 09 09 0A 00 74 78 09 09   r$txt|".....tx..
0x000000C0   73 6C 65 65 70 20 30 2E 35 0A 00 74 78 09 09 65   sleep 0.5..tx..e
0x000000D0   63 68 6F 20 2D 65 6E 20 22 5C 72 24 74 78 74 2F   cho -en "\r$txt/
0x000000E0   22 00 09 64 0A 00 74 78 09 09 73 6C 65 65 70 20   "..d..tx..sleep
0x000000F0   30 2E 35 0A 00 74 78 09 64 6F 6E 65 0A 00 74 78   0.5..tx.done..tx

Mon blem vient surement du fait que j'ai du mal avec le prototype de write

Citation : man 2 write

size_t write(int fd, const void *buf, size_t count);

Je met quoi dans size_t count ?
Dans mon code, je met

//line => string contenant la caine a ecrire
line.size() * sizeof(char);

Mais apparament, ce ne marche pas

EDIT :

Citation : Pas de titre

utiliser fileno (3), qui renvoie le descripteur de fichier associé à un flux.

Bon bah je crois que je vais essayer cette solution

gouttegd

17 juin 2007 à 22:59:39

Hm, bizarre, ce que tu obtiens.

Le x0A, c'est normal, c'est le caractère « nouvelle ligne. » Mais le caractère nul (x00) qui le suit n'a normalement aucune raison d'être là...

À moins qu'il ne s'agisse du caractère nul de terminaison de la chaîne. Mais ce serait quand même bizarre, puisque line.size() est censée ne pas tenir compte de ce caractère (tout comme la fonction strlen en C). Je crains de ne pas suffisamment connaître la bibliothèque C++ pour comprendre exactement ce qui se passe. Essaie quand même de passer line.size() - 1 à write().

gkaam

18 juin 2007 à 17:25:12

J'ai fini par résoudre mon probleme d'écriture, j'utilise fopen, fprintf, et fclose avant d'utiliser open
mais je bute toujours sur le verouillage de mon fichier.

En gros:

//Ouverture du fichier avec fopen
FILE * pFile = fopen(tempName, "w+");

//Ecriture avec fprintf
fprintf (pFile, line);

//Fermeture du fichier avec fclose
fclose(pFile);

//Le fichier est bien édité, je veux le verouiller
//On l'ouvre
int dFile = open(tempName, O_RDONLY);

//On pose le verrou
flock(dFile, LOCK_SH);

//On effectue des actions sur le contenu du fichier
/*
[...]
*/

//On le ferme
flock(dFile, LOCK_UN);
close(dFile);

Sauf que pendant l'exécution des actions, le fichier est "readable" par les autres processus, ce que je ne veux pas !

Si ca ne vous ennuie pas, on continue le sujet ici -> new sujet