struct ssd *ssdmodel_ssd_loadparams(struct lp_block *b, int *num)
{
/* temp vars for parameters */
int n;
struct ssd *result;
if(!disksim->ssdinfo) ssd_initialize_diskinfo();
result = malloc(sizeof(struct ssd));
if(!result) return 0;
bzero(result, sizeof(struct ssd));
n = ssd_add(result);
result->hdr = ssd_hdr_initializer;
if(b->name)
result->hdr.device_name = _strdup(b->name);
lp_loadparams(result, b, &ssdmodel_ssd_mod);
device_add((struct device_header *)result, n);
if (num != NULL)
*num = n;
return result;
}
struct dm_layout_if *
dm_layout_g2_loadparams(struct lp_block *b, struct dm_disk_if *parent) {
int i;
int rv;
struct dm_layout_g2 *result = malloc(sizeof(struct dm_layout_g2));
memset(result, 0, sizeof(struct dm_layout_g2));
// #include "modules/dm_layout_g2_param.c"
lp_loadparams(result, b, &dm_layout_g2_mod);
rv = layout_g2_loadmap(result);
ddbg_assert(rv == 0);
free(result->mapfile); // strdup()ed in loader code
result->mapfile = 0;
// find the zone param
result->hdr = layout_g2;
parent->layout = (struct dm_layout_if *)result;
// do the skew precomputation
precompute_skews(parent);
g2_finish_defects(result);
return (struct dm_layout_if *)result;
}
struct simpledisk *disksim_simpledisk_loadparams(struct lp_block *b)
{
/* temp vars for parameters */
struct simpledisk *result;
int num;
if(!disksim->simplediskinfo) simpledisk_initialize_diskinfo();
result = (struct simpledisk *)calloc(1, sizeof(struct simpledisk));
if(!result) return 0;
num = simpledisk_add(result);
result->hdr = simpledisk_hdr_initializer;
if(b->name)
result->hdr.device_name = strdup(b->name);
//#include "modules/disksim_simpledisk_param.c"
lp_loadparams(result, b, &disksim_simpledisk_mod);
device_add((struct device_header *)result, num);
return result;
}
struct iodriver *disksim_iodriver_loadparams(struct lp_block *b) {
iodriver *result;
if (disksim->iodriver_info == NULL) {
disksim->iodriver_info = malloc (sizeof(iodriver_info_t));
bzero ((char *)disksim->iodriver_info, sizeof(iodriver_info_t));
}
overallqueue = ioqueue_createdefaultqueue ();
result = malloc(sizeof(iodriver));
bzero(result, sizeof(iodriver));
add_driver(result);
result->name = strdup(b->name);
//#include "modules/disksim_iodriver_param.c"
lp_loadparams(result, b, &disksim_iodriver_mod);
result->scale = 0.0;
return result;
}
static int
g2_load_zone(struct dm_layout_g2_zone *result,
struct lp_block *b)
{
//#include "modules/dm_layout_g2_zone_param.c"
lp_loadparams(result, b, &dm_layout_g2_zone_mod);
return 0; // avoid a warning
}
int disksim_iosim_loadparams(struct lp_block *b) {
if(!disksim->iosim_info)
iosim_initialize_iosim_info();
//#include "modules/disksim_iosim_param.c"
lp_loadparams(0, b, &disksim_iosim_mod);
return 1;
}
struct dm_mech_if *
dm_mech_g1_loadparams(struct lp_block *b, int *junk) {
struct dm_mech_g1 *result = malloc(sizeof(*result));
result->hdr = dm_mech_g1;
// #include "modules/dm_mech_g1_param.c"
lp_loadparams(result, b, &dm_mech_g1_mod);
result->rotatetime = dm_time_dtoi(1000.0 / ((double)result->rpm / 60.0));
return (struct dm_mech_if *)result;
}
int disk_load_zones(struct lp_list *lst,
struct dm_layout_g1 *layout)
{
int d;
struct dm_layout_g1_band *result = 0;
// struct lp_block *b = 0;
layout->bands_len = 0;
for(d = 0; d < lst->values_len; d++) {
if(lst->values[d]) layout->bands_len++;
}
layout->bands = malloc(layout->bands_len * sizeof(struct dm_layout_g1_band));
layout->band_blknos = malloc(layout->bands_len * sizeof(int));
bzero(layout->bands, layout->bands_len * sizeof(struct dm_layout_g1_band));
result = layout->bands;
/* iterate over bands */
for(d = 0; d < layout->bands_len; d++) {
long long max = (long long)1 << 32;
layout->bands[d].skew_units = layout->skew_units;
if(!lst->values[d]) continue;
if(lst->values[d]->t != BLOCK) {
fprintf(stderr, "Bad band/zone def.\n");
return 0;
}
// b = lst->values[d]->v.b;
//#include "modules/dm_layout_g1_zone_param.c"
lp_loadparams(result, lst->values[d]->v.b, &dm_layout_g1_zone_mod);
// This is now done in the blkspertrack init code.
// Skews were doing angle_dtoi(skew / blkspertrack) but
// this turned out not to be the same as skew * sector_width and
// caused off-by-1-sector bugs.
// result->sector_width = (dm_angle_t)(max / result->blkspertrack);
result->trkspace = max % result->blkspertrack;
result++;
layout->bands[d].num = d;
}
return 1;
}
int disksim_device_stats_loadparams(struct lp_block *b) {
device_initialize_deviceinfo();
/* unparse_block(b, outputfile); */
//#include "modules/disksim_device_stats_param.c"
lp_loadparams(0, b, &disksim_device_stats_mod);
/* none of the devices currently have dev-specific stats so we aren't
* going to look for them here for now */
return 1;
}
int disksim_iodriver_stats_loadparams(struct lp_block *b) {
if (disksim->iodriver_info == NULL) {
disksim->iodriver_info = (struct iodriver_info *)DISKSIM_malloc (sizeof(iodriver_info_t));
bzero ((char *)disksim->iodriver_info, sizeof(iodriver_info_t));
}
/* unparse_block(b, outputfile); */
//#include "modules/disksim_iodriver_stats_param.c"
lp_loadparams(0, b, &disksim_iodriver_stats_mod);
return 1;
}
struct dm_layout_if *
dm_layout_g4_loadparams(struct lp_block *b,
struct dm_disk_if *parent)
{
int i;
struct dm_layout_g4 *result = calloc(1, sizeof(*result));
result->hdr = layout_g4;
result->parent = parent;
lp_loadparams(result, b, &dm_layout_g4_mod);
// XXX ick
result->root = &result->idx[result->idx_len - 1];
// XXX shouldn't do this
parent->layout = (struct dm_layout_if *)result;
return (struct dm_layout_if *)result;
}
struct cache_if *disksim_cachedev_loadparams(struct lp_block *b)
{
int c;
struct cache_dev *result;
#ifdef DEBUG_CACHEDEV
fprintf (outputfile, "*** %f: Entered cachedev::disksim_cachedev_loadparams\n", simtime );
#endif
result = (struct cache_dev *)calloc(1, sizeof(struct cache_dev));
result->hdr = disksim_cache_dev;
result->name = b->name ? strdup(b->name) : 0;
//#include "modules/disksim_cachedev_param.c"
lp_loadparams(result, b, &disksim_cachedev_mod);
return (struct cache_if *)result;
}
static int iosim_load_map(struct lp_block *b, int n) {
int c;
int i = 0;
char *s = 0;
//#include "modules/disksim_iomap_param.c"
lp_loadparams((void *)n, b, &disksim_iomap_mod);
if (tracemap2[n] == 512) {
tracemap2[n] = 0;
}
else if (tracemap2[n] > 512) {
tracemap2[n] = -(tracemap2[n] / 512);
}
else {
tracemap2[n] = 512 / tracemap2[n];
}
return 1;
}
struct iodriver *disksim_iodriver_loadparams(struct lp_block *b) {
iodriver *result;
if (disksim->iodriver_info == NULL) {
disksim->iodriver_info = (struct iodriver_info *)calloc (1, sizeof(iodriver_info_t));
}
OVERALLQUEUE = ioqueue_createdefaultqueue ();
result = (iodriver *)calloc(1, sizeof(iodriver));
add_driver(result);
result->name = strdup(b->name);
//#include "modules/disksim_iodriver_param.c"
lp_loadparams(result, b, &disksim_iodriver_mod);
result->scale = 0.0;
return result;
}
struct dm_layout_if *
dm_layout_g1_loadparams(struct lp_block *b, struct dm_disk_if *d)
{
struct dm_layout_g1 *result = malloc(sizeof(*result));
memset(result, 0, sizeof(*result));
//#include "modules/dm_layout_g1_param.c"
lp_loadparams(result, b, &dm_layout_g1_mod);
result->disk = d;
result->disk->layout = (struct dm_layout_if *)result;
/* result->hdr = g1_layout_nosparing; */
/* result->hdr = g1_layout_sectpertrackspare; */
/* result->hdr = g1_layout_sectperzonespare; */
/* result->hdr = g1_layout_sectpercylspare; */
/* result->hdr = g1_layout_sectperrangespare; */
switch(result->mapping) {
case LAYOUT_NORMAL:
case LAYOUT_CYLSWITCHONSURF1:
case LAYOUT_CYLSWITCHONSURF2:
if(result->sparescheme == NO_SPARING) {
result->hdr = g1_layout_nosparing;
} else {
if (result->sparescheme == TRACK_SPARING) {
result->hdr = g1_layout_tracksparing;
}
else if (result->sparescheme == SECTPERTRACK_SPARING) {
result->hdr = g1_layout_sectpertrackspare;
}
else if ((issectpercyl(result)) ||
(result->sparescheme == SECTATEND_SPARING))
{
result->hdr = g1_layout_sectpercylspare;
}
else if ((result->sparescheme == SECTSPERZONE_SPARING) ||
(result->sparescheme == SECTSPERZONE_SPARING_SLIPTOEND))
{
result->hdr = g1_layout_sectperzonespare;
}
else if (result->sparescheme == SECTPERRANGE_SPARING) {
result->hdr = g1_layout_sectperrangespare;
}
else {
ddbg_assert2(0, "Unknown sparing scheme");
}
}
break;
default:
ddbg_assert2(0, "Unknown lbn<->pbn scheme");
}
// careful with the order here...
initialize_bands(result->disk);
dm_layout_g1_initialize(d);
checknumblocks(result);
setup_band_blknos(result);
return (struct dm_layout_if *)result;
}
struct mems *memsmodel_mems_loadparams(struct lp_block *b,
int *numptr)
{
int c;
int num;
struct mems *result;
mems_sled_t tmpsled;
device_initialize_deviceinfo();
bzero(&tmpsled, sizeof(tmpsled));
result = (struct mems *)calloc(1, sizeof(mems_t));
if(!result) return 0;
((struct device_header *)result)->device_type = DEVICETYPE_MEMS;
/* Initialize disksim's memsinfo structures */
if (disksim->memsinfo == NULL) {
disksim->memsinfo = (struct mems_info *)calloc(1, sizeof(struct mems_info));
ASSERT(disksim->memsinfo != NULL);
/* disksim->memsinfo->devices = malloc(MAXDEVICES * sizeof(mems_t)); */
/* ASSERT(disksim->memsinfo->devices != NULL); */
}
for(c = 0; c < disksim->memsinfo->devices_len; c++) {
if(!disksim->memsinfo->devices[c]) {
break;
}
}
if(c == disksim->memsinfo->devices_len) {
int newlen = disksim->memsinfo->devices_len ?
disksim->memsinfo->devices_len * 2 : 2;
int zerolen = newlen == 2 ? 2 : newlen / 2;
disksim->memsinfo->devices =
(mems_t **)realloc(disksim->memsinfo->devices,
newlen * sizeof(mems_t *));
bzero(&(disksim->memsinfo->devices[c]), zerolen * sizeof(mems_t *));
disksim->memsinfo->devices_len = newlen;
}
disksim->memsinfo->devices[c] = result;
num = c;
if(numptr) *numptr = num;
result->hdr = mems_hdr_initializer;
result->hdr.device_name = strdup(b->name);
disksim->memsinfo->numdevices++;
//#include "modules/disksim_mems_param.c"
lp_loadparams(result, b, &memsmodel_mems_mod);
for (c = 0; c < MAXINBUSES; c++) {
result->inbuses[c] = -1;
result->depth[c] = -1;
result->slotno[c] = -1;
}
for(c = 0; c < result->num_sleds; c++) {
memcpy(&result->sled[c], &result->sled[0], result->num_sleds * sizeof(mems_sled_t));
result->sled[c].queue = ioqueue_copy(result->queue);
}
device_add((struct device_header *)result, num);
return result;
}
