Lines Matching refs:ilbs
53 * ilbs: pointer to the ilb_stack_t of the IP stack
60 ilb_stack_t *ilbs;
205 ilb_stack_t *ilbs;
212 ilbs = timer->ilbs;
213 c2s_hash = ilbs->ilbs_c2s_conn_hash;
241 if (connp == ilbs->ilbs_conn_list_connp) {
242 ilbs->ilbs_conn_list_connp =
281 (void) taskq_dispatch(timer->ilbs->ilbs_conn_taskq, ilb_conn_cleanup,
294 ilb_conn_hash_init(ilb_stack_t *ilbs)
302 * If ilbs->ilbs_conn_hash_size is not a power of 2, bump it up to
305 if (!ISP2(ilbs->ilbs_conn_hash_size)) {
307 if (ilbs->ilbs_conn_hash_size < (1 << i))
310 ilbs->ilbs_conn_hash_size = 1 << i;
317 ilbs->ilbs_c2s_conn_hash = kmem_zalloc(sizeof (ilb_conn_hash_t) *
318 ilbs->ilbs_conn_hash_size, KM_SLEEP);
319 ilbs->ilbs_s2c_conn_hash = kmem_zalloc(sizeof (ilb_conn_hash_t) *
320 ilbs->ilbs_conn_hash_size, KM_SLEEP);
322 for (i = 0; i < ilbs->ilbs_conn_hash_size; i++) {
323 mutex_init(&ilbs->ilbs_c2s_conn_hash[i].ilb_conn_hash_lock,
326 for (i = 0; i < ilbs->ilbs_conn_hash_size; i++) {
327 mutex_init(&ilbs->ilbs_s2c_conn_hash[i].ilb_conn_hash_lock,
335 (void *)ilbs->ilbs_netstack);
336 ASSERT(ilbs->ilbs_conn_taskq == NULL);
337 ilbs->ilbs_conn_taskq = taskq_create(tq_name,
341 ASSERT(ilbs->ilbs_conn_timer_list == NULL);
342 ilbs->ilbs_conn_timer_list = kmem_zalloc(sizeof (ilb_timer_t) *
349 part = ilbs->ilbs_conn_hash_size / ilb_conn_timer_size + 1;
351 tm = ilbs->ilbs_conn_timer_list + i;
354 if (tm->end > ilbs->ilbs_conn_hash_size)
355 tm->end = ilbs->ilbs_conn_hash_size;
356 tm->ilbs = ilbs;
365 ilb_conn_hash_fini(ilb_stack_t *ilbs)
371 if (ilbs->ilbs_c2s_conn_hash == NULL) {
372 ASSERT(ilbs->ilbs_s2c_conn_hash == NULL);
381 mutex_enter(&ilbs->ilbs_conn_timer_list[i].tid_lock);
382 tid = ilbs->ilbs_conn_timer_list[i].tid;
383 ilbs->ilbs_conn_timer_list[i].tid = 0;
384 mutex_exit(&ilbs->ilbs_conn_timer_list[i].tid_lock);
387 kmem_free(ilbs->ilbs_conn_timer_list, sizeof (ilb_timer_t) *
389 taskq_destroy(ilbs->ilbs_conn_taskq);
390 ilbs->ilbs_conn_taskq = NULL;
393 hash = ilbs->ilbs_s2c_conn_hash;
394 for (i = 0; i < ilbs->ilbs_conn_hash_size; i++) {
414 kmem_free(ilbs->ilbs_c2s_conn_hash, sizeof (ilb_conn_hash_t) *
415 ilbs->ilbs_conn_hash_size);
416 kmem_free(ilbs->ilbs_s2c_conn_hash, sizeof (ilb_conn_hash_t) *
417 ilbs->ilbs_conn_hash_size);
501 ilb_conn_add(ilb_stack_t *ilbs, ilb_rule_t *rule, ilb_server_t *server,
653 hash = ilbs->ilbs_s2c_conn_hash;
657 ntohs(connp->conn_s2c_dport), ilbs->ilbs_conn_hash_size);
671 hash = ilbs->ilbs_c2s_conn_hash;
674 ilbs->ilbs_conn_hash_size);
748 ilb_find_conn(ilb_stack_t *ilbs, void *iph, void *tph, int l4, in6_addr_t *src,
761 ilbs->ilbs_conn_hash_size);
763 hash = ilbs->ilbs_c2s_conn_hash;
782 hash = ilbs->ilbs_s2c_conn_hash;
829 ilb_check_conn(ilb_stack_t *ilbs, int l3, void *iph, int l4, void *tph,
838 if (ilb_find_conn(ilbs, iph, tph, l4, src, sport, dst, dport,
859 if (ilb_find_conn(ilbs, iph, tph, l4, src, sport, dst, dport,
889 ilb_check_icmp_conn(ilb_stack_t *ilbs, mblk_t *mp, int l3, void *out_iph,
961 ilbs->ilbs_conn_hash_size);
962 hash = ilbs->ilbs_c2s_conn_hash;
1029 ilb_list_nat(ilb_stack_t *ilbs, zoneid_t zoneid, ilb_nat_entry_t *nat,
1037 mutex_enter(&ilbs->ilbs_conn_list_lock);
1038 while (ilbs->ilbs_conn_list_busy) {
1039 if (cv_wait_sig(&ilbs->ilbs_conn_list_cv,
1040 &ilbs->ilbs_conn_list_lock) == 0) {
1041 mutex_exit(&ilbs->ilbs_conn_list_lock);
1045 if ((hash = ilbs->ilbs_c2s_conn_hash) == NULL) {
1046 ASSERT(ilbs->ilbs_s2c_conn_hash == NULL);
1047 mutex_exit(&ilbs->ilbs_conn_list_lock);
1052 ilbs->ilbs_conn_list_busy = B_TRUE;
1053 mutex_exit(&ilbs->ilbs_conn_list_lock);
1060 if (ilbs->ilbs_conn_list_cur == ilbs->ilbs_conn_hash_size) {
1065 i = ilbs->ilbs_conn_list_cur;
1067 cur_connp = ilbs->ilbs_conn_list_connp;
1077 if (++i == ilbs->ilbs_conn_hash_size) {
1111 ilbs->ilbs_conn_list_connp = cur_connp;
1115 ilbs->ilbs_conn_list_cur = i;
1119 mutex_enter(&ilbs->ilbs_conn_list_lock);
1120 ilbs->ilbs_conn_list_busy = B_FALSE;
1121 cv_signal(&ilbs->ilbs_conn_list_cv);
1122 mutex_exit(&ilbs->ilbs_conn_list_lock);
1227 ilb_sticky_find_add(ilb_stack_t *ilbs, ilb_rule_t *rule, in6_addr_t *src,
1239 (uint32_t)(uintptr_t)rule, ilbs->ilbs_sticky_hash_size);
1240 hash = &ilbs->ilbs_sticky_hash[i];
1311 ilb_stack_t *ilbs;
1316 ilbs = timer->ilbs;
1317 hash = ilbs->ilbs_sticky_hash;
1345 (void) taskq_dispatch(timer->ilbs->ilbs_sticky_taskq,
1358 ilb_sticky_hash_init(ilb_stack_t *ilbs)
1365 if (!ISP2(ilbs->ilbs_sticky_hash_size)) {
1367 if (ilbs->ilbs_sticky_hash_size < (1 << i))
1370 ilbs->ilbs_sticky_hash_size = 1 << i;
1373 ilbs->ilbs_sticky_hash = kmem_zalloc(sizeof (ilb_sticky_hash_t) *
1374 ilbs->ilbs_sticky_hash_size, KM_SLEEP);
1375 for (i = 0; i < ilbs->ilbs_sticky_hash_size; i++) {
1376 mutex_init(&ilbs->ilbs_sticky_hash[i].sticky_lock, NULL,
1378 list_create(&ilbs->ilbs_sticky_hash[i].sticky_head,
1387 (void *)ilbs->ilbs_netstack);
1388 ASSERT(ilbs->ilbs_sticky_taskq == NULL);
1389 ilbs->ilbs_sticky_taskq = taskq_create(tq_name,
1393 ASSERT(ilbs->ilbs_sticky_timer_list == NULL);
1394 ilbs->ilbs_sticky_timer_list = kmem_zalloc(sizeof (ilb_timer_t) *
1396 part = ilbs->ilbs_sticky_hash_size / ilb_sticky_timer_size + 1;
1398 tm = ilbs->ilbs_sticky_timer_list + i;
1401 if (tm->end > ilbs->ilbs_sticky_hash_size)
1402 tm->end = ilbs->ilbs_sticky_hash_size;
1403 tm->ilbs = ilbs;
1412 ilb_sticky_hash_fini(ilb_stack_t *ilbs)
1417 if (ilbs->ilbs_sticky_hash == NULL)
1425 mutex_enter(&ilbs->ilbs_sticky_timer_list[i].tid_lock);
1426 tid = ilbs->ilbs_sticky_timer_list[i].tid;
1427 ilbs->ilbs_sticky_timer_list[i].tid = 0;
1428 mutex_exit(&ilbs->ilbs_sticky_timer_list[i].tid_lock);
1431 kmem_free(ilbs->ilbs_sticky_timer_list, sizeof (ilb_timer_t) *
1433 taskq_destroy(ilbs->ilbs_sticky_taskq);
1434 ilbs->ilbs_sticky_taskq = NULL;
1436 for (i = 0; i < ilbs->ilbs_sticky_hash_size; i++) {
1437 while ((s = list_head(&ilbs->ilbs_sticky_hash[i].sticky_head))
1439 list_remove(&ilbs->ilbs_sticky_hash[i].sticky_head, s);
1444 kmem_free(ilbs->ilbs_sticky_hash, ilbs->ilbs_sticky_hash_size *
1458 ilb_list_sticky(ilb_stack_t *ilbs, zoneid_t zoneid, ilb_sticky_entry_t *st,
1466 mutex_enter(&ilbs->ilbs_sticky_list_lock);
1467 while (ilbs->ilbs_sticky_list_busy) {
1468 if (cv_wait_sig(&ilbs->ilbs_sticky_list_cv,
1469 &ilbs->ilbs_sticky_list_lock) == 0) {
1470 mutex_exit(&ilbs->ilbs_sticky_list_lock);
1474 if ((hash = ilbs->ilbs_sticky_hash) == NULL) {
1475 mutex_exit(&ilbs->ilbs_sticky_list_lock);
1480 ilbs->ilbs_sticky_list_busy = B_TRUE;
1481 mutex_exit(&ilbs->ilbs_sticky_list_lock);
1488 if (ilbs->ilbs_sticky_list_cur == ilbs->ilbs_sticky_hash_size) {
1493 i = ilbs->ilbs_sticky_list_cur;
1495 curp = ilbs->ilbs_sticky_list_curp;
1505 if (++i == ilbs->ilbs_sticky_hash_size) {
1520 ilbs->ilbs_sticky_list_curp = curp;
1524 ilbs->ilbs_sticky_list_cur = i;
1528 mutex_enter(&ilbs->ilbs_sticky_list_lock);
1529 ilbs->ilbs_sticky_list_busy = B_FALSE;
1530 cv_signal(&ilbs->ilbs_sticky_list_cv);
1531 mutex_exit(&ilbs->ilbs_sticky_list_lock);