Lines Matching defs:svsk
82 static void svc_delete_socket(struct svc_sock *svsk);
86 static void svc_close_socket(struct svc_sock *svsk);
88 static struct svc_deferred_req *svc_deferred_dequeue(struct svc_sock *svsk);
209 svc_sock_wspace(struct svc_sock *svsk)
213 if (svsk->sk_sock->type == SOCK_STREAM)
214 wspace = sk_stream_wspace(svsk->sk_sk);
216 wspace = sock_wspace(svsk->sk_sk);
227 svc_sock_enqueue(struct svc_sock *svsk)
229 struct svc_serv *serv = svsk->sk_server;
234 if (!(svsk->sk_flags &
237 if (test_bit(SK_DEAD, &svsk->sk_flags))
241 pool = svc_pool_for_cpu(svsk->sk_server, cpu);
251 if (test_bit(SK_DEAD, &svsk->sk_flags)) {
253 dprintk("svc: socket %p is dead, not enqueued\n", svsk->sk_sk);
262 if (test_and_set_bit(SK_BUSY, &svsk->sk_flags)) {
264 dprintk("svc: socket %p busy, not enqueued\n", svsk->sk_sk);
267 BUG_ON(svsk->sk_pool != NULL);
268 svsk->sk_pool = pool;
270 set_bit(SOCK_NOSPACE, &svsk->sk_sock->flags);
271 if (((atomic_read(&svsk->sk_reserved) + serv->sv_max_mesg)*2
272 > svc_sock_wspace(svsk))
273 && !test_bit(SK_CLOSE, &svsk->sk_flags)
274 && !test_bit(SK_CONN, &svsk->sk_flags)) {
277 svsk->sk_sk, atomic_read(&svsk->sk_reserved)+serv->sv_max_mesg,
278 svc_sock_wspace(svsk));
279 svsk->sk_pool = NULL;
280 clear_bit(SK_BUSY, &svsk->sk_flags);
283 clear_bit(SOCK_NOSPACE, &svsk->sk_sock->flags);
291 svsk->sk_sk, rqstp);
297 rqstp->rq_sock = svsk;
298 atomic_inc(&svsk->sk_inuse);
300 atomic_add(rqstp->rq_reserved, &svsk->sk_reserved);
301 BUG_ON(svsk->sk_pool != pool);
304 dprintk("svc: socket %p put into queue\n", svsk->sk_sk);
305 list_add_tail(&svsk->sk_ready, &pool->sp_sockets);
306 BUG_ON(svsk->sk_pool != pool);
319 struct svc_sock *svsk;
324 svsk = list_entry(pool->sp_sockets.next,
326 list_del_init(&svsk->sk_ready);
329 svsk->sk_sk, atomic_read(&svsk->sk_inuse));
331 return svsk;
341 svc_sock_received(struct svc_sock *svsk)
343 svsk->sk_pool = NULL;
344 clear_bit(SK_BUSY, &svsk->sk_flags);
345 svc_sock_enqueue(svsk);
364 struct svc_sock *svsk = rqstp->rq_sock;
365 atomic_sub((rqstp->rq_reserved - space), &svsk->sk_reserved);
368 svc_sock_enqueue(svsk);
376 svc_sock_put(struct svc_sock *svsk)
378 if (atomic_dec_and_test(&svsk->sk_inuse)) {
379 BUG_ON(! test_bit(SK_DEAD, &svsk->sk_flags));
382 if (svsk->sk_sock->file)
383 sockfd_put(svsk->sk_sock);
385 sock_release(svsk->sk_sock);
386 if (svsk->sk_info_authunix != NULL)
387 svcauth_unix_info_release(svsk->sk_info_authunix);
388 kfree(svsk);
395 struct svc_sock *svsk = rqstp->rq_sock;
418 svc_sock_put(svsk);
494 struct svc_sock *svsk = rqstp->rq_sock;
495 struct socket *sock = svsk->sk_sock;
576 static int one_sock_name(char *buf, struct svc_sock *svsk)
580 switch(svsk->sk_sk->sk_family) {
583 svsk->sk_sk->sk_protocol==IPPROTO_UDP?
585 NIPQUAD(inet_sk(svsk->sk_sk)->rcv_saddr),
586 inet_sk(svsk->sk_sk)->num);
590 svsk->sk_sk->sk_family);
598 struct svc_sock *svsk, *closesk = NULL;
604 list_for_each_entry(svsk, &serv->sv_permsocks, sk_list) {
605 int onelen = one_sock_name(buf+len, svsk);
607 closesk = svsk;
627 svc_recv_available(struct svc_sock *svsk)
629 struct socket *sock = svsk->sk_sock;
643 struct svc_sock *svsk = rqstp->rq_sock;
649 len = kernel_recvmsg(svsk->sk_sock, &msg, iov, nr, buflen,
654 memcpy(&rqstp->rq_addr, &svsk->sk_remote, svsk->sk_remotelen);
655 rqstp->rq_addrlen = svsk->sk_remotelen;
658 svsk, iov[0].iov_base, iov[0].iov_len, len);
686 struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
688 if (svsk) {
690 svsk, sk, count, test_bit(SK_BUSY, &svsk->sk_flags));
691 set_bit(SK_DATA, &svsk->sk_flags);
692 svc_sock_enqueue(svsk);
704 struct svc_sock *svsk = (struct svc_sock *)(sk->sk_user_data);
706 if (svsk) {
708 svsk, sk, test_bit(SK_BUSY, &svsk->sk_flags));
709 svc_sock_enqueue(svsk);
714 svsk);
742 struct svc_sock *svsk = rqstp->rq_sock;
743 struct svc_serv *serv = svsk->sk_server;
758 if (test_and_clear_bit(SK_CHNGBUF, &svsk->sk_flags))
767 svc_sock_setbufsize(svsk->sk_sock,
771 if ((rqstp->rq_deferred = svc_deferred_dequeue(svsk))) {
772 svc_sock_received(svsk);
776 if (test_bit(SK_CLOSE, &svsk->sk_flags)) {
777 svc_delete_socket(svsk);
781 clear_bit(SK_DATA, &svsk->sk_flags);
783 err = kernel_recvmsg(svsk->sk_sock, &msg, NULL,
786 skb = skb_recv_datagram(svsk->sk_sk, 0, 1, &err);
792 set_bit(SK_DATA, &svsk->sk_flags);
794 svc_sock_received(svsk);
803 svsk->sk_sk->sk_stamp = skb->tstamp;
804 set_bit(SK_DATA, &svsk->sk_flags); /* there may be more data... */
809 svc_sock_received(svsk);
822 skb_free_datagram(svsk->sk_sk, skb);
833 skb_free_datagram(svsk->sk_sk, skb);
837 skb_free_datagram(svsk->sk_sk, skb);
843 skb_free_datagram(svsk->sk_sk, skb);
880 svc_udp_init(struct svc_sock *svsk)
885 svsk->sk_sk->sk_data_ready = svc_udp_data_ready;
886 svsk->sk_sk->sk_write_space = svc_write_space;
887 svsk->sk_recvfrom = svc_udp_recvfrom;
888 svsk->sk_sendto = svc_udp_sendto;
894 svc_sock_setbufsize(svsk->sk_sock,
895 3 * svsk->sk_server->sv_max_mesg,
896 3 * svsk->sk_server->sv_max_mesg);
898 set_bit(SK_DATA, &svsk->sk_flags); /* might have come in before data_ready set up */
899 set_bit(SK_CHNGBUF, &svsk->sk_flags);
904 svsk->sk_sock->ops->setsockopt(svsk->sk_sock, IPPROTO_IP, IP_PKTINFO,
916 struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
932 if (svsk) {
933 set_bit(SK_CONN, &svsk->sk_flags);
934 svc_sock_enqueue(svsk);
949 struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
951 dprintk("svc: socket %p TCP (connected) state change %d (svsk %p)\n",
954 if (!svsk)
957 set_bit(SK_CLOSE, &svsk->sk_flags);
958 svc_sock_enqueue(svsk);
967 struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;
969 dprintk("svc: socket %p TCP data ready (svsk %p)\n",
971 if (svsk) {
972 set_bit(SK_DATA, &svsk->sk_flags);
973 svc_sock_enqueue(svsk);
997 svc_tcp_accept(struct svc_sock *svsk)
1001 struct svc_serv *serv = svsk->sk_server;
1002 struct socket *sock = svsk->sk_sock;
1008 dprintk("svc: tcp_accept %p sock %p\n", svsk, sock);
1012 clear_bit(SK_CONN, &svsk->sk_flags);
1024 set_bit(SK_CONN, &svsk->sk_flags);
1025 svc_sock_enqueue(svsk);
1073 struct svc_sock *svsk = NULL;
1090 svsk = list_entry(serv->sv_tempsocks.prev,
1093 set_bit(SK_CLOSE, &svsk->sk_flags);
1094 atomic_inc(&svsk->sk_inuse);
1098 if (svsk) {
1099 svc_sock_enqueue(svsk);
1100 svc_sock_put(svsk);
1121 struct svc_sock *svsk = rqstp->rq_sock;
1122 struct svc_serv *serv = svsk->sk_server;
1128 svsk, test_bit(SK_DATA, &svsk->sk_flags),
1129 test_bit(SK_CONN, &svsk->sk_flags),
1130 test_bit(SK_CLOSE, &svsk->sk_flags));
1132 if ((rqstp->rq_deferred = svc_deferred_dequeue(svsk))) {
1133 svc_sock_received(svsk);
1137 if (test_bit(SK_CLOSE, &svsk->sk_flags)) {
1138 svc_delete_socket(svsk);
1142 if (svsk->sk_sk->sk_state == TCP_LISTEN) {
1143 svc_tcp_accept(svsk);
1144 svc_sock_received(svsk);
1148 if (test_and_clear_bit(SK_CHNGBUF, &svsk->sk_flags))
1161 svc_sock_setbufsize(svsk->sk_sock,
1165 clear_bit(SK_DATA, &svsk->sk_flags);
1171 if (svsk->sk_tcplen < 4) {
1172 unsigned long want = 4 - svsk->sk_tcplen;
1175 iov.iov_base = ((char *) &svsk->sk_reclen) + svsk->sk_tcplen;
1179 svsk->sk_tcplen += len;
1184 svc_sock_received(svsk);
1188 svsk->sk_reclen = ntohl(svsk->sk_reclen);
1189 if (!(svsk->sk_reclen & 0x80000000)) {
1193 (unsigned long) svsk->sk_reclen);
1196 svsk->sk_reclen &= 0x7fffffff;
1197 dprintk("svc: TCP record, %d bytes\n", svsk->sk_reclen);
1198 if (svsk->sk_reclen > serv->sv_max_mesg) {
1202 (unsigned long) svsk->sk_reclen);
1208 len = svc_recv_available(svsk);
1212 if (len < svsk->sk_reclen) {
1214 len, svsk->sk_reclen);
1215 svc_sock_received(svsk);
1218 len = svsk->sk_reclen;
1219 set_bit(SK_DATA, &svsk->sk_flags);
1252 svsk->sk_reclen = 0;
1253 svsk->sk_tcplen = 0;
1255 svc_sock_received(svsk);
1262 svc_delete_socket(svsk);
1268 svc_sock_received(svsk);
1271 svsk->sk_server->sv_name, -len);
1312 svc_tcp_init(struct svc_sock *svsk)
1314 struct sock *sk = svsk->sk_sk;
1317 svsk->sk_recvfrom = svc_tcp_recvfrom;
1318 svsk->sk_sendto = svc_tcp_sendto;
1323 set_bit(SK_CONN, &svsk->sk_flags);
1330 svsk->sk_reclen = 0;
1331 svsk->sk_tcplen = 0;
1339 svc_sock_setbufsize(svsk->sk_sock,
1340 3 * svsk->sk_server->sv_max_mesg,
1341 3 * svsk->sk_server->sv_max_mesg);
1343 set_bit(SK_CHNGBUF, &svsk->sk_flags);
1344 set_bit(SK_DATA, &svsk->sk_flags);
1346 set_bit(SK_CLOSE, &svsk->sk_flags);
1361 struct svc_sock *svsk =
1363 set_bit(SK_CHNGBUF, &svsk->sk_flags);
1366 struct svc_sock *svsk =
1368 set_bit(SK_CHNGBUF, &svsk->sk_flags);
1381 struct svc_sock *svsk = NULL;
1431 if ((svsk = svc_sock_dequeue(pool)) != NULL) {
1432 rqstp->rq_sock = svsk;
1433 atomic_inc(&svsk->sk_inuse);
1435 atomic_add(rqstp->rq_reserved, &svsk->sk_reserved);
1455 if (!(svsk = rqstp->rq_sock)) {
1465 rqstp, pool->sp_id, svsk, atomic_read(&svsk->sk_inuse));
1466 len = svsk->sk_recvfrom(rqstp);
1475 svsk->sk_lastrecv = get_seconds();
1476 clear_bit(SK_OLD, &svsk->sk_flags);
1502 struct svc_sock *svsk;
1506 if ((svsk = rqstp->rq_sock) == NULL) {
1521 /* Grab svsk->sk_mutex to serialize outgoing data. */
1522 mutex_lock(&svsk->sk_mutex);
1523 if (test_bit(SK_DEAD, &svsk->sk_flags))
1526 len = svsk->sk_sendto(rqstp);
1527 mutex_unlock(&svsk->sk_mutex);
1543 struct svc_sock *svsk;
1557 svsk = list_entry(le, struct svc_sock, sk_list);
1559 if (!test_and_set_bit(SK_OLD, &svsk->sk_flags))
1561 if (atomic_read(&svsk->sk_inuse) || test_bit(SK_BUSY, &svsk->sk_flags))
1563 atomic_inc(&svsk->sk_inuse);
1565 set_bit(SK_CLOSE, &svsk->sk_flags);
1566 set_bit(SK_DETACHED, &svsk->sk_flags);
1574 svsk = list_entry(le, struct svc_sock, sk_list);
1576 dprintk("queuing svsk %p for closing, %lu seconds old\n",
1577 svsk, get_seconds() - svsk->sk_lastrecv);
1580 svc_sock_enqueue(svsk);
1581 svc_sock_put(svsk);
1591 struct svc_sock *svsk;
1597 if (!(svsk = kzalloc(sizeof(*svsk), GFP_KERNEL))) {
1610 kfree(svsk);
1614 set_bit(SK_BUSY, &svsk->sk_flags);
1615 inet->sk_user_data = svsk;
1616 svsk->sk_sock = sock;
1617 svsk->sk_sk = inet;
1618 svsk->sk_ostate = inet->sk_state_change;
1619 svsk->sk_odata = inet->sk_data_ready;
1620 svsk->sk_owspace = inet->sk_write_space;
1621 svsk->sk_server = serv;
1622 atomic_set(&svsk->sk_inuse, 1);
1623 svsk->sk_lastrecv = get_seconds();
1624 spin_lock_init(&svsk->sk_lock);
1625 INIT_LIST_HEAD(&svsk->sk_deferred);
1626 INIT_LIST_HEAD(&svsk->sk_ready);
1627 mutex_init(&svsk->sk_mutex);
1631 svc_udp_init(svsk);
1633 svc_tcp_init(svsk);
1637 set_bit(SK_TEMP, &svsk->sk_flags);
1638 list_add(&svsk->sk_list, &serv->sv_tempsocks);
1648 clear_bit(SK_TEMP, &svsk->sk_flags);
1649 list_add(&svsk->sk_list, &serv->sv_permsocks);
1654 svsk, svsk->sk_sk);
1656 return svsk;
1666 struct svc_sock *svsk = NULL;
1678 svsk = svc_setup_socket(serv, so, &err, SVC_SOCK_DEFAULTS);
1679 if (svsk) {
1680 svc_sock_received(svsk);
1689 return one_sock_name(name_return, svsk);
1699 struct svc_sock *svsk;
1733 if ((svsk = svc_setup_socket(serv, sock, &error, flags)) != NULL) {
1734 svc_sock_received(svsk);
1735 return ntohs(inet_sk(svsk->sk_sk)->sport);
1748 svc_delete_socket(struct svc_sock *svsk)
1753 dprintk("svc: svc_delete_socket(%p)\n", svsk);
1755 serv = svsk->sk_server;
1756 sk = svsk->sk_sk;
1758 sk->sk_state_change = svsk->sk_ostate;
1759 sk->sk_data_ready = svsk->sk_odata;
1760 sk->sk_write_space = svsk->sk_owspace;
1764 if (!test_and_set_bit(SK_DETACHED, &svsk->sk_flags))
1765 list_del_init(&svsk->sk_list);
1773 if (!test_and_set_bit(SK_DEAD, &svsk->sk_flags)) {
1774 BUG_ON(atomic_read(&svsk->sk_inuse)<2);
1775 atomic_dec(&svsk->sk_inuse);
1776 if (test_bit(SK_TEMP, &svsk->sk_flags))
1783 static void svc_close_socket(struct svc_sock *svsk)
1785 set_bit(SK_CLOSE, &svsk->sk_flags);
1786 if (test_and_set_bit(SK_BUSY, &svsk->sk_flags))
1790 atomic_inc(&svsk->sk_inuse);
1791 svc_delete_socket(svsk);
1792 clear_bit(SK_BUSY, &svsk->sk_flags);
1793 svc_sock_put(svsk);
1796 void svc_force_close_socket(struct svc_sock *svsk)
1798 set_bit(SK_CLOSE, &svsk->sk_flags);
1799 if (test_bit(SK_BUSY, &svsk->sk_flags)) {
1803 list_del_init(&svsk->sk_ready);
1804 clear_bit(SK_BUSY, &svsk->sk_flags);
1806 svc_close_socket(svsk);
1838 struct svc_sock *svsk;
1841 svc_sock_put(dr->svsk);
1846 svsk = dr->svsk;
1847 dr->svsk = NULL;
1848 spin_lock(&svsk->sk_lock);
1849 list_add(&dr->handle.recent, &svsk->sk_deferred);
1850 spin_unlock(&svsk->sk_lock);
1851 set_bit(SK_DEFERRED, &svsk->sk_flags);
1852 svc_sock_enqueue(svsk);
1853 svc_sock_put(svsk);
1883 dr->svsk = rqstp->rq_sock;
1909 static struct svc_deferred_req *svc_deferred_dequeue(struct svc_sock *svsk)
1913 if (!test_bit(SK_DEFERRED, &svsk->sk_flags))
1915 spin_lock(&svsk->sk_lock);
1916 clear_bit(SK_DEFERRED, &svsk->sk_flags);
1917 if (!list_empty(&svsk->sk_deferred)) {
1918 dr = list_entry(svsk->sk_deferred.next,
1922 set_bit(SK_DEFERRED, &svsk->sk_flags);
1924 spin_unlock(&svsk->sk_lock);