Skip to content

Commit

Permalink
Unified comment style
Browse files Browse the repository at this point in the history 
Signed-off-by: Tomas Mudrunka <tomas.mudrunka@gmail.com>
  • Loading branch information
@Harvie
Harvie committed Jan 10, 2025
1 parent 6cb934c commit f080798
Showing 1 changed file with 68 additions and 68 deletions.
136 changes: 68 additions & 68 deletions image-mdraid.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -54,32 +54,32 @@ static time_t mdraid_time = 0; //Array creation timestamp has to be identical ac
*/

#ifndef BITMAP_MAGIC
#define BITMAP_MAGIC 0x6d746962 /* This is actualy just char string saying "bitm" :-) */
#define BITMAP_MAGIC 0x6d746962 // This is actualy just char string saying "bitm" :-)

/* use these for bitmap->flags and bitmap->sb->state bit-fields */
// use these for bitmap->flags and bitmap->sb->state bit-fields
enum bitmap_state {
BITMAP_STALE = 1, /* the bitmap file is out of date or had -EIO */
BITMAP_WRITE_ERROR = 2, /* A write error has occurred */
BITMAP_STALE = 1, // the bitmap file is out of date or had -EIO
BITMAP_WRITE_ERROR = 2, // A write error has occurred
BITMAP_HOSTENDIAN = 15,
};

/* the superblock at the front of the bitmap file -- little endian */
// the superblock at the front of the bitmap file -- little endian
typedef struct bitmap_super_s {
__le32 magic; /* 0 BITMAP_MAGIC */
__le32 version; /* 4 the bitmap major for now, could change... */
__u8 uuid[16]; /* 8 128 bit uuid - must match md device uuid */
__le64 events; /* 24 event counter for the bitmap (1)*/
__le64 events_cleared; /*32 event counter when last bit cleared (2) */
__le64 sync_size; /* 40 the size of the md device's sync range(3) */
__le32 state; /* 48 bitmap state information */
__le32 chunksize; /* 52 the bitmap chunk size in bytes */
__le32 daemon_sleep; /* 56 seconds between disk flushes */
__le32 write_behind; /* 60 number of outstanding write-behind writes */
__le32 sectors_reserved; /* 64 number of 512-byte sectors that are
* reserved for the bitmap. */
__le32 nodes; /* 68 the maximum number of nodes in cluster. */
__u8 cluster_name[64]; /* 72 cluster name to which this md belongs */
__u8 pad[256 - 136]; /* set to zero */
__le32 magic; // 0 BITMAP_MAGIC
__le32 version; // 4 the bitmap major for now, could change...
__u8 uuid[16]; // 8 128 bit uuid - must match md device uuid
__le64 events; // 24 event counter for the bitmap (1)*/
__le64 events_cleared; // 32 event counter when last bit cleared (2)
__le64 sync_size; // 40 the size of the md device's sync range(3)
__le32 state; // 48 bitmap state information
__le32 chunksize; // 52 the bitmap chunk size in bytes
__le32 daemon_sleep; // 56 seconds between disk flushes
__le32 write_behind; // 60 number of outstanding write-behind writes
__le32 sectors_reserved; // 64 number of 512-byte sectors that are
// reserved for the bitmap.
__le32 nodes; // 68 the maximum number of nodes in cluster.
__u8 cluster_name[64]; // 72 cluster name to which this md belongs
__u8 pad[256 - 136]; // set to zero
} bitmap_super_t;

/* notes:
Expand Down Expand Up @@ -186,32 +186,32 @@ static int mdraid_generate(struct image *image)

char *name = cfg_getstr(image->imagesec, "label");

/* constant array information - 128 bytes */
sb->magic = MD_SB_MAGIC; /* MD_SB_MAGIC: 0xa92b4efc - little endian. */
sb->major_version = 1; /* Always 1 for 1.xx metadata version :-) */
sb->feature_map = MD_FEATURE_BITMAP_OFFSET; /* bit 0 set if 'bitmap_offset' is meaningful */
sb->pad0 = 0; /* always set to 0 when writing */
//constant array information - 128 bytes
sb->magic = MD_SB_MAGIC; // MD_SB_MAGIC: 0xa92b4efc - little endian.
sb->major_version = 1; // Always 1 for 1.xx metadata version :-)
sb->feature_map = MD_FEATURE_BITMAP_OFFSET; // bit 0 set if 'bitmap_offset' is meaningful
sb->pad0 = 0; // always set to 0 when writing

