X-Git-Url: https://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Ftdb%2Ftools%2Freplay_trace.c;h=4afe900aa8e8317587e2f4eb0d84572d74fc221b;hb=699a8dde00df01e45c3d9a8fcc95687f342f7913;hp=0ca81aaa0386d29aba032162320045231fa9a1a0;hpb=a08f09dbdc69dafea90f8b67655e936cc6d2019a;p=ccan

diff --git a/ccan/tdb/tools/replay_trace.c b/ccan/tdb/tools/replay_trace.c
index 0ca81aaa..4afe900a 100644
--- a/ccan/tdb/tools/replay_trace.c
+++ b/ccan/tdb/tools/replay_trace.c
@@ -147,7 +147,8 @@ struct op {
 			TDB_DATA pre;
 			TDB_DATA post;
 		} append;
-		unsigned int group_len; /* transaction/traverse start */
+		/* transaction/traverse start/chainlock */
+		unsigned int group_len;
 	};
 };
 
@@ -320,6 +321,33 @@ static void op_add_transaction(const char *filename, struct op op[],
 	op[op_num].group_len = 0;
 }
 
+static void op_add_chainlock(const char *filename,
+			     struct op op[], unsigned int op_num, char *words[])
+{
+	if (words[2] == NULL || words[3])
+		fail(filename, op_num+1, "Expected just a key");
+
+	/* A chainlock key isn't a key in the normal sense; it doesn't
+	 * have to be in the db at all.  Also, we don't want to hash this op. */
+	op[op_num].data = make_tdb_data(op, filename, op_num+1, words[2]);
+	op[op_num].key = tdb_null;
+	op[op_num].group_len = 0;
+}
+
+static void op_add_chainlock_ret(const char *filename,
+				 struct op op[], unsigned int op_num,
+				 char *words[])
+{
+	if (!words[2] || !words[3] || !words[4] || words[5]
+	    || !streq(words[3], "="))
+		fail(filename, op_num+1, "Expected <key> = <ret>");
+	op[op_num].ret = atoi(words[4]);
+	op[op_num].data = make_tdb_data(op, filename, op_num+1, words[2]);
+	op[op_num].key = tdb_null;
+	op[op_num].group_len = 0;
+	total_keys++;
+}
+
 static int op_find_start(struct op op[], unsigned int op_num, enum op_type type)
 {
 	unsigned int i;
@@ -353,6 +381,36 @@ static void op_analyze_transaction(const char *filename,
 		op[i].group_start = start;
 }
 
+/* We treat chainlocks a lot like transactions, even though that's overkill */
+static void op_analyze_chainlock(const char *filename,
+				 struct op op[], unsigned int op_num,
+				 char *words[])
+{
+	unsigned int i, start;
+
+	if (words[2] == NULL || words[3])
+		fail(filename, op_num+1, "Expected just a key");
+
+	op[op_num].data = make_tdb_data(op, filename, op_num+1, words[2]);
+	op[op_num].key = tdb_null;
+	total_keys++;
+
+	start = op_find_start(op, op_num, OP_TDB_CHAINLOCK);
+	if (!start)
+		start = op_find_start(op, op_num, OP_TDB_CHAINLOCK_READ);
+	if (!start)
+		fail(filename, op_num+1, "no initial chainlock found");
+
+	/* FIXME: We'd have to do something clever to make this work
+	 * vs. deadlock. */
+	if (!key_eq(op[start].data, op[op_num].data))
+		fail(filename, op_num+1, "nested chainlock calls?");
+
+	op[start].group_len = op_num - start;
+	for (i = start; i <= op_num; i++)
+		op[i].group_start = start;
+}
+
 static void op_analyze_traverse(const char *filename,
 				struct op op[], unsigned int op_num,
 				char *words[])
@@ -377,8 +435,10 @@ static void op_analyze_traverse(const char *filename,
 
 	op[start].group_len = op_num - start;
 
+	/* Don't roll in nested traverse/chainlock */
 	for (i = start; i <= op_num; i++)
-		op[i].group_start = start;
+		if (!op[i].group_start)
+			op[i].group_start = start;
 }
 
 /* Keep -Wmissing-declarations happy: */
@@ -902,6 +962,12 @@ static bool in_transaction(const struct op op[], unsigned int i)
 	return op[i].group_start && starts_transaction(&op[op[i].group_start]);
 }
 
+static bool successful_transaction(const struct op *op)
+{
+	return starts_transaction(op)
+		&& op[op->group_len].op == OP_TDB_TRANSACTION_COMMIT;
+}
+
 static bool starts_traverse(const struct op *op)
 {
 	return op->op == OP_TDB_TRAVERSE_START
@@ -913,17 +979,29 @@ static bool in_traverse(const struct op op[], unsigned int i)
 	return op[i].group_start && starts_traverse(&op[op[i].group_start]);
 }
 
