#include "builtin.h"

#include "cache.h"

#include "repository.h"

#include "config.h"

#include "attr.h"

#include "object.h"

#include "blob.h"

#include "commit.h"

#include "tag.h"

#include "tree.h"

#include "delta.h"

#include "pack.h"

#include "pack-revindex.h"

#include "csum-file.h"

#include "tree-walk.h"

#include "diff.h"

#include "revision.h"

#include "list-objects.h"

#include "list-objects-filter.h"

#include "list-objects-filter-options.h"

#include "pack-objects.h"

#include "progress.h"

#include "refs.h"

#include "streaming.h"

#include "thread-utils.h"

#include "pack-bitmap.h"

#include "delta-islands.h"

#include "reachable.h"

#include "sha1-array.h"

#include "argv-array.h"

#include "list.h"

#include "packfile.h"

#include "object-store.h"

#include "dir.h"

#include "midx.h"

#define IN_PACK(obj) oe_in_pack(&to_pack, obj)

#define SIZE(obj) oe_size(&to_pack, obj)

#define SET_SIZE(obj,size) oe_set_size(&to_pack, obj, size)

#define DELTA_SIZE(obj) oe_delta_size(&to_pack, obj)

#define DELTA(obj) oe_delta(&to_pack, obj)

#define DELTA_CHILD(obj) oe_delta_child(&to_pack, obj)

#define DELTA_SIBLING(obj) oe_delta_sibling(&to_pack, obj)

#define SET_DELTA(obj, val) oe_set_delta(&to_pack, obj, val)

#define SET_DELTA_EXT(obj, oid) oe_set_delta_ext(&to_pack, obj, oid)

#define SET_DELTA_SIZE(obj, val) oe_set_delta_size(&to_pack, obj, val)

#define SET_DELTA_CHILD(obj, val) oe_set_delta_child(&to_pack, obj, val)

#define SET_DELTA_SIBLING(obj, val) oe_set_delta_sibling(&to_pack, obj, val)

static const char *pack_usage[] = {

N_("git pack-objects --stdout [<options>...] [< <ref-list> | < <object-list>]"),

N_("git pack-objects [<options>...] <base-name> [< <ref-list> | < <object-list>]"),

NULL

};

static struct packing_data to_pack;

static struct pack_idx_entry **written_list;

static uint32_t nr_result, nr_written, nr_seen;

static struct bitmap_index *bitmap_git;

static uint32_t write_layer;

static int non_empty;

static int reuse_delta = 1, reuse_object = 1;

static int keep_unreachable, unpack_unreachable, include_tag;

static timestamp_t unpack_unreachable_expiration;

static int pack_loose_unreachable;

static int local;

static int have_non_local_packs;

static int incremental;

static int ignore_packed_keep_on_disk;

static int ignore_packed_keep_in_core;

static int allow_ofs_delta;

static struct pack_idx_option pack_idx_opts;

static const char *base_name;

static int progress = 1;

static int window = 10;

static unsigned long pack_size_limit;

static int depth = 50;

static int delta_search_threads;

static int pack_to_stdout;

static int thin;

static int num_preferred_base;

static struct progress *progress_state;

static struct packed_git *reuse_packfile;

static uint32_t reuse_packfile_objects;

static off_t reuse_packfile_offset;

static int use_bitmap_index_default = 1;

static int use_bitmap_index = -1;

static int write_bitmap_index;

static uint16_t write_bitmap_options;

static int exclude_promisor_objects;

static int use_delta_islands;

static unsigned long delta_cache_size = 0;

static unsigned long max_delta_cache_size = DEFAULT_DELTA_CACHE_SIZE;

static unsigned long cache_max_small_delta_size = 1000;

static unsigned long window_memory_limit = 0;

static struct list_objects_filter_options filter_options;

enum missing_action {

};

static enum missing_action arg_missing_action;

static show_object_fn fn_show_object;

static uint32_t written, written_delta;

static uint32_t reused, reused_delta;

static struct commit **indexed_commits;

static unsigned int indexed_commits_nr;

static unsigned int indexed_commits_alloc;

static void index_commit_for_bitmap(struct commit *commit)

{

if (indexed_commits_nr >= indexed_commits_alloc) {

indexed_commits_alloc = (indexed_commits_alloc + 32) * 2;

REALLOC_ARRAY(indexed_commits, indexed_commits_alloc);

}

indexed_commits[indexed_commits_nr++] = commit;

}

static void *get_delta(struct object_entry *entry)

{

unsigned long size, base_size, delta_size;

void *buf, *base_buf, *delta_buf;

enum object_type type;

buf = read_object_file(&entry->idx.oid, &type, &size);

if (!buf)

die(_("unable to read %s"), oid_to_hex(&entry->idx.oid));

base_buf = read_object_file(&DELTA(entry)->idx.oid, &type,

&base_size);

if (!base_buf)

die("unable to read %s",

oid_to_hex(&DELTA(entry)->idx.oid));

delta_buf = diff_delta(base_buf, base_size,

buf, size, &delta_size, 0);

/*

if (!delta_buf || delta_size != DELTA_SIZE(entry))

BUG("delta size changed");

free(buf);

free(base_buf);

return delta_buf;

}

static unsigned long do_compress(void **pptr, unsigned long size)

{

git_zstream stream;

void *in, *out;

unsigned long maxsize;

git_deflate_init(&stream, pack_compression_level);

maxsize = git_deflate_bound(&stream, size);

in = *pptr;

out = xmalloc(maxsize);

*pptr = out;

stream.next_in = in;

stream.avail_in = size;

stream.next_out = out;

stream.avail_out = maxsize;

while (git_deflate(&stream, Z_FINISH) == Z_OK)

; /* nothing */

git_deflate_end(&stream);

free(in);

return stream.total_out;

}

static unsigned long write_large_blob_data(struct git_istream *st, struct hashfile *f,

const struct object_id *oid)

{

git_zstream stream;

unsigned char ibuf[1024 * 16];

unsigned char obuf[1024 * 16];

unsigned long olen = 0;

git_deflate_init(&stream, pack_compression_level);

for (;;) {

ssize_t readlen;

int zret = Z_OK;

readlen = read_istream(st, ibuf, sizeof(ibuf));

if (readlen == -1)

die(_("unable to read %s"), oid_to_hex(oid));

stream.next_in = ibuf;

stream.avail_in = readlen;

while ((stream.avail_in || readlen == 0) &&

(zret == Z_OK || zret == Z_BUF_ERROR)) {

stream.next_out = obuf;

stream.avail_out = sizeof(obuf);

zret = git_deflate(&stream, readlen ? 0 : Z_FINISH);

hashwrite(f, obuf, stream.next_out - obuf);

olen += stream.next_out - obuf;

}

if (stream.avail_in)

die(_("deflate error (%d)"), zret);

if (readlen == 0) {

if (zret != Z_STREAM_END)

die(_("deflate error (%d)"), zret);

break;

}

}

git_deflate_end(&stream);

return olen;

}

static int check_pack_inflate(struct packed_git *p,

unsigned long expect)

{

git_zstream stream;

unsigned char fakebuf[4096], *in;

int st;

memset(&stream, 0, sizeof(stream));

git_inflate_init(&stream);

do {

in = use_pack(p, w_curs, offset, &stream.avail_in);

stream.next_in = in;

stream.next_out = fakebuf;

stream.avail_out = sizeof(fakebuf);

st = git_inflate(&stream, Z_FINISH);

offset += stream.next_in - in;

} while (st == Z_OK || st == Z_BUF_ERROR);

git_inflate_end(&stream);

return (st == Z_STREAM_END &&

stream.total_out == expect &&

stream.total_in == len) ? 0 : -1;

}

static void copy_pack_data(struct hashfile *f,

off_t len)

{

unsigned char *in;

unsigned long avail;

while (len) {

in = use_pack(p, w_curs, offset, &avail);

if (avail > len)

avail = (unsigned long)len;

hashwrite(f, in, avail);

offset += avail;

len -= avail;

}

}

