vitalif
/
e2fsprogs
mirror of https://github.com/vitalif/e2fsprogs
1
0
Fork 0
Code Issues Releases Wiki Activity
e2fsprogs/lib/evms/fsimext2.c

719 lines
20 KiB
C
Raw Blame History

/*
*
* Copyright (c) International Business Machines Corp., 2000
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
* the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Module: fsimext2.c
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <plugin.h>
#include "fsimext2.h"
int fsim_rw_diskblocks( int, int64_t, int32_t, void *, int );
void set_mkfs_options( option_array_t *, char **, logical_volume_t *, char * );
void set_fsck_options( option_array_t *, char **, logical_volume_t * );
/* Vector of plugin record ptrs that we export for the EVMS Engine. */
plugin_record_t *evms_plugin_records[] = {
&ext2_plugrec,
NULL
};
static plugin_record_t * pMyPluginRecord = &ext2_plugrec;
/*-------------------------------------------------------------------------------------+
+ +
+ Common Routines +
+ +
+--------------------------------------------------------------------------------------*/
/*
* Get the size limits for this volume.
*/
int fsim_get_volume_limits( struct ext2_super_block * sb,
sector_count_t * fs_min_size,
sector_count_t * fs_max_size,
sector_count_t * vol_max_size)
{
int rc = 0;
int blk_to_sect;
blk_to_sect = (1 + sb->s_log_block_size);
*fs_min_size = (sb->s_blocks_count - sb->s_free_blocks_count) << blk_to_sect;
*fs_max_size = (sector_count_t) 1 << (32+blk_to_sect);
*vol_max_size = 0xffffffffff;
LOGEXITRC();
return rc;
}
/*
* Un-Format the volume.
*/
int fsim_unmkfs( logical_volume_t * volume )
{
int fd;
int rc = 0;
LOGENTRY();
fd = open(EVMS_GET_DEVNAME(volume), O_RDWR|O_EXCL, 0);
if (fd < 0) return -1;
if ( volume->private_data ) {
/* clear private data */
memset( (void *) volume->private_data, 0, SIZE_OF_SUPER );
/* zero primary superblock */
rc = fsim_rw_diskblocks( fd, EXT2_SUPER_LOC, SIZE_OF_SUPER,
volume->private_data, PUT );
} else {
rc = ERROR;
}
fd = close(fd);
LOGEXITRC();
return rc;
}
/*
* Format the volume.
*/
int fsim_mkfs(logical_volume_t * volume, option_array_t * options )
{
int rc = FSIM_ERROR;
char *argv[MKFS_EXT2_OPTIONS_COUNT + 6];
char logsize[sizeof(unsigned int) + 1];
pid_t pidm;
int status;
LOGENTRY();
/* Fork and execute the correct program. */
switch (pidm = fork()) {
/* error */
case -1:
rc = EIO;
/* child */
case 0:
set_mkfs_options( options, argv, volume, logsize );
/* close stderr, stdout to suppress mke2fs output */
close(1);
close(2);
open("/dev/null", O_WRONLY);
open("/dev/null", O_WRONLY);
(void) execvp(argv[0], argv);
/* using exit() can hang GUI, use _exit */
_exit(errno);
/* parent */
default:
/* wait for child to complete */
while (1) {
rc = waitpid( pidm, &status, 0 );
if (rc == -1) {
if (errno == EINTR)
continue;
rc = errno;
goto reterr;
} else
break;
}
if ( WIFEXITED(status) ) {
/* get mke2fs exit code */
rc = WEXITSTATUS(status);
if (rc)
LOG("mke2fs exited with status %d", rc);
} else {
if (WIFSIGNALED(status))
LOG("mke2fs died with signal %d",
WTERMSIG(status));
rc = EINTR;
}
}
reterr:
LOGEXITRC();
return rc;
}
/*
* NAME: set_mkfs_options
*
* FUNCTION: Build options array (argv) for mkfs.ext2
*
* PARAMETERS:
* options - options array passed from EVMS engine
* argv - mkfs options array
* vol_name - volume name on which program will be executed
*
*/
void set_mkfs_options( option_array_t * options,
char ** argv,
logical_volume_t * volume,
char * logsize )
{
int i, bufsize, opt_count = 2;
char *buf;
LOGENTRY();
argv[0] = "mke2fs";
/* 'quiet' option */
argv[1] = "-q";
/* the following is a big hack to make sure that we don't use a block */
/* size smaller than hardsector size since this does not work. */
/* would be nice if the ext2/3 utilities (mkfs) handled this themselves */
/* also, eventually we will implement this as a user option to manually */
/* set block size */
if (volume->object->geometry.bytes_per_sector != EVMS_VSECTOR_SIZE) {
switch (volume->object->geometry.bytes_per_sector) {
case 2048:
argv[2] = "-b2048";
opt_count++;
break;
case 4096:
argv[2] = "-b4096";
opt_count++;
break;
default:
/* not one we expect, just skip it */
break;
}
}
for ( i=0; i<options->count; i++ ) {
if ( options->option[i].is_number_based ) {
switch (options->option[i].number) {
case MKFS_CHECKBB_INDEX:
/* 'check for bad blocks' option */
if ( options->option[i].value.bool == TRUE ) {
argv[opt_count++] = "-c";
}
break;
case MKFS_CHECKRW_INDEX:
/* 'check for r/w bad blocks' option */
if ( options->option[i].value.bool == TRUE ) {
argv[opt_count++] = "-cc";
}
break;
case MKFS_JOURNAL_INDEX:
/* 'create ext3 journal' option */
if ( options->option[i].value.bool == TRUE ) {
argv[opt_count++] = "-j";
}
break;
case MKFS_SETVOL_INDEX:
/* 'set volume name' option */
if ( options->option[i].value.s ) {
argv[opt_count++] = "-L";
argv[opt_count++] = options->option[i].value.s;
}
break;
default:
break;
}
} else {
if ( !strcmp(options->option[i].name, "badblocks") ) {
/* 'check for bad blocks' option */
if ( options->option[i].value.bool == TRUE ) {
argv[opt_count++] = "-c";
}
}
if ( !strcmp(options->option[i].name, "badblocks_rw") ) {
/* 'check for r/w bad blocks' option */
if ( options->option[i].value.bool == TRUE ) {
argv[opt_count++] = "-cc";
}
}
if ( !strcmp(options->option[i].name, "journal") ) {
/* 'create ext3 journal' option */
if ( options->option[i].value.bool == TRUE ) {
argv[opt_count++] = "-j";
}
}
if ( !strcmp(options->option[i].name, "vollabel") ) {
/* 'check for bad blocks' option */
if ( options->option[i].value.s ) {
argv[opt_count++] = "-L";
argv[opt_count++] = options->option[i].value.s;
}
}
}
}
argv[opt_count++] = EVMS_GET_DEVNAME(volume);
argv[opt_count] = NULL;
bufsize = 0;
for (i=0; argv[i]; i++)
bufsize += strlen(argv[i]) + 5;
buf = malloc(bufsize+1);
if (!buf)
return;
buf[0] = 0;
for (i=0; argv[i]; i++) {
strcat(buf, argv[i]);
strcat(buf, " ");
}
EngFncs->write_log_entry(DEBUG, pMyPluginRecord,
"mke2fs command: %s\n", buf);
free(buf);
LOGEXIT();
return;
}
/*
* Run fsck on the volume.
*/
int fsim_fsck(logical_volume_t * volume, option_array_t * options,
int *ret_status)
{
int rc = FSIM_ERROR;
char *argv[FSCK_EXT2_OPTIONS_COUNT + 3];
pid_t pidf;
int status, bytes_read;
char *buffer = NULL;
int fds2[2];
int banner = 0;
LOGENTRY();
/* open pipe, alloc buffer for collecting fsck.jfs output */
rc = pipe(fds2);
if (rc) {
return(errno);
}
if (!(buffer = EngFncs->engine_alloc(MAX_USER_MESSAGE_LEN))) {
return(ENOMEM);
}
/* Fork and execute the correct program. */
switch (pidf = fork()) {
/* error */
case -1:
rc = EIO;
/* child */
case 0:
set_fsck_options( options, argv, volume );
/* pipe stderr, stdout */
dup2(fds2[1],1); /* fds2[1] replaces stdout */
dup2(fds2[1],2); /* fds2[1] replaces stderr */
close(fds2[0]); /* don't need this here */
execvp( argv[0], argv );
/* should never get here */
_exit(8); /* FSCK_ERROR -- operational error */
/* parent */
default:
close(fds2[1]);
/* wait for child to complete */
fcntl(fds2[0], F_SETFL, fcntl(fds2[0], F_GETFL,0) | O_NONBLOCK);
while (!(waitpid( pidf, &status, WNOHANG ))) {
/* read e2fsck output */
bytes_read = read(fds2[0],buffer,MAX_USER_MESSAGE_LEN);
if (bytes_read > 0) {
/* display e2fsck output */
if (!banner)
MESSAGE("e2fsck output:");
banner = 1;
MESSAGE("%s",buffer);
memset(buffer,0,bytes_read); /* clear out message */
}
usleep(10000); /* don't hog all the cpu */
}
/* do final read, just in case we missed some */
bytes_read = read(fds2[0],buffer,MAX_USER_MESSAGE_LEN);
if (bytes_read > 0) {
if (!banner)
MESSAGE("e2fsck output:");
MESSAGE("%s",buffer);
}
if ( WIFEXITED(status) ) {
/* get e2fsck exit code */
*ret_status = WEXITSTATUS(status);
LOG("e2fsck completed with exit code %d\n",
*ret_status);
rc = 0;
} else {
if (WIFSIGNALED(status))
LOG("e2fsck died with signal %d",
WTERMSIG(status));
rc = EINTR;
}
}
if (buffer) {
EngFncs->engine_free(buffer);
}
close(fds2[0]);
LOGEXITRC();
return rc;
}
/*
* NAME: set_fsck_options
*
* FUNCTION: Build options array (argv) for e2fsck
*
* PARAMETERS:
* options - options array passed from EVMS engine
* argv - fsck options array
* volume - volume on which program will be executed
*
*/
void set_fsck_options( option_array_t * options, char ** argv, logical_volume_t * volume )
{
int i, bufsize, num_opts, opt_count = 1;
int do_preen = 1;
char *buf;
LOGENTRY();
argv[0] = "e2fsck";
if (options)
num_opts = options->count;
else {
/* No options, assume force (for resizing) */
argv[opt_count++] = "-f";
num_opts = 0;
}
for ( i=0; i < num_opts; i++) {
if ( options->option[i].is_number_based ) {
/* 'force check' option */
if ( (options->option[i].number == FSCK_FORCE_INDEX) &&
(options->option[i].value.bool == TRUE) ) {
argv[opt_count++] = "-f";
}
/* 'check read only' option or mounted */
if ((options->option[i].number == FSCK_READONLY_INDEX) &&
((options->option[i].value.bool == TRUE) ||
EVMS_IS_MOUNTED(volume))) {
argv[opt_count++] = "-n";
do_preen = 0;
}
/* 'bad blocks check' option and NOT mounted */
if ( (options->option[i].number == FSCK_CHECKBB_INDEX) &&
(options->option[i].value.bool == TRUE) &&
!EVMS_IS_MOUNTED(volume) ) {
argv[opt_count++] = "-c";
do_preen = 0;
}
/* 'bad blocks check' option and NOT mounted */
if ( (options->option[i].number == FSCK_CHECKRW_INDEX) &&
(options->option[i].value.bool == TRUE) &&
!EVMS_IS_MOUNTED(volume) ) {
argv[opt_count++] = "-cc";
do_preen = 0;
}
/* timing option */
if ( (options->option[i].number == FSCK_TIMING_INDEX) &&
(options->option[i].value.bool == TRUE) ) {
argv[opt_count++] = "-tt";
}
} else {
/* 'force check' option selected and NOT mounted */
if ( !strcmp(options->option[i].name, "force") &&
(options->option[i].value.bool == TRUE) &&
!EVMS_IS_MOUNTED(volume) ) {
argv[opt_count++] = "-f";
}
/* 'check read only' option selected or mounted */
if ((!strcmp(options->option[i].name, "readonly")) &&
((options->option[i].value.bool == TRUE) ||
EVMS_IS_MOUNTED(volume))) {
argv[opt_count++] = "-n";
do_preen = 0;
}
/* 'check badblocks' option selected and NOT mounted */
if (!strcmp(options->option[i].name, "badblocks") &&
(options->option[i].value.bool == TRUE) &&
!EVMS_IS_MOUNTED(volume)) {
argv[opt_count++] = "-c";
do_preen = 0;
}
/* 'check r/w badblocks' option selected and NOT mounted */
if (!strcmp(options->option[i].name, "badblocks_rw") &&
(options->option[i].value.bool == TRUE) &&
!EVMS_IS_MOUNTED(volume)) {
argv[opt_count++] = "-cc";
do_preen = 0;
}
/* 'timing' option selected */
if (!strcmp(options->option[i].name, "badblocks") &&
(options->option[i].value.bool == TRUE)) {
argv[opt_count++] = "-tt";
}
}
}
if (do_preen)
argv[opt_count++] = "-p";
argv[opt_count++] = EVMS_GET_DEVNAME(volume);
argv[opt_count] = NULL;
bufsize = 0;
for (i=0; argv[i]; i++)
bufsize += strlen(argv[i]) + 5;
buf = malloc(bufsize+1);
if (!buf)
return;
buf[0] = 0;
for (i=0; argv[i]; i++) {
strcat(buf, argv[i]);
strcat(buf, " ");
}
EngFncs->write_log_entry(DEBUG, pMyPluginRecord,
"fsck command: %s\n", buf);
free(buf);
LOGEXIT();
return;
}
/*
* NAME:ext2fs_swap_super
*
* FUNCTION: Swap all fields in the super block to CPU format.
*
* PARAMETERS:
* sb - pointer to superblock
*
* RETURNS:
* void
*/
static void ext2fs_swap_super(struct ext2_super_block * sb)
{
LOGENTRY();
sb->s_inodes_count = DISK_TO_CPU32(sb->s_inodes_count);
sb->s_blocks_count = DISK_TO_CPU32(sb->s_blocks_count);
sb->s_r_blocks_count = DISK_TO_CPU32(sb->s_r_blocks_count);
sb->s_free_blocks_count = DISK_TO_CPU32(sb->s_free_blocks_count);
sb->s_free_inodes_count = DISK_TO_CPU32(sb->s_free_inodes_count);
sb->s_first_data_block = DISK_TO_CPU32(sb->s_first_data_block);
sb->s_log_block_size = DISK_TO_CPU32(sb->s_log_block_size);
sb->s_log_frag_size = DISK_TO_CPU32(sb->s_log_frag_size);
sb->s_blocks_per_group = DISK_TO_CPU32(sb->s_blocks_per_group);
sb->s_frags_per_group = DISK_TO_CPU32(sb->s_frags_per_group);
sb->s_inodes_per_group = DISK_TO_CPU32(sb->s_inodes_per_group);
sb->s_mtime = DISK_TO_CPU32(sb->s_mtime);
sb->s_wtime = DISK_TO_CPU32(sb->s_wtime);
sb->s_mnt_count = DISK_TO_CPU16(sb->s_mnt_count);
sb->s_max_mnt_count = DISK_TO_CPU16(sb->s_max_mnt_count);
sb->s_magic = DISK_TO_CPU16(sb->s_magic);
sb->s_state = DISK_TO_CPU16(sb->s_state);
sb->s_errors = DISK_TO_CPU16(sb->s_errors);
sb->s_minor_rev_level = DISK_TO_CPU16(sb->s_minor_rev_level);
sb->s_lastcheck = DISK_TO_CPU32(sb->s_lastcheck);
sb->s_checkinterval = DISK_TO_CPU32(sb->s_checkinterval);
sb->s_creator_os = DISK_TO_CPU32(sb->s_creator_os);
sb->s_rev_level = DISK_TO_CPU32(sb->s_rev_level);
sb->s_def_resuid = DISK_TO_CPU16(sb->s_def_resuid);
sb->s_def_resgid = DISK_TO_CPU16(sb->s_def_resgid);
sb->s_first_ino = DISK_TO_CPU32(sb->s_first_ino);
sb->s_inode_size = DISK_TO_CPU16(sb->s_inode_size);
sb->s_block_group_nr = DISK_TO_CPU16(sb->s_block_group_nr);
sb->s_feature_compat = DISK_TO_CPU32(sb->s_feature_compat);
sb->s_feature_incompat = DISK_TO_CPU32(sb->s_feature_incompat);
sb->s_feature_ro_compat = DISK_TO_CPU32(sb->s_feature_ro_compat);
sb->s_algorithm_usage_bitmap = DISK_TO_CPU32(sb->s_algorithm_usage_bitmap);
sb->s_journal_inum = DISK_TO_CPU32(sb->s_journal_inum);
sb->s_journal_dev = DISK_TO_CPU32(sb->s_journal_dev);
sb->s_last_orphan = DISK_TO_CPU32(sb->s_last_orphan);
LOGEXIT();
}
/*
* NAME: fsim_get_ext2_superblock
*
* FUNCTION: Get and validate a ext2/3 superblock
*
* PARAMETERS:
* volume - pointer to volume from which to get the superblock
* sb_ptr - pointer to superblock
*
* RETURNS:
* (0) for success
* != 0 otherwise
*
*/
int fsim_get_ext2_superblock( logical_volume_t *volume, struct ext2_super_block *sb_ptr )
{
int fd;
int rc = 0;
LOGENTRY();
fd = open(EVMS_GET_DEVNAME(volume), O_RDONLY, 0);
if (fd < 0) {
rc = EIO;
LOGEXITRC();
return rc;
}
/* get primary superblock */
rc = fsim_rw_diskblocks( fd, EXT2_SUPER_LOC, SIZE_OF_SUPER, sb_ptr, GET );
if( rc == 0 ) {
ext2fs_swap_super(sb_ptr);
/* see if superblock is ext2/3 */
if (( sb_ptr->s_magic != EXT2_SUPER_MAGIC ) ||
( sb_ptr->s_rev_level > 1 ))
rc = FSIM_ERROR;
}
close(fd);
LOGEXITRC();
return rc;
}
/*
* NAME: fsim_rw_diskblocks
*
* FUNCTION: Read or write specific number of bytes for an opened device.
*
* PARAMETERS:
* dev_ptr - file handle of an opened device to read/write
* disk_offset - byte offset from beginning of device for start of disk
* block read/write
* disk_count - number of bytes to read/write
* data_buffer - On read this will be filled in with data read from
* disk; on write this contains data to be written
* mode - GET (read) or PUT (write)
*
* RETURNS:
* FSIM_SUCCESS (0) for success
* ERROR (-1) can't lseek
* EINVAL
* EIO
*
*/
int fsim_rw_diskblocks( int dev_ptr,
int64_t disk_offset,
int32_t disk_count,
void *data_buffer,
int mode )
{
off_t Actual_Location;
size_t Bytes_Transferred;
int rc = 0;
LOGENTRY();
Actual_Location = lseek(dev_ptr,disk_offset, SEEK_SET);
if ( ( Actual_Location < 0 ) || ( Actual_Location != disk_offset ) )
return ERROR;
switch ( mode ) {
case GET:
Bytes_Transferred = read(dev_ptr,data_buffer,disk_count);
break;
case PUT:
Bytes_Transferred = write(dev_ptr,data_buffer,disk_count);
break;
default:
rc = EINVAL;
LOGEXITRC();
return rc;
break;
}
if ( Bytes_Transferred != disk_count ) {
rc = EIO;
LOGEXITRC();
return rc;
}
LOGEXIT();
return FSIM_SUCCESS;
}
/*
* Test e2fsprogs version.
*
* We don't bother since we don't need any special functionality that
* hasn't been around for *years*
*/
int fsim_test_version( )
{
return 0;
}
Reference in New Issue View Git Blame Copy Permalink