treeblockdevice.java

JPC: x86 PC Hardware Emulator. 牛津大学开发的一个纯JAVA的x86系统结构硬件模拟器。

                                {
                                    oldfile.renameTo(new File(path, name + "." + ext));
                                    changedFile.setFile(new File(path, name + "." + ext));
                                }
                            }
                        } 
                    }
                    else
                    {
                        //it is a file, write sector to it
                        try
                        {
                            RandomAccessFile out = new RandomAccessFile(file, "rw");
                            out.seek((clusterCounter*sectorsPerCluster + offset)*bytesPerSector);
                            int len = 512;
                            MyFile castFile = (MyFile) myFile;
                            if ((clusterCounter*sectorsPerCluster + offset + 1)*bytesPerSector > castFile.getfileSize())
                            {
                                len = (int) (512 +castFile.getfileSize() - (clusterCounter*sectorsPerCluster + offset + 1)*bytesPerSector);
                            }
                            out.write(buffer,0,len); //need to clip zeros here at endof file somehow
                            out.close();
                            //update file's clusterlist
                            updateClusterList(myFile, sectorNumber);

                            if (!dataMap.containsKey(new Long(sectorNumber)))
                                dataMap.put(new Long(sectorNumber), myFile);
                            return 0;
                        }
                        catch (IOException e)
                        {
                            System.out.println("IO Exception in writing to file");
                            e.printStackTrace();
                            return -1;
                        }
                    }
                } 
            }
            if ((sectorNumber > 94) && (sectorNumber < 95 + 2*sectorsPerFAT))
            {
                //sector is in FAT

                //read old FAT first to compare to
                byte[] oldFATSector = new byte[512];
                read(sectorNumber, oldFATSector, 1);
                System.arraycopy(buffer, 0, FAT, (int) ((sectorNumber - 95) % sectorsPerFAT)*512, 512);
                long minCluster = ((sectorNumber-95) % sectorsPerFAT)*512/4;
                //long maxCluster = minCluster+512/4;
                boolean FATChanged;

                //make comparison
                // for (int j = (int) minCluster; j < maxCluster; j++)
                for (int j=0; j < 512/4; j++)
                {
                    FATChanged = false;
                    for (int i=0; i<4; i++)
                    {
                        if (buffer[4*j +i] != oldFATSector[4*j+i])
                            FATChanged = true;
                    }
                    if (FATChanged)
                    {
                        if (getFAT((int) (j + minCluster)) == 0)
                        {
                            //a FAT entry has been set to zero so we need to delete a file or dir
                            MyFATEntry myFile = (MyFATEntry) dataMap.get(new Long((j - 2 + minCluster)*sectorsPerCluster + 95 + 2*sectorsPerFAT));
                            if (myFile != null)
                            {
                                myFile.getFile().delete();
                                
                                //remove all references to the file from the data Map
                                long startClusterOfFile = myFile.getStartCluster();
                                for (int k =0; k<8; k++)
                                {
                                    dataMap.remove(new Long((startClusterOfFile-2)*sectorsPerCluster + 95 + 2*sectorsPerFAT + k));
                                }
                            }
                        }
                    }
                }

                //need to check if references have been made to allow us to commit writes from writeMap
                int i=0;
                while (i < bufferedClusters.size())
                {
             
                    long thisCluster = ((Long) bufferedClusters.get(i)).longValue();
                    //see if anything has been allocated with thisCluster value in FAT
                    for (long cluster = minCluster; cluster < minCluster + 512/5; cluster++)
                    {
                        if (getFAT((int) cluster) == thisCluster)
                        {
                            if (dataMap.get(new Long((cluster-2)*sectorsPerCluster +95 +2*sectorsPerFAT))!= null)
                            {
                                try
                                {
                                    MyFATEntry myFile = (MyFATEntry) dataMap.get(new Long((cluster-2)*sectorsPerCluster +95 +2*sectorsPerFAT));
                                    
                                    //need code to cover if it is a directory ************************************

                                    RandomAccessFile out = new RandomAccessFile(new File(myFile.getPath()), "rw");
                                    //calculate offset in file for this cluster
                                    int offset = 0;
                                    long nextCluster = myFile.getStartCluster();
                                    while (nextCluster != thisCluster)
                                    {
                                        offset++;
                                        nextCluster = getFAT((int) nextCluster);
                                    }
                                    for (int j=0; j<8; j++)
                                    {
                                
                                        if(writeMap.containsKey(new Long((thisCluster-2)*sectorsPerCluster +95 + 2*sectorsPerFAT +j)))
                                        {
                                            out.seek(((offset)*sectorsPerCluster+j)*bytesPerSector);
                                            int len = 512;
                                            MyFile castFile = (MyFile) myFile;
                                            if ((offset*sectorsPerCluster + j + 1)*bytesPerSector > castFile.getfileSize())
                                            {
                                                len = (int) (512 +castFile.getfileSize() - (offset*sectorsPerCluster + j + 1)*bytesPerSector);
                                            }
                                            out.write((byte[]) writeMap.get(new Long((thisCluster-2)*sectorsPerCluster + 95 + 2*sectorsPerFAT + j)), 0, len);
                                            //update cluster list for file
                                            updateClusterList(myFile, (thisCluster-2)*sectorsPerCluster + 95 + 2*sectorsPerFAT +j);
                                            
                                            if (!dataMap.containsKey(new Long((thisCluster-2)*sectorsPerCluster + 95 + 2*sectorsPerFAT +j)))
                                                dataMap.put(new Long((thisCluster-2)*sectorsPerCluster + 95 + 2*sectorsPerFAT +j), myFile);
                                        }
                                    }
                                    out.close();
                                    bufferedClusters.remove(i);
                                    i=i-1;
                                }
                                catch (IOException e)
                                {
                                    System.out.println("IO Exception in writing to file");
                                    e.printStackTrace();
                                }
                            }
                        }
                    }
                    i++;
                }
            }
            if (sectorNumber <95)  //end of tricky part.
            {
                System.arraycopy(buffer, 0, start, (int) sectorNumber*512, 512);
            }
            return 0;
        }
    }

    public void changePathOfTree(MyFATEntry mydir, String path)
    {
        MyDir myDir = (MyDir) mydir;
        byte[] dirEntry = myDir.getdirEntry();
        //loop over sectors of dirEntry
        for (int i = 0; i <  (int) dirEntry.length/32 ; i++)
        {
            int newStartCluster = (dirEntry[32*i+26] & 0xFF) + ((dirEntry[32*i+27] & 0xFF) << 8) +  ((dirEntry[32*i+20] & 0xFF) << 16) + ((dirEntry[32*i+21] & 0xFF) << 24);
            if ((dirEntry[32*i] & 0xFF) == 0xE5) 
                continue;
            if ((dirEntry[32*i+11] & 0xFF) == 0xF)
                continue; //skip LFN's for now
            if ((dirEntry[32*i] & 0xFF) == 0x00)
                continue;
            String name = "";
            String ext = "";
            for(int m =0; m<8;m++) {name += (char) dirEntry[32*i + m];}
            for(int m =0; m<3;m++) {ext += (char) dirEntry[32*i + 8 + m];}
            name = name.trim();
            ext = ext.trim();
            if ((name.equals(".")) || (name.equals(".."))) //skip current and parent directory entries
                continue;
            long newStartSector = (newStartCluster-2)*sectorsPerCluster + 95 + 2*sectorsPerFAT;
            boolean isDirectory = (dirEntry[32*i + 11] & 0x10) == 0x10;
            MyFATEntry myfile = (MyFATEntry) dataMap.get(new Long(newStartSector));
            File file = myfile.getFile();
            if (!isDirectory)
            {
                myfile.setFile(new File(path, name + "." + ext));
            }
            else
            {
                myfile.setFile(new File(path, name + ext));
                changePathOfTree((MyDir) myfile, myfile.getFile().getPath());
            }
        }
    }

    public void updateClusterList(MyFATEntry myFile, long sectorNumber)
    {
        if (!myFile.clusterList.containsKey(new Long(clusterNumber(sectorNumber))))
        {
            myFile.clusterList.put(new Long(clusterNumber(sectorNumber)), new Long(myFile.getSizeClusters() + 1));
            myFile.setSizeClusters(myFile.getSizeClusters() + 1);
            if (myFile.getLastSector() < sectorNumber)//wrong
                myFile.setLastSector(sectorNumber);
        }
    }

    public long clusterNumber(long sector) 
    {
        return (long) (sector - 95 - 2*sectorsPerFAT)/sectorsPerCluster + 2 ;
    }

    public boolean inserted()
    {
        return true;
    }

    public boolean locked()
    {
        return locked;
    }

    public boolean readOnly()
    {
        return true;
    }

    public void setLock(boolean l)
    {
        locked = l;
    }

    public long getTotalSectors()
    {
        return totalSectors;
    }

    public int cylinders()
    {
    	//smaller than 1024
        return cylinders; 
    }

    public int heads()
    {
    	//smaller than 256
        return heads;
    }

    public int sectors()// is this looking for totalSectors or 63??
    {
        return (int) sectorsPerTrack;
    }

    public int type()
    {
        return TYPE_HD;
    }
 
    //convert FATmap to FAT
    private void mapToFAT(long offset)
    {
	// set up first 8 bytes of FAT
	byte[] initialbuffer = {(byte) 0xF8,(byte) 0xFF,(byte) 0xFF,(byte) 0x0F,(byte) 0xFF,(byte) 0xFF,(byte) 0xFF,(byte) 0x0F};
	byte[] endmark = {(byte) 0xFF,(byte) 0xFF,(byte) 0xFF,(byte) 0x0F};
	System.arraycopy(initialbuffer, 0, FAT,0, 8);
	
  	Set entries = FATMap.entrySet();
	Iterator itt = entries.iterator();
	while (itt.hasNext()) 
        {
	    Map.Entry entry = (Map.Entry) itt.next();
	    long startCluster =  ((Long) entry.getKey()).longValue();
	    long lengthClusters = ((MyFATEntry) entry.getValue()).getSizeClusters();
	    
            int pos, next;
	    for (long j = 0; j<lengthClusters-1; j++)
            {
                pos = (int) ((startCluster+j)*4);
                next = (int) (startCluster+1+j);
                FAT[pos++] = (byte) next;
                FAT[pos++] = (byte) (next >>> 8);
                FAT[pos++] = (byte) (next >>> 16);
                FAT[pos++] = (byte) (next >>> 24);
            }
	    System.arraycopy(endmark, 0, FAT, (int)(startCluster+lengthClusters-1)*4, 4);
	}
    }

    //convert FATmap to data map
    private void mapToData(long offset)
    {
	Set entries = FATMap.entrySet();
	Iterator itt = entries.iterator();
	while (itt.hasNext()) 
        {
            //Long key = (Long) itt.next();
            //MyFATEntry fe = (MyFATEntry) FATMap.get(key);

	    Map.Entry entry = (Map.Entry) itt.next();
	    for (long j = 0; j < ((MyFATEntry)entry.getValue()).getSizeSectors(); j++)
                dataMap.put(new Long(offset+(((Long)entry.getKey()).longValue()-2)*sectorsPerCluster+j),entry.getValue());
	}
    }

    //method to write out to a new directory tree
    public void writeNewTree(File root)
    {
        //assume sectorsPerCluster = 8
        int relativeSectors;
        int reservedSectors;
        int sectorsPerFAT;
        
        //write disk to a new directory structure
        {
            if (root.isDirectory() && root.canWrite())
            {
                //read in first two sectors to determine drive properties
                byte[] s0 = new byte[512];
                byte[] s1 = new byte[512];
                read(0, s0, 1);
                relativeSectors = (int) s0[454] + (s0[455] << 8) + (s0[456] << 16) + (s0[457] << 24);
                read(relativeSectors, s1, 1);
                reservedSectors = (int) s1[14] + (s1[15] << 8);
                sectorsPerFAT = (int) s1[36] + (s1[37] << 8) + (s1[38] << 16) + (s1[39] << 24);

                /*
                //read FAT into byte[]
                FAT = new byte[512*sectorsPerFAT];
                for (int i = relativeSectors + reservedSectors; i < relativeSectors + reservedSectors + sectorsPerFAT; i++)
                {
                    read((long) i, s0, 1);
                    System.arraycopy(s0,0,FAT,(i - relativeSectors - reservedSectors)*512,512);
                }
                */

                //convert FAT to Hashmap
                hashFAT = new HashMap();