GRUB

https://www.gnu.org/software/grub/manual/grub-dev/
Admin
GRUB is a free software bootloader that enables users to select and boot different operating systems...
Tokens:34,499
Snippets:236
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Example of screen setup

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Example code demonstrating how to initialize a video mode using grub_video_setup.

```APIDOC
## Example of screen setup

### Description
Example of screen setup using grub_video_setup.

### Code
```c
grub_err_t rc;
/* Try to initialize video mode 1024 x 768 with direct RGB.  */
rc = grub_video_setup (1024, 768, GRUB_VIDEO_MODE_TYPE_RGB);
if (rc != GRUB_ERR_NONE)
{
  /* Fall back to standard VGA Index Color mode.  */
  rc = grub_video_setup (640, 480, GRUB_VIDEO_MODE_TYPE_INDEX);
  if (rc != GRUB_ERR_NONE)
  {
  /* Handle error.  */
  }
}
```
```

--------------------------------

### Example of screen setup

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Initializes a 1024x768 RGB video mode, falling back to 640x480 index color mode on failure. Handles errors if both fail.

```c
grub_err_t rc;
/* Try to initialize video mode 1024 x 768 with direct RGB.  */
rc = grub_video_setup (1024, 768, GRUB_VIDEO_MODE_TYPE_RGB);
if (rc != GRUB_ERR_NONE)
{
  /* Fall back to standard VGA Index Color mode.  */
  rc = grub_video_setup (640, 480, GRUB_VIDEO_MODE_TYPE_INDEX);
  if (rc != GRUB_ERR_NONE)
  {
  /* Handle error.  */
  }
}

```

--------------------------------

### Example of setting up console viewport

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Example code demonstrating how to set up a console viewport using video API functions.

```APIDOC
## Example of setting up console viewport

### Description
Example of setting up console viewport.

### Code
```c
grub_uint32_t x, y, width, height;
grub_video_color_t color;
struct grub_font_glyph glyph;
grub_err_t rc;
/* Query existing viewport.  */
grub_video_get_viewport (&x, &y, &width, &height);
/* Fill background.  */
color = grub_video_map_color (GRUB_COLOR_BACKGROUND);
grub_video_fill_rect (color, 0, 0, width, height);
/* Setup console viewport.  */
grub_video_set_viewport (x + 10, y + 10, width - 20, height - 20);
grub_video_get_viewport (&x, &y, &width, &height);
color = grub_video_map_color (GRUB_COLOR_CONSOLE_BACKGROUND);
grub_video_fill_rect (color, 0, 0, width, height);
/* Draw text to viewport.  */
color = grub_video_map_color (GRUB_COLOR_CONSOLE_TEXT);
grub_font_get_glyph ('X', &glyph);
grub_video_blit_glyph (&glyph, color, 0, 0);
```
```

--------------------------------

### Start QEMU in GDB stub mode for i386-pc

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Starts a QEMU instance booting from disk.img, pausing at start to wait for a GDB connection. Use -S to pause and -s to enable GDB stub. Replace disk.img with an appropriate disk image; a block device may require privileged user.

```bash
qemu-system-i386 -drive file=disk.img,format=raw \
    -device virtio-scsi-pci,id=scsi0 -S -s

```

--------------------------------

### Example of setting up console viewport

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Queries the existing viewport, fills the background, sets a console viewport with a 10-pixel margin, fills it, and draws a glyph. Uses grub_video_map_color, grub_video_fill_rect, grub_video_set_viewport, grub_font_get_glyph, and grub_video_blit_glyph.

```c
grub_uint32_t x, y, width, height;
grub_video_color_t color;
struct grub_font_glyph glyph;
grub_err_t rc;
/* Query existing viewport.  */
grub_video_get_viewport (&x, &y, &width, &height);
/* Fill background.  */
color = grub_video_map_color (GRUB_COLOR_BACKGROUND);
grub_video_fill_rect (color, 0, 0, width, height);
/* Setup console viewport.  */
grub_video_set_viewport (x + 10, y + 10, width - 20, height - 20);
grub_video_get_viewport (&x, &y, &width, &height);
color = grub_video_map_color (GRUB_COLOR_CONSOLE_BACKGROUND);
grub_video_fill_rect (color, 0, 0, width, height);
/* Draw text to viewport.  */
color = grub_video_map_color (GRUB_COLOR_CONSOLE_TEXT);
grub_font_get_glyph ('X', &glyph);
grub_video_blit_glyph (&glyph, color, 0, 0);

```

--------------------------------

### x86 assembly startup code for BSS cleaning and setup

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

This assembly code is the first stage of a bootloader port, handling BSS cleaning and other setup before calling main. It is shown for illustration purposes and is intended to be placed in grub-core/kern/$cpu/$platform/startup.S.

```x86 assembly
        .globl _start
_start:
	movl	$_bss_start, %edi
	movl	$_end, %ecx
	subl	%edi, %ecx
	xorl	%eax, %eax
	cld
	rep
	stosb
        call main

```

--------------------------------

### grub_video_setup

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Initializes the video subsystem with the specified width, height, and mode type, selecting the best matching video mode.

```APIDOC
## grub_video_setup

### Description
Initializes the video subsystem with the specified width, height, and mode type, selecting the best matching video mode.

### Prototype
```c
grub_err_t
grub_video_setup (unsigned int width, unsigned int height, unsigned int mode_type);
```

### Parameters
- **width** (unsigned int) - Required - Desired width of the video mode.
- **height** (unsigned int) - Required - Desired height of the video mode.
- **mode_type** (unsigned int) - Required - Type of video mode: `GRUB_VIDEO_MODE_TYPE_INDEX_COLOR`, `GRUB_VIDEO_MODE_TYPE_RGB`, or `GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED`.

### Description Details
- If all parameters are zero, the video adapter will attempt to select the best possible mode.
- For RGB modes, the highest bits per pixel mode is selected.
- For Index Color modes, the mode with the highest number of colors is selected.
- On success, the active rendering target is set to screen and the viewport is maximized.
- In RGB modes, an emulated palette with 16 default VGA entries is set; other colors are black.
- In Indexed Color mode, the driver may set the default VGA palette if supported.

### Return Value
- `GRUB_ERR_NONE` on success.
- An error code if no matching mode is found.
```

--------------------------------

### configure.ac: Add AM_CONDITIONAL for new platform

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

This block shows how to add a conditional for a new platform using AM_CONDITIONAL. The example shows existing conditionals for mips_arc, sparc64_ieee1275, and powerpc_ieee1275.

```shell
AM_CONDITIONAL([COND_mips_arc], [test x$target_cpu = xmips -a x$platform = xarc])
AM_CONDITIONAL([COND_sparc64_ieee1275], [test x$target_cpu = xsparc64 -a x$platform = xieee1275])
AM_CONDITIONAL([COND_powerpc_ieee1275], [test x$target_cpu = xpowerpc -a x$platform = xieee1275])

```

--------------------------------

### Build GRUB for a new platform

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Run bootstrap, then configure with target CPU and platform, setting TARGET_CC, OBJCOPY, and STRIP as needed. Redirect make output to /dev/null to suppress noise.

```shell
./bootstrap
./configure --target=$cpu --with-platform=$platform TARGET_CC=.. OBJCOPY=... STRIP=...
make > /dev/null

```

--------------------------------

### Test GRUB modules with grub-mkimage

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Create a test image that includes the 'hello' module to verify module loading works after porting.

```shell
./grub-mkimage -d grub-core -O $format_id -o test.img hello

```

--------------------------------

### Run GDB with gdb_grub script

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Launches GDB using the gdb_grub script, which automatically connects to the QEMU instance. Assumes /path/to/script is the directory containing the script and debug symbol files. The script handles module symbol loading at runtime.

```bash
cd $(dirname /path/to/script/gdb_grub)
gdb -x gdb_grub

```

--------------------------------

### Create a GRUB image with grub-mkimage

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Generate a test image using the platform's format ID. The -d option points to the grub-core directory and -o specifies the output file.

```shell
./grub-mkimage -d grub-core -O $format_id -o test.img

```

--------------------------------

### configure.ac: List of supported platforms

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

This case statement lists the supported platforms. Add your platform to this list to enable it.

```shell
case "$target_cpu"-"$platform" in
  i386-efi) ;;
  x86_64-efi) ;;
  i386-pc) ;;
  i386-multiboot) ;;
  i386-coreboot) ;;
  ...
esac

```

--------------------------------

### C code for 'Hello, world' bootloader

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

This C code is the main part of the initial bootloader, printing a message and then looping forever. It is intended to be placed in grub-core/kern/$cpu/$platform/init.c with the entry point renamed to grub_machine_init.

```C
static const char msg[] = "Hello, world";

void
putchar (int c)
{
  ...
}

void
main (void)
{
  const char *ptr = msg;
  while (*ptr)
    putchar (*ptr++);
  while (1);
}

```

--------------------------------

### GRUB repository web access URL

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Web access to the GRUB repository is available at this URL.

```text
https://gitlab.freedesktop.org/gnu-grub/grub/
```

--------------------------------

### Load GRUB2 symbols with GDB before execution

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Use this command to load GRUB2 symbols before execution, assuming QEMU is waiting for a debugger connection and the current directory contains gdb_grub. Replace 'address of .text section' with the actual load address obtained from prior runs.

```bash
gdb -x gdb_grub -ex 'dynamic_load_symbols address of .text section'

```

--------------------------------

### grub_video_set_active_render_target prototype

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Prototype for setting the active render target. All drawing commands go to the specified target. Special values include GRUB_VIDEO_RENDER_TARGET_DISPLAY, GRUB_VIDEO_RENDER_TARGET_FRONT_BUFFER (alias), and GRUB_VIDEO_RENDER_TARGET_BACK_BUFFER. Returns GRUB_ERR_NONE on success.

```c
grub_err_t
grub_video_set_active_render_target (struct grub_video_render_target *target);

```

--------------------------------

### grub_video_create_render_target

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Creates a render target with specified dimensions and mode type.

```APIDOC
## grub_video_create_render_target

### Description
Driver will use information provided to it to create best fitting render target. `mode_type` will be used to guide on selecting what features are wanted for render target. Supported values for `mode_type` are `GRUB_VIDEO_MODE_TYPE_INDEX_COLOR` for index color modes, `GRUB_VIDEO_MODE_TYPE_RGB` for direct RGB color modes and `GRUB_VIDEO_MODE_TYPE_ALPHA` for alpha component.

### Prototype
```c
grub_err_t
grub_video_create_render_target (struct grub_video_render_target **result, unsigned int width, unsigned int height, unsigned int mode_type);
```

### Parameters
- **result** (struct grub_video_render_target **) - Required - Pointer to a pointer where the created render target will be stored.
- **width** (unsigned int) - Required - The width of the render target.
- **height** (unsigned int) - Required - The height of the render target.
- **mode_type** (unsigned int) - Required - Bitmask specifying desired features. Supported values: `GRUB_VIDEO_MODE_TYPE_INDEX_COLOR`, `GRUB_VIDEO_MODE_TYPE_RGB`, `GRUB_VIDEO_MODE_TYPE_ALPHA`.

### Returns
grub_err_t - Error code indicating success or failure.
```

--------------------------------

### Using the error stack with grub_error_push and grub_error_pop

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Shows how to save and restore the error state using the error stack. Push before calling functions that might fail, and pop after handling the error to restore the previous state. The stack is protected against overflow, and overflow messages are shown when the prompt is drawn.

```c
/* Save possible old error message.  */
grub_error_push ();

/* Do your stuff here.  */
call_possibly_failing_function ();

if (grub_errno != GRUB_ERR_NONE)
  {
    /* Inform rest of the code that there is error (grub_errno
       is set). There is no pop here as we want both error states 
       to be displayed.  */
    return;
  }

/* Restore old error state by popping previous item from stack. */
grub_error_pop ();

```

--------------------------------

### configure.ac: Platform guessing from CPU and vendor

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

This case statement guesses the platform from the CPU and vendor when with_platform is not set. It is part of the porting process.

```shell
if test "x$with_platform" = x; then
  case "$target_cpu"-"$target_vendor" in
    i386-apple) platform=efi ;;
    i386-*) platform=pc ;;
    x86_64-apple) platform=efi ;;
    x86_64-*) platform=pc ;;
    powerpc-*) platform=ieee1275 ;;
    ...
  esac
else
  ...
fi

```

--------------------------------

### grub_video_bitmap_create

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Creates a new bitmap with given dimensions and blitting format. The allocated bitmap data can then be modified freely and finally blitted with grub_video_blit_bitmap to the rendering target.

```APIDOC
## grub_video_bitmap_create

### Description
Creates a new bitmap with given dimensions and blitting format. Allocated bitmap data can then be modified freely and finally blitted with `grub_video_blit_bitmap` to rendering target.

### Prototype
```c
grub_err_t grub_video_bitmap_create (struct grub_video_bitmap **bitmap, unsigned int width, unsigned int height, enum grub_video_blit_format blit_format)
```

### Parameters
- **bitmap** (struct grub_video_bitmap **) - Output parameter that will point to the newly created bitmap.
- **width** (unsigned int) - Width of the bitmap in pixels.
- **height** (unsigned int) - Height of the bitmap in pixels.
- **blit_format** (enum grub_video_blit_format) - The blitting format for the bitmap.

### Returns
- **grub_err_t** - Return code indicating success or error.
```

--------------------------------

### grub_video_bitmap_get_mode_info

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Returns the bitmap format details in the form of a grub_video_mode_info structure.

```APIDOC
## grub_video_bitmap_get_mode_info

### Description
Returns bitmap format details in form of `grub_video_mode_info`.

### Prototype
```c
void grub_video_bitmap_get_mode_info (struct grub_video_bitmap *bitmap, struct grub_video_mode_info *mode_info);
```

### Parameters
- **bitmap** (struct grub_video_bitmap *) - Pointer to the bitmap.
- **mode_info** (struct grub_video_mode_info *) - Output parameter that will receive the mode information.

### Returns
- **void** - This function does not return a value.
```

--------------------------------

### Run QEMU with debug OVMF to capture GRUB2 load address

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Use this QEMU command to run a debug build of OVMF and write debug messages to debug.log. The log will contain a line like 'Loading driver at 0x00006AEE000 EntryPoint=0x00006AEE756' that reveals the GRUB2 load address.

```bash
qemu-system-x86_64 -bios /path/to/debug/OVMF.fd \
    -drive file=disk.img,format=raw \
    -device virtio-scsi-pci,id=scsi0 \
    -debugcon file:debug.log -global isa-debugcon.iobase=0x402
```

--------------------------------

### Zeroing grub_errno to continue probing

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Shows how to reset grub_errno to GRUB_ERR_NONE after handling an error, allowing continued processing. Use this when you want to ignore a non-fatal error and try an alternative.

```c
grub_err_t
probe_example ()
{
  /* Try to probe device type 1.  */
  probe_for_device ();
  if (grub_errno == GRUB_ERR_NONE)
    {
      /* Device type 1 was found on system.  */
      register_device ();
      return GRUB_ERR_NONE;
    }
  /* Zero out error code.  */
  grub_errno = GRUB_ERR_NONE;

  /* No device type 1 found, try to probe device type 2.  */
  probe_for_device2 ();
  if (grub_errno == GRUB_ERR_NONE)
    {
      /* Device type 2 was found on system.  */
      register_device2 ();
      return GRUB_ERR_NONE;
    }
  /* Zero out error code.  */
  grub_errno = GRUB_ERR_NONE;

  /* Return custom error message.  */
  return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "No device type 1 or 2 found.");
}

```