char *raid_uuid = cfg_getstr(image->imagesec, "raid-uuid");
if (!raid_uuid)
raid_uuid = uuid_random();
uuid_parse(raid_uuid, sb->set_uuid); /* user-space generated. U8[16]*/
uuid_parse(raid_uuid, sb->set_uuid); // user-space generated. U8[16]

strncpy(sb->set_name, name, 32);
sb->set_name[31] = 0; /* set and interpreted by user-space. CHAR[32] */
sb->set_name[31] = 0; // set and interpreted by user-space. CHAR[32]

long int timestamp = cfg_getint(image->imagesec, "timestamp");
if (timestamp >= 0) {
sb->ctime = timestamp & 0xffffffffff;
} else {
sb->ctime = mdraid_time & 0xffffffffff; /* lo 40 bits are seconds, top 24 are microseconds or 0*/
sb->ctime = mdraid_time & 0xffffffffff; // lo 40 bits are seconds, top 24 are microseconds or 0
}

sb->level = 1; /* -4 (multipath), -1 (linear), 0,1,4,5 */
//sb->layout; /* only for raid5 and raid10 currently */
sb->size = (image->size - DATA_OFFSET_BYTES) / 512; /* used size of component devices, in 512byte sectors */
sb->level = 1; // -4 (multipath), -1 (linear), 0,1,4,5
//sb->layout; // only for raid5 and raid10 currently
sb->size = (image->size - DATA_OFFSET_BYTES) / 512; // used size of component devices, in 512byte sectors

sb->chunksize = 0; /* in 512byte sectors - not used in raid 1 */
sb->chunksize = 0; // in 512byte sectors - not used in raid 1
sb->raid_disks = max_devices;
}

Expand All @@ -220,67 +220,67 @@ static int mdraid_generate(struct image *image)
* only meaningful of feature_map[0] is set.
*/

/* constant this-device information - 64 bytes */
sb->data_offset = DATA_OFFSET_SECTORS; /* sector start of data, often 0 */
sb->data_size = sb->size; /* sectors in this device that can be used for data */
sb->super_offset = 8; /* sector start of this superblock */
// constant this-device information - 64 bytes
sb->data_offset = DATA_OFFSET_SECTORS; // sector start of data, often 0
sb->data_size = sb->size; // sectors in this device that can be used for data
sb->super_offset = 8; // sector start of this superblock

sb->dev_number = role; /* permanent identifier of this device - not role in raid (They can be equal tho). */
sb->cnt_corrected_read = 0; /* number of read errors that were corrected by re-writing */
sb->dev_number = role; // permanent identifier of this device - not role in raid (They can be equal tho).
sb->cnt_corrected_read = 0; // number of read errors that were corrected by re-writing

char *disk_uuid = cfg_getstr(image->imagesec, "disk-uuid");
if (!disk_uuid)
disk_uuid = uuid_random();
uuid_parse(disk_uuid, sb->device_uuid); /* user-space setable, ignored by kernel U8[16] */
uuid_parse(disk_uuid, sb->device_uuid); // user-space setable, ignored by kernel U8[16]

sb->devflags = 0; /* per-device flags. Only two defined...*/
//#define WriteMostly1 1 /* mask for writemostly flag in above */
//#define FailFast1 2 /* Should avoid retries and fixups and just fail */
sb->devflags = 0; // per-device flags. Only two defined...
//#define WriteMostly1 1 // mask for writemostly flag in above
//#define FailFast1 2 // Should avoid retries and fixups and just fail

/* Bad block log. If there are any bad blocks the feature flag is set.
* If offset and size are non-zero, that space is reserved and available
*/
sb->bblog_shift = 9; /* shift from sectors to badblock size, typicaly 9-12 (shift by 9 is equal to 512 sectors per badblock) */
sb->bblog_size = 8; /* number of sectors reserved for list */
sb->bblog_offset = sb->bitmap_offset + BITMAP_SECTORS_MAX + 8; /* sector offset from superblock to bblog, signed - not unsigned */
sb->bblog_shift = 9; // shift from sectors to badblock size, typicaly 9-12 (shift by 9 is equal to 512 sectors per badblock)
sb->bblog_size = 8; // number of sectors reserved for list
sb->bblog_offset = sb->bitmap_offset + BITMAP_SECTORS_MAX + 8; // sector offset from superblock to bblog, signed - not unsigned

