code review 5675095: cmd/dist: fix pprof permissions

src/cmd/dist/build.c

 // Copyright 2012 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include "a.h"
 #include "arg.h"
 
 /*
  * Initialization for any invocation.
  */
 
 // The usual variables.
 char *goarch;
 char *gobin;
 char *gohostarch;
 char *gohostchar;
 char *gohostos;
 char *goos;
 char *goroot = GOROOT_FINAL;
 char *goroot_final = GOROOT_FINAL;
 char *workdir;
 char    *tooldir;
 char *gochar;
 char *goversion;
 char *slash;    // / for unix, \ for windows
 
 bool    rebuildall = 0;
 
 static bool shouldbuild(char*, char*);
-static void copy(char*, char*);
+static void copy(char*, char*, int);
 static char *findgoversion(void);
 
 // The known architecture letters.
 static char *gochars = "568";
 
 // The known architectures.
 static char *okgoarch[] = {
         // same order as gochars
         "arm",
         "amd64",
@@ skipping 197 matching lines @@
                 // Add extra information.
                 run(&bmore, goroot, CheckExit, "hg", "log", "--template", " +{node|short}", "-r", rev, nil);
                 chomp(&bmore);
         }
 ········
         bprintf(&b, "%s", tag);
         if(bmore.len > 0)
                 bwriteb(&b, &bmore);
 
         // Cache version.
-        writefile(&b, bstr(&path));
+        writefile(&b, bstr(&path), 0);
 
 done:
         p = btake(&b);
 ········
 ········
         bfree(&b);
         bfree(&path);
         bfree(&bmore);
         bfree(&branch);
         vfree(&tags);
@@ skipping 301 matching lines @@
         vinit(&lib);
         vinit(&extra);
 ········
         // path = full path to dir.
         bpathf(&path, "%s/src/%s", goroot, dir);
         name = lastelem(dir);
 
         // For misc/prof, copy into the tool directory and we're done.
         if(hasprefix(dir, "misc/")) {
                 copy(bpathf(&b, "%s/%s", tooldir, name),
-                        bpathf(&b1, "%s/misc/%s", goroot, name));
+                        bpathf(&b1, "%s/misc/%s", goroot, name), 1);
                 goto out;
         }
 
         // For release, cmd/prof and cmd/cov are not included.
         if((streq(dir, "cmd/cov") || streq(dir, "cmd/prof")) && !isdir(bstr(&path))) {
                 if(vflag > 1)
                         xprintf("skipping %s - does not exist\n", dir);
                 goto out;
         }
 
@@ skipping 162 matching lines @@
         for(i=0; i<lib.len && !stale; i++)
                 if(mtime(lib.p[i]) > ttarg)
                         stale = 1;
 ················
         if(!stale)
                 goto out;
 
         // For package runtime, copy some files into the work space.
         if(streq(dir, "pkg/runtime")) {
                 copy(bpathf(&b, "%s/arch_GOARCH.h", workdir),
-                        bpathf(&b1, "%s/arch_%s.h", bstr(&path), goarch));
+                        bpathf(&b1, "%s/arch_%s.h", bstr(&path), goarch), 0);
                 copy(bpathf(&b, "%s/defs_GOOS_GOARCH.h", workdir),
-                        bpathf(&b1, "%s/defs_%s_%s.h", bstr(&path), goos, goarch));
+                        bpathf(&b1, "%s/defs_%s_%s.h", bstr(&path), goos, goarch), 0);
                 copy(bpathf(&b, "%s/os_GOOS.h", workdir),
-                        bpathf(&b1, "%s/os_%s.h", bstr(&path), goos));
+                        bpathf(&b1, "%s/os_%s.h", bstr(&path), goos), 0);
                 copy(bpathf(&b, "%s/signals_GOOS.h", workdir),
-                        bpathf(&b1, "%s/signals_%s.h", bstr(&path), goos));
+                        bpathf(&b1, "%s/signals_%s.h", bstr(&path), goos), 0);
         }
 
         // Generate any missing files; regenerate existing ones.
         for(i=0; i<files.len; i++) {
                 p = files.p[i];
                 elem = lastelem(p);
                 for(j=0; j<nelem(gentab); j++) {
                         if(hasprefix(elem, gentab[j].nameprefix)) {
                                 if(vflag > 1)
                                         xprintf("generate %s\n", p);
@@ skipping 12 matching lines @@
                 if(find(p, missing.p, missing.len) >= 0)
                         fatal("missing file %s", p);
         built:;
         }
 
         // One more copy for package runtime.
         // The last batch was required for the generators.
         // This one is generated.
         if(streq(dir, "pkg/runtime")) {
                 copy(bpathf(&b, "%s/zasm_GOOS_GOARCH.h", workdir),
-                        bpathf(&b1, "%s/zasm_%s_%s.h", bstr(&path), goos, goarch));
+                        bpathf(&b1, "%s/zasm_%s_%s.h", bstr(&path), goos, goarch), 0);
         }
 ········
         // Generate .c files from .goc files.
         if(streq(dir, "pkg/runtime")) {·········
                 for(i=0; i<files.len; i++) {
                         p = files.p[i];
                         if(!hassuffix(p, ".goc"))
                                 continue;
                         // b = path/zp but with _goarch.c instead of .goc
                         bprintf(&b, "%s%sz%s", bstr(&path), slash, lastelem(p));
@@ skipping 125 matching lines @@
         // Remove target before writing it.
         xremove(link.p[2]);
 
         runv(nil, nil, CheckExit, &link);
 
 nobuild:
         // In package runtime, we install runtime.h and cgocall.h too,
         // for use by cgo compilation.
         if(streq(dir, "pkg/runtime")) {
                 copy(bpathf(&b, "%s/pkg/%s_%s/cgocall.h", goroot, goos, goarch),
-                        bpathf(&b1, "%s/src/pkg/runtime/cgocall.h", goroot));
+                        bpathf(&b1, "%s/src/pkg/runtime/cgocall.h", goroot), 0);
                 copy(bpathf(&b, "%s/pkg/%s_%s/runtime.h", goroot, goos, goarch),
-                        bpathf(&b1, "%s/src/pkg/runtime/runtime.h", goroot));
+                        bpathf(&b1, "%s/src/pkg/runtime/runtime.h", goroot), 0);
         }
 
 
 out:
         for(i=0; i<clean.len; i++)
                 xremove(clean.p[i]);
 
         bfree(&b);
         bfree(&b1);
         bfree(&path);
@@ skipping 93 matching lines @@
 out:
         bfree(&b);
         vfree(&lines);
         vfree(&fields);
 ········
         return ret;
 }
 
 // copy copies the file src to dst, via memory (so only good for small files).
 static void
-copy(char *dst, char *src)
+copy(char *dst, char *src, int exec)
 {
         Buf b;
 ········
         if(vflag > 1)
                 xprintf("cp %s %s\n", src, dst);
 
         binit(&b);
         readfile(&b, src);
-        writefile(&b, dst);
+        writefile(&b, dst, exec);
         bfree(&b);
 }
 
 // buildorder records the order of builds for the 'go bootstrap' command.
 static char *buildorder[] = {
         "lib9",
         "libbio",
         "libmach",
 ········
         "misc/pprof",
@@ skipping 437 matching lines @@
                 break;
         default:
                 usage();
         }ARGEND
 
         if(argc > 0)
                 usage();
 
         xprintf("%s\n", goversion);
 }