Déterminer la taille d'un périphérique bloc
Comment puis-je connaître la taille d'un périphérique bloc, tel que /dev/sda? Fonctionnement ls -l ne donne aucune information utile.
fdisk ne comprend pas la disposition des partitions utilisée par mon Mac sous Linux, ni aucun autre format de partition non PC. (Oui, il y a mac-fdisk pour les anciennes tables de partition Mac et gdisk pour la nouvelle table de partition GPT, mais ce ne sont pas les seules autres dispositions de partition disponibles.)
Étant donné que le noyau a déjà analysé les dispositions de partition lorsque le périphérique de bloc est entré en service, pourquoi ne pas le demander directement?
. 18 390194752 sdb2 8 32 976762584 sdc 8 33 514079 sdc1 8 34 976245952 sdc2 8 0 156290904 sda 8 1 514079 sda1 8 2 155774272 sda2 8 48 1465138584 sdd 8 49 514079 sdd1 8 50 1464621952 sdd2
cat /sys/class/block/sda/size
Cela vous donne sa taille en blocs de 512 octets.
Ce code simple. Impossible de trouver la documentation any, mais fait bien l'affaire:
#include <linux/fs.h>
...
ioctl(file, BLKGETSIZE64, &file_size_in_bytes);
Que diriez-vous:
fdisk -l
Cela vous donnera une liste de tous vos disques avec leur capacité respective, leur utilisation, etc.
blockdev --getsize /dev/sda
lsblk fournit les informations que vous recherchez, y compris les types d'appareils et les points de montage (le cas échéant), avec une arborescence et dans un format lisible par l'homme.
Le type d'appareil signifie qu'il fonctionne pour les lecteurs de CD, comme l'a demandé Ganesh Sittampalam.
Pour obtenir uniquement la taille d'un périphérique particulier en octets:
lsblk -rbno SIZE /dev/block-device
echo "`cat /sys/class/block/sda2/size`*512" | bc
ou si vous utilisez bash ou tout autre shell de type POSIX dont les opérateurs arithmétiques fonctionnent avec des entiers 64 bits, vous n'avez même pas besoin d'appeler bc
echo "$((512*$(cat /sys/class/block/sda2/size)))"
donne la taille en octet.
L'appel à cat et à fork (sauf pour bash) peut être optimisé avec bash, ksh93 et zsh avec:
echo "$((512*$(</sys/class/block/sda2/size)))"
Le blockdev (8) a une réponse différente? Options --getsz et obsolète --getsize ne sont pas les mêmes.
- BLKSSZGET (
blockdev --getss) correspond à la taille du secteur physique et - BLKBSZGET (
blockdev --getbsz) est pour la taille de secteur logique.
echo $(($(blockdev --getsize64 /dev/sda)/$(blockdev --getss /dev/sda)))
Pas besoin d'ioctl en C. Cherchez juste à la fin du fichier et obtenez la taille (en octets) de cette façon:
/* define this before any #includes when dealing with large files: */
#define _FILE_OFFSET_BITS 64
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
// ...
int fd = open("/dev/sda", O_RDONLY);
off_t size = lseek(fd, 0, SEEK_END);
// Now size is the size of the file, in bytes, or -1 on error.
// lseek(fd, 0, SEEK_SET) to get back to the start of the file.
Tout d'abord, mes remerciements à tous ceux qui ont contribué. J'ai appris quelques choses utiles.
Pourtant, mon expérience est que la plupart de ces réponses sont quelque peu incomplètes, du moins en ce qui concerne les CD et les DVD, notamment en ce qui concerne leur disponibilité pour les utilisateurs normaux plutôt que pour le superutilisateur.
Ceci est basé sur des tests sur mon Linux Mageia 2.
Un utilisateur normal peut toujours accéder aux commandes destinées au superutilisateur en les préfixant avec /sbin/, ou parfois avec/usr/sbin /. Maintenant, ils peuvent ou non fonctionner pour un utilisateur normal.
Beaucoup peuvent fonctionner, pour un utilisateur normal, pour un DVD sur le lecteur de DVD, même lorsqu'il n'est pas monté, alors qu'ils ne fonctionneront pas pour un disque dur (à nouveau lorsqu'ils sont appelés en tant qu'utilisateur normal).
Par exemple /sbin/fdisk -l /dev/cdrom fonctionnera sur mon système et donnera la "géométrie" du DVD dans le lecteur ... ce qui est apparemment essentiellement absurde. Mais cela donne la taille du DVD en octets et en secteurs, et une taille de secteur correcte (de 2048 octets comme d'habitude pour les DVD).
Il en va de même pour /usr/sbin/gdisk -l /dev/cdrom, qui ne donne que la taille en secteurs de 2048 octets.
autres exemples (en tant qu'utilisateur non root, normal)
$ /sbin/blockdev --getss /dev/cdrom # DVD sector size
2048
$ /sbin/blockdev --getsize64 /dev/cdrom # DVD byte size
5453316096
$ cat /proc/partitions # see below
...
8 8 416027241 sda8
11 0 5325504 sr0
8 16 1465138584 sdb
...
Cela fonctionne pour le lecteur de DVD, appelé ici sr0, car le périphérique correspondant est en fait /dev/sr0, /dev/cdrom n'y étant qu'un lien symbolique. La taille est donnée en morceaux de 1k.
De même, en tant qu'utilisateur normal, la commande
$ cat /sys/class/block/sr0/size
10651008
donnera la taille d'un DVD sur l'appareil /dev/sr0, en blocs de 512 octets (ainsi que la taille des autres disques, même non montés). Cependant cat /sys/class/block/cdrom/size ne fonctionnera pas car/dev/cdrom n'est qu'un lien symbolique
La commande df, suggérée par certains, donne la taille des partitions montées, pas des disques entiers. De plus, pour un CD ou DVD monté, il donne moins que la taille réelle du CD/DVD. Plus précisément, il existe deux tailles distinctes qui peuvent intéresser:
- la taille globale de l'appareil, y compris ce qui est utilisé pour son organisation interne. Il s'agit généralement de la taille du fichier obtenu s'il est copié en entier avec la commande
dd; - la taille de l'espace disponible (éventuellement uniquement en mode lecture seule) pour l'utilisateur lors de son montage, qui est toujours moindre. C'est la taille indiquée par la commande
df.
Un bloc est une séquence de bits ou d'octets de longueur fixe, soit 512 octets, 4 Ko, 8 Ko, 16 Ko, 32 Ko, etc.
blockdev --getbsz partition
Exemple
# blockdev --getbsz /dev/sda1
4096
La taille de bloc de ce système de fichiers est donc de 4 Ko.
Analogie: nombre de bouteilles dans des caisses.
Si vous utilisez Node.js, vous pouvez utiliser ce module complémentaire natif pour obtenir la taille du périphérique de bloc, la taille du secteur physique et la taille du secteur logique (avec prise en charge de FreeBSD, Linux, macOS et Windows). Il dispose également de quelques autres aides pour effectuer des E/S directes:
Est /sys/block/sda/size en taille de bloc? Si oui lequel?
L'ioctl [~ # ~] blkgetsize [~ # ~] a le même problème que dans des unités de 512 plutôt que [~ # ~] blksszget [~ # ~] . BLKGETSIZE64 résout cette ambiguïté. Le nombre réel de blocs est BLKGETSIZE64/BLKSSZGET .
/*BINFMTC:
http://lkml.indiana.edu/hypermail/linux/kernel/0105.2/0744.html
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/fs.h>
#include <assert.h>
int main(int argc, char **argv)
{
int fd;
long blk=0L;
long ssz=0L;
long long oct=0LL;
if((fd=open(argv[1],O_RDONLY))<0) { perror(argv[1]); exit(1); }
if(ioctl(fd,BLKGETSIZE,&blk)<0) { perror("BLKGETSIZE"); exit(1); }
if(ioctl(fd,BLKSSZGET,&ssz)<0) { perror("BLKSSZGET"); exit(1); }
if(ioctl(fd,BLKGETSIZE64,&oct)<0) { perror("BLKGETSIZE64"); exit(1); }
if(close(fd)<0) { perror("close"); exit(1); }
printf("BLKGETSIZE=%ld BLKSSZGET=%ld BLKGETSIZE64=%lld BLKGETSIZE64/BLKSSZGET=%ld SIZEGB=%f #%f\240GiB\n\n",\
blk,ssz,oct,(long)(oct/(long long)ssz),(double)oct/1000000000.0,(double)oct/1073741824.0);
fflush(stdout); /* before exec */
execl("/bin/bash","bash","-c",\
"for i in \
/sys/block/?d?/{size,alignment_offset,?d??/size,?d??/alignment_offset,queue/*block*,queue/*sector*}; \
do test -f \"$i\" && echo \"$i: $(<$i)\"; done"\
,NULL);
exit(127);
return 127; /* not reached */
}
Voir http://lkml.indiana.edu/hypermail/linux/kernel/0105.2/0744.html
echo "`blockdev --getbsz /dev/sdc`/1024"|bc
affichera la sortie en Ko
[root@veritas datadg2]# echo "`blockdev --getbsz /dev/sdc`/1024"|bc
4
[root@veritas datadg2]#
fdisk -l /dev/sda | grep -m1 ^Disk | awk '{print $3 " " $4}'
Je le trouve très utile que tous ces outils standard ou entrées de proc
Plus simplement:
Sudo parted -l /dev/sda
Est pour moi le plus facile à retenir et à taper
Il existe un utilitaire EMC appelé inq qui fournit des informations sur tous les types de périphériques de bloc tels que les périphériques locaux connectés, SAN basé, etc.
Essaye le.
ftp://ftp.emc.com/pub/symm3000/inquiry/
Voici une brève description de ce qu'il fait: http://slashzeroconf.wordpress.com/2009/02/09/emc-inq-utility/
Si vous voulez le trouver par programme en C, consultez le code de caisse du paquet util-linux - https://github.com/karelzak/util-linux/blob/master/lib/blkdev.c#L81
OU cela est également utile - http://www.linuxproblem.org/art_20.html (Le code fonctionne sur la version du noyau Linux 5.0.0-32-generic.)
Ces deux codes utilisent l'appel système ioctl.