rtc_entropy.c File Reference

RTC-based entropy source. More...

#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <biosint.h>
#include <pic8259.h>
#include <rtc.h>
#include <ipxe/cpuid.h>
#include <ipxe/entropy.h>

Go to the source code of this file.

Macros
#define	RTC_MAX_WAIT_MS   100
	Maximum time to wait for an RTC interrupt, in milliseconds.
#define	RTC_CHECK_COUNT   3
	Number of RTC interrupts to check for.
#define	rtc_flag   __use_text16 ( rtc_flag )

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
struct entropy_source rtc_entropy	__entropy_source (ENTROPY_NORMAL)
	RTC entropy source.
void	rtc_isr (void)
	RTC interrupt handler.
volatile uint8_t	__text16 (rtc_flag)
	Flag set by RTC interrupt handler.
static void	rtc_hook_isr (void)
	Hook RTC interrupt handler.
static void	rtc_unhook_isr (void)
	Unhook RTC interrupt handler.
static int	rtc_enable_int (void)
	Enable RTC interrupts.
static void	rtc_disable_int (void)
	Disable RTC interrupts.
static int	rtc_entropy_check (void)
	Check that entropy gathering is functional.
static int	rtc_entropy_enable (void)
	Enable entropy gathering.
static void	rtc_entropy_disable (void)
	Disable entropy gathering.
static int	rtc_get_noise (noise_sample_t *noise)
	Get noise sample.

Variables
static struct segoff	rtc_old_handler
	Previous RTC interrupt handler.
static uint8_t	rtc_irq_enabled
	Previous RTC interrupt enabled state.
static uint8_t	rtc_int_enabled
	Previous RTC periodic interrupt enabled state.

Detailed Description

RTC-based entropy source.

Definition in file rtc_entropy.c.

Macro Definition Documentation

RTC_MAX_WAIT_MS

#define RTC_MAX_WAIT_MS   100

Maximum time to wait for an RTC interrupt, in milliseconds.

Definition at line 45 of file rtc_entropy.c.

Referenced by rtc_entropy_check().

RTC_CHECK_COUNT

#define RTC_CHECK_COUNT   3

Number of RTC interrupts to check for.

Definition at line 48 of file rtc_entropy.c.

Referenced by rtc_entropy_check().

rtc_flag

#define rtc_flag   __use_text16 ( rtc_flag )

Definition at line 64 of file rtc_entropy.c.

Referenced by __text16(), rtc_entropy_check(), and rtc_entropy_enable().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

__entropy_source()

struct entropy_source rtc_entropy __entropy_source

(

ENTROPY_NORMAL

)

RTC entropy source.

References __entropy_source, and ENTROPY_NORMAL.

rtc_isr()

void rtc_isr ( void )

extern

RTC interrupt handler.

Referenced by rtc_hook_isr(), and rtc_unhook_isr().

__text16()

volatile uint8_t __text16 ( rtc_flag )

extern

Flag set by RTC interrupt handler.

References rtc_flag.

rtc_hook_isr()

void rtc_hook_isr ( void )

static

Hook RTC interrupt handler.

Definition at line 70 of file rtc_entropy.c.

                                  {
 
        /* RTC interrupt handler */
        __asm__ __volatile__ (
                TEXT16_CODE ( "\nrtc_isr:\n\t"
                              /* Preserve registers */
                              "pushw %%ax\n\t"
                              /* Set "interrupt triggered" flag */
                              "movb $0x01, %%cs:rtc_flag\n\t"
                              /* Read RTC status register C to
                               * acknowledge interrupt
                               */
                              "movb %2, %%al\n\t"
                              "outb %%al, %0\n\t"
                              "inb %1\n\t"
                              /* Send EOI */
                              "movb $0x20, %%al\n\t"
                              "outb %%al, $0xa0\n\t"
                              "outb %%al, $0x20\n\t"
                              /* Restore registers and return */
                              "popw %%ax\n\t"
                              "iret\n\t"
                              "\nrtc_flag:\n\t"
                              ".byte 0\n\t" )
                :
                : "i" ( CMOS_ADDRESS ), "i" ( CMOS_DATA ),
                  "i" ( RTC_STATUS_C ) );
 
        hook_bios_interrupt ( RTC_INT, ( intptr_t ) rtc_isr, &rtc_old_handler );
}

References __asm__(), __volatile__(), CMOS_ADDRESS, CMOS_DATA, hook_bios_interrupt(), RTC_INT, rtc_isr(), rtc_old_handler, RTC_STATUS_C, and TEXT16_CODE.

Referenced by rtc_entropy_enable().

rtc_unhook_isr()

void rtc_unhook_isr ( void )

static

Unhook RTC interrupt handler.

Definition at line 105 of file rtc_entropy.c.

                                    {
        int rc;
 
        rc = unhook_bios_interrupt ( RTC_INT, ( intptr_t ) rtc_isr,
                                     &rtc_old_handler );
        assert ( rc == 0 ); /* Should always be able to unhook */
}

