[compiler-rt] Add a routine to specify the mode used when creating profile dirs.

[mattd]

Summary

This patch introduces llvm_profile_set_dir_mode and llvm_profile_get_dir_mode to
the compiler-rt profile API.

Originally, profile data was placed into a directory that was created with a hard-coded
mode value of 0755 (for non-win32 builds). In certain cases, it can be helpful to create
directories with a different mode other than 0755. This patch introduces set/get
routines to allow users to specify a desired mode. The default remains at 0755.

[probinson]

Is it possible/reasonable for the test to call __llvm_profile_recursive_mkdir and then verify the mode of the created directory?
The test would have to be flagged as unsupported on Windows but that seems fine.

[mattd]

In D49953#1180466, @probinson wrote:

Is it possible/reasonable for the test to call __llvm_profile_recursive_mkdir and then verify the mode of the created directory?
The test would have to be flagged as unsupported on Windows but that seems fine.

That't totally possible, as long as it's fine to call fstat()/stat() to gather the mode value on the resulting directory. We'd also
need to get the umask() so that we can ensure that the correct value is set with respect to the user's umask.

[mattd]

• Added a test that creates a directory via __llvm_profile_recursive_mkdir and verifies the mode.
• I intend to only commit one of the two tests, but wanted to provide a more specific/detailed test.
  • I don't know if we really want such a specific test, but it's a potential start at one.
• We can definitely ignore windows here (since there is no mode passed to its equivalent to mkdir).
• I don't know if there are other systems we need to ignore, e.g., android?
• I'm still hesitant to adding the more specific test, it feels very os specific.
• I didn't see an alternative to FileCheck's (deprecated) %T, so I wrote a simple 'dirname' routine that is not dependent on libgen.
  • I hope that is sufficient for this test case.

[mattd]

• Renamed the test output and test directory to clean up the more specific test example.

[mattd]

• Simplify the test case, let the compiler join the literals for us.

[probinson]

Using %t with suffixes instead of %T is the preferred idiom, glad you worked that out.
The more elaborate test depends on a set of Posix-y calls, but that's fine. If there are more environments that can't handle it, the bots will find them for you. :-)
LGTM with the fancier test, once you fix the missing RUN. (The RUN prefixes are how lit decides which lines are the test script.)

test/profile/instrprof-set-dir-mode2.c

3 ↗

(On Diff #158298)

This needs a RUN: in front of it, I think.

lib/profile/InstrProfilingUtil.h

 #define PROFILE_INSTRPROFILINGUTIL_H
 
 #include <stddef.h>
 #include <stdio.h>
 
 /*! \brief Create a directory tree. */
 void __llvm_profile_recursive_mkdir(char *Pathname);
 
+/*! Set the mode used when creating profile directories. */
+void __llvm_profile_set_dir_mode(unsigned Mode);
+
+/*! Return the directory creation mode. */
+unsigned __llvm_profile_get_dir_mode(void);
+
 int lprofLockFd(int fd);
 int lprofUnlockFd(int fd);
 
 /*! Open file \c Filename for read+write with write
  * lock for exclusive access. The caller will block
  * if the lock is already held by another process. */
 FILE *lprofOpenFileEx(const char *Filename);
 /* PS4 doesn't have getenv. Define a shim. */

lib/profile/InstrProfilingUtil.c

 #if defined(__linux__)
 #include <signal.h>
 #include <sys/prctl.h>
 #endif
 
 #include "InstrProfiling.h"
 #include "InstrProfilingUtil.h"
 
+COMPILER_RT_WEAK unsigned lprofDirMode = 0755;
+
 COMPILER_RT_VISIBILITY
 void __llvm_profile_recursive_mkdir(char *path) {
   int i;
 
   for (i = 1; path[i] != '\0'; ++i) {
     char save = path[i];
     if (!IS_DIR_SEPARATOR(path[i]))
       continue;
     path[i] = '\0';
 #ifdef _WIN32
     _mkdir(path);
 #else
-    mkdir(path, 0755); /* Some of these will fail, ignore it. */
+    /* Some of these will fail, ignore it. */
+    mkdir(path, __llvm_profile_get_dir_mode());
 #endif
     path[i] = save;
   }
 }
 
+COMPILER_RT_VISIBILITY
+void __llvm_profile_set_dir_mode(unsigned Mode) { lprofDirMode = Mode; }
+
+COMPILER_RT_VISIBILITY
+unsigned __llvm_profile_get_dir_mode(void) { return lprofDirMode; }
+
 #if COMPILER_RT_HAS_ATOMICS != 1
 COMPILER_RT_VISIBILITY
 uint32_t lprofBoolCmpXchg(void **Ptr, void *OldV, void *NewV) {
   void *R = *Ptr;
   if (R == OldV) {
     *Ptr = NewV;
     return 1;
   }

test/profile/instrprof-set-dir-mode.c

+// UNSUPPORTED: windows
+// RUN: %clang_pgogen -o %t.bin %s -DTESTPATH=\"%t.dir\"
+// RUN: rm -rf %t.dir
+// RUN: %run %t.bin
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+void __llvm_profile_set_dir_mode(unsigned Mode);
+unsigned __llvm_profile_get_dir_mode(void);
+void __llvm_profile_recursive_mkdir(char *Path);
+
+static int test(unsigned Mode, const char *TestDir) {
+  int Ret = 0;
+
+  /* Create a dir and set the mode accordingly. */
+  char *Dir = strdup(TestDir);
+  if (!Dir)
+    return -1;
+  __llvm_profile_set_dir_mode(Mode);
+  __llvm_profile_recursive_mkdir(Dir);
+
+  if (Mode != __llvm_profile_get_dir_mode())
+    Ret = -1;
+  else {
+    const unsigned Expected = ~umask(0) & Mode;
+    struct stat DirSt;
+    if (stat(Dir, &DirSt) == -1)
+      Ret = -1;
+    else if (DirSt.st_mode != Expected) {
+      printf("Modes do not match: Expected %o but found %o (%s)\n", Expected,
+             DirSt.st_mode, Dir);
+      Ret = -1;
+    }
+  }
+
+  free(Dir);
+  return Ret;
+}
+
+int main(void) {
+  if (test(S_IFDIR | 0777, TESTPATH "/foo/bar/baz/") ||
+      test(S_IFDIR | 0666, TESTPATH "/foo/bar/qux/"))
+    return -1;
+  return 0;
+}