#include

#include

#include

#include "mdadm.h$"$

#include "jbod.h$"$

static int mounted $=0$;

$//$ Helper function to create JBOD operation command

static uint$32\_$t create$\_$operation$($jbod$\_$cmd$\_$t cmd$,$ int disk$\_$num, int block$\_$num$)\{$

uint$32\_$t op $=0.$

op $|=($disk$\_$num $<<28)$; $//$ Disk ID in bits $31-28$

op $|=($block$\_$num $<<20)$; $//$ Block ID in bits $27-20$

op $|=($cmd $<<12)$; $//$ Command in bits $19-12$

return op;

$\}$

int mdadm$\_$mount$($void$)\{$

$//$ If already mounted, return error

if $($mounted$)\{$

return $-1$; $//$ System is already mounted

$\}$

$//$ Create the mount operation command

$//$ Since the operation is to mount, we don't care about disk$\_$num or block$\_$num.

uint$32\_$t op $=$ JBOD$\_$MOUNT $<<12$; $//$ Command is stored in bits $19-12,$ so shift JBOD$\_$MOUNT by $12$ bits.

$//$ Call jbod$\_$operation to execute the mount operation

if $($jbod$\_$operation$($op$,$ NULL$)==0)\{$

mounted $=1$; $//$ Mark system as mounted

return $1$; $//$ Return success

$\}$ else $\{$

return $-1$; $//$ Mount operation failed

$\}$

$\}$

extern int mounted;

int mdadm$\_$unmount$($void$)\{$

$//$ If not mounted, return error

if $(!$mounted$)\{$

return $-1$; $//$ System is not mounted, cannot unmount

$\}$

$//$ Create the unmount operation command

$//$ Since the operation is to unmount, we don't care about disk$\_$num or block$\_$num.

uint$32\_$t op $=$ JBOD$\_$UNMOUNT $<<12$; $//$ Command is stored in bits $19-12,$ so shift JBOD$\_$UNMOUNT by $12$ bits.

$//$ Call jbod$\_$operation to execute the unmount operation

if $($jbod$\_$operation$($op$,$ NULL$)==0)\{$

mounted $=0$; $//$ Mark system as unmounted

return $1$; $//$ Return success

$\}$ else $\{$

return $-1$; $//$ Unmount operation failed

$\}$

$\}$

