void
flowadv_add_entry(struct flowadv_fcentry *fce) {
lck_mtx_lock_spin(&fadv_lock);
STAILQ_INSERT_HEAD(&fadv_list, fce, fce_link);
VERIFY(!STAILQ_EMPTY(&fadv_list));
if (!fadv_active && fadv_thread != THREAD_NULL)
wakeup_one((caddr_t)&fadv_list);
lck_mtx_unlock(&fadv_lock);
}
/*
* Routine: lck_mtx_sleep
*/
wait_result_t
lck_mtx_sleep(
lck_mtx_t *lck,
lck_sleep_action_t lck_sleep_action,
event_t event,
wait_interrupt_t interruptible)
{
wait_result_t res;
thread_t thread = current_thread();
KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_SLEEP_CODE) | DBG_FUNC_START,
VM_KERNEL_UNSLIDE_OR_PERM(lck), (int)lck_sleep_action, VM_KERNEL_UNSLIDE_OR_PERM(event), (int)interruptible, 0);
if ((lck_sleep_action & ~LCK_SLEEP_MASK) != 0)
panic("Invalid lock sleep action %x\n", lck_sleep_action);
if (lck_sleep_action & LCK_SLEEP_PROMOTED_PRI) {
/*
* We overload the RW lock promotion to give us a priority ceiling
* during the time that this thread is asleep, so that when it
* is re-awakened (and not yet contending on the mutex), it is
* runnable at a reasonably high priority.
*/
thread->rwlock_count++;
}
res = assert_wait(event, interruptible);
if (res == THREAD_WAITING) {
lck_mtx_unlock(lck);
res = thread_block(THREAD_CONTINUE_NULL);
if (!(lck_sleep_action & LCK_SLEEP_UNLOCK)) {
if ((lck_sleep_action & LCK_SLEEP_SPIN))
lck_mtx_lock_spin(lck);
else if ((lck_sleep_action & LCK_SLEEP_SPIN_ALWAYS))
lck_mtx_lock_spin_always(lck);
else
lck_mtx_lock(lck);
}
}
else
if (lck_sleep_action & LCK_SLEEP_UNLOCK)
lck_mtx_unlock(lck);
if (lck_sleep_action & LCK_SLEEP_PROMOTED_PRI) {
if ((thread->rwlock_count-- == 1 /* field now 0 */) && (thread->sched_flags & TH_SFLAG_RW_PROMOTED)) {
/* sched_flags checked without lock, but will be rechecked while clearing */
lck_rw_clear_promotion(thread);
}
}
KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_SLEEP_CODE) | DBG_FUNC_END, (int)res, 0, 0, 0, 0);
return res;
}
/*
* Routine: lck_mtx_sleep_deadline
*/
wait_result_t
lck_mtx_sleep_deadline(
lck_mtx_t *lck,
lck_sleep_action_t lck_sleep_action,
event_t event,
wait_interrupt_t interruptible,
uint64_t deadline)
{
wait_result_t res;
thread_t thread = current_thread();
KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_SLEEP_DEADLINE_CODE) | DBG_FUNC_START,
VM_KERNEL_UNSLIDE_OR_PERM(lck), (int)lck_sleep_action, VM_KERNEL_UNSLIDE_OR_PERM(event), (int)interruptible, 0);
if ((lck_sleep_action & ~LCK_SLEEP_MASK) != 0)
panic("Invalid lock sleep action %x\n", lck_sleep_action);
if (lck_sleep_action & LCK_SLEEP_PROMOTED_PRI) {
/*
* See lck_mtx_sleep().
*/
thread->rwlock_count++;
}
res = assert_wait_deadline(event, interruptible, deadline);
if (res == THREAD_WAITING) {
lck_mtx_unlock(lck);
res = thread_block(THREAD_CONTINUE_NULL);
if (!(lck_sleep_action & LCK_SLEEP_UNLOCK)) {
if ((lck_sleep_action & LCK_SLEEP_SPIN))
lck_mtx_lock_spin(lck);
else
lck_mtx_lock(lck);
}
}
else
if (lck_sleep_action & LCK_SLEEP_UNLOCK)
lck_mtx_unlock(lck);
if (lck_sleep_action & LCK_SLEEP_PROMOTED_PRI) {
if ((thread->rwlock_count-- == 1 /* field now 0 */) && (thread->sched_flags & TH_SFLAG_RW_PROMOTED)) {
/* sched_flags checked without lock, but will be rechecked while clearing */
lck_rw_clear_promotion(thread);
}
}
KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_LOCKS, LCK_MTX_SLEEP_DEADLINE_CODE) | DBG_FUNC_END, (int)res, 0, 0, 0, 0);
return res;
}
void
flowadv_add(struct flowadv_fclist *fcl)
{
if (STAILQ_EMPTY(fcl))
return;
lck_mtx_lock_spin(&fadv_lock);
STAILQ_CONCAT(&fadv_list, fcl);
VERIFY(!STAILQ_EMPTY(&fadv_list));
if (!fadv_active && fadv_thread != THREAD_NULL)
wakeup_one((caddr_t)&fadv_list);
lck_mtx_unlock(&fadv_lock);
}
static int
flowadv_thread_cont(int err)
{
#pragma unused(err)
for (;;) {
lck_mtx_assert(&fadv_lock, LCK_MTX_ASSERT_OWNED);
while (STAILQ_EMPTY(&fadv_list)) {
VERIFY(!fadv_active);
(void) msleep0(&fadv_list, &fadv_lock, (PSOCK | PSPIN),
"flowadv_cont", 0, flowadv_thread_cont);
/* NOTREACHED */
}
fadv_active = 1;
for (;;) {
struct flowadv_fcentry *fce;
VERIFY(!STAILQ_EMPTY(&fadv_list));
fce = STAILQ_FIRST(&fadv_list);
STAILQ_REMOVE(&fadv_list, fce,
flowadv_fcentry, fce_link);
STAILQ_NEXT(fce, fce_link) = NULL;
lck_mtx_unlock(&fadv_lock);
switch (fce->fce_flowsrc) {
case FLOWSRC_INPCB:
inp_flowadv(fce->fce_flowid);
break;
case FLOWSRC_IFNET:
ifnet_flowadv(fce->fce_flowid);
break;
case FLOWSRC_PF:
default:
break;
}
flowadv_free_entry(fce);
lck_mtx_lock_spin(&fadv_lock);
/* if there's no pending request, we're done */
if (STAILQ_EMPTY(&fadv_list))
break;
}
fadv_active = 0;
}
}
static void hfs_chash_lock_spin(struct hfsmount *hfsmp)
{
lck_mtx_lock_spin(&hfsmp->hfs_chash_mutex);
}
