2 * git gc builtin command
4 * Cleanup unreachable files and optimize the repository.
6 * Copyright (c) 2007 James Bowes
8 * Based on git-gc.sh, which is
10 * Copyright (c) 2006 Shawn O. Pearce
14 #include "repository.h"
18 #include "parse-options.h"
19 #include "run-command.h"
23 #include "commit-graph.h"
25 #include "object-store.h"
27 #include "pack-objects.h"
30 #include "promisor-remote.h"
33 #include "object-store.h"
36 #define FAILED_RUN "failed to run %s"
38 static const char * const builtin_gc_usage
[] = {
39 N_("git gc [<options>]"),
43 static int pack_refs
= 1;
44 static int prune_reflogs
= 1;
45 static int aggressive_depth
= 50;
46 static int aggressive_window
= 250;
47 static int gc_auto_threshold
= 6700;
48 static int gc_auto_pack_limit
= 50;
49 static int detach_auto
= 1;
50 static timestamp_t gc_log_expire_time
;
51 static const char *gc_log_expire
= "1.day.ago";
52 static const char *prune_expire
= "2.weeks.ago";
53 static const char *prune_worktrees_expire
= "3.months.ago";
54 static unsigned long big_pack_threshold
;
55 static unsigned long max_delta_cache_size
= DEFAULT_DELTA_CACHE_SIZE
;
57 static struct strvec pack_refs_cmd
= STRVEC_INIT
;
58 static struct strvec reflog
= STRVEC_INIT
;
59 static struct strvec repack
= STRVEC_INIT
;
60 static struct strvec prune
= STRVEC_INIT
;
61 static struct strvec prune_worktrees
= STRVEC_INIT
;
62 static struct strvec rerere
= STRVEC_INIT
;
64 static struct tempfile
*pidfile
;
65 static struct lock_file log_lock
;
67 static struct string_list pack_garbage
= STRING_LIST_INIT_DUP
;
69 static void clean_pack_garbage(void)
72 for (i
= 0; i
< pack_garbage
.nr
; i
++)
73 unlink_or_warn(pack_garbage
.items
[i
].string
);
74 string_list_clear(&pack_garbage
, 0);
77 static void report_pack_garbage(unsigned seen_bits
, const char *path
)
79 if (seen_bits
== PACKDIR_FILE_IDX
)
80 string_list_append(&pack_garbage
, path
);
83 static void process_log_file(void)
86 if (fstat(get_lock_file_fd(&log_lock
), &st
)) {
88 * Perhaps there was an i/o error or another
89 * unlikely situation. Try to make a note of
90 * this in gc.log along with any existing
93 int saved_errno
= errno
;
94 fprintf(stderr
, _("Failed to fstat %s: %s"),
95 get_lock_file_path(&log_lock
),
96 strerror(saved_errno
));
98 commit_lock_file(&log_lock
);
100 } else if (st
.st_size
) {
101 /* There was some error recorded in the lock file */
102 commit_lock_file(&log_lock
);
104 /* No error, clean up any old gc.log */
105 unlink(git_path("gc.log"));
106 rollback_lock_file(&log_lock
);
110 static void process_log_file_at_exit(void)
116 static void process_log_file_on_signal(int signo
)
123 static int gc_config_is_timestamp_never(const char *var
)
128 if (!git_config_get_value(var
, &value
) && value
) {
129 if (parse_expiry_date(value
, &expire
))
130 die(_("failed to parse '%s' value '%s'"), var
, value
);
136 static void gc_config(void)
140 if (!git_config_get_value("gc.packrefs", &value
)) {
141 if (value
&& !strcmp(value
, "notbare"))
144 pack_refs
= git_config_bool("gc.packrefs", value
);
147 if (gc_config_is_timestamp_never("gc.reflogexpire") &&
148 gc_config_is_timestamp_never("gc.reflogexpireunreachable"))
151 git_config_get_int("gc.aggressivewindow", &aggressive_window
);
152 git_config_get_int("gc.aggressivedepth", &aggressive_depth
);
153 git_config_get_int("gc.auto", &gc_auto_threshold
);
154 git_config_get_int("gc.autopacklimit", &gc_auto_pack_limit
);
155 git_config_get_bool("gc.autodetach", &detach_auto
);
156 git_config_get_expiry("gc.pruneexpire", &prune_expire
);
157 git_config_get_expiry("gc.worktreepruneexpire", &prune_worktrees_expire
);
158 git_config_get_expiry("gc.logexpiry", &gc_log_expire
);
160 git_config_get_ulong("gc.bigpackthreshold", &big_pack_threshold
);
161 git_config_get_ulong("pack.deltacachesize", &max_delta_cache_size
);
163 git_config(git_default_config
, NULL
);
166 static int too_many_loose_objects(void)
169 * Quickly check if a "gc" is needed, by estimating how
170 * many loose objects there are. Because SHA-1 is evenly
171 * distributed, we can check only one and get a reasonable
179 const unsigned hexsz_loose
= the_hash_algo
->hexsz
- 2;
181 dir
= opendir(git_path("objects/17"));
185 auto_threshold
= DIV_ROUND_UP(gc_auto_threshold
, 256);
186 while ((ent
= readdir(dir
)) != NULL
) {
187 if (strspn(ent
->d_name
, "0123456789abcdef") != hexsz_loose
||
188 ent
->d_name
[hexsz_loose
] != '\0')
190 if (++num_loose
> auto_threshold
) {
199 static struct packed_git
*find_base_packs(struct string_list
*packs
,
202 struct packed_git
*p
, *base
= NULL
;
204 for (p
= get_all_packs(the_repository
); p
; p
= p
->next
) {
208 if (p
->pack_size
>= limit
)
209 string_list_append(packs
, p
->pack_name
);
210 } else if (!base
|| base
->pack_size
< p
->pack_size
) {
216 string_list_append(packs
, base
->pack_name
);
221 static int too_many_packs(void)
223 struct packed_git
*p
;
226 if (gc_auto_pack_limit
<= 0)
229 for (cnt
= 0, p
= get_all_packs(the_repository
); p
; p
= p
->next
) {
235 * Perhaps check the size of the pack and count only
236 * very small ones here?
240 return gc_auto_pack_limit
< cnt
;
243 static uint64_t total_ram(void)
245 #if defined(HAVE_SYSINFO)
250 #elif defined(HAVE_BSD_SYSCTL) && (defined(HW_MEMSIZE) || defined(HW_PHYSMEM))
251 int64_t physical_memory
;
256 # if defined(HW_MEMSIZE)
261 length
= sizeof(int64_t);
262 if (!sysctl(mib
, 2, &physical_memory
, &length
, NULL
, 0))
263 return physical_memory
;
264 #elif defined(GIT_WINDOWS_NATIVE)
265 MEMORYSTATUSEX memInfo
;
267 memInfo
.dwLength
= sizeof(MEMORYSTATUSEX
);
268 if (GlobalMemoryStatusEx(&memInfo
))
269 return memInfo
.ullTotalPhys
;
274 static uint64_t estimate_repack_memory(struct packed_git
*pack
)
276 unsigned long nr_objects
= approximate_object_count();
277 size_t os_cache
, heap
;
279 if (!pack
|| !nr_objects
)
283 * First we have to scan through at least one pack.
284 * Assume enough room in OS file cache to keep the entire pack
285 * or we may accidentally evict data of other processes from
288 os_cache
= pack
->pack_size
+ pack
->index_size
;
289 /* then pack-objects needs lots more for book keeping */
290 heap
= sizeof(struct object_entry
) * nr_objects
;
292 * internal rev-list --all --objects takes up some memory too,
293 * let's say half of it is for blobs
295 heap
+= sizeof(struct blob
) * nr_objects
/ 2;
297 * and the other half is for trees (commits and tags are
298 * usually insignificant)
300 heap
+= sizeof(struct tree
) * nr_objects
/ 2;
301 /* and then obj_hash[], underestimated in fact */
302 heap
+= sizeof(struct object
*) * nr_objects
;
303 /* revindex is used also */
304 heap
+= (sizeof(off_t
) + sizeof(uint32_t)) * nr_objects
;
306 * read_sha1_file() (either at delta calculation phase, or
307 * writing phase) also fills up the delta base cache
309 heap
+= delta_base_cache_limit
;
310 /* and of course pack-objects has its own delta cache */
311 heap
+= max_delta_cache_size
;
313 return os_cache
+ heap
;
316 static int keep_one_pack(struct string_list_item
*item
, void *data
)
318 strvec_pushf(&repack
, "--keep-pack=%s", basename(item
->string
));
322 static void add_repack_all_option(struct string_list
*keep_pack
)
324 if (prune_expire
&& !strcmp(prune_expire
, "now"))
325 strvec_push(&repack
, "-a");
327 strvec_push(&repack
, "-A");
329 strvec_pushf(&repack
, "--unpack-unreachable=%s", prune_expire
);
333 for_each_string_list(keep_pack
, keep_one_pack
, NULL
);
336 static void add_repack_incremental_option(void)
338 strvec_push(&repack
, "--no-write-bitmap-index");
341 static int need_to_gc(void)
344 * Setting gc.auto to 0 or negative can disable the
347 if (gc_auto_threshold
<= 0)
351 * If there are too many loose objects, but not too many
352 * packs, we run "repack -d -l". If there are too many packs,
353 * we run "repack -A -d -l". Otherwise we tell the caller
356 if (too_many_packs()) {
357 struct string_list keep_pack
= STRING_LIST_INIT_NODUP
;
359 if (big_pack_threshold
) {
360 find_base_packs(&keep_pack
, big_pack_threshold
);
361 if (keep_pack
.nr
>= gc_auto_pack_limit
) {
362 big_pack_threshold
= 0;
363 string_list_clear(&keep_pack
, 0);
364 find_base_packs(&keep_pack
, 0);
367 struct packed_git
*p
= find_base_packs(&keep_pack
, 0);
368 uint64_t mem_have
, mem_want
;
370 mem_have
= total_ram();
371 mem_want
= estimate_repack_memory(p
);
374 * Only allow 1/2 of memory for pack-objects, leave
375 * the rest for the OS and other processes in the
378 if (!mem_have
|| mem_want
< mem_have
/ 2)
379 string_list_clear(&keep_pack
, 0);
382 add_repack_all_option(&keep_pack
);
383 string_list_clear(&keep_pack
, 0);
384 } else if (too_many_loose_objects())
385 add_repack_incremental_option();
389 if (run_hook_le(NULL
, "pre-auto-gc", NULL
))
394 /* return NULL on success, else hostname running the gc */
395 static const char *lock_repo_for_gc(int force
, pid_t
* ret_pid
)
397 struct lock_file lock
= LOCK_INIT
;
398 char my_host
[HOST_NAME_MAX
+ 1];
399 struct strbuf sb
= STRBUF_INIT
;
406 if (is_tempfile_active(pidfile
))
410 if (xgethostname(my_host
, sizeof(my_host
)))
411 xsnprintf(my_host
, sizeof(my_host
), "unknown");
413 pidfile_path
= git_pathdup("gc.pid");
414 fd
= hold_lock_file_for_update(&lock
, pidfile_path
,
417 static char locking_host
[HOST_NAME_MAX
+ 1];
418 static char *scan_fmt
;
422 scan_fmt
= xstrfmt("%s %%%ds", "%"SCNuMAX
, HOST_NAME_MAX
);
423 fp
= fopen(pidfile_path
, "r");
424 memset(locking_host
, 0, sizeof(locking_host
));
427 !fstat(fileno(fp
), &st
) &&
429 * 12 hour limit is very generous as gc should
430 * never take that long. On the other hand we
431 * don't really need a strict limit here,
432 * running gc --auto one day late is not a big
433 * problem. --force can be used in manual gc
434 * after the user verifies that no gc is
437 time(NULL
) - st
.st_mtime
<= 12 * 3600 &&
438 fscanf(fp
, scan_fmt
, &pid
, locking_host
) == 2 &&
439 /* be gentle to concurrent "gc" on remote hosts */
440 (strcmp(locking_host
, my_host
) || !kill(pid
, 0) || errno
== EPERM
);
445 rollback_lock_file(&lock
);
452 strbuf_addf(&sb
, "%"PRIuMAX
" %s",
453 (uintmax_t) getpid(), my_host
);
454 write_in_full(fd
, sb
.buf
, sb
.len
);
456 commit_lock_file(&lock
);
457 pidfile
= register_tempfile(pidfile_path
);
463 * Returns 0 if there was no previous error and gc can proceed, 1 if
464 * gc should not proceed due to an error in the last run. Prints a
465 * message and returns -1 if an error occurred while reading gc.log
467 static int report_last_gc_error(void)
469 struct strbuf sb
= STRBUF_INIT
;
473 char *gc_log_path
= git_pathdup("gc.log");
475 if (stat(gc_log_path
, &st
)) {
479 ret
= error_errno(_("cannot stat '%s'"), gc_log_path
);
483 if (st
.st_mtime
< gc_log_expire_time
)
486 len
= strbuf_read_file(&sb
, gc_log_path
, 0);
488 ret
= error_errno(_("cannot read '%s'"), gc_log_path
);
491 * A previous gc failed. Report the error, and don't
492 * bother with an automatic gc run since it is likely
493 * to fail in the same way.
495 warning(_("The last gc run reported the following. "
496 "Please correct the root cause\n"
498 "Automatic cleanup will not be performed "
499 "until the file is removed.\n\n"
501 gc_log_path
, sb
.buf
);
510 static void gc_before_repack(void)
513 * We may be called twice, as both the pre- and
514 * post-daemonized phases will call us, but running these
515 * commands more than once is pointless and wasteful.
521 if (pack_refs
&& run_command_v_opt(pack_refs_cmd
.v
, RUN_GIT_CMD
))
522 die(FAILED_RUN
, pack_refs_cmd
.v
[0]);
524 if (prune_reflogs
&& run_command_v_opt(reflog
.v
, RUN_GIT_CMD
))
525 die(FAILED_RUN
, reflog
.v
[0]);
528 int cmd_gc(int argc
, const char **argv
, const char *prefix
)
537 int keep_largest_pack
= -1;
540 struct option builtin_gc_options
[] = {
541 OPT__QUIET(&quiet
, N_("suppress progress reporting")),
542 { OPTION_STRING
, 0, "prune", &prune_expire
, N_("date"),
543 N_("prune unreferenced objects"),
544 PARSE_OPT_OPTARG
, NULL
, (intptr_t)prune_expire
},
545 OPT_BOOL(0, "aggressive", &aggressive
, N_("be more thorough (increased runtime)")),
546 OPT_BOOL_F(0, "auto", &auto_gc
, N_("enable auto-gc mode"),
547 PARSE_OPT_NOCOMPLETE
),
548 OPT_BOOL_F(0, "force", &force
,
549 N_("force running gc even if there may be another gc running"),
550 PARSE_OPT_NOCOMPLETE
),
551 OPT_BOOL(0, "keep-largest-pack", &keep_largest_pack
,
552 N_("repack all other packs except the largest pack")),
556 if (argc
== 2 && !strcmp(argv
[1], "-h"))
557 usage_with_options(builtin_gc_usage
, builtin_gc_options
);
559 strvec_pushl(&pack_refs_cmd
, "pack-refs", "--all", "--prune", NULL
);
560 strvec_pushl(&reflog
, "reflog", "expire", "--all", NULL
);
561 strvec_pushl(&repack
, "repack", "-d", "-l", NULL
);
562 strvec_pushl(&prune
, "prune", "--expire", NULL
);
563 strvec_pushl(&prune_worktrees
, "worktree", "prune", "--expire", NULL
);
564 strvec_pushl(&rerere
, "rerere", "gc", NULL
);
566 /* default expiry time, overwritten in gc_config */
568 if (parse_expiry_date(gc_log_expire
, &gc_log_expire_time
))
569 die(_("failed to parse gc.logexpiry value %s"), gc_log_expire
);
572 pack_refs
= !is_bare_repository();
574 argc
= parse_options(argc
, argv
, prefix
, builtin_gc_options
,
575 builtin_gc_usage
, 0);
577 usage_with_options(builtin_gc_usage
, builtin_gc_options
);
579 if (prune_expire
&& parse_expiry_date(prune_expire
, &dummy
))
580 die(_("failed to parse prune expiry value %s"), prune_expire
);
583 strvec_push(&repack
, "-f");
584 if (aggressive_depth
> 0)
585 strvec_pushf(&repack
, "--depth=%d", aggressive_depth
);
586 if (aggressive_window
> 0)
587 strvec_pushf(&repack
, "--window=%d", aggressive_window
);
590 strvec_push(&repack
, "-q");
594 * Auto-gc should be least intrusive as possible.
600 fprintf(stderr
, _("Auto packing the repository in background for optimum performance.\n"));
602 fprintf(stderr
, _("Auto packing the repository for optimum performance.\n"));
603 fprintf(stderr
, _("See \"git help gc\" for manual housekeeping.\n"));
606 int ret
= report_last_gc_error();
608 /* an I/O error occurred, already reported */
611 /* Last gc --auto failed. Skip this one. */
614 if (lock_repo_for_gc(force
, &pid
))
616 gc_before_repack(); /* dies on failure */
617 delete_tempfile(&pidfile
);
620 * failure to daemonize is ok, we'll continue
623 daemonized
= !daemonize();
626 struct string_list keep_pack
= STRING_LIST_INIT_NODUP
;
628 if (keep_largest_pack
!= -1) {
629 if (keep_largest_pack
)
630 find_base_packs(&keep_pack
, 0);
631 } else if (big_pack_threshold
) {
632 find_base_packs(&keep_pack
, big_pack_threshold
);
635 add_repack_all_option(&keep_pack
);
636 string_list_clear(&keep_pack
, 0);
639 name
= lock_repo_for_gc(force
, &pid
);
642 return 0; /* be quiet on --auto */
643 die(_("gc is already running on machine '%s' pid %"PRIuMAX
" (use --force if not)"),
644 name
, (uintmax_t)pid
);
648 hold_lock_file_for_update(&log_lock
,
651 dup2(get_lock_file_fd(&log_lock
), 2);
652 sigchain_push_common(process_log_file_on_signal
);
653 atexit(process_log_file_at_exit
);
658 if (!repository_format_precious_objects
) {
659 close_object_store(the_repository
->objects
);
660 if (run_command_v_opt(repack
.v
, RUN_GIT_CMD
))
661 die(FAILED_RUN
, repack
.v
[0]);
664 strvec_push(&prune
, prune_expire
);
666 strvec_push(&prune
, "--no-progress");
667 if (has_promisor_remote())
669 "--exclude-promisor-objects");
670 if (run_command_v_opt(prune
.v
, RUN_GIT_CMD
))
671 die(FAILED_RUN
, prune
.v
[0]);
675 if (prune_worktrees_expire
) {
676 strvec_push(&prune_worktrees
, prune_worktrees_expire
);
677 if (run_command_v_opt(prune_worktrees
.v
, RUN_GIT_CMD
))
678 die(FAILED_RUN
, prune_worktrees
.v
[0]);
681 if (run_command_v_opt(rerere
.v
, RUN_GIT_CMD
))
682 die(FAILED_RUN
, rerere
.v
[0]);
684 report_garbage
= report_pack_garbage
;
685 reprepare_packed_git(the_repository
);
686 if (pack_garbage
.nr
> 0) {
687 close_object_store(the_repository
->objects
);
688 clean_pack_garbage();
691 prepare_repo_settings(the_repository
);
692 if (the_repository
->settings
.gc_write_commit_graph
== 1)
693 write_commit_graph_reachable(the_repository
->objects
->odb
,
694 !quiet
&& !daemonized
? COMMIT_GRAPH_WRITE_PROGRESS
: 0,
697 if (auto_gc
&& too_many_loose_objects())
698 warning(_("There are too many unreachable loose objects; "
699 "run 'git prune' to remove them."));
702 unlink(git_path("gc.log"));
707 static const char *const builtin_maintenance_run_usage
[] = {
708 N_("git maintenance run [--auto] [--[no-]quiet] [--task=<task>] [--schedule]"),
712 enum schedule_priority
{
719 static enum schedule_priority
parse_schedule(const char *value
)
722 return SCHEDULE_NONE
;
723 if (!strcasecmp(value
, "hourly"))
724 return SCHEDULE_HOURLY
;
725 if (!strcasecmp(value
, "daily"))
726 return SCHEDULE_DAILY
;
727 if (!strcasecmp(value
, "weekly"))
728 return SCHEDULE_WEEKLY
;
729 return SCHEDULE_NONE
;
732 static int maintenance_opt_schedule(const struct option
*opt
, const char *arg
,
735 enum schedule_priority
*priority
= opt
->value
;
738 die(_("--no-schedule is not allowed"));
740 *priority
= parse_schedule(arg
);
743 die(_("unrecognized --schedule argument '%s'"), arg
);
748 struct maintenance_run_opts
{
751 enum schedule_priority schedule
;
754 /* Remember to update object flag allocation in object.h */
757 struct cg_auto_data
{
758 int num_not_in_graph
;
762 static int dfs_on_ref(const char *refname
,
763 const struct object_id
*oid
, int flags
,
766 struct cg_auto_data
*data
= (struct cg_auto_data
*)cb_data
;
768 struct object_id peeled
;
769 struct commit_list
*stack
= NULL
;
770 struct commit
*commit
;
772 if (!peel_iterated_oid(oid
, &peeled
))
774 if (oid_object_info(the_repository
, oid
, NULL
) != OBJ_COMMIT
)
777 commit
= lookup_commit(the_repository
, oid
);
780 if (parse_commit(commit
) ||
781 commit_graph_position(commit
) != COMMIT_NOT_FROM_GRAPH
)
784 data
->num_not_in_graph
++;
786 if (data
->num_not_in_graph
>= data
->limit
)
789 commit_list_append(commit
, &stack
);
791 while (!result
&& stack
) {
792 struct commit_list
*parent
;
794 commit
= pop_commit(&stack
);
796 for (parent
= commit
->parents
; parent
; parent
= parent
->next
) {
797 if (parse_commit(parent
->item
) ||
798 commit_graph_position(parent
->item
) != COMMIT_NOT_FROM_GRAPH
||
799 parent
->item
->object
.flags
& SEEN
)
802 parent
->item
->object
.flags
|= SEEN
;
803 data
->num_not_in_graph
++;
805 if (data
->num_not_in_graph
>= data
->limit
) {
810 commit_list_append(parent
->item
, &stack
);
814 free_commit_list(stack
);
818 static int should_write_commit_graph(void)
821 struct cg_auto_data data
;
823 data
.num_not_in_graph
= 0;
825 git_config_get_int("maintenance.commit-graph.auto",
833 result
= for_each_ref(dfs_on_ref
, &data
);
835 repo_clear_commit_marks(the_repository
, SEEN
);
840 static int run_write_commit_graph(struct maintenance_run_opts
*opts
)
842 struct child_process child
= CHILD_PROCESS_INIT
;
845 strvec_pushl(&child
.args
, "commit-graph", "write",
846 "--split", "--reachable", NULL
);
849 strvec_push(&child
.args
, "--no-progress");
851 return !!run_command(&child
);
854 static int maintenance_task_commit_graph(struct maintenance_run_opts
*opts
)
856 prepare_repo_settings(the_repository
);
857 if (!the_repository
->settings
.core_commit_graph
)
860 close_object_store(the_repository
->objects
);
861 if (run_write_commit_graph(opts
)) {
862 error(_("failed to write commit-graph"));
869 static int fetch_remote(const char *remote
, struct maintenance_run_opts
*opts
)
871 struct child_process child
= CHILD_PROCESS_INIT
;
874 strvec_pushl(&child
.args
, "fetch", remote
, "--prune", "--no-tags",
875 "--no-write-fetch-head", "--recurse-submodules=no",
879 strvec_push(&child
.args
, "--quiet");
881 strvec_pushf(&child
.args
, "+refs/heads/*:refs/prefetch/%s/*", remote
);
883 return !!run_command(&child
);
886 static int append_remote(struct remote
*remote
, void *cbdata
)
888 struct string_list
*remotes
= (struct string_list
*)cbdata
;
890 string_list_append(remotes
, remote
->name
);
894 static int maintenance_task_prefetch(struct maintenance_run_opts
*opts
)
897 struct string_list_item
*item
;
898 struct string_list remotes
= STRING_LIST_INIT_DUP
;
900 git_config_set_multivar_gently("log.excludedecoration",
903 CONFIG_FLAGS_FIXED_VALUE
|
904 CONFIG_FLAGS_MULTI_REPLACE
);
906 if (for_each_remote(append_remote
, &remotes
)) {
907 error(_("failed to fill remotes"));
912 for_each_string_list_item(item
, &remotes
)
913 result
|= fetch_remote(item
->string
, opts
);
916 string_list_clear(&remotes
, 0);
920 static int maintenance_task_gc(struct maintenance_run_opts
*opts
)
922 struct child_process child
= CHILD_PROCESS_INIT
;
925 strvec_push(&child
.args
, "gc");
928 strvec_push(&child
.args
, "--auto");
930 strvec_push(&child
.args
, "--quiet");
932 strvec_push(&child
.args
, "--no-quiet");
934 close_object_store(the_repository
->objects
);
935 return run_command(&child
);
938 static int prune_packed(struct maintenance_run_opts
*opts
)
940 struct child_process child
= CHILD_PROCESS_INIT
;
943 strvec_push(&child
.args
, "prune-packed");
946 strvec_push(&child
.args
, "--quiet");
948 return !!run_command(&child
);
951 struct write_loose_object_data
{
957 static int loose_object_auto_limit
= 100;
959 static int loose_object_count(const struct object_id
*oid
,
963 int *count
= (int*)data
;
964 if (++(*count
) >= loose_object_auto_limit
)
969 static int loose_object_auto_condition(void)
973 git_config_get_int("maintenance.loose-objects.auto",
974 &loose_object_auto_limit
);
976 if (!loose_object_auto_limit
)
978 if (loose_object_auto_limit
< 0)
981 return for_each_loose_file_in_objdir(the_repository
->objects
->odb
->path
,
986 static int bail_on_loose(const struct object_id
*oid
,
993 static int write_loose_object_to_stdin(const struct object_id
*oid
,
997 struct write_loose_object_data
*d
= (struct write_loose_object_data
*)data
;
999 fprintf(d
->in
, "%s\n", oid_to_hex(oid
));
1001 return ++(d
->count
) > d
->batch_size
;
1004 static int pack_loose(struct maintenance_run_opts
*opts
)
1006 struct repository
*r
= the_repository
;
1008 struct write_loose_object_data data
;
1009 struct child_process pack_proc
= CHILD_PROCESS_INIT
;
1012 * Do not start pack-objects process
1013 * if there are no loose objects.
1015 if (!for_each_loose_file_in_objdir(r
->objects
->odb
->path
,
1020 pack_proc
.git_cmd
= 1;
1022 strvec_push(&pack_proc
.args
, "pack-objects");
1024 strvec_push(&pack_proc
.args
, "--quiet");
1025 strvec_pushf(&pack_proc
.args
, "%s/pack/loose", r
->objects
->odb
->path
);
1029 if (start_command(&pack_proc
)) {
1030 error(_("failed to start 'git pack-objects' process"));
1034 data
.in
= xfdopen(pack_proc
.in
, "w");
1036 data
.batch_size
= 50000;
1038 for_each_loose_file_in_objdir(r
->objects
->odb
->path
,
1039 write_loose_object_to_stdin
,
1046 if (finish_command(&pack_proc
)) {
1047 error(_("failed to finish 'git pack-objects' process"));
1054 static int maintenance_task_loose_objects(struct maintenance_run_opts
*opts
)
1056 return prune_packed(opts
) || pack_loose(opts
);
1059 static int incremental_repack_auto_condition(void)
1061 struct packed_git
*p
;
1063 int incremental_repack_auto_limit
= 10;
1066 if (git_config_get_bool("core.multiPackIndex", &enabled
) ||
1070 git_config_get_int("maintenance.incremental-repack.auto",
1071 &incremental_repack_auto_limit
);
1073 if (!incremental_repack_auto_limit
)
1075 if (incremental_repack_auto_limit
< 0)
1078 for (p
= get_packed_git(the_repository
);
1079 count
< incremental_repack_auto_limit
&& p
;
1081 if (!p
->multi_pack_index
)
1085 return count
>= incremental_repack_auto_limit
;
1088 static int multi_pack_index_write(struct maintenance_run_opts
*opts
)
1090 struct child_process child
= CHILD_PROCESS_INIT
;
1093 strvec_pushl(&child
.args
, "multi-pack-index", "write", NULL
);
1096 strvec_push(&child
.args
, "--no-progress");
1098 if (run_command(&child
))
1099 return error(_("failed to write multi-pack-index"));
1104 static int multi_pack_index_expire(struct maintenance_run_opts
*opts
)
1106 struct child_process child
= CHILD_PROCESS_INIT
;
1109 strvec_pushl(&child
.args
, "multi-pack-index", "expire", NULL
);
1112 strvec_push(&child
.args
, "--no-progress");
1114 close_object_store(the_repository
->objects
);
1116 if (run_command(&child
))
1117 return error(_("'git multi-pack-index expire' failed"));
1122 #define TWO_GIGABYTES (INT32_MAX)
1124 static off_t
get_auto_pack_size(void)
1127 * The "auto" value is special: we optimize for
1128 * one large pack-file (i.e. from a clone) and
1129 * expect the rest to be small and they can be
1132 * The strategy we select here is to select a
1133 * size that is one more than the second largest
1134 * pack-file. This ensures that we will repack
1135 * at least two packs if there are three or more
1139 off_t second_largest_size
= 0;
1141 struct packed_git
*p
;
1142 struct repository
*r
= the_repository
;
1144 reprepare_packed_git(r
);
1145 for (p
= get_all_packs(r
); p
; p
= p
->next
) {
1146 if (p
->pack_size
> max_size
) {
1147 second_largest_size
= max_size
;
1148 max_size
= p
->pack_size
;
1149 } else if (p
->pack_size
> second_largest_size
)
1150 second_largest_size
= p
->pack_size
;
1153 result_size
= second_largest_size
+ 1;
1155 /* But limit ourselves to a batch size of 2g */
1156 if (result_size
> TWO_GIGABYTES
)
1157 result_size
= TWO_GIGABYTES
;
1162 static int multi_pack_index_repack(struct maintenance_run_opts
*opts
)
1164 struct child_process child
= CHILD_PROCESS_INIT
;
1167 strvec_pushl(&child
.args
, "multi-pack-index", "repack", NULL
);
1170 strvec_push(&child
.args
, "--no-progress");
1172 strvec_pushf(&child
.args
, "--batch-size=%"PRIuMAX
,
1173 (uintmax_t)get_auto_pack_size());
1175 close_object_store(the_repository
->objects
);
1177 if (run_command(&child
))
1178 return error(_("'git multi-pack-index repack' failed"));
1183 static int maintenance_task_incremental_repack(struct maintenance_run_opts
*opts
)
1185 prepare_repo_settings(the_repository
);
1186 if (!the_repository
->settings
.core_multi_pack_index
) {
1187 warning(_("skipping incremental-repack task because core.multiPackIndex is disabled"));
1191 if (multi_pack_index_write(opts
))
1193 if (multi_pack_index_expire(opts
))
1195 if (multi_pack_index_repack(opts
))
1200 typedef int maintenance_task_fn(struct maintenance_run_opts
*opts
);
1203 * An auto condition function returns 1 if the task should run
1204 * and 0 if the task should NOT run. See needs_to_gc() for an
1207 typedef int maintenance_auto_fn(void);
1209 struct maintenance_task
{
1211 maintenance_task_fn
*fn
;
1212 maintenance_auto_fn
*auto_condition
;
1215 enum schedule_priority schedule
;
1217 /* -1 if not selected. */
1221 enum maintenance_task_label
{
1224 TASK_INCREMENTAL_REPACK
,
1228 /* Leave as final value */
1232 static struct maintenance_task tasks
[] = {
1235 maintenance_task_prefetch
,
1237 [TASK_LOOSE_OBJECTS
] = {
1239 maintenance_task_loose_objects
,
1240 loose_object_auto_condition
,
1242 [TASK_INCREMENTAL_REPACK
] = {
1243 "incremental-repack",
1244 maintenance_task_incremental_repack
,
1245 incremental_repack_auto_condition
,
1249 maintenance_task_gc
,
1253 [TASK_COMMIT_GRAPH
] = {
1255 maintenance_task_commit_graph
,
1256 should_write_commit_graph
,
1260 static int compare_tasks_by_selection(const void *a_
, const void *b_
)
1262 const struct maintenance_task
*a
= a_
;
1263 const struct maintenance_task
*b
= b_
;
1265 return b
->selected_order
- a
->selected_order
;
1268 static int maintenance_run_tasks(struct maintenance_run_opts
*opts
)
1270 int i
, found_selected
= 0;
1272 struct lock_file lk
;
1273 struct repository
*r
= the_repository
;
1274 char *lock_path
= xstrfmt("%s/maintenance", r
->objects
->odb
->path
);
1276 if (hold_lock_file_for_update(&lk
, lock_path
, LOCK_NO_DEREF
) < 0) {
1278 * Another maintenance command is running.
1280 * If --auto was provided, then it is likely due to a
1281 * recursive process stack. Do not report an error in
1284 if (!opts
->auto_flag
&& !opts
->quiet
)
1285 warning(_("lock file '%s' exists, skipping maintenance"),
1292 for (i
= 0; !found_selected
&& i
< TASK__COUNT
; i
++)
1293 found_selected
= tasks
[i
].selected_order
>= 0;
1296 QSORT(tasks
, TASK__COUNT
, compare_tasks_by_selection
);
1298 for (i
= 0; i
< TASK__COUNT
; i
++) {
1299 if (found_selected
&& tasks
[i
].selected_order
< 0)
1302 if (!found_selected
&& !tasks
[i
].enabled
)
1305 if (opts
->auto_flag
&&
1306 (!tasks
[i
].auto_condition
||
1307 !tasks
[i
].auto_condition()))
1310 if (opts
->schedule
&& tasks
[i
].schedule
< opts
->schedule
)
1313 trace2_region_enter("maintenance", tasks
[i
].name
, r
);
1314 if (tasks
[i
].fn(opts
)) {
1315 error(_("task '%s' failed"), tasks
[i
].name
);
1318 trace2_region_leave("maintenance", tasks
[i
].name
, r
);
1321 rollback_lock_file(&lk
);
1325 static void initialize_maintenance_strategy(void)
1329 if (git_config_get_string("maintenance.strategy", &config_str
))
1332 if (!strcasecmp(config_str
, "incremental")) {
1333 tasks
[TASK_GC
].schedule
= SCHEDULE_NONE
;
1334 tasks
[TASK_COMMIT_GRAPH
].enabled
= 1;
1335 tasks
[TASK_COMMIT_GRAPH
].schedule
= SCHEDULE_HOURLY
;
1336 tasks
[TASK_PREFETCH
].enabled
= 1;
1337 tasks
[TASK_PREFETCH
].schedule
= SCHEDULE_HOURLY
;
1338 tasks
[TASK_INCREMENTAL_REPACK
].enabled
= 1;
1339 tasks
[TASK_INCREMENTAL_REPACK
].schedule
= SCHEDULE_DAILY
;
1340 tasks
[TASK_LOOSE_OBJECTS
].enabled
= 1;
1341 tasks
[TASK_LOOSE_OBJECTS
].schedule
= SCHEDULE_DAILY
;
1345 static void initialize_task_config(int schedule
)
1348 struct strbuf config_name
= STRBUF_INIT
;
1352 initialize_maintenance_strategy();
1354 for (i
= 0; i
< TASK__COUNT
; i
++) {
1358 strbuf_reset(&config_name
);
1359 strbuf_addf(&config_name
, "maintenance.%s.enabled",
1362 if (!git_config_get_bool(config_name
.buf
, &config_value
))
1363 tasks
[i
].enabled
= config_value
;
1365 strbuf_reset(&config_name
);
1366 strbuf_addf(&config_name
, "maintenance.%s.schedule",
1369 if (!git_config_get_string(config_name
.buf
, &config_str
)) {
1370 tasks
[i
].schedule
= parse_schedule(config_str
);
1375 strbuf_release(&config_name
);
1378 static int task_option_parse(const struct option
*opt
,
1379 const char *arg
, int unset
)
1381 int i
, num_selected
= 0;
1382 struct maintenance_task
*task
= NULL
;
1384 BUG_ON_OPT_NEG(unset
);
1386 for (i
= 0; i
< TASK__COUNT
; i
++) {
1387 if (tasks
[i
].selected_order
>= 0)
1389 if (!strcasecmp(tasks
[i
].name
, arg
)) {
1395 error(_("'%s' is not a valid task"), arg
);
1399 if (task
->selected_order
>= 0) {
1400 error(_("task '%s' cannot be selected multiple times"), arg
);
1404 task
->selected_order
= num_selected
+ 1;
1409 static int maintenance_run(int argc
, const char **argv
, const char *prefix
)
1412 struct maintenance_run_opts opts
;
1413 struct option builtin_maintenance_run_options
[] = {
1414 OPT_BOOL(0, "auto", &opts
.auto_flag
,
1415 N_("run tasks based on the state of the repository")),
1416 OPT_CALLBACK(0, "schedule", &opts
.schedule
, N_("frequency"),
1417 N_("run tasks based on frequency"),
1418 maintenance_opt_schedule
),
1419 OPT_BOOL(0, "quiet", &opts
.quiet
,
1420 N_("do not report progress or other information over stderr")),
1421 OPT_CALLBACK_F(0, "task", NULL
, N_("task"),
1422 N_("run a specific task"),
1423 PARSE_OPT_NONEG
, task_option_parse
),
1426 memset(&opts
, 0, sizeof(opts
));
1428 opts
.quiet
= !isatty(2);
1430 for (i
= 0; i
< TASK__COUNT
; i
++)
1431 tasks
[i
].selected_order
= -1;
1433 argc
= parse_options(argc
, argv
, prefix
,
1434 builtin_maintenance_run_options
,
1435 builtin_maintenance_run_usage
,
1436 PARSE_OPT_STOP_AT_NON_OPTION
);
1438 if (opts
.auto_flag
&& opts
.schedule
)
1439 die(_("use at most one of --auto and --schedule=<frequency>"));
1441 initialize_task_config(opts
.schedule
);
1444 usage_with_options(builtin_maintenance_run_usage
,
1445 builtin_maintenance_run_options
);
1446 return maintenance_run_tasks(&opts
);
1449 static int maintenance_register(void)
1452 struct child_process config_set
= CHILD_PROCESS_INIT
;
1453 struct child_process config_get
= CHILD_PROCESS_INIT
;
1455 /* Disable foreground maintenance */
1456 git_config_set("maintenance.auto", "false");
1458 /* Set maintenance strategy, if unset */
1459 if (!git_config_get_string("maintenance.strategy", &config_value
))
1462 git_config_set("maintenance.strategy", "incremental");
1464 config_get
.git_cmd
= 1;
1465 strvec_pushl(&config_get
.args
, "config", "--global", "--get",
1466 "--fixed-value", "maintenance.repo",
1467 the_repository
->worktree
? the_repository
->worktree
1468 : the_repository
->gitdir
,
1470 config_get
.out
= -1;
1472 if (start_command(&config_get
))
1473 return error(_("failed to run 'git config'"));
1475 /* We already have this value in our config! */
1476 if (!finish_command(&config_get
))
1479 config_set
.git_cmd
= 1;
1480 strvec_pushl(&config_set
.args
, "config", "--add", "--global", "maintenance.repo",
1481 the_repository
->worktree
? the_repository
->worktree
1482 : the_repository
->gitdir
,
1485 return run_command(&config_set
);
1488 static int maintenance_unregister(void)
1490 struct child_process config_unset
= CHILD_PROCESS_INIT
;
1492 config_unset
.git_cmd
= 1;
1493 strvec_pushl(&config_unset
.args
, "config", "--global", "--unset",
1494 "--fixed-value", "maintenance.repo",
1495 the_repository
->worktree
? the_repository
->worktree
1496 : the_repository
->gitdir
,
1499 return run_command(&config_unset
);
1502 static const char *get_frequency(enum schedule_priority schedule
)
1505 case SCHEDULE_HOURLY
:
1507 case SCHEDULE_DAILY
:
1509 case SCHEDULE_WEEKLY
:
1512 BUG("invalid schedule %d", schedule
);
1516 static char *launchctl_service_name(const char *frequency
)
1518 struct strbuf label
= STRBUF_INIT
;
1519 strbuf_addf(&label
, "org.git-scm.git.%s", frequency
);
1520 return strbuf_detach(&label
, NULL
);
1523 static char *launchctl_service_filename(const char *name
)
1526 struct strbuf filename
= STRBUF_INIT
;
1527 strbuf_addf(&filename
, "~/Library/LaunchAgents/%s.plist", name
);
1529 expanded
= expand_user_path(filename
.buf
, 1);
1531 die(_("failed to expand path '%s'"), filename
.buf
);
1533 strbuf_release(&filename
);
1537 static char *launchctl_get_uid(void)
1539 return xstrfmt("gui/%d", getuid());
1542 static int launchctl_boot_plist(int enable
, const char *filename
, const char *cmd
)
1545 struct child_process child
= CHILD_PROCESS_INIT
;
1546 char *uid
= launchctl_get_uid();
1548 strvec_split(&child
.args
, cmd
);
1550 strvec_push(&child
.args
, "bootstrap");
1552 strvec_push(&child
.args
, "bootout");
1553 strvec_push(&child
.args
, uid
);
1554 strvec_push(&child
.args
, filename
);
1556 child
.no_stderr
= 1;
1557 child
.no_stdout
= 1;
1559 if (start_command(&child
))
1560 die(_("failed to start launchctl"));
1562 result
= finish_command(&child
);
1568 static int launchctl_remove_plist(enum schedule_priority schedule
, const char *cmd
)
1570 const char *frequency
= get_frequency(schedule
);
1571 char *name
= launchctl_service_name(frequency
);
1572 char *filename
= launchctl_service_filename(name
);
1573 int result
= launchctl_boot_plist(0, filename
, cmd
);
1580 static int launchctl_remove_plists(const char *cmd
)
1582 return launchctl_remove_plist(SCHEDULE_HOURLY
, cmd
) ||
1583 launchctl_remove_plist(SCHEDULE_DAILY
, cmd
) ||
1584 launchctl_remove_plist(SCHEDULE_WEEKLY
, cmd
);
1587 static int launchctl_schedule_plist(const char *exec_path
, enum schedule_priority schedule
, const char *cmd
)
1591 const char *preamble
, *repeat
;
1592 const char *frequency
= get_frequency(schedule
);
1593 char *name
= launchctl_service_name(frequency
);
1594 char *filename
= launchctl_service_filename(name
);
1596 if (safe_create_leading_directories(filename
))
1597 die(_("failed to create directories for '%s'"), filename
);
1598 plist
= xfopen(filename
, "w");
1600 preamble
= "<?xml version=\"1.0\"?>\n"
1601 "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
1602 "<plist version=\"1.0\">"
1604 "<key>Label</key><string>%s</string>\n"
1605 "<key>ProgramArguments</key>\n"
1607 "<string>%s/git</string>\n"
1608 "<string>--exec-path=%s</string>\n"
1609 "<string>for-each-repo</string>\n"
1610 "<string>--config=maintenance.repo</string>\n"
1611 "<string>maintenance</string>\n"
1612 "<string>run</string>\n"
1613 "<string>--schedule=%s</string>\n"
1615 "<key>StartCalendarInterval</key>\n"
1617 fprintf(plist
, preamble
, name
, exec_path
, exec_path
, frequency
);
1620 case SCHEDULE_HOURLY
:
1622 "<key>Hour</key><integer>%d</integer>\n"
1623 "<key>Minute</key><integer>0</integer>\n"
1625 for (i
= 1; i
<= 23; i
++)
1626 fprintf(plist
, repeat
, i
);
1629 case SCHEDULE_DAILY
:
1631 "<key>Day</key><integer>%d</integer>\n"
1632 "<key>Hour</key><integer>0</integer>\n"
1633 "<key>Minute</key><integer>0</integer>\n"
1635 for (i
= 1; i
<= 6; i
++)
1636 fprintf(plist
, repeat
, i
);
1639 case SCHEDULE_WEEKLY
:
1642 "<key>Day</key><integer>0</integer>\n"
1643 "<key>Hour</key><integer>0</integer>\n"
1644 "<key>Minute</key><integer>0</integer>\n"
1652 fprintf(plist
, "</array>\n</dict>\n</plist>\n");
1655 /* bootout might fail if not already running, so ignore */
1656 launchctl_boot_plist(0, filename
, cmd
);
1657 if (launchctl_boot_plist(1, filename
, cmd
))
1658 die(_("failed to bootstrap service %s"), filename
);
1665 static int launchctl_add_plists(const char *cmd
)
1667 const char *exec_path
= git_exec_path();
1669 return launchctl_schedule_plist(exec_path
, SCHEDULE_HOURLY
, cmd
) ||
1670 launchctl_schedule_plist(exec_path
, SCHEDULE_DAILY
, cmd
) ||
1671 launchctl_schedule_plist(exec_path
, SCHEDULE_WEEKLY
, cmd
);
1674 static int launchctl_update_schedule(int run_maintenance
, int fd
, const char *cmd
)
1676 if (run_maintenance
)
1677 return launchctl_add_plists(cmd
);
1679 return launchctl_remove_plists(cmd
);
1682 static char *schtasks_task_name(const char *frequency
)
1684 struct strbuf label
= STRBUF_INIT
;
1685 strbuf_addf(&label
, "Git Maintenance (%s)", frequency
);
1686 return strbuf_detach(&label
, NULL
);
1689 static int schtasks_remove_task(enum schedule_priority schedule
, const char *cmd
)
1692 struct strvec args
= STRVEC_INIT
;
1693 const char *frequency
= get_frequency(schedule
);
1694 char *name
= schtasks_task_name(frequency
);
1696 strvec_split(&args
, cmd
);
1697 strvec_pushl(&args
, "/delete", "/tn", name
, "/f", NULL
);
1699 result
= run_command_v_opt(args
.v
, 0);
1701 strvec_clear(&args
);
1706 static int schtasks_remove_tasks(const char *cmd
)
1708 return schtasks_remove_task(SCHEDULE_HOURLY
, cmd
) ||
1709 schtasks_remove_task(SCHEDULE_DAILY
, cmd
) ||
1710 schtasks_remove_task(SCHEDULE_WEEKLY
, cmd
);
1713 static int schtasks_schedule_task(const char *exec_path
, enum schedule_priority schedule
, const char *cmd
)
1716 struct child_process child
= CHILD_PROCESS_INIT
;
1718 struct tempfile
*tfile
;
1719 const char *frequency
= get_frequency(schedule
);
1720 char *name
= schtasks_task_name(frequency
);
1721 struct strbuf tfilename
= STRBUF_INIT
;
1723 strbuf_addf(&tfilename
, "%s/schedule_%s_XXXXXX",
1724 get_git_common_dir(), frequency
);
1725 tfile
= xmks_tempfile(tfilename
.buf
);
1726 strbuf_release(&tfilename
);
1728 if (!fdopen_tempfile(tfile
, "w"))
1729 die(_("failed to create temp xml file"));
1731 xml
= "<?xml version=\"1.0\" ?>\n"
1732 "<Task version=\"1.4\" xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1734 "<CalendarTrigger>\n";
1735 fputs(xml
, tfile
->fp
);
1738 case SCHEDULE_HOURLY
:
1740 "<StartBoundary>2020-01-01T01:00:00</StartBoundary>\n"
1741 "<Enabled>true</Enabled>\n"
1743 "<DaysInterval>1</DaysInterval>\n"
1744 "</ScheduleByDay>\n"
1746 "<Interval>PT1H</Interval>\n"
1747 "<Duration>PT23H</Duration>\n"
1748 "<StopAtDurationEnd>false</StopAtDurationEnd>\n"
1752 case SCHEDULE_DAILY
:
1754 "<StartBoundary>2020-01-01T00:00:00</StartBoundary>\n"
1755 "<Enabled>true</Enabled>\n"
1756 "<ScheduleByWeek>\n"
1765 "<WeeksInterval>1</WeeksInterval>\n"
1766 "</ScheduleByWeek>\n");
1769 case SCHEDULE_WEEKLY
:
1771 "<StartBoundary>2020-01-01T00:00:00</StartBoundary>\n"
1772 "<Enabled>true</Enabled>\n"
1773 "<ScheduleByWeek>\n"
1777 "<WeeksInterval>1</WeeksInterval>\n"
1778 "</ScheduleByWeek>\n");
1785 xml
= "</CalendarTrigger>\n"
1788 "<Principal id=\"Author\">\n"
1789 "<LogonType>InteractiveToken</LogonType>\n"
1790 "<RunLevel>LeastPrivilege</RunLevel>\n"
1794 "<MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>\n"
1795 "<Enabled>true</Enabled>\n"
1796 "<Hidden>true</Hidden>\n"
1797 "<UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>\n"
1798 "<WakeToRun>false</WakeToRun>\n"
1799 "<ExecutionTimeLimit>PT72H</ExecutionTimeLimit>\n"
1800 "<Priority>7</Priority>\n"
1802 "<Actions Context=\"Author\">\n"
1804 "<Command>\"%s\\git.exe\"</Command>\n"
1805 "<Arguments>--exec-path=\"%s\" for-each-repo --config=maintenance.repo maintenance run --schedule=%s</Arguments>\n"
1809 fprintf(tfile
->fp
, xml
, exec_path
, exec_path
, frequency
);
1810 strvec_split(&child
.args
, cmd
);
1811 strvec_pushl(&child
.args
, "/create", "/tn", name
, "/f", "/xml",
1812 get_tempfile_path(tfile
), NULL
);
1813 close_tempfile_gently(tfile
);
1815 child
.no_stdout
= 1;
1816 child
.no_stderr
= 1;
1818 if (start_command(&child
))
1819 die(_("failed to start schtasks"));
1820 result
= finish_command(&child
);
1822 delete_tempfile(&tfile
);
1827 static int schtasks_schedule_tasks(const char *cmd
)
1829 const char *exec_path
= git_exec_path();
1831 return schtasks_schedule_task(exec_path
, SCHEDULE_HOURLY
, cmd
) ||
1832 schtasks_schedule_task(exec_path
, SCHEDULE_DAILY
, cmd
) ||
1833 schtasks_schedule_task(exec_path
, SCHEDULE_WEEKLY
, cmd
);
1836 static int schtasks_update_schedule(int run_maintenance
, int fd
, const char *cmd
)
1838 if (run_maintenance
)
1839 return schtasks_schedule_tasks(cmd
);
1841 return schtasks_remove_tasks(cmd
);
1844 #define BEGIN_LINE "# BEGIN GIT MAINTENANCE SCHEDULE"
1845 #define END_LINE "# END GIT MAINTENANCE SCHEDULE"
1847 static int crontab_update_schedule(int run_maintenance
, int fd
, const char *cmd
)
1850 int in_old_region
= 0;
1851 struct child_process crontab_list
= CHILD_PROCESS_INIT
;
1852 struct child_process crontab_edit
= CHILD_PROCESS_INIT
;
1853 FILE *cron_list
, *cron_in
;
1854 struct strbuf line
= STRBUF_INIT
;
1856 strvec_split(&crontab_list
.args
, cmd
);
1857 strvec_push(&crontab_list
.args
, "-l");
1858 crontab_list
.in
= -1;
1859 crontab_list
.out
= dup(fd
);
1860 crontab_list
.git_cmd
= 0;
1862 if (start_command(&crontab_list
))
1863 return error(_("failed to run 'crontab -l'; your system might not support 'cron'"));
1865 /* Ignore exit code, as an empty crontab will return error. */
1866 finish_command(&crontab_list
);
1869 * Read from the .lock file, filtering out the old
1870 * schedule while appending the new schedule.
1872 cron_list
= fdopen(fd
, "r");
1875 strvec_split(&crontab_edit
.args
, cmd
);
1876 crontab_edit
.in
= -1;
1877 crontab_edit
.git_cmd
= 0;
1879 if (start_command(&crontab_edit
))
1880 return error(_("failed to run 'crontab'; your system might not support 'cron'"));
1882 cron_in
= fdopen(crontab_edit
.in
, "w");
1884 result
= error(_("failed to open stdin of 'crontab'"));
1888 while (!strbuf_getline_lf(&line
, cron_list
)) {
1889 if (!in_old_region
&& !strcmp(line
.buf
, BEGIN_LINE
))
1891 else if (in_old_region
&& !strcmp(line
.buf
, END_LINE
))
1893 else if (!in_old_region
)
1894 fprintf(cron_in
, "%s\n", line
.buf
);
1897 if (run_maintenance
) {
1898 struct strbuf line_format
= STRBUF_INIT
;
1899 const char *exec_path
= git_exec_path();
1901 fprintf(cron_in
, "%s\n", BEGIN_LINE
);
1903 "# The following schedule was created by Git\n");
1904 fprintf(cron_in
, "# Any edits made in this region might be\n");
1906 "# replaced in the future by a Git command.\n\n");
1908 strbuf_addf(&line_format
,
1909 "%%s %%s * * %%s \"%s/git\" --exec-path=\"%s\" for-each-repo --config=maintenance.repo maintenance run --schedule=%%s\n",
1910 exec_path
, exec_path
);
1911 fprintf(cron_in
, line_format
.buf
, "0", "1-23", "*", "hourly");
1912 fprintf(cron_in
, line_format
.buf
, "0", "0", "1-6", "daily");
1913 fprintf(cron_in
, line_format
.buf
, "0", "0", "0", "weekly");
1914 strbuf_release(&line_format
);
1916 fprintf(cron_in
, "\n%s\n", END_LINE
);
1921 close(crontab_edit
.in
);
1924 if (finish_command(&crontab_edit
))
1925 result
= error(_("'crontab' died"));
1931 #if defined(__APPLE__)
1932 static const char platform_scheduler
[] = "launchctl";
1933 #elif defined(GIT_WINDOWS_NATIVE)
1934 static const char platform_scheduler
[] = "schtasks";
1936 static const char platform_scheduler
[] = "crontab";
1939 static int update_background_schedule(int enable
)
1942 const char *scheduler
= platform_scheduler
;
1943 const char *cmd
= scheduler
;
1945 struct lock_file lk
;
1946 char *lock_path
= xstrfmt("%s/schedule", the_repository
->objects
->odb
->path
);
1948 testing
= xstrdup_or_null(getenv("GIT_TEST_MAINT_SCHEDULER"));
1950 char *sep
= strchr(testing
, ':');
1952 die("GIT_TEST_MAINT_SCHEDULER unparseable: %s", testing
);
1954 scheduler
= testing
;
1958 if (hold_lock_file_for_update(&lk
, lock_path
, LOCK_NO_DEREF
) < 0)
1959 return error(_("another process is scheduling background maintenance"));
1961 if (!strcmp(scheduler
, "launchctl"))
1962 result
= launchctl_update_schedule(enable
, get_lock_file_fd(&lk
), cmd
);
1963 else if (!strcmp(scheduler
, "schtasks"))
1964 result
= schtasks_update_schedule(enable
, get_lock_file_fd(&lk
), cmd
);
1965 else if (!strcmp(scheduler
, "crontab"))
1966 result
= crontab_update_schedule(enable
, get_lock_file_fd(&lk
), cmd
);
1968 die("unknown background scheduler: %s", scheduler
);
1970 rollback_lock_file(&lk
);
1975 static int maintenance_start(void)
1977 if (maintenance_register())
1978 warning(_("failed to add repo to global config"));
1980 return update_background_schedule(1);
1983 static int maintenance_stop(void)
1985 return update_background_schedule(0);
1988 static const char builtin_maintenance_usage
[] = N_("git maintenance <subcommand> [<options>]");
1990 int cmd_maintenance(int argc
, const char **argv
, const char *prefix
)
1993 (argc
== 2 && !strcmp(argv
[1], "-h")))
1994 usage(builtin_maintenance_usage
);
1996 if (!strcmp(argv
[1], "run"))
1997 return maintenance_run(argc
- 1, argv
+ 1, prefix
);
1998 if (!strcmp(argv
[1], "start"))
1999 return maintenance_start();
2000 if (!strcmp(argv
[1], "stop"))
2001 return maintenance_stop();
2002 if (!strcmp(argv
[1], "register"))
2003 return maintenance_register();
2004 if (!strcmp(argv
[1], "unregister"))
2005 return maintenance_unregister();
2007 die(_("invalid subcommand: %s"), argv
[1]);