c9a38f42f7
Decouple the semcount and the work queue length.
Previous Problem:
If a work is queued and cancelled in high priority threads (or queued
by timer and cancelled by another high priority thread) before
work_thread runs, the queue operation will mark work_thread as ready to
run, but the cancel operation minus the semcount back to -1 and makes
wqueue->q empty. Then the work_thread still runs, found empty queue,
and wait sem again, then semcount becomes -2 (being minused by 1)
This can be done multiple times, then semcount can become very small
value. Test case to produce incorrect semcount:
high_priority_task()
{
for (int i = 0; i < 10000; i++)
{
work_queue(LPWORK, &work, worker, NULL, 0);
work_cancel(LPWORK, &work);
usleep(1);
}
/* Now the g_lpwork.sem.semcount is a value near -10000 */
}
With incorrect semcount, any queue operation when the work_thread is
busy, will only increase semcount and push work into queue, but cannot
trigger work_thread (semcount is negative but work_thread is not
waiting), then there will be more and more works left in queue while
the work_thread is waiting sem and cannot call them.
Signed-off-by: Zhe Weng <wengzhe@xiaomi.com>
152 lines
4.5 KiB
C
152 lines
4.5 KiB
C
/****************************************************************************
|
|
* sched/wqueue/kwork_cancel.c
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership. The
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance with the
|
|
* License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
|
|
#include <nuttx/irq.h>
|
|
#include <nuttx/arch.h>
|
|
#include <nuttx/queue.h>
|
|
#include <nuttx/wqueue.h>
|
|
|
|
#include "wqueue/wqueue.h"
|
|
|
|
#ifdef CONFIG_SCHED_WORKQUEUE
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: work_qcancel
|
|
*
|
|
* Description:
|
|
* Cancel previously queued work. This removes work from the work queue.
|
|
* After work has been cancelled, it may be requeued by calling
|
|
* work_queue() again.
|
|
*
|
|
* Input Parameters:
|
|
* qid - The work queue ID
|
|
* work - The previously queued work structure to cancel
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success, a negated errno on failure. This error may be
|
|
* reported:
|
|
*
|
|
* -ENOENT - There is no such work queued.
|
|
* -EINVAL - An invalid work queue was specified
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int work_qcancel(FAR struct kwork_wqueue_s *wqueue,
|
|
FAR struct work_s *work)
|
|
{
|
|
irqstate_t flags;
|
|
int ret = -ENOENT;
|
|
|
|
DEBUGASSERT(work != NULL);
|
|
|
|
/* Cancelling the work is simply a matter of removing the work structure
|
|
* from the work queue. This must be done with interrupts disabled because
|
|
* new work is typically added to the work queue from interrupt handlers.
|
|
*/
|
|
|
|
flags = enter_critical_section();
|
|
if (work->worker != NULL)
|
|
{
|
|
/* Remove the entry from the work queue and make sure that it is
|
|
* marked as available (i.e., the worker field is nullified).
|
|
*/
|
|
|
|
if (WDOG_ISACTIVE(&work->u.timer))
|
|
{
|
|
wd_cancel(&work->u.timer);
|
|
}
|
|
else
|
|
{
|
|
dq_rem((FAR dq_entry_t *)work, &wqueue->q);
|
|
}
|
|
|
|
work->worker = NULL;
|
|
ret = OK;
|
|
}
|
|
|
|
leave_critical_section(flags);
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: work_cancel
|
|
*
|
|
* Description:
|
|
* Cancel previously queued user-mode work. This removes work from the
|
|
* user mode work queue. After work has been cancelled, it may be
|
|
* requeued by calling work_queue() again.
|
|
*
|
|
* Input Parameters:
|
|
* qid - The work queue ID (must be HPWORK or LPWORK)
|
|
* work - The previously queued work structure to cancel
|
|
*
|
|
* Returned Value:
|
|
* Zero (OK) on success, a negated errno on failure. This error may be
|
|
* reported:
|
|
*
|
|
* -ENOENT - There is no such work queued.
|
|
* -EINVAL - An invalid work queue was specified
|
|
*
|
|
****************************************************************************/
|
|
|
|
int work_cancel(int qid, FAR struct work_s *work)
|
|
{
|
|
#ifdef CONFIG_SCHED_HPWORK
|
|
if (qid == HPWORK)
|
|
{
|
|
/* Cancel high priority work */
|
|
|
|
return work_qcancel((FAR struct kwork_wqueue_s *)&g_hpwork, work);
|
|
}
|
|
else
|
|
#endif
|
|
#ifdef CONFIG_SCHED_LPWORK
|
|
if (qid == LPWORK)
|
|
{
|
|
/* Cancel low priority work */
|
|
|
|
return work_qcancel((FAR struct kwork_wqueue_s *)&g_lpwork, work);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
#endif /* CONFIG_SCHED_WORKQUEUE */
|