user-tcpip.c

来自「lustre 1.6.5 source code」· C语言 代码 · 共 605 行 · 第 1/2 页

        pfd.events = POLLIN;
        pfd.revents = 0;

        /* poll(2) measures timeout in msec */
        timeout *= 1000;
        
        while (nob != 0 && timeout > 0) {
                cfs_time_t current_time;

                rc = poll(&pfd, 1, timeout);
                if (rc < 0)
                        return -errno;
                if (rc == 0)
                        return -ETIMEDOUT;
                if ((pfd.revents & POLLIN) == 0)
                        return -EIO;
                                
                rc = read(sock, buffer, nob);                
                if (rc < 0)
                        return -errno;
                if (rc == 0)
                        return -EIO;
                
                buffer = ((char *)buffer) + rc;
                nob -= rc;

                current_time = cfs_time_current();
                timeout -= cfs_duration_sec(cfs_time_sub(cfs_time_current(),
                                                        start_time));
        }
        
        if (nob == 0)
                return 0;
        else
                return -ETIMEDOUT;
}

/* Just try to connect to localhost to wake up entity that are
 * sleeping in accept() */
void
libcfs_sock_abort_accept(__u16 port)
{
        int                fd, rc;
        struct sockaddr_in locaddr;

        memset(&locaddr, 0, sizeof(locaddr));
        locaddr.sin_family = AF_INET;
        locaddr.sin_port = htons(port);
        locaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

        fd = socket(AF_INET, SOCK_STREAM, 0);
        if ( fd < 0 ) {
                CERROR("socket() failed: errno==%d\n", errno);
                return;
        }        
        
        rc = connect(fd, (struct sockaddr *)&locaddr, sizeof(locaddr));
        if ( rc != 0 ) {
                if ( errno != ECONNREFUSED )
                        CERROR("connect() failed: errno==%d\n", errno);
                else
                        CDEBUG(D_NET, "Nobody to wake up at %d\n", port);
        }
        
        close(fd);
}

/*
 * Network functions of common use
 */

int
libcfs_getpeername(int sock_fd, __u32 *ipaddr_p, __u16 *port_p)
{
        int                rc;
        struct sockaddr_in peer_addr;
        socklen_t          peer_addr_len = sizeof(peer_addr);

        rc = getpeername(sock_fd, (struct sockaddr *)&peer_addr, &peer_addr_len);
        if (rc != 0)
                return -errno;
        
        if (ipaddr_p != NULL)
                *ipaddr_p = ntohl(peer_addr.sin_addr.s_addr);
        if (port_p != NULL)
                *port_p = ntohs(peer_addr.sin_port);

        return 0;
}

int
libcfs_socketpair(int *fdp)
{
        int rc, i;
        
        rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fdp);
        if (rc != 0) {
                rc = -errno;
                CERROR ("Cannot create socket pair\n");
                return rc;
        }
        
        for (i = 0; i < 2; i++) {
                rc = libcfs_fcntl_nonblock(fdp[i]);
                if (rc) {
                        close(fdp[0]);                        
                        close(fdp[1]);
                        return rc;
                }
        }
        
        return 0;
}

int
libcfs_fcntl_nonblock(int fd)
{
        int rc, flags;
        
        flags = fcntl(fd, F_GETFL, 0);
        if (flags == -1) {
                rc = -errno;
                CERROR ("Cannot get socket flags\n");
                return rc;
        }
        
        rc = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
        if (rc != 0) {
                rc = -errno;
                CERROR ("Cannot set socket flags\n");
                return rc;
        }
        
        return 0;
}

int
libcfs_sock_set_nagle(int fd, int nagle)
{
        int rc;
        int option = nagle ? 0 : 1;

#if defined(__sun__) || defined(__sun)
        rc = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &option, sizeof(option));
#else
        rc = setsockopt(fd, SOL_TCP, TCP_NODELAY, &option, sizeof(option));
