Determina la dimensione di un dispositivo a blocchi

Come posso scoprire le dimensioni di un dispositivo a blocchi, come /dev/sda? La corsa ls -lnon fornisce informazioni utili.

fdisknon capisce il layout di partizione utilizzato dal mio Mac con Linux, né qualsiasi altro formato di partizione non PC. (Sì, c'è mac-fdiskper le vecchie tabelle delle partizioni Mac e gdiskper la più recente tabella delle partizioni GPT, ma quelle non sono le uniche altre configurazioni di partizioni là fuori.)

Dato che il kernel ha già scansionato i layout delle partizioni quando il dispositivo a blocchi è entrato in servizio, perché non chiederlo direttamente?

$ cat / proc / partitions
nome minore # blocchi principali

   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 restituisce la dimensione in byte.

blockdev --getsz /dev/sda restituisce dimensioni in settori a 512 byte.

Obsoleto: blockdev --getsize /dev/sdarestituisce le dimensioni nei settori.

blockdev fa parte di util-linux .

cat /sys/class/block/sda/size

Questo ti dà le sue dimensioni in blocchi da 512 byte.

Questo semplice codice. Impossibile trovare alcuna documentazione, ma lo fa egregiamente:

#include <linux/fs.h>
...
ioctl(file, BLKGETSIZE64, &file_size_in_bytes);

Che ne dite di:

fdisk -l

Questo ti darà un elenco di tutti i tuoi dischi con le rispettive capacità, utilizzo e altro.

blockdev --getsize /dev/sda

lsblk fornisce le informazioni che stai cercando, inclusi i tipi di dispositivo e i mountpoint (se presenti), con una vista ad albero e in un formato leggibile dall'uomo.

Tipo di dispositivo significa che funziona per le unità CD, come richiesto da Ganesh Sittampalam.

Per ottenere solo le dimensioni di un determinato dispositivo in byte:

lsblk -rbno SIZE /dev/block-device

echo "`cat /sys/class/block/sda2/size`*512" | bc

o se usi bash o qualsiasi altra shell simile a POSIX i cui operatori aritmetici lavorano con numeri interi a 64 bit, non hai nemmeno bisogno di chiamare bc

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

indica la dimensione in byte.

La chiamata a cate forcella (eccetto bash) può essere ottimizzato via con bash, ksh93e zshcon:

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

Non c'è bisogno di ioctl in C. Basta cercare fino alla fine del file e ottenere la dimensione (in byte) in questo modo:

/* 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.

Il blockdev (8) ha una risposta diversa? Opzioni --getsze deprecati --getsizenon sono gli stessi.

• BLKSSZGET ( blockdev --getss) è per le dimensioni del settore fisico e
• BLKBSZGET ( blockdev --getbsz) è per la dimensione del settore logico.

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

Innanzitutto, i miei ringraziamenti a tutti coloro che hanno contribuito. Ho imparato alcune cose utili.

Tuttavia, la mia esperienza è che la maggior parte di queste risposte sono in qualche modo incomplete, almeno per quanto riguarda i CD e i DVD, in particolare per quanto riguarda se sono disponibili per gli utenti normali piuttosto che limitati al superutente.
Questo si basa su test sul mio Linux Mageia 2.

I comandi destinati al superutente sono sempre accessibili da un utente normale prefissandoli con /sbin/, o talvolta con / usr / sbin /. Ora potrebbero funzionare o meno per un normale utente.

Molti potrebbero funzionare, per un utente normale, per un DVD sull'unità DVD, anche quando non è montato, mentre non funzioneranno per un disco rigido (di nuovo se richiamato come utente normale).

Ad esempio /sbin/fdisk -l /dev/cdromfunzionerà sul mio sistema e fornirà la "geometria" del DVD nell'unità ... che apparentemente è per lo più senza senso. Ma fornisce la dimensione del DVD in byte e in settori e una dimensione del settore corretta (di 2048 byte come al solito per il DVD).

Lo stesso vale /usr/sbin/gdisk -l /dev/cdrom, che danno solo la dimensione in settori di 2048 byte.

altri esempi (come utente non root, normale)

$ /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
...

Questo funziona per l'unità DVD, qui chiamata sr0, poiché il dispositivo è effettivamente /dev/sr0, /dev/cdromessendo solo un collegamento simbolico ad essa. La dimensione è data in pezzi di 1k.

Allo stesso modo, come normale utente, il comando

$ cat /sys/class/block/sr0/size
10651008

fornirà la dimensione di un DVD sul dispositivo /dev/sr0, in blocchi di 512 byte (così come la dimensione di un altro disco, anche se non montato). Tuttavia cat /sys/class/block/cdrom/sizenon funzionerà perché causa / dev / cdrom è solo un collegamento simbolico

Il comando df, suggerito da alcuni, fornisce le dimensioni delle partizioni montate, non di interi dischi. Inoltre, per un CD o un DVD montato offre una dimensione inferiore a quella effettiva del CD / DVD. Più precisamente, ci sono due dimensioni distinte che potrebbero interessare:

• le dimensioni complessive del dispositivo, incluso ciò che viene utilizzato per la sua organizzazione interna. In genere questa è la dimensione del file ottenuto se viene copiato intero con il comando dd;
• la dimensione dello spazio disponibile (possibilmente solo in modalità di sola lettura) per l'utente quando è montato, che è sempre inferiore. Questa è la dimensione indicata dal comando df.

Un blocco è una sequenza di bit o byte con una lunghezza fissa, ovvero 512 byte, 4kB, 8kB, 16kB, 32kB ecc.

blockdev --getbsz partition

Esempio

# blockdev --getbsz /dev/sda1 
4096

Quindi la dimensione del blocco di questo file system è di 4kB.

Analogia: numero di bottiglie in cassette.

Se stai usando Node.js, puoi usare questo componente aggiuntivo nativo per ottenere dimensioni del dispositivo a blocchi, dimensioni del settore fisico e dimensioni del settore logico (con supporto per FreeBSD, Linux, macOS e Windows). Ha anche alcuni altri aiutanti per fare IO diretto:

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

È /sys/block/sda/sizein blocchi? In tal caso quale?

BLKGETSIZE ioctl presenta lo stesso problema in unità di 512 anziché BLKSSZGET . BLKGETSIZE64 risolve questa ambiguità. Il conteggio dei blocchi reali è 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 */
}

Vedi http://lkml.indiana.edu/hypermail/linux/kernel/0105.2/0744.html

Esiste un'utilità EMC chiamata inqche fornisce informazioni su tutti i tipi di dispositivi a blocchi come locali collegati, basati su SAN, ecc.

Provalo.

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

Ecco una breve descrizione di ciò che fa: http://slashzeroconf.wordpress.com/2009/02/09/emc-inq-utility/

echo "`blockdev --getbsz /dev/sdc`/1024"|bc

mostrerà l'output in KB

[root@veritas datadg2]# echo "`blockdev --getbsz /dev/sdc`/1024"|bc
4
[root@veritas datadg2]#

Più semplicemente:

sudo parted -l /dev/sda

È per me il più semplice da ricordare e digitare

fdisk -l /dev/sda | grep -m1 ^Disk | awk '{print $3 " " $4}'

Lo trovo molto utile di tutti quegli strumenti standard o voci proc

df -k | grep /dev/sda

ti darà la dimensione in KB (primo numero), nonché lo spazio utilizzato (secondo numero) e lo spazio disponibile (terzo numero)