查找用于计算docker图像大小的源代码

我听说这个数字并不等于图像中所有大小的层加在一起。而且它也不是它所占用的磁盘空间大小

现在我想通过源代码检查逻辑（在这个repo:），因为眼见为实！但是在浏览代码很多时间后，我发现我无法找到真正的imag大小的计算代码

那么docker使用哪个函数/文件来执行大小逻辑呢

您可以在

$ docker image ls
REPOSITORY  TAG                 IMAGE ID            CREATED             SIZE
nginx       1.12-alpine         24ed1c575f81        2 years ago        15.5MB

这个函数代码在这里

并从该代码中获取大小

最后你需要

---

在深入挖掘之前，您可能会发现了解Linux如何实现覆盖文件系统很有用。在我的第一个练习中，我包括了一些关于这个的内容。包括我正在运行的每个命令，它让您了解层是如何合并的，以及添加/修改/删除层时会发生什么

---

这取决于实现，取决于您的主机操作系统和正在使用的图形驱动程序。我以Linux操作系统和Overly2为例，因为这是最常见的用例

它从查看图像开始：

在中，有一个对

layerStores

的调用，其本身是：

深入到

层。存储
实现的
GetRWLayer
，有：

接下来，要查找mount引用的
大小
实现，需要进入特定的图形驱动程序：

func (ml *mountedLayer) Size() (int64, error) {
    return ml.layerStore.driver.DiffSize(ml.mountID, ml.cacheParent())
}

查看Overly2图形驱动程序以查找：

这是调用naiveDiff的

以下
archive.ChangeSize
我们可以看到：

此时，我们使用
os.Lstat
返回一个结构，该结构在每个目录的添加或修改条目上都包含
Size
。请注意，这是代码可能采用的几种路径之一，但我相信这是这种情况下更常见的路径之一。
非常有启发性。向上投票。另外，我听过，所以。。。只要我能，我就会尽力帮忙！
// ImageServiceConfig is the configuration used to create a new ImageService
type ImageServiceConfig struct {
    ContainerStore            containerStore
    DistributionMetadataStore metadata.Store
    EventsService             *daemonevents.Events
    ImageStore                image.Store
    LayerStores               map[string]layer.Store
    MaxConcurrentDownloads    int
    MaxConcurrentUploads      int
    MaxDownloadAttempts       int
    ReferenceStore            dockerreference.Store
    RegistryService           registry.Service
    TrustKey                  libtrust.PrivateKey
}

func (ls *layerStore) GetRWLayer(id string) (RWLayer, error) {
    ls.locker.Lock(id)
    defer ls.locker.Unlock(id)

    ls.mountL.Lock()
    mount := ls.mounts[id]
    ls.mountL.Unlock()
    if mount == nil {
        return nil, ErrMountDoesNotExist
    }

    return mount.getReference(), nil
}

func (ml *mountedLayer) Size() (int64, error) {
    return ml.layerStore.driver.DiffSize(ml.mountID, ml.cacheParent())
}

func (d *Driver) DiffSize(id, parent string) (size int64, err error) {
    if useNaiveDiff(d.home) || !d.isParent(id, parent) {
        return d.naiveDiff.DiffSize(id, parent)
    }
    return directory.Size(context.TODO(), d.getDiffPath(id))
}

func (gdw *NaiveDiffDriver) DiffSize(id, parent string) (size int64, err error) {
    driver := gdw.ProtoDriver

    changes, err := gdw.Changes(id, parent)
    if err != nil {
        return
    }

    layerFs, err := driver.Get(id, "")
    if err != nil {
        return
    }
    defer driver.Put(id)

    return archive.ChangesSize(layerFs.Path(), changes), nil
}

// ChangesSize calculates the size in bytes of the provided changes, based on newDir.
func ChangesSize(newDir string, changes []Change) int64 {
    var (
        size int64
        sf   = make(map[uint64]struct{})
    )
    for _, change := range changes {
        if change.Kind == ChangeModify || change.Kind == ChangeAdd {
            file := filepath.Join(newDir, change.Path)
            fileInfo, err := os.Lstat(file)
            if err != nil {
                logrus.Errorf("Can not stat %q: %s", file, err)
                continue
            }

            if fileInfo != nil && !fileInfo.IsDir() {
                if hasHardlinks(fileInfo) {
                    inode := getIno(fileInfo)
                    if _, ok := sf[inode]; !ok {
                        size += fileInfo.Size()
                        sf[inode] = struct{}{}
                    }
                } else {
                    size += fileInfo.Size()
                }
            }
        }
    }
    return size
}