/* * Check to see if the scheduling-clock interrupt came from an extended * quiescent state, and, if so, tell RCU about it. This function must * be called from hardirq context. It is normally called from the * scheduling-clock interrupt. */ void rcu_check_callbacks(int user) { RCU_TRACE(check_cpu_stalls()); if (user) rcu_sched_qs(); else if (!in_softirq()) rcu_bh_qs(); if (user) rcu_note_voluntary_context_switch(current); }
/** * rcu_read_lock_bh_held() - might we be in RCU-bh read-side critical section? * * Check for bottom half being disabled, which covers both the * CONFIG_PROVE_RCU and not cases. Note that if someone uses * rcu_read_lock_bh(), but then later enables BH, lockdep (if enabled) * will show the situation. This is useful for debug checks in functions * that require that they be called within an RCU read-side critical * section. * * Check debug_lockdep_rcu_enabled() to prevent false positives during boot. * * Note that rcu_read_lock() is disallowed if the CPU is either idle or * offline from an RCU perspective, so check for those as well. */ int rcu_read_lock_bh_held(void) { if (!debug_lockdep_rcu_enabled()) return 1; if (!rcu_is_watching()) return 0; if (!rcu_lockdep_current_cpu_online()) return 0; return in_softirq() || irqs_disabled(); }
/* * Check to see if the scheduling-clock interrupt came from an extended * quiescent state, and, if so, tell RCU about it. This function must * be called from hardirq context. It is normally called from the * scheduling-clock interrupt. */ void rcu_check_callbacks(int user) { mutant_covered = 1; /* MUTANT (del_stmt) */ /* RCU_TRACE(check_cpu_stalls()); */ if (user || rcu_is_cpu_rrupt_from_idle()) rcu_sched_qs(); else if (!in_softirq()) rcu_bh_qs(); if (user) rcu_note_voluntary_context_switch(current); }
/* * Update current's FPSIMD/SVE registers from thread_struct. * * This function should be called only when the FPSIMD/SVE state in * thread_struct is known to be up to date, when preparing to enter * userspace. * * Softirqs (and preemption) must be disabled. */ static void task_fpsimd_load(void) { WARN_ON(!in_softirq() && !irqs_disabled()); if (system_supports_sve() && test_thread_flag(TIF_SVE)) sve_load_state(sve_pffr(¤t->thread), ¤t->thread.uw.fpsimd_state.fpsr, sve_vq_from_vl(current->thread.sve_vl) - 1); else fpsimd_load_state(¤t->thread.uw.fpsimd_state); }
static void do_things(struct work_struct *work) { printk(KERN_INFO "workqueue: I am in a workqueue\n"); printk(KERN_INFO "workqueue: in_atomic=%d\n", in_atomic()); printk(KERN_INFO "workqueue: in_interrupt=%lu\n", in_interrupt()); printk(KERN_INFO "workqueue: in_irq=%lu\n", in_irq()); printk(KERN_INFO "workqueue: in_softirq=%lu\n", in_softirq()); printk(KERN_INFO "\n"); return; }
void ssh_interceptor_proc_uninit(SshInterceptor interceptor) { /* Enable softirqs. */ SSH_ASSERT(in_softirq()); local_bh_enable(); SSH_ASSERT(!in_softirq()); interceptor_ipm_proc_entry_uninit(interceptor); #ifdef DEBUG_LIGHT interceptor_stats_proc_entry_uninit(interceptor); interceptor_debug_proc_entry_uninit(interceptor); #endif /* DEBUG_LIGHT */ interceptor_version_proc_entry_uninit(interceptor); if (interceptor->proc_dir) remove_proc_entry(interceptor->proc_dir->name, NULL); interceptor->proc_dir = NULL; /* Disable softirqs. */ local_bh_disable(); SSH_ASSERT(in_softirq()); }
/* * Check to see if the scheduling-clock interrupt came from an extended * quiescent state, and, if so, tell RCU about it. This function must * be called from hardirq context. It is normally called from the * scheduling-clock interrupt. */ void rcu_check_callbacks(int user) { RCU_TRACE(check_cpu_stalls()); if (user || rcu_is_cpu_rrupt_from_idle()) { rcu_sched_qs(); } else if (!in_softirq()) { rcu_bh_qs(); } if (user) { rcu_note_voluntary_context_switch(current); } }
void arch_local_irq_enable(void) { unsigned long flags; flags = arch_local_save_flags(); /* Allow both L1 and L2 at the onset */ flags |= (STATUS_E1_MASK | STATUS_E2_MASK); /* Called from hard ISR (between irq_enter and irq_exit) */ if (in_irq()) { /* If in L2 ISR, don't re-enable any further IRQs as this can * cause IRQ priorities to get upside down. e.g. it could allow * L1 be taken while in L2 hard ISR which is wrong not only in * theory, it can also cause the dreaded L1-L2-L1 scenario */ if (flags & STATUS_A2_MASK) flags &= ~(STATUS_E1_MASK | STATUS_E2_MASK); /* Even if in L1 ISR, allowe Higher prio L2 IRQs */ else if (flags & STATUS_A1_MASK) flags &= ~(STATUS_E1_MASK); } /* called from soft IRQ, ideally we want to re-enable all levels */ else if (in_softirq()) { /* However if this is case of L1 interrupted by L2, * re-enabling both may cause whaco L1-L2-L1 scenario * because ARC700 allows level 1 to interrupt an active L2 ISR * Thus we disable both * However some code, executing in soft ISR wants some IRQs * to be enabled so we re-enable L2 only * * How do we determine L1 intr by L2 * -A2 is set (means in L2 ISR) * -E1 is set in this ISR's pt_regs->status32 which is * saved copy of status32_l2 when l2 ISR happened */ struct pt_regs *pt = get_irq_regs(); if ((flags & STATUS_A2_MASK) && pt && (pt->status32 & STATUS_A1_MASK)) { /*flags &= ~(STATUS_E1_MASK | STATUS_E2_MASK); */ flags &= ~(STATUS_E1_MASK); } } arch_local_irq_restore(flags); }
/* * Check to see if the scheduling-clock interrupt came from an extended * quiescent state, and, if so, tell RCU about it. This function must * be called from hardirq context. It is normally called from the * scheduling-clock interrupt. */ void rcu_check_callbacks(int user) { RCU_TRACE(check_cpu_stalls()); mutant_covered = 1; /* MUTANT (negate) */ if(! (user || rcu_is_cpu_rrupt_from_idle())) { rcu_sched_qs(); } else if (!in_softirq()) { rcu_bh_qs(); } if (user) { rcu_note_voluntary_context_switch(current); } }
/* * Check to see if the scheduling-clock interrupt came from an extended * quiescent state, and, if so, tell RCU about it. This function must * be called from hardirq context. It is normally called from the * scheduling-clock interrupt. */ void rcu_check_callbacks(int user) { RCU_TRACE(check_cpu_stalls()); if (user || rcu_is_cpu_rrupt_from_idle()) { if (!__covered11) {__covered11 = 1; total_covered += 1;} rcu_sched_qs(); } else if (!in_softirq()) { if (!__covered12) {__covered12 = 1; total_covered += 1;} rcu_bh_qs(); } if (user) { if (!__covered13) {__covered13 = 1; total_covered += 1;} rcu_note_voluntary_context_switch(current); } }
static char * trace_get_console_buffer(void) { int cpu = get_cpu(); int idx; if (in_irq()) { idx = 0; } else if (in_softirq()) { idx = 1; } else { idx = 2; } return trace_console_buffers[cpu][idx]; }
Boolean ssh_interceptor_proc_init(SshInterceptor interceptor) { char name[128]; /* Softirqs are always enabled here. */ SSH_ASSERT(!in_softirq()); /* Create a directory under /proc/ */ ssh_snprintf(name, sizeof(name), "%s%s", SSH_PROC_ROOT, ssh_device_suffix); interceptor->proc_dir = create_proc_entry(name, S_IFDIR, NULL); if (interceptor->proc_dir == NULL) goto error; if (interceptor_ipm_proc_entry_init(interceptor) == FALSE) goto error; #ifdef DEBUG_LIGHT if (interceptor_stats_proc_entry_init(interceptor) == FALSE) goto error; if (interceptor_debug_proc_entry_init(interceptor) == FALSE) goto error; #endif /* DEBUG_LIGHT */ if (interceptor_version_proc_entry_init(interceptor) == FALSE) goto error; return TRUE; error: SSH_DEBUG(SSH_D_ERROR, ("Could not create /proc/%s", name)); interceptor_ipm_proc_entry_uninit(interceptor); #ifdef DEBUG_LIGHT interceptor_stats_proc_entry_uninit(interceptor); interceptor_debug_proc_entry_uninit(interceptor); #endif /* DEBUG_LIGHT */ interceptor_version_proc_entry_uninit(interceptor); if (interceptor->proc_dir) remove_proc_entry(interceptor->proc_dir->name, NULL); interceptor->proc_dir = NULL; return FALSE; }
static struct trace_cpu_data * trace_get_tcd(void) { int cpu; struct trace_cpu_data *tcd; cpu = get_cpu(); if (in_irq()) tcd = &(*trace_data[TCD_TYPE_IRQ])[cpu].tcd; else if (in_softirq()) tcd = &(*trace_data[TCD_TYPE_SOFTIRQ])[cpu].tcd; else tcd = &(*trace_data[TCD_TYPE_PROC])[cpu].tcd; trace_lock_tcd(tcd); return tcd; }
int ramster_remote_flush(struct tmem_xhandle *xh, int remotenode) { int ret = -1, status; struct r2nm_node *node = NULL; struct kvec vec[1]; size_t veclen = 1; node = r2nm_get_node_by_num(remotenode); BUG_ON(node == NULL); xh->client_id = r2nm_this_node(); /* which node is flushing */ vec[0].iov_len = sizeof(*xh); vec[0].iov_base = xh; BUG_ON(irqs_disabled()); BUG_ON(in_softirq()); ret = r2net_send_message_vec(RMSTR_TMEM_FLUSH, RMSTR_KEY, vec, veclen, remotenode, &status); r2nm_node_put(node); return ret; }
void osl_long_delay(osl_t *osh, uint usec, bool yield) { uint d; bool yielded = TRUE; int usec_to_delay = usec; unsigned long tick1, tick2, tick_diff = 0; while (usec_to_delay > 0) { if (!yield || !yielded) { d = MIN(usec_to_delay, 10); udelay(d); usec_to_delay -= d; } if (usec_to_delay > 0) { osh->oshsh->long_delay++; OSL_GETCYCLES(tick1); spin_unlock_bh(osh->oshsh->lock); if (usec_to_delay > 0 && !in_irq() && !in_softirq() && !in_interrupt()) { schedule(); yielded = TRUE; } else { yielded = FALSE; } spin_lock_bh(osh->oshsh->lock); OSL_GETCYCLES(tick2); if (yielded) { tick_diff = TICKDIFF(tick2, tick1); tick_diff = (tick_diff * 2)/(osh->oshsh->MIPS); if (tick_diff) { usec_to_delay -= tick_diff; } else yielded = 0; } osh->oshsh->long_delay--; ASSERT(osh->oshsh->long_delay >= 0); } } }
/* * Probe for the availability of crypto algorithms, and set the available * flag for any algorithms found on the system. This is typically called by * pfkey during userspace SA add, update or register. */ void xfrm_probe_algs(void) { #ifdef CONFIG_CRYPTO int i, status; BUG_ON(in_softirq()); for (i = 0; i < aalg_entries(); i++) { aalg_list[i].available = 1; } for (i = 0; i < ealg_entries(); i++) { ealg_list[i].available = 1; } for (i = 0; i < calg_entries(); i++) { status = crypto_alg_available(calg_list[i].name, 0); if (calg_list[i].available != status) calg_list[i].available = status; } #endif }
void hba_msleep(MV_U32 msec) { MV_U32 tmp=0; MV_U32 mod_msec=2000; if (in_softirq()||in_interrupt() || irqs_disabled()){ mv_touch_nmi_watchdog(); if (msec<=mod_msec) ossw_mdelay(msec); else { for(tmp=0;tmp<msec/mod_msec;tmp++) { ossw_mdelay(mod_msec); mv_touch_nmi_watchdog(); } if (msec%mod_msec) ossw_mdelay(msec%mod_msec); } mv_touch_nmi_watchdog(); }else { set_current_state(TASK_UNINTERRUPTIBLE); schedule_timeout( msecs_to_jiffies(msec)); } }
/* * Ensure FPSIMD/SVE storage in memory for the loaded context is up to * date with respect to the CPU registers. * * Softirqs (and preemption) must be disabled. */ void fpsimd_save(void) { struct user_fpsimd_state *st = __this_cpu_read(fpsimd_last_state.st); /* set by fpsimd_bind_task_to_cpu() or fpsimd_bind_state_to_cpu() */ WARN_ON(!in_softirq() && !irqs_disabled()); if (!test_thread_flag(TIF_FOREIGN_FPSTATE)) { if (system_supports_sve() && test_thread_flag(TIF_SVE)) { if (WARN_ON(sve_get_vl() != current->thread.sve_vl)) { /* * Can't save the user regs, so current would * re-enter user with corrupt state. * There's no way to recover, so kill it: */ force_signal_inject(SIGKILL, SI_KERNEL, 0); return; } sve_save_state(sve_pffr(¤t->thread), &st->fpsr); } else fpsimd_save_state(st); } }
Boolean ssh_interceptor_iface_init(SshInterceptor interceptor) { SSH_ASSERT(!in_softirq()); /* This will register notifier that notifies about bringing the interface up and down. */ interceptor->nf->notifier_netdev.notifier_call = ssh_interceptor_notifier_callback; interceptor->nf->notifier_netdev.priority = 1; interceptor->nf->notifier_netdev.next = NULL; register_netdevice_notifier(&interceptor->nf->notifier_netdev); /* This will register notifier that notifies when address of the interface changes without bringing the interface down. */ interceptor->nf->notifier_inetaddr.notifier_call = ssh_interceptor_notifier_callback; interceptor->nf->notifier_inetaddr.priority = 1; interceptor->nf->notifier_inetaddr.next = NULL; register_inetaddr_notifier(&interceptor->nf->notifier_inetaddr); #ifdef SSH_LINUX_INTERCEPTOR_IPV6 interceptor->nf->notifier_inet6addr.notifier_call = ssh_interceptor_notifier_callback; interceptor->nf->notifier_inet6addr.priority = 1; interceptor->nf->notifier_inet6addr.next = NULL; register_inet6addr_notifier(&interceptor->nf->notifier_inet6addr); #endif /* SSH_LINUX_INTERCEPTOR_IPV6 */ interceptor->nf->iface_notifiers_installed = TRUE; /* Send interface information to engine. This causes the interceptor to grab reference to each net_device. On error cases ssh_interceptor_clear_ifaces() or ssh_interceptor_iface_uninit() must be called to release the references. */ ssh_interceptor_receive_ifaces(interceptor); return TRUE; }
/** * rcu_read_lock_bh_held() - might we be in RCU-bh read-side critical section? * * Check for bottom half being disabled, which covers both the * CONFIG_PROVE_RCU and not cases. Note that if someone uses * rcu_read_lock_bh(), but then later enables BH, lockdep (if enabled) * will show the situation. This is useful for debug checks in functions * that require that they be called within an RCU read-side critical * section. * * Check debug_lockdep_rcu_enabled() to prevent false positives during boot. */ int rcu_read_lock_bh_held(void) { if (!debug_lockdep_rcu_enabled()) return 1; return in_softirq() || irqs_disabled(); }
void _mipi_csi2_unlock(struct mipi_csi2_info *info) { if (!in_irq() && !in_softirq()) mutex_unlock(&info->mutex_lock); }
static int display_secfp_proc_out_sa(char *page, char **start, off_t off, int count, int *eof, void *data) { ASF_uint32_t ulVSGId = 0; ASF_uint32_t ulTunnelId = 0; struct SPDCILinkNode_s *pCINode; SPDOutContainer_t *pOutContainer = NULL; SPDOutSALinkNode_t *pOutSALinkNode; outSA_t *pOutSA = NULL; int bVal = in_softirq(); if (!bVal) local_bh_disable(); if (secFP_TunnelIfaces[ulVSGId][ulTunnelId].bInUse == 0) { printk(KERN_INFO"Tunnel Interface is not in use"\ ".TunnelId=%u, VSGId=%u\n", ulTunnelId, ulVSGId); if (!bVal) local_bh_enable(); return ASF_IPSEC_TUNNEL_NOT_FOUND; } printk(KERN_INFO"\nVSGID= %d TUNNELID= %d, MAGIC NUM = %d\n", ulVSGId, ulTunnelId, secFP_TunnelIfaces[ulVSGId][ulTunnelId].ulTunnelMagicNumber); pCINode = secFP_TunnelIfaces[ulVSGId][ulTunnelId].pSPDCIOutList; for (; pCINode != NULL; pCINode = pCINode->pNext) { pOutContainer = (SPDOutContainer_t *)(ptrIArray_getData( &(secfp_OutDB), pCINode->ulIndex)); if (!pOutContainer) continue; printk(KERN_INFO"=========OUT Policy==================\n"); printk(KERN_INFO"Id=%d, Proto %d, Dscp %d "\ "Flags:Udp(%d) RED(%d),ESN(%d),DSCP(%d),DF(%d)\n", pCINode->ulIndex, pOutContainer->SPDParams.ucProto, pOutContainer->SPDParams.ucDscp, pOutContainer->SPDParams.bUdpEncap, pOutContainer->SPDParams.bRedSideFrag, pOutContainer->SPDParams.bESN, pOutContainer->SPDParams.bCopyDscp, pOutContainer->SPDParams.handleDf); print_SPDPolPPStats(pOutContainer->PPStats); printk(KERN_INFO"--------------SA_LIST--------------------"); for (pOutSALinkNode = pOutContainer->SAHolder.pSAList; pOutSALinkNode != NULL; pOutSALinkNode = pOutSALinkNode->pNext) { printk(KERN_INFO"\nSA-ID= %d ", pOutSALinkNode->ulSAIndex); pOutSA = (outSA_t *) ptrIArray_getData(&secFP_OutSATable, pOutSALinkNode->ulSAIndex); if (pOutSA) { ASFSAStats_t outParams = {0, 0}; ASFIPSecGetSAQueryParams_t inParams; print_SAParams(&pOutSA->SAParams); inParams.ulVSGId = ulVSGId; inParams.ulTunnelId = ulTunnelId; inParams.ulSPDContainerIndex = pCINode->ulIndex; inParams.ulSPI = pOutSA->SAParams.ulSPI; inParams.gwAddr.bIPv4OrIPv6 = pOutSA->SAParams.tunnelInfo.bIPv4OrIPv6; if (pOutSA->SAParams.tunnelInfo.bIPv4OrIPv6) memcpy(inParams.gwAddr.ipv6addr, pOutSA->SAParams.tunnelInfo.addr.iphv6.daddr, 16); else inParams.gwAddr.ipv4addr = pOutSA->SAParams.tunnelInfo.addr.iphv4.daddr; inParams.ucProtocol = pOutSA->SAParams.ucProtocol; inParams.bDir = SECFP_OUT; ASFIPSecSAQueryStats(&inParams, &outParams); printk(KERN_INFO"Stats:ulBytes=%llu, ulPkts=%llu", outParams.ulBytes, outParams.ulPkts); printk(KERN_INFO"L2BlobLen = %d, Magic = %d\n", pOutSA->ulL2BlobLen, pOutSA->l2blobConfig.ulL2blobMagicNumber); #ifdef ASF_QMAN_IPSEC printk(KERN_INFO"SecFQ=%d, RecvFQ=%d\n", pOutSA->ctx.SecFq->qman_fq.fqid, pOutSA->ctx.RecvFq->qman_fq.fqid); #endif } } printk(KERN_INFO"\n"); } if (!bVal) local_bh_enable(); return 0; }
static int display_secfp_proc_in_spd(char *page, char **start, off_t off, int count, int *eof, void *data) { int ulSAIndex; ASF_uint32_t ulVSGId = 0; ASF_uint32_t ulTunnelId = 0; struct SPDCILinkNode_s *pCINode; SPDInContainer_t *pInContainer = NULL; SPDInSPIValLinkNode_t *pSPILinkNode; int bVal = in_softirq(); if (!bVal) local_bh_disable(); if (secFP_TunnelIfaces[ulVSGId][ulTunnelId].bInUse == 0) { printk(KERN_INFO"\nTunnel Interface is not in use"\ ".TunnelId=%u, VSGId=%u\n", ulTunnelId, ulVSGId); if (!bVal) local_bh_enable(); return ASF_IPSEC_TUNNEL_NOT_FOUND; } printk(KERN_INFO"\nVSGID= %d TUNNELID= %d, MAGIC NUM = %d", ulVSGId, ulTunnelId, secFP_TunnelIfaces[ulVSGId][ulTunnelId].ulTunnelMagicNumber); pCINode = secFP_TunnelIfaces[ulVSGId][ulTunnelId].pSPDCIInList; for (; pCINode != NULL; pCINode = pCINode->pNext) { pInContainer = (SPDInContainer_t *)(ptrIArray_getData( &(secfp_InDB), pCINode->ulIndex)); if (!pInContainer) continue; printk(KERN_INFO"=========IN Policy==================\n"); printk(KERN_INFO"Id=%d, Proto 0x%x, Dscp 0x%x "\ "Flags:Udp(%d) ESN(%d),DSCP(%d),ECN(%d)\n", pCINode->ulIndex, pInContainer->SPDParams.ucProto, pInContainer->SPDParams.ucDscp, pInContainer->SPDParams.bUdpEncap, pInContainer->SPDParams.bESN, pInContainer->SPDParams.bCopyDscp, pInContainer->SPDParams.bCopyEcn); print_SPDPolPPStats(pInContainer->PPStats); printk(KERN_INFO"List IN SA -SPI Val:"); for (pSPILinkNode = pInContainer->pSPIValList, ulSAIndex = 0; pSPILinkNode != NULL; pSPILinkNode = pSPILinkNode->pNext, ulSAIndex++) { printk(KERN_INFO"0x%x ", pSPILinkNode->ulSPIVal); if (ulSAIndex % 10) printk(KERN_INFO"\n"); } printk(KERN_INFO"\n"); } if (!bVal) local_bh_enable(); return 0; }
static int display_secfp_proc_out_spd(char *page, char **start, off_t off, int count, int *eof, void *data) { ASF_uint32_t ulVSGId = 0; ASF_uint32_t ulTunnelId = 0; struct SPDCILinkNode_s *pCINode; SPDOutContainer_t *pOutContainer = NULL; SPDOutSALinkNode_t *pOutSALinkNode; int bVal = in_softirq(); if (!bVal) local_bh_disable(); if (secFP_TunnelIfaces[ulVSGId][ulTunnelId].bInUse == 0) { printk(KERN_INFO"Tunnel Interface is not in use"\ ".TunnelId=%u, VSGId=%u\n", ulTunnelId, ulVSGId); if (!bVal) local_bh_enable(); return ASF_IPSEC_TUNNEL_NOT_FOUND; } printk(KERN_INFO"\nVSGID= %d TUNNELID= %d, MAGIC NUM = %d\n", ulVSGId, ulTunnelId, secFP_TunnelIfaces[ulVSGId][ulTunnelId].ulTunnelMagicNumber); pCINode = secFP_TunnelIfaces[ulVSGId][ulTunnelId].pSPDCIOutList; for (; pCINode != NULL; pCINode = pCINode->pNext) { pOutContainer = (SPDOutContainer_t *)(ptrIArray_getData( &(secfp_OutDB), pCINode->ulIndex)); if (!pOutContainer) continue; printk(KERN_INFO"=========OUT Policy==================\n"); printk(KERN_INFO"Id=%d, Proto 0x%x, Dscp 0x%x"\ "Flags:Udp(%d) RED(%d),ESN(%d),DSCP(%d),DF(%d)\n", pCINode->ulIndex, pOutContainer->SPDParams.ucProto, pOutContainer->SPDParams.ucDscp, pOutContainer->SPDParams.bUdpEncap, pOutContainer->SPDParams.bRedSideFrag, pOutContainer->SPDParams.bESN, pOutContainer->SPDParams.bCopyDscp, pOutContainer->SPDParams.handleDf); print_SPDPolPPStats(pOutContainer->PPStats); printk(KERN_INFO"List SA IDs:"); for (pOutSALinkNode = pOutContainer->SAHolder.pSAList; pOutSALinkNode != NULL; pOutSALinkNode = pOutSALinkNode->pNext) { printk(KERN_INFO" %d ", pOutSALinkNode->ulSAIndex); if (pOutSALinkNode->ulSAIndex % 10) printk(KERN_INFO"\n\t"); } printk(KERN_INFO"\n"); } if (!bVal) local_bh_enable(); return 0; }
void sm_pwrite_miss_copy_from_device_start(struct bittern_cache *bc, struct work_item *wi) { struct bio *bio = wi->wi_original_bio; struct cache_block *cache_block = wi->wi_cache_block; int val; struct page *cache_page; M_ASSERT(bio != NULL); ASSERT((wi->wi_flags & WI_FLAG_BIO_CLONED) != 0); ASSERT(wi->wi_original_bio != NULL); ASSERT(bio_is_request_single_cache_block(bio)); ASSERT(cache_block->bcb_sector == bio_sector_to_cache_block_sector(bio)); ASSERT(cache_block->bcb_state == S_CLEAN_P_WRITE_MISS_CPF_DEVICE_START || cache_block->bcb_state == S_DIRTY_P_WRITE_MISS_CPF_DEVICE_START); ASSERT(wi->wi_original_cache_block == NULL); pmem_data_get_page_write(bc, cache_block, &wi->wi_pmem_ctx); cache_page = pmem_context_data_page(&wi->wi_pmem_ctx); atomic_inc(&bc->bc_read_cached_device_requests); val = atomic_inc_return(&bc->bc_pending_cached_device_requests); atomic_set_if_higher(&bc->bc_highest_pending_cached_device_requests, val); BT_TRACE(BT_LEVEL_TRACE2, bc, wi, cache_block, bio, wi->wi_cloned_bio, "copy-from-device"); ASSERT_BITTERN_CACHE(bc); ASSERT_CACHE_BLOCK(cache_block, bc); if (cache_block->bcb_state == S_CLEAN_P_WRITE_MISS_CPF_DEVICE_START) { cache_state_transition3(bc, cache_block, TS_P_WRITE_MISS_WT, S_CLEAN_P_WRITE_MISS_CPF_DEVICE_START, S_CLEAN_P_WRITE_MISS_CPF_DEVICE_END); } else { ASSERT(cache_block->bcb_state == S_DIRTY_P_WRITE_MISS_CPF_DEVICE_START); cache_state_transition3(bc, cache_block, TS_P_WRITE_MISS_WB, S_DIRTY_P_WRITE_MISS_CPF_DEVICE_START, S_DIRTY_P_WRITE_MISS_CPF_DEVICE_END); } /* * we are in the first state -- process context */ M_ASSERT(!in_irq() && !in_softirq()); wi->wi_ts_workqueue = current_kernel_time_nsec(); cached_dev_do_make_request(bc, wi, READ, /* datadir */ false); /* do not set original bio */ }
void sm_pwrite_miss_copy_from_device_end(struct bittern_cache *bc, struct work_item *wi, int err) { struct bio *bio = wi->wi_original_bio; struct cache_block *cache_block = wi->wi_cache_block; uint128_t hash_data; char *cache_vaddr; struct page *cache_page; M_ASSERT_FIXME(err == 0); M_ASSERT(bio != NULL); ASSERT((wi->wi_flags & WI_FLAG_BIO_CLONED) != 0); ASSERT(wi->wi_original_bio != NULL); ASSERT(bio_is_request_single_cache_block(bio)); ASSERT(cache_block->bcb_sector == bio_sector_to_cache_block_sector(bio)); ASSERT(cache_block->bcb_state == S_CLEAN_P_WRITE_MISS_CPF_DEVICE_END || cache_block->bcb_state == S_DIRTY_P_WRITE_MISS_CPF_DEVICE_END); ASSERT(wi->wi_original_cache_block == NULL); BT_TRACE(BT_LEVEL_TRACE2, bc, wi, cache_block, bio, NULL, "endio"); cache_vaddr = pmem_context_data_vaddr(&wi->wi_pmem_ctx); cache_page = pmem_context_data_page(&wi->wi_pmem_ctx); atomic_dec(&bc->bc_pending_cached_device_requests); /* * we can check the original hash */ cache_track_hash_check_buffer(bc, cache_block, cache_vaddr); /* * copy to cache from bio, aka userland writes */ bio_copy_to_cache(wi, bio, &hash_data); /* update hash */ cache_block->bcb_hash_data = hash_data; /* * update hash */ cache_track_hash_set(bc, cache_block, cache_block->bcb_hash_data); ASSERT(wi->wi_original_cache_block == NULL); if (cache_block->bcb_state == S_CLEAN_P_WRITE_MISS_CPF_DEVICE_END) { int val; BT_TRACE(BT_LEVEL_TRACE2, bc, wi, cache_block, bio, wi->wi_cloned_bio, "copy-to-device"); atomic_inc(&bc->bc_write_cached_device_requests); val = atomic_inc_return(&bc->bc_pending_cached_device_requests); atomic_set_if_higher( &bc->bc_highest_pending_cached_device_requests, val); ASSERT_BITTERN_CACHE(bc); ASSERT_CACHE_BLOCK(cache_block, bc); ASSERT_WORK_ITEM(wi, bc); cache_state_transition3(bc, cache_block, TS_P_WRITE_MISS_WT, S_CLEAN_P_WRITE_MISS_CPF_DEVICE_END, S_CLEAN_P_WRITE_MISS_CPT_DEVICE_END); /* * we are in the first state -- process context */ M_ASSERT(!in_irq() && !in_softirq()); wi->wi_ts_workqueue = current_kernel_time_nsec(); cached_dev_do_make_request(bc, wi, WRITE, /* datadir */ false); /* do not set original bio */ } else { BT_TRACE(BT_LEVEL_TRACE2, bc, wi, cache_block, bio, wi->wi_cloned_bio, "copy-to-cache"); /* * for writeback we commit to cache and then we are done */ cache_state_transition3(bc, cache_block, TS_P_WRITE_MISS_WB, S_DIRTY_P_WRITE_MISS_CPF_DEVICE_END, S_DIRTY_P_WRITE_MISS_CPT_CACHE_END); pmem_data_put_page_write(bc, cache_block, &wi->wi_pmem_ctx, wi, /*callback context */ cache_put_page_write_callback, S_DIRTY); } }
ASF_int32_t asfctrl_delete_dev_map(struct net_device *dev) { ASF_int32_t cii; ASF_uint32_t ulVSGId; ASFCTRL_FUNC_ENTRY; #ifdef CONFIG_PPPOE if ((dev->type == ARPHRD_ETHER) || (dev->type == ARPHRD_PPP)) { #else if (dev->type == ARPHRD_ETHER) { #endif cii = asfctrl_dev_get_cii(dev); if (cii < 0) { ASFCTRL_DBG("Failed to determine cii for device %s\n", dev->name); return T_FAILURE; } ASFCTRL_DBG("UNMAP interface %s\n", dev->name); /* Get the VSG Id from asfctrl_netns Subha 11/3 */ ulVSGId = asfctrl_netns_net_to_vsg(dev_net(dev)); printk("UnRegister Device: ulVSGId = %d\n", ulVSGId); ASFUnBindDeviceToVSG(ulVSGId, cii); ASFUnMapInterface(cii); dev_put(dev); p_asfctrl_netdev_cii[cii] = NULL; return T_SUCCESS; } ASFCTRL_FUNC_EXIT; return T_FAILURE; } EXPORT_SYMBOL(asfctrl_delete_dev_map); #if (ASFCTRL_DEBUG_LEVEL >= LOGS) char *print_netevent(int event) { switch (event) { case NETDEV_UP: return (char *)"NETDEV_UP"; case NETDEV_DOWN: return (char *)"NETDEV_DOWN"; case NETDEV_REBOOT: return (char *)"NETDEV_REBOOT"; case NETDEV_CHANGE: return (char *)"NETDEV_CHANGE"; case NETDEV_REGISTER: return (char *)"NETDEV_REGISTER"; case NETDEV_UNREGISTER: return (char *)"NETDEV_UNREGISTER"; case NETDEV_CHANGEMTU: return (char *)"NETDEV_CHANGEMTU"; case NETDEV_CHANGEADDR: return (char *)"NETDEV_CHANGEADDR"; case NETDEV_GOING_DOWN: return (char *)"NETDEV_GOING_DOWN"; case NETDEV_CHANGENAME: return (char *)"NETDEV_CHANGENAME"; case NETDEV_PRE_UP: return (char *)"NETDEV_PRE_UP"; default: return (char *)"UNKNOWN"; } } #endif static int asfctrl_dev_notifier_fn(struct notifier_block *this, unsigned long event, void *ptr) { #if 0 /* Linux verions less than 3.8 */ struct net_device *dev = (struct net_device *)(ptr); #else /* Versions above 3.8 */ struct net_device *dev = ((struct netdev_notifier_info *)(ptr))->dev; #endif if (dev == NULL) { ASFCTRL_DBG("asfctrl_dev_notifier: NULL String for dev? \n"); return NOTIFY_DONE; } ASFCTRL_FUNC_ENTRY; printk(KERN_INFO "Subha: asfctrl_dev_notifier called for dev = 0x%x\n", dev); ASFCTRL_DBG("%s - event %ld (%s)\n", dev->name, event, print_netevent(event)); /* handle only ethernet, vlan, bridge and pppoe (ppp) interfaces */ switch (event) { case NETDEV_REGISTER: /* A new device is allocated*/ printk(KERN_INFO "Subha: NETDEV_REGISTER\n"); printk(KERN_INFO "dev->type = %d, ARPHDR_ETHER =%d device=%s\n", dev->type, ARPHRD_ETHER, dev->name); ASFCTRL_INFO("Register Device type %d mac %pM\n", dev->type, dev->dev_addr); if (dev->type == ARPHRD_ETHER) asfctrl_create_dev_map(dev, 1); break; case NETDEV_UNREGISTER:/* A new device is deallocated*/ ASFCTRL_INFO("Unregister Device type %d mac %pM\n", dev->type, dev->dev_addr); #ifdef CONFIG_PPPOE if (dev->type == ARPHRD_ETHER || dev->type == ARPHRD_PPP) #else if (dev->type == ARPHRD_ETHER) #endif asfctrl_delete_dev_map(dev); break; #ifdef CONFIG_PPPOE case NETDEV_UP: if (dev->type == ARPHRD_PPP) asfctrl_create_dev_map(dev, 1); break; #endif } ASFCTRL_FUNC_EXIT; return NOTIFY_DONE; } int asfctrl_dev_fp_tx_hook(struct sk_buff *skb, struct net_device *dev) { ASF_uint16_t usEthType; ASF_int32_t hh_len; ASF_boolean_t bPPPoE = 0; struct iphdr *iph = 0; struct ipv6hdr *ipv6h; unsigned int proto; unsigned int tun_hdr = 0; ASFCTRL_FUNC_ENTRY; if (!asfctrl_skb_is_dummy(skb)) return AS_FP_PROCEED; asfctrl_skb_unmark_dummy(skb); if (dev->type != ARPHRD_ETHER) goto drop; ASFCTRL_INFO("asfctrl_dev_fp_tx: 2\n"); usEthType = skb->protocol; hh_len = ETH_HLEN; if (usEthType == __constant_htons(ETH_P_8021Q)) { struct vlan_hdr *vhdr = (struct vlan_hdr *)(skb->data+hh_len); ASFCTRL_TRACE("8021Q packet"); hh_len += VLAN_HLEN; usEthType = vhdr->h_vlan_encapsulated_proto; } if (usEthType == __constant_htons(ETH_P_PPP_SES)) { unsigned char *poe_hdr = skb->data+hh_len; unsigned short ppp_proto; ASFCTRL_TRACE("PPPoE packet"); /*PPPoE header is of 6 bytes */ ppp_proto = *(unsigned short *)(poe_hdr+6); /* PPPOE: VER=1,TYPE=1,CODE=0 and PPP:_PROTO=0x0021 (IP) */ if ((poe_hdr[0] != 0x11) || (poe_hdr[1] != 0) || (ppp_proto != __constant_htons(0x0021))) { goto drop; } hh_len += (8); /* 6+2 -- pppoe+ppp headers */ usEthType = __constant_htons(ETH_P_IP); bPPPoE = 1; } ASFCTRL_INFO("subha: asfctrl_dev_fp_tx: 3\n"); if (usEthType != __constant_htons(ETH_P_IP) && usEthType != __constant_htons(ETH_P_IPV6)) goto drop; ASFCTRL_INFO("subha: asfctrl_dev_fp_tx: 4\n"); if (usEthType == __constant_htons(ETH_P_IP)) { iph = (struct iphdr *)(skb->data+hh_len); proto = iph->protocol; if (proto == IPPROTO_IPV6) { ipv6h = (struct ipv6hdr *)(skb->data+hh_len+sizeof(struct iphdr)); proto = ipv6h->nexthdr; tun_hdr = sizeof(struct iphdr); } } else { ipv6h = (struct ipv6hdr *)(skb->data+hh_len); proto = ipv6h->nexthdr; if (proto == IPPROTO_IPIP) { iph = (struct iphdr *)(skb->data+hh_len+sizeof(struct ipv6hdr)); proto = iph->protocol; tun_hdr = sizeof(struct ipv6hdr); } } ASFCTRL_INFO("subha: asfctrl_dev_fp_tx: 5\n"); switch (proto) { asf_linux_L2blobPktData_t *pData; ASFFFPUpdateFlowParams_t cmd; case ASFCTRL_IPPROTO_DUMMY_L2BLOB: /* * if the packet is coming on a PPP interface, * network header points to start of PPPOE header * instaed of IP header. * So always dynamically identify start of IP header! */ memset(&cmd, 0, sizeof(cmd)); cmd.u.l2blob.bUpdatePPPoELen = bPPPoE; ASFCTRL_INFO( "DUMMY_L2BLOB: %pM:%pM..%02x%02x (skb->proto 0x%04x) " "data 0x%p nw_hdr 0x%p tr_hdr 0x%p\n", skb->data, skb->data+6, skb->data[12], skb->data[13], skb->protocol, skb->data, skb_network_header(skb), skb_transport_header(skb)); if (usEthType == __constant_htons(ETH_P_IP)) { pData = (asf_linux_L2blobPktData_t *)(skb->data+hh_len + (iph->ihl * 4) + (tun_hdr ? sizeof(struct ipv6hdr) : 0)); cmd.u.l2blob.tunnel.bIP6IP4Out = tun_hdr ? 1 : 0; } else { pData = (asf_linux_L2blobPktData_t *)(skb->data+hh_len + sizeof(struct ipv6hdr) + (tun_hdr ? sizeof(struct iphdr) : 0)); cmd.u.l2blob.tunnel.bIP4IP6Out = tun_hdr ? 1 : 0; } memcpy(&cmd.tuple, &pData->tuple, sizeof(cmd.tuple)); cmd.ulZoneId = pData->ulZoneId; cmd.bL2blobUpdate = 1; cmd.u.l2blob.ulDeviceId = asfctrl_dev_get_cii(dev); cmd.u.l2blob.ulPathMTU = pData->ulPathMTU; cmd.u.l2blob.ulL2blobMagicNumber = asfctrl_vsg_l2blobconfig_id; /* need to include PPPOE+PPP header if any */ cmd.u.l2blob.l2blobLen = hh_len + tun_hdr; memcpy(cmd.u.l2blob.l2blob, skb->data, cmd.u.l2blob.l2blobLen); #ifdef CONFIG_VLAN_8021Q #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0) if (vlan_tx_tag_present(skb)) { #else if (skb_vlan_tag_present(skb)) { #endif cmd.u.l2blob.bTxVlan = 1; #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0) cmd.u.l2blob.usTxVlanId = (vlan_tx_tag_get(skb) | VLAN_TAG_PRESENT); #else cmd.u.l2blob.usTxVlanId = (skb_vlan_tag_get(skb) | VLAN_TAG_PRESENT); #endif } else #endif cmd.u.l2blob.bTxVlan = 0; ASFFFPRuntime(pData->ulVsgId, ASF_FFP_MODIFY_FLOWS, &cmd, sizeof(cmd), NULL, 0); break; #ifdef ASFCTRL_IPSEC_FP_SUPPORT case ASFCTRL_IPPROTO_DUMMY_IPSEC_L2BLOB: ASFCTRL_INFO("DUMMY_IPSEC_L2BLOB"); skb->protocol = usEthType; if (fn_ipsec_l2blob_update) fn_ipsec_l2blob_update(skb, hh_len, asfctrl_dev_get_cii(dev)); break; #endif #ifdef ASFCTRL_FWD_FP_SUPPORT case ASFCTRL_IPPROTO_DUMMY_FWD_L2BLOB: ASFCTRL_INFO("DUMMY_FWD_L2BLOB"); if (fn_fwd_l2blob_update) fn_fwd_l2blob_update(skb, hh_len, asfctrl_dev_get_cii(dev)); break; #endif #ifdef ASFCTRL_TERM_FP_SUPPORT case ASFCTRL_IPPROTO_DUMMY_TERM_L2BLOB: ASFCTRL_INFO("DUMMY_TERM_L2BLOB"); if (fn_term_l2blob_update) fn_term_l2blob_update(skb, hh_len, asfctrl_dev_get_cii(dev)); break; #endif } drop: ASFCTRLKernelSkbFree(skb); ASFCTRL_FUNC_EXIT; return AS_FP_STOLEN; } static struct notifier_block asfctrl_dev_notifier = { .notifier_call = asfctrl_dev_notifier_fn, }; ASF_void_t asfctrl_fnInterfaceNotFound( ASFBuffer_t Buffer, genericFreeFn_t pFreeFn, ASF_void_t *freeArg) { struct sk_buff *skb; int bVal = in_softirq(); ASFCTRL_FUNC_ENTRY; skb = AsfBuf2Skb(Buffer); if (!bVal) local_bh_disable(); /* Send it to for normal path handling */ ASFCTRL_netif_receive_skb(skb); if (!bVal) local_bh_enable(); ASFCTRL_FUNC_EXIT; } ASF_void_t asfctrl_fnVSGMappingNotFound( ASF_uint32_t ulCommonInterfaceId, ASFBuffer_t Buffer, genericFreeFn_t pFreeFn, ASF_void_t *freeArg) { struct sk_buff *skb; int bVal = in_softirq(); ASFCTRL_FUNC_ENTRY; skb = AsfBuf2Skb(Buffer); if (!bVal) local_bh_disable(); /* Send it to for normal path handling */ ASFCTRL_netif_receive_skb(skb); if (!bVal) local_bh_enable(); ASFCTRL_FUNC_EXIT; } static int __init asfctrl_init(void) { int ret; ASFFFPConfigIdentity_t cmd; ASFFFPCallbackFns_t asfctrl_Cbs = { asfctrl_fnInterfaceNotFound, asfctrl_fnVSGMappingNotFound, asfctrl_fnZoneMappingNotFound, asfctrl_fnNoFlowFound, asfctrl_fnRuntime, asfctrl_fnFlowRefreshL2Blob, asfctrl_fnFlowActivityRefresh, asfctrl_fnFlowTcpSpecialPkts, asfctrl_fnFlowValidate, asfctrl_fnAuditLog }; ASFCTRL_FUNC_ENTRY; memset(p_asfctrl_netdev_cii, 0, sizeof(p_asfctrl_netdev_cii)); ASFGetCapabilities(&g_cap); if (!g_cap.bBufferHomogenous) { ASFCTRL_ERR("ASF capabilities: Non homogenous buffer"); return -1; } asfctrl_vsg_config_id = jiffies; memset(&cmd, 0, sizeof(cmd)); cmd.ulConfigMagicNumber = asfctrl_vsg_config_id; ASFFFPUpdateConfigIdentity(ASF_DEF_VSG, cmd); memset(&cmd, 0, sizeof(cmd)); cmd.bL2blobMagicNumber = 1; cmd.l2blobConfig.ulL2blobMagicNumber = asfctrl_vsg_l2blobconfig_id; ASFFFPUpdateConfigIdentity(ASF_DEF_VSG, cmd); ASFFFPRegisterCallbackFns(&asfctrl_Cbs); ret = asfctrl_netns_vsg_init(); printk("asfctrl_netns_vsg_init returned %d\n", ret); printk(KERN_INFO "Subha: before asfctrl_dev_notifier\r\n"); register_netdevice_notifier(&asfctrl_dev_notifier); printk(KERN_INFO "Subha: before devfp_register_hook\r\n"); printk(KERN_INFO "Subha: devfp_register_hook called asf_ffp_devfp_rx=0x%x, asfctrl_dev_fp_tx_hook=%x\r\n", (int)asf_ffp_devfp_rx, (int)asfctrl_dev_fp_tx_hook); //devfp_register_hook(asf_ffp_devfp_rx, asfctrl_dev_fp_tx_hook); devfp_register_rx_hook_veth(asf_ffp_devfp_rx_veth); devfp_register_tx_hook_veth(asfctrl_dev_fp_tx_hook); route_hook_fn_register(&asfctrl_l3_route_flush); #ifdef ASF_IPV6_FP_SUPPORT ipv6_route_hook_fn_register(&asfctrl_l3_ipv6_route_flush); #endif asfctrl_sysfs_init(); if (g_cap.mode & fwMode) asfctrl_linux_register_ffp(); if (ASFGetStatus() == 0) ASFDeploy(); ASFCTRL_INFO("ASF Control Module - Core Loaded.\n"); ASFCTRL_FUNC_EXIT; return 0; }
static int display_secfp_proc_in_sa(char *page, char **start, off_t off, int count, int *eof, void *data) { int ulSAIndex; ASF_uint32_t ulVSGId = 0; ASF_uint32_t ulTunnelId = 0; struct SPDCILinkNode_s *pCINode; SPDInContainer_t *pInContainer = NULL; SPDInSPIValLinkNode_t *pSPILinkNode; inSA_t *pInSA = NULL; unsigned int ulHashVal; int bVal = in_softirq(); if (!bVal) local_bh_disable(); if (secFP_TunnelIfaces[ulVSGId][ulTunnelId].bInUse == 0) { printk(KERN_INFO"Tunnel Interface is not in use"\ ".TunnelId=%u, VSGId=%u\n", ulTunnelId, ulVSGId); if (!bVal) local_bh_enable(); return ASF_IPSEC_TUNNEL_NOT_FOUND; } printk(KERN_INFO"\nVSGID= %d TUNNELID= %d, MAGIC NUM = %d\n", ulVSGId, ulTunnelId, secFP_TunnelIfaces[ulVSGId][ulTunnelId].ulTunnelMagicNumber); pCINode = secFP_TunnelIfaces[ulVSGId][ulTunnelId].pSPDCIInList; for (; pCINode != NULL; pCINode = pCINode->pNext) { pInContainer = (SPDInContainer_t *)(ptrIArray_getData( &(secfp_InDB), pCINode->ulIndex)); if (!pInContainer) continue; printk(KERN_INFO"=========IN Policy==================\n"); printk(KERN_INFO"Id=%d, Proto %d, Dscp %d "\ "Flags:Udp(%d) ESN(%d),DSCP(%d),ECN(%d)\n", pCINode->ulIndex, pInContainer->SPDParams.ucProto, pInContainer->SPDParams.ucDscp, pInContainer->SPDParams.bUdpEncap, pInContainer->SPDParams.bESN, pInContainer->SPDParams.bCopyDscp, pInContainer->SPDParams.bCopyEcn); print_SPDPolPPStats(pInContainer->PPStats); printk(KERN_INFO"--------------SA_LIST--------------------"); for (pSPILinkNode = pInContainer->pSPIValList, ulSAIndex = 0; pSPILinkNode != NULL; pSPILinkNode = pSPILinkNode->pNext, ulSAIndex++) { printk(KERN_INFO"\nSPI = 0x%x", pSPILinkNode->ulSPIVal); ulHashVal = secfp_compute_hash(pSPILinkNode->ulSPIVal); for (pInSA = secFP_SPIHashTable[ulHashVal].pHeadSA; pInSA != NULL; pInSA = pInSA->pNext) { ASFSAStats_t outParams = {0, 0}; ASFIPSecGetSAQueryParams_t inParams; printk(KERN_INFO"SpdContId =%d", pInSA->ulSPDInContainerIndex); print_SAParams(&pInSA->SAParams); inParams.ulVSGId = ulVSGId; inParams.ulTunnelId = ulTunnelId; inParams.ulSPDContainerIndex = pCINode->ulIndex; inParams.ulSPI = pInSA->SAParams.ulSPI; inParams.gwAddr.bIPv4OrIPv6 = pInSA->SAParams.tunnelInfo.bIPv4OrIPv6; if (pInSA->SAParams.tunnelInfo.bIPv4OrIPv6) memcpy(inParams.gwAddr.ipv6addr, pInSA->SAParams.tunnelInfo.addr.iphv6.daddr, 16); else inParams.gwAddr.ipv4addr = pInSA->SAParams.tunnelInfo.addr.iphv4.daddr; inParams.ucProtocol = pInSA->SAParams.ucProtocol; inParams.bDir = SECFP_IN; ASFIPSecSAQueryStats(&inParams, &outParams); printk(KERN_INFO"Stats:ulBytes=%llu,ulPkts= %llu", outParams.ulBytes, outParams.ulPkts); #ifdef ASF_QMAN_IPSEC printk(KERN_INFO"SecFQ=%d, RecvFQ=%d\n", pInSA->ctx.SecFq->qman_fq.fqid, pInSA->ctx.RecvFq->qman_fq.fqid); #endif } } printk(KERN_INFO"\n"); } if (!bVal) local_bh_enable(); return 0; }