Page Menu
Home
Phabricator
Search
Configure Global Search
Log In
Files
F4324354
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Size
159 KB
Referenced Files
None
Subscribers
None
View Options
diff --git a/src/xmount.c b/src/xmount.c
index cae2851..bac6ddc 100755
--- a/src/xmount.c
+++ b/src/xmount.c
@@ -1,2170 +1,2168 @@
/*******************************************************************************
* xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu> *
* *
* xmount is a small tool to "fuse mount" various harddisk image formats as dd, *
* vdi, vhd or vmdk files and enable virtual write access to them. *
* *
* 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 3 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, see <http://www.gnu.org/licenses/>. *
*******************************************************************************/
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <inttypes.h> // For PRI*
#include <errno.h>
#include <dlfcn.h> // For dlopen, dlclose, dlsym
#include <dirent.h> // For opendir, readdir, closedir
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/stat.h> // For fstat
#include <sys/types.h>
#ifdef HAVE_LINUX_FS_H
#include <linux/fs.h> // For SEEK_* ??
#endif
#if !defined(__APPLE__) && defined(HAVE_GRP_H) && defined(HAVE_PWD_H)
#include <grp.h> // For getgrnam, struct group
#include <pwd.h> // For getpwuid, struct passwd
#endif
#include <pthread.h>
#include <time.h> // For time
#include "xmount.h"
#include "xmount_fuse.h"
#include "md5.h"
#include "macros.h"
#include "../libxmount/libxmount.h"
#define XMOUNT_COPYRIGHT_NOTICE \
"xmount v%s Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>"
#define LOG_WARNING(...) { \
LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
}
#define LOG_ERROR(...) { \
LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
}
#define LOG_DEBUG(...) { \
LIBXMOUNT_LOG_DEBUG(glob_xmount.debug,__VA_ARGS__); \
}
#define HASH_AMOUNT (1024*1024)*10 // Amount of data used to construct a
// "unique" hash for every input image
// (10MByte)
/*******************************************************************************
* Forward declarations
******************************************************************************/
/*
* Misc
*/
static void InitResources();
static void FreeResources();
static void PrintUsage(char*);
static void CheckFuseSettings();
static int ParseCmdLine(const int, char**);
static int ExtractOutputFileNames(char*);
static int CalculateInputImageHash(uint64_t*, uint64_t*);
/*
* Info file
*/
static int InitInfoFile();
/*
* Lib related
*/
static int LoadLibs();
static int FindInputLib(pts_InputImage);
static int FindMorphingLib();
static int FindOutputLib();
static int SplitLibraryParameters(char*, uint32_t*, pts_LibXmountOptions**);
/*
* Functions exported to LibXmount_Morphing
*/
static int LibXmount_Morphing_ImageCount(uint64_t*);
static int LibXmount_Morphing_Size(uint64_t, uint64_t*);
static int LibXmount_Morphing_Read(uint64_t, char*, off_t, size_t, size_t*);
/*
* Functions exported to LibXmount_Output
*/
static int LibXmount_Output_Size(uint64_t*);
static int LibXmount_Output_Read(char*, off_t, size_t, size_t*);
static int LibXmount_Output_Write(char*, off_t, size_t, size_t*);
/*******************************************************************************
* Helper functions
******************************************************************************/
//! Print usage instructions (cmdline options etc..)
/*!
* \param p_prog_name Program name (argv[0])
*/
static void PrintUsage(char *p_prog_name) {
char *p_buf;
int first;
int ret;
printf("\n" XMOUNT_COPYRIGHT_NOTICE "\n",XMOUNT_VERSION);
printf("\nUsage:\n");
printf(" %s [fopts] <xopts> <mntp>\n\n",p_prog_name);
printf("Options:\n");
printf(" fopts:\n");
printf(" -d : Enable FUSE's and xmount's debug mode.\n");
printf(" -h : Display this help message.\n");
printf(" -s : Run single threaded.\n");
printf(" -o no_allow_other : Disable automatic addition of FUSE's "
"allow_other option.\n");
printf(" -o <fopts> : Specify fuse mount options. Will also disable "
"automatic addition of FUSE's allow_other option!\n");
printf("\n");
printf(" xopts:\n");
printf(" --cache <cfile> : Enable virtual write support.\n");
printf(" <cfile> specifies the cache file to use.\n");
printf(" --in <itype> <ifile> : Input image format and source file(s). "
"May be specified multiple times.\n");
printf(" <itype> can be ");
// List supported input formats
first=1;
for(uint32_t i=0;i<glob_xmount.input.libs_count;i++) {
p_buf=glob_xmount.input.pp_libs[i]->p_supported_input_types;
while(*p_buf!='\0') {
if(first==1) {
printf("\"%s\"",p_buf);
first=0;
} else printf(", \"%s\"",p_buf);
p_buf+=(strlen(p_buf)+1);
}
}
printf(".\n");
printf(" <ifile> specifies the source file. If your image is split into "
"multiple files, you have to specify them all!\n");
printf(" --inopts <iopts> : Specify input library specific options.\n");
printf(" <iopts> specifies a comma separated list of key=value options. "
"See below for details.\n");
printf(" --info : Print out infos about used compiler and libraries.\n");
printf(" --morph <mtype> : Morphing function to apply to input image(s). "
"If not specified, defaults to \"combine\".\n");
printf(" <mtype> can be ");
// List supported morphing functions
first=1;
for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
p_buf=glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types;
while(*p_buf!='\0') {
if(first==1) {
printf("\"%s\"",p_buf);
first=0;
} else printf(", \"%s\"",p_buf);
p_buf+=(strlen(p_buf)+1);
}
}
printf(".\n");
printf(" --morphopts <mopts> : Specify morphing library specific "
"options.\n");
printf(" <mopts> specifies a comma separated list of key=value options. "
"See below for details.\n");
printf(" --offset <off> : Move the output image data start <off> bytes "
"into the input image(s).\n");
printf(" --out <otype> : Output image format. If not specified, "
"defaults to ");
#ifdef __APPLE__
printf("\"dmg\".\n");
#else
printf("\"raw\".\n");
#endif
printf(" <otype> can be ");
// List supported output formats
first=1;
for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
p_buf=glob_xmount.output.pp_libs[i]->p_supported_output_formats;
while(*p_buf!='\0') {
if(first==1) {
printf("\"%s\"",p_buf);
first=0;
} else printf(", \"%s\"",p_buf);
p_buf+=(strlen(p_buf)+1);
}
}
printf(".\n");
printf(" --outopts <oopts> : Specify output library specific "
"options.\n");
printf(" --owcache <file> : Same as --cache <file> but overwrites "
"existing cache file.\n");
printf(" --sizelimit <size> : The data end of input image(s) is set to no "
"more than <size> bytes after the data start.\n");
printf(" --version : Same as --info.\n");
printf("\n");
printf(" mntp:\n");
printf(" Mount point where output image should be located.\n");
printf("\n");
printf("Infos:\n");
printf(" * One --in option and a mount point are mandatory!\n");
printf(" * If you specify --in multiple times, data from all images is "
"morphed into one output image using the specified morphing "
"function.\n");
printf(" * For VMDK emulation, you have to uncomment \"user_allow_other\" "
"in /etc/fuse.conf or run xmount as root.\n");
printf("\n");
printf("Input / Morphing library specific options:\n");
printf(" Input / Morphing libraries might support an own set of "
"options to configure / tune their behaviour.\n");
printf(" Libraries supporting this feature (if any) and their "
"options are listed below.\n");
printf("\n");
// List input, morphing and output lib options
for(uint32_t i=0;i<glob_xmount.input.libs_count;i++) {
ret=glob_xmount.input.pp_libs[i]->
lib_functions.OptionsHelp((const char**)&p_buf);
if(ret!=0) {
LOG_ERROR("Unable to get options help for library '%s': %s!\n",
glob_xmount.input.pp_libs[i]->p_name,
glob_xmount.input.pp_libs[i]->
lib_functions.GetErrorMessage(ret));
}
if(p_buf==NULL) continue;
printf(" - %s\n",glob_xmount.input.pp_libs[i]->p_name);
printf("%s",p_buf);
printf("\n");
ret=glob_xmount.input.pp_libs[i]->lib_functions.FreeBuffer(p_buf);
if(ret!=0) {
LOG_ERROR("Unable to free options help text from library '%s': %s!\n",
glob_xmount.input.pp_libs[i]->p_name,
glob_xmount.input.pp_libs[i]->
lib_functions.GetErrorMessage(ret));
}
}
for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
ret=glob_xmount.morphing.pp_libs[i]->
lib_functions.OptionsHelp((const char**)&p_buf);
if(ret!=0) {
LOG_ERROR("Unable to get options help for library '%s': %s!\n",
glob_xmount.morphing.pp_libs[i]->p_name,
glob_xmount.morphing.pp_libs[i]->
lib_functions.GetErrorMessage(ret));
}
if(p_buf==NULL) continue;
printf(" - %s\n",glob_xmount.morphing.pp_libs[i]->p_name);
printf("%s",p_buf);
printf("\n");
}
for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
ret=glob_xmount.output.pp_libs[i]->
lib_functions.OptionsHelp((const char**)&p_buf);
if(ret!=0) {
LOG_ERROR("Unable to get options help for library '%s': %s!\n",
glob_xmount.output.pp_libs[i]->p_name,
glob_xmount.output.pp_libs[i]->
lib_functions.GetErrorMessage(ret));
}
if(p_buf==NULL) continue;
printf(" - %s\n",glob_xmount.output.pp_libs[i]->p_name);
printf("%s",p_buf);
printf("\n");
}
}
//! Check fuse settings
/*!
* Check if FUSE allows us to pass the -o allow_other parameter. This only works
* if we are root or user_allow_other is set in /etc/fuse.conf.
*
* In addition, this function also checks if the user is member of the fuse
* group which is generally needed to use fuse at all.
*/
static void CheckFuseSettings() {
#if !defined(__APPLE__) && defined(HAVE_GRP_H) && defined(HAVE_PWD_H)
struct group *p_group;
struct passwd *p_passwd;
#endif
int found;
FILE *h_fuse_conf;
char line[256];
glob_xmount.may_set_fuse_allow_other=FALSE;
if(geteuid()==0) {
// Running as root, there should be no problems
glob_xmount.may_set_fuse_allow_other=TRUE;
return;
}
#if !defined(__APPLE__) && defined(HAVE_GRP_H) && defined(HAVE_PWD_H)
// Check if a fuse group exists and if so, make sure user is a member of it.
// Makes only sense on Linux because as far as I know osxfuse has no own group
p_group=getgrnam("fuse");
if(p_group!=NULL) {
// Get effective user name
p_passwd=getpwuid(geteuid());
if(p_passwd==NULL) {
printf("\nWARNING: Unable to determine your effective user name. If "
"mounting works, you can ignore this message.\n\n");
return;
}
// Check if user is member of fuse group
found=FALSE;
while(*(p_group->gr_mem)!=NULL) {
if(strcmp(*(p_group->gr_mem),p_passwd->pw_name)==0) {
found=TRUE;
break;
}
p_group->gr_mem++;
}
if(found==FALSE) {
printf("\nWARNING: You are not a member of the \"fuse\" group. This will "
"prevent you from mounting images using xmount. Please add "
"yourself to the \"fuse\" group using the command "
"\"sudo usermod -a -G fuse %s\" and reboot your system or "
"execute xmount as root.\n\n",
p_passwd->pw_name);
return;
}
} else {
printf("\nWARNING: Your system does not seem to have a \"fuse\" group. If "
"mounting works, you can ignore this message.\n\n");
}
#endif
// Read FUSE's config file /etc/fuse.conf and check for set user_allow_other
h_fuse_conf=(FILE*)FOPEN("/etc/fuse.conf","r");
if(h_fuse_conf!=NULL) {
// Search conf file for set user_allow_others
found=FALSE;
while(fgets(line,sizeof(line),h_fuse_conf)!=NULL) {
// TODO: This works as long as there is no other parameter beginning with
// "user_allow_other" :)
if(strncmp(line,"user_allow_other",16)==0) {
found=TRUE;
break;
}
}
fclose(h_fuse_conf);
if(found==TRUE) {
glob_xmount.may_set_fuse_allow_other=TRUE;
} else {
printf("\nWARNING: FUSE will not allow other users nor root to access "
"your virtual harddisk image. To change this behavior, please "
"add \"user_allow_other\" to /etc/fuse.conf or execute xmount "
"as root.\n\n");
}
} else {
printf("\nWARNING: Unable to open /etc/fuse.conf. If mounting works, you "
"can ignore this message. If you encounter issues, please create "
"the file and add a single line containing the string "
"\"user_allow_other\" or execute xmount as root.\n\n");
return;
}
}
//! Parse command line options
/*!
* \param argc Number of cmdline params
* \param pp_argv Array containing cmdline params
* \return TRUE on success, FALSE on error
*/
static int ParseCmdLine(const int argc, char **pp_argv) {
int i=1;
int FuseMinusOControl=TRUE;
int FuseAllowOther=TRUE;
int first;
char *p_buf;
pts_InputImage p_input_image=NULL;
int ret;
// add pp_argv[0] to FUSE's argv
XMOUNT_MALLOC(glob_xmount.pp_fuse_argv,char**,sizeof(char*));
XMOUNT_STRSET(glob_xmount.pp_fuse_argv[0],pp_argv[0]);
glob_xmount.fuse_argc=1;
// Parse options
while(i<argc && *pp_argv[i]=='-') {
if(strlen(pp_argv[i])>1 && *(pp_argv[i]+1)!='-') {
// Options beginning with one - are mostly FUSE specific
if(strcmp(pp_argv[i],"-d")==0) {
// Enable FUSE's and xmount's debug mode
XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
char**,
(glob_xmount.fuse_argc+1)*sizeof(char*));
XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
pp_argv[i])
glob_xmount.fuse_argc++;
glob_xmount.debug=TRUE;
} else if(strcmp(pp_argv[i],"-h")==0) {
// Print help message
PrintUsage(pp_argv[0]);
exit(0);
} else if(strcmp(pp_argv[i],"-o")==0) {
// Next parameter specifies fuse mount options
if((i+1)<argc) {
i++;
// As the user specified the -o option, we assume he knows what he is
// doing. We won't append allow_other automatically. And we allow him
// to disable allow_other by passing a single "-o no_allow_other"
// which won't be passed to FUSE as it is xmount specific.
if(strcmp(pp_argv[i],"no_allow_other")!=0) {
glob_xmount.fuse_argc+=2;
XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
char**,
glob_xmount.fuse_argc*sizeof(char*));
XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-2],
pp_argv[i-1]);
XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
pp_argv[i]);
FuseMinusOControl=FALSE;
} else FuseAllowOther=FALSE;
} else {
LOG_ERROR("Couldn't parse fuse mount options!\n")
return FALSE;
}
} else if(strcmp(pp_argv[i],"-s")==0) {
// Enable FUSE's single threaded mode
XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
char**,
(glob_xmount.fuse_argc+1)*sizeof(char*));
XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
pp_argv[i]);
glob_xmount.fuse_argc++;
} else if(strcmp(pp_argv[i],"-V")==0) {
// Display FUSE version info
XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
char**,
(glob_xmount.fuse_argc+1)*sizeof(char*));
XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
pp_argv[i]);
glob_xmount.fuse_argc++;
} else {
LOG_ERROR("Unknown command line option \"%s\"\n",pp_argv[i]);
return FALSE;
}
} else {
// Options beginning with -- are xmount specific
if(strcmp(pp_argv[i],"--cache")==0 /*|| strcmp(pp_argv[i],"--rw")==0*/) {
// Emulate writable access to mounted image
// Next parameter must be cache file to read/write changes from/to
if((i+1)<argc) {
i++;
- XMOUNT_STRSET(glob_xmount.cache.p_cache_file,pp_argv[i])
+ XMOUNT_STRSET(glob_xmount.args.p_cache_file,pp_argv[i])
glob_xmount.output.writable=TRUE;
} else {
LOG_ERROR("You must specify a cache file!\n")
return FALSE;
}
LOG_DEBUG("Enabling virtual write support using cache file \"%s\"\n",
- glob_xmount.cache.p_cache_file)
+ glob_xmount.args.p_cache_file)
} else if(strcmp(pp_argv[i],"--in")==0) {
// Specify input image type and source files
if((i+2)<argc) {
i++;
// Alloc and init new ts_InputImage struct
XMOUNT_MALLOC(p_input_image,pts_InputImage,sizeof(ts_InputImage));
XMOUNT_STRSET(p_input_image->p_type,pp_argv[i]);
p_input_image->pp_files=NULL;
p_input_image->p_functions=NULL;
p_input_image->p_handle=NULL;
// Parse input image filename(s) and add to p_input_image->pp_files
i++;
p_input_image->files_count=0;
while(i<(argc-1) && strncmp(pp_argv[i],"--",2)!=0) {
p_input_image->files_count++;
XMOUNT_REALLOC(p_input_image->pp_files,
char**,
p_input_image->files_count*sizeof(char*));
XMOUNT_STRSET(p_input_image->pp_files[p_input_image->files_count-1],
pp_argv[i]);
i++;
}
i--;
if(p_input_image->files_count==0) {
LOG_ERROR("No input files specified for \"--in %s\"!\n",
p_input_image->p_type)
free(p_input_image->p_type);
free(p_input_image);
return FALSE;
}
// Add input image struct to input image array
glob_xmount.input.images_count++;
XMOUNT_REALLOC(glob_xmount.input.pp_images,
pts_InputImage*,
glob_xmount.input.images_count*
sizeof(pts_InputImage));
glob_xmount.input.pp_images[glob_xmount.input.images_count-1]=
p_input_image;
} else {
LOG_ERROR("You must specify an input image type and source file!\n");
return FALSE;
}
} else if(strcmp(pp_argv[i],"--inopts")==0) {
// Set input lib options
if((i+1)<argc) {
i++;
if(glob_xmount.input.pp_lib_params==NULL) {
if(SplitLibraryParameters(pp_argv[i],
&(glob_xmount.input.lib_params_count),
&(glob_xmount.input.pp_lib_params)
)==FALSE)
{
LOG_ERROR("Unable to parse input library options '%s'!\n",
pp_argv[i]);
return FALSE;
}
} else {
LOG_ERROR("You can only specify --inopts once!")
return FALSE;
}
} else {
LOG_ERROR("You must specify special options!\n");
return FALSE;
}
} else if(strcmp(pp_argv[i],"--morph")==0) {
// Set morphing lib to use
if((i+1)<argc) {
i++;
if(glob_xmount.morphing.p_morph_type==NULL) {
XMOUNT_STRSET(glob_xmount.morphing.p_morph_type,pp_argv[i]);
} else {
LOG_ERROR("You can only specify --morph once!")
return FALSE;
}
} else {
LOG_ERROR("You must specify morphing type!\n");
return FALSE;
}
} else if(strcmp(pp_argv[i],"--morphopts")==0) {
// Set morphing lib options
if((i+1)<argc) {
i++;
if(glob_xmount.morphing.pp_lib_params==NULL) {
if(SplitLibraryParameters(pp_argv[i],
&(glob_xmount.morphing.lib_params_count),
&(glob_xmount.morphing.pp_lib_params)
)==FALSE)
{
LOG_ERROR("Unable to parse morphing library options '%s'!\n",
pp_argv[i]);
return FALSE;
}
} else {
LOG_ERROR("You can only specify --morphopts once!")
return FALSE;
}
} else {
LOG_ERROR("You must specify special morphing lib params!\n");
return FALSE;
}
} else if(strcmp(pp_argv[i],"--offset")==0) {
// Set input image offset
if((i+1)<argc) {
i++;
glob_xmount.input.image_offset=StrToUint64(pp_argv[i],&ret);
if(ret==0) {
LOG_ERROR("Unable to convert '%s' to a number!\n",pp_argv[i])
return FALSE;
}
} else {
LOG_ERROR("You must specify an offset!\n")
return FALSE;
}
LOG_DEBUG("Setting input image offset to \"%" PRIu64 "\"\n",
glob_xmount.input.image_offset)
} else if(strcmp(pp_argv[i],"--out")==0) {
// Set output lib to use
if((i+1)<argc) {
i++;
if(glob_xmount.output.p_output_format==NULL) {
XMOUNT_STRSET(glob_xmount.output.p_output_format,pp_argv[i]);
} else {
LOG_ERROR("You can only specify --out once!")
return FALSE;
}
} else {
LOG_ERROR("You must specify an output format!\n");
return FALSE;
}
} else if(strcmp(pp_argv[i],"--outopts")==0) {
// Set output lib options
if((i+1)<argc) {
i++;
if(glob_xmount.output.pp_lib_params==NULL) {
if(SplitLibraryParameters(pp_argv[i],
&(glob_xmount.output.lib_params_count),
&(glob_xmount.output.pp_lib_params)
)==FALSE)
{
LOG_ERROR("Unable to parse output library options '%s'!\n",
pp_argv[i]);
return FALSE;
}
} else {
LOG_ERROR("You can only specify --outopts once!")
return FALSE;
}
} else {
LOG_ERROR("You must specify special output lib params!\n");
return FALSE;
}
} else if(strcmp(pp_argv[i],"--owcache")==0) {
// Enable writable access to mounted image and overwrite existing cache
// Next parameter must be cache file to read/write changes from/to
if((i+1)<argc) {
i++;
- XMOUNT_STRSET(glob_xmount.cache.p_cache_file,pp_argv[i])
+ XMOUNT_STRSET(glob_xmount.args.p_cache_file,pp_argv[i])
glob_xmount.output.writable=TRUE;
- glob_xmount.cache.overwrite_cache=TRUE;
+ glob_xmount.args.overwrite_cache=TRUE;
} else {
LOG_ERROR("You must specify a cache file!\n")
return FALSE;
}
LOG_DEBUG("Enabling virtual write support overwriting cache file %s\n",
- glob_xmount.cache.p_cache_file)
+ glob_xmount.args.p_cache_file)
} else if(strcmp(pp_argv[i],"--sizelimit")==0) {
// Set input image size limit
if((i+1)<argc) {
i++;
glob_xmount.input.image_size_limit=StrToUint64(pp_argv[i],&ret);
if(ret==0) {
LOG_ERROR("Unable to convert '%s' to a number!\n",pp_argv[i])
return FALSE;
}
} else {
LOG_ERROR("You must specify a size limit!\n")
return FALSE;
}
LOG_DEBUG("Setting input image size limit to \"%" PRIu64 "\"\n",
glob_xmount.input.image_size_limit)
} else if(strcmp(pp_argv[i],"--version")==0 ||
strcmp(pp_argv[i],"--info")==0)
{
// Print xmount info
printf(XMOUNT_COPYRIGHT_NOTICE "\n\n",XMOUNT_VERSION);
#ifdef __GNUC__
printf(" compile timestamp: %s %s\n",__DATE__,__TIME__);
printf(" gcc version: %s\n",__VERSION__);
#endif
printf(" loaded input libraries:\n");
for(uint32_t ii=0;ii<glob_xmount.input.libs_count;ii++) {
printf(" - %s supporting ",glob_xmount.input.pp_libs[ii]->p_name);
p_buf=glob_xmount.input.pp_libs[ii]->p_supported_input_types;
first=TRUE;
while(*p_buf!='\0') {
if(first) {
printf("\"%s\"",p_buf);
first=FALSE;
} else printf(", \"%s\"",p_buf);
p_buf+=(strlen(p_buf)+1);
}
printf("\n");
}
printf(" loaded morphing libraries:\n");
for(uint32_t ii=0;ii<glob_xmount.morphing.libs_count;ii++) {
printf(" - %s supporting ",
glob_xmount.morphing.pp_libs[ii]->p_name);
p_buf=glob_xmount.morphing.pp_libs[ii]->p_supported_morphing_types;
first=TRUE;
while(*p_buf!='\0') {
if(first) {
printf("\"%s\"",p_buf);
first=FALSE;
} else printf(", \"%s\"",p_buf);
p_buf+=(strlen(p_buf)+1);
}
printf("\n");
}
printf(" loaded output libraries:\n");
for(uint32_t ii=0;ii<glob_xmount.output.libs_count;ii++) {
printf(" - %s supporting ",
glob_xmount.output.pp_libs[ii]->p_name);
p_buf=glob_xmount.output.pp_libs[ii]->p_supported_output_formats;
first=TRUE;
while(*p_buf!='\0') {
if(first) {
printf("\"%s\"",p_buf);
first=FALSE;
} else printf(", \"%s\"",p_buf);
p_buf+=(strlen(p_buf)+1);
}
printf("\n");
}
printf("\n");
exit(0);
} else {
LOG_ERROR("Unknown command line option \"%s\"\n",pp_argv[i]);
return FALSE;
}
}
i++;
}
// Extract mountpoint
if(i==(argc-1)) {
XMOUNT_STRSET(glob_xmount.p_mountpoint,pp_argv[argc-1])
XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
char**,
(glob_xmount.fuse_argc+1)*sizeof(char*));
XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
glob_xmount.p_mountpoint);
glob_xmount.fuse_argc++;
} else {
LOG_ERROR("No mountpoint specified!\n")
return FALSE;
}
if(FuseMinusOControl==TRUE) {
// We control the -o flag, set subtype, fsname and allow_other options
glob_xmount.fuse_argc+=2;
XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
char**,
glob_xmount.fuse_argc*sizeof(char*));
XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-2],"-o");
XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
"subtype=xmount");
if(glob_xmount.input.images_count!=0) {
// Set name of first source file as fsname
XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
",fsname='");
// If possible, use full path
p_buf=realpath(glob_xmount.input.pp_images[0]->pp_files[0],NULL);
if(p_buf==NULL) {
XMOUNT_STRSET(p_buf,glob_xmount.input.pp_images[0]->pp_files[0]);
}
// Make sure fsname does not include some forbidden chars
for(uint32_t i=0;i<strlen(p_buf);i++) {
if(p_buf[i]=='\'') p_buf[i]='_';
}
// Set fsname
XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
p_buf);
XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
"'");
free(p_buf);
}
if(FuseAllowOther==TRUE) {
// Add "allow_other" option if allowed
if(glob_xmount.may_set_fuse_allow_other) {
XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
",allow_other");
}
}
}
return TRUE;
}
//! Extract output file name from input image name
/*!
* \param p_orig_name Name of input image (may include a path)
* \return TRUE on success, FALSE on error
*/
static int ExtractOutputFileNames(char *p_orig_name) {
char *tmp;
// Truncate any leading path
tmp=strrchr(p_orig_name,'/');
if(tmp!=NULL) p_orig_name=tmp+1;
// Extract file extension
tmp=strrchr(p_orig_name,'.');
// Set leading '/'
XMOUNT_STRSET(glob_xmount.output.p_virtual_image_path,"/");
XMOUNT_STRSET(glob_xmount.output.p_info_path,"/");
// Copy filename
if(tmp==NULL) {
// Input image filename has no extension
XMOUNT_STRAPP(glob_xmount.output.p_virtual_image_path,p_orig_name);
XMOUNT_STRAPP(glob_xmount.output.p_info_path,p_orig_name);
XMOUNT_STRAPP(glob_xmount.output.p_info_path,".info");
} else {
XMOUNT_STRNAPP(glob_xmount.output.p_virtual_image_path,p_orig_name,
strlen(p_orig_name)-strlen(tmp));
XMOUNT_STRNAPP(glob_xmount.output.p_info_path,p_orig_name,
strlen(p_orig_name)-strlen(tmp));
XMOUNT_STRAPP(glob_xmount.output.p_info_path,".info");
}
// Add virtual file extensions
// TODO: Get from output lib and add
//XMOUNT_STRAPP(glob_xmount.output.p_virtual_image_path,".dd");
LOG_DEBUG("Set virtual image name to \"%s\"\n",
glob_xmount.output.p_virtual_image_path);
LOG_DEBUG("Set virtual image info name to \"%s\"\n",
glob_xmount.output.p_info_path);
return TRUE;
}
//! Calculates an MD5 hash of the first HASH_AMOUNT bytes of the input image
/*!
* \param p_hash_low Pointer to the lower 64 bit of the hash
* \param p_hash_high Pointer to the higher 64 bit of the hash
* \return TRUE on success, FALSE on error
*/
static int CalculateInputImageHash(uint64_t *p_hash_low,
uint64_t *p_hash_high)
{
char hash[16];
md5_state_t md5_state;
char *p_buf;
int ret;
size_t read_data;
XMOUNT_MALLOC(p_buf,char*,HASH_AMOUNT*sizeof(char));
ret=ReadMorphedImageData(p_buf,0,HASH_AMOUNT,&read_data);
if(ret!=TRUE || read_data==0) {
LOG_ERROR("Couldn't read data from morphed image file!\n")
free(p_buf);
return FALSE;
}
// Calculate MD5 hash
md5_init(&md5_state);
md5_append(&md5_state,(const md5_byte_t*)p_buf,read_data);
md5_finish(&md5_state,(md5_byte_t*)hash);
// Convert MD5 hash into two 64bit integers
*p_hash_low=*((uint64_t*)hash);
*p_hash_high=*((uint64_t*)(hash+8));
free(p_buf);
return TRUE;
}
//! Create info file
/*!
* \return TRUE on success, FALSE on error
*/
static int InitInfoFile() {
int ret;
char *p_buf;
// Start with static input header
XMOUNT_MALLOC(glob_xmount.output.p_info_file,
char*,
strlen(IMAGE_INFO_INPUT_HEADER)+1);
strncpy(glob_xmount.output.p_info_file,
IMAGE_INFO_INPUT_HEADER,
strlen(IMAGE_INFO_INPUT_HEADER)+1);
// Get and add infos from input lib(s)
for(uint64_t i=0;i<glob_xmount.input.images_count;i++) {
ret=glob_xmount.input.pp_images[i]->p_functions->
GetInfofileContent(glob_xmount.input.pp_images[i]->p_handle,(const char**)&p_buf);
if(ret!=0) {
LOG_ERROR("Unable to get info file content for image '%s': %s!\n",
glob_xmount.input.pp_images[i]->pp_files[0],
glob_xmount.input.pp_images[i]->p_functions->
GetErrorMessage(ret));
return FALSE;
}
// Add infos to main buffer and free p_buf
XMOUNT_STRAPP(glob_xmount.output.p_info_file,"\n--> ");
XMOUNT_STRAPP(glob_xmount.output.p_info_file,
glob_xmount.input.pp_images[i]->pp_files[0]);
XMOUNT_STRAPP(glob_xmount.output.p_info_file," <--\n");
if(p_buf!=NULL) {
XMOUNT_STRAPP(glob_xmount.output.p_info_file,p_buf);
glob_xmount.input.pp_images[i]->p_functions->FreeBuffer(p_buf);
} else {
XMOUNT_STRAPP(glob_xmount.output.p_info_file,"None\n");
}
}
// Add static morphing header
XMOUNT_STRAPP(glob_xmount.output.p_info_file,IMAGE_INFO_MORPHING_HEADER);
// Get and add infos from morphing lib
ret=glob_xmount.morphing.p_functions->
GetInfofileContent(glob_xmount.morphing.p_handle,(const char**)&p_buf);
if(ret!=0) {
LOG_ERROR("Unable to get info file content from morphing lib: %s!\n",
glob_xmount.morphing.p_functions->GetErrorMessage(ret));
return FALSE;
}
if(p_buf!=NULL) {
XMOUNT_STRAPP(glob_xmount.output.p_info_file,p_buf);
glob_xmount.morphing.p_functions->FreeBuffer(p_buf);
} else {
XMOUNT_STRAPP(glob_xmount.output.p_info_file,"None\n");
}
return TRUE;
}
//! Load input / morphing libs
/*!
* \return TRUE on success, FALSE on error
*/
static int LoadLibs() {
DIR *p_dir=NULL;
struct dirent *p_dirent=NULL;
int base_library_path_len=0;
char *p_library_path=NULL;
void *p_libxmount=NULL;
t_LibXmount_Input_GetApiVersion pfun_input_GetApiVersion;
t_LibXmount_Input_GetSupportedFormats pfun_input_GetSupportedFormats;
t_LibXmount_Input_GetFunctions pfun_input_GetFunctions;
t_LibXmount_Morphing_GetApiVersion pfun_morphing_GetApiVersion;
t_LibXmount_Morphing_GetSupportedTypes pfun_morphing_GetSupportedTypes;
t_LibXmount_Morphing_GetFunctions pfun_morphing_GetFunctions;
t_LibXmount_Output_GetApiVersion pfun_output_GetApiVersion;
t_LibXmount_Output_GetSupportedFormats pfun_output_GetSupportedFormats;
t_LibXmount_Output_GetFunctions pfun_output_GetFunctions;
const char *p_supported_formats=NULL;
const char *p_buf;
uint32_t supported_formats_len=0;
pts_InputLib p_input_lib=NULL;
pts_MorphingLib p_morphing_lib=NULL;
pts_OutputLib p_output_lib=NULL;
LOG_DEBUG("Searching for xmount libraries in '%s'.\n",
XMOUNT_LIBRARY_PATH);
// Open lib dir
p_dir=opendir(XMOUNT_LIBRARY_PATH);
if(p_dir==NULL) {
LOG_ERROR("Unable to access xmount library directory '%s'!\n",
XMOUNT_LIBRARY_PATH);
return FALSE;
}
// Construct base library path
base_library_path_len=strlen(XMOUNT_LIBRARY_PATH);
XMOUNT_STRSET(p_library_path,XMOUNT_LIBRARY_PATH);
if(XMOUNT_LIBRARY_PATH[base_library_path_len]!='/') {
base_library_path_len++;
XMOUNT_STRAPP(p_library_path,"/");
}
#define LIBXMOUNT_LOAD(path) { \
p_libxmount=dlopen(path,RTLD_NOW); \
if(p_libxmount==NULL) { \
LOG_ERROR("Unable to load input library '%s': %s!\n", \
path, \
dlerror()); \
continue; \
} \
}
#define LIBXMOUNT_LOAD_SYMBOL(name,pfun) { \
if((pfun=dlsym(p_libxmount,name))==NULL) { \
LOG_ERROR("Unable to load symbol '%s' from library '%s'!\n", \
name, \
p_library_path); \
dlclose(p_libxmount); \
p_libxmount=NULL; \
continue; \
} \
}
// Loop over lib dir
while((p_dirent=readdir(p_dir))!=NULL) {
LOG_DEBUG("Trying to load '%s'\n",p_dirent->d_name);
// Construct full path to found object
p_library_path=realloc(p_library_path,
base_library_path_len+strlen(p_dirent->d_name)+1);
if(p_library_path==NULL) {
LOG_ERROR("Couldn't allocate memory!\n");
exit(1);
}
strcpy(p_library_path+base_library_path_len,p_dirent->d_name);
if(strncmp(p_dirent->d_name,"libxmount_input_",16)==0) {
// Found possible input lib. Try to load it
LIBXMOUNT_LOAD(p_library_path);
// Load library symbols
LIBXMOUNT_LOAD_SYMBOL("LibXmount_Input_GetApiVersion",
pfun_input_GetApiVersion);
// Check library's API version
if(pfun_input_GetApiVersion()!=LIBXMOUNT_INPUT_API_VERSION) {
LOG_DEBUG("Failed! Wrong API version.\n");
LOG_ERROR("Unable to load input library '%s'. Wrong API version\n",
p_library_path);
dlclose(p_libxmount);
continue;
}
LIBXMOUNT_LOAD_SYMBOL("LibXmount_Input_GetSupportedFormats",
pfun_input_GetSupportedFormats);
LIBXMOUNT_LOAD_SYMBOL("LibXmount_Input_GetFunctions",
pfun_input_GetFunctions);
// Construct new entry for our library list
XMOUNT_MALLOC(p_input_lib,pts_InputLib,sizeof(ts_InputLib));
// Initialize lib_functions structure to NULL
memset(&(p_input_lib->lib_functions),
0,
sizeof(ts_LibXmountInputFunctions));
// Set name and handle
XMOUNT_STRSET(p_input_lib->p_name,p_dirent->d_name);
p_input_lib->p_lib=p_libxmount;
// Get and set supported formats
p_supported_formats=pfun_input_GetSupportedFormats();
supported_formats_len=0;
p_buf=p_supported_formats;
while(*p_buf!='\0') {
supported_formats_len+=(strlen(p_buf)+1);
p_buf+=(strlen(p_buf)+1);
}
supported_formats_len++;
XMOUNT_MALLOC(p_input_lib->p_supported_input_types,
char*,
supported_formats_len);
memcpy(p_input_lib->p_supported_input_types,
p_supported_formats,
supported_formats_len);
// Get, set and check lib_functions
pfun_input_GetFunctions(&(p_input_lib->lib_functions));
if(p_input_lib->lib_functions.CreateHandle==NULL ||
p_input_lib->lib_functions.DestroyHandle==NULL ||
p_input_lib->lib_functions.Open==NULL ||
p_input_lib->lib_functions.Close==NULL ||
p_input_lib->lib_functions.Size==NULL ||
p_input_lib->lib_functions.Read==NULL ||
p_input_lib->lib_functions.OptionsHelp==NULL ||
p_input_lib->lib_functions.OptionsParse==NULL ||
p_input_lib->lib_functions.GetInfofileContent==NULL ||
p_input_lib->lib_functions.GetErrorMessage==NULL ||
p_input_lib->lib_functions.FreeBuffer==NULL)
{
LOG_DEBUG("Missing implemention of one or more functions in lib %s!\n",
p_dirent->d_name);
free(p_input_lib->p_supported_input_types);
free(p_input_lib->p_name);
free(p_input_lib);
dlclose(p_libxmount);
continue;
}
// Add entry to the input library list
XMOUNT_REALLOC(glob_xmount.input.pp_libs,
pts_InputLib*,
sizeof(pts_InputLib)*(glob_xmount.input.libs_count+1));
glob_xmount.input.pp_libs[glob_xmount.input.libs_count++]=p_input_lib;
LOG_DEBUG("Input library '%s' loaded successfully\n",p_dirent->d_name);
} if(strncmp(p_dirent->d_name,"libxmount_morphing_",19)==0) {
// Found possible morphing lib. Try to load it
LIBXMOUNT_LOAD(p_library_path);
// Load library symbols
LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetApiVersion",
pfun_morphing_GetApiVersion);
// Check library's API version
if(pfun_morphing_GetApiVersion()!=LIBXMOUNT_MORPHING_API_VERSION) {
LOG_DEBUG("Failed! Wrong API version.\n");
LOG_ERROR("Unable to load morphing library '%s'. Wrong API version\n",
p_library_path);
dlclose(p_libxmount);
continue;
}
LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetSupportedTypes",
pfun_morphing_GetSupportedTypes);
LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetFunctions",
pfun_morphing_GetFunctions);
// Construct new entry for our library list
XMOUNT_MALLOC(p_morphing_lib,pts_MorphingLib,sizeof(ts_MorphingLib));
// Initialize lib_functions structure to NULL
memset(&(p_morphing_lib->lib_functions),
0,
sizeof(ts_LibXmountMorphingFunctions));
// Set name and handle
XMOUNT_STRSET(p_morphing_lib->p_name,p_dirent->d_name);
p_morphing_lib->p_lib=p_libxmount;
// Get and set supported types
p_supported_formats=pfun_morphing_GetSupportedTypes();
supported_formats_len=0;
p_buf=p_supported_formats;
while(*p_buf!='\0') {
supported_formats_len+=(strlen(p_buf)+1);
p_buf+=(strlen(p_buf)+1);
}
supported_formats_len++;
XMOUNT_MALLOC(p_morphing_lib->p_supported_morphing_types,
char*,
supported_formats_len);
memcpy(p_morphing_lib->p_supported_morphing_types,
p_supported_formats,
supported_formats_len);
// Get, set and check lib_functions
pfun_morphing_GetFunctions(&(p_morphing_lib->lib_functions));
if(p_morphing_lib->lib_functions.CreateHandle==NULL ||
p_morphing_lib->lib_functions.DestroyHandle==NULL ||
p_morphing_lib->lib_functions.Morph==NULL ||
p_morphing_lib->lib_functions.Size==NULL ||
p_morphing_lib->lib_functions.Read==NULL ||
p_morphing_lib->lib_functions.OptionsHelp==NULL ||
p_morphing_lib->lib_functions.OptionsParse==NULL ||
p_morphing_lib->lib_functions.GetInfofileContent==NULL ||
p_morphing_lib->lib_functions.GetErrorMessage==NULL ||
p_morphing_lib->lib_functions.FreeBuffer==NULL)
{
LOG_DEBUG("Missing implemention of one or more functions in lib %s!\n",
p_dirent->d_name);
free(p_morphing_lib->p_supported_morphing_types);
free(p_morphing_lib->p_name);
free(p_morphing_lib);
dlclose(p_libxmount);
continue;
}
// Add entry to the input library list
XMOUNT_REALLOC(glob_xmount.morphing.pp_libs,
pts_MorphingLib*,
sizeof(pts_MorphingLib)*
(glob_xmount.morphing.libs_count+1));
glob_xmount.morphing.pp_libs[glob_xmount.morphing.libs_count++]=
p_morphing_lib;
LOG_DEBUG("Morphing library '%s' loaded successfully\n",p_dirent->d_name);
} if(strncmp(p_dirent->d_name,"libxmount_output_",17)==0) {
// Found possible output lib. Try to load it
LIBXMOUNT_LOAD(p_library_path);
// Load library symbols
LIBXMOUNT_LOAD_SYMBOL("LibXmount_Output_GetApiVersion",
pfun_output_GetApiVersion);
// Check library's API version
if(pfun_output_GetApiVersion()!=LIBXMOUNT_OUTPUT_API_VERSION) {
LOG_DEBUG("Failed! Wrong API version.\n");
LOG_ERROR("Unable to load output library '%s'. Wrong API version\n",
p_library_path);
dlclose(p_libxmount);
continue;
}
LIBXMOUNT_LOAD_SYMBOL("LibXmount_Output_GetSupportedFormats",
pfun_output_GetSupportedFormats);
LIBXMOUNT_LOAD_SYMBOL("LibXmount_Output_GetFunctions",
pfun_output_GetFunctions);
// Construct new entry for our library list
XMOUNT_MALLOC(p_output_lib,pts_OutputLib,sizeof(ts_OutputLib));
// Initialize lib_functions structure to NULL
memset(&(p_output_lib->lib_functions),
0,
sizeof(ts_LibXmountOutput_Functions));
// Set name and handle
XMOUNT_STRSET(p_output_lib->p_name,p_dirent->d_name);
p_output_lib->p_lib=p_libxmount;
// Get and set supported types
p_supported_formats=pfun_output_GetSupportedFormats();
supported_formats_len=0;
p_buf=p_supported_formats;
while(*p_buf!='\0') {
supported_formats_len+=(strlen(p_buf)+1);
p_buf+=(strlen(p_buf)+1);
}
supported_formats_len++;
XMOUNT_MALLOC(p_output_lib->p_supported_output_formats,
char*,
supported_formats_len);
memcpy(p_output_lib->p_supported_output_formats,
p_supported_formats,
supported_formats_len);
// Get, set and check lib_functions
pfun_output_GetFunctions(&(p_output_lib->lib_functions));
if(p_output_lib->lib_functions.CreateHandle==NULL ||
p_output_lib->lib_functions.DestroyHandle==NULL ||
p_output_lib->lib_functions.Transform==NULL ||
p_output_lib->lib_functions.Size==NULL ||
p_output_lib->lib_functions.Read==NULL ||
p_output_lib->lib_functions.Write==NULL ||
p_output_lib->lib_functions.OptionsHelp==NULL ||
p_output_lib->lib_functions.OptionsParse==NULL ||
p_output_lib->lib_functions.GetInfofileContent==NULL ||
p_output_lib->lib_functions.GetErrorMessage==NULL ||
p_output_lib->lib_functions.FreeBuffer==NULL)
{
LOG_DEBUG("Missing implemention of one or more functions in lib %s!\n",
p_dirent->d_name);
free(p_output_lib->p_supported_output_formats);
free(p_output_lib->p_name);
free(p_output_lib);
dlclose(p_libxmount);
continue;
}
// Add entry to the input library list
XMOUNT_REALLOC(glob_xmount.output.pp_libs,
pts_OutputLib*,
sizeof(pts_OutputLib)*
(glob_xmount.output.libs_count+1));
glob_xmount.output.pp_libs[glob_xmount.output.libs_count++]=
p_output_lib;
LOG_DEBUG("Output library '%s' loaded successfully\n",p_dirent->d_name);
} else {
LOG_DEBUG("Ignoring '%s'.\n",p_dirent->d_name);
continue;
}
}
#undef LIBXMOUNT_LOAD_SYMBOL
#undef LIBXMOUNT_LOAD
LOG_DEBUG("A total of %u input libs, %u morphing libs and %u output libs "
"were loaded.\n",
glob_xmount.input.libs_count,
glob_xmount.morphing.libs_count,
glob_xmount.output.libs_count);
free(p_library_path);
closedir(p_dir);
return ((glob_xmount.input.libs_count>0 &&
glob_xmount.morphing.libs_count>0 &&
glob_xmount.output.libs_count>0) ? TRUE : FALSE);
}
//! Search an appropriate input lib for specified input type
/*!
* \param p_input_image Input image to search input lib for
* \return TRUE on success, FALSE on error
*/
static int FindInputLib(pts_InputImage p_input_image) {
char *p_buf;
LOG_DEBUG("Trying to find suitable library for input type '%s'.\n",
p_input_image->p_type);
// Loop over all loaded libs
for(uint32_t i=0;i<glob_xmount.input.libs_count;i++) {
LOG_DEBUG("Checking input library %s\n",
glob_xmount.input.pp_libs[i]->p_name);
p_buf=glob_xmount.input.pp_libs[i]->p_supported_input_types;
while(*p_buf!='\0') {
if(strcmp(p_buf,p_input_image->p_type)==0) {
// Library supports input type, set lib functions
LOG_DEBUG("Input library '%s' pretends to handle that input type.\n",
glob_xmount.input.pp_libs[i]->p_name);
p_input_image->p_functions=
&(glob_xmount.input.pp_libs[i]->lib_functions);
return TRUE;
}
p_buf+=(strlen(p_buf)+1);
}
}
LOG_DEBUG("Couldn't find any suitable library.\n");
// No library supporting input type found
return FALSE;
}
//! Search an appropriate morphing lib for the specified morph type
/*!
* \return TRUE on success, FALSE on error
*/
static int FindMorphingLib() {
char *p_buf;
LOG_DEBUG("Trying to find suitable library for morph type '%s'.\n",
glob_xmount.morphing.p_morph_type);
// Loop over all loaded libs
for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
LOG_DEBUG("Checking morphing library %s\n",
glob_xmount.morphing.pp_libs[i]->p_name);
p_buf=glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types;
while(*p_buf!='\0') {
if(strcmp(p_buf,glob_xmount.morphing.p_morph_type)==0) {
// Library supports morph type, set lib functions
LOG_DEBUG("Morphing library '%s' pretends to handle that morph type.\n",
glob_xmount.morphing.pp_libs[i]->p_name);
glob_xmount.morphing.p_functions=
&(glob_xmount.morphing.pp_libs[i]->lib_functions);
return TRUE;
}
p_buf+=(strlen(p_buf)+1);
}
}
LOG_DEBUG("Couldn't find any suitable library.\n");
// No library supporting morph type found
return FALSE;
}
//! Search an appropriate output lib for the specified output format
/*!
* \return TRUE on success, FALSE on error
*/
static int FindOutputLib() {
char *p_buf;
LOG_DEBUG("Trying to find suitable library for output format '%s'.\n",
glob_xmount.output.p_output_format);
// Loop over all loaded output libs
for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
LOG_DEBUG("Checking output library %s\n",
glob_xmount.output.pp_libs[i]->p_name);
p_buf=glob_xmount.output.pp_libs[i]->p_supported_output_formats;
while(*p_buf!='\0') {
if(strcmp(p_buf,glob_xmount.output.p_output_format)==0) {
// Library supports output type, set lib functions
LOG_DEBUG("Output library '%s' pretends to handle that output format.\n",
glob_xmount.output.pp_libs[i]->p_name);
glob_xmount.output.p_functions=
&(glob_xmount.output.pp_libs[i]->lib_functions);
return TRUE;
}
p_buf+=(strlen(p_buf)+1);
}
}
LOG_DEBUG("Couldn't find any suitable library.\n");
// No library supporting output format found
return FALSE;
}
static void InitResources() {
+ // Args
+ glob_xmount.args.overwrite_cache=FALSE;
+ glob_xmount.args.p_cache_file=NULL;
+
// Input
glob_xmount.input.libs_count=0;
glob_xmount.input.pp_libs=NULL;
glob_xmount.input.lib_params_count=0;
glob_xmount.input.pp_lib_params=NULL;
glob_xmount.input.images_count=0;
glob_xmount.input.pp_images=NULL;
glob_xmount.input.image_offset=0;
glob_xmount.input.image_size_limit=0;
glob_xmount.input.image_hash_lo=0;
glob_xmount.input.image_hash_hi=0;
// Morphing
glob_xmount.morphing.libs_count=0;
glob_xmount.morphing.pp_libs=NULL;
glob_xmount.morphing.p_morph_type=NULL;
glob_xmount.morphing.lib_params_count=0;
glob_xmount.morphing.pp_lib_params=NULL;
glob_xmount.morphing.p_handle=NULL;
glob_xmount.morphing.p_functions=NULL;
glob_xmount.morphing.input_image_functions.ImageCount=
&LibXmount_Morphing_ImageCount;
glob_xmount.morphing.input_image_functions.Size=&LibXmount_Morphing_Size;
glob_xmount.morphing.input_image_functions.Read=&LibXmount_Morphing_Read;
// Cache
- glob_xmount.cache.overwrite_cache=FALSE;
- glob_xmount.cache.p_cache_file=NULL;
- glob_xmount.cache.h_cache_file=NULL;
- glob_xmount.cache.h_block_cache=NULL;
- glob_xmount.cache.h_block_cache_index=NULL;
- glob_xmount.cache.p_block_cache_index=NULL;
- glob_xmount.cache.block_cache_index_len=0;
+ glob_xmount.h_cache=NULL;
// Output
glob_xmount.output.libs_count=0;
glob_xmount.output.pp_libs=NULL;
glob_xmount.output.p_output_format=NULL;
glob_xmount.output.lib_params_count=0;
glob_xmount.output.pp_lib_params=NULL;
glob_xmount.output.p_handle=NULL;
glob_xmount.output.p_functions=NULL;
glob_xmount.output.input_functions.Size=&LibXmount_Output_Size;
glob_xmount.output.input_functions.Read=&LibXmount_Output_Read;
glob_xmount.output.input_functions.Write=&LibXmount_Output_Write;
glob_xmount.output.image_size=0;
glob_xmount.output.writable=FALSE;
glob_xmount.output.p_virtual_image_path=NULL;
glob_xmount.output.p_info_path=NULL;
glob_xmount.output.p_info_file=NULL;
// Misc data
glob_xmount.debug=FALSE;
glob_xmount.may_set_fuse_allow_other=FALSE;
glob_xmount.fuse_argc=0;
glob_xmount.pp_fuse_argv=NULL;
glob_xmount.p_mountpoint=NULL;
}
/*
* FreeResources
*/
static void FreeResources() {
int ret;
- teGidaFsError gidafs_ret=eGidaFsError_None;
+ te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
LOG_DEBUG("Freeing all resources\n");
// Misc
if(glob_xmount.pp_fuse_argv!=NULL) {
for(int i=0;i<glob_xmount.fuse_argc;i++) free(glob_xmount.pp_fuse_argv[i]);
free(glob_xmount.pp_fuse_argv);
}
if(glob_xmount.p_mountpoint!=NULL) free(glob_xmount.p_mountpoint);
// Output
if(glob_xmount.output.p_functions!=NULL) {
if(glob_xmount.output.p_handle!=NULL) {
// Destroy output handle
ret=glob_xmount.output.p_functions->
DestroyHandle(&(glob_xmount.output.p_handle));
if(ret!=0) {
LOG_ERROR("Unable to destroy output handle: %s!\n",
glob_xmount.output.p_functions->GetErrorMessage(ret));
}
}
}
if(glob_xmount.output.pp_lib_params!=NULL) {
for(uint32_t i=0;i<glob_xmount.output.lib_params_count;i++)
free(glob_xmount.output.pp_lib_params[i]);
free(glob_xmount.output.pp_lib_params);
}
if(glob_xmount.output.p_output_format!=NULL)
free(glob_xmount.output.p_output_format);
if(glob_xmount.output.pp_libs!=NULL) {
// Unload output libs
for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
if(glob_xmount.output.pp_libs[i]==NULL) continue;
if(glob_xmount.output.pp_libs[i]->p_supported_output_formats!=NULL)
free(glob_xmount.output.pp_libs[i]->p_supported_output_formats);
if(glob_xmount.output.pp_libs[i]->p_lib!=NULL)
dlclose(glob_xmount.output.pp_libs[i]->p_lib);
if(glob_xmount.output.pp_libs[i]->p_name!=NULL)
free(glob_xmount.output.pp_libs[i]->p_name);
free(glob_xmount.output.pp_libs[i]);
}
free(glob_xmount.output.pp_libs);
}
if(glob_xmount.output.p_info_path!=NULL)
free(glob_xmount.output.p_info_path);
if(glob_xmount.output.p_info_file!=NULL)
free(glob_xmount.output.p_info_file);
if(glob_xmount.output.p_virtual_image_path!=NULL)
free(glob_xmount.output.p_virtual_image_path);
// Cache
- if(glob_xmount.cache.h_cache_file!=NULL) {
- if(glob_xmount.cache.p_block_cache_index!=NULL)
- free(glob_xmount.cache.p_block_cache_index);
- if(glob_xmount.cache.h_block_cache_index!=NULL) {
- gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file,
- &(glob_xmount.cache.h_block_cache_index));
- if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to close block cache index file: Error code %u: "
- "Ignoring!\n",
- gidafs_ret)
- }
- }
- if(glob_xmount.cache.h_block_cache!=NULL) {
- gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file,
- &(glob_xmount.cache.h_block_cache));
- if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to close block cache file: Error code %u: "
- "Ignoring!\n",
- gidafs_ret)
- }
- }
- gidafs_ret=GidaFsLib_CloseFs(&(glob_xmount.cache.h_cache_file));
- if(gidafs_ret!=eGidaFsError_None) {
+ if(glob_xmount.h_cache!=NULL) {
+ cache_ret=XmountCache_Close(&(glob_xmount.h_cache));
+ if(cache_ret!=e_XmountCache_Error_None) {
LOG_ERROR("Unable to close cache file: Error code %u: Ignoring!\n",
- gidafs_ret)
+ cache_ret);
}
}
- if(glob_xmount.cache.p_cache_file!=NULL) free(glob_xmount.cache.p_cache_file);
// Morphing
if(glob_xmount.morphing.p_functions!=NULL) {
if(glob_xmount.morphing.p_handle!=NULL) {
// Destroy morphing handle
ret=glob_xmount.morphing.p_functions->
DestroyHandle(&(glob_xmount.morphing.p_handle));
if(ret!=0) {
LOG_ERROR("Unable to destroy morphing handle: %s!\n",
glob_xmount.morphing.p_functions->GetErrorMessage(ret));
}
}
}
if(glob_xmount.morphing.pp_lib_params!=NULL) {
for(uint32_t i=0;i<glob_xmount.morphing.lib_params_count;i++)
free(glob_xmount.morphing.pp_lib_params[i]);
free(glob_xmount.morphing.pp_lib_params);
}
if(glob_xmount.morphing.p_morph_type!=NULL)
free(glob_xmount.morphing.p_morph_type);
if(glob_xmount.morphing.pp_libs!=NULL) {
// Unload morphing libs
for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
if(glob_xmount.morphing.pp_libs[i]==NULL) continue;
if(glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types!=NULL)
free(glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types);
if(glob_xmount.morphing.pp_libs[i]->p_lib!=NULL)
dlclose(glob_xmount.morphing.pp_libs[i]->p_lib);
if(glob_xmount.morphing.pp_libs[i]->p_name!=NULL)
free(glob_xmount.morphing.pp_libs[i]->p_name);
free(glob_xmount.morphing.pp_libs[i]);
}
free(glob_xmount.morphing.pp_libs);
}
// Input
if(glob_xmount.input.pp_images!=NULL) {
// Close all input images
for(uint64_t i=0;i<glob_xmount.input.images_count;i++) {
if(glob_xmount.input.pp_images[i]==NULL) continue;
if(glob_xmount.input.pp_images[i]->p_functions!=NULL) {
if(glob_xmount.input.pp_images[i]->p_handle!=NULL) {
ret=glob_xmount.input.pp_images[i]->p_functions->
Close(glob_xmount.input.pp_images[i]->p_handle);
if(ret!=0) {
LOG_ERROR("Unable to close input image: %s\n",
glob_xmount.input.pp_images[i]->p_functions->
GetErrorMessage(ret));
}
ret=glob_xmount.input.pp_images[i]->p_functions->
DestroyHandle(&(glob_xmount.input.pp_images[i]->p_handle));
if(ret!=0) {
LOG_ERROR("Unable to destroy input image handle: %s\n",
glob_xmount.input.pp_images[i]->p_functions->
GetErrorMessage(ret));
}
}
}
if(glob_xmount.input.pp_images[i]->pp_files!=NULL) {
for(uint64_t ii=0;ii<glob_xmount.input.pp_images[i]->files_count;ii++) {
if(glob_xmount.input.pp_images[i]->pp_files[ii]!=NULL)
free(glob_xmount.input.pp_images[i]->pp_files[ii]);
}
free(glob_xmount.input.pp_images[i]->pp_files);
}
if(glob_xmount.input.pp_images[i]->p_type!=NULL)
free(glob_xmount.input.pp_images[i]->p_type);
free(glob_xmount.input.pp_images[i]);
}
free(glob_xmount.input.pp_images);
}
if(glob_xmount.input.pp_lib_params!=NULL) {
for(uint32_t i=0;i<glob_xmount.input.lib_params_count;i++)
free(glob_xmount.input.pp_lib_params[i]);
free(glob_xmount.input.pp_lib_params);
}
if(glob_xmount.input.pp_libs!=NULL) {
// Unload all input libs
for(uint32_t i=0;i<glob_xmount.input.libs_count;i++) {
if(glob_xmount.input.pp_libs[i]->p_supported_input_types!=NULL)
free(glob_xmount.input.pp_libs[i]->p_supported_input_types);
if(glob_xmount.input.pp_libs[i]->p_lib!=NULL)
dlclose(glob_xmount.input.pp_libs[i]->p_lib);
if(glob_xmount.input.pp_libs[i]->p_name!=NULL)
free(glob_xmount.input.pp_libs[i]->p_name);
free(glob_xmount.input.pp_libs[i]);
}
free(glob_xmount.input.pp_libs);
}
+ // Args
+ if(glob_xmount.args.p_cache_file!=NULL) {
+ XMOUNT_FREE(glob_xmount.args.p_cache_file);
+ }
+
// Before we return, initialize everything in case ReleaseResources would be
// called again.
InitResources();
}
//! Function to split given library options
static int SplitLibraryParameters(char *p_params,
uint32_t *p_ret_opts_count,
pts_LibXmountOptions **ppp_ret_opt)
{
pts_LibXmountOptions p_opts=NULL;
pts_LibXmountOptions *pp_opts=NULL;
uint32_t params_len;
uint32_t opts_count=0;
uint32_t sep_pos=0;
char *p_buf=p_params;
if(p_params==NULL) return FALSE;
// Get params length
params_len=strlen(p_params);
// Return if no params specified
if(params_len==0) {
*ppp_ret_opt=NULL;
p_ret_opts_count=0;
return TRUE;
}
// Split params
while(*p_buf!='\0') {
XMOUNT_MALLOC(p_opts,pts_LibXmountOptions,sizeof(ts_LibXmountOptions));
p_opts->valid=0;
#define FREE_PP_OPTS() { \
if(pp_opts!=NULL) { \
for(uint32_t i=0;i<opts_count;i++) free(pp_opts[i]); \
free(pp_opts); \
} \
}
// Search next assignment operator
sep_pos=0;
while(p_buf[sep_pos]!='\0' && p_buf[sep_pos]!='=') sep_pos++;
if(sep_pos==0 || p_buf[sep_pos]=='\0') {
LOG_ERROR("Library parameter '%s' is missing an assignment operator!\n",
p_buf);
free(p_opts);
FREE_PP_OPTS();
return FALSE;
}
// Save option key
XMOUNT_STRNSET(p_opts->p_key,p_buf,sep_pos);
p_buf+=(sep_pos+1);
// Search next separator
sep_pos=0;
while(p_buf[sep_pos]!='\0' && p_buf[sep_pos]!=',') sep_pos++;
if(sep_pos==0) {
LOG_ERROR("Library parameter '%s' is not of format key=value!\n",
p_opts->p_key);
free(p_opts->p_key);
free(p_opts);
FREE_PP_OPTS();
return FALSE;
}
// Save option value
XMOUNT_STRNSET(p_opts->p_value,p_buf,sep_pos);
p_buf+=sep_pos;
LOG_DEBUG("Extracted library option: '%s' = '%s'\n",
p_opts->p_key,
p_opts->p_value);
#undef FREE_PP_OPTS
// Add current option to return array
XMOUNT_REALLOC(pp_opts,
pts_LibXmountOptions*,
sizeof(pts_LibXmountOptions)*(opts_count+1));
pp_opts[opts_count++]=p_opts;
// If we're not at the end of p_params, skip over separator for next run
if(*p_buf!='\0') p_buf++;
}
LOG_DEBUG("Extracted a total of %" PRIu32 " library options\n",opts_count);
*p_ret_opts_count=opts_count;
*ppp_ret_opt=pp_opts;
return TRUE;
}
/*******************************************************************************
* LibXmount_Morphing function implementation
******************************************************************************/
//! Function to get the amount of input images
/*!
* \param p_count Count of input images
* \return 0 on success
*/
static int LibXmount_Morphing_ImageCount(uint64_t *p_count) {
*p_count=glob_xmount.input.images_count;
return 0;
}
//! Function to get the size of the morphed data
/*!
* \param image Image number
* \param p_size Pointer to store input image's size to
* \return 0 on success
*/
static int LibXmount_Morphing_Size(uint64_t image, uint64_t *p_size) {
if(image>=glob_xmount.input.images_count) return -1;
*p_size=glob_xmount.input.pp_images[image]->size;
return 0;
}
//! Function to read data from input image
/*!
* \param image Image number
* \param p_buf Buffer to store read data to
* \param offset Position at which to start reading
* \param count Amount of bytes to read
* \param p_read Number of read bytes on success
* \return 0 on success or negated error code on error
*/
static int LibXmount_Morphing_Read(uint64_t image,
char *p_buf,
off_t offset,
size_t count,
size_t *p_read)
{
if(image>=glob_xmount.input.images_count) return -EIO;
return ReadInputImageData(glob_xmount.input.pp_images[image],
p_buf,
offset,
count,
p_read);
}
/*******************************************************************************
* LibXmount_Output function implementation
******************************************************************************/
//! Function to get the size of the morphed image
/*!
* \param p_size Pointer to store morphed image's size to
* \return 0 on success
*/
static int LibXmount_Output_Size(uint64_t *p_size) {
int ret=0;
ret=GetMorphedImageSize(p_size);
return ret==TRUE ? 0 : ret;
}
//! Function to read data from the morphed image
/*!
* \param p_buf Buffer to store read data to
* \param offset Position at which to start reading
* \param count Amount of bytes to read
* \param p_read Number of read bytes on success
* \return 0 on success or negated error code on error
*/
static int LibXmount_Output_Read(char *p_buf,
off_t offset,
size_t count,
size_t *p_read)
{
return ReadMorphedImageData(p_buf,offset,count,p_read);
}
//! Function to write data to the morphed image
/*!
* \param p_buf Buffer with data to write
* \param offset Position at which to start writing
* \param count Amount of bytes to write
* \param p_written Number of written bytes on success
* \return 0 on success or negated error code on error
*/
static int LibXmount_Output_Write(char *p_buf,
off_t offset,
size_t count,
size_t *p_written)
{
return WriteMorphedImageData(p_buf,offset,count,p_written);
}
/*******************************************************************************
* Main
******************************************************************************/
int main(int argc, char *argv[]) {
struct stat file_stat;
int ret;
int fuse_ret;
char *p_err_msg;
+ te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
// Set implemented FUSE functions
struct fuse_operations xmount_operations = {
//.access=FuseAccess,
.getattr=Xmount_FuseGetAttr,
.mkdir=Xmount_FuseMkDir,
.mknod=Xmount_FuseMkNod,
.open=Xmount_FuseOpen,
.readdir=Xmount_FuseReadDir,
.read=Xmount_FuseRead,
.rename=Xmount_FuseRename,
.rmdir=Xmount_FuseRmDir,
//.statfs=FuseStatFs,
.unlink=Xmount_FuseUnlink,
.write=Xmount_FuseWrite
};
// Disable std output / input buffering
setbuf(stdout,NULL);
setbuf(stderr,NULL);
// Init glob_xmount
InitResources();
- // Load input and morphing libs
+ // Load input, morphing and output libs
if(!LoadLibs()) {
LOG_ERROR("Unable to load any libraries!\n")
return 1;
}
// Check FUSE settings
CheckFuseSettings();
// Parse command line options
if(ParseCmdLine(argc,argv)!=TRUE) {
PrintUsage(argv[0]);
FreeResources();
return 1;
}
// Check command line options
if(glob_xmount.input.images_count==0) {
LOG_ERROR("No --in command line option specified!\n")
PrintUsage(argv[0]);
FreeResources();
return 1;
}
if(glob_xmount.fuse_argc<2) {
LOG_ERROR("Couldn't parse command line options!\n")
PrintUsage(argv[0]);
FreeResources();
return 1;
}
if(glob_xmount.morphing.p_morph_type==NULL) {
XMOUNT_STRSET(glob_xmount.morphing.p_morph_type,"combine");
}
+ // TODO: Add default output image format here
// Check if mountpoint is a valid dir
if(stat(glob_xmount.p_mountpoint,&file_stat)!=0) {
LOG_ERROR("Unable to stat mount point '%s'!\n",glob_xmount.p_mountpoint);
PrintUsage(argv[0]);
FreeResources();
return 1;
}
if(!S_ISDIR(file_stat.st_mode)) {
LOG_ERROR("Mount point '%s' is not a directory!\n",
glob_xmount.p_mountpoint);
PrintUsage(argv[0]);
FreeResources();
return 1;
}
if(glob_xmount.debug==TRUE) {
LOG_DEBUG("Options passed to FUSE: ")
for(int i=0;i<glob_xmount.fuse_argc;i++) {
printf("%s ",glob_xmount.pp_fuse_argv[i]);
}
printf("\n");
}
// Init mutexes
pthread_mutex_init(&(glob_xmount.mutex_image_rw),NULL);
pthread_mutex_init(&(glob_xmount.mutex_info_read),NULL);
// Load input images
for(uint64_t i=0;i<glob_xmount.input.images_count;i++) {
if(glob_xmount.debug==TRUE) {
if(glob_xmount.input.pp_images[i]->files_count==1) {
LOG_DEBUG("Loading image file \"%s\"...\n",
glob_xmount.input.pp_images[i]->pp_files[0])
} else {
LOG_DEBUG("Loading image files \"%s .. %s\"...\n",
glob_xmount.input.pp_images[i]->pp_files[0],
glob_xmount.input.pp_images[i]->
pp_files[glob_xmount.input.pp_images[i]->files_count-1])
}
}
// Find input lib
if(!FindInputLib(glob_xmount.input.pp_images[i])) {
LOG_ERROR("Unknown input image type '%s' for input image '%s'!\n",
glob_xmount.input.pp_images[i]->p_type,
glob_xmount.input.pp_images[i]->pp_files[0])
PrintUsage(argv[0]);
FreeResources();
return 1;
}
// Init input image handle
ret=glob_xmount.input.pp_images[i]->p_functions->
CreateHandle(&(glob_xmount.input.pp_images[i]->p_handle),
glob_xmount.input.pp_images[i]->p_type,
glob_xmount.debug);
if(ret!=0) {
LOG_ERROR("Unable to init input handle for input image '%s': %s!\n",
glob_xmount.input.pp_images[i]->pp_files[0],
glob_xmount.input.pp_images[i]->p_functions->
GetErrorMessage(ret));
FreeResources();
return 1;
}
// Parse input lib specific options
if(glob_xmount.input.pp_lib_params!=NULL) {
ret=glob_xmount.input.pp_images[i]->p_functions->
OptionsParse(glob_xmount.input.pp_images[i]->p_handle,
glob_xmount.input.lib_params_count,
glob_xmount.input.pp_lib_params,
(const char**)&p_err_msg);
if(ret!=0) {
if(p_err_msg!=NULL) {
LOG_ERROR("Unable to parse input library specific options for image "
"'%s': %s: %s!\n",
glob_xmount.input.pp_images[i]->pp_files[0],
glob_xmount.input.pp_images[i]->p_functions->
GetErrorMessage(ret),
p_err_msg);
glob_xmount.input.pp_images[i]->p_functions->FreeBuffer(p_err_msg);
FreeResources();
return 1;
} else {
LOG_ERROR("Unable to parse input library specific options for image "
"'%s': %s!\n",
glob_xmount.input.pp_images[i]->pp_files[0],
glob_xmount.input.pp_images[i]->p_functions->
GetErrorMessage(ret));
FreeResources();
return 1;
}
}
}
// Open input image
ret=
glob_xmount.input.pp_images[i]->
p_functions->
Open(glob_xmount.input.pp_images[i]->p_handle,
(const char**)(glob_xmount.input.pp_images[i]->pp_files),
glob_xmount.input.pp_images[i]->files_count);
if(ret!=0) {
LOG_ERROR("Unable to open input image file '%s': %s!\n",
glob_xmount.input.pp_images[i]->pp_files[0],
glob_xmount.input.pp_images[i]->p_functions->
GetErrorMessage(ret));
FreeResources();
return 1;
}
// Determine input image size
ret=glob_xmount.input.pp_images[i]->
p_functions->
Size(glob_xmount.input.pp_images[i]->p_handle,
&(glob_xmount.input.pp_images[i]->size));
if(ret!=0) {
LOG_ERROR("Unable to determine size of input image '%s': %s!\n",
glob_xmount.input.pp_images[i]->pp_files[0],
glob_xmount.input.pp_images[i]->
p_functions->GetErrorMessage(ret));
FreeResources();
return 1;
}
// If an offset was specified, check it against offset and change size
if(glob_xmount.input.image_offset!=0) {
if(glob_xmount.input.image_offset>glob_xmount.input.pp_images[i]->size) {
LOG_ERROR("The specified offset is larger than the size of the input "
"image '%s'! (%" PRIu64 " > %" PRIu64 ")\n",
glob_xmount.input.pp_images[i]->pp_files[0],
glob_xmount.input.image_offset,
glob_xmount.input.pp_images[i]->size);
FreeResources();
return 1;
}
glob_xmount.input.pp_images[i]->size-=glob_xmount.input.image_offset;
}
// If a size limit was specified, check it and change size
if(glob_xmount.input.image_size_limit!=0) {
if(glob_xmount.input.pp_images[i]->size<
glob_xmount.input.image_size_limit)
{
LOG_ERROR("The specified size limit is larger than the size of the "
"input image '%s'! (%" PRIu64 " > %" PRIu64 ")\n",
glob_xmount.input.pp_images[i]->pp_files[0],
glob_xmount.input.image_size_limit,
glob_xmount.input.pp_images[i]->size);
FreeResources();
return 1;
}
glob_xmount.input.pp_images[i]->size=glob_xmount.input.image_size_limit;
}
LOG_DEBUG("Input image loaded successfully\n")
}
// Find morphing lib
if(FindMorphingLib()!=TRUE) {
LOG_ERROR("Unable to find a library supporting the morphing type '%s'!\n",
glob_xmount.morphing.p_morph_type);
FreeResources();
return 1;
}
// Init morphing
ret=glob_xmount.morphing.p_functions->
CreateHandle(&glob_xmount.morphing.p_handle,
glob_xmount.morphing.p_morph_type,
glob_xmount.debug);
if(ret!=0) {
LOG_ERROR("Unable to create morphing handle: %s!\n",
glob_xmount.morphing.p_functions->GetErrorMessage(ret));
FreeResources();
return 1;
}
// Parse morphing lib specific options
if(glob_xmount.morphing.pp_lib_params!=NULL) {
p_err_msg=NULL;
ret=glob_xmount.morphing.p_functions->
OptionsParse(glob_xmount.morphing.p_handle,
glob_xmount.morphing.lib_params_count,
glob_xmount.morphing.pp_lib_params,
(const char**)&p_err_msg);
if(ret!=0) {
if(p_err_msg!=NULL) {
LOG_ERROR("Unable to parse morphing library specific options: %s: %s!\n",
glob_xmount.morphing.p_functions->GetErrorMessage(ret),
p_err_msg);
glob_xmount.morphing.p_functions->FreeBuffer(p_err_msg);
FreeResources();
return 1;
} else {
LOG_ERROR("Unable to parse morphing library specific options: %s!\n",
glob_xmount.morphing.p_functions->GetErrorMessage(ret));
FreeResources();
return 1;
}
}
}
// Morph image
ret=glob_xmount.morphing.p_functions->
Morph(glob_xmount.morphing.p_handle,
&(glob_xmount.morphing.input_image_functions));
if(ret!=0) {
LOG_ERROR("Unable to start morphing: %s!\n",
glob_xmount.morphing.p_functions->GetErrorMessage(ret));
FreeResources();
return 1;
}
// Init random generator
srand(time(NULL));
// Calculate partial MD5 hash of input image file
if(CalculateInputImageHash(&(glob_xmount.input.image_hash_lo),
&(glob_xmount.input.image_hash_hi))==FALSE)
{
LOG_ERROR("Couldn't calculate partial hash of morphed image!\n")
return 1;
}
if(glob_xmount.debug==TRUE) {
LOG_DEBUG("Partial MD5 hash of morphed image: ")
for(int i=0;i<8;i++)
printf("%02hhx",*(((char*)(&(glob_xmount.input.image_hash_lo)))+i));
for(int i=0;i<8;i++)
printf("%02hhx",*(((char*)(&(glob_xmount.input.image_hash_hi)))+i));
printf("\n");
}
if(!ExtractOutputFileNames(glob_xmount.input.pp_images[0]->pp_files[0])) {
LOG_ERROR("Couldn't extract virtual file names!\n");
FreeResources();
return 1;
}
LOG_DEBUG("Virtual file names extracted successfully\n")
// Find output lib
if(FindOutputLib()!=TRUE) {
LOG_ERROR("Unable to find a library supporting the output format '%s'!\n",
glob_xmount.output.p_output_format);
FreeResources();
return 1;
}
// Init output
ret=glob_xmount.output.p_functions->
CreateHandle(&glob_xmount.output.p_handle,
glob_xmount.output.p_output_format,
glob_xmount.debug);
if(ret!=0) {
LOG_ERROR("Unable to create output handle: %s!\n",
glob_xmount.output.p_functions->GetErrorMessage(ret));
FreeResources();
return 1;
}
// Parse output lib specific options
if(glob_xmount.output.pp_lib_params!=NULL) {
p_err_msg=NULL;
ret=glob_xmount.output.p_functions->
OptionsParse(glob_xmount.output.p_handle,
glob_xmount.output.lib_params_count,
glob_xmount.output.pp_lib_params,
(const char**)&p_err_msg);
if(ret!=0) {
if(p_err_msg!=NULL) {
LOG_ERROR("Unable to parse output library specific options: %s: %s!\n",
glob_xmount.output.p_functions->GetErrorMessage(ret),
p_err_msg);
glob_xmount.output.p_functions->FreeBuffer(p_err_msg);
FreeResources();
return 1;
} else {
LOG_ERROR("Unable to parse output library specific options: %s!\n",
glob_xmount.output.p_functions->GetErrorMessage(ret));
FreeResources();
return 1;
}
}
}
// Morph image
ret=glob_xmount.morphing.p_functions->
Morph(glob_xmount.morphing.p_handle,
&(glob_xmount.morphing.input_image_functions));
if(ret!=0) {
LOG_ERROR("Unable to start morphing: %s!\n",
glob_xmount.morphing.p_functions->GetErrorMessage(ret));
FreeResources();
return 1;
}
// Gather infos for info file
if(!InitInfoFile()) {
LOG_ERROR("Couldn't gather infos for virtual image info file!\n")
FreeResources();
return 1;
}
LOG_DEBUG("Virtual image info file build successfully\n")
if(glob_xmount.output.writable) {
// Init cache file and cache file block index
+ // TODO: Add cache file creration / opening
+/*
+ if(glob_xmount.args.overwrite_cache==TRUE) {
+ cache_ret=XmountCache_Create(&(glob_xmount.h_cache),
+ glob_xmount.args.p_cache_file,
+
+
+ } else {
+ cache_ret=XmountCache_Open
+ }
+
+
+ te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
if(!InitCacheFile()) {
LOG_ERROR("Couldn't initialize cache file!\n")
FreeResources();
return 1;
}
+*/
LOG_DEBUG("Cache file initialized successfully\n")
}
// Call fuse_main to do the fuse magic
fuse_ret=fuse_main(glob_xmount.fuse_argc,
glob_xmount.pp_fuse_argv,
&xmount_operations,
NULL);
// Destroy mutexes
pthread_mutex_destroy(&(glob_xmount.mutex_image_rw));
pthread_mutex_destroy(&(glob_xmount.mutex_info_read));
// Free allocated memory
FreeResources();
return fuse_ret;
}
diff --git a/src/xmount.h b/src/xmount.h
index 58bfb58..36340ec 100755
--- a/src/xmount.h
+++ b/src/xmount.h
@@ -1,83 +1,93 @@
/*******************************************************************************
* xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu> *
* *
* xmount is a small tool to "fuse mount" various image formats and enable *
* virtual write access. *
* *
* 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 3 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, see <http://www.gnu.org/licenses/>. *
*******************************************************************************/
#ifndef XMOUNT_H
#define XMOUNT_H
#include "xmount_input.h"
#include "xmount_morphing.h"
#include "xmount_cache.h"
#include "xmount_output.h"
#undef FALSE
#undef TRUE
#define FALSE 0
#define TRUE 1
/*
* Constants
*/
#define IMAGE_INFO_INPUT_HEADER \
"------> The following values are supplied by the used input library(ies) " \
"<------\n"
#define IMAGE_INFO_MORPHING_HEADER \
"\n------> The following values are supplied by the used morphing library " \
"<------\n\n"
/*******************************************************************************
* Xmount specific structures
******************************************************************************/
+//! Structure containing xmount arguments
+typedef struct s_XmountArgs {
+ //! Cache file
+ char *p_cache_file;
+ //! If set to 1, overwrite any existing cache file
+ uint8_t overwrite_cache;
+} ts_XmountArgs;
+
//! Structure containing global xmount runtime infos
typedef struct s_XmountData {
+ //! Parsed xmount arguments
+ ts_XmountArgs args;
//! Input image related data
ts_InputData input;
//! Morphing related data
ts_MorphingData morphing;
- //! Cache file related data
- ts_CacheData cache;
+ //! Cache file handle
+ pts_XmountCacheHandle h_cache;
//! Output image related data
ts_OutputData output;
//! Enable debug output
uint8_t debug;
//! Set if we are allowed to set fuse's allow_other option
uint8_t may_set_fuse_allow_other;
//! Argv for FUSE
int fuse_argc;
//! Argv for FUSE
char **pp_fuse_argv;
//! Mount point
char *p_mountpoint;
//! Mutex to control concurrent read & write access on output image
pthread_mutex_t mutex_image_rw;
//! Mutex to control concurrent read access on info file
pthread_mutex_t mutex_info_read;
} ts_XmountData;
/*******************************************************************************
* Global vars
******************************************************************************/
//! Struct that contains various runtime configuration options
ts_XmountData glob_xmount;
/*******************************************************************************
* Xmount functions
******************************************************************************/
#endif // XMOUNT_H
diff --git a/src/xmount_cache.c b/src/xmount_cache.c
index 576b3ef..9538c28 100644
--- a/src/xmount_cache.c
+++ b/src/xmount_cache.c
@@ -1,957 +1,798 @@
/*******************************************************************************
* xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu> *
* *
* 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 3 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, see <http://www.gnu.org/licenses/>. *
*******************************************************************************/
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "xmount_cache.h"
#include "xmount.h"
#include "macros.h"
/*******************************************************************************
* Private definitions / macros
******************************************************************************/
#define LOG_WARNING(...) { \
LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
}
#define LOG_ERROR(...) { \
LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
}
#define LOG_DEBUG(...) { \
LIBXMOUNT_LOG_DEBUG(glob_xmount.debug,__VA_ARGS__); \
}
#ifndef __LP64__
//! Value used to indicate an uncached block entry
#define XMOUNT_CACHE_INVALID_INDEX 0xFFFFFFFFFFFFFFFFLL
#else
#define XMOUNT_CACHE_INVALID_INDEX 0xFFFFFFFFFFFFFFFF
#endif
//! Structures and vars needed for write access
#define XMOUNT_CACHE_FOLDER "/.xmount"
#define XMOUNT_CACHE_BLOCK_FILE XMOUNT_CACHE_FOLDER "/blocks.data"
#define XMOUNT_CACHE_BLOCK_INDEX_FILE XMOUNT_CACHE_FOLDER "/blocks.index"
/*******************************************************************************
* Private types / structures / enums
******************************************************************************/
typedef struct s_XmountCacheHandle {
//! Cache file to save changes to
char *p_cache_file;
//! Handle to cache file
hGidaFs h_cache_file;
//! Handle to block cache
hGidaFsFile h_block_cache;
//! Handle to block cache index
hGidaFsFile h_block_cache_index;
//! In-memory copy of cache index
uint64_t *p_block_cache_index;
//! Length (in elements) of in-memory block cache index
uint64_t block_cache_index_len;
// TODO: Move to s_XmountData
//! Overwrite existing cache
uint8_t overwrite_cache;
} ts_XmountCacheHandle, *pts_XmountCacheHandle;
/*******************************************************************************
* Private functions declarations
******************************************************************************/
/*!
* \brief Create a new xmount cache handle
*
* \param pp_h Pointer to an xmount cache handle
* \param p_file Cache file path / name
* \return e_XmountCache_Error_None on success
*/
te_XmountCache_Error XmountCache_CreateHandle(pts_XmountCacheHandle *pp_h,
const char *p_file);
/*!
* \brief Destroy an xmount cache handle
*
* \param pp_h Pointer to an xmount cache handle
* \return e_XmountCache_Error_None on success
*/
te_XmountCache_Error XmountCache_DestroyHandle(pts_XmountCacheHandle *pp_h);
/*!
* \brief Check if a file exists
*
* Checks if the given file p_file exists.
*
* \param p_file File to check for
* \return e_XmountCache_Error_None if file exists
*/
te_XmountCache_Error XmountCache_FileExists(const char *p_file);
+/*!
+ * \brief Updates a block cache entry
+ *
+ * Updates the given block cache index entry on disk. If the special value
+ * XMOUNT_CACHE_INVALID_INDEX is given as entry value, the whole block cache
+ * index is updated.
+ *
+ * \param p_h Cache handle
+ * \param entry Block cache entry number to update
+ * \return e_XmountCache_Error_None on success
+ */
+te_XmountCache_Error XmountCache_UpdateIndex(pts_XmountCacheHandle p_h,
+ uint64_t entry);
+
/*******************************************************************************
* Public functions implementations
******************************************************************************/
/*
* XmountCache_Create
*/
te_XmountCache_Error XmountCache_Create(pts_XmountCacheHandle *pp_h,
const char *p_file,
uint64_t image_size,
uint8_t overwrite)
{
pts_XmountCacheHandle p_h=NULL;
teGidaFsError gidafs_ret=eGidaFsError_None;
te_XmountCache_Error ret=e_XmountCache_Error_None;
- // Check params
+ // Params check
if(pp_h==NULL) return e_XmountCache_Error_InvalidHandlePointer;
if(p_file==NULL) return e_XmountCache_Error_InvalidString;
if(strlen(p_file)==0) return e_XmountCache_Error_InvalidFile;
// Make sure file does not exist when overwrite was not specified
if(overwrite==0 && XmountCache_FileExists(p_file)==e_XmountCache_Error_None) {
// Given file exists and overwrite was not specified. This is fatal!
return e_XmountCache_Error_ExistingFile;
}
// Create new handle
ret=XmountCache_CreateHandle(&p_h,p_file);
if(ret!=e_XmountCache_Error_None) return ret;
#define XMOUNTCACHE_CREATE__DESTROY_HANDLE do { \
ret=XmountCache_DestroyHandle(&p_h); \
if(ret!=e_XmountCache_Error_None) { \
LOG_ERROR("Unable to destroy cache handle: Error code %u: Ignoring!\n", \
ret); \
} \
*pp_h=NULL; \
} while(0)
// Create new cache file
gidafs_ret=GidaFsLib_NewFs(&(p_h->h_cache_file),
p_h->p_cache_file,
0);
if(gidafs_ret!=eGidaFsError_None) {
LOG_ERROR("Unable to create new xmount cache file '%s': Error code %u!\n",
p_h->p_cache_file,
gidafs_ret);
XMOUNTCACHE_CREATE__DESTROY_HANDLE;
return FALSE;
}
#define XMOUNTCACHE_CREATE__CLOSE_CACHE do { \
gidafs_ret=GidaFsLib_CloseFs(&(p_h->h_cache_file)); \
if(gidafs_ret!=eGidaFsError_None) { \
LOG_ERROR("Unable to close xmount cache file '%s': " \
"Error code %u: Ignoring!\n", \
p_h->p_cache_file, \
gidafs_ret); \
} \
} while(0)
// TODO: Check if cache file uses same block size as we do
// Create needed xmount subdirectory
gidafs_ret=GidaFsLib_CreateDir(p_h->h_cache_file,
XMOUNT_CACHE_FOLDER,
eGidaFsNodeFlag_RWXu);
if(gidafs_ret!=eGidaFsError_None) {
LOG_ERROR("Unable to create cache file directory '%s': Error code %u!\n",
XMOUNT_CACHE_FOLDER,
gidafs_ret);
XMOUNTCACHE_CREATE__CLOSE_CACHE;
XMOUNTCACHE_CREATE__DESTROY_HANDLE;
return e_XmountCache_Error_FailedCacheInit;
}
// Create block cache file
gidafs_ret=GidaFsLib_OpenFile(p_h->h_cache_file,
XMOUNT_CACHE_BLOCK_FILE,
&(p_h->h_block_cache),
eGidaFsOpenFileFlag_ReadWrite |
eGidaFsOpenFileFlag_CreateAlways,
eGidaFsNodeFlag_Rall | eGidaFsNodeFlag_Wusr);
if(gidafs_ret!=eGidaFsError_None) {
LOG_ERROR("Unable to create block cache file '%s': Error code %u!\n",
XMOUNT_CACHE_BLOCK_FILE,
gidafs_ret);
XMOUNTCACHE_CREATE__CLOSE_CACHE;
XMOUNTCACHE_CREATE__DESTROY_HANDLE;
+ // TODO: Own error code needed here
return e_XmountCache_Error_FailedCacheInit;
}
#define XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE do { \
gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file, \
&(p_h->h_block_cache)); \
if(gidafs_ret!=eGidaFsError_None) { \
LOG_ERROR("Unable to close block cache file: Error code %u: " \
"Ignoring!\n", \
gidafs_ret); \
} \
} while(0)
// Create block cache index file
gidafs_ret=GidaFsLib_OpenFile(p_h->h_cache_file,
XMOUNT_CACHE_BLOCK_INDEX_FILE,
&(p_h->h_block_cache_index),
eGidaFsOpenFileFlag_ReadWrite |
eGidaFsOpenFileFlag_CreateAlways,
eGidaFsNodeFlag_Rall | eGidaFsNodeFlag_Wusr);
if(gidafs_ret!=eGidaFsError_None) {
LOG_ERROR("Unable to create block cache index file '%s': Error code %u!\n",
XMOUNT_CACHE_BLOCK_FILE,
gidafs_ret);
XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE;
XMOUNTCACHE_CREATE__CLOSE_CACHE;
XMOUNTCACHE_CREATE__DESTROY_HANDLE;
+ // TODO: Own error code needed here
return e_XmountCache_Error_FailedCacheInit;
}
#define XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE_INDEX do { \
gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file, \
&(p_h->h_block_cache_index)); \
if(gidafs_ret!=eGidaFsError_None) { \
LOG_ERROR("Unable to close block cache index file: Error code %u: " \
"Ignoring!\n", \
gidafs_ret); \
} \
} while(0)
// Calculate how many cache blocks are needed and how big the cache block
// index must be
p_h->block_cache_index_len=image_size/XMOUNT_CACHE_BLOCK_SIZE;
if((image_size%XMOUNT_CACHE_BLOCK_SIZE)!=0) p_h->block_cache_index_len++;
LOG_DEBUG("Cache blocks: %" PRIu64 " entries using %" PRIu64 " bytes\n",
p_h->block_cache_index_len,
p_h->block_cache_index_len*sizeof(uint8_t));
// Prepare in-memory buffer for block cache index
p_h->p_block_cache_index=
(uint64_t*)calloc(1,p_h->block_cache_index_len*sizeof(uint64_t));
if(p_h->p_block_cache_index==NULL) {
XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE_INDEX;
XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE;
XMOUNTCACHE_CREATE__CLOSE_CACHE;
XMOUNTCACHE_CREATE__DESTROY_HANDLE;
return e_XmountCache_Error_Alloc;
}
// Generate initial block cache index
for(uint64_t i=0;i<p_h->block_cache_index_len;i++) {
p_h->p_block_cache_index[i]=XMOUNT_CACHE_INVALID_INDEX;
}
// Write initial block cache index to cache file
- if(UpdateBlockCacheIndex(XMOUNT_BLOCK_CACHE_INVALID_INDEX,0)!=TRUE) {
- LOG_ERROR("Unable to generate initial block cache index file '%s': "
+ ret=XmountCache_UpdateIndex(p_h,XMOUNT_CACHE_INVALID_INDEX);
+ if(ret!=e_XmountCache_Error_None) {
+ LOG_ERROR("Unable to update initial block cache index file: "
"Error code %u!\n",
XMOUNT_CACHE_BLOCK_FILE,
- gidafs_ret);
+ ret);
XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE_INDEX;
XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE;
XMOUNTCACHE_CREATE__CLOSE_CACHE;
XMOUNTCACHE_CREATE__DESTROY_HANDLE;
- return e_XmountCache_Error_FailedCacheInit;
+ return ret;
}
#undef XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE_INDEX
#undef XMOUNTCACHE_CREATE__CLOSE_BLOCK_CACHE
#undef XMOUNTCACHE_CREATE__CLOSE_CACHE
#undef XMOUNTCACHE_CREATE__DESTROY_HANDLE
*pp_h=p_h;
return e_XmountCache_Error_None;
}
/*
* XmountCache_Open
*/
te_XmountCache_Error XmountCache_Open(pts_XmountCacheHandle *pp_h,
const char *p_file,
uint64_t image_size)
{
+ uint64_t blockindex_size=0;
+ uint64_t read=0;
pts_XmountCacheHandle p_h=NULL;
teGidaFsError gidafs_ret=eGidaFsError_None;
te_XmountCache_Error ret=e_XmountCache_Error_None;
- // Check params
+ // Params check
if(pp_h==NULL) return e_XmountCache_Error_InvalidHandlePointer;
if(p_file==NULL) return e_XmountCache_Error_InvalidString;
if(strlen(p_file)==0) return e_XmountCache_Error_InvalidFile;
// Make sure file exists
if(XmountCache_FileExists(p_file)!=e_XmountCache_Error_None) {
// Given file does not exist. This is fatal!
return e_XmountCache_Error_InexistingFile;
}
// Create new handle
ret=XmountCache_CreateHandle(&p_h,p_file);
if(ret!=e_XmountCache_Error_None) return ret;
#define XMOUNTCACHE_OPEN__DESTROY_HANDLE do { \
ret=XmountCache_DestroyHandle(&p_h); \
if(ret!=e_XmountCache_Error_None) { \
LOG_ERROR("Unable to destroy cache handle: Error code %u: Ignoring!\n", \
ret); \
} \
*pp_h=NULL; \
} while(0)
// Open cache file
gidafs_ret=GidaFsLib_OpenFs(&(p_h->h_cache_file),p_h->p_cache_file);
if(gidafs_ret!=eGidaFsError_None) {
// TODO: Check for old cache file type and inform user it isn't supported
// anymore!
LOG_ERROR("Couldn't open xmount cache file '%s': Error code %u!\n",
p_h->p_cache_file,
gidafs_ret)
return e_XmountCache_Error_FailedOpeningCache;
}
#define XMOUNTCACHE_OPEN__CLOSE_CACHE do { \
gidafs_ret=GidaFsLib_CloseFs(&(p_h->h_cache_file)); \
if(gidafs_ret!=eGidaFsError_None) { \
LOG_ERROR("Unable to close xmount cache file '%s': " \
"Error code %u: Ignoring!\n", \
p_h->p_cache_file, \
gidafs_ret); \
} \
} while(0)
+ // Open block cache file
+ gidafs_ret=GidaFsLib_OpenFile(p_h->h_cache_file,
+ XMOUNT_CACHE_BLOCK_FILE,
+ &(p_h->h_block_cache),
+ eGidaFsOpenFileFlag_ReadWrite,
+ 0);
+ if(gidafs_ret!=eGidaFsError_None) {
+ LOG_ERROR("Unable to open block cache file '%s': Error code %u!\n",
+ XMOUNT_CACHE_BLOCK_FILE,
+ gidafs_ret);
+ XMOUNTCACHE_OPEN__CLOSE_CACHE;
+ XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+ // TODO: Own error code needed here
+ return e_XmountCache_Error_FailedOpeningCache;
+ }
+
#define XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE do { \
gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file, \
&(p_h->h_block_cache)); \
if(gidafs_ret!=eGidaFsError_None) { \
LOG_ERROR("Unable to close block cache file: Error code %u: " \
"Ignoring!\n", \
gidafs_ret); \
} \
} while(0)
+ // Open block cache index file
+ gidafs_ret=GidaFsLib_OpenFile(p_h->h_cache_file,
+ XMOUNT_CACHE_BLOCK_INDEX_FILE,
+ &(p_h->h_block_cache_index),
+ eGidaFsOpenFileFlag_ReadWrite,
+ 0);
+ if(gidafs_ret!=eGidaFsError_None) {
+ LOG_ERROR("Unable to open block cache index file '%s': Error code %u!\n",
+ XMOUNT_CACHE_BLOCK_FILE,
+ gidafs_ret);
+ XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE;
+ XMOUNTCACHE_OPEN__CLOSE_CACHE;
+ XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+ // TODO: Own error code needed here
+ return e_XmountCache_Error_FailedOpeningCache;
+ }
+
#define XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX do { \
gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file, \
&(p_h->h_block_cache_index)); \
if(gidafs_ret!=eGidaFsError_None) { \
LOG_ERROR("Unable to close block cache index file: Error code %u: " \
"Ignoring!\n", \
gidafs_ret); \
} \
} while(0)
+ // Calculate how many cache blocks are needed and how big the cache block
+ // index must be
+ p_h->block_cache_index_len=image_size/XMOUNT_CACHE_BLOCK_SIZE;
+ if((image_size%XMOUNT_CACHE_BLOCK_SIZE)!=0) p_h->block_cache_index_len++;
+ LOG_DEBUG("Cache blocks: %" PRIu64 " entries using %" PRIu64 " bytes\n",
+ p_h->block_cache_index_len,
+ p_h->block_cache_index_len*sizeof(uint8_t));
-
-
-
-
-
-
-/*
-
-
-#define INITCACHEFILE__CLOSE_CACHE do { \
- gidafs_ret=GidaFsLib_CloseFs(&(glob_xmount.cache.h_cache_file)); \
- if(gidafs_ret!=eGidaFsError_None) { \
- LOG_ERROR("Unable to close cache file: Error code %u: Ignoring!\n", \
- gidafs_ret) \
- } \
-} while(0)
-
-#define INITCACHEFILE__CLOSE_BLOCK_CACHE do { \
- gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file, \
- &(glob_xmount.cache.h_block_cache)); \
- if(gidafs_ret!=eGidaFsError_None) { \
- LOG_ERROR("Unable to close block cache file: Error code %u: Ignoring!\n", \
- gidafs_ret) \
- } \
-} while(0)
-
-#define INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX do { \
- gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file, \
- &(glob_xmount.cache.h_block_cache_index)); \
- if(gidafs_ret!=eGidaFsError_None) { \
- LOG_ERROR("Unable to close block cache index file: Error code %u: " \
- "Ignoring!\n", \
- gidafs_ret) \
- } \
-} while(0)
-
- // TODO: Check if cache file uses same block size as we do
-
- if(is_new_cache_file==1) {
- // New cache file, create needed xmount subdirectory
- gidafs_ret=GidaFsLib_CreateDir(glob_xmount.cache.h_cache_file,
- XMOUNT_CACHE_FOLDER,
- eGidaFsNodeFlag_RWXu);
- if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to create cache file directory '%s': Error code %u!\n",
- XMOUNT_CACHE_FOLDER,
- gidafs_ret)
- INITCACHEFILE__CLOSE_CACHE;
- return FALSE;
- }
- }
-
- // Open / Create block cache file
- gidafs_ret=GidaFsLib_OpenFile(glob_xmount.cache.h_cache_file,
- XMOUNT_CACHE_BLOCK_FILE,
- &(glob_xmount.cache.h_block_cache),
- eGidaFsOpenFileFlag_ReadWrite |
- (is_new_cache_file==1 ?
- eGidaFsOpenFileFlag_CreateAlways : 0),
- eGidaFsNodeFlag_Rall |
- eGidaFsNodeFlag_Wusr);
- if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to open / create block cache file '%s': Error code %u!\n",
- XMOUNT_CACHE_BLOCK_FILE,
- gidafs_ret)
- INITCACHEFILE__CLOSE_CACHE;
- return FALSE;
- }
-
- // Open / Create block cache index file
- gidafs_ret=GidaFsLib_OpenFile(glob_xmount.cache.h_cache_file,
- XMOUNT_CACHE_BLOCK_INDEX_FILE,
- &(glob_xmount.cache.h_block_cache_index),
- eGidaFsOpenFileFlag_ReadWrite |
- (is_new_cache_file==1 ?
- eGidaFsOpenFileFlag_CreateAlways : 0),
- eGidaFsNodeFlag_Rall |
- eGidaFsNodeFlag_Wusr);
+ // Make sure block cache index has correct size
+ gidafs_ret=GidaFsLib_GetFileSize(p_h->h_cache_file,
+ p_h->h_block_cache_index,
+ &blockindex_size);
if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to open / create block cache index file '%s': "
- "Error code %u!\n",
- XMOUNT_CACHE_BLOCK_FILE,
+ LOG_ERROR("Unable to get block cache index file size: Error code %u!\n",
gidafs_ret)
- INITCACHEFILE__CLOSE_BLOCK_CACHE;
- INITCACHEFILE__CLOSE_CACHE;
- return FALSE;
+ XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX;
+ XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE;
+ XMOUNTCACHE_OPEN__CLOSE_CACHE;
+ XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+ return e_XmountCache_Error_FailedGettingIndexSize;
}
-
- // Calculate how many cache blocks are needed and how big the cache block
- // index must be
- glob_xmount.cache.block_cache_index_len=image_size/CACHE_BLOCK_SIZE;
- if((image_size%CACHE_BLOCK_SIZE)!=0) {
- glob_xmount.cache.block_cache_index_len++;
+ if(blockindex_size%sizeof(uint64_t)!=0 ||
+ (blockindex_size/sizeof(uint64_t))!=p_h->block_cache_index_len)
+ {
+ // TODO: Be more helpfull in error message
+ LOG_ERROR("Block cache index size is incorrect for given input image!\n")
+ XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX;
+ XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE;
+ XMOUNTCACHE_OPEN__CLOSE_CACHE;
+ XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+ return e_XmountCache_Error_InvalidIndexSize;
}
- LOG_DEBUG("Cache blocks: %u (0x%04X) entries using %zd (0x%08zX) bytes\n",
- glob_xmount.cache.block_cache_index_len,
- glob_xmount.cache.block_cache_index_len,
- glob_xmount.cache.block_cache_index_len*
- sizeof(t_CacheFileBlockIndex),
- glob_xmount.cache.block_cache_index_len*
- sizeof(t_CacheFileBlockIndex))
-
// Prepare in-memory buffer for block cache index
- XMOUNT_MALLOC(glob_xmount.cache.p_block_cache_index,
- t_CacheFileBlockIndex*,
- glob_xmount.cache.block_cache_index_len*
- sizeof(t_CacheFileBlockIndex))
-
- if(is_new_cache_file==1) {
- // Generate initial block cache index
- for(uint64_t i=0;i<glob_xmount.cache.block_cache_index_len;i++) {
- glob_xmount.cache.p_block_cache_index[i]=CACHE_BLOCK_FREE;
- }
- // Write initial block cache index to cache file
- if(UpdateBlockCacheIndex(XMOUNT_BLOCK_CACHE_INVALID_INDEX,0)!=TRUE) {
- LOG_ERROR("Unable to generate initial block cache index file '%s': "
- "Error code %u!\n",
- XMOUNT_CACHE_BLOCK_FILE,
- gidafs_ret)
- INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
- INITCACHEFILE__CLOSE_BLOCK_CACHE;
- INITCACHEFILE__CLOSE_CACHE;
- XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
- return FALSE;
- }
- } else {
- // Existing cache file, make sure block cache index has correct size
- gidafs_ret=GidaFsLib_GetFileSize(glob_xmount.cache.h_cache_file,
- glob_xmount.cache.h_block_cache_index,
- &blockindex_size);
- if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to get block cache index file size: Error code %u!\n",
- gidafs_ret)
- INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
- INITCACHEFILE__CLOSE_BLOCK_CACHE;
- INITCACHEFILE__CLOSE_CACHE;
- XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
- return FALSE;
- }
- if(blockindex_size%sizeof(t_CacheFileBlockIndex)!=0 ||
- (blockindex_size/sizeof(t_CacheFileBlockIndex))!=
- glob_xmount.cache.block_cache_index_len)
- {
- // TODO: Be more helpfull in error message
- LOG_ERROR("Block cache index size is incorrect for given input image!\n")
- INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
- INITCACHEFILE__CLOSE_BLOCK_CACHE;
- INITCACHEFILE__CLOSE_CACHE;
- XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
- return FALSE;
- }
- // Read block cache index into memory
- gidafs_ret=GidaFsLib_ReadFile(glob_xmount.cache.h_cache_file,
- glob_xmount.cache.h_block_cache_index,
- 0,
- blockindex_size,
- glob_xmount.cache.p_block_cache_index,
- &read);
- if(gidafs_ret!=eGidaFsError_None || read!=blockindex_size) {
- LOG_ERROR("Unable to read block cache index: Error code %u!\n",
- gidafs_ret);
- INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
- INITCACHEFILE__CLOSE_BLOCK_CACHE;
- INITCACHEFILE__CLOSE_CACHE;
- XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
- return FALSE;
- }
+ p_h->p_block_cache_index=
+ (uint64_t*)calloc(1,p_h->block_cache_index_len*sizeof(uint64_t));
+ if(p_h->p_block_cache_index==NULL) {
+ XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX;
+ XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE;
+ XMOUNTCACHE_OPEN__CLOSE_CACHE;
+ XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+ return e_XmountCache_Error_Alloc;
}
-#undef INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX
-#undef INITCACHEFILE__CLOSE_BLOCK_CACHE
-#undef INITCACHEFILE__CLOSE_CACHE
-*/
+ // Read block cache index into memory
+ gidafs_ret=GidaFsLib_ReadFile(p_h->h_cache_file,
+ p_h->h_block_cache_index,
+ 0,
+ blockindex_size,
+ p_h->p_block_cache_index,
+ &read);
+ if(gidafs_ret!=eGidaFsError_None || read!=blockindex_size) {
+ LOG_ERROR("Unable to read block cache index: Error code %u!\n",
+ gidafs_ret);
+ XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX;
+ XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE;
+ XMOUNTCACHE_OPEN__CLOSE_CACHE;
+ XMOUNTCACHE_OPEN__DESTROY_HANDLE;
+ return e_XmountCache_Error_FailedReadingIndex;
+ }
#undef XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE_INDEX
#undef XMOUNTCACHE_OPEN__CLOSE_BLOCK_CACHE
#undef XMOUNTCACHE_OPEN__CLOSE_CACHE
#undef XMOUNTCACHE_OPEN__DESTROY_HANDLE
*pp_h=p_h;
return e_XmountCache_Error_None;
}
/*
* XmountCache_Close
*/
te_XmountCache_Error XmountCache_Close(pts_XmountCacheHandle *pp_h) {
pts_XmountCacheHandle p_h=NULL;
+ teGidaFsError gidafs_ret=eGidaFsError_None;
+ te_XmountCache_Error final_ret=e_XmountCache_Error_None;
te_XmountCache_Error ret=e_XmountCache_Error_None;
+ // Params check
+ if(pp_h==NULL) return e_XmountCache_Error_InvalidHandlePointer;
+ if(*pp_h==NULL) return e_XmountCache_Error_InvalidHandle;
+ p_h=*pp_h;
+
+ // Close block cache index
+ gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file,&(p_h->h_block_cache_index));
+ if(gidafs_ret!=eGidaFsError_None) {
+ LOG_ERROR("Unable to close block cache index file: Error code %u: "
+ "Ignoring!\n",
+ gidafs_ret);
+ if(final_ret==e_XmountCache_Error_None) {
+ final_ret=e_XmountCache_Error_FailedClosingIndex;
+ }
+ }
+
+ // Close block cache
+ gidafs_ret=GidaFsLib_CloseFile(p_h->h_cache_file,&(p_h->h_block_cache));
+ if(gidafs_ret!=eGidaFsError_None) {
+ LOG_ERROR("Unable to close block cache file: Error code %u: "
+ "Ignoring!\n",
+ gidafs_ret);
+ if(final_ret==e_XmountCache_Error_None) {
+ final_ret=e_XmountCache_Error_FailedClosingBlockCache;
+ }
+ }
+
+ // Close cache file
+ gidafs_ret=GidaFsLib_CloseFs(&(p_h->h_cache_file));
+ if(gidafs_ret!=eGidaFsError_None) {
+ LOG_ERROR("Unable to close xmount cache file '%s': Error code %u: "
+ "Ignoring!\n",
+ p_h->p_cache_file,
+ gidafs_ret);
+ if(final_ret==e_XmountCache_Error_None) {
+ final_ret=e_XmountCache_Error_FailedClosingCache;
+ }
+ }
+ // Destroy handle
+ ret=XmountCache_DestroyHandle(&p_h);
+ if(ret!=e_XmountCache_Error_None) {
+ LOG_ERROR("Unable to destroy cache handle: Error code %u: Ignoring!\n",
+ ret);
+ if(final_ret==e_XmountCache_Error_None) {
+ final_ret=ret;
+ }
+ }
*pp_h=NULL;
- return e_XmountCache_Error_None;
+ return final_ret;
}
/*
* XmountCache_BlockCacheRead
*/
te_XmountCache_Error XmountCache_BlockCacheRead(pts_XmountCacheHandle p_h,
char *p_buf,
uint64_t block,
uint64_t block_offset,
uint64_t count)
{
- te_XmountCache_Error ret=e_XmountCache_Error_None;
+ uint64_t read=0;
+ teGidaFsError gidafs_ret=eGidaFsError_None;
+
+ // Params check
+ if(p_h==NULL) return e_XmountCache_Error_InvalidHandle;
+ if(p_buf==NULL) return e_XmountCache_Error_InvalidBuffer;
+ if(block>=p_h->block_cache_index_len) return e_XmountCache_Error_InvalidIndex;
+ if(block_offset>XMOUNT_CACHE_BLOCK_SIZE ||
+ block_offset+count>XMOUNT_CACHE_BLOCK_SIZE)
+ {
+ return e_XmountCache_Error_ReadBeyondBlockBounds;
+ }
+ if(p_h->p_block_cache_index[block]==XMOUNT_CACHE_INVALID_INDEX) {
+ return e_XmountCache_Error_UncachedBlock;
+ }
+
+ // Read requested data from block cache file
+ gidafs_ret=GidaFsLib_ReadFile(p_h->h_cache_file,
+ p_h->h_block_cache,
+ p_h->p_block_cache_index[block]+block_offset,
+ count,
+ p_buf,
+ &read);
+ if(gidafs_ret!=eGidaFsError_None || read!=count) {
+ LOG_ERROR("Unable to read cached data from block %" PRIu64
+ ": Error code %u!\n",
+ block,
+ gidafs_ret);
+ return e_XmountCache_Error_FailedReadingBlockCache;
+ }
+
+ return e_XmountCache_Error_None;
}
/*
* XmountCache_BlockCacheWrite
*/
te_XmountCache_Error XmountCache_BlockCacheWrite(pts_XmountCacheHandle p_h,
char *p_buf,
uint64_t block,
uint64_t block_offset,
uint64_t count)
{
- te_XmountCache_Error ret=e_XmountCache_Error_None;
+ uint64_t written=0;
+ teGidaFsError gidafs_ret=eGidaFsError_None;
+
+ // Params check
+ if(p_h==NULL) return e_XmountCache_Error_InvalidHandle;
+ if(p_buf==NULL) return e_XmountCache_Error_InvalidBuffer;
+ if(block>=p_h->block_cache_index_len) return e_XmountCache_Error_InvalidIndex;
+ if(block_offset>XMOUNT_CACHE_BLOCK_SIZE ||
+ block_offset+count>XMOUNT_CACHE_BLOCK_SIZE)
+ {
+ return e_XmountCache_Error_ReadBeyondBlockBounds;
+ }
+ if(p_h->p_block_cache_index[block]==XMOUNT_CACHE_INVALID_INDEX) {
+ return e_XmountCache_Error_UncachedBlock;
+ }
+
+ gidafs_ret=GidaFsLib_WriteFile(p_h->h_cache_file,
+ p_h->h_block_cache,
+ p_h->p_block_cache_index[block]+block_offset,
+ count,
+ p_buf,
+ &written);
+ if(gidafs_ret!=eGidaFsError_None || written!=count) {
+ LOG_ERROR("Unable to write data to cached block %" PRIu64
+ ": Error code %u!\n",
+ block,
+ gidafs_ret);
+ return e_XmountCache_Error_FailedWritingBlockCache;
+ }
+
+ return e_XmountCache_Error_None;
}
/*
* XmountCache_BlockCacheAppend
*/
te_XmountCache_Error XmountCache_BlockCacheAppend(pts_XmountCacheHandle p_h,
char *p_buf,
uint64_t block)
{
+ uint64_t written=0;
+ teGidaFsError gidafs_ret=eGidaFsError_None;
te_XmountCache_Error ret=e_XmountCache_Error_None;
+
+ // Params check
+ if(p_h==NULL) return e_XmountCache_Error_InvalidHandle;
+ if(p_buf==NULL) return e_XmountCache_Error_InvalidBuffer;
+ if(block>=p_h->block_cache_index_len) return e_XmountCache_Error_InvalidIndex;
+
+ // Get current block cache size
+ gidafs_ret=GidaFsLib_GetFileSize(p_h->h_cache_file,
+ p_h->h_block_cache,
+ &(p_h->p_block_cache_index[block]));
+ if(gidafs_ret!=eGidaFsError_None) {
+ LOG_ERROR("Unable to get current block cache size: Error code %u!\n",
+ gidafs_ret);
+ return e_XmountCache_Error_FailedGettingIndexSize;
+ }
+
+ // Append new block
+ gidafs_ret=GidaFsLib_WriteFile(p_h->h_cache_file,
+ p_h->h_block_cache,
+ p_h->p_block_cache_index[block],
+ XMOUNT_CACHE_BLOCK_SIZE,
+ p_buf,
+ &written);
+ if(gidafs_ret!=eGidaFsError_None || written!=XMOUNT_CACHE_BLOCK_SIZE) {
+ LOG_ERROR("Unable to write data to cached block %" PRIu64
+ ": Error code %u!\n",
+ block,
+ gidafs_ret);
+ return e_XmountCache_Error_FailedWritingBlockCache;
+ }
+
+ // Update on-disk block cache index
+ ret=XmountCache_UpdateIndex(p_h,block);
+ if(ret!=e_XmountCache_Error_None) {
+ LOG_ERROR("Unable to update block cache index %" PRIu64
+ ": Error code %u!\n",
+ block,
+ ret);
+ return ret;
+ }
+
+ return e_XmountCache_Error_None;
}
/*
* XmountCache_IsBlockCached
*/
te_XmountCache_Error XmountCache_IsBlockCached(pts_XmountCacheHandle p_h,
uint64_t block)
{
- te_XmountCache_Error ret=e_XmountCache_Error_None;
+ // Params check
+ if(p_h==NULL) return e_XmountCache_Error_InvalidHandle;
+ if(block>=p_h->block_cache_index_len) return e_XmountCache_Error_InvalidIndex;
+
+ // Check if given block has been cached previously
+ if(p_h->p_block_cache_index[block]==XMOUNT_CACHE_INVALID_INDEX) {
+ // Block is not in cache
+ return e_XmountCache_Error_UncachedBlock;
+ }
+
+ return e_XmountCache_Error_None;
}
/*******************************************************************************
* Private functions implementations
******************************************************************************/
/*
* XmountCache_CreateHandle
*/
te_XmountCache_Error XmountCache_CreateHandle(pts_XmountCacheHandle *pp_h,
const char *p_file)
{
pts_XmountCacheHandle p_h=NULL;
- // Check given handle pointer
- if(pp_h==NULL) return e_XmountCache_Error_InvalidHandlePointer;
-
// Alloc memory for handle
p_h=(pts_XmountCacheHandle)calloc(1,sizeof(ts_XmountCacheHandle));
if(p_h==NULL) {
*pp_h=NULL;
return e_XmountCache_Error_Alloc;
}
// Init values. The p_cache_file alloc and memcpy works corrently as strlen()
// counts the amount of bytes, not chars. No UTF8-issue here.
p_h->p_cache_file=(char*)calloc(1,strlen(p_file)+1);
if(p_h->p_cache_file==NULL) {
free(p_h);
*pp_h=NULL;
return e_XmountCache_Error_Alloc;
}
memcpy(p_h->p_cache_file,p_file,strlen(p_file));
p_h->h_cache_file=NULL;
p_h->h_block_cache=NULL;
p_h->h_block_cache_index=NULL;
p_h->p_block_cache_index=NULL;
// Return new handle
*pp_h=p_h;
return e_XmountCache_Error_None;
}
/*
* XmountCache_DestroyHandle
*/
te_XmountCache_Error XmountCache_DestroyHandle(pts_XmountCacheHandle *pp_h) {
- pts_XmountCacheHandle p_h=NULL;
-
- // Check given handle pointer
- if(pp_h==NULL) return e_XmountCache_Error_InvalidHandlePointer;
- if(*pp_h==NULL) return e_XmountCache_Error_InvalidHandle;
- p_h=*pp_h;
+ pts_XmountCacheHandle p_h=*pp_h;
// Free handle
if(p_h->p_cache_file!=NULL) free(p_h->p_cache_file);
if(p_h->p_block_cache_index!=NULL) free(p_h->p_block_cache_index);
free(p_h);
// Return destroyed handle
*pp_h=NULL;
return e_XmountCache_Error_None;
}
/*
* XmountCache_FileExists
*/
te_XmountCache_Error XmountCache_FileExists(const char *p_file) {
struct stat statbuf;
if(lstat(p_file,&statbuf)==0) return e_XmountCache_Error_None;
else return e_XmountCache_Error_InexistingFile;
}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//! Create / load cache file to enable virtual write support
-/*!
- * \return TRUE on success, FALSE on error
- */
-int InitCacheFile() {
- uint64_t blockindex_size=0;
- uint64_t image_size=0;
- uint64_t read=0;
- uint8_t is_new_cache_file=0;
- teGidaFsError gidafs_ret=eGidaFsError_None;
-
- // Get input image size for later use
- if(!GetMorphedImageSize(&image_size)) {
- LOG_ERROR("Couldn't get morphed image size!\n")
- return FALSE;
- }
-
- if(!glob_xmount.cache.overwrite_cache) {
- // Try to open an existing cache file or create a new one
- gidafs_ret=GidaFsLib_OpenFs(&(glob_xmount.cache.h_cache_file),
- glob_xmount.cache.p_cache_file);
- if(gidafs_ret!=eGidaFsError_None &&
- gidafs_ret!=eGidaFsError_FailedOpeningFsFile)
- {
- // TODO: Check for old cache file type and inform user it isn't supported
- // anymore!
- LOG_ERROR("Couldn't open cache file '%s': Error code %u!\n",
- glob_xmount.cache.p_cache_file,
- gidafs_ret)
- return FALSE;
- } else if(gidafs_ret==eGidaFsError_FailedOpeningFsFile) {
- // Unable to open cache file. It might simply not exist.
- LOG_DEBUG("Cache file '%s' does not exist. Creating new one\n",
- glob_xmount.cache.p_cache_file)
- gidafs_ret=GidaFsLib_NewFs(&(glob_xmount.cache.h_cache_file),
- glob_xmount.cache.p_cache_file,
- 0);
- if(gidafs_ret!=eGidaFsError_None) {
- // There is really a problem opening/creating the file
- LOG_ERROR("Couldn't open cache file '%s': Error code %u!\n",
- glob_xmount.cache.p_cache_file,
- gidafs_ret)
- return FALSE;
- }
- is_new_cache_file=1;
- }
- } else {
- // Overwrite existing cache file or create a new one
- gidafs_ret=GidaFsLib_NewFs(&(glob_xmount.cache.h_cache_file),
- glob_xmount.cache.p_cache_file,
- 0);
- if(gidafs_ret!=eGidaFsError_None) {
- // There is really a problem opening/creating the file
- LOG_ERROR("Couldn't open cache file '%s': Error code %u!\n",
- glob_xmount.cache.p_cache_file,
- gidafs_ret)
- return FALSE;
- }
- is_new_cache_file=1;
- }
-
-#define INITCACHEFILE__CLOSE_CACHE do { \
- gidafs_ret=GidaFsLib_CloseFs(&(glob_xmount.cache.h_cache_file)); \
- if(gidafs_ret!=eGidaFsError_None) { \
- LOG_ERROR("Unable to close cache file: Error code %u: Ignoring!\n", \
- gidafs_ret) \
- } \
-} while(0)
-
-#define INITCACHEFILE__CLOSE_BLOCK_CACHE do { \
- gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file, \
- &(glob_xmount.cache.h_block_cache)); \
- if(gidafs_ret!=eGidaFsError_None) { \
- LOG_ERROR("Unable to close block cache file: Error code %u: Ignoring!\n", \
- gidafs_ret) \
- } \
-} while(0)
-
-#define INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX do { \
- gidafs_ret=GidaFsLib_CloseFile(glob_xmount.cache.h_cache_file, \
- &(glob_xmount.cache.h_block_cache_index)); \
- if(gidafs_ret!=eGidaFsError_None) { \
- LOG_ERROR("Unable to close block cache index file: Error code %u: " \
- "Ignoring!\n", \
- gidafs_ret) \
- } \
-} while(0)
-
- // TODO: Check if cache file uses same block size as we do
-
- if(is_new_cache_file==1) {
- // New cache file, create needed xmount subdirectory
- gidafs_ret=GidaFsLib_CreateDir(glob_xmount.cache.h_cache_file,
- XMOUNT_CACHE_FOLDER,
- eGidaFsNodeFlag_RWXu);
- if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to create cache file directory '%s': Error code %u!\n",
- XMOUNT_CACHE_FOLDER,
- gidafs_ret)
- INITCACHEFILE__CLOSE_CACHE;
- return FALSE;
- }
- }
-
- // Open / Create block cache file
- gidafs_ret=GidaFsLib_OpenFile(glob_xmount.cache.h_cache_file,
- XMOUNT_CACHE_BLOCK_FILE,
- &(glob_xmount.cache.h_block_cache),
- eGidaFsOpenFileFlag_ReadWrite |
- (is_new_cache_file==1 ?
- eGidaFsOpenFileFlag_CreateAlways : 0),
- eGidaFsNodeFlag_Rall |
- eGidaFsNodeFlag_Wusr);
- if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to open / create block cache file '%s': Error code %u!\n",
- XMOUNT_CACHE_BLOCK_FILE,
- gidafs_ret)
- INITCACHEFILE__CLOSE_CACHE;
- return FALSE;
- }
-
- // Open / Create block cache index file
- gidafs_ret=GidaFsLib_OpenFile(glob_xmount.cache.h_cache_file,
- XMOUNT_CACHE_BLOCK_INDEX_FILE,
- &(glob_xmount.cache.h_block_cache_index),
- eGidaFsOpenFileFlag_ReadWrite |
- (is_new_cache_file==1 ?
- eGidaFsOpenFileFlag_CreateAlways : 0),
- eGidaFsNodeFlag_Rall |
- eGidaFsNodeFlag_Wusr);
- if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to open / create block cache index file '%s': "
- "Error code %u!\n",
- XMOUNT_CACHE_BLOCK_FILE,
- gidafs_ret)
- INITCACHEFILE__CLOSE_BLOCK_CACHE;
- INITCACHEFILE__CLOSE_CACHE;
- return FALSE;
- }
-
- // Calculate how many cache blocks are needed and how big the cache block
- // index must be
- glob_xmount.cache.block_cache_index_len=image_size/CACHE_BLOCK_SIZE;
- if((image_size%CACHE_BLOCK_SIZE)!=0) {
- glob_xmount.cache.block_cache_index_len++;
- }
-
- LOG_DEBUG("Cache blocks: %u (0x%04X) entries using %zd (0x%08zX) bytes\n",
- glob_xmount.cache.block_cache_index_len,
- glob_xmount.cache.block_cache_index_len,
- glob_xmount.cache.block_cache_index_len*
- sizeof(t_CacheFileBlockIndex),
- glob_xmount.cache.block_cache_index_len*
- sizeof(t_CacheFileBlockIndex))
-
- // Prepare in-memory buffer for block cache index
- XMOUNT_MALLOC(glob_xmount.cache.p_block_cache_index,
- t_CacheFileBlockIndex*,
- glob_xmount.cache.block_cache_index_len*
- sizeof(t_CacheFileBlockIndex))
-
- if(is_new_cache_file==1) {
- // Generate initial block cache index
- for(uint64_t i=0;i<glob_xmount.cache.block_cache_index_len;i++) {
- glob_xmount.cache.p_block_cache_index[i]=CACHE_BLOCK_FREE;
- }
- // Write initial block cache index to cache file
- if(UpdateBlockCacheIndex(XMOUNT_BLOCK_CACHE_INVALID_INDEX,0)!=TRUE) {
- LOG_ERROR("Unable to generate initial block cache index file '%s': "
- "Error code %u!\n",
- XMOUNT_CACHE_BLOCK_FILE,
- gidafs_ret)
- INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
- INITCACHEFILE__CLOSE_BLOCK_CACHE;
- INITCACHEFILE__CLOSE_CACHE;
- XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
- return FALSE;
- }
- } else {
- // Existing cache file, make sure block cache index has correct size
- gidafs_ret=GidaFsLib_GetFileSize(glob_xmount.cache.h_cache_file,
- glob_xmount.cache.h_block_cache_index,
- &blockindex_size);
- if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to get block cache index file size: Error code %u!\n",
- gidafs_ret)
- INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
- INITCACHEFILE__CLOSE_BLOCK_CACHE;
- INITCACHEFILE__CLOSE_CACHE;
- XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
- return FALSE;
- }
- if(blockindex_size%sizeof(t_CacheFileBlockIndex)!=0 ||
- (blockindex_size/sizeof(t_CacheFileBlockIndex))!=
- glob_xmount.cache.block_cache_index_len)
- {
- // TODO: Be more helpfull in error message
- LOG_ERROR("Block cache index size is incorrect for given input image!\n")
- INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
- INITCACHEFILE__CLOSE_BLOCK_CACHE;
- INITCACHEFILE__CLOSE_CACHE;
- XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
- return FALSE;
- }
- // Read block cache index into memory
- gidafs_ret=GidaFsLib_ReadFile(glob_xmount.cache.h_cache_file,
- glob_xmount.cache.h_block_cache_index,
- 0,
- blockindex_size,
- glob_xmount.cache.p_block_cache_index,
- &read);
- if(gidafs_ret!=eGidaFsError_None || read!=blockindex_size) {
- LOG_ERROR("Unable to read block cache index: Error code %u!\n",
- gidafs_ret);
- INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX;
- INITCACHEFILE__CLOSE_BLOCK_CACHE;
- INITCACHEFILE__CLOSE_CACHE;
- XMOUNT_FREE(glob_xmount.cache.p_block_cache_index);
- return FALSE;
- }
- }
-
-#undef INITCACHEFILE__CLOSE_BLOCK_CACHE_INDEX
-#undef INITCACHEFILE__CLOSE_BLOCK_CACHE
-#undef INITCACHEFILE__CLOSE_CACHE
-
- return TRUE;
-}
-
-//! Update block cache index
-/*!
- * \return TRUE on success, FALSE on error
+/*
+ * XmountCache_UpdateIndex
*/
-int UpdateBlockCacheIndex(uint64_t index, t_CacheFileBlockIndex value) {
+te_XmountCache_Error XmountCache_UpdateIndex(pts_XmountCacheHandle p_h,
+ uint64_t entry)
+{
uint64_t update_size=0;
uint64_t written=0;
+ uint64_t *p_buf;
teGidaFsError gidafs_ret=eGidaFsError_None;
- t_CacheFileBlockIndex *p_buf;
- if(index!=XMOUNT_BLOCK_CACHE_INVALID_INDEX) {
- // Update specific index element in cache file
- p_buf=glob_xmount.cache.p_block_cache_index+index;
- update_size=sizeof(t_CacheFileBlockIndex);
+ if(entry!=XMOUNT_CACHE_INVALID_INDEX) {
+ // Update specific index entry in cache file
+ p_buf=p_h->p_block_cache_index+entry;
+ update_size=sizeof(uint64_t);
} else {
// Dump whole block cache index to cache file
- p_buf=glob_xmount.cache.p_block_cache_index;
- update_size=glob_xmount.cache.block_cache_index_len*
- sizeof(t_CacheFileBlockIndex);
+ p_buf=p_h->p_block_cache_index;
+ update_size=p_h->block_cache_index_len*sizeof(uint64_t);
}
// Update cache file
- gidafs_ret=GidaFsLib_WriteFile(glob_xmount.cache.h_cache_file,
- glob_xmount.cache.h_block_cache_index,
+ gidafs_ret=GidaFsLib_WriteFile(p_h->h_cache_file,
+ p_h->h_block_cache_index,
0,
update_size,
p_buf,
&written);
if(gidafs_ret!=eGidaFsError_None || written!=update_size) {
- LOG_ERROR("Unable to update block cache index file '%s': "
- "Error code %u!\n",
- XMOUNT_CACHE_BLOCK_INDEX_FILE,
+ LOG_ERROR("Unable to update block cache index: Error code %u!\n",
gidafs_ret)
- return FALSE;
+ return e_XmountCache_Error_FailedUpdatingIndex;
}
- return TRUE;
+ return e_XmountCache_Error_None;
}
diff --git a/src/xmount_cache.h b/src/xmount_cache.h
index cfc318a..5431e3f 100644
--- a/src/xmount_cache.h
+++ b/src/xmount_cache.h
@@ -1,176 +1,203 @@
/*******************************************************************************
* xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu> *
* *
* 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 3 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, see <http://www.gnu.org/licenses/>. *
*******************************************************************************/
#ifndef XMOUNT_CACHE_H
#define XMOUNT_CACHE_H
#include <gidafs.h>
/*******************************************************************************
* Public definitions / macros
******************************************************************************/
//! Default block cache block size to use (1 megabyte)
#define XMOUNT_CACHE_BLOCK_SIZE (1024*1024)
/*******************************************************************************
* Public types / structures / enums
******************************************************************************/
typedef struct s_XmountCacheHandle *pts_XmountCacheHandle;
typedef enum e_XmountCache_Error {
//! No error
e_XmountCache_Error_None=0,
//! Error to allocate memory
e_XmountCache_Error_Alloc,
//! Invalid cache handle
e_XmountCache_Error_InvalidHandle,
//! Invalid pointer to a cache handle
e_XmountCache_Error_InvalidHandlePointer,
//! A given string is invalid
e_XmountCache_Error_InvalidString,
//! A given file path / name is invalid
e_XmountCache_Error_InvalidFile,
//! A given file does not exist
e_XmountCache_Error_InexistingFile,
//! A given file exists
e_XmountCache_Error_ExistingFile,
//! Unable to create needed xmount structures inside cache file
e_XmountCache_Error_FailedCacheInit,
//! Unable to open xmount cache file
e_XmountCache_Error_FailedOpeningCache,
+ //! Failed to get block cache index size
+ e_XmountCache_Error_FailedGettingIndexSize,
+ //! Invalid block cache index size
+ e_XmountCache_Error_InvalidIndexSize,
+ //! Unable to read block cache index
+ e_XmountCache_Error_FailedReadingIndex,
+ //! Failed closing cache block index
+ e_XmountCache_Error_FailedClosingIndex,
+ //! Failed closing cache block index
+ e_XmountCache_Error_FailedClosingBlockCache,
+ //! Failed closing cache block index
+ e_XmountCache_Error_FailedClosingCache,
+ //! Failed to update block cache index
+ e_XmountCache_Error_FailedUpdatingIndex,
+ //! Invalid block cache index specified
+ e_XmountCache_Error_InvalidIndex,
+ //! Block has not yet been cached
+ e_XmountCache_Error_UncachedBlock,
+ //! Invalid buffer specified
+ e_XmountCache_Error_InvalidBuffer,
+ //! Request would read beyond a single cache block
+ e_XmountCache_Error_ReadBeyondBlockBounds,
+ //! Failed reading cached data
+ e_XmountCache_Error_FailedReadingBlockCache,
+ //! Failed writing cached data
+ e_XmountCache_Error_FailedWritingBlockCache,
} te_XmountCache_Error;
/*******************************************************************************
* Public functions declarations
******************************************************************************/
/*!
* \brief Create new xmount cache file
*
* Creates a new xmount cache file in the given file. If the given file already
* exists, this function will fail except if overwrite is set to 1.
*
* \param pp_handle Pointer to an xmount cache handle
* \param p_file File to use as cache file
* \param image_size Size of image in bytes for which this cache will be used
* \param overwrite If set to 1, overwrites existig cache file
* \return e_XmountCache_Error_None on success
*/
te_XmountCache_Error XmountCache_Create(pts_XmountCacheHandle *pp_h,
const char *p_file,
uint64_t image_size,
uint8_t overwrite);
/*!
* \brief Open an existing xmount cache file
*
* Opens the given xmount cache file.
*
* \param pp_handle Pointer to an xmount cache handle
* \param p_file File to use as cache file
* \param image_size Size of image in bytes for which this cache will be used
* \return e_XmountCache_Error_None on success
*/
te_XmountCache_Error XmountCache_Open(pts_XmountCacheHandle *pp_h,
const char *p_file,
uint64_t image_size);
/*!
* \brief Closes a previously openend xmount cache file
*
* Closes the given xmount cache file and frees any used resources.
*
* \param pp_handle Pointer to an xmount cache handle
* \return e_XmountCache_Error_None on success
*/
te_XmountCache_Error XmountCache_Close(pts_XmountCacheHandle *pp_h);
/*!
* \brief Read data from block cache
*
* Reads count bytes at offset block_offset from block number block and writes
* the read data into the pre-allocated buffer p_buf. The given block has to
* have been previously cached by a call to XmountCache_BlockCacheAppend().
*
* WARNING: This function does only work on single blocks. It is not possible to
* read beyond a block end.
*
* \param p_handle Xmount cache handle
* \param p_buf Buffer to store read data into
* \param block Number of block to read data from
* \param block_offset Offset inside block to start reading from
* \param count Amount of bytes to read
* \return e_XmountCache_Error_None on success
*/
te_XmountCache_Error XmountCache_BlockCacheRead(pts_XmountCacheHandle p_h,
char *p_buf,
uint64_t block,
uint64_t block_offset,
uint64_t count);
/*!
* \brief Write data to block cache
*
* Writes count bytes from buffer p_buf to block number block at offset
* block_offset. The given block has to have been previously cached by a call to
* XmountCache_BlockCacheAppend().
*
* WARNING: This function does only work on single blocks. It is not possible to
* write beyond a block end.
*
* \param p_handle Xmount cache handle
* \param p_buf Buffer with data to write
* \param block Number of block to write data to
* \param block_offset Offset inside block to start writing from
* \param count Amount of bytes to write
* \return e_XmountCache_Error_None on success
*/
te_XmountCache_Error XmountCache_BlockCacheWrite(pts_XmountCacheHandle p_h,
char *p_buf,
uint64_t block,
uint64_t block_offset,
uint64_t count);
/*!
* \brief Add a new block to the cache
*
* Adds the data inside p_buf to the cache file and saves it under the block
* number block. Every block must contain exactly XMOUNT_CACHE_BLOCK_SIZE bytes.
* Every block can only be cached once. Appending the same block twice will
* fail.
*
* \param p_handle Xmount cache handle
* \param p_buf Buffer with block data
* \param block Number of block under which to save given data
* \return e_XmountCache_Error_None on success
*/
te_XmountCache_Error XmountCache_BlockCacheAppend(pts_XmountCacheHandle p_h,
char *p_buf,
uint64_t block);
/*!
* \brief Chech if a block has previously been chached
*
- * Checks if the given block has previously been cached.
+ * Checks if the given block has previously been cached. If it hasn't,
+ * e_XmountCache_Error_UncachedBlock is returned.
*
* \param p_handle Xmount cache handle
* \param block Number of block to check
* \return e_XmountCache_Error_None on success
*/
te_XmountCache_Error XmountCache_IsBlockCached(pts_XmountCacheHandle p_h,
uint64_t block);
#endif // XMOUNT_CACHE_H
diff --git a/src/xmount_morphing.c b/src/xmount_morphing.c
index bcc5a44..ea3fb42 100644
--- a/src/xmount_morphing.c
+++ b/src/xmount_morphing.c
@@ -1,324 +1,316 @@
/*******************************************************************************
* xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu> *
* *
* 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 3 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, see <http://www.gnu.org/licenses/>. *
*******************************************************************************/
#include <errno.h>
+#include <string.h> // For memcpy
#include "xmount_morphing.h"
#include "xmount.h"
#include "macros.h"
#define LOG_WARNING(...) { \
LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
}
#define LOG_ERROR(...) { \
LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
}
#define LOG_DEBUG(...) { \
LIBXMOUNT_LOG_DEBUG(glob_xmount.debug,__VA_ARGS__); \
}
//! Get size of morphed image
/*!
* \param p_size Buf to save size to
* \return TRUE on success, FALSE on error
*/
int GetMorphedImageSize(uint64_t *p_size) {
int ret;
ret=glob_xmount.morphing.p_functions->Size(glob_xmount.morphing.p_handle,
p_size);
if(ret!=0) {
LOG_ERROR("Unable to get morphed image size: %s!\n",
glob_xmount.morphing.p_functions->GetErrorMessage(ret));
return FALSE;
}
return TRUE;
}
//! Read data from morphed image
/*!
* \param p_buf Pointer to buffer to write read data to (must be preallocated!)
* \param offset Offset at which data should be read
* \param size Size of data which should be read (size of buffer)
* \param p_read Number of read bytes on success
* \return TRUE on success, negated error code on error
*/
int ReadMorphedImageData(char *p_buf,
off_t offset,
size_t size,
size_t *p_read)
{
uint64_t block_off=0;
uint64_t cur_block=0;
uint64_t cur_to_read=0;
uint64_t image_size=0;
size_t read=0;
size_t to_read=0;
int ret;
- teGidaFsError gidafs_ret=eGidaFsError_None;
+ uint8_t is_block_cached=FALSE;
+ te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
// Make sure we aren't reading past EOF of image file
if(GetMorphedImageSize(&image_size)!=TRUE) {
LOG_ERROR("Couldn't get size of morphed image!\n");
return -EIO;
}
if(offset>=image_size) {
// Offset is beyond image size
LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
*p_read=0;
return FALSE;
}
if(offset+size>image_size) {
// Attempt to read data past EOF of morphed image file
to_read=image_size-offset;
LOG_DEBUG("Attempt to read data past EOF of morphed image. Corrected size "
"from %zu to %" PRIu64 ".\n",
size,
to_read);
} else to_read=size;
// Calculate block to start reading data from
- cur_block=offset/CACHE_BLOCK_SIZE;
- block_off=offset%CACHE_BLOCK_SIZE;
+ cur_block=offset/XMOUNT_CACHE_BLOCK_SIZE;
+ block_off=offset%XMOUNT_CACHE_BLOCK_SIZE;
// Read image data
while(to_read!=0) {
// Calculate how many bytes we have to read from this block
- if(block_off+to_read>CACHE_BLOCK_SIZE) {
- cur_to_read=CACHE_BLOCK_SIZE-block_off;
+ if(block_off+to_read>XMOUNT_CACHE_BLOCK_SIZE) {
+ cur_to_read=XMOUNT_CACHE_BLOCK_SIZE-block_off;
} else cur_to_read=to_read;
+ // Determine if we have to read cached data
+ is_block_cached=FALSE;
+ if(glob_xmount.output.writable==TRUE) {
+ cache_ret=XmountCache_IsBlockCached(glob_xmount.h_cache,cur_block);
+ if(cache_ret==e_XmountCache_Error_None) is_block_cached=TRUE;
+ else if(cache_ret!=e_XmountCache_Error_UncachedBlock) {
+ LOG_ERROR("Unable to determine if block %" PRIu64 " is cached: "
+ "Error code %u!\n",
+ cur_block,
+ cache_ret);
+ return -EIO;
+ }
+ }
+
// Check if block is cached
- if(glob_xmount.output.writable==TRUE &&
- glob_xmount.cache.p_block_cache_index[cur_block]!=CACHE_BLOCK_FREE)
- {
+ if(is_block_cached==TRUE) {
// Write support enabled and need to read altered data from cachefile
- LOG_DEBUG("Reading %zu bytes at offset %" PRIu64
- " from block cache file\n",
- cur_to_read,
- glob_xmount.cache.p_block_cache_index[cur_block]+block_off)
+ LOG_DEBUG("Reading %zu bytes from block cache file\n",cur_to_read);
- gidafs_ret=GidaFsLib_ReadFile(glob_xmount.cache.h_cache_file,
- glob_xmount.cache.h_block_cache,
- glob_xmount.cache.
- p_block_cache_index[cur_block]+block_off,
- cur_to_read,
- p_buf,
- &read);
- if(gidafs_ret!=eGidaFsError_None || read!=cur_to_read) {
- LOG_ERROR("Unable to read cached data from block %" PRIu64
- ": Error code %u!\n",
+ cache_ret=XmountCache_BlockCacheRead(glob_xmount.h_cache,
+ p_buf,
+ cur_block,
+ block_off,
+ cur_to_read);
+ if(cache_ret!=e_XmountCache_Error_None) {
+ LOG_ERROR("Unable to read %" PRIu64
+ " bytes of cached data from cache block %" PRIu64
+ " at cache block offset %" PRIu64 ": Error code %u!\n",
+ cur_to_read,
cur_block,
- gidafs_ret);
+ block_off,
+ cache_ret);
return -EIO;
}
} else {
// No write support or data not cached
ret=glob_xmount.morphing.p_functions->Read(glob_xmount.morphing.p_handle,
p_buf,
- (cur_block*CACHE_BLOCK_SIZE)+
+ (cur_block*XMOUNT_CACHE_BLOCK_SIZE)+
block_off,
cur_to_read,
&read);
if(ret!=0 || read!=cur_to_read) {
LOG_ERROR("Couldn't read %zu bytes at offset %zu from morphed image: "
"%s!\n",
cur_to_read,
offset,
glob_xmount.morphing.p_functions->GetErrorMessage(ret));
return -EIO;
}
LOG_DEBUG("Read %" PRIu64 " bytes at offset %" PRIu64
" from morphed image file\n",
cur_to_read,
- (cur_block*CACHE_BLOCK_SIZE)+block_off);
+ (cur_block*XMOUNT_CACHE_BLOCK_SIZE)+block_off);
}
cur_block++;
block_off=0;
p_buf+=cur_to_read;
to_read-=cur_to_read;
}
*p_read=to_read;
return TRUE;
}
//! Write data to morphed image
/*!
* \param p_buf Buffer with data to write
* \param offset Offset to start writing at
* \param count Amount of bytes to write
* \param p_written Amount of successfully written bytes
* \return TRUE on success, negated error code on error
*/
int WriteMorphedImageData(const char *p_buf,
off_t offset,
size_t count,
size_t *p_written)
{
uint64_t block_off=0;
uint64_t cur_block=0;
uint64_t cur_to_read=0;
uint64_t cur_to_write=0;
uint64_t image_size=0;
uint64_t read=0;
size_t written=0;
size_t to_write=0;
int ret;
- teGidaFsError gidafs_ret=eGidaFsError_None;
char *p_buf2=NULL;
+ uint8_t is_block_cached=FALSE;
+ te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
// Make sure we aren't writing past EOF of image file
if(GetMorphedImageSize(&image_size)!=TRUE) {
LOG_ERROR("Couldn't get size of morphed image!\n");
return -EIO;
}
if(offset>=image_size) {
// Offset is beyond image size
LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
*p_written=0;
return 0;
}
if(offset+count>image_size) {
// Attempt to write data past EOF of morphed image file
to_write=image_size-offset;
LOG_DEBUG("Attempt to write data past EOF of morphed image. Corrected size "
"from %zu to %" PRIu64 ".\n",
count,
to_write);
} else to_write=count;
// Calculate block to start writing data to
- cur_block=offset/CACHE_BLOCK_SIZE;
- block_off=offset%CACHE_BLOCK_SIZE;
+ cur_block=offset/XMOUNT_CACHE_BLOCK_SIZE;
+ block_off=offset%XMOUNT_CACHE_BLOCK_SIZE;
while(to_write!=0) {
// Calculate how many bytes we have to write to this block
- if(block_off+to_write>CACHE_BLOCK_SIZE) {
- cur_to_write=CACHE_BLOCK_SIZE-block_off;
+ if(block_off+to_write>XMOUNT_CACHE_BLOCK_SIZE) {
+ cur_to_write=XMOUNT_CACHE_BLOCK_SIZE-block_off;
} else cur_to_write=to_write;
+ // Determine if block is already in cache
+ is_block_cached=FALSE;
+ cache_ret=XmountCache_IsBlockCached(glob_xmount.h_cache,cur_block);
+ if(cache_ret==e_XmountCache_Error_None) is_block_cached=TRUE;
+ else if(cache_ret!=e_XmountCache_Error_UncachedBlock) {
+ LOG_ERROR("Unable to determine if block %" PRIu64 " is cached: "
+ "Error code %u!\n",
+ cur_block,
+ cache_ret);
+ return -EIO;
+ }
+
// Check if block is cached
- if(glob_xmount.cache.p_block_cache_index[cur_block]!=CACHE_BLOCK_FREE) {
+ if(is_block_cached==TRUE) {
// Block is cached
- gidafs_ret=GidaFsLib_WriteFile(glob_xmount.cache.h_cache_file,
- glob_xmount.cache.h_block_cache,
- glob_xmount.cache.
- p_block_cache_index[cur_block]+block_off,
- cur_to_write,
- p_buf,
- &written);
- if(gidafs_ret!=eGidaFsError_None || written!=cur_to_write) {
- LOG_ERROR("Unable to write data to cached block %" PRIu64
- ": Error code %u!\n",
+ cache_ret=XmountCache_BlockCacheWrite(glob_xmount.h_cache,
+ p_buf,
+ cur_block,
+ block_off,
+ cur_to_write);
+ if(cache_ret!=e_XmountCache_Error_None) {
+ LOG_ERROR("Unable to write %" PRIu64
+ " bytes of data to cache block %" PRIu64
+ " at cache block offset %" PRIu64 ": Error code %u!\n",
+ cur_to_write,
cur_block,
- gidafs_ret);
+ block_off,
+ cache_ret);
return -EIO;
}
- LOG_DEBUG("Wrote %" PRIu64 " bytes at offset %" PRIu64
- " to block cache file\n",
- cur_to_write,
- glob_xmount.cache.p_block_cache_index[cur_block]+block_off);
+ LOG_DEBUG("Wrote %" PRIu64 " bytes to block cache\n",cur_to_write);
} else {
// Uncached block. Need to cache entire new block
// Prepare new write buffer
- XMOUNT_MALLOC(p_buf2,char*,CACHE_BLOCK_SIZE);
- memset(p_buf2,0x00,CACHE_BLOCK_SIZE);
+ XMOUNT_MALLOC(p_buf2,char*,XMOUNT_CACHE_BLOCK_SIZE);
+ memset(p_buf2,0x00,XMOUNT_CACHE_BLOCK_SIZE);
// Read full block from morphed image
- cur_to_read=CACHE_BLOCK_SIZE;
- if((cur_block*CACHE_BLOCK_SIZE)+CACHE_BLOCK_SIZE>image_size) {
- cur_to_read=CACHE_BLOCK_SIZE-(((cur_block*CACHE_BLOCK_SIZE)+
- CACHE_BLOCK_SIZE)-image_size);
+ cur_to_read=XMOUNT_CACHE_BLOCK_SIZE;
+ if((cur_block*XMOUNT_CACHE_BLOCK_SIZE)+XMOUNT_CACHE_BLOCK_SIZE>image_size) {
+ cur_to_read=XMOUNT_CACHE_BLOCK_SIZE-(((cur_block*XMOUNT_CACHE_BLOCK_SIZE)+
+ XMOUNT_CACHE_BLOCK_SIZE)-image_size);
}
ret=glob_xmount.morphing.p_functions->Read(glob_xmount.morphing.p_handle,
p_buf2,
- cur_block*CACHE_BLOCK_SIZE,
+ cur_block*XMOUNT_CACHE_BLOCK_SIZE,
cur_to_read,
&read);
if(ret!=0 || read!=cur_to_read) {
LOG_ERROR("Couldn't read %" PRIu64 " bytes at offset %zu "
"from morphed image: %s!\n",
cur_to_read,
offset,
glob_xmount.morphing.p_functions->GetErrorMessage(ret));
XMOUNT_FREE(p_buf2);
return -EIO;
}
// Set changed data
memcpy(p_buf2+block_off,p_buf,cur_to_write);
- // Write new block to block cache
- // Get current block cache size
- gidafs_ret=GidaFsLib_GetFileSize(glob_xmount.cache.h_cache_file,
- glob_xmount.cache.h_block_cache,
- &(glob_xmount.cache.
- p_block_cache_index[cur_block]));
- if(gidafs_ret!=eGidaFsError_None) {
- LOG_ERROR("Unable to get current block cache size: Error code %u!\n",
- gidafs_ret);
- XMOUNT_FREE(p_buf2);
- return -EIO;
- }
- // Append new block
- gidafs_ret=GidaFsLib_WriteFile(glob_xmount.cache.h_cache_file,
- glob_xmount.cache.h_block_cache,
- glob_xmount.cache.
- p_block_cache_index[cur_block],
- CACHE_BLOCK_SIZE,
- p_buf2,
- &written);
- if(gidafs_ret!=eGidaFsError_None || written!=cur_to_write) {
- LOG_ERROR("Unable to write data to cached block %" PRIu64
+ cache_ret=XmountCache_BlockCacheAppend(glob_xmount.h_cache,
+ p_buf,
+ cur_block);
+ if(cache_ret!=e_XmountCache_Error_None) {
+ LOG_ERROR("Unable to append new block cache block %" PRIu64
": Error code %u!\n",
cur_block,
- gidafs_ret);
+ cache_ret);
XMOUNT_FREE(p_buf2);
return -EIO;
}
XMOUNT_FREE(p_buf2);
- // Update on-disk block cache index
- ret=UpdateBlockCacheIndex(cur_block,
- glob_xmount.cache.p_block_cache_index[
- cur_block]);
- if(ret!=TRUE) {
- LOG_ERROR("Unable to update block cache index %" PRIu64
- ": Error code %u!\n",
- cur_block,
- gidafs_ret);
- return -EIO;
- }
- LOG_DEBUG("Updated cache file block index: Number=%" PRIu64
- ", Data offset=%" PRIu64 "\n",
- cur_block,
- glob_xmount.cache.p_block_cache_index[cur_block]);
+ LOG_DEBUG("Appended new block cache block %" PRIu64 "\n",cur_block);
}
block_off=0;
cur_block++;
p_buf+=cur_to_write;
to_write-=cur_to_write;
}
*p_written=to_write;
return TRUE;
}
File Metadata
Details
Attached
Mime Type
text/x-diff
Expires
Mon, Dec 23, 10:56 AM (6 h, 41 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
1176899
Default Alt Text
(159 KB)
Attached To
Mode
rXMOUNT xmount
Attached
Detach File
Event Timeline
Log In to Comment