mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

lockfile.c: introduce 'hold_lock_file_for_update_mode'

Browse Source 
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>
This commit is contained in:
Taylor Blau
2020-04-27 10:27:58 -06:00
committed by Junio C Hamano
parent bef0413c35
commit fa3bff2466
2 changed files with 38 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
lockfile.h
View File

@ -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 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)
{
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.
*/