static unsigned long write_no_reuse_object(struct hashfile *f, struct object_entry *entry,

unsigned long limit, int usable_delta)

{

unsigned long size, datalen;

unsigned char header[MAX_PACK_OBJECT_HEADER],

dheader[MAX_PACK_OBJECT_HEADER];

unsigned hdrlen;

enum object_type type;

void *buf;

struct git_istream *st = NULL;

const unsigned hashsz = the_hash_algo->rawsz;

if (!usable_delta) {

if (oe_type(entry) == OBJ_BLOB &&

oe_size_greater_than(&to_pack, entry, big_file_threshold) &&

(st = open_istream(&entry->idx.oid, &type, &size, NULL)) != NULL)

buf = NULL;

else {

buf = read_object_file(&entry->idx.oid, &type, &size);

if (!buf)

die(_("unable to read %s"),

oid_to_hex(&entry->idx.oid));

}

/*

FREE_AND_NULL(entry->delta_data);

entry->z_delta_size = 0;

} else if (entry->delta_data) {

size = DELTA_SIZE(entry);

buf = entry->delta_data;

entry->delta_data = NULL;

type = (allow_ofs_delta && DELTA(entry)->idx.offset) ?

OBJ_OFS_DELTA : OBJ_REF_DELTA;

} else {

buf = get_delta(entry);

size = DELTA_SIZE(entry);

type = (allow_ofs_delta && DELTA(entry)->idx.offset) ?

OBJ_OFS_DELTA : OBJ_REF_DELTA;

}

if (st) /* large blob case, just assume we don't compress well */

datalen = size;

else if (entry->z_delta_size)

datalen = entry->z_delta_size;

else

datalen = do_compress(&buf, size);

/*

hdrlen = encode_in_pack_object_header(header, sizeof(header),

type, size);

if (type == OBJ_OFS_DELTA) {

/*

off_t ofs = entry->idx.offset - DELTA(entry)->idx.offset;

unsigned pos = sizeof(dheader) - 1;

dheader[pos] = ofs & 127;

while (ofs >>= 7)

dheader[--pos] = 128 | (--ofs & 127);

if (limit && hdrlen + sizeof(dheader) - pos + datalen + hashsz >= limit) {

if (st)

close_istream(st);

free(buf);

return 0;

}

hashwrite(f, header, hdrlen);

hashwrite(f, dheader + pos, sizeof(dheader) - pos);

hdrlen += sizeof(dheader) - pos;

} else if (type == OBJ_REF_DELTA) {

/*

if (limit && hdrlen + hashsz + datalen + hashsz >= limit) {

if (st)

close_istream(st);

free(buf);

return 0;

}

hashwrite(f, header, hdrlen);

hashwrite(f, DELTA(entry)->idx.oid.hash, hashsz);

hdrlen += hashsz;

} else {

if (limit && hdrlen + datalen + hashsz >= limit) {

if (st)

close_istream(st);

free(buf);

return 0;

}

hashwrite(f, header, hdrlen);

}

if (st) {

datalen = write_large_blob_data(st, f, &entry->idx.oid);

close_istream(st);

} else {

hashwrite(f, buf, datalen);

free(buf);

}

return hdrlen + datalen;

}

static off_t write_reuse_object(struct hashfile *f, struct object_entry *entry,

unsigned long limit, int usable_delta)

{

struct packed_git *p = IN_PACK(entry);

struct pack_window *w_curs = NULL;

struct revindex_entry *revidx;

off_t offset;

enum object_type type = oe_type(entry);

off_t datalen;

unsigned char header[MAX_PACK_OBJECT_HEADER],

dheader[MAX_PACK_OBJECT_HEADER];

unsigned hdrlen;

const unsigned hashsz = the_hash_algo->rawsz;

unsigned long entry_size = SIZE(entry);

if (DELTA(entry))

type = (allow_ofs_delta && DELTA(entry)->idx.offset) ?

OBJ_OFS_DELTA : OBJ_REF_DELTA;

hdrlen = encode_in_pack_object_header(header, sizeof(header),

type, entry_size);

offset = entry->in_pack_offset;

revidx = find_pack_revindex(p, offset);

datalen = revidx[1].offset - offset;

if (!pack_to_stdout && p->index_version > 1 &&

check_pack_crc(p, &w_curs, offset, datalen, revidx->nr)) {

error(_("bad packed object CRC for %s"),

oid_to_hex(&entry->idx.oid));

unuse_pack(&w_curs);

return write_no_reuse_object(f, entry, limit, usable_delta);

}

offset += entry->in_pack_header_size;

datalen -= entry->in_pack_header_size;

if (!pack_to_stdout && p->index_version == 1 &&

check_pack_inflate(p, &w_curs, offset, datalen, entry_size)) {

error(_("corrupt packed object for %s"),

oid_to_hex(&entry->idx.oid));

unuse_pack(&w_curs);

return write_no_reuse_object(f, entry, limit, usable_delta);

}

if (type == OBJ_OFS_DELTA) {

off_t ofs = entry->idx.offset - DELTA(entry)->idx.offset;

unsigned pos = sizeof(dheader) - 1;

dheader[pos] = ofs & 127;

while (ofs >>= 7)

dheader[--pos] = 128 | (--ofs & 127);

if (limit && hdrlen + sizeof(dheader) - pos + datalen + hashsz >= limit) {

unuse_pack(&w_curs);

return 0;

}

hashwrite(f, header, hdrlen);

hashwrite(f, dheader + pos, sizeof(dheader) - pos);

hdrlen += sizeof(dheader) - pos;

reused_delta++;

} else if (type == OBJ_REF_DELTA) {

if (limit && hdrlen + hashsz + datalen + hashsz >= limit) {

unuse_pack(&w_curs);

return 0;

}

hashwrite(f, header, hdrlen);

hashwrite(f, DELTA(entry)->idx.oid.hash, hashsz);

hdrlen += hashsz;

reused_delta++;

} else {

if (limit && hdrlen + datalen + hashsz >= limit) {

unuse_pack(&w_curs);

return 0;

}

hashwrite(f, header, hdrlen);

}

copy_pack_data(f, p, &w_curs, offset, datalen);

unuse_pack(&w_curs);

reused++;

return hdrlen + datalen;

}

static off_t write_object(struct hashfile *f,

struct object_entry *entry,

off_t write_offset)

{

unsigned long limit;

off_t len;

int usable_delta, to_reuse;

if (!pack_to_stdout)

crc32_begin(f);

/* apply size limit if limited packsize and not first object */

if (!pack_size_limit || !nr_written)

limit = 0;

else if (pack_size_limit <= write_offset)

/*

limit = 1;

else

limit = pack_size_limit - write_offset;

if (!DELTA(entry))

usable_delta = 0; /* no delta */

else if (!pack_size_limit)

usable_delta = 1; /* unlimited packfile */

else if (DELTA(entry)->idx.offset == (off_t)-1)

usable_delta = 0; /* base was written to another pack */

else if (DELTA(entry)->idx.offset)

usable_delta = 1; /* base already exists in this pack */

else

usable_delta = 0; /* base could end up in another pack */

if (!reuse_object)

to_reuse = 0; /* explicit */

else if (!IN_PACK(entry))

to_reuse = 0; /* can't reuse what we don't have */

else if (oe_type(entry) == OBJ_REF_DELTA ||

oe_type(entry) == OBJ_OFS_DELTA)

/* check_object() decided it for us ... */

to_reuse = usable_delta;

/* ... but pack split may override that */

else if (oe_type(entry) != entry->in_pack_type)

to_reuse = 0; /* pack has delta which is unusable */

else if (DELTA(entry))

to_reuse = 0; /* we want to pack afresh */

else

to_reuse = 1; /* we have it in-pack undeltified,

if (!to_reuse)

len = write_no_reuse_object(f, entry, limit, usable_delta);

else

len = write_reuse_object(f, entry, limit, usable_delta);

if (!len)

return 0;

if (usable_delta)

written_delta++;

written++;

if (!pack_to_stdout)

entry->idx.crc32 = crc32_end(f);

return len;

}

enum write_one_status {

};

static enum write_one_status write_one(struct hashfile *f,

struct object_entry *e,

off_t *offset)

{

off_t size;

int recursing;

/*

recursing = (e->idx.offset == 1);

if (recursing) {

warning(_("recursive delta detected for object %s"),

oid_to_hex(&e->idx.oid));

return WRITE_ONE_RECURSIVE;

} else if (e->idx.offset || e->preferred_base) {

/* offset is non zero if object is written already. */

return WRITE_ONE_SKIP;

}

/* if we are deltified, write out base object first. */

if (DELTA(e)) {

e->idx.offset = 1; /* now recurse */

switch (write_one(f, DELTA(e), offset)) {

case WRITE_ONE_RECURSIVE:

/* we cannot depend on this one */

SET_DELTA(e, NULL);

break;

default:

break;

case WRITE_ONE_BREAK:

e->idx.offset = recursing;

return WRITE_ONE_BREAK;

}

}

e->idx.offset = *offset;

size = write_object(f, e, *offset);

if (!size) {

e->idx.offset = recursing;

return WRITE_ONE_BREAK;

}

written_list[nr_written++] = &e->idx;

/* make sure off_t is sufficiently large not to wrap */

if (signed_add_overflows(*offset, size))

die(_("pack too large for current definition of off_t"));

*offset += size;

return WRITE_ONE_WRITTEN;

}

