rdscomm.c File Reference

#include <xinu.h>

Include dependency graph for rdscomm.c:

Go to the source code of this file.

Functions
status	rdscomm (struct rd_msg_hdr *msg, int32 mlen, struct rd_msg_hdr *reply, int32 rlen, struct rdscblk *rdptr)

Function Documentation

rdscomm()

status rdscomm	(	struct rd_msg_hdr *	msg,
		int32	mlen,
		struct rd_msg_hdr *	reply,
		int32	rlen,
		struct rdscblk *	rdptr
	)

Definition at line 11 of file rdscomm.c.

References disable(), FALSE, getlocalip(), htonl, network::ipvalid, kprintf(), NetData, ntohl, ntohs, OK, rdscblk::rd_loc_port, RD_MSG_RESPONSE, rdscblk::rd_registered, RD_RETRIES, rdscblk::rd_seq, rdscblk::rd_ser_ip, rdscblk::rd_ser_port, RD_TIMEOUT, rdscblk::rd_udpslot, restore(), SYSERR, TIMEOUT, TRUE, udp_recv(), udp_register(), and udp_sendto().

Referenced by rdscontrol(), rdsopen(), and rdsprocess().

{
    intmask     mask;       /* Saved interrupt mask     */
    int32       i;      /* Counts retries       */
    int32       retval;     /* Return value         */
    int32       seq;        /* Sequence for this exchange   */
    uint32      localip;    /* Local IP address     */
    int16       rtype;      /* Reply type in host byte order*/
    bool8       xmit;       /* Should we transmit again?    */
    int32       slot;       /* UDP slot         */

    /* Disable interrupts while testing status */

    mask = disable();

    /* Register the server port, if not registered */

    if ( ! rdptr->rd_registered ) {
        slot = udp_register(0, rdptr->rd_ser_port,
                        rdptr->rd_loc_port);
        if(slot == SYSERR) {
            restore(mask);
            return SYSERR;
        }
        rdptr->rd_udpslot = slot;
        rdptr->rd_registered = TRUE;
    }

    /* Get the local IP address */

    if ( NetData.ipvalid == FALSE ) {
        localip = getlocalip();
        if((int32)localip == SYSERR) {
            restore(mask);
            return SYSERR;
        }
    }
    restore(mask);

    /* Retrieve the saved UDP slot number  */

    slot = rdptr->rd_udpslot;

    /* Assign message next sequence number */

    seq = rdptr->rd_seq++;
    msg->rd_seq = htonl(seq);

    /* Repeat RD_RETRIES times: send message and receive reply */

    xmit = TRUE;
    for (i=0; i<RD_RETRIES; i++) {
        if (xmit) {

        /* Send a copy of the message */

        retval = udp_sendto(slot, rdptr->rd_ser_ip, rdptr->rd_ser_port,
                    (char *)msg, mlen);
        if (retval == SYSERR) {
            kprintf("Cannot send to remote disk server\n\r");
            return SYSERR;
        }
        } else {
        xmit = TRUE;
        }

        /* Receive a reply */

        retval = udp_recv(slot, (char *)reply, rlen,
                        RD_TIMEOUT);

        if (retval == TIMEOUT) {
        continue;
        } else if (retval == SYSERR) {
        kprintf("Error reading remote disk reply\n\r");
        return SYSERR;
        }

        /* Verify that sequence in reply matches request */

        
        if (ntohl(reply->rd_seq) < seq) {
        xmit = FALSE;
        } else if (ntohl(reply->rd_seq) != seq) {
            continue;
        }

        /* Verify the type in the reply matches the request */

        rtype = ntohs(reply->rd_type);
        if (rtype != ( ntohs(msg->rd_type) | RD_MSG_RESPONSE) ) {
        continue;
        }

        /* Check the status */

        if (ntohs(reply->rd_status) != 0) {
        return SYSERR;
        }

        return OK;
    }

    /* Retries exhausted without success */

    kprintf("Timeout on exchange with remote disk server\n\r");
    return TIMEOUT;
}

Here is the call graph for this function:

Here is the caller graph for this function: