david/ipxe
david
/
ipxe
Archived
1
0
Fork 0
Code

Warnings purge of src/core

This commit is contained in:
Marty Connor 2007-07-02 15:26:40 -04:00
parent 8febe42f78
commit bf871c4d03
9 changed files with 26 additions and 487 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

474
src/core/async.c
View File

@ -1,474 +0,0 @@
/*
* Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
*
* 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 <string.h>
#include <errno.h>
#include <assert.h>
#include <gpxe/process.h>
#include <gpxe/async.h>
/** @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<UNKNOWN>";
}
}
/**
* 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,
},
};

4
src/core/btext.c
View File

@ -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

1
src/core/debug.c
View File

@ -1,3 +1,4 @@
#include <stdio.h>
#include <stdint.h>
#include <stdarg.h>
#include <io.h>

7
src/core/dev.c
View File

@ -1,6 +1,7 @@
#include "etherboot.h"
#include "stddef.h"
#include "dev.h"
#include <stdio.h>
#include <etherboot.h>
#include <stddef.h>
#include <dev.h>
/*
* Each bus driver defines several methods, which are described in

4
src/core/disk.c
View File

@ -1,5 +1,5 @@
#include "etherboot.h"
#include "disk.h"
#include <etherboot.h>
#include <disk.h>
#warning "disk.c is currently broken"
#if 0

5
src/core/misc.c
View File

@ -2,9 +2,10 @@
MISC Support Routines
**************************************************************************/
#include "etherboot.h"
#include "console.h"
#include <etherboot.h>
#include <console.h>
#include <stdlib.h>
#include <stdio.h>
/**************************************************************************
IPCHKSUM - Checksum IP Header

15
src/core/pcmcia.c
View File

@ -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 <stdio.h>
#include <pcmcia.h>
#include <i82365.h>
#define CODE_STATUS "alpha"
#define CODE_VERSION "0.1.3"
#include "pcmcia-opts.h"
#include "console.h"
#include <pcmcia-opts.h>
#include <console.h>
#include <gpxe/init.h>
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

1
src/core/random.c
View File

@ -5,6 +5,7 @@
*/
#include <stdlib.h>
#include <etherboot.h>
static int32_t rnd_seed = 0;

2
src/core/serial.c
View File

@ -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);