* [Cluster-devel] cluster/gfs/gfs_mkfs Makefile device_geometry. ...
@ 2006-07-10 23:39 rpeterso
0 siblings, 0 replies; only message in thread
From: rpeterso @ 2006-07-10 23:39 UTC (permalink / raw)
To: cluster-devel.redhat.com
CVSROOT: /cvs/cluster
Module name: cluster
Changes by: rpeterso at sourceware.org 2006-07-10 23:39:35
Modified files:
gfs/gfs_mkfs : Makefile device_geometry.c fs_geometry.c main.c
mkfs_gfs.h structures.c
Log message:
Changes necessary due to removal of iddev parts (replaced by libvolume_id)
Also incorporated libgfs for common functions.
Patches:
http://sourceware.org/cgi-bin/cvsweb.cgi/cluster/gfs/gfs_mkfs/Makefile.diff?cvsroot=cluster&r1=1.4&r2=1.5
http://sourceware.org/cgi-bin/cvsweb.cgi/cluster/gfs/gfs_mkfs/device_geometry.c.diff?cvsroot=cluster&r1=1.2&r2=1.3
http://sourceware.org/cgi-bin/cvsweb.cgi/cluster/gfs/gfs_mkfs/fs_geometry.c.diff?cvsroot=cluster&r1=1.1&r2=1.2
http://sourceware.org/cgi-bin/cvsweb.cgi/cluster/gfs/gfs_mkfs/main.c.diff?cvsroot=cluster&r1=1.3&r2=1.4
http://sourceware.org/cgi-bin/cvsweb.cgi/cluster/gfs/gfs_mkfs/mkfs_gfs.h.diff?cvsroot=cluster&r1=1.3&r2=1.4
http://sourceware.org/cgi-bin/cvsweb.cgi/cluster/gfs/gfs_mkfs/structures.c.diff?cvsroot=cluster&r1=1.2&r2=1.3
--- cluster/gfs/gfs_mkfs/Makefile 2005/05/19 19:51:08 1.4
+++ cluster/gfs/gfs_mkfs/Makefile 2006/07/10 23:39:35 1.5
@@ -28,7 +28,7 @@
-DGFS_RELEASE_NAME=\"${RELEASE}\"
INCLUDE= -I${top_srcdir}/include -I${top_srcdir}/config \
- -I${gfskincdir} -I${iddevincdir} -I${incdir}
+ -I${gfskincdir} -I${incdir} -I${top_srcdir}/libgfs
ifneq (${KERNEL_SRC}, )
# Use the kernel tree if patched, otherwise, look where cluster headers
@@ -40,13 +40,12 @@
INCLUDE += -I${incdir}
endif
-LDFLAGS+= -L${iddevlibdir} -L${libdir}
-LOADLIBES+= -liddev
+LDFLAGS+=-L${top_srcdir}/libgfs -L${libdir}
all: ${TARGET}
gfs_mkfs: ${SOURCE}
- ${CC} ${CFLAGS} ${INCLUDE} ${LDFLAGS} ${SOURCE} ${LOADLIBES} ${LDLIBS} -o $@
+ ${CC} ${CFLAGS} ${INCLUDE} ${LDFLAGS} ${SOURCE} ${LOADLIBES} ${LDLIBS} -o $@ -lgfs -lvolume_id
copytobin: ${TARGET}
cp ${TARGET} ${top_srcdir}/bin
--- cluster/gfs/gfs_mkfs/device_geometry.c 2004/09/01 18:31:50 1.2
+++ cluster/gfs/gfs_mkfs/device_geometry.c 2006/07/10 23:39:35 1.3
@@ -27,13 +27,8 @@
#include "global.h"
#include <linux/gfs_ondisk.h>
#include "osi_list.h"
-#include "iddev.h"
-
#include "mkfs_gfs.h"
-
-
-
-
+#include "libgfs.h"
/**
* device_geometry - Get the size of a device
@@ -44,35 +39,31 @@
void device_geometry(commandline_t *comline, mkfs_device_t *device)
{
- int fd;
- uint64 bytes;
- int error;
-
-
- fd = open(comline->device, O_RDONLY);
- if (fd < 0)
- die("can't open %s: %s\n", comline->device, strerror(errno));
-
- error = device_size(fd, &bytes);
- if (error)
- die("can't determine size of %s: %s\n", comline->device, strerror(errno));
+ int fd;
+ uint64 bytes;
+ int error;
- close(fd);
+ fd = open(comline->device, O_RDONLY);
+ if (fd < 0)
+ die("can't open %s: %s\n", comline->device, strerror(errno));
+ error = device_size(fd, &bytes);
+ if (error)
+ die("can't determine size of %s: %s\n", comline->device, strerror(errno));
- if (comline->debug)
- printf("\nPartition size = %"PRIu64"\n", bytes >> 9);
+ close(fd);
+ if (comline->debug)
+ printf("\nPartition size = %"PRIu64"\n", bytes >> 9);
- device->nsubdev = 1;
+ device->nsubdev = 1;
- type_zalloc(device->subdev, mkfs_subdevice_t, 1);
+ type_zalloc(device->subdev, mkfs_subdevice_t, 1);
- device->subdev->start = 0;
- device->subdev->length = bytes >> 9;
+ device->subdev->start = 0;
+ device->subdev->length = bytes >> 9;
}
-
/**
* add_journals_to_device - carve space out of a mkfs_device_t to add journals
* @comline: the command line arguments
@@ -82,51 +73,44 @@
void add_journals_to_device(commandline_t *comline, mkfs_device_t *device)
{
- mkfs_subdevice_t *old;
- uint64 jsize;
- unsigned int x;
-
-
- MKFS_ASSERT(device->nsubdev == 1 &&
- !device->subdev->is_journal, );
-
+ mkfs_subdevice_t *old;
+ uint64 jsize;
+ unsigned int x;
- if (!comline->journals)
- die("No journals specified (use -j)\n");
+ MKFS_ASSERT(device->nsubdev == 1 &&
+ !device->subdev->is_journal, );
- if (!comline->jsize)
- die("journal size is zero (use -J)\n");
+ if (!comline->journals)
+ die("No journals specified (use -j)\n");
- jsize = comline->jsize * (1 << 20) / GFS_BASIC_BLOCK;
+ if (!comline->jsize)
+ die("journal size is zero (use -J)\n");
- if (comline->journals * jsize > device->subdev->length)
- die("Partition too small for number/size of journals\n");
+ jsize = comline->jsize * (1 << 20) / GFS_BASIC_BLOCK;
+ if (comline->journals * jsize > device->subdev->length)
+ die("Partition too small for number/size of journals\n");
- old = device->subdev;
+ old = device->subdev;
+ device->nsubdev = comline->journals + 2;
+ type_zalloc(device->subdev, mkfs_subdevice_t, device->nsubdev);
+
+ device->subdev[0].start = old->start;
+ device->subdev[0].length = (old->length - comline->journals * jsize) / 2;
- device->nsubdev = comline->journals + 2;
- type_zalloc(device->subdev, mkfs_subdevice_t, device->nsubdev);
+ for (x = 1; x <= comline->journals; x++) {
+ device->subdev[x].start = device->subdev[x - 1].start + device->subdev[x - 1].length;
+ device->subdev[x].length = jsize;
+ device->subdev[x].is_journal = TRUE;
+ }
- device->subdev[0].start = old->start;
- device->subdev[0].length = (old->length - comline->journals * jsize) / 2;
+ device->subdev[x].start = device->subdev[x - 1].start + device->subdev[x - 1].length;
+ device->subdev[x].length = device->subdev[0].length;
- for (x = 1; x <= comline->journals; x++)
- {
- device->subdev[x].start = device->subdev[x - 1].start + device->subdev[x - 1].length;
- device->subdev[x].length = jsize;
- device->subdev[x].is_journal = TRUE;
- }
-
- device->subdev[x].start = device->subdev[x - 1].start + device->subdev[x - 1].length;
- device->subdev[x].length = device->subdev[0].length;
-
-
- free(old);
+ free(old);
}
-
/**
* fix_device_geometry - round off address and lengths and convert to FS blocks
* @comline: the command line
@@ -136,60 +120,47 @@
void fix_device_geometry(commandline_t *comline, mkfs_device_t *device)
{
- unsigned int x;
- uint64 offset, len;
- uint32 bbsize = comline->bsize >> 9;
+ unsigned int x;
+ uint64 offset, len;
+ uint32 bbsize = comline->bsize >> 9;
+
+ if (comline->debug) {
+ printf("\nDevice Geometry: (in basic blocks)\n");
+ for (x = 0; x < device->nsubdev; x++)
+ printf(" SubDevice #%d: %s: start = %"PRIu64", len = %"PRIu64"\n",
+ x,
+ (device->subdev[x].is_journal) ? "journal" : "data",
+ device->subdev[x].start,
+ device->subdev[x].length);
+ }
+
+ /* Make sure all the subdevices are aligned */
+
+ for (x = 0; x < device->nsubdev; x++) {
+ offset = device->subdev[x].start;
+ len = device->subdev[x].length;
+
+ if (len < 100 * bbsize)
+ die("subdevice %d is way too small (%"PRIu64" bytes)\n", x, len * GFS_BASIC_BLOCK);
+
+ if (offset % bbsize) {
+ len -= bbsize - (offset % bbsize);
+ offset += bbsize - (offset % bbsize);
+ }
+
+ device->subdev[x].start = offset / bbsize;
+ device->subdev[x].length = len / bbsize;
+ }
+
+ if (comline->debug) {
+ printf("\nDevice Geometry: (in FS blocks)\n");
+ for (x = 0; x < device->nsubdev; x++)
+ printf(" SubDevice #%d: %s: start = %"PRIu64", len = %"PRIu64"\n",
+ x,
+ (device->subdev[x].is_journal) ? "journal" : "data",
+ device->subdev[x].start,
+ device->subdev[x].length);
-
- if (comline->debug)
- {
- printf("\nDevice Geometry: (in basic blocks)\n");
- for (x = 0; x < device->nsubdev; x++)
- printf(" SubDevice #%d: %s: start = %"PRIu64", len = %"PRIu64"\n",
- x,
- (device->subdev[x].is_journal) ? "journal" : "data",
- device->subdev[x].start,
- device->subdev[x].length);
- }
-
-
- /* Make sure all the subdevices are aligned */
-
- for (x = 0; x < device->nsubdev; x++)
- {
- offset = device->subdev[x].start;
- len = device->subdev[x].length;
-
-
- if (len < 100 * bbsize)
- die("subdevice %d is way too small (%"PRIu64" bytes)\n", x, len * GFS_BASIC_BLOCK);
-
-
- if (offset % bbsize)
- {
- len -= bbsize - (offset % bbsize);
- offset += bbsize - (offset % bbsize);
- }
-
-
- device->subdev[x].start = offset / bbsize;
- device->subdev[x].length = len / bbsize;
- }
-
-
- if (comline->debug)
- {
- printf("\nDevice Geometry: (in FS blocks)\n");
- for (x = 0; x < device->nsubdev; x++)
- printf(" SubDevice #%d: %s: start = %"PRIu64", len = %"PRIu64"\n",
- x,
- (device->subdev[x].is_journal) ? "journal" : "data",
- device->subdev[x].start,
- device->subdev[x].length);
-
- printf("\njournals = %u\n", comline->journals);
- }
+ printf("\njournals = %u\n", comline->journals);
+ }
}
-
-
-
--- cluster/gfs/gfs_mkfs/fs_geometry.c 2004/06/24 08:53:23 1.1
+++ cluster/gfs/gfs_mkfs/fs_geometry.c 2006/07/10 23:39:35 1.2
@@ -29,10 +29,6 @@
#include "mkfs_gfs.h"
-
-
-
-
/**
* how_many_rgrps - figure out how many RG to put in a subdevice
* @comline: the command line
@@ -43,21 +39,20 @@
static uint64 how_many_rgrps(commandline_t *comline, mkfs_subdevice_t *sdev)
{
- uint64 nrgrp;
- unsigned int min = (comline->expert) ? 1 : 4;
+ uint64 nrgrp;
+ unsigned int min = (comline->expert) ? 1 : 4;
- nrgrp = DIV_RU(sdev->length, (comline->rgsize << 20) / comline->bsize);
+ nrgrp = DIV_RU(sdev->length, (comline->rgsize << 20) / comline->bsize);
- if (nrgrp < min)
- nrgrp = min;
+ if (nrgrp < min)
+ nrgrp = min;
- if (comline->debug)
- printf(" nrgrp = %"PRIu64"\n", nrgrp);
+ if (comline->debug)
+ printf(" nrgrp = %"PRIu64"\n", nrgrp);
- return nrgrp;
+ return nrgrp;
}
-
/**
* compute_rgrp_layout - figure out where the RG in a FS are
* @comline: the command line
@@ -69,79 +64,67 @@
void compute_rgrp_layout(commandline_t *comline, mkfs_device_t *device, osi_list_t *rlist)
{
- mkfs_subdevice_t *sdev;
- rgrp_list_t *rl, *rlast = NULL;
- osi_list_t *tmp;
- uint64 rgrp, nrgrp;
- unsigned int x;
- int first_sdev = TRUE;
+ mkfs_subdevice_t *sdev;
+ rgrp_list_t *rl, *rlast = NULL;
+ osi_list_t *tmp;
+ uint64 rgrp, nrgrp;
+ unsigned int x;
+ int first_sdev = TRUE;
+ for (x = 0; x < device->nsubdev; x++) {
+ sdev = &device->subdev[x];
- for (x = 0; x < device->nsubdev; x++)
- {
- sdev = &device->subdev[x];
+ if (!sdev->is_journal) {
+ /* If this is the 1st subdevice reserve space for the superblock */
- if (!sdev->is_journal)
- {
- /* If this is the first subdevice reserve space for the superblock */
+ if (first_sdev)
+ sdev->length -= comline->sb_addr + 1;
- if (first_sdev)
- sdev->length -= comline->sb_addr + 1;
+ if (comline->debug)
+ printf("\nData Subdevice %u\n", x);
+ nrgrp = how_many_rgrps(comline, sdev);
- if (comline->debug)
- printf("\nData Subdevice %u\n", x);
+ for (rgrp = 0; rgrp < nrgrp; rgrp++) {
+ type_zalloc(rl, rgrp_list_t, 1);
- nrgrp = how_many_rgrps(comline, sdev);
+ rl->subdevice = x;
+ if (rgrp) {
+ rl->rg_offset = rlast->rg_offset + rlast->rg_length;
+ rl->rg_length = sdev->length / nrgrp;
+ }
+ else {
+ rl->rg_offset = sdev->start;
+ rl->rg_length = sdev->length - (nrgrp - 1) * (sdev->length / nrgrp);
- for (rgrp = 0; rgrp < nrgrp; rgrp++)
- {
- type_zalloc(rl, rgrp_list_t, 1);
+ if (first_sdev)
+ rl->rg_offset += comline->sb_addr + 1;
+ }
- rl->subdevice = x;
+ osi_list_add_prev(&rl->list, rlist);
- if (rgrp)
- {
- rl->rg_offset = rlast->rg_offset + rlast->rg_length;
- rl->rg_length = sdev->length / nrgrp;
- }
- else
- {
- rl->rg_offset = sdev->start;
- rl->rg_length = sdev->length - (nrgrp - 1) * (sdev->length / nrgrp);
+ rlast = rl;
+ }
- if (first_sdev)
- rl->rg_offset += comline->sb_addr + 1;
- }
+ first_sdev = FALSE;
- osi_list_add_prev(&rl->list, rlist);
-
- rlast = rl;
- }
+ comline->rgrps += nrgrp;
+ }
+ }
- first_sdev = FALSE;
+ if (comline->debug) {
+ printf("\n");
- comline->rgrps += nrgrp;
- }
- }
-
-
- if (comline->debug)
- {
- printf("\n");
-
- for (tmp = rlist->next; tmp != rlist; tmp = tmp->next)
- {
- rl = osi_list_entry(tmp, rgrp_list_t, list);
- printf("subdevice %u: rg_o = %"PRIu64", rg_l = %"PRIu64"\n",
- rl->subdevice,
- rl->rg_offset, rl->rg_length);
- }
- }
+ for (tmp = rlist->next; tmp != rlist; tmp = tmp->next) {
+ rl = osi_list_entry(tmp, rgrp_list_t, list);
+ printf("subdevice %u: rg_o = %"PRIu64", rg_l = %"PRIu64"\n",
+ rl->subdevice,
+ rl->rg_offset, rl->rg_length);
+ }
+ }
}
-
/**
* compute_journal_layout - figure out where the journals in a FS are
* @comline: the command line
@@ -153,56 +136,48 @@
void compute_journal_layout(commandline_t *comline, mkfs_device_t *device, osi_list_t *jlist)
{
- mkfs_subdevice_t *sdev;
- journal_list_t *jl;
- osi_list_t *tmp;
- unsigned int x, j = 0;
- uint64 boffset, bcount;
- unsigned int min_jsize = (comline->expert) ? 1 : 32;
-
-
- for (x = 0; x < device->nsubdev; x++)
- {
- sdev = &device->subdev[x];
+ mkfs_subdevice_t *sdev;
+ journal_list_t *jl;
+ osi_list_t *tmp;
+ unsigned int x, j = 0;
+ uint64 boffset, bcount;
+ unsigned int min_jsize = (comline->expert) ? 1 : 32;
+
+ for (x = 0; x < device->nsubdev; x++) {
+ sdev = &device->subdev[x];
+
+ if (sdev->is_journal) {
+ type_zalloc(jl, journal_list_t, 1);
+
+ /* Align the journals on seg_size boundries */
+
+ boffset = sdev->start;
+ bcount = sdev->length;
+
+ if ((bcount + comline->seg_size) * comline->bsize < min_jsize << 20)
+ die("journal %d is too small (minimum size is %u MB)\n", j, min_jsize);
+
+ if (boffset % comline->seg_size) {
+ bcount -= comline->seg_size - (boffset % comline->seg_size);
+ boffset += comline->seg_size - (boffset % comline->seg_size);
+ }
+
+ jl->start = boffset;
+ jl->segments = bcount / comline->seg_size;
+
+ osi_list_add_prev(&jl->list, jlist);
- if (sdev->is_journal)
- {
- type_zalloc(jl, journal_list_t, 1);
-
- /* Align the journals on seg_size boundries */
-
- boffset = sdev->start;
- bcount = sdev->length;
-
- if ((bcount + comline->seg_size) * comline->bsize < min_jsize << 20)
- die("journal %d is too small (minimum size is %u MB)\n", j, min_jsize);
-
- if (boffset % comline->seg_size)
- {
- bcount -= comline->seg_size - (boffset % comline->seg_size);
- boffset += comline->seg_size - (boffset % comline->seg_size);
- }
-
- jl->start = boffset;
- jl->segments = bcount / comline->seg_size;
-
- osi_list_add_prev(&jl->list, jlist);
-
- j++;
- }
- }
-
-
- if (comline->debug)
- {
- printf("\n");
+ j++;
+ }
+ }
- for (tmp = jlist->next, j = 0; tmp != jlist; tmp = tmp->next, j++)
- {
- jl = osi_list_entry(tmp, journal_list_t, list);
- printf("journal %u: start = %"PRIu64", segments = %u\n",
- j, jl->start, jl->segments);
- }
- }
+ if (comline->debug) {
+ printf("\n");
+
+ for (tmp = jlist->next, j = 0; tmp != jlist; tmp = tmp->next, j++) {
+ jl = osi_list_entry(tmp, journal_list_t, list);
+ printf("journal %u: start = %"PRIu64", segments = %u\n",
+ j, jl->start, jl->segments);
+ }
+ }
}
-
--- cluster/gfs/gfs_mkfs/main.c 2005/01/05 01:49:05 1.3
+++ cluster/gfs/gfs_mkfs/main.c 2006/07/10 23:39:35 1.4
@@ -26,8 +26,8 @@
#include "global.h"
#include <linux/gfs_ondisk.h>
#include "osi_list.h"
-#include "iddev.h"
-
+#include "libvolume_id.h"
+#include "libgfs.h"
#include "copyright.cf"
#define EXTERN
@@ -218,25 +218,27 @@
void are_you_sure(commandline_t *comline)
{
- char buf[1024];
- char input[32];
- int unknown;
-
- unknown = identify_device(comline->fd, buf, 1024);
- if (unknown < 0)
- die("error identifying the contents of %s: %s\n", comline->device, strerror(errno));
-
- printf("This will destroy any data on %s.\n", comline->device);
- if (!unknown)
- printf(" It appears to contain a %s.\n", buf);
-
- printf("\nAre you sure you want to proceed? [y/n] ");
- fgets(input, 32, stdin);
+ char input[32];
+ struct volume_id *vid = NULL;
- if (input[0] != 'y')
- die("aborted\n");
- else
- printf("\n");
+ vid = volume_id_open_node(comline->device);
+ if (vid == NULL)
+ die("error identifying the contents of %s: %s\n",
+ comline->device, strerror(errno));
+
+ printf("This will destroy any data on %s.\n",
+ comline->device);
+ if (volume_id_probe_all(vid, 0, MKFS_DEFAULT_BSIZE) == 0)
+ printf(" It appears to contain a %s %s.\n", vid->type,
+ vid->usage_id == VOLUME_ID_OTHER? "partition" : vid->usage);
+ volume_id_close(vid);
+ printf("\nAre you sure you want to proceed? [y/n] ");
+ fgets(input, 32, stdin);
+
+ if (input[0] != 'y')
+ die("aborted\n");
+ else
+ printf("\n");
}
@@ -283,125 +285,105 @@
int main(int argc, char *argv[])
{
- commandline_t comline;
- mkfs_device_t device;
- osi_list_t rlist;
- osi_list_t jlist;
- unsigned int x;
-
+ commandline_t comline;
+ mkfs_device_t device;
+ osi_list_t rlist;
+ osi_list_t jlist;
+ unsigned int x;
- prog_name = argv[0];
+ prog_name = argv[0];
- osi_list_init(&rlist);
- osi_list_init(&jlist);
+ osi_list_init(&rlist);
+ osi_list_init(&jlist);
+ /* Process the command line arguments */
- /* Process the command line arguments */
+ memset(&comline, 0, sizeof(commandline_t));
+ comline.bsize = MKFS_DEFAULT_BSIZE;
+ comline.seg_size = MKFS_DEFAULT_SEG_SIZE;
+ comline.jsize = MKFS_DEFAULT_JSIZE;
+ comline.rgsize = MKFS_DEFAULT_RGSIZE;
- memset(&comline, 0, sizeof(commandline_t));
- comline.bsize = MKFS_DEFAULT_BSIZE;
- comline.seg_size = MKFS_DEFAULT_SEG_SIZE;
- comline.jsize = MKFS_DEFAULT_JSIZE;
- comline.rgsize = MKFS_DEFAULT_RGSIZE;
+ decode_arguments(argc, argv, &comline);
- decode_arguments(argc, argv, &comline);
+ if (!comline.expert) {
+ char buf[256];
+ if (test_locking(comline.lockproto, comline.locktable, buf, 256))
+ die("%s\n", buf);
+ }
- if (!comline.expert)
- {
- char buf[256];
- if (test_locking(comline.lockproto, comline.locktable, buf, 256))
- die("%s\n", buf);
- }
+ /* Block sizes must be a power of two from 512 to 65536 */
+ for (x = 512; x; x <<= 1)
+ if (x == comline.bsize)
+ break;
+ if (!x || comline.bsize > 65536)
+ die("block size must be a power of two between 512 and 65536\n");
- /* Block sizes must be a power of two from 512 to 65536 */
-
- for (x = 512; x; x <<= 1)
- if (x == comline.bsize)
- break;
+ comline.sb_addr = GFS_SB_ADDR * GFS_BASIC_BLOCK / comline.bsize;
- if (!x || comline.bsize > 65536)
- die("block size must be a power of two between 512 and 65536\n");
+ if (comline.seg_size < 2)
+ die("segment size too small\n");
- comline.sb_addr = GFS_SB_ADDR * GFS_BASIC_BLOCK / comline.bsize;
+ if (!comline.expert && (uint64)comline.seg_size * comline.bsize > 4194304)
+ die("segment size too large\n");
- if (comline.seg_size < 2)
- die("segment size too small\n");
-
- if (!comline.expert && (uint64)comline.seg_size * comline.bsize > 4194304)
- die("segment size too large\n");
-
- if (comline.expert)
- {
- if (1 > comline.rgsize || comline.rgsize > 2048)
- die("bad resource group size\n");
- }
- else
- {
- if (32 > comline.rgsize || comline.rgsize > 2048)
- die("bad resource group size\n");
- }
+ if (comline.expert) {
+ if (1 > comline.rgsize || comline.rgsize > 2048)
+ die("bad resource group size\n");
+ }
+ else {
+ if (32 > comline.rgsize || comline.rgsize > 2048)
+ die("bad resource group size\n");
+ }
+ /* Get the device geometry */
+ memset(&device, 0, sizeof(mkfs_device_t));
- /* Get the device geometry */
+ device_geometry(&comline, &device);
+ add_journals_to_device(&comline, &device);
- memset(&device, 0, sizeof(mkfs_device_t));
+ fix_device_geometry(&comline, &device);
- device_geometry(&comline, &device);
- add_journals_to_device(&comline, &device);
+ /* Compute the resource group layouts */
- fix_device_geometry(&comline, &device);
+ compute_rgrp_layout(&comline, &device, &rlist);
+ compute_journal_layout(&comline, &device, &jlist);
+ /* Start writing stuff out */
- /* Compute the resource group layouts */
+ comline.fd = open(comline.device, O_RDWR);
+ if (comline.fd < 0)
+ die("can't open device %s\n", comline.device);
- compute_rgrp_layout(&comline, &device, &rlist);
+ if (!comline.override)
+ are_you_sure(&comline);
- compute_journal_layout(&comline, &device, &jlist);
+ write_mkfs_sb(&comline, &rlist);
+ /* Figure out where we start allocating in rgrp 0 */
+ comline.rgrp0_next = comline.sbd->sd_sb.sb_root_di.no_addr + 1;
- /* Start writing stuff out */
+ write_jindex(&comline, &jlist);
- comline.fd = open(comline.device, O_RDWR);
- if (comline.fd < 0)
- die("can't open device %s\n", comline.device);
+ write_rindex(&comline, &rlist);
+ write_root(&comline);
- if (!comline.override)
- are_you_sure(&comline);
+ write_quota(&comline);
+ write_license(&comline);
- write_sb(&comline, &rlist);
+ write_rgrps(&comline, &rlist);
- /* Figure out where we start allocting in rgrp 0 */
- comline.rgrp0_next = comline.sb->sb_root_di.no_addr + 1;
+ write_journals(&comline, &jlist);
- write_jindex(&comline, &jlist);
+ close(comline.fd);
+ free(comline.sbd);
+ print_results(&comline);
- write_rindex(&comline, &rlist);
-
- write_root(&comline);
-
- write_quota(&comline);
-
- write_license(&comline);
-
- write_rgrps(&comline, &rlist);
-
- write_journals(&comline, &jlist);
-
-
- close(comline.fd);
-
-
- print_results(&comline);
-
-
- exit(EXIT_SUCCESS);
+ exit(EXIT_SUCCESS);
}
-
-
-
--- cluster/gfs/gfs_mkfs/mkfs_gfs.h 2005/01/05 01:49:05 1.3
+++ cluster/gfs/gfs_mkfs/mkfs_gfs.h 2006/07/10 23:39:35 1.4
@@ -115,7 +115,7 @@
uint64 rgrps; /* Number of rgrps */
int fd; /* fd of the device */
- struct gfs_sb *sb; /* A copy of the superblock */
+ struct gfs_sbd *sbd; /* A copy of the superblock */
uint64 fssize; /* size of the filesystem */
uint64 sb_addr;
@@ -178,7 +178,7 @@
/* structures.c */
-void write_sb(commandline_t *comline, osi_list_t *rlist);
+void write_mkfs_sb(commandline_t *comline, osi_list_t *rlist);
void write_jindex(commandline_t *comline, osi_list_t *jlist);
void write_rindex(commandline_t *comline, osi_list_t *rlist);
void write_root(commandline_t *comline);
--- cluster/gfs/gfs_mkfs/structures.c 2005/04/14 19:27:34 1.2
+++ cluster/gfs/gfs_mkfs/structures.c 2006/07/10 23:39:35 1.3
@@ -27,39 +27,13 @@
#include <linux/gfs_ondisk.h>
#include "osi_list.h"
#include "linux_endian.h"
-
+#include "libgfs.h"
#include "mkfs_gfs.h"
#define MKFS_ROOT_MODE (0755)
#define MKFS_HIDDEN_MODE (0600)
-
-#define do_lseek(fd, off) \
-{ \
- if (lseek((fd), (off), SEEK_SET) != (off)) \
- die("bad seek: %s on line %d of file %s\n", \
- strerror(errno),__LINE__, __FILE__); \
-}
-
-#define do_read(fd, buff, len) \
-{ \
- if (read((fd), (buff), (len)) != (len)) \
- die("bad read: %s on line %d of file %s\n", \
- strerror(errno), __LINE__, __FILE__); \
-}
-
-#define do_write(fd, buff, len) \
-{ \
- if (write((fd), (buff), (len)) != (len)) \
- die("bad write: %s on line %d of file %s\n", \
- strerror(errno), __LINE__, __FILE__); \
-}
-
-
-
-
-
/**
* rgblocks2bitblocks - blerg
* @bsize: the FS block size
@@ -102,132 +76,76 @@
/**
- * write_sb - write the superblock
+ * write_mkfs_sb - write the superblock
* @comline: the command line
* @rlist: the list of RGs
*
*/
-void write_sb(commandline_t *comline, osi_list_t *rlist)
+void write_mkfs_sb(commandline_t *comline, osi_list_t *rlist)
{
- struct gfs_sb *sb;
- uint64 jindex_dinode;
- char buf[comline->bsize];
- int x;
-
-
- memset(buf, 0, comline->bsize);
-
- for (x = 0; x < comline->sb_addr; x++)
- {
- do_lseek(comline->fd, x * comline->bsize);
- do_write(comline->fd, buf, comline->bsize);
- }
-
-
- /* Figure out the location of the journal index inode */
-
- {
- rgrp_list_t *rl = osi_list_entry(rlist->next, rgrp_list_t, list);
- uint32_t rgblocks, bitblocks;
-
- rgblocks = rl->rg_length;
- rgblocks2bitblocks(comline->bsize, &rgblocks, &bitblocks);
-
- jindex_dinode = rl->rg_offset + bitblocks;
- }
-
-
- /* Now, fill in the superblock */
-
- type_zalloc(sb, struct gfs_sb, 1);
- comline->sb = sb;
-
-
- sb->sb_header.mh_magic = GFS_MAGIC;
- sb->sb_header.mh_type = GFS_METATYPE_SB;
- sb->sb_header.mh_format = GFS_FORMAT_SB;
-
- sb->sb_fs_format = GFS_FORMAT_FS;
- sb->sb_multihost_format = GFS_FORMAT_MULTI;
-
- sb->sb_bsize = comline->bsize;
- sb->sb_bsize_shift = ffs(comline->bsize) - 1;
- sb->sb_seg_size = comline->seg_size;
-
- sb->sb_jindex_di.no_formal_ino = jindex_dinode;
- sb->sb_jindex_di.no_addr = jindex_dinode;
- sb->sb_rindex_di.no_formal_ino = jindex_dinode + 1;
- sb->sb_rindex_di.no_addr = jindex_dinode + 1;
- sb->sb_root_di.no_formal_ino = jindex_dinode + 4;
- sb->sb_root_di.no_addr = jindex_dinode + 4;
-
- strcpy(sb->sb_lockproto, comline->lockproto);
- strcpy(sb->sb_locktable, comline->locktable);
-
- sb->sb_quota_di.no_formal_ino = jindex_dinode + 2;
- sb->sb_quota_di.no_addr = jindex_dinode + 2;
- sb->sb_license_di.no_formal_ino = jindex_dinode + 3;
- sb->sb_license_di.no_addr = jindex_dinode + 3;
-
-
- gfs_sb_out(sb, buf);
-
-
- do_lseek(comline->fd, comline->sb_addr * comline->bsize);
- do_write(comline->fd, buf, comline->bsize);
-
-
- if (comline->debug)
- {
- printf("\nSuperblock:\n");
- gfs_sb_print(sb);
- }
-}
-
-
-/**
- * compute_height - give a file length and block size compute the file's height
- * @sz: the file size
- * @bsize: the blocksize
- *
- * Returns: the file height
- */
-
-static unsigned int compute_height(uint64 sz, unsigned int bsize)
-{
- uint32 diptrs = (bsize - sizeof(struct gfs_dinode)) / sizeof(uint64);
- uint32 inptrs = (bsize - sizeof(struct gfs_indirect)) / sizeof(uint64);
- unsigned int height;
- uint64 space, old_space;
-
-
- bsize -= sizeof(struct gfs_meta_header);
-
- height = 1;
- space = diptrs * bsize;
-
-
- for (;;)
- {
- if (sz <= space)
- break;
-
- old_space = space;
+ struct gfs_sbd *sbd;
+ uint64 jindex_dinode;
+ char buf[comline->bsize];
+ int x;
+
+ memset(buf, 0, comline->bsize);
+
+ for (x = 0; x < comline->sb_addr; x++) {
+ do_lseek(comline->fd, x * comline->bsize);
+ do_write(comline->fd, buf, comline->bsize);
+ }
- height++;
- space *= inptrs;
+ /* Figure out the location of the journal index inode */
+ {
+ rgrp_list_t *rl = osi_list_entry(rlist->next, rgrp_list_t, list);
+ uint32_t rgblocks, bitblocks;
+
+ rgblocks = rl->rg_length;
+ rgblocks2bitblocks(comline->bsize, &rgblocks, &bitblocks);
+
+ jindex_dinode = rl->rg_offset + bitblocks;
+ }
- if (space / inptrs != old_space ||
- space % inptrs != 0)
- break;
- }
+ /* Now, fill in the superblock */
+ type_zalloc(sbd, struct gfs_sbd, 1);
+ comline->sbd = sbd;
- return height;
+ sbd->sd_sb.sb_header.mh_magic = GFS_MAGIC;
+ sbd->sd_sb.sb_header.mh_type = GFS_METATYPE_SB;
+ sbd->sd_sb.sb_header.mh_format = GFS_FORMAT_SB;
+
+ sbd->sd_sb.sb_fs_format = GFS_FORMAT_FS;
+ sbd->sd_sb.sb_multihost_format = GFS_FORMAT_MULTI;
+
+ sbd->sd_sb.sb_bsize = comline->bsize;
+ sbd->sd_sb.sb_bsize_shift = ffs(comline->bsize) - 1;
+ sbd->sd_sb.sb_seg_size = comline->seg_size;
+
+ sbd->sd_sb.sb_jindex_di.no_formal_ino = jindex_dinode;
+ sbd->sd_sb.sb_jindex_di.no_addr = jindex_dinode;
+ sbd->sd_sb.sb_rindex_di.no_formal_ino = jindex_dinode + 1;
+ sbd->sd_sb.sb_rindex_di.no_addr = jindex_dinode + 1;
+ sbd->sd_sb.sb_root_di.no_formal_ino = jindex_dinode + 4;
+ sbd->sd_sb.sb_root_di.no_addr = jindex_dinode + 4;
+
+ strcpy(sbd->sd_sb.sb_lockproto, comline->lockproto);
+ strcpy(sbd->sd_sb.sb_locktable, comline->locktable);
+
+ sbd->sd_sb.sb_quota_di.no_formal_ino = jindex_dinode + 2;
+ sbd->sd_sb.sb_quota_di.no_addr = jindex_dinode + 2;
+ sbd->sd_sb.sb_license_di.no_formal_ino = jindex_dinode + 3;
+ sbd->sd_sb.sb_license_di.no_addr = jindex_dinode + 3;
+ sbd->sd_fsb2bb_shift = sbd->sd_sb.sb_bsize_shift - GFS_BASIC_BLOCK_SHIFT;
+
+ write_sb(comline->fd, sbd);
+ if (comline->debug) {
+ printf("\nSuperblock:\n");
+ gfs_sb_print(&sbd->sd_sb);
+ }
}
-
/**
* build_tree - build the pointers and indirect blocks for a file
* @comline: the command line
@@ -239,92 +157,79 @@
static void build_tree(commandline_t *comline, struct gfs_dinode *di, uint64 addr, unsigned int blocks)
{
- struct gfs_indirect ind;
- char *buf;
- unsigned int x, offset;
- unsigned int height;
- unsigned int indblocks;
- uint64 tmp_addr;
- unsigned int tmp_blocks;
-
+ struct gfs_indirect ind;
+ char *buf;
+ unsigned int x, offset;
+ unsigned int height;
+ unsigned int indblocks;
+ uint64 tmp_addr;
+ unsigned int tmp_blocks;
- di->di_height = compute_height(di->di_size, comline->bsize);
-
-
- if (di->di_height == 1)
- {
- type_zalloc(buf, char, comline->bsize);
-
- for (x = 0; x < blocks; x++)
- ((uint64 *)(buf + sizeof(struct gfs_dinode)))[x] = cpu_to_gfs64(addr + x);
-
- gfs_dinode_out(di, buf);
-
- do_lseek(comline->fd, di->di_num.no_addr * comline->bsize);
- do_write(comline->fd, buf, comline->bsize);
-
- free(buf);
- }
- else
- {
- tmp_addr = addr;
- tmp_blocks = blocks;
+ di->di_height = compute_height(comline->sbd, di->di_size);
+ if (di->di_height == 1) {
+ type_zalloc(buf, char, comline->bsize);
- for (height = di->di_height; height > 1; height--)
- {
- memset(&ind, 0, sizeof(struct gfs_indirect));
- ind.in_header.mh_magic = GFS_MAGIC;
- ind.in_header.mh_type = GFS_METATYPE_IN;
- ind.in_header.mh_format = GFS_FORMAT_IN;
+ for (x = 0; x < blocks; x++)
+ ((uint64 *)(buf + sizeof(struct gfs_dinode)))[x] = cpu_to_gfs64(addr + x);
+ gfs_dinode_out(di, buf);
- indblocks = DIV_RU((tmp_blocks * sizeof(uint64)),
- (comline->bsize - sizeof(struct gfs_indirect)));
+ do_lseek(comline->fd, di->di_num.no_addr * comline->bsize);
+ do_write(comline->fd, buf, comline->bsize);
- type_zalloc(buf, char, indblocks * comline->bsize);
-
-
- offset = 0;
- for (x = 0; x < tmp_blocks; x++)
- {
- if (!(offset % comline->bsize))
- {
- gfs_indirect_out(&ind, buf + offset);
- offset += sizeof(struct gfs_indirect);
+ free(buf);
}
+ else {
+ tmp_addr = addr;
+ tmp_blocks = blocks;
+
+ for (height = di->di_height; height > 1; height--) {
+ memset(&ind, 0, sizeof(struct gfs_indirect));
+ ind.in_header.mh_magic = GFS_MAGIC;
+ ind.in_header.mh_type = GFS_METATYPE_IN;
+ ind.in_header.mh_format = GFS_FORMAT_IN;
+
+ indblocks = DIV_RU((tmp_blocks * sizeof(uint64)),
+ (comline->bsize - sizeof(struct gfs_indirect)));
+
+ type_zalloc(buf, char, indblocks * comline->bsize);
+
+ offset = 0;
+ for (x = 0; x < tmp_blocks; x++) {
+ if (!(offset % comline->bsize)) {
+ gfs_indirect_out(&ind, buf + offset);
+ offset += sizeof(struct gfs_indirect);
+ }
+
+ *((uint64 *)(buf + offset)) = cpu_to_gfs64(tmp_addr + x);
+ offset += sizeof(uint64);
+ }
+
+ do_lseek(comline->fd, comline->rgrp0_next * comline->bsize);
+ do_write(comline->fd, buf, indblocks * comline->bsize);
+
+ free(buf);
+
+ tmp_addr = comline->rgrp0_next;
+ tmp_blocks = indblocks;
+
+ di->di_blocks += indblocks;
+
+ comline->rgrp0_next += indblocks;
+ }
+ type_zalloc(buf, char, comline->bsize);
- *((uint64 *)(buf + offset)) = cpu_to_gfs64(tmp_addr + x);
- offset += sizeof(uint64);
- }
-
-
- do_lseek(comline->fd, comline->rgrp0_next * comline->bsize);
- do_write(comline->fd, buf, indblocks * comline->bsize);
-
- free(buf);
-
- tmp_addr = comline->rgrp0_next;
- tmp_blocks = indblocks;
-
- di->di_blocks += indblocks;
-
- comline->rgrp0_next += indblocks;
- }
-
-
- type_zalloc(buf, char, comline->bsize);
-
- for (x = 0; x < tmp_blocks; x++)
- ((uint64 *)(buf + sizeof(struct gfs_dinode)))[x] = cpu_to_gfs64(tmp_addr + x);
+ for (x = 0; x < tmp_blocks; x++)
+ ((uint64 *)(buf + sizeof(struct gfs_dinode)))[x] = cpu_to_gfs64(tmp_addr + x);
- gfs_dinode_out(di, buf);
+ gfs_dinode_out(di, buf);
- do_lseek(comline->fd, di->di_num.no_addr * comline->bsize);
- do_write(comline->fd, buf, comline->bsize);
+ do_lseek(comline->fd, di->di_num.no_addr * comline->bsize);
+ do_write(comline->fd, buf, comline->bsize);
- free(buf);
- }
+ free(buf);
+ }
}
@@ -338,49 +243,41 @@
static char *fill_jindex(commandline_t *comline, osi_list_t *jlist)
{
- journal_list_t *jl;
- struct gfs_jindex ji;
- osi_list_t *tmp;
- char *buf;
- unsigned int j = 0;
-
-
- type_alloc(buf, char, comline->journals * sizeof(struct gfs_jindex));
-
-
- for (tmp = jlist->next; tmp != jlist; tmp = tmp->next)
- {
- jl = osi_list_entry(tmp, journal_list_t, list);
-
- memset(&ji, 0, sizeof(struct gfs_jindex));
-
- ji.ji_addr = jl->start;
- ji.ji_nsegment = jl->segments;
+ journal_list_t *jl;
+ struct gfs_jindex ji;
+ osi_list_t *tmp;
+ char *buf;
+ unsigned int j = 0;
+
+ type_alloc(buf, char, comline->journals * sizeof(struct gfs_jindex));
- gfs_jindex_out(&ji, buf + j * sizeof(struct gfs_jindex));
+ for (tmp = jlist->next; tmp != jlist; tmp = tmp->next) {
+ jl = osi_list_entry(tmp, journal_list_t, list);
- j++;
- }
+ memset(&ji, 0, sizeof(struct gfs_jindex));
+ ji.ji_addr = jl->start;
+ ji.ji_nsegment = jl->segments;
- if (comline->debug)
- {
- printf("\nJournal Index data:\n");
+ gfs_jindex_out(&ji, buf + j * sizeof(struct gfs_jindex));
- for (j = 0; j < comline->journals; j++)
- {
- gfs_jindex_in(&ji, buf + j * sizeof(struct gfs_jindex));
+ j++;
+ }
- printf("\n Journal %d\n", j);
- gfs_jindex_print(&ji);
- }
- }
+ if (comline->debug) {
+ printf("\nJournal Index data:\n");
+ for (j = 0; j < comline->journals; j++) {
+ gfs_jindex_in(&ji, buf + j * sizeof(struct gfs_jindex));
+
+ printf("\n Journal %d\n", j);
+ gfs_jindex_print(&ji);
+ }
+ }
- return buf;
+ return buf;
}
-
/**
* write_jindex - write out the journal index
* @comline: the command line
@@ -390,96 +287,82 @@
void write_jindex(commandline_t *comline, osi_list_t *jlist)
{
- struct gfs_dinode di;
- struct gfs_meta_header jd;
- char *buf, *data;
- uint64 addr;
- unsigned int blocks;
- unsigned int x, left, jbsize = comline->bsize - sizeof(struct gfs_meta_header);
-
+ struct gfs_dinode di;
+ struct gfs_meta_header jd;
+ char *buf, *data;
+ uint64 addr;
+ unsigned int blocks;
+ unsigned int x, left, jbsize = comline->bsize - sizeof(struct gfs_meta_header);
- memset(&di, 0, sizeof(struct gfs_dinode));
+ memset(&di, 0, sizeof(struct gfs_dinode));
- di.di_header.mh_magic = GFS_MAGIC;
- di.di_header.mh_type = GFS_METATYPE_DI;
- di.di_header.mh_format = GFS_FORMAT_DI;
-
- di.di_num = comline->sb->sb_jindex_di;
-
- di.di_mode = MKFS_HIDDEN_MODE;
- di.di_nlink = 1;
- di.di_size = comline->journals * sizeof(struct gfs_jindex);
- di.di_blocks = 1;
- di.di_atime = di.di_mtime = di.di_ctime = time(NULL);
-
- di.di_flags = GFS_DIF_JDATA;
- di.di_payload_format = GFS_FORMAT_JI;
- di.di_type = GFS_FILE_REG;
-
-
- data = fill_jindex(comline, jlist);
-
+ di.di_header.mh_magic = GFS_MAGIC;
+ di.di_header.mh_type = GFS_METATYPE_DI;
+ di.di_header.mh_format = GFS_FORMAT_DI;
- if (di.di_size < comline->bsize - sizeof(struct gfs_dinode))
- {
- type_zalloc(buf, char, comline->bsize);
+ di.di_num = comline->sbd->sd_sb.sb_jindex_di;
- gfs_dinode_out(&di, buf);
+ di.di_mode = MKFS_HIDDEN_MODE;
+ di.di_nlink = 1;
+ di.di_size = comline->journals * sizeof(struct gfs_jindex);
+ di.di_blocks = 1;
+ di.di_atime = di.di_mtime = di.di_ctime = time(NULL);
- memcpy(buf + sizeof(struct gfs_dinode), data, comline->journals * sizeof(struct gfs_jindex));
+ di.di_flags = GFS_DIF_JDATA;
+ di.di_payload_format = GFS_FORMAT_JI;
+ di.di_type = GFS_FILE_REG;
- do_lseek(comline->fd, di.di_num.no_addr * comline->bsize);
- do_write(comline->fd, buf, comline->bsize);
+ data = fill_jindex(comline, jlist);
- free(buf);
- }
- else
- {
- blocks = DIV_RU(di.di_size, (comline->bsize - sizeof(struct gfs_meta_header)));
- di.di_blocks += blocks;
+ if (di.di_size < comline->bsize - sizeof(struct gfs_dinode)) {
+ type_zalloc(buf, char, comline->bsize);
- addr = comline->rgrp0_next;
+ gfs_dinode_out(&di, buf);
+ memcpy(buf + sizeof(struct gfs_dinode), data, comline->journals * sizeof(struct gfs_jindex));
- memset(&jd, 0, sizeof(struct gfs_meta_header));
- jd.mh_magic = GFS_MAGIC;
- jd.mh_type = GFS_METATYPE_JD;
- jd.mh_format = GFS_FORMAT_JD;
-
-
- type_zalloc(buf, char, blocks * comline->bsize);
-
- left = comline->journals * sizeof(struct gfs_jindex);
- for (x = 0; x < blocks; x++)
- {
- gfs_meta_header_out(&jd, buf + x * comline->bsize);
- memcpy(buf + x * comline->bsize + sizeof(struct gfs_meta_header),
- data + x * jbsize,
- (left > jbsize) ? jbsize : left);
- left -= jbsize;
- }
-
-
- do_lseek(comline->fd, addr * comline->bsize);
- do_write(comline->fd, buf, blocks * comline->bsize);
-
- free(buf);
+ do_lseek(comline->fd, di.di_num.no_addr * comline->bsize);
+ do_write(comline->fd, buf, comline->bsize);
+ free(buf);
+ }
+ else {
+ blocks = DIV_RU(di.di_size, (comline->bsize - sizeof(struct gfs_meta_header)));
+ di.di_blocks += blocks;
+
+ addr = comline->rgrp0_next;
+ memset(&jd, 0, sizeof(struct gfs_meta_header));
+ jd.mh_magic = GFS_MAGIC;
+ jd.mh_type = GFS_METATYPE_JD;
+ jd.mh_format = GFS_FORMAT_JD;
+
+ type_zalloc(buf, char, blocks * comline->bsize);
+
+ left = comline->journals * sizeof(struct gfs_jindex);
+ for (x = 0; x < blocks; x++) {
+ gfs_meta_header_out(&jd, buf + x * comline->bsize);
+ memcpy(buf + x * comline->bsize + sizeof(struct gfs_meta_header),
+ data + x * jbsize,
+ (left > jbsize) ? jbsize : left);
+ left -= jbsize;
+ }
- comline->rgrp0_next += blocks;
+ do_lseek(comline->fd, addr * comline->bsize);
+ do_write(comline->fd, buf, blocks * comline->bsize);
- build_tree(comline, &di, addr, blocks);
- }
+ free(buf);
+ comline->rgrp0_next += blocks;
- free(data);
+ build_tree(comline, &di, addr, blocks);
+ }
+ free(data);
- if (comline->debug)
- {
- printf("\nJournal index dinode:\n");
- gfs_dinode_print(&di);
- }
+ if (comline->debug) {
+ printf("\nJournal index dinode:\n");
+ gfs_dinode_print(&di);
+ }
}
@@ -493,61 +376,52 @@
static char *fill_rindex(commandline_t *comline, osi_list_t *rlist)
{
- struct gfs_rindex *ri, rindex;
- rgrp_list_t *rl;
- osi_list_t *tmp;
- char *buf;
- unsigned int r = 0;
- uint32 rgblocks, bitblocks;
-
-
- type_alloc(buf, char, comline->rgrps * sizeof(struct gfs_rindex));
+ struct gfs_rindex *ri, rindex;
+ rgrp_list_t *rl;
+ osi_list_t *tmp;
+ char *buf;
+ unsigned int r = 0;
+ uint32 rgblocks, bitblocks;
+ type_alloc(buf, char, comline->rgrps * sizeof(struct gfs_rindex));
- for (tmp = rlist->next; tmp != rlist; tmp = tmp->next)
- {
- rl = osi_list_entry(tmp, rgrp_list_t, list);
-
- rgblocks = rl->rg_length;
- rgblocks2bitblocks(comline->bsize, &rgblocks, &bitblocks);
-
- type_zalloc(ri, struct gfs_rindex, 1);
- rl->ri = ri;
-
- ri->ri_addr = rl->rg_offset;
- ri->ri_length = bitblocks;
-
- ri->ri_data1 = rl->rg_offset + bitblocks;
- ri->ri_data = rgblocks;
-
- ri->ri_bitbytes = rgblocks / GFS_NBBY;
-
- gfs_rindex_out(ri, buf + r * sizeof(struct gfs_rindex));
+ for (tmp = rlist->next; tmp != rlist; tmp = tmp->next) {
+ rl = osi_list_entry(tmp, rgrp_list_t, list);
+
+ rgblocks = rl->rg_length;
+ rgblocks2bitblocks(comline->bsize, &rgblocks, &bitblocks);
- comline->fssize += rgblocks;
+ type_zalloc(ri, struct gfs_rindex, 1);
+ rl->ri = ri;
+
+ ri->ri_addr = rl->rg_offset;
+ ri->ri_length = bitblocks;
- r++;
- }
+ ri->ri_data1 = rl->rg_offset + bitblocks;
+ ri->ri_data = rgblocks;
+ ri->ri_bitbytes = rgblocks / GFS_NBBY;
- if (comline->debug)
- {
- printf("\nResource Index data:\n");
+ gfs_rindex_out(ri, buf + r * sizeof(struct gfs_rindex));
+
+ comline->fssize += rgblocks;
- for (r = 0; r < comline->rgrps; r++)
- {
- gfs_rindex_in(&rindex, buf + r * sizeof(struct gfs_rindex));
+ r++;
+ }
- printf("\n Resource index %d\n", r);
- gfs_rindex_print(&rindex);
- }
- }
+ if (comline->debug) {
+ printf("\nResource Index data:\n");
+ for (r = 0; r < comline->rgrps; r++) {
+ gfs_rindex_in(&rindex, buf + r * sizeof(struct gfs_rindex));
- return buf;
+ printf("\n Resource index %d\n", r);
+ gfs_rindex_print(&rindex);
+ }
+ }
+ return buf;
}
-
/**
* write_rindex - write out the resource group index
* @comline: the command line
@@ -557,96 +431,83 @@
void write_rindex(commandline_t *comline, osi_list_t *rlist)
{
- struct gfs_dinode di;
- struct gfs_meta_header jd;
- char *buf, *data;
- uint64 addr;
- unsigned int blocks;
- unsigned int x, left, jbsize = comline->bsize - sizeof(struct gfs_meta_header);
-
-
- memset(&di, 0, sizeof(struct gfs_dinode));
+ struct gfs_dinode di;
+ struct gfs_meta_header jd;
+ char *buf, *data;
+ uint64 addr;
+ unsigned int blocks;
+ unsigned int x, left, jbsize = comline->bsize - sizeof(struct gfs_meta_header);
- di.di_header.mh_magic = GFS_MAGIC;
- di.di_header.mh_type = GFS_METATYPE_DI;
- di.di_header.mh_format = GFS_FORMAT_DI;
+ memset(&di, 0, sizeof(struct gfs_dinode));
- di.di_num = comline->sb->sb_rindex_di;
+ di.di_header.mh_magic = GFS_MAGIC;
+ di.di_header.mh_type = GFS_METATYPE_DI;
+ di.di_header.mh_format = GFS_FORMAT_DI;
- di.di_mode = MKFS_HIDDEN_MODE;
- di.di_nlink = 1;
- di.di_size = comline->rgrps * sizeof(struct gfs_rindex);
- di.di_blocks = 1;
- di.di_atime = di.di_mtime = di.di_ctime = time(NULL);
+ di.di_num = comline->sbd->sd_sb.sb_rindex_di;
- di.di_flags = GFS_DIF_JDATA;
- di.di_payload_format = GFS_FORMAT_RI;
- di.di_type = GFS_FILE_REG;
+ di.di_mode = MKFS_HIDDEN_MODE;
+ di.di_nlink = 1;
+ di.di_size = comline->rgrps * sizeof(struct gfs_rindex);
+ di.di_blocks = 1;
+ di.di_atime = di.di_mtime = di.di_ctime = time(NULL);
+ di.di_flags = GFS_DIF_JDATA;
+ di.di_payload_format = GFS_FORMAT_RI;
+ di.di_type = GFS_FILE_REG;
- data = fill_rindex(comline, rlist);
+ data = fill_rindex(comline, rlist);
+ if (di.di_size < comline->bsize - sizeof(struct gfs_dinode)) {
+ type_zalloc(buf, char, comline->bsize);
- if (di.di_size < comline->bsize - sizeof(struct gfs_dinode))
- {
- type_zalloc(buf, char, comline->bsize);
-
- gfs_dinode_out(&di, buf);
+ gfs_dinode_out(&di, buf);
- memcpy(buf + sizeof(struct gfs_dinode), data, comline->rgrps * sizeof(struct gfs_rindex));
-
- do_lseek(comline->fd, di.di_num.no_addr * comline->bsize);
- do_write(comline->fd, buf, comline->bsize);
-
- free(buf);
- }
- else
- {
- blocks = DIV_RU(di.di_size, (comline->bsize - sizeof(struct gfs_meta_header)));
- di.di_blocks += blocks;
-
- addr = comline->rgrp0_next;
-
-
- memset(&jd, 0, sizeof(struct gfs_meta_header));
- jd.mh_magic = GFS_MAGIC;
- jd.mh_type = GFS_METATYPE_JD;
- jd.mh_format = GFS_FORMAT_JD;
-
+ memcpy(buf + sizeof(struct gfs_dinode), data, comline->rgrps * sizeof(struct gfs_rindex));
- type_zalloc(buf, char, blocks * comline->bsize);
-
- left = comline->rgrps * sizeof(struct gfs_rindex);
- for (x = 0; x < blocks; x++)
- {
- gfs_meta_header_out(&jd, buf + x * comline->bsize);
- memcpy(buf + x * comline->bsize + sizeof(struct gfs_meta_header),
- data + x * jbsize,
- (left > jbsize) ? jbsize : left);
- left -= jbsize;
- }
-
-
- do_lseek(comline->fd, addr * comline->bsize);
- do_write(comline->fd, buf, blocks * comline->bsize);
-
- free(buf);
+ do_lseek(comline->fd, di.di_num.no_addr * comline->bsize);
+ do_write(comline->fd, buf, comline->bsize);
+ free(buf);
+ }
+ else {
+ blocks = DIV_RU(di.di_size, (comline->bsize - sizeof(struct gfs_meta_header)));
+ di.di_blocks += blocks;
+
+ addr = comline->rgrp0_next;
+
+ memset(&jd, 0, sizeof(struct gfs_meta_header));
+ jd.mh_magic = GFS_MAGIC;
+ jd.mh_type = GFS_METATYPE_JD;
+ jd.mh_format = GFS_FORMAT_JD;
+
+ type_zalloc(buf, char, blocks * comline->bsize);
+
+ left = comline->rgrps * sizeof(struct gfs_rindex);
+ for (x = 0; x < blocks; x++) {
+ gfs_meta_header_out(&jd, buf + x * comline->bsize);
+ memcpy(buf + x * comline->bsize + sizeof(struct gfs_meta_header),
+ data + x * jbsize,
+ (left > jbsize) ? jbsize : left);
+ left -= jbsize;
+ }
- comline->rgrp0_next += blocks;
+ do_lseek(comline->fd, addr * comline->bsize);
+ do_write(comline->fd, buf, blocks * comline->bsize);
- build_tree(comline, &di, addr, blocks);
- }
+ free(buf);
+ comline->rgrp0_next += blocks;
- free(data);
+ build_tree(comline, &di, addr, blocks);
+ }
+ free(data);
- if (comline->debug)
- {
- printf("\nResource index dinode:\n");
- gfs_dinode_print(&di);
- }
+ if (comline->debug) {
+ printf("\nResource index dinode:\n");
+ gfs_dinode_print(&di);
+ }
}
@@ -658,89 +519,78 @@
void write_root(commandline_t *comline)
{
- struct gfs_dinode di;
- struct gfs_dirent de;
-
- char buf[comline->bsize];
-
-
- memset(&di, 0, sizeof(struct gfs_dinode));
- memset(buf, 0, comline->bsize);
-
-
- di.di_header.mh_magic = GFS_MAGIC;
- di.di_header.mh_type = GFS_METATYPE_DI;
- di.di_header.mh_format = GFS_FORMAT_DI;
+ struct gfs_dinode di;
+ struct gfs_dirent de;
+ char buf[comline->bsize];
- di.di_num = comline->sb->sb_root_di;
+ memset(&di, 0, sizeof(struct gfs_dinode));
+ memset(buf, 0, comline->bsize);
- di.di_mode = MKFS_ROOT_MODE;
- di.di_nlink = 2;
- di.di_size = comline->bsize - sizeof(struct gfs_dinode);
- di.di_blocks = 1;
- di.di_atime = di.di_mtime = di.di_ctime = time(NULL);
+ di.di_header.mh_magic = GFS_MAGIC;
+ di.di_header.mh_type = GFS_METATYPE_DI;
+ di.di_header.mh_format = GFS_FORMAT_DI;
- di.di_flags = GFS_DIF_JDATA;
- di.di_payload_format = GFS_FORMAT_DE;
- di.di_type = GFS_FILE_DIR;
+ di.di_num = comline->sbd->sd_sb.sb_root_di;
- di.di_entries = 2;
+ di.di_mode = MKFS_ROOT_MODE;
+ di.di_nlink = 2;
+ di.di_size = comline->bsize - sizeof(struct gfs_dinode);
+ di.di_blocks = 1;
+ di.di_atime = di.di_mtime = di.di_ctime = time(NULL);
- gfs_dinode_out(&di, buf);
+ di.di_flags = GFS_DIF_JDATA;
+ di.di_payload_format = GFS_FORMAT_DE;
+ di.di_type = GFS_FILE_DIR;
+ di.di_entries = 2;
- /* Fill in . */
+ gfs_dinode_out(&di, buf);
- memset(&de, 0, sizeof(struct gfs_dirent));
+ /* Fill in . */
- de.de_inum = comline->sb->sb_root_di;
- de.de_hash = gfs_dir_hash(".", 1);
- de.de_rec_len = GFS_DIRENT_SIZE(1);
- de.de_name_len = 1;
- de.de_type = GFS_FILE_DIR;
+ memset(&de, 0, sizeof(struct gfs_dirent));
- gfs_dirent_out(&de, buf + sizeof(struct gfs_dinode));
- memcpy(buf + sizeof(struct gfs_dinode) + sizeof(struct gfs_dirent), ".", 1);
+ de.de_inum = comline->sbd->sd_sb.sb_root_di;
+ de.de_hash = gfs_dir_hash(".", 1);
+ de.de_rec_len = GFS_DIRENT_SIZE(1);
+ de.de_name_len = 1;
+ de.de_type = GFS_FILE_DIR;
- if (comline->debug)
- {
- printf("\nRoot Dinode dirent:\n");
- gfs_dirent_print(&de, ".");
- }
+ gfs_dirent_out(&de, buf + sizeof(struct gfs_dinode));
+ memcpy(buf + sizeof(struct gfs_dinode) + sizeof(struct gfs_dirent), ".", 1);
+ if (comline->debug) {
+ printf("\nRoot Dinode dirent:\n");
+ gfs_dirent_print(&de, ".");
+ }
- /* Fill in .. */
-
- memset(&de, 0, sizeof(struct gfs_dirent));
-
- de.de_inum = comline->sb->sb_root_di;
- de.de_hash = gfs_dir_hash("..", 2);
- de.de_rec_len = comline->bsize - GFS_DIRENT_SIZE(1) - sizeof(struct gfs_dinode);
- de.de_name_len = 2;
- de.de_type = GFS_FILE_DIR;
-
- gfs_dirent_out(&de, buf + sizeof(struct gfs_dinode) + GFS_DIRENT_SIZE(1));
- memcpy(buf + sizeof(struct gfs_dinode) + GFS_DIRENT_SIZE(1) + sizeof(struct gfs_dirent), "..", 2);
-
- if (comline->debug)
- {
- printf("\nRoot Dinode dirent:\n");
- gfs_dirent_print(&de, "..");
- }
+ /* Fill in .. */
+ memset(&de, 0, sizeof(struct gfs_dirent));
- do_lseek(comline->fd, di.di_num.no_addr * comline->bsize);
- do_write(comline->fd, buf, comline->bsize);
+ de.de_inum = comline->sbd->sd_sb.sb_root_di;
+ de.de_hash = gfs_dir_hash("..", 2);
+ de.de_rec_len = comline->bsize - GFS_DIRENT_SIZE(1) - sizeof(struct gfs_dinode);
+ de.de_name_len = 2;
+ de.de_type = GFS_FILE_DIR;
+
+ gfs_dirent_out(&de, buf + sizeof(struct gfs_dinode) + GFS_DIRENT_SIZE(1));
+ memcpy(buf + sizeof(struct gfs_dinode) + GFS_DIRENT_SIZE(1) + sizeof(struct gfs_dirent), "..", 2);
+
+ if (comline->debug) {
+ printf("\nRoot Dinode dirent:\n");
+ gfs_dirent_print(&de, "..");
+ }
+ do_lseek(comline->fd, di.di_num.no_addr * comline->bsize);
+ do_write(comline->fd, buf, comline->bsize);
- if (comline->debug)
- {
- printf("\nRoot dinode:\n");
- gfs_dinode_print(&di);
- }
+ if (comline->debug) {
+ printf("\nRoot dinode:\n");
+ gfs_dinode_print(&di);
+ }
}
-
/**
* write_quota - write out the quota dinode
* @comline: the command line
@@ -749,75 +599,65 @@
void write_quota(commandline_t *comline)
{
- struct gfs_dinode di;
- struct gfs_quota qu;
-
- char buf[comline->bsize];
-
-
- memset(&di, 0, sizeof(struct gfs_dinode));
- memset(buf, 0, comline->bsize);
-
+ struct gfs_dinode di;
+ struct gfs_quota qu;
- di.di_header.mh_magic = GFS_MAGIC;
- di.di_header.mh_type = GFS_METATYPE_DI;
- di.di_header.mh_format = GFS_FORMAT_DI;
+ char buf[comline->bsize];
- di.di_num = comline->sb->sb_quota_di;
+ memset(&di, 0, sizeof(struct gfs_dinode));
+ memset(buf, 0, comline->bsize);
- di.di_mode = MKFS_HIDDEN_MODE;
- di.di_nlink = 1;
- di.di_size = 2 * sizeof(struct gfs_quota);
- di.di_blocks = 1;
- di.di_atime = di.di_mtime = di.di_ctime = time(NULL);
+ di.di_header.mh_magic = GFS_MAGIC;
+ di.di_header.mh_type = GFS_METATYPE_DI;
+ di.di_header.mh_format = GFS_FORMAT_DI;
- di.di_flags = GFS_DIF_JDATA;
- di.di_payload_format = GFS_FORMAT_QU;
- di.di_type = GFS_FILE_REG;
+ di.di_num = comline->sbd->sd_sb.sb_quota_di;
- gfs_dinode_out(&di, buf);
+ di.di_mode = MKFS_HIDDEN_MODE;
+ di.di_nlink = 1;
+ di.di_size = 2 * sizeof(struct gfs_quota);
+ di.di_blocks = 1;
+ di.di_atime = di.di_mtime = di.di_ctime = time(NULL);
+ di.di_flags = GFS_DIF_JDATA;
+ di.di_payload_format = GFS_FORMAT_QU;
+ di.di_type = GFS_FILE_REG;
- /* Fill in the root user quota */
+ gfs_dinode_out(&di, buf);
- memset(&qu, 0, sizeof(struct gfs_quota));
- qu.qu_value = comline->rgrp0_next - comline->sb->sb_jindex_di.no_addr;
+ /* Fill in the root user quota */
- gfs_quota_out(&qu, buf + sizeof(struct gfs_dinode));
+ memset(&qu, 0, sizeof(struct gfs_quota));
+ qu.qu_value = comline->rgrp0_next - comline->sbd->sd_sb.sb_jindex_di.no_addr;
- if (comline->debug)
- {
- printf("\nRoot user quota:\n");
- gfs_quota_print(&qu);
- }
+ gfs_quota_out(&qu, buf + sizeof(struct gfs_dinode));
+ if (comline->debug) {
+ printf("\nRoot user quota:\n");
+ gfs_quota_print(&qu);
+ }
- /* Fill in the root group quota */
-
- memset(&qu, 0, sizeof(struct gfs_quota));
- qu.qu_value = comline->rgrp0_next - comline->sb->sb_jindex_di.no_addr;
-
- gfs_quota_out(&qu, buf + sizeof(struct gfs_dinode) + sizeof(struct gfs_quota));
+ /* Fill in the root group quota */
- if (comline->debug)
- {
- printf("\nRoot group quota:\n");
- gfs_quota_print(&qu);
- }
+ memset(&qu, 0, sizeof(struct gfs_quota));
+ qu.qu_value = comline->rgrp0_next - comline->sbd->sd_sb.sb_jindex_di.no_addr;
+ gfs_quota_out(&qu, buf + sizeof(struct gfs_dinode) + sizeof(struct gfs_quota));
- do_lseek(comline->fd, di.di_num.no_addr * comline->bsize);
- do_write(comline->fd, buf, comline->bsize);
+ if (comline->debug) {
+ printf("\nRoot group quota:\n");
+ gfs_quota_print(&qu);
+ }
+ do_lseek(comline->fd, di.di_num.no_addr * comline->bsize);
+ do_write(comline->fd, buf, comline->bsize);
- if (comline->debug)
- {
- printf("\nQuota dinode:\n");
- gfs_dinode_print(&di);
- }
+ if (comline->debug) {
+ printf("\nQuota dinode:\n");
+ gfs_dinode_print(&di);
+ }
}
-
/**
* write_license - write out the quota dinode
* @comline: the command line
@@ -826,46 +666,41 @@
void write_license(commandline_t *comline)
{
- struct gfs_dinode di;
+ struct gfs_dinode di;
- char buf[comline->bsize];
+ char buf[comline->bsize];
+ memset(&di, 0, sizeof(struct gfs_dinode));
+ memset(buf, 0, comline->bsize);
- memset(&di, 0, sizeof(struct gfs_dinode));
- memset(buf, 0, comline->bsize);
+ di.di_header.mh_magic = GFS_MAGIC;
+ di.di_header.mh_type = GFS_METATYPE_DI;
+ di.di_header.mh_format = GFS_FORMAT_DI;
+ di.di_num = comline->sbd->sd_sb.sb_license_di;
- di.di_header.mh_magic = GFS_MAGIC;
- di.di_header.mh_type = GFS_METATYPE_DI;
- di.di_header.mh_format = GFS_FORMAT_DI;
+ di.di_mode = MKFS_HIDDEN_MODE;
+ di.di_nlink = 1;
+ di.di_size = 0;
+ di.di_blocks = 1;
+ di.di_atime = di.di_mtime = di.di_ctime = time(NULL);
- di.di_num = comline->sb->sb_license_di;
+ di.di_flags = GFS_DIF_JDATA;
+ di.di_payload_format = GFS_FORMAT_QU;
+ di.di_type = GFS_FILE_REG;
- di.di_mode = MKFS_HIDDEN_MODE;
- di.di_nlink = 1;
- di.di_size = 0;
- di.di_blocks = 1;
- di.di_atime = di.di_mtime = di.di_ctime = time(NULL);
+ gfs_dinode_out(&di, buf);
- di.di_flags = GFS_DIF_JDATA;
- di.di_payload_format = GFS_FORMAT_QU;
- di.di_type = GFS_FILE_REG;
+ do_lseek(comline->fd, di.di_num.no_addr * comline->bsize);
+ do_write(comline->fd, buf, comline->bsize);
- gfs_dinode_out(&di, buf);
-
- do_lseek(comline->fd, di.di_num.no_addr * comline->bsize);
- do_write(comline->fd, buf, comline->bsize);
-
-
- if (comline->debug)
- {
- printf("\nLicense dinode:\n");
- gfs_dinode_print(&di);
- }
+ if (comline->debug) {
+ printf("\nLicense dinode:\n");
+ gfs_dinode_print(&di);
+ }
}
-
/**
* write_rgrps - write out the resource group headers
* @comline: the command line
@@ -875,110 +710,96 @@
void write_rgrps(commandline_t *comline, osi_list_t *rlist)
{
- struct gfs_rgrp rg;
- struct gfs_meta_header rb;
- rgrp_list_t *rl;
- osi_list_t *tmp;
- char *buf, *data;
- unsigned int x, offset;
- unsigned int byte, bit;
- unsigned int blk_count;
- unsigned int r = 0;
-
-
- memset(&rb, 0, sizeof(struct gfs_meta_header));
- rb.mh_magic = GFS_MAGIC;
- rb.mh_type = GFS_METATYPE_RB;
- rb.mh_format = GFS_FORMAT_RB;
-
-
- for (tmp = rlist->next; tmp != rlist; tmp = tmp->next)
- {
- rl = osi_list_entry(tmp, rgrp_list_t, list);
-
- memset(&rg, 0, sizeof(struct gfs_rgrp));
- rg.rg_header.mh_magic = GFS_MAGIC;
- rg.rg_header.mh_type = GFS_METATYPE_RG;
- rg.rg_header.mh_format = GFS_FORMAT_RG;
- rg.rg_free = rl->ri->ri_data;
-
- type_zalloc(data, char, rl->ri->ri_bitbytes);
- type_zalloc(buf, char, rl->ri->ri_length * comline->bsize);
-
-
- /* Deal with the special case of the first dinode */
-
- if (!r)
- {
- if (comline->rgrp0_next > rl->ri->ri_data1 + rl->ri->ri_data)
- die("RG 0 is full.\n");
-
- /* Compensate for the hidden dinodes */
-
- *data = (GFS_BLKST_USEDMETA << 3 * GFS_BIT_SIZE) |
- (GFS_BLKST_USEDMETA << 2 * GFS_BIT_SIZE) |
- (GFS_BLKST_USEDMETA << GFS_BIT_SIZE) |
- GFS_BLKST_USEDMETA;
- *(data + 1) = GFS_BLKST_USEDMETA;
- rg.rg_free -= 5;
- rg.rg_useddi = 5;
-
- /* Compensate for the data the hidden dinodes point to */
-
- for (x = rl->ri->ri_data1 + 5; x < comline->rgrp0_next; x++)
- {
- byte = (x - rl->ri->ri_data1) / GFS_NBBY;
- bit = (x - rl->ri->ri_data1) % GFS_NBBY;
-
- data[byte] |= GFS_BLKST_USEDMETA << (bit * GFS_BIT_SIZE);
-
- rg.rg_free--;
- rg.rg_usedmeta++;
- }
- }
-
-
- gfs_rgrp_out(&rg, buf);
- offset = sizeof(struct gfs_rgrp);
- blk_count = 1;
-
- for (x = 0; x < rl->ri->ri_bitbytes; x++)
- {
- if (!(offset % comline->bsize))
- {
- gfs_meta_header_out(&rb, buf + offset);
- offset += sizeof(struct gfs_meta_header);
- blk_count++;
- }
-
- buf[offset] = data[x];
- offset++;
- }
-
- if (blk_count != rl->ri->ri_length)
- die("RG underflow (rg = %u, blk_count = %u, rl->ri->ri_length = %u)\n",
- r, blk_count, rl->ri->ri_length);
-
-
- do_lseek(comline->fd, rl->ri->ri_addr * comline->bsize);
- do_write(comline->fd, buf, rl->ri->ri_length * comline->bsize);
-
+ struct gfs_rgrp rg;
+ struct gfs_meta_header rb;
+ rgrp_list_t *rl;
+ osi_list_t *tmp;
+ char *buf, *data;
+ unsigned int x, offset;
+ unsigned int byte, bit;
+ unsigned int blk_count;
+ unsigned int r = 0;
+
+ memset(&rb, 0, sizeof(struct gfs_meta_header));
+ rb.mh_magic = GFS_MAGIC;
+ rb.mh_type = GFS_METATYPE_RB;
+ rb.mh_format = GFS_FORMAT_RB;
+
+ for (tmp = rlist->next; tmp != rlist; tmp = tmp->next) {
+ rl = osi_list_entry(tmp, rgrp_list_t, list);
+
+ memset(&rg, 0, sizeof(struct gfs_rgrp));
+ rg.rg_header.mh_magic = GFS_MAGIC;
+ rg.rg_header.mh_type = GFS_METATYPE_RG;
+ rg.rg_header.mh_format = GFS_FORMAT_RG;
+ rg.rg_free = rl->ri->ri_data;
+
+ type_zalloc(data, char, rl->ri->ri_bitbytes);
+ type_zalloc(buf, char, rl->ri->ri_length * comline->bsize);
+
+ /* Deal with the special case of the first dinode */
+
+ if (!r) {
+ if (comline->rgrp0_next > rl->ri->ri_data1 + rl->ri->ri_data)
+ die("RG 0 is full.\n");
+
+ /* Compensate for the hidden dinodes */
+
+ *data = (GFS_BLKST_USEDMETA << 3 * GFS_BIT_SIZE) |
+ (GFS_BLKST_USEDMETA << 2 * GFS_BIT_SIZE) |
+ (GFS_BLKST_USEDMETA << GFS_BIT_SIZE) |
+ GFS_BLKST_USEDMETA;
+ *(data + 1) = GFS_BLKST_USEDMETA;
+ rg.rg_free -= 5;
+ rg.rg_useddi = 5;
+
+ /* Compensate for the data the hidden dinodes point to */
+
+ for (x = rl->ri->ri_data1 + 5; x < comline->rgrp0_next; x++) {
+ byte = (x - rl->ri->ri_data1) / GFS_NBBY;
+ bit = (x - rl->ri->ri_data1) % GFS_NBBY;
+
+ data[byte] |= GFS_BLKST_USEDMETA << (bit * GFS_BIT_SIZE);
+
+ rg.rg_free--;
+ rg.rg_usedmeta++;
+ }
+ }
- free(buf);
- free(data);
+ gfs_rgrp_out(&rg, buf);
+ offset = sizeof(struct gfs_rgrp);
+ blk_count = 1;
+
+ for (x = 0; x < rl->ri->ri_bitbytes; x++) {
+ if (!(offset % comline->bsize)) {
+ gfs_meta_header_out(&rb, buf + offset);
+ offset += sizeof(struct gfs_meta_header);
+ blk_count++;
+ }
+ buf[offset] = data[x];
+ offset++;
+ }
- if (comline->debug)
- {
- printf("\nResource group header %d\n", r);
- gfs_rgrp_print(&rg);
- }
+ if (blk_count != rl->ri->ri_length)
+ die("RG underflow (rg = %u, blk_count = %u, rl->ri->ri_length = %u)\n",
+ r, blk_count, rl->ri->ri_length);
+
+ do_lseek(comline->fd, rl->ri->ri_addr * comline->bsize);
+ do_write(comline->fd, buf, rl->ri->ri_length * comline->bsize);
+
+ free(buf);
+ free(data);
+
+ if (comline->debug) {
+ printf("\nResource group header %d\n", r);
+ gfs_rgrp_print(&rg);
+ }
- r++;
- }
+ r++;
+ }
}
-
/**
* write_journals - write out the journal log headers
* @comline: the command line
@@ -988,55 +809,48 @@
void write_journals(commandline_t *comline, osi_list_t *jlist)
{
- struct gfs_log_header lh;
- journal_list_t *jl;
- osi_list_t *tmp;
- char buf[comline->bsize];
- uint32 seg, sequence;
- int x = 0;
-
-
- srandom(time(NULL));
-
-
- for (tmp = jlist->next; tmp != jlist; tmp = tmp->next)
- {
- jl = osi_list_entry(tmp, journal_list_t, list);
-
- if (comline->debug)
- printf("Starting journal %d\n", x++);
-
- sequence = jl->segments / (RAND_MAX + 1.0) * random();
-
- for (seg = 0; seg < jl->segments; seg++)
- {
- memset(buf, 0, comline->bsize);
- memset(&lh, 0, sizeof(struct gfs_log_header));
-
- lh.lh_header.mh_magic = GFS_MAGIC;
- lh.lh_header.mh_type = GFS_METATYPE_LH;
- lh.lh_header.mh_format = GFS_FORMAT_LH;
- lh.lh_flags = GFS_LOG_HEAD_UNMOUNT;
- lh.lh_first = jl->start + seg * comline->seg_size;
- lh.lh_sequence = sequence;
- /* Don't care about tail */
- /* Don't care about log dump */
-
- gfs_log_header_out(&lh, buf);
- gfs_log_header_out(&lh, buf + GFS_BASIC_BLOCK - sizeof(struct gfs_log_header));
-
- do_lseek(comline->fd, lh.lh_first * comline->bsize);
- do_write(comline->fd, buf, comline->bsize);
-
- if (++sequence == jl->segments)
- sequence = 0;
-
- if (!(seg % 100))
- if (comline->debug)
- printf("seg #%u\n", seg);
-
- }
- }
+ struct gfs_log_header lh;
+ journal_list_t *jl;
+ osi_list_t *tmp;
+ char buf[comline->bsize];
+ uint32 seg, sequence;
+ int x = 0;
+
+ srandom(time(NULL));
+
+ for (tmp = jlist->next; tmp != jlist; tmp = tmp->next) {
+ jl = osi_list_entry(tmp, journal_list_t, list);
+
+ if (comline->debug)
+ printf("Starting journal %d\n", x++);
+
+ sequence = jl->segments / (RAND_MAX + 1.0) * random();
+
+ for (seg = 0; seg < jl->segments; seg++) {
+ memset(buf, 0, comline->bsize);
+ memset(&lh, 0, sizeof(struct gfs_log_header));
+
+ lh.lh_header.mh_magic = GFS_MAGIC;
+ lh.lh_header.mh_type = GFS_METATYPE_LH;
+ lh.lh_header.mh_format = GFS_FORMAT_LH;
+ lh.lh_flags = GFS_LOG_HEAD_UNMOUNT;
+ lh.lh_first = jl->start + seg * comline->seg_size;
+ lh.lh_sequence = sequence;
+ /* Don't care about tail */
+ /* Don't care about log dump */
+
+ gfs_log_header_out(&lh, buf);
+ gfs_log_header_out(&lh, buf + GFS_BASIC_BLOCK - sizeof(struct gfs_log_header));
+
+ do_lseek(comline->fd, lh.lh_first * comline->bsize);
+ do_write(comline->fd, buf, comline->bsize);
+
+ if (++sequence == jl->segments)
+ sequence = 0;
+
+ if (!(seg % 100))
+ if (comline->debug)
+ printf("seg #%u\n", seg);
+ }
+ }
}
-
-
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2006-07-10 23:39 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2006-07-10 23:39 [Cluster-devel] cluster/gfs/gfs_mkfs Makefile device_geometry. rpeterso
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.