src/arch/i386/include/librm.h

   1 #ifndef LIBRM_H
   2 #define LIBRM_H
   3
   4 /* Drag in protected-mode segment selector values */
   5 #include "virtaddr.h"
   6 #include "realmode.h"
   7
   8 #ifndef ASSEMBLY
   9
  10 #include "stddef.h"
  11 #include "string.h"
  12
  13 /*
  14  * Data structures and type definitions
  15  *
  16  */
  17
  18 /* Access to variables in .data16 and .text16 */
  19 extern char *data16;
  20 extern char *text16;
  21
  22 #define __data16( variable )                                            \
  23         __attribute__ (( section ( ".data16" ) ))                       \
  24         _data16_ ## variable __asm__ ( #variable )
  25
  26 #define __data16_array( variable, array )                               \
  27         __attribute__ (( section ( ".data16" ) ))                       \
  28         _data16_ ## variable array __asm__ ( #variable )
  29
  30 #define __text16( variable )                                            \
  31         __attribute__ (( section ( ".text16.data" ) ))                  \
  32         _text16_ ## variable __asm__ ( #variable )
  33
  34 #define __text16_array( variable, array )                               \
  35         __attribute__ (( section ( ".text16.data" ) ))                  \
  36         _text16_ ## variable array __asm__ ( #variable )
  37
  38 #define __use_data16( variable )                                        \
  39         ( * ( ( typeof ( _data16_ ## variable ) * )                     \
  40               & ( data16 [ ( size_t ) & ( _data16_ ## variable ) ] ) ) )
  41
  42 #define __use_text16( variable )                                        \
  43         ( * ( ( typeof ( _text16_ ## variable ) * )                     \
  44               & ( text16 [ ( size_t ) & ( _text16_ ## variable ) ] ) ) )
  45
  46 #define __from_data16( variable )                                       \
  47         ( * ( ( typeof ( variable ) * )                                 \
  48               ( ( ( void * ) &(variable) ) - ( ( void * ) data16 ) ) ) )
  49
  50 #define __from_text16( variable )                                       \
  51         ( * ( ( typeof ( variable ) * )                                 \
  52               ( ( ( void * ) &(variable) ) - ( ( void * ) text16 ) ) ) )
  53
  54 /* Variables in librm.S, present in the normal data segment */
  55 extern uint16_t rm_sp;
  56 extern uint16_t rm_ss;
  57 extern uint32_t pm_esp;
  58 extern uint16_t __data16 ( rm_cs );
  59 #define rm_cs __use_data16 ( rm_cs )
  60 extern uint16_t __text16 ( rm_ds );
  61 #define rm_ds __use_text16 ( rm_ds )
  62
  63 /* Functions that librm expects to be able to link to.  Included here
  64  * so that the compiler will catch prototype mismatches.
  65  */
  66 extern void gateA20_set ( void );
  67
  68 /*
  69  * librm_mgmt: functions for manipulating base memory and executing
  70  * real-mode code.
  71  *
  72  * Full API documentation for these functions is in realmode.h.
  73  *
  74  */
  75
  76 /* Macro for obtaining a physical address from a segment:offset pair. */
  77 #define VIRTUAL(x,y) ( phys_to_virt ( ( ( x ) << 4 ) + ( y ) ) )
  78
  79 /* Copy to/from base memory */
  80 static inline __attribute__ (( always_inline )) void
  81 copy_to_real_librm ( unsigned int dest_seg, unsigned int dest_off,
  82                      void *src, size_t n ) {
  83         memcpy ( VIRTUAL ( dest_seg, dest_off ), src, n );
  84 }
  85 static inline __attribute__ (( always_inline )) void
  86 copy_from_real_librm ( void *dest, unsigned int src_seg,
  87                        unsigned int src_off, size_t n ) {
  88         memcpy ( dest, VIRTUAL ( src_seg, src_off ), n );
  89 }
  90 #define put_real_librm( var, dest_seg, dest_off )                             \
  91         do {                                                                  \
  92                 * ( ( typeof(var) * ) VIRTUAL ( dest_seg, dest_off ) ) = var; \
  93         } while ( 0 )
  94 #define get_real_librm( var, src_seg, src_off )                               \
  95         do {                                                                  \
  96                 var = * ( ( typeof(var) * ) VIRTUAL ( src_seg, src_off ) ); \
  97         } while ( 0 )
  98 #define copy_to_real copy_to_real_librm
  99 #define copy_from_real copy_from_real_librm
 100 #define put_real put_real_librm
 101 #define get_real get_real_librm
 102
 103 /**
 104  * A pointer to a user buffer
 105  *
 106  * Even though we could just use a void *, we use an intptr_t so that
 107  * attempts to use normal pointers show up as compiler warnings.  Such
 108  * code is actually valid for librm, but not for libkir (i.e. under
 109  * KEEP_IT_REAL), so it's good to have the warnings even under librm.
 110  */
 111 typedef intptr_t userptr_t;
 112
 113 /**
 114  * Copy data to user buffer
 115  *
 116  * @v buffer    User buffer
 117  * @v offset    Offset within user buffer
 118  * @v src       Source
 119  * @v len       Length
 120  */
 121 static inline __attribute__ (( always_inline )) void
 122 copy_to_user ( userptr_t buffer, off_t offset, const void *src, size_t len ) {
 123         memcpy ( ( void * ) buffer + offset, src, len );
 124 }
 125
 126 /**
 127  * Copy data from user buffer
 128  *
 129  * @v dest      Destination
 130  * @v buffer    User buffer
 131  * @v offset    Offset within user buffer
 132  * @v len       Length
 133  */
 134 static inline __attribute__ (( always_inline )) void
 135 copy_from_user ( void *dest, userptr_t buffer, off_t offset, size_t len ) {
 136         memcpy ( dest, ( void * ) buffer + offset, len );
 137 }
 138
 139 /**
 140  * Convert virtual address to user buffer
 141  *
 142  * @v virtual   Virtual address
 143  * @ret buffer  User buffer
 144  *
 145  * This constructs a user buffer from an ordinary pointer.  Use it
 146  * when you need to pass a pointer to an internal buffer to a function
 147  * that expects a @c userptr_t.
 148  */
 149 static inline __attribute__ (( always_inline )) userptr_t
 150 virt_to_user ( void * virtual ) {
 151         return ( ( intptr_t ) virtual );
 152 }
 153
 154 /**
 155  * Convert segment:offset address to user buffer
 156  *
 157  * @v segment   Real-mode segment
 158  * @v offset    Real-mode offset
 159  * @ret buffer  User buffer
 160  */
 161 static inline __attribute__ (( always_inline )) userptr_t
 162 real_to_user ( unsigned int segment, unsigned int offset ) {
 163         return virt_to_user ( VIRTUAL ( segment, offset ) );
 164 }
 165
 166 /* Copy to/from real-mode stack */
 167 extern uint16_t copy_to_rm_stack ( void *data, size_t size );
 168 extern void remove_from_rm_stack ( void *data, size_t size );
 169
 170 /* Place/remove parameter on real-mode stack in a way that's
 171  * compatible with libkir
 172  */
 173 #define BASEMEM_PARAMETER_INIT_LIBRM( param ) \
 174         copy_to_rm_stack ( & ( param ), sizeof ( param ) )
 175 #define BASEMEM_PARAMETER_DONE_LIBRM( param ) \
 176         remove_from_rm_stack ( & ( param ), sizeof ( param ) )
 177 #define BASEMEM_PARAMETER_INIT BASEMEM_PARAMETER_INIT_LIBRM
 178 #define BASEMEM_PARAMETER_DONE BASEMEM_PARAMETER_DONE_LIBRM
 179
 180 /* REAL_CODE: declare a fragment of code that executes in real mode */
 181 #define REAL_CODE( asm_code_str )                       \
 182         "pushl $1f\n\t"                                 \
 183         "call real_call\n\t"                            \
 184         "addl $4, %%esp\n\t"                            \
 185         ".section \".text16\", \"ax\", @progbits\n\t"   \
 186         ".code16\n\t"                                   \
 187         ".arch i386\n\t"                                \
 188         "\n1:\n\t"                                      \
 189         asm_code_str "\n\t"                             \
 190         "ret\n\t"                                       \
 191         ".code32\n\t"                                   \
 192         ".previous\n\t"
 193
 194 #endif /* ASSEMBLY */
 195
 196 #endif /* LIBRM_H */