Source file src/pkg/cmd/go/internal/cache/hash.go

     1	// Copyright 2017 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package cache
     6	
     7	import (
     8		"bytes"
     9		"crypto/sha256"
    10		"fmt"
    11		"hash"
    12		"io"
    13		"os"
    14		"runtime"
    15		"sync"
    16	)
    17	
    18	var debugHash = false // set when GODEBUG=gocachehash=1
    19	
    20	// HashSize is the number of bytes in a hash.
    21	const HashSize = 32
    22	
    23	// A Hash provides access to the canonical hash function used to index the cache.
    24	// The current implementation uses salted SHA256, but clients must not assume this.
    25	type Hash struct {
    26		h    hash.Hash
    27		name string        // for debugging
    28		buf  *bytes.Buffer // for verify
    29	}
    30	
    31	// hashSalt is a salt string added to the beginning of every hash
    32	// created by NewHash. Using the Go version makes sure that different
    33	// versions of the go command (or even different Git commits during
    34	// work on the development branch) do not address the same cache
    35	// entries, so that a bug in one version does not affect the execution
    36	// of other versions. This salt will result in additional ActionID files
    37	// in the cache, but not additional copies of the large output files,
    38	// which are still addressed by unsalted SHA256.
    39	var hashSalt = []byte(runtime.Version())
    40	
    41	// Subkey returns an action ID corresponding to mixing a parent
    42	// action ID with a string description of the subkey.
    43	func Subkey(parent ActionID, desc string) ActionID {
    44		h := sha256.New()
    45		h.Write([]byte("subkey:"))
    46		h.Write(parent[:])
    47		h.Write([]byte(desc))
    48		var out ActionID
    49		h.Sum(out[:0])
    50		if debugHash {
    51			fmt.Fprintf(os.Stderr, "HASH subkey %x %q = %x\n", parent, desc, out)
    52		}
    53		if verify {
    54			hashDebug.Lock()
    55			hashDebug.m[out] = fmt.Sprintf("subkey %x %q", parent, desc)
    56			hashDebug.Unlock()
    57		}
    58		return out
    59	}
    60	
    61	// NewHash returns a new Hash.
    62	// The caller is expected to Write data to it and then call Sum.
    63	func NewHash(name string) *Hash {
    64		h := &Hash{h: sha256.New(), name: name}
    65		if debugHash {
    66			fmt.Fprintf(os.Stderr, "HASH[%s]\n", h.name)
    67		}
    68		h.Write(hashSalt)
    69		if verify {
    70			h.buf = new(bytes.Buffer)
    71		}
    72		return h
    73	}
    74	
    75	// Write writes data to the running hash.
    76	func (h *Hash) Write(b []byte) (int, error) {
    77		if debugHash {
    78			fmt.Fprintf(os.Stderr, "HASH[%s]: %q\n", h.name, b)
    79		}
    80		if h.buf != nil {
    81			h.buf.Write(b)
    82		}
    83		return h.h.Write(b)
    84	}
    85	
    86	// Sum returns the hash of the data written previously.
    87	func (h *Hash) Sum() [HashSize]byte {
    88		var out [HashSize]byte
    89		h.h.Sum(out[:0])
    90		if debugHash {
    91			fmt.Fprintf(os.Stderr, "HASH[%s]: %x\n", h.name, out)
    92		}
    93		if h.buf != nil {
    94			hashDebug.Lock()
    95			if hashDebug.m == nil {
    96				hashDebug.m = make(map[[HashSize]byte]string)
    97			}
    98			hashDebug.m[out] = h.buf.String()
    99			hashDebug.Unlock()
   100		}
   101		return out
   102	}
   103	
   104	// In GODEBUG=gocacheverify=1 mode,
   105	// hashDebug holds the input to every computed hash ID,
   106	// so that we can work backward from the ID involved in a
   107	// cache entry mismatch to a description of what should be there.
   108	var hashDebug struct {
   109		sync.Mutex
   110		m map[[HashSize]byte]string
   111	}
   112	
   113	// reverseHash returns the input used to compute the hash id.
   114	func reverseHash(id [HashSize]byte) string {
   115		hashDebug.Lock()
   116		s := hashDebug.m[id]
   117		hashDebug.Unlock()
   118		return s
   119	}
   120	
   121	var hashFileCache struct {
   122		sync.Mutex
   123		m map[string][HashSize]byte
   124	}
   125	
   126	// FileHash returns the hash of the named file.
   127	// It caches repeated lookups for a given file,
   128	// and the cache entry for a file can be initialized
   129	// using SetFileHash.
   130	// The hash used by FileHash is not the same as
   131	// the hash used by NewHash.
   132	func FileHash(file string) ([HashSize]byte, error) {
   133		hashFileCache.Lock()
   134		out, ok := hashFileCache.m[file]
   135		hashFileCache.Unlock()
   136	
   137		if ok {
   138			return out, nil
   139		}
   140	
   141		h := sha256.New()
   142		f, err := os.Open(file)
   143		if err != nil {
   144			if debugHash {
   145				fmt.Fprintf(os.Stderr, "HASH %s: %v\n", file, err)
   146			}
   147			return [HashSize]byte{}, err
   148		}
   149		_, err = io.Copy(h, f)
   150		f.Close()
   151		if err != nil {
   152			if debugHash {
   153				fmt.Fprintf(os.Stderr, "HASH %s: %v\n", file, err)
   154			}
   155			return [HashSize]byte{}, err
   156		}
   157		h.Sum(out[:0])
   158		if debugHash {
   159			fmt.Fprintf(os.Stderr, "HASH %s: %x\n", file, out)
   160		}
   161	
   162		SetFileHash(file, out)
   163		return out, nil
   164	}
   165	
   166	// SetFileHash sets the hash returned by FileHash for file.
   167	func SetFileHash(file string, sum [HashSize]byte) {
   168		hashFileCache.Lock()
   169		if hashFileCache.m == nil {
   170			hashFileCache.m = make(map[string][HashSize]byte)
   171		}
   172		hashFileCache.m[file] = sum
   173		hashFileCache.Unlock()
   174	}
   175	

View as plain text