path: root/src/ufs_ffinfo.c

#include <ufs/ffs/fs.h>
#include <libufs.h>

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <strings.h>
#include <stdlib.h>

#define MAXBINS 20

#ifndef max
# define max(a,b) ((a) > (b) ? (a) : (b))
#endif

struct ffinfo {
	uint64_t bins[MAXBINS];	
	uint64_t free_blocks[MAXBINS];	
	uint64_t blocks_num;
};

struct ffinfo_ctx {
	struct fs *fs;
	struct ffinfo* info_cg;
	struct ffinfo info_sum;
	uint8_t verbose;
};

static int
rdfs(ufs2_daddr_t bno, size_t size, void *bf, int fsi)
{
	ssize_t	n;

	if (bno < 0) {
		fprintf(stderr, "rdfs: attempting to read negative block number");
		return -1;
	}

	if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0) {
		fprintf(stderr, "rdfs: seek error: %jd", (intmax_t)bno);
		return -1;
	}

	n = read(fsi, bf, size);

	if (n != (ssize_t)size) {
		fprintf(stderr, "rdfs: read error: %jd", (intmax_t)bno);
		return -1;
	}

	return 0;
}

static int
isblock(const struct fs *fs, unsigned char *cp, int h)
{
	unsigned char mask;

	switch (fs->fs_frag) {
	case 8:
		return (cp[h] == 0xff);
	case 4:
		mask = 0x0f << ((h & 0x1) << 2);
		return ((cp[h >> 1] & mask) == mask);
	case 2:
		mask = 0x03 << ((h & 0x3) << 1);
		return ((cp[h >> 2] & mask) == mask);
	case 1:
		mask = 0x01 << (h & 0x7);
		return ((cp[h >> 3] & mask) == mask);
	default:
		fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
		return (0);
	}
}

/*
 * Read the superblock and init the work ctx
 */

static struct ffinfo_ctx *
ffinfo_ctx_init(int fd, uint8_t verbose)
{
	struct fs *fs;
	struct ffinfo_ctx *ctx;
	int ret;

	// Read the superblock
	if ((ret = sbget(fd, &fs, -1)) != 0) {
		fprintf(stderr, "Unable to read superblock\n");
		return NULL;
	}

	ctx = calloc(1, sizeof(struct ffinfo_ctx));
	if (!ctx) {
		fprintf(stderr, "Unable to allocate memory for ctx\n");
		goto err_free_sb_mem;
	}

	ctx->fs = fs;
	ctx->verbose = verbose;

	if (verbose) {
		fprintf(stdout, "Superblock found,\n"
			"size (KB) total: %llu, CG num: %d, block size: %d, frags per block: %d, max_bpg: %d\n",
			fs->fs_size * fs->fs_fsize / 1024llu, fs->fs_ncg, fs->fs_bsize, fs->fs_frag, fs->fs_maxbpg);
	}

	ctx->info_cg = calloc(fs->fs_ncg, sizeof(struct ffinfo));
	if (!ctx->info_cg) {
		fprintf(stderr, "Unable to allocate memory for info_cg\n");
		goto err_free_ctx;
	}

	return ctx;

err_free_ctx:
	free(ctx);

err_free_sb_mem:
	free(fs);

	return NULL;
}

static void
ffinfo_ctx_free(struct ffinfo_ctx *ctx)
{
	free(ctx->info_cg);
	free(ctx->fs);
	free(ctx);
}

static void
ffinfo_print_hysto(uint64_t hysto_blocks_num, uint64_t total_blocks_num, const uint64_t *bins, const uint64_t *free_blocks)
{
	uint64_t blocks;
	int e;
	for (blocks = 1, e = 0; blocks < hysto_blocks_num && e < MAXBINS; blocks <<= 1, e++) {
		fprintf(stdout, "  [%lu ... %lu) - %lu %lu %.2f\n", blocks, blocks << 1, bins[e], free_blocks[e], 100 * free_blocks[e]/(float)total_blocks_num);
	}
}

