reset/checkout/read-tree: unify config callback for submodule recursion
[git/git.git] / submodule.c
1 #include "cache.h"
2 #include "submodule-config.h"
3 #include "submodule.h"
4 #include "dir.h"
5 #include "diff.h"
6 #include "commit.h"
7 #include "revision.h"
8 #include "run-command.h"
9 #include "diffcore.h"
10 #include "refs.h"
11 #include "string-list.h"
12 #include "sha1-array.h"
13 #include "argv-array.h"
14 #include "blob.h"
15 #include "thread-utils.h"
16 #include "quote.h"
17 #include "remote.h"
18 #include "worktree.h"
19
20 static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
21 static int config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
22 static int parallel_jobs = 1;
23 static struct string_list changed_submodule_paths = STRING_LIST_INIT_DUP;
24 static int initialized_fetch_ref_tips;
25 static struct oid_array ref_tips_before_fetch;
26 static struct oid_array ref_tips_after_fetch;
27
28 /*
29 * The following flag is set if the .gitmodules file is unmerged. We then
30 * disable recursion for all submodules where .git/config doesn't have a
31 * matching config entry because we can't guess what might be configured in
32 * .gitmodules unless the user resolves the conflict. When a command line
33 * option is given (which always overrides configuration) this flag will be
34 * ignored.
35 */
36 static int gitmodules_is_unmerged;
37
38 /*
39 * This flag is set if the .gitmodules file had unstaged modifications on
40 * startup. This must be checked before allowing modifications to the
41 * .gitmodules file with the intention to stage them later, because when
42 * continuing we would stage the modifications the user didn't stage herself
43 * too. That might change in a future version when we learn to stage the
44 * changes we do ourselves without staging any previous modifications.
45 */
46 static int gitmodules_is_modified;
47
48 int is_staging_gitmodules_ok(void)
49 {
50 return !gitmodules_is_modified;
51 }
52
53 /*
54 * Try to update the "path" entry in the "submodule.<name>" section of the
55 * .gitmodules file. Return 0 only if a .gitmodules file was found, a section
56 * with the correct path=<oldpath> setting was found and we could update it.
57 */
58 int update_path_in_gitmodules(const char *oldpath, const char *newpath)
59 {
60 struct strbuf entry = STRBUF_INIT;
61 const struct submodule *submodule;
62
63 if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
64 return -1;
65
66 if (gitmodules_is_unmerged)
67 die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
68
69 submodule = submodule_from_path(null_sha1, oldpath);
70 if (!submodule || !submodule->name) {
71 warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
72 return -1;
73 }
74 strbuf_addstr(&entry, "submodule.");
75 strbuf_addstr(&entry, submodule->name);
76 strbuf_addstr(&entry, ".path");
77 if (git_config_set_in_file_gently(".gitmodules", entry.buf, newpath) < 0) {
78 /* Maybe the user already did that, don't error out here */
79 warning(_("Could not update .gitmodules entry %s"), entry.buf);
80 strbuf_release(&entry);
81 return -1;
82 }
83 strbuf_release(&entry);
84 return 0;
85 }
86
87 /*
88 * Try to remove the "submodule.<name>" section from .gitmodules where the given
89 * path is configured. Return 0 only if a .gitmodules file was found, a section
90 * with the correct path=<path> setting was found and we could remove it.
91 */
92 int remove_path_from_gitmodules(const char *path)
93 {
94 struct strbuf sect = STRBUF_INIT;
95 const struct submodule *submodule;
96
97 if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
98 return -1;
99
100 if (gitmodules_is_unmerged)
101 die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
102
103 submodule = submodule_from_path(null_sha1, path);
104 if (!submodule || !submodule->name) {
105 warning(_("Could not find section in .gitmodules where path=%s"), path);
106 return -1;
107 }
108 strbuf_addstr(&sect, "submodule.");
109 strbuf_addstr(&sect, submodule->name);
110 if (git_config_rename_section_in_file(".gitmodules", sect.buf, NULL) < 0) {
111 /* Maybe the user already did that, don't error out here */
112 warning(_("Could not remove .gitmodules entry for %s"), path);
113 strbuf_release(&sect);
114 return -1;
115 }
116 strbuf_release(&sect);
117 return 0;
118 }
119
120 void stage_updated_gitmodules(void)
121 {
122 if (add_file_to_cache(".gitmodules", 0))
123 die(_("staging updated .gitmodules failed"));
124 }
125
126 static int add_submodule_odb(const char *path)
127 {
128 struct strbuf objects_directory = STRBUF_INIT;
129 int ret = 0;
130
131 ret = strbuf_git_path_submodule(&objects_directory, path, "objects/");
132 if (ret)
133 goto done;
134 if (!is_directory(objects_directory.buf)) {
135 ret = -1;
136 goto done;
137 }
138 add_to_alternates_memory(objects_directory.buf);
139 done:
140 strbuf_release(&objects_directory);
141 return ret;
142 }
143
144 void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
145 const char *path)
146 {
147 const struct submodule *submodule = submodule_from_path(null_sha1, path);
148 if (submodule) {
149 if (submodule->ignore)
150 handle_ignore_submodules_arg(diffopt, submodule->ignore);
151 else if (gitmodules_is_unmerged)
152 DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
153 }
154 }
155
156 int submodule_config(const char *var, const char *value, void *cb)
157 {
158 if (!strcmp(var, "submodule.fetchjobs")) {
159 parallel_jobs = git_config_int(var, value);
160 if (parallel_jobs < 0)
161 die(_("negative values not allowed for submodule.fetchJobs"));
162 return 0;
163 } else if (starts_with(var, "submodule."))
164 return parse_submodule_config_option(var, value);
165 else if (!strcmp(var, "fetch.recursesubmodules")) {
166 config_fetch_recurse_submodules = parse_fetch_recurse_submodules_arg(var, value);
167 return 0;
168 }
169 return 0;
170 }
171
172 int option_parse_recurse_submodules_worktree_updater(const struct option *opt,
173 const char *arg, int unset)
174 {
175 if (unset) {
176 config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
177 return 0;
178 }
179 if (arg)
180 config_update_recurse_submodules =
181 parse_update_recurse_submodules_arg(opt->long_name,
182 arg);
183 else
184 config_update_recurse_submodules = RECURSE_SUBMODULES_ON;
185
186 return 0;
187 }
188
189 void load_submodule_cache(void)
190 {
191 if (config_update_recurse_submodules == RECURSE_SUBMODULES_OFF)
192 return;
193
194 gitmodules_config();
195 git_config(submodule_config, NULL);
196 }
197
198 void gitmodules_config(void)
199 {
200 const char *work_tree = get_git_work_tree();
201 if (work_tree) {
202 struct strbuf gitmodules_path = STRBUF_INIT;
203 int pos;
204 strbuf_addstr(&gitmodules_path, work_tree);
205 strbuf_addstr(&gitmodules_path, "/.gitmodules");
206 if (read_cache() < 0)
207 die("index file corrupt");
208 pos = cache_name_pos(".gitmodules", 11);
209 if (pos < 0) { /* .gitmodules not found or isn't merged */
210 pos = -1 - pos;
211 if (active_nr > pos) { /* there is a .gitmodules */
212 const struct cache_entry *ce = active_cache[pos];
213 if (ce_namelen(ce) == 11 &&
214 !memcmp(ce->name, ".gitmodules", 11))
215 gitmodules_is_unmerged = 1;
216 }
217 } else if (pos < active_nr) {
218 struct stat st;
219 if (lstat(".gitmodules", &st) == 0 &&
220 ce_match_stat(active_cache[pos], &st, 0) & DATA_CHANGED)
221 gitmodules_is_modified = 1;
222 }
223
224 if (!gitmodules_is_unmerged)
225 git_config_from_file(submodule_config, gitmodules_path.buf, NULL);
226 strbuf_release(&gitmodules_path);
227 }
228 }
229
230 void gitmodules_config_sha1(const unsigned char *commit_sha1)
231 {
232 struct strbuf rev = STRBUF_INIT;
233 unsigned char sha1[20];
234
235 if (gitmodule_sha1_from_commit(commit_sha1, sha1, &rev)) {
236 git_config_from_blob_sha1(submodule_config, rev.buf,
237 sha1, NULL);
238 }
239 strbuf_release(&rev);
240 }
241
242 /*
243 * NEEDSWORK: With the addition of different configuration options to determine
244 * if a submodule is of interests, the validity of this function's name comes
245 * into question. Once the dust has settled and more concrete terminology is
246 * decided upon, come up with a more proper name for this function. One
247 * potential candidate could be 'is_submodule_active()'.
248 *
249 * Determine if a submodule has been initialized at a given 'path'
250 */
251 int is_submodule_initialized(const char *path)
252 {
253 int ret = 0;
254 char *key = NULL;
255 char *value = NULL;
256 const struct string_list *sl;
257 const struct submodule *module = submodule_from_path(null_sha1, path);
258
259 /* early return if there isn't a path->module mapping */
260 if (!module)
261 return 0;
262
263 /* submodule.<name>.active is set */
264 key = xstrfmt("submodule.%s.active", module->name);
265 if (!git_config_get_bool(key, &ret)) {
266 free(key);
267 return ret;
268 }
269 free(key);
270
271 /* submodule.active is set */
272 sl = git_config_get_value_multi("submodule.active");
273 if (sl) {
274 struct pathspec ps;
275 struct argv_array args = ARGV_ARRAY_INIT;
276 const struct string_list_item *item;
277
278 for_each_string_list_item(item, sl) {
279 argv_array_push(&args, item->string);
280 }
281
282 parse_pathspec(&ps, 0, 0, NULL, args.argv);
283 ret = match_pathspec(&ps, path, strlen(path), 0, NULL, 1);
284
285 argv_array_clear(&args);
286 clear_pathspec(&ps);
287 return ret;
288 }
289
290 /* fallback to checking if the URL is set */
291 key = xstrfmt("submodule.%s.url", module->name);
292 ret = !git_config_get_string(key, &value);
293
294 free(value);
295 free(key);
296 return ret;
297 }
298
299 int is_submodule_populated_gently(const char *path, int *return_error_code)
300 {
301 int ret = 0;
302 char *gitdir = xstrfmt("%s/.git", path);
303
304 if (resolve_gitdir_gently(gitdir, return_error_code))
305 ret = 1;
306
307 free(gitdir);
308 return ret;
309 }
310
311 int parse_submodule_update_strategy(const char *value,
312 struct submodule_update_strategy *dst)
313 {
314 free((void*)dst->command);
315 dst->command = NULL;
316 if (!strcmp(value, "none"))
317 dst->type = SM_UPDATE_NONE;
318 else if (!strcmp(value, "checkout"))
319 dst->type = SM_UPDATE_CHECKOUT;
320 else if (!strcmp(value, "rebase"))
321 dst->type = SM_UPDATE_REBASE;
322 else if (!strcmp(value, "merge"))
323 dst->type = SM_UPDATE_MERGE;
324 else if (skip_prefix(value, "!", &value)) {
325 dst->type = SM_UPDATE_COMMAND;
326 dst->command = xstrdup(value);
327 } else
328 return -1;
329 return 0;
330 }
331
332 const char *submodule_strategy_to_string(const struct submodule_update_strategy *s)
333 {
334 struct strbuf sb = STRBUF_INIT;
335 switch (s->type) {
336 case SM_UPDATE_CHECKOUT:
337 return "checkout";
338 case SM_UPDATE_MERGE:
339 return "merge";
340 case SM_UPDATE_REBASE:
341 return "rebase";
342 case SM_UPDATE_NONE:
343 return "none";
344 case SM_UPDATE_UNSPECIFIED:
345 return NULL;
346 case SM_UPDATE_COMMAND:
347 strbuf_addf(&sb, "!%s", s->command);
348 return strbuf_detach(&sb, NULL);
349 }
350 return NULL;
351 }
352
353 void handle_ignore_submodules_arg(struct diff_options *diffopt,
354 const char *arg)
355 {
356 DIFF_OPT_CLR(diffopt, IGNORE_SUBMODULES);
357 DIFF_OPT_CLR(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
358 DIFF_OPT_CLR(diffopt, IGNORE_DIRTY_SUBMODULES);
359
360 if (!strcmp(arg, "all"))
361 DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
362 else if (!strcmp(arg, "untracked"))
363 DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
364 else if (!strcmp(arg, "dirty"))
365 DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES);
366 else if (strcmp(arg, "none"))
367 die("bad --ignore-submodules argument: %s", arg);
368 }
369
370 static int prepare_submodule_summary(struct rev_info *rev, const char *path,
371 struct commit *left, struct commit *right,
372 struct commit_list *merge_bases)
373 {
374 struct commit_list *list;
375
376 init_revisions(rev, NULL);
377 setup_revisions(0, NULL, rev, NULL);
378 rev->left_right = 1;
379 rev->first_parent_only = 1;
380 left->object.flags |= SYMMETRIC_LEFT;
381 add_pending_object(rev, &left->object, path);
382 add_pending_object(rev, &right->object, path);
383 for (list = merge_bases; list; list = list->next) {
384 list->item->object.flags |= UNINTERESTING;
385 add_pending_object(rev, &list->item->object,
386 oid_to_hex(&list->item->object.oid));
387 }
388 return prepare_revision_walk(rev);
389 }
390
391 static void print_submodule_summary(struct rev_info *rev, FILE *f,
392 const char *line_prefix,
393 const char *del, const char *add, const char *reset)
394 {
395 static const char format[] = " %m %s";
396 struct strbuf sb = STRBUF_INIT;
397 struct commit *commit;
398
399 while ((commit = get_revision(rev))) {
400 struct pretty_print_context ctx = {0};
401 ctx.date_mode = rev->date_mode;
402 ctx.output_encoding = get_log_output_encoding();
403 strbuf_setlen(&sb, 0);
404 strbuf_addstr(&sb, line_prefix);
405 if (commit->object.flags & SYMMETRIC_LEFT) {
406 if (del)
407 strbuf_addstr(&sb, del);
408 }
409 else if (add)
410 strbuf_addstr(&sb, add);
411 format_commit_message(commit, format, &sb, &ctx);
412 if (reset)
413 strbuf_addstr(&sb, reset);
414 strbuf_addch(&sb, '\n');
415 fprintf(f, "%s", sb.buf);
416 }
417 strbuf_release(&sb);
418 }
419
420 static void prepare_submodule_repo_env_no_git_dir(struct argv_array *out)
421 {
422 const char * const *var;
423
424 for (var = local_repo_env; *var; var++) {
425 if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
426 argv_array_push(out, *var);
427 }
428 }
429
430 void prepare_submodule_repo_env(struct argv_array *out)
431 {
432 prepare_submodule_repo_env_no_git_dir(out);
433 argv_array_pushf(out, "%s=%s", GIT_DIR_ENVIRONMENT,
434 DEFAULT_GIT_DIR_ENVIRONMENT);
435 }
436
437 /* Helper function to display the submodule header line prior to the full
438 * summary output. If it can locate the submodule objects directory it will
439 * attempt to lookup both the left and right commits and put them into the
440 * left and right pointers.
441 */
442 static void show_submodule_header(FILE *f, const char *path,
443 const char *line_prefix,
444 struct object_id *one, struct object_id *two,
445 unsigned dirty_submodule, const char *meta,
446 const char *reset,
447 struct commit **left, struct commit **right,
448 struct commit_list **merge_bases)
449 {
450 const char *message = NULL;
451 struct strbuf sb = STRBUF_INIT;
452 int fast_forward = 0, fast_backward = 0;
453
454 if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
455 fprintf(f, "%sSubmodule %s contains untracked content\n",
456 line_prefix, path);
457 if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
458 fprintf(f, "%sSubmodule %s contains modified content\n",
459 line_prefix, path);
460
461 if (is_null_oid(one))
462 message = "(new submodule)";
463 else if (is_null_oid(two))
464 message = "(submodule deleted)";
465
466 if (add_submodule_odb(path)) {
467 if (!message)
468 message = "(not initialized)";
469 goto output_header;
470 }
471
472 /*
473 * Attempt to lookup the commit references, and determine if this is
474 * a fast forward or fast backwards update.
475 */
476 *left = lookup_commit_reference(one->hash);
477 *right = lookup_commit_reference(two->hash);
478
479 /*
480 * Warn about missing commits in the submodule project, but only if
481 * they aren't null.
482 */
483 if ((!is_null_oid(one) && !*left) ||
484 (!is_null_oid(two) && !*right))
485 message = "(commits not present)";
486
487 *merge_bases = get_merge_bases(*left, *right);
488 if (*merge_bases) {
489 if ((*merge_bases)->item == *left)
490 fast_forward = 1;
491 else if ((*merge_bases)->item == *right)
492 fast_backward = 1;
493 }
494
495 if (!oidcmp(one, two)) {
496 strbuf_release(&sb);
497 return;
498 }
499
500 output_header:
501 strbuf_addf(&sb, "%s%sSubmodule %s ", line_prefix, meta, path);
502 strbuf_add_unique_abbrev(&sb, one->hash, DEFAULT_ABBREV);
503 strbuf_addstr(&sb, (fast_backward || fast_forward) ? ".." : "...");
504 strbuf_add_unique_abbrev(&sb, two->hash, DEFAULT_ABBREV);
505 if (message)
506 strbuf_addf(&sb, " %s%s\n", message, reset);
507 else
508 strbuf_addf(&sb, "%s:%s\n", fast_backward ? " (rewind)" : "", reset);
509 fwrite(sb.buf, sb.len, 1, f);
510
511 strbuf_release(&sb);
512 }
513
514 void show_submodule_summary(FILE *f, const char *path,
515 const char *line_prefix,
516 struct object_id *one, struct object_id *two,
517 unsigned dirty_submodule, const char *meta,
518 const char *del, const char *add, const char *reset)
519 {
520 struct rev_info rev;
521 struct commit *left = NULL, *right = NULL;
522 struct commit_list *merge_bases = NULL;
523
524 show_submodule_header(f, path, line_prefix, one, two, dirty_submodule,
525 meta, reset, &left, &right, &merge_bases);
526
527 /*
528 * If we don't have both a left and a right pointer, there is no
529 * reason to try and display a summary. The header line should contain
530 * all the information the user needs.
531 */
532 if (!left || !right)
533 goto out;
534
535 /* Treat revision walker failure the same as missing commits */
536 if (prepare_submodule_summary(&rev, path, left, right, merge_bases)) {
537 fprintf(f, "%s(revision walker failed)\n", line_prefix);
538 goto out;
539 }
540
541 print_submodule_summary(&rev, f, line_prefix, del, add, reset);
542
543 out:
544 if (merge_bases)
545 free_commit_list(merge_bases);
546 clear_commit_marks(left, ~0);
547 clear_commit_marks(right, ~0);
548 }
549
550 void show_submodule_inline_diff(FILE *f, const char *path,
551 const char *line_prefix,
552 struct object_id *one, struct object_id *two,
553 unsigned dirty_submodule, const char *meta,
554 const char *del, const char *add, const char *reset,
555 const struct diff_options *o)
556 {
557 const struct object_id *old = &empty_tree_oid, *new = &empty_tree_oid;
558 struct commit *left = NULL, *right = NULL;
559 struct commit_list *merge_bases = NULL;
560 struct strbuf submodule_dir = STRBUF_INIT;
561 struct child_process cp = CHILD_PROCESS_INIT;
562
563 show_submodule_header(f, path, line_prefix, one, two, dirty_submodule,
564 meta, reset, &left, &right, &merge_bases);
565
566 /* We need a valid left and right commit to display a difference */
567 if (!(left || is_null_oid(one)) ||
568 !(right || is_null_oid(two)))
569 goto done;
570
571 if (left)
572 old = one;
573 if (right)
574 new = two;
575
576 fflush(f);
577 cp.git_cmd = 1;
578 cp.dir = path;
579 cp.out = dup(fileno(f));
580 cp.no_stdin = 1;
581
582 /* TODO: other options may need to be passed here. */
583 argv_array_push(&cp.args, "diff");
584 argv_array_pushf(&cp.args, "--line-prefix=%s", line_prefix);
585 if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
586 argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
587 o->b_prefix, path);
588 argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
589 o->a_prefix, path);
590 } else {
591 argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
592 o->a_prefix, path);
593 argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
594 o->b_prefix, path);
595 }
596 argv_array_push(&cp.args, oid_to_hex(old));
597 /*
598 * If the submodule has modified content, we will diff against the
599 * work tree, under the assumption that the user has asked for the
600 * diff format and wishes to actually see all differences even if they
601 * haven't yet been committed to the submodule yet.
602 */
603 if (!(dirty_submodule & DIRTY_SUBMODULE_MODIFIED))
604 argv_array_push(&cp.args, oid_to_hex(new));
605
606 prepare_submodule_repo_env(&cp.env_array);
607 if (run_command(&cp))
608 fprintf(f, "(diff failed)\n");
609
610 done:
611 strbuf_release(&submodule_dir);
612 if (merge_bases)
613 free_commit_list(merge_bases);
614 if (left)
615 clear_commit_marks(left, ~0);
616 if (right)
617 clear_commit_marks(right, ~0);
618 }
619
620 void set_config_fetch_recurse_submodules(int value)
621 {
622 config_fetch_recurse_submodules = value;
623 }
624
625 int should_update_submodules(void)
626 {
627 return config_update_recurse_submodules == RECURSE_SUBMODULES_ON;
628 }
629
630 const struct submodule *submodule_from_ce(const struct cache_entry *ce)
631 {
632 if (!S_ISGITLINK(ce->ce_mode))
633 return NULL;
634
635 if (!should_update_submodules())
636 return NULL;
637
638 return submodule_from_path(null_sha1, ce->name);
639 }
640
641 static struct oid_array *submodule_commits(struct string_list *submodules,
642 const char *path)
643 {
644 struct string_list_item *item;
645
646 item = string_list_insert(submodules, path);
647 if (item->util)
648 return (struct oid_array *) item->util;
649
650 /* NEEDSWORK: should we have oid_array_init()? */
651 item->util = xcalloc(1, sizeof(struct oid_array));
652 return (struct oid_array *) item->util;
653 }
654
655 static void collect_changed_submodules_cb(struct diff_queue_struct *q,
656 struct diff_options *options,
657 void *data)
658 {
659 int i;
660 struct string_list *changed = data;
661
662 for (i = 0; i < q->nr; i++) {
663 struct diff_filepair *p = q->queue[i];
664 struct oid_array *commits;
665 if (!S_ISGITLINK(p->two->mode))
666 continue;
667
668 if (S_ISGITLINK(p->one->mode)) {
669 /*
670 * NEEDSWORK: We should honor the name configured in
671 * the .gitmodules file of the commit we are examining
672 * here to be able to correctly follow submodules
673 * being moved around.
674 */
675 commits = submodule_commits(changed, p->two->path);
676 oid_array_append(commits, &p->two->oid);
677 } else {
678 /* Submodule is new or was moved here */
679 /*
680 * NEEDSWORK: When the .git directories of submodules
681 * live inside the superprojects .git directory some
682 * day we should fetch new submodules directly into
683 * that location too when config or options request
684 * that so they can be checked out from there.
685 */
686 continue;
687 }
688 }
689 }
690
691 /*
692 * Collect the paths of submodules in 'changed' which have changed based on
693 * the revisions as specified in 'argv'. Each entry in 'changed' will also
694 * have a corresponding 'struct oid_array' (in the 'util' field) which lists
695 * what the submodule pointers were updated to during the change.
696 */
697 static void collect_changed_submodules(struct string_list *changed,
698 struct argv_array *argv)
699 {
700 struct rev_info rev;
701 const struct commit *commit;
702
703 init_revisions(&rev, NULL);
704 setup_revisions(argv->argc, argv->argv, &rev, NULL);
705 if (prepare_revision_walk(&rev))
706 die("revision walk setup failed");
707
708 while ((commit = get_revision(&rev))) {
709 struct rev_info diff_rev;
710
711 init_revisions(&diff_rev, NULL);
712 diff_rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
713 diff_rev.diffopt.format_callback = collect_changed_submodules_cb;
714 diff_rev.diffopt.format_callback_data = changed;
715 diff_tree_combined_merge(commit, 1, &diff_rev);
716 }
717
718 reset_revision_walk();
719 }
720
721 static void free_submodules_oids(struct string_list *submodules)
722 {
723 struct string_list_item *item;
724 for_each_string_list_item(item, submodules)
725 oid_array_clear((struct oid_array *) item->util);
726 string_list_clear(submodules, 1);
727 }
728
729 static int has_remote(const char *refname, const struct object_id *oid,
730 int flags, void *cb_data)
731 {
732 return 1;
733 }
734
735 static int append_oid_to_argv(const struct object_id *oid, void *data)
736 {
737 struct argv_array *argv = data;
738 argv_array_push(argv, oid_to_hex(oid));
739 return 0;
740 }
741
742 static int check_has_commit(const struct object_id *oid, void *data)
743 {
744 int *has_commit = data;
745
746 if (!lookup_commit_reference(oid->hash))
747 *has_commit = 0;
748
749 return 0;
750 }
751
752 static int submodule_has_commits(const char *path, struct oid_array *commits)
753 {
754 int has_commit = 1;
755
756 /*
757 * Perform a cheap, but incorrect check for the existance of 'commits'.
758 * This is done by adding the submodule's object store to the in-core
759 * object store, and then querying for each commit's existance. If we
760 * do not have the commit object anywhere, there is no chance we have
761 * it in the object store of the correct submodule and have it
762 * reachable from a ref, so we can fail early without spawning rev-list
763 * which is expensive.
764 */
765 if (add_submodule_odb(path))
766 return 0;
767
768 oid_array_for_each_unique(commits, check_has_commit, &has_commit);
769
770 if (has_commit) {
771 /*
772 * Even if the submodule is checked out and the commit is
773 * present, make sure it exists in the submodule's object store
774 * and that it is reachable from a ref.
775 */
776 struct child_process cp = CHILD_PROCESS_INIT;
777 struct strbuf out = STRBUF_INIT;
778
779 argv_array_pushl(&cp.args, "rev-list", "-n", "1", NULL);
780 oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
781 argv_array_pushl(&cp.args, "--not", "--all", NULL);
782
783 prepare_submodule_repo_env(&cp.env_array);
784 cp.git_cmd = 1;
785 cp.no_stdin = 1;
786 cp.dir = path;
787
788 if (capture_command(&cp, &out, GIT_MAX_HEXSZ + 1) || out.len)
789 has_commit = 0;
790
791 strbuf_release(&out);
792 }
793
794 return has_commit;
795 }
796
797 static int submodule_needs_pushing(const char *path, struct oid_array *commits)
798 {
799 if (!submodule_has_commits(path, commits))
800 /*
801 * NOTE: We do consider it safe to return "no" here. The
802 * correct answer would be "We do not know" instead of
803 * "No push needed", but it is quite hard to change
804 * the submodule pointer without having the submodule
805 * around. If a user did however change the submodules
806 * without having the submodule around, this indicates
807 * an expert who knows what they are doing or a
808 * maintainer integrating work from other people. In
809 * both cases it should be safe to skip this check.
810 */
811 return 0;
812
813 if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
814 struct child_process cp = CHILD_PROCESS_INIT;
815 struct strbuf buf = STRBUF_INIT;
816 int needs_pushing = 0;
817
818 argv_array_push(&cp.args, "rev-list");
819 oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
820 argv_array_pushl(&cp.args, "--not", "--remotes", "-n", "1" , NULL);
821
822 prepare_submodule_repo_env(&cp.env_array);
823 cp.git_cmd = 1;
824 cp.no_stdin = 1;
825 cp.out = -1;
826 cp.dir = path;
827 if (start_command(&cp))
828 die("Could not run 'git rev-list <commits> --not --remotes -n 1' command in submodule %s",
829 path);
830 if (strbuf_read(&buf, cp.out, 41))
831 needs_pushing = 1;
832 finish_command(&cp);
833 close(cp.out);
834 strbuf_release(&buf);
835 return needs_pushing;
836 }
837
838 return 0;
839 }
840
841 int find_unpushed_submodules(struct oid_array *commits,
842 const char *remotes_name, struct string_list *needs_pushing)
843 {
844 struct string_list submodules = STRING_LIST_INIT_DUP;
845 struct string_list_item *submodule;
846 struct argv_array argv = ARGV_ARRAY_INIT;
847
848 /* argv.argv[0] will be ignored by setup_revisions */
849 argv_array_push(&argv, "find_unpushed_submodules");
850 oid_array_for_each_unique(commits, append_oid_to_argv, &argv);
851 argv_array_push(&argv, "--not");
852 argv_array_pushf(&argv, "--remotes=%s", remotes_name);
853
854 collect_changed_submodules(&submodules, &argv);
855
856 for_each_string_list_item(submodule, &submodules) {
857 struct oid_array *commits = submodule->util;
858 const char *path = submodule->string;
859
860 if (submodule_needs_pushing(path, commits))
861 string_list_insert(needs_pushing, path);
862 }
863
864 free_submodules_oids(&submodules);
865 argv_array_clear(&argv);
866
867 return needs_pushing->nr;
868 }
869
870 static int push_submodule(const char *path,
871 const struct remote *remote,
872 const char **refspec, int refspec_nr,
873 const struct string_list *push_options,
874 int dry_run)
875 {
876 if (add_submodule_odb(path))
877 return 1;
878
879 if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
880 struct child_process cp = CHILD_PROCESS_INIT;
881 argv_array_push(&cp.args, "push");
882 if (dry_run)
883 argv_array_push(&cp.args, "--dry-run");
884
885 if (push_options && push_options->nr) {
886 const struct string_list_item *item;
887 for_each_string_list_item(item, push_options)
888 argv_array_pushf(&cp.args, "--push-option=%s",
889 item->string);
890 }
891
892 if (remote->origin != REMOTE_UNCONFIGURED) {
893 int i;
894 argv_array_push(&cp.args, remote->name);
895 for (i = 0; i < refspec_nr; i++)
896 argv_array_push(&cp.args, refspec[i]);
897 }
898
899 prepare_submodule_repo_env(&cp.env_array);
900 cp.git_cmd = 1;
901 cp.no_stdin = 1;
902 cp.dir = path;
903 if (run_command(&cp))
904 return 0;
905 close(cp.out);
906 }
907
908 return 1;
909 }
910
911 /*
912 * Perform a check in the submodule to see if the remote and refspec work.
913 * Die if the submodule can't be pushed.
914 */
915 static void submodule_push_check(const char *path, const struct remote *remote,
916 const char **refspec, int refspec_nr)
917 {
918 struct child_process cp = CHILD_PROCESS_INIT;
919 int i;
920
921 argv_array_push(&cp.args, "submodule--helper");
922 argv_array_push(&cp.args, "push-check");
923 argv_array_push(&cp.args, remote->name);
924
925 for (i = 0; i < refspec_nr; i++)
926 argv_array_push(&cp.args, refspec[i]);
927
928 prepare_submodule_repo_env(&cp.env_array);
929 cp.git_cmd = 1;
930 cp.no_stdin = 1;
931 cp.no_stdout = 1;
932 cp.dir = path;
933
934 /*
935 * Simply indicate if 'submodule--helper push-check' failed.
936 * More detailed error information will be provided by the
937 * child process.
938 */
939 if (run_command(&cp))
940 die("process for submodule '%s' failed", path);
941 }
942
943 int push_unpushed_submodules(struct oid_array *commits,
944 const struct remote *remote,
945 const char **refspec, int refspec_nr,
946 const struct string_list *push_options,
947 int dry_run)
948 {
949 int i, ret = 1;
950 struct string_list needs_pushing = STRING_LIST_INIT_DUP;
951
952 if (!find_unpushed_submodules(commits, remote->name, &needs_pushing))
953 return 1;
954
955 /*
956 * Verify that the remote and refspec can be propagated to all
957 * submodules. This check can be skipped if the remote and refspec
958 * won't be propagated due to the remote being unconfigured (e.g. a URL
959 * instead of a remote name).
960 */
961 if (remote->origin != REMOTE_UNCONFIGURED)
962 for (i = 0; i < needs_pushing.nr; i++)
963 submodule_push_check(needs_pushing.items[i].string,
964 remote, refspec, refspec_nr);
965
966 /* Actually push the submodules */
967 for (i = 0; i < needs_pushing.nr; i++) {
968 const char *path = needs_pushing.items[i].string;
969 fprintf(stderr, "Pushing submodule '%s'\n", path);
970 if (!push_submodule(path, remote, refspec, refspec_nr,
971 push_options, dry_run)) {
972 fprintf(stderr, "Unable to push submodule '%s'\n", path);
973 ret = 0;
974 }
975 }
976
977 string_list_clear(&needs_pushing, 0);
978
979 return ret;
980 }
981
982 static int append_oid_to_array(const char *ref, const struct object_id *oid,
983 int flags, void *data)
984 {
985 struct oid_array *array = data;
986 oid_array_append(array, oid);
987 return 0;
988 }
989
990 void check_for_new_submodule_commits(struct object_id *oid)
991 {
992 if (!initialized_fetch_ref_tips) {
993 for_each_ref(append_oid_to_array, &ref_tips_before_fetch);
994 initialized_fetch_ref_tips = 1;
995 }
996
997 oid_array_append(&ref_tips_after_fetch, oid);
998 }
999
1000 static void calculate_changed_submodule_paths(void)
1001 {
1002 struct argv_array argv = ARGV_ARRAY_INIT;
1003 struct string_list changed_submodules = STRING_LIST_INIT_DUP;
1004 const struct string_list_item *item;
1005
1006 /* No need to check if there are no submodules configured */
1007 if (!submodule_from_path(NULL, NULL))
1008 return;
1009
1010 argv_array_push(&argv, "--"); /* argv[0] program name */
1011 oid_array_for_each_unique(&ref_tips_after_fetch,
1012 append_oid_to_argv, &argv);
1013 argv_array_push(&argv, "--not");
1014 oid_array_for_each_unique(&ref_tips_before_fetch,
1015 append_oid_to_argv, &argv);
1016
1017 /*
1018 * Collect all submodules (whether checked out or not) for which new
1019 * commits have been recorded upstream in "changed_submodule_paths".
1020 */
1021 collect_changed_submodules(&changed_submodules, &argv);
1022
1023 for_each_string_list_item(item, &changed_submodules) {
1024 struct oid_array *commits = item->util;
1025 const char *path = item->string;
1026
1027 if (!submodule_has_commits(path, commits))
1028 string_list_append(&changed_submodule_paths, path);
1029 }
1030
1031 free_submodules_oids(&changed_submodules);
1032 argv_array_clear(&argv);
1033 oid_array_clear(&ref_tips_before_fetch);
1034 oid_array_clear(&ref_tips_after_fetch);
1035 initialized_fetch_ref_tips = 0;
1036 }
1037
1038 struct submodule_parallel_fetch {
1039 int count;
1040 struct argv_array args;
1041 const char *work_tree;
1042 const char *prefix;
1043 int command_line_option;
1044 int quiet;
1045 int result;
1046 };
1047 #define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0}
1048
1049 static int get_next_submodule(struct child_process *cp,
1050 struct strbuf *err, void *data, void **task_cb)
1051 {
1052 int ret = 0;
1053 struct submodule_parallel_fetch *spf = data;
1054
1055 for (; spf->count < active_nr; spf->count++) {
1056 struct strbuf submodule_path = STRBUF_INIT;
1057 struct strbuf submodule_git_dir = STRBUF_INIT;
1058 struct strbuf submodule_prefix = STRBUF_INIT;
1059 const struct cache_entry *ce = active_cache[spf->count];
1060 const char *git_dir, *default_argv;
1061 const struct submodule *submodule;
1062
1063 if (!S_ISGITLINK(ce->ce_mode))
1064 continue;
1065
1066 submodule = submodule_from_path(null_sha1, ce->name);
1067 if (!submodule)
1068 submodule = submodule_from_name(null_sha1, ce->name);
1069
1070 default_argv = "yes";
1071 if (spf->command_line_option == RECURSE_SUBMODULES_DEFAULT) {
1072 if (submodule &&
1073 submodule->fetch_recurse !=
1074 RECURSE_SUBMODULES_NONE) {
1075 if (submodule->fetch_recurse ==
1076 RECURSE_SUBMODULES_OFF)
1077 continue;
1078 if (submodule->fetch_recurse ==
1079 RECURSE_SUBMODULES_ON_DEMAND) {
1080 if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
1081 continue;
1082 default_argv = "on-demand";
1083 }
1084 } else {
1085 if ((config_fetch_recurse_submodules == RECURSE_SUBMODULES_OFF) ||
1086 gitmodules_is_unmerged)
1087 continue;
1088 if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND) {
1089 if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
1090 continue;
1091 default_argv = "on-demand";
1092 }
1093 }
1094 } else if (spf->command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {
1095 if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
1096 continue;
1097 default_argv = "on-demand";
1098 }
1099
1100 strbuf_addf(&submodule_path, "%s/%s", spf->work_tree, ce->name);
1101 strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
1102 strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name);
1103 git_dir = read_gitfile(submodule_git_dir.buf);
1104 if (!git_dir)
1105 git_dir = submodule_git_dir.buf;
1106 if (is_directory(git_dir)) {
1107 child_process_init(cp);
1108 cp->dir = strbuf_detach(&submodule_path, NULL);
1109 prepare_submodule_repo_env(&cp->env_array);
1110 cp->git_cmd = 1;
1111 if (!spf->quiet)
1112 strbuf_addf(err, "Fetching submodule %s%s\n",
1113 spf->prefix, ce->name);
1114 argv_array_init(&cp->args);
1115 argv_array_pushv(&cp->args, spf->args.argv);
1116 argv_array_push(&cp->args, default_argv);
1117 argv_array_push(&cp->args, "--submodule-prefix");
1118 argv_array_push(&cp->args, submodule_prefix.buf);
1119 ret = 1;
1120 }
1121 strbuf_release(&submodule_path);
1122 strbuf_release(&submodule_git_dir);
1123 strbuf_release(&submodule_prefix);
1124 if (ret) {
1125 spf->count++;
1126 return 1;
1127 }
1128 }
1129 return 0;
1130 }
1131
1132 static int fetch_start_failure(struct strbuf *err,
1133 void *cb, void *task_cb)
1134 {
1135 struct submodule_parallel_fetch *spf = cb;
1136
1137 spf->result = 1;
1138
1139 return 0;
1140 }
1141
1142 static int fetch_finish(int retvalue, struct strbuf *err,
1143 void *cb, void *task_cb)
1144 {
1145 struct submodule_parallel_fetch *spf = cb;
1146
1147 if (retvalue)
1148 spf->result = 1;
1149
1150 return 0;
1151 }
1152
1153 int fetch_populated_submodules(const struct argv_array *options,
1154 const char *prefix, int command_line_option,
1155 int quiet, int max_parallel_jobs)
1156 {
1157 int i;
1158 struct submodule_parallel_fetch spf = SPF_INIT;
1159
1160 spf.work_tree = get_git_work_tree();
1161 spf.command_line_option = command_line_option;
1162 spf.quiet = quiet;
1163 spf.prefix = prefix;
1164
1165 if (!spf.work_tree)
1166 goto out;
1167
1168 if (read_cache() < 0)
1169 die("index file corrupt");
1170
1171 argv_array_push(&spf.args, "fetch");
1172 for (i = 0; i < options->argc; i++)
1173 argv_array_push(&spf.args, options->argv[i]);
1174 argv_array_push(&spf.args, "--recurse-submodules-default");
1175 /* default value, "--submodule-prefix" and its value are added later */
1176
1177 if (max_parallel_jobs < 0)
1178 max_parallel_jobs = parallel_jobs;
1179
1180 calculate_changed_submodule_paths();
1181 run_processes_parallel(max_parallel_jobs,
1182 get_next_submodule,
1183 fetch_start_failure,
1184 fetch_finish,
1185 &spf);
1186
1187 argv_array_clear(&spf.args);
1188 out:
1189 string_list_clear(&changed_submodule_paths, 1);
1190 return spf.result;
1191 }
1192
1193 unsigned is_submodule_modified(const char *path, int ignore_untracked)
1194 {
1195 struct child_process cp = CHILD_PROCESS_INIT;
1196 struct strbuf buf = STRBUF_INIT;
1197 FILE *fp;
1198 unsigned dirty_submodule = 0;
1199 const char *git_dir;
1200 int ignore_cp_exit_code = 0;
1201
1202 strbuf_addf(&buf, "%s/.git", path);
1203 git_dir = read_gitfile(buf.buf);
1204 if (!git_dir)
1205 git_dir = buf.buf;
1206 if (!is_git_directory(git_dir)) {
1207 if (is_directory(git_dir))
1208 die(_("'%s' not recognized as a git repository"), git_dir);
1209 strbuf_release(&buf);
1210 /* The submodule is not checked out, so it is not modified */
1211 return 0;
1212 }
1213 strbuf_reset(&buf);
1214
1215 argv_array_pushl(&cp.args, "status", "--porcelain=2", NULL);
1216 if (ignore_untracked)
1217 argv_array_push(&cp.args, "-uno");
1218
1219 prepare_submodule_repo_env(&cp.env_array);
1220 cp.git_cmd = 1;
1221 cp.no_stdin = 1;
1222 cp.out = -1;
1223 cp.dir = path;
1224 if (start_command(&cp))
1225 die("Could not run 'git status --porcelain=2' in submodule %s", path);
1226
1227 fp = xfdopen(cp.out, "r");
1228 while (strbuf_getwholeline(&buf, fp, '\n') != EOF) {
1229 /* regular untracked files */
1230 if (buf.buf[0] == '?')
1231 dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
1232
1233 if (buf.buf[0] == 'u' ||
1234 buf.buf[0] == '1' ||
1235 buf.buf[0] == '2') {
1236 /* T = line type, XY = status, SSSS = submodule state */
1237 if (buf.len < strlen("T XY SSSS"))
1238 die("BUG: invalid status --porcelain=2 line %s",
1239 buf.buf);
1240
1241 if (buf.buf[5] == 'S' && buf.buf[8] == 'U')
1242 /* nested untracked file */
1243 dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
1244
1245 if (buf.buf[0] == 'u' ||
1246 buf.buf[0] == '2' ||
1247 memcmp(buf.buf + 5, "S..U", 4))
1248 /* other change */
1249 dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
1250 }
1251
1252 if ((dirty_submodule & DIRTY_SUBMODULE_MODIFIED) &&
1253 ((dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) ||
1254 ignore_untracked)) {
1255 /*
1256 * We're not interested in any further information from
1257 * the child any more, neither output nor its exit code.
1258 */
1259 ignore_cp_exit_code = 1;
1260 break;
1261 }
1262 }
1263 fclose(fp);
1264
1265 if (finish_command(&cp) && !ignore_cp_exit_code)
1266 die("'git status --porcelain=2' failed in submodule %s", path);
1267
1268 strbuf_release(&buf);
1269 return dirty_submodule;
1270 }
1271
1272 int submodule_uses_gitfile(const char *path)
1273 {
1274 struct child_process cp = CHILD_PROCESS_INIT;
1275 const char *argv[] = {
1276 "submodule",
1277 "foreach",
1278 "--quiet",
1279 "--recursive",
1280 "test -f .git",
1281 NULL,
1282 };
1283 struct strbuf buf = STRBUF_INIT;
1284 const char *git_dir;
1285
1286 strbuf_addf(&buf, "%s/.git", path);
1287 git_dir = read_gitfile(buf.buf);
1288 if (!git_dir) {
1289 strbuf_release(&buf);
1290 return 0;
1291 }
1292 strbuf_release(&buf);
1293
1294 /* Now test that all nested submodules use a gitfile too */
1295 cp.argv = argv;
1296 prepare_submodule_repo_env(&cp.env_array);
1297 cp.git_cmd = 1;
1298 cp.no_stdin = 1;
1299 cp.no_stderr = 1;
1300 cp.no_stdout = 1;
1301 cp.dir = path;
1302 if (run_command(&cp))
1303 return 0;
1304
1305 return 1;
1306 }
1307
1308 /*
1309 * Check if it is a bad idea to remove a submodule, i.e. if we'd lose data
1310 * when doing so.
1311 *
1312 * Return 1 if we'd lose data, return 0 if the removal is fine,
1313 * and negative values for errors.
1314 */
1315 int bad_to_remove_submodule(const char *path, unsigned flags)
1316 {
1317 ssize_t len;
1318 struct child_process cp = CHILD_PROCESS_INIT;
1319 struct strbuf buf = STRBUF_INIT;
1320 int ret = 0;
1321
1322 if (!file_exists(path) || is_empty_dir(path))
1323 return 0;
1324
1325 if (!submodule_uses_gitfile(path))
1326 return 1;
1327
1328 argv_array_pushl(&cp.args, "status", "--porcelain",
1329 "--ignore-submodules=none", NULL);
1330
1331 if (flags & SUBMODULE_REMOVAL_IGNORE_UNTRACKED)
1332 argv_array_push(&cp.args, "-uno");
1333 else
1334 argv_array_push(&cp.args, "-uall");
1335
1336 if (!(flags & SUBMODULE_REMOVAL_IGNORE_IGNORED_UNTRACKED))
1337 argv_array_push(&cp.args, "--ignored");
1338
1339 prepare_submodule_repo_env(&cp.env_array);
1340 cp.git_cmd = 1;
1341 cp.no_stdin = 1;
1342 cp.out = -1;
1343 cp.dir = path;
1344 if (start_command(&cp)) {
1345 if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
1346 die(_("could not start 'git status' in submodule '%s'"),
1347 path);
1348 ret = -1;
1349 goto out;
1350 }
1351
1352 len = strbuf_read(&buf, cp.out, 1024);
1353 if (len > 2)
1354 ret = 1;
1355 close(cp.out);
1356
1357 if (finish_command(&cp)) {
1358 if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
1359 die(_("could not run 'git status' in submodule '%s'"),
1360 path);
1361 ret = -1;
1362 }
1363 out:
1364 strbuf_release(&buf);
1365 return ret;
1366 }
1367
1368 static const char *get_super_prefix_or_empty(void)
1369 {
1370 const char *s = get_super_prefix();
1371 if (!s)
1372 s = "";
1373 return s;
1374 }
1375
1376 static int submodule_has_dirty_index(const struct submodule *sub)
1377 {
1378 struct child_process cp = CHILD_PROCESS_INIT;
1379
1380 prepare_submodule_repo_env_no_git_dir(&cp.env_array);
1381
1382 cp.git_cmd = 1;
1383 argv_array_pushl(&cp.args, "diff-index", "--quiet",
1384 "--cached", "HEAD", NULL);
1385 cp.no_stdin = 1;
1386 cp.no_stdout = 1;
1387 cp.dir = sub->path;
1388 if (start_command(&cp))
1389 die("could not recurse into submodule '%s'", sub->path);
1390
1391 return finish_command(&cp);
1392 }
1393
1394 static void submodule_reset_index(const char *path)
1395 {
1396 struct child_process cp = CHILD_PROCESS_INIT;
1397 prepare_submodule_repo_env_no_git_dir(&cp.env_array);
1398
1399 cp.git_cmd = 1;
1400 cp.no_stdin = 1;
1401 cp.dir = path;
1402
1403 argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
1404 get_super_prefix_or_empty(), path);
1405 argv_array_pushl(&cp.args, "read-tree", "-u", "--reset", NULL);
1406
1407 argv_array_push(&cp.args, EMPTY_TREE_SHA1_HEX);
1408
1409 if (run_command(&cp))
1410 die("could not reset submodule index");
1411 }
1412
1413 /**
1414 * Moves a submodule at a given path from a given head to another new head.
1415 * For edge cases (a submodule coming into existence or removing a submodule)
1416 * pass NULL for old or new respectively.
1417 */
1418 int submodule_move_head(const char *path,
1419 const char *old,
1420 const char *new,
1421 unsigned flags)
1422 {
1423 int ret = 0;
1424 struct child_process cp = CHILD_PROCESS_INIT;
1425 const struct submodule *sub;
1426 int *error_code_ptr, error_code;
1427
1428 if (!is_submodule_initialized(path))
1429 return 0;
1430
1431 if (flags & SUBMODULE_MOVE_HEAD_FORCE)
1432 /*
1433 * Pass non NULL pointer to is_submodule_populated_gently
1434 * to prevent die()-ing. We'll use connect_work_tree_and_git_dir
1435 * to fixup the submodule in the force case later.
1436 */
1437 error_code_ptr = &error_code;
1438 else
1439 error_code_ptr = NULL;
1440
1441 if (old && !is_submodule_populated_gently(path, error_code_ptr))
1442 return 0;
1443
1444 sub = submodule_from_path(null_sha1, path);
1445
1446 if (!sub)
1447 die("BUG: could not get submodule information for '%s'", path);
1448
1449 if (old && !(flags & SUBMODULE_MOVE_HEAD_FORCE)) {
1450 /* Check if the submodule has a dirty index. */
1451 if (submodule_has_dirty_index(sub))
1452 return error(_("submodule '%s' has dirty index"), path);
1453 }
1454
1455 if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
1456 if (old) {
1457 if (!submodule_uses_gitfile(path))
1458 absorb_git_dir_into_superproject("", path,
1459 ABSORB_GITDIR_RECURSE_SUBMODULES);
1460 } else {
1461 char *gitdir = xstrfmt("%s/modules/%s",
1462 get_git_common_dir(), sub->name);
1463 connect_work_tree_and_git_dir(path, gitdir);
1464 free(gitdir);
1465
1466 /* make sure the index is clean as well */
1467 submodule_reset_index(path);
1468 }
1469
1470 if (old && (flags & SUBMODULE_MOVE_HEAD_FORCE)) {
1471 char *gitdir = xstrfmt("%s/modules/%s",
1472 get_git_common_dir(), sub->name);
1473 connect_work_tree_and_git_dir(path, gitdir);
1474 free(gitdir);
1475 }
1476 }
1477
1478 prepare_submodule_repo_env_no_git_dir(&cp.env_array);
1479
1480 cp.git_cmd = 1;
1481 cp.no_stdin = 1;
1482 cp.dir = path;
1483
1484 argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
1485 get_super_prefix_or_empty(), path);
1486 argv_array_pushl(&cp.args, "read-tree", NULL);
1487
1488 if (flags & SUBMODULE_MOVE_HEAD_DRY_RUN)
1489 argv_array_push(&cp.args, "-n");
1490 else
1491 argv_array_push(&cp.args, "-u");
1492
1493 if (flags & SUBMODULE_MOVE_HEAD_FORCE)
1494 argv_array_push(&cp.args, "--reset");
1495 else
1496 argv_array_push(&cp.args, "-m");
1497
1498 argv_array_push(&cp.args, old ? old : EMPTY_TREE_SHA1_HEX);
1499 argv_array_push(&cp.args, new ? new : EMPTY_TREE_SHA1_HEX);
1500
1501 if (run_command(&cp)) {
1502 ret = -1;
1503 goto out;
1504 }
1505
1506 if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
1507 if (new) {
1508 struct child_process cp1 = CHILD_PROCESS_INIT;
1509 /* also set the HEAD accordingly */
1510 cp1.git_cmd = 1;
1511 cp1.no_stdin = 1;
1512 cp1.dir = path;
1513
1514 argv_array_pushl(&cp1.args, "update-ref", "HEAD", new, NULL);
1515
1516 if (run_command(&cp1)) {
1517 ret = -1;
1518 goto out;
1519 }
1520 } else {
1521 struct strbuf sb = STRBUF_INIT;
1522
1523 strbuf_addf(&sb, "%s/.git", path);
1524 unlink_or_warn(sb.buf);
1525 strbuf_release(&sb);
1526
1527 if (is_empty_dir(path))
1528 rmdir_or_warn(path);
1529 }
1530 }
1531 out:
1532 return ret;
1533 }
1534
1535 static int find_first_merges(struct object_array *result, const char *path,
1536 struct commit *a, struct commit *b)
1537 {
1538 int i, j;
1539 struct object_array merges = OBJECT_ARRAY_INIT;
1540 struct commit *commit;
1541 int contains_another;
1542
1543 char merged_revision[42];
1544 const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
1545 "--all", merged_revision, NULL };
1546 struct rev_info revs;
1547 struct setup_revision_opt rev_opts;
1548
1549 memset(result, 0, sizeof(struct object_array));
1550 memset(&rev_opts, 0, sizeof(rev_opts));
1551
1552 /* get all revisions that merge commit a */
1553 xsnprintf(merged_revision, sizeof(merged_revision), "^%s",
1554 oid_to_hex(&a->object.oid));
1555 init_revisions(&revs, NULL);
1556 rev_opts.submodule = path;
1557 setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
1558
1559 /* save all revisions from the above list that contain b */
1560 if (prepare_revision_walk(&revs))
1561 die("revision walk setup failed");
1562 while ((commit = get_revision(&revs)) != NULL) {
1563 struct object *o = &(commit->object);
1564 if (in_merge_bases(b, commit))
1565 add_object_array(o, NULL, &merges);
1566 }
1567 reset_revision_walk();
1568
1569 /* Now we've got all merges that contain a and b. Prune all
1570 * merges that contain another found merge and save them in
1571 * result.
1572 */
1573 for (i = 0; i < merges.nr; i++) {
1574 struct commit *m1 = (struct commit *) merges.objects[i].item;
1575
1576 contains_another = 0;
1577 for (j = 0; j < merges.nr; j++) {
1578 struct commit *m2 = (struct commit *) merges.objects[j].item;
1579 if (i != j && in_merge_bases(m2, m1)) {
1580 contains_another = 1;
1581 break;
1582 }
1583 }
1584
1585 if (!contains_another)
1586 add_object_array(merges.objects[i].item, NULL, result);
1587 }
1588
1589 free(merges.objects);
1590 return result->nr;
1591 }
1592
1593 static void print_commit(struct commit *commit)
1594 {
1595 struct strbuf sb = STRBUF_INIT;
1596 struct pretty_print_context ctx = {0};
1597 ctx.date_mode.type = DATE_NORMAL;
1598 format_commit_message(commit, " %h: %m %s", &sb, &ctx);
1599 fprintf(stderr, "%s\n", sb.buf);
1600 strbuf_release(&sb);
1601 }
1602
1603 #define MERGE_WARNING(path, msg) \
1604 warning("Failed to merge submodule %s (%s)", path, msg);
1605
1606 int merge_submodule(unsigned char result[20], const char *path,
1607 const unsigned char base[20], const unsigned char a[20],
1608 const unsigned char b[20], int search)
1609 {
1610 struct commit *commit_base, *commit_a, *commit_b;
1611 int parent_count;
1612 struct object_array merges;
1613
1614 int i;
1615
1616 /* store a in result in case we fail */
1617 hashcpy(result, a);
1618
1619 /* we can not handle deletion conflicts */
1620 if (is_null_sha1(base))
1621 return 0;
1622 if (is_null_sha1(a))
1623 return 0;
1624 if (is_null_sha1(b))
1625 return 0;
1626
1627 if (add_submodule_odb(path)) {
1628 MERGE_WARNING(path, "not checked out");
1629 return 0;
1630 }
1631
1632 if (!(commit_base = lookup_commit_reference(base)) ||
1633 !(commit_a = lookup_commit_reference(a)) ||
1634 !(commit_b = lookup_commit_reference(b))) {
1635 MERGE_WARNING(path, "commits not present");
1636 return 0;
1637 }
1638
1639 /* check whether both changes are forward */
1640 if (!in_merge_bases(commit_base, commit_a) ||
1641 !in_merge_bases(commit_base, commit_b)) {
1642 MERGE_WARNING(path, "commits don't follow merge-base");
1643 return 0;
1644 }
1645
1646 /* Case #1: a is contained in b or vice versa */
1647 if (in_merge_bases(commit_a, commit_b)) {
1648 hashcpy(result, b);
1649 return 1;
1650 }
1651 if (in_merge_bases(commit_b, commit_a)) {
1652 hashcpy(result, a);
1653 return 1;
1654 }
1655
1656 /*
1657 * Case #2: There are one or more merges that contain a and b in
1658 * the submodule. If there is only one, then present it as a
1659 * suggestion to the user, but leave it marked unmerged so the
1660 * user needs to confirm the resolution.
1661 */
1662
1663 /* Skip the search if makes no sense to the calling context. */
1664 if (!search)
1665 return 0;
1666
1667 /* find commit which merges them */
1668 parent_count = find_first_merges(&merges, path, commit_a, commit_b);
1669 switch (parent_count) {
1670 case 0:
1671 MERGE_WARNING(path, "merge following commits not found");
1672 break;
1673
1674 case 1:
1675 MERGE_WARNING(path, "not fast-forward");
1676 fprintf(stderr, "Found a possible merge resolution "
1677 "for the submodule:\n");
1678 print_commit((struct commit *) merges.objects[0].item);
1679 fprintf(stderr,
1680 "If this is correct simply add it to the index "
1681 "for example\n"
1682 "by using:\n\n"
1683 " git update-index --cacheinfo 160000 %s \"%s\"\n\n"
1684 "which will accept this suggestion.\n",
1685 oid_to_hex(&merges.objects[0].item->oid), path);
1686 break;
1687
1688 default:
1689 MERGE_WARNING(path, "multiple merges found");
1690 for (i = 0; i < merges.nr; i++)
1691 print_commit((struct commit *) merges.objects[i].item);
1692 }
1693
1694 free(merges.objects);
1695 return 0;
1696 }
1697
1698 int parallel_submodules(void)
1699 {
1700 return parallel_jobs;
1701 }
1702
1703 /*
1704 * Embeds a single submodules git directory into the superprojects git dir,
1705 * non recursively.
1706 */
1707 static void relocate_single_git_dir_into_superproject(const char *prefix,
1708 const char *path)
1709 {
1710 char *old_git_dir = NULL, *real_old_git_dir = NULL, *real_new_git_dir = NULL;
1711 const char *new_git_dir;
1712 const struct submodule *sub;
1713
1714 if (submodule_uses_worktrees(path))
1715 die(_("relocate_gitdir for submodule '%s' with "
1716 "more than one worktree not supported"), path);
1717
1718 old_git_dir = xstrfmt("%s/.git", path);
1719 if (read_gitfile(old_git_dir))
1720 /* If it is an actual gitfile, it doesn't need migration. */
1721 return;
1722
1723 real_old_git_dir = real_pathdup(old_git_dir, 1);
1724
1725 sub = submodule_from_path(null_sha1, path);
1726 if (!sub)
1727 die(_("could not lookup name for submodule '%s'"), path);
1728
1729 new_git_dir = git_path("modules/%s", sub->name);
1730 if (safe_create_leading_directories_const(new_git_dir) < 0)
1731 die(_("could not create directory '%s'"), new_git_dir);
1732 real_new_git_dir = real_pathdup(new_git_dir, 1);
1733
1734 fprintf(stderr, _("Migrating git directory of '%s%s' from\n'%s' to\n'%s'\n"),
1735 get_super_prefix_or_empty(), path,
1736 real_old_git_dir, real_new_git_dir);
1737
1738 relocate_gitdir(path, real_old_git_dir, real_new_git_dir);
1739
1740 free(old_git_dir);
1741 free(real_old_git_dir);
1742 free(real_new_git_dir);
1743 }
1744
1745 /*
1746 * Migrate the git directory of the submodule given by path from
1747 * having its git directory within the working tree to the git dir nested
1748 * in its superprojects git dir under modules/.
1749 */
1750 void absorb_git_dir_into_superproject(const char *prefix,
1751 const char *path,
1752 unsigned flags)
1753 {
1754 int err_code;
1755 const char *sub_git_dir;
1756 struct strbuf gitdir = STRBUF_INIT;
1757 strbuf_addf(&gitdir, "%s/.git", path);
1758 sub_git_dir = resolve_gitdir_gently(gitdir.buf, &err_code);
1759
1760 /* Not populated? */
1761 if (!sub_git_dir) {
1762 const struct submodule *sub;
1763
1764 if (err_code == READ_GITFILE_ERR_STAT_FAILED) {
1765 /* unpopulated as expected */
1766 strbuf_release(&gitdir);
1767 return;
1768 }
1769
1770 if (err_code != READ_GITFILE_ERR_NOT_A_REPO)
1771 /* We don't know what broke here. */
1772 read_gitfile_error_die(err_code, path, NULL);
1773
1774 /*
1775 * Maybe populated, but no git directory was found?
1776 * This can happen if the superproject is a submodule
1777 * itself and was just absorbed. The absorption of the
1778 * superproject did not rewrite the git file links yet,
1779 * fix it now.
1780 */
1781 sub = submodule_from_path(null_sha1, path);
1782 if (!sub)
1783 die(_("could not lookup name for submodule '%s'"), path);
1784 connect_work_tree_and_git_dir(path,
1785 git_path("modules/%s", sub->name));
1786 } else {
1787 /* Is it already absorbed into the superprojects git dir? */
1788 char *real_sub_git_dir = real_pathdup(sub_git_dir, 1);
1789 char *real_common_git_dir = real_pathdup(get_git_common_dir(), 1);
1790
1791 if (!starts_with(real_sub_git_dir, real_common_git_dir))
1792 relocate_single_git_dir_into_superproject(prefix, path);
1793
1794 free(real_sub_git_dir);
1795 free(real_common_git_dir);
1796 }
1797 strbuf_release(&gitdir);
1798
1799 if (flags & ABSORB_GITDIR_RECURSE_SUBMODULES) {
1800 struct child_process cp = CHILD_PROCESS_INIT;
1801 struct strbuf sb = STRBUF_INIT;
1802
1803 if (flags & ~ABSORB_GITDIR_RECURSE_SUBMODULES)
1804 die("BUG: we don't know how to pass the flags down?");
1805
1806 strbuf_addstr(&sb, get_super_prefix_or_empty());
1807 strbuf_addstr(&sb, path);
1808 strbuf_addch(&sb, '/');
1809
1810 cp.dir = path;
1811 cp.git_cmd = 1;
1812 cp.no_stdin = 1;
1813 argv_array_pushl(&cp.args, "--super-prefix", sb.buf,
1814 "submodule--helper",
1815 "absorb-git-dirs", NULL);
1816 prepare_submodule_repo_env(&cp.env_array);
1817 if (run_command(&cp))
1818 die(_("could not recurse into submodule '%s'"), path);
1819
1820 strbuf_release(&sb);
1821 }
1822 }
1823
1824 const char *get_superproject_working_tree(void)
1825 {
1826 struct child_process cp = CHILD_PROCESS_INIT;
1827 struct strbuf sb = STRBUF_INIT;
1828 const char *one_up = real_path_if_valid("../");
1829 const char *cwd = xgetcwd();
1830 const char *ret = NULL;
1831 const char *subpath;
1832 int code;
1833 ssize_t len;
1834
1835 if (!is_inside_work_tree())
1836 /*
1837 * FIXME:
1838 * We might have a superproject, but it is harder
1839 * to determine.
1840 */
1841 return NULL;
1842
1843 if (!one_up)
1844 return NULL;
1845
1846 subpath = relative_path(cwd, one_up, &sb);
1847
1848 prepare_submodule_repo_env(&cp.env_array);
1849 argv_array_pop(&cp.env_array);
1850
1851 argv_array_pushl(&cp.args, "--literal-pathspecs", "-C", "..",
1852 "ls-files", "-z", "--stage", "--full-name", "--",
1853 subpath, NULL);
1854 strbuf_reset(&sb);
1855
1856 cp.no_stdin = 1;
1857 cp.no_stderr = 1;
1858 cp.out = -1;
1859 cp.git_cmd = 1;
1860
1861 if (start_command(&cp))
1862 die(_("could not start ls-files in .."));
1863
1864 len = strbuf_read(&sb, cp.out, PATH_MAX);
1865 close(cp.out);
1866
1867 if (starts_with(sb.buf, "160000")) {
1868 int super_sub_len;
1869 int cwd_len = strlen(cwd);
1870 char *super_sub, *super_wt;
1871
1872 /*
1873 * There is a superproject having this repo as a submodule.
1874 * The format is <mode> SP <hash> SP <stage> TAB <full name> \0,
1875 * We're only interested in the name after the tab.
1876 */
1877 super_sub = strchr(sb.buf, '\t') + 1;
1878 super_sub_len = sb.buf + sb.len - super_sub - 1;
1879
1880 if (super_sub_len > cwd_len ||
1881 strcmp(&cwd[cwd_len - super_sub_len], super_sub))
1882 die (_("BUG: returned path string doesn't match cwd?"));
1883
1884 super_wt = xstrdup(cwd);
1885 super_wt[cwd_len - super_sub_len] = '\0';
1886
1887 ret = real_path(super_wt);
1888 free(super_wt);
1889 }
1890 strbuf_release(&sb);
1891
1892 code = finish_command(&cp);
1893
1894 if (code == 128)
1895 /* '../' is not a git repository */
1896 return NULL;
1897 if (code == 0 && len == 0)
1898 /* There is an unrelated git repository at '../' */
1899 return NULL;
1900 if (code)
1901 die(_("ls-tree returned unexpected return code %d"), code);
1902
1903 return ret;
1904 }
1905
1906 int submodule_to_gitdir(struct strbuf *buf, const char *submodule)
1907 {
1908 const struct submodule *sub;
1909 const char *git_dir;
1910 int ret = 0;
1911
1912 strbuf_reset(buf);
1913 strbuf_addstr(buf, submodule);
1914 strbuf_complete(buf, '/');
1915 strbuf_addstr(buf, ".git");
1916
1917 git_dir = read_gitfile(buf->buf);
1918 if (git_dir) {
1919 strbuf_reset(buf);
1920 strbuf_addstr(buf, git_dir);
1921 }
1922 if (!is_git_directory(buf->buf)) {
1923 gitmodules_config();
1924 sub = submodule_from_path(null_sha1, submodule);
1925 if (!sub) {
1926 ret = -1;
1927 goto cleanup;
1928 }
1929 strbuf_reset(buf);
1930 strbuf_git_path(buf, "%s/%s", "modules", sub->name);
1931 }
1932
1933 cleanup:
1934 return ret;
1935 }