iPXE
memmap_settings.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA.
18  *
19  * You can also choose to distribute this program under the terms of
20  * the Unmodified Binary Distribution Licence (as given in the file
21  * COPYING.UBDL), provided that you have satisfied its requirements.
22  */
23 
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25 
26 #include <string.h>
27 #include <errno.h>
28 #include <byteswap.h>
29 #include <ipxe/init.h>
30 #include <ipxe/settings.h>
31 #include <ipxe/io.h>
32 
33 /** @file
34  *
35  * Memory map settings
36  *
37  * Memory map settings are numerically encoded as:
38  *
39  * Bits 31-24 Number of regions, minus one
40  * Bits 23-16 Starting region
41  * Bits 15-11 Unused
42  * Bit 10 Ignore non-existent regions (rather than generating an error)
43  * Bit 9 Include length
44  * Bit 8 Include start address
45  * Bits 7-6 Unused
46  * Bits 5-0 Scale factor (i.e. right shift count)
47  */
48 
49 /**
50  * Construct memory map setting tag
51  *
52  * @v start Starting region
53  * @v count Number of regions
54  * @v include_start Include start address
55  * @v include_length Include length
56  * @v ignore Ignore non-existent regions
57  * @v scale Scale factor
58  * @ret tag Setting tag
59  */
60 #define MEMMAP_TAG( start, count, include_start, include_length, \
61  ignore, scale ) \
62  ( ( (start) << 16 ) | ( ( (count) - 1 ) << 24 ) | \
63  ( (ignore) << 10 ) | ( (include_length) << 9 ) | \
64  ( (include_start) << 8 ) | (scale) )
65 
66 /**
67  * Extract number of regions from setting tag
68  *
69  * @v tag Setting tag
70  * @ret count Number of regions
71  */
72 #define MEMMAP_COUNT( tag ) ( ( ( (tag) >> 24 ) & 0xff ) + 1 )
73 
74 /**
75  * Extract starting region from setting tag
76  *
77  * @v tag Setting tag
78  * @ret start Starting region
79  */
80 #define MEMMAP_START( tag ) ( ( (tag) >> 16 ) & 0xff )
81 
82 /**
83  * Extract ignore flag from setting tag
84  *
85  * @v tag Setting tag
86  * @ret ignore Ignore non-existent regions
87  */
88 #define MEMMAP_IGNORE_NONEXISTENT( tag ) ( (tag) & 0x00000400UL )
89 
90 /**
91  * Extract length inclusion flag from setting tag
92  *
93  * @v tag Setting tag
94  * @ret include_length Include length
95  */
96 #define MEMMAP_INCLUDE_LENGTH( tag ) ( (tag) & 0x00000200UL )
97 
98 /**
99  * Extract start address inclusion flag from setting tag
100  *
101  * @v tag Setting tag
102  * @ret include_start Include start address
103  */
104 #define MEMMAP_INCLUDE_START( tag ) ( (tag) & 0x00000100UL )
105 
106 /**
107  * Extract scale factor from setting tag
108  *
109  * @v tag Setting tag
110  * @v scale Scale factor
111  */
112 #define MEMMAP_SCALE( tag ) ( (tag) & 0x3f )
113 
114 /** Memory map settings scope */
116 
117 /**
118  * Check applicability of memory map setting
119  *
120  * @v settings Settings block
121  * @v setting Setting
122  * @ret applies Setting applies within this settings block
123  */
125  const struct setting *setting ) {
126 
127  return ( setting->scope == &memmap_settings_scope );
128 }
129 
130 /**
131  * Fetch value of memory map setting
132  *
133  * @v settings Settings block
134  * @v setting Setting to fetch
135  * @v data Buffer to fill with setting data
136  * @v len Length of buffer
137  * @ret len Length of setting data, or negative error
138  */
140  struct setting *setting,
141  void *data, size_t len ) {
142  struct memory_map memmap;
143  struct memory_region *region;
144  uint64_t result = 0;
145  unsigned int start;
146  unsigned int count;
147  unsigned int scale;
148  int include_start;
149  int include_length;
150  int ignore_nonexistent;
151  unsigned int i;
152 
153  /* Parse settings tag */
154  start = MEMMAP_START ( setting->tag );
155  count = MEMMAP_COUNT ( setting->tag );
156  scale = MEMMAP_SCALE ( setting->tag );
157  include_start = MEMMAP_INCLUDE_START ( setting->tag );
158  include_length = MEMMAP_INCLUDE_LENGTH ( setting->tag );
159  ignore_nonexistent = MEMMAP_IGNORE_NONEXISTENT ( setting->tag );
160  DBGC ( settings, "MEMMAP start %d count %d %s%s%s%s scale %d\n",
161  start, count, ( include_start ? "start" : "" ),
162  ( ( include_start && include_length ) ? "+" : "" ),
163  ( include_length ? "length" : "" ),
164  ( ignore_nonexistent ? " ignore" : "" ), scale );
165 
166  /* Fetch memory map */
167  get_memmap ( &memmap );
168 
169  /* Extract results from memory map */
170  for ( i = start ; count-- ; i++ ) {
171 
172  /* Check that region exists */
173  if ( i >= memmap.count ) {
174  if ( ignore_nonexistent ) {
175  continue;
176  } else {
177  DBGC ( settings, "MEMMAP region %d does not "
178  "exist\n", i );
179  return -ENOENT;
180  }
181  }
182 
183  /* Extract results from this region */
184  region = &memmap.regions[i];
185  if ( include_start ) {
186  result += region->start;
187  DBGC ( settings, "MEMMAP %d start %08llx\n",
188  i, region->start );
189  }
190  if ( include_length ) {
191  result += ( region->end - region->start );
192  DBGC ( settings, "MEMMAP %d length %08llx\n",
193  i, ( region->end - region->start ) );
194  }
195  }
196 
197  /* Scale result */
198  result >>= scale;
199 
200  /* Return result */
201  result = cpu_to_be64 ( result );
202  if ( len > sizeof ( result ) )
203  len = sizeof ( result );
204  memcpy ( data, &result, len );
205 
206  /* Set type if not already specified */
207  if ( ! setting->type )
208  setting->type = &setting_type_hexraw;
209 
210  return sizeof ( result );
211 }
212 
213 /** Memory map settings operations */
216  .fetch = memmap_settings_fetch,
217 };
218 
219 /** Memory map settings */
220 static struct settings memmap_settings = {
221  .refcnt = NULL,
222  .siblings = LIST_HEAD_INIT ( memmap_settings.siblings ),
223  .children = LIST_HEAD_INIT ( memmap_settings.children ),
225  .default_scope = &memmap_settings_scope,
226 };
227 
228 /** Initialise memory map settings */
229 static void memmap_settings_init ( void ) {
230  int rc;
231 
233  "memmap" ) ) != 0 ) {
234  DBG ( "MEMMAP could not register settings: %s\n",
235  strerror ( rc ) );
236  return;
237  }
238 }
239 
240 /** Memory map settings initialiser */
241 struct init_fn memmap_settings_init_fn __init_fn ( INIT_NORMAL ) = {
243 };
244 
245 /** Memory map predefined settings */
246 const struct setting memsize_setting __setting ( SETTING_MISC, memsize ) = {
247  .name = "memsize",
248  .description = "Memory size (in MB)",
249  .tag = MEMMAP_TAG ( 0, 0x100, 0, 1, 1, 20 ),
250  .type = &setting_type_int32,
251  .scope = &memmap_settings_scope,
252 };
iPXE I/O API
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
void get_memmap(struct memory_map *memmap)
Get memory map.
void(* initialise)(void)
Definition: init.h:15
const struct setting memsize_setting __setting(SETTING_MISC, memsize)
Memory map predefined settings.
#define MEMMAP_COUNT(tag)
Extract number of regions from setting tag.
unsigned int count
Number of used regions.
Definition: io.h:503
Error codes.
#define DBGC(...)
Definition: compiler.h:505
#define MEMMAP_INCLUDE_LENGTH(tag)
Extract length inclusion flag from setting tag.
#define ENOENT
No such file or directory.
Definition: errno.h:514
unsigned long long uint64_t
Definition: stdint.h:13
#define SETTING_MISC
Miscellaneous settings.
Definition: settings.h:80
#define MEMMAP_SCALE(tag)
Extract scale factor from setting tag.
struct init_fn memmap_settings_init_fn __init_fn(INIT_NORMAL)
Memory map settings initialiser.
A memory map.
Definition: io.h:499
static int memmap_settings_applies(struct settings *settings __unused, const struct setting *setting)
Check applicability of memory map setting.
static struct settings_operations memmap_settings_operations
Memory map settings operations.
const char * name
Name.
Definition: settings.h:28
uint32_t start
Starting offset.
Definition: netvsc.h:12
struct memory_region regions[MAX_MEMORY_REGIONS]
Memory regions.
Definition: io.h:501
uint64_t tag
Setting tag, if applicable.
Definition: settings.h:43
#define MEMMAP_TAG(start, count, include_start, include_length, ignore, scale)
Construct memory map setting tag.
#define INIT_NORMAL
Normal initialisation.
Definition: init.h:30
void * memcpy(void *dest, const void *src, size_t len) __nonnull
int result
Definition: bigint.h:148
An initialisation function.
Definition: init.h:14
static int memmap_settings_fetch(struct settings *settings, struct setting *setting, void *data, size_t len)
Fetch value of memory map setting.
const struct setting_type * type
Setting type.
Definition: settings.h:36
static void memmap_settings_init(void)
Initialise memory map settings.
Configuration settings.
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
static const struct settings_scope memmap_settings_scope
Memory map settings scope.
#define MEMMAP_START(tag)
Extract starting region from setting tag.
Settings block operations.
Definition: settings.h:85
A settings block.
Definition: settings.h:132
A setting scope.
Definition: settings.h:176
A usable memory region.
Definition: io.h:488
struct list_head siblings
Sibling settings blocks.
Definition: settings.h:140
A setting.
Definition: settings.h:23
#define __unused
Declare a variable or data structure as unused.
Definition: compiler.h:573
static struct settings memmap_settings
Memory map settings.
uint32_t len
Length.
Definition: ena.h:14
uint64_t start
Physical start address.
Definition: io.h:490
FILE_LICENCE(GPL2_OR_LATER_OR_UBDL)
uint16_t count
Number of entries.
Definition: ena.h:22
#define cpu_to_be64(value)
Definition: byteswap.h:111
int(* applies)(struct settings *settings, const struct setting *setting)
Check applicability of setting.
Definition: settings.h:98
struct list_head children
Child settings blocks.
Definition: settings.h:142
int register_settings(struct settings *settings, struct settings *parent, const char *name)
Register settings block.
Definition: settings.c:478
struct arbelprm_port_state_change_st data
Message.
Definition: arbel.h:12
#define DBG(...)
Print a debugging message.
Definition: compiler.h:498
#define LIST_HEAD_INIT(list)
Initialise a static list head.
Definition: list.h:30
const struct settings_scope * scope
Setting scope (or NULL)
Definition: settings.h:49
#define MEMMAP_IGNORE_NONEXISTENT(tag)
Extract ignore flag from setting tag.
uint64_t end
Physical end address.
Definition: io.h:492
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
String functions.
struct refcnt * refcnt
Reference counter.
Definition: settings.h:134
#define MEMMAP_INCLUDE_START(tag)
Extract start address inclusion flag from setting tag.