initfini.c

/*
 *
 * This file is part of UEFI fdisk.
 *
 * UEFI fdisk is a port of util-linux fdisk to UEFI/BIOS.
 * UEFI fdisk est un portage de util-linux fdisk vers UEFI/BIOS.
 * Ce fichier a été initié par Bernard Burette en janvier 2014.
 *
 * All this work is copyleft Bernard Burette.
 * Gauche d'auteur Bernard Burette.
 *
 * This program is distributed under the terms of the GNU General Public
 *  License version 2 or more.
 * La diffusion de ce code est faite selon les termes de la licence publique
 *  générale GNU version 2 ou plus.
 *
 */

/** @file
 *
 * Initialization and finalization.
 *
 */


#include "uefi.h"
#include "debug.h"
#include <unistd.h>
#include <string.h>
#include <assert.h>


/*
 * Arguments à passer aux fonctions d'init.
 */
static char* argv[] = { "fdisk" , NULL , NULL } ;
static char* envp[] = { NULL } ;


/**
 * Le script de link elf-$(ARCH).lds définit ces symboles.
 */
extern void ( * __init_array_start[] ) ( int , char ** , char ** ) ;
extern void ( * __init_array_end[] ) ( int , char ** , char ** ) ;
extern void ( * __fini_array_start[] ) ( void ) ;
extern void ( * __fini_array_end[] ) ( void ) ;


/**
 * Fonction interne pour enregistrer une fonction de fin d'exécution.
 */
static void __internal_atexit( void (*func) (void) , void *arg ) ;


/**
 * La fonction _call_init() appelée depuis _start au tout début de l'exécution
 * avant de passer le contrôle à efi_main().
 * Cette fonction appelle toutes les fonctions référencées dans le tableau
 * __init_array[] dont le début et la fin sont fournies à ce code par les
 * symboles __init_array_start et __init_array_end.
 */
void _call_init( void ) ;
void
_call_init()
{
	size_t size ;
	size_t i;
	UEFI_dprintf( D_INIT | D_INFO , "Entre dans _call_init()\n" ) ;
	size = __init_array_end - __init_array_start;
	UEFI_dprintf( D_INIT | D_INFO , "__init_array[%ld]\n" , size ) ;
	/* debug : affiche les adresses des premières fonctions */
	for (i = 0; i < size; i++) {
		UEFI_dprintf( D_INIT | D_INFO , " __init_array[%ld] = %p\n" ,
			i , __init_array_start[ i ] ) ;
		if ( i >= 4 ) {
			UEFI_dprintf( D_INIT | D_INFO , " ...\n" ) ;
			break ;
		}
	}
	for (i = 0; i < size; i++) {
		void (* appel) ( int , char ** , char ** ) ;
		appel = __init_array_start[ i ] ;
		UEFI_dprintf( D_INIT | D_INFO | D_DEBUG ,
			"Appelle __init_array[%ld] = %p -" , i , appel ) ;
#ifdef EFI_DEBUG
		/* le début du code de cette fonction sur 12 octets */
		size_t j ;
		if ( uefi_debug_mask( D_INIT | D_INFO ) ) {
			for ( j = 0 ; j < 12 ; j ++ ) {
				unsigned char * x = (unsigned char *) appel ;
				UEFI_dprintf( D_INIT | D_INFO , " %02x" ,
					x[ j ] ) ;
			}
			UEFI_dprintf( D_INIT | D_INFO , "\n--> Touche : " ) ;
			UEFI_console_getchar() ;
			UEFI_console_putchar( '\n' , 1 ) ;
		}
#endif
		/* l'appelle */
		( * appel )( 1 , argv , envp ) ;
		UEFI_dprintf( D_INIT | D_INFO , "<--\n" ) ;
	}
	/* enregistre les fonctions de fin */
	size = __fini_array_end - __fini_array_start;
	UEFI_dprintf( D_INIT | D_INFO , "__fini_array[%ld]\n" , size ) ;
	for (i = 0; i < size; i++) {
		void (* to_call) (void) ;
		to_call = __fini_array_start[ i ] ;
		__internal_atexit( to_call , 0 ) ;
	}
	
	UEFI_dprintf( D_INIT | D_INFO , "Quitte _call_init()\n" ) ;
}


/**
 * Un truc lié à C++.
 */
/* int __dso_handle ; */


/**
 * Types des fonctions de fin d'excution.
 */
enum {
	ef_free = 0 /* `ef_free' MUST be zero! */ ,
	ef_us , ef_on , ef_at , ef_cxa
} ;


/**
 * La structure qui enregistre une fonction de fin d'exécution.
 */
struct exit_function {
	long int flavor ;
	union {
		void (*at) (void) ;
		struct {
			void (*fn) (int status, void *arg) ;
			void *arg ;
		} on ;
		struct {
			void (*fn) (void *arg, int status) ;
			void *arg ;
			void *dso_handle ;
		} cxa ;
	} func ;
} ;


/**
 * La structure qui enregistre une fonction de fin d'exécution.
 * Cette structure permet d'en créer une liste chaînée.
 */
struct exit_function_list {
	struct exit_function_list *next ;
	struct exit_function f ;
} ;


/**
 * La liste des fonctions de fin d'exécution enregistrées.
 */
static struct exit_function_list * liste = NULL ;


/**
 * Enregistre une fonction de fin d'exécution.
 */
static void __internal_atexit( func , arg )
	void (*func) (void) ;
	void *arg ;
{
	/* crée une nouvelle structure */
	struct exit_function_list * n ;
	n = malloc( sizeof( struct exit_function_list ) ) ;
	if ( n == NULL ) __fortify_fail( "__internal_atexit() ENOMEM" ) ;
	memset( n , 0 , sizeof( n ) ) ;
	/* l'insère au tout début de la chaîne */
	n-> next = liste ;
	liste = n ;
	/* met les bonnes valeurs */
	n-> f. func. at = func ;
	n-> f. func. cxa. arg = arg ;
	/* debug */
	UEFI_dprintf( D_INIT | D_INFO , "__internal_atexit( %p )\n" , func ) ;
}


/**
 * Enregistre une fonction C de fin d'exécution.
 */
int atexit( func )
	void (*func) (void) ;
{
	__internal_atexit( func , NULL ) ;
	return 0 ;
}


/**
 * Enregistre une fonction C++ de fin d'exécution.
 */
#if 0
int __cxa_atexit( func , arg , d )
	void (*func) (void *) ;
	void *arg ;
	void *d __attribute__((unused)) ;
{
	__internal_atexit( (void(*)(void)) func , arg ) ;
	return 0 ;
}
#endif


/**
 * __fortify_fail() : grave panne.
 */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
__attribute__((__noreturn__))
void __fortify_fail( msg )
	const char* msg ;
{
	write( 2 , "** " , 3 ) ;
	         /* 123 */
	write( 2 , (void *) msg , strlen( msg ) ) ;
	/* car on espère que strlen() fonctionne encore... */
	write( 2 , " **: aborting\n" , 14 ) ;
	         /* 1234567890123 4 */
	/* abandonne le programme avec un statut EFI_ABORTED */
	exit( 8 ) ;
}
#pragma GCC diagnostic pop


/**
 * abort() : abandonne le programme avec un petit message.
 */
__attribute__((__noreturn__))
void abort()
{
	__fortify_fail( "abort()" ) ;
}


/**
 * La fonction _call_fini() appelée depuis _start en fin d'exécution ou
 * depuis exit() ci-dessous.
 */
void _call_fini( int stat ) ;
void
_call_fini( stat )
	int stat ;
{
	/* décroche une par une les fonctions et les appelle */
	while ( liste != NULL ) {
		struct exit_function_list * elem ;
		elem = liste ;
		liste = elem-> next ;
		UEFI_dprintf( D_INIT | D_INFO | D_DEBUG , "Appelle %p" ,
			elem-> f. func. cxa. fn ) ;
		elem-> f. func. cxa. fn( elem-> f. func. cxa. arg , stat ) ;
	}
}


/*
 * La fonction exit() classique.
 */
__attribute__((__noreturn__))
void exit( stat )
	int stat ;
{
	/* le status envoyé à UEFI:Exit */
	EFI_STATUS status ;
	/* mappe le status */
	status = stat ;
	switch ( stat ) {
		case 1 : {
			/* new() a retourné NULL
			   c++ lèvera plutôt une exception */
			status = EFI_OUT_OF_RESOURCES ;
			break ;
		}
		case 2 :
			/* erreur fatale dans gpt.cc */
		case 5 : {
			/* cin ne fonctionne plus */
			status = EFI_DEVICE_ERROR ;
			break ;
		}
		case 8 : {
			/* quitte le programme sans sauver */
			status = EFI_ABORTED ;
			break ;
		}
#if 0
		case 25 : {
			/* le test des tailles mémoire SizesOK() a raté */
			status = EFI_INCOMPATIBLE_VERSION ;
			break ;
		}
#endif
	}
	/* avant de terminer, fait le ménage */
	_call_fini( stat ) ;
	/* debug */
	UEFI_dprintf( D_INIT | D_INFO , "Fin du programme : %lx\n" , status ) ;
	/* appelle Exit() qui ne devrait jamais revenir */
	for(;;) UEFI_call( ST-> BootServices-> Exit , UEFI_ImageHandle ,
		status , 0 , 0 ) ;
}