int _spi_iomsg_write(resmgr_context_t *ctp, io_msg_t *msg, spi_ocb_t *ocb) { spi_msg_t *spimsg = (spi_msg_t *)msg; uint8_t *buf; int nbytes, msglen, status; SPIDEV *drvhdl = (SPIDEV *)ocb->hdr.attr; spi_dev_t *dev = drvhdl->hdl; uint16_t chip = spimsg->device & SPI_DEV_ID_MASK; /* check if message buffer is too short */ nbytes = spimsg->xlen; if (nbytes <= 0) { _IO_SET_WRITE_NBYTES(ctp, 0); return _RESMGR_NPARTS(0); } msglen = nbytes + sizeof(spi_msg_t); if (msglen > ctp->msg_max_size) { if (dev->buflen < msglen) { dev->buflen = msglen; if (dev->buf) free(dev->buf); if ((dev->buf = malloc(dev->buflen)) == NULL) { dev->buflen = 0; return ENOMEM; } } status = resmgr_msgread(ctp, dev->buf, msglen, 0); if (status < 0) return errno; if (status < msglen) return EFAULT; buf = dev->buf; } else buf = (uint8_t *)msg; if (chip == SPI_DEV_ID_NONE) chip = ocb->chip; buf = dev->funcs->xfer(drvhdl, _SPI_DEV_WRITE(chip), buf + sizeof(spi_msg_t), &nbytes); if (nbytes == 0) return EAGAIN; if (nbytes > 0) { _IO_SET_WRITE_NBYTES(ctp, nbytes); return _RESMGR_NPARTS(0); } return EIO; }
int io_write (resmgr_context_t *ctp, io_write_t *msg, RESMGR_OCB_T *ocb) { int status; if ((status = iofunc_write_verify(ctp, msg, ocb, NULL)) != EOK) return (status); if ((msg->i.xtype & _IO_XTYPE_MASK) != _IO_XTYPE_NONE) return(ENOSYS); /* set up the number of bytes (returned by client's write()) */ _IO_SET_WRITE_NBYTES (ctp, msg->i.nbytes); /* * Reread the data from the sender's message buffer. * We're not assuming that all of the data fit into the * resource manager library's receive buffer. */ resmgr_msgread(ctp, buffer, min(msg->i.nbytes, 4095), sizeof(msg->i)); buffer[min(msg->i.nbytes, 4095)] = '\0'; /* just in case the text is not NULL terminated */ ocb->offset = 0; attr.nbytes = strlen (buffer)+1; printf("%s\n", buffer); if (msg->i.nbytes > 0) ocb->attr->flags |= IOFUNC_ATTR_MTIME | IOFUNC_ATTR_CTIME; return (_RESMGR_NPARTS (0)); }
int io_write(resmgr_context_t *ctp, io_write_t *msg, iofunc_ocb_t *ocb) { LOCK(resource_mutex); printf("IO write activated\n"); // set data to return _IO_SET_WRITE_NBYTES(ctp, msg->i.nbytes); int nBytes = msg->i.nbytes + 1; char *buf = (char *)malloc(nBytes * sizeof(char)); if (!buf) RETURN_UNLOCK(ENOMEM, resource_mutex); resmgr_msgread(ctp, buf, nBytes, sizeof(msg->i)); buf[msg->i.nbytes] = '\0'; printf("Received %d bytes = \"%s\"\n", msg->i.nbytes, buf); int rcvid = fifo_rem_blocked_id(fifoHandler); if(rcvid != -1) { printf("Found blocked id, sending string '%s' with %i bytes\n", buf, nBytes); MsgReply(rcvid, nBytes, buf, nBytes); free(buf); RETURN_UNLOCK(_RESMGR_NPARTS(0), resource_mutex); } fifo_add_string(fifoHandler, buf); free(buf); RETURN_UNLOCK(_RESMGR_NPARTS(0), resource_mutex); }
int io_console_write(resmgr_context_t *ctp, io_write_t *msg, iofunc_ocb_t *ocb) { int n; int off; int len; int ret; int cnt; int status; int nonblock; char *cptr; ret = EOK; cptr = (char *) (sizeof(msg->i) + (char *)&msg->i); off = 0; len = msg->i.nbytes; // Is device open for write? if((status = iofunc_write_verify(ctp, msg, ocb, &nonblock)) != EOK) return status; // No special xtypes if((msg->i.xtype & _IO_XTYPE_MASK) != _IO_XTYPE_NONE) return(EINVAL); while(off < len) { /* Limit write to max payload, NULL terminate the string, * and figure out how many ints we're writing. */ n = min(len - off, _SLOG_MAXSIZE - _SLOG_HDRINTS*sizeof(int) - 1); cptr[n] = '\0'; cnt = n/sizeof(int) +1; /* put it in the log */ ret = _io_write_log(ctp, msg, ocb, cnt, 1); if(ret != EOK) break; off += n; //skip the MsgRead() if we're done. if (off == len) break; ret = MsgRead(ctp->rcvid, cptr, n, off + sizeof(msg->i)); if(ret <= 0) break; } _IO_SET_WRITE_NBYTES(ctp, off); return(ret); }
int io_write (resmgr_context_t *ctp, io_write_t *msg, RESMGR_OCB_T *ocb){ char *buf; /* set up the number of bytes (returned by client's write()) */ _IO_SET_WRITE_NBYTES (ctp, msg->i.nbytes); buf = (char *) malloc(msg->i.nbytes + 1); if (buf == NULL) return(ENOMEM); /* * Reread the data from the sender's message buffer. * We're not assuming that all of the data fit into the * resource manager library's receive buffer. */ resmgr_msgread(ctp, buf, msg->i.nbytes, sizeof(msg->i)); buf [msg->i.nbytes] = '\0'; /* just in case the text is not NULL terminated */ printf ("Received %d bytes = '%s'\n", msg -> i.nbytes, buf); /* Set the dir var for counter thread according to the command */ if(!strncmp(buf, "up", 2)){ /* Count upwards */ pthread_mutex_lock(&lock); counter_dir = DIR_UP; pthread_mutex_unlock(&lock); }else if(!strncmp(buf,"down", 4)){ /* Count downwards */ pthread_mutex_lock(&lock); counter_dir = DIR_DOWN; pthread_mutex_unlock(&lock); }else if(!strncmp(buf, "stop", 4)){ /* Stop counting */ pthread_mutex_lock(&lock); counter_dir = DIR_NONE; pthread_mutex_unlock(&lock); }else{ // do nothing } free(buf); return (_RESMGR_NPARTS (0)); }
int dumper_write(resmgr_context_t *ctp, io_write_t *msg, iofunc_ocb_t *ocb) { int status; int nonblock; long size = max_core_size; char *p, *tmp; pid_t pid; if((status = iofunc_write_verify(ctp, msg, ocb, &nonblock)) != EOK) { return status; } switch(msg->i.xtype & _IO_XTYPE_MASK) { case _IO_XTYPE_NONE: break; default: return EINVAL; } if(msg->i.nbytes > sizeof ctp->msg - sizeof msg->i) { return ENOSPC; } p = (char *)(&msg->i) + sizeof msg->i; p[msg->i.nbytes] = '\0'; pid = strtol(p, &tmp, 10); /* eat whitespace */ while(*tmp && !ISDIGIT(*tmp)) tmp++; if(*tmp){ size = strtol(tmp, NULL, 10); if(size > max_core_size) size = max_core_size; } DeliverNotifies(pid); // send all notifications first, // since the call to dump might return an error if((status = dump(ctp->info.nd, pid, size)) != EOK) { return status; } _IO_SET_WRITE_NBYTES(ctp, msg->i.nbytes); return EOK; }
int io_write( resmgr_context_t *ctp, io_write_t *msg, RESMGR_OCB_T *ocb) { int status; char *buf; if((status = iofunc_write_verify(ctp, msg, ocb, NULL)) != EOK ) return(status); if((msg->i.xtype & _IO_XTYPE_MASK) != _IO_XTYPE_NONE) return(ENOSYS); _IO_SET_WRITE_NBYTES(ctp, msg->i.nbytes); buf = (char *)malloc(msg->i.nbytes + 1); if( buf == NULL) return(ENOMEM); /* * reread the data from the sender's message buffer. * We're not assuming that all of the data fit into the * resource manager library's receive buffer. */ if( (status = resmgr_msgread(ctp, buf, msg->i.nbytes, sizeof(msg->i))) == -1){ return(ENOSYS); } fprintf(stderr,"_ics660-drvr: bytes attemted: %d bytes received %d\n",msg->i.nbytes,status); buf[msg->i.nbytes] = '\0'; //just in case text is not NULL terminated memcpy((int *)ics660->mem1,buf,(size_t)msg->i.nbytes); free(buf); if(msg->i.nbytes > 0) ocb->attr->flags |= IOFUNC_ATTR_MTIME | IOFUNC_ATTR_CTIME; return(_RESMGR_NPARTS(0)); }
int io_write (resmgr_context_t *ctp, io_write_t *msg, RESMGR_OCB_T *ocb) { int status; if (optv) { printf ("%s: in io_write\n", progname); } if ((status = iofunc_write_verify(ctp, msg, ocb, NULL)) != EOK) return (status); // No special xtypes if ((msg->i.xtype & _IO_XTYPE_MASK) != _IO_XTYPE_NONE) { return(ENOSYS); } _IO_SET_WRITE_NBYTES (ctp, msg -> i.nbytes); if (msg->i.nbytes > 0) ocb->attr->flags |= IOFUNC_ATTR_MTIME | IOFUNC_ATTR_CTIME; return (_RESMGR_NPARTS (0)); }
int io_write (resmgr_context_t *ctp, io_write_t *msg, RESMGR_OCB_T *ocb) { int status; int nb; if (optv) { printf ("%s: in io_write, of %d bytes\n", progname, msg->i.nbytes); } if ((status = iofunc_write_verify(ctp, msg, ocb, NULL)) != EOK) return (status); // No special xtypes if ((msg->i.xtype & _IO_XTYPE_MASK) != _IO_XTYPE_NONE) { return(ENOSYS); } if( msg->i.nbytes == ctp->info.msglen - (ctp->offset + sizeof(*msg) )) { /* have all the data */ char *buf; buf = (char *)(msg+1); nb = write( STDOUT_FILENO , buf, msg->i.nbytes ); // fd 1 is stdout if( -1 == nb ) return errno; } else { #if 0 char *buf; buf = malloc( msg->i.nbytes ); if (NULL == buf ) return ENOMEM; nb = resmgr_msgread(ctp, buf, msg->i.nbytes, sizeof(*msg)); nb = write(1, buf, nb ); // fd 1 is stdout free(buf); if( -1 == nb ) return errno; #else char buf[1000]; // my hardware buffer int count, bytes; count = 0; while ( count < msg->i.nbytes ) { bytes = resmgr_msgread( ctp, buf, 1000, count + sizeof(*msg )); if( bytes == -1 ) return errno; bytes = write( 1, buf, bytes ); // fd 1 is standard out if( bytes == -1 ) { if (!count ) return errno; else break; } count += bytes; } nb = count; #endif } _IO_SET_WRITE_NBYTES (ctp, nb); if (msg->i.nbytes > 0) ocb->attr->flags |= IOFUNC_ATTR_MTIME | IOFUNC_ATTR_CTIME; return (_RESMGR_NPARTS (0)); }