git
1#define USE_THE_REPOSITORY_VARIABLE2* Don't use mmap() at all for reading `packed-refs`.23*/24MMAP_NONE,25* Can use mmap() for reading `packed-refs`, but the file must28* not remain mmapped. This is the usual option on Windows,29* where you cannot rename a new version of a file onto a file30* that is currently mmapped.31*/32MMAP_TEMPORARY,33* It is OK to leave the `packed-refs` file mmapped while36* arbitrary other code is running.37*/38MMAP_OK39};40/*52* A `snapshot` represents one snapshot of a `packed-refs` file.53*54* Normally, this will be a mmapped view of the contents of the55* `packed-refs` file at the time the snapshot was created. However,56* if the `packed-refs` file was not sorted, this might point at heap57* memory holding the contents of the `packed-refs` file with its58* records sorted by refname.59*60* `snapshot` instances are reference counted (via61* `acquire_snapshot()` and `release_snapshot()`). This is to prevent62* an instance from disappearing while an iterator is still iterating63* over it. Instances are garbage collected when their `referrers`64* count goes to zero.65*66* The most recent `snapshot`, if available, is referenced by the67* `packed_ref_store`. Its freshness is checked whenever68* `get_snapshot()` is called; if the existing snapshot is obsolete, a69* new snapshot is taken.70*/71struct snapshot {72/*73* A back-pointer to the packed_ref_store with which this74* snapshot is associated:75*/76struct packed_ref_store *refs;77* The contents of the `packed-refs` file:83*84* - buf -- a pointer to the start of the memory85* - start -- a pointer to the first byte of actual references86* (i.e., after the header line, if one is present)87* - eof -- a pointer just past the end of the reference88* contents89*90* If the `packed-refs` file was already sorted, `buf` points91* at the mmapped contents of the file. If not, it points at92* heap-allocated memory containing the contents, sorted. If93* there were no contents (e.g., because the file didn't94* exist), `buf`, `start`, and `eof` are all NULL.95*/96char *buf, *start, *eof;97* What is the peeled state of the `packed-refs` file that100* this snapshot represents? (This is usually determined from101* the file's header.)102*/103enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled;104* Count of references to this instance, including the pointer107* from `packed_ref_store::snapshot`, if any. The instance108* will not be freed as long as the reference count is109* nonzero.110*/111unsigned int referrers;112* The metadata of the `packed-refs` file from which this115* snapshot was created, used to tell if the file has been116* replaced since we read it.117*/118struct stat_validity validity;119};120/*122* A `ref_store` representing references stored in a `packed-refs`123* file. It implements the `ref_store` interface, though it has some124* limitations:125*126* - It cannot store symbolic references.127*128* - It cannot store reflogs.129*130* - It does not support reference renaming (though it could).131*132* On the other hand, it can be locked outside of a reference133* transaction. In that case, it remains locked even after the134* transaction is done and the new `packed-refs` file is activated.135*/136struct packed_ref_store {137struct ref_store base;138* A snapshot of the values read from the `packed-refs` file,146* if it might still be current; otherwise, NULL.147*/148struct snapshot *snapshot;149* Lock used for the "packed-refs" file. Note that this (and152* thus the enclosing `packed_ref_store`) must not be freed.153*/154struct lock_file lock;155* Temporary file used when rewriting new contents to the158* "packed-refs" file. Note that this (and thus the enclosing159* `packed_ref_store`) must not be freed.160*/161struct tempfile *tempfile;162};163/*165* Increment the reference count of `*snapshot`.166*/167static void acquire_snapshot(struct snapshot *snapshot)168{169snapshot->referrers++;170}171/*173* If the buffer in `snapshot` is active, then either munmap the174* memory and close the file, or free the memory. Then set the buffer175* pointers to NULL.176*/177static void clear_snapshot_buffer(struct snapshot *snapshot)178{179if (snapshot->mmapped) {180if (munmap(snapshot->buf, snapshot->eof - snapshot->buf))181die_errno("error ummapping packed-refs file %s",182snapshot->refs->path);183snapshot->mmapped = 0;184} else {185free(snapshot->buf);186}187snapshot->buf = snapshot->start = snapshot->eof = NULL;188}189/*191* Decrease the reference count of `*snapshot`. If it goes to zero,192* free `*snapshot` and return true; otherwise return false.193*/194static int release_snapshot(struct snapshot *snapshot)195{196if (!--snapshot->referrers) {197stat_validity_clear(&snapshot->validity);198clear_snapshot_buffer(snapshot);199free(snapshot);200return 1;201} else {202return 0;203}204}205{208return snapshot->refs->base.repo->hash_algo->hexsz;209}210{215struct packed_ref_store *refs = xcalloc(1, sizeof(*refs));216struct ref_store *ref_store = (struct ref_store *)refs;217struct strbuf sb = STRBUF_INIT;218}227/*229* Downcast `ref_store` to `packed_ref_store`. Die if `ref_store` is230* not a `packed_ref_store`. Also die if `packed_ref_store` doesn't231* support at least the flags specified in `required_flags`. `caller`232* is used in any necessary error messages.233*/234static struct packed_ref_store *packed_downcast(struct ref_store *ref_store,235unsigned int required_flags,236const char *caller)237{238struct packed_ref_store *refs;239}252{255if (refs->snapshot) {256struct snapshot *snapshot = refs->snapshot;257}262{265struct packed_ref_store *refs = packed_downcast(ref_store, 0, "release");266clear_snapshot(refs);267rollback_lock_file(&refs->lock);268delete_tempfile(&refs->tempfile);269free(refs->path);270}271{275if (len < 80)276die("unterminated line in %s: %.*s", path, (int)len, p);277else278die("unterminated line in %s: %.75s...", path, p);279}280{284const char *eol = memchr(p, '\n', len);285}294{303const struct snapshot *snapshot = cb_data;304const struct snapshot_record *e1 = v1, *e2 = v2;305const char *r1 = e1->start + snapshot_hexsz(snapshot) + 1;306const char *r2 = e2->start + snapshot_hexsz(snapshot) + 1;307}321/*323* Compare a snapshot record at `rec` to the specified NUL-terminated324* refname.325*/326static int cmp_record_to_refname(const char *rec, const char *refname,327int start, const struct snapshot *snapshot)328{329const char *r1 = rec + snapshot_hexsz(snapshot) + 1;330const char *r2 = refname;331}343/*345* `snapshot->buf` is not known to be sorted. Check whether it is, and346* if not, sort it into new memory and munmap/free the old storage.347*/348static void sort_snapshot(struct snapshot *snapshot)349{350struct snapshot_record *records = NULL;351size_t alloc = 0, nr = 0;352int sorted = 1;353const char *pos, *eof, *eol;354size_t len, i;355char *new_buffer, *dst;356* Initialize records based on a crude estimate of the number367* of references in the file (we'll grow it below if needed):368*/369ALLOC_GROW(records, len / 80 + 20, alloc);370* Keep any peeled line together with its383* reference:384*/385const char *peeled_start = eol;386* Allocate a new chunk of memory, and copy the old memory to416* the new in the order indicated by `records` (not bothering417* with the header line):418*/419new_buffer = xmalloc(len);420for (dst = new_buffer, i = 0; i < nr; i++) {421memcpy(dst, records[i].start, records[i].len);422dst += records[i].len;423}424* Now munmap the old buffer and use the sorted buffer in its427* place:428*/429clear_snapshot_buffer(snapshot);430snapshot->buf = snapshot->start = new_buffer;431snapshot->eof = new_buffer + len;432}436/*438* Return a pointer to the start of the record that contains the439* character `*p` (which must be within the buffer). If no other440* record start is found, return `buf`.441*/442static const char *find_start_of_record(const char *buf, const char *p)443{444while (p > buf && (p[-1] != '\n' || p[0] == '^'))445p--;446return p;447}448/*450* Return a pointer to the start of the record following the record451* that contains `*p`. If none is found before `end`, return `end`.452*/453static const char *find_end_of_record(const char *p, const char *end)454{455while (++p < end && (p[-1] != '\n' || p[0] == '^'))456;457return p;458}459/*461* We want to be able to compare mmapped reference records quickly,462* without totally parsing them. We can do so because the records are463* LF-terminated, and the refname should start exactly (GIT_SHA1_HEXSZ464* + 1) bytes past the beginning of the record.465*466* But what if the `packed-refs` file contains garbage? We're willing467* to tolerate not detecting the problem, as long as we don't produce468* totally garbled output (we can't afford to check the integrity of469* the whole file during every Git invocation). But we do want to be470* sure that we never read past the end of the buffer in memory and471* perform an illegal memory access.472*473* Guarantee that minimum level of safety by verifying that the last474* record in the file is LF-terminated, and that it has at least475* (GIT_SHA1_HEXSZ + 1) characters before the LF. Die if either of476* these checks fails.477*/478static void verify_buffer_safe(struct snapshot *snapshot)479{480const char *start = snapshot->start;481const char *eof = snapshot->eof;482const char *last_line;483}493/*497* Depending on `mmap_strategy`, either mmap or read the contents of498* the `packed-refs` file into the snapshot. Return 1 if the file499* existed and was read, or 0 if the file was absent or empty. Die on500* errors.501*/502static int load_contents(struct snapshot *snapshot)503{504int fd;505struct stat st;506size_t size;507ssize_t bytes_read;508* This is OK; it just means that no514* "packed-refs" file has been written yet,515* which is equivalent to it being empty,516* which is its state when initialized with517* zeros.518*/519return 0;520} else {521die_errno("couldn't read %s", snapshot->refs->path);522}523}524}551{556/*557* This is not *quite* a garden-variety binary search, because558* the data we're searching is made up of records, and we559* always need to find the beginning of a record to do a560* comparison. A "record" here is one line for the reference561* itself and zero or one peel lines that start with '^'. Our562* loop invariant is described in the next two comments.563*/564* A pointer to the character at the start of a record whose567* preceding records all have reference names that come568* *before* `refname`.569*/570const char *lo = snapshot->start;571* A pointer to a the first character of a record whose574* reference name comes *after* `refname`.575*/576const char *hi = snapshot->eof;577}599/*601* Find the place in `snapshot->buf` where the start of the record for602* `refname` starts. If `mustexist` is true and the reference doesn't603* exist, then return NULL. If `mustexist` is false and the reference604* doesn't exist, then return the point where that reference would be605* inserted, or `snapshot->eof` (which might be NULL) if it would be606* inserted at the end of the file. In the latter mode, `refname`607* doesn't have to be a proper reference name; for example, one could608* search for "refs/replace/" to find the start of any replace609* references.610*611* The record is sought using a binary search, so `snapshot->buf` must612* be sorted.613*/614static const char *find_reference_location(struct snapshot *snapshot,615const char *refname, int mustexist)616{617return find_reference_location_1(snapshot, refname, mustexist, 1);618}619/*621* Find the place in `snapshot->buf` after the end of the record for622* `refname`. In other words, find the location of first thing *after*623* `refname`.624*625* Other semantics are identical to the ones in626* `find_reference_location()`.627*/628static const char *find_reference_location_end(struct snapshot *snapshot,629const char *refname,630int mustexist)631{632return find_reference_location_1(snapshot, refname, mustexist, 0);633}634/*636* Create a newly-allocated `snapshot` of the `packed-refs` file in637* its current state and return it. The return value will already have638* its reference count incremented.639*640* A comment line of the form "# pack-refs with: " may contain zero or641* more traits. We interpret the traits as follows:642*643* Neither `peeled` nor `fully-peeled`:644*645* Probably no references are peeled. But if the file contains a646* peeled value for a reference, we will use it.647*648* `peeled`:649*650* References under "refs/tags/", if they *can* be peeled, *are*651* peeled in this file. References outside of "refs/tags/" are652* probably not peeled even if they could have been, but if we find653* a peeled value for such a reference we will use it.654*655* `fully-peeled`:656*657* All references in the file that can be peeled are peeled.658* Inversely (and this is more important), any references in the659* file for which no peeled value is recorded is not peelable. This660* trait should typically be written alongside "peeled" for661* compatibility with older clients, but we do not require it662* (i.e., "peeled" is a no-op if "fully-peeled" is set).663*664* `sorted`:665*666* The references in this file are known to be sorted by refname.667*/668static struct snapshot *create_snapshot(struct packed_ref_store *refs)669{670struct snapshot *snapshot = xcalloc(1, sizeof(*snapshot));671int sorted = 0;672* Reordering the records might have moved a short one724* to the end of the buffer, so verify the buffer's725* safety again:726*/727verify_buffer_safe(snapshot);728}729* We don't want to leave the file mmapped, so we are733* forced to make a copy now:734*/735size_t size = snapshot->eof - snapshot->start;736char *buf_copy = xmalloc(size);737}746/*748* Check that `refs->snapshot` (if present) still reflects the749* contents of the `packed-refs` file. If not, clear the snapshot.750*/751static void validate_snapshot(struct packed_ref_store *refs)752{753if (refs->snapshot &&754!stat_validity_check(&refs->snapshot->validity, refs->path))755clear_snapshot(refs);756}757/*759* Get the `snapshot` for the specified packed_ref_store, creating and760* populating it if it hasn't been read before or if the file has been761* changed (according to its `validity` field) since it was last read.762* On the other hand, if we hold the lock, then assume that the file763* hasn't been changed out from under us, so skip the extra `stat()`764* call in `stat_validity_check()`. This function does *not* increase765* the snapshot's reference count on behalf of the caller.766*/767static struct snapshot *get_snapshot(struct packed_ref_store *refs)768{769if (!is_lock_file_locked(&refs->lock))770validate_snapshot(refs);771}777{782struct packed_ref_store *refs =783packed_downcast(ref_store, REF_STORE_READ, "read_raw_ref");784struct snapshot *snapshot = get_snapshot(refs);785const char *rec;786}803/*805* This value is set in `base.flags` if the peeled value of the806* current reference is known. In that case, `peeled` contains the807* correct peeled value for the reference, which might be `null_oid`808* if the reference is not a tag or if it is broken.809*/810#define REF_KNOWS_PEELED 0x40811/*813* An iterator over a snapshot of a `packed-refs` file.814*/815struct packed_ref_iterator {816struct ref_iterator base;817/*842* Move the iterator to the next record in the snapshot, without843* respect for whether the record is actually required by the current844* iteration. Adjust the fields in `iter` and return `ITER_OK` or845* `ITER_DONE`. This function does not free the iterator in the case846* of `ITER_DONE`.847*/848static int next_record(struct packed_ref_iterator *iter)849{850const char *p, *eol;851* If iter->pos is contained within a skipped region, jump past856* it.857*858* Note that each skipped region is considered at most once,859* since they are ordered based on their starting position.860*/861while (iter->jump_cur < iter->jump_nr) {862struct jump_list_entry *curr = &iter->jump[iter->jump_cur];863if (iter->pos < curr->start)864break; /* not to the next jump yet */865* Regardless of what the file header said, we920* definitely know the value of *this* reference. But921* we suppress it if the reference is broken:922*/923if ((iter->base.flags & REF_ISBROKEN)) {924oidclr(&iter->peeled, iter->repo->hash_algo);925iter->base.flags &= ~REF_KNOWS_PEELED;926} else {927iter->base.flags |= REF_KNOWS_PEELED;928}929} else {930oidclr(&iter->peeled, iter->repo->hash_algo);931}932}935{938struct packed_ref_iterator *iter =939(struct packed_ref_iterator *)ref_iterator;940int ok;941}960{964struct packed_ref_iterator *iter =965(struct packed_ref_iterator *)ref_iterator;966}976{979struct packed_ref_iterator *iter =980(struct packed_ref_iterator *)ref_iterator;981int ok = ITER_DONE;982}989{998const struct jump_list_entry *a = va;999const struct jump_list_entry *b = vb;1000}1007{1010const char *p;1011for (p = str; *p; p++) {1012if (is_glob_special(*p))1013return 1;1014}1015return 0;1016}1017{1022size_t i, j;1023const char **pattern;1024struct jump_list_entry *last_disjoint;1025* We can't feed any excludes with globs in them to the1035* refs machinery. It only understands prefix matching.1036* We likewise can't even feed the string leading up to1037* the first meta-character, as something like "foo[a]"1038* should not exclude "foobar" (but the prefix "foo"1039* would match that and mark it for exclusion).1040*/1041if (has_glob_special(*pattern))1042continue;1043* Every entry in exclude_patterns has a meta-character,1060* nothing to do here.1061*/1062return;1063}1064* As an optimization, merge adjacent entries in the jump list1069* to jump forwards as far as possible when entering a skipped1070* region.1071*1072* For example, if we have two skipped regions:1073*1074* [[A, B], [B, C]]1075*1076* we want to combine that into a single entry jumping from A to1077* C.1078*/1079last_disjoint = iter->jump;1080}1097{1103struct packed_ref_store *refs;1104struct snapshot *snapshot;1105const char *start;1106struct packed_ref_iterator *iter;1107struct ref_iterator *ref_iterator;1108unsigned int required_flags = REF_STORE_READ;1109* Note that `get_snapshot()` internally checks whether the1116* snapshot is up to date with what is on disk, and re-reads1117* it if not.1118*/1119snapshot = get_snapshot(refs);1120}1154/*1156* Write an entry to the packed-refs file for the specified refname.1157* If peeled is non-NULL, write it as the entry's peeled value. On1158* error, return a nonzero value and leave errno set at the value left1159* by the failing call to `fprintf()`.1160*/1161static int write_packed_entry(FILE *fh, const char *refname,1162const struct object_id *oid,1163const struct object_id *peeled)1164{1165if (fprintf(fh, "%s %s\n", oid_to_hex(oid), refname) < 0 ||1166(peeled && fprintf(fh, "^%s\n", oid_to_hex(peeled)) < 0))1167return -1;1168}1171{1174struct packed_ref_store *refs =1175packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN,1176"packed_refs_lock");1177static int timeout_configured = 0;1178static int timeout_value = 1000;1179* Note that we close the lockfile immediately because we1187* don't write new content to it, but rather to a separate1188* tempfile.1189*/1190if (hold_lock_file_for_update_timeout(1191&refs->lock,1192refs->path,1193flags, timeout_value) < 0) {1194unable_to_lock_message(refs->path, errno, err);1195return -1;1196}1197* There is a stat-validity problem might cause `update-ref -d`1206* lost the newly commit of a ref, because a new `packed-refs`1207* file might has the same on-disk file attributes such as1208* timestamp, file size and inode value, but has a changed1209* ref value.1210*1211* This could happen with a very small chance when1212* `update-ref -d` is called and at the same time another1213* `pack-refs --all` process is running.1214*1215* Now that we hold the `packed-refs` lock, it is important1216* to make sure we could read the latest version of1217* `packed-refs` file no matter we have just mmap it or not.1218* So what need to do is clear the snapshot if we hold it1219* already.1220*/1221clear_snapshot(refs);1222* Now make sure that the packed-refs file as it exists in the1225* locked state is loaded into the snapshot:1226*/1227get_snapshot(refs);1228return 0;1229}1230{1233struct packed_ref_store *refs = packed_downcast(1234ref_store,1235REF_STORE_READ | REF_STORE_WRITE,1236"packed_refs_unlock");1237}1242{1245struct packed_ref_store *refs = packed_downcast(1246ref_store,1247REF_STORE_READ | REF_STORE_WRITE,1248"packed_refs_is_locked");1249}1252/*1254* The packed-refs header line that we write out. Perhaps other traits1255* will be added later.1256*1257* Note that earlier versions of Git used to parse these traits by1258* looking for " trait " in the line. For this reason, the space after1259* the colon and the trailing space are required.1260*/1261static const char PACKED_REFS_HEADER[] =1262"# pack-refs with: peeled fully-peeled sorted \n";1263{1268/* Nothing to do. */1269return 0;1270}1271{1275struct packed_ref_store *refs = packed_downcast(ref_store, 0, "remove");1276}1284/*1286* Write the packed refs from the current snapshot to the packed-refs1287* tempfile, incorporating any changes from `updates`. `updates` must1288* be a sorted string list whose keys are the refnames and whose util1289* values are `struct ref_update *`. On error, rollback the tempfile,1290* write an error message to `err`, and return a nonzero value.1291*1292* The packfile must be locked before calling this function and will1293* remain locked when it is done.1294*/1295static int write_with_updates(struct packed_ref_store *refs,1296struct string_list *updates,1297struct strbuf *err)1298{1299struct ref_iterator *iter = NULL;1300size_t i;1301int ok;1302FILE *out;1303struct strbuf sb = STRBUF_INIT;1304char *packed_refs_path;1305* If packed-refs is a symlink, we want to overwrite the1311* symlinked-to file, not the symlink itself. Also, put the1312* staging file next to it:1313*/1314packed_refs_path = get_locked_file_path(&refs->lock);1315strbuf_addf(&sb, "%s.new", packed_refs_path);1316free(packed_refs_path);1317refs->tempfile = create_tempfile(sb.buf);1318if (!refs->tempfile) {1319strbuf_addf(err, "unable to create file %s: %s",1320sb.buf, strerror(errno));1321strbuf_release(&sb);1322return -1;1323}1324strbuf_release(&sb);1325* We iterate in parallel through the current list of refs and1338* the list of updates, processing an entry from at least one1339* of the lists each time through the loop. When the current1340* list of refs is exhausted, set iter to NULL. When the list1341* of updates is exhausted, leave i set to updates->nr.1342*/1343iter = packed_ref_iterator_begin(&refs->base, "", NULL,1344DO_FOR_EACH_INCLUDE_BROKEN);1345if ((ok = ref_iterator_advance(iter)) != ITER_OK)1346iter = NULL;1347* There is both an old value and an update1368* for this reference. Check the old value if1369* necessary:1370*/1371if ((update->flags & REF_HAVE_OLD)) {1372if (is_null_oid(&update->old_oid)) {1373strbuf_addf(err, "cannot update ref '%s': "1374"reference already exists",1375update->refname);1376goto error;1377} else if (!oideq(&update->old_oid, iter->oid)) {1378strbuf_addf(err, "cannot update ref '%s': "1379"is at %s but expected %s",1380update->refname,1381oid_to_hex(iter->oid),1382oid_to_hex(&update->old_oid));1383goto error;1384}1385}1386* The update takes precedence. Skip1391* the iterator over the unneeded1392* value.1393*/1394if ((ok = ref_iterator_advance(iter)) != ITER_OK)1395iter = NULL;1396cmp = +1;1397} else {1398/*1399* The update doesn't actually want to1400* change anything. We're done with it.1401*/1402i++;1403cmp = -1;1404}1405} else if (cmp > 0) {1406/*1407* There is no old value but there is an1408* update for this reference. Make sure that1409* the update didn't expect an existing value:1410*/1411if ((update->flags & REF_HAVE_OLD) &&1412!is_null_oid(&update->old_oid)) {1413strbuf_addf(err, "cannot update ref '%s': "1414"reference is missing but expected %s",1415update->refname,1416oid_to_hex(&update->old_oid));1417goto error;1418}1419}1420* The update wants to delete the reference,1437* and the reference either didn't exist or we1438* have already skipped it. So we're done with1439* the update (and don't have to write1440* anything).1441*/1442i++;1443} else {1444struct object_id peeled;1445int peel_error = peel_object(refs->base.repo,1446&update->new_oid,1447&peeled);1448}1488{1492struct packed_ref_store *refs = packed_downcast(1493ref_store,1494REF_STORE_READ,1495"is_packed_transaction_needed");1496struct strbuf referent = STRBUF_INIT;1497size_t i;1498int ret;1499* We're only going to bother returning false for the common,1505* trivial case that references are only being deleted, their1506* old values are not being checked, and the old `packed-refs`1507* file doesn't contain any of those reference(s). This gives1508* false positives for some other cases that could1509* theoretically be optimized away:1510*1511* 1. It could be that the old value is being verified without1512* setting a new value. In this case, we could verify the1513* old value here and skip the update if it agrees. If it1514* disagrees, we could either let the update go through1515* (the actual commit would re-detect and report the1516* problem), or come up with a way of reporting such an1517* error to *our* caller.1518*1519* 2. It could be that a new value is being set, but that it1520* is identical to the current packed value of the1521* reference.1522*1523* Neither of these cases will come up in the current code,1524* because the only caller of this function passes to it a1525* transaction that only includes `delete` updates with no1526* `old_id`. Even if that ever changes, false positives only1527* cause an optimization to be missed; they do not affect1528* correctness.1529*/1530* Start with the cheap checks that don't require old1533* reference values to be read:1534*/1535for (i = 0; i < transaction->nr; i++) {1536struct ref_update *update = transaction->updates[i];1537* The transaction isn't checking any old values nor is it1549* setting any nonzero new values, so it still might be able1550* to be skipped. Now do the more expensive check: the update1551* is needed if any of the updates is a delete, and the old1552* `packed-refs` file contains a value for that reference.1553*/1554ret = 0;1555for (i = 0; i < transaction->nr; i++) {1556struct ref_update *update = transaction->updates[i];1557int failure_errno;1558unsigned int type;1559struct object_id oid;1560* This reference isn't being deleted -> not1564* needed.1565*/1566continue;1567* We have to actually delete that reference1573* -> this transaction is needed.1574*/1575ret = 1;1576break;1577}1578}1579}1583{1594struct packed_transaction_backend_data *data = transaction->backend_data;1595}1613{1618struct packed_ref_store *refs = packed_downcast(1619ref_store,1620REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,1621"ref_transaction_prepare");1622struct packed_transaction_backend_data *data;1623size_t i;1624int ret = TRANSACTION_GENERIC_ERROR;1625* Note that we *don't* skip transactions with zero updates,1628* because such a transaction might be executed for the side1629* effect of ensuring that all of the references are peeled or1630* ensuring that the `packed-refs` file is sorted. If the1631* caller wants to optimize away empty transactions, it should1632* do so itself.1633*/1634* Stick the updates in a string list by refname so that we1642* can sort them:1643*/1644for (i = 0; i < transaction->nr; i++) {1645struct ref_update *update = transaction->updates[i];1646struct string_list_item *item =1647string_list_append(&data->updates, update->refname);1648}1673{1678struct packed_ref_store *refs = packed_downcast(1679ref_store,1680REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,1681"ref_transaction_abort");1682}1686{1691struct packed_ref_store *refs = packed_downcast(1692ref_store,1693REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,1694"ref_transaction_finish");1695int ret = TRANSACTION_GENERIC_ERROR;1696char *packed_refs_path;1697}1714{1719return ref_transaction_commit(transaction, err);1720}1721{1725/*1726* Packed refs are already packed. It might be that loose refs1727* are packed *into* a packed refs store, but that is done by1728* updating the packed references via a transaction.1729*/1730return 0;1731}1732{1735return empty_ref_iterator_begin();1736}1737{1741return 0;1742}1743