Discussion :

[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.

[Jipété]

Yop !

Toute petite customisation de la sortie :

Code :

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

1
2
3
4
5
6
7
# ./statfs4pascal . -i
Blocs, taille optimum :             4096 octets
Espace total          :     876093894656 octets
 | zone allouée au fs :      44509847552 octets
 | espace utilisable  :     831584047104 octets
    | utilisé         :     763911966720 octets
    | disponible      :      67672080384 octets

je trouve ça plus choupinet,

Et comme dit hier après avoir posté, je remplace le switch -p par -i (comme "interactif") avec fonctionnement inversé (testé sous Lazarus, c'est plus mieux cool ) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    if (argv[2] == NULL) {
         printf("%d %llu %llu %llu %llu %llu\n", bsize, grdtotal, reserved, usable, used, dispo); 
    } else {
    if (argv[2] [0] == '-') {
        if (argv[2] [1] == 'i') {
            fprintf (stdout,   "Blocs, taille optimum : %16d octets\n"  , bsize);
            fprintf (stdout,   "Espace total          : %16llu octets\n", grdtotal);
            fprintf (stdout,   " | zone allouée au fs : %16llu octets\n", reserved);
            fprintf (stdout,   " | espace utilisable  : %16llu octets\n", usable);
            fprintf (stdout,   "    | utilisé         : %16llu octets\n", used);    
            fprintf (stdout,   "    | disponible      : %16llu octets\n", dispo);   // = df -B1 "Dispo"
            } 
        }
    }

Bon trolldi,

EDIT : et l'ihm de test donne ça, trop

[Jipété]

Bonjour,

je ne résiste pas au plaisir de vous proposer la version Bash pur (qui appelle df, quand même -- faut bien avoir les infos), qui affiche exactement les mêmes résultats que la version en C.

Ça tombe bien, j'avais besoin de ces valeurs dans un script.

Code :

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

1
2
3
4
5
Espace total          :      88453705728 octets
 | zone allouée au fs :       4500049920 octets
 | espace utilisable  :      83953655808 octets
    | utilisé         :      31676510208 octets
    | disponible      :      52277145600 octets

Code bash :

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
#!/bin/bash
 
if [ -z "$1" ]; then
  echo "Usage : $(basename $0) chemin_valide"
  exit
fi
# ici il faudrait vérifier que $1 est vraiment un chemin valide, 
# sinon insulter grave l'utilisateur inconscient/insouciant.
# je vous laisse gérer ce point...
 
# récupère les infos utiles en virant la ligne d'en-tête
declare -a retourdf=($(df --sync -B1 $1 | awk 'NR==2'))
#echo ${#retourdf[*]} # 6 champs, ça commence à 0
ttal=${retourdf[1]} # total
used=${retourdf[2]} # util.(isé !)
free=${retourdf[3]} # Disponible
 
# 2 calculs
usable=$(($used + $free))
rsrved=$(($ttal - $usable))
 
# sortie mode statfs4pascal :
printf "Espace total          : %16d octets\n" $ttal
printf " | zone allouée au fs : %16d octets\n" $rsrved
printf " | espace utilisable  : %16d octets\n" $usable
printf "    | utilisé         : %16d octets\n" $used
printf "    | disponible      : %16d octets\n" $free

Enjoy !,
et bon dimanche.

EDIt : me demande si la sortie ne serait pas encore plus compréhensible dans l'enchaînement des valeurs comme ça, en ne lisant que la colonne de gauche de haut en bas :

Code :

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

1
2
3
4
5
Espace total          :     116498505728 octets
 - zone allouée au fs :       5924610048 octets
 = espace utilisable  :     110573895680 octets
    = utilisé         :      36397154304 octets
    + disponible      :      74176741376 octets

Vous verrez...

[Jipété]

Salut,

Retour d'utilisation :

Code bash :

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

1
2
3
# récupère les infos utiles en virant la ligne d'en-tête
declare -a retourdf=($(df --sync -B1 $1 | awk 'NR==2'))
...

Des fois ça prend du temps s'il y a plusieurs arborescences à analyser (pour par ex. sortir l'image montrée précédemment), genre dans une boucle.
Il y a un truc à déplacer hors de la boucle :

Code :

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

1
2
3
4
5
6
# avant la boucle
sync
# dans la boucle, s'il y en a une :
# récupère les infos utiles en virant la ligne d'en-tête
declare -a retourdf=($(df -B1 $1 | awk 'NR==2'))
...

Joyeux Noël,

[N_BaH]

version Bash pur (qui appelle df, quand même

et awk

Code bash :

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

1
2
mapfile -s1 -t data < <( df --sync -B1 "$1")
read part ttal used free perc mountP <<<"${data[0]}"

[Jipété]

et awk

Mais je ne suis pas spécialiste...

Code bash :

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

1
2
mapfile -s1 -t data < <( df --sync -B1 "$1")
read part ttal used free perc mountP <<<"${data[0]}"

N'oublie pas d'enlever le --sync pour le reporter avant, car en cas de boucle c'est dur...

Code bash :

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

1
2
3
4
5
# avant l'appel
sync
# dans une fonction, qu'on appellera en lui passant le point de montage à analyser (pour ceux qui en ont plusieurs)
mapfile -s1 -t data < <( df -B1 "$1")
read part ttal used free perc mountP <<<"${data[0]}"