+static bool starts_chainlock(const struct op *op)
+{
+	return op->op == OP_TDB_CHAINLOCK_READ || op->op == OP_TDB_CHAINLOCK;
+}
+
+static bool in_chainlock(const struct op op[], unsigned int i)
+{
+	return op[i].group_start && starts_chainlock(&op[op[i].group_start]);
+}
+
 /* What's the data after this op?  pre if nothing changed. */
 static const TDB_DATA *gives(const TDB_DATA *key, const TDB_DATA *pre,
 			     const struct op *op)
 {
-	if (starts_transaction(op)) {
+	if (starts_transaction(op) || starts_chainlock(op)) {
 		unsigned int i;
 
 		/* Cancelled transactions don't change anything. */
 		if (op[op->group_len].op == OP_TDB_TRANSACTION_CANCEL)
 			return pre;
-		assert(op[op->group_len].op == OP_TDB_TRANSACTION_COMMIT);
+		assert(op[op->group_len].op == OP_TDB_TRANSACTION_COMMIT
+		       || op[op->group_len].op == OP_TDB_CHAINUNLOCK_READ
+		       || op[op->group_len].op == OP_TDB_CHAINUNLOCK);
 
 		for (i = 1; i < op->group_len; i++) {
 			/* This skips nested transactions, too */
@@ -984,7 +1062,8 @@ static struct keyinfo *hash_ops(struct op *op[], unsigned int num_ops[],
 
 			/* If it's in a transaction, it's the transaction which
 			 * matters from an analysis POV. */
-			if (in_transaction(op[i], j)) {
+			if (in_transaction(op[i], j)
+			    || in_chainlock(op[i], j)) {
 				unsigned start = op[i][j].group_start;
 
 				/* Don't include twice. */
@@ -1011,7 +1090,7 @@ static bool satisfies(const TDB_DATA *key, const TDB_DATA *data,
 {
 	const TDB_DATA *need = NULL;
 
-	if (starts_transaction(op)) {
+	if (starts_transaction(op) || starts_chainlock(op)) {
 		unsigned int i;
 
 		/* Look through for an op in this transaction which
@@ -1192,8 +1271,21 @@ static void sort_ops(struct keyinfo hash[], char *filename[], struct op *op[],
 			return a->op_num - b->op_num;
 
 		/* Otherwise, arrange by serial order. */
-		return op[a->file][a->op_num].serial
-			- op[b->file][b->op_num].serial;
+		if (op[a->file][a->op_num].serial !=
+		    op[b->file][b->op_num].serial)
+			return op[a->file][a->op_num].serial
+				- op[b->file][b->op_num].serial;
+
+		/* Cancelled transactions are assumed to happen first. */
+		if (starts_transaction(&op[a->file][a->op_num])
+		    && !successful_transaction(&op[a->file][a->op_num]))
+			return -1;
+		if (starts_transaction(&op[b->file][b->op_num])
+		    && !successful_transaction(&op[b->file][b->op_num]))
+			return 1;
+
+		/* No idea. */
+		return 0;
 	}
 
 	/* Now sort into serial order. */
@@ -1240,9 +1332,11 @@ static void add_dependency(void *ctx,
 	 * traverse/transaction, it creates a dependency between the
 	 * two groups. */
 	if ((in_traverse(op[satisfies_file], satisfies_opnum)
-	     && op[needs_file][needs_opnum].group_start)
+	     && (starts_transaction(&op[needs_file][needs_opnum])
+		 || starts_traverse(&op[needs_file][needs_opnum])))
 	    || (in_traverse(op[needs_file], needs_opnum)
-		&& op[satisfies_file][satisfies_opnum].group_start)) {
+		&& (starts_transaction(&op[satisfies_file][satisfies_opnum])
+		    || starts_traverse(&op[satisfies_file][satisfies_opnum])))){
 		unsigned int sat;
 
 		/* We are satisfied by end of group. */
@@ -1270,8 +1364,10 @@ static void add_dependency(void *ctx,
 	}
 #endif
 
- 	/* If you depend on a transaction, you actually depend on it ending. */
- 	if (starts_transaction(&op[satisfies_file][satisfies_opnum])) {
+ 	/* If you depend on a transaction or chainlock, you actually
+	 * depend on it ending. */
+ 	if (starts_transaction(&op[satisfies_file][satisfies_opnum])
+	    || starts_chainlock(&op[satisfies_file][satisfies_opnum])) {
  		satisfies_opnum
  			+= op[satisfies_file][satisfies_opnum].group_len;
 #if DEBUG_DEPS