Esempio n. 1
0
void bell_fall_scan(void)
{
	long a0,a1,a2,a3,a4,a5,a6,a7;
	OBJECT *oa8,*oa0;
	OBJECT *obj=current_proc->pa8;

	if (distance_off_ground(current_proc,current_proc->pa8)<=224)
		return;						// wait to get off screen

	stop_me(current_proc->pa8);
	obj->oxpos.u.intpos=0xb0;		// SCX(600);
	process_sleep(0x50);			// let scroller catch up!

	set_noedge(current_proc->pdata.p_otherguy);		// dont allow otherguy to update position with neew world edges

	obj->oyvel.pos=SCY(0xc0000);
	obj->ograv.pos=0;
	set_x_vel(current_proc->pa8,0);

	/* bfall3 */
	do
	{
		process_sleep(1);
	}
	while(distance_off_ground(current_proc,current_proc->pa8)>SCY(0x10));

	dallprc(PID_BACKG);
	dallprc(PID_SCROLL);
	stop_scrolling();

	a0=worldtlx.pos;
	a1=worldtlx1.pos;
	a2=worldtlx2.pos;
	a3=worldtlx3.pos;
	a4=worldtlx4.pos;
	a5=worldtlx5.pos;
	a6=worldtlx6.pos;
	a7=worldtlx7.pos;

	/* init */
	init_background_module(bell2_module);
	worldtly.u.intpos-=SCY(0x50);
	multi_plane();
	worldtly.u.intpos+=SCY(0x50);

	worldtlx.pos=a0;
	worldtlx1.pos=a1;
	worldtlx2.pos=a2;
	worldtlx3.pos=a3;
	worldtlx4.pos=a4;
	worldtlx5.pos=a5;
	worldtlx6.pos=a6;
	worldtlx7.pos=a7;

	(OBJECT *)a0=baklst8;
	a7=0;
	/* adj8 */
	do
	{
		a1=((OBJECT *)a0)->oypos.u.intpos=((OBJECT *)a0)->oypos.u.intpos+ONE_FLOOR;
		a1+=((OBJECT *)a0)->osize.u.ypos;
		if (a1>=a7)
			a7=a1;				// new lowest point

		(OBJECT *)a0=((OBJECT*)a0)->olink;
	}
	while((OBJECT *)a0!=NULL);

	/* tack on xtra pieces to bottom of floor */
	(long)current_proc->a7=a7;
	(long)current_proc->a6=worldtlx.u.intpos;
	current_proc->a3=0;
	floor_piece();
	broken_floor_a();
	broken_floor_b();
	current_proc->a3^=1;
	floor_piece();

	CREATE(PID_FX,crash_fx)->pa8=(OBJECT *)(current_proc->pdata.p_store7);
	scrolly.pos=SCY(0xc0000);					// dont fall 2 fast

	/* wait_old_offscreen */
	do
	{
		process_sleep(1);
	}
	while(worldtly.u.intpos<SCRBOT);

	current_proc->pa8=(OBJECT*)current_proc->pdata.p_store7;
	clear_shadow_bit(current_proc->pdata.p_otherguy);
	set_inviso(current_proc->pdata.p_otherguy);

	/* get rid of bell tower #1 images */
	f_skew=0;
	delolist(&baklst1);
	delolist(&baklst2);
	delolist(&baklst3);
	delolist(&baklst4);
	delolist(&baklst5);
	delolist(&baklst6);
	delolist(&baklst7);

	/* make another copy of bell2 on list 7 */
	(short)current_proc->a10=worldtly.u.intpos;
	worldtlx7.pos=worldtlx8.pos;
	current_proc->pa8=oa8=baklst8;
	oa0=get_object();
	copy_obj(oa8,oa0);
	baklst7=oa0;
	goto copy81;

	/* copy8 */
	do
	{
		oa0=get_object();
		copy_obj(oa8,oa0);
		((OBJECT *)current_proc->pa9)->olink=oa0;
copy81:
		oa0->oypos.u.intpos+=ONE_FLOOR;
		oa0->olink=NULL;
		(OBJECT *)current_proc->pa9=oa0;
		oa8=oa8->olink;
	}
	while(oa8!=NULL);

	scroll_down_1_floor();
	baklst_down_2_floors(&baklst8);
	scroll_down_1_floor();
	baklst_down_2_floors(&baklst7);

	/* speed up past the guy !! */
	scrolly.pos=SCY(0x100000);				// dont fall to fast
	scroll_down_1_floor();

	/* fix borken pieces !!! */
	fix_broken_pieces(baklst7);
	fix_broken_pieces(baklst8);

	baklst_down_2_floors(&baklst8);
	scroll_down_1_floor();
	baklst_down_2_floors(&baklst7);
	scroll_down_1_floor();

	current_proc->a10=14;
	(short)current_proc->a3=worldtlx.u.intpos;
	/* spike3 */
	do
	{
		oa0=make_a_spike();
		oa0->ozval=0;

		oa0=make_a_spike();
		oa0->ozval=100;

	}
	while(--current_proc->a10>0 );

	process_sleep(5);
	scrolly.pos=0;
	current_proc->pa8=oa8=(OBJECT*)current_proc->pdata.p_store7;

	/* falld3, fall till I meet my maker !!! */
	do
	{
		process_sleep(1);
	}
	while(oa8->oypos.u.intpos<SCY(0xa40) );

	rsnd_stab();
	death_scream;
	find_ani_part2(ANIM_KDOWN);
	do_next_a9_frame(oa8);

	oa8->oyvel.pos=SCY(0xa0000);

	/* falld4 */
	do
	{
		process_sleep(1);
		oa8->oyvel.pos>>=4;
	}
	while(oa8->oyvel.pos>SCY(0x10000) );

	ground_y=oa8->oypos.u.intpos+SCY(0x100);
	create_blood_proc(BLOOD_PIT);

	process_sleep(10);

	death_blow_complete();
	f_no_bonus=0;								// allow bonus routine to do its thing
	stop_a8(oa8);
	wait_forever();
}
Esempio n. 2
0
/*
* pgpool main program
*/
int main(int argc, char **argv)
{
	int opt;
	int i;
	int pid;
	int size;
	int retrycnt;
	int sys_retrycnt;

	myargc = argc;
	myargv = argv;

	snprintf(conf_file, sizeof(conf_file), "%s/%s", DEFAULT_CONFIGDIR, POOL_CONF_FILE_NAME);
	snprintf(pcp_conf_file, sizeof(pcp_conf_file), "%s/%s", DEFAULT_CONFIGDIR, PCP_PASSWD_FILE_NAME);
	snprintf(hba_file, sizeof(hba_file), "%s/%s", DEFAULT_CONFIGDIR, HBA_CONF_FILE_NAME);

	while ((opt = getopt(argc, argv, "a:cdf:F:hm:nv")) != -1)
	{
		switch (opt)
		{
			case 'a':    /* specify hba configuration file */
				if (!optarg)
				{
					usage();
					exit(1);
				}
				strncpy(hba_file, optarg, sizeof(hba_file));
				break;

			case 'c':			/* clear cache option */
				clear_cache = 1;
				break;

			case 'd':	/* debug option */
				debug = 1;
				break;

			case 'f':	/* specify configuration file */
				if (!optarg)
				{
					usage();
					exit(1);
				}
				strncpy(conf_file, optarg, sizeof(conf_file));
				break;

			case 'F':   /* specify PCP password file */
				if (!optarg)
				{
					usage();
					exit(1);
				}
				strncpy(pcp_conf_file, optarg, sizeof(pcp_conf_file));
				break;

			case 'h':
				usage();
				exit(0);
				break;

			case 'm':	/* stop mode */
				if (!optarg)
				{
					usage();
					exit(1);
				}
				if (*optarg == 's' || !strcmp("smart", optarg))
					stop_sig = SIGTERM;		/* smart shutdown */
				else if (*optarg == 'f' || !strcmp("fast", optarg))
					stop_sig = SIGINT;		/* fast shutdown */
				else if (*optarg == 'i' || !strcmp("immediate", optarg))
					stop_sig = SIGQUIT;		/* immediate shutdown */
				else
				{
					usage();
					exit(1);
				}
				break;

			case 'n':	/* no detaching control ttys */
				not_detach = 1;
				break;

			case 'v':
				show_version();
				exit(0);

			default:
				usage();
				exit(1);
		}
	}

	mypid = getpid();

	if (pool_init_config())
		exit(1);

	if (pool_get_config(conf_file, INIT_CONFIG))
	{
		pool_error("Unable to get configuration. Exiting...");
		exit(1);
	}

	if (pool_config->enable_pool_hba)
		load_hba(hba_file);

	/*
	 * If a non-switch argument remains, then it should be either "reload" or "stop".
	 */
	if (optind == (argc - 1))
	{
		if (!strcmp(argv[optind], "reload"))
		{
				pid_t pid;

				pid = read_pid_file();
				if (pid < 0)
				{
					pool_error("could not read pid file");
					pool_shmem_exit(1);
					exit(1);
				}

				if (kill(pid, SIGHUP) == -1)
				{
					pool_error("could not reload configuration file pid: %d. reason: %s", pid, strerror(errno));
					pool_shmem_exit(1);
					exit(1);
				}
				pool_shmem_exit(0);
				exit(0);
		}
		if (!strcmp(argv[optind], "stop"))
		{
			stop_me();
			pool_shmem_exit(0);
			exit(0);
		}
		else
		{
			usage();
			pool_shmem_exit(1);
			exit(1);
		}
	}
	/*
	 * else if no non-switch argument remains, then it should be a start request
	 */
	else if (optind == argc)
	{
		pid = read_pid_file();
		if (pid > 0)
		{
			if (kill(pid, 0) == 0)
			{
				fprintf(stderr, "pid file found. is another pgpool(%d) is running?\n", pid);
				exit(1);
			}
			else
				fprintf(stderr, "pid file found but it seems bogus. Trying to start pgpool anyway...\n");
		}
	}
	/*
	 * otherwise an error...
	 */
	else
	{
		usage();
		exit(1);
	}

	/* set signal masks */
	poolinitmask();

	if (not_detach)
		write_pid_file();
	else
		daemonize();

	if (pool_semaphore_create(MAX_NUM_SEMAPHORES))
	{
		pool_error("Unable to create semaphores. Exiting...");
		pool_shmem_exit(1);
		exit(1);
	}

	/*
	 * Restore previous backend status if possible
	 */
	read_status_file();

	/* clear cache */
	if (clear_cache && pool_config->enable_query_cache && SYSDB_STATUS == CON_UP)
	{
		Interval interval[1];

		interval[0].quantity = 0;
		interval[0].unit = second;

		pool_clear_cache_by_time(interval, 1);
	}

	/* set unix domain socket path */
	snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/.s.PGSQL.%d",
			 pool_config->socket_dir,
			 pool_config->port);

	/* set up signal handlers */
	pool_signal(SIGPIPE, SIG_IGN);

	/* create unix domain socket */
	unix_fd = create_unix_domain_socket(un_addr);

	/* create inet domain socket if any */
	if (pool_config->listen_addresses[0])
	{
		inet_fd = create_inet_domain_socket(pool_config->listen_addresses, pool_config->port);
	}

	size = pool_config->num_init_children * pool_config->max_pool * sizeof(ConnectionInfo);
	con_info = pool_shared_memory_create(size);
	if (con_info == NULL)
	{
		pool_error("failed to allocate connection informations");
		myexit(1);
	}
	memset(con_info, 0, size);

	size = pool_config->num_init_children * (sizeof(ProcessInfo));
	pids = pool_shared_memory_create(size);
	if (pids == NULL)
	{
		pool_error("failed to allocate pids");
		myexit(1);
	}
	memset(pids, 0, size);
	for (i = 0; i < pool_config->num_init_children; i++)
	{
		pids[i].connection_info = &con_info[i * pool_config->max_pool];
	}

	/* create fail over/switch over event area */
	Req_info = pool_shared_memory_create(sizeof(POOL_REQUEST_INFO));
	if (Req_info == NULL)
	{
		pool_error("failed to allocate Req_info");
		myexit(1);
	}

	/* initialize Req_info */
	Req_info->kind = NODE_UP_REQUEST;
	memset(Req_info->node_id, -1, sizeof(int) * MAX_NUM_BACKENDS);
	Req_info->master_node_id = get_next_master_node();
	Req_info->conn_counter = 0;

	InRecovery = pool_shared_memory_create(sizeof(int));
	if (InRecovery == NULL)
	{
		pool_error("failed to allocate InRecovery");
		myexit(1);
	}
	*InRecovery = 0;

	/*
	 * We need to block signal here. Otherwise child might send some
	 * signals, for example SIGUSR1(fail over).  Children will inherit
	 * signal blocking but they do unblock signals at the very beginning
	 * of process.  So this is harmless.
	 */
	POOL_SETMASK(&BlockSig);

	/* fork the children */
	for (i=0;i<pool_config->num_init_children;i++)
	{
		pids[i].pid = fork_a_child(unix_fd, inet_fd, i);
		pids[i].start_time = time(NULL);
	}

	/* set up signal handlers */

	pool_signal(SIGTERM, exit_handler);
	pool_signal(SIGINT, exit_handler);
	pool_signal(SIGQUIT, exit_handler);
	pool_signal(SIGCHLD, reap_handler);
	pool_signal(SIGUSR1, failover_handler);
	pool_signal(SIGUSR2, wakeup_handler);
	pool_signal(SIGHUP, reload_config_handler);

	/* create pipe for delivering event */
	if (pipe(pipe_fds) < 0)
	{
		pool_error("failed to create pipe");
		myexit(1);
	}

	pool_log("pgpool successfully started");

	/* fork a child for PCP handling */
	snprintf(pcp_un_addr.sun_path, sizeof(pcp_un_addr.sun_path), "%s/.s.PGSQL.%d",
			 pool_config->pcp_socket_dir,
			 pool_config->pcp_port);
	pcp_unix_fd = create_unix_domain_socket(pcp_un_addr);
    /* maybe change "*" to pool_config->pcp_listen_addresses */
	pcp_inet_fd = create_inet_domain_socket("*", pool_config->pcp_port);
	pcp_pid = pcp_fork_a_child(pcp_unix_fd, pcp_inet_fd, pcp_conf_file);

	retrycnt = 0;		/* reset health check retry counter */
	sys_retrycnt = 0;	/* reset SystemDB health check retry counter */

	/*
	 * This is the main loop
	 */
	for (;;)
	{
		CHECK_REQUEST;

		/* do we need health checking for PostgreSQL? */
		if (pool_config->health_check_period > 0)
		{
			int sts;
			int sys_sts = 0;
			unsigned int sleep_time;

			if (retrycnt == 0)
			{
				pool_debug("starting health checking");
			}
			else
			{
				pool_debug("retrying %d th health checking", retrycnt);
			}

			if (pool_config->health_check_timeout > 0)
			{
				/*
				 * set health checker timeout. we want to detect
				 * communication path failure much earlier before
				 * TCP/IP stack detects it.
				 */
				pool_signal(SIGALRM, health_check_timer_handler);
				alarm(pool_config->health_check_timeout);
			}

			/*
			 * do actual health check. trying to connect to the backend
			 */
			errno = 0;
			health_check_timer_expired = 0;
			POOL_SETMASK(&UnBlockSig);
			sts = health_check();
			POOL_SETMASK(&BlockSig);
			if (pool_config->parallel_mode || pool_config->enable_query_cache)
				sys_sts = system_db_health_check();

			if ((sts > 0 || sys_sts < 0) && (errno != EINTR || (errno == EINTR && health_check_timer_expired)))
			{
				if (sts > 0)
				{
					sts--;

					if (!pool_config->parallel_mode)
					{
						pool_log("set %d th backend down status", sts);
						Req_info->kind = NODE_DOWN_REQUEST;
						Req_info->node_id[0] = sts;
						failover();
						/* need to distribute this info to children */
					}
					else
					{
						retrycnt++;
						pool_signal(SIGALRM, SIG_IGN);	/* Cancel timer */

						if (retrycnt > NUM_BACKENDS)
						{
							/* retry count over */
							pool_log("set %d th backend down status", sts);
							Req_info->kind = NODE_DOWN_REQUEST;
							Req_info->node_id[0] = sts;
							failover();
							retrycnt = 0;
						}
						else
						{
							/* continue to retry */
							sleep_time = pool_config->health_check_period/NUM_BACKENDS;
							pool_debug("retry sleep time: %d seconds", sleep_time);
							pool_sleep(sleep_time);
							continue;
						}
					}
				}
				if (sys_sts < 0)
				{
					sys_retrycnt++;
					pool_signal(SIGALRM, SIG_IGN);

					if (sys_retrycnt > NUM_BACKENDS)
					{
						pool_log("set SystemDB down status");
						SYSDB_STATUS = CON_DOWN;
						sys_retrycnt = 0;
					}
					else if (sts == 0) /* goes to sleep only when SystemDB alone was down */
					{
						sleep_time = pool_config->health_check_period/NUM_BACKENDS;
						pool_debug("retry sleep time: %d seconds", sleep_time);
						pool_sleep(sleep_time);
						continue;
					}
				}
			}

			if (pool_config->health_check_timeout > 0)
			{
				/* seems ok. cancel health check timer */
				pool_signal(SIGALRM, SIG_IGN);
			}

			sleep_time = pool_config->health_check_period;
			pool_sleep(sleep_time);
		}
		else
		{
			for (;;)
			{
				int r;
				struct timeval t = {3, 0};

				POOL_SETMASK(&UnBlockSig);
				r = pool_pause(&t);
				POOL_SETMASK(&BlockSig);
				if (r > 0)
					break;
			}
		}
	}

	pool_shmem_exit(0);
}