--------------------------------

### grub_video_map_rgb

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Maps RGB values to compatible screen color data.

```APIDOC
## grub_video_map_rgb

### Description
Maps RGB values to compatible screen color data. Values are expected in range 0-255. In RGB modes they are converted to screen color data. In index color modes, the index color palette is searched for the specified color and the index is returned.

### Prototype
```c
grub_video_color_t
grub_video_map_rgb (grub_uint8_t red, grub_uint8_t green, grub_uint8_t blue);
```

### Parameters
- **red** (grub_uint8_t) - Required - Red component (0-255).
- **green** (grub_uint8_t) - Required - Green component (0-255).
- **blue** (grub_uint8_t) - Required - Blue component (0-255).

### Returns
- **grub_video_color_t** - The mapped screen color data.

```

--------------------------------

### Forwarding exceptions with grub_errno

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Shows how to forward an exception to the caller by checking grub_errno and returning it if not GRUB_ERR_NONE. Use this pattern when a function cannot handle an error itself.

```c
grub_err_t
forwarding_example (void)
{
  /* Call function that might cause exception.  */
  foobar ();

  /* No special exception handler, just forward possible exceptions.  */
  if (grub_errno != GRUB_ERR_NONE)
    {
      return grub_errno;
    }

  /* All is OK, do more processing.  */

  /* Return OK signal, to caller.  */
  return GRUB_ERR_NONE;
}

```

--------------------------------

### grub_video_get_info

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Queries the properties of the active rendering target, filling the provided mode_info structure with the current video mode details. Returns GRUB_ERR_BAD_DEVICE if no video driver is active, otherwise GRUB_ERR_NONE.

```APIDOC
## grub_video_get_info

### Description
Queries the properties of the active rendering target, filling the provided mode_info structure with the current video mode details. Returns GRUB_ERR_BAD_DEVICE if no video driver is active, otherwise GRUB_ERR_NONE.

### Prototype
```c
grub_err_t
grub_video_get_info (struct grub_video_mode_info *mode_info);
```

### Parameters
- **mode_info** (struct grub_video_mode_info *) - Required - Pointer to a structure that will be filled with the video mode information.

### Return Value
- **grub_err_t** - GRUB_ERR_NONE on success, GRUB_ERR_BAD_DEVICE if no active video driver.

### Data Structure
```c
struct grub_video_mode_info
{
  unsigned int width;              /* Width of the screen. */
  unsigned int height;             /* Height of the screen. */
  unsigned int mode_type;          /* Mode type bitmask. */
  unsigned int bpp;                /* Bits per pixel. */
  unsigned int bytes_per_pixel;    /* Bytes per pixel. */
  unsigned int pitch;              /* Pitch of one scanline. */
  unsigned int number_of_colors;   /* Number of colors. */
  enum grub_video_blit_format blit_format; /* Optimization hint. */
  unsigned int red_mask_size;      /* Bits reserved for red. */
  unsigned int red_field_pos;      /* Location of red bits. */
  unsigned int green_mask_size;    /* Bits reserved for green. */
  unsigned int green_field_pos;    /* Location of green bits. */
  unsigned int blue_mask_size;     /* Bits reserved for blue. */
  unsigned int blue_field_pos;     /* Location of blue bits. */
  unsigned int reserved_mask_size; /* Bits reserved in color. */
  unsigned int reserved_field_pos; /* Location of reserved bits. */
};
```
```

--------------------------------

### grub_video_get_active_render_target prototype

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Prototype for retrieving the currently active render target. The returned target can be passed back to grub_video_set_active_render_target.

```c
grub_err_t
grub_video_get_active_render_target (struct grub_video_render_target **target);

```

--------------------------------

### grub_video_delete_render_target prototype

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Prototype for deleting a previously created render target. Passing NULL does nothing; returns GRUB_ERR_NONE on success.