static int mark_tagged(const char *path, const struct object_id *oid, int flag,

void *cb_data)

{

struct object_id peeled;

struct object_entry *entry = packlist_find(&to_pack, oid->hash, NULL);

if (entry)

entry->tagged = 1;

if (!peel_ref(path, &peeled)) {

entry = packlist_find(&to_pack, peeled.hash, NULL);

if (entry)

entry->tagged = 1;

}

return 0;

}

static inline void add_to_write_order(struct object_entry **wo,

unsigned int *endp,

struct object_entry *e)

{

if (e->filled || oe_layer(&to_pack, e) != write_layer)

return;

wo[(*endp)++] = e;

e->filled = 1;

}

static void add_descendants_to_write_order(struct object_entry **wo,

unsigned int *endp,

struct object_entry *e)

{

int add_to_order = 1;

while (e) {

if (add_to_order) {

struct object_entry *s;

/* add this node... */

add_to_write_order(wo, endp, e);

/* all its siblings... */

for (s = DELTA_SIBLING(e); s; s = DELTA_SIBLING(s)) {

add_to_write_order(wo, endp, s);

}

}

/* drop down a level to add left subtree nodes if possible */

if (DELTA_CHILD(e)) {

add_to_order = 1;

e = DELTA_CHILD(e);

} else {

add_to_order = 0;

/* our sibling might have some children, it is next */

if (DELTA_SIBLING(e)) {

e = DELTA_SIBLING(e);

continue;

}

/* go back to our parent node */

e = DELTA(e);

while (e && !DELTA_SIBLING(e)) {

/* we're on the right side of a subtree, keep

e = DELTA(e);

}

if (!e) {

/* done- we hit our original root node */

return;

}

/* pass it off to sibling at this level */

e = DELTA_SIBLING(e);

}

};

}

