Harddrive with 4096 physical sector size reported as 512 behind USB bridge

I think you're confused, possibly because you've read several documents that use different terminology. Terms like “block size” and “cluster size” don't have a universal meaning, even within the context of filesystem literature.

Filesystems

For ext2 or ext3, the situation is relatively simple: each file occupies a certain number of blocks. All blocks on a given filesystem have the same size, usually one of 1024, 2048 or 4096 bytes. A file¹ whose size is between N blocks plus one byte and N+1 blocks occupies N+1 blocks. That block size is what you specify with mke2fs -b. There is no separate notion of clusters.

The FAT filesystem used in particular by MS-DOS and early versions of Windows has a similarly simple space allocation. What ext2 calls blocks, FAT calls clusters; the concept is the same.

Some filesystems have a more sophisticated allocation scheme: they have fixed-size blocks, but can use the same block to store the last few bytes of more than one file. This is known as block suballocation; Reiserfs and Btrfs do it, but not ext3 or even ext4.

Utilities

Unix utilities often use the word “block” to mean an arbitrarily-sized unit, typically 512 bytes or 1kB. This usage is unrelated to any particular filesystem or disk hardware. Historically, the 512B block did come about because disks and filesystems at the time often operated in 512B chunks, but the modern usage is just arbitrary. Traditional unix utilities and interfaces still use 512B blocks sometimes, though 1kB blocks are now often preferred. You need to check the documentation of each utility to know what size of block it's using (some have a switch, e.g. du -B or df -B on Linux).

In the GNU/Linux stat utility, the blocks figure is the number of 512B blocks used by the file. The IO Block figure is the preferred size for file input-output, which is in principle unrelated but usually an indication of the underlying filesystem's block size (or cluster size if that's what you want to call it). Here, you have a 13-byte file, which is occupying one block on the ext3 filesystem with a block size of 2048; therefore the file occupies 4 512-byte units (called “blocks” by stat).

Disks

Most disks present an interface that shows the disk as a bunch of sectors. The disk can only write or read a whole sector, not individual bits or bytes. Most hard disks have 512-byte sectors, though 4kB-sector disks started appearing a couple of years ago.

The disk sector size is not directly related to the filesystem block size, but having a block be a whole number of sectors is better for performance.

¹ _{Exception: sparse files save space .}

512 byte is not really the default sector size. It depends on your hardware.

You can display what physical/logical sector sizes your disk reports via the /sys pseudo filesystem, for instance:

# cat /sys/block/sda/queue/physical_block_size
4096
# cat /sys/block/sda/queue/logical_block_size
512

What is the difference between those two values?

• The physical_block_size is the minimal size of a block the drive is able to write in an atomic operation.
• The logical_block_size is the smallest size the drive is able to write (cf. the linux kernel documentation).

Thus, if you have a 4k drive it makes sense that your storage stack (filesystem etc.) uses something equal or greater than the physical sector size.

Those values are also displayed in recent versions of fdisk, for instance:

# fdisk -l /dev/sda
[..]
Sector size (logical/physical): 512 bytes / 4096 bytes

On current linux distributions, programs (that should care about the optimal sector size) like mkfs.xfs will pick the optimal sector size by default (e.g. 4096 bytes).

But you can also explicitly specify it via an option, for instance:

# mkfs.xfs -f -s size=4096 /dev/sda

Or:

# mkfs.ext4 -F -b 4096 /dev/sda

In any case, most mkfs variants will also display the used block size during execution.

For an existing filesystem the block size can be determined with a command like:

# xfs_info /mnt
[..]
meta-data=                       sectsz=4096
data     =                       bsize=4096
naming   =version 2              bsize=4096
log      =internal               bsize=4096
         =                       sectsz=4096
realtime =none                   extsz=4096

Or:

# tune2fs -l /dev/sda
Block size:               4096
Fragment size:            4096

Or:

# btrfs inspect-internal dump-super /dev/sda | grep size
csum_size             4
sys_array_size        97
sectorsize            4096
nodesize              16384
leafsize              16384
stripesize            4096
dev_item.sector_size  4096

When creating the filesystem on a partition, another thing to check then is if the partition start address is actually aligned to the physical block size. For example, look at the fdisk -l output, convert the start addresses into bytes, divide them by the physical block size - the reminder must be zero if the partitions are aligned.