From: Clemens Helfmeier <clemens@helfmeier.de>
To: grub-devel@gnu.org
Subject: Patch for different sector sizes
Date: Wed, 8 Oct 2008 00:30:57 +0200 [thread overview]
Message-ID: <20081007223057.GD413@helfmeier.de> (raw)
[-- Attachment #1: Type: text/plain, Size: 387 bytes --]
Hey Guys,
this seems to be a tough topic ;-)
At Least i have fixed a few lines of code today, it compiles not yet in total,
but i hope the task can be completed in a few more hours of work. I guess a few
things will still be broken after completion, i didn't yet test anything.
Maybe this is even too bad to be done? what do you think?
Path Attached, please comment!
bye,
sumsum
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: variable_sector_size.patch --]
[-- Type: text/x-diff; charset=unknown-8bit, Size: 65527 bytes --]
Index: disk/lvm.c
===================================================================
--- disk/lvm.c (revision 1886)
+++ disk/lvm.c (working copy)
@@ -185,7 +185,7 @@
read from. */
if (pv->disk)
err = grub_disk_read (pv->disk, offset, 0,
- size << GRUB_DISK_SECTOR_BITS, buf);
+ size * pv->disk->sector_size, buf);
else
err = grub_error (GRUB_ERR_UNKNOWN_DEVICE,
"Physical volume %s not found", pv->name);
Index: disk/scsi.c
===================================================================
--- disk/scsi.c (revision 1886)
+++ disk/scsi.c (working copy)
@@ -294,7 +294,7 @@
/* SCSI blocks can be something else than 512, although GRUB
wants 512 byte blocks. */
disk->total_sectors = ((scsi->size * scsi->blocksize)
- << GRUB_DISK_SECTOR_BITS);
+ * disk->sector_size);
grub_dprintf ("scsi", "capacity=%llu, blksize=%d\n",
disk->total_sectors, scsi->blocksize);
@@ -325,7 +325,7 @@
/* SCSI sectors are variable in size. GRUB uses 512 byte
sectors. */
- sector = grub_divmod64 (sector, scsi->blocksize >> GRUB_DISK_SECTOR_BITS,
+ sector = grub_divmod64 (sector, scsi->blocksize / disk->sector_size,
NULL);
/* Depending on the type, select a read function. */
Index: disk/ata.c
===================================================================
--- disk/ata.c (revision 1886)
+++ disk/ata.c (working copy)
@@ -77,6 +77,9 @@
GRUB_ATA_CMD_EXEC_DEV_DIAGNOSTICS = 0x90
};
+// TODO: Put the sector size into grub_ata_device
+#define GRUB_ATA_SECTOR_SIZE 512
+
struct grub_ata_device
{
/* IDE port to use. */
@@ -323,7 +326,7 @@
grub_uint16_t *info16;
int ataerr = 0;
- info = grub_malloc (GRUB_DISK_SECTOR_SIZE);
+ info = grub_malloc (GRUB_ATA_SECTOR_SIZE);
if (! info)
return grub_errno;
@@ -343,7 +346,7 @@
}
grub_ata_wait ();
- if (grub_ata_pio_read (dev, info, GRUB_DISK_SECTOR_SIZE))
+ if (grub_ata_pio_read (dev, info, GRUB_ATA_SECTOR_SIZE))
ataerr = grub_ata_regget (dev, GRUB_ATA_REG_ERROR);
if (ataerr & 4)
{
Index: disk/i386/pc/biosdisk.c
===================================================================
--- disk/i386/pc/biosdisk.c (revision 1886)
+++ disk/i386/pc/biosdisk.c (working copy)
@@ -196,8 +196,7 @@
struct grub_biosdisk_dap *dap;
dap = (struct grub_biosdisk_dap *) (GRUB_MEMORY_MACHINE_SCRATCH_ADDR
- + (data->sectors
- << GRUB_DISK_SECTOR_BITS));
+ + (data->sectors) * disk->sector_size);
dap->length = sizeof (*dap);
dap->reserved = 0;
dap->blocks = size;
@@ -305,8 +304,8 @@
return grub_errno;
grub_memcpy (buf, (void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR,
- len << GRUB_DISK_SECTOR_BITS);
- buf += len << GRUB_DISK_SECTOR_BITS;
+ len * disk->sector_size);
+ buf += len * disk->sector_size;
sector += len;
size -= len;
}
@@ -329,13 +328,13 @@
len = size;
grub_memcpy ((void *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR, buf,
- len << GRUB_DISK_SECTOR_BITS);
+ len * disk->sector_size);
if (grub_biosdisk_rw (GRUB_BIOSDISK_WRITE, disk, sector, len,
GRUB_MEMORY_MACHINE_SCRATCH_SEG))
return grub_errno;
- buf += len << GRUB_DISK_SECTOR_BITS;
+ buf += len * disk->sector_size;
sector += len;
size -= len;
}
Index: disk/raid.c
===================================================================
--- disk/raid.c (revision 1886)
+++ disk/raid.c (working copy)
@@ -240,6 +240,9 @@
if (read_size > size)
read_size = size;
+ // sector size for array (must be equal for all drives, not checked)
+ unsigned int sector_size = 0;
+
for (i = 0; i < near; i++)
{
unsigned int k;
@@ -249,13 +252,14 @@
{
if (array->device[k])
{
+ sector_size = array->device[k]->sector_size;
if (grub_errno == GRUB_ERR_READ_ERROR)
grub_errno = GRUB_ERR_NONE;
err = grub_disk_read (array->device[k],
read_sector + j * far_ofs + b,
0,
- read_size << GRUB_DISK_SECTOR_BITS,
+ read_size * sector_size,
buf);
if (! err)
break;
@@ -285,7 +289,7 @@
if (err)
return err;
- buf += read_size << GRUB_DISK_SECTOR_BITS;
+ buf += read_size * sector_size;
size -= read_size;
if (! size)
break;
@@ -366,7 +370,7 @@
err = grub_disk_read (array->device[disknr],
read_sector + b, 0,
- read_size << GRUB_DISK_SECTOR_BITS,
+ read_size * array->device[disknr]->sector_size,
buf);
if ((err) && (err != GRUB_ERR_READ_ERROR))
@@ -405,7 +409,7 @@
break;
}
- buf += read_size << GRUB_DISK_SECTOR_BITS;
+ buf += read_size * array->device[disknr]->sector_size;
size -= read_size;
if (! size)
break;
Index: disk/memdisk.c
===================================================================
--- disk/memdisk.c (revision 1886)
+++ disk/memdisk.c (working copy)
@@ -56,7 +56,7 @@
grub_memdisk_read (grub_disk_t disk __attribute((unused)), grub_disk_addr_t sector,
grub_size_t size, char *buf)
{
- grub_memcpy (buf, memdisk_addr + (sector << GRUB_DISK_SECTOR_BITS), size << GRUB_DISK_SECTOR_BITS);
+ grub_memcpy (buf, memdisk_addr + (sector * disk->sector_size), size * disk->sector_size);
return 0;
}
@@ -64,7 +64,7 @@
grub_memdisk_write (grub_disk_t disk __attribute((unused)), grub_disk_addr_t sector,
grub_size_t size, const char *buf)
{
- grub_memcpy (memdisk_addr + (sector << GRUB_DISK_SECTOR_BITS), buf, size << GRUB_DISK_SECTOR_BITS);
+ grub_memcpy (memdisk_addr + (sector * disk->sector_size), buf, size * disk->sector_size);
return 0;
}
Index: disk/raid5_recover.c
===================================================================
--- disk/raid5_recover.c (revision 1886)
+++ disk/raid5_recover.c (working copy)
@@ -31,7 +31,10 @@
char *buf2;
int i;
- size <<= GRUB_DISK_SECTOR_BITS;
+ if (array->device[0] == 0)
+ return grub_errno;
+
+ size *= array->device[0]->sector_size;
buf2 = grub_malloc (size);
if (!buf2)
return grub_errno;
Index: disk/loopback.c
===================================================================
--- disk/loopback.c (revision 1886)
+++ disk/loopback.c (working copy)
@@ -200,20 +200,20 @@
grub_file_t file = (grub_file_t) disk->data;
grub_off_t pos;
- grub_file_seek (file, sector << GRUB_DISK_SECTOR_BITS);
+ grub_file_seek (file, sector * disk->sector_size);
- grub_file_read (file, buf, size << GRUB_DISK_SECTOR_BITS);
+ grub_file_read (file, buf, size * disk->sector_size);
if (grub_errno)
return grub_errno;
/* In case there is more data read than there is available, in case
of files that are not a multiple of GRUB_DISK_SECTOR_SIZE, fill
the rest with zeros. */
- pos = (sector + size) << GRUB_DISK_SECTOR_BITS;
+ pos = (sector + size) * disk->sector_size;
if (pos > file->size)
{
grub_size_t amount = pos - file->size;
- grub_memset (buf + (size << GRUB_DISK_SECTOR_BITS) - amount, 0, amount);
+ grub_memset (buf + (size * disk->sector_size) - amount, 0, amount);
}
return 0;
Index: disk/raid6_recover.c
===================================================================
--- disk/raid6_recover.c (revision 1886)
+++ disk/raid6_recover.c (working copy)
@@ -95,7 +95,10 @@
int err[2], nerr;
char *pbuf = 0, *qbuf = 0;
- size <<= GRUB_DISK_SECTOR_BITS;
+ if (array->device[0] == 0)
+ goto quit;
+
+ size *= array->device[0]->sector_size;
pbuf = grub_malloc (size);
if (!pbuf)
goto quit;
Index: kern/fs.c
===================================================================
--- kern/fs.c (revision 1886)
+++ kern/fs.c (working copy)
@@ -198,7 +198,7 @@
goto fail;
}
- file->size += (blocks[i].length << GRUB_DISK_SECTOR_BITS);
+ file->size += (blocks[i].length * disk->sector_size);
p++;
}
@@ -212,6 +212,23 @@
return grub_errno;
}
+static grub_uint32_t
+grub_fs_log2 (grub_uint32_t x)
+{
+ grub_uint32_t i;
+
+ if (x == 0)
+ return -1;
+
+ for (i = 0; (x & 1) == 0; i++)
+ x >>= 1;
+
+ if (x != 1)
+ return -1;
+
+ return i;
+}
+
static grub_ssize_t
grub_fs_blocklist_read (grub_file_t file, char *buf, grub_size_t len)
{
@@ -219,12 +236,17 @@
grub_disk_addr_t sector;
grub_off_t offset;
grub_ssize_t ret = 0;
+ grub_disk_t disk = file->device->disk;
if (len > file->size - file->offset)
len = file->size - file->offset;
- sector = (file->offset >> GRUB_DISK_SECTOR_BITS);
- offset = (file->offset & (GRUB_DISK_SECTOR_SIZE - 1));
+// TODO: find something nice for those 64 bit divisions in here,
+// for now we will use a log2 based shifting approach.
+ grub_uint32_t sector_shift = grub_fs_log2( disk->sector_size );
+
+ sector = (file->offset >> sector_shift);
+ offset = (file->offset & (disk->sector_size - 1));
for (p = file->data; p->length && len > 0; p++)
{
if (sector < p->length)
@@ -232,9 +254,9 @@
grub_size_t size;
size = len;
- 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 (((size + offset + disk->sector_size - 1)
+ >> sector_shift) > p->length - sector)
+ size = ((p->length - sector) * disk->sector_size) - offset;
if (grub_disk_read (file->device->disk, p->offset + sector, offset,
size, buf) != GRUB_ERR_NONE)
@@ -242,8 +264,8 @@
ret += size;
len -= size;
- sector -= ((size + offset) >> GRUB_DISK_SECTOR_BITS);
- offset = ((size + offset) & (GRUB_DISK_SECTOR_SIZE - 1));
+ sector -= ((size + offset) >> sector_shift);
+ offset = ((size + offset) & (disk->sector_size - 1));
}
else
sector -= p->length;
Index: kern/rescue.c
===================================================================
--- kern/rescue.c (revision 1886)
+++ kern/rescue.c (working copy)
@@ -129,8 +129,9 @@
static void
grub_rescue_cmd_cat (int argc, char *argv[])
{
+#define CHUNK_SIZE 512
grub_file_t file;
- char buf[GRUB_DISK_SECTOR_SIZE];
+ char buf[CHUNK_SIZE];
grub_ssize_t size;
if (argc < 1)
Index: kern/disk.c
===================================================================
--- kern/disk.c (revision 1886)
+++ kern/disk.c (working copy)
@@ -148,25 +148,25 @@
}
static grub_err_t
-grub_disk_cache_store (unsigned long dev_id, unsigned long disk_id,
+grub_disk_cache_store (unsigned long dev_id, grub_disk_t disk,
grub_disk_addr_t sector, const char *data)
{
unsigned index;
struct grub_disk_cache *cache;
- grub_disk_cache_invalidate (dev_id, disk_id, sector);
+ grub_disk_cache_invalidate (dev_id, disk->id, sector);
- index = grub_disk_cache_get_index (dev_id, disk_id, sector);
+ index = grub_disk_cache_get_index (dev_id, disk->id, sector);
cache = grub_disk_cache_table + index;
- cache->data = grub_malloc (GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS);
+ cache->data = grub_malloc ( disk->sector_size << GRUB_DISK_CACHE_BITS);
if (! cache->data)
return grub_errno;
grub_memcpy (cache->data, data,
- GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS);
+ disk->sector_size << GRUB_DISK_CACHE_BITS);
cache->dev_id = dev_id;
- cache->disk_id = disk_id;
+ cache->disk_id = disk->id;
cache->sector = sector;
return GRUB_ERR_NONE;
@@ -330,8 +330,8 @@
grub_disk_adjust_range (grub_disk_t disk, grub_disk_addr_t *sector,
grub_off_t *offset, grub_size_t size)
{
- *sector += *offset >> GRUB_DISK_SECTOR_BITS;
- *offset &= GRUB_DISK_SECTOR_SIZE - 1;
+ *sector += *offset * disk->sector_size;
+ *offset &= disk->sector_size - 1;
if (disk->partition)
{
@@ -342,16 +342,16 @@
len = grub_partition_get_len (disk->partition);
if (*sector >= len
- || len - *sector < ((*offset + size + GRUB_DISK_SECTOR_SIZE - 1)
- >> GRUB_DISK_SECTOR_BITS))
+ || len - *sector < ((*offset + size + disk->sector_size - 1)
+ * disk->sector_size))
return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of partition");
*sector += start;
}
if (disk->total_sectors <= *sector
- || ((*offset + size + GRUB_DISK_SECTOR_SIZE - 1)
- >> GRUB_DISK_SECTOR_BITS) > disk->total_sectors - *sector)
+ || ((*offset + size + disk->sector_size - 1)
+ * disk->sector_size) > disk->total_sectors - *sector)
return grub_error (GRUB_ERR_OUT_OF_RANGE, "out of disk");
return GRUB_ERR_NONE;
@@ -380,7 +380,7 @@
real_offset = offset;
/* Allocate a temporary buffer. */
- tmp_buf = grub_malloc (GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS);
+ tmp_buf = grub_malloc (disk->sector_size << GRUB_DISK_CACHE_BITS);
if (! tmp_buf)
return grub_errno;
@@ -394,8 +394,8 @@
/* For reading bulk data. */
start_sector = sector & ~(GRUB_DISK_CACHE_SIZE - 1);
- pos = (sector - start_sector) << GRUB_DISK_SECTOR_BITS;
- len = ((GRUB_DISK_SECTOR_SIZE << GRUB_DISK_CACHE_BITS)
+ pos = (sector - start_sector) * disk->sector_size;
+ len = ((disk->sector_size << GRUB_DISK_CACHE_BITS)
- pos - real_offset);
if (len > size)
len = size;
@@ -421,10 +421,10 @@
grub_errno = GRUB_ERR_NONE;
- num = ((size + GRUB_DISK_SECTOR_SIZE - 1)
- >> GRUB_DISK_SECTOR_BITS);
+ num = ((size + disk->sector_size - 1)
+ / disk->sector_size);
- p = grub_realloc (tmp_buf, num << GRUB_DISK_SECTOR_BITS);
+ p = grub_realloc (tmp_buf, num * disk->sector_size);
if (!p)
goto finish;
@@ -445,11 +445,11 @@
while (size)
{
(disk->read_hook) (sector, real_offset,
- ((size > GRUB_DISK_SECTOR_SIZE)
- ? GRUB_DISK_SECTOR_SIZE
+ ((size > disk->sector_size)
+ ? disk->sector_size
: size));
sector++;
- size -= GRUB_DISK_SECTOR_SIZE - real_offset;
+ size -= disk->sector_size - real_offset;
real_offset = 0;
}
@@ -459,7 +459,7 @@
/* Copy it and store it in the disk cache. */
grub_memcpy (buf, tmp_buf + pos + real_offset, len);
- grub_disk_cache_store (disk->dev->id, disk->id,
+ grub_disk_cache_store (disk->dev->id, disk,
start_sector, tmp_buf);
}
@@ -472,15 +472,15 @@
while (l)
{
(disk->read_hook) (s, real_offset,
- ((l > GRUB_DISK_SECTOR_SIZE)
- ? GRUB_DISK_SECTOR_SIZE
+ ((l > disk->sector_size)
+ ? disk->sector_size
: l));
- if (l < GRUB_DISK_SECTOR_SIZE - real_offset)
+ if (l < disk->sector_size - real_offset)
break;
s++;
- l -= GRUB_DISK_SECTOR_SIZE - real_offset;
+ l -= disk->sector_size - real_offset;
real_offset = 0;
}
}
@@ -513,16 +513,16 @@
while (size)
{
- if (real_offset != 0 || (size < GRUB_DISK_SECTOR_SIZE && size != 0))
+ if (real_offset != 0 || (size < disk->sector_size && size != 0))
{
- char tmp_buf[GRUB_DISK_SECTOR_SIZE];
+ char tmp_buf[disk->sector_size];
grub_size_t len;
- if (grub_disk_read (disk, sector, 0, GRUB_DISK_SECTOR_SIZE, tmp_buf)
+ if (grub_disk_read (disk, sector, 0, disk->sector_size, tmp_buf)
!= GRUB_ERR_NONE)
goto finish;
- len = GRUB_DISK_SECTOR_SIZE - real_offset;
+ len = disk->sector_size - real_offset;
if (len > size)
len = size;
@@ -543,8 +543,8 @@
grub_size_t len;
grub_size_t n;
- len = size & ~(GRUB_DISK_SECTOR_SIZE - 1);
- n = size >> GRUB_DISK_SECTOR_BITS;
+ len = size & ~(disk->sector_size - 1);
+ n = size / disk->sector_size;
if ((disk->dev->write) (disk, sector, n, buf) != GRUB_ERR_NONE)
goto finish;
Index: fs/xfs.c
===================================================================
--- fs/xfs.c (revision 1886)
+++ fs/xfs.c (working copy)
@@ -188,6 +188,23 @@
#define GRUB_XFS_NEXT_DIRENT(pos,len) \
(pos) + GRUB_XFS_ROUND_TO_DIRENT (8 + 1 + len + 2)
\f
+static int
+xfs_log2 (unsigned x)
+{
+ int i;
+
+ if (x == 0)
+ return -1;
+
+ for (i = 0; (x & 1) == 0; i++)
+ x >>= 1;
+
+ if (x != 1)
+ return -1;
+
+ return i;
+}
+
static inline int
grub_xfs_inode_block (struct grub_xfs_data *data,
grub_uint64_t ino)
@@ -197,7 +214,7 @@
long long block;
block = (inoinag >> 4) + ag * data->agsize;
- block <<= (data->sblock.log2_bsize - GRUB_DISK_SECTOR_BITS);
+ block <<= (data->sblock.log2_bsize - data->disk->sector_size);
return block;
}
@@ -267,8 +284,7 @@
if (grub_disk_read (node->data->disk,
grub_be_to_cpu64 (keys[i - 1 + XFS_INODE_EXTENTS])
- << (node->data->sblock.log2_bsize
- - GRUB_DISK_SECTOR_BITS),
+ << (node->data->sblock.log2_bsize) / node->data->disk->sector_size,
0, node->data->sblock.bsize, (char *) leaf))
return 0;
@@ -333,8 +349,7 @@
return grub_fshelp_read_file (node->data->disk, node, read_hook,
pos, len, buf, grub_xfs_read_block,
grub_be_to_cpu64 (node->inode.size),
- node->data->sblock.log2_bsize
- - GRUB_DISK_SECTOR_BITS);
+ node->data->sblock.log2_bsize - xfs_log2 (node->data->disk->sector_size));
}
Index: fs/afs.c
===================================================================
--- fs/afs.c (revision 1886)
+++ fs/afs.c (working copy)
@@ -179,6 +179,23 @@
static grub_dl_t my_mod;
#endif
+static int
+afs_log2 (unsigned x)
+{
+ int i;
+
+ if (x == 0)
+ return -1;
+
+ for (i = 0; (x & 1) == 0; i++)
+ x >>= 1;
+
+ if (x != 1)
+ return -1;
+
+ return i;
+}
+
static grub_afs_off_t
grub_afs_run_to_num (struct grub_afs_sblock *sb,
struct grub_afs_blockrun *run)
@@ -193,7 +210,7 @@
{
return grub_disk_read (data->disk,
ino *
- (data->sblock.block_size >> GRUB_DISK_SECTOR_BITS),
+ (data->sblock.block_size / data->disk->sector_size),
0, sizeof (struct grub_afs_inode),
(char *) inode);
}
@@ -228,7 +245,7 @@
int j;
if (grub_disk_read (node->data->disk,
- blk * (sb->block_size >> GRUB_DISK_SECTOR_BITS),
+ blk * (sb->block_size / node->data->disk->sector_size),
0, sizeof (indir),
(char *) indir))
return 0;
@@ -264,14 +281,14 @@
if (grub_disk_read (node->data->disk,
(grub_afs_run_to_num (sb, &ds->double_indirect)
+ idblk) *
- (sb->block_size >> GRUB_DISK_SECTOR_BITS),
+ (sb->block_size / node->data->disk->sector_size),
0, sizeof (indir),
(char *) indir))
return 0;
if (grub_disk_read (node->data->disk,
(grub_afs_run_to_num (sb, &indir[idptr]) + dblk) *
- (sb->block_size >> GRUB_DISK_SECTOR_BITS),
+ (sb->block_size / node->data->disk->sector_size),
0, sizeof (indir),
(char *) indir))
return 0;
@@ -293,7 +310,7 @@
U64 (&node->data->sblock,
node->inode.stream.size),
node->data->sblock.block_shift
- - GRUB_DISK_SECTOR_BITS);
+ - afs_log2 (node->data->disk->sector_size));
}
static int
Index: fs/ntfs.c
===================================================================
--- fs/ntfs.c (revision 1886)
+++ fs/ntfs.c (working copy)
@@ -42,10 +42,10 @@
return grub_error (GRUB_ERR_BAD_FS, "%s label not found", magic);
ss = u16at (buf, 6) - 1;
- if (ss * (int) data->blocksize != len * GRUB_DISK_SECTOR_SIZE)
+ if (ss * (int) data->blocksize != len * data->disk->sector_size)
return grub_error (GRUB_ERR_BAD_FS, "Size not match",
ss * (int) data->blocksize,
- len * GRUB_DISK_SECTOR_SIZE);
+ len * data->disk->sector_size);
pu = buf + u16at (buf, 4);
us = u16at (pu, 0);
buf -= 2;
@@ -178,8 +178,8 @@
{
int n;
- n = ((u32at (pa, 0x30) + GRUB_DISK_SECTOR_SIZE - 1)
- & (~(GRUB_DISK_SECTOR_SIZE - 1)));
+ n = ((u32at (pa, 0x30) + at->mft->data->disk->sector_size - 1)
+ & (~(at->mft->data->disk->sector_size - 1)));
at->attr_cur = at->attr_end;
at->edat_buf = grub_malloc (n);
if (!at->edat_buf)
Index: fs/fat.c
===================================================================
--- fs/fat.c (revision 1886)
+++ fs/fat.c (working copy)
@@ -188,11 +188,12 @@
goto fail;
/* Get the sizes of logical sectors and clusters. */
- data->logical_sector_bits =
- fat_log2 (grub_le_to_cpu16 (bpb.bytes_per_sector));
- if (data->logical_sector_bits < GRUB_DISK_SECTOR_BITS)
- goto fail;
- data->logical_sector_bits -= GRUB_DISK_SECTOR_BITS;
+// data->logical_sector_bits =
+// fat_log2 (grub_le_to_cpu16 (bpb.bytes_per_sector));
+// if (data->logical_sector_bits < GRUB_DISK_SECTOR_BITS)
+// goto fail;
+// data->logical_sector_bits -= GRUB_DISK_SECTOR_BITS;
+ data->logical_sector_bits = fat_log2 (grub_le_to_cpu16 (bpb.bytes_per_sector / disk->sector_size) );
data->cluster_bits = fat_log2 (bpb.sectors_per_cluster);
if (data->cluster_bits < 0)
@@ -226,10 +227,10 @@
data->root_sector = data->fat_sector + bpb.num_fats * data->sectors_per_fat;
data->num_root_sectors
- = ((((grub_uint32_t) grub_le_to_cpu16 (bpb.num_root_entries)
+ = (((((grub_uint32_t) grub_le_to_cpu16 (bpb.num_root_entries)
* GRUB_FAT_DIR_ENTRY_SIZE
+ grub_le_to_cpu16 (bpb.bytes_per_sector) - 1)
- >> (data->logical_sector_bits + GRUB_DISK_SECTOR_BITS))
+ >> (data->logical_sector_bits)) / disk->sector_size )
<< (data->logical_sector_bits));
data->cluster_sector = data->root_sector + data->num_root_sectors;
@@ -353,7 +354,7 @@
in clusters. */
if (data->file_cluster == ~0U)
{
- size = (data->num_root_sectors << GRUB_DISK_SECTOR_BITS) - offset;
+ size = (data->num_root_sectors * disk->sector_size) - offset;
if (size > len)
size = len;
@@ -366,7 +367,7 @@
/* Calculate the logical cluster number and offset. */
logical_cluster_bits = (data->cluster_bits
+ data->logical_sector_bits
- + GRUB_DISK_SECTOR_BITS);
+ + fat_log2 (disk->sector_size));
logical_cluster = offset >> logical_cluster_bits;
offset &= (1 << logical_cluster_bits) - 1;
Index: fs/iso9660.c
===================================================================
--- fs/iso9660.c (revision 1886)
+++ fs/iso9660.c (working copy)
@@ -550,8 +550,8 @@
{
if (grub_disk_read (dir->data->disk,
(dir->blk << GRUB_ISO9660_LOG2_BLKSZ)
- + offset / GRUB_DISK_SECTOR_SIZE,
- offset % GRUB_DISK_SECTOR_SIZE,
+ + offset / dir->data->disk->sector_size,
+ offset % dir->data->disk->sector_size,
sizeof (dirent), (char *) &dirent))
return 0;
@@ -580,16 +580,16 @@
&& grub_iso9660_susp_iterate (dir->data,
(dir->blk << GRUB_ISO9660_LOG2_BLKSZ)
+ (sua_off
- / GRUB_DISK_SECTOR_SIZE),
- sua_off % GRUB_DISK_SECTOR_SIZE,
+ / dir->data->disk->sector_size),
+ sua_off % dir->data->disk->sector_size,
sua_size, susp_iterate_dir))
return 0;
/* Read the name. */
if (grub_disk_read (dir->data->disk,
(dir->blk << GRUB_ISO9660_LOG2_BLKSZ)
- + nameoffset / GRUB_DISK_SECTOR_SIZE,
- nameoffset % GRUB_DISK_SECTOR_SIZE,
+ + nameoffset / dir->data->disk->sector_size,
+ nameoffset % dir->data->disk->sector_size,
dirent.namelen, (char *) name))
return 0;
@@ -602,8 +602,8 @@
node->size = grub_le_to_cpu32 (dirent.size);
node->blk = grub_le_to_cpu32 (dirent.first_sector);
node->dir_blk = ((dir->blk << GRUB_ISO9660_LOG2_BLKSZ)
- + offset / GRUB_DISK_SECTOR_SIZE);
- node->dir_off = offset % GRUB_DISK_SECTOR_SIZE;
+ + offset / dir->data->disk->sector_size);
+ node->dir_off = offset % dir->data->disk->sector_size;
/* If the filetype was not stored using rockridge, use
whatever is stored in the iso9660 filesystem. */
Index: fs/affs.c
===================================================================
--- fs/affs.c (revision 1886)
+++ fs/affs.c (working copy)
@@ -124,7 +124,7 @@
for (links = grub_divmod64 (fileblock, data->htsize, &mod); links; links--)
{
grub_disk_read (data->disk, block + data->blocksize - 1,
- data->blocksize * (GRUB_DISK_SECTOR_SIZE
+ data->blocksize * (data->disk->sector_size
- GRUB_AFFS_FILE_LOCATION),
sizeof (file), (char *) &file);
if (grub_errno)
@@ -203,7 +203,7 @@
/* No sane person uses more than 8KB for a block. At least I hope
for that person because in that case this won't work. */
- rootblock = grub_malloc (GRUB_DISK_SECTOR_SIZE * 16);
+ rootblock = grub_malloc (disk->sector_size * 16);
if (!rootblock)
goto fail;
@@ -211,7 +211,7 @@
/* Read the rootblock. */
grub_disk_read (disk, (disk->total_sectors >> 1) + blocksize, 0,
- GRUB_DISK_SECTOR_SIZE * 16, (char *) rootblock);
+ disk->sector_size * 16, (char *) rootblock);
if (grub_errno)
goto fail;
@@ -222,10 +222,10 @@
rblock->checksum = 0;
for (blocksize = 0; blocksize < 8; blocksize++)
{
- grub_uint32_t *currblock = rootblock + GRUB_DISK_SECTOR_SIZE * blocksize;
+ grub_uint32_t *currblock = rootblock + disk->sector_size * blocksize;
unsigned int i;
- for (i = 0; i < GRUB_DISK_SECTOR_SIZE / sizeof (*currblock); i++)
+ for (i = 0; i < disk->sector_size / sizeof (*currblock); i++)
checksum += grub_be_to_cpu32 (currblock[i]);
if (checksumr == -checksum)
@@ -350,7 +350,7 @@
while (next)
{
grub_disk_read (data->disk, next + data->blocksize - 1,
- data->blocksize * GRUB_DISK_SECTOR_SIZE
+ data->blocksize * data->disk->sector_size
- GRUB_AFFS_FILE_LOCATION,
sizeof (file), (char *) &file);
if (grub_errno)
@@ -524,7 +524,7 @@
/* The rootblock maps quite well on a file header block, it's
something we can use here. */
grub_disk_read (data->disk, disk->total_sectors >> 1,
- data->blocksize * (GRUB_DISK_SECTOR_SIZE
+ data->blocksize * (data->disk->sector_size
- GRUB_AFFS_FILE_LOCATION),
sizeof (file), (char *) &file);
if (grub_errno)
Index: fs/fshelp.c
===================================================================
--- fs/fshelp.c (revision 1886)
+++ fs/fshelp.c (working copy)
@@ -233,15 +233,15 @@
grub_off_t filesize, int log2blocksize)
{
grub_disk_addr_t i, blockcnt;
- int blocksize = 1 << (log2blocksize + GRUB_DISK_SECTOR_BITS);
+ int blocksize = (1 << log2blocksize) * disk->sector_size;
/* Adjust LEN so it we can't read past the end of the file. */
if (pos + len > filesize)
len = filesize - pos;
- blockcnt = ((len + pos) + blocksize - 1) >> (log2blocksize + GRUB_DISK_SECTOR_BITS);
+ blockcnt = (((len + pos) + blocksize - 1) >> log2blocksize) / disk->sector_size;
- for (i = pos >> (log2blocksize + GRUB_DISK_SECTOR_BITS); i < blockcnt; i++)
+ for (i = (pos >> log2blocksize) / disk->sector_size; i < blockcnt; i++)
{
grub_disk_addr_t blknr;
int blockoff = pos & (blocksize - 1);
@@ -266,7 +266,7 @@
}
/* First block. */
- if (i == (pos >> (log2blocksize + GRUB_DISK_SECTOR_BITS)))
+ if (i == ((pos >> log2blocksize) / disk->sector_size))
{
skipfirst = blockoff;
blockend -= skipfirst;
Index: fs/reiserfs.c
===================================================================
--- fs/reiserfs.c (revision 1886)
+++ fs/reiserfs.c (working copy)
@@ -509,9 +509,9 @@
do
{
grub_disk_read (data->disk,
- block_number * (block_size >> GRUB_DISK_SECTOR_BITS),
+ block_number * (block_size / data->disk->sector_size),
(((grub_off_t) block_number * block_size)
- & (GRUB_DISK_SECTOR_SIZE - 1)),
+ & (data->disk->sector_size - 1)),
block_size, (char *) block_header);
if (grub_errno)
goto fail;
@@ -659,7 +659,7 @@
block_size = grub_le_to_cpu16 (node->data->superblock.block_size);
len = grub_le_to_cpu16 (found.header.item_size);
- block = found.block_number * (block_size >> GRUB_DISK_SECTOR_BITS);
+ block = found.block_number * (block_size / node->data->disk->sector_size);
offset = grub_le_to_cpu16 (found.header.item_location);
symlink_buffer = grub_malloc (len + 1);
@@ -686,7 +686,7 @@
data = grub_malloc (sizeof (*data));
if (! data)
goto fail;
- grub_disk_read (disk, REISERFS_SUPER_BLOCK_OFFSET / GRUB_DISK_SECTOR_SIZE,
+ grub_disk_read (disk, REISERFS_SUPER_BLOCK_OFFSET / disk->sector_size,
0, sizeof (data->superblock), (char *) &(data->superblock));
if (grub_errno)
goto fail;
@@ -744,9 +744,9 @@
struct grub_reiserfs_item_header *item_headers;
grub_disk_read (data->disk,
- block_number * (block_size >> GRUB_DISK_SECTOR_BITS),
+ block_number * (block_size / data->disk->sector_size),
(((grub_off_t) block_number * block_size)
- & (GRUB_DISK_SECTOR_SIZE - 1)),
+ & (data->disk->sector_size - 1)),
block_size, (char *) block_header);
if (grub_errno)
goto fail;
@@ -838,7 +838,7 @@
{
struct grub_reiserfs_stat_item_v1 entry_v1_stat;
grub_disk_read (data->disk,
- entry_block_number * (block_size >> GRUB_DISK_SECTOR_BITS),
+ entry_block_number * (block_size / data->disk->sector_size),
grub_le_to_cpu16 (entry_item->header.item_location),
sizeof (entry_v1_stat),
(char *) &entry_v1_stat);
@@ -880,7 +880,7 @@
{
struct grub_reiserfs_stat_item_v2 entry_v2_stat;
grub_disk_read (data->disk,
- entry_block_number * (block_size >> GRUB_DISK_SECTOR_BITS),
+ entry_block_number * (block_size / data->disk->sector_size),
grub_le_to_cpu16 (entry_item->header.item_location),
sizeof (entry_v2_stat),
(char *) &entry_v2_stat);
@@ -1028,10 +1028,10 @@
{
struct grub_reiserfs_stat_item_v1 entry_v1_stat;
grub_disk_read (data->disk,
- block_number * (block_size >> GRUB_DISK_SECTOR_BITS),
+ block_number * (block_size / data->disk->sector_size),
entry_location
+ (((grub_off_t) block_number * block_size)
- & (GRUB_DISK_SECTOR_SIZE - 1)),
+ & (data->disk->sector_size - 1)),
sizeof (entry_v1_stat), (char *) &entry_v1_stat);
if (grub_errno)
goto fail;
@@ -1041,10 +1041,10 @@
{
struct grub_reiserfs_stat_item_v2 entry_v2_stat;
grub_disk_read (data->disk,
- block_number * (block_size >> GRUB_DISK_SECTOR_BITS),
+ block_number * (block_size / data->disk->sector_size),
entry_location
+ (((grub_off_t) block_number * block_size)
- & (GRUB_DISK_SECTOR_SIZE - 1)),
+ & (data->disk->sector_size - 1)),
sizeof (entry_v2_stat), (char *) &entry_v2_stat);
if (grub_errno)
goto fail;
@@ -1111,7 +1111,7 @@
switch (found.type)
{
case GRUB_REISERFS_DIRECT:
- block = found.block_number * (block_size >> GRUB_DISK_SECTOR_BITS);
+ block = found.block_number * (block_size / data->disk->sector_size);
grub_dprintf ("reiserfs_blocktype", "D: %u\n", (unsigned) block);
if (initial_position < current_position + item_size)
{
@@ -1143,7 +1143,7 @@
if (! indirect_block_ptr)
goto fail;
grub_disk_read (found.data->disk,
- found.block_number * (block_size >> GRUB_DISK_SECTOR_BITS),
+ found.block_number * (block_size / found.data->disk->sector_size),
grub_le_to_cpu16 (found.header.item_location),
item_size, (char *) indirect_block_ptr);
if (grub_errno)
@@ -1155,7 +1155,7 @@
indirect_block++)
{
block = grub_le_to_cpu32 (indirect_block_ptr[indirect_block]) *
- (block_size >> GRUB_DISK_SECTOR_BITS);
+ (block_size / found.data->disk->sector_size);
grub_dprintf ("reiserfs_blocktype", "I: %u\n", (unsigned) block);
if (current_position + block_size >= initial_position)
{
@@ -1334,7 +1334,7 @@
if (*label)
{
grub_disk_read (device->disk,
- REISERFS_SUPER_BLOCK_OFFSET / GRUB_DISK_SECTOR_SIZE,
+ REISERFS_SUPER_BLOCK_OFFSET / device->disk->sector_size,
REISERFS_LABEL_OFFSET, REISERFS_MAX_LABEL_LENGTH,
*label);
}
Index: fs/jfs.c
===================================================================
--- fs/jfs.c (revision 1886)
+++ fs/jfs.c (working copy)
@@ -277,8 +277,7 @@
if (grub_disk_read (data->disk,
grub_le_to_cpu32 (extents[found].extent.blk2)
- << (grub_le_to_cpu16 (data->sblock.log2_blksz)
- - GRUB_DISK_SECTOR_BITS), 0,
+ << (grub_le_to_cpu16 (data->sblock.log2_blksz)) * data->disk->sector_size, 0,
sizeof (tree), (char *) &tree))
return -1;
@@ -309,14 +308,14 @@
/* Read in the IAG. */
if (grub_disk_read (data->disk,
- iagblk << (grub_le_to_cpu16 (data->sblock.log2_blksz)
- - GRUB_DISK_SECTOR_BITS), 0,
+ iagblk << (grub_le_to_cpu16 (data->sblock.log2_blksz)) * data->disk->sector_size, 0,
sizeof (struct grub_jfs_iag), (char *) &iag))
return grub_errno;
inoblk = grub_le_to_cpu32 (iag.inodes[inoext].blk2);
- inoblk <<= (grub_le_to_cpu16 (data->sblock.log2_blksz)
- - GRUB_DISK_SECTOR_BITS);
+ inoblk <<= (grub_le_to_cpu16 (data->sblock.log2_blksz));
+ inoblk /= data->disk->sector_size;
+
inoblk += inonum;
if (grub_disk_read (data->disk, inoblk, 0,
@@ -412,7 +411,8 @@
}
blk = grub_le_to_cpu32 (de[inode->dir.header.sorted[0]].ex.blk2);
- blk <<= (grub_le_to_cpu16 (data->sblock.log2_blksz) - GRUB_DISK_SECTOR_BITS);
+ blk <<= (grub_le_to_cpu16 (data->sblock.log2_blksz));
+ blk /= data->disk->sector_size;
/* Read in the nodes until we are on the leaf node level. */
do
@@ -430,8 +430,7 @@
de = (struct grub_jfs_internal_dirent *) diro->dirpage->dirent;
index = diro->dirpage->sorted[diro->dirpage->header.sindex * 32];
blk = (grub_le_to_cpu32 (de[index].ex.blk2)
- << (grub_le_to_cpu16 (data->sblock.log2_blksz)
- - GRUB_DISK_SECTOR_BITS));
+ << (grub_le_to_cpu16 (data->sblock.log2_blksz)) * data->disk->sector_size);
} while (!(diro->dirpage->header.flags & GRUB_JFS_TREE_LEAF));
diro->leaf = diro->dirpage->dirent;
@@ -485,8 +484,8 @@
return GRUB_ERR_OUT_OF_RANGE;
next = grub_le_to_cpu64 (diro->dirpage->header.nextb);
- next <<= (grub_le_to_cpu16 (diro->data->sblock.log2_blksz)
- - GRUB_DISK_SECTOR_BITS);
+ next <<= (grub_le_to_cpu16 (diro->data->sblock.log2_blksz));
+ next /= diro->data->disk->sector_size;
if (grub_disk_read (diro->data->disk, next, 0,
grub_le_to_cpu32 (diro->data->sblock.blksz),
@@ -583,8 +582,7 @@
data->disk->read_hook = read_hook;
grub_disk_read (data->disk,
- blknr << (grub_le_to_cpu16 (data->sblock.log2_blksz)
- - GRUB_DISK_SECTOR_BITS),
+ blknr << (grub_le_to_cpu16 (data->sblock.log2_blksz)) * data->disk->sector_size,
skipfirst, blockend, buf);
data->disk->read_hook = 0;
Index: fs/minix.c
===================================================================
--- fs/minix.c (revision 1886)
+++ fs/minix.c (working copy)
@@ -263,8 +263,8 @@
if (data->version == 1)
{
- block += ino / (GRUB_DISK_SECTOR_SIZE / sizeof (struct grub_minix_inode));
- int offs = (ino % (GRUB_DISK_SECTOR_SIZE
+ block += ino / (data->disk->sector_size / sizeof (struct grub_minix_inode));
+ int offs = (ino % (data->disk->sector_size
/ sizeof (struct grub_minix_inode))
* sizeof (struct grub_minix_inode));
@@ -273,10 +273,10 @@
}
else
{
- block += ino / (GRUB_DISK_SECTOR_SIZE
+ block += ino / (data->disk->sector_size
/ sizeof (struct grub_minix2_inode));
int offs = (ino
- % (GRUB_DISK_SECTOR_SIZE / sizeof (struct grub_minix2_inode))
+ % (data->disk->sector_size / sizeof (struct grub_minix2_inode))
* sizeof (struct grub_minix2_inode));
grub_disk_read (data->disk, block, offs,
Index: fs/hfsplus.c
===================================================================
--- fs/hfsplus.c (revision 1886)
+++ fs/hfsplus.c (working copy)
@@ -225,6 +225,23 @@
#endif
\f
+static int
+hfsplus_log2 (unsigned x)
+{
+ int i;
+
+ if (x == 0)
+ return -1;
+
+ for (i = 0; (x & 1) == 0; i++)
+ x >>= 1;
+
+ if (x != 1)
+ return -1;
+
+ return i;
+}
+
/* Return the offset of the record with the index INDEX, in the node
NODE which is part of the B+ tree BTREE. */
static inline unsigned int
@@ -310,7 +327,7 @@
if (blk != -1)
return (blk
+ (node->data->embedded_offset >> (node->data->log2blksize
- - GRUB_DISK_SECTOR_BITS)));
+ - hfsplus_log2 (node->data->disk->sector_size))));
/* For the extent overflow file, extra extents can't be found in
the extent overflow file. If this happens, you found a
@@ -363,7 +380,7 @@
return grub_fshelp_read_file (node->data->disk, node, read_hook,
pos, len, buf, grub_hfsplus_read_block,
node->size,
- node->data->log2blksize - GRUB_DISK_SECTOR_BITS);
+ node->data->log2blksize - hfsplus_log2 (node->data->disk->sector_size));
}
static struct grub_hfsplus_data *
@@ -409,7 +426,7 @@
ablk_start = grub_be_to_cpu16 (volheader.hfs.first_block);
data->embedded_offset = (ablk_start
+ extent_start
- * (ablk_size >> GRUB_DISK_SECTOR_BITS));
+ * (ablk_size / data->disk->sector_size));
grub_disk_read (disk, data->embedded_offset + GRUB_HFSPLUS_SBLOCK, 0,
sizeof (volheader), (char *) &volheader);
Index: fs/cpio.c
===================================================================
--- fs/cpio.c (revision 1886)
+++ fs/cpio.c (working copy)
@@ -145,9 +145,9 @@
return grub_errno;
data->size = grub_strtoul (hd.size, NULL, 8);
- data->dofs = data->hofs + GRUB_DISK_SECTOR_SIZE;
- *ofs = data->dofs + ((data->size + GRUB_DISK_SECTOR_SIZE - 1) &
- ~(GRUB_DISK_SECTOR_SIZE - 1));
+ data->dofs = data->hofs + data->disk->sector_size;
+ *ofs = data->dofs + ((data->size + data->disk->sector_size - 1) &
+ ~(data->disk->sector_size - 1));
}
return GRUB_ERR_NONE;
}
Index: include/grub/ntfs.h
===================================================================
--- include/grub/ntfs.h (revision 1886)
+++ include/grub/ntfs.h (working copy)
@@ -67,7 +67,8 @@
#define FLAG_ENCRYPTED 0x4000
#define FLAG_SPARSE 0x8000
-#define BLK_SHR GRUB_DISK_SECTOR_BITS
+// TODO: This is quite bad, was GRUB_DISK_SECTOR_BITS (whch in turn was 9 for 512 Byte/Sector disks)
+#define BLK_SHR 9
#define MAX_MFT (1024 >> BLK_SHR)
#define MAX_IDX (16384 >> BLK_SHR)
Index: include/grub/disk.h
===================================================================
--- include/grub/disk.h (revision 1886)
+++ include/grub/disk.h (working copy)
@@ -94,6 +94,9 @@
/* The underlying disk device. */
grub_disk_dev_t dev;
+ /* The size of each sector. */
+ grub_uint32_t sector_size;
+
/* The total number of sectors. */
grub_uint64_t total_sectors;
@@ -126,8 +129,8 @@
#endif
/* The sector size. */
-#define GRUB_DISK_SECTOR_SIZE 0x200
-#define GRUB_DISK_SECTOR_BITS 9
+#define GRUB_DISK_SECTOR_SIZE (disk->sector_size)
+// #define GRUB_DISK_SECTOR_BITS 9
/* The maximum number of disk caches. */
#define GRUB_DISK_CACHE_NUM 1021
Index: commands/cat.c
===================================================================
--- commands/cat.c (revision 1886)
+++ commands/cat.c (working copy)
@@ -31,8 +31,9 @@
int argc, char **args)
{
+#define GRUB_CMD_CAT_CHUNK_SIZE 512
grub_file_t file;
- char buf[GRUB_DISK_SECTOR_SIZE];
+ char buf[GRUB_CMD_CAT_CHUNK_SIZE];
grub_ssize_t size;
int key = 0;
Index: commands/blocklist.c
===================================================================
--- commands/blocklist.c (revision 1886)
+++ commands/blocklist.c (working copy)
@@ -31,7 +31,7 @@
int argc, char **args)
{
grub_file_t file;
- char buf[GRUB_DISK_SECTOR_SIZE];
+ char *buf;
unsigned long start_sector = 0;
unsigned num_sectors = 0;
int num_entries = 0;
@@ -47,7 +47,7 @@
if (num_sectors > 0)
{
if (start_sector + num_sectors == sector
- && offset == 0 && length == GRUB_DISK_SECTOR_SIZE)
+ && offset == 0 && length == file->device->disk->sector_size)
{
num_sectors++;
return;
@@ -57,7 +57,7 @@
num_sectors = 0;
}
- if (offset == 0 && length == GRUB_DISK_SECTOR_SIZE)
+ if (offset == 0 && length == file->device->disk->sector_size)
{
start_sector = sector;
num_sectors++;
@@ -90,6 +90,8 @@
return grub_error (GRUB_ERR_BAD_DEVICE,
"this command is available only for disk devices.");
+ buf = grub_malloc (file->device->disk->sector_size);
+
if (file->device->disk->partition)
part_start = grub_partition_get_start (file->device->disk->partition);
@@ -103,6 +105,7 @@
grub_file_close (file);
+ grub_free (buf);
return grub_errno;
}
Index: loader/i386/pc/linux.c
===================================================================
--- loader/i386/pc/linux.c (revision 1886)
+++ loader/i386/pc/linux.c (working copy)
@@ -143,8 +143,8 @@
if (! setup_sects)
setup_sects = GRUB_LINUX_DEFAULT_SETUP_SECTS;
- real_size = setup_sects << GRUB_DISK_SECTOR_BITS;
- prot_size = grub_file_size (file) - real_size - GRUB_DISK_SECTOR_SIZE;
+ real_size = setup_sects * file->device->disk->sector_size;
+ prot_size = grub_file_size (file) - real_size - file->device->disk->sector_size;
grub_linux_tmp_addr = (char *) GRUB_LINUX_BZIMAGE_ADDR + prot_size;
@@ -229,7 +229,7 @@
/* Put the real mode code at the temporary address. */
grub_memmove (grub_linux_tmp_addr, &lh, sizeof (lh));
- len = real_size + GRUB_DISK_SECTOR_SIZE - sizeof (lh);
+ len = real_size + file->device->disk->sector_size - sizeof (lh);
if (grub_file_read (file, grub_linux_tmp_addr + sizeof (lh), len) != len)
{
grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
@@ -240,10 +240,10 @@
|| grub_le_to_cpu16 (lh.version) < 0x0200)
/* Clear the heap space. */
grub_memset (grub_linux_tmp_addr
- + ((setup_sects + 1) << GRUB_DISK_SECTOR_BITS),
+ + ((setup_sects + 1) * file->device->disk->sector_size),
0,
((GRUB_LINUX_MAX_SETUP_SECTS - setup_sects - 1)
- << GRUB_DISK_SECTOR_BITS));
+ * file->device->disk->sector_size));
/* Specify the boot file. */
dest = grub_stpcpy (grub_linux_tmp_addr + GRUB_LINUX_CL_OFFSET,
Index: loader/i386/pc/chainloader.c
===================================================================
--- loader/i386/pc/chainloader.c (revision 1886)
+++ loader/i386/pc/chainloader.c (working copy)
@@ -63,32 +63,9 @@
grub_dl_ref (my_mod);
- file = grub_file_open (filename);
- if (! file)
- goto fail;
- /* Read the first block. */
- if (grub_file_read (file, (char *) 0x7C00, GRUB_DISK_SECTOR_SIZE)
- != GRUB_DISK_SECTOR_SIZE)
- {
- if (grub_errno == GRUB_ERR_NONE)
- grub_error (GRUB_ERR_BAD_OS, "too small");
-
- goto fail;
- }
-
- /* Check the signature. */
- signature = *((grub_uint16_t *) (0x7C00 + GRUB_DISK_SECTOR_SIZE - 2));
- if (signature != grub_le_to_cpu16 (0xaa55)
- && ! (flags & GRUB_CHAINLOADER_FORCE))
- {
- grub_error (GRUB_ERR_BAD_OS, "invalid signature");
- goto fail;
- }
-
- grub_file_close (file);
-
- /* Obtain the partition table from the root device. */
+ /* Obtain the partition table from the root device. we have to open the
+ device in order to get the sector size */
dev = grub_device_open (0);
if (dev)
{
@@ -96,6 +73,35 @@
if (disk)
{
+ file = grub_file_open (filename);
+ if (! file)
+ {
+ goto fail;
+ grub_device_close (dev);
+ }
+
+ /* Read the first block. */
+ if (grub_file_read (file, (char *) 0x7C00, disk->sector_size)
+ != disk->sector_size)
+ {
+ if (grub_errno == GRUB_ERR_NONE)
+ grub_error (GRUB_ERR_BAD_OS, "too small");
+ grub_device_close (dev);
+ goto fail;
+ }
+
+ /* Check the signature. */
+ signature = *((grub_uint16_t *) (0x7C00 + disk->sector_size - 2));
+ if (signature != grub_le_to_cpu16 (0xaa55)
+ && ! (flags & GRUB_CHAINLOADER_FORCE))
+ {
+ grub_error (GRUB_ERR_BAD_OS, "invalid signature");
+ grub_device_close (dev);
+ goto fail;
+ }
+
+ grub_file_close (file);
+
grub_partition_t p = disk->partition;
/* In i386-pc, the id is equal to the BIOS drive number. */
Index: util/grub-probe.c
===================================================================
--- util/grub-probe.c (revision 1886)
+++ util/grub-probe.c (working copy)
@@ -112,18 +112,26 @@
int abstraction_type;
grub_device_t dev = NULL;
grub_fs_t fs;
+
+ grub_util_info ("starting probe...");
if (path == NULL)
{
if (! grub_util_check_block_device (device_name))
+ grub_util_info ("2");
grub_util_error ("%s is not a block device.\n", device_name);
}
- else
+ else {
+ grub_util_info ("3");
device_name = grub_guess_root_device (path);
+ }
+ grub_util_info ("1");
if (! device_name)
grub_util_error ("cannot find a device for %s.\n", path);
+ grub_util_info ("2");
+
if (print == PRINT_DEVICE)
{
printf ("%s\n", device_name);
@@ -165,7 +173,7 @@
grub_util_info ("opening %s", drive_name);
dev = grub_device_open (drive_name);
if (! dev)
- grub_util_error ("%s", grub_errmsg);
+ grub_util_error ("grub_device_open failed: %s", grub_errmsg);
if (print == PRINT_PARTMAP)
{
@@ -358,22 +366,32 @@
}
argument = argv[optind];
+
+ grub_util_info ("arguments parsed.");
/* Initialize the emulated biosdisk driver. */
grub_util_biosdisk_init (dev_map ? : DEFAULT_DEVICE_MAP);
+
+ grub_util_info ("biosdisk initialized");
/* Initialize all modules. */
grub_init_all ();
+ grub_util_info ("all modules initialized");
+
/* Do it. */
if (argument_is_device)
probe (NULL, argument);
else
probe (argument, NULL);
+
+ grub_util_info ("probe executed");
/* Free resources. */
grub_fini_all ();
grub_util_biosdisk_fini ();
+
+ grub_util_info ("all modules deinitialized");
free (dev_map);
Index: util/i386/pc/grub-mkimage.c
===================================================================
--- util/i386/pc/grub-mkimage.c (revision 1886)
+++ util/i386/pc/grub-mkimage.c (working copy)
@@ -129,7 +129,7 @@
#endif
static void
-generate_image (const char *dir, char *prefix, FILE *out, char *mods[], char *memdisk_path)
+generate_image (const char *dir, char *prefix, FILE *out, char *mods[], char *memdisk_path, grub_uint32_t target_sector_size)
{
grub_addr_t module_addr = 0;
char *kernel_img, *boot_img, *core_img;
@@ -208,19 +208,19 @@
grub_util_info ("the core size is 0x%x", core_size);
- num = ((core_size + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS);
+ num = ((core_size + target_sector_size - 1) / target_sector_size);
if (num > 0xffff)
grub_util_error ("the core image is too big");
boot_path = grub_util_get_path (dir, "diskboot.img");
boot_size = grub_util_get_image_size (boot_path);
- if (boot_size != GRUB_DISK_SECTOR_SIZE)
+ if (boot_size != target_sector_size)
grub_util_error ("diskboot.img is not one sector size");
boot_img = grub_util_read_image (boot_path);
/* i386 is a little endian architecture. */
- *((grub_uint16_t *) (boot_img + GRUB_DISK_SECTOR_SIZE
+ *((grub_uint16_t *) (boot_img + target_sector_size
- GRUB_BOOT_MACHINE_LIST_SIZE + 8))
= grub_cpu_to_le16 (num);
@@ -229,7 +229,7 @@
free (boot_path);
module_addr = (path_list
- ? (GRUB_BOOT_MACHINE_KERNEL_ADDR + GRUB_DISK_SECTOR_SIZE
+ ? (GRUB_BOOT_MACHINE_KERNEL_ADDR + target_sector_size
+ kernel_size)
: 0);
@@ -280,6 +280,7 @@
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"verbose", no_argument, 0, 'v'},
+ {"sector-size", required_argument, 0, 's'},
{0, 0, 0, 0}
};
@@ -301,6 +302,7 @@
-h, --help display this message and exit\n\
-V, --version print version information and exit\n\
-v, --verbose print verbose messages\n\
+ -s, --sector-size=NR set sector size to NR bytes\n\
\n\
Report bugs to <%s>.\n\
", GRUB_LIBDIR, DEFAULT_DIRECTORY, PACKAGE_BUGREPORT);
@@ -316,6 +318,7 @@
char *prefix = NULL;
char *memdisk = NULL;
FILE *fp = stdout;
+ grub_uint32_t target_sector_size = 0;
progname = "grub-mkimage";
@@ -372,6 +375,10 @@
case 'v':
verbosity++;
break;
+
+ case 's':
+ target_sector_size = atoi (optarg);
+ break;
default:
usage (1);
@@ -386,8 +393,15 @@
grub_util_error ("cannot open %s", output);
}
- generate_image (dir ? : GRUB_LIBDIR, prefix ? : DEFAULT_DIRECTORY, fp, argv + optind, memdisk);
+ if (target_sector_size == 0)
+ {
+ printf ("invalid sector size given!");
+ usage (1);
+ }
+
+ generate_image (dir ? : GRUB_LIBDIR, prefix ? : DEFAULT_DIRECTORY, fp, argv + optind, memdisk, target_sector_size);
+
fclose (fp);
if (dir)
Index: util/i386/pc/grub-setup.c
===================================================================
--- util/i386/pc/grub-setup.c (revision 1886)
+++ util/i386/pc/grub-setup.c (working copy)
@@ -105,9 +105,8 @@
char *tmp_img;
int i;
grub_disk_addr_t first_sector;
- grub_uint16_t current_segment
- = GRUB_BOOT_MACHINE_KERNEL_SEG + (GRUB_DISK_SECTOR_SIZE >> 4);
- grub_uint16_t last_length = GRUB_DISK_SECTOR_SIZE;
+ grub_uint16_t current_segment;
+ grub_uint16_t last_length = 0;
grub_file_t file;
FILE *fp;
struct { grub_uint64_t start; grub_uint64_t end; } embed_region;
@@ -160,7 +159,7 @@
grub_util_info ("the first sector is <%llu,%u,%u>",
sector, offset, length);
- if (offset != 0 || length != GRUB_DISK_SECTOR_SIZE)
+ if (offset != 0 || length != dest_dev->disk->sector_size)
grub_util_error ("The first sector of the core file is not sector-aligned");
first_sector = sector;
@@ -174,7 +173,7 @@
grub_util_info ("saving <%llu,%u,%u> with the segment 0x%x",
sector, offset, length, (unsigned) current_segment);
- if (offset != 0 || last_length != GRUB_DISK_SECTOR_SIZE)
+ if (offset != 0 || last_length != dest_dev->disk->sector_size)
grub_util_error ("Non-sector-aligned data is found in the core file");
if (block != first_block
@@ -193,15 +192,25 @@
}
last_length = length;
- current_segment += GRUB_DISK_SECTOR_SIZE >> 4;
+ current_segment += dest_dev->disk->sector_size >> 4;
}
-
+
+ /* Open the destination device and read sector size (automagically done by grub_device_open)*/
+ dest_dev = grub_device_open (dest);
+ if (! dest_dev)
+ grub_util_error ("%s", grub_errmsg);
+
+ /* initialize sector-size dependant variables */
+ last_length = dest_dev->disk->sector_size;
+ current_segment = GRUB_BOOT_MACHINE_KERNEL_SEG + (dest_dev->disk->sector_size >> 4);
+
/* Read the boot image by the OS service. */
boot_path = grub_util_get_path (dir, boot_file);
boot_size = grub_util_get_image_size (boot_path);
- if (boot_size != GRUB_DISK_SECTOR_SIZE)
- grub_util_error ("The size of `%s' is not %d",
- boot_path, GRUB_DISK_SECTOR_SIZE);
+ if (boot_size != dest_dev->disk->sector_size)
+ grub_util_error ("The size of `%s' is not %d, you should adapt the image sector size to the\
+ sector size of the target block device.",
+ boot_path, dest_dev->disk->sector_size);
boot_img = grub_util_read_image (boot_path);
free (boot_path);
@@ -215,23 +224,23 @@
core_path = grub_util_get_path (dir, core_file);
core_size = grub_util_get_image_size (core_path);
- core_sectors = ((core_size + GRUB_DISK_SECTOR_SIZE - 1)
- >> GRUB_DISK_SECTOR_BITS);
- if (core_size < GRUB_DISK_SECTOR_SIZE)
+ core_sectors = ((core_size + dest_dev->disk->sector_size - 1)
+ / dest_dev->disk->sector_size);
+ if (core_size < dest_dev->disk->sector_size)
grub_util_error ("The size of `%s' is too small", core_path);
- else if (core_size > 0xFFFF * GRUB_DISK_SECTOR_SIZE)
+ else if (core_size > 0xFFFF * dest_dev->disk->sector_size)
grub_util_error ("The size of `%s' is too large", core_path);
core_img = grub_util_read_image (core_path);
/* Have FIRST_BLOCK to point to the first blocklist. */
first_block = (struct boot_blocklist *) (core_img
- + GRUB_DISK_SECTOR_SIZE
+ + dest_dev->disk->sector_size
- sizeof (*block));
- install_dos_part = (grub_int32_t *) (core_img + GRUB_DISK_SECTOR_SIZE
+ install_dos_part = (grub_int32_t *) (core_img + dest_dev->disk->sector_size
+ GRUB_KERNEL_MACHINE_INSTALL_DOS_PART);
- install_bsd_part = (grub_int32_t *) (core_img + GRUB_DISK_SECTOR_SIZE
+ install_bsd_part = (grub_int32_t *) (core_img + dest_dev->disk->sector_size
+ GRUB_KERNEL_MACHINE_INSTALL_BSD_PART);
/* Open the root device and the destination device. */
@@ -239,17 +248,13 @@
if (! root_dev)
grub_util_error ("%s", grub_errmsg);
- dest_dev = grub_device_open (dest);
- if (! dest_dev)
- grub_util_error ("%s", grub_errmsg);
-
grub_util_info ("setting the root device to `%s'", root);
if (grub_env_set ("root", root) != GRUB_ERR_NONE)
grub_util_error ("%s", grub_errmsg);
/* Read the original sector from the disk. */
- tmp_img = xmalloc (GRUB_DISK_SECTOR_SIZE);
- if (grub_disk_read (dest_dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE, tmp_img))
+ tmp_img = xmalloc (dest_dev->disk->sector_size);
+ if (grub_disk_read (dest_dev->disk, 0, 0, dest_dev->disk->sector_size, tmp_img))
grub_util_error ("%s", grub_errmsg);
/* Copy the possible DOS BPB. */
@@ -327,7 +332,7 @@
first_block->len = grub_cpu_to_le16 (core_sectors - 1);
first_block->segment
= grub_cpu_to_le16 (GRUB_BOOT_MACHINE_KERNEL_SEG
- + (GRUB_DISK_SECTOR_SIZE >> 4));
+ + (dest_dev->disk->sector_size >> 4));
/* Make sure that the second blocklist is a terminator. */
block = first_block - 1;
@@ -346,7 +351,7 @@
*kernel_sector = grub_cpu_to_le64 (embed_region.start);
/* Write the boot image onto the disk. */
- if (grub_disk_write (dest_dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE,
+ if (grub_disk_write (dest_dev->disk, 0, 0, dest_dev->disk->sector_size,
boot_img))
grub_util_error ("%s", grub_errmsg);
@@ -457,14 +462,14 @@
grub_util_error ("%s", grub_errmsg);
file->read_hook = save_first_sector;
- if (grub_file_read (file, tmp_img, GRUB_DISK_SECTOR_SIZE)
- != GRUB_DISK_SECTOR_SIZE)
+ if (grub_file_read (file, tmp_img, dest_dev->disk->sector_size)
+ != dest_dev->disk->sector_size)
grub_util_error ("Failed to read the first sector of the core image");
block = first_block;
file->read_hook = save_blocklists;
- if (grub_file_read (file, tmp_img, core_size - GRUB_DISK_SECTOR_SIZE)
- != (grub_ssize_t) core_size - GRUB_DISK_SECTOR_SIZE)
+ if (grub_file_read (file, tmp_img, core_size - dest_dev->disk->sector_size)
+ != (grub_ssize_t) core_size - dest_dev->disk->sector_size)
grub_util_error ("Failed to read the rest sectors of the core image");
grub_file_close (file);
@@ -487,11 +492,11 @@
if (! fp)
grub_util_error ("Cannot open `%s'", core_path);
- grub_util_write_image (core_img, GRUB_DISK_SECTOR_SIZE * 2, fp);
+ grub_util_write_image (core_img, dest_dev->disk->sector_size * 2, fp);
fclose (fp);
/* Write the boot image onto the disk. */
- if (grub_disk_write (dest_dev->disk, 0, 0, GRUB_DISK_SECTOR_SIZE, boot_img))
+ if (grub_disk_write (dest_dev->disk, 0, 0, dest_dev->disk->sector_size, boot_img))
grub_util_error ("%s", grub_errmsg);
finish:
Index: util/grub-mkdevicemap.c
===================================================================
--- util/grub-mkdevicemap.c (revision 1886)
+++ util/grub-mkdevicemap.c (working copy)
@@ -70,6 +70,9 @@
# ifndef BLKGETSIZE
# define BLKGETSIZE _IO(0x12,96) /* return device size */
# endif /* ! BLKGETSIZE */
+# ifndef BLKSSZGET
+# define BLKSSZGET _IO(0x12,104)/* get block device sector size */
+#endif
#endif /* __linux__ */
/* Use __FreeBSD_kernel__ instead of __FreeBSD__ for compatibility with
@@ -328,7 +331,7 @@
static int
check_device (const char *device)
{
- char buf[512];
+ char *buf;
FILE *fp;
/* If DEVICE is empty, just return error. */
@@ -393,12 +396,20 @@
#endif /* __FreeBSD_kernel__ || __NetBSD__ || __OpenBSD__ */
/* Attempt to read the first sector. */
- if (fread (buf, 1, 512, fp) != 512)
+ grub_uint32_t size;
+ if (ioctl (fileno (fp), BLKSSZGET, &size))
{
+ grub_util_info ("can not get sector size for %s, assuming 512Bytes (non fatal).", device);
+ size = 512;
+ }
+ buf = grub_malloc( size );
+ if (fread (buf, 1, size, fp) != size)
+ {
+ free (buf);
fclose (fp);
return 0;
}
-
+ free (buf);
fclose (fp);
return 1;
}
Index: util/hostdisk.c
===================================================================
--- util/hostdisk.c (revision 1886)
+++ util/hostdisk.c (working copy)
@@ -64,6 +64,9 @@
# ifndef BLKGETSIZE64
# define BLKGETSIZE64 _IOR(0x12,114,size_t) /* return device size */
# endif /* ! BLKGETSIZE64 */
+# ifndef BLKSSZGET
+# define BLKSSZGET _IO(0x12,104)/* get block device sector size */
+#endif
# ifndef MAJOR
# ifndef MINORBITS
# define MINORBITS 8
@@ -170,10 +173,14 @@
size = grub_util_get_disk_size (map[drive].device);
- if (size % 512)
+// TODO: find correct sector size for mingw32
+ grub_util_info ("compiled with mingw32, assuming 512 byte sector size!");
+ disk->sector_size = 512;
+
+ if (size % disk->sector_size)
grub_util_error ("unaligned device size");
- disk->total_sectors = size >> 9;
+ disk->total_sectors = size / disk->sector_size;
grub_util_info ("the size of %s is %llu", name, disk->total_sectors);
@@ -194,6 +201,13 @@
goto fail;
}
+ if (ioctl (fd, BLKSSZGET, &nr))
+ {
+ close (fd);
+ goto fail;
+ }
+ disk->sector_size = nr;
+
if (ioctl (fd, BLKGETSIZE64, &nr))
{
close (fd);
@@ -201,12 +215,12 @@
}
close (fd);
- disk->total_sectors = nr / 512;
+ disk->total_sectors = nr / disk->sector_size;
- if (nr % 512)
+ if (nr % disk->sector_size)
grub_util_error ("unaligned device size");
- grub_util_info ("the size of %s is %llu", name, disk->total_sectors);
+ grub_util_info ("the size of %s is %llu with sector size %iu", name, disk->total_sectors, disk->sector_size);
return GRUB_ERR_NONE;
}
@@ -215,15 +229,19 @@
/* In GNU/Hurd, stat() will return the right size. */
#elif !defined (__GNU__)
# warning "No special routine to get the size of a block device is implemented for your OS. This is not possibly fatal."
+# warning "No routine for getting sector size is implemented, assuming 512 bytes."
+ disk->sector_size = 512;
#endif
- if (stat (map[drive].device, &st) < 0)
- return grub_error (GRUB_ERR_BAD_DEVICE, "cannot stat `%s'", map[drive].device);
+ {
+ if (stat (map[drive].device, &st) < 0)
+ return grub_error (GRUB_ERR_BAD_DEVICE, "cannot stat `%s'", map[drive].device);
- disk->total_sectors = st.st_size >> GRUB_DISK_SECTOR_BITS;
+ disk->total_sectors = st.st_size / disk->sector_size;
- grub_util_info ("the size of %s is %lu", name, disk->total_sectors);
+ grub_util_info ("the size of %s is %lu with sector size %iu", name, disk->total_sectors, disk->sector_size);
- return GRUB_ERR_NONE;
+ return GRUB_ERR_NONE;
+ }
}
#ifdef __linux__
@@ -346,7 +364,7 @@
_syscall5 (int, _llseek, uint, filedes, ulong, hi, ulong, lo,
loff_t *, res, uint, wh);
- offset = (loff_t) sector << GRUB_DISK_SECTOR_BITS;
+ offset = (loff_t) sector * disk->sector_size;
if (_llseek (fd, offset >> 32, offset & 0xffffffff, &result, SEEK_SET))
{
grub_error (GRUB_ERR_BAD_DEVICE, "cannot seek `%s'", map[disk->id].device);
@@ -356,7 +374,7 @@
}
#else
{
- off_t offset = (off_t) sector << GRUB_DISK_SECTOR_BITS;
+ off_t offset = (off_t) sector * disk->sector_size;
if (lseek (fd, offset, SEEK_SET) != offset)
{
@@ -422,6 +440,8 @@
return size;
}
+
+/* read size number of SECTORS which each in turn is of disk->sector_size bytes */
static grub_err_t
grub_util_biosdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
grub_size_t size, char *buf)
@@ -432,27 +452,29 @@
if (fd < 0)
return grub_errno;
-#ifdef __linux__
- if (sector == 0 && size > 1)
- {
- /* Work around a bug in Linux ez remapping. Linux remaps all
- sectors that are read together with the MBR in one read. It
- should only remap the MBR, so we split the read in two
- parts. -jochen */
- if (nread (fd, buf, GRUB_DISK_SECTOR_SIZE) != GRUB_DISK_SECTOR_SIZE)
- {
- grub_error (GRUB_ERR_READ_ERROR, "cannot read `%s'", map[disk->id].device);
- close (fd);
- return grub_errno;
- }
-
- buf += GRUB_DISK_SECTOR_SIZE;
- size--;
- }
-#endif /* __linux__ */
-
- if (nread (fd, buf, size << GRUB_DISK_SECTOR_BITS)
- != (ssize_t) (size << GRUB_DISK_SECTOR_BITS))
+//#ifdef __linux__
+// if (sector == 0 && size > 1)
+// {
+// /* Work around a bug in Linux ez remapping. Linux remaps all
+// sectors that are read together with the MBR in one read. It
+// should only remap the MBR, so we split the read in two
+// parts. -jochen */
+// if (nread (fd, buf, GRUB_DISK_SECTOR_SIZE) != GRUB_DISK_SECTOR_SIZE)
+// {
+// grub_error (GRUB_ERR_READ_ERROR, "cannot read `%s'", map[disk->id].device);
+// close (fd);
+// return grub_errno;
+// }
+//
+// buf += GRUB_DISK_SECTOR_SIZE;
+// size--;
+// }
+//#endif /* __linux__ */
+// since we now read sectors only, we don'Ãt need no sepcial handling for MBRsize!=SectorSize
+// this _must_ be done by the caller now!
+
+ if (nread (fd, buf, size * disk->sector_size)
+ != (ssize_t) (size * disk->sector_size))
grub_error (GRUB_ERR_READ_ERROR, "cannot read from `%s'", map[disk->id].device);
close (fd);
@@ -469,8 +491,8 @@
if (fd < 0)
return grub_errno;
- if (nwrite (fd, buf, size << GRUB_DISK_SECTOR_BITS)
- != (ssize_t) (size << GRUB_DISK_SECTOR_BITS))
+ if (nwrite (fd, buf, size * disk->sector_size)
+ != (ssize_t) (size * disk->sector_size))
grub_error (GRUB_ERR_WRITE_ERROR, "cannot write to `%s'", map[disk->id].device);
close (fd);
next reply other threads:[~2008-10-07 22:31 UTC|newest]
Thread overview: 2+ messages / expand[flat|nested] mbox.gz Atom feed top
2008-10-07 22:30 Clemens Helfmeier [this message]
2008-10-08 16:11 ` Patch for different sector sizes Clemens Helfmeier
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20081007223057.GD413@helfmeier.de \
--to=clemens@helfmeier.de \
--cc=grub-devel@gnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox