samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Bifurcation 0
Code Tickets Demandes d'ajout Actions Paquets Projets Publications Wiki Activité

qcacmn: Reduce/remove scheduler logs

Parcourir la source 
As part of the effort to reduce overly verbose and excessive logging
driver wide, reduce or remove logs in scheduler as much as possible.

Change-Id: I1e45c439315e81d9ff05e1688fe690d0ca30e097
CRs-Fixed: 2280337
Cette révision appartient à :
Dustin Brown
2018-07-16 16:00:58 -07:00
révisé par nshrivas
Parent 2a331374b8
révision 8afde5a83f
2 fichiers modifiés avec 83 ajouts et 118 suppressions
Télécharger le Fichier Patch Télécharger le Fichier des Différences Développer tous les fichiers Réduire tous les fichiers

172
scheduler/src/scheduler_api.c
Voir le fichier

@@ -24,14 +24,12 @@ QDF_STATUS scheduler_disable(void)
{
struct scheduler_ctx *sched_ctx;
sched_info("Disabling Scheduler");
sched_debug("Disabling Scheduler");
sched_ctx = scheduler_get_context();
QDF_BUG(sched_ctx);
if (!sched_ctx) {
sched_err("sched_ctx is NULL");
if (!sched_ctx)
return QDF_STATUS_E_INVAL;
}
/* send shutdown signal to scheduler thread */
qdf_atomic_set_bit(MC_SHUTDOWN_EVENT_MASK, &sched_ctx->sch_event_flag);
@@ -73,8 +71,7 @@ static void scheduler_watchdog_timeout(void *arg)
if (qdf_atomic_test_bit(MC_SHUTDOWN_EVENT_MASK, &sched->sch_event_flag))
return;
sched_fatal("Going down for Scheduler Watchdog Bite!");
QDF_BUG(0);
QDF_DEBUG_PANIC("Going down for Scheduler Watchdog Bite!");
}
#else
static void scheduler_watchdog_timeout(void *arg)
@@ -87,14 +84,12 @@ QDF_STATUS scheduler_enable(void)
{
struct scheduler_ctx *sched_ctx;
sched_info("Enabling Scheduler");
sched_debug("Enabling Scheduler");
sched_ctx = scheduler_get_context();
QDF_BUG(sched_ctx);
if (!sched_ctx) {
sched_err("sched_ctx is null");
if (!sched_ctx)
return QDF_STATUS_E_INVAL;
}
qdf_atomic_clear_bit(MC_SHUTDOWN_EVENT_MASK,
&sched_ctx->sch_event_flag);
@@ -109,13 +104,13 @@ QDF_STATUS scheduler_enable(void)
return QDF_STATUS_E_RESOURCES;
}
sched_info("Scheduler thread created");
sched_debug("Scheduler thread created");
/* wait for the scheduler thread to startup */
qdf_wake_up_process(sched_ctx->sch_thread);
qdf_wait_single_event(&sched_ctx->sch_start_event, 0);
sched_info("Scheduler thread started");
sched_debug("Scheduler thread started");
return QDF_STATUS_SUCCESS;
}
@@ -125,7 +120,7 @@ QDF_STATUS scheduler_init(void)
QDF_STATUS status;
struct scheduler_ctx *sched_ctx;
sched_info("Initializing Scheduler");
sched_debug("Initializing Scheduler");
status = scheduler_create_ctx();
if (QDF_IS_STATUS_ERROR(status)) {
@@ -136,7 +131,6 @@ QDF_STATUS scheduler_init(void)
sched_ctx = scheduler_get_context();
QDF_BUG(sched_ctx);
if (!sched_ctx) {
sched_err("sched_ctx is null");
status = QDF_STATUS_E_FAILURE;
goto ctx_destroy;
}
@@ -198,14 +192,12 @@ QDF_STATUS scheduler_deinit(void)
QDF_STATUS status;
struct scheduler_ctx *sched_ctx;
sched_info("Deinitializing Scheduler");
sched_debug("Deinitializing Scheduler");
sched_ctx = scheduler_get_context();
QDF_BUG(sched_ctx);
if (!sched_ctx) {
sched_err("sched_ctx is null");
if (!sched_ctx)
return QDF_STATUS_E_INVAL;
}
qdf_timer_free(&sched_ctx->watchdog_timer);
qdf_spinlock_destroy(&sched_ctx->sch_thread_lock);
@@ -233,16 +225,14 @@ QDF_STATUS scheduler_post_msg_by_priority(QDF_MODULE_ID qid,
struct scheduler_msg *queue_msg;
struct scheduler_ctx *sched_ctx;
if (!msg) {
sched_err("msg is null");
QDF_BUG(msg);
if (!msg)
return QDF_STATUS_E_INVAL;
}
sched_ctx = scheduler_get_context();
if (!sched_ctx) {
sched_err("sched_ctx is null");
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_INVAL;
}
if (!sched_ctx->sch_thread) {
sched_err("Cannot post message; scheduler thread is stopped");
@@ -278,8 +268,7 @@ QDF_STATUS scheduler_post_msg_by_priority(QDF_MODULE_ID qid,
}
if (!sched_ctx->queue_ctx.scheduler_msg_process_fn[qidx]) {
sched_err("callback not registered for qid[%d]", qid);
QDF_ASSERT(0);
QDF_DEBUG_PANIC("callback not registered for qid[%d]", qid);
return QDF_STATUS_E_FAILURE;
}
@@ -301,18 +290,16 @@ QDF_STATUS scheduler_post_msg_by_priority(QDF_MODULE_ID qid,
}
QDF_STATUS scheduler_register_module(QDF_MODULE_ID qid,
scheduler_msg_process_fn_t callback)
scheduler_msg_process_fn_t callback)
{
struct scheduler_mq_ctx *ctx;
struct scheduler_ctx *sched_ctx = scheduler_get_context();
sched_enter();
if (!sched_ctx) {
QDF_ASSERT(0);
sched_err("sched_ctx is NULL");
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
}
if (sched_ctx->sch_last_qidx >= SCHEDULER_NUMBER_OF_MSG_QUEUE) {
sched_err("Already registered max %d no of message queues",
@@ -339,11 +326,9 @@ QDF_STATUS scheduler_deregister_module(QDF_MODULE_ID qid)
sched_enter();
if (!sched_ctx) {
QDF_ASSERT(0);
sched_err("sched_ctx is NULL");
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
}
ctx = &sched_ctx->queue_ctx;
qidx = ctx->scheduler_msg_qid_to_qidx[qid];
@@ -400,10 +385,13 @@ QDF_STATUS scheduler_target_if_mq_handler(struct scheduler_msg *msg)
struct scheduler_ctx *sched_ctx = scheduler_get_context();
QDF_STATUS (*target_if_msg_handler)(struct scheduler_msg *);
if (NULL == msg || NULL == sched_ctx) {
sched_err("msg %pK sch %pK", msg, sched_ctx);
QDF_BUG(msg);
if (!msg)
return QDF_STATUS_E_FAILURE;
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
}
target_if_msg_handler = msg->callback;
@@ -417,7 +405,7 @@ QDF_STATUS scheduler_target_if_mq_handler(struct scheduler_msg *msg)
* 2) For new messages which have valid callbacks invoke their callbacks
* directly.
*/
if (NULL == target_if_msg_handler)
if (!target_if_msg_handler)
status = sched_ctx->legacy_wma_handler(msg);
else
status = target_if_msg_handler(msg);
@@ -429,18 +417,16 @@ QDF_STATUS scheduler_os_if_mq_handler(struct scheduler_msg *msg)
{
QDF_STATUS (*os_if_msg_handler)(struct scheduler_msg *);
if (NULL == msg) {
sched_err("Msg is NULL");
QDF_BUG(msg);
if (!msg)
return QDF_STATUS_E_FAILURE;
}
os_if_msg_handler = msg->callback;
if (NULL == os_if_msg_handler) {
sched_err("Msg callback is NULL");
QDF_ASSERT(0);
QDF_BUG(os_if_msg_handler);
if (!os_if_msg_handler)
return QDF_STATUS_E_FAILURE;
}
os_if_msg_handler(msg);
return QDF_STATUS_SUCCESS;
@@ -448,53 +434,45 @@ QDF_STATUS scheduler_os_if_mq_handler(struct scheduler_msg *msg)
QDF_STATUS scheduler_timer_q_mq_handler(struct scheduler_msg *msg)
{
QDF_STATUS status;
struct scheduler_ctx *sched_ctx = scheduler_get_context();
qdf_mc_timer_callback_t timer_q_msg_handler;
qdf_mc_timer_callback_t timer_callback;
if (NULL == msg || NULL == sched_ctx) {
sched_err("msg %pK sch %pK", msg, sched_ctx);
QDF_BUG(msg);
if (!msg)
return QDF_STATUS_E_FAILURE;
}
timer_q_msg_handler = msg->callback;
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
/* Timer message handler */
if (SYS_MSG_COOKIE == msg->reserved &&
SYS_MSG_ID_MC_TIMER == msg->type) {
if (timer_q_msg_handler) {
status = QDF_STATUS_SUCCESS;
timer_q_msg_handler(msg->bodyptr);
} else {
sched_err("Timer cb is null");
status = QDF_STATUS_E_FAILURE;
}
/* legacy sys message handler? */
if (msg->reserved != SYS_MSG_COOKIE || msg->type != SYS_MSG_ID_MC_TIMER)
return sched_ctx->legacy_sys_handler(msg);
return status;
} else {
/* Legacy sys message handler */
status = sched_ctx->legacy_sys_handler(msg);
timer_callback = msg->callback;
QDF_BUG(timer_callback);
if (!timer_callback)
return QDF_STATUS_E_FAILURE;
return status;
}
timer_callback(msg->bodyptr);
return QDF_STATUS_SUCCESS;
}
QDF_STATUS scheduler_scan_mq_handler(struct scheduler_msg *msg)
{
QDF_STATUS (*scan_q_msg_handler)(struct scheduler_msg *);
if (NULL == msg) {
sched_err("Msg is NULL");
QDF_BUG(msg);
if (!msg)
return QDF_STATUS_E_FAILURE;
}
scan_q_msg_handler = msg->callback;
if (NULL == scan_q_msg_handler) {
sched_err("Msg callback is NULL");
QDF_ASSERT(0);
QDF_BUG(scan_q_msg_handler);
if (!scan_q_msg_handler)
return QDF_STATUS_E_FAILURE;
}
scan_q_msg_handler(msg);
return QDF_STATUS_SUCCESS;
@@ -505,10 +483,9 @@ QDF_STATUS scheduler_register_wma_legacy_handler(scheduler_msg_process_fn_t
{
struct scheduler_ctx *sched_ctx = scheduler_get_context();
if (NULL == sched_ctx) {
sched_err("scheduler context is null");
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
}
sched_ctx->legacy_wma_handler = wma_callback;
@@ -520,10 +497,9 @@ QDF_STATUS scheduler_register_sys_legacy_handler(scheduler_msg_process_fn_t
{
struct scheduler_ctx *sched_ctx = scheduler_get_context();
if (NULL == sched_ctx) {
sched_err("scheduler context is null");
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
}
sched_ctx->legacy_sys_handler = sys_callback;
@@ -534,10 +510,9 @@ QDF_STATUS scheduler_deregister_wma_legacy_handler(void)
{
struct scheduler_ctx *sched_ctx = scheduler_get_context();
if (NULL == sched_ctx) {
sched_err("scheduler context is null");
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
}
sched_ctx->legacy_wma_handler = NULL;
@@ -548,10 +523,9 @@ QDF_STATUS scheduler_deregister_sys_legacy_handler(void)
{
struct scheduler_ctx *sched_ctx = scheduler_get_context();
if (NULL == sched_ctx) {
sched_err("scheduler context is null");
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
}
sched_ctx->legacy_sys_handler = NULL;
@@ -573,12 +547,9 @@ void scheduler_mc_timer_callback(unsigned long data)
void *user_data = NULL;
QDF_TIMER_TYPE type = QDF_TIMER_TYPE_SW;
QDF_ASSERT(timer);
if (timer == NULL) {
sched_err("Null pointer passed in!");
QDF_BUG(timer);
if (!timer)
return;
}
qdf_spin_lock_irqsave(&timer->platform_info.spinlock);
@@ -623,19 +594,16 @@ void scheduler_mc_timer_callback(unsigned long data)
qdf_spin_unlock_irqrestore(&timer->platform_info.spinlock);
if (QDF_STATUS_SUCCESS != status) {
sched_err("TIMER callback called in a wrong state=%d",
timer->state);
if (QDF_IS_STATUS_ERROR(status)) {
sched_debug("MC timer fired but is not running; skip callback");
return;
}
qdf_try_allowing_sleep(type);
if (callback == NULL) {
sched_err("No TIMER callback, Couldn't enqueue timer to any queue");
QDF_ASSERT(0);
QDF_BUG(callback);
if (!callback)
return;
}
/* serialize to scheduler controller thread */
msg.type = SYS_MSG_ID_MC_TIMER;
@@ -647,7 +615,7 @@ void scheduler_mc_timer_callback(unsigned long data)
/* bodyptr points to user data, do not free it during msg flush */
msg.flush_callback = scheduler_msg_flush_noop;
if (scheduler_post_msg(QDF_MODULE_ID_SYS, &msg) == QDF_STATUS_SUCCESS)
return;
sched_err("Could not enqueue timer to timer queue");
status = scheduler_post_msg(QDF_MODULE_ID_SYS, &msg);
if (QDF_IS_STATUS_ERROR(status))
sched_err("Could not enqueue timer to timer queue");
}

29
scheduler/src/scheduler_core.c
Voir le fichier

@@ -84,10 +84,9 @@ static QDF_STATUS scheduler_all_queues_init(struct scheduler_ctx *sched_ctx)
sched_enter();
if (!sched_ctx) {
QDF_DEBUG_PANIC("sched_ctx is null");
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
}
qdf_atomic_set(&__sched_queue_depth, 0);
@@ -114,10 +113,9 @@ static QDF_STATUS scheduler_all_queues_deinit(struct scheduler_ctx *sched_ctx)
sched_enter();
if (!sched_ctx) {
QDF_DEBUG_PANIC("sched_ctx is null");
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
}
/* De-Initialize all message queues */
for (i = 0; i < SCHEDULER_NUMBER_OF_MSG_QUEUE; i++)
@@ -175,10 +173,9 @@ QDF_STATUS scheduler_queues_init(struct scheduler_ctx *sched_ctx)
sched_enter();
if (!sched_ctx) {
QDF_DEBUG_PANIC("sched_ctx is null");
QDF_BUG(sched_ctx);
if (!sched_ctx)
return QDF_STATUS_E_FAILURE;
}
status = scheduler_all_queues_init(sched_ctx);
if (QDF_IS_STATUS_ERROR(status)) {
@@ -245,7 +242,7 @@ static void scheduler_thread_process_queues(struct scheduler_ctx *sch_ctx,
/* Check if MC needs to shutdown */
if (qdf_atomic_test_bit(MC_SHUTDOWN_EVENT_MASK,
&sch_ctx->sch_event_flag)) {
sched_info("scheduler thread signaled to shutdown");
sched_debug("scheduler thread signaled to shutdown");
*shutdown = true;
/* Check for any Suspend Indication */
@@ -338,7 +335,7 @@ int scheduler_thread(void *arg)
}
/* If we get here the scheduler thread must exit */
sched_info("Scheduler thread exiting");
sched_debug("Scheduler thread exiting");
qdf_event_set(&sch_ctx->sch_shutdown);
qdf_exit_thread(QDF_STATUS_SUCCESS);
@@ -352,13 +349,13 @@ static void scheduler_flush_single_queue(struct scheduler_mq_type *mq)
while ((msg = scheduler_mq_get(mq))) {
if (msg->flush_callback) {
sched_info("Calling flush callback; type: %x",
msg->type);
sched_debug("Calling flush callback; type: %x",
msg->type);
flush_cb = msg->flush_callback;
flush_cb(msg);
} else if (msg->bodyptr) {
sched_info("Freeing scheduler msg bodyptr; type: %x",
msg->type);
sched_debug("Freeing scheduler msg bodyptr; type: %x",
msg->type);
qdf_mem_free(msg->bodyptr);
}
@@ -371,7 +368,7 @@ void scheduler_queues_flush(struct scheduler_ctx *sched_ctx)
struct scheduler_mq_type *mq;
int i;
sched_info("Flushing scheduler message queues");
sched_debug("Flushing scheduler message queues");
for (i = 0; i < SCHEDULER_NUMBER_OF_MSG_QUEUE; i++) {
mq = &sched_ctx->queue_ctx.sch_msg_q[i];