← Back to branch summary

~ubuntu-branches/debian/sid/grub2/sid-200907171837

« back to all changes in this revision

Viewing changes to kern/i386/pc/init.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Millan
  • Date: 2009-07-02 13:23:51 UTC
  • mfrom: (1.1.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20090702132351-tanpn0ryyijp93gu
Tags: 1.96+20090702-1
http://bugs.debian.org/535026
* New SVN snapshot.
* rules: Remove duplicated files in sparc64-ieee1275 port.
* rules: Comment out -DGRUB_ASSUME_LINUX_HAS_FB_SUPPORT=1 setting.  We'll
  re-evaluate using it when it's more mature.  (Closes: #535026).

Show diffs side-by-side

added added

removed removed

Lines of Context:
kern/i386/pc/init.c
22
22
#include <grub/machine/memory.h>
23
23
#include <grub/machine/console.h>
24
24
#include <grub/machine/kernel.h>
25
 
#include <grub/machine/biosdisk.h>
26
25
#include <grub/types.h>
27
26
#include <grub/err.h>
28
27
#include <grub/dl.h>
31
30
#include <grub/env.h>
32
31
#include <grub/cache.h>
33
32
#include <grub/time.h>
 
33
#include <grub/cpu/tsc.h>
34
34
 
35
35
struct mem_region
36
36
{
45
45
 
46
46
grub_addr_t grub_os_area_addr;
47
47
grub_size_t grub_os_area_size;
48
 
grub_size_t grub_lower_mem, grub_upper_mem;
49
48
 
50
49
void
51
 
grub_millisleep (grub_uint32_t ms)
52
 
{
53
 
  grub_millisleep_generic (ms);
54
 
}
55
 
 
56
 
void 
57
50
grub_arch_sync_caches (void *address __attribute__ ((unused)),
58
51
                       grub_size_t len __attribute__ ((unused)))
59
52
{
65
58
  /* XXX: This should be enough.  */
66
59
  char dev[100];
67
60
 
68
 
  if (grub_memdisk_image_size)
69
 
    {
70
 
      grub_sprintf (dev, "(memdisk)%s", grub_prefix);
71
 
      grub_strcpy (grub_prefix, dev);
72
 
    }
73
 
  else if (grub_install_dos_part != -2)
74
 
    {
75
 
      if (grub_boot_drive >= GRUB_BIOSDISK_MACHINE_CDROM_START)
76
 
        grub_sprintf (dev, "(cd%u",
77
 
                      grub_boot_drive - GRUB_BIOSDISK_MACHINE_CDROM_START);
78
 
      else
79
 
        grub_sprintf (dev, "(%cd%u",
80
 
                      (grub_boot_drive & 0x80) ? 'h' : 'f',
81
 
                      grub_boot_drive & 0x7f);
82
 
      
 
61
  if (grub_prefix[0] != '(')
 
62
    {
 
63
      /* No hardcoded root partition - make it from the boot drive and the
 
64
         partition number encoded at the install time.  */
 
65
      grub_sprintf (dev, "(%cd%u", (grub_boot_drive & 0x80) ? 'h' : 'f',
 
66
                    grub_boot_drive & 0x7f);
 
67
 
83
68
      if (grub_install_dos_part >= 0)
84
69
        grub_sprintf (dev + grub_strlen (dev), ",%u", grub_install_dos_part + 1);
85
 
      
 
70
 
86
71
      if (grub_install_bsd_part >= 0)
87
72
        grub_sprintf (dev + grub_strlen (dev), ",%c", grub_install_bsd_part + 'a');
88
 
      
 
73
 
89
74
      grub_sprintf (dev + grub_strlen (dev), ")%s", grub_prefix);
90
75
      grub_strcpy (grub_prefix, dev);
91
76
    }
92
 
      
 
77
 
93
78
  return grub_prefix;
94
79
}
95
80
 
127
112
    if (mem_regions[i].addr + mem_regions[i].size >= mem_regions[i + 1].addr)
128
113
      {
129
114
        j = i + 1;
130
 
        
 
115
 
131
116
        if (mem_regions[i].addr + mem_regions[i].size
132
117
            < mem_regions[j].addr + mem_regions[j].size)
133
118
          mem_regions[i].size = (mem_regions[j].addr + mem_regions[j].size
143
128
void
144
129
grub_machine_init (void)
145
130
{
146
 
  grub_uint32_t cont;
147
 
  struct grub_machine_mmap_entry *entry
148
 
    = (struct grub_machine_mmap_entry *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
149
131
  int i;
150
 
  
 
132
  int grub_lower_mem;
 
133
 
151
134
  /* Initialize the console as early as possible.  */
152
135
  grub_console_init ();
153
 
  
 
136
 
154
137
  grub_lower_mem = grub_get_memsize (0) << 10;
155
 
  
 
138
 
156
139
  /* Sanity check.  */
157
140
  if (grub_lower_mem < GRUB_MEMORY_MACHINE_RESERVED_END)
158
141
    grub_fatal ("too small memory");
162
145
  grub_gate_a20 (1);
163
146
#endif
164
147
 
 
148
/* FIXME: This prevents loader/i386/linux.c from using low memory.  When our
 
149
   heap implements support for requesting a chunk in low memory, this should
 
150
   no longer be a problem.  */
 
151
#if 0
165
152
  /* Add the lower memory into free memory.  */
166
153
  if (grub_lower_mem >= GRUB_MEMORY_MACHINE_RESERVED_END)
167
154
    add_mem_region (GRUB_MEMORY_MACHINE_RESERVED_END,
168
155
                    grub_lower_mem - GRUB_MEMORY_MACHINE_RESERVED_END);
169
 
  
170
 
  /* Check if grub_get_mmap_entry works.  */
171
 
  cont = grub_get_mmap_entry (entry, 0);
172
 
 
173
 
  if (entry->size)
174
 
    do
175
 
      {
176
 
        /* Avoid the lower memory.  */
177
 
        if (entry->addr < 0x100000)
178
 
          {
179
 
            if (entry->len <= 0x100000 - entry->addr)
180
 
              goto next;
181
 
 
182
 
            entry->len -= 0x100000 - entry->addr;
183
 
            entry->addr = 0x100000;
184
 
          }
185
 
        
186
 
        /* Ignore >4GB.  */
187
 
        if (entry->addr <= 0xFFFFFFFF && entry->type == 1)
188
 
          {
189
 
            grub_addr_t addr;
190
 
            grub_size_t len;
191
 
 
192
 
            addr = (grub_addr_t) entry->addr;
193
 
            len = ((addr + entry->len > 0xFFFFFFFF)
194
 
                   ? 0xFFFFFFFF - addr
195
 
                   : (grub_size_t) entry->len);
196
 
            add_mem_region (addr, len);
197
 
          }
198
 
        
199
 
      next:
200
 
        if (! cont)
201
 
          break;
202
 
        
203
 
        cont = grub_get_mmap_entry (entry, cont);
204
 
      }
205
 
    while (entry->size);
206
 
  else
 
156
#endif
 
157
 
 
158
  auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
 
159
  int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size, grub_uint32_t type)
207
160
    {
208
 
      grub_uint32_t eisa_mmap = grub_get_eisa_mmap ();
209
 
 
210
 
      if (eisa_mmap)
211
 
        {
212
 
          add_mem_region (0x100000, (eisa_mmap & 0xFFFF) << 10);
213
 
          add_mem_region (0x1000000, eisa_mmap & ~0xFFFF);
214
 
        }
215
 
      else
216
 
        add_mem_region (0x100000, grub_get_memsize (1) << 10);
 
161
      /* Avoid the lower memory.  */
 
162
      if (addr < 0x100000)
 
163
        {
 
164
          if (size <= 0x100000 - addr)
 
165
            return 0;
 
166
 
 
167
          size -= 0x100000 - addr;
 
168
          addr = 0x100000;
 
169
        }
 
170
 
 
171
      /* Ignore >4GB.  */
 
172
      if (addr <= 0xFFFFFFFF && type == GRUB_MACHINE_MEMORY_AVAILABLE)
 
173
        {
 
174
          grub_size_t len;
 
175
 
 
176
          len = (grub_size_t) ((addr + size > 0xFFFFFFFF)
 
177
                 ? 0xFFFFFFFF - addr
 
178
                 : size);
 
179
          add_mem_region (addr, len);
 
180
        }
 
181
 
 
182
      return 0;
217
183
    }
218
184
 
 
185
  grub_machine_mmap_iterate (hook);
 
186
 
219
187
  compact_mem_regions ();
220
188
 
221
189
  /* Add the memory regions to free memory, except for the region starting
226
194
      {
227
195
        grub_size_t quarter = mem_regions[i].size >> 2;
228
196
 
229
 
        grub_upper_mem = mem_regions[i].size;
230
197
        grub_os_area_addr = mem_regions[i].addr;
231
198
        grub_os_area_size = mem_regions[i].size - quarter;
232
199
        grub_mm_init_region ((void *) (grub_os_area_addr + grub_os_area_size),
234
201
      }
235
202
    else
236
203
      grub_mm_init_region ((void *) mem_regions[i].addr, mem_regions[i].size);
237
 
  
 
204
 
238
205
  if (! grub_os_area_addr)
239
206
    grub_fatal ("no upper memory");
 
207
 
 
208
  grub_tsc_init ();
240
209
}
241
210
 
242
211
void
250
219
grub_machine_fini (void)
251
220
{
252
221
  grub_console_fini ();
 
222
  grub_stop_floppy ();
253
223
}
254
224
 
255
225
/* Return the end of the core image.  */
256
226
grub_addr_t
257
227
grub_arch_modules_addr (void)
258
228
{
259
 
  return grub_end_addr;
260
 
}
261
 
 
262
 
/* Return the start of the memdisk image.  */
263
 
grub_addr_t
264
 
grub_arch_memdisk_addr (void)
265
 
{
266
229
  return GRUB_MEMORY_MACHINE_DECOMPRESSION_ADDR
267
 
    + (grub_kernel_image_size - GRUB_KERNEL_MACHINE_RAW_SIZE)
268
 
    + grub_total_module_size;
269
 
}
270
 
 
271
 
/* Return the size of the memdisk image.  */
272
 
grub_off_t
273
 
grub_arch_memdisk_size (void)
274
 
{
275
 
  return grub_memdisk_image_size;
 
230
    + (grub_kernel_image_size - GRUB_KERNEL_MACHINE_RAW_SIZE);
276
231
}