lockfile.c: introduce 'hold_lock_file_for_update_mode'

We use 'hold_lock_file_for_update' (and the '_timeout') variant to
acquire a lock when updating references, the commit-graph file, and so
on.

In particular, the commit-graph machinery uses this to acquire a
temporary file that is used to write a non-split commit-graph. In a
subsequent commit, an issue in the commit-graph machinery produces
graph files that have a different permission based on whether or not
they are part of a multi-layer graph will be addressed.

To do so, the commit-graph machinery will need a version of
'hold_lock_file_for_update' that takes the permission bits from the
caller.

Introduce such a function in this patch for both the
'hold_lock_file_for_update' and 'hold_lock_file_for_update_timeout'
functions, and leave the existing functions alone by inlining their
definitions in terms of the new mode variants.

Note that, like in the previous commit, 'hold_lock_file_for_update_mode'
is not guarenteed to set the given mode, since it may be modified by
both the umask and 'core.sharedRepository'.

Note also that even though the commit-graph machinery only calls
'hold_lock_file_for_update', that this is defined in terms of
'hold_lock_file_for_update_timeout', and so both need an additional mode
parameter here.

Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/lockfile.c b/lockfile.c
index 8e8ab4f29f3eaf05f056211042b5fd2f01727363..cc9a4b84283be34cdcd72770d77e2ef1adb998a6 100644 (file)
--- a/lockfile.c
+++ b/lockfile.c
@@ -70,7 +70,8 @@ static void resolve_symlink(struct strbuf *path)
 }
 
 /* Make sure errno contains a meaningful value on error */
-static int lock_file(struct lock_file *lk, const char *path, int flags)
+static int lock_file(struct lock_file *lk, const char *path, int flags,
+                    int mode)
 {
        struct strbuf filename = STRBUF_INIT;
 
@@ -79,7 +80,7 @@ static int lock_file(struct lock_file *lk, const char *path, int flags)
                resolve_symlink(&filename);
 
        strbuf_addstr(&filename, LOCK_SUFFIX);
-       lk->tempfile = create_tempfile(filename.buf);
+       lk->tempfile = create_tempfile_mode(filename.buf, mode);
        strbuf_release(&filename);
        return lk->tempfile ? lk->tempfile->fd : -1;
 }
@@ -99,7 +100,7 @@ static int lock_file(struct lock_file *lk, const char *path, int flags)
  * exactly once. If timeout_ms is -1, try indefinitely.
  */
 static int lock_file_timeout(struct lock_file *lk, const char *path,
-                            int flags, long timeout_ms)
+                            int flags, long timeout_ms, int mode)
 {
        int n = 1;
        int multiplier = 1;
@@ -107,7 +108,7 @@ static int lock_file_timeout(struct lock_file *lk, const char *path,
        static int random_initialized = 0;
 
        if (timeout_ms == 0)
-               return lock_file(lk, path, flags);
+               return lock_file(lk, path, flags, mode);
 
        if (!random_initialized) {
                srand((unsigned int)getpid());
@@ -121,7 +122,7 @@ static int lock_file_timeout(struct lock_file *lk, const char *path,
                long backoff_ms, wait_ms;
                int fd;
 
-               fd = lock_file(lk, path, flags);
+               fd = lock_file(lk, path, flags, mode);
 
                if (fd >= 0)
                        return fd; /* success */
@@ -169,10 +170,11 @@ NORETURN void unable_to_lock_die(const char *path, int err)
 }
 
 /* This should return a meaningful errno on failure */
-int hold_lock_file_for_update_timeout(struct lock_file *lk, const char *path,
-                                     int flags, long timeout_ms)
+int hold_lock_file_for_update_timeout_mode(struct lock_file *lk,
+                                          const char *path, int flags,
+                                          long timeout_ms, int mode)
 {
-       int fd = lock_file_timeout(lk, path, flags, timeout_ms);
+       int fd = lock_file_timeout(lk, path, flags, timeout_ms, mode);
        if (fd < 0) {
                if (flags & LOCK_DIE_ON_ERROR)
                        unable_to_lock_die(path, errno);

diff --git a/lockfile.h b/lockfile.h
index 9843053ce8940391834a86b122d1f64d5b345edf..db93e6ba73e68ddcd114da0c75e5217a33b5a395 100644 (file)
--- a/lockfile.h
+++ b/lockfile.h
@@ -90,6 +90,15 @@
  * functions. In particular, the state diagram and the cleanup
  * machinery are all implemented in the tempfile module.
  *
+ * Permission bits
+ * ---------------
+ *
+ * If you call either `hold_lock_file_for_update_mode` or
+ * `hold_lock_file_for_update_timeout_mode`, you can specify a suggested
+ * mode for the underlying temporary file. Note that the file isn't
+ * guaranteed to have this exact mode, since it may be limited by either
+ * the umask, 'core.sharedRepository', or both. See `adjust_shared_perm`
+ * for more.
  *
  * Error handling
  * --------------
@@ -156,12 +165,20 @@ struct lock_file {
  * file descriptor for writing to it, or -1 on error. If the file is
  * currently locked, retry with quadratic backoff for at least
  * timeout_ms milliseconds. If timeout_ms is 0, try exactly once; if
- * timeout_ms is -1, retry indefinitely. The flags argument and error
- * handling are described above.
+ * timeout_ms is -1, retry indefinitely. The flags argument, error
+ * handling, and mode are described above.
  */
-int hold_lock_file_for_update_timeout(
+int hold_lock_file_for_update_timeout_mode(
+               struct lock_file *lk, const char *path,
+               int flags, long timeout_ms, int mode);
+
+static inline int hold_lock_file_for_update_timeout(
                struct lock_file *lk, const char *path,
-               int flags, long timeout_ms);
+               int flags, long timeout_ms)
+{
+       return hold_lock_file_for_update_timeout_mode(lk, path, flags,
+                                                     timeout_ms, 0666);
+}
 
 /*
  * Attempt to create a lockfile for the file at `path` and return a
@@ -175,6 +192,13 @@ static inline int hold_lock_file_for_update(
        return hold_lock_file_for_update_timeout(lk, path, flags, 0);
 }
 
+static inline int hold_lock_file_for_update_mode(
+               struct lock_file *lk, const char *path,
+               int flags, int mode)
+{
+       return hold_lock_file_for_update_timeout_mode(lk, path, flags, 0, mode);
+}
+
 /*
  * Return a nonzero value iff `lk` is currently locked.
  */