2004-04-04 Yoshinori K. Okuji <okuji@enbug.org>
All symbols prefixed with PUPA_ and pupa_ are renamed to GRUB_ and grub_, respectively. Because the conversion is trivial and mechanical, I omit the details here. Please refer to the CVS if you need more information.
This commit is contained in:
okuji
parent
6a1425510d
commit
4b13b216f4
125 changed files with 6198 additions and 6181 deletions
132
kern/fs.c
132
kern/fs.c
|
|
@ -1,9 +1,9 @@
|
|||
/* fs.c - filesystem manager */
|
||||
/*
|
||||
* PUPA -- Preliminary Universal Programming Architecture for GRUB
|
||||
* GRUB -- GRand Unified Bootloader
|
||||
* Copyright (C) 2002 Free Software Foundation, Inc.
|
||||
*
|
||||
* PUPA is free software; you can redistribute it and/or modify
|
||||
* GRUB is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
|
|
@ -14,35 +14,35 @@
|
|||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with PUPA; if not, write to the Free Software
|
||||
* along with GRUB; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <pupa/disk.h>
|
||||
#include <pupa/net.h>
|
||||
#include <pupa/fs.h>
|
||||
#include <pupa/file.h>
|
||||
#include <pupa/err.h>
|
||||
#include <pupa/misc.h>
|
||||
#include <pupa/types.h>
|
||||
#include <pupa/mm.h>
|
||||
#include <pupa/term.h>
|
||||
#include <grub/disk.h>
|
||||
#include <grub/net.h>
|
||||
#include <grub/fs.h>
|
||||
#include <grub/file.h>
|
||||
#include <grub/err.h>
|
||||
#include <grub/misc.h>
|
||||
#include <grub/types.h>
|
||||
#include <grub/mm.h>
|
||||
#include <grub/term.h>
|
||||
|
||||
static pupa_fs_t pupa_fs_list;
|
||||
static grub_fs_t grub_fs_list;
|
||||
|
||||
void
|
||||
pupa_fs_register (pupa_fs_t fs)
|
||||
grub_fs_register (grub_fs_t fs)
|
||||
{
|
||||
fs->next = pupa_fs_list;
|
||||
pupa_fs_list = fs;
|
||||
fs->next = grub_fs_list;
|
||||
grub_fs_list = fs;
|
||||
}
|
||||
|
||||
void
|
||||
pupa_fs_unregister (pupa_fs_t fs)
|
||||
grub_fs_unregister (grub_fs_t fs)
|
||||
{
|
||||
pupa_fs_t *p, q;
|
||||
grub_fs_t *p, q;
|
||||
|
||||
for (p = &pupa_fs_list, q = *p; q; p = &(q->next), q = q->next)
|
||||
for (p = &grub_fs_list, q = *p; q; p = &(q->next), q = q->next)
|
||||
if (q == fs)
|
||||
{
|
||||
*p = q->next;
|
||||
|
|
@ -51,19 +51,19 @@ pupa_fs_unregister (pupa_fs_t fs)
|
|||
}
|
||||
|
||||
void
|
||||
pupa_fs_iterate (int (*hook) (const pupa_fs_t fs))
|
||||
grub_fs_iterate (int (*hook) (const grub_fs_t fs))
|
||||
{
|
||||
pupa_fs_t p;
|
||||
grub_fs_t p;
|
||||
|
||||
for (p = pupa_fs_list; p; p = p->next)
|
||||
for (p = grub_fs_list; p; p = p->next)
|
||||
if (hook (p))
|
||||
break;
|
||||
}
|
||||
|
||||
pupa_fs_t
|
||||
pupa_fs_probe (pupa_device_t device)
|
||||
grub_fs_t
|
||||
grub_fs_probe (grub_device_t device)
|
||||
{
|
||||
pupa_fs_t p;
|
||||
grub_fs_t p;
|
||||
auto int dummy_func (const char *filename, int dir);
|
||||
|
||||
int dummy_func (const char *filename __attribute__ ((unused)),
|
||||
|
|
@ -74,22 +74,22 @@ pupa_fs_probe (pupa_device_t device)
|
|||
|
||||
if (device->disk)
|
||||
{
|
||||
for (p = pupa_fs_list; p; p = p->next)
|
||||
for (p = grub_fs_list; p; p = p->next)
|
||||
{
|
||||
(p->dir) (device, "/", dummy_func);
|
||||
if (pupa_errno == PUPA_ERR_NONE)
|
||||
if (grub_errno == GRUB_ERR_NONE)
|
||||
return p;
|
||||
|
||||
if (pupa_errno != PUPA_ERR_BAD_FS)
|
||||
if (grub_errno != GRUB_ERR_BAD_FS)
|
||||
return 0;
|
||||
|
||||
pupa_errno = PUPA_ERR_NONE;
|
||||
grub_errno = GRUB_ERR_NONE;
|
||||
}
|
||||
}
|
||||
else if (device->net->fs)
|
||||
return device->net->fs;
|
||||
|
||||
pupa_error (PUPA_ERR_UNKNOWN_FS, "unknown filesystem");
|
||||
grub_error (GRUB_ERR_UNKNOWN_FS, "unknown filesystem");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -97,31 +97,31 @@ pupa_fs_probe (pupa_device_t device)
|
|||
|
||||
/* Block list support routines. */
|
||||
|
||||
struct pupa_fs_block
|
||||
struct grub_fs_block
|
||||
{
|
||||
unsigned long offset;
|
||||
unsigned long length;
|
||||
};
|
||||
|
||||
static pupa_err_t
|
||||
pupa_fs_blocklist_open (pupa_file_t file, const char *name)
|
||||
static grub_err_t
|
||||
grub_fs_blocklist_open (grub_file_t file, const char *name)
|
||||
{
|
||||
char *p = (char *) name;
|
||||
unsigned num = 0;
|
||||
unsigned i;
|
||||
pupa_disk_t disk = file->device->disk;
|
||||
struct pupa_fs_block *blocks;
|
||||
grub_disk_t disk = file->device->disk;
|
||||
struct grub_fs_block *blocks;
|
||||
|
||||
/* First, count the number of blocks. */
|
||||
do
|
||||
{
|
||||
num++;
|
||||
p = pupa_strchr (p, ',');
|
||||
p = grub_strchr (p, ',');
|
||||
}
|
||||
while (p);
|
||||
|
||||
/* Allocate a block list. */
|
||||
blocks = pupa_malloc (sizeof (struct pupa_fs_block) * (num + 1));
|
||||
blocks = grub_malloc (sizeof (struct grub_fs_block) * (num + 1));
|
||||
if (! blocks)
|
||||
return 0;
|
||||
|
||||
|
|
@ -131,10 +131,10 @@ pupa_fs_blocklist_open (pupa_file_t file, const char *name)
|
|||
{
|
||||
if (*p != '+')
|
||||
{
|
||||
blocks[i].offset = pupa_strtoul (p, &p, 0);
|
||||
if (pupa_errno != PUPA_ERR_NONE || *p != '+')
|
||||
blocks[i].offset = grub_strtoul (p, &p, 0);
|
||||
if (grub_errno != GRUB_ERR_NONE || *p != '+')
|
||||
{
|
||||
pupa_error (PUPA_ERR_BAD_FILENAME,
|
||||
grub_error (GRUB_ERR_BAD_FILENAME,
|
||||
"invalid file name `%s'", name);
|
||||
goto fail;
|
||||
}
|
||||
|
|
@ -143,68 +143,68 @@ pupa_fs_blocklist_open (pupa_file_t file, const char *name)
|
|||
blocks[i].offset = 0;
|
||||
|
||||
p++;
|
||||
blocks[i].length = pupa_strtoul (p, &p, 0);
|
||||
if (pupa_errno != PUPA_ERR_NONE
|
||||
blocks[i].length = grub_strtoul (p, &p, 0);
|
||||
if (grub_errno != GRUB_ERR_NONE
|
||||
|| blocks[i].length == 0
|
||||
|| (*p && *p != ',' && ! pupa_isspace (*p)))
|
||||
|| (*p && *p != ',' && ! grub_isspace (*p)))
|
||||
{
|
||||
pupa_error (PUPA_ERR_BAD_FILENAME,
|
||||
grub_error (GRUB_ERR_BAD_FILENAME,
|
||||
"invalid file name `%s'", name);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (disk->total_sectors < blocks[i].offset + blocks[i].length)
|
||||
{
|
||||
pupa_error (PUPA_ERR_BAD_FILENAME, "beyond the total sectors");
|
||||
grub_error (GRUB_ERR_BAD_FILENAME, "beyond the total sectors");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
file->size += (blocks[i].length << PUPA_DISK_SECTOR_BITS);
|
||||
file->size += (blocks[i].length << GRUB_DISK_SECTOR_BITS);
|
||||
p++;
|
||||
}
|
||||
|
||||
blocks[i].length = 0;
|
||||
file->data = blocks;
|
||||
|
||||
return PUPA_ERR_NONE;
|
||||
return GRUB_ERR_NONE;
|
||||
|
||||
fail:
|
||||
pupa_free (blocks);
|
||||
return pupa_errno;
|
||||
grub_free (blocks);
|
||||
return grub_errno;
|
||||
}
|
||||
|
||||
static pupa_ssize_t
|
||||
pupa_fs_blocklist_read (pupa_file_t file, char *buf, pupa_ssize_t len)
|
||||
static grub_ssize_t
|
||||
grub_fs_blocklist_read (grub_file_t file, char *buf, grub_ssize_t len)
|
||||
{
|
||||
struct pupa_fs_block *p;
|
||||
struct grub_fs_block *p;
|
||||
unsigned long sector;
|
||||
unsigned long offset;
|
||||
pupa_ssize_t ret = 0;
|
||||
grub_ssize_t ret = 0;
|
||||
|
||||
if (len > file->size - file->offset)
|
||||
len = file->size - file->offset;
|
||||
|
||||
sector = (file->offset >> PUPA_DISK_SECTOR_BITS);
|
||||
offset = (file->offset & (PUPA_DISK_SECTOR_SIZE - 1));
|
||||
sector = (file->offset >> GRUB_DISK_SECTOR_BITS);
|
||||
offset = (file->offset & (GRUB_DISK_SECTOR_SIZE - 1));
|
||||
for (p = file->data; p->length && len > 0; p++)
|
||||
{
|
||||
if (sector < p->length)
|
||||
{
|
||||
pupa_ssize_t size;
|
||||
grub_ssize_t size;
|
||||
|
||||
size = len;
|
||||
if (((size + offset + PUPA_DISK_SECTOR_SIZE - 1)
|
||||
>> PUPA_DISK_SECTOR_BITS) > p->length - sector)
|
||||
size = ((p->length - sector) << PUPA_DISK_SECTOR_BITS) - offset;
|
||||
if (((size + offset + GRUB_DISK_SECTOR_SIZE - 1)
|
||||
>> GRUB_DISK_SECTOR_BITS) > p->length - sector)
|
||||
size = ((p->length - sector) << GRUB_DISK_SECTOR_BITS) - offset;
|
||||
|
||||
if (pupa_disk_read (file->device->disk, p->offset + sector, offset,
|
||||
size, buf) != PUPA_ERR_NONE)
|
||||
if (grub_disk_read (file->device->disk, p->offset + sector, offset,
|
||||
size, buf) != GRUB_ERR_NONE)
|
||||
return -1;
|
||||
|
||||
ret += size;
|
||||
len -= size;
|
||||
sector -= ((size + offset) >> PUPA_DISK_SECTOR_BITS);
|
||||
offset = ((size + offset) & (PUPA_DISK_SECTOR_SIZE - 1));
|
||||
sector -= ((size + offset) >> GRUB_DISK_SECTOR_BITS);
|
||||
offset = ((size + offset) & (GRUB_DISK_SECTOR_SIZE - 1));
|
||||
}
|
||||
else
|
||||
sector -= p->length;
|
||||
|
|
@ -213,12 +213,12 @@ pupa_fs_blocklist_read (pupa_file_t file, char *buf, pupa_ssize_t len)
|
|||
return ret;
|
||||
}
|
||||
|
||||
struct pupa_fs pupa_fs_blocklist =
|
||||
struct grub_fs grub_fs_blocklist =
|
||||
{
|
||||
.name = "blocklist",
|
||||
.dir = 0,
|
||||
.open = pupa_fs_blocklist_open,
|
||||
.read = pupa_fs_blocklist_read,
|
||||
.open = grub_fs_blocklist_open,
|
||||
.read = grub_fs_blocklist_read,
|
||||
.close = 0,
|
||||
.next = 0
|
||||
};
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue