How about:

sudo fdisk -l

This will give you a list of all your disks with their respective capacity, usage, file system, and more.

df -k | grep /dev/sda

will give you the size in KB (first number) as well as the space used (second number) and space available (third number)

cat /sys/class/block/sda/size

This gives you its size in 512-byte blocks.

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

or if you use bash or any other POSIX-like shell whose arithmetic operators work with 64bit integers, you don’t even need to call bc

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

gives the size in byte.

The call to cat and fork (except for bash) can be optimised away with bash, ksh93 and zsh with:

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

blockdev --getsize /dev/sda

This simple code. Couldn’t find any documentation, but does the trick nicely:

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

blockdev --getsize64 /dev/sda returns size in bytes.

blockdev --getsz /dev/sda returns size in 512-byte sectors.

Deprecated: blockdev --getsize /dev/sda returns size in sectors.

blockdev is part of util-linux.

Is /sys/block/sda/size in block size? If so which one?

The ioctl BLKGETSIZE has the same problem as it is in units of 512 rather than BLKSSZGET. BLKGETSIZE64 solves this ambiguity. The real block count is 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 #%f240GiBnn",
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 */
}

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

The blockdev(8) has a different answer? Options --getsz and deprecated --getsize are not the same.

• BLKSSZGET (blockdev --getss) is for physical sector size and
• BLKBSZGET (blockdev --getbsz) is for logical sector size.

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

No need for ioctl in C. Just seek to the end of the file and get the size (in bytes) that way:

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

There is an EMC utility called inq which gives information about all types of block devices like local attached, SAN based, etc.

Try it out.

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

Here is a brief description of what it does:
http://slashzeroconf.wordpress.com/2009/02/09/emc-inq-utility/

First, my thanks to all who contributed. I learned a few
useful things.

Still, my experience is that most of these answers are somewhat
incomplete, at least where CD and DVDs are concerned,
notably regarding whether they are available to normal users
rather than restricted to the superuser.
This is based on tests on my Linux Mageia 2.

Commands intended for the superuser can always be accessed by a normal
user by prefixing them with /sbin/, or sometimes with /usr/sbin/.
Now they may or may not work for a normal user.

Many may work, for a normal user, for a DVD on the DVD drive, even
when it is not mounted, while they will not work for a hard disk
(again when invoked as normal user).

For example /sbin/fdisk -l /dev/cdrom will work on my system and
give the “geometry” of the DVD in the drive … which is apparently
mostly nonsense. But it does give the size of the DVD in bytes and in
sectors, and a correct sector size (of 2048 bytes as is usual for DVD).

The same is true of /usr/sbin/gdisk -l /dev/cdrom, which give only
the size in sectors of 2048 bytes.

other examples (as non-root, normal user)

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

This works for the DVD drive, here called sr0, since the device for it
is actually /dev/sr0, /dev/cdrom being only a symbolic link to it.
The size is given in chunks of 1k.

Similarly, as normal user, the command

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

will give the size of a DVD on device /dev/sr0, in chunks of 512 bytes
(as well as the size of other disk, even not mounted).
However cat /sys/class/block/cdrom/size will not work be cause
/dev/cdrom is only a symbolic link

The command df, suggested by some, gives the size of mounted
partitions, not of whole disks. Furthermore, for a mounted CD or DVD
it gives less than the actual size of the CD/DVD. More precisely, there are
two distinct sizes one may be interested in :

• the overall size of the device, including what is used for its internal organization. Typically that is the size of the file obtained if it is copied whole with the command dd;
• the size of the space available (possibly only in read-only mode) to the user when it is mounted, which is always less. That is the size that is indicated by the command df.

Interactive use

lsblk -no SIZE /dev/block-device

Note that, if there are partitions, you get a list with the total size of the device followed by the size of each partition or you can append the partition to the device name.

Scripting

If you need to store the size in a variable, use:

size=$(lsblk -bno SIZE /dev/path | head -1)

Now, the result is always in bytes and, if path does not include a partition, it is the total disk size, otherwise it is the partition size.

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

I find it very useful than all those standard tools or proc entries

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

will show output in KB

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

A block is a sequence of bit or Bytes with a fixed length ie 512 bytes, 4kB, 8kB, 16kB, 32kB etc.

blockdev --getbsz partition

Example

# blockdev --getbsz /dev/sda1 
4096

So the block size of this file system is 4kB.

Analogy: number of bottles in crates.

If you are using Node.js, you can use this native add on to get block device size, physical sector size and logical sector size (with support for FreeBSD, Linux, macOS and Windows). It also has a few other helpers for doing direct IO:

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

More simply:


sudo parted -l /dev/sda


Is for me the easiest to remember and type

If you want to find it programmatically in C, checkout code of util-linux package – https://github.com/karelzak/util-linux/blob/master/lib/blkdev.c#L81

OR this is also useful – http://www.linuxproblem.org/art_20.html
(The code works on Linux Kernel version 5.0.0-32-generic.)

Both these codes use ioctl system call.

To show disks sizes in human readable form, type this as a simple user :

$ lsblk -do NAME,SIZE /dev/sd?
NAME      SIZE
sda       75G
sdb       200G

disk_name=$(mount|grep ' / '|cut -d' ' -f 1) && sudo tune2fs -l $disk_name | grep Block

This command will work.