Struggling to install huggingface_hub

Beginners
14

Oh…

Your Jetson is almost certainly fine.
What you are seeing is:

  • the JetPack SD image itself is ~22 GB, so after Etcher writes it, the root filesystem is 22 GB,
  • the rest of the 1 TB card is unallocated / unused,
  • the file manager then shows “22 GB drive”, even though the physical card is 1 TB.

There is also a smaller chance the card is a fake “1 TB” card. I will cover both.

1. What actually happened when you used Balena Etcher

1.1 The JetPack SD image is ~22 GB

For the Jetson Orin Nano devkit, NVIDIA distributes an SD image (e.g. JP5.1.1 or similar). When you download and unzip it, you get a file called sd-blob.img that is about 22 GB in size. Multiple Japanese setup articles show exactly this: zip ≈10 GB → sd-blob.img ≈22 GB, and they recommend using a 64 GB or larger card. ((Deliversary of Digital Light-light.))

So:

  • The image you wrote to the card contains its own partition table and partitions, sized for ~22 GB.
  • That layout is copied bit-for-bit to your microSD, regardless of the card’s real size.

1.2 Etcher just clones the image; it doesn’t “shrink” the card

Balena Etcher does not change the hardware capacity of the card. It just writes the image as-is. The usual confusion is:

  • After flashing, operating systems and file managers only show the usable partition(s), not the full raw device capacity.
  • Balena’s own docs and support threads confirm this: if a card looks “smaller” after flashing, it is because of the partitions in the image, not because Etcher damaged the card. (balenaForums)

So your 1 TB card is now:

  • physically ≈1 TB,
  • but with a partition table that defines only ~22 GB of space for the root filesystem plus some boot partitions,
  • leaving the rest as empty/unallocated space that the OS simply doesn’t mount.

That’s why Jetson “sees” it as ~22 GB.

2. Two main possibilities

Case A: Everything is normal, the image just uses 22 GB

This is the most likely case:

  • The JetPack SD image is fixed at ~22 GB. ((Deliversary of Digital Light-light.))
  • The Jetson Linux docs explain that the root partition is placed at the end and can be resized with resize2fs, often via an automatic oem-config / nvresizefs step on first boot. (NVIDIA Docs)
  • If that auto-resize did not run (or you interrupted setup), the system stays at ~22 GB.

Case B: The “1 TB” card is not really 1 TB

Unfortunately, there are many counterfeit “1 TB” microSD cards that are really ~16–32 GB with a lying controller.

If the raw device size is only ~22–32 GB when you inspect it from Linux, then:

  • the physical capacity is not 1 TB, or
  • the card is badly broken and only part of it is usable.

You cannot fix that in software; you replace the card.

The next step is to distinguish A vs B.

3. Step 1: Check the real card size on the Jetson

On the Jetson (booted from this SD card), run:

lsblk -o NAME,SIZE,TYPE,MOUNTPOINT

You will see something like one of these patterns.

Pattern 1: Card really is 1 TB (normal situation)

Example:

NAME         SIZE TYPE MOUNTPOINT
mmcblk0    931.5G disk 
├─mmcblk0p1  256M part /boot/firmware
└─mmcblk0p2   22G part /

Interpretation:

  • mmcblk0 (the whole SD card) is ≈931 GB → this matches a 1 TB card.
  • The root partition (mounted at /) is only 22 GB, which matches the sd-blob.img size.

This means:

  • Hardware is fine.
  • You just need to resize the partition / filesystem to use the rest of the card.

Pattern 2: Card is actually small or fake

Example:

NAME        SIZE TYPE MOUNTPOINT
mmcblk0    29.8G disk 
├─mmcblk0p1 256M part /boot/firmware
└─mmcblk0p2  22G part /

Here:

  • The whole device mmcblk0 is only 29.8 GB.
  • This does not match a true 1 TB card.

If you see this kind of total size, the card is not what it claims to be, or it is badly damaged.
In that case there is no safe way to “make it 1 TB” again; hardware is the limit.

4. If the card is really 1 TB: how to use the full space

Assuming lsblk shows the device as ~931 GB:

You have two clean options:

  1. Expand the root filesystem to the full card.
  2. Keep the 22 GB root, create an extra /data partition in the free space.

4.1 Option 1: Use NVIDIA’s resize script (preferred)

Jetson Linux includes an nvresizefs script and systemd service to expand the root filesystem after flashing. Documentation and package manifests list nvresizefs.sh under /usr/lib/nvidia/resizefs. (NVIDIA Docs)

