src/vzcalc.c

/*
 *  Copyright (C) 2000-2006 SWsoft. All rights reserved.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <ctype.h>

#include "logger.h"
#include "ub.h"
#include "config.h"
#include "util.h"

LOG_DATA

void usage()
{
	printf("Usage: vzcalc [-v] <veid>\n");
}

int check_param(struct ub_struct *param)
{
	int ret = 0;	
#define CHECKPARAM(name, str_name) \
if (param->name == NULL) { \
	fprintf(stderr, "Error: parameter " #str_name " not found\n"); \
	ret = 1; \
}
	CHECKPARAM(numproc, NUMPROC);
	CHECKPARAM(vmguarpages, VMGUARPAGES);
	CHECKPARAM(kmemsize, KMEMSIZE);
	CHECKPARAM(tcpsndbuf, TCPSNDBUF);
	CHECKPARAM(tcprcvbuf, TCPRCVBUF);
	CHECKPARAM(othersockbuf, OTHERSOCKBUF);
	CHECKPARAM(dgramrcvbuf, DGRAMRCVBUF);
	CHECKPARAM(privvmpages, PRIVVMPAGES);

	return ret;
}

int calculate(int veid, ub_param *ub, int verbose)
{
	ub_param ub_cur;
	struct ub_struct ubs;
	struct ub_struct ubs_cur;
	char tmp[STR_SIZE];
	int ret = 0;
	double kmem_net_cur, lm_cur, tr_cur, ms_cur, al_cur, np_cur;
	double kmem_net_max, lm_max, lm_prm, ms_prm, al_prm, al_max, np_max;
	double cur, prm, max;
	unsigned long long lowmem;
	unsigned long long ram, swap = 1;
	int run, thrmax;
	int page;

	ub2ubs(ub, &ubs);
	if (check_param(&ubs))
		return 1;
	if (get_mem(&ram))
		return 1;
	if (get_thrmax(&thrmax))
		return 1;
	get_swap(&swap);
	if (get_lowmem(&lowmem))
		return 1;
	page = get_pagesize();
	lm_cur = tr_cur = ms_cur = al_cur = np_cur = 0;
	lowmem *= 0.4;
	memset(&ub_cur, 0, sizeof(ub_cur));
	if (!(run = vps_read_ubc(veid, &ub_cur))) {
		ub2ubs(&ub_cur, &ubs_cur);
		if (check_param(&ubs_cur))
			return 1;
		kmem_net_cur = (double)ubs_cur.kmemsize[0] + 
			(double)ubs_cur.tcprcvbuf[0] + 
			(double)ubs_cur.tcpsndbuf[0] +
			(double)ubs_cur.dgramrcvbuf[0] +
			(double)ubs_cur.othersockbuf[0];
		/*	Low memory	*/
		lm_cur = kmem_net_cur / lowmem;
		/*	Total RAM	*/
		tr_cur = ((double)ubs_cur.physpages[0] * page + kmem_net_cur) 
					/ ram;
		/*	Mem + Swap	*/
		ms_cur = ((double)ubs_cur.oomguarpages[0] * page +
				kmem_net_cur) /	(ram + swap);
		/*	Allocated	*/
		al_cur = ((double)ubs_cur.privvmpages[0] * page +
			       kmem_net_cur) / (ram + swap);
		/*	Numproc		*/
		np_cur = (double)ubs_cur.numproc[0] / thrmax;	
	}
	kmem_net_max = (double)ubs.kmemsize[1] + 
		(double)ubs.tcprcvbuf[1] +
		(double)ubs.tcpsndbuf[1] +
		(double)ubs.dgramrcvbuf[1] +
		(double)ubs.othersockbuf[1];
	
	/*      Low memory      */
	lm_max = kmem_net_max / lowmem;
	lm_prm = lm_max;
	/*      Mem + Swap      */
	ms_prm = ((double)ubs.oomguarpages[0] * page + kmem_net_max) /
			(ram + swap);
	/*      Allocated       */
	al_prm = ((double)ubs.vmguarpages[0] * page + kmem_net_max) / 
			(ram + swap);
	al_max = ((double)ubs.privvmpages[1] * page + kmem_net_max) /
			(ram + swap);
	/*	Numproc		*/
	np_max = (double)ubs.numproc[0] / thrmax;

	/* Calculate maximum for current */
	cur = lm_cur;
	if (tr_cur > cur)
		cur = tr_cur;
	if (ms_cur > cur)
		cur = ms_cur;
	if (al_cur > cur)
		cur = al_cur;
	if (np_cur > cur)
		cur = np_cur;
	/* Calculate maximum for promised */
	prm = lm_prm;
	if (ms_prm > prm)
		prm = ms_prm;
	if (al_prm > prm)
		prm = al_prm;
	/* Calculate maximum for Max */
	max = lm_max;
	if (al_max > max)
		max = al_max;
	if (np_max > max)
		max = np_max;
	sprintf(tmp, "n/a");
	printf("Resource     Current(%%)  Promised(%%)  Max(%%)\n");
	if (verbose) {
		if (!run)
			sprintf(tmp, "%10.2f", lm_cur * 100);
		printf("Low Mem    %10s %10.2f %10.2f\n",
				tmp, lm_prm * 100, lm_max * 100);
		if (!run)
			sprintf(tmp, "%10.2f", tr_cur * 100);
		printf("Total RAM  %10s        n/a        n/a \n", tmp);
		if (!run)
			sprintf(tmp, "%10.2f", ms_cur * 100);
		printf("Mem + Swap %10s %10.2f        n/a\n",
				tmp, ms_prm * 100);
		if (!run)
			sprintf(tmp, "%10.2f", al_cur * 100);
		printf("Alloc. Mem %10s %10.2f %10.2f\n",
				tmp , al_prm * 100, al_max * 100);
		if (!run)
			sprintf(tmp, "%10.2f", np_cur * 100);
		printf("Num. Proc  %10s        n/a %10.2f\n",
				tmp, np_max * 100);
		printf("--------------------------------------------\n");
	}
	if (!run)
		sprintf(tmp, "%10.2f", cur * 100);
	printf("Memory     %10s %10.2f %10.2f\n", tmp, prm * 100, max * 100);
	free_ub_param(&ub_cur);
	return ret;
}

int main(int argc, char **argv)
{
	struct stat st;
	char path[64];
	int ret, opt, veid, verbose = 0;
	vps_param *param;

	while ((opt = getopt(argc, argv, "vh")) > 0) {
		switch(opt) {
		case 'v':
			verbose = 1;
			break;
		case 'h':
			usage();
			exit(1);
			break;
		default	:
			exit(1);
		}
	}
	if (optind == argc) {
		usage();
		exit(1);
	}
	if (parse_int(argv[optind], &veid)) {
		fprintf(stderr, "Invalid veid: %s\n", argv[optind]);
		exit(1);
	}
	get_vps_conf_path(veid, path, sizeof(path));
	if (stat(path, &st)) {
		fprintf(stderr, "VPS configuration file: %s not found\n", path);
		exit(1);
	}
	param = init_vps_param();
	if (vps_parse_config(veid, path, param, NULL))
		exit(1);
	ret = calculate(veid, &param->res.ub, verbose);
	free_vps_param(param);
	exit(ret);
}