Déterminer la taille d'un périphérique bloc

Comment puis-je connaître la taille d'un périphérique en mode bloc, tel que /dev/sda? Courir ls -lne donne aucune information utile.

fdiskne comprend pas la disposition des partitions utilisée par mon Mac sous Linux, ni aucun autre format de partition autre que PC. (Oui, il y en a mac-fdiskpour les anciennes tables de partitions Mac et gdiskpour les nouvelles tables de partitions GPT, mais ce ne sont pas les seules dispositions de partitions disponibles.)

Puisque le noyau a déjà analysé les dispositions de partition lorsque le périphérique de blocage est entré en service, pourquoi ne pas le demander directement?

$ cat / proc / partitions
majeur mineur #blocs nom

   8 16 390711384 sdb
   8 17 514079 sdb1
   8 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

blockdev --getsize64 /dev/sda renvoie la taille en octets.

blockdev --getsz /dev/sda renvoie la taille dans des secteurs de 512 octets.

Obsolète: blockdev --getsize /dev/sdarenvoie la taille en secteurs.

blockdev fait partie d' util-linux .

cat /sys/class/block/sda/size

Cela vous donne sa taille en blocs de 512 octets.

Ce code simple. Impossible de trouver de la documentation, 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 donne les informations que vous recherchez, y compris les types de périphériques et les points de montage (le cas échéant), sous forme d'arborescence et dans un format lisible par l'homme.

Type de périphérique signifie que cela fonctionne pour les lecteurs de CD, comme demandé par 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 à la catfourchette et ( à l' exception bashpeut être optimisée) avec une distance bash, ksh93et zshavec:

echo "$((512*$(</sys/class/block/sda2/size)))"

Pas besoin d'ioctl dans C. Recherchez simplement 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.

Le blockdev (8) a une réponse différente? Les options --getszet obsolète --getsizene sont pas les mêmes.

• BLKSSZGET ( blockdev --getss) concerne la taille du secteur physique et
• BLKBSZGET ( blockdev --getbsz) est pour la taille du secteur logique.

echo $(($(blockdev --getsize64 /dev/sda)/$(blockdev --getss /dev/sda)))

Tout d’abord, merci à tous ceux qui ont contribué. J'ai appris quelques choses utiles.

Cependant, mon expérience montre 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.

Les commandes destinées au super-utilisateur sont toujours accessibles aux utilisateurs normaux en les préfixant avec /sbin/, ou parfois, avec / usr / sbin /. Maintenant, ils peuvent ou peuvent ne pas fonctionner pour un utilisateur normal.

Beaucoup peuvent fonctionner, pour un utilisateur normal, pour un DVD sur le lecteur de DVD, même s'il n'est pas monté, alors qu'ils ne fonctionneront pas pour un disque dur (à nouveau lorsqu'il est appelé 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 pour la plupart absurde. Mais il donne la taille du DVD en octets et en secteurs, ainsi qu'une taille de secteur correcte (de 2048 octets, comme d'habitude pour les DVD).

Il en va de même de /usr/sbin/gdisk -l /dev/cdromqui ne donne que la taille en secteurs de 2048 octets.

autres exemples (en tant qu'utilisateur non root, utilisateur 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, puisque le dispositif car il est en fait /dev/sr0, /dev/cdromêtre seulement un lien symbolique vers elle. 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 le périphérique /dev/sr0, en morceaux de 512 octets (ainsi que la taille d'un autre disque, même non monté). Cependant, cat /sys/class/block/cdrom/sizecela 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 celle des disques entiers. En outre, pour un CD ou un DVD monté, la taille du CD / DVD est inférieure à sa taille réelle. Plus précisément, il existe deux tailles distinctes, on peut être intéressé par:

• 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 lorsqu'il est monté, ce qui est toujours inférieur. 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 cet additif natif pour obtenir la taille du périphérique en bloc, la taille du secteur physique et la taille du secteur logique (avec la prise en charge de FreeBSD, Linux, macOS et Windows). Il a également quelques autres aides pour effectuer des opérations d’information directes:

https://github.com/ronomon/direct-io

Est /sys/block/sda/sizeen taille de bloc? Si oui lequel?

Le ioctl BLKGETSIZE a le même problème que dans les 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

Il existe un utilitaire EMC appelé inqqui fournit des informations sur tous les types de périphériques en bloc, tels que les périphériques locaux connectés, les réseaux SAN, etc.

Essaye le.

ftp://ftp.emc.com/pub/symm3000/inquiry/

Voici une brève description de ce qu’elle fait: http://slashzeroconf.wordpress.com/2009/02/09/emc-inq-utility/

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]#

Plus simplement:

sudo parted -l /dev/sda

Est pour moi le plus facile à retenir et à taper

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

df -k | grep /dev/sda

vous donnera la taille en Ko (premier nombre) ainsi que l'espace utilisé (deuxième nombre) et l'espace disponible (troisième nombre)