J'ai suivi la mise en place de la commande du (seconde moitié)
introduction
Ceci est une continuation de Dernière fois. Nous continuerons à suivre la mise en œuvre de la commande du.
la revue
Je republierai le du_files () que j'ai vu la dernière fois.
python
/* Recursively print the sizes of the directories (and, if selected, files)
named in FILES, the last entry of which is NULL.
BIT_FLAGS controls how fts works.
Return true if successful. */
static bool
du_files (char **files, int bit_flags)
{
bool ok = true;
if (*files)
{
FTS *fts = xfts_open (files, bit_flags, NULL); //(1)
while (1)
{
FTSENT *ent;
ent = fts_read (fts); //(2)
if (ent == NULL)
{
if (errno != 0)
{
error (0, errno, _("fts_read failed"));
ok = false;
}
break;
}
FTS_CROSS_CHECK (fts);
ok &= process_file (fts, ent); //(3)
}
if (fts_close (fts) != 0)
{
error (0, errno, _("fts_close failed"));
ok = false;
}
}
return ok;
}
Le traitement effectué ici est le suivant.
(1). Récupérez la structure FTS du nom de fichier avec xfts_open ().
(2). Récupérez la structure FTSENT de la structure FTS avec fts_read (). --- Jusqu'à la dernière fois
(3). Appelez process_file () et revenez à (2).
La figure est la suivante.
Cette fois, nous allons regarder process_file () dans (3).
process_file()
python
static bool
process_file (FTS *fts, FTSENT *ent)
{
bool ok = true;
struct duinfo dui;
struct duinfo dui_to_print;
size_t level;
static size_t prev_level;
static size_t n_alloc;
static struct dulevel *dulvl;
const char *file = ent->fts_path;
const struct stat *sb = ent->fts_statp;
//Continuer
Regardons les variables.
-
dui: informations sur le répertoire actuel. Le champ de taille correspond à la taille totale des fichiers sous le répertoire. -
dui_to_print: informations de répertoire à afficher. Informations affichées à l'écran lorsque la commande du est exécutée. -
level: La profondeur de la hiérarchie de fichiers actuelle. -
prev_level: La profondeur de la hiérarchie de fichiers précédente. -
n_alloc: un paramètre utilisé pour allouerdulvl. Définissez une valeur supérieure à la profondeur de la hiérarchie de fichiers. -
dulvl: Un tableau avec des informations de répertoire. La profondeur de la hiérarchie des fichiers correspond à l'index du tableau. Par exemple, les informations du répertoire en profondeur 2 correspondent à dulvl [2]. Les champs de la structure dulevel sont: -
struct duinfo ent: informations de répertoire excluant les sous-répertoires. -
struct duinfo subdir: informations de répertoire pour les sous-répertoires. -
Le champ
sizede ʻent` est la taille du fichier sous le répertoire. Cependant, la taille de fichier sous le sous-répertoire est exclue. D'autre part, le champ «size» du «sous-répertoire» contient la taille du fichier dans le sous-répertoire. En d'autres termes, la somme de «size» de «ent »et de« subdir »donne la taille du fichier, y compris les sous-répertoires sous le répertoire. -
file: Le chemin racine du fichier. -
sb: un pointeur vers la structure stat. Obtenez la taille du fichier à partir d'ici.
duinfo_set()
Appelez ensuite duinfo_set ().
python
duinfo_set (&dui,
(apparent_size
? MAX (0, sb->st_size)
: (uintmax_t) ST_NBLOCKS (*sb) * ST_NBLOCKSIZE),
(time_type == time_mtime ? get_stat_mtime (sb)
: time_type == time_atime ? get_stat_atime (sb)
: get_stat_ctime (sb)));
python
static inline void
duinfo_set (struct duinfo *a, uintmax_t size, struct timespec tmax)
{
a->size = size;
a->inodes = 1;
a->tmax = tmax;
}
duinfo_set () est une fonction qui définit la taille du fichier et l'horodatage dans le premier argument dui.
ʻApparent_size est un indicateur qui affiche la taille réelle du fichier, pas l'utilisation du disque. L'utilisation du disque d'un fichier est la taille du fichier arrondie à la taille de bloc du système de fichiers. Par exemple, si la taille du bloc est de 4 Ko et la taille du fichier de 8,5 Ko, l'utilisation du disque sera de 12 Ko. La commande du affiche l'utilisation du disque par défaut. Quand ʻapparent_size est vrai, la taille réelle du fichier est passée à l'argument deduinfo_set (), et quand elle est fausse, l'utilisation du bloc est passée.
Ajouter la taille du fichier
La taille du fichier a été définie dans dui par duinfo_set ().
Voir le processus suivant.
python
level = ent->fts_level;
dui_to_print = dui;
Entrez la profondeur de la hiérarchie des fichiers dans level. Définissez également dui_to_print.
L'étape suivante consiste à ajouter la taille du fichier dui à la taille du répertoire.
Le traitement est divisé selon les trois modèles suivants.
- Lorsque vous êtes dans la même hiérarchie de fichiers que celle que vous avez suivie
- En descendant la hiérarchie des fichiers et en augmentant la profondeur
- Lorsque vous montez dans la hiérarchie des fichiers et que la profondeur diminue
1. Lorsque vous êtes dans la même hiérarchie de fichiers que celle que vous avez suivie
python
prev_level = level;
if (! (opt_separate_dirs && IS_DIR_TYPE (info)))
duinfo_add (&dulvl[level].ent, &dui);
duinfo_add (&tot_dui, &dui);
Tout d'abord, ajoutez la taille de fichier de dui à duvlv [level] .ent. dulvl [niveau] est une structure qui gère les informations sur les répertoires au niveau de la profondeur . Ici, la taille totale du fichier de la même hiérarchie est calculée. Notez que ʻopt_separate_dirs est une option qui n'inclut pas la taille du sous-répertoire, et ʻIS_DIR_TYPE (ent-> fts_info) est vrai si le fichier que vous regardez est un répertoire. Autrement dit, si vous n'incluez pas de sous-répertoires, la taille du répertoire n'est pas ajoutée. Ensuite, ajoutez également la taille du fichier à tot_dui. tot_dui` est la somme de toutes les tailles de fichiers.
2. En descendant la hiérarchie des fichiers et en augmentant la profondeur
python
size_t i;
for (i = prev_level + 1; i <= level; i++)
{
duinfo_init (&dulvl[i].ent);
duinfo_init (&dulvl[i].subdir);
}
prev_level = level;
if (! (opt_separate_dirs && IS_DIR_TYPE (info)))
duinfo_add (&dulvl[level].ent, &dui);
duinfo_add (&tot_dui, &dui);
Lorsque vous descendez dans la hiérarchie des fichiers, vous serez dans ce répertoire pour la première fois, alors initialisez dulvl [i] avec duinfo_init (). Le reste du processus est le même qu'avant.
3. Lorsque vous montez dans la hiérarchie des fichiers et que la profondeur diminue
python
duinfo_add (&dui_to_print, &dulvl[prev_level].ent);
if (!opt_separate_dirs)
duinfo_add (&dui_to_print, &dulvl[prev_level].subdir);
duinfo_add (&dulvl[level].subdir, &dulvl[prev_level].ent);
duinfo_add (&dulvl[level].subdir, &dulvl[prev_level].subdir);
prev_level = level;
if (! (opt_separate_dirs && IS_DIR_TYPE (ent->fts_info)))
duinfo_add (&dulvl[level].ent, &dui);
duinfo_add (&tot_dui, &dui);
Lorsque vous montez dans la hiérarchie des fichiers, l'emplacement précédent est le sous-répertoire actuel. Donc, ajoutez la capacité du répertoire précédent à dui_to_print et dulvl [level] .subdir.
Enfin, si le fichier que vous regardez est un répertoire, la capacité du répertoire est affichée.
python
if ((IS_DIR_TYPE (ent->fts_info) && level <= max_depth)
|| ((opt_all && level <= max_depth) || level == 0))
print_size (&dui_to_print, file);
en conclusion
C'est la première fois que je lis le code source d'une commande, mais c'est aussi recommandé pour les débutants car le code n'est pas long et le principe de fonctionnement est simple. Aussi, il est amusant de lire tout en anticipant le principe de fonctionnement de la commande.
Recommended Posts