int das_tmr_read_msg( resmgr_context_t *ctp, RESMGR_OCB_T *pocb,
int num_entries)
{
static das_msg_t msg; /// don't allocate on stack
static int pdata[QMM10XT_N_TIMERS];
unsigned int count;
if ( ( count = qmm10xt_tmr_get_scan( pmain_board, pdata, num_entries ) )
!= num_entries )
{
fprintf(stderr, "TMR_READ: count %d driver count %d\n",
num_entries, count);
}
/*
* Setup message reply header and data buffer.
*/
msg.n = count; /// tells client how many were read
#undef DO_TEST
#ifdef DO_TEST
{
int i;
for (i = 0; i < num_entries; i++)
pdata[i] = i * 1000;
}
#endif
SETIOV(&ctp->iov[0], &msg, sizeof(msg));
SETIOV(&ctp->iov[1], pdata, count * sizeof(unsigned));
MsgReplyv(ctp->rcvid, EOK, ctp->iov, 2);
return (_RESMGR_NOREPLY);
}
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);
}
dev_t rsrcdbmgr_devno_attach(const char *name, int minor_guess, int flags) {
iov_t iovout[3], iovin[1];
rsrc_cmd_t request;
rsrc_minor_request_t data;
if (name && strchr(name, '/')) {
errno = EINVAL;
return((dev_t)-1);
}
if (!name)
name = " ";
request.i.type = RSRCDBMGR_RSRC_CMD;
request.i.subtype = RSRCDBMGR_REQ_ATTACH | RSRCDBMGR_MINOR_NUM;
request.i.pid = 0;
request.i.count = 1;
request.i.nbytes = sizeof(data) + strlen(name) +1;
data.major = 0;
data.minor = minor_guess;
data.flags = flags;
data.name = NULL;
SETIOV(&iovout[0], &request, sizeof(request));
SETIOV(&iovout[1], &data, sizeof(data));
SETIOV(&iovout[2], name, strlen(name) +1);
SETIOV(&iovin[0], &data, sizeof(data));
if (MsgSendv(RSRCDBMGR_COID, iovout, 3, iovin, 1) == -1) {
return((dev_t)-1);
}
return(makedev(0, data.major, data.minor));
}
//----------------------------------------------------------------------------------------------
static int ata_pass_thru(int fd,struct cam_pass_thru *pcpt)
{
int icnt;
int status;
iov_t iov[3];
struct cam_pass_thru cpt;
cpt=*pcpt;
icnt=1;
SETIOV(&iov[0],&cpt,sizeof(cpt));
cpt.cam_timeout=cpt.cam_timeout?cpt.cam_timeout:CAM_TIME_DEFAULT;
if(cpt.cam_sense_len)
{
SETIOV(&iov[1],(void *)cpt.cam_sense_ptr,cpt.cam_sense_len);
cpt.cam_sense_ptr=sizeof(cpt);
icnt++;
}
if(cpt.cam_dxfer_len)
{
SETIOV(&iov[2],(void *)cpt.cam_data_ptr,cpt.cam_dxfer_len);
cpt.cam_data_ptr=(paddr_t)sizeof(cpt)+cpt.cam_sense_len;
icnt++;
}
if((status=devctlv(fd,DCMD_CAM_PASS_THRU,icnt,icnt,iov,iov,NULL)))
pout("ata_pass_thru devctl: %s\n",strerror(status));
pcpt->cam_status=cpt.cam_status;
pcpt->cam_scsi_status=cpt.cam_scsi_status;
return(status);
}
static int
process_read_data(int rcvid, devi_attr_t *attr, devi_ocb_t *ocb, int nbytes)
{
int q_size;
int num_req_packets;
int num_pkts_xfer;
int num_pkts_end;
iov_t iov[3];
int parts = 1;
char *ptr = NULL;
event_bus_line_t *line = attr->line;
if (line->head > ocb->read_ptr)
q_size = line->head - ocb->read_ptr;
else
q_size = RESMGR_Q_SIZE - ocb->read_ptr + line->head;
num_req_packets = nbytes / line->elem_size;
if (num_req_packets == 0)
MsgReply(rcvid, EOK, NULL, 0);
if (q_size < num_req_packets) {
return (-1);
}
num_pkts_xfer = min(num_req_packets, q_size);
num_pkts_end = RESMGR_Q_SIZE - ocb->read_ptr;
switch(line->type) {
case DEVI_CLASS_KBD:
ptr = (char *) line->u.kq;
break;
case DEVI_CLASS_REL:
ptr = (char *) line->u.mq;
break;
case DEVI_CLASS_ABS:
ptr = (char *) line->u.tq;
break;
}
if (num_pkts_end >= num_pkts_xfer)
SETIOV(&iov[0], ptr + line->elem_size * ocb->read_ptr,
num_pkts_xfer * line->elem_size);
else {
SETIOV(&iov[0], ptr + line->elem_size * ocb->read_ptr,
num_pkts_end * line->elem_size);
num_pkts_xfer -= num_pkts_end;
SETIOV(&iov[1], ptr, num_pkts_xfer * line->elem_size);
parts = 2;
}
MsgReplyv(rcvid, num_pkts_xfer * line->elem_size, iov, parts);
ocb->read_ptr = (ocb->read_ptr + num_pkts_xfer) % RESMGR_Q_SIZE;
return (EOK);
}
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);
}
ssize_t write(int fd, const void *buff, size_t nbytes) {
io_write_t msg;
iov_t iov[2];
msg.i.type = _IO_WRITE;
msg.i.combine_len = sizeof msg.i;
msg.i.xtype = _IO_XTYPE_NONE;
msg.i.nbytes = nbytes;
msg.i.zero = 0;
SETIOV(iov + 0, &msg.i, sizeof msg.i);
SETIOV(iov + 1, buff, nbytes);
return MsgSendv(fd, iov, 2, 0, 0);
}
/**
* 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 memmgr_peer_sendnc( pid_t pid, int coid, void *smsg, size_t sbytes, void *rmsg, size_t rbytes )
{
mem_peer_t peer;
iov_t siov[2];
peer.i.type = _MEM_PEER;
peer.i.peer_msg_len = sizeof(peer);
peer.i.pid = pid;
SETIOV(siov + 0, &peer, sizeof peer);
SETIOV(siov + 1, smsg, sbytes);
return MsgSendvsnc( coid, siov, 2, rmsg, rbytes );
}
int sysmgr_confstr_set(int cmd, int name, const char *str) {
sys_conf_t msg;
iov_t iov[2];
msg.i.type = _SYS_CONF;
msg.i.subtype = _SYS_SUB_SET;
msg.i.cmd = _CONF_STR | cmd;
msg.i.name = name;
msg.i.value = str ? strlen(str) : 0;
SETIOV(iov + 0, &msg.i, sizeof msg.i);
SETIOV(iov + 1, str, msg.i.value);
return MsgSendvnc(SYSMGR_COID, iov, 2, 0, 0);
}
int _intr_v86(int swi, struct _v86reg *regs, void *data, int datasize) {
x86_cpu_v86_t msg;
iov_t iov[3];
msg.i.type = _X86_CPU_V86;
msg.i.cputype = SYSPAGE_X86;
msg.i.swi = swi;
SETIOV(iov + 0, &msg, offsetof(struct _x86_cpu_v86, regs));
SETIOV(iov + 1, regs, sizeof *regs);
SETIOV(iov + 2, data, min(datasize, _V86_DATA_SIZE));
return MsgSendvnc(SYSMGR_COID, iov, 3, iov, 3);
}
static int
devi_devctl(resmgr_context_t *ctp, io_devctl_t *msg, RESMGR_OCB_T *ocb)
{
devi_attr_t *attr;
iov_t iov;
char *buffer, *allocd;
long dcmd;
int error, nbytes;
attr = ocb->ocb.attr;
error = EOK;
if ((error = iofunc_devctl(ctp, msg, &ocb->ocb, &attr->attr)) != _RESMGR_DEFAULT)
return (error);
/* ripped off from deva....:-) */
if (!(get_device_direction(dcmd = msg->i.dcmd) & DEVDIR_TOFROM))
nbytes = 0, buffer = allocd = NULL;
else if ((nbytes = msg->i.nbytes) <= ctp->msg_max_size - sizeof(*msg))
buffer = _DEVCTL_DATA(*msg), allocd = NULL;
else if ((buffer = allocd = malloc((nbytes + 3) & ~3)) == NULL)
return (_RESMGR_ERRNO(ENOMEM));
else if ((get_device_direction(dcmd) & DEVDIR_TO)) {
SETIOV(&iov, buffer, nbytes);
if (resmgr_msgreadv(ctp, &iov, 1, sizeof(msg->i)) == -1)
goto error_out;
}
/* TODO: now call a helper function to actually do the devctl
returns < 0 on error, else nbytes to xfer back on EOK */
msg->o.ret_val = error;
if (error == EOK && get_device_direction(dcmd) & DEVDIR_FROM) {
SETIOV(&iov, buffer, nbytes);
if (resmgr_msgwritev(ctp, &iov, 1, sizeof(msg->o)) == -1)
goto error_out;
}
if (allocd != NULL)
free(allocd);
return((error == EOK) ? _RESMGR_PTR(ctp, &msg->o, sizeof(msg->o)) :
_RESMGR_ERRNO(error));
error_out:
error = errno;
if (allocd != NULL)
free(allocd);
return(_RESMGR_ERRNO(error));
}
/**
* 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);
}
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 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 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 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 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_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_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));
}
/*
* Actually do the reply to the client described by the blocked pointer, and
* then afterward we have replied free the blocked strucuture.
*/
static void _iofunc_lock_unblock(iofunc_lock_list_t *list, struct _iofunc_lock_blocked *blocked) {
struct _msg_info info;
struct _io_lock_reply reply;
struct iovec iov[2];
//Some initial sanity checking ...
if (MsgInfo(blocked->rcvid, &info) == EOK && blocked->pflock &&
blocked->pflock->l_sysid == info.scoid) {
SETIOV(&iov[0], &reply, sizeof(reply));
SETIOV(&iov[1], blocked->pflock, sizeof(*blocked->pflock));
(void)MsgReplyv(blocked->rcvid, EOK, iov, 2);
}
_iofunc_blocked_free(blocked);
}
static int
mc9s08dz60_i2c_write(uint8_t reg, uint8_t *val, int num)
{
iov_t siov[3];
i2c_send_t hdr;
hdr.slave.addr = MC9S08DZ60_I2C_ADDRESS;
hdr.slave.fmt = I2C_ADDRFMT_7BIT;
hdr.len = num + 1;
hdr.stop = 1;
SETIOV(&siov[0], &hdr, sizeof(hdr));
SETIOV(&siov[1], ®, 1);
SETIOV(&siov[2], val, num);
return devctlv(fd, DCMD_I2C_SEND, 3, 0, siov, NULL, NULL);
}
static int
ds3232_i2c_write(unsigned char reg, unsigned char val[], unsigned char num)
{
iov_t siov[3];
i2c_send_t hdr;
hdr.slave.addr = DS3232_I2C_ADDRESS;
hdr.slave.fmt = I2C_ADDRFMT_7BIT;
hdr.len = num + 1;
hdr.stop = 1;
SETIOV(&siov[0], &hdr, sizeof(hdr));
SETIOV(&siov[1], ®, sizeof(reg));
SETIOV(&siov[2], val, num);
return devctlv(fd, DCMD_I2C_SEND, 3, 0, siov, NULL, NULL);
}
void *srv_graph(void *v) {
name_attach_t* pnat;
char srv_name[BUFFER_SIZE] = SRV_NAME;
char cmd[BUFFER_SIZE], param[BUFFER_SIZE];
int rcvid;
frame_t frame;
size_t i;
iov_t *piov, header;
FILE * pfcfg = fopen(FILE_NAME_CFG, "r");
if(NULL != pfcfg) {
while(0 == feof(pfcfg)) {
fscanf(pfcfg, "%s %s", cmd, param);
if(0 == strcmp(cmd, "srv_name")) {
strcpy(srv_name, param);
}
}
fclose(pfcfg);
}
//log_start("srv_graph_log", "srv_graph_err");
pnat = name_attach(NULL, srv_name, NAME_FLAG_ATTACH_GLOBAL);
SETIOV(&header, &frame, sizeof(frame_t));
while(true) {
//log_update();
rcvid = MsgReceivev(pnat->chid, &header, 1, NULL);
__ERROR_CONT(rcvid, -1, MSG_ERR_MSGREC);
if(0 == rcvid) {
switch(frame.header.code) {
case _PULSE_CODE_DISCONNECT:
printf("Client has gone\n");
break;
case _PULSE_CODE_UNBLOCK:
printf("_PULSE_CODE_UNBLOCK\n");
__ERROR_CHECK(MsgError(frame.header.value.sival_int, ETIME),-1,MSG_ERR_MSGERR);
break;
default:
break;
}
} else {
if (frame.header.type == _IO_CONNECT) {
printf("Send OK\n");
frame_reply(rcvid, NULL);
continue;
}
frame_datareceive(rcvid, &frame);
frame_reply(rcvid, NULL);
i=0;
while(i<frame.size) {
processtask(frame.ptask+i);
++i;
}
frame_destroy(&frame);
}
//log_stop();
}
}
void *router(void *v) {
wrk_info_t wrk_info = *(wrk_info_t*)v;
int result, rcvid;
iov_t *piov, header;
frame_t frame;
size_t i;
SETIOV(&header, &frame, sizeof(frame_t));
while(true) {
rcvid = MsgReceivev(wrk_info.chid, &header, 1, NULL);
printf("rcvid %i\n", rcvid);
__ERROR_CONT(rcvid, -1, MSG_ERR_MSGREC);
if(0 == rcvid) {
switch(frame.header.code) {
case _PULSE_CODE_DISCONNECT:
printf("Client has gone\n");
break;
default:
break;
}
} else {
if (frame.header.type == _IO_CONNECT) {
printf("Send OK\n");
frame_reply(rcvid, NULL);
continue;
}
if(frame.protocol == STANDART) {
__ERROR_CHECK(MsgError(rcvid, ENOTSUP),-1,MSG_ERR_MSGERR);
continue;
}
printf("Thread %i, client %i\n", wrk_info.id, frame.cid);
if(frame.protocol == NOREPLY) {
for(i=0; i<wrk_info.pslave->amount; ++i) {
if(FULL != wrk_info.pslave->pslave[i].status) {
if(0 == sem_trywait(&wrk_info.pslave->pslave[i].sem)) {
wrk_info.pslave->pslave[i].clientnow ++;
if(wrk_info.pslave->pslave[i].clientnow ==
wrk_info.pslave->pslave[i].clientmax) {
wrk_info.pslave->pslave[i].status = FULL;
}
sem_post(&wrk_info.pslave->pslave[i].sem);
break;
}
}
}
if(i == wrk_info.pslave->amount) {
__ERROR_CHECK(MsgError(rcvid, EAGAIN),-1,MSG_ERR_MSGERR);
continue;
}
frame_datareceive(rcvid, &frame);
frame_reply(rcvid, NULL);
__ERROR_CHECK(frame_send(wrk_info.pslave->pslave[i].coid, &frame, NULL), -1, "sendv");
}
}
}
}
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 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 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);
}
static int
ds3232_i2c_read(unsigned char reg, unsigned char val[], unsigned char num)
{
iov_t siov[2], riov[2];
i2c_sendrecv_t hdr;
hdr.slave.addr = DS3232_I2C_ADDRESS;
hdr.slave.fmt = I2C_ADDRFMT_7BIT;
hdr.send_len = 1;
hdr.recv_len = num;
hdr.stop = 1;
SETIOV(&siov[0], &hdr, sizeof(hdr));
SETIOV(&siov[1], ®, sizeof(reg));
SETIOV(&riov[0], &hdr, sizeof(hdr));
SETIOV(&riov[1], val, num);
return devctlv(fd, DCMD_I2C_SENDRECV, 2, 2, siov, riov, NULL);
}