References assert, rc, RTC_INT, rtc_isr(), rtc_old_handler, and unhook_bios_interrupt().

Referenced by rtc_entropy_disable(), and rtc_entropy_enable().

rtc_enable_int()

int rtc_enable_int ( void )

static

Enable RTC interrupts.

Return values

enabled

Periodic interrupt was previously enabled

Definition at line 118 of file rtc_entropy.c.

                                   {
        uint8_t status_b;
 
        /* Clear any stale pending interrupts via status register C */
        outb ( ( RTC_STATUS_C | CMOS_DISABLE_NMI ), CMOS_ADDRESS );
        inb ( CMOS_DATA );
 
        /* Set Periodic Interrupt Enable bit in status register B */
        outb ( ( RTC_STATUS_B | CMOS_DISABLE_NMI ), CMOS_ADDRESS );
        status_b = inb ( CMOS_DATA );
        outb ( ( RTC_STATUS_B | CMOS_DISABLE_NMI ), CMOS_ADDRESS );
        outb ( ( status_b | RTC_STATUS_B_PIE ), CMOS_DATA );
 
        /* Re-enable NMI and reset to default address */
        outb ( CMOS_DEFAULT_ADDRESS, CMOS_ADDRESS );
        inb ( CMOS_DATA ); /* Discard; may be needed on some platforms */
 
        /* Return previous state */
        return ( status_b & RTC_STATUS_B_PIE );
}

References CMOS_ADDRESS, CMOS_DATA, CMOS_DEFAULT_ADDRESS, CMOS_DISABLE_NMI, inb, outb, RTC_STATUS_B, RTC_STATUS_B_PIE, and RTC_STATUS_C.

Referenced by rtc_entropy_enable().

rtc_disable_int()

void rtc_disable_int ( void )

static

Disable RTC interrupts.

Definition at line 143 of file rtc_entropy.c.

                                     {
        uint8_t status_b;
 
        /* Clear Periodic Interrupt Enable bit in status register B */
        outb ( ( RTC_STATUS_B | CMOS_DISABLE_NMI ), CMOS_ADDRESS );
        status_b = inb ( CMOS_DATA );
        outb ( ( RTC_STATUS_B | CMOS_DISABLE_NMI ), CMOS_ADDRESS );
        outb ( ( status_b & ~RTC_STATUS_B_PIE ), CMOS_DATA );
 
        /* Re-enable NMI and reset to default address */
        outb ( CMOS_DEFAULT_ADDRESS, CMOS_ADDRESS );
        inb ( CMOS_DATA ); /* Discard; may be needed on some platforms */
}

References CMOS_ADDRESS, CMOS_DATA, CMOS_DEFAULT_ADDRESS, CMOS_DISABLE_NMI, inb, outb, RTC_STATUS_B, and RTC_STATUS_B_PIE.

Referenced by rtc_entropy_disable(), and rtc_entropy_enable().

rtc_entropy_check()

int rtc_entropy_check ( void )

static

Check that entropy gathering is functional.

Return values

rc	Return status code

Definition at line 162 of file rtc_entropy.c.

                                      {
        unsigned int count = 0;
        unsigned int i;
 
        /* Check that RTC interrupts are working */
        rtc_flag = 0;
        for ( i = 0 ; i < RTC_MAX_WAIT_MS ; i++ ) {
 
                /* Allow interrupts to occur */
                __asm__ __volatile__ ( "sti\n\t"
                                       "nop\n\t"
                                       "nop\n\t"
                                       "cli\n\t" );
 
                /* Check for RTC interrupt flag */
                if ( rtc_flag ) {
                        rtc_flag = 0;
                        if ( ++count >= RTC_CHECK_COUNT )
                                return 0;
                }
 
                /* Delay */
                mdelay ( 1 );
        }
 
        DBGC ( &rtc_flag, "RTC timed out waiting for interrupt %d/%d\n",
               ( count + 1 ), RTC_CHECK_COUNT );
        return -ETIMEDOUT;
}

References __asm__(), __volatile__(), count, DBGC, ETIMEDOUT, mdelay(), RTC_CHECK_COUNT, rtc_flag, and RTC_MAX_WAIT_MS.

Referenced by rtc_entropy_enable().

rtc_entropy_enable()

int rtc_entropy_enable ( void )

static

Enable entropy gathering.

Return values

rc	Return status code

