« back to all changes in this revision
Viewing changes to xpeek/fsckcbbl.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Christopher L Cheney
- Date: 2002-02-10 01:00:00 UTC
- Revision ID: james.westby@ubuntu.com-20020210010000-v63g4150dcpnehzq
Tags: upstream-1.0.14
Import upstream version 1.0.14
- files added:
- defrag
- extendfs
- fsck
- include
- libfs
- logdump
- logredo
- mkfs
- xchkdmp
- xchklog
- xpeek
added
removed
xpeek/fsckcbbl.c
1
/*
2
*
3
* Copyright (c) International Business Machines Corp., 2000
4
*
5
* This program is free software; you can redistribute it and/or modify
6
* it under the terms of the GNU General Public License as published by
7
* the Free Software Foundation; either version 2 of the License, or
8
* (at your option) any later version.
9
*
10
* This program is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13
* the GNU General Public License for more details.
14
*
15
* You should have received a copy of the GNU General Public License
16
* along with this program; if not, write to the Free Software
17
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
*/
19
20
#include "xpeek.h"
21
22
/* JFS includes */
23
#include <jfs_filsys.h>
24
#include <jfs_superblock.h>
25
#include <jfs_logmgr.h>
26
27
/* libfs includes */
28
#include <fsckcbbl.h>
29
#include <fsckwsp.h>
30
31
/* global data */
32
extern int64_t fsckwsp_offset; /* defined in xpeek.c */
33
extern int64_t jlog_super_offset; /* defined in xpeek.c */
34
35
/* forward references */
36
int32_t display_cbblfsck( struct fsck_blk_map_hdr * );
37
int32_t display_fsck_wsphdr( struct fsck_blk_map_hdr * );
38
int32_t display_logsuper( logsuper_t * );
39
40
int32_t get_fsckwsphdr( struct fsck_blk_map_hdr * );
41
int32_t get_logsuper( logsuper_t * );
42
43
int32_t put_fsckwsphdr( struct fsck_blk_map_hdr * );
44
int32_t put_logsuper( logsuper_t * );
45
46
/* endian routines */
47
extern uint32_t type_jfs;
48
extern void ujfs_swap_fsck_blk_map_hdr( fsck_blk_map_hdr_t * );
49
extern void ujfs_swap_logsuper_t( logsuper_t * );
50
51
/*************************************************************
52
* cbblfsck()
53
*
54
*/
55
void cbblfsck()
56
{
57
struct fsck_blk_map_hdr fsckwsp;
58
59
if( get_fsckwsphdr( &fsckwsp ) ) {
60
fputs("cbblfsck: error returned from get_fsckwsphdr()\n\n",stderr);
61
return;
62
}
63
if (display_cbblfsck( &fsckwsp ) == XPEEK_CHANGED)
64
if( put_fsckwsphdr( &fsckwsp ) )
65
fputs("cbblfsck: error returned from put_fsckwsphdr()\n\n",stderr);
66
return;
67
} /* end cbblfsck() */
68
69
70
/*************************************************************
71
* fsckwsphdr()
72
*
73
*/
74
void fsckwsphdr()
75
{
76
struct fsck_blk_map_hdr fsckwsp;
77
78
if( get_fsckwsphdr( &fsckwsp ) ) {
79
fputs("fsckwsphdr: error returned from get_fsckwsphdr()\n\n",stderr);
80
return;
81
}
82
if (display_fsck_wsphdr( &fsckwsp ) == XPEEK_CHANGED)
83
if( put_fsckwsphdr( &fsckwsp ) )
84
fputs("fsckwsphdr: error returned from put_fsckwsphdr()\n\n",stderr);
85
return;
86
} /* end fsckwsphdr() */
87
88
89
/*************************************************************
90
* logsuper()
91
*
92
*/
93
void logsuper()
94
{
95
char buffer[PSIZE];
96
logsuper_t *lsp;
97
98
lsp = (logsuper_t *) &(buffer[0]);
99
100
if( get_logsuper( lsp ) ) {
101
fputs("logsuper: error returned from get_fsckwsphdr()\n\n",stderr);
102
return;
103
}
104
if (display_logsuper( lsp ) == XPEEK_CHANGED)
105
if( put_logsuper( lsp ) )
106
fputs("logsuper: error returned from put_fsckwsphdr()\n\n",stderr);
107
return;
108
} /* end logsuper() */
109
110
/*
111
* ============================================================
112
*/
113
114
/*************************************************************
115
* display_cbblfsck()
116
*
117
***************** Sample output of display_cbblfsck()
118
119
[1] eyecatcher: 'fsckcbbl' [13] bufptr_eyecatch: 'cbblbufs'
120
[2] cbbl_retcode: 0 [14] cbbl_agg_recptr: 0x00067f40
121
[3] fs_blksize: 1024 [15] ImapInoPtr: 0x00067cb0
122
[4] lv_blksize: 512 [16] ImapCtlPtr: 0x00061a70
123
[5] fs_lv_ratio: 2
124
[6] fs_last_metablk: 0x00000000000008a8 (0d02216)
125
[7] fs_first_wspblk: 0x00000000001fba2b (0d02079275)
126
[8] total_bad_blocks: 20
127
[9] resolved_blocks: 18 [17] ImapLeafPtr: 0x00060a60
128
[10] reloc_extents: 14 [18] iagPtr: 0x00066ca0
129
[11] reloc_blocks: 1028 [19] InoExtPtr: 0x00060a70
130
[12] LVM_lists: 3
131
132
*/
133
int32_t display_cbblfsck( struct fsck_blk_map_hdr *fsckwsp_ptr )
134
{
135
int32_t rc = XPEEK_OK;
136
struct fsckcbbl_record *cbblrec;
137
char cmdline[512];
138
int32_t field;
139
char *token;
140
char s1[9];
141
char s2[9];
142
143
cbblrec = &( fsckwsp_ptr->cbblrec );
144
145
changed:
146
147
strncpy(s1, cbblrec->eyecatcher, 8);
148
s1[8] = '\0';
149
strncpy(s2, cbblrec->bufptr_eyecatcher, 8);
150
s2[8] = '\0';
151
152
printf("[1] eyecatcher: \t'%s'\t", s1);
153
printf("[13] bufptr_eyecatch:\t'%s'\n", s2);
154
printf("[2] cbbl_retcode:\t%d\t\t", cbblrec->cbbl_retcode);
155
printf("[14] cbbl_agg_recptr:\t0x%8p\n", cbblrec->clrbblks_agg_recptr);
156
printf("[3] fs_blksize:\t\t%d\t\t", cbblrec->fs_blksize);
157
printf("[15] ImapInoPtr:\t0x%8p\n", cbblrec->ImapInoPtr);
158
printf("[4] lv_blksize:\t\t%d\t\t", cbblrec->lv_blksize);
159
printf("[16] ImapCtlPtr:\t0x%8p\n", cbblrec->ImapCtlPtr);
160
printf("[5] fs_lv_ratio:\t%d\n", cbblrec->fs_lv_ratio);
161
printf("[6] last_metablk:\t0x%016llx (0d0%lld)\n",
162
(long long)cbblrec->fs_last_metablk, (long long)cbblrec->fs_last_metablk);
163
printf("[7] first_wspblk:\t0x%016llx (0d0%lld)\n",
164
(long long)cbblrec->fs_first_wspblk, (long long)cbblrec->fs_first_wspblk);
165
printf("[8] total_bad_blocks:\t%0d\n", cbblrec->total_bad_blocks);
166
printf("[9] resolved_blocks:\t%d\t\t", cbblrec->resolved_blocks);
167
printf("[17] ImapLeafPtr:\t0x%8p\n", cbblrec->ImapLeafPtr);
168
printf("[10] reloc_extents:\t%d\t\t", cbblrec->reloc_extents);
169
printf("[18] iagPtr:\t\t0x%8p\n", cbblrec->iagPtr);
170
printf("[11] reloc_blocks:\t%lld\t\t", (long long)cbblrec->reloc_blocks);
171
printf("[19] InoExtPtr:\t\t0x%8p\n", cbblrec->InoExtPtr);
172
printf("[12] LVM_lists:\t\t%d\n", cbblrec->LVM_lists);
173
174
retry:
175
fputs("display_cbblfsck: [m]odify or e[x]it: ", stdout);
176
fgets(cmdline, 512, stdin);
177
token = strtok(cmdline, " \n");
178
if (token == 0 || token[0] != 'm')
179
return rc;
180
181
field = m_parse(cmdline, 19, &token);
182
if (field == 0)
183
goto retry;
184
185
switch (field) {
186
case 1:
187
strncpy(cbblrec->eyecatcher, token, 8);
188
break;
189
case 2:
190
cbblrec->cbbl_retcode = strtol(token, 0, 8);
191
break;
192
case 3:
193
cbblrec->fs_blksize = strtol(token, 0, 0);
194
break;
195
case 4:
196
cbblrec->lv_blksize = strtol(token, 0, 0);
197
break;
198
case 5:
199
cbblrec->fs_lv_ratio = strtol(token, 0, 0);
200
break;
201
case 6:
202
cbblrec->fs_last_metablk = strtoull(token, 0, 16);
203
break;
204
case 7:
205
cbblrec->fs_first_wspblk = strtoull(token, 0, 16);
206
break;
207
case 8:
208
cbblrec->total_bad_blocks = strtol(token, 0, 0);
209
break;
210
case 9:
211
cbblrec->resolved_blocks = strtol(token, 0, 0);
212
break;
213
case 10:
214
cbblrec->reloc_extents = strtol(token, 0, 0);
215
break;
216
case 11:
217
cbblrec->reloc_blocks = strtol(token, 0, 0);
218
break;
219
case 12:
220
cbblrec->LVM_lists = strtoul(token, 0, 0);
221
break;
222
case 13:
223
strncpy(cbblrec->bufptr_eyecatcher, token, 8);
224
break;
225
case 14:
226
cbblrec->clrbblks_agg_recptr = (void *) strtoul(token, 0, 16);
227
break;
228
case 15:
229
cbblrec->ImapInoPtr = (void *) strtoul(token, 0, 16);
230
break;
231
case 16:
232
cbblrec->ImapCtlPtr = (void *) strtoul(token, 0, 16);
233
break;
234
case 17:
235
cbblrec->ImapLeafPtr = (void *) strtoul(token, 0, 16);
236
break;
237
case 18:
238
cbblrec->iagPtr = (void *) strtoul(token, 0, 16);
239
break;
240
case 19:
241
cbblrec->InoExtPtr = (void *) strtoul(token, 0, 16);
242
break;
243
}
244
rc = XPEEK_CHANGED;
245
goto changed;
246
} /* end display_cbblfsck() */
247
248
249
/*************************************************************
250
* display_fsck_wsphdr()
251
*
252
*
253
***************** Sample output of display_fsck_wsphdr()
254
255
[1] eyecatcher: 'wspblkmp'
256
[2] last_entry_pos: 0
257
[3] next_entry_pos: 0
258
[4] start_time: 2/5/999.11.2
259
[5] end_time: 2/5/999.11.4
260
[6] return_code: 0
261
[7] super_buff_addr: 0x164f0be0
262
[8] agg_record_addr: 0x164f4cd0
263
[9] bmap_record_addr: 0x16463ce0
264
[10] fscklog_agg_offset: 0x000000003f786600 (0d01064855040)
265
[11] fscklog_full: 0
266
[12] fscklog_buf_allocated: -1
267
[13] fscklog_buf_alloc_err: 0
268
[14] num_logwrite_errors: 0
269
270
*/
271
272
int32_t display_fsck_wsphdr( struct fsck_blk_map_hdr *wp )
273
{
274
int32_t rc = XPEEK_OK;
275
char cmdline[512];
276
int32_t field;
277
char *token;
278
char s1[9];
279
280
changed:
281
282
strncpy(s1, wp->hdr.eyecatcher, 8);
283
s1[8] = '\0';
284
285
printf("[1] eyecatcher:\t\t\t'%s'\n", s1 );
286
printf("[2] last_entry_pos:\t\t%d\n", wp->hdr.last_entry_pos );
287
printf("[3] next_entry_pos:\t\t%d\n", wp->hdr.next_entry_pos );
288
printf("[4] start_time:\t\t\t%s\n", wp->hdr.start_time );
289
printf("[5] end_time:\t\t\t%s\n", wp->hdr.end_time );
290
printf("[6] return_code:\t\t%d\n", wp->hdr.return_code );
291
printf("[7] super_buff_addr:\t\t%8p\n", wp->hdr.super_buff_addr );
292
printf("[8] agg_record_addr:\t\t0x%8p\n", wp->hdr.agg_record_addr );
293
printf("[9] bmap_record_addr:\t\t0x%8p\n", wp->hdr.bmap_record_addr );
294
printf("[10] fscklog_agg_offset:\t0x%016llx (0d0%lld)\n",
295
(long long)wp->hdr.fscklog_agg_offset, (long long)wp->hdr.fscklog_agg_offset);
296
printf("[11] fscklog_full:\t\t%d\n", wp->hdr.fscklog_full );
297
printf("[12] fscklog_buf_allocated:\t%d\n", wp->hdr.fscklog_buf_allocated );
298
printf("[13] fscklog_buf_alloc_err:\t%d\n", wp->hdr.fscklog_buf_alloc_err );
299
printf("[14] num_logwrite_errors:\t%d\n", wp->hdr.num_logwrite_errors );
300
301
retry:
302
fputs("display_fsck_wsphdr: [m]odify or e[x]it: ", stdout);
303
fgets(cmdline, 512, stdin);
304
token = strtok(cmdline, " \n");
305
if (token == 0 || token[0] != 'm')
306
return rc;
307
308
field = m_parse(cmdline, 14, &token);
309
if (field == 0)
310
goto retry;
311
312
switch (field) {
313
case 1:
314
strncpy(wp->hdr.eyecatcher, token, 8);
315
break;
316
case 2:
317
wp->hdr.last_entry_pos = strtol(token, 0, 0);
318
break;
319
case 3:
320
wp->hdr.next_entry_pos = strtol(token, 0, 0);
321
break;
322
case 4:
323
strncpy(wp->hdr.start_time, token, 16);
324
break;
325
case 5:
326
strncpy(wp->hdr.end_time, token, 16);
327
break;
328
case 6:
329
wp->hdr.return_code = strtol(token, 0, 0);
330
break;
331
case 7:
332
wp->hdr.super_buff_addr = (char *) strtoul(token, 0, 16);
333
break;
334
case 8:
335
wp->hdr.agg_record_addr = (char *) strtoul(token, 0, 16);
336
break;
337
case 9:
338
wp->hdr.bmap_record_addr = (char *) strtoul(token, 0, 16);
339
break;
340
case 10:
341
wp->hdr.fscklog_agg_offset = strtoull(token, 0, 16);
342
break;
343
case 11:
344
wp->hdr.fscklog_full = strtol(token, 0, 0);
345
break;
346
case 12:
347
wp->hdr.fscklog_buf_allocated = strtol(token, 0, 0);
348
break;
349
case 13:
350
wp->hdr.fscklog_buf_alloc_err = strtol(token, 0, 0);
351
break;
352
case 14:
353
wp->hdr.num_logwrite_errors = strtol(token, 0, 8);
354
break;
355
}
356
rc = XPEEK_CHANGED;
357
goto changed;
358
} /* end display_fsck_wsphdr() */
359
360
361
/*************************************************************
362
* display_logsuper()
363
*
364
*
365
***************** Sample output of display_logsuper()
366
367
[1] eyecatcher: 'wspblkmp'
368
[2] last_entry_pos: 0
369
[3] next_entry_pos: 0
370
[4] start_time: 2/5/999.11.2
371
[5] end_time: 2/5/999.11.4
372
[6] return_code: 0
373
[7] super_buff_addr: 0x164f0be0
374
[8] agg_record_addr: 0x164f4cd0
375
[9] bmap_record_addr: 0x16463ce0
376
[10] fscklog_agg_offset: 0x000000003f786600 (0d01064855040)
377
[11] fscklog_full: 0
378
[12] fscklog_buf_allocated: -1
379
[13] fscklog_buf_alloc_err: 0
380
[14] num_logwrite_errors: 0
381
382
*/
383
384
int32_t display_logsuper( logsuper_t *lsp )
385
{
386
int32_t rc = XPEEK_OK;
387
char cmdline[512];
388
int32_t field;
389
char *token;
390
391
changed:
392
393
printf("[1] magic:\t\t\t0x%x\n", lsp->magic );
394
printf("[2] version:\t\t\t%d\n", lsp->version );
395
printf("[3] serial:\t\t\t%d\n", lsp->serial );
396
printf("[4] log size:\t\t\t%d\t(at 4096 bytes/log block)\n", lsp->size );
397
printf("[5] agg block size:\t\t%d\t(bytes)\n", lsp->bsize );
398
printf("[6] log2(agg blk size):\t\t%d\n", lsp->l2bsize );
399
printf("[7] flag:\t\t\t0x%08x\n", lsp->flag );
400
printf("[8] state:\t\t\t0x%08x\n", lsp->state );
401
printf("[9] end:\t\t\t0x%x (d %d)\n", lsp->end, lsp->end);
402
printf("[] active[0]:\t0x%x (%d)\t active[4]:\t0x%x (%d)\n",
403
lsp->active[0], lsp->active[0],
404
lsp->active[4], lsp->active[4] );
405
printf(" active[1]:\t0x%x (%d)\t active[5]:\t0x%x (%d)\n",
406
lsp->active[1], lsp->active[1],
407
lsp->active[5], lsp->active[5] );
408
printf(" active[2]:\t0x%x (%d)\t active[6]:\t0x%x (%d)\n",
409
lsp->active[2], lsp->active[2],
410
lsp->active[6], lsp->active[6] );
411
printf(" active[3]:\t0x%x (%d)\t active[7]:\t0x%x (%d)\n",
412
lsp->active[3], lsp->active[3],
413
lsp->active[7], lsp->active[7] );
414
415
retry:
416
fputs("display_fsck_wsphdr: [m]odify or e[x]it: ", stdout);
417
fgets(cmdline, 512, stdin);
418
token = strtok(cmdline, " \n");
419
if (token == 0 || token[0] != 'm')
420
return rc;
421
422
field = m_parse(cmdline, 9, &token);
423
if (field == 0)
424
goto retry;
425
426
switch (field) {
427
case 1:
428
lsp->magic = strtoul(token, 0, 16);
429
break;
430
case 2:
431
lsp->version = strtol(token, 0, 0);
432
break;
433
case 3:
434
lsp->serial = strtol(token, 0, 0);
435
break;
436
case 4:
437
lsp->size = strtol(token, 0, 0);
438
break;
439
case 5:
440
lsp->bsize = strtol(token, 0, 0);
441
break;
442
case 6:
443
lsp->l2bsize = strtol(token, 0, 0);
444
break;
445
case 7:
446
lsp->flag = strtoul(token, 0, 16);
447
break;
448
case 8:
449
lsp->state = strtoul(token, 0, 16);
450
break;
451
case 9:
452
lsp->end = strtoul(token, 0, 16);
453
break;
454
}
455
rc = XPEEK_CHANGED;
456
goto changed;
457
} /* end display_logsuper() */
458
459
460
/*************************************************************
461
* get_fsckwsphdr()
462
*
463
*/
464
int32_t get_fsckwsphdr( struct fsck_blk_map_hdr *wsphdr_ptr )
465
{
466
if( xRead( fsckwsp_offset, PSIZE, (char *)wsphdr_ptr ) ) {
467
fputs("get_fsckwsphdr: error returned from xRead(fsckwsp_offset)\n\n",stderr);
468
return( -2 );
469
}
470
471
/* swap if on big endian machine */
472
if (type_jfs & JFS_SWAP_BYTES) {
473
ujfs_swap_fsck_blk_map_hdr( wsphdr_ptr );
474
}
475
476
return( 0 );
477
} /* end get_fsckwsphdr() */
478
479
480
/*************************************************************
481
* get_logsuper()
482
*
483
*/
484
int32_t get_logsuper( logsuper_t *lsp )
485
{
486
if( xRead( jlog_super_offset, PSIZE, (char *)lsp ) ) {
487
fputs("get_logsuper: error returned from xRead(jlog_super_offset)\n\n",stderr);
488
return( -3 );
489
}
490
491
/* swap if on big endian machine */
492
if (type_jfs & JFS_SWAP_BYTES) {
493
ujfs_swap_logsuper_t( lsp );
494
}
495
496
return( 0 );
497
} /* end get_logsuper() */
498
499
500
/*************************************************************
501
* put_fsckwsphdr()
502
*
503
*/
504
int32_t put_fsckwsphdr( blk_cntrlptr wsphdr_ptr )
505
{
506
507
/* swap if on big endian machine */
508
if (type_jfs & JFS_SWAP_BYTES) {
509
ujfs_swap_fsck_blk_map_hdr( wsphdr_ptr );
510
}
511
512
if( xWrite( fsckwsp_offset, PSIZE, (char *)wsphdr_ptr ) ) {
513
fputs("put_fsckwsphdr: error returned from xWrite(fsckwsp_offset)\n\n",stderr);
514
/* swap back if on big endian machine */
515
if (type_jfs & JFS_SWAP_BYTES) ujfs_swap_fsck_blk_map_hdr( wsphdr_ptr );
516
return( -4 );
517
}
518
519
/* swap back if on big endian machine */
520
if (type_jfs & JFS_SWAP_BYTES) {
521
ujfs_swap_fsck_blk_map_hdr( wsphdr_ptr );
522
}
523
524
525
return( 0 );
526
} /* end put_fsckwsphdr() */
527
528
529
/*************************************************************
530
* put_logsuper()
531
*
532
*/
533
int32_t put_logsuper( logsuper_t *lsp )
534
{
535
536
/* swap if on big endian machine */
537
if (type_jfs & JFS_SWAP_BYTES) {
538
ujfs_swap_logsuper_t( lsp );
539
}
540
541
if( xWrite( jlog_super_offset, PSIZE, (char *)lsp ) ) {
542
fputs("put_logsuper: error returned from xWrite(jlog_super_offset)\n\n",stderr);
543
/* swap back if on big endian machine */
544
if (type_jfs & JFS_SWAP_BYTES) ujfs_swap_logsuper_t( lsp );
545
return( -5 );
546
}
547
548
/* swap back if on big endian machine */
549
if (type_jfs & JFS_SWAP_BYTES) {
550
ujfs_swap_logsuper_t( lsp );
551
}
552
553
554
return( 0 );
555
} /* end put_logsuper() */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1