Lines Matching refs:xprt
64 static void xs_close(struct rpc_xprt *xprt);
66 static void xs_tcp_set_socket_timeouts(struct rpc_xprt *xprt,
234 static inline struct sockaddr *xs_addr(struct rpc_xprt *xprt)
236 return (struct sockaddr *) &xprt->addr;
239 static inline struct sockaddr_un *xs_addr_un(struct rpc_xprt *xprt)
241 return (struct sockaddr_un *) &xprt->addr;
244 static inline struct sockaddr_in *xs_addr_in(struct rpc_xprt *xprt)
246 return (struct sockaddr_in *) &xprt->addr;
249 static inline struct sockaddr_in6 *xs_addr_in6(struct rpc_xprt *xprt)
251 return (struct sockaddr_in6 *) &xprt->addr;
254 static void xs_format_common_peer_addresses(struct rpc_xprt *xprt)
256 struct sockaddr *sap = xs_addr(xprt);
264 sun = xs_addr_un(xprt);
271 xprt->address_strings[RPC_DISPLAY_ADDR] =
276 xprt->address_strings[RPC_DISPLAY_ADDR] =
278 sin = xs_addr_in(xprt);
283 xprt->address_strings[RPC_DISPLAY_ADDR] =
285 sin6 = xs_addr_in6(xprt);
292 xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL);
295 static void xs_format_common_peer_ports(struct rpc_xprt *xprt)
297 struct sockaddr *sap = xs_addr(xprt);
301 xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_KERNEL);
304 xprt->address_strings[RPC_DISPLAY_HEX_PORT] = kstrdup(buf, GFP_KERNEL);
307 static void xs_format_peer_addresses(struct rpc_xprt *xprt,
311 xprt->address_strings[RPC_DISPLAY_PROTO] = protocol;
312 xprt->address_strings[RPC_DISPLAY_NETID] = netid;
313 xs_format_common_peer_addresses(xprt);
314 xs_format_common_peer_ports(xprt);
317 static void xs_update_peer_port(struct rpc_xprt *xprt)
319 kfree(xprt->address_strings[RPC_DISPLAY_HEX_PORT]);
320 kfree(xprt->address_strings[RPC_DISPLAY_PORT]);
322 xs_format_common_peer_ports(xprt);
325 static void xs_free_peer_addresses(struct rpc_xprt *xprt)
335 kfree(xprt->address_strings[i]);
615 struct rpc_xprt *xprt = &transport->xprt;
620 if (!xprt->bc_serv)
624 req = xprt_lookup_bc_request(xprt, transport->recv.xid);
651 struct rpc_xprt *xprt = &transport->xprt;
656 spin_lock(&xprt->queue_lock);
657 req = xprt_lookup_rqst(xprt, transport->recv.xid);
663 spin_unlock(&xprt->queue_lock);
667 spin_lock(&xprt->queue_lock);
674 spin_unlock(&xprt->queue_lock);
784 xprt_wake_pending_tasks(&transport->xprt, -EACCES);
789 trace_xs_stream_read_data(&transport->xprt, ret, read);
814 transport->xprt.stat.connect_count++;
815 transport->xprt.stat.connect_start = jiffies;
828 struct rpc_xprt *xprt = &transport->xprt;
835 spin_lock(&xprt->transport_lock);
838 if (xprt_connected(xprt)) {
843 xprt_wait_for_buffer_space(xprt);
847 spin_unlock(&xprt->transport_lock);
854 container_of(req->rq_xprt, struct sock_xprt, xprt);
868 container_of(req->rq_xprt, struct sock_xprt, xprt);
920 struct rpc_xprt *xprt = req->rq_xprt;
922 container_of(xprt, struct sock_xprt, xprt);
935 xprt_force_disconnect(xprt);
971 xprt_force_disconnect(xprt);
991 struct rpc_xprt *xprt = req->rq_xprt;
992 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
995 .msg_name = xs_addr(xprt),
996 .msg_namelen = xprt->addrlen,
1006 if (!xprt_bound(xprt))
1009 if (!xprt_request_get_cong(xprt, req))
1077 struct rpc_xprt *xprt = req->rq_xprt;
1078 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1103 xs_tcp_set_socket_timeouts(xprt, transport->sock);
1129 if (atomic_long_read(&xprt->xmit_queuelen) == 1)
1180 static void xs_sock_reset_state_flags(struct rpc_xprt *xprt)
1182 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1197 static void xs_sock_reset_connection_flags(struct rpc_xprt *xprt)
1199 xprt->connect_cookie++;
1201 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1202 clear_bit(XPRT_CLOSING, &xprt->state);
1203 xs_sock_reset_state_flags(xprt);
1217 struct rpc_xprt *xprt;
1219 if (!(xprt = xprt_from_sock(sk)))
1222 transport = container_of(xprt, struct sock_xprt, xprt);
1227 xprt, -transport->xprt_err);
1228 trace_rpc_socket_error(xprt, sk->sk_socket, transport->xprt_err);
1239 struct rpc_xprt *xprt = &transport->xprt;
1251 set_bit(XPRT_CLOSE_WAIT, &xprt->state);
1255 if (atomic_read(&transport->xprt.swapper))
1271 xprt_clear_connected(xprt);
1272 xs_sock_reset_connection_flags(xprt);
1278 trace_rpc_socket_close(xprt, sock);
1281 xprt_disconnect_done(xprt);
1286 * @xprt: transport
1294 static void xs_close(struct rpc_xprt *xprt)
1296 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1298 dprintk("RPC: xs_close xprt %p\n", xprt);
1303 xprt->reestablish_timeout = 0;
1306 static void xs_inject_disconnect(struct rpc_xprt *xprt)
1308 dprintk("RPC: injecting transport disconnect on xprt=%p\n",
1309 xprt);
1310 xprt_disconnect_done(xprt);
1313 static void xs_xprt_free(struct rpc_xprt *xprt)
1315 xs_free_peer_addresses(xprt);
1316 xprt_free(xprt);
1321 * @xprt: doomed transport
1324 static void xs_destroy(struct rpc_xprt *xprt)
1326 struct sock_xprt *transport = container_of(xprt,
1327 struct sock_xprt, xprt);
1328 dprintk("RPC: xs_destroy xprt %p\n", xprt);
1331 xs_close(xprt);
1334 xs_xprt_free(xprt);
1340 * @xprt: transport
1345 static void xs_udp_data_read_skb(struct rpc_xprt *xprt,
1367 spin_lock(&xprt->queue_lock);
1368 rovr = xprt_lookup_rqst(xprt, *xp);
1373 spin_unlock(&xprt->queue_lock);
1381 spin_lock(&xprt->queue_lock);
1387 spin_lock(&xprt->transport_lock);
1388 xprt_adjust_cwnd(xprt, task, copied);
1389 spin_unlock(&xprt->transport_lock);
1390 spin_lock(&xprt->queue_lock);
1396 spin_unlock(&xprt->queue_lock);
1413 xs_udp_data_read_skb(&transport->xprt, sk, skb);
1439 struct rpc_xprt *xprt;
1443 xprt = xprt_from_sock(sk);
1444 if (xprt != NULL) {
1445 struct sock_xprt *transport = container_of(xprt,
1446 struct sock_xprt, xprt);
1448 trace_xs_data_ready(xprt);
1458 if (xprt->reestablish_timeout)
1459 xprt->reestablish_timeout = 0;
1469 static void xs_tcp_force_close(struct rpc_xprt *xprt)
1471 xprt_force_disconnect(xprt);
1475 static size_t xs_tcp_bc_maxpayload(struct rpc_xprt *xprt)
1488 struct rpc_xprt *xprt;
1491 if (!(xprt = xprt_from_sock(sk)))
1493 transport = container_of(xprt, struct sock_xprt, xprt);
1495 clear_bit(XPRT_CONNECTED, &xprt->state);
1508 struct rpc_xprt *xprt;
1511 if (!(xprt = xprt_from_sock(sk)))
1513 dprintk("RPC: xs_tcp_state_change client %p...\n", xprt);
1515 sk->sk_state, xprt_connected(xprt),
1520 transport = container_of(xprt, struct sock_xprt, xprt);
1521 trace_rpc_socket_state_change(xprt, sk->sk_socket);
1524 if (!xprt_test_and_set_connected(xprt)) {
1525 xprt->connect_cookie++;
1527 xprt_clear_connecting(xprt);
1529 xprt->stat.connect_count++;
1530 xprt->stat.connect_time += (long)jiffies -
1531 xprt->stat.connect_start;
1537 xprt->connect_cookie++;
1538 xprt->reestablish_timeout = 0;
1539 set_bit(XPRT_CLOSING, &xprt->state);
1541 clear_bit(XPRT_CONNECTED, &xprt->state);
1542 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1547 xprt->connect_cookie++;
1548 clear_bit(XPRT_CONNECTED, &xprt->state);
1556 if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
1557 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
1560 set_bit(XPRT_CLOSING, &xprt->state);
1562 clear_bit(XPRT_CONNECTED, &xprt->state);
1568 xprt_clear_connecting(xprt);
1569 clear_bit(XPRT_CLOSING, &xprt->state);
1578 struct rpc_xprt *xprt;
1584 if (unlikely(!(xprt = xprt_from_sock(sk))))
1586 transport = container_of(xprt, struct sock_xprt, xprt);
1627 static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
1629 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1634 sk->sk_rcvbuf = transport->rcvsize * xprt->max_reqs * 2;
1638 sk->sk_sndbuf = transport->sndsize * xprt->max_reqs * 2;
1645 * @xprt: generic transport
1651 static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize)
1653 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1662 xs_udp_do_set_buffer_size(xprt);
1667 * @xprt: controlling transport
1672 static void xs_udp_timer(struct rpc_xprt *xprt, struct rpc_task *task)
1674 spin_lock(&xprt->transport_lock);
1675 xprt_adjust_cwnd(xprt, task, -ETIMEDOUT);
1676 spin_unlock(&xprt->transport_lock);
1712 * @xprt: generic transport
1716 static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
1718 dprintk("RPC: setting port for xprt %p to %u\n", xprt, port);
1720 rpc_set_port(xs_addr(xprt), port);
1721 xs_update_peer_port(xprt);
1726 if (transport->srcport == 0 && transport->xprt.reuseport)
1734 if (port == 0 && transport->xprt.resvport)
1739 static unsigned short xs_sock_srcport(struct rpc_xprt *xprt)
1741 struct sock_xprt *sock = container_of(xprt, struct sock_xprt, xprt);
1750 static int xs_sock_srcaddr(struct rpc_xprt *xprt, char *buf, size_t buflen)
1752 struct sock_xprt *sock = container_of(xprt, struct sock_xprt, xprt);
1773 if (!transport->xprt.resvport)
1788 * transport->xprt.resvport == 0), don't bind. Let the local
1798 * transport->xprt.resvport == 1) xs_get_srcport above will
1804 memcpy(&myaddr, &transport->srcaddr, transport->xprt.addrlen);
1808 transport->xprt.addrlen);
1810 if (transport->xprt.reuseport)
1839 static void xs_local_set_port(struct rpc_xprt *xprt, unsigned short port)
1898 static struct socket *xs_create_sock(struct rpc_xprt *xprt,
1906 err = __sock_create(xprt->xprt_net, family, type, protocol, &sock, 1);
1933 static int xs_local_finish_connecting(struct rpc_xprt *xprt,
1936 struct sock_xprt *transport = container_of(xprt, struct sock_xprt,
1937 xprt);
1946 sk->sk_user_data = xprt;
1953 xprt_clear_connected(xprt);
1964 return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, 0);
1973 struct rpc_xprt *xprt = &transport->xprt;
1978 status = __sock_create(xprt->xprt_net, AF_LOCAL,
1994 dprintk("RPC: worker connecting xprt %p via AF_LOCAL to %s\n",
1995 xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
1997 status = xs_local_finish_connecting(xprt, sock);
1998 trace_rpc_socket_connect(xprt, sock, status);
2001 dprintk("RPC: xprt %p connected to %s\n",
2002 xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
2003 xprt->stat.connect_count++;
2004 xprt->stat.connect_time += (long)jiffies -
2005 xprt->stat.connect_start;
2006 xprt_set_connected(xprt);
2011 dprintk("RPC: xprt %p: socket %s does not exist\n",
2012 xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
2015 dprintk("RPC: xprt %p: connection refused for %s\n",
2016 xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
2021 xprt->address_strings[RPC_DISPLAY_ADDR]);
2025 xprt_clear_connecting(xprt);
2026 xprt_wake_pending_tasks(xprt, status);
2030 static void xs_local_connect(struct rpc_xprt *xprt, struct rpc_task *task)
2032 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2056 xprt_force_disconnect(xprt);
2058 xprt_clear_connecting(xprt);
2059 xprt_wake_pending_tasks(xprt, -ENOTCONN);
2068 static void xs_set_memalloc(struct rpc_xprt *xprt)
2070 struct sock_xprt *transport = container_of(xprt, struct sock_xprt,
2071 xprt);
2079 if (atomic_read(&xprt->swapper))
2085 * @xprt: transport to tag
2091 xs_enable_swap(struct rpc_xprt *xprt)
2093 struct sock_xprt *xs = container_of(xprt, struct sock_xprt, xprt);
2096 if (atomic_inc_return(&xprt->swapper) == 1 &&
2105 * @xprt: transport to tag
2107 * Drop a "swapper" reference to this xprt on behalf of the rpc_clnt. If the
2111 xs_disable_swap(struct rpc_xprt *xprt)
2113 struct sock_xprt *xs = container_of(xprt, struct sock_xprt, xprt);
2116 if (atomic_dec_and_test(&xprt->swapper) &&
2122 static void xs_set_memalloc(struct rpc_xprt *xprt)
2127 xs_enable_swap(struct rpc_xprt *xprt)
2133 xs_disable_swap(struct rpc_xprt *xprt)
2138 static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
2140 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2149 sk->sk_user_data = xprt;
2154 xprt_set_connected(xprt);
2160 xs_set_memalloc(xprt);
2164 xs_udp_do_set_buffer_size(xprt);
2166 xprt->stat.connect_start = jiffies;
2173 struct rpc_xprt *xprt = &transport->xprt;
2178 if (atomic_read(&xprt->swapper))
2180 sock = xs_create_sock(xprt, transport,
2181 xs_addr(xprt)->sa_family, SOCK_DGRAM,
2186 dprintk("RPC: worker connecting xprt %p via %s to "
2187 "%s (port %s)\n", xprt,
2188 xprt->address_strings[RPC_DISPLAY_PROTO],
2189 xprt->address_strings[RPC_DISPLAY_ADDR],
2190 xprt->address_strings[RPC_DISPLAY_PORT]);
2192 xs_udp_finish_connecting(xprt, sock);
2193 trace_rpc_socket_connect(xprt, sock, 0);
2196 xprt_clear_connecting(xprt);
2197 xprt_unlock_connect(xprt, transport);
2198 xprt_wake_pending_tasks(xprt, status);
2204 * @xprt: transport
2209 static void xs_tcp_shutdown(struct rpc_xprt *xprt)
2211 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2217 if (!xprt->reuseport) {
2218 xs_close(xprt);
2229 trace_rpc_socket_shutdown(xprt, sock);
2236 static void xs_tcp_set_socket_timeouts(struct rpc_xprt *xprt,
2239 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2248 spin_lock(&xprt->transport_lock);
2249 keepidle = DIV_ROUND_UP(xprt->timeout->to_initval, HZ);
2250 keepcnt = xprt->timeout->to_retries + 1;
2251 timeo = jiffies_to_msecs(xprt->timeout->to_initval) *
2252 (xprt->timeout->to_retries + 1);
2254 spin_unlock(&xprt->transport_lock);
2267 DIV_ROUND_UP(xprt->connect_timeout, HZ), 1);
2276 static void xs_tcp_do_set_connect_timeout(struct rpc_xprt *xprt,
2280 container_of(xprt, struct sock_xprt, xprt);
2284 memcpy(&to, xprt->timeout, sizeof(to));
2291 xprt->timeout = &transport->tcp_timeout;
2292 xprt->connect_timeout = connect_timeout;
2295 static void xs_tcp_set_connect_timeout(struct rpc_xprt *xprt,
2299 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2301 spin_lock(&xprt->transport_lock);
2302 if (reconnect_timeout < xprt->max_reconnect_timeout)
2303 xprt->max_reconnect_timeout = reconnect_timeout;
2304 if (connect_timeout < xprt->connect_timeout)
2305 xs_tcp_do_set_connect_timeout(xprt, connect_timeout);
2307 spin_unlock(&xprt->transport_lock);
2310 static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
2312 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2324 if (xs_addr(xprt)->sa_family == PF_INET6) {
2329 xs_tcp_set_socket_timeouts(xprt, sock);
2336 sk->sk_user_data = xprt;
2346 xprt_clear_connected(xprt);
2355 if (!xprt_bound(xprt))
2358 xs_set_memalloc(xprt);
2364 return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
2378 struct rpc_xprt *xprt = &transport->xprt;
2382 if (atomic_read(&xprt->swapper))
2385 if (xprt_connected(xprt))
2391 sock = xs_create_sock(xprt, transport, xs_addr(xprt)->sa_family,
2394 xprt_wake_pending_tasks(xprt, PTR_ERR(sock));
2399 dprintk("RPC: worker connecting xprt %p via %s to "
2400 "%s (port %s)\n", xprt,
2401 xprt->address_strings[RPC_DISPLAY_PROTO],
2402 xprt->address_strings[RPC_DISPLAY_ADDR],
2403 xprt->address_strings[RPC_DISPLAY_PORT]);
2405 status = xs_tcp_finish_connecting(xprt, sock);
2406 trace_rpc_socket_connect(xprt, sock, status);
2408 xprt, -status, xprt_connected(xprt),
2415 if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
2416 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
2446 xprt_wake_pending_tasks(xprt, status);
2447 xs_tcp_force_close(xprt);
2449 xprt_clear_connecting(xprt);
2451 xprt_unlock_connect(xprt, transport);
2457 * xprt CONNECTED.
2463 container_of(lower_xprt, struct sock_xprt, xprt);
2464 struct rpc_xprt *upper_xprt = &upper_transport->xprt;
2537 * @data: address of xprt to wake
2546 container_of(lower_xprt, struct sock_xprt, xprt);
2556 container_of(lower_xprt, struct sock_xprt, xprt);
2617 * The "upper-layer xprt" is visible to the RPC consumer. Once it has
2621 * A "lower-layer xprt", created in this function, handles the mechanics
2624 * layer xprt is marked connected.
2631 struct rpc_xprt *upper_xprt = &upper_transport->xprt;
2670 * the lower xprt.
2724 * @xprt: pointer to transport structure
2736 static void xs_connect(struct rpc_xprt *xprt, struct rpc_task *task)
2738 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2741 WARN_ON_ONCE(!xprt_lock_connect(xprt, task, transport));
2744 dprintk("RPC: xs_connect delayed xprt %p for %lu "
2745 "seconds\n", xprt, xprt->reestablish_timeout / HZ);
2747 delay = xprt_reconnect_delay(xprt);
2748 xprt_reconnect_backoff(xprt, XS_TCP_INIT_REEST_TO);
2751 dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
2762 xs_tcp_force_close(&transport->xprt);
2768 xprt_write_space(&transport->xprt);
2784 xprt_wake_pending_tasks(&transport->xprt, sockerr);
2792 xprt_wake_pending_tasks(&transport->xprt, -EAGAIN);
2808 * @xprt: rpc_xprt struct containing statistics
2812 static void xs_local_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
2816 if (xprt_connected(xprt))
2817 idle_time = (long)(jiffies - xprt->last_used) / HZ;
2821 xprt->stat.bind_count,
2822 xprt->stat.connect_count,
2823 xprt->stat.connect_time / HZ,
2825 xprt->stat.sends,
2826 xprt->stat.recvs,
2827 xprt->stat.bad_xids,
2828 xprt->stat.req_u,
2829 xprt->stat.bklog_u,
2830 xprt->stat.max_slots,
2831 xprt->stat.sending_u,
2832 xprt->stat.pending_u);
2837 * @xprt: rpc_xprt struct containing statistics
2841 static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
2843 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2848 xprt->stat.bind_count,
2849 xprt->stat.sends,
2850 xprt->stat.recvs,
2851 xprt->stat.bad_xids,
2852 xprt->stat.req_u,
2853 xprt->stat.bklog_u,
2854 xprt->stat.max_slots,
2855 xprt->stat.sending_u,
2856 xprt->stat.pending_u);
2861 * @xprt: rpc_xprt struct containing statistics
2865 static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
2867 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2870 if (xprt_connected(xprt))
2871 idle_time = (long)(jiffies - xprt->last_used) / HZ;
2876 xprt->stat.bind_count,
2877 xprt->stat.connect_count,
2878 xprt->stat.connect_time / HZ,
2880 xprt->stat.sends,
2881 xprt->stat.recvs,
2882 xprt->stat.bad_xids,
2883 xprt->stat.req_u,
2884 xprt->stat.bklog_u,
2885 xprt->stat.max_slots,
2886 xprt->stat.sending_u,
2887 xprt->stat.pending_u);
2936 container_of(req->rq_xprt, struct sock_xprt, xprt);
2969 struct svc_xprt *xprt;
2973 * Get the server socket associated with this callback xprt
2975 xprt = req->rq_xprt->bc_xprt;
2981 mutex_lock(&xprt->xpt_mutex);
2982 if (test_bit(XPT_DEAD, &xprt->xpt_flags))
2986 mutex_unlock(&xprt->xpt_mutex);
2998 static void bc_close(struct rpc_xprt *xprt)
3000 xprt_disconnect_done(xprt);
3004 * The xprt destroy routine. Again, because this connection is client
3008 static void bc_destroy(struct rpc_xprt *xprt)
3010 dprintk("RPC: bc_destroy xprt %p\n", xprt);
3012 xs_xprt_free(xprt);
3144 struct rpc_xprt *xprt;
3147 if (args->addrlen > sizeof(xprt->addr)) {
3152 xprt = xprt_alloc(args->net, sizeof(*new), slot_table_size,
3154 if (xprt == NULL) {
3160 new = container_of(xprt, struct sock_xprt, xprt);
3162 memcpy(&xprt->addr, args->dstaddr, args->addrlen);
3163 xprt->addrlen = args->addrlen;
3171 xprt_free(xprt);
3176 return xprt;
3195 struct rpc_xprt *xprt;
3198 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries,
3200 if (IS_ERR(xprt))
3201 return xprt;
3202 transport = container_of(xprt, struct sock_xprt, xprt);
3204 xprt->prot = 0;
3205 xprt->xprt_class = &xs_local_transport;
3206 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
3208 xprt->bind_timeout = XS_BIND_TO;
3209 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
3210 xprt->idle_timeout = XS_IDLE_DISC_TO;
3212 xprt->ops = &xs_local_ops;
3213 xprt->timeout = &xs_local_default_timeout;
3227 xprt_set_bound(xprt);
3228 xs_format_peer_addresses(xprt, "local", RPCBIND_NETID_LOCAL);
3235 dprintk("RPC: set up xprt to %s via AF_LOCAL\n",
3236 xprt->address_strings[RPC_DISPLAY_ADDR]);
3239 return xprt;
3242 xs_xprt_free(xprt);
3261 struct rpc_xprt *xprt;
3265 xprt = xs_setup_xprt(args, xprt_udp_slot_table_entries,
3267 if (IS_ERR(xprt))
3268 return xprt;
3269 transport = container_of(xprt, struct sock_xprt, xprt);
3271 xprt->prot = IPPROTO_UDP;
3272 xprt->xprt_class = &xs_udp_transport;
3274 xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
3276 xprt->bind_timeout = XS_BIND_TO;
3277 xprt->reestablish_timeout = XS_UDP_REEST_TO;
3278 xprt->idle_timeout = XS_IDLE_DISC_TO;
3280 xprt->ops = &xs_udp_ops;
3282 xprt->timeout = &xs_udp_default_timeout;
3291 xprt_set_bound(xprt);
3293 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP);
3297 xprt_set_bound(xprt);
3299 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6);
3306 if (xprt_bound(xprt))
3307 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
3308 xprt->address_strings[RPC_DISPLAY_ADDR],
3309 xprt->address_strings[RPC_DISPLAY_PORT],
3310 xprt->address_strings[RPC_DISPLAY_PROTO]);
3312 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
3313 xprt->address_strings[RPC_DISPLAY_ADDR],
3314 xprt->address_strings[RPC_DISPLAY_PROTO]);
3317 return xprt;
3320 xs_xprt_free(xprt);
3338 struct rpc_xprt *xprt;
3346 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries,
3348 if (IS_ERR(xprt))
3349 return xprt;
3350 transport = container_of(xprt, struct sock_xprt, xprt);
3352 xprt->prot = IPPROTO_TCP;
3353 xprt->xprt_class = &xs_tcp_transport;
3354 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
3356 xprt->bind_timeout = XS_BIND_TO;
3357 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
3358 xprt->idle_timeout = XS_IDLE_DISC_TO;
3360 xprt->ops = &xs_tcp_ops;
3361 xprt->timeout = &xs_tcp_default_timeout;
3363 xprt->max_reconnect_timeout = xprt->timeout->to_maxval;
3365 xprt->max_reconnect_timeout = args->reconnect_timeout;
3367 xprt->connect_timeout = xprt->timeout->to_initval *
3368 (xprt->timeout->to_retries + 1);
3370 xs_tcp_do_set_connect_timeout(xprt, args->connect_timeout);
3379 xprt_set_bound(xprt);
3381 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
3385 xprt_set_bound(xprt);
3387 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
3394 if (xprt_bound(xprt))
3395 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
3396 xprt->address_strings[RPC_DISPLAY_ADDR],
3397 xprt->address_strings[RPC_DISPLAY_PORT],
3398 xprt->address_strings[RPC_DISPLAY_PROTO]);
3400 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
3401 xprt->address_strings[RPC_DISPLAY_ADDR],
3402 xprt->address_strings[RPC_DISPLAY_PROTO]);
3405 return xprt;
3408 xs_xprt_free(xprt);
3420 struct rpc_xprt *xprt;
3428 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries,
3430 if (IS_ERR(xprt))
3431 return xprt;
3432 transport = container_of(xprt, struct sock_xprt, xprt);
3434 xprt->prot = IPPROTO_TCP;
3435 xprt->xprt_class = &xs_tcp_transport;
3436 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
3438 xprt->bind_timeout = XS_BIND_TO;
3439 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
3440 xprt->idle_timeout = XS_IDLE_DISC_TO;
3442 xprt->ops = &xs_tcp_ops;
3443 xprt->timeout = &xs_tcp_default_timeout;
3445 xprt->max_reconnect_timeout = xprt->timeout->to_maxval;
3446 xprt->connect_timeout = xprt->timeout->to_initval *
3447 (xprt->timeout->to_retries + 1);
3455 xprt->xprtsec = args->xprtsec;
3467 xprt_set_bound(xprt);
3469 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
3473 xprt_set_bound(xprt);
3475 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
3482 if (xprt_bound(xprt))
3483 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
3484 xprt->address_strings[RPC_DISPLAY_ADDR],
3485 xprt->address_strings[RPC_DISPLAY_PORT],
3486 xprt->address_strings[RPC_DISPLAY_PROTO]);
3488 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
3489 xprt->address_strings[RPC_DISPLAY_ADDR],
3490 xprt->address_strings[RPC_DISPLAY_PROTO]);
3493 return xprt;
3496 xs_xprt_free(xprt);
3508 struct rpc_xprt *xprt;
3513 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries,
3515 if (IS_ERR(xprt))
3516 return xprt;
3517 transport = container_of(xprt, struct sock_xprt, xprt);
3519 xprt->prot = IPPROTO_TCP;
3520 xprt->xprt_class = &xs_bc_tcp_transport;
3521 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
3522 xprt->timeout = &xs_tcp_default_timeout;
3525 xprt_set_bound(xprt);
3526 xprt->bind_timeout = 0;
3527 xprt->reestablish_timeout = 0;
3528 xprt->idle_timeout = 0;
3530 xprt->ops = &bc_tcp_ops;
3534 xs_format_peer_addresses(xprt, "tcp",
3538 xs_format_peer_addresses(xprt, "tcp",
3546 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
3547 xprt->address_strings[RPC_DISPLAY_ADDR],
3548 xprt->address_strings[RPC_DISPLAY_PORT],
3549 xprt->address_strings[RPC_DISPLAY_PROTO]);
3552 * Once we've associated a backchannel xprt with a connection,
3557 xprt_get(xprt);
3558 args->bc_xprt->xpt_bc_xprt = xprt;
3559 xprt->bc_xprt = args->bc_xprt;
3566 * the xprt status to connected
3568 xprt_set_connected(xprt);
3571 return xprt;
3575 xprt_put(xprt);
3578 xs_xprt_free(xprt);