rflwrite.c File Reference

#include <xinu.h>

Include dependency graph for rflwrite.c:

Go to the source code of this file.

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

Function Documentation

rflwrite()

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

Definition at line 9 of file rflwrite.c.

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

Referenced by rflputc().

{
    struct  rflcblk *rfptr;     /* Pointer to control block */
    int32   retval;         /* Return value         */
    struct  rf_msg_wreq  msg;   /* Request message to send  */
    struct  rf_msg_wres resp;   /* Buffer for response      */
    char    *from, *to;     /* Used to copy name        */
    int i;          /* Counts bytes copied into req */
    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 and mode allows writing */

    rfptr = &rfltab[devptr->dvminor];
    if ( (rfptr->rfstate == RF_FREE) ||
         ! (rfptr->rfmode & RF_MODE_W) ) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Form write request */

    msg.rf_type = htons(RF_MSG_WREQ);
    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;
        }
    }
    while ( (*to++ = *from++) ) {   /* Copy name into request   */
        ;
    }
    msg.rf_pos = htonl(rfptr->rfpos);/* Set file position       */
    msg.rf_len = htonl(count);  /* Set count of bytes to write  */
    for (i=0; i<count; i++) {   /* Copy data into message   */
        msg.rf_data[i] = *buff++;
    }
    while (i < RF_DATALEN) {
        msg.rf_data[i++] = NULLCH;
    }

    /* Send message and receive response */

    retval = rfscomm((struct rf_msg_hdr *)&msg,
                    sizeof(struct rf_msg_wreq),
             (struct rf_msg_hdr *)&resp,
                sizeof(struct rf_msg_wres) );

    /* 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;
    }

    /* Report results to caller */

    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: