Description

The config.New() function performs unnecessary filesystem lookups when running dockerd --version, which only needs to display version information.

FIXME reference:
https://github.com/moby/moby/blob/master/daemon/command/docker.go#L19

// FIXME(thaJeztah): config.New also looks up default binary-path, but this code is also executed when running "--version".
cfg, err := config.New()

Current behavior

When running dockerd --version, the following sequence occurs:

1. newDaemonCommand() is called
2. config.New() is executed
3. setPlatformDefaults() performs filesystem lookups
4. lookupBinPath("docker-proxy") searches multiple directories:
   • /usr/local/libexec/docker/
   • usr/libexec/docker/
   • /usr/local/lib/docker/
   • /usr/lib/docker/
   • Falls back to PATH lookup

This happens even though --version only needs to print version information and exit immediately.

Code reference:

https://github.com/moby/moby/blob/master/daemon/config/config_linux.go#L158-L170

Impact

• Performance overhead: ~50-100ms of unnecessary filesystem I/O (more on network filesystems)
• Unnecessary system calls: Multiple stat() calls on paths that may not exist
• Debug logs: In some cases, debug messages are logged (suppressed at debug level)
• Code clarity: Makes it unclear why binary path lookup is needed for --version

Proposed solutions

I see a few possible approaches, and I'd like to get maintainer feedback on which direction is preferred:

Option 1: Defer binary path lookup (Simple, recommended for short-term)

Delay the lookupBinPath() call until the daemon actually starts:

func setPlatformDefaults(cfg *Config) error {
    // Don't lookup binary path here
    cfg.BridgeConfig.UserlandProxyPath = ""  // Will be resolved later
    // ...
}

// Then in daemon startup:
func (daemon *Daemon) initNetworkController() error {
    if daemon.config.BridgeConfig.UserlandProxyPath == "" {
        path, err := lookupBinPath(userlandProxyBinary)
        // handle error...
        daemon.config.BridgeConfig.UserlandProxyPath = path
    }
    // ...
}

Pros:

• Minimal code changes
• No filesystem I/O for --version
• Easy to implement and test

Cons:

• Delays error detection (binary path issues only detected at daemon start)

Option 2: Split Config initialization (More architectural)

Separate minimal config (for CLI purposes) from full config (for daemon):

// Lightweight config creation (no filesystem access)
func NewMinimal() *Config { ... }

// Full config with platform defaults
func NewFull() (*Config, error) {
    cfg := NewMinimal()
    if err := setPlatformDefaults(cfg); err != nil {
        return nil, err
    }
    return cfg, nil
}

Pros:

• Clear separation of concerns
• Can be applied to other similar cases
  Better long-term architecture

Cons:

• Larger refactoring required
• Need to update all callers

Option 3: Lazy command construction

Only construct full daemon command when not running --version:

func newDaemonCommand() (*cobra.Command, error) {
    cmd := &cobra.Command{
        // ...
        RunE: func(cmd *cobra.Command, args []string) error {
            // Only now call config.New()
            cfg, err := config.New()
            // ...
        },
    }
    // ...
}

Pros:
--version skips config.New() entirely

• Clean conceptually

Cons:

• Flag setup might need restructuring
• More changes to command initialization

Questions for maintainers

1. Which approach aligns best with the project's direction?
2. Are there any other constraints or considerations I should be aware of?
3. Is this optimization worth pursuing, or are there higher priority items?
4. Would you accept a PR implementing one of these approaches?

Additional context

• This FIXME was added in: e8e20c0 (2024-01-09)
• The workaround currently is to log at debug level to avoid noise during --version
• Similar patterns might exist in other CLI tools in the repository