Lines Matching refs:xprt
60 static void xs_close(struct rpc_xprt *xprt);
61 static void xs_tcp_set_socket_timeouts(struct rpc_xprt *xprt,
227 static inline struct sockaddr *xs_addr(struct rpc_xprt *xprt)
229 return (struct sockaddr *) &xprt->addr;
232 static inline struct sockaddr_un *xs_addr_un(struct rpc_xprt *xprt)
234 return (struct sockaddr_un *) &xprt->addr;
237 static inline struct sockaddr_in *xs_addr_in(struct rpc_xprt *xprt)
239 return (struct sockaddr_in *) &xprt->addr;
242 static inline struct sockaddr_in6 *xs_addr_in6(struct rpc_xprt *xprt)
244 return (struct sockaddr_in6 *) &xprt->addr;
247 static void xs_format_common_peer_addresses(struct rpc_xprt *xprt)
249 struct sockaddr *sap = xs_addr(xprt);
257 sun = xs_addr_un(xprt);
259 xprt->address_strings[RPC_DISPLAY_ADDR] =
264 xprt->address_strings[RPC_DISPLAY_ADDR] =
266 sin = xs_addr_in(xprt);
271 xprt->address_strings[RPC_DISPLAY_ADDR] =
273 sin6 = xs_addr_in6(xprt);
280 xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL);
283 static void xs_format_common_peer_ports(struct rpc_xprt *xprt)
285 struct sockaddr *sap = xs_addr(xprt);
289 xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_KERNEL);
292 xprt->address_strings[RPC_DISPLAY_HEX_PORT] = kstrdup(buf, GFP_KERNEL);
295 static void xs_format_peer_addresses(struct rpc_xprt *xprt,
299 xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
300 xprt->address_strings[RPC_DISPLAY_NETID] = netid;
301 xs_format_common_peer_addresses(xprt);
302 xs_format_common_peer_ports(xprt);
305 static void xs_update_peer_port(struct rpc_xprt *xprt)
307 kfree(xprt->address_strings[RPC_DISPLAY_HEX_PORT]);
308 kfree(xprt->address_strings[RPC_DISPLAY_PORT]);
310 xs_format_common_peer_ports(xprt);
313 static void xs_free_peer_addresses(struct rpc_xprt *xprt)
323 kfree(xprt->address_strings[i]);
557 struct rpc_xprt *xprt = &transport->xprt;
562 req = xprt_lookup_bc_request(xprt, transport->recv.xid);
589 struct rpc_xprt *xprt = &transport->xprt;
594 spin_lock(&xprt->queue_lock);
595 req = xprt_lookup_rqst(xprt, transport->recv.xid);
601 spin_unlock(&xprt->queue_lock);
605 spin_lock(&xprt->queue_lock);
612 spin_unlock(&xprt->queue_lock);
723 trace_xs_stream_read_data(&transport->xprt, ret, read);
748 transport->xprt.stat.connect_count++;
749 transport->xprt.stat.connect_start = jiffies;
762 struct rpc_xprt *xprt = &transport->xprt;
769 spin_lock(&xprt->transport_lock);
772 if (xprt_connected(xprt)) {
783 xprt_wait_for_buffer_space(xprt);
787 spin_unlock(&xprt->transport_lock);
794 container_of(req->rq_xprt, struct sock_xprt, xprt);
808 container_of(req->rq_xprt, struct sock_xprt, xprt);
860 struct rpc_xprt *xprt = req->rq_xprt;
862 container_of(xprt, struct sock_xprt, xprt);
874 xprt_force_disconnect(xprt);
912 xprt_force_disconnect(xprt);
932 struct rpc_xprt *xprt = req->rq_xprt;
933 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
936 .msg_name = xs_addr(xprt),
937 .msg_namelen = xprt->addrlen,
947 if (!xprt_bound(xprt))
950 if (!xprt_request_get_cong(xprt, req))
1015 struct rpc_xprt *xprt = req->rq_xprt;
1016 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1039 xs_tcp_set_socket_timeouts(xprt, transport->sock);
1129 static void xs_sock_reset_state_flags(struct rpc_xprt *xprt)
1131 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1145 static void xs_sock_reset_connection_flags(struct rpc_xprt *xprt)
1148 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1149 clear_bit(XPRT_CLOSING, &xprt->state);
1150 xs_sock_reset_state_flags(xprt);
1164 struct rpc_xprt *xprt;
1167 if (!(xprt = xprt_from_sock(sk)))
1170 transport = container_of(xprt, struct sock_xprt, xprt);
1175 xprt, -transport->xprt_err);
1176 trace_rpc_socket_error(xprt, sk->sk_socket, transport->xprt_err);
1189 struct rpc_xprt *xprt = &transport->xprt;
1201 set_bit(XPRT_CLOSE_WAIT, &xprt->state);
1205 if (atomic_read(&transport->xprt.swapper))
1219 xprt_clear_connected(xprt);
1221 xs_sock_reset_connection_flags(xprt);
1226 trace_rpc_socket_close(xprt, sock);
1229 xprt_disconnect_done(xprt);
1234 * @xprt: transport
1242 static void xs_close(struct rpc_xprt *xprt)
1244 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1246 dprintk("RPC: xs_close xprt %p\n", xprt);
1249 xprt->reestablish_timeout = 0;
1252 static void xs_inject_disconnect(struct rpc_xprt *xprt)
1254 dprintk("RPC: injecting transport disconnect on xprt=%p\n",
1255 xprt);
1256 xprt_disconnect_done(xprt);
1259 static void xs_xprt_free(struct rpc_xprt *xprt)
1261 xs_free_peer_addresses(xprt);
1262 xprt_free(xprt);
1267 * @xprt: doomed transport
1270 static void xs_destroy(struct rpc_xprt *xprt)
1272 struct sock_xprt *transport = container_of(xprt,
1273 struct sock_xprt, xprt);
1274 dprintk("RPC: xs_destroy xprt %p\n", xprt);
1277 xs_close(xprt);
1280 xs_xprt_free(xprt);
1286 * @xprt: transport
1291 static void xs_udp_data_read_skb(struct rpc_xprt *xprt,
1313 spin_lock(&xprt->queue_lock);
1314 rovr = xprt_lookup_rqst(xprt, *xp);
1319 spin_unlock(&xprt->queue_lock);
1327 spin_lock(&xprt->queue_lock);
1333 spin_lock(&xprt->transport_lock);
1334 xprt_adjust_cwnd(xprt, task, copied);
1335 spin_unlock(&xprt->transport_lock);
1336 spin_lock(&xprt->queue_lock);
1342 spin_unlock(&xprt->queue_lock);
1359 xs_udp_data_read_skb(&transport->xprt, sk, skb);
1385 struct rpc_xprt *xprt;
1389 xprt = xprt_from_sock(sk);
1390 if (xprt != NULL) {
1391 struct sock_xprt *transport = container_of(xprt,
1392 struct sock_xprt, xprt);
1397 if (xprt->reestablish_timeout)
1398 xprt->reestablish_timeout = 0;
1409 static void xs_tcp_force_close(struct rpc_xprt *xprt)
1411 xprt_force_disconnect(xprt);
1415 static size_t xs_tcp_bc_maxpayload(struct rpc_xprt *xprt)
1428 struct rpc_xprt *xprt;
1432 if (!(xprt = xprt_from_sock(sk)))
1434 dprintk("RPC: xs_tcp_state_change client %p...\n", xprt);
1436 sk->sk_state, xprt_connected(xprt),
1441 transport = container_of(xprt, struct sock_xprt, xprt);
1442 trace_rpc_socket_state_change(xprt, sk->sk_socket);
1445 if (!xprt_test_and_set_connected(xprt)) {
1446 xprt->connect_cookie++;
1448 xprt_clear_connecting(xprt);
1450 xprt->stat.connect_count++;
1451 xprt->stat.connect_time += (long)jiffies -
1452 xprt->stat.connect_start;
1458 xprt->connect_cookie++;
1459 xprt->reestablish_timeout = 0;
1460 set_bit(XPRT_CLOSING, &xprt->state);
1462 clear_bit(XPRT_CONNECTED, &xprt->state);
1463 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1468 xprt->connect_cookie++;
1469 clear_bit(XPRT_CONNECTED, &xprt->state);
1477 if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
1478 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
1481 set_bit(XPRT_CLOSING, &xprt->state);
1483 clear_bit(XPRT_CONNECTED, &xprt->state);
1489 xprt_clear_connecting(xprt);
1490 clear_bit(XPRT_CLOSING, &xprt->state);
1502 struct rpc_xprt *xprt;
1508 if (unlikely(!(xprt = xprt_from_sock(sk))))
1510 transport = container_of(xprt, struct sock_xprt, xprt);
1564 static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
1566 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1571 sk->sk_rcvbuf = transport->rcvsize * xprt->max_reqs * 2;
1575 sk->sk_sndbuf = transport->sndsize * xprt->max_reqs * 2;
1582 * @xprt: generic transport
1588 static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize)
1590 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1599 xs_udp_do_set_buffer_size(xprt);
1604 * @xprt: controlling transport
1609 static void xs_udp_timer(struct rpc_xprt *xprt, struct rpc_task *task)
1611 spin_lock(&xprt->transport_lock);
1612 xprt_adjust_cwnd(xprt, task, -ETIMEDOUT);
1613 spin_unlock(&xprt->transport_lock);
1649 * @xprt: generic transport
1653 static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
1655 dprintk("RPC: setting port for xprt %p to %u\n", xprt, port);
1657 rpc_set_port(xs_addr(xprt), port);
1658 xs_update_peer_port(xprt);
1663 if (transport->srcport == 0 && transport->xprt.reuseport)
1671 if (port == 0 && transport->xprt.resvport)
1676 unsigned short get_srcport(struct rpc_xprt *xprt)
1678 struct sock_xprt *sock = container_of(xprt, struct sock_xprt, xprt);
1687 if (!transport->xprt.resvport)
1702 * transport->xprt.resvport == 0), don't bind. Let the local
1712 * transport->xprt.resvport == 1) xs_get_srcport above will
1718 memcpy(&myaddr, &transport->srcaddr, transport->xprt.addrlen);
1722 transport->xprt.addrlen);
1724 if (transport->xprt.reuseport)
1753 static void xs_local_set_port(struct rpc_xprt *xprt, unsigned short port)
1812 static struct socket *xs_create_sock(struct rpc_xprt *xprt,
1820 err = __sock_create(xprt->xprt_net, family, type, protocol, &sock, 1);
1847 static int xs_local_finish_connecting(struct rpc_xprt *xprt,
1850 struct sock_xprt *transport = container_of(xprt, struct sock_xprt,
1851 xprt);
1860 sk->sk_user_data = xprt;
1866 xprt_clear_connected(xprt);
1877 return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, 0);
1886 struct rpc_xprt *xprt = &transport->xprt;
1891 status = __sock_create(xprt->xprt_net, AF_LOCAL,
1907 dprintk("RPC: worker connecting xprt %p via AF_LOCAL to %s\n",
1908 xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
1910 status = xs_local_finish_connecting(xprt, sock);
1911 trace_rpc_socket_connect(xprt, sock, status);
1914 dprintk("RPC: xprt %p connected to %s\n",
1915 xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
1916 xprt->stat.connect_count++;
1917 xprt->stat.connect_time += (long)jiffies -
1918 xprt->stat.connect_start;
1919 xprt_set_connected(xprt);
1924 dprintk("RPC: xprt %p: socket %s does not exist\n",
1925 xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
1928 dprintk("RPC: xprt %p: connection refused for %s\n",
1929 xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
1934 xprt->address_strings[RPC_DISPLAY_ADDR]);
1938 xprt_clear_connecting(xprt);
1939 xprt_wake_pending_tasks(xprt, status);
1943 static void xs_local_connect(struct rpc_xprt *xprt, struct rpc_task *task)
1945 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1973 static void xs_set_memalloc(struct rpc_xprt *xprt)
1975 struct sock_xprt *transport = container_of(xprt, struct sock_xprt,
1976 xprt);
1984 if (atomic_read(&xprt->swapper))
1990 * @xprt: transport to tag
1996 xs_enable_swap(struct rpc_xprt *xprt)
1998 struct sock_xprt *xs = container_of(xprt, struct sock_xprt, xprt);
2000 if (atomic_inc_return(&xprt->swapper) != 1)
2002 if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE))
2006 xprt_release_xprt(xprt, NULL);
2012 * @xprt: transport to tag
2014 * Drop a "swapper" reference to this xprt on behalf of the rpc_clnt. If the
2018 xs_disable_swap(struct rpc_xprt *xprt)
2020 struct sock_xprt *xs = container_of(xprt, struct sock_xprt, xprt);
2022 if (!atomic_dec_and_test(&xprt->swapper))
2024 if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE))
2028 xprt_release_xprt(xprt, NULL);
2031 static void xs_set_memalloc(struct rpc_xprt *xprt)
2036 xs_enable_swap(struct rpc_xprt *xprt)
2042 xs_disable_swap(struct rpc_xprt *xprt)
2047 static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
2049 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2058 sk->sk_user_data = xprt;
2063 xprt_set_connected(xprt);
2069 xs_set_memalloc(xprt);
2073 xs_udp_do_set_buffer_size(xprt);
2075 xprt->stat.connect_start = jiffies;
2082 struct rpc_xprt *xprt = &transport->xprt;
2086 sock = xs_create_sock(xprt, transport,
2087 xs_addr(xprt)->sa_family, SOCK_DGRAM,
2092 dprintk("RPC: worker connecting xprt %p via %s to "
2093 "%s (port %s)\n", xprt,
2094 xprt->address_strings[RPC_DISPLAY_PROTO],
2095 xprt->address_strings[RPC_DISPLAY_ADDR],
2096 xprt->address_strings[RPC_DISPLAY_PORT]);
2098 xs_udp_finish_connecting(xprt, sock);
2099 trace_rpc_socket_connect(xprt, sock, 0);
2102 xprt_clear_connecting(xprt);
2103 xprt_unlock_connect(xprt, transport);
2104 xprt_wake_pending_tasks(xprt, status);
2109 * @xprt: transport
2114 static void xs_tcp_shutdown(struct rpc_xprt *xprt)
2116 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2125 trace_rpc_socket_shutdown(xprt, sock);
2133 static void xs_tcp_set_socket_timeouts(struct rpc_xprt *xprt,
2136 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2141 spin_lock(&xprt->transport_lock);
2142 keepidle = DIV_ROUND_UP(xprt->timeout->to_initval, HZ);
2143 keepcnt = xprt->timeout->to_retries + 1;
2144 timeo = jiffies_to_msecs(xprt->timeout->to_initval) *
2145 (xprt->timeout->to_retries + 1);
2147 spin_unlock(&xprt->transport_lock);
2159 static void xs_tcp_set_connect_timeout(struct rpc_xprt *xprt,
2163 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2167 spin_lock(&xprt->transport_lock);
2168 if (reconnect_timeout < xprt->max_reconnect_timeout)
2169 xprt->max_reconnect_timeout = reconnect_timeout;
2170 if (connect_timeout < xprt->connect_timeout) {
2171 memcpy(&to, xprt->timeout, sizeof(to));
2180 xprt->timeout = &transport->tcp_timeout;
2181 xprt->connect_timeout = connect_timeout;
2184 spin_unlock(&xprt->transport_lock);
2187 static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
2189 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2202 if (xs_addr(xprt)->sa_family == PF_INET6) {
2207 xs_tcp_set_socket_timeouts(xprt, sock);
2213 sk->sk_user_data = xprt;
2224 xprt_clear_connected(xprt);
2233 if (!xprt_bound(xprt))
2236 xs_set_memalloc(xprt);
2242 ret = kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
2249 if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
2250 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
2271 struct rpc_xprt *xprt = &transport->xprt;
2274 if (xprt_connected(xprt))
2280 sock = xs_create_sock(xprt, transport, xs_addr(xprt)->sa_family,
2288 dprintk("RPC: worker connecting xprt %p via %s to "
2289 "%s (port %s)\n", xprt,
2290 xprt->address_strings[RPC_DISPLAY_PROTO],
2291 xprt->address_strings[RPC_DISPLAY_ADDR],
2292 xprt->address_strings[RPC_DISPLAY_PORT]);
2294 status = xs_tcp_finish_connecting(xprt, sock);
2295 trace_rpc_socket_connect(xprt, sock, status);
2297 xprt, -status, xprt_connected(xprt),
2308 xs_tcp_force_close(xprt);
2315 xprt_unlock_connect(xprt, transport);
2333 xprt_wake_pending_tasks(xprt, status);
2334 xs_tcp_force_close(xprt);
2339 xprt_clear_connecting(xprt);
2340 xprt_unlock_connect(xprt, transport);
2341 xprt_wake_pending_tasks(xprt, status);
2346 * @xprt: pointer to transport structure
2358 static void xs_connect(struct rpc_xprt *xprt, struct rpc_task *task)
2360 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2363 WARN_ON_ONCE(!xprt_lock_connect(xprt, task, transport));
2366 dprintk("RPC: xs_connect delayed xprt %p for %lu "
2367 "seconds\n", xprt, xprt->reestablish_timeout / HZ);
2369 delay = xprt_reconnect_delay(xprt);
2370 xprt_reconnect_backoff(xprt, XS_TCP_INIT_REEST_TO);
2373 dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
2383 xs_tcp_force_close(&transport->xprt);
2389 xprt_write_space(&transport->xprt);
2405 xprt_wake_pending_tasks(&transport->xprt, sockerr);
2413 xprt_wake_pending_tasks(&transport->xprt, -EAGAIN);
2429 * @xprt: rpc_xprt struct containing statistics
2433 static void xs_local_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
2437 if (xprt_connected(xprt))
2438 idle_time = (long)(jiffies - xprt->last_used) / HZ;
2442 xprt->stat.bind_count,
2443 xprt->stat.connect_count,
2444 xprt->stat.connect_time / HZ,
2446 xprt->stat.sends,
2447 xprt->stat.recvs,
2448 xprt->stat.bad_xids,
2449 xprt->stat.req_u,
2450 xprt->stat.bklog_u,
2451 xprt->stat.max_slots,
2452 xprt->stat.sending_u,
2453 xprt->stat.pending_u);
2458 * @xprt: rpc_xprt struct containing statistics
2462 static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
2464 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2469 xprt->stat.bind_count,
2470 xprt->stat.sends,
2471 xprt->stat.recvs,
2472 xprt->stat.bad_xids,
2473 xprt->stat.req_u,
2474 xprt->stat.bklog_u,
2475 xprt->stat.max_slots,
2476 xprt->stat.sending_u,
2477 xprt->stat.pending_u);
2482 * @xprt: rpc_xprt struct containing statistics
2486 static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
2488 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2491 if (xprt_connected(xprt))
2492 idle_time = (long)(jiffies - xprt->last_used) / HZ;
2497 xprt->stat.bind_count,
2498 xprt->stat.connect_count,
2499 xprt->stat.connect_time / HZ,
2501 xprt->stat.sends,
2502 xprt->stat.recvs,
2503 xprt->stat.bad_xids,
2504 xprt->stat.req_u,
2505 xprt->stat.bklog_u,
2506 xprt->stat.max_slots,
2507 xprt->stat.sending_u,
2508 xprt->stat.pending_u);
2557 container_of(req->rq_xprt, struct sock_xprt, xprt);
2587 struct svc_xprt *xprt;
2591 * Get the server socket associated with this callback xprt
2593 xprt = req->rq_xprt->bc_xprt;
2599 mutex_lock(&xprt->xpt_mutex);
2600 if (test_bit(XPT_DEAD, &xprt->xpt_flags))
2604 mutex_unlock(&xprt->xpt_mutex);
2616 static void bc_close(struct rpc_xprt *xprt)
2618 xprt_disconnect_done(xprt);
2622 * The xprt destroy routine. Again, because this connection is client
2626 static void bc_destroy(struct rpc_xprt *xprt)
2628 dprintk("RPC: bc_destroy xprt %p\n", xprt);
2630 xs_xprt_free(xprt);
2758 struct rpc_xprt *xprt;
2761 if (args->addrlen > sizeof(xprt->addr)) {
2766 xprt = xprt_alloc(args->net, sizeof(*new), slot_table_size,
2768 if (xprt == NULL) {
2774 new = container_of(xprt, struct sock_xprt, xprt);
2776 memcpy(&xprt->addr, args->dstaddr, args->addrlen);
2777 xprt->addrlen = args->addrlen;
2785 xprt_free(xprt);
2790 return xprt;
2809 struct rpc_xprt *xprt;
2812 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries,
2814 if (IS_ERR(xprt))
2815 return xprt;
2816 transport = container_of(xprt, struct sock_xprt, xprt);
2818 xprt->prot = 0;
2819 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
2821 xprt->bind_timeout = XS_BIND_TO;
2822 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
2823 xprt->idle_timeout = XS_IDLE_DISC_TO;
2825 xprt->ops = &xs_local_ops;
2826 xprt->timeout = &xs_local_default_timeout;
2840 xprt_set_bound(xprt);
2841 xs_format_peer_addresses(xprt, "local", RPCBIND_NETID_LOCAL);
2848 dprintk("RPC: set up xprt to %s via AF_LOCAL\n",
2849 xprt->address_strings[RPC_DISPLAY_ADDR]);
2852 return xprt;
2855 xs_xprt_free(xprt);
2874 struct rpc_xprt *xprt;
2878 xprt = xs_setup_xprt(args, xprt_udp_slot_table_entries,
2880 if (IS_ERR(xprt))
2881 return xprt;
2882 transport = container_of(xprt, struct sock_xprt, xprt);
2884 xprt->prot = IPPROTO_UDP;
2886 xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
2888 xprt->bind_timeout = XS_BIND_TO;
2889 xprt->reestablish_timeout = XS_UDP_REEST_TO;
2890 xprt->idle_timeout = XS_IDLE_DISC_TO;
2892 xprt->ops = &xs_udp_ops;
2894 xprt->timeout = &xs_udp_default_timeout;
2903 xprt_set_bound(xprt);
2905 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP);
2909 xprt_set_bound(xprt);
2911 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6);
2918 if (xprt_bound(xprt))
2919 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
2920 xprt->address_strings[RPC_DISPLAY_ADDR],
2921 xprt->address_strings[RPC_DISPLAY_PORT],
2922 xprt->address_strings[RPC_DISPLAY_PROTO]);
2924 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
2925 xprt->address_strings[RPC_DISPLAY_ADDR],
2926 xprt->address_strings[RPC_DISPLAY_PROTO]);
2929 return xprt;
2932 xs_xprt_free(xprt);
2950 struct rpc_xprt *xprt;
2958 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries,
2960 if (IS_ERR(xprt))
2961 return xprt;
2962 transport = container_of(xprt, struct sock_xprt, xprt);
2964 xprt->prot = IPPROTO_TCP;
2965 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
2967 xprt->bind_timeout = XS_BIND_TO;
2968 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
2969 xprt->idle_timeout = XS_IDLE_DISC_TO;
2971 xprt->ops = &xs_tcp_ops;
2972 xprt->timeout = &xs_tcp_default_timeout;
2974 xprt->max_reconnect_timeout = xprt->timeout->to_maxval;
2975 xprt->connect_timeout = xprt->timeout->to_initval *
2976 (xprt->timeout->to_retries + 1);
2985 xprt_set_bound(xprt);
2987 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
2991 xprt_set_bound(xprt);
2993 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
3000 if (xprt_bound(xprt))
3001 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
3002 xprt->address_strings[RPC_DISPLAY_ADDR],
3003 xprt->address_strings[RPC_DISPLAY_PORT],
3004 xprt->address_strings[RPC_DISPLAY_PROTO]);
3006 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
3007 xprt->address_strings[RPC_DISPLAY_ADDR],
3008 xprt->address_strings[RPC_DISPLAY_PROTO]);
3011 return xprt;
3014 xs_xprt_free(xprt);
3026 struct rpc_xprt *xprt;
3031 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries,
3033 if (IS_ERR(xprt))
3034 return xprt;
3035 transport = container_of(xprt, struct sock_xprt, xprt);
3037 xprt->prot = IPPROTO_TCP;
3038 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
3039 xprt->timeout = &xs_tcp_default_timeout;
3042 xprt_set_bound(xprt);
3043 xprt->bind_timeout = 0;
3044 xprt->reestablish_timeout = 0;
3045 xprt->idle_timeout = 0;
3047 xprt->ops = &bc_tcp_ops;
3051 xs_format_peer_addresses(xprt, "tcp",
3055 xs_format_peer_addresses(xprt, "tcp",
3063 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
3064 xprt->address_strings[RPC_DISPLAY_ADDR],
3065 xprt->address_strings[RPC_DISPLAY_PORT],
3066 xprt->address_strings[RPC_DISPLAY_PROTO]);
3069 * Once we've associated a backchannel xprt with a connection,
3074 xprt_get(xprt);
3075 args->bc_xprt->xpt_bc_xprt = xprt;
3076 xprt->bc_xprt = args->bc_xprt;
3083 * the xprt status to connected
3085 xprt_set_connected(xprt);
3088 return xprt;
3092 xprt_put(xprt);
3095 xs_xprt_free(xprt);