Line data Source code
1 : #include "../fd_util.h"
2 : #include "fd_wksp_private.h"
3 :
4 : #if FD_HAS_HOSTED
5 :
6 : /* TODO: add owner query */
7 :
8 : #include <stdio.h>
9 : #include <errno.h>
10 : #include <unistd.h>
11 : #include <fcntl.h>
12 : #include <sys/stat.h>
13 :
14 : FD_IMPORT_CSTR( fd_wksp_ctl_help, "src/util/wksp/fd_wksp_ctl_help" );
15 :
16 : /* fd_printf_wksp pretty prints the detailed workspace state to file.
17 : Includes detailed metadata integrity checking. Return value
18 : semantics are the same as for fprintf. */
19 :
20 : static int
21 : fprintf_wksp( FILE * file,
22 0 : fd_wksp_t * wksp ) {
23 :
24 0 : if( FD_UNLIKELY( !file ) ) {
25 0 : FD_LOG_WARNING(( "NULL file" ));
26 0 : return -1;
27 0 : }
28 :
29 0 : if( FD_UNLIKELY( !wksp ) ) {
30 0 : FD_LOG_WARNING(( "NULL wksp" ));
31 0 : return -1;
32 0 : }
33 :
34 0 : int ret = 0;
35 0 : # define TRAP(x) do { int _err = (x); if( _err<0 ) { fd_wksp_private_unlock( wksp ); return _err; } ret += _err; } while(0)
36 :
37 0 : ulong part_max = wksp->part_max;
38 0 : ulong gaddr_lo = wksp->gaddr_lo;
39 0 : ulong gaddr_hi = wksp->gaddr_hi;
40 :
41 0 : fd_wksp_private_pinfo_t * pinfo = fd_wksp_private_pinfo( wksp );
42 :
43 0 : TRAP( fprintf( file,
44 0 : "wksp %s\n"
45 0 : "\tmagic 0x%016lx\n"
46 0 : "\tseed %u\n"
47 0 : "\tpart_max %lu\n"
48 0 : "\tdata_max %lu\n"
49 0 : "\tgaddr [0x%016lx,0x%016lx)\n",
50 0 : wksp->name, wksp->magic, wksp->seed, part_max, wksp->data_max, gaddr_lo, gaddr_hi ) );
51 :
52 : /* TODO: considering running verify and/or doing extra metadata
53 : integrity checks */
54 :
55 0 : ulong cnt = 0UL;
56 :
57 0 : if( FD_UNLIKELY( fd_wksp_private_lock( wksp ) ) ) { cnt++; TRAP( fprintf( file, "\tlock err\n" ) ); }
58 0 : else {
59 0 : ulong used_cnt = 0UL; ulong free_cnt = 0UL;
60 0 : ulong used_sz = 0UL; ulong free_sz = 0UL;
61 0 : ulong used_max = 0UL; ulong free_max = 0UL;
62 :
63 0 : ulong cycle_tag = wksp->cycle_tag++;
64 :
65 0 : ulong last_i = FD_WKSP_PRIVATE_PINFO_IDX_NULL;
66 0 : ulong last_hi = gaddr_lo;
67 0 : ulong i = fd_wksp_private_pinfo_idx( wksp->part_head_cidx );
68 0 : while( !fd_wksp_private_pinfo_idx_is_null( i ) ) {
69 0 : if( FD_UNLIKELY( i>=part_max ) ) { cnt++; TRAP( fprintf( file, "\tindex err\n" ) ); break; }
70 0 : if( FD_UNLIKELY( pinfo[ i ].cycle_tag==cycle_tag ) ) { cnt++; TRAP( fprintf( file, "\tcycle err\n" ) ); break; }
71 0 : pinfo[ i ].cycle_tag = cycle_tag;
72 :
73 0 : ulong lo = pinfo[ i ].gaddr_lo;
74 0 : ulong hi = pinfo[ i ].gaddr_hi;
75 0 : ulong tag = pinfo[ i ].tag;
76 0 : ulong sz = hi - lo;
77 0 : ulong h = fd_wksp_private_pinfo_idx( pinfo[ i ].prev_cidx );
78 :
79 0 : int used = !!tag;
80 0 : if( used ) {
81 0 : used_cnt++;
82 0 : used_sz += sz;
83 0 : if( sz>used_max ) used_max = sz;
84 0 : } else {
85 0 : free_cnt++;
86 0 : free_sz += sz;
87 0 : if( sz>free_max ) free_max = sz;
88 0 : }
89 :
90 0 : TRAP( fprintf( file, "\tpartition [0x%016lx,0x%016lx) sz %20lu tag %20lu idx %lu", lo, hi, sz, tag, i ) );
91 0 : if( FD_UNLIKELY( h !=last_i ) ) { cnt++; TRAP( fprintf( file, ", link_err" ) ); }
92 0 : if( FD_UNLIKELY( lo!=last_hi ) ) { cnt++; TRAP( fprintf( file, ", adjacent_err" ) ); }
93 0 : if( FD_UNLIKELY( lo>=hi ) ) { cnt++; TRAP( fprintf( file, ", size_err" ) ); }
94 0 : TRAP( fprintf( file, "\n" ) );
95 :
96 0 : last_i = i;
97 0 : last_hi = hi;
98 0 : i = fd_wksp_private_pinfo_idx( pinfo[ i ].next_cidx );
99 0 : }
100 :
101 0 : ulong j = fd_wksp_private_pinfo_idx( wksp->part_tail_cidx );
102 0 : if( FD_UNLIKELY( j!=last_i ) ) { cnt++; TRAP( fprintf( file, "\ttail err\n" ) ); }
103 0 : if( FD_UNLIKELY( gaddr_hi!=last_hi ) ) { cnt++; TRAP( fprintf( file, "\tincomplete err\n" ) ); }
104 :
105 0 : TRAP( fprintf( file, "\t%20lu bytes used (%20lu blocks, largest %20lu bytes)\n", used_sz, used_cnt, used_max ) );
106 0 : TRAP( fprintf( file, "\t%20lu bytes free (%20lu blocks, largest %20lu bytes)\n", free_sz, free_cnt, free_max ) );
107 :
108 0 : fd_wksp_private_unlock( wksp );
109 0 : }
110 :
111 0 : TRAP( fprintf( file, "\t%20lu errors detected\n", cnt ) );
112 0 : # undef TRAP
113 :
114 0 : return ret;
115 0 : }
116 :
117 : int
118 : main( int argc,
119 : char ** argv ) {
120 : fd_boot( &argc, &argv );
121 : # define SHIFT(n) argv+=(n),argc-=(n)
122 :
123 : if( FD_UNLIKELY( argc<1 ) ) FD_LOG_ERR(( "no arguments" ));
124 : char const * bin = argv[0];
125 : SHIFT(1);
126 :
127 : umask( (mode_t)0 ); /* So mode setting gets respected */
128 :
129 : ulong tag = 1UL;
130 :
131 : int cnt = 0;
132 : while( argc ) {
133 : char const * cmd = argv[0];
134 : SHIFT(1);
135 :
136 : if( !strcmp( cmd, "help" ) ) {
137 :
138 : fflush( stdout ); fflush( stderr );
139 : fputs( fd_wksp_ctl_help, stdout );
140 : fflush( stdout ); fflush( stderr );
141 :
142 : FD_LOG_NOTICE(( "%i: %s: success", cnt, cmd ));
143 :
144 : } else if( !strcmp( cmd, "tag" ) ) {
145 :
146 : if( FD_UNLIKELY( argc<1 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
147 :
148 : tag = fd_cstr_to_ulong( argv[0] );
149 :
150 : FD_LOG_NOTICE(( "%i: %s %lu: success", cnt, cmd, tag ));
151 : SHIFT(1);
152 :
153 : } else if( !strcmp( cmd, "supported-styles" ) ) {
154 :
155 : printf( "%s\n", FD_HAS_LZ4 ? "0 1 2 3" : "0 1 2" );
156 :
157 : FD_LOG_NOTICE(( "%i: %s: success", cnt, cmd ));
158 :
159 : } else if( !strcmp( cmd, "new" ) ) {
160 :
161 : if( FD_UNLIKELY( argc<5 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
162 :
163 : char const * name = argv[0];
164 : ulong page_cnt = fd_cstr_to_ulong ( argv[1] );
165 : ulong page_sz = fd_cstr_to_shmem_page_sz( argv[2] );
166 : char const * seq = argv[3];
167 : ulong mode = fd_cstr_to_ulong_octal ( argv[4] );
168 :
169 : /* Partition the pages over the seq */
170 :
171 : ulong sub_page_cnt[ 512 ];
172 : ulong sub_cpu_idx [ 512 ];
173 : ulong sub_cnt = fd_cstr_to_ulong_seq( seq, sub_cpu_idx, 512UL );
174 :
175 : if( FD_UNLIKELY( !sub_cnt ) )
176 : FD_LOG_ERR(( "%i: %s %s %lu %s %s 0%03lo: empty or invalid cpu sequence\n\t"
177 : "Do %s help for help", cnt, cmd, name, page_cnt, argv[2], seq, mode, bin ));
178 :
179 : if( FD_UNLIKELY( sub_cnt>512UL ) )
180 : FD_LOG_ERR(( "%i: %s %s %lu %s %s 0%03lo: sequence too long, increase limit in fd_wksp_ctl.c\n\t"
181 : "Do %s help for help", cnt, cmd, name, page_cnt, argv[2], seq, mode, bin ));
182 :
183 : ulong sub_page_min = page_cnt / sub_cnt;
184 : ulong sub_page_rem = page_cnt % sub_cnt;
185 : for( ulong sub_idx=0UL; sub_idx<sub_cnt; sub_idx++ ) sub_page_cnt[ sub_idx ] = sub_page_min + (ulong)(sub_idx<sub_page_rem);
186 :
187 : /* Create the workspace */
188 :
189 : /* TODO: allow user to specify seed and/or part_max */
190 : int err = fd_wksp_new_named( name, page_sz, sub_cnt, sub_page_cnt, sub_cpu_idx, mode, 0U, 0UL ); /* logs details */
191 : if( FD_UNLIKELY( err ) )
192 : FD_LOG_ERR(( "%i: %s %s %lu %s %s 0%03lo: fd_wksp_new_named failed (%i-%s)\n\t"
193 : "Do %s help for help", cnt, cmd, name, page_cnt, argv[2], seq, mode, err, fd_wksp_strerror( err ), bin ));
194 :
195 : FD_LOG_NOTICE(( "%i: %s %s %lu %s %s 0%03lo: success", cnt, cmd, name, page_cnt, argv[2], seq, mode ));
196 : SHIFT(5);
197 :
198 : } else if( !strcmp( cmd, "delete" ) ) {
199 :
200 : if( FD_UNLIKELY( argc<1 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
201 :
202 : char const * name = argv[0];
203 :
204 : int err = fd_wksp_delete_named( name );
205 : if( FD_UNLIKELY( err ) )
206 : FD_LOG_ERR(( "%i: %s %s: fd_wksp_delete_named failed (%i-%s)\n\t"
207 : "Do %s help for help", cnt, cmd, name, err, fd_wksp_strerror( err ), bin ));
208 :
209 : FD_LOG_NOTICE(( "%i: %s %s: success", cnt, cmd, name ));
210 : SHIFT(1);
211 :
212 : } else if( !strcmp( cmd, "alloc" ) ) {
213 :
214 : if( FD_UNLIKELY( argc<3 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
215 :
216 : char const * name = argv[0];
217 : ulong align = fd_cstr_to_ulong( argv[1] );
218 : ulong sz = fd_cstr_to_ulong( argv[2] );
219 :
220 : char name_gaddr[ FD_WKSP_CSTR_MAX ];
221 : if( !fd_wksp_cstr_alloc( name, align, sz, tag, name_gaddr ) ) /* logs details */
222 : FD_LOG_ERR(( "%i: %s %s %lu %lu %lu: fd_wksp_cstr_alloc failed", cnt, cmd, name, align, sz, tag ));
223 : printf( "%s\n", name_gaddr );
224 :
225 : FD_LOG_NOTICE(( "%i: %s %s %lu %lu: success", cnt, cmd, name, align, sz ));
226 : SHIFT(3);
227 :
228 : } else if( !strcmp( cmd, "info" ) ) {
229 :
230 : if( FD_UNLIKELY( argc<2 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
231 :
232 : char const * name = argv[0];
233 : ulong tag = fd_cstr_to_ulong( argv[1] );
234 :
235 : fd_wksp_t * wksp = fd_wksp_attach( name ); /* logs details */
236 : if( FD_LIKELY( wksp ) ) {
237 : fd_wksp_tag_query_info_t info[1];
238 : ulong tag_cnt = tag ? fd_wksp_tag_query( wksp, &tag, 1UL, info, 1UL ) : 0UL; /* logs details */
239 : if( tag_cnt ) printf( "%s:%lu %lu\n", name, info->gaddr_lo, info->gaddr_hi - info->gaddr_lo );
240 : else printf( "- 0\n" );
241 : fd_wksp_detach( wksp ); /* logs details */
242 : }
243 :
244 : FD_LOG_NOTICE(( "%i: %s %s %lu: success", cnt, cmd, name, tag ));
245 : SHIFT(2);
246 :
247 : } else if( !strcmp( cmd, "free" ) ) {
248 :
249 : if( FD_UNLIKELY( argc<1 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
250 :
251 : char const * name_gaddr = argv[0];
252 :
253 : fd_wksp_cstr_free( name_gaddr ); /* logs details */
254 :
255 : FD_LOG_NOTICE(( "%i: %s %s: success", cnt, cmd, name_gaddr )); /* FIXME: HMMM (print success on bad free?) */
256 : SHIFT(1);
257 :
258 : } else if( !strcmp( cmd, "tag-query" ) ) {
259 :
260 : if( FD_UNLIKELY( argc<1 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
261 :
262 : char const * name_gaddr = argv[0];
263 :
264 : printf( "%lu\n", fd_wksp_cstr_tag( name_gaddr ) ); /* logs details */
265 :
266 : FD_LOG_NOTICE(( "%i: %s %s: success", cnt, cmd, name_gaddr ));
267 : SHIFT(1);
268 :
269 : } else if( !strcmp( cmd, "tag-free" ) ) {
270 :
271 : if( FD_UNLIKELY( argc<2 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
272 :
273 : char const * name = argv[0];
274 : ulong tag = fd_cstr_to_ulong( argv[1] );
275 :
276 : fd_wksp_t * wksp = fd_wksp_attach( name ); /* logs details */
277 : if( FD_LIKELY( wksp ) ) {
278 : fd_wksp_tag_free( wksp, &tag, 1UL ); /* logs details */
279 : fd_wksp_detach( wksp ); /* logs details */
280 : }
281 :
282 : FD_LOG_NOTICE(( "%i: %s %s %lu: success", cnt, cmd, name, tag ));
283 : SHIFT(2);
284 :
285 : } else if( !strcmp( cmd, "memset" ) ) {
286 :
287 : if( FD_UNLIKELY( argc<2 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
288 :
289 : char const * name_gaddr = argv[0];
290 : int c = fd_cstr_to_int( argv[1] );
291 :
292 : fd_wksp_cstr_memset( name_gaddr, c ); /* logs details */
293 :
294 : FD_LOG_NOTICE(( "%i: %s %s %i: success", cnt, cmd, name_gaddr, c ));
295 : SHIFT(2);
296 :
297 : } else if( !strcmp( cmd, "check" ) ) {
298 :
299 : if( FD_UNLIKELY( argc<1 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
300 :
301 : char const * name = argv[0];
302 :
303 : fd_wksp_t * wksp = fd_wksp_attach( name ); /* logs details */
304 : if( FD_UNLIKELY( !wksp ) ) FD_LOG_ERR(( "%i: %s %s: wksp_attach failed", cnt, cmd, name ));
305 :
306 : if( FD_UNLIKELY( fd_wksp_private_lock( wksp ) ) ) FD_LOG_ERR(( "%i: %s %s: failed", cnt, cmd, name )); /* logs details */
307 : fd_wksp_private_unlock( wksp );
308 :
309 : fd_wksp_detach( wksp ); /* logs details */
310 :
311 : FD_LOG_NOTICE(( "%i: %s %s: success", cnt, cmd, name ));
312 : SHIFT(1);
313 :
314 : } else if( !strcmp( cmd, "verify" ) ) {
315 :
316 : if( FD_UNLIKELY( argc<1 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
317 :
318 : char const * name = argv[0];
319 :
320 : fd_wksp_t * wksp = fd_wksp_attach( name ); /* logs details */
321 : if( FD_UNLIKELY( !wksp ) ) FD_LOG_ERR(( "%i: %s %s: wksp_attach failed", cnt, cmd, name ));
322 :
323 : if( FD_UNLIKELY( fd_wksp_private_lock( wksp ) ) || /* logs details */
324 : FD_UNLIKELY( fd_wksp_verify( wksp ) ) ) /* logs details */
325 : FD_LOG_ERR(( "%i: %s %s: failed", cnt, cmd, name ));
326 : fd_wksp_private_unlock( wksp );
327 :
328 : fd_wksp_detach( wksp ); /* logs details */
329 :
330 : FD_LOG_NOTICE(( "%i: %s %s: success", cnt, cmd, name ));
331 : SHIFT(1);
332 :
333 : } else if( !strcmp( cmd, "rebuild" ) ) {
334 :
335 : if( FD_UNLIKELY( argc<2 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
336 :
337 : char const * name = argv[0];
338 : char const * _seed = argv[1];
339 :
340 : fd_wksp_t * wksp = fd_wksp_attach( name ); /* logs details */
341 : if( FD_UNLIKELY( !wksp ) ) FD_LOG_ERR(( "%i: %s %s %s: wksp_attach failed", cnt, cmd, name, _seed ));
342 :
343 : uint seed = strcmp( _seed, "-" ) ? fd_cstr_to_uint( _seed ) : fd_wksp_seed( wksp );
344 :
345 : if( FD_UNLIKELY( fd_wksp_private_lock( wksp ) ) || /* logs details */
346 : FD_UNLIKELY( fd_wksp_rebuild( wksp, seed ) ) ) /* logs details */
347 : FD_LOG_ERR(( "%i: %s %s %u: failed", cnt, cmd, name, seed ));
348 : fd_wksp_private_unlock( wksp );
349 :
350 : fd_wksp_detach( wksp ); /* logs details */
351 :
352 : FD_LOG_NOTICE(( "%i: %s %s %u: success", cnt, cmd, name, seed ));
353 : SHIFT(2);
354 :
355 : } else if( !strcmp( cmd, "reset" ) ) {
356 :
357 : if( FD_UNLIKELY( argc<1 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
358 :
359 : char const * name = argv[0];
360 :
361 : fd_wksp_t * wksp = fd_wksp_attach( name ); /* logs details */
362 : if( FD_UNLIKELY( !wksp ) ) FD_LOG_ERR(( "%i: %s %s: wksp_attach failed", cnt, cmd, name ));
363 : fd_wksp_reset( wksp, fd_wksp_seed( wksp ) ); /* logs details */
364 : fd_wksp_detach( wksp ); /* logs details */
365 :
366 : FD_LOG_NOTICE(( "%i: %s %s: success", cnt, cmd, name ));
367 : SHIFT(1);
368 :
369 : } else if( !strcmp( cmd, "usage" ) ) {
370 :
371 : if( FD_UNLIKELY( argc<2 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
372 :
373 : char const * name = argv[0];
374 : ulong tag = fd_cstr_to_ulong( argv[1] );
375 :
376 : fd_wksp_t * wksp = fd_wksp_attach( name ); /* logs details */
377 : if( FD_UNLIKELY( !wksp ) ) fprintf( stdout, "-\n" );
378 : else {
379 : fd_wksp_usage_t usage[1];
380 : fd_wksp_usage( wksp, &tag, 1UL, usage );
381 : fprintf( stdout,
382 : "wksp %s\n"
383 : "\t%20lu bytes max (%lu blocks, %lu blocks max)\n"
384 : "\t%20lu bytes used (%lu blocks)\n"
385 : "\t%20lu bytes avail (%lu blocks)\n"
386 : "\t%20lu bytes w/tag %4lu (%lu blocks)\n",
387 : wksp->name,
388 : usage->total_sz, usage->total_cnt, usage->total_max,
389 : usage->total_sz - usage->free_sz, usage->total_cnt - usage->free_cnt,
390 : usage->free_sz, usage->free_cnt,
391 : usage->used_sz, tag, usage->used_cnt );
392 : fd_wksp_detach( wksp ); /* logs details */
393 : }
394 :
395 : FD_LOG_NOTICE(( "%i: %s %s %lu: success", cnt, cmd, name, tag ));
396 : SHIFT(2);
397 :
398 : } else if( !strcmp( cmd, "query" ) ) {
399 :
400 : if( FD_UNLIKELY( argc<1 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
401 :
402 : char const * name = argv[0];
403 :
404 : fd_wksp_t * wksp = fd_wksp_attach( name ); /* logs details */
405 : if( FD_UNLIKELY( !wksp ) ) FD_LOG_ERR(( "%i: %s %s: wksp_attach failed", cnt, cmd, name ));
406 : fprintf_wksp( stdout, wksp ); /* logs details */
407 : fd_wksp_detach( wksp ); /* logs details */
408 :
409 : FD_LOG_NOTICE(( "%i: %s %s: success", cnt, cmd, name ));
410 : SHIFT(1);
411 :
412 : } else if( !strcmp( cmd, "checkpt" ) ) {
413 :
414 : if( FD_UNLIKELY( argc<5 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
415 :
416 : char const * name = argv[0];
417 : char const * path = argv[1];
418 : ulong mode = fd_cstr_to_ulong_octal( argv[2] );
419 : int style = fd_cstr_to_int ( argv[3] );
420 : char const * info = argv[4];
421 :
422 : fd_wksp_t * wksp = fd_wksp_attach( name ); /* logs details */
423 : if( FD_UNLIKELY( !wksp ) )
424 : FD_LOG_ERR(( "%i: %s %s %s 0%03lo %i ...: wksp_attach failed", cnt, cmd, name, path, mode, style ));
425 :
426 : int err = fd_wksp_checkpt( wksp, path, mode, style, info ); /* logs details */
427 : if( FD_UNLIKELY( err ) )
428 : FD_LOG_ERR(( "%i: %s %s %s 0%03lo %i ...: fd_wksp_checkpt failed", cnt, cmd, name, path, mode, style ));
429 :
430 : fd_wksp_detach( wksp ); /* logs details */
431 :
432 : FD_LOG_NOTICE(( "%i: %s %s %s 0%03lo %i ...: success", cnt, cmd, name, path, mode, style ));
433 : SHIFT(5);
434 :
435 : } else if( !strcmp( cmd, "checkpt-query" ) ) {
436 :
437 : if( FD_UNLIKELY( argc<2 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
438 :
439 : char const * path = argv[0];
440 : int verbose = fd_cstr_to_int( argv[1] );
441 :
442 : fd_wksp_printf( fileno( stdout ), path, verbose );
443 :
444 : FD_LOG_NOTICE(( "%i: %s %s %i: success", cnt, cmd, path, verbose ));
445 : SHIFT(2);
446 :
447 : } else if( !strcmp( cmd, "restore" ) ) {
448 :
449 : if( FD_UNLIKELY( argc<3 ) ) FD_LOG_ERR(( "%i: %s: too few arguments\n\tDo %s help for help", cnt, cmd, bin ));
450 :
451 : char const * name = argv[0];
452 : char const * path = argv[1];
453 : char const * _seed = argv[2];
454 :
455 : fd_wksp_t * wksp = fd_wksp_attach( name ); /* logs details */
456 : if( FD_UNLIKELY( !wksp ) ) FD_LOG_ERR(( "%i: %s %s %s %s: wksp_attach failed", cnt, cmd, name, path, _seed ));
457 :
458 : uint seed = strcmp( _seed, "-" ) ? fd_cstr_to_uint( _seed ) : fd_wksp_seed( wksp );
459 :
460 : int err = fd_wksp_restore( wksp, path, seed ); /* logs details */
461 : if( FD_UNLIKELY( err ) ) FD_LOG_ERR(( "%i: %s %s %s %u: fd_wksp_restore failed", cnt, cmd, name, path, seed ));
462 :
463 : fd_wksp_detach( wksp ); /* logs details */
464 :
465 : FD_LOG_NOTICE(( "%i: %s %s %s %u: success", cnt, cmd, name, path, seed ));
466 : SHIFT(3);
467 :
468 : } else {
469 :
470 : FD_LOG_ERR(( "%i: %s: unknown command\n\t"
471 : "Do %s help for help", cnt, cmd, bin ));
472 :
473 : }
474 : cnt++;
475 : }
476 :
477 : if( FD_UNLIKELY( cnt<1 ) ) FD_LOG_NOTICE(( "processed %i commands\n\tDo %s help for help", cnt, bin ));
478 : else FD_LOG_NOTICE(( "processed %i commands", cnt ));
479 :
480 : # undef SHIFT
481 : fd_halt();
482 : return 0;
483 : }
484 :
485 : #else
486 :
487 : int
488 : main( int argc,
489 : char ** argv ) {
490 : fd_boot( &argc, &argv );
491 : if( FD_UNLIKELY( argc<1 ) ) FD_LOG_ERR(( "No arguments" ));
492 : if( FD_UNLIKELY( argc>1 ) ) FD_LOG_ERR(( "fd_wksp_ctl not supported on this platform" ));
493 : FD_LOG_NOTICE(( "processed 0 commands" ));
494 : fd_halt();
495 : return 0;
496 : }
497 :
498 : #endif
|
