int
main(int argc, char **argv)
{
int ret = 0;
int n;
double mean_lifetime = 3 * 24 * 60 * 60;
if (parse_arguments(argc, argv))
return 1;
struct activity_stats *as = NULL;
if (file == NULL) {
fprintf(stderr, "No file name provided\n");
usage();
return 1;
}
if (!print_le && (!lv_name || !vg_name)) {
fprintf(stderr, "You must ask for logical extents or provide volume"
" group and logical volume name.\n");
usage();
return 1;
}
struct program_params pp = { .lvm2_handle = NULL };
if (!print_le) {
init_le_to_pe(&pp);
}
n = read_activity_stats(&as, file);
assert(!n);
struct block_scores *bs = NULL;
if(get_max)
get_best_blocks_with_max_score(as, &bs, blocks, read_mult,
write_mult, mean_lifetime, max_score);
else
get_best_blocks(as, &bs, blocks, read_mult, write_mult, mean_lifetime);
if (pvmove_output) {
if (print_le) {
printf("%llu", bs[0].offset);
for (int i=1; i< blocks; i++) {
printf(":%llu", bs[i].offset);
}
printf("\n");
} else {
struct pv_info *pvi;
struct pv_info *pvn;
pvi = LE_to_PE(vg_name, lv_name, bs[0].offset);
printf("%s:%llu", pvi->pv_name, pvi->start_seg);
for (int i=1; i<blocks; i++) {
pvn = LE_to_PE(vg_name, lv_name, bs[i].offset);
if (!pvn)
continue;
if (!strcmp(pvi->pv_name, pvn->pv_name)) {
printf(":%llu", pvn->start_seg);
pv_info_free(pvn);
continue;
} else {
printf("\n%s:%llu", pvn->pv_name, pvn->start_seg);
pv_info_free(pvi);
pvi = pvn;
continue;
}
}
printf("\n");
pv_info_free(pvi);
}
} else {
if (!print_le) {
fprintf(stderr, "Unsupported combination of parameters"
" (add --pvmove or --LE)\n");
} else
print_block_scores(bs, blocks);
}
free(bs);
bs = NULL;
//dump_activity_stats(as);
destroy_activity_stats(as);
as = NULL;
if (!print_le) {
le_to_pe_exit(&pp);
}
return ret;
}
struct extent_info_t* read_stdin(uint64_t start_time, struct extent_info_t *extent_info)
{
char in_buf[8192]= {0};
char blk_dev_num[4096]= {0};
int cpu_id=0;
uint64_t seq_num=0;
double time_stamp=0;
int proc_id=0;
char action_id[8]= {0};
char rwbs[8]= {0};
uint64_t offset=0;
char plus_sgn[8]= {0};
uint64_t len=0;
char err_val[16];
// number of sectors in extent
init_le_to_pe();
uint64_t sec_in_ext = get_pe_size(vg_name);
if (sec_in_ext == 0) {
fprintf(stderr, "No volume group named %s\n", vg_name);
exit(1);
}
FILE *btrace;
// offset in extents
uint64_t extent_num=0;
int r;
uint64_t last_print = 0;
char cmd[8192]= {0};
sprintf(cmd, "btrace -t -a complete /dev/%s/%s", vg_name, lv_name);
// XXX UGLY!!
btrace = popen(cmd, "r");
if(!btrace) {
fprintf(stderr, "can't invoke btrace");
exit(1);
}
while (fgets(in_buf, 8191, btrace)) {
r = sscanf(in_buf,
"%4095s %100i %" SCNu64 " %64lf %64i %7s %7s %" SCNu64 " %4s "
"%" SCNu64 " %15s",
blk_dev_num, &cpu_id, &seq_num, &time_stamp, &proc_id,
action_id, rwbs, &offset, plus_sgn, &len, err_val);
// ignore all non Complete events
if (strcmp(action_id,"C"))
continue;
// print current stats every 5 minutes
if (last_print+60*5<time_stamp) {
print_extents(extent_info);
last_print = time_stamp;
}
// round up
extent_num=(offset+(sec_in_ext-1))/sec_in_ext;
if (extents<=extent_num) {
extent_info = realloc(extent_info,
sizeof(struct extent_info_t)*(extent_num+100));
if (!extent_info) {
fprintf(stderr, "out of memory\n");
exit(1);
}
memset(&extent_info[extents], 0,
(extent_num+100-extents)*sizeof(struct extent_info_t));
extents=extent_num+100;
}
if (rwbs[0] == 'R')
add_io(&extent_info[(size_t)extent_num],
start_time + time_stamp, READ);
if (rwbs[0] == 'W')
add_io(&extent_info[(size_t)extent_num],
start_time + time_stamp, WRITE);
}
pclose(btrace);
return extent_info;
}
int
main(int argc, char **argv)
{
if (argc != 4) {
fprintf(stderr, "Tool to defragment LogicalVolume on selected PhysicalVolume\n");
fprintf(stderr, "Usage: lvmdefrag VolumeGroup LogicalVolume PhysicalVolume\n");
return EXIT_FAILURE;
}
char *vg_name = argv[1];
char *lv_name = argv[2];
char *pv_name = argv[3];
struct program_params pp = { .lvm2_handle = NULL };
init_le_to_pe(&pp);
struct le_info first_le;
first_le = get_first_LE_info(vg_name, lv_name, pv_name);
for(size_t i=0; i < pv_segments_num; i ++)
if( !strcmp(pv_segments[i].lv_name, lv_name) &&
!strcmp(pv_segments[i].vg_name, vg_name) &&
!strcmp(pv_segments[i].pv_name, pv_name)) {
long int optimal_pos;
optimal_pos = first_le.pe + pv_segments[i].lv_start - first_le.le;
if (pv_segments[i].pv_start == optimal_pos)
continue;
struct le_info optimal;
long int move_extent = 0;
for (long int j=optimal_pos;
j < optimal_pos + pv_segments[i].pv_length;
j++) {
optimal = get_PE_allocation(vg_name, pv_name, j);
if (optimal.dev == NULL) {
printf("# Optimal position for LE %li-%li on %s is after end of "
"the device\n",
pv_segments[i].lv_start,
pv_segments[i].lv_start + pv_segments[i].pv_length,
pv_name);
break;
} else if (strcmp(optimal.lv_name, "free")) {
printf("# Optimal position for LE %li-%li is used by %s LE %li\n",
pv_segments[i].lv_start,
pv_segments[i].lv_start + pv_segments[i].pv_length,
optimal.lv_name, optimal.le);
break;
}
move_extent++;
}
if (move_extent) {
printf("pvmove -i1 --alloc anywhere %s:%li-%li %s:%li-%li # LE %li (size: %li)\n",
pv_name,
pv_segments[i].pv_start,
pv_segments[i].pv_start + move_extent - 1,
pv_name,
optimal_pos,
optimal_pos + move_extent - 1,
pv_segments[i].lv_start,
move_extent);
}
}
le_to_pe_exit(&pp);
lvm2_exit(pp.lvm2_handle);
return EXIT_SUCCESS;
}
void print_extents(struct extent_info_t *extent_info)
{
struct extent_score_t *extent_score;
extent_score = convert_extent_info_to_extent_score(extent_info);
qsort(extent_score, EXTENTS, sizeof(struct extent_score_t), extent_cmp);
init_le_to_pe();
time_t res;
res = time(NULL);
printf("\n\n");
printf("%s", asctime(localtime(&res)));
printf("%i most active physical extents: (from most to least)\n", ext_to_print);
for(int i=EXTENTS-1, num=0; num<ext_to_print; i--) {
struct pv_info *ret;
if(!extent_score[i].read_score && !extent_score[i].write_score)
break;
ret = LE_to_PE(vg_name, lv_name, extent_score[i].offset);
if(num%10==9)
printf("%lu\n", ret->start_seg);
else
printf("%lu:", ret->start_seg);
num++;
free(ret->pv_name);
free(ret);
}
printf("\n\n");
qsort(extent_score, EXTENTS, sizeof(struct extent_score_t), extent_read_cmp);
printf("%i most read extents (from most to least):\n", ext_to_print);
for(int i=EXTENTS-1, num=0; num<ext_to_print; i--) {
struct pv_info *ret;
if(!extent_score[i].read_score)
break;
ret = LE_to_PE(vg_name, lv_name, extent_score[i].offset);
if(num%10==9)
printf("%lu\n", ret->start_seg);
else
printf("%lu:", ret->start_seg);
num++;
free(ret->pv_name);
free(ret);
}
printf("\n\n");
qsort(extent_score, EXTENTS, sizeof(struct extent_score_t), extent_write_cmp);
printf("%i most write extents (from most to least):\n", ext_to_print);
for(int i=EXTENTS-1, num=0; num<ext_to_print; i--) {
struct pv_info *ret;
if(!extent_score[i].write_score)
break;
ret = LE_to_PE(vg_name, lv_name, extent_score[i].offset);
if(num%10==9)
printf("%lu\n", ret->start_seg);
else
printf("%lu:", ret->start_seg);
num++;
free(ret->pv_name);
free(ret);
}
free(extent_score);
le_to_pe_exit();
}
int main(int argc, char **argv)
{
struct program_params pp = { .lvm2_handle = NULL };
init_le_to_pe(&pp);
if (argc != 4) {
printf("Usage: %s VolumeGroupName LogicalVolumeName"
" LogicalVolumeExtent\n", argv[0]);
le_to_pe_exit(&pp);
return 1;
}
for(int i=0; i < pv_segments_num; i++)
if(!strcmp(pv_segments[i].lv_name, argv[1]))
printf("%s %li-%li (%li-%li)\n", pv_segments[i].pv_name,
pv_segments[i].pv_start,
pv_segments[i].pv_start+pv_segments[i].pv_length,
pv_segments[i].lv_start,
pv_segments[i].lv_start+pv_segments[i].pv_length);
if (argc <= 2)
return 0;
struct pv_info *pv_info;
pv_info = LE_to_PE(argv[1], argv[2], atoi(argv[3]));
if (pv_info)
printf("LE no %i of %s-%s is at: %s:%li\n", atoi(argv[3]), argv[1], argv[2],
pv_info->pv_name, pv_info->start_seg);
else
printf("no LE found\n");
printf("vg: %s, extent size: %lu bytes\n", argv[1], get_pe_size(argv[1]));
long int free_extents = get_free_extent_number(argv[1], pv_info->pv_name);
printf("vg: %s, pv: %s, free space: %lue (%luB)\n", argv[1],
pv_info->pv_name,
free_extents,
free_extents * get_pe_size(argv[1]));
long int used_extents = get_used_space_on_pv(argv[1], argv[2],
pv_info->pv_name);
printf("Space used by lv %s on pv %s: %lue (%luB)\n",
argv[2],
pv_info->pv_name,
used_extents,
used_extents * get_pe_size(argv[1]));
struct le_info le_inf;
le_inf = get_first_LE_info(argv[1], argv[2], pv_info->pv_name);
printf("First LE on %s is %li at PE %li\n",
le_inf.dev, le_inf.le, le_inf.pe);
long int optimal_pe = le_inf.pe + atoi(argv[3]) - le_inf.le;
printf("Optimal position for LE %i is at %s:%li\n", atoi(argv[3]),
le_inf.dev, optimal_pe);
printf("%s:%li is ", le_inf.dev, optimal_pe);
if (optimal_pe == pv_info->start_seg) {
printf("allocated correctly\n");
} else {
struct le_info optimal;
optimal = get_PE_allocation(argv[1], pv_info->pv_name, optimal_pe);
if (optimal.dev == NULL)
printf("after the end of the device\n");
else if (!strcmp(optimal.lv_name, "free"))
printf("free\n");
else
printf("allocated to %s, LE: %li\n", optimal.lv_name, optimal.le);
}
pv_info_free(pv_info);
le_to_pe_exit(&pp);
lvm2_exit(pp.lvm2_handle);
return 0;
}