```c
grub_err_t
grub_video_delete_render_target (struct grub_video_render_target *target);

```

--------------------------------

### grub_video_bitmap_load

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Loads a bitmap from a file using registered bitmap loaders. Returns an error if the format is not recognized or supported.

```APIDOC
## grub_video_bitmap_load

### Description
Tries to load given bitmap (`filename`) using registered bitmap loaders. In case bitmap format is not recognized or supported error `GRUB_ERR_BAD_FILE_TYPE` is returned.

### Prototype
```c
grub_err_t grub_video_bitmap_load (struct grub_video_bitmap **bitmap, const char *filename);
```

### Parameters
- **bitmap** (struct grub_video_bitmap **) - Output parameter that will point to the loaded bitmap.
- **filename** (const char *) - Path to the bitmap file to load.

### Returns
- **grub_err_t** - Return code indicating success or error. Returns `GRUB_ERR_BAD_FILE_TYPE` if the format is not recognized or supported.
```

--------------------------------

### grub_video_map_rgba

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Maps RGBA values to compatible screen color data.

```APIDOC
## grub_video_map_rgba

### Description
Maps RGBA values to compatible screen color data. Values are expected in range 0-255. In RGBA modes they are converted to screen color data. In index color modes, the index color palette is searched for the best matching color and its index is returned.

### Prototype
```c
grub_video_color_t
grub_video_map_rgba (grub_uint8_t red, grub_uint8_t green, grub_uint8_t blue, grub_uint8_t alpha);
```

### Parameters
- **red** (grub_uint8_t) - Required - Red component (0-255).
- **green** (grub_uint8_t) - Required - Green component (0-255).
- **blue** (grub_uint8_t) - Required - Blue component (0-255).
- **alpha** (grub_uint8_t) - Required - Alpha component (0-255).

### Returns
- **grub_video_color_t** - The mapped screen color data.

```

--------------------------------

### grub_video_blit_bitmap

Source: https://www.gnu.org/software/grub/manual/grub-dev/grub-dev.html

Blits a bitmap to the viewport at specified coordinates with optional clipping and blending.

```APIDOC
## grub_video_blit_bitmap

### Description
Used to blit bitmap to viewport in specified coordinates. If part of bitmap is outside of viewport region, it will be clipped out. Offsets affect bitmap position where data will be copied from. Negative values for both viewport coordinates and bitmap offset coordinates are allowed. If data is looked out of bounds of bitmap, color value will be assumed to be transparent. If viewport coordinates are negative, area of the blitted rectangle will be shrinken to follow size limits of the viewport and bitmap. Blitting operator `oper` specifies should source pixel replace data in screen or blend with pixel alpha value. Software developer should use `grub_video_bitmap_create` or `grub_video_bitmap_load` to create or load bitmap data.

### Prototype
```c
grub_err_t
grub_video_blit_bitmap (struct grub_video_bitmap *bitmap, enum grub_video_blit_operators oper, int x, int y, int offset_x, int offset_y, unsigned int width, unsigned int height);
```

### Parameters
- **bitmap** (struct grub_video_bitmap *) - Required - Pointer to the bitmap to blit.
- **oper** (enum grub_video_blit_operators) - Required - Blitting operator: `GRUB_VIDEO_BLIT_REPLACE` or `GRUB_VIDEO_BLIT_BLEND`.
- **x** (int) - Required - The x-coordinate of the top-left corner of the destination rectangle.
- **y** (int) - Required - The y-coordinate of the top-left corner of the destination rectangle.
- **offset_x** (int) - Required - The x-offset into the bitmap from which to start copying.
- **offset_y** (int) - Required - The y-offset into the bitmap from which to start copying.
- **width** (unsigned int) - Required - The width of the region to blit.
- **height** (unsigned int) - Required - The height of the region to blit.

### Returns
grub_err_t - Error code indicating success or failure.
```
Tokens:
Raw