static int multipath_end_request(struct bio *bio, unsigned int bytes_done,
int error)
{
int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
struct multipath_bh * mp_bh = (struct multipath_bh *)(bio->bi_private);
multipath_conf_t *conf = mddev_to_conf(mp_bh->mddev);
mdk_rdev_t *rdev = conf->multipaths[mp_bh->path].rdev;
if (bio->bi_size)
return 1;
if (uptodate)
multipath_end_bh_io(mp_bh, 0);
else if (!bio_rw_ahead(bio)) {
/*
* oops, IO error:
*/
char b[BDEVNAME_SIZE];
md_error (mp_bh->mddev, rdev);
printk(KERN_ERR "multipath: %s: rescheduling sector %llu\n",
bdevname(rdev->bdev,b),
(unsigned long long)bio->bi_sector);
multipath_reschedule_retry(mp_bh);
} else
multipath_end_bh_io(mp_bh, error);
rdev_dec_pending(rdev, conf->mddev);
return 0;
}
static void multipath_end_request(struct bio *bio, int error)
{
int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
struct multipath_bh *mp_bh = bio->bi_private;
struct mpconf *conf = mp_bh->mddev->private;
struct md_rdev *rdev = conf->multipaths[mp_bh->path].rdev;
if (uptodate)
multipath_end_bh_io(mp_bh, 0);
else if (!bio_rw_flagged(bio, BIO_RW_AHEAD)) {
/*
* oops, IO error:
*/
char b[BDEVNAME_SIZE];
md_error (mp_bh->mddev, rdev);
printk(KERN_ERR "multipath: %s: rescheduling sector %llu\n",
bdevname(rdev->bdev,b),
(unsigned long long)bio->bi_sector);
multipath_reschedule_retry(mp_bh);
} else
multipath_end_bh_io(mp_bh, error);
rdev_dec_pending(rdev, conf->mddev);
}
void jasmin_print_type(ast_type type)
{
switch(type.type)
{
case VAR_BOOL:
jasmin_print("Z");
break;
case VAR_INT:
jasmin_print("I");
break;
case VAR_INT_ARRAY:
jasmin_print("[I");
break;
case VAR_STRING_ARRAY:
jasmin_print("[Ljava/lang/String;");
break;
case VAR_CLASS:
jasmin_print("L%s;", type.classname);
break;
default:
md_error(-1, "!! unsupported type, during jasmin generation, this should never happen");
}
}
void jasmin_expr(ast_expr *expr)
{
switch(expr->type)
{
case INT_CONST:
jasmin_println("ldc %d", expr->int_const);
break;
case BOOL_CONST:
jasmin_println(expr->bool_const ? "iconst_1" : "iconst_0");
break;
case VARNAME:
{
if(expr->bind_var->parent.type == SYM_CLASS)
{
jasmin_println("aload_0 ; load <this>");
jasmin_print("\tgetfield '%s/%s' ", expr->bind_var->parent.class->id, expr->bind_var->id);
jasmin_print_type(expr->bind_var->type);
jasmin_print("\n");
}
else
{
switch(expr->bind_var->type.type)
{
case VAR_INT:
case VAR_BOOL:
jasmin_println("iload %d ; load %s", expr->bind_var->var_reg, expr->bind_var->id);
break;
case VAR_INT_ARRAY:
case VAR_CLASS:
jasmin_println("aload %d ; load %s", expr->bind_var->var_reg, expr->bind_var->id);
break;
default:
md_error(-1, "!! unsupported VARNAME type during jasmin generation, this should never happen");
}
}
break;
}
int main(int argc, char** argv) {
md_debug(1);
md_error(1);
SG_debug("%s\n", "starting up debugging");
SG_error("%s\n", "starting up errors");
int c;
char* config_file = (char*)CLIENT_DEFAULT_CONFIG;
int portnum = 0;
struct md_HTTP syndicate_http;
char* username = NULL;
char* password = NULL;
char* volume_name = NULL;
char* volume_secret = NULL;
char* ms_url = NULL;
int read_count = 1;
static struct option syndicate_options[] = {
{"config-file", required_argument, 0, 'c'},
{"volume-name", required_argument, 0, 'v'},
{"volume-secret", required_argument, 0, 's'},
{"username", required_argument, 0, 'u'},
{"password", required_argument, 0, 'p'},
{"port", required_argument, 0, 'P'},
{"MS", required_argument, 0, 'm'},
{"read-count", required_argument, 0, 'R'},
{0, 0, 0, 0}
};
int opt_index = 0;
while((c = getopt_long(argc, argv, "c:v:s:u:p:P:fm:R:", syndicate_options, &opt_index)) != -1) {
switch( c ) {
case 'R': {
read_count = strtol(optarg, NULL, 10);
break;
}
case 'v': {
volume_name = optarg;
break;
}
case 'c': {
config_file = optarg;
break;
}
case 's': {
volume_secret = optarg;
break;
}
case 'u': {
username = optarg;
break;
}
case 'p': {
password = optarg;
break;
}
case 'P': {
portnum = strtol(optarg, NULL, 10);
break;
}
case 'm': {
ms_url = optarg;
break;
}
default: {
break;
}
}
}
int rc = syndicate_init( config_file, &syndicate_http, portnum, ms_url, volume_name, volume_secret, username, password );
if( rc != 0 )
exit(1);
struct md_syndicate_conf* conf = syndicate_get_conf();
if( portnum == 0 )
portnum = conf->httpd_portnum;
struct syndicate_state* state = syndicate_get_state();
// synchronous everything
conf->default_write_freshness = 0;
conf->default_read_freshness = 0;
char file[PATH_MAX];
memset(file, 0, PATH_MAX);
strcpy( file, READ_FILE );
struct fs_file_handle* fh = NULL;
ssize_t nw = 0;
ssize_t file_size = conf->blocking_factor * 100;
char* buf = SG_CALLOC( char, file_size );
char fill = rand() % 26 + 'A';
memset( buf, fill, file_size );
struct timespec ts, ts2;
DATA_BLOCK("open");
SG_BEGIN_TIMING_DATA( ts );
// create the file
fh = fs_entry_open( state->core, file, NULL, conf->owner, conf->volume, O_SYNC | O_RDWR, 0666, &rc );
if( rc != 0 ) {
SG_error("fs_entry_open(%s) rc = %d\n", file, rc );
exit(1);
}
SG_END_TIMING_DATA( ts, ts2, "open + MS revalidate + manifest refresh" );
DATA_BLOCK("remote read miss");
// mark the file as stale
fs_entry_wlock( fh->fent );
fs_entry_mark_read_stale( fh->fent );
fs_entry_unlock( fh->fent );
char const* key = "remote read miss";
char const* hit = "remote read hit";
for( int i = 0; i < read_count; i++ ) {
// read the file
SG_BEGIN_TIMING_DATA( ts );
nw = fs_entry_read( state->core, fh, buf, file_size, 0 );
if( nw != file_size ) {
SG_error("fs_entry_read(%s) rc = %ld\n", file, nw );
exit(1);
}
SG_END_TIMING_DATA( ts, ts2, key );
key = hit;
char buf[100];
sprintf(buf, "remote read hit %d", i );
DATA_BLOCK(buf);
}
SG_BEGIN_TIMING_DATA( ts );
// close
rc = fs_entry_close( state->core, fh );
if( rc != 0 ) {
SG_error("fs_entry_close(%s) rc = %d\n", file, rc );
exit(1);
}
SG_END_TIMING_DATA( ts, ts2, "close" );
DATA_BLOCK("");
free( fh );
syndicate_destroy();
free( buf );
return 0;
}