On the Jetson:

ls /usr/lib/nvidia/resizefs

If you see nvresizefs.sh there, run:

sudo /usr/lib/nvidia/resizefs/nvresizefs.sh

What it does (high level):

  • Figures out which partition is your root (APP).
  • Uses resize2fs to grow it to fill the remaining space on the device. (NVIDIA Docs)

After it finishes:

sudo reboot

Then verify:

df -h /
lsblk -o NAME,SIZE,TYPE,MOUNTPOINT

Now / should be close to 1 TB (minus boot partitions and overhead).

If the script complains or refuses to run, note the exact message; the usual causes are unsupported layout or that it already resized once.

4.2 Option 2: Use gparted (GUI) to resize the root partition

If nvresizefs is missing or fails, you can use standard Linux tools.

On the Jetson:

sudo apt update
sudo apt install gparted
sudo gparted

In the gparted GUI:

  1. Select the SD card device (e.g. /dev/mmcblk0) at the top-right dropdown.

  2. Identify the large ext4 partition that is mounted as / (root).

  3. Right-click that partition → Resize/Move:

    • Drag the right edge to the end of the disk, or
    • Manually set “New size” to use all available free space.

  4. Apply the changes.

gparted will adjust the partition and run resize2fs for you. This is exactly what NVIDIA’s scripts use under the hood, just automated. (NVIDIA Developer Forums)

Finally:

df -h /

You should see near-1 TB available.

Important: only touch the big root partition. Leave small boot / firmware partitions alone.

4.3 Option 3: Keep root at 22 GB and add a /data partition

Sometimes it is actually nicer to keep the OS small and separate data:

  1. Use gparted on the Jetson:

    • Select the unallocated space after the existing partitions.
    • Create a new ext4 partition using all that free space.

  2. Note its name (e.g. /dev/mmcblk0p3).

  3. Format (if gparted didn’t already):

    sudo mkfs.ext4 /dev/mmcblk0p3

  4. Create a mount point and test:

    sudo mkdir /data
sudo mount /dev/mmcblk0p3 /data
df -h /data

  5. To mount automatically on boot, add a line to /etc/fstab like:

    /dev/mmcblk0p3  /data  ext4  defaults  0  2

This way:

  • / stays ~22 GB (OS, JetPack stuff).
  • /data gives you almost the full 1 TB for models, datasets, logs.
  • If you ever re-flash the OS, you can choose to leave /data alone.

5. If the card is not really 1 TB

If lsblk shows the entire device as only tens of GB (e.g. 29.8 GB, 59 GB, 119 GB), your situation is:

  • The card capacity is whatever that SIZE field is.
  • The “1 TB” printed on the label or product page is misleading.

To be absolutely sure, you can test from a PC with tools like:

  • f3probe / f3write (Linux, checks how much data can really be written).
  • h2testw (Windows, same idea). (Ask Ubuntu)

If those tests confirm a small real capacity, there is no software fix. You replace the card with a reputable 256 GB or 512 GB or 1 TB card.

6. Why this is different from your earlier SDK Manager problem

Your old problem:

  • SDK Manager’s “Target HW image folder” was stuck,
  • you tried to “flash to SD card” by pointing that host path at /media/rui/Boot, which is not how SD flashing works.

With Balena Etcher:

  • You bypassed SDK Manager entirely for the SD-boot OS,
  • you correctly wrote the NVIDIA sd-blob.img onto the card,
  • now the only remaining step is resizing / partitioning, not fixing host paths.

So the current issue is purely partition layout on the SD card, not JetPack / SDKM state.

7. Summary

  • The JetPack SD image for Jetson Orin Nano is about 22 GB, so after Etcher writes it, the root filesystem is ~22 GB, even on a 1 TB card. ((Deliversary of Digital Light-light.))

  • Etcher does not destroy card capacity; it just clones the image’s partition table. (balenaForums)

  • First check the real device size on the Jetson:

    • lsblk -o NAME,SIZE,TYPE,MOUNTPOINT

  • If the device is ≈1 TB:

    • Use NVIDIA’s nvresizefs.sh script or gparted to grow the root partition to fill the card, or
    • Keep / small and make an extra /data partition in the free space. (NVIDIA Docs)

  • If the device is only ~20–120 GB total:

    • The card is not truly 1 TB or is badly damaged; no software fix; replace the card and always verify capacity using tools like f3 / h2testw if you buy very large cards cheaply. (balenaForums)