?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fetch.9: Minor fixes.
[dragonfly.git] / sys / netproto / atm / sigpvc / sigpvc_if.c
blob95ec097e57e742cc231fb609aa451d18deb8ffa0
1 /*
2 *
3 * ===================================
4 * HARP | Host ATM Research Platform
5 * ===================================
6 *
7 *
8 * This Host ATM Research Platform ("HARP") file (the "Software") is
9 * made available by Network Computing Services, Inc. ("NetworkCS")
10 * "AS IS". NetworkCS does not provide maintenance, improvements or
11 * support of any kind.
12 *
13 * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14 * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15 * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16 * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17 * In no event shall NetworkCS be responsible for any damages, including
18 * but not limited to consequential damages, arising from or relating to
19 * any use of the Software or related support.
20 *
21 * Copyright 1994-1998 Network Computing Services, Inc.
22 *
23 * Copies of this Software may be made, however, the above copyright
24 * notice must be reproduced on all copies.
25 *
26 * @(#) $FreeBSD: src/sys/netatm/sigpvc/sigpvc_if.c,v 1.7 2000/01/17 20:49:46 mks Exp $
27 * @(#) $DragonFly: src/sys/netproto/atm/sigpvc/sigpvc_if.c,v 1.11 2006/12/20 18:14:43 dillon Exp $
28 */
29
30 /*
31 * PVC-only Signalling Manager
32 * ---------------------------
33 *
34 * External interfaces to SigPVC manager. Includes support for
35 * running as a loadable kernel module.
36 *
37 */
38
39 #ifndef ATM_SIGPVC_MODULE
40 #include "opt_atm.h"
41 #endif
42
43 #include <netproto/atm/kern_include.h>
44
45 #include "sigpvc_var.h"
46
47 /*
48 * Global variables
49 */
50 struct sp_info sigpvc_vcpool = {
51 "sigpvc vcc pool", /* si_name */
52 sizeof(struct sigpvc_vccb), /* si_blksiz */
53 10, /* si_blkcnt */
54 50 /* si_maxallow */
55 };
56
57 /*
58 * Local functions
59 */
60 static int sigpvc_start (void);
61 static int sigpvc_stop (void);
62 static int sigpvc_attach (struct sigmgr *, struct atm_pif *);
63 static int sigpvc_detach (struct atm_pif *);
64 static int sigpvc_setup (Atm_connvc *, int *);
65 static int sigpvc_release (struct vccb *, int *);
66 static int sigpvc_free (struct vccb *);
67 static int sigpvc_ioctl (int, caddr_t, caddr_t);
68
69 /*
70 * Local variables
71 */
72 static int sigpvc_registered = 0;
73 static struct sigmgr sigpvc_mgr = {
74 NULL,
75 ATM_SIG_PVC,
76 NULL,
77 sigpvc_attach,
78 sigpvc_detach,
79 sigpvc_setup,
80 NULL,
81 NULL,
82 sigpvc_release,
83 sigpvc_free,
84 sigpvc_ioctl
85 };
86
87 static struct attr_cause sigpvc_cause = {
88 T_ATM_PRESENT,
89 {
90 T_ATM_ITU_CODING,
91 T_ATM_LOC_USER,
92 T_ATM_CAUSE_UNSPECIFIED_NORMAL,
93 {0, 0, 0, 0}
94 }
95 };
96
97
98 /*
99 * Initialize sigpvc processing
100 *
101 * This will be called during module loading. We'll just register
102 * the sigpvc protocol descriptor and wait for a SigPVC ATM interface
103 * to come online.
104 *
105 * Arguments:
106 * none
107 *
108 * Returns:
109 * 0 startup was successful
110 * errno startup failed - reason indicated
111 *
112 */
113 static int
114 sigpvc_start(void)
115 {
116 int err = 0;
117
118 /*
119 * Verify software version
120 */
121 if (atm_version != ATM_VERSION) {
122 log(LOG_ERR, "version mismatch: sigpvc=%d.%d kernel=%d.%d\n",
123 ATM_VERS_MAJ(ATM_VERSION), ATM_VERS_MIN(ATM_VERSION),
124 ATM_VERS_MAJ(atm_version), ATM_VERS_MIN(atm_version));
125 return (EINVAL);
126 }
127
128 /*
129 * Register ourselves with system
130 */
131 err = atm_sigmgr_register(&sigpvc_mgr);
132 if (err == 0)
133 sigpvc_registered = 1;
134
135 return (err);
136 }
137
138
139 /*
140 * Halt sigpvc processing
141 *
142 * This should be called just prior to unloading the module from
143 * memory. All sigpvc interfaces must be deregistered before the
144 * protocol can be shutdown.
145 *
146 * Arguments:
147 * none
148 *
149 * Returns:
150 * 0 shutdown was successful
151 * errno shutdown failed - reason indicated
152 *
153 */
154 static int
155 sigpvc_stop(void)
156 {
157 int err = 0;
158
159 crit_enter();
160
161 /*
162 * Is protocol even setup?
163 */
164 if (sigpvc_registered) {
165
166 /*
167 * Any protocol instances still registered??
168 */
169 if (sigpvc_mgr.sm_prinst) {
170
171 /* Yes, can't stop now */
172 err = EBUSY;
173 goto done;
174 }
175
176 /*
177 * De-register from system
178 */
179 err = atm_sigmgr_deregister(&sigpvc_mgr);
180 sigpvc_registered = 0;
181
182 /*
183 * Free up our vccb storage pool
184 */
185 atm_release_pool(&sigpvc_vcpool);
186 } else
187 err = ENXIO;
188
189 done:
190 crit_exit();
191 return (err);
192 }
193
194
195 /*
196 * Attach a SigPVC-controlled interface
197 *
198 * Each ATM physical interface must be attached with the signalling manager for
199 * the interface's signalling protocol (via the atm_sigmgr_attach function).
200 * This function will handle the attachment for SigPVC-controlled interfaces.
201 * A new sigpvc protocol instance will be created and then we'll just sit
202 * around waiting for connection requests.
203 *
204 * Function must be called from a critical section.
205 *
206 * Arguments:
207 * smp pointer to sigpvc signalling manager control block
208 * pip pointer to atm physical interface control block
209 *
210 * Returns:
211 * 0 attach successful
212 * errno attach failed - reason indicated
213 *
214 */
215 static int
216 sigpvc_attach(struct sigmgr *smp, struct atm_pif *pip)
217 {
218 int err = 0;
219 struct sigpvc *pvp = NULL;
220
221 /*
222 * Allocate sigpvc protocol instance control block
223 */
224 pvp = KM_ALLOC(sizeof(struct sigpvc), M_DEVBUF, M_INTWAIT | M_NULLOK);
225 if (pvp == NULL) {
226 err = ENOMEM;
227 goto done;
228 }
229 KM_ZERO(pvp, sizeof(struct sigpvc));
230
231 /*
232 * Link instance into manager's chain
233 */
234 LINK2TAIL((struct siginst *)pvp, struct siginst,
235 smp->sm_prinst, si_next);
236
237 /*
238 * Finally, set state and link in interface
239 */
240 pvp->pv_pif = pip;
241 pvp->pv_state = SIGPVC_ACTIVE;
242 pip->pif_sigmgr = smp;
243 pip->pif_siginst = (struct siginst *)pvp;
244
245 done:
246 /*
247 * Reset our work if attach fails
248 */
249 if (err) {
250 pip->pif_sigmgr = NULL;
251 pip->pif_siginst = NULL;
252 if (pvp) {
253 UNLINK((struct siginst *)pvp, struct siginst,
254 smp->sm_prinst, si_next);
255 KM_FREE(pvp, sizeof(struct sigpvc), M_DEVBUF);
256 }
257 }
258
259 return (err);
260 }
261
262
263 /*
264 * Detach a SigPVC-controlled interface
265 *
266 * Each ATM physical interface may be detached from its signalling manager
267 * (via the atm_sigmgr_detach function). This function will handle the
268 * detachment for all SigPVC-controlled interfaces. All circuits will be
269 * immediately terminated.
270 *
271 * Function must be called from a critical section.
272 *
273 * Arguments:
274 * pip pointer to atm physical interface control block
275 *
276 * Returns:
277 * 0 detach successful
278 * errno detach failed - reason indicated
279 *
280 */
281 static int
282 sigpvc_detach(struct atm_pif *pip)
283 {
284 struct sigpvc *pvp;
285 struct vccb *vcp, *vnext;
286
287 /*
288 * Get SigPVC protocol instance
289 */
290 pvp = (struct sigpvc *)pip->pif_siginst;
291
292 /*
293 * Terminate all of our VCCs
294 */
295 for (vcp = Q_HEAD(pvp->pv_vccq, struct vccb); vcp; vcp = vnext){
296 u_char oustate;
297
298 vnext = Q_NEXT(vcp, struct vccb, vc_sigelem);
299
300 /*
301 * Close VCC and notify owner
302 */
303 oustate = vcp->vc_ustate;
304 sigpvc_close_vcc(vcp);
305 if (oustate == VCCU_OPEN) {
306 vcp->vc_connvc->cvc_attr.cause = sigpvc_cause;
307 atm_cm_cleared(vcp->vc_connvc);
308 }
309 }
310
311 /*
312 * If there are no vcc's queued, then get rid of the protocol
313 * instance.
314 */
315 if (Q_HEAD(pvp->pv_vccq, struct vccb) == NULL) {
316 struct sigmgr *smp = pip->pif_sigmgr;
317
318 pip->pif_sigmgr = NULL;
319 pip->pif_siginst = NULL;
320 UNLINK((struct siginst *)pvp, struct siginst, smp->sm_prinst,
321 si_next);
322 KM_FREE(pvp, sizeof(struct sigpvc), M_DEVBUF);
323 } else {
324
325 /*
326 * Otherwise, set new state indicating detach in progress.
327 * The protocol instance will be freed during sigpvc_free
328 * processing for the last queued vcc.
329 */
330 pvp->pv_state = SIGPVC_DETACH;
331 }
332
333 return (0);
334 }
335
336
337 /*
338 * Open a SigPVC ATM Connection
339 *
340 * All service user requests to open a VC connection (via atm_open_connection)
341 * over an ATM interface attached to the SigPVC signalling manager are handled
342 * here. Only PVC requests are allowed.
343 *
344 * Function will be called from a critical section.
345 *
346 * Arguments:
347 * cvp pointer to CM's connection VCC
348 * errp location to store an error code if CALL_FAILED is returned
349 *
350 * Returns:
351 * CALL_PROCEEDING - connection establishment is in progress
352 * CALL_FAILED - connection establishment failed
353 * CALL_CONNECTED - connection has been successfully established
354 *
355 */
356 static int
357 sigpvc_setup(Atm_connvc *cvp, int *errp)
358 {
359 struct sigpvc *pvp =
360 (struct sigpvc *)cvp->cvc_attr.nif->nif_pif->pif_siginst;
361 int ret;
362
363 /*
364 * See what signalling has to say
365 */
366 switch (pvp->pv_state) {
367
368 case SIGPVC_ACTIVE:
369 break;
370
371 default:
372 *errp = ENXIO;
373 ret = CALL_FAILED;
374 goto done;
375 }
376
377 /*
378 * Open requested type of connection
379 */
380 switch (cvp->cvc_attr.called.addr.address_format) {
381
382 case T_ATM_PVC_ADDR:
383 /*
384 * Create a PVC
385 */
386 ret = sigpvc_create_pvc(pvp, cvp, errp);
387 break;
388
389 default:
390 *errp = EPROTONOSUPPORT;
391 ret = CALL_FAILED;
392 }
393
394 done:
395 return (ret);
396 }
397
398
399 /*
400 * Close a SigPVC ATM Connection
401 *
402 * All service user requests to terminate a previously open VC connection
403 * (via the atm_close_connection function), which is running over an interface
404 * attached to the SigPVC signalling manager, are handled here.
405 *
406 * Function will be called from a critical section.
407 *
408 * Arguments:
409 * vcp pointer to connection's VC control block
410 * errp location to store an error code if CALL_FAILED is returned
411 *
412 * Returns:
413 * CALL_PROCEEDING - connection termination is in progress
414 * CALL_FAILED - connection termination failed
415 * CALL_CLEARED - connection has been successfully terminated
416 *
417 */
418 static int
419 sigpvc_release(struct vccb *vcp, int *errp)
420 {
421
422 /*
423 * Make sure VCC is open
424 */
425 if ((vcp->vc_sstate == VCCS_NULL) || (vcp->vc_sstate == VCCS_FREE) ||
426 (vcp->vc_ustate == VCCU_NULL) || (vcp->vc_ustate == VCCU_CLOSED)) {
427 *errp = EALREADY;
428 return (CALL_FAILED);
429 }
430
431 /*
432 * Not much else to do except close the vccb
433 */
434 sigpvc_close_vcc(vcp);
435
436 return (CALL_CLEARED);
437 }
438
439
440 /*
441 * Free SigPVC ATM Connection Resources
442 *
443 * All service user requests to free the resources of a closed VCC connection
444 * (via the atm_free_connection function), which is running over an interface
445 * attached to the SigPVC signalling manager, are handled here.
446 *
447 * Function will be called from a critical section.
448 *
449 * Arguments:
450 * vcp pointer to connection's VCC control block
451 *
452 * Returns:
453 * 0 connection free was successful
454 * errno connection free failed - reason indicated
455 *
456 */
457 static int
458 sigpvc_free(struct vccb *vcp)
459 {
460 struct atm_pif *pip = vcp->vc_pif;
461 struct sigpvc *pvp = (struct sigpvc *)pip->pif_siginst;
462
463 /*
464 * Make sure VCC has been closed
465 */
466 if ((vcp->vc_ustate != VCCU_CLOSED) || (vcp->vc_sstate != VCCS_FREE))
467 return (EEXIST);
468
469 /*
470 * Remove vccb from protocol queue
471 */
472 DEQUEUE(vcp, struct vccb, vc_sigelem, pvp->pv_vccq);
473
474 /*
475 * Free vccb storage
476 */
477 vcp->vc_ustate = VCCU_NULL;
478 vcp->vc_sstate = VCCS_NULL;
479 atm_free((caddr_t)vcp);
480
481 /*
482 * If we're detaching and this was the last vcc queued,
483 * get rid of the protocol instance
484 */
485 if ((pvp->pv_state == SIGPVC_DETACH) &&
486 (Q_HEAD(pvp->pv_vccq, struct vccb) == NULL)) {
487 struct sigmgr *smp = pip->pif_sigmgr;
488
489 pip->pif_sigmgr = NULL;
490 pip->pif_siginst = NULL;
491 UNLINK((struct siginst *)pvp, struct siginst, smp->sm_prinst,
492 si_next);
493 KM_FREE(pvp, sizeof(struct sigpvc), M_DEVBUF);
494 }
495
496 return (0);
497 }
498
499
500 /*
501 * Process Signalling Manager PF_ATM ioctls
502 *
503 * Function will be called from a critical section.
504 *
505 * Arguments:
506 * code PF_ATM sub-operation code
507 * data pointer to code specific parameter data area
508 * arg1 pointer to code specific argument
509 *
510 * Returns:
511 * 0 request procesed
512 * errno error processing request - reason indicated
513 *
514 */
515 static int
516 sigpvc_ioctl(int code, caddr_t data, caddr_t arg1)
517 {
518 struct atmdelreq *adp;
519 struct atminfreq *aip;
520 struct air_vcc_rsp avr;
521 struct sigpvc *pvp;
522 struct vccb *vcp;
523 Atm_connection *cop;
524 caddr_t cp;
525 u_int vpi, vci;
526 int i, space, err = 0;
527
528
529 switch (code) {
530
531 case AIOCS_DEL_PVC:
532 /*
533 * Delete a PVC
534 */
535 adp = (struct atmdelreq *)data;
536 pvp = (struct sigpvc *)arg1;
537
538 /*
539 * Find requested VCC
540 */
541 vpi = adp->adr_pvc_vpi;
542 vci = adp->adr_pvc_vci;
543 for (vcp = Q_HEAD(pvp->pv_vccq, struct vccb); vcp;
544 vcp = Q_NEXT(vcp, struct vccb, vc_sigelem)) {
545 if ((vcp->vc_vpi == vpi) && (vcp->vc_vci == vci))
546 break;
547 }
548 if (vcp == NULL)
549 return (ENOENT);
550
551 /*
552 * Schedule VCC termination
553 */
554 err = atm_cm_abort(vcp->vc_connvc, &sigpvc_cause.v);
555 break;
556
557 case AIOCS_DEL_SVC:
558 /*
559 * Delete a SVC
560 */
561 err = ENOENT;
562 break;
563
564 case AIOCS_INF_VCC:
565 /*
566 * Get VCC information
567 */
568 aip = (struct atminfreq *)data;
569 pvp = (struct sigpvc *)arg1;
570
571 cp = aip->air_buf_addr;
572 space = aip->air_buf_len;
573
574 /*
575 * Get info for all VCCs on interface
576 */
577 for (vcp = Q_HEAD(pvp->pv_vccq, struct vccb); vcp;
578 vcp = Q_NEXT(vcp, struct vccb, vc_sigelem)) {
579 /*
580 * Make sure there's room in user buffer
581 */
582 if (space < sizeof(avr)) {
583 err = ENOSPC;
584 break;
585 }
586
587 /*
588 * Fill in info to be returned
589 */
590 ksnprintf(avr.avp_intf, sizeof(avr.avp_intf),
591 "%s%d",
592 pvp->pv_pif->pif_name, pvp->pv_pif->pif_unit);
593 avr.avp_vpi = vcp->vc_vpi;
594 avr.avp_vci = vcp->vc_vci;
595 avr.avp_type = vcp->vc_type;
596 avr.avp_sig_proto = ATM_SIG_PVC;
597 avr.avp_aal = vcp->vc_connvc->cvc_attr.aal.type;
598 cop = vcp->vc_connvc->cvc_conn;
599 if (cop)
600 avr.avp_encaps = cop->co_mpx;
601 else
602 avr.avp_encaps = 0;
603 KM_ZERO(avr.avp_owners, sizeof(avr.avp_owners));
604 for (i = 0; cop && i < sizeof(avr.avp_owners);
605 cop = cop->co_next,
606 i += T_ATM_APP_NAME_LEN+1) {
607 strncpy(&avr.avp_owners[i],
608 cop->co_endpt->ep_getname(cop->co_toku),
609 T_ATM_APP_NAME_LEN);
610 }
611 avr.avp_state = vcp->vc_sstate;
612 avr.avp_daddr.address_format = T_ATM_ABSENT;
613 avr.avp_dsubaddr.address_format = T_ATM_ABSENT;
614 avr.avp_ipdus = vcp->vc_ipdus;
615 avr.avp_opdus = vcp->vc_opdus;
616 avr.avp_ibytes = vcp->vc_ibytes;
617 avr.avp_obytes = vcp->vc_obytes;
618 avr.avp_ierrors = vcp->vc_ierrors;
619 avr.avp_oerrors = vcp->vc_oerrors;
620 avr.avp_tstamp = vcp->vc_tstamp;
621
622 /*
623 * Copy data to user buffer and update buffer info
624 */
625 if ((err = copyout((caddr_t)&avr, cp, sizeof(avr))) != 0)
626 break;
627 cp += sizeof(avr);
628 space -= sizeof(avr);
629 }
630
631 /*
632 * Update buffer pointer/count
633 */
634 aip->air_buf_addr = cp;
635 aip->air_buf_len = space;
636 break;
637
638 case AIOCS_INF_ARP:
639 case AIOCS_INF_ASV:
640 /*
641 * Get ARP table/server information
642 */
643 /* We don't maintain any ARP information */
644 break;
645
646 default:
647 err = EOPNOTSUPP;
648 }
649
650 return (err);
651 }
652
653
654 #ifdef ATM_SIGPVC_MODULE
655 /*
656 *******************************************************************
657 *
658 * Loadable Module Support
659 *
660 *******************************************************************
661 */
662 static int sigpvc_doload (void);
663 static int sigpvc_dounload (void);
664
665 /*
666 * Generic module load processing
667 *
668 * This function is called by an OS-specific function when this
669 * module is being loaded.
670 *
671 * Arguments:
672 * none
673 *
674 * Returns:
675 * 0 load was successful
676 * errno load failed - reason indicated
677 *
678 */
679 static int
680 sigpvc_doload(void)
681 {
682 int err = 0;
683
684 /*
685 * Start us up
686 */
687 err = sigpvc_start();
688 if (err)
689 /* Problems, clean up */
690 sigpvc_stop();
691
692 return (err);
693 }
694
695
696 /*
697 * Generic module unload processing
698 *
699 * This function is called by an OS-specific function when this
700 * module is being unloaded.
701 *
702 * Arguments:
703 * none
704 *
705 * Returns:
706 * 0 unload was successful
707 * errno unload failed - reason indicated
708 *
709 */
710 static int
711 sigpvc_dounload(void)
712 {
713 int err = 0;
714
715 /*
716 * OK, try to clean up our mess
717 */
718 err = sigpvc_stop();
719
720 return (err);
721 }
722
723 #include <sys/exec.h>
724 #include <sys/sysent.h>
725 #include <sys/lkm.h>
726
727 /*
728 * Loadable miscellaneous module description
729 */
730 MOD_MISC(sigpvc);
731
732
733 /*
734 * Loadable module support "load" entry point
735 *
736 * This is the routine called by the lkm driver whenever the
737 * modload(1) command is issued for this module.
738 *
739 * Arguments:
740 * lkmtp pointer to lkm drivers's structure
741 * cmd lkm command code
742 *
743 * Returns:
744 * 0 command was successful
745 * errno command failed - reason indicated
746 *
747 */
748 static int
749 sigpvc_load(struct lkm_table *lkmtp, int cmd)
750 {
751 return(sigpvc_doload());
752 }
753
754
755 /*
756 * Loadable module support "unload" entry point
757 *
758 * This is the routine called by the lkm driver whenever the
759 * modunload(1) command is issued for this module.
760 *
761 * Arguments:
762 * lkmtp pointer to lkm drivers's structure
763 * cmd lkm command code
764 *
765 * Returns:
766 * 0 command was successful
767 * errno command failed - reason indicated
768 *
769 */
770 static int
771 sigpvc_unload(struct lkm_table *lkmtp, int cmd)
772 {
773 return(sigpvc_dounload());
774 }
775
776
777 /*
778 * Loadable module support entry point
779 *
780 * This is the routine called by the lkm driver for all loadable module
781 * functions for this driver. This routine name must be specified
782 * on the modload(1) command. This routine will be called whenever the
783 * modload(1), modunload(1) or modstat(1) commands are issued for this
784 * module.
785 *
786 * Arguments:
787 * lkmtp pointer to lkm drivers's structure
788 * cmd lkm command code
789 * ver lkm version
790 *
791 * Returns:
792 * 0 command was successful
793 * errno command failed - reason indicated
794 *
795 */
796 int
797 sigpvc_mod(struct lkm_table *lkmtp, int cmd, int ver)
798 {
799 MOD_DISPATCH(sigpvc, lkmtp, cmd, ver,
800 sigpvc_load, sigpvc_unload, lkm_nullcmd);
801 }
802
803 #else /* !ATM_SIGPVC_MODULE */
804
805 /*
806 *******************************************************************
807 *
808 * Kernel Compiled Module Support
809 *
810 *******************************************************************
811 */
812 static void sigpvc_doload (void *);
813
814 SYSINIT(atmsigpvc, SI_SUB_PROTO_END, SI_ORDER_ANY, sigpvc_doload, NULL)
815
816 /*
817 * Kernel initialization
818 *
819 * Arguments:
820 * arg Not used
821 *
822 * Returns:
823 * none
824 *
825 */
826 static void
827 sigpvc_doload(void *arg)
828 {
829 int err = 0;
830
831 /*
832 * Start us up
833 */
834 err = sigpvc_start();
835 if (err) {
836 /* Problems, clean up */
837 sigpvc_stop();
838
839 log(LOG_ERR, "ATM SIGPVC unable to initialize (%d)!!\n", err);
840 }
841 return;
842 }
843 #endif /* ATM_SIGPVC_MODULE */
844
DragonFly BSD