tempfile: stop using the_repository
cover tempfile: stop using the_repository
create_tempfile_mode() and create_tempfile() use the_repository internally to call adjust_shared_perm(). Expose that dependency and push it out to their callers.
Patch 5 is a bonus; it converts lockfile users that already work with other repositories.
tempfile: add repo_create_tempfile{,_mode}()
refs/packed: use repo_create_tempfile()
lockfile: add repo_hold_lock_file_for_update{,_timeout}{,_mode}()
tempfile: stop using the_repository
use repo_hold_lock_file_for_update{,_mode,_timeout}() with custom repos
apply.c | 10 ++++++---- builtin/difftool.c | 2 +- builtin/gc.c | 2 +- builtin/history.c | 2 +- builtin/sparse-checkout.c | 3 ++- bundle.c | 4 ++-- commit-graph.c | 9 +++++---- config.c | 4 ++-- lockfile.c | 30 ++++++++++++++++++++++-------- lockfile.h | 31 +++++++++++++++++++++++++++++++ loose.c | 6 ++++-- midx-write.c | 7 ++++--- odb/source-files.c | 3 ++- refs/files-backend.c | 10 ++++++---- refs/packed-backend.c | 9 ++++----- refs/packed-backend.h | 2 +- repack-midx.c | 3 ++- repository.c | 2 +- rerere.c | 6 +++--- tempfile.c | 7 +++---- tempfile.h | 10 +++++++--- 21 files changed, 110 insertions(+), 52 deletions(-)
Signature · 1 line
2.55.0
PATCH 1/5 tempfile: add repo_create_tempfile{,_mode}()
Add variants of create_tempfile_mode() that handle arbitrary repositories.
--- tempfile.c | 8 +++++++- tempfile.h | 11 +++++++++++ 2 files changed, 18 insertions(+), 1 deletion(-)
tempfile.c +7 -1
@@ -135,6 +135,12 @@ static void deactivate_tempfile(struct tempfile *tempfile)/* Make sure errno contains a meaningful value on error */ struct tempfile *create_tempfile_mode (const char *path,int mode) +{ +return repo_create_tempfile_mode (the_repository, path, mode); +} + +struct tempfile *repo_create_tempfile_mode (struct repository *r, +const char *path,int mode) {struct tempfile *tempfile =new_tempfile ();
@@ -150,7 +156,7 @@ struct tempfile *create_tempfile_mode(const char *path, int mode)return NULL ; }activate_tempfile (tempfile); -if (adjust_shared_perm (the_repository, tempfile->filename.buf)) { +if (adjust_shared_perm (r, tempfile->filename.buf)) {int save_errno = errno;error ("cannot fix permission bits on %s" , tempfile->filename.buf);delete_tempfile (&tempfile);
tempfile.h +11 -0
@@ -4,6 +4,8 @@#include "list.h" #include "strbuf.h" +struct repository ; +/* * Handle temporary files. *
@@ -94,11 +96,20 @@ struct tempfile {*/ struct tempfile *create_tempfile_mode (const char *path,int mode); +struct tempfile *repo_create_tempfile_mode (struct repository *r, +const char *path,int mode); +static inline struct tempfile *create_tempfile (const char *path) {return create_tempfile_mode (path,0666 ); } +static inline struct tempfile *repo_create_tempfile (struct repository *r, +const char *path) +{ +return repo_create_tempfile_mode (r, path,0666 ); +} +/* * Register an existing file as a tempfile, meaning that it will be * deleted when the program exits. The tempfile is considered closed,
Signature · 1 line
2.55.0
Re: [PATCH 1/5] tempfile: add repo_create_tempfile{,_mode}()
Quoted 2 lines · René Scharfe
Add variants of
create_tempfile_mode()that handle arbitrary repositories.
One thing I was wondering is whether it really makes sense to pass in a full repository. All we require it for is adjust_shared_perm(), and it feels quite extreme to require a full-blown repository.
An alternative would be to let callers pass in the setting by themselves, but that would likely lead to lots of duplicated code. So maybe this is a good first step, and we could eventually create another API where users can pass in the configuration instead of a repository if we ever gain callers that don't have a repository available.
tempfile.c static void deactivate_tempfile(struct tempfile *tempfile) · line 140
Quoted 11 lines
tempfile.c +3
-0@@ -135,6 +135,12 @@ static void deactivate_tempfile(struct tempfile *tempfile)/* Make sure errno contains a meaningful value on error */ struct tempfile *create_tempfile_mode (const char *path,int mode) +{ +return repo_create_tempfile_mode (the_repository, path, mode); +}
Nit: We could've easily created this as an inline function in "tempfile.h". But I expect that we'll get mostly rid of this function in subssubsequent patches, so it probably doesn't matter too much.
Patrick
Re: [PATCH 1/5] tempfile: add repo_create_tempfile{,_mode}()
Quoted 8 lines · Patrick Steinhardt
Quoted 2 lines · René Scharfe
Add variants of
create_tempfile_mode()that handle arbitrary repositories.One thing I was wondering is whether it really makes sense to pass in a full repository. All we require it for is
adjust_shared_perm(), and it feels quite extreme to require a full-blown repository.
Quoted 5 lines
An alternative would be to let callers pass in the setting by themselves, but that would likely lead to lots of duplicated code. So maybe this is a good first step, and we could eventually create another API where users can pass in the configuration instead of a repository if we ever gain callers that don't have a repository available.
Had the same thought. I think it's because create_tempfile() sounds quite generic, but is actually for creating temporary files within a repository, not just anywhere or just for the duration of the creating process, so shared access matters (if enabled).
I didn't find a case where a caller would not have at least the_repository to pass in, so while a repo-less adjust_shared_perm() or create_tempfile() might seem cleaner, we probably won't need it in practice. We'll find out..
René
PATCH 2/5 refs/packed: use repo_create_tempfile()
In reply to René ScharfeApply the config setting core.sharedRepository from the ref store base repository at hand instead of from the_repository.
--- refs/packed-backend.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
refs/packed-backend.c +1 -1
@@ -1393,7 +1393,7 @@ static enum ref_transaction_error write_with_updates(struct packed_ref_store *re packed_refs_path =get_locked_file_path (&refs->lock);strbuf_addf (&sb,"%s.new" , packed_refs_path);free (packed_refs_path); - refs->tempfile =create_tempfile (sb.buf); + refs->tempfile =repo_create_tempfile (refs->base.repo, sb.buf);if (!refs->tempfile) {strbuf_addf (err,"unable to create file %s: %s" , sb.buf,strerror (errno));
Signature · 1 line
2.55.0
PATCH 3/5 lockfile: add repo_hold_lock_file_for_update{,_timeout}{,_mode}()
In reply to René ScharfeAdd variants of hold_lock_file_for_update_timeout_mode() that handle arbitrary repositories.
--- lockfile.c | 30 ++++++++++++++++++++++-------- lockfile.h | 31 +++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 8 deletions(-)
lockfile.c +22 -8
@@ -2,11 +2,14 @@* Copyright (c) 2005, Junio C Hamano */ +#define USE_THE_REPOSITORY_VARIABLE +#include "git-compat-util.h" #include "abspath.h" #include "gettext.h" #include "lockfile.h" #include "parse.h" +#include "repository.h" #include "strbuf.h" #include "wrapper.h"
@@ -162,8 +165,8 @@ static int read_lock_pid(const char *pid_path, uintmax_t *pid_out) }/* Make sure errno contains a meaningful value on error */ -static int lock_file (struct lock_file *lk,const char *path,int flags, -int mode) +static int lock_file (struct repository *r,struct lock_file *lk, +const char *path,int flags,int mode) {struct strbuf base_path =STRBUF_INIT ;struct strbuf lock_path =STRBUF_INIT ;
@@ -176,7 +179,7 @@ static int lock_file(struct lock_file *lk, const char *path, int flags,get_lock_path (&lock_path, base_path.buf);get_pid_path (&pid_path, base_path.buf); - lk->tempfile =create_tempfile_mode (lock_path.buf, mode); + lk->tempfile =repo_create_tempfile_mode (r, lock_path.buf, mode);if (lk->tempfile) lk->pid_tempfile =create_lock_pid_file (pid_path.buf, mode);
@@ -200,8 +203,9 @@ static int lock_file(struct lock_file *lk, const char *path, int flags,* timeout_ms milliseconds. If timeout_ms is 0, try locking the file * 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 mode) +static int lock_file_timeout (struct repository *r,struct lock_file *lk, +const char *path,int flags,long timeout_ms, +int mode) {int n =1 ;int multiplier =1 ;
@@ -209,7 +213,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, mode); +return lock_file (r, lk, path, flags, mode);if (!random_initialized) {srand ((unsigned int )getpid ());
@@ -223,7 +227,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, mode); + fd =lock_file (r, lk, path, flags, mode);if (fd >=0 )return fd;/* success */
@@ -308,7 +312,17 @@ 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, mode); + return repo_hold_lock_file_for_update_timeout_mode(the_repository, +lk ,path ,flags , +timeout_ms ,mode ); +} + +int repo_hold_lock_file_for_update_timeout_mode (struct repository *r, +struct lock_file *lk, +const char *path,int flags, +long timeout_ms,int mode) +{ +int fd =lock_file_timeout (r, lk, path, flags, timeout_ms, mode);if (fd <0 ) {if (flags &LOCK_DIE_ON_ERROR )unable_to_lock_die (path, errno);
lockfile.h +31 -0
@@ -189,6 +189,11 @@ int hold_lock_file_for_update_timeout_mode( struct lock_file *lk, const char *path, int flags, long timeout_ms, int mode); +int repo_hold_lock_file_for_update_timeout_mode (struct repository *r, +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)
@@ -197,6 +202,16 @@ static inline int hold_lock_file_for_update_timeout( timeout_ms, 0666); } +static inline int repo_hold_lock_file_for_update_timeout (struct repository *r, +struct lock_file *lk, +const char *path, +int flags, +long timeout_ms) +{ +return repo_hold_lock_file_for_update_timeout_mode (r, lk, path, flags, + timeout_ms,0666 ); +} +/* * Attempt to create a lockfile for the file at `path` and return a * file descriptor for writing to it, or -1 on error. The flags
@@ -208,6 +223,13 @@ static inline int hold_lock_file_for_update(return hold_lock_file_for_update_timeout (lk, path, flags,0 ); } +static inline int repo_hold_lock_file_for_update (struct repository *r, +struct lock_file *lk, +const char *path,int flags) +{ +return repo_hold_lock_file_for_update_timeout (r, lk, path, flags,0 ); +} +static inline int hold_lock_file_for_update_mode (struct lock_file *lk,const char *path,int flags,int mode)
@@ -215,6 +237,15 @@ static inline int hold_lock_file_for_update_mode(return hold_lock_file_for_update_timeout_mode (lk, path, flags,0 , mode); } +static inline int repo_hold_lock_file_for_update_mode (struct repository *r, +struct lock_file *lk, +const char *path, +int flags,int mode) +{ +return repo_hold_lock_file_for_update_timeout_mode (r, lk, path, flags, +0 , mode); +} +/* * Return a nonzero value iff `lk` is currently locked. */
Signature · 1 line
2.55.0
PATCH 4/5 tempfile: stop using the_repository
In reply to René ScharfeRemove the compatibility wrappers create_tempfile_mode() and create_tempfile() that have become unused.
--- tempfile.c | 7 ------- tempfile.h | 7 ------- 2 files changed, 14 deletions(-)
tempfile.c +0 -7
@@ -42,8 +42,6 @@* file created by its parent. */ -#define USE_THE_REPOSITORY_VARIABLE -#include "git-compat-util.h" #include "abspath.h" #include "path.h"
@@ -134,11 +132,6 @@ static void deactivate_tempfile(struct tempfile *tempfile) }/* Make sure errno contains a meaningful value on error */ -struct tempfile *create_tempfile_mode (const char *path,int mode) -{ -return repo_create_tempfile_mode (the_repository, path, mode); -} -struct tempfile *repo_create_tempfile_mode (struct repository *r,const char *path,int mode) {
tempfile.h +0 -7
@@ -94,16 +94,9 @@ struct tempfile {* `core.sharedRepository`, so it is not guaranteed to have the given * mode. */ -struct tempfile *create_tempfile_mode (const char *path,int mode); -struct tempfile *repo_create_tempfile_mode (struct repository *r,const char *path,int mode); -static inline struct tempfile *create_tempfile (const char *path) -{ -return create_tempfile_mode (path,0666 ); -} -static inline struct tempfile *repo_create_tempfile (struct repository *r,const char *path) {
Signature · 1 line
2.55.0
Quoted 2 lines · René Scharfe
Remove the compatibility wrappers
create_tempfile_mode()andcreate_tempfile()that have become unused.
Ah, so we do get rid of it. Nice. We might tease in the preceding commit message that we'll get rid of it in a subsequent patch.
Patrick
PATCH 5/5 use repo_hold_lock_file_for_update{,_mode,_timeout}() with custom repos
In reply to René ScharfeApply the config setting core.sharedRepository from the repository at hand instead of from the_repository.
--- apply.c | 10 ++++++---- builtin/difftool.c | 2 +- builtin/gc.c | 2 +- builtin/history.c | 2 +- builtin/sparse-checkout.c | 3 ++- bundle.c | 4 ++-- commit-graph.c | 9 +++++---- config.c | 4 ++-- loose.c | 6 ++++-- midx-write.c | 7 ++++--- odb/source-files.c | 3 ++- refs/files-backend.c | 10 ++++++---- refs/packed-backend.c | 7 +++---- refs/packed-backend.h | 2 +- repack-midx.c | 3 ++- repository.c | 2 +- rerere.c | 6 +++--- 17 files changed, 46 insertions(+), 36 deletions(-)
apply.c +6 -4
@@ -4287,7 +4287,8 @@ static int build_fake_ancestor(struct apply_state *state, struct patch *list) } } -hold_lock_file_for_update (&lock, state->fake_ancestor,LOCK_DIE_ON_ERROR ); +repo_hold_lock_file_for_update (state->repo, &lock, state->fake_ancestor, +LOCK_DIE_ON_ERROR ); res =write_locked_index (&result, &lock,COMMIT_LOCK );discard_index (&result);
@@ -4945,9 +4946,10 @@ static int apply_patch(struct apply_state *state, state->update_index = (state->check_index || state->ita_only) && state->apply;if (state->update_index && !is_lock_file_locked (&state->lock_file)) {if (state->index_file) -hold_lock_file_for_update (&state->lock_file, - state->index_file, -LOCK_DIE_ON_ERROR ); +repo_hold_lock_file_for_update (state->repo, + &state->lock_file, + state->index_file, +LOCK_DIE_ON_ERROR );else repo_hold_locked_index (state->repo, &state->lock_file,LOCK_DIE_ON_ERROR );
builtin/difftool.c +1 -1
@@ -636,7 +636,7 @@ static int run_dir_diff(struct repository *repo,struct lock_file lock =LOCK_INIT ;strbuf_reset (&buf);strbuf_addf (&buf,"%s/wtindex" , tmpdir.buf); -if (hold_lock_file_for_update (&lock, buf.buf,0 ) <0 || +if (repo_hold_lock_file_for_update (repo, &lock, buf.buf,0 ) <0 ||write_locked_index (&wtindex, &lock,COMMIT_LOCK )) { ret =error ("could not write %s" , buf.buf); goto finish;
builtin/gc.c +1 -1
@@ -1790,7 +1790,7 @@ static int maintenance_run_tasks(struct maintenance_run_opts *opts,struct repository *r = the_repository;char *lock_path =xstrfmt ("%s/maintenance" , r->objects->sources->path); -if (hold_lock_file_for_update (&lk, lock_path,LOCK_NO_DEREF ) <0 ) { +if (repo_hold_lock_file_for_update (r, &lk, lock_path,LOCK_NO_DEREF ) <0 ) {/* * Another maintenance command is running. *
builtin/history.c +1 -1
@@ -764,7 +764,7 @@ static int write_ondisk_index(struct repository *repo,prime_cache_tree (repo, &index, tree); -if (hold_lock_file_for_update (&lock, path,0 ) <0 ) { +if (repo_hold_lock_file_for_update (repo, &lock, path,0 ) <0 ) { ret =error_errno (_ ("unable to acquire index lock" )); goto out; }
builtin/sparse-checkout.c +2 -1
@@ -341,7 +341,8 @@ static int write_patterns_and_update(struct repository *repo,if (safe_create_leading_directories (repo, sparse_filename))die (_ ("failed to create directory for sparse-checkout file" )); -hold_lock_file_for_update (&lk, sparse_filename,LOCK_DIE_ON_ERROR ); +repo_hold_lock_file_for_update (repo, &lk, sparse_filename, +LOCK_DIE_ON_ERROR ); result =update_working_directory (repo, pl);if (result) {
bundle.c +2 -2
@@ -519,8 +519,8 @@ int create_bundle(struct repository *r, const char *path,if (bundle_to_stdout) bundle_fd =1 ;else - bundle_fd =hold_lock_file_for_update (&lock, path, -LOCK_DIE_ON_ERROR ); + bundle_fd =repo_hold_lock_file_for_update (r, &lock, path, +LOCK_DIE_ON_ERROR );if (version ==-1 ) version = min_version;
commit-graph.c +5 -4
@@ -2122,8 +2122,8 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx)if (ctx->split) {char *lock_name =get_commit_graph_chain_filename (ctx->odb_source); -hold_lock_file_for_update_mode (&lk, lock_name, -LOCK_DIE_ON_ERROR ,0444 ); +repo_hold_lock_file_for_update_mode (ctx->r, &lk, lock_name, +LOCK_DIE_ON_ERROR ,0444 );free (lock_name); graph_layer =mks_tempfile_m (ctx->graph_name,0444 );
@@ -2141,8 +2141,9 @@ static int write_commit_graph_file(struct write_commit_graph_context *ctx) f =hashfd (ctx->r->hash_algo,get_tempfile_fd (graph_layer),get_tempfile_path (graph_layer)); }else { -hold_lock_file_for_update_mode (&lk, ctx->graph_name, -LOCK_DIE_ON_ERROR ,0444 ); +repo_hold_lock_file_for_update_mode (ctx->r, &lk, + ctx->graph_name, +LOCK_DIE_ON_ERROR ,0444 ); f =hashfd (ctx->r->hash_algo,get_lock_file_fd (&lk),get_lock_file_path (&lk)); }
config.c +2 -2
@@ -3034,7 +3034,7 @@ int repo_config_set_multivar_in_file_gently(struct repository *r,* The lock serves a purpose in addition to locking: the new * contents of .git/config will be written into it. */ - fd =hold_lock_file_for_update (&lock, config_filename,0 ); + fd =repo_hold_lock_file_for_update (r, &lock, config_filename,0 );if (fd <0 ) {error_errno (_ ("could not lock config file %s" ), config_filename); ret =CONFIG_NO_LOCK ;
@@ -3379,7 +3379,7 @@ static int repo_config_copy_or_rename_section_in_file(if (!config_filename) config_filename = filename_buf =repo_git_path (r,"config" ); - out_fd =hold_lock_file_for_update (&lock, config_filename,0 ); + out_fd =repo_hold_lock_file_for_update (r, &lock, config_filename,0 );if (out_fd <0 ) { ret =error (_ ("could not lock config file %s" ), config_filename); goto out;
loose.c +4 -2
@@ -138,7 +138,8 @@ int repo_write_loose_object_map(struct repository *repo)return 0 ;repo_common_path_replace (repo, &path,"objects/loose-object-idx" ); - fd =hold_lock_file_for_update_timeout (&lock, path.buf,LOCK_DIE_ON_ERROR ,-1 ); + fd =repo_hold_lock_file_for_update_timeout (repo, &lock, path.buf, +LOCK_DIE_ON_ERROR ,-1 ); iter =kh_begin (map);if (write_in_full (fd, loose_object_header,strlen (loose_object_header)) <0 ) goto errout;
@@ -180,7 +181,8 @@ static int write_one_object(struct odb_source_loose *loose,struct strbuf buf =STRBUF_INIT , path =STRBUF_INIT ;strbuf_addf (&path,"%s/loose-object-idx" , loose->base.path); -hold_lock_file_for_update_timeout (&lock, path.buf,LOCK_DIE_ON_ERROR ,-1 ); +repo_hold_lock_file_for_update_timeout (loose->base.odb->repo, &lock, + path.buf,LOCK_DIE_ON_ERROR ,-1 ); fd =open (path.buf,O_WRONLY |O_CREAT |O_APPEND ,0666 );if (fd <0 )
midx-write.c +4 -3
@@ -1627,8 +1627,8 @@ static int write_midx_internal(struct write_midx_opts *opts)struct strbuf lock_name =STRBUF_INIT ;get_midx_chain_filename (opts->source, &lock_name); -hold_lock_file_for_update (&lk, lock_name.buf, -LOCK_DIE_ON_ERROR ); +repo_hold_lock_file_for_update (r, &lk, lock_name.buf, +LOCK_DIE_ON_ERROR );strbuf_release (&lock_name); }
@@ -1647,7 +1647,8 @@ static int write_midx_internal(struct write_midx_opts *opts) f =hashfd (r->hash_algo,get_tempfile_fd (incr),get_tempfile_path (incr)); }else { -hold_lock_file_for_update (&lk, midx_name.buf,LOCK_DIE_ON_ERROR ); +repo_hold_lock_file_for_update (r, &lk, midx_name.buf, +LOCK_DIE_ON_ERROR ); f =hashfd (r->hash_algo,get_lock_file_fd (&lk),get_lock_file_path (&lk)); }
odb/source-files.c +2 -1
@@ -218,7 +218,8 @@ static int odb_source_files_write_alternate(struct odb_source *source,int found =0 ;int ret; -hold_lock_file_for_update (&lock, path,LOCK_DIE_ON_ERROR ); +repo_hold_lock_file_for_update (source->odb->repo, &lock, path, +LOCK_DIE_ON_ERROR ); out =fdopen_lock_file (&lock,"w" );if (!out) { ret =error_errno (_ ("unable to fdopen alternates lockfile" ));
refs/files-backend.c +6 -4
@@ -842,7 +842,7 @@ static enum ref_transaction_error lock_raw_ref(struct files_ref_store *refs, goto error_return; } -if (hold_lock_file_for_update_timeout ( +if (repo_hold_lock_file_for_update_timeout (refs->base.repo, &lock->lk, ref_file.buf,LOCK_NO_DEREF ,get_files_ref_lock_timeout_ms (transaction->ref_store->repo)) <0 ) {int myerr = errno;
@@ -1250,8 +1250,8 @@ struct create_reflock_cb {static int create_reflock (const char *path,void *cb) {struct create_reflock_cb *data = cb; -return hold_lock_file_for_update_timeout ( - data->lk, path,LOCK_NO_DEREF , +return repo_hold_lock_file_for_update_timeout ( + data->repo, data->lk, path,LOCK_NO_DEREF ,get_files_ref_lock_timeout_ms (data->repo)) <0 ?-1 :0 ; }
@@ -3581,7 +3581,9 @@ static int files_reflog_expire(struct ref_store *ref_store,* work we need, including cleaning up if the program * exits unexpectedly. */ -if (hold_lock_file_for_update (&reflog_lock, log_file,0 ) <0 ) { +if (repo_hold_lock_file_for_update (ref_store->repo, + &reflog_lock, log_file, +0 ) <0 ) {struct strbuf err =STRBUF_INIT ;unable_to_lock_message (log_file, errno, &err);error ("%s" , err.buf);
refs/packed-backend.c +3 -4
@@ -1246,10 +1246,9 @@ int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err)* don't write new content to it, but rather to a separate * tempfile. */ -if (hold_lock_file_for_update_timeout ( - &refs->lock, - refs->path, - flags, timeout_value) <0 ) { +if (repo_hold_lock_file_for_update_timeout (ref_store->repo, &refs->lock, + refs->path, flags, + timeout_value) <0 ) {unable_to_lock_message (refs->path, errno, err);return -1 ; }
refs/packed-backend.h +1 -1
@@ -21,7 +21,7 @@ struct ref_store *packed_ref_store_init(struct repository *repo,/* * Lock the packed-refs file for writing. Flags is passed to -* hold_lock_file_for_update(). Return 0 on success. On errors, write +* repo_hold_lock_file_for_update(). Return 0 on success. On errors, write * an error message to `err` and return a nonzero value. */ int packed_refs_lock (struct ref_store *ref_store,int flags,struct strbuf *err);
repack-midx.c +2 -1
@@ -954,7 +954,8 @@ static int write_midx_incremental(struct repack_write_midx_opts *opts) lock_name.buf))die_errno (_ ("unable to create leading directories of %s" ), lock_name.buf); -hold_lock_file_for_update (&lf, lock_name.buf,LOCK_DIE_ON_ERROR ); +repo_hold_lock_file_for_update (opts->existing->repo, &lf, lock_name.buf, +LOCK_DIE_ON_ERROR );if (!fdopen_lock_file (&lf,"w" )) { ret =error_errno (_ ("unable to open multi-pack-index chain file" ));
repository.c +1 -1
@@ -472,5 +472,5 @@ int repo_hold_locked_index(struct repository *repo, {if (!repo->index_file)BUG ("the repo hasn't been setup" ); -return hold_lock_file_for_update (lf, repo->index_file, flags); +return repo_hold_lock_file_for_update (repo, lf, repo->index_file, flags); }
rerere.c +3 -3
@@ -911,9 +911,9 @@ int setup_rerere(struct repository *r, struct string_list *merge_rr, int flags)if (flags &RERERE_READONLY ) fd =0 ;else - fd =hold_lock_file_for_update (&write_lock, -git_path_merge_rr (r), -LOCK_DIE_ON_ERROR ); + fd =repo_hold_lock_file_for_update (r, &write_lock, +git_path_merge_rr (r), +LOCK_DIE_ON_ERROR );read_rr (r, merge_rr);return fd; }
Signature · 1 line
2.55.0
Re: [PATCH 5/5] use repo_hold_lock_file_for_update{,_mode,_timeout}() with custom repos
Quoted 2 lines · René Scharfe
Apply the config setting core.sharedRepository from the repository at hand instead of from
the_repository.
We only do this for a subset of callsites, apparently. How did you select which subsystems to convert and which not to? To make this
explicit: I don't mind a partial migration, but I think the commit message should briefly explain the reasoning behind it.
Also, as you don't get rid of the old functions that still implicitly depend on the_repository, I think we should have an additional commit on top that guards all functions that have this implicit dependency with USE_THE_REPOSITORY_VARIABLE. This ensures that we cannot accidentally call such functions from other subsystems that already got rid of the global dependency.
Thanks!
Patrick
Re: [PATCH 5/5] use repo_hold_lock_file_for_update{,_mode,_timeout}() with custom repos
Quoted 8 lines · Patrick Steinhardt
Quoted 2 lines · René Scharfe
Apply the config setting core.sharedRepository from the repository at hand instead of from
the_repository.We only do this for a subset of callsites, apparently. How did you select which subsystems to convert and which not to? To make this
explicit: I don't mind a partial migration, but I think the commit message should briefly explain the reasoning behind it.
All those that have a repository reference other than the_repository.
Quoted 6 lines
Also, as you don't get rid of the old functions that still implicitly depend on
the_repository, I think we should have an additional commit on top that guards all functions that have this implicit dependency withUSE_THE_REPOSITORY_VARIABLE. This ensures that we cannot accidentally call such functions from other subsystems that already got rid of the global dependency.
Probably, but the lockfile conversions deserve their own patch series. Patch 5 is only included here because it was easy to write. We can drop it and leave the low-hanging fruit on the tree if that's preferable.
René
Re: [PATCH 5/5] use repo_hold_lock_file_for_update{,_mode,_timeout}() with custom repos
Quoted 19 lines · René Scharfe
Quoted 8 lines · Patrick Steinhardt
Quoted 2 lines · René Scharfe
Apply the config setting core.sharedRepository from the repository at hand instead of from
the_repository.We only do this for a subset of callsites, apparently. How did you select which subsystems to convert and which not to? To make this
explicit: I don't mind a partial migration, but I think the commit message should briefly explain the reasoning behind it.All those that have a repository reference other than
the_repository.Quoted 6 lines
Also, as you don't get rid of the old functions that still implicitly depend on
the_repository, I think we should have an additional commit on top that guards all functions that have this implicit dependency withUSE_THE_REPOSITORY_VARIABLE. This ensures that we cannot accidentally call such functions from other subsystems that already got rid of the global dependency.
Quoted 3 lines
Probably, but the lockfile conversions deserve their own patch series. Patch 5 is only included here because it was easy to write. We can drop it and leave the low-hanging fruit on the tree if that's preferable.
I am personally indifferent as to what we do immediately in this series, as long as we all agree on the longer-term direction. It seems we are in agreement on providing additional safety in the medium term?
Thanks.
Re: [PATCH 5/5] use repo_hold_lock_file_for_update{,_mode,_timeout}() with custom repos
Quoted 21 lines · Junio C Hamano
Quoted 19 lines · René Scharfe
Quoted 8 lines · Patrick Steinhardt
Quoted 2 lines · René Scharfe
Apply the config setting core.sharedRepository from the repository at hand instead of from
the_repository.We only do this for a subset of callsites, apparently. How did you select which subsystems to convert and which not to? To make this
explicit: I don't mind a partial migration, but I think the commit message should briefly explain the reasoning behind it.All those that have a repository reference other than
the_repository.Quoted 6 lines
Also, as you don't get rid of the old functions that still implicitly depend on
the_repository, I think we should have an additional commit on top that guards all functions that have this implicit dependency withUSE_THE_REPOSITORY_VARIABLE. This ensures that we cannot accidentally call such functions from other subsystems that already got rid of the global dependency.
Quoted 8 lines
Quoted 3 lines
Probably, but the lockfile conversions deserve their own patch series. Patch 5 is only included here because it was easy to write. We can drop it and leave the low-hanging fruit on the tree if that's preferable.
I am personally indifferent as to what we do immediately in this series, as long as we all agree on the longer-term direction. It seems we are in agreement on providing additional safety in the medium term?
It would be an easy thing to guard existing interfaces that depend on the_repository behind USE_THE_REPOSITORY_VARIABLE. But the patch series is already a strict improvement over the status quo, so I don't mind if we merge it as-is and defer that to a later point.
Thanks!
Patrick
Quoted 4 lines · René Scharfe
create_tempfile_mode()andcreate_tempfile()usethe_repositoryinternally to calladjust_shared_perm(). Expose that dependency and push it out to their callers.
Quoted 8 lines
Patch 5 is a bonus; it converts lockfile users that already work with other repositories.
tempfile: add repo_create_tempfile{,_mode}()
refs/packed: userepo_create_tempfile()
lockfile: add repo_hold_lock_file_for_update{,_timeout}{,_mode}()
tempfile: stop usingthe_repository
use repo_hold_lock_file_for_update{,_mode,_timeout}() with custom repos
Will queue. If I have a chance I may revisit the topic a bit deeper, but nothing stood out as glaringly wrong to my cursory reading so far.
Thanks.
Quoted 23 lines
apply.c | 10 ++++++---- builtin/difftool.c | 2 +- builtin/gc.c | 2 +- builtin/history.c | 2 +- builtin/sparse-checkout.c | 3 ++- bundle.c | 4 ++-- commit-graph.c | 9 +++++---- config.c | 4 ++-- lockfile.c | 30 ++++++++++++++++++++++-------- lockfile.h | 31 +++++++++++++++++++++++++++++++ loose.c | 6 ++++-- midx-write.c | 7 ++++--- odb/source-files.c | 3 ++- refs/files-backend.c | 10 ++++++---- refs/packed-backend.c | 9 ++++----- refs/packed-backend.h | 2 +- repack-midx.c | 3 ++- repository.c | 2 +- rerere.c | 6 +++--- tempfile.c | 7 +++---- tempfile.h | 10 +++++++--- 21 files changed, 110 insertions(+), 52 deletions(-)
Quoted 3 lines · René Scharfe
create_tempfile_mode()andcreate_tempfile()usethe_repositoryinternally to calladjust_shared_perm(). Expose that dependency and push it out to their callers.
Yay! I was just starting to have a look at this area yesterday because the implicit dependency got in my way. Happy to see that you tackle it :)
Patrick