#endif

        if (rc != 0) {
                rc = -errno;
                CERROR ("Cannot set NODELAY socket option\n");
                return rc;
        }

        return 0;
}

int
libcfs_sock_set_bufsiz(int fd, int bufsiz)
{
        int rc, option;
        
        LASSERT (bufsiz != 0);

        option = bufsiz;
        rc = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &option, sizeof(option));
        if (rc != 0) {
                rc = -errno;
                CERROR ("Cannot set SNDBUF socket option\n");
                return rc;
        }

        option = bufsiz;
        rc = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &option, sizeof(option));
        if (rc != 0) {
                rc = -errno;
                CERROR ("Cannot set RCVBUF socket option\n");
                return rc;
        }

        return 0;
}

int
libcfs_sock_create(int *fdp)
{
        int rc, fd, option;

        fd = socket(AF_INET, SOCK_STREAM, 0);
        if (fd < 0) {
                rc = -errno;
                CERROR ("Cannot create socket\n");
                return rc;
        }

        option = 1;
        rc = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, 
                        &option, sizeof(option));
        if (rc != 0) {
                rc = -errno;
                CERROR  ("Cannot set SO_REUSEADDR for socket\n");
                close(fd);
                return rc;
        } 
        
        *fdp = fd;
        return 0;
}

int
libcfs_sock_bind_to_port(int fd, __u16 port)
{
        int                rc;
        struct sockaddr_in locaddr;

        memset(&locaddr, 0, sizeof(locaddr)); 
        locaddr.sin_family = AF_INET; 
        locaddr.sin_addr.s_addr = INADDR_ANY;
        locaddr.sin_port = htons(port);

        rc = bind(fd, (struct sockaddr *)&locaddr, sizeof(locaddr));
        if (rc != 0) {
                rc = -errno;
                CERROR  ("Cannot bind to port %d\n", port);
                return rc;
        }

        return 0;
}

int
libcfs_sock_connect(int fd, __u32 ip, __u16 port)
{
        int                rc;
        struct sockaddr_in addr;

        memset(&addr, 0, sizeof(addr));
        addr.sin_family      = AF_INET;
        addr.sin_addr.s_addr = htonl(ip);
        addr.sin_port        = htons(port);
        
        rc = connect(fd, (struct sockaddr *)&addr,
                     sizeof(struct sockaddr_in));

        if(rc != 0 && errno != EINPROGRESS) {
                rc = -errno;
                if (rc != -EADDRINUSE && rc != -EADDRNOTAVAIL)
                        CERROR ("Cannot connect to %u.%u.%u.%u:%d (err=%d)\n",
                                HIPQUAD(ip), port, errno);
                return rc;
        }

        return 0;
}

/* NB: EPIPE and ECONNRESET are considered as non-fatal
 * because:
 * 1) it still makes sense to continue reading &&
 * 2) anyway, poll() will set up POLLHUP|POLLERR flags */ 
int libcfs_sock_writev(int fd, const struct iovec *vector, int count)
{
        int rc;
        
        rc = syscall(SYS_writev, fd, vector, count);
        
        if (rc == 0) /* write nothing */ 
                return 0;
        
        if (rc < 0) {
                if (errno == EAGAIN ||   /* write nothing   */
                    errno == EPIPE ||    /* non-fatal error */
                    errno == ECONNRESET) /* non-fatal error */
                        return 0;
                else
                        return -errno;
        }

        return rc;
}

int libcfs_sock_readv(int fd, const struct iovec *vector, int count)
{
        int rc;
        
        rc = syscall(SYS_readv, fd, vector, count);
        
        if (rc == 0) /* EOF */ 
                return -EIO;
        
        if (rc < 0) {
                if (errno == EAGAIN) /* read nothing */
                        return 0;
                else
                        return -errno;
        }

        return rc;
}

#endif /* !defined(REDSTORM) */
#endif /* !__KERNEL__ */