/* array state information - 64 bytes */
sb->utime = sb->ctime; /* 40 bits second, 24 bits microseconds */
sb->events = 0; /* incremented when superblock updated */
sb->resync_offset = 0; /* data before this offset (from data_offset) known to be in sync */
sb->max_dev = max_devices; /* size of devs[] array to consider */
//__u8 pad3[64-32]; /* set to 0 when writing */
// array state information - 64 bytes
sb->utime = sb->ctime; // 40 bits second, 24 bits microseconds
sb->events = 0; // incremented when superblock updated
sb->resync_offset = 0; // data before this offset (from data_offset) known to be in sync
sb->max_dev = max_devices; // size of devs[] array to consider
//__u8 pad3[64-32]; // set to 0 when writing

/* device state information. Indexed by dev_number.
* 2 bytes per device
* Note there are no per-device state flags. State information is rolled
* into the 'roles' value. If a device is spare or faulty, then it doesn't
* have a meaningful role.
*/
__le16 *dev_roles = (__le16 *)((char *)sb + sizeof(struct mdp_superblock_1)); /* role in array, or 0xffff for a spare, or 0xfffe for faulty */
__le16 *dev_roles = (__le16 *)((char *)sb + sizeof(struct mdp_superblock_1)); // role in array, or 0xffff for a spare, or 0xfffe for faulty
//memset(dev_roles, 0xFF, max_devices*2); //All devices in array are set as inactive initialy
for (int i = 0; i < max_devices; i++) { //All devices are assigned roles equal to their dev_number initialy
dev_roles[i] = i; //Assign active role to all devices
for (int i = 0; i < max_devices; i++) { //All devices are assigned roles equal to their dev_number initialy
dev_roles[i] = i; //Assign active role to all devices
}

//Calculate superblock checksum
sb->sb_csum = calc_sb_1_csum(sb);

//Prepare bitmap superblock (bitmaps don't have checksums for performance reasons)
bsb->magic = BITMAP_MAGIC; /* 0 BITMAP_MAGIC - This is actualy just char string saying "bitm" :-) */
bsb->version = 4; /* v4 is compatible with mdraid v1.2, 4 the bitmap major for now, could change... */
memcpy(bsb->uuid, sb->set_uuid, sizeof(bsb->uuid)); /* 8 128 bit uuid - must match md device uuid */
//bsb->events = 0; /* 24 event counter for the bitmap (1)*/
//bsb->events_cleared = 0;/*32 event counter when last bit cleared (2) */
bsb->sync_size = sb->data_size; /* 40 the size of the md device's sync range(3) */
//bsb->state = 0; /* 48 bitmap state information */
bsb->chunksize = 64 * 1024 * 1024; /* 52 the bitmap chunk size in bytes, 64MB is default on linux */
bsb->daemon_sleep = 5; /* 5 is considered safe default. 56 seconds between disk flushes */
//bsb->write_behind = 0; /* 60 number of outstanding write-behind writes */
bsb->sectors_reserved = roundup(bsb->sync_size / bsb->chunksize, 8); /* 64 number of 512-byte sectors that are reserved for the bitmap. */
//bsb->nodes; /* 68 the maximum number of nodes in cluster. */
//bsb->cluster_name[64]; /* 72 cluster name to which this md belongs */
//__u8 pad[256 - 136]; /* set to zero */
bsb->magic = BITMAP_MAGIC; // 0 BITMAP_MAGIC - This is actualy just char string saying "bitm" :-)
bsb->version = 4; // v4 is compatible with mdraid v1.2, 4 the bitmap major for now, could change...
memcpy(bsb->uuid, sb->set_uuid, sizeof(bsb->uuid)); // 8 128 bit uuid - must match md device uuid
//bsb->events = 0; // 24 event counter for the bitmap (1)*/
//bsb->events_cleared = 0; // 32 event counter when last bit cleared (2)
bsb->sync_size = sb->data_size; // 40 the size of the md device's sync range(3)
//bsb->state = 0; // 48 bitmap state information
bsb->chunksize = 64 * 1024 * 1024; // 52 the bitmap chunk size in bytes, 64MB is default on linux
bsb->daemon_sleep = 5; // 5 is considered safe default. 56 seconds between disk flushes
//bsb->write_behind = 0; // 60 number of outstanding write-behind writes
bsb->sectors_reserved = roundup(bsb->sync_size / bsb->chunksize, 8); // 64 number of 512-byte sectors that are reserved for the bitmap.
//bsb->nodes; // 68 the maximum number of nodes in cluster.
//bsb->cluster_name[64]; // 72 cluster name to which this md belongs
//__u8 pad[256 - 136]; // set to zero

//Increase bitmap chunk size till we fit in sectors max
while (bsb->sectors_reserved > BITMAP_SECTORS_MAX) {
Expand Down

0 comments on commit f080798

Please sign in to comment.