static void add_family_to_write_order(struct object_entry **wo,

unsigned int *endp,

struct object_entry *e)

{

struct object_entry *root;

for (root = e; DELTA(root); root = DELTA(root))

; /* nothing */

add_descendants_to_write_order(wo, endp, root);

}

static void compute_layer_order(struct object_entry **wo, unsigned int *wo_end)

{

unsigned int i, last_untagged;

struct object_entry *objects = to_pack.objects;

for (i = 0; i < to_pack.nr_objects; i++) {

if (objects[i].tagged)

break;

add_to_write_order(wo, wo_end, &objects[i]);

}

last_untagged = i;

/*

for (; i < to_pack.nr_objects; i++) {

if (objects[i].tagged)

add_to_write_order(wo, wo_end, &objects[i]);

}

/*

for (i = last_untagged; i < to_pack.nr_objects; i++) {

if (oe_type(&objects[i]) != OBJ_COMMIT &&

oe_type(&objects[i]) != OBJ_TAG)

continue;

add_to_write_order(wo, wo_end, &objects[i]);

}

/*

for (i = last_untagged; i < to_pack.nr_objects; i++) {

if (oe_type(&objects[i]) != OBJ_TREE)

continue;

add_to_write_order(wo, wo_end, &objects[i]);

}

/*

for (i = last_untagged; i < to_pack.nr_objects; i++) {

if (!objects[i].filled && oe_layer(&to_pack, &objects[i]) == write_layer)

add_family_to_write_order(wo, wo_end, &objects[i]);

}

}

static struct object_entry **compute_write_order(void)

{

uint32_t max_layers = 1;

unsigned int i, wo_end;

struct object_entry **wo;

struct object_entry *objects = to_pack.objects;

for (i = 0; i < to_pack.nr_objects; i++) {

objects[i].tagged = 0;

objects[i].filled = 0;

SET_DELTA_CHILD(&objects[i], NULL);

SET_DELTA_SIBLING(&objects[i], NULL);

}

/*

for (i = to_pack.nr_objects; i > 0;) {

struct object_entry *e = &objects[--i];

if (!DELTA(e))

continue;

/* Mark me as the first child */

e->delta_sibling_idx = DELTA(e)->delta_child_idx;

SET_DELTA_CHILD(DELTA(e), e);

}

