static void sigd_put_skb(struct sk_buff *skb)
{
#ifdef WAIT_FOR_DEMON
- static unsigned long silence;
DECLARE_WAITQUEUE(wait,current);
add_wait_queue(&sigd_sleep,&wait);
while (!sigd) {
set_current_state(TASK_UNINTERRUPTIBLE);
- if (time_after(jiffies, silence) || silence == 0) {
- printk(KERN_INFO "atmsvc: waiting for signaling demon "
- "...\n");
- silence = (jiffies+30*HZ)|1;
- }
+ DPRINTK("atmsvc: waiting for signaling demon...\n");
schedule();
}
current->state = TASK_RUNNING;
remove_wait_queue(&sigd_sleep,&wait);
#else
if (!sigd) {
- printk(KERN_WARNING "atmsvc: no signaling demon\n");
+ DPRINTK("atmsvc: no signaling demon\n");
kfree_skb(skb);
return;
}
#endif
atm_force_charge(sigd,skb->truesize);
- skb_queue_tail(&sigd->sk->sk_receive_queue,skb);
- sigd->sk->sk_data_ready(sigd->sk, skb->len);
+ skb_queue_tail(&sk_atm(sigd)->sk_receive_queue,skb);
+ sk_atm(sigd)->sk_data_ready(sk_atm(sigd), skb->len);
}
{
struct atmsvc_msg *msg;
struct atm_vcc *session_vcc;
+ struct sock *sk;
msg = (struct atmsvc_msg *) skb->data;
- atomic_sub(skb->truesize, &vcc->sk->sk_wmem_alloc);
+ atomic_sub(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);
DPRINTK("sigd_send %d (0x%lx)\n",(int) msg->type,
(unsigned long) msg->vcc);
vcc = *(struct atm_vcc **) &msg->vcc;
+ sk = sk_atm(vcc);
+
switch (msg->type) {
case as_okay:
- vcc->sk->sk_err = -msg->reply;
+ sk->sk_err = -msg->reply;
clear_bit(ATM_VF_WAITING, &vcc->flags);
if (!*vcc->local.sas_addr.prv &&
!*vcc->local.sas_addr.pub) {
case as_error:
clear_bit(ATM_VF_REGIS,&vcc->flags);
clear_bit(ATM_VF_READY,&vcc->flags);
- vcc->sk->sk_err = -msg->reply;
+ sk->sk_err = -msg->reply;
clear_bit(ATM_VF_WAITING, &vcc->flags);
break;
case as_indicate:
vcc = *(struct atm_vcc **) &msg->listen_vcc;
+ sk = sk_atm(vcc);
DPRINTK("as_indicate!!!\n");
- lock_sock(vcc->sk);
- if (vcc->sk->sk_ack_backlog ==
- vcc->sk->sk_max_ack_backlog) {
- sigd_enq(0,as_reject,vcc,NULL,NULL);
+ lock_sock(sk);
+ if (sk_acceptq_is_full(sk)) {
+ sigd_enq(NULL,as_reject,vcc,NULL,NULL);
+ dev_kfree_skb(skb);
goto as_indicate_complete;
}
- vcc->sk->sk_ack_backlog++;
- skb_queue_tail(&vcc->sk->sk_receive_queue, skb);
- DPRINTK("waking vcc->sk->sk_sleep 0x%p\n", vcc->sk->sk_sleep);
- vcc->sk->sk_state_change(vcc->sk);
+ sk->sk_ack_backlog++;
+ skb_queue_tail(&sk->sk_receive_queue, skb);
+ DPRINTK("waking sk->sk_sleep 0x%p\n", sk->sk_sleep);
+ sk->sk_state_change(sk);
as_indicate_complete:
- release_sock(vcc->sk);
+ release_sock(sk);
return 0;
case as_close:
set_bit(ATM_VF_RELEASED,&vcc->flags);
- clear_bit(ATM_VF_READY,&vcc->flags);
- vcc->sk->sk_err = -msg->reply;
- clear_bit(ATM_VF_WAITING, &vcc->flags);
- break;
+ vcc_release_async(vcc, msg->reply);
+ goto out;
case as_modify:
modify_qos(vcc,msg);
break;
+ case as_addparty:
+ case as_dropparty:
+ sk->sk_err_soft = msg->reply; /* < 0 failure, otherwise ep_ref */
+ clear_bit(ATM_VF_WAITING, &vcc->flags);
+ break;
default:
printk(KERN_ALERT "sigd_send: bad message type %d\n",
(int) msg->type);
return -EINVAL;
}
- vcc->sk->sk_state_change(vcc->sk);
+ sk->sk_state_change(sk);
+out:
dev_kfree_skb(skb);
return 0;
}
{
struct sk_buff *skb;
struct atmsvc_msg *msg;
+ static unsigned session = 0;
DPRINTK("sigd_enq %d (0x%p)\n",(int) type,vcc);
while (!(skb = alloc_skb(sizeof(struct atmsvc_msg),GFP_KERNEL)))
if (svc) msg->svc = *svc;
if (vcc) msg->local = vcc->local;
if (pvc) msg->pvc = *pvc;
+ if (vcc) {
+ if (type == as_connect && test_bit(ATM_VF_SESSION, &vcc->flags))
+ msg->session = ++session;
+ /* every new pmp connect gets the next session number */
+ }
sigd_put_skb(skb);
if (vcc) set_bit(ATM_VF_REGIS,&vcc->flags);
}
static void purge_vcc(struct atm_vcc *vcc)
{
- if (vcc->sk->sk_family == PF_ATMSVC &&
- !test_bit(ATM_VF_META,&vcc->flags)) {
- set_bit(ATM_VF_RELEASED,&vcc->flags);
- vcc->sk->sk_err = EUNATCH;
- clear_bit(ATM_VF_WAITING, &vcc->flags);
- vcc->sk->sk_state_change(vcc->sk);
+ if (sk_atm(vcc)->sk_family == PF_ATMSVC &&
+ !test_bit(ATM_VF_META, &vcc->flags)) {
+ set_bit(ATM_VF_RELEASED, &vcc->flags);
+ clear_bit(ATM_VF_REGIS, &vcc->flags);
+ vcc_release_async(vcc, -EUNATCH);
}
}
DPRINTK("sigd_close\n");
sigd = NULL;
- if (skb_peek(&vcc->sk->sk_receive_queue))
+ if (skb_peek(&sk_atm(vcc)->sk_receive_queue))
printk(KERN_ERR "sigd_close: closing with requests pending\n");
- skb_queue_purge(&vcc->sk->sk_receive_queue);
+ skb_queue_purge(&sk_atm(vcc)->sk_receive_queue);
read_lock(&vcc_sklist_lock);
for(i = 0; i < VCC_HTABLE_SIZE; ++i) {
sk_for_each(s, node, head) {
struct atm_vcc *vcc = atm_sk(s);
- if (vcc->dev)
- purge_vcc(vcc);
+ purge_vcc(vcc);
}
}
read_unlock(&vcc_sklist_lock);
DPRINTK("sigd_attach\n");
sigd = vcc;
vcc->dev = &sigd_dev;
- vcc_insert_socket(vcc->sk);
+ vcc_insert_socket(sk_atm(vcc));
set_bit(ATM_VF_META,&vcc->flags);
set_bit(ATM_VF_READY,&vcc->flags);
#ifdef WAIT_FOR_DEMON