NORETURN void unable_to_lock_die(const char *path, int err) { struct strbuf buf = STRBUF_INIT; unable_to_lock_message(path, err, &buf); die("%s", buf.buf); }
int unable_to_lock_error(const char *path, int err) { char *msg = unable_to_lock_message(path, err); error("%s", msg); free(msg); return -1; }
int unable_to_lock_error(const char *path, int err) { struct strbuf buf = STRBUF_INIT; unable_to_lock_message(path, err, &buf); error("%s", buf.buf); strbuf_release(&buf); return -1; }
int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err) { struct packed_ref_store *refs = packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN, "packed_refs_lock"); static int timeout_configured = 0; static int timeout_value = 1000; if (!timeout_configured) { git_config_get_int("core.packedrefstimeout", &timeout_value); timeout_configured = 1; } /* * Note that we close the lockfile immediately because we * 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) { unable_to_lock_message(refs->path, errno, err); return -1; } if (close_lock_file_gently(&refs->lock)) { strbuf_addf(err, "unable to close %s: %s", refs->path, strerror(errno)); rollback_lock_file(&refs->lock); return -1; } /* * Now that we hold the `packed-refs` lock, make sure that our * snapshot matches the current version of the file. Normally * `get_snapshot()` does that for us, but that function * assumes that when the file is locked, any existing snapshot * is still valid. We've just locked the file, but it might * have changed the moment *before* we locked it. */ validate_snapshot(refs); /* * Now make sure that the packed-refs file as it exists in the * locked state is loaded into the snapshot: */ get_snapshot(refs); return 0; }
NORETURN void unable_to_lock_index_die(const char *path, int err) { die("%s", unable_to_lock_message(path, err)); }