lightningd: keep closed channels in memory.

They're small, and this will allow us to efficiently respond to reestablish on them.

Signed-off-by: Rusty Russell <[email protected]>

Author: rustyrussell

lightningd/channel.c

@@ -99,6 +99,8 @@ void delete_channel(struct channel *channel STEALS, bool completely_eliminate)
 		/* Never open at all, not ours. */
 		if (completely_eliminate)
 			wallet_channel_delete(ld->wallet, channel);
+		else
+			wallet_load_one_closed_channel(ld->wallet, ld->closed_channels, channel->dbid);
 	}
 
 	/* Tell the hsm to forget the channel, needs to be after it's

lightningd/closed_channel.c

@@ -10,6 +10,11 @@
 #include <lightningd/peer_control.h>
 #include <wallet/wallet.h>
 
+size_t hash_cid(const struct channel_id *cid)
+{
+	return siphash24(siphash_seed(), cid->id, sizeof(cid->id));
+}
+
 static void json_add_closed_channel(struct json_stream *response,
 				    const char *fieldname,
 				    const struct closed_channel *channel)
@@ -90,7 +95,8 @@ static struct command_result *json_listclosedchannels(struct command *cmd,
 {
 	struct node_id *peer_id;
 	struct json_stream *response;
-	struct closed_channel **chans;
+	struct closed_channel *cc;
+	struct closed_channel_map_iter it;
 
 	if (!param(cmd, buffer, params,
 		   p_opt("id", param_node_id, &peer_id),
@@ -100,15 +106,16 @@ static struct command_result *json_listclosedchannels(struct command *cmd,
 	response = json_stream_success(cmd);
 	json_array_start(response, "closedchannels");
 
-	chans = wallet_load_closed_channels(cmd, cmd->ld->wallet);
-	for (size_t i = 0; i < tal_count(chans); i++) {
+	for (cc = closed_channel_map_first(cmd->ld->closed_channels, &it);
+	     cc;
+	     cc = closed_channel_map_next(cmd->ld->closed_channels, &it)) {
 		if (peer_id) {
-			if (!chans[i]->peer_id)
+			if (!cc->peer_id)
 				continue;
-			if (!node_id_eq(chans[i]->peer_id, peer_id))
+			if (!node_id_eq(cc->peer_id, peer_id))
 				continue;
 		}
-		json_add_closed_channel(response, NULL, chans[i]);
+		json_add_closed_channel(response, NULL, cc);
 	}
 	json_array_end(response);
 

lightningd/closed_channel.h

@@ -30,4 +30,19 @@ struct closed_channel {
 	u64 last_stable_connection;
 };
 
+static inline const struct channel_id *keyof_closed_channel(const struct closed_channel *cc)
+{
+	return &cc->cid;
+}
+
+size_t hash_cid(const struct channel_id *cid);
+
+static inline bool closed_channel_eq_cid(const struct closed_channel *cc, const struct channel_id *cid)
+{
+	return channel_id_eq(cid, &cc->cid);
+}
+
+HTABLE_DEFINE_NODUPS_TYPE(struct closed_channel, keyof_closed_channel, hash_cid, closed_channel_eq_cid,
+			  closed_channel_map);
+
 #endif /* LIGHTNING_LIGHTNINGD_CLOSED_CHANNEL_H */

lightningd/lightningd.c

@@ -67,6 +67,7 @@
 #include <lightningd/channel.h>
 #include <lightningd/channel_control.h>
 #include <lightningd/channel_gossip.h>
+#include <lightningd/closed_channel.h>
 #include <lightningd/coin_mvts.h>
 #include <lightningd/connect_control.h>
 #include <lightningd/gossip_control.h>
@@ -212,6 +213,11 @@ static struct lightningd *new_lightningd(const tal_t *ctx)
 	ld->htlc_sets = tal(ld, struct htlc_set_map);
 	htlc_set_map_init(ld->htlc_sets);
 
+	/*~ We keep a map of closed channels.  Mainly so we can respond to peers
+	 * who talk to us about long-closed channels. */
+	ld->closed_channels = tal(ld, struct closed_channel_map);
+	closed_channel_map_init(ld->closed_channels);
+
 	/*~ We have a multi-entry log-book infrastructure: we define a 10MB log
 	 * book to hold all the entries (and trims as necessary), and multiple
 	 * log objects which each can write into it, each with a unique

lightningd/lightningd.h

@@ -280,6 +280,9 @@ struct lightningd {
 	/* Contains the codex32 string used with --recover flag */
 	char *recover;
 
+	/* Any channels which are already closed */
+	struct closed_channel_map *closed_channels;
+
 	/* 2, unless overridden by --dev-fd-limit-multiplier */
 	u32 fd_limit_multiplier;
 

lightningd/memdump.c

@@ -11,6 +11,7 @@
 #include <gossipd/gossipd_wiregen.h>
 #include <hsmd/hsmd_wiregen.h>
 #include <lightningd/chaintopology.h>
