自学教程：C++ send_signal函数代码示例

void mu_signal_process(char *command, int signal){	boolean_t	pid_present, name_present;	int4		pid, length, status, item, outv;	char		prc_nam[20];	unsigned short	name_len;	$DESCRIPTOR(d_prc_nam,"");	memset(prc_nam, 0, SIZEOF(prc_nam));	pid_present = name_present = FALSE;	if (cli_present("id") == CLI_PRESENT)	{		if(!cli_get_hex("id", &pid))			return;		pid_present = TRUE;	}	if (cli_present("name") == CLI_PRESENT)	{		name_len = 20;		if (!cli_get_str("name", prc_nam, &name_len))			return;		if (prc_nam[name_len-1] == '"')			name_len--;		if (prc_nam[0] == '"')		{			d_prc_nam.dsc$a_pointer = &prc_nam[1];			name_len--;		} else			d_prc_nam.dsc$a_pointer = &prc_nam;		d_prc_nam.dsc$w_length = name_len;		name_present = TRUE;	}	if (!name_present)	{		if (SS$_NORMAL == send_signal(pid, signal))			SENDMSG_OUTPUT("", pid);		return;	}	item = JPI$_PID;	status = lib$getjpi(&item, 0, &d_prc_nam, &outv, 0, 0);	if (SS$_NORMAL != status)	{		rts_error(VARLSTCNT(1) status);		return;	}	if (!pid_present)	{		if (SS$_NORMAL == send_signal(outv, signal))			SENDMSG_OUTPUT(&prc_nam, outv);		return;	}	if (outv != pid)	{		util_out_print("ID !XL and NAME !AD are not the same process", FLUSH, pid, LEN_AND_STR(&prc_nam));		return;	}	if (SS$_NORMAL == send_signal(pid, signal))		SENDMSG_OUTPUT(&prc_nam, pid);	return;}

void send_signals() {    printf("Sending %d SIGRTMIN signals to catcher.../n", signal_num);    for (int i = 0; i < signal_num; i++)        send_signal(catcher_pid, SIGRTMIN);    printf("Sending SIGRTMIN+1 to catcher.../n");    send_signal(catcher_pid, SIGRTMIN + 1);}

void send_signals(int signal_num, pid_t sender_pid) {    sigusr1_received = 0;    for (int i = 0; i < signal_num; i++) {        send_signal(sender_pid, SIGUSR1);        while (!sigusr1_received);        sigusr1_received = 0;    }    send_signal(sender_pid, SIGUSR2);}

