aboutsummaryrefslogtreecommitdiffstats
path: root/net/netrom
diff options
context:
space:
mode:
authorRalf Baechle <ralf@linux-mips.org>2007-04-20 19:06:45 -0400
committerDavid S. Miller <davem@sunset.davemloft.net>2007-04-26 01:29:15 -0400
commit75606dc69adcfff433bca0ff747538d8495da0ab (patch)
treec36260ce3ee94fe5f405be68b90af888c7324825 /net/netrom
parent80feaacb8a6400a9540a961b6743c69a5896b937 (diff)
[AX25/NETROM/ROSE]: Convert to use modern wait queue API
Signed-off-by: Ralf Baechle <ralf@linux-mips.org> Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'net/netrom')
-rw-r--r--net/netrom/af_netrom.c93
1 files changed, 46 insertions, 47 deletions
diff --git a/net/netrom/af_netrom.c b/net/netrom/af_netrom.c
index 5dc7448925db..5d4a26c2aa0c 100644
--- a/net/netrom/af_netrom.c
+++ b/net/netrom/af_netrom.c
@@ -625,42 +625,42 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
625 ax25_address *source = NULL; 625 ax25_address *source = NULL;
626 ax25_uid_assoc *user; 626 ax25_uid_assoc *user;
627 struct net_device *dev; 627 struct net_device *dev;
628 int err = 0;
628 629
629 lock_sock(sk); 630 lock_sock(sk);
630 if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) { 631 if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
631 sock->state = SS_CONNECTED; 632 sock->state = SS_CONNECTED;
632 release_sock(sk); 633 goto out_release; /* Connect completed during a ERESTARTSYS event */
633 return 0; /* Connect completed during a ERESTARTSYS event */
634 } 634 }
635 635
636 if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) { 636 if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
637 sock->state = SS_UNCONNECTED; 637 sock->state = SS_UNCONNECTED;
638 release_sock(sk); 638 err = -ECONNREFUSED;
639 return -ECONNREFUSED; 639 goto out_release;
640 } 640 }
641 641
642 if (sk->sk_state == TCP_ESTABLISHED) { 642 if (sk->sk_state == TCP_ESTABLISHED) {
643 release_sock(sk); 643 err = -EISCONN; /* No reconnect on a seqpacket socket */
644 return -EISCONN; /* No reconnect on a seqpacket socket */ 644 goto out_release;
645 } 645 }
646 646
647 sk->sk_state = TCP_CLOSE; 647 sk->sk_state = TCP_CLOSE;
648 sock->state = SS_UNCONNECTED; 648 sock->state = SS_UNCONNECTED;
649 649
650 if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25)) { 650 if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25)) {
651 release_sock(sk); 651 err = -EINVAL;
652 return -EINVAL; 652 goto out_release;
653 } 653 }
654 if (addr->sax25_family != AF_NETROM) { 654 if (addr->sax25_family != AF_NETROM) {
655 release_sock(sk); 655 err = -EINVAL;
656 return -EINVAL; 656 goto out_release;
657 } 657 }
658 if (sock_flag(sk, SOCK_ZAPPED)) { /* Must bind first - autobinding in this may or may not work */ 658 if (sock_flag(sk, SOCK_ZAPPED)) { /* Must bind first - autobinding in this may or may not work */
659 sock_reset_flag(sk, SOCK_ZAPPED); 659 sock_reset_flag(sk, SOCK_ZAPPED);
660 660
661 if ((dev = nr_dev_first()) == NULL) { 661 if ((dev = nr_dev_first()) == NULL) {
662 release_sock(sk); 662 err = -ENETUNREACH;
663 return -ENETUNREACH; 663 goto out_release;
664 } 664 }
665 source = (ax25_address *)dev->dev_addr; 665 source = (ax25_address *)dev->dev_addr;
666 666
@@ -671,8 +671,8 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
671 } else { 671 } else {
672 if (ax25_uid_policy && !capable(CAP_NET_ADMIN)) { 672 if (ax25_uid_policy && !capable(CAP_NET_ADMIN)) {
673 dev_put(dev); 673 dev_put(dev);
674 release_sock(sk); 674 err = -EPERM;
675 return -EPERM; 675 goto out_release;
676 } 676 }
677 nr->user_addr = *source; 677 nr->user_addr = *source;
678 } 678 }
@@ -707,8 +707,8 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
707 707
708 /* Now the loop */ 708 /* Now the loop */
709 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) { 709 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
710 release_sock(sk); 710 err = -EINPROGRESS;
711 return -EINPROGRESS; 711 goto out_release;
712 } 712 }
713 713
714 /* 714 /*
@@ -716,46 +716,46 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
716 * closed. 716 * closed.
717 */ 717 */
718 if (sk->sk_state == TCP_SYN_SENT) { 718 if (sk->sk_state == TCP_SYN_SENT) {
719 struct task_struct *tsk = current; 719 DEFINE_WAIT(wait);
720 DECLARE_WAITQUEUE(wait, tsk);
721 720
722 add_wait_queue(sk->sk_sleep, &wait);
723 for (;;) { 721 for (;;) {
724 set_current_state(TASK_INTERRUPTIBLE); 722 prepare_to_wait(sk->sk_sleep, &wait,
723 TASK_INTERRUPTIBLE);
725 if (sk->sk_state != TCP_SYN_SENT) 724 if (sk->sk_state != TCP_SYN_SENT)
726 break; 725 break;
727 release_sock(sk); 726 if (!signal_pending(current)) {
728 if (!signal_pending(tsk)) { 727 release_sock(sk);
729 schedule(); 728 schedule();
730 lock_sock(sk); 729 lock_sock(sk);
731 continue; 730 continue;
732 } 731 }
733 current->state = TASK_RUNNING; 732 err = -ERESTARTSYS;
734 remove_wait_queue(sk->sk_sleep, &wait); 733 break;
735 return -ERESTARTSYS;
736 } 734 }
737 current->state = TASK_RUNNING; 735 finish_wait(sk->sk_sleep, &wait);
738 remove_wait_queue(sk->sk_sleep, &wait); 736 if (err)
737 goto out_release;
739 } 738 }
740 739
741 if (sk->sk_state != TCP_ESTABLISHED) { 740 if (sk->sk_state != TCP_ESTABLISHED) {
742 sock->state = SS_UNCONNECTED; 741 sock->state = SS_UNCONNECTED;
743 release_sock(sk); 742 err = sock_error(sk); /* Always set at this point */
744 return sock_error(sk); /* Always set at this point */ 743 goto out_release;
745 } 744 }
746 745
747 sock->state = SS_CONNECTED; 746 sock->state = SS_CONNECTED;
747
748out_release:
748 release_sock(sk); 749 release_sock(sk);
749 750
750 return 0; 751 return err;
751} 752}
752 753
753static int nr_accept(struct socket *sock, struct socket *newsock, int flags) 754static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
754{ 755{
755 struct task_struct *tsk = current;
756 DECLARE_WAITQUEUE(wait, tsk);
757 struct sk_buff *skb; 756 struct sk_buff *skb;
758 struct sock *newsk; 757 struct sock *newsk;
758 DEFINE_WAIT(wait);
759 struct sock *sk; 759 struct sock *sk;
760 int err = 0; 760 int err = 0;
761 761
@@ -765,42 +765,40 @@ static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
765 lock_sock(sk); 765 lock_sock(sk);
766 if (sk->sk_type != SOCK_SEQPACKET) { 766 if (sk->sk_type != SOCK_SEQPACKET) {
767 err = -EOPNOTSUPP; 767 err = -EOPNOTSUPP;
768 goto out; 768 goto out_release;
769 } 769 }
770 770
771 if (sk->sk_state != TCP_LISTEN) { 771 if (sk->sk_state != TCP_LISTEN) {
772 err = -EINVAL; 772 err = -EINVAL;
773 goto out; 773 goto out_release;
774 } 774 }
775 775
776 /* 776 /*
777 * The write queue this time is holding sockets ready to use 777 * The write queue this time is holding sockets ready to use
778 * hooked into the SABM we saved 778 * hooked into the SABM we saved
779 */ 779 */
780 add_wait_queue(sk->sk_sleep, &wait);
781 for (;;) { 780 for (;;) {
781 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
782 skb = skb_dequeue(&sk->sk_receive_queue); 782 skb = skb_dequeue(&sk->sk_receive_queue);
783 if (skb) 783 if (skb)
784 break; 784 break;
785 785
786 current->state = TASK_INTERRUPTIBLE;
787 release_sock(sk);
788 if (flags & O_NONBLOCK) { 786 if (flags & O_NONBLOCK) {
789 current->state = TASK_RUNNING; 787 err = -EWOULDBLOCK;
790 remove_wait_queue(sk->sk_sleep, &wait); 788 break;
791 return -EWOULDBLOCK;
792 } 789 }
793 if (!signal_pending(tsk)) { 790 if (!signal_pending(current)) {
791 release_sock(sk);
794 schedule(); 792 schedule();
795 lock_sock(sk); 793 lock_sock(sk);
796 continue; 794 continue;
797 } 795 }
798 current->state = TASK_RUNNING; 796 err = -ERESTARTSYS;
799 remove_wait_queue(sk->sk_sleep, &wait); 797 break;
800 return -ERESTARTSYS;
801 } 798 }
802 current->state = TASK_RUNNING; 799 finish_wait(sk->sk_sleep, &wait);
803 remove_wait_queue(sk->sk_sleep, &wait); 800 if (err)
801 goto out_release;
804 802
805 newsk = skb->sk; 803 newsk = skb->sk;
806 newsk->sk_socket = newsock; 804 newsk->sk_socket = newsock;
@@ -811,8 +809,9 @@ static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
811 sk_acceptq_removed(sk); 809 sk_acceptq_removed(sk);
812 newsock->sk = newsk; 810 newsock->sk = newsk;
813 811
814out: 812out_release:
815 release_sock(sk); 813 release_sock(sk);
814
816 return err; 815 return err;
817} 816}
818 817