80486DX2-66/86Box-fork
1
0
Fork 0
Code Issues Pull Requests Activity

More linting in src/disk

Browse Source
This commit is contained in:
Jasmine Iwanek
2023-08-21 20:22:55 -04:00
parent 532f8ca91f
commit 7342c0a77a
10 changed files with 149 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/disk/hdc.c
View File

@@ -142,7 +142,7 @@ hdc_reset(void)
device_add(&ide_qua_device); device_add(&ide_qua_device);
} }
char * const char *
hdc_get_internal_name(int hdc) hdc_get_internal_name(int hdc)
{ {
return device_get_internal_name(controllers[hdc].device); return device_get_internal_name(controllers[hdc].device);
@@ -154,7 +154,7 @@ hdc_get_from_internal_name(char *s)
int c = 0; int c = 0;
while (controllers[c].device != NULL) { while (controllers[c].device != NULL) {
if (!strcmp((char *) controllers[c].device->internal_name, s)) if (!strcmp(controllers[c].device->internal_name, s))
return c; return c;
c++; c++;
} }

2
src/disk/hdc_esdi_at.c
View File

@@ -789,7 +789,7 @@ esdi_callback(void *priv)
default: default:
esdi_at_log("WD1007: callback on unknown command %02x\n", esdi->command); esdi_at_log("WD1007: callback on unknown command %02x\n", esdi->command);
/*FALLTHROUGH*/ fallthrough;
case 0xe8: case 0xe8:
esdi->status = STAT_READY | STAT_ERR | STAT_DSC; esdi->status = STAT_READY | STAT_ERR | STAT_DSC;

2
src/disk/hdc_ide.c
View File

@@ -1279,7 +1279,7 @@ ide_write_data(ide_t *ide, uint32_t val, int length)
void void
ide_writew(uint16_t addr, uint16_t val, void *priv) ide_writew(uint16_t addr, uint16_t val, void *priv)
{ {
ide_board_t *dev = (ide_board_t *) priv; const ide_board_t *dev = (ide_board_t *) priv;
ide_t *ide; ide_t *ide;
int ch; int ch;

8
src/disk/hdc_st506_xt.c
View File

@@ -1573,10 +1573,10 @@ set_switches(hdc_t *dev, hd_type_t *hdt, int num)
static void * static void *
st506_init(const device_t *info) st506_init(const device_t *info)
{ {
char *fn = NULL; const char *fn = NULL;
hdc_t *dev; hdc_t *dev;
int i; int i;
int c; int c;
dev = (hdc_t *) malloc(sizeof(hdc_t)); dev = (hdc_t *) malloc(sizeof(hdc_t));
memset(dev, 0x00, sizeof(hdc_t)); memset(dev, 0x00, sizeof(hdc_t));

28
src/disk/hdc_xta.c
View File

@@ -432,13 +432,13 @@ do_fmt:
static void static void
hdc_callback(void *priv) hdc_callback(void *priv)
{ {
hdc_t *dev = (hdc_t *) priv; hdc_t *dev = (hdc_t *) priv;
dcb_t *dcb = &dev->dcb; dcb_t *dcb = &dev->dcb;
drive_t *drive; drive_t *drive;
dprm_t *params; const dprm_t *params;
off64_t addr; off64_t addr;
int no_data = 0; int no_data = 0;
int val; int val;
drive = &dev->drives[dcb->drvsel]; drive = &dev->drives[dcb->drvsel];
dev->comp = (dcb->drvsel) ? COMP_DRIVE : 0x00; dev->comp = (dcb->drvsel) ? COMP_DRIVE : 0x00;
@@ -983,12 +983,12 @@ hdc_write(uint16_t port, uint8_t val, void *priv)
static void * static void *
xta_init(const device_t *info) xta_init(const device_t *info)
{ {
drive_t *drive; drive_t *drive;
char *bios_rev = NULL; const char *bios_rev = NULL;
char *fn = NULL; const char *fn = NULL;
hdc_t *dev; hdc_t *dev;
int c; int c;
int max = XTA_NUM; int max = XTA_NUM;
/* Allocate and initialize device block. */ /* Allocate and initialize device block. */
dev = malloc(sizeof(hdc_t)); dev = malloc(sizeof(hdc_t));
@@ -1004,7 +1004,7 @@ xta_init(const device_t *info)
dev->rom_addr = device_get_config_hex20("bios_addr"); dev->rom_addr = device_get_config_hex20("bios_addr");
dev->dma = 3; dev->dma = 3;
bios_rev = (char *) device_get_config_bios("bios_rev"); bios_rev = (char *) device_get_config_bios("bios_rev");
fn = (char *) device_get_bios_file(info, (const char *) bios_rev, 0); fn = (char *) device_get_bios_file(info, bios_rev, 0);
max = 1; max = 1;
break; break;

2
src/disk/hdd.c
View File

@@ -461,7 +461,7 @@ hdd_preset_get_from_internal_name(char *s)
int c = 0; int c = 0;
for (int i = 0; i < (sizeof(hdd_speed_presets) / sizeof(hdd_preset_t)); i++) { for (int i = 0; i < (sizeof(hdd_speed_presets) / sizeof(hdd_preset_t)); i++) {
if (!strcmp((char *) hdd_speed_presets[c].internal_name, s)) if (!strcmp(hdd_speed_presets[c].internal_name, s))
return c; return c;
c++; c++;
} }

30
src/disk/hdd_image.c
View File

@@ -85,28 +85,28 @@ image_is_hdi(const char *s)
int int
image_is_hdx(const char *s, int check_signature) image_is_hdx(const char *s, int check_signature)
{ {
FILE *f; FILE *fp;
uint64_t filelen; uint64_t filelen;
uint64_t signature; uint64_t signature;
if (!strcasecmp(path_get_extension((char *) s), "HDX")) { if (!strcasecmp(path_get_extension((char *) s), "HDX")) {
if (check_signature) { if (check_signature) {
f = plat_fopen(s, "rb"); fp = plat_fopen(s, "rb");
if (!f) if (!fp)
return 0; return 0;
if (fseeko64(f, 0, SEEK_END)) if (fseeko64(fp, 0, SEEK_END))
fatal("image_is_hdx(): Error while seeking"); fatal("image_is_hdx(): Error while seeking");
filelen = ftello64(f); filelen = ftello64(fp);
if (fseeko64(f, 0, SEEK_SET)) if (fseeko64(fp, 0, SEEK_SET))
fatal("image_is_hdx(): Error while seeking"); fatal("image_is_hdx(): Error while seeking");
if (filelen < 44) { if (filelen < 44) {
if (f != NULL) if (fp != NULL)
fclose(f); fclose(fp);
return 0; return 0;
} }
if (fread(&signature, 1, 8, f) != 8) if (fread(&signature, 1, 8, fp) != 8)
fatal("image_is_hdx(): Error reading signature\n"); fatal("image_is_hdx(): Error reading signature\n");
fclose(f); fclose(fp);
if (signature == 0xD778A82044445459LL) if (signature == 0xD778A82044445459LL)
return 1; return 1;
else else
@@ -120,16 +120,16 @@ image_is_hdx(const char *s, int check_signature)
int int
image_is_vhd(const char *s, int check_signature) image_is_vhd(const char *s, int check_signature)
{ {
FILE *f; FILE *fp;
if (!strcasecmp(path_get_extension((char *) s), "VHD")) { if (!strcasecmp(path_get_extension((char *) s), "VHD")) {
if (check_signature) { if (check_signature) {
f = plat_fopen(s, "rb"); fp = plat_fopen(s, "rb");
if (!f) if (!fp)
return 0; return 0;
bool is_vhd = mvhd_file_is_vhd(f); bool is_vhd = mvhd_file_is_vhd(fp);
fclose(f); fclose(fp);
return is_vhd ? 1 : 0; return is_vhd ? 1 : 0;
} else } else
return 1; return 1;

52
src/disk/minivhd/create.c
View File

@@ -245,11 +245,11 @@ mvhd_create_fixed_raw(const char* path, FILE* raw_img, uint64_t size_in_bytes, M
goto end; goto end;
} }
FILE* f = mvhd_fopen(path, "wb+", err); FILE* fp = mvhd_fopen(path, "wb+", err);
if (f == NULL) { if (fp == NULL) {
goto cleanup_vhdm; goto cleanup_vhdm;
} }
mvhd_fseeko64(f, 0, SEEK_SET); mvhd_fseeko64(fp, 0, SEEK_SET);
uint32_t size_sectors = (uint32_t)(size_in_bytes / MVHD_SECTOR_SIZE); uint32_t size_sectors = (uint32_t)(size_in_bytes / MVHD_SECTOR_SIZE);
uint32_t s; uint32_t s;
@@ -269,22 +269,22 @@ mvhd_create_fixed_raw(const char* path, FILE* raw_img, uint64_t size_in_bytes, M
mvhd_fseeko64(raw_img, 0, SEEK_SET); mvhd_fseeko64(raw_img, 0, SEEK_SET);
for (s = 0; s < size_sectors; s++) { for (s = 0; s < size_sectors; s++) {
(void) !fread(img_data, sizeof img_data, 1, raw_img); (void) !fread(img_data, sizeof img_data, 1, raw_img);
fwrite(img_data, sizeof img_data, 1, f); fwrite(img_data, sizeof img_data, 1, fp);
if (progress_callback) if (progress_callback)
progress_callback(s + 1, size_sectors); progress_callback(s + 1, size_sectors);
} }
} else { } else {
gen_footer(&vhdm->footer, size_in_bytes, geom, MVHD_TYPE_FIXED, 0); gen_footer(&vhdm->footer, size_in_bytes, geom, MVHD_TYPE_FIXED, 0);
for (s = 0; s < size_sectors; s++) { for (s = 0; s < size_sectors; s++) {
fwrite(img_data, sizeof img_data, 1, f); fwrite(img_data, sizeof img_data, 1, fp);
if (progress_callback) if (progress_callback)
progress_callback(s + 1, size_sectors); progress_callback(s + 1, size_sectors);
} }
} }
mvhd_footer_to_buffer(&vhdm->footer, footer_buff); mvhd_footer_to_buffer(&vhdm->footer, footer_buff);
fwrite(footer_buff, sizeof footer_buff, 1, f); fwrite(footer_buff, sizeof footer_buff, 1, fp);
fclose(f); fclose(fp);
f = NULL; fp = NULL;
free(vhdm); free(vhdm);
vhdm = mvhd_open(path, false, err); vhdm = mvhd_open(path, false, err);
goto end; goto end;
@@ -352,11 +352,11 @@ create_sparse_diff(const char* path, const char* par_path, uint64_t size_in_byte
goto cleanup_vhdm; goto cleanup_vhdm;
} }
FILE* f = mvhd_fopen(path, "wb+", err); FILE* fp = mvhd_fopen(path, "wb+", err);
if (f == NULL) { if (fp == NULL) {
goto cleanup_vhdm; goto cleanup_vhdm;
} }
mvhd_fseeko64(f, 0, SEEK_SET); mvhd_fseeko64(fp, 0, SEEK_SET);
/* Note, the sparse header follows the footer copy at the beginning of the file */ /* Note, the sparse header follows the footer copy at the beginning of the file */
if (par_path == NULL) { if (par_path == NULL) {
@@ -367,7 +367,7 @@ create_sparse_diff(const char* path, const char* par_path, uint64_t size_in_byte
mvhd_footer_to_buffer(&vhdm->footer, footer_buff); mvhd_footer_to_buffer(&vhdm->footer, footer_buff);
/* As mentioned, start with a copy of the footer */ /* As mentioned, start with a copy of the footer */
fwrite(footer_buff, sizeof footer_buff, 1, f); fwrite(footer_buff, sizeof footer_buff, 1, fp);
/** /**
* Calculate the number of (2MB or 512KB) data blocks required to store the entire * Calculate the number of (2MB or 512KB) data blocks required to store the entire
@@ -417,20 +417,20 @@ create_sparse_diff(const char* path, const char* par_path, uint64_t size_in_byte
} }
gen_sparse_header(&vhdm->sparse, num_blks, bat_offset, block_size_in_sectors); gen_sparse_header(&vhdm->sparse, num_blks, bat_offset, block_size_in_sectors);
mvhd_header_to_buffer(&vhdm->sparse, sparse_buff); mvhd_header_to_buffer(&vhdm->sparse, sparse_buff);
fwrite(sparse_buff, sizeof sparse_buff, 1, f); fwrite(sparse_buff, sizeof sparse_buff, 1, fp);
/* The BAT sectors need to be filled with 0xffffffff */ /* The BAT sectors need to be filled with 0xffffffff */
for (uint32_t k = 0; k < num_bat_sect; k++) { for (uint32_t k = 0; k < num_bat_sect; k++) {
fwrite(bat_sect, sizeof bat_sect, 1, f); fwrite(bat_sect, sizeof bat_sect, 1, fp);
} }
mvhd_write_empty_sectors(f, 5); mvhd_write_empty_sectors(fp, 5);
/** /**
* If creating a differencing VHD, the paths to the parent image need to be written * If creating a differencing VHD, the paths to the parent image need to be written
* tp the file. Both absolute and relative paths are written * tp the file. Both absolute and relative paths are written
* */ * */
if (par_vhdm != NULL) { if (par_vhdm != NULL) {
uint64_t curr_pos = (uint64_t)mvhd_ftello64(f); uint64_t curr_pos = (uint64_t)mvhd_ftello64(fp);
/* Double check my sums... */ /* Double check my sums... */
assert(curr_pos == par_loc_offset); assert(curr_pos == par_loc_offset);
@@ -440,25 +440,25 @@ create_sparse_diff(const char* path, const char* par_path, uint64_t size_in_byte
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
for (uint32_t j = 0; j < (vhdm->sparse.par_loc_entry[i].plat_data_space / MVHD_SECTOR_SIZE); j++) { for (uint32_t j = 0; j < (vhdm->sparse.par_loc_entry[i].plat_data_space / MVHD_SECTOR_SIZE); j++) {
fwrite(empty_sect, sizeof empty_sect, 1, f); fwrite(empty_sect, sizeof empty_sect, 1, fp);
} }
} }
/* Now write the location entries */ /* Now write the location entries */
mvhd_fseeko64(f, vhdm->sparse.par_loc_entry[0].plat_data_offset, SEEK_SET); mvhd_fseeko64(fp, vhdm->sparse.par_loc_entry[0].plat_data_offset, SEEK_SET);
fwrite(w2ku_path_buff, vhdm->sparse.par_loc_entry[0].plat_data_len, 1, f); fwrite(w2ku_path_buff, vhdm->sparse.par_loc_entry[0].plat_data_len, 1, fp);
mvhd_fseeko64(f, vhdm->sparse.par_loc_entry[1].plat_data_offset, SEEK_SET); mvhd_fseeko64(fp, vhdm->sparse.par_loc_entry[1].plat_data_offset, SEEK_SET);
fwrite(w2ru_path_buff, vhdm->sparse.par_loc_entry[1].plat_data_len, 1, f); fwrite(w2ru_path_buff, vhdm->sparse.par_loc_entry[1].plat_data_len, 1, fp);
/* and reset the file position to continue */ /* and reset the file position to continue */
mvhd_fseeko64(f, vhdm->sparse.par_loc_entry[1].plat_data_offset + vhdm->sparse.par_loc_entry[1].plat_data_space, SEEK_SET); mvhd_fseeko64(fp, vhdm->sparse.par_loc_entry[1].plat_data_offset + vhdm->sparse.par_loc_entry[1].plat_data_space, SEEK_SET);
mvhd_write_empty_sectors(f, 5); mvhd_write_empty_sectors(fp, 5);
} }
/* And finish with the footer */ /* And finish with the footer */
fwrite(footer_buff, sizeof footer_buff, 1, f); fwrite(footer_buff, sizeof footer_buff, 1, fp);
fclose(f); fclose(fp);
f = NULL; fp = NULL;
free(vhdm); free(vhdm);
vhdm = mvhd_open(path, false, err); vhdm = mvhd_open(path, false, err);
goto end; goto end;

89
src/disk/mo.c
View File

@@ -316,9 +316,9 @@ find_mo_for_channel(uint8_t channel)
static int static int
mo_load_abort(mo_t *dev) mo_load_abort(mo_t *dev)
{ {
if (dev->drv->f) if (dev->drv->fp)
fclose(dev->drv->f); fclose(dev->drv->fp);
dev->drv->f = NULL; dev->drv->fp = NULL;
dev->drv->medium_size = 0; dev->drv->medium_size = 0;
dev->drv->sector_size = 0; dev->drv->sector_size = 0;
mo_eject(dev->id); /* Make sure the host OS knows we've rejected (and ejected) the image. */ mo_eject(dev->id); /* Make sure the host OS knows we've rejected (and ejected) the image. */
@@ -343,11 +343,11 @@ mo_load(mo_t *dev, char *fn)
is_mdi = image_is_mdi(fn); is_mdi = image_is_mdi(fn);
dev->drv->f = plat_fopen(fn, dev->drv->read_only ? "rb" : "rb+"); dev->drv->fp = plat_fopen(fn, dev->drv->read_only ? "rb" : "rb+");
if (!dev->drv->f) { if (!dev->drv->fp) {
if (!dev->drv->read_only) { if (!dev->drv->read_only) {
dev->drv->f = plat_fopen(fn, "rb"); dev->drv->fp = plat_fopen(fn, "rb");
if (dev->drv->f) if (dev->drv->fp)
dev->drv->read_only = 1; dev->drv->read_only = 1;
else else
return mo_load_abort(dev); return mo_load_abort(dev);
@@ -355,8 +355,8 @@ mo_load(mo_t *dev, char *fn)
return mo_load_abort(dev); return mo_load_abort(dev);
} }
fseek(dev->drv->f, 0, SEEK_END); fseek(dev->drv->fp, 0, SEEK_END);
size = (uint32_t) ftell(dev->drv->f); size = (uint32_t) ftell(dev->drv->fp);
if (is_mdi) { if (is_mdi) {
/* This is a MDI image. */ /* This is a MDI image. */
@@ -376,7 +376,7 @@ mo_load(mo_t *dev, char *fn)
if (!found) if (!found)
return mo_load_abort(dev); return mo_load_abort(dev);
if (fseek(dev->drv->f, dev->drv->base, SEEK_SET) == -1) if (fseek(dev->drv->fp, dev->drv->base, SEEK_SET) == -1)
fatal("mo_load(): Error seeking to the beginning of the file\n"); fatal("mo_load(): Error seeking to the beginning of the file\n");
strncpy(dev->drv->image_path, fn, sizeof(dev->drv->image_path) - 1); strncpy(dev->drv->image_path, fn, sizeof(dev->drv->image_path) - 1);
@@ -401,16 +401,16 @@ mo_disk_reload(mo_t *dev)
void void
mo_disk_unload(mo_t *dev) mo_disk_unload(mo_t *dev)
{ {
if (dev->drv->f) { if (dev->drv->fp) {
fclose(dev->drv->f); fclose(dev->drv->fp);
dev->drv->f = NULL; dev->drv->fp = NULL;
} }
} }
void void
mo_disk_close(mo_t *dev) mo_disk_close(mo_t *dev)
{ {
if (dev->drv->f) { if (dev->drv->fp) {
mo_disk_unload(dev); mo_disk_unload(dev);
memcpy(dev->drv->prev_image_path, dev->drv->image_path, sizeof(dev->drv->prev_image_path)); memcpy(dev->drv->prev_image_path, dev->drv->image_path, sizeof(dev->drv->prev_image_path));
@@ -515,8 +515,8 @@ mo_atapi_phase_to_scsi(mo_t *dev)
static void static void
mo_mode_sense_load(mo_t *dev) mo_mode_sense_load(mo_t *dev)
{ {
FILE *f; FILE *fp;
char file_name[512]; char fn[512];
memset(&dev->ms_pages_saved, 0, sizeof(mode_sense_pages_t)); memset(&dev->ms_pages_saved, 0, sizeof(mode_sense_pages_t));
if (mo_drives[dev->id].bus_type == MO_BUS_SCSI) if (mo_drives[dev->id].bus_type == MO_BUS_SCSI)
@@ -524,33 +524,33 @@ mo_mode_sense_load(mo_t *dev)
else else
memcpy(&dev->ms_pages_saved, &mo_mode_sense_pages_default, sizeof(mode_sense_pages_t)); memcpy(&dev->ms_pages_saved, &mo_mode_sense_pages_default, sizeof(mode_sense_pages_t));
memset(file_name, 0, 512); memset(fn, 0, 512);
if (dev->drv->bus_type == MO_BUS_SCSI) if (dev->drv->bus_type == MO_BUS_SCSI)
sprintf(file_name, "scsi_mo_%02i_mode_sense_bin", dev->id); sprintf(fn, "scsi_mo_%02i_mode_sense_bin", dev->id);
else else
sprintf(file_name, "mo_%02i_mode_sense_bin", dev->id); sprintf(fn, "mo_%02i_mode_sense_bin", dev->id);
f = plat_fopen(nvr_path(file_name), "rb"); fp = plat_fopen(nvr_path(fn), "rb");
if (f) { if (fp) {
/* Nothing to read, not used by MO. */ /* Nothing to read, not used by MO. */
fclose(f); fclose(fp);
} }
} }
static void static void
mo_mode_sense_save(mo_t *dev) mo_mode_sense_save(mo_t *dev)
{ {
FILE *f; FILE *fp;
char file_name[512]; char fn[512];
memset(file_name, 0, 512); memset(fn, 0, 512);
if (dev->drv->bus_type == MO_BUS_SCSI) if (dev->drv->bus_type == MO_BUS_SCSI)
sprintf(file_name, "scsi_mo_%02i_mode_sense_bin", dev->id); sprintf(fn, "scsi_mo_%02i_mode_sense_bin", dev->id);
else else
sprintf(file_name, "mo_%02i_mode_sense_bin", dev->id); sprintf(fn, "mo_%02i_mode_sense_bin", dev->id);
f = plat_fopen(nvr_path(file_name), "wb"); fp = plat_fopen(nvr_path(fn), "wb");
if (f) { if (fp) {
/* Nothing to write, not used by MO. */ /* Nothing to write, not used by MO. */
fclose(f); fclose(fp);
} }
} }
@@ -562,16 +562,13 @@ mo_mode_sense_read(mo_t *dev, uint8_t page_control, uint8_t page, uint8_t pos)
case 0: case 0:
case 3: case 3:
return dev->ms_pages_saved.pages[page][pos]; return dev->ms_pages_saved.pages[page][pos];
break;
case 1: case 1:
return mo_mode_sense_pages_changeable.pages[page][pos]; return mo_mode_sense_pages_changeable.pages[page][pos];
break;
case 2: case 2:
if (dev->drv->bus_type == MO_BUS_SCSI) if (dev->drv->bus_type == MO_BUS_SCSI)
return mo_mode_sense_pages_default_scsi.pages[page][pos]; return mo_mode_sense_pages_default_scsi.pages[page][pos];
else else
return mo_mode_sense_pages_default.pages[page][pos]; return mo_mode_sense_pages_default.pages[page][pos];
break;
default: default:
break; break;
@@ -965,17 +962,17 @@ mo_blocks(mo_t *dev, int32_t *len, UNUSED(int first_batch), int out)
*len = dev->requested_blocks * dev->drv->sector_size; *len = dev->requested_blocks * dev->drv->sector_size;
for (int i = 0; i < dev->requested_blocks; i++) { for (int i = 0; i < dev->requested_blocks; i++) {
if (fseek(dev->drv->f, dev->drv->base + (dev->sector_pos * dev->drv->sector_size) + (i * dev->drv->sector_size), SEEK_SET) == 1) if (fseek(dev->drv->fp, dev->drv->base + (dev->sector_pos * dev->drv->sector_size) + (i * dev->drv->sector_size), SEEK_SET) == 1)
break; break;
if (feof(dev->drv->f)) if (feof(dev->drv->fp))
break; break;
if (out) { if (out) {
if (fwrite(dev->buffer + (i * dev->drv->sector_size), 1, dev->drv->sector_size, dev->drv->f) != dev->drv->sector_size) if (fwrite(dev->buffer + (i * dev->drv->sector_size), 1, dev->drv->sector_size, dev->drv->fp) != dev->drv->sector_size)
fatal("mo_blocks(): Error writing data\n"); fatal("mo_blocks(): Error writing data\n");
} else { } else {
if (fread(dev->buffer + (i * dev->drv->sector_size), 1, dev->drv->sector_size, dev->drv->f) != dev->drv->sector_size) if (fread(dev->buffer + (i * dev->drv->sector_size), 1, dev->drv->sector_size, dev->drv->fp) != dev->drv->sector_size)
fatal("mo_blocks(): Error reading data\n"); fatal("mo_blocks(): Error reading data\n");
} }
} }
@@ -1003,14 +1000,14 @@ mo_format(mo_t *dev)
mo_log("MO %i: Formatting media...\n", dev->id); mo_log("MO %i: Formatting media...\n", dev->id);
fseek(dev->drv->f, 0, SEEK_END); fseek(dev->drv->fp, 0, SEEK_END);
size = ftell(dev->drv->f); size = ftell(dev->drv->fp);
#ifdef _WIN32 #ifdef _WIN32
HANDLE fh; HANDLE fh;
LARGE_INTEGER liSize; LARGE_INTEGER liSize;
fd = _fileno(dev->drv->f); fd = _fileno(dev->drv->fp);
fh = (HANDLE) _get_osfhandle(fd); fh = (HANDLE) _get_osfhandle(fd);
liSize.QuadPart = 0; liSize.QuadPart = 0;
@@ -1044,7 +1041,7 @@ mo_format(mo_t *dev)
return; return;
} }
#else #else
fd = fileno(dev->drv->f); fd = fileno(dev->drv->fp);
ret = ftruncate(fd, 0); ret = ftruncate(fd, 0);
@@ -1083,13 +1080,13 @@ mo_erase(mo_t *dev)
mo_buf_alloc(dev, dev->drv->sector_size); mo_buf_alloc(dev, dev->drv->sector_size);
memset(dev->buffer, 0, dev->drv->sector_size); memset(dev->buffer, 0, dev->drv->sector_size);
fseek(dev->drv->f, dev->drv->base + (dev->sector_pos * dev->drv->sector_size), SEEK_SET); fseek(dev->drv->fp, dev->drv->base + (dev->sector_pos * dev->drv->sector_size), SEEK_SET);
for (i = 0; i < dev->requested_blocks; i++) { for (i = 0; i < dev->requested_blocks; i++) {
if (feof(dev->drv->f)) if (feof(dev->drv->fp))
break; break;
fwrite(dev->buffer, 1, dev->drv->sector_size, dev->drv->f); fwrite(dev->buffer, 1, dev->drv->sector_size, dev->drv->fp);
} }
mo_log("MO %i: Erased %i bytes of blocks...\n", dev->id, i * dev->drv->sector_size); mo_log("MO %i: Erased %i bytes of blocks...\n", dev->id, i * dev->drv->sector_size);
@@ -1140,7 +1137,7 @@ mo_pre_execution_check(mo_t *dev, uint8_t *cdb)
return 0; return 0;
} }
ready = (dev->drv->f != NULL); ready = (dev->drv->fp != NULL);
/* If the drive is not ready, there is no reason to keep the /* If the drive is not ready, there is no reason to keep the
UNIT ATTENTION condition present, as we only use it to mark UNIT ATTENTION condition present, as we only use it to mark
@@ -1256,7 +1253,7 @@ mo_request_sense_for_scsi(scsi_common_t *sc, uint8_t *buffer, uint8_t alloc_leng
mo_t *dev = (mo_t *) sc; mo_t *dev = (mo_t *) sc;
int ready = 0; int ready = 0;
ready = (dev->drv->f != NULL); ready = (dev->drv->fp != NULL);
if (!ready && dev->unit_attention) { if (!ready && dev->unit_attention) {
/* If the drive is not ready, there is no reason to keep the /* If the drive is not ready, there is no reason to keep the

84
src/disk/zip.c
View File

@@ -470,9 +470,9 @@ find_zip_for_channel(uint8_t channel)
static int static int
zip_load_abort(zip_t *dev) zip_load_abort(zip_t *dev)
{ {
if (dev->drv->f) if (dev->drv->fp)
fclose(dev->drv->f); fclose(dev->drv->fp);
dev->drv->f = NULL; dev->drv->fp = NULL;
dev->drv->medium_size = 0; dev->drv->medium_size = 0;
zip_eject(dev->id); /* Make sure the host OS knows we've rejected (and ejected) the image. */ zip_eject(dev->id); /* Make sure the host OS knows we've rejected (and ejected) the image. */
return 0; return 0;
@@ -483,11 +483,11 @@ zip_load(zip_t *dev, char *fn)
{ {
int size = 0; int size = 0;
dev->drv->f = plat_fopen(fn, dev->drv->read_only ? "rb" : "rb+"); dev->drv->fp = plat_fopen(fn, dev->drv->read_only ? "rb" : "rb+");
if (!dev->drv->f) { if (!dev->drv->fp) {
if (!dev->drv->read_only) { if (!dev->drv->read_only) {
dev->drv->f = plat_fopen(fn, "rb"); dev->drv->fp = plat_fopen(fn, "rb");
if (dev->drv->f) if (dev->drv->fp)
dev->drv->read_only = 1; dev->drv->read_only = 1;
else else
return zip_load_abort(dev); return zip_load_abort(dev);
@@ -495,8 +495,8 @@ zip_load(zip_t *dev, char *fn)
return zip_load_abort(dev); return zip_load_abort(dev);
} }
fseek(dev->drv->f, 0, SEEK_END); fseek(dev->drv->fp, 0, SEEK_END);
size = ftell(dev->drv->f); size = ftell(dev->drv->fp);
if ((size == ((ZIP_250_SECTORS << 9) + 0x1000)) || (size == ((ZIP_SECTORS << 9) + 0x1000))) { if ((size == ((ZIP_250_SECTORS << 9) + 0x1000)) || (size == ((ZIP_SECTORS << 9) + 0x1000))) {
/* This is a ZDI image. */ /* This is a ZDI image. */
@@ -521,7 +521,7 @@ zip_load(zip_t *dev, char *fn)
dev->drv->medium_size = size >> 9; dev->drv->medium_size = size >> 9;
if (fseek(dev->drv->f, dev->drv->base, SEEK_SET) == -1) if (fseek(dev->drv->fp, dev->drv->base, SEEK_SET) == -1)
fatal("zip_load(): Error seeking to the beginning of the file\n"); fatal("zip_load(): Error seeking to the beginning of the file\n");
strncpy(dev->drv->image_path, fn, sizeof(dev->drv->image_path) - 1); strncpy(dev->drv->image_path, fn, sizeof(dev->drv->image_path) - 1);
@@ -546,16 +546,16 @@ zip_disk_reload(zip_t *dev)
void void
zip_disk_unload(zip_t *dev) zip_disk_unload(zip_t *dev)
{ {
if (dev->drv->f) { if (dev->drv->fp) {
fclose(dev->drv->f); fclose(dev->drv->fp);
dev->drv->f = NULL; dev->drv->fp = NULL;
} }
} }
void void
zip_disk_close(zip_t *dev) zip_disk_close(zip_t *dev)
{ {
if (dev->drv->f) { if (dev->drv->fp) {
zip_disk_unload(dev); zip_disk_unload(dev);
memcpy(dev->drv->prev_image_path, dev->drv->image_path, sizeof(dev->drv->prev_image_path)); memcpy(dev->drv->prev_image_path, dev->drv->image_path, sizeof(dev->drv->prev_image_path));
@@ -660,8 +660,8 @@ zip_atapi_phase_to_scsi(zip_t *dev)
static void static void
zip_mode_sense_load(zip_t *dev) zip_mode_sense_load(zip_t *dev)
{ {
FILE *f; FILE *fp;
char file_name[512]; char fn[512];
memset(&dev->ms_pages_saved, 0, sizeof(mode_sense_pages_t)); memset(&dev->ms_pages_saved, 0, sizeof(mode_sense_pages_t));
if (dev->drv->is_250) { if (dev->drv->is_250) {
@@ -676,33 +676,33 @@ zip_mode_sense_load(zip_t *dev)
memcpy(&dev->ms_pages_saved, &zip_mode_sense_pages_default, sizeof(mode_sense_pages_t)); memcpy(&dev->ms_pages_saved, &zip_mode_sense_pages_default, sizeof(mode_sense_pages_t));
} }
memset(file_name, 0, 512); memset(fn, 0, 512);
if (dev->drv->bus_type == ZIP_BUS_SCSI) if (dev->drv->bus_type == ZIP_BUS_SCSI)
sprintf(file_name, "scsi_zip_%02i_mode_sense_bin", dev->id); sprintf(fn, "scsi_zip_%02i_mode_sense_bin", dev->id);
else else
sprintf(file_name, "zip_%02i_mode_sense_bin", dev->id); sprintf(fn, "zip_%02i_mode_sense_bin", dev->id);
f = plat_fopen(nvr_path(file_name), "rb"); fp = plat_fopen(nvr_path(fn), "rb");
if (f) { if (fp) {
/* Nothing to read, not used by ZIP. */ /* Nothing to read, not used by ZIP. */
fclose(f); fclose(fp);
} }
} }
static void static void
zip_mode_sense_save(zip_t *dev) zip_mode_sense_save(zip_t *dev)
{ {
FILE *f; FILE *fp;
char file_name[512]; char fn[512];
memset(file_name, 0, 512); memset(fn, 0, 512);
if (dev->drv->bus_type == ZIP_BUS_SCSI) if (dev->drv->bus_type == ZIP_BUS_SCSI)
sprintf(file_name, "scsi_zip_%02i_mode_sense_bin", dev->id); sprintf(fn, "scsi_zip_%02i_mode_sense_bin", dev->id);
else else
sprintf(file_name, "zip_%02i_mode_sense_bin", dev->id); sprintf(fn, "zip_%02i_mode_sense_bin", dev->id);
f = plat_fopen(nvr_path(file_name), "wb"); fp = plat_fopen(nvr_path(fn), "wb");
if (f) { if (fp) {
/* Nothing to write, not used by ZIP. */ /* Nothing to write, not used by ZIP. */
fclose(f); fclose(fp);
} }
} }
@@ -1140,17 +1140,17 @@ zip_blocks(zip_t *dev, int32_t *len, UNUSED(int first_batch), int out)
*len = dev->requested_blocks << 9; *len = dev->requested_blocks << 9;
for (int i = 0; i < dev->requested_blocks; i++) { for (int i = 0; i < dev->requested_blocks; i++) {
if (fseek(dev->drv->f, dev->drv->base + (dev->sector_pos << 9) + (i << 9), SEEK_SET) == 1) if (fseek(dev->drv->fp, dev->drv->base + (dev->sector_pos << 9) + (i << 9), SEEK_SET) == 1)
break; break;
if (feof(dev->drv->f)) if (feof(dev->drv->fp))
break; break;
if (out) { if (out) {
if (fwrite(dev->buffer + (i << 9), 1, 512, dev->drv->f) != 512) if (fwrite(dev->buffer + (i << 9), 1, 512, dev->drv->fp) != 512)
fatal("zip_blocks(): Error writing data\n"); fatal("zip_blocks(): Error writing data\n");
} else { } else {
if (fread(dev->buffer + (i << 9), 1, 512, dev->drv->f) != 512) if (fread(dev->buffer + (i << 9), 1, 512, dev->drv->fp) != 512)
fatal("zip_blocks(): Error reading data\n"); fatal("zip_blocks(): Error reading data\n");
} }
} }
@@ -1209,7 +1209,7 @@ zip_pre_execution_check(zip_t *dev, uint8_t *cdb)
return 0; return 0;
} }
ready = (dev->drv->f != NULL); ready = (dev->drv->fp != NULL);
/* If the drive is not ready, there is no reason to keep the /* If the drive is not ready, there is no reason to keep the
UNIT ATTENTION condition present, as we only use it to mark UNIT ATTENTION condition present, as we only use it to mark
@@ -1325,7 +1325,7 @@ zip_request_sense_for_scsi(scsi_common_t *sc, uint8_t *buffer, uint8_t alloc_len
zip_t *dev = (zip_t *) sc; zip_t *dev = (zip_t *) sc;
int ready = 0; int ready = 0;
ready = (dev->drv->f != NULL); ready = (dev->drv->fp != NULL);
if (!ready && dev->unit_attention) { if (!ready && dev->unit_attention) {
/* If the drive is not ready, there is no reason to keep the /* If the drive is not ready, there is no reason to keep the
@@ -1972,7 +1972,7 @@ atapi_out:
dev->buffer[pos++] = 0; dev->buffer[pos++] = 0;
dev->buffer[pos++] = 0; dev->buffer[pos++] = 0;
dev->buffer[pos++] = 0; dev->buffer[pos++] = 0;
if (dev->drv->f != NULL) if (dev->drv->fp != NULL)
dev->buffer[pos++] = 16; dev->buffer[pos++] = 16;
else else
dev->buffer[pos++] = 8; dev->buffer[pos++] = 8;
@@ -1981,7 +1981,7 @@ atapi_out:
if (dev->drv->is_250) { if (dev->drv->is_250) {
/* ZIP 250 also supports ZIP 100 media, so if the medium is inserted, /* ZIP 250 also supports ZIP 100 media, so if the medium is inserted,
we return the inserted medium's size, otherwise, the ZIP 250 size. */ we return the inserted medium's size, otherwise, the ZIP 250 size. */
if (dev->drv->f != NULL) { if (dev->drv->fp != NULL) {
dev->buffer[pos++] = (dev->drv->medium_size >> 24) & 0xff; dev->buffer[pos++] = (dev->drv->medium_size >> 24) & 0xff;
dev->buffer[pos++] = (dev->drv->medium_size >> 16) & 0xff; dev->buffer[pos++] = (dev->drv->medium_size >> 16) & 0xff;
dev->buffer[pos++] = (dev->drv->medium_size >> 8) & 0xff; dev->buffer[pos++] = (dev->drv->medium_size >> 8) & 0xff;
@@ -2001,7 +2001,7 @@ atapi_out:
dev->buffer[pos++] = (ZIP_SECTORS >> 16) & 0xff; dev->buffer[pos++] = (ZIP_SECTORS >> 16) & 0xff;
dev->buffer[pos++] = (ZIP_SECTORS >> 8) & 0xff; dev->buffer[pos++] = (ZIP_SECTORS >> 8) & 0xff;
dev->buffer[pos++] = ZIP_SECTORS & 0xff; dev->buffer[pos++] = ZIP_SECTORS & 0xff;
if (dev->drv->f != NULL) if (dev->drv->fp != NULL)
dev->buffer[pos++] = 2; dev->buffer[pos++] = 2;
else else
dev->buffer[pos++] = 3; dev->buffer[pos++] = 3;
@@ -2011,7 +2011,7 @@ atapi_out:
dev->buffer[pos++] = 512 >> 8; dev->buffer[pos++] = 512 >> 8;
dev->buffer[pos++] = 512 & 0xff; dev->buffer[pos++] = 512 & 0xff;
if (dev->drv->f != NULL) { if (dev->drv->fp != NULL) {
/* Formattable capacity descriptor */ /* Formattable capacity descriptor */
dev->buffer[pos++] = (dev->drv->medium_size >> 24) & 0xff; dev->buffer[pos++] = (dev->drv->medium_size >> 24) & 0xff;
dev->buffer[pos++] = (dev->drv->medium_size >> 16) & 0xff; dev->buffer[pos++] = (dev->drv->medium_size >> 16) & 0xff;
@@ -2117,9 +2117,9 @@ zip_phase_data_out(scsi_common_t *sc)
dev->buffer[6] = (s >> 8) & 0xff; dev->buffer[6] = (s >> 8) & 0xff;
dev->buffer[7] = s & 0xff; dev->buffer[7] = s & 0xff;
} }
if (fseek(dev->drv->f, dev->drv->base + (i << 9), SEEK_SET) == -1) if (fseek(dev->drv->fp, dev->drv->base + (i << 9), SEEK_SET) == -1)
fatal("zip_phase_data_out(): Error seeking\n"); fatal("zip_phase_data_out(): Error seeking\n");
if (fwrite(dev->buffer, 1, 512, dev->drv->f) != 512) if (fwrite(dev->buffer, 1, 512, dev->drv->fp) != 512)
fatal("zip_phase_data_out(): Error writing data\n"); fatal("zip_phase_data_out(): Error writing data\n");
} }
break; break;