static void
ffinfo_print(const struct ffinfo_ctx *ctx)
{
	uint32_t c;
	uint32_t blocks;
	uint32_t e;
	uint64_t free_blocks;

	struct ffinfo* info;

	uint64_t sum_bins[MAXBINS] = {0};
	uint64_t sum_free_blocks[MAXBINS] = {0};
	uint64_t max_blocks_num = 0;
	uint64_t total_free_blocks_num = 0;

	for (c = 0; c < ctx->fs->fs_ncg; c++) {
		free_blocks = 0;
		info = &ctx->info_cg[c];
		max_blocks_num = max(max_blocks_num, ctx->info_cg[c].blocks_num);
		for (blocks = 1, e = 0; blocks < ctx->info_cg[c].blocks_num && e < MAXBINS; blocks <<= 1, e++) {
			free_blocks += info->free_blocks[e];
			sum_bins[e] += info->bins[e];
			sum_free_blocks[e] += info->free_blocks[e];
		}
		total_free_blocks_num += free_blocks;

		fprintf(stdout, "Cylinder group %d, total blocks: %lu, free blocks: %lu\n", c, ctx->info_cg[c].blocks_num, free_blocks);
		ffinfo_print_hysto(ctx->info_cg[c].blocks_num, free_blocks, info->bins, info->free_blocks);
	}

	fprintf(stdout, "Summary\n");

	ffinfo_print_hysto(max_blocks_num, total_free_blocks_num, sum_bins, sum_free_blocks);


}

static union {
	struct cg	cg;
	char		pad[MAXBSIZE];
} cgun2;
#define	aocg	cgun2.cg

static void
ffinfo_scan_freemap(const struct fs* fs, char* map, uint32_t size, struct ffinfo* res)
{
	uint32_t d;
	uint32_t blocks = size / fs->fs_frag;
	uint32_t bin;
	uint32_t free_count= 0;

	for (d = 0; d < blocks; d++) {
		if (isblock(fs, map, d)) {
			free_count++;
		} else {
			if (free_count) {
				bin = fls(free_count) - 1;

				if (bin >= MAXBINS)
					break;

				res->bins[bin]++;
				res->free_blocks[bin] += free_count;;

				free_count = 0;
			}
		}
	}

	if (free_count) {
		bin = fls(free_count) - 1;
		if (bin >= MAXBINS)
			return;
		res->bins[bin]++;
		res->free_blocks[bin] += free_count;
	}
}

static int
ffinfo_run(int fd)
{
	uint32_t c;
	char* map;
	struct ffinfo_ctx *ctx;

        ctx = ffinfo_ctx_init(fd, 1);
	if (!ctx) {
		return -1;
	}

	for (c = 0; c < ctx->fs->fs_ncg; c++) {
		if (rdfs(fsbtodb(ctx->fs, cgtod(ctx->fs, c)),
			(size_t)ctx->fs->fs_cgsize, (void*)&aocg, fd) < 0) {
			goto err_free_ctx;
		}

		ctx->info_cg[c].blocks_num = aocg.cg_ndblk / ctx->fs->fs_frag;
		
		map = cg_blksfree(&aocg);

		ffinfo_scan_freemap(ctx->fs, map, aocg.cg_ndblk, &ctx->info_cg[c]);
	}

	ffinfo_print(ctx);

	ffinfo_ctx_free(ctx);

	return 0;

err_free_ctx:

	ffinfo_ctx_free(ctx);
	return -1;
}

int
main(int argc, char *argv[])
{
	const char* special;
	int fsfd;

	if (argc != 2)
		fprintf(stderr, "no block device given\n");

	special = argv[1];

	if ((fsfd = open(special, O_RDONLY)) < 0 || ffinfo_run(fsfd) < 0)
		fprintf(stderr, "err\n");

	return 0;
}