read-tree.c

   1 /*
   2  * GIT - The information manager from hell
   3  *
   4  * Copyright (C) Linus Torvalds, 2005
   5  */
   6 #include "cache.h"
   7
   8 static int stage = 0;
   9 static int update = 0;
  10
  11 static int unpack_tree(unsigned char *sha1)
  12 {
  13         void *buffer;
  14         unsigned long size;
  15         int ret;
  16
  17         buffer = read_object_with_reference(sha1, "tree", &size, NULL);
  18         if (!buffer)
  19                 return -1;
  20         ret = read_tree(buffer, size, stage);
  21         free(buffer);
  22         return ret;
  23 }
  24
  25 static char *lockfile_name;
  26
  27 static void remove_lock_file(void)
  28 {
  29         if (lockfile_name)
  30                 unlink(lockfile_name);
  31 }
  32
  33 static int path_matches(struct cache_entry *a, struct cache_entry *b)
  34 {
  35         int len = ce_namelen(a);
  36         return ce_namelen(b) == len &&
  37                 !memcmp(a->name, b->name, len);
  38 }
  39
  40 static int same(struct cache_entry *a, struct cache_entry *b)
  41 {
  42         return a->ce_mode == b->ce_mode &&
  43                 !memcmp(a->sha1, b->sha1, 20);
  44 }
  45
  46
  47 /*
  48  * This removes all trivial merges that don't change the tree
  49  * and collapses them to state 0.
  50  *
  51  * _Any_ other merge is left to user policy.  That includes "both
  52  * created the same file", and "both removed the same file" - which are
  53  * trivial, but the user might still want to _note_ it.
  54  */
  55 static struct cache_entry *merge_entries(struct cache_entry *a,
  56                                          struct cache_entry *b,
  57                                          struct cache_entry *c)
  58 {
  59         int len = ce_namelen(a);
  60
  61         /*
  62          * Are they all the same filename? We won't do
  63          * any name merging
  64          */
  65         if (ce_namelen(b) != len ||
  66             ce_namelen(c) != len ||
  67             memcmp(a->name, b->name, len) ||
  68             memcmp(a->name, c->name, len))
  69                 return NULL;
  70
  71         /*
  72          * Ok, all three entries describe the same
  73          * filename, but maybe the contents or file
  74          * mode have changed?
  75          *
  76          * The trivial cases end up being the ones where two
  77          * out of three files are the same:
  78          *  - both destinations the same, trivially take either
  79          *  - one of the destination versions hasn't changed,
  80          *    take the other.
  81          *
  82          * The "all entries exactly the same" case falls out as
  83          * a special case of any of the "two same" cases.
  84          *
  85          * Here "a" is "original", and "b" and "c" are the two
  86          * trees we are merging.
  87          */
  88         if (same(b,c))
  89                 return c;
  90         if (same(a,b))
  91                 return c;
  92         if (same(a,c))
  93                 return b;
  94         return NULL;
  95 }
  96
  97 /*
  98  * When a CE gets turned into an unmerged entry, we
  99  * want it to be up-to-date
 100  */
 101 static void verify_uptodate(struct cache_entry *ce)
 102 {
 103         struct stat st;
 104
 105         if (!lstat(ce->name, &st)) {
 106                 unsigned changed = ce_match_stat(ce, &st);
 107                 if (!changed)
 108                         return;
 109                 errno = 0;
 110         }
 111         if (errno == ENOENT)
 112                 return;
 113         die("Entry '%s' not uptodate. Cannot merge.", ce->name);
 114 }
 115
 116 /*
 117  * If the old tree contained a CE that isn't even in the
 118  * result, that's always a problem, regardless of whether
 119  * it's up-to-date or not (ie it can be a file that we
 120  * have updated but not committed yet).
 121  */
 122 static void reject_merge(struct cache_entry *ce)
 123 {
 124         die("Entry '%s' would be overwritten by merge. Cannot merge.", ce->name);
 125 }
 126
 127 #define CHECK_OLD(ce) if (old && same(old, ce)) { verify_uptodate(old); old = NULL; }
 128
 129 static void trivially_merge_cache(struct cache_entry **src, int nr)
 130 {
 131         struct cache_entry **dst = src;
 132         struct cache_entry *old = NULL;
 133
 134         while (nr--) {
 135                 struct cache_entry *ce, *result;
 136
 137                 ce = *src++;
 138
 139                 /* We throw away original cache entries except for the stat information */
 140                 if (!ce_stage(ce)) {
 141                         if (old)
 142                                 reject_merge(old);
 143                         old = ce;
 144                         active_nr--;
 145                         continue;
 146                 }
 147                 if (old && !path_matches(old, ce))
 148                         reject_merge(old);
 149                 if (nr > 2 && (result = merge_entries(ce, src[1], src[2])) != NULL) {
 150                         result->ce_flags |= htons(CE_UPDATE);
 151                         /*
 152                          * See if we can re-use the old CE directly?
 153                          * That way we get the uptodate stat info.
 154                          *
 155                          * This also removes the UPDATE flag on
 156                          * a match.
 157                          */
 158                         if (old && same(old, result)) {
 159                                 *result = *old;
 160                                 old = NULL;
 161                         }
 162                         CHECK_OLD(ce);
 163                         CHECK_OLD(src[1]);
 164                         CHECK_OLD(src[2]);
 165                         ce = result;
 166                         ce->ce_flags &= ~htons(CE_STAGEMASK);
 167                         src += 2;
 168                         nr -= 2;
 169                         active_nr -= 2;
 170                 }
 171
 172                 /*
 173                  * If we had an old entry that we now effectively
 174                  * overwrite, make sure it wasn't dirty.
 175                  */
 176                 CHECK_OLD(ce);
 177                 *dst++ = ce;
 178         }
 179         if (old)
 180                 reject_merge(old);
 181 }
 182
 183 /*
 184  * When we find a "stage2" entry in the two-way merge, that's
 185  * the one that will remain. If we have an exact old match,
 186  * we don't care whether the file is up-to-date or not, we just
 187  * re-use the thing directly.
 188  *
 189  * If we didn't have an exact match, then we want to make sure
 190  * that we've seen a stage1 that matched the old, and that the
 191  * old file was up-to-date. Because it will be gone after this
 192  * merge..
 193  */
 194 static void twoway_check(struct cache_entry *old, int seen_stage1, struct cache_entry *ce)
 195 {
 196         if (path_matches(old, ce)) {
 197                 /*
 198                  * This also removes the UPDATE flag on
 199                  * a match
 200                  */
 201                 if (same(old, ce)) {
 202                         *ce = *old;
 203                         return;
 204                 }
 205                 if (!seen_stage1)
 206                         reject_merge(old);
 207         }
 208         verify_uptodate(old);
 209 }
 210
 211 /*
 212  * Two-way merge.
 213  *
 214  * The rule is:
 215  *  - every current entry has to match the old tree
 216  *  - if the current entry matches the new tree, we leave it
 217  *    as-is. Otherwise we require that it be up-to-date.
 218  */
 219 static void twoway_merge(struct cache_entry **src, int nr)
 220 {
 221         int seen_stage1 = 0;
 222         struct cache_entry *old = NULL;
 223         struct cache_entry **dst = src;
 224
 225         while (nr--) {
 226                 struct cache_entry *ce = *src++;
 227                 int stage = ce_stage(ce);
 228
 229                 switch (stage) {
 230                 case 0:
 231                         if (old)
 232                                 reject_merge(old);
 233                         old = ce;
 234                         seen_stage1 = 0;
 235                         active_nr--;
 236                         continue;
 237
 238                 case 1:
 239                         active_nr--;
 240                         if (!old)
 241                                 continue;
 242                         if (!path_matches(old, ce) || !same(old, ce))
 243                                 reject_merge(old);
 244                         seen_stage1 = 1;
 245                         continue;
 246
 247                 case 2:
 248                         ce->ce_flags |= htons(CE_UPDATE);
 249                         if (old) {
 250                                 twoway_check(old, seen_stage1, ce);
 251                                 old = NULL;
 252                         }
 253                         ce->ce_flags &= ~htons(CE_STAGEMASK);
 254                         *dst++ = ce;
 255                         continue;
 256                 }
 257                 die("impossible two-way stage");
 258         }
 259
 260         /*
 261          * Unmatched with a new entry? Make sure it was
 262          * at least uptodate in the working directory _and_
 263          * the original tree..
 264          */
 265         if (old) {
 266                 if (!seen_stage1)
 267                         reject_merge(old);
 268                 verify_uptodate(old);
 269         }
 270 }
 271
 272 static void merge_stat_info(struct cache_entry **src, int nr)
 273 {
 274         static struct cache_entry null_entry;
 275         struct cache_entry **dst = src;
 276         struct cache_entry *stat = &null_entry;
 277
 278         while (nr--) {
 279                 struct cache_entry *ce = *src++;
 280
 281                 /* We throw away original cache entries except for the stat information */
 282                 if (!ce_stage(ce)) {
 283                         stat = ce;
 284                         active_nr--;
 285                         continue;
 286                 }
 287                 if (path_matches(ce, stat) && same(ce, stat))
 288                         *ce = *stat;
 289                 ce->ce_flags &= ~htons(CE_STAGEMASK);
 290                 *dst++ = ce;
 291         }
 292 }
 293
 294 static void check_updates(struct cache_entry **src, int nr)
 295 {
 296         static struct checkout state = {
 297                 .base_dir = "",
 298                 .force = 1,
 299                 .quiet = 1,
 300                 .refresh_cache = 1,
 301         };
 302         unsigned short mask = htons(CE_UPDATE);
 303         while (nr--) {
 304                 struct cache_entry *ce = *src++;
 305                 if (ce->ce_flags & mask) {
 306                         ce->ce_flags &= ~mask;
 307                         if (update)
 308                                 checkout_entry(ce, &state);
 309                 }
 310         }
 311 }
 312
 313 static char *read_tree_usage = "git-read-tree (<sha> | -m <sha1> [<sha2> [<sha3>]])";
 314
 315 int main(int argc, char **argv)
 316 {
 317         int i, newfd, merge;
 318         unsigned char sha1[20];
 319         static char lockfile[MAXPATHLEN+1];
 320         const char *indexfile = get_index_file();
 321
 322         snprintf(lockfile, sizeof(lockfile), "%s.lock", indexfile);
 323
 324         newfd = open(lockfile, O_RDWR | O_CREAT | O_EXCL, 0600);
 325         if (newfd < 0)
 326                 die("unable to create new cachefile");
 327         atexit(remove_lock_file);
 328         lockfile_name = lockfile;
 329
 330         merge = 0;
 331         for (i = 1; i < argc; i++) {
 332                 const char *arg = argv[i];
 333
 334                 /* "-u" means "update", meaning that a merge will update the working directory */
 335                 if (!strcmp(arg, "-u")) {
 336                         update = 1;
 337                         continue;
 338                 }
 339
 340                 /* "-m" stands for "merge", meaning we start in stage 1 */
 341                 if (!strcmp(arg, "-m")) {
 342                         int i;
 343                         if (stage)
 344                                 die("-m needs to come first");
 345                         read_cache();
 346                         for (i = 0; i < active_nr; i++) {
 347                                 if (ce_stage(active_cache[i]))
 348                                         die("you need to resolve your current index first");
 349                         }
 350                         stage = 1;
 351                         merge = 1;
 352                         continue;
 353                 }
 354                 if (get_sha1(arg, sha1) < 0)
 355                         usage(read_tree_usage);
 356                 if (stage > 3)
 357                         usage(read_tree_usage);
 358                 if (unpack_tree(sha1) < 0)
 359                         die("failed to unpack tree object %s", arg);
 360                 stage++;
 361         }
 362         if (merge) {
 363                 switch (stage) {
 364                 case 4: /* Three-way merge */
 365                         trivially_merge_cache(active_cache, active_nr);
 366                         check_updates(active_cache, active_nr);
 367                         break;
 368                 case 3: /* Update from one tree to another */
 369                         twoway_merge(active_cache, active_nr);
 370                         check_updates(active_cache, active_nr);
 371                         break;
 372                 case 2: /* Just read a tree, merge with old cache contents */
 373                         merge_stat_info(active_cache, active_nr);
 374                         break;
 375                 default:
 376                         die("just how do you expect me to merge %d trees?", stage-1);
 377                 }
 378         }
 379         if (write_cache(newfd, active_cache, active_nr) || rename(lockfile, indexfile))
 380                 die("unable to write new index file");
 381         lockfile_name = NULL;
 382         return 0;
 383 }