示例#1
0
// LoadBinaryFuzzesFromGoogleStorage pulls all fuzzes out of GCS that are on the given whitelist
// and loads them into memory (as staging).  After loading them, it updates the cache
// and moves them from staging to the current copy.
func (g *GSLoader) LoadBinaryFuzzesFromGoogleStorage(whitelist []string) error {
	revision := config.FrontEnd.SkiaVersion.Hash
	sort.Strings(whitelist)
	reports, err := g.getBinaryReportsFromGS(fmt.Sprintf("binary_fuzzes/%s/bad/", revision), whitelist)
	if err != nil {
		return err
	}
	fuzz.StagingFromCurrent()
	n := 0
	for report := range reports {
		if g.finder != nil {
			report.DebugStackTrace.LookUpFunctions(g.finder)
			report.ReleaseStackTrace.LookUpFunctions(g.finder)
		}
		fuzz.NewBinaryFuzzFound(report)
		n++
	}
	glog.Infof("%d new fuzzes loaded from Google Storage", n)
	fuzz.StagingToCurrent()

	_, oldBinaryFuzzNames, err := g.Cache.Load(revision)
	if err != nil {
		glog.Warningf("Could not read old binary fuzz names from cache.  Continuing...", err)
		oldBinaryFuzzNames = []string{}
	}

	return g.Cache.Store(fuzz.StagingCopy(), append(oldBinaryFuzzNames, whitelist...), revision)
}
示例#2
0
// LoadFromBoltDB loads the fuzz.FuzzReport from FuzzReportCache associated with the given hash.
// The FuzzReport is first put into the staging fuzz cache, and then into the current.
// If a cache for the commit does not exist, or there are other problems with the retrieval,
// an error is returned.
func LoadFromBoltDB(cache *fuzzcache.FuzzReportCache) error {
	glog.Infof("Looking into cache for revision %s", config.FrontEnd.SkiaVersion.Hash)
	if staging, fuzzes, err := cache.Load(config.FrontEnd.SkiaVersion.Hash); err != nil {
		return fmt.Errorf("Problem decoding existing from bolt db: %s", err)
	} else {
		fuzz.SetStaging(*staging)
		fuzz.StagingToCurrent()
		glog.Infof("Successfully loaded %d binary fuzzes from bolt db cache", len(fuzzes))
	}
	return nil
}
示例#3
0
// LoadFreshFromGoogleStorage pulls all fuzzes out of GCS and loads them into memory.
// The "fresh" in the name refers to the fact that all other loaded fuzzes (if any)
// are written over, including in the cache.
// Upon completion, the full results are cached to a boltDB instance and moved from staging
// to the current copy.
func (g *GSLoader) LoadFreshFromGoogleStorage() error {
	revision := config.FrontEnd.SkiaVersion.Hash
	reports, err := g.getBinaryReportsFromGS(fmt.Sprintf("binary_fuzzes/%s/bad/", revision), nil)
	if err != nil {
		return err
	}
	fuzz.ClearStaging()
	binaryFuzzNames := make([]string, 0, len(reports))
	for report := range reports {
		report.DebugStackTrace.LookUpFunctions(g.finder)
		report.ReleaseStackTrace.LookUpFunctions(g.finder)
		fuzz.NewBinaryFuzzFound(report)
		binaryFuzzNames = append(binaryFuzzNames, report.BadBinaryName)
	}
	glog.Infof("%d fuzzes freshly loaded from Google Storage", len(binaryFuzzNames))
	fuzz.StagingToCurrent()

	return g.Cache.Store(fuzz.StagingCopy(), binaryFuzzNames, revision)
}