Definition at line 197 of file rtc_entropy.c.

                                       {
        struct x86_features features;
        int rc;
 
        /* Check that TSC is supported */
        x86_features ( &features );
        if ( ! ( features.intel.edx & CPUID_FEATURES_INTEL_EDX_TSC ) ) {
                DBGC ( &rtc_flag, "RTC has no TSC\n" );
                rc = -ENOTSUP;
                goto err_no_tsc;
        }
 
        /* Hook ISR and enable RTC interrupts */
        rtc_hook_isr();
        rtc_irq_enabled = enable_irq ( RTC_IRQ );
        rtc_int_enabled = rtc_enable_int();
        DBGC ( &rtc_flag, "RTC had IRQ%d %sabled, interrupt %sabled\n",
               RTC_IRQ, ( rtc_irq_enabled ? "en" : "dis" ),
               ( rtc_int_enabled ? "en" : "dis" ) );
 
        /* Check that RTC interrupts are working */
        if ( ( rc = rtc_entropy_check() ) != 0 )
                goto err_check;
 
        /* The min-entropy has been measured on several platforms
         * using the entropy_sample test code.  Modelling the samples
         * as independent, and using a confidence level of 99.99%, the
         * measurements were as follows:
         *
         *    qemu-kvm          : 7.38 bits
         *    VMware            : 7.46 bits
         *    Physical hardware : 2.67 bits
         *
         * We choose the lowest of these (2.67 bits) and apply a 50%
         * safety margin to allow for some potential non-independence
         * of samples.
         */
        entropy_init ( &rtc_entropy, MIN_ENTROPY ( 1.3 ) );
 
        return 0;
 
 err_check:
        if ( ! rtc_int_enabled )
                rtc_disable_int();
        if ( ! rtc_irq_enabled )
                disable_irq ( RTC_IRQ );
        rtc_unhook_isr();
 err_no_tsc:
        return rc;
}

References CPUID_FEATURES_INTEL_EDX_TSC, DBGC, ENOTSUP, entropy_init(), features, MIN_ENTROPY, rc, rtc_disable_int(), rtc_enable_int(), rtc_entropy_check(), rtc_flag, rtc_hook_isr(), rtc_int_enabled, RTC_IRQ, rtc_irq_enabled, rtc_unhook_isr(), and x86_features().

rtc_entropy_disable()

void rtc_entropy_disable ( void )

static

Disable entropy gathering.

Definition at line 252 of file rtc_entropy.c.

                                         {
 
        /* Restore RTC interrupt state and unhook ISR */
        if ( ! rtc_int_enabled )
                rtc_disable_int();
        if ( ! rtc_irq_enabled )
                disable_irq ( RTC_IRQ );
        rtc_unhook_isr();
}

References rtc_disable_int(), rtc_int_enabled, RTC_IRQ, rtc_irq_enabled, and rtc_unhook_isr().

rtc_get_noise()

int rtc_get_noise ( noise_sample_t * noise )

static

Get noise sample.

Return values

noise	Noise sample
rc	Return status code

Definition at line 268 of file rtc_entropy.c.

                                                   {
        uint32_t before;
        uint32_t after;
        uint32_t temp;
 
        __asm__ __volatile__ (
                REAL_CODE ( /* Enable interrupts */
                            "sti\n\t"
                            /* Wait for RTC interrupt */
                            "movb %b2, %%cs:rtc_flag\n\t"
                            "\n1:\n\t"
                            "xchgb %b2, %%cs:rtc_flag\n\t" /* Serialize */
                            "testb %b2, %b2\n\t"
                            "jz 1b\n\t"
                            /* Read "before" TSC */
                            "rdtsc\n\t"
                            /* Store "before" TSC on stack */
                            "pushl %0\n\t"
                            /* Wait for another RTC interrupt */
                            "xorb %b2, %b2\n\t"
                            "movb %b2, %%cs:rtc_flag\n\t"
                            "\n1:\n\t"
                            "xchgb %b2, %%cs:rtc_flag\n\t" /* Serialize */
                            "testb %b2, %b2\n\t"
                            "jz 1b\n\t"
                            /* Read "after" TSC */
                            "rdtsc\n\t"
                            /* Retrieve "before" TSC on stack */
                            "popl %1\n\t"
                            /* Disable interrupts */
                            "cli\n\t"
                            )
                : "=a" ( after ), "=d" ( before ), "=Q" ( temp )
                : "2" ( 0 ) );
 
        *noise = ( after - before );
        return 0;
}

References __asm__(), __volatile__(), after, before, and REAL_CODE.

Variable Documentation

rtc_old_handler

struct segoff rtc_old_handler

static

Previous RTC interrupt handler.

Definition at line 54 of file rtc_entropy.c.

Referenced by rtc_hook_isr(), and rtc_unhook_isr().

rtc_irq_enabled

uint8_t rtc_irq_enabled

static

Previous RTC interrupt enabled state.

Definition at line 57 of file rtc_entropy.c.

Referenced by rtc_entropy_disable(), and rtc_entropy_enable().

rtc_int_enabled

uint8_t rtc_int_enabled

static

Previous RTC periodic interrupt enabled state.

Definition at line 60 of file rtc_entropy.c.

Referenced by rtc_entropy_disable(), and rtc_entropy_enable().