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; }