mlock.c

linux集群服务器软件代码包

	size_t i;
	
  	int  task_table[][9] =
		{
			/*test 1:
			  testing lock function in only one machine*/
			{0, OPEN},
			{0, WAIT},
			{0, RUN, 1, 1, F_TEST, 0, 1, PASS},
			{0, RUN, 1, 2, F_TEST, 0, END, PASS},
			{0, RUN, 1, 3, F_TEST, 1, 1, PASS},
			{0, RUN, 1, 4, F_TEST, 1, END, PASS},
			{0, SEND},
			{0, CLOSE},
			
			{1, SEND},
			{1, WAIT},

			/*test 2: 
			  node 1 locks the whole file
			  node 2 tries to lock different regions of 
			  the same file*/

			{0, OPEN},
			{0 ,WAIT},
			{0, RUN, 2, 0, F_TLOCK, 0, END, PASS},
			{0, SEND},
			{0, WAIT},
			{0, CLOSE},

			{1, OPEN},
			{1, SEND},
			{1, WAIT},
			{1, RUN, 2, 1, F_TEST, 0, 1, EACCES},
			{1, RUN, 2, 2, F_TEST, 0, END, EACCES},
			{1, RUN, 2, 3, F_TEST, 1, 1, EACCES},
			{1, RUN, 2, 4, F_TEST, 1, END, EACCES},
			{1, SEND},
			{1, CLOSE},

			/* test 3:
			   node 1 locks the 1st byte.
			   node 2 tries to lock different regions*/

			{0, OPEN},
			{0, WAIT},
			{0, RUN, 3, 0, F_TLOCK, 0, 1, PASS},
			{0, SEND},
			{0, WAIT},
			{0, RUN, 3, 5, F_ULOCK, 0, 1, PASS},
			{0, CLOSE},
			
			{1, OPEN},
			{1, SEND},
			{1, WAIT},
			{1, RUN, 3, 1, F_TEST, 0, 1, EACCES},
			{1, RUN, 3, 2, F_TEST, 0, END, EACCES},
			{1, RUN, 3, 3, F_TEST, 1, 1, PASS},
			{1, RUN, 3, 4, F_TEST, 1, END, PASS},
			{1, SEND},
			{1, CLOSE},
			
			/* test 4:
			   node 1 locks the second byte
			   node 2 tries to lock different regions
			*/
			
			{0, OPEN},
			{0, WAIT},
			{0, RUN, 4, 0, F_TLOCK, 1, 1, PASS},
			{0, SEND},
			{0, WAIT},
			{0, RUN, 4, 10, F_ULOCK, 1, 1, PASS},
			{0, CLOSE},
			
			{1, OPEN},
			{1, SEND},
			{1, WAIT},
			{1, RUN, 4, 1, F_TEST, 0, 1, PASS},
			{1, RUN, 4, 2, F_TEST, 0, 2, EACCES},
			{1, RUN, 4, 3, F_TEST, 0, END, EACCES},
			{1, RUN, 4, 4, F_TEST, 1, 1, EACCES},
			{1, RUN, 4, 5, F_TEST, 1, 2, EACCES},
			{1, RUN, 4, 6, F_TEST, 1, END, EACCES},
			{1, RUN, 4, 7, F_TEST, 2, 1, PASS},
			{1, RUN, 4, 8, F_TEST, 2, 2, PASS},
			{1, RUN, 4, 9, F_TEST, 2, END, PASS},
			{1, SEND},
			{1, CLOSE},
			
			/* test 5:
			   node 1 locks the 1st and 3rd bytes, 
			   node 2 tries to lock different regions
			*/

			{0, OPEN},
			{0, WAIT},
			{0, RUN, 5, 0, F_TLOCK, 0, 1, PASS},
			{0, RUN, 5, 1, F_TLOCK, 2, 1, PASS},
			{0, SEND},
			{0, WAIT},
			{0, RUN, 5, 14, F_ULOCK, 0, 1, PASS},
			{0, RUN, 5, 15, F_ULOCK, 2, 1, PASS},
			{0, CLOSE},
			
			{1, OPEN},
			{1, SEND},
			{1, WAIT},
			{1, RUN, 5, 2, F_TEST, 0, 1, EACCES},
			{1, RUN, 5, 3, F_TEST, 0, 2, EACCES},
			{1, RUN, 5, 4, F_TEST, 0, END, EACCES},
			{1, RUN, 5, 5, F_TEST, 1, 1, PASS},
			{1, RUN, 5, 6, F_TEST, 1, 2, EACCES},
			{1, RUN, 5, 7, F_TEST, 1, END, EACCES},
			{1, RUN, 5, 8, F_TEST, 2, 1, EACCES},
			{1, RUN, 5, 9, F_TEST, 2, 2, EACCES},
			{1, RUN, 5, 10, F_TEST, 2, END, EACCES},
			{1, RUN, 5, 11, F_TEST, 3, 1, PASS},
			{1, RUN, 5, 12, F_TEST, 3, 2, PASS},
			{1, RUN, 5, 13, F_TEST, 3, END, PASS},
			{1, SEND},
			{1, CLOSE},

			/*test 6 : about maxof , ignored now
			 */


			/*test 7: test nodes' mutual exclusion.
			 */

			{0, OPEN},
			{0, WAIT},
			{0, RUN, 7, 0, F_TLOCK, WR_START, LOCKLEN, PASS},
			{0, WRITE, 7, 1, WR_START, MSGONE},
			{0, SEND},
			{0, READ, 7, 2, WR_START, MSGONE},
			{0, RUN, 7, 3, F_ULOCK, WR_START, LOCKLEN, PASS},
			{0, WAIT},
			{0, RUN, 7, 7, F_LOCK, WR_START, LOCKLEN, PASS},
			{0, READ, 7, 8, WR_START, MSGTWO},
			{0, RUN, 7, 9, F_ULOCK, WR_START, LOCKLEN, PASS},
			{0, SEND},
			{0, CLOSE},
			

			{1, OPEN},
			{1, SEND},
			{1, WAIT},
			{1, RUN, 7, 4, F_LOCK, WR_START, LOCKLEN, PASS},
			{1, SEND},
			{1, WRITE, 7, 5, WR_START, MSGTWO},
			{1, RUN, 7, 6, F_ULOCK, WR_START, LOCKLEN, PASS},
			{1, WAIT},
			{1, CLOSE},

			/*test 8: rate test, ignored now
			 */


			/*test 9: Test mandatory locking.
			  FIXME: this testing cannot work yet
			 */
#if 0
			{0, MANOPEN},
			{0, SLEEP, 20},
			{0, WAIT},
			{0, RUN,   9, 0, F_TLOCK, 0, LOCKLEN, PASS},
			{0, WRITE, 9, 1, 0, MSGONE},
			{0, SEND},
			{0, READ,  9, 2, 0, MSGONE},
			{0, RUN,   9, 3, F_ULOCK, 0, LOCKLEN, PASS},
			{0, WAIT},
			{0, READ,  9, 5, 0, MSGTWO},
			{0, SEND},
			{0, CLOSE},
			
			{1, OPEN},
			{1, SEND},
			{1, WAIT},
			{1, RUN, 9, 4, F_TEST, 0, LOCKLEN, EACCES},
			{1, WRITE, 9, 4, 0, MSGTWO},
			{1, SEND},
			{1, WAIT},
			{1, CLOSE},
#endif 
			/* test 10:
			   Make sure a locked region is split properly
			*/
			
			{0, OPEN},
			{0, WAIT},
			{0, RUN, 10, 0, F_TLOCK, 0, 3, PASS},
			{0, RUN, 10, 1, F_ULOCK, 1, 1, PASS},
			{0, SEND},
			{0, WAIT},
			{0, RUN, 10, 6, F_ULOCK, 0, 1, PASS},
			{0, RUN, 10, 7, F_ULOCK, 2, 1, PASS},
			{0, SEND},
			{0, WAIT},
			/* {0, RUN, 10, 9, F_ULOCK, 0, 1, PASS}, */
			{0, RUN, 10, 10, F_TLOCK, 1, 3, PASS},
			{0, RUN, 10, 11, F_ULOCK, 2, 1, PASS},
			{0, SEND},
			{0, WAIT},
			{0, CLOSE},
			
			{1, OPEN},
			{1, SEND},
			{1, WAIT},
			{1, RUN, 10, 2, F_TEST, 0, 1, EACCES},
			{1, RUN, 10, 3, F_TEST, 2, 1, EACCES},
			{1, RUN, 10, 4, F_TEST, 3, END, PASS},
			{1, RUN, 10, 5, F_TEST, 1, 1, PASS},
			{1, SEND},
			{1, WAIT},
			{1, RUN, 10, 8, F_TEST, 0, 3, PASS},
			{1, SEND},
			{1, WAIT},
			{1, RUN, 10, 12, F_TEST, 1, 1, EACCES},
			{1, RUN, 10, 13, F_TEST, 3, 1, EACCES},
			{1, RUN, 10, 14, F_TEST, 4, END, PASS},
			{1, RUN, 10, 15, F_TEST, 2, 1, PASS},
			{1, RUN, 10, 16, F_TEST, 0, 1, PASS},
			{1, SEND},
			{1, CLOSE},

			/* test 11:
			   make sure close() releases the process's locks
			*/
			{0, OPEN},
			{0, WAIT},
			{0, PUSHFD},
			{0, RUN, 11, 0, F_TLOCK, 0, 0, PASS},
			{0, CLOSE},
			{0, SEND},

			{0, WAIT},
			{0, POPFD},
			{0, RUN, 11, 3, F_TLOCK, 29, 1463, PASS},
			{0, RUN, 11, 4, F_TLOCK, 0X2000, 87, PASS},
			{0, CLOSE},
			{0, SEND},
		

			{0, WAIT},
			{0, POPFD},
			{0, WRITE, 11, 7, 0, MSGONE},
			{0, RUN, 11, 8, F_TLOCK, 0, 0, PASS},
			{0, CLOSE},
			{0, SEND},
			
			{0, WAIT},
			{0, POPFD},
			{0, WRITE, 11, 11, 0, MSGTWO},
			{0, RUN, 11, 12, F_TLOCK, 0, 0, PASS},
			{0, TRUNC},
			{0, CLOSE},
			{0, SEND},
			{0, WAIT},
			{0, CLOSE_SAVEFD},

			{1, OPEN},
			{1, SEND},
			{1, WAIT},
			{1, RUN, 11, 1, F_TLOCK, 0, 0, PASS},
			{1, RUN, 11, 2, F_ULOCK, 0, 0, PASS},			
			{1, SEND},
			
			{1, WAIT},
			{1, RUN, 11, 5, F_TLOCK, 0, 0, PASS},
			{1, RUN, 11, 6, F_ULOCK, 0, 0, PASS},
			{1, SEND},
			
			{1, WAIT},
			{1, RUN, 11, 9, F_TLOCK, 0, 0, PASS},
			{1, RUN, 11, 10, F_ULOCK, 0, 0, PASS},
			{1, SEND},
			
			{1, WAIT},
			{1, RUN, 11, 13, F_TLOCK, 0, 0, PASS},
			{1, RUN, 11, 14, F_ULOCK, 0, 0, PASS},
			{1, SEND},
			{1, CLOSE},
			
			/* test 12:
			   Signalled process should release locks.
			*/
			
	  		{0, OPEN},
			{0, WAIT},
			{0, SLEEP, 1},
			{0, RUN, 12, 1, F_TLOCK, 0, 0, PASS},
			{0, SEND},
			{0, CLOSE},
			
			{1, OPEN},
			{1, FORK, RUN, 12, 0, F_TLOCK, 0, 0, PASS},
			{1, SLEEP, 1},
			{1, KILL},
			{1, SEND},
			{1, WAIT},
			{1, CLOSE},
			
			
			
		};
	
	for (i = 0; i < sizeof(task_table)/(sizeof(task_table[0])); i++ ){
		if ( gi.clientID == task_table[i][0]){
			struct task* task  = g_malloc( sizeof(struct task));
			int j = 2;

			task->op = task_table[i][1];			
			
			switch(task->op){
		

			case WRITE:
			case READ:
				task->io_param.num = task_table[i][j++];
				task->io_param.sec = task_table[i][j++];	
				task->io_param.start = task_table[i][j++];
				task->io_param.whichmsg = task_table[i][j++];
				break;
				
			case SLEEP:
				task->sleep_param.time = task_table[i][j++];
				break;
				
			case FORK:
				j++;
				/* fall through */
			case RUN:
				task->run_param.num = task_table[i][j++];
				task->run_param.sec = task_table[i][j++];
				task->run_param.func = task_table[i][j++];
				task->run_param.offset = task_table[i][j++];				     
				task->run_param.length = task_table[i][j++];
				task->run_param.pass = task_table[i][j++];				     
				break;						
				
			}
			task_list = g_slist_append(task_list, task);
		}
	}     		
	return task_list;
}