+#include <lightningd/closed_channel.h>
 #include <lightningd/hsm_control.h>
 #include <lightningd/jsonrpc.h>
 #include <lightningd/lightningd.h>
@@ -201,6 +202,7 @@ static bool lightningd_check_leaks(struct command *cmd)
 	memleak_scan_htable(memtable, &ld->htlc_sets->raw);
 	memleak_scan_htable(memtable, &ld->peers->raw);
 	memleak_scan_htable(memtable, &ld->peers_by_dbid->raw);
+	memleak_scan_htable(memtable, &ld->closed_channels->raw);
 	wallet_memleak_scan(memtable, ld->wallet);
 
 	/* Now delete ld and those which it has pointers to. */

lightningd/test/run-find_my_abspath.c

@@ -120,6 +120,9 @@ void handle_early_opts(struct lightningd *ld UNNEEDED, int argc UNNEEDED, char *
 /* Generated stub for handle_opts */
 void handle_opts(struct lightningd *ld UNNEEDED)
 { fprintf(stderr, "handle_opts called!\n"); abort(); }
+/* Generated stub for hash_cid */
+size_t hash_cid(const struct channel_id *cid UNNEEDED)
+{ fprintf(stderr, "hash_cid called!\n"); abort(); }
 /* Generated stub for hash_htlc_key */
 size_t hash_htlc_key(const struct htlc_key *htlc_key UNNEEDED)
 { fprintf(stderr, "hash_htlc_key called!\n"); abort(); }

wallet/test/run-db.c

@@ -112,6 +112,9 @@ void get_channel_basepoints(struct lightningd *ld UNNEEDED,
 			    struct basepoints *local_basepoints UNNEEDED,
 			    struct pubkey *local_funding_pubkey UNNEEDED)
 { fprintf(stderr, "get_channel_basepoints called!\n"); abort(); }
+/* Generated stub for hash_cid */
+size_t hash_cid(const struct channel_id *cid UNNEEDED)
+{ fprintf(stderr, "hash_cid called!\n"); abort(); }
 /* Generated stub for htlc_in_check */
 struct htlc_in *htlc_in_check(const struct htlc_in *hin UNNEEDED, const char *abortstr UNNEEDED)
 { fprintf(stderr, "htlc_in_check called!\n"); abort(); }
@@ -285,8 +288,7 @@ struct peer *new_peer(struct lightningd *ld UNNEEDED, u64 dbid UNNEEDED,
 		      bool connected_incoming UNNEEDED)
 { fprintf(stderr, "new_peer called!\n"); abort(); }
 /* Generated stub for notify_chain_mvt */
-void notify_chain_mvt(struct lightningd *ld UNNEEDED,
-		      const struct chain_coin_mvt *chain_mvt UNNEEDED)
+void notify_chain_mvt(struct lightningd *ld UNNEEDED, const struct chain_coin_mvt *mvt UNNEEDED)
 { fprintf(stderr, "notify_chain_mvt called!\n"); abort(); }
 /* Generated stub for notify_forward_event */
 void notify_forward_event(struct lightningd *ld UNNEEDED,

wallet/test/run-wallet.c

@@ -380,6 +380,9 @@ u32 get_block_height(const struct chain_topology *topo UNNEEDED)
 /* Generated stub for get_network_blockheight */
 u32 get_network_blockheight(const struct chain_topology *topo UNNEEDED)
 { fprintf(stderr, "get_network_blockheight called!\n"); abort(); }
+/* Generated stub for hash_cid */
+size_t hash_cid(const struct channel_id *cid UNNEEDED)
+{ fprintf(stderr, "hash_cid called!\n"); abort(); }
 /* Generated stub for hsmd_wire_name */
 const char *hsmd_wire_name(int e UNNEEDED)
 { fprintf(stderr, "hsmd_wire_name called!\n"); abort(); }
@@ -701,12 +704,10 @@ struct uncommitted_channel *new_uncommitted_channel(struct peer *peer UNNEEDED)
 bool node_announcement_same(const u8 *nann1 UNNEEDED, const u8 *nann2 UNNEEDED)
 { fprintf(stderr, "node_announcement_same called!\n"); abort(); }
 /* Generated stub for notify_chain_mvt */
-void notify_chain_mvt(struct lightningd *ld UNNEEDED,
-		      const struct chain_coin_mvt *chain_mvt UNNEEDED)
+void notify_chain_mvt(struct lightningd *ld UNNEEDED, const struct chain_coin_mvt *mvt UNNEEDED)
 { fprintf(stderr, "notify_chain_mvt called!\n"); abort(); }
 /* Generated stub for notify_channel_mvt */
-void notify_channel_mvt(struct lightningd *ld UNNEEDED,
-			const struct channel_coin_mvt *chan_mvt UNNEEDED)
+void notify_channel_mvt(struct lightningd *ld UNNEEDED, const struct channel_coin_mvt *mvt UNNEEDED)
 { fprintf(stderr, "notify_channel_mvt called!\n"); abort(); }
 /* Generated stub for notify_channel_open_failed */
 void notify_channel_open_failed(struct lightningd *ld UNNEEDED,
@@ -2118,7 +2119,7 @@ static bool test_channel_inflight_crud(struct lightningd *ld, const tal_t *ctx)
 
 	/* do inflights get cleared when the channel is closed?*/
 	dbid = chan->dbid;
-	delete_channel(chan, false); /* Also clears up peer! */
+	delete_channel(chan, true); /* Also clears up peer! */
 	CHECK_MSG(count_inflights(w, dbid) == 0, "inflights cleaned up");
 	db_commit_transaction(w->db);
 	CHECK_MSG(!wallet_err, wallet_err);
@@ -2364,6 +2365,8 @@ int main(int argc, const char *argv[])
 	ld->htlcs_out = tal(ld, struct htlc_out_map);
 	htlc_out_map_init(ld->htlcs_out);
 	list_head_init(&ld->wait_commands);
+	ld->closed_channels = tal(ld, struct closed_channel_map);
+	closed_channel_map_init(ld->closed_channels);
 
 	/* We do a runtime test here, so we still check compile! */
 	if (HAVE_SQLITE3) {

wallet/wallet.c

@@ -2069,11 +2069,10 @@ static struct closed_channel *wallet_stmt2closed_channel(const tal_t *ctx,
 	return cc;
 }
 
-struct closed_channel **wallet_load_closed_channels(const tal_t *ctx,
-						    struct wallet *w)
+void wallet_load_closed_channels(struct wallet *w,
+				 struct closed_channel_map *cc_map)
 {
 	struct db_stmt *stmt;
-	struct closed_channel **chans = tal_arr(ctx, struct closed_channel *, 0);
 
 	/* We load all channels */
 	stmt = db_prepare_v2(w->db, SQL("SELECT "
@@ -2107,12 +2106,53 @@ struct closed_channel **wallet_load_closed_channels(const tal_t *ctx,
 	db_query_prepared(stmt);
 
 	while (db_step(stmt)) {
-		struct closed_channel *cc = wallet_stmt2closed_channel(chans,
+		struct closed_channel *cc = wallet_stmt2closed_channel(cc_map,
 								       w, stmt);
-		tal_arr_expand(&chans, cc);
+		closed_channel_map_add(cc_map, cc);
 	}
 	tal_free(stmt);
-	return chans;
+}
+
+void wallet_load_one_closed_channel(struct wallet *w,
+				    struct closed_channel_map *cc_map,
+				    u64 wallet_id)
+{
+	struct db_stmt *stmt;
+
+	stmt = db_prepare_v2(w->db, SQL("SELECT "
+					" p.node_id"
+					", full_channel_id"
+					", scid"
+					", alias_local"
+					", alias_remote"
+					", funder"
+					", closer"
+					", channel_flags"
+					", next_index_local"
+					", next_index_remote"
+					", next_htlc_id"
+					", funding_tx_id"
+					", funding_tx_outnum"
+					", funding_satoshi"
+					", push_msatoshi"
+					", msatoshi_local"
+					", msatoshi_to_us_min"
+					", msatoshi_to_us_max"
+					", last_tx"
+					", channel_type"
+					", state_change_reason"
+					", lease_commit_sig"
+					", last_stable_connection"
+					" FROM channels"
+					" LEFT JOIN peers p ON p.id = peer_id"
+                                        " WHERE channels.id = ?;"));
+	db_bind_u64(stmt, wallet_id);
+	db_query_prepared(stmt);
+
+	db_step(stmt);
+	closed_channel_map_add(cc_map,
+			       wallet_stmt2closed_channel(cc_map, w, stmt));
+	tal_free(stmt);
 }
 
 static void set_max_channel_dbid(struct wallet *w)

wallet/wallet.h

@@ -21,6 +21,7 @@ struct amount_msat;
 struct invoices;
 struct channel;
 struct channel_inflight;
+struct closed_channel_map;
 struct htlc_in;
 struct htlc_in_map;
 struct htlc_out;
@@ -733,13 +734,25 @@ bool wallet_init_channels(struct wallet *w);
 
 /**
  * wallet_load_closed_channels -- Loads dead channels.
- * @ctx: context to allocate returned array from
  * @w: wallet to load from
+ * @cc_map: the map to fill
  *
  * These will be all state CLOSED.
  */
-struct closed_channel **wallet_load_closed_channels(const tal_t *ctx,
-						    struct wallet *w);
+void wallet_load_closed_channels(struct wallet *w,
+				 struct closed_channel_map *cc_map);
+
+/**
+ * wallet_load_one_closed_channel -- Loads one single (just-closed) channel.
+ * @w: wallet to load from
+ * @cc_map: the map to fill
+ * @wallet_id: the id of the channel.
+ *
+ * Must be newly closed via wallet_channel_close().
+ */
+void wallet_load_one_closed_channel(struct wallet *w,
+				    struct closed_channel_map *cc_map,
+				    u64 wallet_id);
 
 /**
  * wallet_channel_stats_incr_* - Increase channel statistics.