Lines Matching defs:xprt
210 struct rpc_xprt xprt;
258 static void xs_format_peer_addresses(struct rpc_xprt *xprt)
260 struct sockaddr_in *addr = (struct sockaddr_in *) &xprt->addr;
268 xprt->address_strings[RPC_DISPLAY_ADDR] = buf;
275 xprt->address_strings[RPC_DISPLAY_PORT] = buf;
277 if (xprt->prot == IPPROTO_UDP)
278 xprt->address_strings[RPC_DISPLAY_PROTO] = "udp";
280 xprt->address_strings[RPC_DISPLAY_PROTO] = "tcp";
287 xprt->prot == IPPROTO_UDP ? "udp" : "tcp");
289 xprt->address_strings[RPC_DISPLAY_ALL] = buf;
292 static void xs_free_peer_addresses(struct rpc_xprt *xprt)
294 kfree(xprt->address_strings[RPC_DISPLAY_ADDR]);
295 kfree(xprt->address_strings[RPC_DISPLAY_PORT]);
296 kfree(xprt->address_strings[RPC_DISPLAY_ALL]);
413 struct rpc_xprt *xprt = req->rq_xprt;
414 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
422 spin_lock_bh(&xprt->transport_lock);
425 if (!xprt_connected(xprt))
430 spin_unlock_bh(&xprt->transport_lock);
450 struct rpc_xprt *xprt = req->rq_xprt;
451 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
461 (struct sockaddr *) &xprt->addr,
462 xprt->addrlen, xdr,
504 struct rpc_xprt *xprt = req->rq_xprt;
505 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
556 xprt_disconnect(xprt);
565 * @xprt: transport
572 static void xs_tcp_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
576 if (task != xprt->snd_task)
587 xprt_release_xprt(xprt, task);
592 * @xprt: transport
597 static void xs_close(struct rpc_xprt *xprt)
599 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
606 dprintk("RPC: xs_close xprt %p\n", xprt);
623 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
629 * @xprt: doomed transport
632 static void xs_destroy(struct rpc_xprt *xprt)
634 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
636 dprintk("RPC: xs_destroy xprt %p\n", xprt);
641 xprt_disconnect(xprt);
642 xs_close(xprt);
643 xs_free_peer_addresses(xprt);
644 kfree(xprt->slot);
645 kfree(xprt);
662 struct rpc_xprt *xprt;
671 if (!(xprt = xprt_from_sock(sk)))
677 if (xprt->shutdown)
693 spin_lock(&xprt->transport_lock);
694 rovr = xprt_lookup_rqst(xprt, *xp);
714 spin_unlock(&xprt->transport_lock);
721 static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc)
723 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
747 xprt_disconnect(xprt);
787 static inline void xs_tcp_read_request(struct rpc_xprt *xprt, struct xdr_skb_reader *desc)
789 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
796 spin_lock(&xprt->transport_lock);
797 req = xprt_lookup_rqst(xprt, transport->tcp_xid);
802 spin_unlock(&xprt->transport_lock);
839 dprintk("RPC: xprt = %p, tcp_copied = %lu, "
841 xprt, transport->tcp_copied,
848 dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, "
849 "tcp_reclen = %u\n", xprt, transport->tcp_copied,
862 spin_unlock(&xprt->transport_lock);
882 struct rpc_xprt *xprt = rd_desc->arg.data;
883 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
895 xs_tcp_read_fraghdr(xprt, &desc);
905 xs_tcp_read_request(xprt, &desc);
923 struct rpc_xprt *xprt;
929 if (!(xprt = xprt_from_sock(sk)))
931 if (xprt->shutdown)
934 /* We use rd_desc to pass struct xprt to xs_tcp_data_recv */
935 rd_desc.arg.data = xprt;
949 struct rpc_xprt *xprt;
952 if (!(xprt = xprt_from_sock(sk)))
954 dprintk("RPC: xs_tcp_state_change client %p...\n", xprt);
956 sk->sk_state, xprt_connected(xprt),
962 spin_lock_bh(&xprt->transport_lock);
963 if (!xprt_test_and_set_connected(xprt)) {
964 struct sock_xprt *transport = container_of(xprt,
965 struct sock_xprt, xprt);
974 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
975 xprt_wake_pending_tasks(xprt, 0);
977 spin_unlock_bh(&xprt->transport_lock);
984 set_bit(XPRT_CLOSE_WAIT, &xprt->state);
985 if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0)
986 schedule_work(&xprt->task_cleanup);
988 xprt_disconnect(xprt);
1011 struct rpc_xprt *xprt;
1015 if (unlikely(!(xprt = xprt_from_sock(sk))))
1020 xprt_write_space(xprt);
1044 struct rpc_xprt *xprt;
1048 if (unlikely(!(xprt = xprt_from_sock(sk))))
1053 xprt_write_space(xprt);
1060 static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
1062 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1067 sk->sk_rcvbuf = transport->rcvsize * xprt->max_reqs * 2;
1071 sk->sk_sndbuf = transport->sndsize * xprt->max_reqs * 2;
1078 * @xprt: generic transport
1084 static void xs_udp_set_buffer_size(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize)
1086 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1095 xs_udp_do_set_buffer_size(xprt);
1118 * @xprt: generic transport
1122 static void xs_set_port(struct rpc_xprt *xprt, unsigned short port)
1124 struct sockaddr_in *sap = (struct sockaddr_in *) &xprt->addr;
1126 dprintk("RPC: setting port for xprt %p to %u\n", xprt, port);
1198 struct rpc_xprt *xprt = &transport->xprt;
1202 if (xprt->shutdown || !xprt_bound(xprt))
1206 xs_close(xprt);
1214 if (xprt->resvport && xs_bindresvport(transport, sock) < 0) {
1219 dprintk("RPC: worker connecting xprt %p to address: %s\n",
1220 xprt, xprt->address_strings[RPC_DISPLAY_ALL]);
1227 sk->sk_user_data = xprt;
1236 xprt_set_connected(xprt);
1244 xs_udp_do_set_buffer_size(xprt);
1247 xprt_wake_pending_tasks(xprt, status);
1248 xprt_clear_connecting(xprt);
1255 static void xs_tcp_reuse_connection(struct rpc_xprt *xprt)
1258 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1261 dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt);
1285 struct rpc_xprt *xprt = &transport->xprt;
1289 if (xprt->shutdown || !xprt_bound(xprt))
1301 if (xprt->resvport && xs_bindresvport(transport, sock) < 0) {
1307 xs_tcp_reuse_connection(xprt);
1309 dprintk("RPC: worker connecting xprt %p to address: %s\n",
1310 xprt, xprt->address_strings[RPC_DISPLAY_ALL]);
1317 sk->sk_user_data = xprt;
1332 xprt_clear_connected(xprt);
1342 xprt->stat.connect_count++;
1343 xprt->stat.connect_start = jiffies;
1344 status = kernel_connect(sock, (struct sockaddr *) &xprt->addr,
1345 xprt->addrlen, O_NONBLOCK);
1347 xprt, -status, xprt_connected(xprt),
1360 xs_close(xprt);
1365 xprt_wake_pending_tasks(xprt, status);
1367 xprt_clear_connecting(xprt);
1385 struct rpc_xprt *xprt = task->tk_xprt;
1386 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1388 if (xprt_test_and_set_connecting(xprt))
1392 dprintk("RPC: xs_connect delayed xprt %p for %lu "
1394 xprt, xprt->reestablish_timeout / HZ);
1396 xprt->reestablish_timeout);
1397 xprt->reestablish_timeout <<= 1;
1398 if (xprt->reestablish_timeout > XS_TCP_MAX_REEST_TO)
1399 xprt->reestablish_timeout = XS_TCP_MAX_REEST_TO;
1401 dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
1412 * @xprt: rpc_xprt struct containing statistics
1416 static void xs_udp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
1418 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1422 xprt->stat.bind_count,
1423 xprt->stat.sends,
1424 xprt->stat.recvs,
1425 xprt->stat.bad_xids,
1426 xprt->stat.req_u,
1427 xprt->stat.bklog_u);
1432 * @xprt: rpc_xprt struct containing statistics
1436 static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
1438 struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
1441 if (xprt_connected(xprt))
1442 idle_time = (long)(jiffies - xprt->last_used) / HZ;
1446 xprt->stat.bind_count,
1447 xprt->stat.connect_count,
1448 xprt->stat.connect_time,
1450 xprt->stat.sends,
1451 xprt->stat.recvs,
1452 xprt->stat.bad_xids,
1453 xprt->stat.req_u,
1454 xprt->stat.bklog_u);
1492 struct rpc_xprt *xprt;
1495 if (addrlen > sizeof(xprt->addr)) {
1506 xprt = &new->xprt;
1508 xprt->max_reqs = slot_table_size;
1509 xprt->slot = kcalloc(xprt->max_reqs, sizeof(struct rpc_rqst), GFP_KERNEL);
1510 if (xprt->slot == NULL) {
1511 kfree(xprt);
1517 memcpy(&xprt->addr, addr, addrlen);
1518 xprt->addrlen = addrlen;
1521 return xprt;
1533 struct rpc_xprt *xprt;
1536 xprt = xs_setup_xprt(addr, addrlen, xprt_udp_slot_table_entries);
1537 if (IS_ERR(xprt))
1538 return xprt;
1539 transport = container_of(xprt, struct sock_xprt, xprt);
1542 xprt_set_bound(xprt);
1544 xprt->prot = IPPROTO_UDP;
1545 xprt->tsh_size = 0;
1546 xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
1549 xprt->bind_timeout = XS_BIND_TO;
1550 xprt->connect_timeout = XS_UDP_CONN_TO;
1551 xprt->reestablish_timeout = XS_UDP_REEST_TO;
1552 xprt->idle_timeout = XS_IDLE_DISC_TO;
1554 xprt->ops = &xs_udp_ops;
1557 xprt->timeout = *to;
1559 xprt_set_timeout(&xprt->timeout, 5, 5 * HZ);
1561 xs_format_peer_addresses(xprt);
1563 xprt->address_strings[RPC_DISPLAY_ALL]);
1565 return xprt;
1577 struct rpc_xprt *xprt;
1580 xprt = xs_setup_xprt(addr, addrlen, xprt_tcp_slot_table_entries);
1581 if (IS_ERR(xprt))
1582 return xprt;
1583 transport = container_of(xprt, struct sock_xprt, xprt);
1586 xprt_set_bound(xprt);
1588 xprt->prot = IPPROTO_TCP;
1589 xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
1590 xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
1593 xprt->bind_timeout = XS_BIND_TO;
1594 xprt->connect_timeout = XS_TCP_CONN_TO;
1595 xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
1596 xprt->idle_timeout = XS_IDLE_DISC_TO;
1598 xprt->ops = &xs_tcp_ops;
1601 xprt->timeout = *to;
1603 xprt_set_timeout(&xprt->timeout, 2, 60 * HZ);
1605 xs_format_peer_addresses(xprt);
1607 xprt->address_strings[RPC_DISPLAY_ALL]);
1609 return xprt;