static void
remove_task_list(GSList* task_list)
{
	size_t i;
	
	for (i = 0; i < g_slist_length(task_list); i++){
		g_free(g_slist_nth_data(task_list, i));
	}
	
	g_slist_free(task_list);
	
}

static void
runtests(GSList* task_list)
{
	size_t i;
	
	for (i = 0; i < g_slist_length(task_list); i++){
		struct task* task; 
		
		task =  g_slist_nth_data(task_list, i);
		switch(task->op){

		case OPEN:
			open_testfile();
			break;
		case MANOPEN:
			manopen_testfile();
			break;
		case CLOSE:
			close_testfile();
			break;
		case CLOSE_SAVEFD:
			close_savefd();
			break;
		case WAIT:
			waitnotice();
			break;
		case SEND:
			sendnotice();
			break;
		case WRITE:
			write_testfile(task);			
			break;
		case READ:
			read_testfile(task);			
			break;
		case RUN:
			test( task->run_param.num,
			      task->run_param.sec,
			      task->run_param.func,
			      task->run_param.offset,
			      task->run_param.length,
			      task->run_param.pass, 
			      FATAL);
			break;
		case FORK:{
			int subpid = fork();
			if (subpid < 0){
				perror("can't fork off child");
				exit(1);
			}
			if (subpid == 0){
				test( task->run_param.num,
				      task->run_param.sec,
				      task->run_param.func,
				      task->run_param.offset,
				      task->run_param.length,
				      task->run_param.pass, 
				      FATAL);
				while(1) {
					sleep(1);
				}
			}else{
				gi.forkpid = subpid;
			}
			break;
		}
		case KILL:
			if(kill(gi.forkpid, SIGINT) == -1){
				perror("kill");
				exit(1);

			}
			break;
		case SLEEP:
			sleep(task->sleep_param.time);
			break;
		case PUSHFD:
			pushfd();
			break;
		case POPFD:
			popfd();
			break;
		case TRUNC:
			hb_trunc();
			break;
		}
		
	}
	
}

