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

diff --git a/ccan/tdb/tools/replay_trace.c b/ccan/tdb/tools/replay_trace.c
index baa56077..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,12 +321,39 @@ static void op_add_transaction(const char *filename, struct op op[],
 	op[op_num].group_len = 0;
 }
 
-static int op_transaction_start(struct op op[], unsigned int op_num)
+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;
 
 	for (i = op_num-1; i > 0; i--) {
-		if (op[i].op == OP_TDB_TRANSACTION_START && !op[i].group_len)
+		if (op[i].op == type && !op[i].group_len)
 			return i;
 	}
 	return 0;
@@ -342,7 +370,7 @@ static void op_analyze_transaction(const char *filename,
 	if (words[2])
 		fail(filename, op_num+1, "Expect no arguments");
 
-	start = op_transaction_start(op, op_num);
+	start = op_find_start(op, op_num, OP_TDB_TRANSACTION_START);
 	if (!start)
 		fail(filename, op_num+1, "no transaction start found");
 
@@ -353,10 +381,35 @@ static void op_analyze_transaction(const char *filename,
 		op[i].group_start = start;
 }
 
-struct traverse_hash {
-	TDB_DATA key;
-	unsigned int index;
-};
+/* 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,
@@ -374,23 +427,18 @@ static void op_analyze_traverse(const char *filename,
 	} else
 		op[op_num].ret = 0;
 
-	for (i = op_num-1; i >= 0; i--) {
-		if (op[i].op != OP_TDB_TRAVERSE_READ_START
-		    && op[i].op != OP_TDB_TRAVERSE_START)
-			continue;
-		if (op[i].group_len)
-			continue;
-		break;
-	}
-
-	if (i < 0)
+	start = op_find_start(op, op_num, OP_TDB_TRAVERSE_START);
+	if (!start)
+		start = op_find_start(op, op_num, OP_TDB_TRAVERSE_READ_START);
+	if (!start)
 		fail(filename, op_num+1, "no traversal start found");
 
-	start = i;
 	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: */
@@ -743,7 +791,7 @@ unsigned run_ops(struct tdb_context *tdb,
 static struct op *maybe_cancel_transaction(const char *filename,
 					   struct op *op, unsigned int *num)
 {
-	unsigned int start = op_transaction_start(op, *num);
+	unsigned int start = op_find_start(op, *num, OP_TDB_TRANSACTION_START);
 
 	if (start) {
 		char *words[] = { "<unknown>", "tdb_close", NULL };
@@ -904,22 +952,56 @@ static const TDB_DATA *needs(const struct op *op)
 	
 }
 
-static bool is_transaction(const struct op *op)
+static bool starts_transaction(const struct op *op)
 {
 	return op->op == OP_TDB_TRANSACTION_START;
 }
 
+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
+		|| op->op == OP_TDB_TRAVERSE_READ_START;
+}
+
+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 (is_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 */
@@ -945,22 +1027,6 @@ static const TDB_DATA *gives(const TDB_DATA *key, const TDB_DATA *pre,
 	return pre;
 }
 
-static bool in_transaction(const struct op op[], unsigned int i)
-{
-	return op[i].group_start && is_transaction(&op[op[i].group_start]);
-}
-
-static bool is_traverse(const struct op *op)
-{
-	return op->op == OP_TDB_TRAVERSE_START
-		|| op->op == OP_TDB_TRAVERSE_READ_START;
-}
-
-static bool in_traverse(const struct op op[], unsigned int i)
-{
-	return op[i].group_start && is_traverse(&op[op[i].group_start]);
-}
-
 static struct keyinfo *hash_ops(struct op *op[], unsigned int num_ops[],
 				unsigned int num)
 {
@@ -996,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. */
@@ -1023,7 +1090,7 @@ static bool satisfies(const TDB_DATA *key, const TDB_DATA *data,
 {
 	const TDB_DATA *need = NULL;
 
-	if (is_transaction(op)) {
+	if (starts_transaction(op) || starts_chainlock(op)) {
 		unsigned int i;
 
 		/* Look through for an op in this transaction which
@@ -1204,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. */
@@ -1252,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. */
@@ -1282,8 +1364,10 @@ static void add_dependency(void *ctx,
 	}
 #endif
 
- 	/* If you depend on a transaction, you actually depend on it ending. */
- 	if (is_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
@@ -1440,7 +1524,7 @@ static void make_traverse_depends(char *filename[],
  			/* Traverse start (ignore those in
 			 * transactions; they're already covered by
 			 * transaction dependencies). */
-			if (is_traverse(&op[i][j])
+			if (starts_traverse(&op[i][j])
 			    && !in_transaction(op[i], j)) {
 				dep = talloc_realloc(NULL, dep,
 						     struct traverse_dep,
@@ -1455,6 +1539,12 @@ static void make_traverse_depends(char *filename[],
 
 	for (i = 1; i < num_traversals; i++) {
 		const struct op *prev = &op[dep[i-1].file][dep[i-1].op_num];
+		const struct op *curr = &op[dep[i].file][dep[i].op_num];
+
+		/* Read traverses don't depend on each other (read lock). */
+		if (prev->op == OP_TDB_TRAVERSE_READ_START
+		    && curr->op == OP_TDB_TRAVERSE_READ_START)
+			continue;
 
 		/* Only make dependency if it's clear. */
 		if (compare_traverse_dep(&dep[i], &dep[i-1])) {