int ext4_mbr_scan(struct ext4_blockdev *parent, struct ext4_mbr_bdevs *bdevs)
{
int r;
size_t i;
ext4_dbg(DEBUG_MBR, DBG_INFO "ext4_mbr_scan\n");
memset(bdevs, 0, sizeof(struct ext4_mbr_bdevs));
r = ext4_block_init(parent);
if (r != EOK)
return r;
r = ext4_block_readbytes(parent, 0, parent->bdif->ph_bbuf, 512);
if (r != EOK) {
goto blockdev_fini;
}
const struct ext4_mbr *mbr = (void *)parent->bdif->ph_bbuf;
if (to_le16(mbr->signature) != MBR_SIGNATURE) {
ext4_dbg(DEBUG_MBR, DBG_ERROR "ext4_mbr_scan: unknown "
"signature: 0x%x\n", to_le16(mbr->signature));
r = ENOENT;
goto blockdev_fini;
}
/*Show bootstrap code*/
ext4_dbg(DEBUG_MBR, "mbr_part: bootstrap:");
for (i = 0; i < sizeof(mbr->bootstrap); ++i) {
if (!(i & 0xF))
ext4_dbg(DEBUG_MBR | DEBUG_NOPREFIX, "\n");
ext4_dbg(DEBUG_MBR | DEBUG_NOPREFIX, "%02x, ", mbr->bootstrap[i]);
}
ext4_dbg(DEBUG_MBR | DEBUG_NOPREFIX, "\n\n");
for (i = 0; i < 4; ++i) {
const struct ext4_part_entry *pe = &mbr->part_entry[i];
ext4_dbg(DEBUG_MBR, "mbr_part: %d\n", (int)i);
ext4_dbg(DEBUG_MBR, "\tstatus: 0x%x\n", pe->status);
ext4_dbg(DEBUG_MBR, "\ttype 0x%x:\n", pe->type);
ext4_dbg(DEBUG_MBR, "\tfirst_lba: 0x%"PRIx32"\n", pe->first_lba);
ext4_dbg(DEBUG_MBR, "\tsectors: 0x%"PRIx32"\n", pe->sectors);
if (!pe->sectors)
continue; /*Empty entry*/
if (pe->type != 0x83)
continue; /*Unsupported entry. 0x83 - linux native*/
bdevs->partitions[i].bdif = parent->bdif;
bdevs->partitions[i].part_offset =
(uint64_t)pe->first_lba * parent->bdif->ph_bsize;
bdevs->partitions[i].part_size =
(uint64_t)pe->sectors * parent->bdif->ph_bsize;
}
blockdev_fini:
ext4_block_fini(parent);
return r;
}
static void da2013_cmd_setup(uint16_t cmd, uint16_t req, uint16_t arg0,
uint16_t arg1, uint8_t foot)
{
memset(&da2013_cmd, 0, sizeof(struct cmd));
da2013_cmd.command = to_le16(cmd);
da2013_cmd.request = to_le16(req);
da2013_cmd.arg0 = to_le16(arg0);
da2013_cmd.arg1 = to_le16(arg1);
da2013_cmd.footer = foot;
da2013_ret.report = 0;
}
void IDeserializer::NumberI16(const char* name, int16_t& out, int16_t lower, int16_t upper)
{
int16_t value;
Get(name, (u8*)&value, sizeof(uint16_t));
value = (i16)to_le16((u16)value);
if (!(lower <= value && value <= upper))
throw PSERROR_Deserialize_OutOfBounds(name);
out = value;
}
/* Then calculate crc32 checksum against block_group_desc */
checksum = ext4_crc32c(checksum, bitmap, blocks_per_group / 8);
}
return checksum;
}
#else
#define ext4_balloc_bitmap_csum(...) 0
#endif
void ext4_balloc_set_bitmap_csum(struct ext4_sblock *sb,
struct ext4_bgroup *bg,
void *bitmap __unused)
{
int desc_size = ext4_sb_get_desc_size(sb);
uint32_t checksum = ext4_balloc_bitmap_csum(sb, bitmap);
uint16_t lo_checksum = to_le16(checksum & 0xFFFF),
hi_checksum = to_le16(checksum >> 16);
if (!ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM))
return;
/* See if we need to assign a 32bit checksum */
bg->block_bitmap_csum_lo = lo_checksum;
if (desc_size == EXT4_MAX_BLOCK_GROUP_DESCRIPTOR_SIZE)
bg->block_bitmap_csum_hi = hi_checksum;
}
#if CONFIG_META_CSUM_ENABLE
static bool
ext4_balloc_verify_bitmap_csum(struct ext4_sblock *sb,
int main() {
char *file2 = "test2.wav";
FILE *f = fopen(file2,"wb");
unsigned int test_channels = 2;
unsigned int test_sampleRate = 44000;
unsigned int test_sampleByte = 2;
unsigned int test_samplesPerChannel = 44000;
unsigned int test_seconds = 60;
unsigned int test_hertz = 440;
write_wav_header(f,test_channels,test_sampleRate,test_sampleByte,test_samplesPerChannel*test_seconds);
void *sampleData = malloc(sizeof(char)*test_channels*test_sampleByte*test_seconds);
if(sampleData==NULL)
return;
wav_sample_t sample = {
test_channels,
test_sampleByte,
test_channels*test_sampleByte,
NULL
};
int i,j;
double high,low;
for(i=0;i<test_samplesPerChannel*test_seconds;i++) {
for(j=0;j<test_channels;j++) {
// sin(2*Pi*(Hz / 44000)*i)
high = sin( (double) i * ( ((double) (test_hertz + ((double)(i % 1000))/440) * 2 * M_PI) / (double)test_sampleRate));
if((i%(22000))<1100*test_seconds) {
low = sin( (double) i * ( ((double) (test_hertz + (50) * 2 * M_PI) / (double)test_sampleRate)));
} else {
low = sin( (double) i * ( ((double) (test_hertz + (75) * 2 * M_PI) / (double)test_sampleRate)));
}
*(((short *)sampleData) + j) = to_le16((short)(( high/2 + low*4 )*0xFFF));
}
sample.sampleData = sampleData;
write_wav_sample(f,&sample);
}
free(sampleData);
fclose(f);
wav_header_t *readHeader = malloc(sizeof(wav_header_t));
if(readHeader==NULL) {
printf("Something failed :(\n");
return 0;
}
FILE *f2 = fopen(file2,"rb");
read_wav_header(f2,readHeader);
int samplePerChannel = readHeader->Data.Subchunk2Size / (readHeader->Fmt.NumChannels * (readHeader->Fmt.BytesPerSample));
printf("samplePerChannel = %d\n",samplePerChannel);
fclose(f2);
free(readHeader);
return 0;
}
void IDeserializer::NumberI16_Unbounded(const char* name, int16_t& out)
{
int16_t value;
Get(name, (u8*)&value, sizeof(int16_t));
out = (i16)to_le16((u16)value);
}
void IDeserializer::NumberU16_Unbounded(const char* name, uint16_t& out)
{
uint16_t value;
Get(name, (u8*)&value, sizeof(uint16_t));
out = to_le16(value);
}
uint64_t ext4_extent_get_start(struct ext4_extent *extent)
{
return ((uint64_t)to_le16(extent->start_hi)) << 32 |
((uint64_t)to_le32(extent->start_lo));
}
void ext4_extent_set_block_count(struct ext4_extent *extent, uint16_t count)
{
extent->block_count = to_le16(count);
}
uint16_t ext4_extent_get_block_count(struct ext4_extent *extent)
{
return to_le16(extent->block_count);
}
/**@brief Set current number of index node entries.
* @param climit Pointer to counlimit structure
* @param count Number of entries in node
*/
static inline void
ext4_dir_dx_countlimit_set_count(struct ext4_directory_dx_countlimit *climit,
uint16_t count)
{
climit->count = to_le16(count);
}
/**@brief Get current number of index node entries.
* @param climit Pointer to counlimit structure
* @return Number of entries in node
*/
static inline uint16_t
ext4_dir_dx_countlimit_get_count(struct ext4_directory_dx_countlimit *climit)
{
return to_le16(climit->count);
}
