void * pi_a() {
int coid;
int rcvid;
char send[50] = "PI_A";
char receive[50];
int from;
int to;
double result;
int status = 0;
coid = ConnectAttach(0, pid, chid, 0, NULL);
checkresult(coid, "\nConnect Attach failed in PI_A: ");
printf("PI_A: connected to channel (Connect ID = %i) \n", coid);
while (status == 0){
status = MsgSend(coid, &send, sizeof(send), &from, sizeof(double));
status = MsgSend(coid, &send, sizeof(send), &to, sizeof(double));
k = 0, pi_old = 0, pi = 0;
for(k = from; k <= to;k++){
pi = pi_old + 4 * (pow(-1, k+1)) / (2*k -1);
pi_old = pi;
}
status = MsgSend(coid, &pi, sizeof(double), &receive, sizeof(receive));
}
return(NULL);
}//end pi
/** timeout callback, see doc on g_timeout_add()
* -- called until this returns FALSE when it will be removed */
gboolean tmo_callback(gpointer data) {
//printf("%s\n", (char*)data);
twmsg(__func__, (char*)data);
/* send msg to loop 1 and 2
* - ideally check to see who caused the tmo
*/
MsgSend(&loop_1, "TMO1");
MsgSend(&loop_2, "TMO2");
return TRUE;
}
// -------------------------------ReadMsg-----------------------------------------
void readMsg(int system, int sensor)
{
hiInputSet simUpperByte;
hiInputSet pportUpperByte;
// msgType => write
smsg.msgType = READ;
// command the simulator to return system status
MsgSend(coidsim,&smsg,sizeof(smsg),&rmsg,sizeof(rmsg));
// extract system status data
simUpperByte.hiInputSetByte = rmsg.rwdataMsg.upper_data;
// Send the status request to the PPORT, only need the lower byte data.
MsgSend(coidpport,&smsg,sizeof(smsg),&rmsg,sizeof(rmsg));
readLowerByte.lowInputSetByte = rmsg.rwdataMsg.lower_data;
pportUpperByte.hiInputSetByte = rmsg.rwdataMsg.upper_data;
// combine the sim and pport pulses
readUpperByte.loader_nEMPTY = pportUpperByte.loader_nEMPTY;
readUpperByte.unloader_nEMPTY = pportUpperByte.unloader_nEMPTY;
readUpperByte.baseLimit_nBL = simUpperByte.baseLimit_nBL;
readUpperByte.shoulderLimit_nBL = simUpperByte.shoulderLimit_nBL;
readUpperByte.elbowLimit_nBL = simUpperByte.elbowLimit_nBL;
readUpperByte.pitchLimit_nBL = simUpperByte.pitchLimit_nBL;
readUpperByte.rollLimit_nBL = simUpperByte.rollLimit_nBL;
readUpperByte.hiIpReserved7 = simUpperByte.hiIpReserved7;
// Check whether system status has changed and whether user wants to display it
if ((system == 1) && (memData.upperByte != readUpperByte.hiInputSetByte))
{
// display interpretation
if (readUpperByte.baseLimit_nBL == 1)
printf("base working outside limit!\n");
if (readUpperByte.shoulderLimit_nBL == 0)
printf("shoudler outside limit!\n");
if (readUpperByte.elbowLimit_nBL == 0)
printf("elbow outside its limit!\n");
if (readUpperByte.pitchLimit_nBL == 0)
printf("pitch outside its limit!\n");
if (readUpperByte.rollLimit_nBL == 0)
printf("roll outside its limit!\n");
if (readUpperByte.unloader_nEMPTY == 0)
printf("Unloader detect a block.\n");
if (readUpperByte.loader_nEMPTY == 1)
printf("loader outside its limit!\n");
// printf("\n");
flushall();
}
// Check whether user wants to see the sensor states and whether sensor states has changed
if ((sensor == 1) && ((system == 1))) //&& (memData.lowerByte != readLowerByte.lowInputSetByte)))
{
printf(" A2: %i\n B1: %i\n B4: %i\n C3: %i\n C2: %i\n C1: %i\n\n",readLowerByte.sensor_nA2,readLowerByte.sensor_nB1,readLowerByte.sensor_nB4,readLowerByte.sensor_nC3,readLowerByte.sensor_nC2,readLowerByte.sensor_nC1);
flushall();
}
}
int main(int argc, char *argv[]) {
int status;
struct MESSAGE msg; // буфер посылаемого сообщени¤
unsigned char rmsg; // Ѕуфер ответного сообщени¤
char command[10]; // Ѕуфер команд оператора
int coid;
coid=name_open("apu/roby",0);
printf("apu/roby has coid=%d\n\n", coid);
do {
printf("\n>");
scanf("%s", command);
switch (command[0]) {
case 'A': //Write port A
msg.type = 0;
sscanf(command + 1, "%X", &msg.buf);
status = MsgSend(coid, &msg, sizeof(msg), &rmsg, sizeof(rmsg));
printf("Write port A: message <0x%X>\n", msg.buf);
break;
case 'C': //Write port C
msg.type = 1;
sscanf(command + 1, "%X", &msg.buf);
status = MsgSend(coid, &msg, sizeof(msg), &rmsg, sizeof(rmsg));
printf("Write port C: message <0x%X>\n", msg.buf);
break;
case 'c': //Read port C
msg.type = 2;
status = MsgSend(coid, &msg, sizeof(msg), &rmsg, sizeof(rmsg));
printf("Port C: 0x%X\n", rmsg);
break;
case 'b': //Read port B
msg.type = 3;
status = MsgSend(coid, &msg, sizeof(msg), &rmsg, sizeof(rmsg));
printf("Port B: 0x%X\n", rmsg);
break;
case 'E':
return 0; //Return from main
default:
printf("Unknown command\n");
break;
}
} while (1);
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
int coid; //Connection ID to server
int status; //status return value used for ConnectAttach and MsgSend
int server_pid; //server's process ID
int server_chid; //server's channel ID
kom_t msg;
kom_t reply;
if(3 != argc) {
printf("This program must be started with commandline arguments, for example:\n\n");
printf(" cli 482834 1 \n\n");
printf(" 1st arg(482834): server's pid\n");
printf(" 2nd arg(1): server's chid\n");
exit(EXIT_FAILURE);
}
server_pid = atoi(argv[1]);
server_chid = atoi(argv[2]);
printf("attempting to establish connection with server pid: %d, chid %d\n", server_pid, server_chid);
coid = ConnectAttach(ND_LOCAL_NODE, server_pid, server_chid, _NTO_SIDE_CHANNEL, 0);
if(-1 == coid) {
perror("ConnectAttach");
exit(EXIT_FAILURE);
}
int i = 0;
while(i++ < 10) {
msg.type = 1;
msg.from = getpid();
sprintf(msg.text, "Proces %d, krok petli %d\n", getpid(), i);
status = MsgSend(coid, &msg, sizeof(msg), &reply, sizeof(reply) );
if(-1 == status) {
perror("MsgSend");
exit(EXIT_FAILURE);
}
sleep(1);
}
msg.type = 0;
status = MsgSend(coid, &msg, sizeof(msg), &reply, sizeof(reply) );
exit(EXIT_SUCCESS);
}
/**
* This function represents client thread. Thanks to this function we can send
* data to serwer.
*
* @param nth - not used but demanded by pthread_create() convencion
* @return no value returned
*/
void* send(void* nth) {
my_data_t msg;
std::string buffer;
/* We trying to open connection with channel, store coid value */
while((coid = name_open(stranger_channel, 0)) == -1) {
std::cout<<"Waiting for the server to be created. \n";
sleep(2);
}
msg.header.type = 0x00;
msg.header.subtype = 0x00;
/* main loop - sending data */
while(true) {
//std::cout<<"["<<my_channel<<"]: ";
printf("[%s]: ", my_channel);
fflush(stdout);
std::getline(std::cin, buffer);
std::strncpy(msg.data, buffer.c_str(), 32);
msg.data[31]='\0';
if(MsgSend(coid, &msg, sizeof(msg), NULL, 0) == -1) {
std::cerr<<"Error while sending message\n";
exit(-1);
}
}
}
void
RepDown(Link l)
{
Rep r = l->rep;
int n = (r->links[0] == l)?0:1;
Log(LG_REP, ("[%s] Rep: DOWN event from %s (%d)",
r->name, l->name, n));
r->p_up &= ~(1 << n);
if (r->links[1-n])
PhysClose(r->links[1-n]);
if (r->csock > 0 && r->node_id) {
char path[NG_PATHSIZ];
snprintf(path, sizeof(path), "[%x]:", r->node_id);
NgFuncShutdownNode(r->csock, r->name, path);
r->node_id = 0;
close(r->csock);
r->csock = -1;
}
l->rep->links[n] = NULL;
l->rep = NULL;
if (!l->stay) {
REF(l);
MsgSend(&l->msgs, MSG_SHUTDOWN, l);
}
if (r->links[1-n] == NULL)
RepShutdown(r);
}
int main(int argc, char *argv[]) {
if(argc < 2) {
printf("use with channel_id\n");
return 1;
}
int chid = atoi(argv[1]);
sleep(1);
coid = ConnectAttach(getppid(), chid, 0);
if(coid < 0) {
printf("kernel not responsible\n");
return 2;
}
pthread_t tid;
pthread_create(&tid, NULL, ping, NULL);
printf("console\n");
MESSAGE *pmsg = (MESSAGE *) malloc(MAXMSGSIZE);
pmsg->type = MSGCMD;
for(;;) {
printf("%% "); fflush(stdout);
if(!fgets(pmsg->body, MAXMSGSIZE - sizeof(MESSAGE) - 1, stdin)) break;
pmsg->len = strlen(pmsg->body);
MsgSend(coid, pmsg, sizeof(MESSAGE) + pmsg->len, pmsg, MAXMSGSIZE);
if(pmsg->len < 1 || (pmsg->len == 1 && pmsg->body[0] == '\n')) continue;
pmsg->body[pmsg->len] = 0;
printf("kernel said:\n");
printf("%s", pmsg->body);
}
printf("console closed\n");
return EXIT_SUCCESS;
}
/*
* qnx_name_locate
*
* Note that currently the only valid values for nid are 0 and the
* local nid.
*/
int
qnx_name_locate(nid_t nid, char *name, unsigned size, unsigned *copies)
{
procmgr_msg_t msg;
procmgr_reply_t reply;
if (nid != 0 && nid != getnid()) {
errno = EHOSTUNREACH;
return -1;
}
msg.hdr.type = _IO_MSG;
msg.hdr.combine_len = sizeof(msg.hdr);
msg.hdr.mgrid = MGR_ID_PROCMGR;
msg.hdr.subtype = _PROCMGR_QNX_NAME_LOCATE;
msg.un.locate.nid = nid; /* 0 */
msg.un.locate.vc_size = size;
strncpy(msg.un.locate.name, name, _NAME_MAX_LEN);
msg.un.locate.name[_NAME_MAX_LEN] = '\0';
if (MsgSend(magic.procmgr_fd, &msg, sizeof(msg), &reply, sizeof(reply)) == -1)
return -1;
errno = reply.set_errno_to_this;
if (copies)
*copies = reply.un.locate.copies;
return reply.un.locate.pid;
}
/*
* Given a process id, iterate through all open files of that process
* looking for a match to the target file, and then determine how it
* is being used by that process. This is quite different in QNX to
* UNIX, as chroot and chdir do not hold open a reference to the file.
* The iteration process attempts to dup each file descriptor into
* this process, so it can then be queried; attempt to skip things which
* aren't files (heuristic guess) and use a timeout as self-defence.
*/
int howused(pid_t pid, match_t *match)
{
struct _server_info sinfo;
struct _fdinfo finfo;
struct stat st;
io_dup_t msg;
uint64_t to;
int fd, coid, usage;
usage = 0;
for (fd = 0; (fd = ConnectServerInfo(pid, fd, &sinfo)) != -1; ++fd) {
if ((pid != sinfo.pid || !(fd & _NTO_SIDE_CHANNEL)) && (coid = ConnectAttach(sinfo.nd, sinfo.pid, sinfo.chid, 0, _NTO_COF_CLOEXEC)) != -1) {
msg.i.type = _IO_DUP;
msg.i.combine_len = sizeof(msg.i);
msg.i.info.nd = netmgr_remote_nd(sinfo.nd, ND_LOCAL_NODE);
msg.i.info.pid = pid;
msg.i.info.chid = sinfo.chid;
msg.i.info.scoid = sinfo.scoid;
msg.i.info.coid = fd;
TimerTimeout(CLOCK_MONOTONIC, _NTO_TIMEOUT_SEND | _NTO_TIMEOUT_REPLY, NULL, (to = 1000000000LL, &to), NULL);
if (MsgSend(coid, &msg.i, sizeof(msg.i), NULL, 0) == -1) {
ConnectDetach(coid);
}
else {
if (fstat(coid, &st) != -1 && ismatch(match, st.st_dev, st.st_ino)) {
if (iofdinfo(coid, 0, &finfo, NULL, 0) == -1 || sinfo.pid != PATHMGR_PID || finfo.mode != 0)
usage |= USED_OPEN;
}
close(coid);
}
}
}
return(usage);
}
extern "C" DLL_EXPORT bool _dbg_dbgcmdexec(const char* cmd)
{
int len = (int)strlen(cmd);
char* newcmd = (char*)emalloc((len + 1) * sizeof(char), "_dbg_dbgcmdexec:newcmd");
strcpy_s(newcmd, len + 1, cmd);
return MsgSend(gMsgStack, 0, (uint)newcmd, 0);
}
//Communication with the server
//Using buffers: buffer, receive
void* message_client(void* arg){
//Define thread priority
if(((struct thread_args*)arg)->which_thread == 0){
set_priority(22);
printf("I HAVE PRIORITY 22\n");
}
else if(((struct thread_args*)arg)->which_thread == 1){
set_priority(21);
printf("I HAVE PRIORITY 21\n");
}
else if(((struct thread_args*)arg)->which_thread == 2){
set_priority(19);
printf("I HAVE PRIORITY 19\n");
}
else{
set_priority(18);
printf("I HAVE PRIORITY 18\n");
}
//Perform communication
int channelID, status;
channelID = ConnectAttach(0, ((struct thread_args*)arg)->pid, 1, 0, 0);
//Sends data in buffer. Puts returned data in receive buffer
status = MsgSend(channelID, &buffer, sizeof buffer, &receive, sizeof receive);
printf("SERVER REPLY: %c\n", receive[0]);
//Detach from server
ConnectDetach(channelID);
return 0;
}
//接收到PC发来的USB数据包
void DeviceAudioOnCmd(void)
{
if(!UsbIntFlag)
{
UsbIntFlag = TRUE;
MsgSend(MSG_USB_DEVICE_INTERRUPT_CB);
}
}
void *ping(void *arg) {
MESSAGE msg = { MSGPING, 0 }, reply;
for(;;) {
if(MsgSend(coid, &msg, sizeof(msg), &reply, sizeof(reply)) < 0 || reply.type != MSGPONG) {
printf("kernel not responsible\n");
exit(1);
}
sleep(1);
}
}
//Button map
int ButtonMap::mapButton(int player, int button)
{
recv_msg msg;
msg.code = RETROARCH_BUTTON_MAP;
this->player = player;
this->button = button;
return MsgSend(coid, (void*)&msg, sizeof(msg), (void*)NULL, 0);
}
int main(int argc, char *argv[]) {
pid_t pid_2 = getpid();
pid_t pid_1 = getppid();
char *msg = (char*)malloc(BUFFER_LENGTH*sizeof(char));
char *rmsg = (char*)malloc(BUFFER_LENGTH*sizeof(char));
printf(" P2>\n");
printf(" P2> Parent pid: %i\n", pid_1);
int chidP1 = atoi(argv[0]);
// Step 3 Creating channel - chidP2.
int chidP2 = ChannelCreate(0);
printf(" P2> pid: %i, P1 chid: %i, P2 chid: %i\n", pid_2, chidP1, chidP2);
// Step 4 Spawning P3 process - pid_3.
char argv0[12];
sprintf(argv0, "%i", chidP2);
int pid_3 = spawnl(P_NOWAITO, "/tmp/M3", argv0, NULL);
// Step 6 Sending chidP2 to P1.
int coid_1 = ConnectAttach(ND_LOCAL_NODE, pid_1, chidP1, _NTO_SIDE_CHANNEL, 0);
if (coid_1==-1) {
fprintf(stderr, "Connection error.\n");
exit(EXIT_FAILURE);
}
printf(" P2> P2 coid: %i\n", coid_1);
int msg_res = MsgSend(coid_1, &chidP2, sizeof(int), rmsg, BUFFER_LENGTH*sizeof(char)); //sizeof(bytes)
if (msg_res < 0) {
msg_res = errno;
fprintf(stderr, " P2> Error MsgSend\n");
fprintf(stderr, " P2> Error code:%i\n", msg_res);
exit(EXIT_FAILURE);
}
printf(" P2> Server replied \n%s\n", rmsg);
// Step 8 Receiving query from P3.
int rcvid = MsgReceive(chidP2, msg, sizeof(msg), NULL);
printf(" P2> Received, rcvid: %i\n", rcvid);
printf(" P2> Message: %s\n", msg);
// Step 9 Replying to P3. Sending pid_1 and chidP1.
*(int*)((int)msg) = pid_1;
*(int*)((int)msg + 4) = chidP1;
MsgReply(rcvid, EOK, msg, 8);
// Step 12 Receiving message from P1. Reply.
rcvid = MsgReceive(chidP2, msg, sizeof(msg), NULL);
printf(" P2> Received, rcvid: %i\n", rcvid);
printf(" P2> Message: %s\n", msg);
strcpy(msg, "P2 OK");
MsgReply(rcvid, EOK, msg, strlen(msg) + 1);
printf(" P2> Good luck!\n");
return EXIT_SUCCESS;
}
//Communication with the server
//Using buffers: buffer, receive
int message_client(pid_t pid){
int channelID, status;
channelID = ConnectAttach(0, pid, 1, 0, 0);
//Sends data in buffer. Puts returned data in receive buffer
status = MsgSend(channelID, &buffer, sizeof buffer, &receive, sizeof receive);
//Detach from server
ConnectDetach(channelID);
//Unnecessary return
return channelID;
}
int main(int argc, char* argv[])
{
int coid; //Connection ID to server
cksum_msg_t msg;
int incoming_checksum; //space for server's reply
int status; //status return value used for ConnectAttach and MsgSend
int server_pid; //server's process ID
int server_chid; //server's channel ID
setvbuf (stdout, NULL, _IOLBF, 0);
if(4 != argc) {
printf("This program must be started with commandline arguments, for example:\n\n");
printf(" cli 482834 1 abcdefghi \n\n");
printf(" 1st arg(482834): server's pid\n");
printf(" 2nd arg(1): server's chid\n");
printf(" 3rd arg(abcdefghi): string to send to server\n"); //to make it
//easy, let's not bother handling spaces
exit(EXIT_FAILURE);
}
server_pid = atoi(argv[1]);
server_chid = atoi(argv[2]);
printf("attempting to establish connection with server pid: %d, chid %d\n", server_pid, server_chid);
//PUT CODE HERE to establish a connection to the server's channel, store the
//connection id in the variable 'coid'
coid = ConnectAttach(ND_LOCAL_NODE, server_pid, server_chid, _NTO_SIDE_CHANNEL, NULL);
if(-1 == coid) { //was there an error attaching to server?
perror("ConnectAttach"); //look up error code and print
exit(EXIT_FAILURE);
}
msg.msg_type = CKSUM_MSG_TYPE;
strcpy(msg.string_to_cksum, argv[3]);
printf("Sending string: %s\n", msg.string_to_cksum);
//PUT CODE HERE to send message to server and get the reply
status = MsgSend(coid, &msg, sizeof(msg), &incoming_checksum, sizeof(incoming_checksum));
if(-1 == status) { //was there an error sending to server?
perror("MsgSend");
exit(EXIT_FAILURE);
}
printf("received checksum=%d from server\n", incoming_checksum);
printf("MsgSend return status: %d\n", status);
return EXIT_SUCCESS;
}
static bool GotoNextMode(void)
{
if(gSys.NextModuleID == MODULE_ID_PLAYER_SD)
{
gSys.DiskType = SD_TYPE;
}
else if(gSys.NextModuleID == MODULE_ID_PLAYER_USB)
{
gSys.DiskType = USB_TYPE;
}
MsgSend(MSG_COMMON_CLOSE);
return TRUE;
}
/*
* Implement the '-u' option (display user associated with the process).
* First directly query procnto (however it restricts this to processes
* in the same session); then deduce it from profcs (address space owner).
*/
uid_t whois(pid_t pid)
{
proc_getsetid_t msg;
struct stat st;
char as[32];
msg.i.type = _PROC_GETSETID, msg.i.subtype = _PROC_ID_GETID;
msg.i.pid = pid;
if (MsgSend(PROCMGR_COID, &msg.i, sizeof(msg.i), &msg.o, sizeof(msg.o)) != -1)
return(msg.o.cred.ruid);
sprintf(as, "/proc/%d/as", pid);
if (stat(as, &st) != -1)
return(st.st_uid);
return((uid_t)-1);
}
//Communication with the server
//Using buffers: buffer, receive
void* message_client(pid_t pid){
int channelID, status;
printf("RECEIVED ARGUMENT FROM DUMB PROCESS: %d\n", pid);
channelID = ConnectAttach(0, pid, 1, 0, 0);
//Sends data in buffer. Puts returned data in receive buffer
status = MsgSend(channelID, &buffer, sizeof buffer, &receive, sizeof receive);
printf("SERVER REPLY: %c\n", receive[0]);
//Detach from server
ConnectDetach(channelID);
return 0;
}
/*** Client Side of the code ***/
int client() {
mss_t msg;
int server_coid;
mss_t rmsg;
if ((server_coid = name_open(ATTACH_POINT, 0)) == -1) {
return EXIT_FAILURE;
}
/* We would have pre-defined data to stuff here */
// msg.hdr.type = 0x00;
//msg.hdr.subtype = 0x00;
msg.ile = 0;
int typ = 1;
msg.typ = typ;
int from = getpid();
msg.from = from;
int i = 0;
int count = 0;
/* Do whatever work you wanted with server connection */
printf("what you want Send?");
scanf("%s", msg.text);
for(i = 0; i < strlen(msg.text); i++){
if(islower(msg.text[i]) )
count++;
}
printf("count : %d ", count);
msg.ile = count;
printf("Client sending msg, lower case letters: %d \n", msg.ile);
if (MsgSend(server_coid, &msg, sizeof(msg), &rmsg, sizeof(rmsg)) == -1) {
perror("MsgSend");
exit(EXIT_FAILURE);
}
printf("received message %s from server %d\n",rmsg.text, rmsg.from);
/* Close the connection */
name_close(server_coid);
return EXIT_SUCCESS;
}
int close(int fd) {
io_close_t msg;
int ret, err;
msg.i.type = _IO_CLOSE;
msg.i.combine_len = sizeof msg.i;
if((ret = MsgSend(fd, &msg.i, sizeof msg.i, 0, 0)) != -1 || errno != EINTR) {
if((err = ConnectDetach_r(fd)) == EOK) {
return ret;
}
if(ret != -1) {
errno = err;
}
}
return -1;
}
int posix_fallocate64(int fd, off64_t offset, off64_t len) {
io_space_t msg;
msg.i.type = _IO_SPACE;
msg.i.combine_len = sizeof msg.i;
msg.i.subtype = F_ALLOCSP64;
msg.i.whence = SEEK_SET;
msg.i.start = offset;
msg.i.len = len;
if(MsgSend(fd, &msg.i, sizeof msg.i, 0, 0) == -1) {
return -1;
}
return 0;
}
int
name_init(void)
{
procmgr_msg_t msg;
procmgr_reply_t reply;
msg.hdr.type = _IO_MSG;
msg.hdr.combine_len = sizeof(msg.hdr);
msg.hdr.mgrid = MGR_ID_PROCMGR;
msg.hdr.subtype = _PROCMGR_GET_NID;
if (MsgSend(magic.procmgr_fd, &msg, sizeof(msg), &reply, sizeof(reply)) == -1)
return -1;
magic.nid = reply.un.get_nid.nid;
return 0;
}
void *count_primes2(void *arg) {
int status;
int coid;
par_t reply;
coid = ConnectAttach(ND_LOCAL_NODE, pid, chid, _NTO_SIDE_CHANNEL, 0);
while (1) {
par_t args;
args.typ = 10;
args.numer = pthread_self();
status = MsgSend(coid, &args, sizeof(args), &reply, sizeof(reply));
if (reply.typ == 1) {
sleep(1);
int primes_count = 0;
printf("Proces: %d, watek: %d\n", getpid(), pthread_self());
int i;
for (i = reply.pocz; i < reply.kon; i++) {
int c;
int prime = 1;
for (c = 2; c <= i / 2; c++) {
if (i % c == 0) {
prime = 0;
break;
}
}
if (prime && i != 0 && i != 1)
primes_count++;
}
//sleep(15 - args->numer);
printf("\twatek: %d, poczatek %d, koniec %d, primes %d\n",
pthread_self(), reply.pocz, reply.kon, primes_count);
pthread_mutex_lock(&primes_mutex);
p_count += primes_count;
pthread_mutex_unlock(&primes_mutex);
} else if (reply.typ == 0) {
return 0;
}
}
}
void nagger(void *arg){
set_priority(*(int*)arg);
// Creating shared memory
int skynetDesc = shm_open("/skynetcore", O_RDWR, S_IRWXU);
struct skynetCore_t* skynetCore = mmap(0, sizeof(struct skynetCore_t), PROT_READ|PROT_WRITE, MAP_SHARED, skynetDesc, 0);
pthread_mutex_lock(&skynetCore->protector);
int corePid = skynetCore->pid;
pthread_mutex_unlock(&skynetCore->protector);
int message = *(int*)arg;
int skynetChannelId = ConnectAttach(0, corePid, 1, 0, 0);
MsgSend(skynetChannelId, &message, sizeof(int), &message, sizeof(int));
printf("I sent %i and got %i back!\n", *(int*)arg, message);
ConnectDetach(skynetChannelId);
}
void *t2()
{
int coid, sending_status;
struct _msg_info client_info;
client_info.tid = 2;
client_info.priority = 13;
coid = ConnectAttach(0, pid, chid, _NTO_SIDE_CHANNEL, &client_info);
sending_status = MsgSend(coid, NULL, 0, NULL, 0);
if(-1 == sending_status) { //was there an error sending to server?
perror("MsgSend");
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
int main( int argc, char** argv )
{
int fd;
unsigned *addr;
int ConnectionID;
/* Create a new memory object */
fd = shm_open( "/MySharedMemory", O_RDWR, 0777 );
if( fd == -1 )
{
printf("error: couldn't open a shared memory object\n");
return EXIT_FAILURE;
}
/* Map the memory object */
addr = mmap( 0, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 );
if( addr == MAP_FAILED )
{
printf("error: mapping in the memory failed\n");
return EXIT_FAILURE;
}
printf( "memory mapping address is 0x%08x\n", addr );
if((ConnectionID = ConnectAttach(0, addr[1022], addr[1023], _NTO_SIDE_CHANNEL, 0)) == -1)
printf("error: couldn't attach to channel\n");
while(1)
{
/* synchronize with the server: block until server has written shared memory */
if(MsgSend(ConnectionID, NULL, 0, NULL, 0) == -1)
break;
/* Read to shared memory */
printf("read shared memory: %s\n", (char*)addr);
sleep(1);
}
close( fd );
shm_unlink( "/MySharedMemory" );
return EXIT_SUCCESS;
}
/*
* qnx_name_detach
*
* Note that currently the only valid values for nid are 0 and the
* local nid.
*/
int
qnx_name_detach(nid_t nid, int name_id)
{
procmgr_msg_t msg;
procmgr_reply_t reply;
if (nid != 0 && nid != getnid()) {
errno = EHOSTUNREACH;
return -1;
}
msg.hdr.type = _IO_MSG;
msg.hdr.combine_len = sizeof(msg.hdr);
msg.hdr.mgrid = MGR_ID_PROCMGR;
msg.hdr.subtype = _PROCMGR_QNX_NAME_DETACH;
msg.un.detach.nid = nid;
msg.un.detach.name_id = name_id;
if (MsgSend(magic.procmgr_fd, &msg, sizeof(msg), &reply, sizeof(reply)) == -1)
return -1;
errno = reply.set_errno_to_this;
return reply.un.detach.retval;
}
