Discussion :

[disedorgue]

Perso, j'ai des fichiers qui ont par exemple 16 blocs en plus si on calcul par rapport à leur taille réelle...

Ceci se joue à cause de la fragmentation. As-tu essayé d'utiliser debugfs comme par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
debugfs /dev/sdc1 <<_EOF
dump_extents -l "/Wang Dang Doodle.wav"
_EOF

Chez moi, par exemple le fichier avec 16 blocs en plus par rapport à sa taille me donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Level Entries         Logical              Physical Length Flags
 1/ 1   1/ 14      0 -    124  78250624 -  78250748    125 
 1/ 1   2/ 14    125 -   6143  88631239 -  88637257   6019 
 1/ 1   3/ 14   6144 -   8191 101388288 - 101390335   2048 
 1/ 1   4/ 14   8192 -  10239 101535744 - 101537791   2048 
 1/ 1   5/ 14  10240 -  12287 101617664 - 101619711   2048 
 1/ 1   6/ 14  12288 -  14335 103501824 - 103503871   2048 
 1/ 1   7/ 14  14336 -  18431 104091648 - 104095743   4096 
 1/ 1   8/ 14  18432 -  51199 104163328 - 104196095  32768 
 1/ 1   9/ 14  51200 -  83967 104196096 - 104228863  32768 
 1/ 1  10/ 14  83968 - 116735 104228864 - 104261631  32768 
 1/ 1  11/ 14 116736 - 149503 104261632 - 104294399  32768 
 1/ 1  12/ 14 149504 - 182271 104294400 - 104327167  32768 
 1/ 1  13/ 14 182272 - 186367 104327168 - 104331263   4096 
 1/ 1  14/ 14 186368 - 211277 104419328 - 104444237  24910

[Jipété]

Perso, j'ai des fichiers qui ont par exemple 16 blocs en plus si on calcule par rapport à leur taille réelle...

Et encore, tu n'as pas précisé si les blocs étaient de 512, 1024 ou 4096 octets,

Ceci se joue à cause de la fragmentation. As-tu essayé d'utiliser debugfs

Je ne connaissais pas cet outil, j'ai fait man debugfs et j'ai pleuré un grand coup,

Bon, le mieux étant l'ennemi du bien, je crois que je vais en rester là.

L'idée de base était de récupérer l'espace libre exact d'une partoche, pour pouvoir y créer par programmation des disques virtuels statiques de grande taille.
Si l'espace remonté par le champ f_bavail de la structure statvfs est toujours supérieur (ou égal, par une sacrée coïncidence !) à la réalité, on va donc dire que dans tous les cas ça ira.

Merci à tous,


Ah, pour les curieux (compil sous geany : F8 puis F9) :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/* file mydf.c -- jipété, déc. 2018 */
 
/* http://www.linuxquestions.org/questions/programming-9/find-dir-space-419927/#post2126437
 
 mettre ce define sinon erreur EOVERFLOW si fichier > 2,147 Gb
 
 vient de config.h de coreutils */
/* Number of bits in a file offset, on hosts where this is settable. */
#define _FILE_OFFSET_BITS 64
/* oblige à rajouter un casting (long long) et modif lu -> llu */
 
#include <sys/types.h>
#include <sys/statvfs.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h> // sync
 
int main (int nb_args, char * args[])
{
  long long total, occup, libre;
	struct statvfs sbuf;
 
	if (nb_args != 2) {
		 fprintf (stderr, "syntaxe : %s <fichier> ou <dossier>\n", args[0]);
		 exit (1);
	}
 
  sync();
 
  if (statvfs(args[1], &sbuf) < 0) {
     fprintf (stderr, "Erreur en récupérant les informations de %s\n", args[1]);
     exit(-1);
  }
/*  
  printf("mode 'df -B1':\n");
  //printf("Espace total : %15llu %s\n", (long long) sbuf.f_frsize *  sbuf.f_blocks, " = df 1B-blocks");
  printf("Espace used  : %15llu %s\n", (long long) sbuf.f_frsize * (sbuf.f_blocks - sbuf.f_bfree), " = df Util.");
  printf("Espace dispo : %15llu %s\n", (long long) sbuf.f_frsize *  sbuf.f_bavail, " = df Disponible, bavail");
  printf("nouveau total: %15llu %s\n", (long long) sbuf.f_frsize * (sbuf.f_blocks - sbuf.f_bfree + sbuf.f_bavail), " = blocks-bfree+bavail (= Util.+Dispo)");
  printf("Espace libre : %15llu %s\n", (long long) sbuf.f_frsize *  sbuf.f_bfree, " = bfree, tune2fs Free blocks");
  printf("libre - dispo= %15llu %s\n", (long long) sbuf.f_frsize * (sbuf.f_bfree - sbuf.f_bavail), " = bfree - bavail, tune2fs Reserved block count");
//netbsd    printf("libre - dispo= %15llu %s\n", (long long) sbuf.f_frsize * (sbuf.f_bresvd), " = f_bresvd, tune2fs Reserved block count");
  printf("\n"); 
*/  
  total = sbuf.f_frsize * (sbuf.f_blocks - sbuf.f_bfree + sbuf.f_bavail);
  occup = sbuf.f_frsize * (sbuf.f_blocks - sbuf.f_bfree);
  libre = sbuf.f_frsize *  sbuf.f_bavail;
  printf("Espace gnd total |         utilisé |      disponible | (en octets)\n");
  printf("%16llu  %16llu  %16llu \n", total, occup, libre);
 
/* sortie (dossier '.') :
Espace gnd total |         utilisé |      disponible | (en octets)
     83953655808       31480061952       52473593856 
     
   et pour récupérer les champs par script :
   # /datas/Coding/C/stat_work/mydf . | awk 'NR==2 {print $1}'
   83953655808
   # /datas/Coding/C/stat_work/mydf . | awk 'NR==2 {print $2}'
   31480094720
   # /datas/Coding/C/stat_work/mydf . | awk 'NR==2 {print $3}'
   52473561088
 */
    /* https://stackoverflow.com/questions/4965355/converting-statvfs-to-percentage-free-correctly
     * SIMUL -- les champs commençant par "f_" viennent de la structure statvfs
     *  les deux autres sont calculés : 
     *  USED = f_blocks - f_bfree (= df Util.[isé]), 
     *  Rfr = f_bfree - f_bavail
     *
     * |<--------------------- f_blocks 100------------------------->|
     *                 |<---------------- f_bfree 60---------------->|
     *
     * ---------------------------------------------------------------
     * | USED  40      | f_bavail  35            | Resrv for root 25 |
     * ---------------------------------------------------------------
     *
     * Rfr = 60 -35 = 25
     * nouveau total = 100-60+35 = 75 --> = 100-25 = used + bavail = 40+35 = 75
     */
 
    return (0);
}

