Lines Matching refs:xprt
197 struct rpc_xprt xprt;
255 static inline struct sockaddr *xs_addr(struct rpc_xprt *xprt)
257 return (struct sockaddr *) &xprt->addr;
260 static inline struct sockaddr_in *xs_addr_in(struct rpc_xprt *xprt)
262 return (struct sockaddr_in *) &xprt->addr;
265 static inline struct sockaddr_in6 *xs_addr_in6(struct rpc_xprt *xprt)
267 return (struct sockaddr_in6 *) &xprt->addr;
270 static void xs_format_common_peer_addresses(struct rpc_xprt *xprt)
272 struct sockaddr *sap = xs_addr(xprt);
278 xprt->address_strings[RPC_DISPLAY_ADDR] = kstrdup(buf, GFP_KERNEL);
282 sin = xs_addr_in(xprt);
286 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]);
447 struct sock_xprt *transport = container_of(task->tk_rqstp->rq_xprt, struct sock_xprt, xprt);
461 struct rpc_xprt *xprt = req->rq_xprt;
462 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
470 spin_lock_bh(&xprt->transport_lock);
473 if (xprt_connected(xprt)) {
490 spin_unlock_bh(&xprt->transport_lock);
508 struct rpc_xprt *xprt = req->rq_xprt;
509 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
517 if (!xprt_bound(xprt))
520 xs_addr(xprt),
521 xprt->addrlen, xdr,
559 * @xprt: transport
564 static void xs_tcp_shutdown(struct rpc_xprt *xprt)
566 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
583 struct rpc_xprt *xprt = req->rq_xprt;
584 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
635 xs_tcp_shutdown(xprt);
646 * @xprt: transport
653 static void xs_tcp_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
657 if (task != xprt->snd_task)
668 xprt_release_xprt(xprt, task);
711 * @xprt: transport
719 static void xs_close(struct rpc_xprt *xprt)
721 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
723 dprintk("RPC: xs_close xprt %p\n", xprt);
726 xprt->reestablish_timeout = 0;
729 clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
730 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
731 clear_bit(XPRT_CLOSING, &xprt->state);
733 xprt_disconnect_done(xprt);
736 static void xs_tcp_close(struct rpc_xprt *xprt)
738 if (test_and_clear_bit(XPRT_CONNECTION_CLOSE, &xprt->state))
739 xs_close(xprt);
741 xs_tcp_shutdown(xprt);
746 * @xprt: doomed transport
749 static void xs_destroy(struct rpc_xprt *xprt)
751 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
753 dprintk("RPC: xs_destroy xprt %p\n", xprt);
757 xs_close(xprt);
758 xs_free_peer_addresses(xprt);
759 kfree(xprt->slot);
760 kfree(xprt);
778 struct rpc_xprt *xprt;
787 if (!(xprt = xprt_from_sock(sk)))
793 if (xprt->shutdown)
809 spin_lock(&xprt->transport_lock);
810 rovr = xprt_lookup_rqst(xprt, *xp);
833 spin_unlock(&xprt->transport_lock);
840 static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc)
842 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
866 xprt_force_disconnect(xprt);
947 xprt_force_disconnect(&transport->xprt);
952 static inline void xs_tcp_read_common(struct rpc_xprt *xprt,
957 container_of(xprt, struct sock_xprt, xprt);
1007 dprintk("RPC: xprt = %p, tcp_copied = %lu, "
1009 xprt, transport->tcp_copied,
1016 dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, "
1017 "tcp_reclen = %u\n", xprt, transport->tcp_copied,
1032 static inline int xs_tcp_read_reply(struct rpc_xprt *xprt,
1036 container_of(xprt, struct sock_xprt, xprt);
1042 spin_lock(&xprt->transport_lock);
1043 req = xprt_lookup_rqst(xprt, transport->tcp_xid);
1047 spin_unlock(&xprt->transport_lock);
1051 xs_tcp_read_common(xprt, desc, req);
1056 spin_unlock(&xprt->transport_lock);
1068 static inline int xs_tcp_read_callback(struct rpc_xprt *xprt,
1072 container_of(xprt, struct sock_xprt, xprt);
1075 req = xprt_alloc_bc_request(xprt);
1078 xprt_force_disconnect(xprt);
1084 xs_tcp_read_common(xprt, desc, req);
1087 struct svc_serv *bc_serv = xprt->bc_serv;
1107 static inline int _xs_tcp_read_data(struct rpc_xprt *xprt,
1111 container_of(xprt, struct sock_xprt, xprt);
1114 xs_tcp_read_reply(xprt, desc) :
1115 xs_tcp_read_callback(xprt, desc);
1118 static inline int _xs_tcp_read_data(struct rpc_xprt *xprt,
1121 return xs_tcp_read_reply(xprt, desc);
1129 static void xs_tcp_read_data(struct rpc_xprt *xprt,
1133 container_of(xprt, struct sock_xprt, xprt);
1135 if (_xs_tcp_read_data(xprt, desc) == 0)
1162 struct rpc_xprt *xprt = rd_desc->arg.data;
1163 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1175 xs_tcp_read_fraghdr(xprt, &desc);
1190 xs_tcp_read_data(xprt, &desc);
1208 struct rpc_xprt *xprt;
1215 if (!(xprt = xprt_from_sock(sk)))
1217 if (xprt->shutdown)
1223 if (xprt->reestablish_timeout)
1224 xprt->reestablish_timeout = 0;
1226 /* We use rd_desc to pass struct xprt to xs_tcp_data_recv */
1227 rd_desc.arg.data = xprt;
1241 static void xs_tcp_schedule_linger_timeout(struct rpc_xprt *xprt,
1246 if (xprt_test_and_set_connecting(xprt))
1248 set_bit(XPRT_CONNECTION_ABORT, &xprt->state);
1249 transport = container_of(xprt, struct sock_xprt, xprt);
1254 static void xs_tcp_cancel_linger_timeout(struct rpc_xprt *xprt)
1258 transport = container_of(xprt, struct sock_xprt, xprt);
1260 if (!test_bit(XPRT_CONNECTION_ABORT, &xprt->state) ||
1263 clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
1264 xprt_clear_connecting(xprt);
1267 static void xs_sock_mark_closed(struct rpc_xprt *xprt)
1270 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1271 clear_bit(XPRT_CLOSING, &xprt->state);
1274 xprt_disconnect_done(xprt);
1284 struct rpc_xprt *xprt;
1287 if (!(xprt = xprt_from_sock(sk)))
1289 dprintk("RPC: xs_tcp_state_change client %p...\n", xprt);
1291 sk->sk_state, xprt_connected(xprt),
1298 spin_lock(&xprt->transport_lock);
1299 if (!xprt_test_and_set_connected(xprt)) {
1300 struct sock_xprt *transport = container_of(xprt,
1301 struct sock_xprt, xprt);
1310 xprt_wake_pending_tasks(xprt, -EAGAIN);
1312 spin_unlock(&xprt->transport_lock);
1316 xprt->connect_cookie++;
1317 xprt->reestablish_timeout = 0;
1318 set_bit(XPRT_CLOSING, &xprt->state);
1320 clear_bit(XPRT_CONNECTED, &xprt->state);
1321 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
1323 xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
1327 xprt_force_disconnect(xprt);
1329 xprt->connect_cookie++;
1335 if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
1336 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
1339 set_bit(XPRT_CLOSING, &xprt->state);
1340 xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
1342 clear_bit(XPRT_CONNECTED, &xprt->state);
1346 xs_tcp_cancel_linger_timeout(xprt);
1347 xs_sock_mark_closed(xprt);
1359 struct rpc_xprt *xprt;
1362 if (!(xprt = xprt_from_sock(sk)))
1366 __func__, xprt, sk->sk_err);
1367 xprt_wake_pending_tasks(xprt, -EAGAIN);
1375 struct rpc_xprt *xprt;
1381 if (unlikely(!(xprt = xprt_from_sock(sk))))
1386 xprt_write_space(xprt);
1431 static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
1433 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1438 sk->sk_rcvbuf = transport->rcvsize * xprt->max_reqs * 2;
1442 sk->sk_sndbuf = transport->sndsize * xprt->max_reqs * 2;
1449 * @xprt: generic transport
1455 static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize)
1457 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1466 xs_udp_do_set_buffer_size(xprt);
1489 * @xprt: generic transport
1493 static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
1495 dprintk("RPC: setting port for xprt %p to %u\n", xprt, port);
1497 rpc_set_port(xs_addr(xprt), port);
1498 xs_update_peer_port(xprt);
1505 if (port == 0 && transport->xprt.resvport)
1514 if (!transport->xprt.resvport)
1617 static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1619 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1628 sk->sk_user_data = xprt;
1635 xprt_set_connected(xprt);
1643 xs_udp_do_set_buffer_size(xprt);
1656 struct rpc_xprt *xprt = &transport->xprt;
1660 if (xprt->shutdown)
1678 dprintk("RPC: worker connecting xprt %p via %s to "
1679 "%s (port %s)\n", xprt,
1680 xprt->address_strings[RPC_DISPLAY_PROTO],
1681 xprt->address_strings[RPC_DISPLAY_ADDR],
1682 xprt->address_strings[RPC_DISPLAY_PORT]);
1684 xs_udp_finish_connecting(xprt, sock);
1687 xprt_clear_connecting(xprt);
1688 xprt_wake_pending_tasks(xprt, status);
1701 struct rpc_xprt *xprt = &transport->xprt;
1705 if (xprt->shutdown)
1723 dprintk("RPC: worker connecting xprt %p via %s to "
1724 "%s (port %s)\n", xprt,
1725 xprt->address_strings[RPC_DISPLAY_PROTO],
1726 xprt->address_strings[RPC_DISPLAY_ADDR],
1727 xprt->address_strings[RPC_DISPLAY_PORT]);
1729 xs_udp_finish_connecting(xprt, sock);
1732 xprt_clear_connecting(xprt);
1733 xprt_wake_pending_tasks(xprt, status);
1740 static void xs_abort_connection(struct rpc_xprt *xprt, struct sock_xprt *transport)
1745 dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt);
1755 xs_sock_mark_closed(xprt);
1761 static void xs_tcp_reuse_connection(struct rpc_xprt *xprt, struct sock_xprt *transport)
1784 xs_abort_connection(xprt, transport);
1787 static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
1789 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1798 sk->sk_user_data = xprt;
1811 xprt_clear_connected(xprt);
1820 if (!xprt_bound(xprt))
1824 xprt->stat.connect_count++;
1825 xprt->stat.connect_start = jiffies;
1826 return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
1831 * @xprt: RPC transport to connect
1837 static void xs_tcp_setup_socket(struct rpc_xprt *xprt,
1845 if (xprt->shutdown)
1849 clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
1850 sock = create_sock(xprt, transport);
1859 &xprt->state);
1861 xs_tcp_reuse_connection(xprt, transport);
1867 dprintk("RPC: worker connecting xprt %p via %s to "
1868 "%s (port %s)\n", xprt,
1869 xprt->address_strings[RPC_DISPLAY_PROTO],
1870 xprt->address_strings[RPC_DISPLAY_ADDR],
1871 xprt->address_strings[RPC_DISPLAY_PORT]);
1873 status = xs_tcp_finish_connecting(xprt, sock);
1875 xprt, -status, xprt_connected(xprt),
1885 set_bit(XPRT_CONNECTION_CLOSE, &xprt->state);
1886 xprt_force_disconnect(xprt);
1895 xprt_clear_connecting(xprt);
1906 xprt_clear_connecting(xprt);
1907 xprt_wake_pending_tasks(xprt, status);
1910 static struct socket *xs_create_tcp_sock4(struct rpc_xprt *xprt,
1944 struct rpc_xprt *xprt = &transport->xprt;
1946 xs_tcp_setup_socket(xprt, transport, xs_create_tcp_sock4);
1949 static struct socket *xs_create_tcp_sock6(struct rpc_xprt *xprt,
1983 struct rpc_xprt *xprt = &transport->xprt;
1985 xs_tcp_setup_socket(xprt, transport, xs_create_tcp_sock6);
2003 struct rpc_xprt *xprt = task->tk_xprt;
2004 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2007 dprintk("RPC: xs_connect delayed xprt %p for %lu "
2009 xprt, xprt->reestablish_timeout / HZ);
2012 xprt->reestablish_timeout);
2013 xprt->reestablish_timeout <<= 1;
2014 if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
2015 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
2016 if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO)
2017 xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO;
2019 dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
2027 * @xprt: rpc_xprt struct containing statistics
2031 static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
2033 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2037 xprt->stat.bind_count,
2038 xprt->stat.sends,
2039 xprt->stat.recvs,
2040 xprt->stat.bad_xids,
2041 xprt->stat.req_u,
2042 xprt->stat.bklog_u);
2047 * @xprt: rpc_xprt struct containing statistics
2051 static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
2053 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
2056 if (xprt_connected(xprt))
2057 idle_time = (long)(jiffies - xprt->last_used) / HZ;
2061 xprt->stat.bind_count,
2062 xprt->stat.connect_count,
2063 xprt->stat.connect_time,
2065 xprt->stat.sends,
2066 xprt->stat.recvs,
2067 xprt->stat.bad_xids,
2068 xprt->stat.req_u,
2069 xprt->stat.bklog_u);
2116 struct rpc_xprt *xprt = req->rq_xprt;
2118 container_of(xprt, struct sock_xprt, xprt);
2148 struct svc_xprt *xprt;
2154 * Get the server socket associated with this callback xprt
2156 xprt = req->rq_xprt->bc_xprt;
2157 svsk = container_of(xprt, struct svc_sock, sk_xprt);
2163 if (!mutex_trylock(&xprt->xpt_mutex)) {
2164 rpc_sleep_on(&xprt->xpt_bc_pending, task, NULL);
2165 if (!mutex_trylock(&xprt->xpt_mutex))
2167 rpc_wake_up_queued_task(&xprt->xpt_bc_pending, task);
2169 if (test_bit(XPT_DEAD, &xprt->xpt_flags))
2173 mutex_unlock(&xprt->xpt_mutex);
2185 static void bc_close(struct rpc_xprt *xprt)
2190 * The xprt destroy routine. Again, because this connection is client
2194 static void bc_destroy(struct rpc_xprt *xprt)
2250 struct rpc_xprt *xprt;
2253 if (args->addrlen > sizeof(xprt->addr)) {
2264 xprt = &new->xprt;
2266 xprt->max_reqs = slot_table_size;
2267 xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL);
2268 if (xprt->slot == NULL) {
2269 kfree(xprt);
2275 memcpy(&xprt->addr, args->dstaddr, args->addrlen);
2276 xprt->addrlen = args->addrlen;
2280 return xprt;
2298 struct rpc_xprt *xprt;
2302 xprt = xs_setup_xprt(args, xprt_udp_slot_table_entries);
2303 if (IS_ERR(xprt))
2304 return xprt;
2305 transport = container_of(xprt, struct sock_xprt, xprt);
2307 xprt->prot = IPPROTO_UDP;
2308 xprt->tsh_size = 0;
2309 xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
2311 xprt->bind_timeout = XS_BIND_TO;
2312 xprt->reestablish_timeout = XS_UDP_REEST_TO;
2313 xprt->idle_timeout = XS_IDLE_DISC_TO;
2315 xprt->ops = &xs_udp_ops;
2317 xprt->timeout = &xs_udp_default_timeout;
2322 xprt_set_bound(xprt);
2326 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP);
2330 xprt_set_bound(xprt);
2334 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6);
2341 if (xprt_bound(xprt))
2342 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
2343 xprt->address_strings[RPC_DISPLAY_ADDR],
2344 xprt->address_strings[RPC_DISPLAY_PORT],
2345 xprt->address_strings[RPC_DISPLAY_PROTO]);
2347 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
2348 xprt->address_strings[RPC_DISPLAY_ADDR],
2349 xprt->address_strings[RPC_DISPLAY_PROTO]);
2352 return xprt;
2355 kfree(xprt->slot);
2356 kfree(xprt);
2374 struct rpc_xprt *xprt;
2378 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
2379 if (IS_ERR(xprt))
2380 return xprt;
2381 transport = container_of(xprt, struct sock_xprt, xprt);
2383 xprt->prot = IPPROTO_TCP;
2384 xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
2385 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
2387 xprt->bind_timeout = XS_BIND_TO;
2388 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
2389 xprt->idle_timeout = XS_IDLE_DISC_TO;
2391 xprt->ops = &xs_tcp_ops;
2392 xprt->timeout = &xs_tcp_default_timeout;
2397 xprt_set_bound(xprt);
2401 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP);
2405 xprt_set_bound(xprt);
2409 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
2416 if (xprt_bound(xprt))
2417 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
2418 xprt->address_strings[RPC_DISPLAY_ADDR],
2419 xprt->address_strings[RPC_DISPLAY_PORT],
2420 xprt->address_strings[RPC_DISPLAY_PROTO]);
2422 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
2423 xprt->address_strings[RPC_DISPLAY_ADDR],
2424 xprt->address_strings[RPC_DISPLAY_PROTO]);
2428 return xprt;
2431 kfree(xprt->slot);
2432 kfree(xprt);
2444 struct rpc_xprt *xprt;
2449 xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
2450 if (IS_ERR(xprt))
2451 return xprt;
2452 transport = container_of(xprt, struct sock_xprt, xprt);
2454 xprt->prot = IPPROTO_TCP;
2455 xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
2456 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
2457 xprt->timeout = &xs_tcp_default_timeout;
2460 xprt_set_bound(xprt);
2461 xprt->bind_timeout = 0;
2462 xprt->reestablish_timeout = 0;
2463 xprt->idle_timeout = 0;
2469 xprt->bc_xprt = args->bc_xprt;
2471 bc_sock->sk_bc_xprt = xprt;
2475 xprt->ops = &bc_tcp_ops;
2479 xs_format_peer_addresses(xprt, "tcp",
2483 xs_format_peer_addresses(xprt, "tcp",
2491 if (xprt_bound(xprt))
2492 dprintk("RPC: set up xprt to %s (port %s) via %s\n",
2493 xprt->address_strings[RPC_DISPLAY_ADDR],
2494 xprt->address_strings[RPC_DISPLAY_PORT],
2495 xprt->address_strings[RPC_DISPLAY_PROTO]);
2497 dprintk("RPC: set up xprt to %s (autobind) via %s\n",
2498 xprt->address_strings[RPC_DISPLAY_ADDR],
2499 xprt->address_strings[RPC_DISPLAY_PROTO]);
2503 * the xprt status to connected
2505 xprt_set_connected(xprt);
2509 return xprt;
2512 kfree(xprt->slot);
2513 kfree(xprt);