static void
usage(const char* pgm)
{
 	output("Usage: this test need to run in two machines, the filesname and num have to be the same in both nodes\n");
	output("node1:\n %s [-N num] <filename>\n", pgm);
	output("node2:\n %s [-N num] <filename> <node1_hostname>\n", pgm);
	return;
}

int
main (int argc, char**  argv)
{
	char* servername = NULL;
	char* filename = NULL;
	GSList* task_list = NULL;
	int option;
	int num_ites;
	int i;

	extern char *optarg;

	/*default number of phase is 1*/
	num_ites = 1; 
	while ((option = getopt(argc, argv, "N:h")) != -1){
		switch(option){
		case 'N':
			sscanf(optarg, "%d", &num_ites); 
			break;
		case 'h':
		default:
			usage(argv[0]);
			exit(1);
		}
	}
	
	gi.clientID = 0;
	for (i = optind ; i <  argc; i++)
		{
			if (filename == NULL){
                                filename = argv[i];
			} else {
	                        servername = argv[i];
                                gi.clientID = 1;
			}
		}
	if (filename == NULL){
		usage(argv[0]);
		exit(1);
	}
	gi.testpass = 0;
	gi.testwarn = 0;
	gi.testfail = 0;
	
	strcpy(gi.filename, filename);
	
	init_comm(servername);
	
	for (i = 0; i < num_ites; i++){
		
		output("Iteration %d: \n", i);
		task_list = generate_task_list();
		
		runtests(task_list);
		
		remove_task_list(task_list);
	}
	
	test_exit();

	return 0;
}