[Jipété]

Bonsoir,

j'ai fini, normalement.

J'ai appelé ça stat4pascal car c'est prévu pour être appelé depuis un prog Lazarus, qui s'appuie sur FreePascal.

Ce dernier proposant une version de stat minimaliste, qui était à la limite de l'inutilisable, j'ai donc bricolé ce petit binaire de même pas 7 ko, qui me donne exactement ce que je veux, basé sur le croquis déjà proposé et à peine amélioré (ai rajouté une ligne, "utilisable") :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
https://stackoverflow.com/questions/4965355/converting-statvfs-to-percentage-free-correctly
 
  |<--------------------- f_blocks ----------------------------->|
  ----------------------------------------------------------------
  | USED        | f_bavail                  | Resrvd for root fs |
  ----------------------------------------------------------------
                |<------------------ f_bfree ------------------->|
  |<------------- utilisable -------------->|

Et donc la sortie ressemble à ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
# ./stat4pascal stat4pascal.c
Taille optimale des blocs   : 4096
Grand total                 :     876093894656 octets
Espace réservé pour le fs   :      44509847552 octets
Taille totale utilisable    :     831584047104 octets
Espace utilisé              :     763911974912 octets
Espace disponible           :      67672072192 octets

On notera que la ligne 3 - la ligne 4 = la ligne 5 et que
la ligne 6 + la ligne 7 = aussi la ligne 5, ce qui me rend très heureux.

Et un switch -p (p pour Pascal, vous l'aviez compris) sort tout sur une ligne sans textes superflus, très facile à récupérer depuis l'ihm Lazarus.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
# ./stat4pascal stat4pascal.c -p
4096 876093894656 44509847552 831584047104 763911974912 67672072192

Cadeau (c'est bientôt Noël) :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/* 
  jipété, déc. 2018
 
  compil sous Geany : F8 puis F9
 
  mettre ce define *AVANT* les include's, sinon gcc pas content
  et erreur EOVERFLOW si fichier > 2,147 Gb
  vient de coreutils-version/lib/config.h, rajouté (long long) et modifié lu --> llu
*/
#define _FILE_OFFSET_BITS 64
 
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h> // sync
#include <sys/statfs.h>
 
int main(int args, char * argv[]){
    struct statfs stat_fs;
    int bsize;
    long long grdtotal, reserved, usable, used, dispo;
 
    if (args < 2) {
        fprintf (stderr, "syntaxe : %s <fichier> [-p]\n ", argv[0]);
        exit (1);
    }
 
    sync();
 
    if (statfs (argv[1], &stat_fs) != 0) { exit (errno); }
 
    // données utiles genre 'df -B1 fichier' 
    bsize    = stat_fs.f_bsize;
    grdtotal = (long long)   stat_fs.f_blocks * bsize;
    used     = (long long)  (stat_fs.f_blocks - stat_fs.f_bfree)  * bsize;
    reserved = (long long) ((stat_fs.f_blocks - stat_fs.f_bavail) * bsize) - used;
    dispo    = (long long)   stat_fs.f_bavail * bsize;
    usable   = (long long)   dispo + used;
 
 
    if (argv[2] != NULL) {
        if (argv[2] [0] == '-') {
            if (argv[2] [1] == 'p') {
                printf("%d %llu %llu %llu %llu %llu\n", bsize, grdtotal, reserved, usable, used, dispo); 
            }
        }
    } else {
        fprintf (stdout,   "Taille optimale des blocs   : %d\n", bsize);
        fprintf (stdout,   "Grand total                 : %16llu octets\n", grdtotal);
        fprintf (stdout,   "Espace réservé pour le fs   : %16llu octets\n", reserved);
        fprintf (stdout,   "Taille totale utilisable    : %16llu octets\n", usable);
        fprintf (stdout,   "Espace utilisé              : %16llu octets\n", used);    
        fprintf (stdout,   "Espace disponible           : %16llu octets\n", dispo);   // = df -B1 "Dispo"
    }
    return 0;
}

Et au plus je regarde tout ça, au plus je me dis que le comportement par défaut devrait être la sortie brute sur une ligne, et pour avoir les détails, un switch -i comme interactif.
Je vous laisse faire la modif.