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  * Two-way merge.
 185  *
 186  * The rule is:
 187  *  - every current entry has to match the old tree
 188  *  - if the current entry matches the new tree, we leave it
 189  *    as-is. Otherwise we require that it be up-to-date.
 190  */
 191 static void twoway_merge(struct cache_entry **src, int nr)
 192 {
 193         static struct cache_entry null_entry;
 194         struct cache_entry *old = NULL, *stat = &null_entry;
 195         struct cache_entry **dst = src;
 196
 197         while (nr--) {
 198                 struct cache_entry *ce = *src++;
 199                 int stage = ce_stage(ce);
 200
 201                 switch (stage) {
 202                 case 0:
 203                         if (old)
 204                                 reject_merge(old);
 205                         old = ce;
 206                         stat = ce;
 207                         active_nr--;
 208                         continue;
 209
 210                 case 1:
 211                         active_nr--;
 212                         if (!old)
 213                                 continue;
 214                         if (!path_matches(old, ce) || !same(old, ce))
 215                                 reject_merge(old);
 216                         continue;
 217
 218                 case 2:
 219                         ce->ce_flags |= htons(CE_UPDATE);
 220                         if (old) {
 221                                 if (!path_matches(old, ce))
 222                                         reject_merge(old);
 223                                 /*
 224                                  * This also removes the UPDATE flag on
 225                                  * a match
 226                                  */
 227                                 if (same(old, ce))
 228                                         *ce = *old;
 229                                 else
 230                                         verify_uptodate(old);
 231                                 old = NULL;
 232                         }
 233                         ce->ce_flags &= ~htons(CE_STAGEMASK);
 234                         *dst++ = ce;
 235                         continue;
 236                 }
 237                 die("impossible two-way stage");
 238         }
 239         if (old)
 240                 reject_merge(old);
 241 }
 242
 243 static void merge_stat_info(struct cache_entry **src, int nr)
 244 {
 245         static struct cache_entry null_entry;
 246         struct cache_entry **dst = src;
 247         struct cache_entry *stat = &null_entry;
 248
 249         while (nr--) {
 250                 struct cache_entry *ce = *src++;
 251
 252                 /* We throw away original cache entries except for the stat information */
 253                 if (!ce_stage(ce)) {
 254                         stat = ce;
 255                         active_nr--;
 256                         continue;
 257                 }
 258                 if (path_matches(ce, stat) && same(ce, stat))
 259                         *ce = *stat;
 260                 ce->ce_flags &= ~htons(CE_STAGEMASK);
 261                 *dst++ = ce;
 262         }
 263 }
 264
 265 static void check_updates(struct cache_entry **src, int nr)
 266 {
 267         static struct checkout state = {
 268                 .base_dir = "",
 269                 .force = 1,
 270                 .quiet = 1,
 271                 .refresh_cache = 1,
 272         };
 273         unsigned short mask = htons(CE_UPDATE);
 274         while (nr--) {
 275                 struct cache_entry *ce = *src++;
 276                 if (ce->ce_flags & mask) {
 277                         ce->ce_flags &= ~mask;
 278                         if (update)
 279                                 checkout_entry(ce, &state);
 280                 }
 281         }
 282 }
 283
 284 static char *read_tree_usage = "git-read-tree (<sha> | -m <sha1> [<sha2> [<sha3>]])";
 285
 286 int main(int argc, char **argv)
 287 {
 288         int i, newfd, merge;
 289         unsigned char sha1[20];
 290         static char lockfile[MAXPATHLEN+1];
 291         const char *indexfile = get_index_file();
 292
 293         snprintf(lockfile, sizeof(lockfile), "%s.lock", indexfile);
 294
 295         newfd = open(lockfile, O_RDWR | O_CREAT | O_EXCL, 0600);
 296         if (newfd < 0)
 297                 die("unable to create new cachefile");
 298         atexit(remove_lock_file);
 299         lockfile_name = lockfile;
 300
 301         merge = 0;
 302         for (i = 1; i < argc; i++) {
 303                 const char *arg = argv[i];
 304
 305                 /* "-u" means "update", meaning that a merge will update the working directory */
 306                 if (!strcmp(arg, "-u")) {
 307                         update = 1;
 308                         continue;
 309                 }
 310
 311                 /* "-m" stands for "merge", meaning we start in stage 1 */
 312                 if (!strcmp(arg, "-m")) {
 313                         int i;
 314                         if (stage)
 315                                 die("-m needs to come first");
 316                         read_cache();
 317                         for (i = 0; i < active_nr; i++) {
 318                                 if (ce_stage(active_cache[i]))
 319                                         die("you need to resolve your current index first");
 320                         }
 321                         stage = 1;
 322                         merge = 1;
 323                         continue;
 324                 }
 325                 if (get_sha1(arg, sha1) < 0)
 326                         usage(read_tree_usage);
 327                 if (stage > 3)
 328                         usage(read_tree_usage);
 329                 if (unpack_tree(sha1) < 0)
 330                         die("failed to unpack tree object %s", arg);
 331                 stage++;
 332         }
 333         if (merge) {
 334                 switch (stage) {
 335                 case 4: /* Three-way merge */
 336                         trivially_merge_cache(active_cache, active_nr);
 337                         check_updates(active_cache, active_nr);
 338                         break;
 339                 case 3: /* Update from one tree to another */
 340                         twoway_merge(active_cache, active_nr);
 341                         check_updates(active_cache, active_nr);
 342                         break;
 343                 case 2: /* Just read a tree, merge with old cache contents */
 344                         merge_stat_info(active_cache, active_nr);
 345                         break;
 346                 default:
 347                         die("just how do you expect me to merge %d trees?", stage-1);
 348                 }
 349         }
 350         if (write_cache(newfd, active_cache, active_nr) || rename(lockfile, indexfile))
 351                 die("unable to write new index file");
 352         lockfile_name = NULL;
 353         return 0;
 354 }