main.c

linux/unix下c/s形式的资源监视,客户端负责搜集机器,再传送到服务端.

/* 
 *  Monitor-Server/main.c
 *
 *  Copyright (C) 2004 Jian Shen <[e-mail]>
 *
 *  Collect cluster-wide load information in proc filesystem. 
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <linux/net.h>
#include <linux/socket.h>
#include <linux/inet.h>
#include <linux/unistd.h>
#include <linux/time.h>
#include <net/sock.h>
#include <asm/uaccess.h>

#include "config.h"
#include "statinfo.h"
#include "socket.h"
#include "nodelist.h"
#include "sysctl.h"

struct proc_dir_entry *cluster_dir;
extern int sysctl_cltload_stop;

extern void ps_mutex_init();

char* in_ntoa(struct sockaddr_in in)
{
	unsigned char* bytes;
	char* buffer;

	bytes = (unsigned char*)&(in.sin_addr.s_addr);

	buffer = (char*)kmalloc(20, GFP_KERNEL);
	if(buffer == NULL) {
		printk(KERN_ERR "kmalloc failed in in_ntoa().\n");
		return NULL;
	}

	sprintf(buffer, "%d.%d.%d.%d",
	      bytes[0], bytes[1], bytes[2], bytes[3]);

	return buffer;				/* caller free */
}


/* void test_addr_translation() */
/* { */
/* 	struct sockaddr_in sin; */

/* 	sin.sin_family	     = AF_INET; */
/* 	sin.sin_addr.s_addr  = (__u32)in_aton("162.105.146.166"); */
/* 	sin.sin_port         = htons((unsigned short)MONPORT); */
/* 	memset(&(sin.sin_zero), '\0', 8); */

/* 	char* addr = in_ntoa(sin); */
/* 	if(addr != NULL) { */
/* 		printk(KERN_INFO "%s\n", addr); */
/* 		kfree(addr); */
/* 	} */
/* } */

static int RefreshThr(void* arg)
{
#ifdef KERNEL_2_4
	MOD_INC_USE_COUNT;
#else
	/* in kernel 2.6 MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT are deprecated. 
	   see linux/module.h. */
	try_module_get(THIS_MODULE);
#endif

	sprintf(current->comm, "refresh");

	while(sysctl_cltload_stop == 0) {

		current->state = TASK_INTERRUPTIBLE;
		schedule_timeout(HZ * REFRESH_INTERVAL);

		if(sysctl_cltload_stop != 0)
			break;

		nlist_check();
	}

#ifdef KERNEL_2_4
	MOD_DEC_USE_COUNT;
#else
	module_put(THIS_MODULE);
#endif

	return 0;
}

static int CltDaemon(void *arg)
{
	struct socket *sock;
	struct sockaddr_in sin;
	struct sockaddr_in caddr;
	int error;

	int optval;
	mm_segment_t oldfs;

	system_load_info sysload;

	int addrlen;

#ifdef KERNEL_2_4
	MOD_INC_USE_COUNT;
#else
	/* in kernel 2.6 MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT are deprecated. 
	   see linux/module.h. */
	try_module_get(THIS_MODULE);
#endif

	sprintf(current->comm,"cluster load");

	/* make up address */
	sin.sin_family	     = AF_INET;
	sin.sin_addr.s_addr  = INADDR_ANY;
	sin.sin_port         = htons((unsigned short)SVRPORT);
	memset(&(sin.sin_zero), '\0', 8);

	/* create a socket */
#ifdef KERNEL_2_4
	error = sock_create(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
#else
	error = sock_create(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock, 1);
#endif
	if(error < 0) {
	     printk(KERN_ERR "sock_create failed %d.\n", -error);
		 return -1;
	}

	oldfs = get_fs();
	set_fs(KERNEL_DS);
	error = sock_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&optval, sizeof(optval));
	if(error < 0) {
		printk(KERN_ERR "sock_setsockopt failed %d.\n", -error);
		sock_release(sock);
		return -1;
	}
	set_fs(oldfs);

/* 	sock->sk->reuse = 1; */

	error = sock->ops->bind(sock, (struct sockaddr*)&sin, sizeof(sin));
	if (error < 0) {
		printk(KERN_ERR "sock->ops->bind failed %d.\n", -error);
		sock_release(sock);
		return -1;
	}

	/* create collector's thread */
	kernel_thread(RefreshThr, NULL, 0);

	while(sysctl_cltload_stop == 0) {
		error = ps_recvfrom(sock, &sysload, sizeof(system_load_info), 0, &caddr, &addrlen);
		if(error <0) {
			printk(KERN_ERR "ps_recvfrom failed.\n");
			sock_release(sock);
			return -1;
		}

		if(sysctl_cltload_stop !=0 )
			break;

//		printk("CPU util: %s%s\n", sysload.cpu_util[0], "%");

		nlist_update(in_ntoa(caddr), &sysload);
	}


	sock_release(sock);

#ifdef KERNEL_2_4
	MOD_DEC_USE_COUNT;
#else
	module_put(THIS_MODULE);
#endif

	return 0;
}

int cluster_module_init()
{
	printk(KERN_INFO "Cluster monitor initialize.\n");

    /* create /proc/cluster directory */
    cluster_dir = proc_mkdir("cluster", &proc_root);
    if(cluster_dir == 0) {
		printk(KERN_ERR "proc_mkdir failed.\n");
        return -1;
	}
	printk(KERN_ERR "create /proc/cluster directory.\n");

//	test_addr_translation();

	start_sysctl();

	nlist_init();
//	ps_mutex_init();

	/* create collector's thread */
	kernel_thread(CltDaemon, NULL, 0);

    return 0;
}

void cluster_module_cleanup()
{
	printk(KERN_INFO "Cluster monitor cleanup.\n");

	nlist_removeall();

	if(cluster_dir != 0)
		remove_proc_entry("cluster", &proc_root);

//	printk(KERN_INFO "STOP:%d.\n", sysctl_cltload_stop);
	end_sysctl();

}


MODULE_LICENSE("GPL");
MODULE_AUTHOR("Shen Jian <[e-mail]");

module_init(cluster_module_init);
module_exit(cluster_module_cleanup);