# kubectl get --raw "/api/v1/nodes/kind-worker/proxy/stats/summary" | grep imageFs -A 5
   "imageFs": {
    "time": "2024-02-26T14:40:12Z",
    "availableBytes": 21507072000,
    "capacityBytes": 31025332224,
    "usedBytes": 541495296,
    "inodesFree": 3668005,

service ImageService {
    // ListImages lists existing images.
    rpc ListImages(ListImagesRequest) returns (ListImagesResponse) {}
    // ImageStatus returns the status of the image. If the image is not
    // present, returns a response with ImageStatusResponse.Image set to
    // nil.
    rpc ImageStatus(ImageStatusRequest) returns (ImageStatusResponse) {}
    // PullImage pulls an image with authentication config.
    rpc PullImage(PullImageRequest) returns (PullImageResponse) {}
    // RemoveImage removes the image.
    // This call is idempotent, and must not return an error if the image has
    // already been removed.
    rpc RemoveImage(RemoveImageRequest) returns (RemoveImageResponse) {}
    // ImageFSInfo returns information of the filesystem that is used to store images.
    rpc ImageFsInfo(ImageFsInfoRequest) returns (ImageFsInfoResponse) {}
}

# crictl  imagefsinfo
{
  "status": {
    "timestamp": "1708958572632331985",
    "fsId": {
      "mountpoint": "/var/lib/containerd/io.containerd.snapshotter.v1.overlayfs"
    },
    "usedBytes": {
      "value": "541495296"
    },
    "inodesUsed": {
      "value": "18150"
    }
  }
}

...
    imageFsInfo, err := p.getFsInfo(fs.GetFsId())
    if err != nil {
        return nil, nil, fmt.Errorf("get filesystem info: %w", err)
    }
    if imageFsInfo != nil {
        // The image filesystem id is unknown to the local node or there's
        // an error on retrieving the stats. In these cases, we omit those
        // stats and return the best-effort partial result. See
        // https://github.com/kubernetes/heapster/issues/1793.
        imageFsRet.AvailableBytes = &imageFsInfo.Available
        imageFsRet.CapacityBytes = &imageFsInfo.Capacity
        imageFsRet.InodesFree = imageFsInfo.InodesFree
        imageFsRet.Inodes = imageFsInfo.Inodes
    }
...

func (p *criStatsProvider) getFsInfo(fsID *runtimeapi.FilesystemIdentifier) (*cadvisorapiv2.FsInfo, error) {
    if fsID == nil {
        klog.V(2).InfoS("Failed to get filesystem info: fsID is nil")
        return nil, nil
    }
    mountpoint := fsID.GetMountpoint()
    fsInfo, err := p.cadvisor.GetDirFsInfo(mountpoint)
    if err != nil {
        msg := "Failed to get the info of the filesystem with mountpoint"
        if errors.Is(err, cadvisorfs.ErrNoSuchDevice) ||
            errors.Is(err, cadvisorfs.ErrDeviceNotInPartitionsMap) ||
            errors.Is(err, cadvisormemory.ErrDataNotFound) {
            klog.V(2).InfoS(msg, "mountpoint", mountpoint, "err", err)
        } else {
            klog.ErrorS(err, msg, "mountpoint", mountpoint)
            return nil, fmt.Errorf("%s: %w", msg, err)
        }
        return nil, nil
    }
    return &fsInfo, nil
}

func (m *FilesystemIdentifier) GetMountpoint() string {
    if m != nil {
        return m.Mountpoint
    }
    return ""
}

# df -BKB
Filesystem     1kB-blocks      Used  Available Use% Mounted on
overlay        31025333kB 9502487kB 21506069kB  31% /
tmpfs             67109kB       0kB    67109kB   0% /dev
shm               67109kB       0kB    67109kB   0% /dev/shm
/dev/root      31025333kB 9502487kB 21506069kB  31% /var
tmpfs          16794874kB    9552kB 16785322kB   1% /run