From bf871c4d03f1dd00a196e15df5267e8be0c8878c Mon Sep 17 00:00:00 2001 From: Marty Connor Date: Mon, 2 Jul 2007 15:26:40 -0400 Subject: [PATCH] Warnings purge of src/core --- src/core/async.c | 474 ---------------------------------------------- src/core/btext.c | 4 + src/core/debug.c | 1 + src/core/dev.c | 7 +- src/core/disk.c | 4 +- src/core/misc.c | 5 +- src/core/pcmcia.c | 15 +- src/core/random.c | 1 + src/core/serial.c | 2 +- 9 files changed, 26 insertions(+), 487 deletions(-) delete mode 100644 src/core/async.c diff --git a/src/core/async.c b/src/core/async.c deleted file mode 100644 index d1ae0770..00000000 --- a/src/core/async.c +++ /dev/null @@ -1,474 +0,0 @@ -/* - * Copyright (C) 2006 Michael Brown . - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License as - * published by the Free Software Foundation; either version 2 of the - * License, or any later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include -#include -#include -#include -#include - -/** @file - * - * Asynchronous operations - * - */ - -/** - * Name signal - * - * @v signal Signal number - * @ret name Name of signal - */ -static inline __attribute__ (( always_inline )) const char * -signal_name ( enum signal signal ) { - switch ( signal ) { - case SIGCHLD: return "SIGCHLD"; - case SIGKILL: return "SIGKILL"; - case SIGUPDATE: return "SIGUPDATE"; - default: return "SIG"; - } -} - -/** - * Initialise an asynchronous operation - * - * @v async Asynchronous operation - * @v aop Asynchronous operation operations to use - * @v parent Parent asynchronous operation, or NULL - * @ret aid Asynchronous operation ID - * - * It is valid to create an asynchronous operation with no parent - * operation; see async_init_orphan(). - */ -aid_t async_init ( struct async *async, struct async_operations *aop, - struct async *parent ) { - static aid_t aid = 1; - - /* Assign identifier. Negative IDs are used to indicate - * errors, so avoid assigning them. - */ - ++aid; - aid &= ( ( ~( ( aid_t ) 0 ) ) >> 1 ); - - DBGC ( async, "ASYNC %p (type %p) initialising as", async, aop ); - if ( parent ) { - DBGC ( async, " child of ASYNC %p", parent ); - } else { - DBGC ( async, " orphan" ); - } - DBGC ( async, " with ID %ld\n", aid ); - - assert ( async != NULL ); - assert ( aop != NULL ); - - /* Add to hierarchy */ - if ( parent ) { - async->parent = parent; - list_add ( &async->siblings, &parent->children ); - } - INIT_LIST_HEAD ( &async->children ); - - /* Initialise fields */ - async->rc = -EINPROGRESS; - async->completed = 0; - async->total = 0; - async->aop = aop; - async->aid = aid; - - return async->aid; -} - -/** - * Uninitialise an asynchronous operation - * - * @v async Asynchronous operation - * - * Abandon an asynchronous operation without signalling the parent. - * You may do this only during the period between calling async_init() - * and returning to the parent for the first time. It is designed to - * simplify the error paths of asynchronous operations that themselves - * spawn further asynchronous operations. - * - * An example may help: - * - * int start_something ( ..., struct async *parent ) { - * struct my_data_structure *myself; - * - * ... allocate memory for myself ... - * - * async_init ( &myself->async, &my_async_operations, parent ); - * if ( ( rc = start_child_operation ( ..., &myself->async ) ) != 0 ) { - * async_uninit ( &myself->async ); - * return rc; - * } - * - * return 0; - * } - * - * It is valid to call async_uninit() on an asynchronous operation - * that has not yet been initialised (i.e. a zeroed-out @c struct @c - * async). - */ -void async_uninit ( struct async *async ) { - - assert ( async != NULL ); - - if ( async->parent ) { - assert ( list_empty ( &async->children ) ); - - DBGC ( async, "ASYNC %p uninitialising\n", async ); - list_del ( &async->siblings ); - } -} - -/** - * SIGCHLD 'ignore' handler - * - * @v async Asynchronous operation - * @v signal Signal received - */ -static void async_ignore_sigchld ( struct async *async, enum signal signal ) { - aid_t waited_aid; - - assert ( async != NULL ); - assert ( signal == SIGCHLD ); - - /* Reap the child */ - waited_aid = async_wait ( async, NULL, 0 ); - assert ( waited_aid >= 0 ); -} - -/** - * SIGUPDATE 'ignore' handler - * - * @v async Asynchronous operation - * @v signal Signal received - */ -static void async_ignore_sigupdate ( struct async *async, - enum signal signal ) { - struct async *child; - - assert ( async != NULL ); - assert ( signal == SIGUPDATE ); - - async_signal_children ( async, signal ); - async->completed = 0; - async->total = 0; - list_for_each_entry ( child, &async->children, siblings ) { - async->completed += child->completed; - async->total += child->total; - } -} - -/** - * 'Ignore' signal handler - * - * @v async Asynchronous operation - * @v signal Signal received - */ -void async_ignore_signal ( struct async *async, enum signal signal ) { - - DBGC ( async, "ASYNC %p using ignore handler for %s\n", - async, signal_name ( signal ) ); - - assert ( async != NULL ); - - switch ( signal ) { - case SIGCHLD: - async_ignore_sigchld ( async, signal ); - break; - case SIGUPDATE: - async_ignore_sigupdate ( async, signal ); - break; - case SIGKILL: - default: - /* Nothing to do */ - break; - } -} - -/** - * Default signal handler - * - * @v async Asynchronous operation - * @v signal Signal received - */ -static void async_default_signal ( struct async *async, enum signal signal ) { - - DBGC ( async, "ASYNC %p using default handler for %s\n", - async, signal_name ( signal ) ); - - assert ( async != NULL ); - - switch ( signal ) { - case SIGCHLD: - case SIGKILL: - case SIGUPDATE: - default: - /* Nothing to do */ - break; - } -} - -/** - * Send signal to asynchronous operation - * - * @v async Asynchronous operation - * @v signal Signal to send - */ -void async_signal ( struct async *async, enum signal signal ) { - signal_handler_t handler; - - DBGC ( async, "ASYNC %p receiving %s\n", - async, signal_name ( signal ) ); - - assert ( async != NULL ); - assert ( async->aop != NULL ); - assert ( signal < SIGMAX ); - - handler = async->aop->signal[signal]; - if ( handler ) { - /* Use the asynchronous operation's signal handler */ - handler ( async, signal ); - } else { - /* Use the default handler */ - async_default_signal ( async, signal ); - } -} - -/** - * Send signal to all child asynchronous operations - * - * @v async Asynchronous operation - * @v signal Signal to send - */ -void async_signal_children ( struct async *async, enum signal signal ) { - struct async *child; - struct async *tmp; - - assert ( async != NULL ); - - list_for_each_entry_safe ( child, tmp, &async->children, siblings ) { - async_signal ( child, signal ); - } -} - -/** - * Reap default handler - * - * @v async Asynchronous operation - */ -static void async_reap_default ( struct async *async ) { - - DBGC ( async, "ASYNC %p ignoring REAP\n", async ); - - assert ( async != NULL ); - - /* Nothing to do */ -} - -/** - * Reap asynchronous operation - * - * @v async Asynchronous operation - * - * Note that the asynchronous operation should have been freed by - * calling this function; you may not dereference @c async after this - * call. - */ -static void async_reap ( struct async *async ) { - - DBGC ( async, "ASYNC %p being reaped, exit status %d (%s)\n", - async, async->rc, strerror ( async->rc ) ); - - assert ( async != NULL ); - assert ( async->aop != NULL ); - assert ( list_empty ( &async->children ) ); - - /* Unlink from hierarchy */ - if ( async->parent ) - list_del ( &async->siblings ); - async->parent = NULL; - - /* Release all resources */ - if ( async->aop->reap ) { - async->aop->reap ( async ); - } else { - async_reap_default ( async ); - } -} - -/** - * Mark asynchronous operation as complete - * - * @v async Asynchronous operation - * @v rc Return status code - * - * An asynchronous operation should call this once it has completed. - * After calling async_done(), it must be prepared to be reaped by - * having its reap() method called. - */ -void async_done ( struct async *async, int rc ) { - struct async *child; - struct async *tmp; - - DBGC ( async, "ASYNC %p completing with status %d (%s)\n", - async, rc, strerror ( rc ) ); - - assert ( async != NULL ); - assert ( async->parent != NULL ); - assert ( rc != -EINPROGRESS ); - - /* Store return status code */ - async->rc = rc; - - /* Disown all of our children */ - list_for_each_entry_safe ( child, tmp, &async->children, siblings ) { - DBGC ( async, "ASYNC %p disowning child ASYNC %p\n", - async, child ); - list_del ( &child->siblings ); - child->parent = NULL; - } - - /* Send SIGCHLD to parent. If we don't have a parent then we - * have to take care of our own funeral arrangements. - */ - if ( async->parent ) { - async_signal ( async->parent, SIGCHLD ); - } else { - async_reap ( async ); - } -} - -/** - * Wait for any child asynchronous operation to complete - * - * @v child Child asynchronous operation - * @v rc Child exit status to fill in, or NULL - * @v block Block waiting for child operation to complete - * @ret aid Asynchronous operation ID, or -1 on error - */ -aid_t async_wait ( struct async *async, int *rc, int block ) { - struct async *child; - aid_t child_aid; - int dummy_rc; - - DBGC ( async, "ASYNC %p performing %sblocking wait%s\n", async, - ( block ? "" : "non-" ), ( rc ? "" : " (ignoring status)" ) ); - - assert ( async != NULL ); - - /* Avoid multiple tests for "if ( rc )" */ - if ( ! rc ) - rc = &dummy_rc; - - while ( 1 ) { - - /* Return immediately if we have no children */ - if ( list_empty ( &async->children ) ) { - DBGC ( async, "ASYNC %p has no more children\n", - async ); - *rc = -ECHILD; - return -1; - } - - /* Look for a completed child */ - list_for_each_entry ( child, &async->children, siblings ) { - if ( child->rc == -EINPROGRESS ) - continue; - - /* Found a completed child */ - *rc = child->rc; - child_aid = child->aid; - - DBGC ( async, "ASYNC %p reaping child ASYNC %p " - "(ID %ld)\n", async, child, child_aid ); - - /* Reap the child and return */ - async_reap ( child ); - return child_aid; - } - - /* Return immediately if non-blocking */ - if ( ! block ) { - *rc = -EINPROGRESS; - return -1; - } - - /* Allow processes to run */ - step(); - } -} - -/** - * Wait for any child asynchronous operation to complete, with progress bar - * - * @v child Child asynchronous operation - * @v rc Child exit status to fill in, or NULL - * @ret aid Asynchronous operation ID, or -1 on error - */ -aid_t async_wait_progress ( struct async *async, int *rc ) { - struct async *child; - long last_progress = -1; - long progress; - aid_t child_aid; - - do { - step(); - async_signal ( async, SIGUPDATE ); - if ( async->total ) { - progress = ( async->completed / (async->total / 100) ); - if ( progress != last_progress ) - printf ( "\rProgress: %d%%", progress ); - last_progress = progress; - } - child_aid = async_wait ( async, rc, 0 ); - } while ( *rc == -EINPROGRESS ); - - printf ( "\n" ); - return child_aid; -} - -/** - * Default asynchronous operations - * - * The default is to ignore SIGCHLD (i.e. to automatically reap - * children) and to use the default handler (i.e. do nothing) for all - * other signals. - */ -struct async_operations default_async_operations = { - .signal = { - [SIGCHLD] = SIG_IGN, - [SIGUPDATE] = SIG_IGN, - }, -}; - -/** - * Default asynchronous operations for orphan asynchronous operations - * - * The default for orphan asynchronous operations is to do nothing for - * SIGCHLD (i.e. to not automatically reap children), on the - * assumption that you're probably creating the orphan solely in order - * to async_wait() on it. - */ -struct async_operations orphan_async_operations = { - .signal = { - [SIGCHLD] = SIG_DFL, - [SIGUPDATE] = SIG_IGN, - }, -}; diff --git a/src/core/btext.c b/src/core/btext.c index 409c429e..6e1a29e1 100644 --- a/src/core/btext.c +++ b/src/core/btext.c @@ -1,3 +1,5 @@ +#if 0 + /* * Procedures for drawing on the screen early on in the boot process. * @@ -5037,3 +5039,5 @@ static const unsigned char vga_font[cmapsz] BTDATA = { 0x00, /* 00000000 */ #endif }; + +#endif diff --git a/src/core/debug.c b/src/core/debug.c index 4754bfde..d72b3df3 100644 --- a/src/core/debug.c +++ b/src/core/debug.c @@ -1,3 +1,4 @@ +#include #include #include #include diff --git a/src/core/dev.c b/src/core/dev.c index 541a9eb1..582edf87 100644 --- a/src/core/dev.c +++ b/src/core/dev.c @@ -1,6 +1,7 @@ -#include "etherboot.h" -#include "stddef.h" -#include "dev.h" +#include +#include +#include +#include /* * Each bus driver defines several methods, which are described in diff --git a/src/core/disk.c b/src/core/disk.c index 2ccd5ff2..415fdece 100644 --- a/src/core/disk.c +++ b/src/core/disk.c @@ -1,5 +1,5 @@ -#include "etherboot.h" -#include "disk.h" +#include +#include #warning "disk.c is currently broken" #if 0 diff --git a/src/core/misc.c b/src/core/misc.c index e214a628..58399136 100644 --- a/src/core/misc.c +++ b/src/core/misc.c @@ -2,9 +2,10 @@ MISC Support Routines **************************************************************************/ -#include "etherboot.h" -#include "console.h" +#include +#include #include +#include /************************************************************************** IPCHKSUM - Checksum IP Header diff --git a/src/core/pcmcia.c b/src/core/pcmcia.c index c15fe9cc..53d45416 100644 --- a/src/core/pcmcia.c +++ b/src/core/pcmcia.c @@ -1,3 +1,5 @@ +#if 0 + /* * pcmcia.c * @@ -23,12 +25,13 @@ * at some point. If there's anything obvious or better, not-so-obvious, * please contact me by e-mail: anselm (AT) hoffmeister (DOT) be *THANKS* */ -#include "pcmcia.h" -#include "i82365.h" +#include +#include +#include #define CODE_STATUS "alpha" #define CODE_VERSION "0.1.3" -#include "pcmcia-opts.h" -#include "console.h" +#include +#include #include int sockets; /* AHTODO: Phase this out! */ @@ -118,7 +121,7 @@ static void pcmcia_init_all(void) { printf ( "]\nHighest config available is %d\n", uc[2*(ui+3)] ); m = uc[2*(ui+2)]; pccsock[i].configoffset = 0; - for ( j = 0; j <= m & 3; ++j ) { + for ( j = 0; j <= (m & 3); ++j ) { pccsock[i].configoffset += uc[2*(ui+4+j)] << (8*j); } pccsock[i].rmask0 = 0; @@ -262,3 +265,5 @@ static void pcmcia_shutdown_all(void) { } INIT_FN ( INIT_PCMCIA, pcmcia_init_all, NULL, pcmcia_shutdown_all ); + +#endif diff --git a/src/core/random.c b/src/core/random.c index c15bb6de..0d914c90 100644 --- a/src/core/random.c +++ b/src/core/random.c @@ -5,6 +5,7 @@ */ #include +#include static int32_t rnd_seed = 0; diff --git a/src/core/serial.c b/src/core/serial.c index d0827481..63040377 100644 --- a/src/core/serial.c +++ b/src/core/serial.c @@ -213,7 +213,7 @@ static void serial_init ( void ) { /* rx buffer reg * throw away (unconditionally the first time) */ - uart_readb(UART_BASE + UART_RBR); + (void) uart_readb(UART_BASE + UART_RBR); /* line status reg */ status = uart_readb(UART_BASE + UART_LSR); } while(status & UART_LSR_DR);