static int packed_transaction_prepare(struct ref_store *ref_store, struct ref_transaction *transaction, struct strbuf *err) { struct packed_ref_store *refs = packed_downcast( ref_store, REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB, "ref_transaction_prepare"); struct packed_transaction_backend_data *data; size_t i; int ret = TRANSACTION_GENERIC_ERROR; /* * Note that we *don't* skip transactions with zero updates, * because such a transaction might be executed for the side * effect of ensuring that all of the references are peeled or * ensuring that the `packed-refs` file is sorted. If the * caller wants to optimize away empty transactions, it should * do so itself. */ data = xcalloc(1, sizeof(*data)); string_list_init(&data->updates, 0); transaction->backend_data = data; /* * Stick the updates in a string list by refname so that we * can sort them: */ for (i = 0; i < transaction->nr; i++) { struct ref_update *update = transaction->updates[i]; struct string_list_item *item = string_list_append(&data->updates, update->refname); /* Store a pointer to update in item->util: */ item->util = update; } string_list_sort(&data->updates); if (ref_update_reject_duplicates(&data->updates, err)) goto failure; if (!is_lock_file_locked(&refs->lock)) { if (packed_refs_lock(ref_store, 0, err)) goto failure; data->own_lock = 1; } if (write_with_updates(refs, &data->updates, err)) goto failure; transaction->state = REF_TRANSACTION_PREPARED; return 0; failure: packed_transaction_cleanup(refs, transaction); return ret; }
int packed_refs_is_locked(struct ref_store *ref_store) { struct packed_ref_store *refs = packed_downcast( ref_store, REF_STORE_READ | REF_STORE_WRITE, "packed_refs_is_locked"); return is_lock_file_locked(&refs->lock); }
/* * Get the `snapshot` for the specified packed_ref_store, creating and * populating it if it hasn't been read before or if the file has been * changed (according to its `validity` field) since it was last read. * On the other hand, if we hold the lock, then assume that the file * hasn't been changed out from under us, so skip the extra `stat()` * call in `stat_validity_check()`. This function does *not* increase * the snapshot's reference count on behalf of the caller. */ static struct snapshot *get_snapshot(struct packed_ref_store *refs) { if (!is_lock_file_locked(&refs->lock)) validate_snapshot(refs); if (!refs->snapshot) refs->snapshot = create_snapshot(refs); return refs->snapshot; }
void packed_refs_unlock(struct ref_store *ref_store) { struct packed_ref_store *refs = packed_downcast( ref_store, REF_STORE_READ | REF_STORE_WRITE, "packed_refs_unlock"); if (!is_lock_file_locked(&refs->lock)) die("BUG: packed_refs_unlock() called when not locked"); rollback_lock_file(&refs->lock); }
static void packed_transaction_cleanup(struct packed_ref_store *refs, struct ref_transaction *transaction) { struct packed_transaction_backend_data *data = transaction->backend_data; if (data) { string_list_clear(&data->updates, 0); if (is_tempfile_active(refs->tempfile)) delete_tempfile(&refs->tempfile); if (data->own_lock && is_lock_file_locked(&refs->lock)) { packed_refs_unlock(&refs->base); data->own_lock = 0; } free(data); transaction->backend_data = NULL; } transaction->state = REF_TRANSACTION_CLOSED; }
int is_packed_transaction_needed(struct ref_store *ref_store, struct ref_transaction *transaction) { struct packed_ref_store *refs = packed_downcast( ref_store, REF_STORE_READ, "is_packed_transaction_needed"); struct strbuf referent = STRBUF_INIT; size_t i; int ret; if (!is_lock_file_locked(&refs->lock)) BUG("is_packed_transaction_needed() called while unlocked"); /* * We're only going to bother returning false for the common, * trivial case that references are only being deleted, their * old values are not being checked, and the old `packed-refs` * file doesn't contain any of those reference(s). This gives * false positives for some other cases that could * theoretically be optimized away: * * 1. It could be that the old value is being verified without * setting a new value. In this case, we could verify the * old value here and skip the update if it agrees. If it * disagrees, we could either let the update go through * (the actual commit would re-detect and report the * problem), or come up with a way of reporting such an * error to *our* caller. * * 2. It could be that a new value is being set, but that it * is identical to the current packed value of the * reference. * * Neither of these cases will come up in the current code, * because the only caller of this function passes to it a * transaction that only includes `delete` updates with no * `old_id`. Even if that ever changes, false positives only * cause an optimization to be missed; they do not affect * correctness. */ /* * Start with the cheap checks that don't require old * reference values to be read: */ for (i = 0; i < transaction->nr; i++) { struct ref_update *update = transaction->updates[i]; if (update->flags & REF_HAVE_OLD) /* Have to check the old value -> needed. */ return 1; if ((update->flags & REF_HAVE_NEW) && !is_null_oid(&update->new_oid)) /* Have to set a new value -> needed. */ return 1; } /* * The transaction isn't checking any old values nor is it * setting any nonzero new values, so it still might be able * to be skipped. Now do the more expensive check: the update * is needed if any of the updates is a delete, and the old * `packed-refs` file contains a value for that reference. */ ret = 0; for (i = 0; i < transaction->nr; i++) { struct ref_update *update = transaction->updates[i]; unsigned int type; struct object_id oid; if (!(update->flags & REF_HAVE_NEW)) /* * This reference isn't being deleted -> not * needed. */ continue; if (!refs_read_raw_ref(ref_store, update->refname, &oid, &referent, &type) || errno != ENOENT) { /* * We have to actually delete that reference * -> this transaction is needed. */ ret = 1; break; } } strbuf_release(&referent); return ret; }
/* * Write the packed refs from the current snapshot to the packed-refs * tempfile, incorporating any changes from `updates`. `updates` must * be a sorted string list whose keys are the refnames and whose util * values are `struct ref_update *`. On error, rollback the tempfile, * write an error message to `err`, and return a nonzero value. * * The packfile must be locked before calling this function and will * remain locked when it is done. */ static int write_with_updates(struct packed_ref_store *refs, struct string_list *updates, struct strbuf *err) { struct ref_iterator *iter = NULL; size_t i; int ok; FILE *out; struct strbuf sb = STRBUF_INIT; char *packed_refs_path; if (!is_lock_file_locked(&refs->lock)) die("BUG: write_with_updates() called while unlocked"); /* * If packed-refs is a symlink, we want to overwrite the * symlinked-to file, not the symlink itself. Also, put the * staging file next to it: */ 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); if (!refs->tempfile) { strbuf_addf(err, "unable to create file %s: %s", sb.buf, strerror(errno)); strbuf_release(&sb); return -1; } strbuf_release(&sb); out = fdopen_tempfile(refs->tempfile, "w"); if (!out) { strbuf_addf(err, "unable to fdopen packed-refs tempfile: %s", strerror(errno)); goto error; } if (fprintf(out, "%s", PACKED_REFS_HEADER) < 0) goto write_error; /* * We iterate in parallel through the current list of refs and * the list of updates, processing an entry from at least one * of the lists each time through the loop. When the current * list of refs is exhausted, set iter to NULL. When the list * of updates is exhausted, leave i set to updates->nr. */ iter = packed_ref_iterator_begin(&refs->base, "", DO_FOR_EACH_INCLUDE_BROKEN); if ((ok = ref_iterator_advance(iter)) != ITER_OK) iter = NULL; i = 0; while (iter || i < updates->nr) { struct ref_update *update = NULL; int cmp; if (i >= updates->nr) { cmp = -1; } else { update = updates->items[i].util; if (!iter) cmp = +1; else cmp = strcmp(iter->refname, update->refname); } if (!cmp) { /* * There is both an old value and an update * for this reference. Check the old value if * necessary: */ if ((update->flags & REF_HAVE_OLD)) { if (is_null_oid(&update->old_oid)) { strbuf_addf(err, "cannot update ref '%s': " "reference already exists", update->refname); goto error; } else if (oidcmp(&update->old_oid, iter->oid)) { strbuf_addf(err, "cannot update ref '%s': " "is at %s but expected %s", update->refname, oid_to_hex(iter->oid), oid_to_hex(&update->old_oid)); goto error; } } /* Now figure out what to use for the new value: */ if ((update->flags & REF_HAVE_NEW)) { /* * The update takes precedence. Skip * the iterator over the unneeded * value. */ if ((ok = ref_iterator_advance(iter)) != ITER_OK) iter = NULL; cmp = +1; } else { /* * The update doesn't actually want to * change anything. We're done with it. */ i++; cmp = -1; } } else if (cmp > 0) { /* * There is no old value but there is an * update for this reference. Make sure that * the update didn't expect an existing value: */ if ((update->flags & REF_HAVE_OLD) && !is_null_oid(&update->old_oid)) { strbuf_addf(err, "cannot update ref '%s': " "reference is missing but expected %s", update->refname, oid_to_hex(&update->old_oid)); goto error; } } if (cmp < 0) { /* Pass the old reference through. */ struct object_id peeled; int peel_error = ref_iterator_peel(iter, &peeled); if (write_packed_entry(out, iter->refname, iter->oid, peel_error ? NULL : &peeled)) goto write_error; if ((ok = ref_iterator_advance(iter)) != ITER_OK) iter = NULL; } else if (is_null_oid(&update->new_oid)) { /* * The update wants to delete the reference, * and the reference either didn't exist or we * have already skipped it. So we're done with * the update (and don't have to write * anything). */ i++; } else { struct object_id peeled; int peel_error = peel_object(&update->new_oid, &peeled); if (write_packed_entry(out, update->refname, &update->new_oid, peel_error ? NULL : &peeled)) goto write_error; i++; } } if (ok != ITER_DONE) { strbuf_addstr(err, "unable to write packed-refs file: " "error iterating over old contents"); goto error; } if (close_tempfile_gently(refs->tempfile)) { strbuf_addf(err, "error closing file %s: %s", get_tempfile_path(refs->tempfile), strerror(errno)); strbuf_release(&sb); delete_tempfile(&refs->tempfile); return -1; } return 0; write_error: strbuf_addf(err, "error writing to %s: %s", get_tempfile_path(refs->tempfile), strerror(errno)); error: if (iter) ref_iterator_abort(iter); delete_tempfile(&refs->tempfile); return -1; }
int cmd_checkout_index(int argc, const char **argv, const char *prefix) { int i; struct lock_file lock_file = LOCK_INIT; int all = 0; int read_from_stdin = 0; int prefix_length; int force = 0, quiet = 0, not_new = 0; int index_opt = 0; struct option builtin_checkout_index_options[] = { OPT_BOOL('a', "all", &all, N_("check out all files in the index")), OPT__FORCE(&force, N_("force overwrite of existing files"), 0), OPT__QUIET(&quiet, N_("no warning for existing files and files not in index")), OPT_BOOL('n', "no-create", ¬_new, N_("don't checkout new files")), OPT_BOOL('u', "index", &index_opt, N_("update stat information in the index file")), OPT_BOOL('z', NULL, &nul_term_line, N_("paths are separated with NUL character")), OPT_BOOL(0, "stdin", &read_from_stdin, N_("read list of paths from the standard input")), OPT_BOOL(0, "temp", &to_tempfile, N_("write the content to temporary files")), OPT_STRING(0, "prefix", &state.base_dir, N_("string"), N_("when creating files, prepend <string>")), { OPTION_CALLBACK, 0, "stage", NULL, "(1|2|3|all)", N_("copy out the files from named stage"), PARSE_OPT_NONEG, option_parse_stage }, OPT_END() }; if (argc == 2 && !strcmp(argv[1], "-h")) usage_with_options(builtin_checkout_index_usage, builtin_checkout_index_options); git_config(git_default_config, NULL); prefix_length = prefix ? strlen(prefix) : 0; if (read_cache() < 0) { die("invalid cache"); } argc = parse_options(argc, argv, prefix, builtin_checkout_index_options, builtin_checkout_index_usage, 0); state.istate = &the_index; state.force = force; state.quiet = quiet; state.not_new = not_new; if (!state.base_dir) state.base_dir = ""; state.base_dir_len = strlen(state.base_dir); /* * when --prefix is specified we do not want to update cache. */ if (index_opt && !state.base_dir_len && !to_tempfile) { state.refresh_cache = 1; state.istate = &the_index; hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR); } /* Check out named files first */ for (i = 0; i < argc; i++) { const char *arg = argv[i]; char *p; if (all) die("git checkout-index: don't mix '--all' and explicit filenames"); if (read_from_stdin) die("git checkout-index: don't mix '--stdin' and explicit filenames"); p = prefix_path(prefix, prefix_length, arg); checkout_file(p, prefix); free(p); } if (read_from_stdin) { struct strbuf buf = STRBUF_INIT; struct strbuf unquoted = STRBUF_INIT; strbuf_getline_fn getline_fn; if (all) die("git checkout-index: don't mix '--all' and '--stdin'"); getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf; while (getline_fn(&buf, stdin) != EOF) { char *p; if (!nul_term_line && buf.buf[0] == '"') { strbuf_reset(&unquoted); if (unquote_c_style(&unquoted, buf.buf, NULL)) die("line is badly quoted"); strbuf_swap(&buf, &unquoted); } p = prefix_path(prefix, prefix_length, buf.buf); checkout_file(p, prefix); free(p); } strbuf_release(&unquoted); strbuf_release(&buf); } if (all) checkout_all(prefix, prefix_length); if (is_lock_file_locked(&lock_file) && write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) die("Unable to write new index file"); return 0; }