void pacemaker_avi(void const *i) {    volatile static int state = IdleAVI;    while(1) {        switch(state) {        case IdleAVI: {            ////////pc.printf("/nIdleAVI");            osEvent evt = Thread::signal_wait(0);            Thread::wait(1);            if(evt.value.signals & Apace || evt.value.signals & Asense) {                //////////pc.printf("/nAP/AS");                x_clock.reset();                state = AVI;            }            break;        }        case AVI: {            osEvent evt;            evt = Thread::signal_wait(Vsense, t_avi - x_clock.read_ms());            Thread::wait(1);            if(evt.value.signals & Vsense) {                state = IdleAVI;            }            else if(x_clock.read_ms() >= t_avi && clk_clock.read_ms() >= t_uri) {                pc.printf("/nAVI Vpace%i:", test_clock.read_ms());                send_signal(Vpace);                state = IdleAVI;            }            else if(x_clock.read_ms() >= t_avi && clk_clock.read_ms() < t_uri) {                state = WaitURI;            }            break;        }        case WaitURI: {            ////////pc.printf("/nWaitURI");            osEvent evt = Thread::signal_wait(Vsense, t_uri - clk_clock.read_ms() );            Thread::wait(1);            if(evt.value.signals & Vsense) {                state = IdleAVI;            }            else if(clk_clock.read_ms() >= t_uri  ) {                send_signal(Vpace);                pc.printf("/nAVI Vpace%i:", test_clock.read_ms());                state = IdleAVI;            }            break;        }        default: {            state = IdleAVI;        }        }    }}

int main(int argc, char *argv[]){    int client_flag, server_cmd;    if (!connect_server())    {        qDebug() << "Not connected control server!";        return 1;    }    else    {        qDebug() << "Connected to control server!";    }    if (!connect_psdb())    {        qDebug() << "Not connected parameter server database!";        return 1;    }    else    {        qDebug() << "Connected to parameter server database!";    }    while (1)    {        server_cmd = request_cmd();        switch (server_cmd)        {            case cmd_work:                client_flag = execute_evo_motor();                break;            case cmd_term:                qDebug() << "cmd_exit";                break;            default:                qDebug() << "error exit";                break;        }        switch (client_flag)        {            case flag_success:                send_signal(flag_success);                break;            case flag_failure:            default:                qDebug() << "flag_failure";                send_signal(flag_failure);                break;        }    }    return 0;}

uint8 i2c_ReadByte(uint8 SlaveAddress,uint8 AccessAddress,uint8 *Data){    I2C0_C1     |= 0x10;           //TX = 1,MCU设置为发送模式    send_signal('S');               //发送开始信号     I2C0_D  = SlaveAddress & 0xfe;   //发送设备地址,并通知从机接收数据               if(i2c_wait('T'))                  //等待一个字节数据传送完成      {              return 1;                         //没有传送成功,读一个字节失败       }    if (i2c_wait('A'))                 //等待从机应答信号     {        return 1;                         //没有等到应答信号,读一个字节失败     }    I2C0_D  = AccessAddress;        //发送访问地址        if (i2c_wait('T'))                //等待一个字节数据传送完成     {        return 1;                        //没有传送成功,读一个字节失败    }    if (i2c_wait('A'))                //等待从机应答信号       {         return 1;                        //没有等到应答信号,读一个字节失败      }        pause();    I2C0_C1 |= 0x04;//当MCU在主机模 式下，向该位写1将产生一个重新开始信号      I2C0_D = SlaveAddress | 0x01; //通知从机改为发送数据        if (i2c_wait('T'))               //等待一个字节数据传送完成      {        return 1;                       //没有传送成功,读一个字节失败     }    if (i2c_wait('A'))               //等待从机应答信号      {        return 1;                      //没有等到应答信号,读一个字节失败    }    I2C0_C1 &= 0xef;           //TX = 0,MCU设置为接收模式        *Data = I2C0_D;            //读出IIC1D,准备接收数据       if (i2c_wait('T'))              //等待一个字节数据传送完成      {          return 1;                      //没有传送成功,读一个字节失败      }    send_signal('O');           //发送停止信号        *Data = I2C0_D;            //读出接收到的一个数据                  pause();        return 0;                          //正确接收到一个字节数据 }

static void ep_ready(int txid, int status) {    struct transaction_data *data = NULL;    if (txid == 0)        return;    /* find the correct transaction data structure */    data = ep_get_transaction(txid);    if (data) {#if 0        printf("libep: decreasing data '%p' reference count from '%u' to '%u'/n",                data, data->refcount, data->refcount - 1);#endif        data->refcount--;        if ((data->refcount == 0 && data->ready) || !status) {            /* all callbacks have returned true or one has failed */            send_signal(txid, status);            ep_list_remove(&transaction_list, data);            free(data);            data = NULL;        }    }    return;}

intsock_send_signal(int purpose,int  sig){  if (accept_if_needed(purpose) != -1)    return send_signal(purpose_table[purpose], sig);  return -1;}

void pacemaker_vrp(void const *i) {    volatile static int state = IdleVRP;    while(1) {        switch(state) {        case IdleVRP: {            //pc.printf("/nIdleVRP%i",test_clock.read_ms());            osEvent evt = Thread::signal_wait(0);            Thread::wait(1);            if(evt.value.signals & Vsignal) {                pc.printf("/n Vsignal Rec");                send_signal(Vsense);                x_clock.reset();                state = VRP;            }            else if(evt.value.signals & Vpace) {                x_clock.reset();                state = VRP;            }            break;        }        case VRP: {            if( x_clock.read_ms() < t_vrp) {                Thread::wait(t_vrp - x_clock.read_ms());            }            else if( x_clock.read_ms() >= t_vrp) {                state = IdleVRP;            }            break;        }        default: {            state = IdleVRP;        }        }    }}

void original_getinfo(){    passnumber=1;    send_signal();    sleep(3);    passnumber=0;}

static voidps7500_update_intr (void *mach){	struct machine_config *mc = (struct machine_config *) mach;	void *state = (void *) mc->state;#if 0        state->NfiqSig = (io.fiq[FIQ] & io.fiqmask[FIQ]) ? LOW : HIGH;        state->NirqSig =                ((io.irq[IRQA] & io.irqmask[IRQA]) ||                 (io.irq[IRQB] & io.irqmask[IRQB]) ||                 (io.irq[IRQC] & io.irqmask[IRQC]) ||                 (io.irq[IRQD] & io.irqmask[IRQD]) ||                 (io.irq[IRQDMA] & io.irqmask[IRQDMA])) ? LOW : HIGH;#endif	interrupt_signal_t interrupt_signal;	interrupt_signal.arm_signal.reset = Prev_level;	interrupt_signal.arm_signal.firq = (io.fiq[FIQ] & io.fiqmask[FIQ]) ? Low_level : High_level;	interrupt_signal.arm_signal.irq =		((io.irq[IRQA] & io.irqmask[IRQA]) ||                 (io.irq[IRQB] & io.irqmask[IRQB]) ||                 (io.irq[IRQC] & io.irqmask[IRQC]) ||                 (io.irq[IRQD] & io.irqmask[IRQD]) ||                 (io.irq[IRQDMA] & io.irqmask[IRQDMA])) ? Low_level : High_level;	send_signal(&interrupt_signal);}

static void ps7500_update_int(void *state){	int i;	//if (io.irq[IRQB] & io.net_int[IRQB]) {	//	printf("Network interrupt set/n");	//	for (i=0; i < 5; i++) {	//		printf("IRQ[%d] %02x IRQMASK[%d] %02x/n",	//			i, io.irq[i], i, io.irqmask[i]);	//	}	//}#if 0	state->NfiqSig = (io.fiq[FIQ] & io.fiqmask[FIQ]) ? LOW : HIGH;	state->NirqSig =		((io.irq[IRQA] & io.irqmask[IRQA]) ||		 (io.irq[IRQB] & io.irqmask[IRQB]) ||		 (io.irq[IRQC] & io.irqmask[IRQC]) ||		 (io.irq[IRQD] & io.irqmask[IRQD]) ||		 (io.irq[IRQDMA] & io.irqmask[IRQDMA])) ? LOW : HIGH;#endif	interrupt_signal_t interrupt_signal;	interrupt_signal.arm_signal.reset = Prev_level;	interrupt_signal.arm_signal.firq = (io.fiq[FIQ] & io.fiqmask[FIQ]) ? Low_level : High_level;	interrupt_signal.arm_signal.irq =		((io.irq[IRQA] & io.irqmask[IRQA]) ||		 (io.irq[IRQB] & io.irqmask[IRQB]) ||		 (io.irq[IRQC] & io.irqmask[IRQC]) ||		 (io.irq[IRQD] & io.irqmask[IRQD]) ||                 (io.irq[IRQDMA] & io.irqmask[IRQDMA])) ? Low_level : High_level;	send_signal(&interrupt_signal);}

void child_main() {	// Ignore control-C in child	setup_signal_handling(SIGINT, SIG_IGN);	// Create the message queue	msg_queue_id = msgget(MESSAGE_QUEUE_KEY, 0666 | IPC_CREAT);		if (msg_queue_id == -1) {		// Invalid message queue		dump("Failed to open/create controller queue.");		send_signal(SIGTERM, true);		return;	}		while(running) {		child_loop();	}		// Delete the message queue	dump("Removing message queue");	if (-1 == msgctl(msg_queue_id, IPC_RMID, 0)) {		dump("Failed to delete message queue");	}		dump("Finished");}

static voidomap5912_update_int (void *state){	//uart1 and os timer int is mapped to l2 int        uint32_t requests;	//printf("irq sig initial: %x/n", state->NirqSig);	omap5912_update_l2_int(state);	//printf(" here test  mpu1_itr data = %x/n", omap5912_io.ic.mpu_l1_itr);	requests = omap5912_io.ic.mpu_l1_itr & ((~omap5912_io.ic.mpu_l1_mir) & 0xffffffff);	//printf("requests %x/n",requests);#if 0	state->NirqSig = (requests) ? LOW : HIGH;	state->NfiqSig = HIGH;#endif	interrupt_signal_t interrupt_signal;	interrupt_signal.arm_signal.firq = High_level;	interrupt_signal.arm_signal.reset = Prev_level;	interrupt_signal.arm_signal.irq = (requests) ? Low_level : High_level;	send_signal(&interrupt_signal);	//printf("irq sig in l1:%x/n", state->NirqSig);}

void sys_raise(struct cpu_state **cpu){    unsigned int sig = (*cpu)->CPU_ARG1;    send_signal(current_thread->process, sig);    (*cpu)->CPU_ARG0 = 0;}

uint32_t write_pipe(fs_node_t *node, uint32_t offset, uint32_t size, uint8_t *buffer) {	assert(node->device != 0 && "Attempted to write to a fully-closed pipe.");	/* Retreive the pipe object associated with this file node */	pipe_device_t * pipe = (pipe_device_t *)node->device;#if DEBUG_PIPES	if (pipe->size > 300) { /* Ignore small pipes (ie, keyboard) */		debug_print(INFO, "[debug] Call to write to pipe 0x%x", node->device);		debug_print(INFO, "        Available space: %d", pipe_available(pipe));		debug_print(INFO, "        Total size:      %d", pipe->size);		debug_print(INFO, "        Request size:    %d", size);		debug_print(INFO, "        Write pointer:   %d", pipe->write_ptr);		debug_print(INFO, "        Read  pointer:   %d", pipe->read_ptr);		debug_print(INFO, "        Buffer address:  0x%x", pipe->buffer);		debug_print(INFO, " Write: %s", buffer);	}#endif	if (pipe->dead) {		debug_print(WARNING, "Pipe is dead?");		send_signal(getpid(), SIGPIPE);		return 0;	}	size_t written = 0;	while (written < size) {		spin_lock(pipe->lock_write);#if 0		size_t available = 0;		if (pipe->read_ptr <= pipe->write_ptr) {			available = pipe->size - pipe->write_ptr;		} else {			available = pipe->read_ptr - pipe->write_ptr - 1;		}		if (available) {			available = min(available, size - written);			memcpy(&pipe->buffer[pipe->write_ptr], buffer, available);			pipe_increment_write_by(pipe, available);			written += available;		}#else		while (pipe_available(pipe) > 0 && written < size) {			pipe->buffer[pipe->write_ptr] = buffer[written];			pipe_increment_write(pipe);			written++;		}#endif		spin_unlock(pipe->lock_write);		wakeup_queue(pipe->wait_queue_readers);		pipe_alert_waiters(pipe);		if (written < size) {			sleep_on(pipe->wait_queue_writers);		}	}	return written;}

/* * --------------------------------------------------------------------------- *  unifi_send_signal * *    Invokes send_signal() to queue a signal in the command or traffic queue *    If sigptr pointer is NULL, it pokes the bh to check if UniFi is responsive. * *  Arguments: *      card        Pointer to card context struct *      sigptr      Pointer to signal from card. *      siglen      Size of the signal *      bulkdata    Pointer to the bulk data of the signal * *  Returns: *      CSR_RESULT_SUCCESS on success *      CSR_WIFI_HIP_RESULT_NO_SPACE if there were insufficient data slots or no free signal queue entry * *  Notes: *      unifi_send_signal() is used to queue signals, created by the driver, *      to the device. Signals are constructed using the UniFi packed structures. * --------------------------------------------------------------------------- */CsrResult unifi_send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 siglen,                            const bulk_data_param_t *bulkdata){    q_t *sig_soft_q;    CsrUint16 signal_id;    CsrResult r;    CsrUint32 run_bh;    CsrUint32 priority_q;    /* A NULL signal pointer is a request to check if UniFi is responsive */    if (sigptr == NULL)    {        card->bh_reason_host = 1;        return unifi_run_bh(card->ospriv);    }    priority_q = 0;    run_bh = 1;    signal_id = GET_SIGNAL_ID(sigptr);    /*     * If the signal is a CSR_MA_PACKET_REQUEST ,     * we send it using the traffic soft queue. Else we use the command soft queue.     */    if (signal_id == CSR_MA_PACKET_REQUEST_ID)    {        CsrUint16 frame_priority;        if (card->periodic_wake_mode == UNIFI_PERIODIC_WAKE_HOST_ENABLED)        {            run_bh = 0;        }#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)        unifi_debug_log_to_buf("D");#endif        /* Sanity check: MA-PACKET.req must have a valid bulk data */        if ((bulkdata->d[0].data_length == 0) || (bulkdata->d[0].os_data_ptr == NULL))        {            unifi_error(card->ospriv, "MA-PACKET.req with empty bulk data (%d bytes in %p)/n",                        bulkdata->d[0].data_length, bulkdata->d[0].os_data_ptr);            dump((void *)sigptr, siglen);            return CSR_RESULT_FAILURE;        }        /* Map the frame priority to a traffic queue index. */        frame_priority = GET_PACKED_MA_PACKET_REQUEST_FRAME_PRIORITY(sigptr);        priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY)frame_priority);        sig_soft_q = &card->fh_traffic_queue[priority_q];    }    else    {        sig_soft_q = &card->fh_command_queue;    }    r = send_signal(card, sigptr, siglen, bulkdata, sig_soft_q, priority_q, run_bh);    /* On error, the caller must free or requeue bulkdata buffers */    return r;} /* unifi_send_signal() */

void parent_loop() {	// Wait to get instruction from controller	dump("Waiting for instruction from controller");	int monitor_fifo_fd = open(monitor_fifo_name, O_RDONLY);	if (-1 == monitor_fifo_fd) {		unlink(monitor_fifo_name);		if (EINTR != errno) {			dump("Failed to open monitor fifo with error: %d", errno);		}		return;	}		// Read the response	fifo_data fdata;	if (-1 == read(monitor_fifo_fd, &fdata, sizeof(fdata))) {		unlink(monitor_fifo_name);		if (EINTR != errno) {			dump("Failed to read monitor fifo with error: %d", errno);		}		return;	}		// Check if we got the go ahead	switch(fdata.request_type) {		case STOP:			dump("Received stop command from controller");			send_signal(SIGTERM, true);			return;		default:			dump("Invalid response received from controller");			return;	}}

/* This is called by the lower half when a break is received. */voidinput_break (){  struct queue **qp = termstate.c_lflag & ICANON ? &rawq : &inputq;  /* Don't do anything if IGNBRK is set. */  if (termstate.c_iflag & IGNBRK)    return;  /* If BRKINT is set, then flush queues and send SIGINT. */  if (termstate.c_iflag & BRKINT)    {      drop_output ();      /* XXX drop pending input How?? */      send_signal (SIGINT);      return;    }  /* A break is then read as a null byte; marked specially if PARMRK is set. */  if (termstate.c_iflag & PARMRK)    {      enqueue_quote (qp, CHAR_USER_QUOTE);      enqueue_quote (qp, '/0');    }  enqueue_quote (qp, '/0');}

int main (void) {    // enable pull up resistors    bset(PORTB, 1);    bset(PORTB, 2);    bset(PORTB, 3);    // burn some time to let inputs settle    __builtin_avr_delay_cycles(20);        // this is a really inefficent way to do it, but i had the I/Os    // and a free 4 position switch, so why not. simpler than binary input.        // to read, all pull ups are enabled, and each pin of the switch    // is connected to a seperate IO. the IO that is low is switch pos        uint16_t delay = 60; // assume position 1 by default    // could use uint8_t and save some code space    // divide each delay by 4, then then delay for 4000ms in the loop    if (!bisset(PINB,3)) // position 2        delay = 120;        if (!bisset(PINB,1)) // position 3        delay = 180;        if (!bisset(PINB,2)) // position 4        delay = 300;        PORTB = 0; // disable pull ups        // enable output    bset(DDRB, 0);        while(true) {        send_signal(); // begin bulb exposure                // this is wasteful of power, but i tried using the wdt        // to let me sleep 1s in power down state, and it turns        // out that the wdt oscilator is way off. better to busy        // wait and be about correct than way out in left field        for(uint16_t i = 0; i <= delay; i++)            _delay_ms(1000);                send_signal(); // terminate bulb exposure        _delay_ms(10000); // wait for camera to recover its wits    }}

void *get_data(){    sleep(1);    printf("get information/n");    send_signal();    sleep(2);    passnumber=0;    pthread_exit(0);}

intsend_wakeup(Sock *sock){#ifdef SIGUSR1  return send_signal(sock, SIGUSR1);#else  return -1;#endif}

int main(int argc, const char * argv[]) {    // insert code here...    int ret=send_signal(6561);    if(ret>0) std::cout<<"The process whose identifier is pid."<<std::endl;    else if (ret==0) std::cout<<"All processes in the same process group as the sender."<<std::endl;    else if (ret==-1) std::cout<<"If the process is privileged, send the signal to all processes except for some special system processes. Otherwise, send the signal to all processes with the same effective user ID."<<std::endl;    else std::cout<<"The process group whose identifier is -pid."<<std::endl;    return 0;}

intProcFamily::spree_cgroup(int sig){	// The general idea here is we freeze the cgroup, give the signal,	// then thaw everything out.  This way, signals are given in an atomic manner.	//	// Note that if the FREEZE call could be attempted, but not 100% completed, we	// proceed anyway.	bool use_freezer = !m_last_signal_was_sigstop;	m_last_signal_was_sigstop = sig == SIGSTOP ? true : false;	if (!use_freezer) {		dprintf(D_ALWAYS,			"Not using freezer controller to send signal; last "			"signal was SIGSTOP./n");	} else {		dprintf(D_FULLDEBUG,			"Using freezer controller to send signal to process family./n");	}	int err = use_freezer ? freezer_cgroup(FROZEN) : 0;	if ((err != 0) && (err != -EBUSY)) {		return err;	}	ASSERT (m_cgroup.isValid());	cgroup_get_cgroup(&const_cast<struct cgroup&>(m_cgroup.getCgroup()));	void **handle = (void **)malloc(sizeof(void*));	ASSERT (handle != NULL);	pid_t pid;	err = cgroup_get_task_begin(m_cgroup_string.c_str(), FREEZE_CONTROLLER_STR, handle, &pid);	if ((err > 0) && (err != ECGEOF))		handle = NULL;	while (err != ECGEOF) {		if (err > 0) {			dprintf(D_ALWAYS,				"Unable to iterate through cgroup %s (ProcFamily %u): %u %s/n",				m_cgroup_string.c_str(), m_root_pid, err, cgroup_strerror(err));			goto release;		}		send_signal(pid, sig);		err = cgroup_get_task_next(handle, &pid);	}	err = 0;	release:	if (handle != NULL) {		cgroup_get_task_end(handle);		free(handle);	}	if (use_freezer) freezer_cgroup(THAWED);	return err;}

void handle_signal(int sigtype) {	if (SIGINT == sigtype) {		dump("Received SIGINT signal");		running = false;				if (is_parent()) {			send_signal(SIGTERM, false);		}	} else if (SIGTERM == sigtype) {		dump("Received SIGTERM signal");		running = false;		if (is_parent()) {			send_signal(SIGTERM, false);		}	} else {		dump("Received unknown signal. Ignoring it");	}}

void RemoteDispatcher::run (){  if( !m_running && !m_pendingSignals.isEmpty() )  {    NLog::global()->add_message( QString("Executing %1 frame(s)")                                       .arg(m_pendingSignals.count()) );    m_nextIndex = 1;    m_running = true;    send_signal(0);  }}

/* * sigint_handler - The kernel sends a SIGINT to the shell whenver the *    user types ctrl-c at the keyboard.  Catch it and send it along *    to the foreground job. */void sigint_handler(int sig){    pid_t pid = fgpid(jobs);    int jid = pid2jid(pid);    if (pid != 0) {        printf("Jobs [%d] (%d) terminated by signal %d/n", jid, pid, sig);        deletejob(jobs, pid);        send_signal(-pid, sig);    }}

/* * sigtstp_handler - The kernel sends a SIGTSTP to the shell whenever *     the user types ctrl-z at the keyboard. Catch it and suspend the *     foreground job by sending it a SIGTSTP. */void sigtstp_handler(int sig){    pid_t pid = fgpid(jobs);    int jid = pid2jid(pid);    if (pid != 0) {        printf("Job [%d] (%d) stopped by signal %d/n", jid, pid, sig);        getjobpid(jobs, pid)->state = ST;        send_signal(-pid, sig);    }}

voidProcFamily::signal_root(int sig){#if !defined(WIN32)	if (m_proxy != NULL) {		glexec_kill(m_proxy, m_root_pid, sig);		return;	}#endif	send_signal(m_root_pid, sig);}

status_tExpanderThread::ResumeExternalExpander(){	thread_info info;	status_t status = get_thread_info(fThreadId, &info);	if (status == B_OK)		return send_signal(-fThreadId, SIGCONT);	else		return status;}