static void write_inode_tables(ext2_filsys fs)
{
errcode_t retval;
blk_t blk;
dgrp_t i;
int num;
struct progress_struct progress;
int lazy_flag = 0;
if (quiet)
memset(&progress, 0, sizeof(progress));
else
progress_init(&progress, _("Writing inode tables: "),
fs->group_desc_count);
if (EXT2_HAS_COMPAT_FEATURE(fs->super,
EXT2_FEATURE_COMPAT_LAZY_BG))
lazy_flag = 1;
for (i = 0; i < fs->group_desc_count; i++) {
progress_update(&progress, i);
blk = fs->group_desc[i].bg_inode_table;
num = fs->inode_blocks_per_group;
if (!(lazy_flag &&
(fs->group_desc[i].bg_flags & EXT2_BG_INODE_UNINIT))) {
retval = zero_blocks(fs, blk, num, 0, &blk, &num);
if (retval) {
fprintf(stderr, _("\nCould not write %d "
"blocks in inode table starting at %u: %s\n"),
num, blk, error_message(retval));
exit(1);
}
}
if (sync_kludge) {
if (sync_kludge == 1)
sync();
else if ((i % sync_kludge) == 0)
sync();
}
}
zero_blocks(0, 0, 0, 0, 0, 0);
progress_close(&progress);
}
static void create_journal_dev(ext2_filsys fs)
{
struct progress_struct progress;
errcode_t retval;
char *buf;
blk_t blk;
int count;
retval = ext2fs_create_journal_superblock(fs,
fs->super->s_blocks_count, 0, &buf);
if (retval) {
com_err("create_journal_dev", retval,
_("while initializing journal superblock"));
exit(1);
}
if (quiet)
memset(&progress, 0, sizeof(progress));
else
progress_init(&progress, _("Zeroing journal device: "),
fs->super->s_blocks_count);
retval = zero_blocks(fs, 0, fs->super->s_blocks_count,
&progress, &blk, &count);
if (retval) {
com_err("create_journal_dev", retval,
_("while zeroing journal device (block %u, count %d)"),
blk, count);
exit(1);
}
zero_blocks(0, 0, 0, 0, 0, 0);
retval = io_channel_write_blk(fs->io,
fs->super->s_first_data_block+1,
1, buf);
if (retval) {
com_err("create_journal_dev", retval,
_("while writing journal superblock"));
exit(1);
}
progress_close(&progress);
}
// Progress window task
void __saveds progress_task(void)
{
IPCData *ipc;
ProgressWindow *prog;
IPCMessage *msg;
// Do startup
if (!(ipc=L_IPC_ProcStartup((ULONG *)&prog,0)))
return;
// Fix A4 pointer
putreg(REG_A4,prog->pw_A4);
/*
// Debug?
if (prog->pw_Flags&PWF_DEBUG)
KPrintF("progress task : code entry %lx\n",(ULONG)progress_task);
*/
// Open invisibly?
if (prog->pw_Flags&PWF_INVISIBLE) prog->pw_Flags&=~PWF_INVISIBLE;
// Open progress window
else progress_open(prog);
// Loop for messages
FOREVER
{
BOOL quit=0;
// Window open?
if (prog->pw_Window)
{
struct IntuiMessage *msg;
// Look for messages
while (msg=(struct IntuiMessage *)GetMsg(prog->pw_Window->UserPort))
{
// Look at message
switch (msg->Class)
{
// Key press
case IDCMP_RAWKEY:
// If not escape, break
if (msg->Code!=0x45) break;
// Abort
case IDCMP_CLOSEWINDOW:
case IDCMP_GADGETUP:
// Task to signal?
if (prog->pw_SigTask) Signal(prog->pw_SigTask,1<<prog->pw_SigBit);
// Set flag
prog->pw_Flags|=PWF_ABORTED;
break;
// Refresh
case IDCMP_REFRESHWINDOW:
// Refresh window
BeginRefresh(prog->pw_Window);
progress_draw(prog,PWF_ALL);
EndRefresh(prog->pw_Window,TRUE);
break;
}
// Reply the message
ReplyMsg((struct Message *)msg);
}
}
// Any messages?
while (msg=(IPCMessage *)GetMsg(ipc->command_port))
{
// Look at message
switch (msg->command)
{
// Hide
case IPC_HIDE:
progress_close(prog);
break;
// Show
case IPC_SHOW:
progress_open(prog);
break;
// Quit
case IPC_QUIT:
quit=1;
break;
// Set parameters
case PROGRESS_SET:
progress_set(prog,(struct TagItem *)msg->data);
break;
// Get parameters
case PROGRESS_GET:
progress_get(prog,(struct TagItem *)msg->data);
break;
}
// Reply to the message
IPC_Reply(msg);
}
// Quit?
if (quit) break;
// Wait for messages
Wait( 1<<ipc->command_port->mp_SigBit|
((prog->pw_Window)?1<<prog->pw_Window->UserPort->mp_SigBit:0));
}
// Close window
progress_close(prog);
// Free IPC data
IPC_Free(ipc);
// Free control structure
FreeVec(prog);
}
