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
_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 syslink_frameq_getv(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb) {
FrameQDrv_CmdArgs *cargs = (FrameQDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
FrameQDrv_CmdArgs *out = (FrameQDrv_CmdArgs *) (_DEVCTL_DATA (msg->o));
FrameQ_Frame *framePtr = NULL;
UInt32 *filledQueueId = NULL;
FrameQ_FrameBufInfo *frameBufInfo;
Ptr phyPtr;
Ptr addr;
UInt32 j;
int i;
framePtr = (FrameQ_Frame*)(cargs+1);
filledQueueId = (UInt32*)(framePtr + cargs->args.getv.numFrames);
out->apiStatus = FrameQ_getv (cargs->args.getv.handle,
framePtr,
(Ptr)filledQueueId,
&cargs->args.getv.numFrames);
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(FrameQDrv_CmdArgs));
if ((out->apiStatus >= 0) && (cargs->args.getv.numFrames > 0)) {
for (i = 0; i < cargs->args.getv.numFrames; i++) {
/* Convert Frame and frame buffer address in frame
* to physical address formatso that user space api
* convert this physical address in to user space
* virtual format.
*/
frameBufInfo = (FrameQ_FrameBufInfo *)
&(framePtr[i]->frameBufInfo[0]);
for(j = 0; j < framePtr[i]->numFrameBuffers; j++) {
addr = (Ptr)frameBufInfo[j].bufPtr;
phyPtr = Memory_translate(
addr,
Memory_XltFlags_Virt2Phys);
GT_assert(curTrace,(phyPtr != NULL));
frameBufInfo[j].bufPtr = (UInt32)phyPtr;
}
framePtr[i] = Memory_translate(
framePtr[i],
Memory_XltFlags_Virt2Phys);
}
SETIOV(&ctp->iov[1], framePtr, sizeof (UInt32) * cargs->args.getv.numFrames);
return _RESMGR_NPARTS(2);
}
return _RESMGR_NPARTS(1);
}
int io_read (resmgr_context_t *ctp, io_read_t *msg, RESMGR_OCB_T *ocb){
int nbytes;
int buffer_read;
/* Check if the buffer has been reads */
if(ocb->offset){
nbytes = 0;
_IO_SET_READ_NBYTES (ctp, 0);
buffer_read = 0;
}else{
nbytes = BUFFER_SIZE;
pthread_mutex_lock(&lock);
sprintf(buffer, "%i\n", counter_var);
pthread_mutex_unlock(&lock);
printf("buffer is: %s \n", buffer);
/* Set up the return data IOV */
SETIOV (ctp->iov, buffer, nbytes);
/* Set up the number of bytes (returned by client's read()) */
_IO_SET_READ_NBYTES (ctp, nbytes);
/* Set the offset to one, indicating the buffer has been read */
ocb->offset = 1;
buffer_read = 1;
}
return (_RESMGR_NPARTS (buffer_read));
}
int syslink_frameq_get_vnumfreeframes(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb) {
FrameQDrv_CmdArgs *cargs = (FrameQDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
FrameQDrv_CmdArgs *out = (FrameQDrv_CmdArgs *) (_DEVCTL_DATA (msg->o));
/* Get the available frames in filled queue 0 of FrameQ */
UInt32 *freeQueueId = NULL;
UInt32 *numFreeFrames;
numFreeFrames = (UInt32*)(cargs+1);
freeQueueId = (UInt32*)(numFreeFrames + cargs->args.getvNumFreeFrames.numFreeQids);
out->apiStatus = FrameQ_getvNumFreeFrames(
cargs->args.getvNumFreeFrames.handle,
numFreeFrames,
(Ptr)freeQueueId,
cargs->args.getvNumFreeFrames.numFreeQids);
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(FrameQDrv_CmdArgs));
SETIOV(&ctp->iov[1], numFreeFrames, sizeof (UInt32) * cargs->args.getvNumFreeFrames.numFreeQids);
return _RESMGR_NPARTS(2);
}
static int
devi_notify(resmgr_context_t *ctp, io_notify_t *msg, RESMGR_OCB_T *ocb)
{
devi_attr_t *attr = ocb->ocb.attr;
event_bus_line_t *line = attr->line;
int trig = 0, n;
int sts;
/* we don't support output or out of band notification */
if (msg->i.flags & (_NOTIFY_COND_OBAND | _NOTIFY_COND_OUTPUT))
return (ENOSYS);
pthread_mutex_lock(&line->mutex);
/* if queue non-empty, trigger */
if (ocb->read_ptr != line->head)
trig = _NOTIFY_COND_INPUT;
pthread_mutex_unlock(&line->mutex);
sts = iofunc_notify(ctp, msg, attr->notify, trig, NULL, &n);
if (sts == EBUSY)
return (EBUSY);
if (n)
attr->flags |= DEVI_NOTIFICATION_ARMED;
return (_RESMGR_NPARTS(1));
}
int
io_read (resmgr_context_t *ctp, io_read_t *msg, RESMGR_OCB_T *ocb)
{
int status;
static char data[] = "hello";
int nb;
if (optv) {
printf ("%s: in io_read\n", progname);
}
if ((status = iofunc_read_verify(ctp, msg, ocb, NULL)) != EOK) {
if (optv) printf("read failed because of error %d\n", status );
return (status);
}
// No special xtypes
if ((msg->i.xtype & _IO_XTYPE_MASK) != _IO_XTYPE_NONE) {
return(ENOSYS);
}
nb = strlen(data );
nb = min( nb, msg->i.nbytes );
_IO_SET_READ_NBYTES (ctp, nb);
SETIOV( ctp->iov, data, nb );
if (nb > 0)
ocb->attr->flags |= IOFUNC_ATTR_ATIME;
return (_RESMGR_NPARTS (1));
}
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_read (resmgr_context_t *ctp, io_read_t *msg, RESMGR_OCB_T *ocb)
{
int nleft;
int nbytes;
int nparts;
int status;
if ((status = iofunc_read_verify (ctp, msg, ocb, NULL)) != EOK)
return (status);
if ((msg->i.xtype & _IO_XTYPE_MASK) != _IO_XTYPE_NONE)
return (ENOSYS);
/*
* On all reads (first and subsequent), calculate
* how many bytes we can return to the client,
* based upon the number of bytes available (nleft)
* and the client's buffer size
*/
nleft = ocb->attr->nbytes - ocb->offset;
nbytes = min(msg->i.nbytes, nleft);
if (nbytes > 0) {
/* set up the return data IOV */
SETIOV (ctp->iov, buffer + ocb->offset, nbytes);
/* set up the number of bytes (returned by client's read()) */
_IO_SET_READ_NBYTES (ctp, nbytes);
/*
* advance the offset by the number of bytes
* returned to the client.
*/
ocb->offset += nbytes;
nparts = 1;
} else {
/*
* they've asked for zero bytes or they've already previously
* read everything
*/
_IO_SET_READ_NBYTES (ctp, 0);
nparts = 0;
}
/* mark the access time as invalid (we just accessed it) */
if (msg->i.nbytes > 0)
ocb->attr->flags |= IOFUNC_ATTR_ATIME;
return (_RESMGR_NPARTS (nparts));
}
int
_spi_read(resmgr_context_t *ctp, io_read_t *msg, spi_ocb_t *ocb)
{
uint8_t *buf;
int nbytes;
int nonblock = 0;
int status;
SPIDEV *drvhdl = (SPIDEV *)ocb->hdr.attr;
spi_dev_t *dev = drvhdl->hdl;
if ((status = iofunc_read_verify(ctp, msg, &ocb->hdr, &nonblock)) != EOK)
return status;
if ((msg->i.xtype & _IO_XTYPE_MASK) != _IO_XTYPE_NONE)
return ENOSYS;
/*
* Check to see if the device is locked
*/
if ((status =_spi_lock_check(ctp, ocb->chip, ocb)) != EOK)
return status;
if (msg->i.nbytes <= 0) {
_IO_SET_READ_NBYTES(ctp, 0);
return _RESMGR_NPARTS(0);
}
/* check if message buffer is too short */
nbytes = msg->i.nbytes;
if (nbytes > ctp->msg_max_size) {
if (dev->buflen < nbytes) {
dev->buflen = nbytes;
if (dev->buf)
free(dev->buf);
if (NULL == (dev->buf = malloc(dev->buflen))) {
dev->buflen = 0;
return ENOMEM;
}
}
buf = dev->buf;
}
else
buf = (uint8_t *)msg;
buf = dev->funcs->xfer(drvhdl, _SPI_DEV_READ(ocb->chip), buf, &nbytes);
if (nbytes > 0) {
_IO_SET_READ_NBYTES(ctp, nbytes);
return _RESMGR_PTR(ctp, buf, nbytes);
}
return EIO;
}
/**
* Handler for frameq getconfig API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_frameq_getconfig(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb){
FrameQDrv_CmdArgs *cargs = (FrameQDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
FrameQ_Config *config = (FrameQ_Config*)(cargs+1);
FrameQ_getConfig (config);
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(FrameQDrv_CmdArgs));
SETIOV(&ctp->iov[1], config, sizeof(FrameQ_Config));
return _RESMGR_NPARTS(2);
}
/**
* Handler for heapbuf mp params init API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_heapbufmp_params_init(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb)
{
HeapBufMPDrv_CmdArgs * cargs = (HeapBufMPDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
HeapBufMP_Params *local_params = (HeapBufMP_Params *)(cargs+1);
HeapBufMP_Params_init (local_params);
cargs->apiStatus = HeapBufMP_S_SUCCESS;
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(HeapBufMPDrv_CmdArgs));
SETIOV(&ctp->iov[1], local_params, sizeof(HeapBufMP_Params));
return _RESMGR_NPARTS(2);
}
int io_read(resmgr_context_t *ctp, io_read_t *msg, iofunc_ocb_t *ocb)
{
LOCK(resource_mutex);
printf("IO read activated\n");
int nonblock, status;
if ((status = iofunc_read_verify (ctp, msg, ocb, &nonblock)) != EOK)
{
RETURN_UNLOCK(status, resource_mutex);
}
// set data to return
if (ocb->offset)
{
SETIOV(ctp->iov, NULL, 0);
_IO_SET_READ_NBYTES(ctp, 0);
RETURN_UNLOCK(_RESMGR_NPARTS(0), resource_mutex);
}
ocb->offset = 1;
if (nonblock && !fifo_status(fifoHandler))
{
SETIOV(ctp->iov, NULL, 0);
_IO_SET_READ_NBYTES(ctp, 0);
RETURN_UNLOCK(_RESMGR_NPARTS(0), resource_mutex);
}
else if(!fifo_status(fifoHandler))
{
fifo_add_blocked_id(fifoHandler, ctp->rcvid);
RETURN_UNLOCK(_RESMGR_NOREPLY, resource_mutex);
}
char buffer[WIDTH];
fifo_rem_string(fifoHandler, buffer);
SETIOV(ctp->iov, buffer, strlen(buffer));
_IO_SET_READ_NBYTES(ctp, strlen(buffer));
RETURN_UNLOCK(_RESMGR_NPARTS(1), resource_mutex);
}
int syslink_frameq_shmem_params_init(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb){
FrameQDrv_CmdArgs *cargs = (FrameQDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
FrameQ_ShMem_Params *params = (FrameQ_ShMem_Params*)(cargs+1);
FrameQ_ShMem_Params_init(params);
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(FrameQDrv_CmdArgs));
SETIOV(&ctp->iov[1], params, sizeof(FrameQ_ShMem_Params));
return _RESMGR_NPARTS(2);
}
/**
* Handler for shared region get config API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_sharedregion_getconfig(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb) {
SharedRegionDrv_CmdArgs * cargs = (SharedRegionDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
SharedRegion_Config *config = (SharedRegion_Config *)(cargs+1);
SharedRegion_getConfig (config);
cargs->apiStatus = SharedRegion_S_SUCCESS;
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(SharedRegionDrv_CmdArgs));
SETIOV(&ctp->iov[1], config, sizeof(SharedRegion_Config));
return _RESMGR_NPARTS(2);
}
/**
* Handler for heapbuf mp get config API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_heapbufmp_getconfig(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb) {
HeapBufMPDrv_CmdArgs * cargs = (HeapBufMPDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
HeapBufMP_Config *config = (HeapBufMP_Config *)(cargs+1);
HeapBufMP_getConfig (config);
cargs->apiStatus = HeapBufMP_S_SUCCESS;
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(HeapBufMPDrv_CmdArgs));
SETIOV(&ctp->iov[1], config, sizeof(HeapBufMP_Config));
return _RESMGR_NPARTS(2);
}
/**
* Handler for messageq params init API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_messageq_params_init(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb)
{
MessageQDrv_CmdArgs * cargs = (MessageQDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
MessageQ_Params *local_params = (MessageQ_Params *)(cargs+1);
MessageQ_Params_init (local_params);
cargs->apiStatus = MessageQ_S_SUCCESS;
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(MessageQDrv_CmdArgs));
SETIOV(&ctp->iov[1], local_params, sizeof(*local_params));
return _RESMGR_NPARTS(2);
}
/**
* Handler for messageq getconfig API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_messageq_getconfig(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb)
{
MessageQDrv_CmdArgs * cargs =
(MessageQDrv_CmdArgs *)(_DEVCTL_DATA (msg->i));
MessageQ_Config local_config;
MessageQ_getConfig (&local_config);
cargs->apiStatus = MessageQ_S_SUCCESS;
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(MessageQDrv_CmdArgs));
SETIOV(&ctp->iov[1], &local_config, sizeof(MessageQ_Config));
return _RESMGR_NPARTS(2);
}
/**
* Handler for heap buf mp get extended stats API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_heapbufmp_getextendedstats(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb) {
HeapBufMPDrv_CmdArgs * cargs = (HeapBufMPDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
HeapBufMP_ExtendedStats *stats = (HeapBufMP_ExtendedStats *)(cargs+1);
HeapBufMP_getExtendedStats ( cargs->args.getExtendedStats.handle,
stats);
cargs->apiStatus = HeapBufMP_S_SUCCESS;
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(HeapBufMPDrv_CmdArgs));
SETIOV(&ctp->iov[1], stats, sizeof(HeapBufMP_ExtendedStats));
return _RESMGR_NPARTS(2);
}
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 syslink_frameq_shmem_memreq(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb){
FrameQDrv_CmdArgs *cargs = (FrameQDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
FrameQ_ShMem_Params *params = NULL;
UInt32 *memreq;
memreq = (UInt32*)(cargs+1);
params = (FrameQ_ShMem_Params*)(memreq+1);
*memreq = FrameQ_ShMem_sharedMemReq(params);
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(FrameQDrv_CmdArgs));
SETIOV(&ctp->iov[1], memreq, sizeof (UInt32));
return _RESMGR_NPARTS(2);
}
int reply_symlink(resmgr_context_t *ctp, unsigned eflag, struct _io_connect_link_reply *linkp, struct symlink_object *symlinkp, const char *path, const char *tail) {
int len;
iov_t *iov;
if(path) {
_IO_SET_CONNECT_RET(ctp, _IO_CONNECT_RET_LINK);
}
linkp->eflag = eflag;
linkp->nentries = 0;
linkp->path_len = symlinkp->len;
iov = ctp->iov;
SETIOV(iov, linkp, sizeof *linkp);
iov++;
len = 0;
if(path) {
if(symlinkp->name[0] != '/' && (len = tail - path)) {
while(--len && path[len-1] != '/') {
/* nothing to do */
}
}
if(len) {
linkp->path_len += len;
SETIOV(iov, path, len);
iov++;
}
len = strlen(tail);
}
SETIOV(iov, symlinkp->name, len ? symlinkp->len - 1 : symlinkp->len);
iov++;
if(len) {
linkp->path_len += len + 1;
SETIOV(iov, tail - 1, len + 2);
iov++;
}
return _RESMGR_NPARTS(iov - ctp->iov);
}
/**
* Handler for messageq create API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_messageq_create(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb)
{
MessageQDrv_CmdArgs * cargs = (MessageQDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
MessageQDrv_CmdArgs * out = (MessageQDrv_CmdArgs *) (_DEVCTL_DATA (msg->o));
MessageQ_Params *local_createparams = NULL;
String local_createname = NULL;
out->apiStatus = MessageQ_S_SUCCESS;
if (cargs->args.create.params) {
local_createparams = (MessageQ_Params *)(cargs+1);
if (cargs->args.create.name)
local_createname = (String)(local_createparams+1);
}
else {
if (cargs->args.create.name)
local_createname = (String)(cargs+1);
}
out->args.create.handle = MessageQ_create (local_createname, local_createparams);
GT_assert (curTrace, (out->args.create.handle != NULL));
/* Set failure status if create has failed. */
if (out->args.create.handle == NULL) {
out->apiStatus = MessageQ_E_FAIL;
}
else {
out->apiStatus = MessageQ_S_SUCCESS;
}
if (out->args.create.handle != NULL) {
out->args.create.queueId = MessageQ_getQueueId (
out->args.create.handle);
}
if (out->apiStatus >= 0) {
/* At this call to the list to be cleaned-up */
add_ocb_res(ocb, DCMD_MESSAGEQ_DELETE, (int)out->args.create.handle, NULL);
}
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(MessageQDrv_CmdArgs));
return _RESMGR_NPARTS(1);
}
/**
* Handler for messageq setup API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_messageq_setup(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb) {
MessageQDrv_CmdArgs * cargs = (MessageQDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
MessageQDrv_CmdArgs * out = (MessageQDrv_CmdArgs *) (_DEVCTL_DATA (msg->o));
MessageQ_Config *local_setupconfig;
local_setupconfig = (MessageQ_Config *)(cargs+1);
out->apiStatus = MessageQ_setup (local_setupconfig);
GT_assert (curTrace, (out->apiStatus >= 0));
if (out->apiStatus >= 0) {
/* Add this call to the list to be cleaned-up */
add_ocb_res(ocb, DCMD_MESSAGEQ_DESTROY, NULL, NULL);
}
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(MessageQDrv_CmdArgs));
return _RESMGR_NPARTS(1);
}
/**
* Handler for shared region setup API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_sharedregion_setup(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb) {
SharedRegionDrv_CmdArgs * cargs = (SharedRegionDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
SharedRegionDrv_CmdArgs * out = (SharedRegionDrv_CmdArgs *) (_DEVCTL_DATA (msg->o));
SharedRegion_Config *config = (SharedRegion_Config*)(cargs+1);
SharedRegion_Region *region = (SharedRegion_Region *)(config+1);
UInt16 i;
out->apiStatus = SharedRegion_setup (config);
GT_assert (curTrace, (out->apiStatus >= 0));
for (i = 0; i < config->numEntries; i++) {
SharedRegion_getRegionInfo (i, ®ion[i]);
if (region[i].entry.isValid == TRUE) {
/* Convert the kernel virtual address to physical
* addresses */
region[i].entry.base = MemoryOS_translate (
(Ptr)region[i].entry.base,
Memory_XltFlags_Virt2Phys);
GT_assert (curTrace, (region[i].entry.base != NULL));
}
}
if (out->apiStatus >= 0) {
/* Add this call to the list to be cleaned-up */
add_ocb_res(ocb, DCMD_SHAREDREGION_DESTROY, (int)NULL, NULL);
}
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(SharedRegionDrv_CmdArgs));
SETIOV(&ctp->iov[1], config, sizeof(SharedRegion_Config) );
SETIOV(&ctp->iov[2], region, config->numEntries*sizeof(SharedRegion_Region));
return _RESMGR_NPARTS(3);
}
/**
* Handler for shared region get region info API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_sharedregion_getregioninfo(
resmgr_context_t * ctp,
io_devctl_t * msg,
syslink_ocb_t * ocb)
{
SharedRegionDrv_CmdArgs * cmdArgs;
SharedRegion_Region * region;
SharedRegion_Config config;
UInt16 i;
cmdArgs = (SharedRegionDrv_CmdArgs *)(_DEVCTL_DATA(msg->i));
region = (SharedRegion_Region *)(cmdArgs + 1);
SharedRegion_getConfig(&config);
for (i = 0; i < config.numEntries; i++) {
SharedRegion_getRegionInfo(i, ®ion[i]);
if (region[i].entry.isValid) {
if (region[i].entry.createHeap) {
/* convert the kernel virtual address to physical addresses */
region[i].entry.base = MemoryOS_translate(
(Ptr)region[i].entry.base, Memory_XltFlags_Virt2Phys);
GT_assert(curTrace, (region[i].entry.base != NULL));
}
/* else, nothing to do, entry.base is already physical address */
}
else {
region[i].entry.base = NULL;
}
}
SETIOV(&ctp->iov[0], &msg->o,
sizeof(msg->o) + sizeof(SharedRegionDrv_CmdArgs));
SETIOV(&ctp->iov[1], region,
(sizeof(SharedRegion_Region) * config.numEntries));
return(_RESMGR_NPARTS(2)); /* config.numEntries */
}
/**
* Handler for messageq open API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_messageq_open(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb)
{
MessageQDrv_CmdArgs * cargs = (MessageQDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
MessageQDrv_CmdArgs * out = (MessageQDrv_CmdArgs *) (_DEVCTL_DATA (msg->o));
MessageQ_QueueId queueId = MessageQ_INVALIDMESSAGEQ;
String local_openname = (String)(cargs+1);
out->apiStatus = MessageQ_open (local_openname, &queueId);
GT_1trace (curTrace,
GT_2CLASS,
" MessageQ_open ioctl queueId [0x%x]",
queueId);
out->args.open.queueId = queueId;
if (out->apiStatus >= 0) {
/* At this call to the list to be cleaned-up */
add_ocb_res(ocb, DCMD_MESSAGEQ_CLOSE, (int)out->args.open.queueId, NULL);
}
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(MessageQDrv_CmdArgs));
return _RESMGR_NPARTS(1);
}
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;
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;
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));
}