///////// TEST PROGRAM, NOT FOR ACTUAL USERS, MAKES DIRECT KERNEL CALLS !
int _dwrite (int argc, char ** argv)
{
char ans[1024] = "HARA BARA";
int bytes = 1024;
unsigned int sector = 1;
if(argc > 2)
{
int i;
int len = strlen(argv[1]);
sector = atoi(argv[2]);
if(len < 1024)
{
for(i = 0; i < len; ++i) {
ans[i] = argv[1][i];
}
for(; i < 1024; ++i)
{
ans[i] = 0;
}
}
int offset = 0;
int ata = ATA0;
_disk_write(ata, ans, 1, sector);
printf("Escrito en sector %d\n", sector);
}
return 0;
}
int write_disk(int ata, int sector, void * msg, int count, int offset) {
//##################### NEW
//sprintf("sector:%d\tcount:%d\n",sector,count);
/*new cache stuff according to hipotetical_write*/
/*int quantblocks = (int) (count / 512) + 1;
if (quantblocks > CACHE_BLOCKS) {
_disk_write(0x1f0, (char *) msg, count / 512, sector + 1);
return -1; //disk_write(block,buffer,size);
}
//Si no estan todos los bloques, entonces leo y meto en la cache.
if (cache_searchblockpackage(sector, quantblocks) == -1) {
char * buffer2 = (char *) malloc(count);
read_disk(0, sector, buffer2, count, 0);
cache_write(sector, buffer2, count);
//hipotetical_read(block, buffer2, size);
}
return cache_write(sector, msg, count);
//calculo la cantidad de bloques.
//si es muy grande lo que me piden para cache leo de disco directamente.
//me fijo si estan en la cache.
//si no estan me los traigo.
//escribo de la cache en el buffer y marco como dirty.
*/
//##################### NEW
return _disk_write(0x1f0, (char *) msg, count / 512, sector + 1);
}
void hdd_write(char * buffer, unsigned int sector) {
if(cache){
_cache_write(ATA0, buffer, 2, sector);
}
else{
_disk_write(ATA0, buffer, 2, sector);
}
}
int _cache_flush(void){
int i = 0;
for( i=0; i<SECTORS; i++ ){
if( sectors[i].used && sectors[i].dirty ){
_disk_write( ATA0, sectors[i].data, 1, sectors[i].index );
}
sectors[i].used = 0;
}
return 1;
}
int getFree(){
int i = 0;
for( i=0; i<SECTORS; i++ ){
if(!sectors[i].used){
return i;
}
}
if( sectors[SECTORS-count%SECTORS-1].dirty ){
_disk_write( ATA0, sectors[SECTORS-count%SECTORS-1].data, 1, sectors[SECTORS-count%SECTORS-1].index);
sectors[SECTORS-count%SECTORS-1].dirty = 0;
}
sectors[SECTORS-count%SECTORS-1].used = 0;
return SECTORS-count++%SECTORS-1;
}
int _dfill (int argc, char ** argv)
{
int j = 0;
for(j = 0; j < 1000; ++j)
{
int count = 384;
int bytes = 65536;
int sector = 1 + j * 128;
if(argc > 1)
{
int i;
sector = atoi(argv[1]);
for(i = 0; i < 65536; ++i) {
ans[i] = '0' + (i / 512) % 10;
}
int offset = 0;
int ata = ATA0;
Cli();
_disk_write(ata, ans, count, sector);
for(i = 0; i < 65536; ++i) {
ans[i] = 0;
}
// _disk_read(ata, ans, count, sector);
Sti();
printf("%d\n", j);
// for(i = 0; i < count; ++i) {
// if(ans[i * 512] != i % 10 + '0') {
// printf("Err %d %d %d %d\n", i % 10 + '0', ans[i * 512], i, j);
// getC();
// break;
// }
// }
}
}
return 0;
}