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

134

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.

lfaraone
la source
Comprendre la taille du bloc: wiki.linuxquestions.org/wiki/Block_size
Vue elliptique
2
Sachant que j'ai 9 ans de retard pour répondre, je suppose que vous trouverez la réponse avec une commande lsblk .
Ada Ya

Réponses:

73

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
éphémère
la source
Cela ne fonctionne pas pour des choses comme les lecteurs de CD
Ganesh Sittampalam le
2
Et ne signale que les noms "natifs". Sur un serveur avec iSCSI et / ou Multipath et / ou LVM, vous obtenez de nombreux périphériques sd * et dm- *, mais vous devez généralement rechercher le lien symbolique de celui qui vous intéresse (par exemple, un / dev / mapper / * one)
Luke404
2
Les valeurs indiquées ici sont des multiples de 1 Ko, ce qui peut être un secteur (512 octets) trop petit.
Lekensteyn
1
C'était utile pour moi. J'ai fini par faireawk '/sd[a-z]$/{printf "%s %8.2f GiB\n", $NF, $(NF-1) / 1024 / 1024}' /proc/partitions
suprjami
173

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 .

David
la source
4
a malheureusement besoin du superutilisateur
heinrich5991
6
@ heinrich5991 vous n'avez pas le choix. Un utilisateur normal ne peut pas accéder directement à un périphérique en mode bloc ("lecture brute"), ce qui est bon pour la sécurité.
Totor
@Totor Bien sûr, mais il existe encore des réponses à cette question spécifique qui n'exigent aucun droit de super utilisateur.
Heinrich5991
2
@ heinrich5991 lorsque vous travaillez avec des systèmes de fichiers, vous devriez demander à statfs () et à vos amis. Plus important encore, vous ne devez pas supposer de relation directe entre la taille du périphérique en bloc et l’espace total / utilisable / effectif / libre / quel que soit l’espace disponible sur le système de fichiers.
Luke404
2
La page de manuel à linux.die.net/man/8/blockdev indique qu'elle --getsizeest obsolète et suggère --getszdes secteurs cohérents de 512 octets. Si --getsizedoit être utilisé, je suppose que cela --getssdevrait également être utilisé pour s’assurer que la taille du secteur correspond à vos attentes.
mwfearnley
35
cat /sys/class/block/sda/size

Cela vous donne sa taille en blocs de 512 octets.


la source
9
@ heinrich5991 Comment pouvez-vous être sûr que la taille de bloc du périphérique est toujours de 512 octets?
Totor
5
La taille du secteur est toujours de 512 octets selon la source . Pour le futur, j'essaie de documenter cette interface .
Lekensteyn
Merci d'avoir précisé cela. J'ai remarqué qu'il existe également un fichier / sys / class / block / sda / queue / logical_block_size. Je n'étais pas sûr de devoir utiliser cela, ni la constante 512.
Edward Falk
33

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);

la source
Correction: cela vous donne la taille en SECTEURS. Modifiez-le et je voterai.
JCCyC
8
@JCCyC: BLKGETSIZE64renvoie la taille en octets. Voir linux/fs.hqui note "retourne la taille du périphérique en octets". Notez que BLKGETSIZE(pas "64") le renvoie "/ 512".
Thanatos
J'ai élaboré un échantillon plus complet en partie basé sur ceci à stackoverflow.com/a/48490543/446106 . Pour utiliser l'extrait ci-dessus ici, il filefaut un descripteur de fichier (par exemple, de open()) et file_size_in_bytesdevrait être un size_t.
mwfearnley
(En fait, file_size_in_bytesdevrait être un type 64 bits, il devrait en être ainsi unsigned long long.)
mwfearnley le
16

Que diriez-vous:

fdisk -l

Cela vous donnera une liste de tous vos disques avec leur capacité respective, leur utilisation, etc.

Wadih M.
la source
3
Essayez-le avec sudo, sinon rien ne sera imprimé.
Alfe
10

blockdev --getsize /dev/sda

Vi.
la source
Utilisez avec sudo, sinon vous obtenez Permission denied.
Wimateeka
9

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
Antonio
la source
7
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)))"
Stéphane Chazelas
la source
5

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.
mpartel
la source
Si vous recherchez la taille du lecteur de disque brut, vous devez disposer de droits d'accès root pour ouvrir le fichier à la fin.
Edward Falk
5

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)))
Palec
la source
En fait, je pense que vous les avez inversés. (Sauf si mon système a des blocs physiques de 512 octets et des blocs logiques de 4096 octets.)
Edward Falk
2
Eh bien, je me suis rendu compte que, block/ioctl.cdans le noyau Linux, le code source contient des commentaires trompeurs. BLKPBSZGET (notez que le P) obtient la taille du secteur physique, BLKSSZGET obtient la taille du secteur logique et BLKBSZGET (ou BLKBSZGET_32 in block/compat_ioctl.c) obtient la taille de l'unité d'allocation du système de fichiers (cluster). La taille du secteur logique et physique diffère lorsque le format avancé 512e est utilisé. ( 512e @ WP )
Palec le
@Palec Le commentaire le plus informatif parmi toutes les réponses et commentaires à cette question.
Irfan Latif le
5

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.
babou
la source
hausse de $ / sbin / blockdev --getss / dev / cdrom # taille du secteur du DVD
peterretief
Vous dites 512k mais vous voulez dire seulement des secteurs de 512 octets.
Tom Hale
3

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.
entrez la description de l'image ici

Premraj
la source
C'est la bonne réponse.
Karl Morrison
1

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

Joran Greef
la source
0

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

Au hasard832
la source
1
Abus d'assertion: si vous désactivez les assertions, vos effets secondaires nécessaires ne se produiront plus.
Alfe
0
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]#
Urvesh RHCE
la source
bash peut faire en ligne calculs: echo $(( $(blockdev ...)/1024 )). Notez également que --getbszdonne la taille du bloc, pas la taille du périphérique.
mwfearnley
0

Plus simplement:

sudo parted -l /dev/sda

Est pour moi le plus facile à retenir et à taper

Vicente Adolfo Bolea Sánchez
la source
-1
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

SHW
la source
-3
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)


la source
5
C'est seulement si le système de fichiers est monté.
lfaraone
2
Cela ne concerne pas l’espace des périphériques en mode bloc, il vous donnera l’espace utilisé et utilisable des systèmes de fichiers montés qui se trouvent sur / dev / sda. Qu'en est-il de l'espace non partitionné? Et si vous avez plusieurs partitions?
kbyrd