/*

for_each_tag_ref(mark_tagged, NULL);

if (use_delta_islands)

max_layers = compute_pack_layers(&to_pack);

ALLOC_ARRAY(wo, to_pack.nr_objects);

wo_end = 0;

for (; write_layer < max_layers; ++write_layer)

compute_layer_order(wo, &wo_end);

if (wo_end != to_pack.nr_objects)

die(_("ordered %u objects, expected %"PRIu32),

wo_end, to_pack.nr_objects);

return wo;

}

static off_t write_reused_pack(struct hashfile *f)

{

unsigned char buffer[8192];

off_t to_write, total;

int fd;

if (!is_pack_valid(reuse_packfile))

die(_("packfile is invalid: %s"), reuse_packfile->pack_name);

fd = git_open(reuse_packfile->pack_name);

if (fd < 0)

die_errno(_("unable to open packfile for reuse: %s"),

reuse_packfile->pack_name);

if (lseek(fd, sizeof(struct pack_header), SEEK_SET) == -1)

die_errno(_("unable to seek in reused packfile"));

if (reuse_packfile_offset < 0)

reuse_packfile_offset = reuse_packfile->pack_size - the_hash_algo->rawsz;

total = to_write = reuse_packfile_offset - sizeof(struct pack_header);

while (to_write) {

int read_pack = xread(fd, buffer, sizeof(buffer));

if (read_pack <= 0)

die_errno(_("unable to read from reused packfile"));

if (read_pack > to_write)

read_pack = to_write;

hashwrite(f, buffer, read_pack);

to_write -= read_pack;

/*

written = reuse_packfile_objects *

(((double)(total - to_write)) / total);

display_progress(progress_state, written);

}

close(fd);

written = reuse_packfile_objects;

display_progress(progress_state, written);

return reuse_packfile_offset - sizeof(struct pack_header);

}

static const char no_split_warning[] = N_(

);

static void write_pack_file(void)

{

uint32_t i = 0, j;

struct hashfile *f;

off_t offset;

uint32_t nr_remaining = nr_result;

time_t last_mtime = 0;

struct object_entry **write_order;

if (progress > pack_to_stdout)

progress_state = start_progress(_("Writing objects"), nr_result);

ALLOC_ARRAY(written_list, to_pack.nr_objects);

write_order = compute_write_order();

do {

struct object_id oid;

char *pack_tmp_name = NULL;

if (pack_to_stdout)

f = hashfd_throughput(1, "<stdout>", progress_state);

else

f = create_tmp_packfile(&pack_tmp_name);

offset = write_pack_header(f, nr_remaining);

if (reuse_packfile) {

off_t packfile_size;

assert(pack_to_stdout);

packfile_size = write_reused_pack(f);

offset += packfile_size;

}

nr_written = 0;

for (; i < to_pack.nr_objects; i++) {

struct object_entry *e = write_order[i];

if (write_one(f, e, &offset) == WRITE_ONE_BREAK)

break;

display_progress(progress_state, written);

}

/*

if (pack_to_stdout) {

finalize_hashfile(f, oid.hash, CSUM_HASH_IN_STREAM | CSUM_CLOSE);

} else if (nr_written == nr_remaining) {

finalize_hashfile(f, oid.hash, CSUM_HASH_IN_STREAM | CSUM_FSYNC | CSUM_CLOSE);

} else {

int fd = finalize_hashfile(f, oid.hash, 0);

fixup_pack_header_footer(fd, oid.hash, pack_tmp_name,

nr_written, oid.hash, offset);

close(fd);

if (write_bitmap_index) {

warning(_(no_split_warning));

write_bitmap_index = 0;

}

}

if (!pack_to_stdout) {

struct stat st;

struct strbuf tmpname = STRBUF_INIT;

/*

if (stat(pack_tmp_name, &st) < 0) {

warning_errno(_("failed to stat %s"), pack_tmp_name);

} else if (!last_mtime) {

last_mtime = st.st_mtime;

} else {

struct utimbuf utb;

utb.actime = st.st_atime;

utb.modtime = --last_mtime;

if (utime(pack_tmp_name, &utb) < 0)

warning_errno(_("failed utime() on %s"), pack_tmp_name);

}

strbuf_addf(&tmpname, "%s-", base_name);

if (write_bitmap_index) {

bitmap_writer_set_checksum(oid.hash);

bitmap_writer_build_type_index(

&to_pack, written_list, nr_written);

}

finish_tmp_packfile(&tmpname, pack_tmp_name,

written_list, nr_written,

&pack_idx_opts, oid.hash);

if (write_bitmap_index) {

strbuf_addf(&tmpname, "%s.bitmap", oid_to_hex(&oid));

stop_progress(&progress_state);

bitmap_writer_show_progress(progress);

bitmap_writer_reuse_bitmaps(&to_pack);

bitmap_writer_select_commits(indexed_commits, indexed_commits_nr, -1);

bitmap_writer_build(&to_pack);

bitmap_writer_finish(written_list, nr_written,

tmpname.buf, write_bitmap_options);

write_bitmap_index = 0;

}

strbuf_release(&tmpname);

free(pack_tmp_name);

puts(oid_to_hex(&oid));

}

/* mark written objects as written to previous pack */

for (j = 0; j < nr_written; j++) {

written_list[j]->offset = (off_t)-1;

}

nr_remaining -= nr_written;

} while (nr_remaining && i < to_pack.nr_objects);

free(written_list);

free(write_order);

stop_progress(&progress_state);

if (written != nr_result)

die(_("wrote %"PRIu32" objects while expecting %"PRIu32),

written, nr_result);

}

static int no_try_delta(const char *path)

{

static struct attr_check *check;

if (!check)

check = attr_check_initl("delta", NULL);

git_check_attr(&the_index, path, check);

if (ATTR_FALSE(check->items[0].value))

return 1;

return 0;

}

static int have_duplicate_entry(const struct object_id *oid,

int exclude,

uint32_t *index_pos)

{

struct object_entry *entry;

entry = packlist_find(&to_pack, oid->hash, index_pos);

if (!entry)

return 0;

if (exclude) {

if (!entry->preferred_base)