rflread.c File Reference

#include <xinu.h>

Include dependency graph for rflread.c:

Go to the source code of this file.

Functions
devcall	rflread (struct dentry *devptr, char *buff, int32 count)

Function Documentation

rflread()

devcall rflread	(	struct dentry *	devptr,
		char *	buff,
		int32	count
	)

Definition at line 9 of file rflread.c.

References dentry::dvminor, htonl, htons, kprintf(), memset(), ntohl, ntohs, NULLCH, Rf_data, RF_DATALEN, RF_FREE, rf_msg_rreq::rf_len, RF_MODE_R, RF_MSG_RREQ, rfdata::rf_mutex, RF_NAMLEN, rf_msg_rreq::rf_pos, rfltab, rflcblk::rfmode, rflcblk::rfname, rflcblk::rfpos, rfscomm(), rflcblk::rfstate, signal(), SYSERR, TIMEOUT, and wait().

Referenced by rflgetc().

{
    struct  rflcblk *rfptr;     /* Pointer to control block */
    int32   retval;         /* Return value         */
    struct  rf_msg_rreq  msg;   /* Request message to send  */
    struct  rf_msg_rres resp;   /* Buffer for response      */
    int32   i;          /* Counts bytes copied      */
    char    *from, *to;     /* Used during name copy    */
    int32   len;            /* Length of name       */

    /* Wait for exclusive access */

    wait(Rf_data.rf_mutex);

    /* Verify count is legitimate */

    if ( (count <= 0) || (count > RF_DATALEN) ) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Verify pseudo-device is in use */

    rfptr = &rfltab[devptr->dvminor];

    /* If device not currently in use, report an error */

    if (rfptr->rfstate == RF_FREE) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Verify pseudo-device allows reading */

    if ((rfptr->rfmode & RF_MODE_R) == 0) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Form read request */

    msg.rf_type = htons(RF_MSG_RREQ);
    msg.rf_status = htons(0);
    msg.rf_seq = 0;         /* Rfscomm will set sequence    */
    from = rfptr->rfname;
    to = msg.rf_name;
    memset(to, NULLCH, RF_NAMLEN);  /* Start name as all zero bytes */
    len = 0;
    while ( (*to++ = *from++) ) {   /* Copy name to request     */
        if (++len >= RF_NAMLEN) {
            signal(Rf_data.rf_mutex);
            return SYSERR;
        }
    }
    msg.rf_pos = htonl(rfptr->rfpos);/* Set file position       */
    msg.rf_len = htonl(count);  /* Set count of bytes to read   */

    /* Send message and receive response */

    retval = rfscomm((struct rf_msg_hdr *)&msg,
                    sizeof(struct rf_msg_rreq),
             (struct rf_msg_hdr *)&resp,
                    sizeof(struct rf_msg_rres) );

    /* Check response */

    if (retval == SYSERR) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    } else if (retval == TIMEOUT) {
        kprintf("Timeout during remote file read\n");
        signal(Rf_data.rf_mutex);
        return SYSERR;
    } else if (ntohs(resp.rf_status) != 0) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Copy data to application buffer and update file position */

    for (i=0; i<ntohl(resp.rf_len); i++) {
        *buff++ = resp.rf_data[i];
    }
    rfptr->rfpos += ntohl(resp.rf_len);

    signal(Rf_data.rf_mutex);
    return ntohl(resp.rf_len);
}

Here is the call graph for this function:

Here is the caller graph for this function: