예제 #1
0
파일: shd-process.c 프로젝트: Javex/shadow
void process_stop(Process* proc) {
    MAGIC_ASSERT(proc);

    /* we only have state if we are running */
    if(process_isRunning(proc)) {
        info("stopping '%s' process", g_quark_to_string(proc->programID));
        program_swapInState(proc->prog, proc->state);

        thread_execute(proc->mainThread, program_getFreeFunc(proc->prog));

        debug("calling atexit for '%s' process", g_quark_to_string(proc->programID));

        while(proc->atExitFunctions && g_queue_get_length(proc->atExitFunctions) > 0) {
            ProcessExitCallbackData* exitCallback = g_queue_pop_head(proc->atExitFunctions);
            if(exitCallback->passArgument) {
                thread_executeExitCallback(proc->mainThread, exitCallback->callback, exitCallback->argument);
            } else {
                thread_execute(proc->mainThread, (PluginNotifyFunc)exitCallback->callback);
            }
            g_free(exitCallback);
        }

        program_swapOutState(proc->prog, proc->state);

        /* free our copy of plug-in resources, and other application state */
        program_freeState(proc->prog, proc->state);
        proc->state = NULL;

        thread_stop(proc->mainThread);
        thread_unref(proc->mainThread);
        proc->mainThread = NULL;
    }
}
예제 #2
0
/**
 * @fn eigrp_update_send_GR_thread
 *
 * @param[in]		thread		contains neighbor who would receive Graceful restart
 *
 * @return int      always 0
 *
 * @par
 * Function used for sending Graceful restart Update packet
 * in thread, it is prepared for multiple chunks of packet.
 *
 * Uses nbr_gr_packet_type and t_nbr_send_gr from neighbor.
 */
int
eigrp_update_send_GR_thread(struct thread *thread)
{
	struct eigrp_neighbor *nbr;

	/* get argument from thread */
	nbr = THREAD_ARG(thread);
	/* remove this thread pointer */
	nbr->t_nbr_send_gr = NULL;

	/* if there is packet waiting in queue,
	 * schedule this thread again with small delay */
	if(nbr->retrans_queue->count > 0)
	{
		nbr->t_nbr_send_gr = thread_add_timer_msec(master, eigrp_update_send_GR_thread, nbr, 10);
		return 0;
	}

	/* send GR EIGRP packet chunk */
	eigrp_update_send_GR_part(nbr);

	/* if it wasn't last chunk, schedule this thread again */
	if(nbr->nbr_gr_packet_type != EIGRP_PACKET_PART_LAST)
		nbr->t_nbr_send_gr = thread_execute(master, eigrp_update_send_GR_thread, nbr, 0);

	return 0;
}
예제 #3
0
int ff_slice_thread_execute_with_mainfunc(AVCodecContext *avctx, action_func2* func2, main_func *mainfunc, void *arg, int *ret, int job_count)
{
    SliceThreadContext *c = avctx->internal->thread_ctx;
    c->func2 = func2;
    c->mainfunc = mainfunc;
    return thread_execute(avctx, NULL, arg, ret, job_count, 0);
}
예제 #4
0
파일: shd-process.c 프로젝트: Javex/shadow
void process_notify(Process* proc, Thread* thread) {
    MAGIC_ASSERT(proc);

    /* only notify if we are running */
    if(process_isRunning(proc)) {
        program_swapInState(proc->prog, proc->state);
        thread_execute(thread, program_getNotifyFunc(proc->prog));
        program_swapOutState(proc->prog, proc->state);
    }
}
예제 #5
0
void thread_list_execute (struct thread_master *master, struct thread_list *list)
{
  struct thread *thread;

  thread = thread_trim_head (list);
  if (thread != NULL)
    {
      thread_execute (master, thread->func, thread->arg, thread->u.val);
      thread->type = THREAD_UNUSED;
      thread_add_unuse (master, thread);
    }
}
예제 #6
0
/**
 * @fn eigrp_update_send_GR
 *
 * @param[in]		nbr			Neighbor who would receive Graceful restart
 * @param[in]		gr_type 	Who executed Graceful restart
 * @param[in]		vty 		Virtual terminal for log output
 *
 * @return void
 *
 * @par
 * Function used for sending Graceful restart Update packet:
 * Creates Update packet with INIT, RS, EOT flags and include
 * all route except those filtered
 */
void
eigrp_update_send_GR (struct eigrp_neighbor *nbr, enum GR_type gr_type, struct vty *vty)
{
	struct eigrp_prefix_entry *pe2;
	struct listnode *node2, *nnode2;
	struct list *prefixes;

	if(gr_type == EIGRP_GR_FILTER)
	{
		/* function was called after applying filtration */
		zlog_info("Neighbor %s (%s) is resync: route configuration changed",
				  inet_ntoa(nbr->src), ifindex2ifname(nbr->ei->ifp->ifindex));
	}
	else if(gr_type == EIGRP_GR_MANUAL)
	{
		/* Graceful restart was called manually */
		zlog_info("Neighbor %s (%s) is resync: manually cleared",
				  inet_ntoa(nbr->src), ifindex2ifname(nbr->ei->ifp->ifindex));

		if(vty != NULL)
		{
			vty_time_print (vty, 0);
			vty_out (vty, "Neighbor %s (%s) is resync: manually cleared%s",
					inet_ntoa (nbr->src),
					ifindex2ifname (nbr->ei->ifp->ifindex),
					VTY_NEWLINE);
		}
	}

	prefixes = list_new();
	/* add all prefixes from topology table to list */
	for (ALL_LIST_ELEMENTS(nbr->ei->eigrp->topology_table, node2, nnode2, pe2))
	{
		listnode_add(prefixes, pe2);
	}

	/* save prefixes to neighbor */
	nbr->nbr_gr_prefixes_send = prefixes;
	/* indicate, that this is first GR Update packet chunk */
	nbr->nbr_gr_packet_type = EIGRP_PACKET_PART_FIRST;
	/* execute packet sending in thread */
	nbr->t_nbr_send_gr = thread_execute(master, eigrp_update_send_GR_thread, nbr, 0);
}
예제 #7
0
void
ospf6_interface_if_del (struct interface *ifp)
{
  struct ospf6_interface *oi;

  oi = (struct ospf6_interface *) ifp->info;
  if (oi == NULL)
    return;

  /* interface stop */
  if (oi->area)
    thread_execute (master, interface_down, oi, 0);

  listnode_delete (oi->area->if_list, oi);
  oi->area = (struct ospf6_area *) NULL;

  /* cut link */
  oi->interface = NULL;
  ifp->info = NULL;

  ospf6_interface_delete (oi);
}
예제 #8
0
static int thread_execute2(AVCodecContext *avctx, action_func2* func2, void *arg, int *ret, int job_count)
{
    SliceThreadContext *c = avctx->internal->thread_ctx;
    c->func2 = func2;
    return thread_execute(avctx, NULL, arg, ret, job_count, 0);
}