diff --git a/sched/paging/pg_worker.c b/sched/paging/pg_worker.c index 72bc0de28d..a73a36b995 100644 --- a/sched/paging/pg_worker.c +++ b/sched/paging/pg_worker.c @@ -72,7 +72,8 @@ pid_t g_pgworker; /* The page fill worker thread maintains a static variable called g_pftcb. * If no fill is in progress, g_pftcb will be NULL. Otherwise, g_pftcb will - * point to the TCB of the task which is receiving the fill that is in progress. + * point to the TCB of the task which is receiving the fill that is in + * progress. * * NOTE: I think that this is the only state in which a TCB does not reside * in some list. Here is it in limbo, outside of the normally queuing while @@ -230,23 +231,24 @@ static void pg_callback(FAR struct tcb_s *tcb, int result) static inline bool pg_dequeue(void) { - /* Loop until either (1) the TCB of a task that requires a fill is found, OR - * (2) the g_watingforfill list becomes empty. + /* Loop until either (1) the TCB of a task that requires a fill is found, + * OR (2) the g_watingforfill list becomes empty. */ do { /* Remove the TCB from the head of the list (if any) */ - g_pftcb = (FAR struct tcb_s *)dq_remfirst((dq_queue_t *)&g_waitingforfill); + g_pftcb = (FAR struct tcb_s *) + dq_remfirst((FAR dq_queue_t *)&g_waitingforfill); pginfo("g_pftcb: %p\n", g_pftcb); if (g_pftcb != NULL) { - /* Call the architecture-specific function up_checkmapping() to see if - * the page fill still needs to be performed. In certain conditions, - * the page fault may occur on several threads for the same page and - * be queues multiple times. In this corner case, the blocked task will - * simply be restarted. + /* Call the architecture-specific function up_checkmapping() to see + * if the page fill still needs to be performed. In certain + * conditions, the page fault may occur on several threads for the + * same page and be queues multiple times. In this corner case, the + * blocked task will simply be restarted. */ if (!up_checkmapping(g_pftcb)) @@ -352,10 +354,10 @@ static inline bool pg_startfill(void) if (pg_dequeue()) { - /* Call up_allocpage(tcb, &vpage). This architecture-specific function will - * set aside page in memory and map to virtual address (vpage). If all - * available pages are in-use (the typical case), this function will select - * a page in-use, un-map it, and make it available. + /* Call up_allocpage(tcb, &vpage). This architecture-specific function + * will set aside page in memory and map to virtual address (vpage). If + * all available pages are in-use (the typical case), this function + * will select a page in-use, un-map it, and make it available. */ pginfo("Call up_allocpage(%p)\n", g_pftcb); @@ -363,29 +365,30 @@ static inline bool pg_startfill(void) DEBUGASSERT(result == OK); /* Start the fill. The exact way that the fill is started depends upon - * the nature of the architecture-specific up_fillpage() function -- Is it - * a blocking or a non-blocking call? + * the nature of the architecture-specific up_fillpage() function -- Is + * it a blocking or a non-blocking call? */ #ifdef CONFIG_PAGING_BLOCKINGFILL - /* If CONFIG_PAGING_BLOCKINGFILL is defined, then up_fillpage is blocking - * call. In this case, up_fillpage() will accept only (1) a reference to - * the TCB that requires the fill. Architecture-specific context information - * within the TCB will be sufficient to perform the fill. And (2) the - * (virtual) address of the allocated page to be filled. The resulting - * status of the fill will be provided by return value from up_fillpage(). + /* If CONFIG_PAGING_BLOCKINGFILL is defined, then up_fillpage is + * blocking call. In this case, up_fillpage() will accept only (1) a + * reference to the TCB that requires the fill. Architecture-specific + * context information within the TCB will be sufficient to perform the + * fill. And (2) the (virtual) address of the allocated page to be + * filled. The resulting status of the fill will be provided by return + * value from up_fillpage(). */ pginfo("Call up_fillpage(%p)\n", g_pftcb); result = up_fillpage(g_pftcb, vpage); DEBUGASSERT(result == OK); #else - /* If CONFIG_PAGING_BLOCKINGFILL is defined, then up_fillpage is non-blocking - * call. In this case up_fillpage() will accept an additional argument: The - * page fill worker thread will provide a callback function, pg_callback. - * - * Calling up_fillpage will start an asynchronous page fill. pg_callback - * ill be called when the page fill is finished (or an error occurs). This + /* If CONFIG_PAGING_BLOCKINGFILL is defined, then up_fillpage is non- + * blocking call. In this case up_fillpage() will accept an additional + * argument: The page fill worker thread will provide a callback + * function, pg_callback. + * up_fillpage will start an asynchronous page fill. pg_callback + * will be called when the page fill is finished (or an error occurs). * This callback will probably from interrupt level. */ @@ -393,23 +396,24 @@ static inline bool pg_startfill(void) result = up_fillpage(g_pftcb, vpage, pg_callback); DEBUGASSERT(result == OK); - /* Save the time that the fill was started. These will be used to check for - * timeouts. + /* Save the time that the fill was started. These will be used to + * check for timeouts. */ #ifdef CONFIG_PAGING_TIMEOUT_TICKS g_starttime = clock_systimer(); #endif - /* Return and wait to be signaled for the next event -- the fill completion - * event. While the fill is in progress, other tasks may execute. If - * another page fault occurs during this time, the faulting task will be - * blocked, its TCB will be added (in priority order) to g_waitingforfill - * and the priority of the page worker task may be boosted. But no action - * will be taken until the current page fill completes. NOTE: The IDLE task - * must also be fully locked in memory. The IDLE task cannot be blocked. It - * the case where all tasks are blocked waiting for a page fill, the IDLE - * task must still be available to run. + /* Return and wait to be signaled for the next event -- the fill + * completion event. While the fill is in progress, other tasks may + * execute. If another page fault occurs during this time, the faulting + * task will be blocked, its TCB will be added (in priority order) to + * g_waitingforfill and the priority of the page worker task may be + * boosted. But no action will be taken until the current page fill + * completes. NOTE: The IDLE task must also be fully locked in memory. + * The IDLE task cannot be blocked. It the case where all tasks are + * blocked waiting for a page fill, the IDLE task must still be + * available to run. */ #endif /* CONFIG_PAGING_BLOCKINGFILL */ @@ -418,6 +422,7 @@ static inline bool pg_startfill(void) } pginfo("Queue empty\n"); + UNUSED(result); return false; } @@ -518,8 +523,8 @@ static inline void pg_fillcomplete(void) int pg_worker(int argc, char *argv[]) { - /* Loop forever -- Notice that interrupts will be disabled at all times that - * this thread runs. That is so that we can't lose signals or have + /* Loop forever -- Notice that interrupts will be disabled at all times + * that this thread runs. That is so that we can't lose signals or have * asynchronous page faults. * * All interrupt logic as well as all page fill worker thread logic must @@ -532,10 +537,10 @@ int pg_worker(int argc, char *argv[]) up_irq_save(); for (; ; ) { - /* Wait awhile. We will wait here until either the configurable timeout - * elapses or until we are awakened by a signal (which terminates the - * nxsig_usleep with an EINTR error). Note that interrupts will be re- - * enabled while this task sleeps. + /* Wait awhile. We will wait here until either the configurable + * timeout elapses or until we are awakened by a signal (which + * terminates the nxsig_usleep with an EINTR error). Note that + * interrupts will be re- enabled while this task sleeps. * * The timeout is a failsafe that will handle any cases where a single * is lost (that would really be a bug and shouldn't happen!) and also @@ -544,7 +549,7 @@ int pg_worker(int argc, char *argv[]) nxsig_usleep(CONFIG_PAGING_WORKPERIOD); - /* The page fill worker thread will be awakened on one of three conditions: + /* The page fill worker thread will be awakened on one of 3 conditions: * * - When signaled by pg_miss(), the page fill worker thread will be * awakened, @@ -556,15 +561,16 @@ int pg_worker(int argc, char *argv[]) */ #ifndef CONFIG_PAGING_BLOCKINGFILL - /* For the non-blocking up_fillpage(), the page fill worker thread will detect - * that the page fill is complete when it is awakened with g_pftcb non-NULL - * and fill completion status from pg_callback. + /* For the non-blocking up_fillpage(), the page fill worker thread will + * detect that the page fill is complete when it is awakened with + * g_pftcb non-NULL and fill completion status from pg_callback. */ if (g_pftcb != NULL) { - /* If it is a real page fill completion event, then the result of the page - * fill will be in g_fillresult and will not be equal to -EBUSY. + /* If it is a real page fill completion event, then the result of + * the page fill will be in g_fillresult and will not be equal to + * -EBUSY. */ if (g_fillresult != -EBUSY) @@ -573,8 +579,8 @@ int pg_worker(int argc, char *argv[]) DEBUGASSERT(g_fillresult == OK); - /* Handle the successful page fill complete event by restarting the - * task that was blocked waiting for this page fill. + /* Handle the successful page fill complete event by restarting + * the task that was blocked waiting for this page fill. */ pginfo("Restarting TCB: %p\n", g_pftcb); @@ -598,8 +604,8 @@ int pg_worker(int argc, char *argv[]) } } - /* If a configurable timeout period expires with no page fill completion - * event, then declare a failure. + /* If a configurable timeout period expires with no page fill + * completion event, then declare a failure. */ #ifdef CONFIG_PAGING_TIMEOUT_TICKS