Line data Source code
1 : #include "config_parse.h"
2 :
3 : FD_IMPORT_BINARY( fdctl_default_config, "src/app/fdctl/config/default.toml" );
4 : FD_IMPORT_BINARY( fdctl_default_firedancer_config, "src/app/fdctl/config/default-firedancer.toml" );
5 :
6 : /* Pod query utils ****************************************************/
7 :
8 : static int
9 : fdctl_cfg_get_cstr_( char * out,
10 : ulong out_sz,
11 : fd_pod_info_t const * info,
12 102 : char const * path ) {
13 102 : if( FD_UNLIKELY( info->val_type != FD_POD_VAL_TYPE_CSTR ) ) {
14 0 : FD_LOG_WARNING(( "invalid value for `%s`", path ));
15 0 : return 0;
16 0 : }
17 102 : char const * str = info->val;
18 102 : ulong sz = strlen( str ) + 1;
19 102 : if( FD_UNLIKELY( sz > out_sz ) ) {
20 0 : FD_LOG_WARNING(( "`%s`: too long (max %ld)", path, (long)out_sz-1L ));
21 0 : return 0;
22 0 : }
23 102 : fd_memcpy( out, str, sz );
24 102 : return 1;
25 102 : }
26 :
27 : #define fdctl_cfg_get_cstr( out, out_sz, info, path ) \
28 0 : fdctl_cfg_get_cstr_( *out, out_sz, info, path )
29 :
30 : static int
31 : fdctl_cfg_get_ulong( ulong * out,
32 : ulong out_sz FD_PARAM_UNUSED,
33 : fd_pod_info_t const * info,
34 132 : char const * path ) {
35 :
36 132 : ulong num;
37 132 : switch( info->val_type ) {
38 132 : case FD_POD_VAL_TYPE_LONG:
39 132 : fd_ulong_svw_dec( (uchar const *)info->val, &num );
40 132 : long snum = fd_long_zz_dec( num );
41 132 : if( snum < 0L ) {
42 0 : FD_LOG_WARNING(( "`%s` cannot be negative", path ));
43 0 : return 0;
44 0 : }
45 132 : num = (ulong)snum;
46 132 : break;
47 0 : case FD_POD_VAL_TYPE_ULONG:
48 0 : fd_ulong_svw_dec( (uchar const *)info->val, &num );
49 0 : break;
50 0 : default:
51 0 : FD_LOG_WARNING(( "invalid value for `%s`", path ));
52 0 : return 0;
53 132 : }
54 :
55 132 : *out = num;
56 132 : return 1;
57 132 : }
58 :
59 : static int
60 : fdctl_cfg_get_uint( uint * out,
61 : ulong out_sz FD_PARAM_UNUSED,
62 : fd_pod_info_t const * info,
63 87 : char const * path ) {
64 87 : ulong num;
65 87 : if( FD_UNLIKELY( !fdctl_cfg_get_ulong( &num, sizeof(num), info, path ) ) ) return 0;
66 87 : if( num > UINT_MAX ) {
67 0 : FD_LOG_WARNING(( "`%s` is out of bounds (%lx)", path, num ));
68 0 : return 0;
69 0 : }
70 87 : *out = (uint)num;
71 87 : return 1;
72 87 : }
73 :
74 : static int
75 : fdctl_cfg_get_ushort( ushort * out,
76 : ulong out_sz FD_PARAM_UNUSED,
77 : fd_pod_info_t const * info,
78 24 : char const * path ) {
79 24 : ulong num;
80 24 : if( FD_UNLIKELY( !fdctl_cfg_get_ulong( &num, sizeof(num), info, path ) ) ) return 0;
81 24 : if( num > USHORT_MAX ) {
82 0 : FD_LOG_WARNING(( "`%s` is out of bounds (%lx)", path, num ));
83 0 : return 0;
84 0 : }
85 24 : *out = (ushort)num;
86 24 : return 1;
87 24 : }
88 :
89 : static int
90 : fdctl_cfg_get_bool( int * out,
91 : ulong out_sz FD_PARAM_UNUSED,
92 : fd_pod_info_t const * info,
93 90 : char const * path ) {
94 90 : if( FD_UNLIKELY( info->val_type != FD_POD_VAL_TYPE_INT ) ) {
95 0 : FD_LOG_WARNING(( "invalid value for `%s`", path ));
96 0 : return 0;
97 0 : }
98 90 : ulong u; fd_ulong_svw_dec( (uchar const *)info->val, &u );
99 90 : *out = (int)u;
100 90 : return 1;
101 90 : }
102 :
103 : /* Find leftover ******************************************************/
104 :
105 : /* fdctl_pod_find_leftover recursively searches for non-subpod keys in
106 : pod. Prints to the warning log if it finds any. Used to detect
107 : config keys that were not recognized by fdctl. Returns 0 if no
108 : leftover key was found. Otherwise, returns a non-zero number of
109 : segments of the leftover key. The key can be reassembled by joining
110 : stack[0] .. stack[depth-1].
111 :
112 : Not thread safe (uses global buffer). */
113 :
114 0 : # define FDCTL_CFG_MAX_DEPTH (16)
115 :
116 : static ulong
117 : fdctl_pod_find_leftover_recurse( uchar * pod,
118 : char const ** stack,
119 78 : ulong depth ) {
120 :
121 78 : if( FD_UNLIKELY( depth+1 >= FDCTL_CFG_MAX_DEPTH ) ) {
122 0 : FD_LOG_WARNING(( "configuration file has too many nested keys" ));
123 0 : return depth;
124 0 : }
125 :
126 153 : for( fd_pod_iter_t iter = fd_pod_iter_init( pod ); !fd_pod_iter_done( iter ); iter = fd_pod_iter_next( iter ) ) {
127 75 : fd_pod_info_t info = fd_pod_iter_info( iter );
128 75 : stack[ depth ] = info.key;
129 75 : depth++;
130 75 : if( FD_LIKELY( info.val_type == FD_POD_VAL_TYPE_SUBPOD ) ) {
131 75 : ulong sub_depth = fdctl_pod_find_leftover_recurse( (uchar *)info.val, stack, depth );
132 75 : if( FD_UNLIKELY( sub_depth ) ) return sub_depth;
133 75 : } else {
134 0 : return depth;
135 0 : }
136 75 : depth--;
137 75 : }
138 :
139 78 : return 0;
140 78 : }
141 :
142 : static int
143 3 : fdctl_pod_find_leftover( uchar * pod ) {
144 :
145 3 : static char const * stack[ FDCTL_CFG_MAX_DEPTH ];
146 3 : ulong depth = fdctl_pod_find_leftover_recurse( pod, stack, 0UL );
147 3 : if( FD_LIKELY( !depth ) ) return 1;
148 :
149 0 : static char path[ 64*FDCTL_CFG_MAX_DEPTH + 4 ];
150 0 : char * c = fd_cstr_init( path );
151 0 : char * end = path + 64*FDCTL_CFG_MAX_DEPTH - 1;
152 0 : for( ulong j=0UL; j<depth; j++ ) {
153 0 : char const * key = stack[j];
154 0 : ulong key_len = strlen( key );
155 0 : if( c+key_len+1 >= end ) {
156 0 : c = fd_cstr_append_text( c, "...", 3UL );
157 0 : break;
158 0 : }
159 0 : c = fd_cstr_append_text( c, key, key_len );
160 0 : c = fd_cstr_append_char( c, '.' );
161 0 : }
162 0 : c -= 1;
163 0 : fd_cstr_fini( c );
164 :
165 0 : FD_LOG_WARNING(( "Unrecognized key `%s`", path ));
166 0 : return 0;
167 3 : }
168 :
169 : /* Converter **********************************************************/
170 :
171 : config_t *
172 : fdctl_pod_to_cfg( config_t * config,
173 3 : uchar * pod ) {
174 :
175 3 : # define CFG_POP( type, cfg_path ) \
176 432 : do { \
177 432 : char const * key = #cfg_path; \
178 432 : fd_pod_info_t info[1]; \
179 432 : if( fd_pod_query( pod, key, info ) ) break; \
180 432 : if( FD_UNLIKELY( !fdctl_cfg_get_##type( &config->cfg_path, sizeof(config->cfg_path), \
181 324 : info, key ) ) ) \
182 324 : return NULL; \
183 324 : fd_pod_remove( pod, key ); \
184 324 : } while(0)
185 :
186 3 : # define CFG_POP_ARRAY( type, cfg_path ) \
187 30 : do { \
188 30 : char const * key = #cfg_path; \
189 30 : fd_pod_info_t info[1]; \
190 30 : if( fd_pod_query( pod, key, info ) ) break; \
191 30 : if( FD_UNLIKELY( info->val_type!=FD_POD_VAL_TYPE_SUBPOD ) ) { \
192 0 : FD_LOG_WARNING(( "`%s`: expected array", key )); \
193 0 : return NULL; \
194 0 : } \
195 24 : ulong arr_len = sizeof( config->cfg_path ) / sizeof( config->cfg_path[ 0 ] ); \
196 24 : ulong j = 0UL; \
197 24 : for( fd_pod_iter_t iter = fd_pod_iter_init( info->val ); !fd_pod_iter_done( iter ); iter = fd_pod_iter_next( iter ) ) { \
198 0 : if( FD_UNLIKELY( j>=arr_len ) ) { \
199 0 : FD_LOG_WARNING(( "`%s`: too many values (max %lu)", key, arr_len )); \
200 0 : return NULL; \
201 0 : } \
202 0 : fd_pod_info_t sub_info = fd_pod_iter_info( iter ); \
203 0 : fdctl_cfg_get_##type( &config->cfg_path[j], sizeof(config->cfg_path[j]), &sub_info, key ); \
204 0 : j++; \
205 0 : } \
206 24 : config->cfg_path ## _cnt = j; \
207 24 : fd_pod_remove( pod, key ); \
208 24 : } while(0)
209 :
210 3 : CFG_POP ( cstr, name );
211 3 : CFG_POP ( cstr, user );
212 3 : CFG_POP ( cstr, scratch_directory );
213 3 : CFG_POP ( cstr, dynamic_port_range );
214 :
215 3 : CFG_POP ( cstr, log.path );
216 3 : CFG_POP ( cstr, log.colorize );
217 3 : CFG_POP ( cstr, log.level_logfile );
218 3 : CFG_POP ( cstr, log.level_stderr );
219 3 : CFG_POP ( cstr, log.level_flush );
220 :
221 3 : CFG_POP ( cstr, reporting.solana_metrics_config );
222 :
223 3 : CFG_POP ( cstr, ledger.path );
224 3 : CFG_POP ( cstr, ledger.accounts_path );
225 3 : CFG_POP ( uint, ledger.limit_size );
226 3 : CFG_POP_ARRAY( cstr, ledger.account_indexes );
227 3 : CFG_POP_ARRAY( cstr, ledger.account_index_include_keys );
228 3 : CFG_POP_ARRAY( cstr, ledger.account_index_exclude_keys );
229 3 : CFG_POP ( bool, ledger.require_tower );
230 3 : CFG_POP ( cstr, ledger.snapshot_archive_format );
231 :
232 3 : CFG_POP_ARRAY( cstr, gossip.entrypoints );
233 3 : CFG_POP ( bool, gossip.port_check );
234 3 : CFG_POP ( ushort, gossip.port );
235 3 : CFG_POP ( cstr, gossip.host );
236 :
237 3 : CFG_POP ( cstr, consensus.identity_path );
238 3 : CFG_POP ( cstr, consensus.vote_account_path );
239 3 : CFG_POP_ARRAY( cstr, consensus.authorized_voter_paths );
240 3 : CFG_POP ( bool, consensus.snapshot_fetch );
241 3 : CFG_POP ( bool, consensus.genesis_fetch );
242 3 : CFG_POP ( bool, consensus.poh_speed_test );
243 3 : CFG_POP ( cstr, consensus.expected_genesis_hash );
244 3 : CFG_POP ( uint, consensus.wait_for_supermajority_at_slot );
245 3 : CFG_POP ( cstr, consensus.expected_bank_hash );
246 3 : CFG_POP ( ushort, consensus.expected_shred_version );
247 3 : CFG_POP ( bool, consensus.wait_for_vote_to_start_leader );
248 3 : CFG_POP_ARRAY( uint, consensus.hard_fork_at_slots );
249 3 : CFG_POP_ARRAY( cstr, consensus.known_validators );
250 3 : CFG_POP ( bool, consensus.os_network_limits_test );
251 :
252 3 : CFG_POP ( ushort, rpc.port );
253 3 : CFG_POP ( bool, rpc.full_api );
254 3 : CFG_POP ( bool, rpc.private );
255 3 : CFG_POP ( bool, rpc.transaction_history );
256 3 : CFG_POP ( bool, rpc.extended_tx_metadata_storage );
257 3 : CFG_POP ( bool, rpc.only_known );
258 3 : CFG_POP ( bool, rpc.pubsub_enable_block_subscription );
259 3 : CFG_POP ( bool, rpc.pubsub_enable_vote_subscription );
260 3 : CFG_POP ( bool, rpc.bigtable_ledger_storage );
261 :
262 3 : CFG_POP ( bool, snapshots.incremental_snapshots );
263 3 : CFG_POP ( uint, snapshots.full_snapshot_interval_slots );
264 3 : CFG_POP ( uint, snapshots.incremental_snapshot_interval_slots );
265 3 : CFG_POP ( uint, snapshots.minimum_snapshot_download_speed );
266 3 : CFG_POP ( uint, snapshots.maximum_full_snapshots_to_retain );
267 3 : CFG_POP ( uint, snapshots.maximum_incremental_snapshots_to_retain);
268 3 : CFG_POP ( cstr, snapshots.path );
269 3 : CFG_POP ( cstr, snapshots.incremental_path );
270 :
271 3 : CFG_POP ( cstr, layout.affinity );
272 3 : CFG_POP ( cstr, layout.agave_affinity );
273 3 : CFG_POP ( uint, layout.net_tile_count );
274 3 : CFG_POP ( uint, layout.quic_tile_count );
275 3 : CFG_POP ( uint, layout.resolv_tile_count );
276 3 : CFG_POP ( uint, layout.verify_tile_count );
277 3 : CFG_POP ( uint, layout.bank_tile_count );
278 3 : CFG_POP ( uint, layout.shred_tile_count );
279 :
280 3 : CFG_POP ( cstr, hugetlbfs.mount_path );
281 :
282 3 : CFG_POP ( cstr, tiles.net.interface );
283 3 : CFG_POP ( cstr, tiles.net.xdp_mode );
284 3 : CFG_POP ( uint, tiles.net.xdp_rx_queue_size );
285 3 : CFG_POP ( uint, tiles.net.xdp_tx_queue_size );
286 3 : CFG_POP ( uint, tiles.net.xdp_aio_depth );
287 3 : CFG_POP ( uint, tiles.net.send_buffer_size );
288 3 : CFG_POP_ARRAY( cstr, tiles.net.multihome_ip_addrs );
289 :
290 3 : CFG_POP ( ushort, tiles.quic.regular_transaction_listen_port );
291 3 : CFG_POP ( ushort, tiles.quic.quic_transaction_listen_port );
292 3 : CFG_POP ( uint, tiles.quic.txn_reassembly_count );
293 3 : CFG_POP ( uint, tiles.quic.max_concurrent_connections );
294 3 : CFG_POP ( uint, tiles.quic.max_concurrent_handshakes );
295 3 : CFG_POP ( uint, tiles.quic.idle_timeout_millis );
296 3 : CFG_POP ( uint, tiles.quic.ack_delay_millis );
297 3 : CFG_POP ( bool, tiles.quic.retry );
298 :
299 3 : CFG_POP ( uint, tiles.verify.signature_cache_size );
300 3 : CFG_POP ( uint, tiles.verify.receive_buffer_size );
301 3 : CFG_POP ( uint, tiles.verify.mtu );
302 :
303 3 : CFG_POP ( uint, tiles.dedup.signature_cache_size );
304 :
305 3 : CFG_POP ( uint, tiles.pack.max_pending_transactions );
306 3 : CFG_POP ( bool, tiles.pack.use_consumed_cus );
307 :
308 3 : CFG_POP ( bool, tiles.poh.lagged_consecutive_leader_start );
309 :
310 3 : CFG_POP ( uint, tiles.shred.max_pending_shred_sets );
311 3 : CFG_POP ( ushort, tiles.shred.shred_listen_port );
312 :
313 3 : CFG_POP ( cstr, tiles.metric.prometheus_listen_address );
314 3 : CFG_POP ( ushort, tiles.metric.prometheus_listen_port );
315 :
316 3 : CFG_POP ( bool, tiles.gui.enabled );
317 3 : CFG_POP ( cstr, tiles.gui.gui_listen_address );
318 3 : CFG_POP ( ushort, tiles.gui.gui_listen_port );
319 :
320 3 : CFG_POP ( bool, development.sandbox );
321 3 : CFG_POP ( bool, development.no_clone );
322 3 : CFG_POP ( bool, development.no_agave );
323 3 : CFG_POP ( bool, development.bootstrap );
324 :
325 3 : CFG_POP ( bool, development.netns.enabled );
326 3 : CFG_POP ( cstr, development.netns.interface0 );
327 3 : CFG_POP ( cstr, development.netns.interface0_mac );
328 3 : CFG_POP ( cstr, development.netns.interface0_addr );
329 3 : CFG_POP ( cstr, development.netns.interface1 );
330 3 : CFG_POP ( cstr, development.netns.interface1_mac );
331 3 : CFG_POP ( cstr, development.netns.interface1_addr );
332 :
333 3 : CFG_POP ( bool, development.gossip.allow_private_address );
334 :
335 3 : CFG_POP ( ulong, development.genesis.hashes_per_tick );
336 3 : CFG_POP ( ulong, development.genesis.target_tick_duration_micros );
337 3 : CFG_POP ( ulong, development.genesis.ticks_per_slot );
338 3 : CFG_POP ( ulong, development.genesis.fund_initial_accounts );
339 3 : CFG_POP ( ulong, development.genesis.fund_initial_amount_lamports );
340 3 : CFG_POP ( ulong, development.genesis.vote_account_stake_lamports );
341 3 : CFG_POP ( bool, development.genesis.warmup_epochs );
342 :
343 3 : CFG_POP ( uint, development.bench.benchg_tile_count );
344 3 : CFG_POP ( uint, development.bench.benchs_tile_count );
345 3 : CFG_POP ( cstr, development.bench.affinity );
346 3 : CFG_POP ( bool, development.bench.larger_max_cost_per_block );
347 3 : CFG_POP ( bool, development.bench.larger_shred_limits_per_block );
348 3 : CFG_POP ( ulong, development.bench.disable_blockstore_from_slot );
349 3 : CFG_POP ( bool, development.bench.disable_status_cache );
350 :
351 : /* Firedancer-only configuration */
352 :
353 3 : CFG_POP ( ulong, blockstore.shred_max );
354 3 : CFG_POP ( ulong, blockstore.block_max );
355 3 : CFG_POP ( ulong, blockstore.idx_max );
356 3 : CFG_POP ( ulong, blockstore.txn_max );
357 3 : CFG_POP ( ulong, blockstore.alloc_max );
358 3 : CFG_POP ( cstr, blockstore.file );
359 3 : CFG_POP ( cstr, blockstore.checkpt );
360 3 : CFG_POP ( cstr, blockstore.restore );
361 :
362 3 : CFG_POP ( bool, consensus.vote );
363 :
364 3 : CFG_POP_ARRAY( cstr, tiles.gossip.entrypoints );
365 3 : CFG_POP ( ushort, tiles.gossip.gossip_listen_port );
366 3 : CFG_POP_ARRAY( ushort, tiles.gossip.peer_ports );
367 :
368 3 : CFG_POP ( ushort, tiles.repair.repair_intake_listen_port );
369 3 : CFG_POP ( ushort, tiles.repair.repair_serve_listen_port );
370 :
371 3 : CFG_POP ( cstr, tiles.replay.capture );
372 3 : CFG_POP ( cstr, tiles.replay.funk_checkpt );
373 3 : CFG_POP ( ulong, tiles.replay.funk_rec_max );
374 3 : CFG_POP ( ulong, tiles.replay.funk_sz_gb );
375 3 : CFG_POP ( ulong, tiles.replay.funk_txn_max );
376 3 : CFG_POP ( cstr, tiles.replay.funk_file );
377 3 : CFG_POP ( cstr, tiles.replay.genesis );
378 3 : CFG_POP ( cstr, tiles.replay.incremental );
379 3 : CFG_POP ( cstr, tiles.replay.slots_replayed );
380 3 : CFG_POP ( cstr, tiles.replay.snapshot );
381 3 : CFG_POP ( cstr, tiles.replay.status_cache );
382 3 : CFG_POP ( ulong, tiles.replay.tpool_thread_count );
383 3 : CFG_POP ( cstr, tiles.replay.cluster_version );
384 3 : CFG_POP ( bool, tiles.replay.in_wen_restart );
385 3 : CFG_POP ( cstr, tiles.replay.tower_checkpt );
386 3 : CFG_POP ( cstr, tiles.replay.wen_restart_coordinator );
387 :
388 3 : CFG_POP ( cstr, tiles.store_int.slots_pending );
389 3 : CFG_POP ( cstr, tiles.store_int.shred_cap_archive );
390 3 : CFG_POP ( cstr, tiles.store_int.shred_cap_replay );
391 :
392 3 : CFG_POP ( ulong, tiles.snaps.full_interval );
393 3 : CFG_POP ( ulong, tiles.snaps.incremental_interval );
394 3 : CFG_POP ( cstr, tiles.snaps.out_dir );
395 3 : CFG_POP ( ulong, tiles.snaps.hash_tpool_thread_count );
396 :
397 3 : # undef CFG_POP
398 3 : # undef CFG_ARRAY
399 :
400 3 : if( FD_UNLIKELY( !fdctl_pod_find_leftover( pod ) ) ) return NULL;
401 3 : return config;
402 3 : }
403 :
404 : void
405 3 : fdctl_cfg_validate( config_t * cfg ) {
406 :
407 57 : # define CFG_HAS_NON_EMPTY( key ) do { \
408 57 : if( !strnlen( cfg->key, sizeof(cfg->key) ) ) { \
409 0 : FD_LOG_ERR(( "missing `%s`", #key )); \
410 0 : } \
411 57 : } while(0)
412 :
413 96 : # define CFG_HAS_NON_ZERO( key ) do { \
414 96 : if( !cfg->key ) { FD_LOG_ERR(( "missing `%s`", #key )); } \
415 96 : } while(0)
416 :
417 6 : # define CFG_HAS_POW2( key ) do { \
418 6 : ulong value = (ulong)( cfg -> key ); \
419 6 : if( !value || !fd_ulong_is_pow2( value ) ) { \
420 0 : FD_LOG_ERR(( "`%s` must be a power of 2", #key )); \
421 0 : } \
422 6 : } while(0)
423 :
424 3 : CFG_HAS_NON_EMPTY( name );
425 3 : CFG_HAS_NON_EMPTY( scratch_directory );
426 3 : CFG_HAS_NON_EMPTY( dynamic_port_range );
427 :
428 3 : CFG_HAS_NON_EMPTY( log.colorize );
429 3 : CFG_HAS_NON_EMPTY( log.level_logfile );
430 3 : CFG_HAS_NON_EMPTY( log.level_stderr );
431 3 : CFG_HAS_NON_EMPTY( log.level_flush );
432 :
433 3 : CFG_HAS_NON_EMPTY( ledger.snapshot_archive_format );
434 :
435 3 : CFG_HAS_NON_ZERO( gossip.port );
436 :
437 3 : CFG_HAS_NON_ZERO( snapshots.full_snapshot_interval_slots );
438 3 : CFG_HAS_NON_ZERO( snapshots.incremental_snapshot_interval_slots );
439 3 : CFG_HAS_NON_ZERO( snapshots.minimum_snapshot_download_speed );
440 :
441 3 : CFG_HAS_NON_EMPTY( layout.affinity );
442 3 : CFG_HAS_NON_EMPTY( layout.agave_affinity );
443 3 : CFG_HAS_NON_ZERO ( layout.net_tile_count );
444 3 : CFG_HAS_NON_ZERO ( layout.quic_tile_count );
445 3 : CFG_HAS_NON_ZERO ( layout.resolv_tile_count );
446 3 : CFG_HAS_NON_ZERO ( layout.verify_tile_count );
447 3 : CFG_HAS_NON_ZERO ( layout.bank_tile_count );
448 3 : CFG_HAS_NON_ZERO ( layout.shred_tile_count );
449 :
450 3 : CFG_HAS_NON_EMPTY( hugetlbfs.mount_path );
451 :
452 3 : CFG_HAS_NON_EMPTY( tiles.net.xdp_mode );
453 3 : CFG_HAS_POW2 ( tiles.net.xdp_rx_queue_size );
454 3 : CFG_HAS_POW2 ( tiles.net.xdp_tx_queue_size );
455 3 : CFG_HAS_NON_ZERO ( tiles.net.xdp_aio_depth );
456 3 : CFG_HAS_NON_ZERO ( tiles.net.send_buffer_size );
457 :
458 3 : CFG_HAS_NON_ZERO( tiles.quic.regular_transaction_listen_port );
459 3 : CFG_HAS_NON_ZERO( tiles.quic.quic_transaction_listen_port );
460 3 : CFG_HAS_NON_ZERO( tiles.quic.max_concurrent_connections );
461 3 : CFG_HAS_NON_ZERO( tiles.quic.txn_reassembly_count );
462 3 : CFG_HAS_NON_ZERO( tiles.quic.max_concurrent_handshakes );
463 3 : CFG_HAS_NON_ZERO( tiles.quic.idle_timeout_millis );
464 :
465 3 : CFG_HAS_NON_ZERO( tiles.verify.signature_cache_size );
466 3 : CFG_HAS_NON_ZERO( tiles.verify.receive_buffer_size );
467 :
468 3 : CFG_HAS_NON_ZERO( tiles.dedup.signature_cache_size );
469 :
470 3 : CFG_HAS_NON_ZERO( tiles.pack.max_pending_transactions );
471 :
472 3 : CFG_HAS_NON_ZERO( tiles.shred.max_pending_shred_sets );
473 3 : CFG_HAS_NON_ZERO( tiles.shred.shred_listen_port );
474 :
475 3 : CFG_HAS_NON_ZERO( tiles.metric.prometheus_listen_port );
476 :
477 3 : CFG_HAS_NON_ZERO( tiles.gui.gui_listen_port );
478 :
479 3 : CFG_HAS_NON_EMPTY( development.netns.interface0 );
480 3 : CFG_HAS_NON_EMPTY( development.netns.interface0_mac );
481 3 : CFG_HAS_NON_EMPTY( development.netns.interface0_addr );
482 3 : CFG_HAS_NON_EMPTY( development.netns.interface1 );
483 3 : CFG_HAS_NON_EMPTY( development.netns.interface1_mac );
484 3 : CFG_HAS_NON_EMPTY( development.netns.interface1_addr );
485 :
486 3 : CFG_HAS_NON_ZERO( development.genesis.target_tick_duration_micros );
487 3 : CFG_HAS_NON_ZERO( development.genesis.ticks_per_slot );
488 3 : CFG_HAS_NON_ZERO( development.genesis.fund_initial_accounts );
489 3 : CFG_HAS_NON_ZERO( development.genesis.fund_initial_amount_lamports );
490 :
491 3 : CFG_HAS_NON_ZERO ( development.bench.benchg_tile_count );
492 3 : CFG_HAS_NON_ZERO ( development.bench.benchs_tile_count );
493 3 : CFG_HAS_NON_EMPTY( development.bench.affinity );
494 :
495 3 : # undef CFG_HAS_NON_EMPTY
496 3 : # undef CFG_HAS_NON_ZERO
497 3 : # undef CFG_HAS_POW2
498 3 : }
|