int mdadm$\_$read$($uint$32\_$t start$\_$addr, uint$32\_$t read$\_$len, uint$8\_$t $*$read$\_$buf$)\{$

$//$ Basic validation checks

if $(!$mounted$)$ return $-3$; $//$ System is unmounted

if $($read$\_$len $>1024)$ return $-2$; $//$ Exceeds max read length

if $($read$\_$len $>0$ and read$\_$buf $==$ NULL$)$ return $-4$; $//$ Null buffer

if $($read$\_$len $==0)$ return $0$; $//$ Nothing to read

if $($start$\_$addr $>=$ JBOD$\_$NUM$\_$DISKS $*$ JBOD$\_$DISK$\_$SIZE$)$ return $-1$; $//$ Out of bounds

if $($start$\_$addr $+$ read$\_$len $>$ JBOD$\_$NUM$\_$DISKS $*$ JBOD$\_$DISK$\_$SIZE$)$ return $-1$; $//$ Out of bounds

uint$32\_$t bytes$\_$read $=0.$

uint$32\_$t curr$\_$addr $=$ start$\_$addr;

$//$ Calculate the initial disk and block based on the start address

uint$32\_$t disk$\_$id $=$ curr$\_$addr $/$ JBOD$\_$DISK$\_$SIZE;

uint$32\_$t disk$\_$offset $=$ curr$\_$addr $\%$ JBOD$\_$DISK$\_$SIZE;

uint$32\_$t block$\_$id $=$ disk$\_$offset $/$ JBOD$\_$BLOCK$\_$SIZE;

uint$32\_$t block$\_$offset $=$ disk$\_$offset $\%$ JBOD$\_$BLOCK$\_$SIZE;

$//$ Seek to the initial disk and block

uint$32\_$t seek$\_$disk$\_$op $=$ create$\_$operation$($JBOD$\_$SEEK$\_$TO$\_$DISK, disk$\_$id$,0)$;

if $($jbod$\_$operation$($seek$\_$disk$\_$op$,$ NULL$)!=0)$ return $-4$;

uint$32\_$t seek$\_$block$\_$op $=$ create$\_$operation$($JBOD$\_$SEEK$\_$TO$\_$BLOCK, $0,$ block$\_$id$)$;

if $($jbod$\_$operation$($seek$\_$block$\_$op$,$ NULL$)!=0)$ return $-4$;

while $($bytes$\_$read $<$ read$\_$len$)\{$

$//$ Read the block at the current position

uint$8\_$t block$[$JBOD$\_$BLOCK$\_$SIZE$]$;

uint$32\_$t read$\_$op $=$ create$\_$operation$($JBOD$\_$READ$\_$BLOCK, $0,0)$;

if $($jbod$\_$operation$($read$\_$op$,$ block$)!=0)$ return $-4$;

$//$ Calculate how many bytes to copy from this block

uint$32\_$t remaining$\_$in$\_$block $=$ JBOD$\_$BLOCK$\_$SIZE $-$ block$\_$offset;

uint$32\_$t remaining$\_$to$\_$read $=$ read$\_$len $-$ bytes$\_$read;

uint$32\_$t bytes$\_$to$\_$copy $=($remaining$\_$in$\_$block $<$ remaining$\_$to$\_$read$)?$ remaining$\_$in$\_$block : remaining$\_$to$\_$read;

$//$ Copy the required bytes from the block to the output buffer

memcpy$($read$\_$buf $+$ bytes$\_$read, block $+$ block$\_$offset, bytes$\_$to$\_$copy$)$;

$//$ Update counters

bytes$\_$read $+=$ bytes$\_$to$\_$copy;

curr$\_$addr $+=$ bytes$\_$to$\_$copy;

if $($curr$\_$addr $\%$ JBOD$\_$BLOCK$\_$SIZE $==0)\{$

block$\_$id$++$; $//$ Move to the next block

block$\_$offset $=0$; $//$ Reset block offset to $0$ for the new block

$\}$

$//$ Reset block$\_$offset since we start reading from the beginning of the next block

block$\_$offset $=0$;

$//$ Move to the next disk if the current address exceeds the disk boundary

if $($curr$\_$addr $\%$ JBOD$\_$DISK$\_$SIZE $==0)\{$

disk$\_$id$++$;

block$\_$id $=0$;

seek$\_$disk$\_$op $=$ create$\_$operation$($JBOD$\_$SEEK$\_$TO$\_$DISK, disk$\_$id$,0)$;

if $($jbod$\_$operation$($seek$\_$disk$\_$op$,$ NULL$)!=0)$ return $-4$;

$\}$

$\}$

return bytes$\_$read; $//$ Return the number of bytes read

$\}$

This is my code for a JBOD program. Disk Operation Format:

$|$ Bits $|$ Width $|$ Field $|$ Description $|$

$|0-3|4|$ DiskID $|$ ID of the disk for the operation $|$

$|4-11|8|$ BlockID $|$ ID of the block within the disk $|$

$|12-19|8|$ Command $|$ The command to be executed $|$

$|20-31|12|$ Reserved $|$ Unused $|$

Each of these hard disks consists of $`$i$`$ blocks, with each block holding $`256`$ bytes. Since you$$ve bought $`$j$`$ disks, the total storage capacity is:

$25616256=1,048,576$ bytes $=1$ MB$`$

The following function can be used to control the disks:

$`$int jbod$\_$operation$($uint$32\_$t op$,$ uint$8\_$t $*$block$)$;

Only $8/10$ of my test cases are

running $.$The mdadm$\_$read function correctly handles reading within a single disk, but when it tries to read across disk boundaries, the data read does not match the expected result.

The test case is expecting the last $8$ bytes of disk $14$ to be $0$xee and the first $8$ bytes of disk $15$ to be $0$xff$.$ However, the mdadm$\_$read function is returning $0$xaa for both disks,indicating that the disk switch $($from disk $14$ to disk $15).$ PLEASE CORRECT MY CODE TO HANDLE THESE EDGE CASES. you dont need more lib funcs