@matheusbsbs / matheus-bagliano / commits / 3f061bf514

lockfile: LOCK_REPORT_ON_ERROR

The "libify sequencer" topic stopped passing the die_on_error option to hold_locked_index(), and this lost an error message from "git merge --ff-only $commit" when there are competing updates in progress. The command still exits with a non-zero status, but that is not of much help for an interactive user. The last thing the command says is "Updating $from..$to". We used to follow it with a big error message that makes it clear that "merge --ff-only" did not succeed. What is sad is that we should have noticed this regression while reviewing the change. It was clear that the update to the checkout_fast_forward() function made a failing hold_locked_index() silent, but the only caller of the checkout_fast_forward() function had this comment: if (checkout_fast_forward(from, to, 1)) - exit(128); /* the callee should have complained already */ + return -1; /* the callee should have complained already */ which clearly contradicted the assumption X-<. Add a new option LOCK_REPORT_ON_ERROR that can be passed instead of LOCK_DIE_ON_ERROR to the hold_lock*() family of functions and teach checkout_fast_forward() to use it to fix this regression. After going thourgh all calls to hold_lock*() family of functions that used to pass LOCK_DIE_ON_ERROR but were modified to pass 0 in the "libify sequencer" topic "git show --first-parent 2a4062a4a8", it appears that this is the only one that has become silent. Many others used to give detailed report that talked about "there may be competing Git process running" but with the series merged they now only give a single liner "Unable to lock ...", some of which may have to be tweaked further, but at least they say something, unlike the one this patch fixes. Reported-by: Robbie Iannucci <iannucci@google.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Junio C Hamano committed Dec 7, 2016 at 10:56 UTC 3f061bf514667497a948804828064b9b9c3b249b

3 files changed +18 -4

lockfile.c

+10 -2

@@ -174,8 +174,16 @@ int hold_lock_file_for_update_timeout(struct lock_file *lk, const char *path,

174 int flags, long timeout_ms)

175 {

176 int fd = lock_file_timeout(lk, path, flags, timeout_ms);

177 - if (fd < 0 && (flags & LOCK_DIE_ON_ERROR))

178 - unable_to_lock_die(path, errno);

177 + if (fd < 0) {

178 + if (flags & LOCK_DIE_ON_ERROR)

179 + unable_to_lock_die(path, errno);

180 + if (flags & LOCK_REPORT_ON_ERROR) {

181 + struct strbuf buf = STRBUF_INIT;

182 + unable_to_lock_message(path, errno, &buf);

183 + error("%s", buf.buf);

184 + strbuf_release(&buf);

185 + }

186 + }

187 return fd;

188 }

189

lockfile.h

+7 -1

@@ -129,10 +129,16 @@ struct lock_file {

129 /*

130 * If a lock is already taken for the file, `die()` with an error

131 * message. If this flag is not specified, trying to lock a file that

132 - * is already locked returns -1 to the caller.

132 + * is already locked silently returns -1 to the caller, or ...

133 */

134 #define LOCK_DIE_ON_ERROR 1

135

136 +/*

137 + * ... this flag can be passed instead to return -1 and give the usual

138 + * error message upon an error.

139 + */

140 +#define LOCK_REPORT_ON_ERROR 2

141 +

142 /*

143 * Usually symbolic links in the destination path are resolved. This

144 * means that (1) the lockfile is created by adding ".lock" to the

merge.c

+1 -1

@@ -57,7 +57,7 @@ int checkout_fast_forward(const unsigned char *head,

58 refresh_cache(REFRESH_QUIET);

60 - if (hold_locked_index(lock_file, 0) < 0)

60 + if (hold_locked_index(lock_file, LOCK_REPORT_ON_ERROR) < 0)

61 return -1;

63 memset(&trees, 0, sizeof(trees));