[apple/boot.git] / i386 / libsaio / ufs.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 *  ufs.c - File System Module for UFS.
 *
 *  Copyright (c) 1998-2002 Apple Computer, Inc.
 *
 *  DRI: Josh de Cesare
 */

#include <sl.h>

#include "ufs_byteorder.h"

typedef struct dinode Inode, *InodePtr;

// Private function prototypes

static char *ReadBlock(long fragNum, long fragOffset, long length,
                       char *buffer, long cache);
static long ReadInode(long inodeNum, InodePtr inode, long *flags, long *time);
static long ResolvePathToInode(char *filePath, long *flags,
                               InodePtr fileInode, InodePtr dirInode);
static long ReadDirEntry(InodePtr dirInode, long *fileInodeNum,
                         long *dirIndex, char **name);
static long FindFileInDir(char *fileName, long *flags,
                          InodePtr fileInode, InodePtr dirInode);
static char *ReadFileBlock(InodePtr fileInode, long fragNum, long blockOffset,
                           long length, char *buffer, long cache);
static long ReadFile(InodePtr fileInode, long *length);

#define kDevBlockSize (0x200)    // Size of each disk block.
#define kDiskLableBlock (15)     // Block the DL is in.

#ifdef __i386__

static CICell    gCurrentIH;
static long long gPartitionBase;
static char      *gDLBuf;
static char      *gFSBuf;
static struct fs *gFS;
static long      gBlockSize;
static long      gFragSize;
static long      gFragsPerBlock;
static char      *gTempBlock;
static char      *gTempName;
static char      *gTempName2;
static InodePtr  gRootInodePtr;
static InodePtr  gFileInodePtr;

#else  /* !__i386__ */

static CICell    gCurrentIH;
static long long gPartitionBase;
static char      gDLBuf[8192];
static char      gFSBuf[SBSIZE];
static struct fs *gFS;
static long      gBlockSize;
static long      gFragSize;
static long      gFragsPerBlock;
static char      *gTempBlock;
static char      gTempName[MAXNAMLEN + 1];
static char      gTempName2[MAXNAMLEN + 1];
static Inode     _gRootInode;
static Inode     _gFileInode;
static InodePtr  gRootInodePtr = &_gRootInode;
static InodePtr  gFileInodePtr = &_gFileInode;

#endif /* !__i386__ */

// Public functions

long UFSInitPartition( CICell ih )
{
    if (ih == gCurrentIH) {
#ifdef __i386__
        CacheInit(ih, gBlockSize);
#endif
        return 0;
    }

    verbose("UFSInitPartition: %x\n", ih);

    gCurrentIH = 0;

#ifdef __i386__
    if (!gDLBuf) gDLBuf = (char *) malloc(8192);
    if (!gFSBuf) gFSBuf = (char *) malloc(SBSIZE);
    if (!gTempName) gTempName = (char *) malloc(MAXNAMLEN + 1);
    if (!gTempName2) gTempName2 = (char *) malloc(MAXNAMLEN + 1);
    if (!gRootInodePtr) gRootInodePtr = (InodePtr) malloc(sizeof(Inode));
    if (!gFileInodePtr) gFileInodePtr = (InodePtr) malloc(sizeof(Inode));
    if (!gDLBuf || !gFSBuf || !gTempName || !gTempName2 ||
        !gRootInodePtr || !gFileInodePtr) return -1;
#endif

    // Assume there is no Disk Label
    gPartitionBase = 0;

    // Look for the Super Block
    Seek(ih, gPartitionBase + SBOFF);
    Read(ih, (long)gFSBuf, SBSIZE);

    gFS = (struct fs *)gFSBuf;
    byte_swap_superblock(gFS);

    if (gFS->fs_magic != FS_MAGIC) {
#ifdef __i386__
        return -1;  // not yet for Intel
#else  /* !__i386__ */
        disk_label_t *dl;
        partition_t  *part;

        // Did not find it... Look for the Disk Label.
        // Look for the Disk Label
        Seek(ih, 1ULL * kDevBlockSize * kDiskLableBlock);
        Read(ih, (long)gDLBuf, 8192);
    
        dl = (disk_label_t *)gDLBuf;
        byte_swap_disklabel_in(dl);
    
        if (dl->dl_version != DL_VERSION) {
            return -1;
        }
    
        part = &dl->dl_part[0];
        gPartitionBase = (1ULL * (dl->dl_front + part->p_base) * dl->dl_secsize) -
                         (1ULL * (dl->dl_label_blkno - kDiskLableBlock) * kDevBlockSize);
    
        // Re-read the Super Block.
        Seek(ih, gPartitionBase + SBOFF);
        Read(ih, (long)gFSBuf, SBSIZE);

        gFS = (struct fs *)gFSBuf;
        if (gFS->fs_magic != FS_MAGIC) {
            return -1;
        }
#endif /* !__i386__ */
    }

    // Calculate the block size and set up the block cache.
    gBlockSize = gFS->fs_bsize;
    gFragSize  = gFS->fs_fsize;
    gFragsPerBlock = gBlockSize / gFragSize;
    if (gTempBlock != 0) free(gTempBlock);
    gTempBlock = malloc(gBlockSize);
    CacheInit(ih, gBlockSize);

    gCurrentIH = ih;

    // Read the Root Inode
    ReadInode(ROOTINO, gRootInodePtr, 0, 0);

    return 0;
}

long UFSLoadFile( CICell ih, char * filePath )
{
    long ret, length, flags;

    if (UFSInitPartition(ih) == -1) return -1;

    verbose("Loading UFS file: [%s] from %x.\n", filePath, (unsigned)ih);

    // Skip one or two leading '/'.
    if (*filePath == '/') filePath++;
    if (*filePath == '/') filePath++;

    ret = ResolvePathToInode(filePath, &flags, gFileInodePtr, gRootInodePtr);
    if ((ret == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) return -1;

#if 0
    // System.config/Default.table will fail this check.
    // Turn this back on when usage of System.config is deprecated.
    if (flags & (kOwnerNotRoot | kPermGroupWrite | kPermOtherWrite)) return -1;
#endif

    ret = ReadFile(gFileInodePtr, &length);
    if (ret == -1) return -1;
    
    return length;
}

long UFSGetDirEntry( CICell ih, char * dirPath, long * dirIndex,
                     char ** name, long * flags, long * time )
{
    long  ret, fileInodeNum, dirFlags;
    Inode tmpInode;

    if (UFSInitPartition(ih) == -1) return -1;

    // Skip a leading '/' if present
    if (*dirPath == '/') dirPath++;
    if (*dirPath == '/') dirPath++;

    ret = ResolvePathToInode(dirPath, &dirFlags, gFileInodePtr, gRootInodePtr);
    if ((ret == -1) || ((dirFlags & kFileTypeMask) != kFileTypeDirectory))
        return -1;

    ret = ReadDirEntry(gFileInodePtr, &fileInodeNum, dirIndex, name);
    if (ret != 0) return ret;

    ReadInode(fileInodeNum, &tmpInode, flags, time);

    return 0;
}

// Private functions

static char * ReadBlock( long fragNum, long blockOffset, long length,
                         char * buffer, long cache )
{
    long long offset;
    long blockNum;

    blockNum = fragNum / gFragsPerBlock;
    fragNum -= blockNum * gFragsPerBlock;
    
    blockOffset += fragNum * gFragSize;
    
    offset = gPartitionBase + 1ULL * blockNum * gBlockSize;

    if (cache && ((blockOffset + length) <= gBlockSize)) {
        CacheRead(gCurrentIH, gTempBlock, offset, gBlockSize, 1);
        if (buffer != 0) bcopy(gTempBlock + blockOffset, buffer, length);
        else buffer = gTempBlock + blockOffset;
    } else {
        offset += blockOffset;
        CacheRead(gCurrentIH, buffer, offset, length, 0);
    }

    return buffer;
}

static long ReadInode( long inodeNum, InodePtr inode, long * flags, long * time )
{
    long fragNum = ino_to_fsba(gFS, inodeNum);
    long blockOffset = ino_to_fsbo(gFS, inodeNum) * sizeof(Inode);

    ReadBlock(fragNum, blockOffset, sizeof(Inode), (char *)inode, 1);
    byte_swap_dinode_in(inode);

    if (time != 0) *time = inode->di_mtime;

    if (flags != 0) {
        switch (inode->di_mode & IFMT) {
            case IFREG: *flags = kFileTypeFlat; break;
            case IFDIR: *flags = kFileTypeDirectory; break;
            case IFLNK: *flags = kFileTypeLink; break;
            default :   *flags = kFileTypeUnknown; break;
        }

        *flags |= inode->di_mode & kPermMask;

        if (inode->di_uid != 0) *flags |= kOwnerNotRoot;
    }

    return 0;
}

static long ResolvePathToInode( char * filePath, long * flags,
                                InodePtr fileInode, InodePtr dirInode )
{
    char * restPath;
    long   ret, cnt;

    // if filePath is empty the we want this directory.
    if (*filePath == '\0') {
        bcopy((char *)dirInode, (char *)fileInode, sizeof(Inode));
        return 0;
    }

    // Copy the file name to gTempName
    cnt = 0;
    while ((filePath[cnt] != '/') && (filePath[cnt] != '\0')) cnt++;
    strncpy(gTempName, filePath, cnt);

    // Move restPath to the right place.
    if (filePath[cnt] != '\0') cnt++;
    restPath = filePath + cnt;

    // gTempName is a name in the current Dir.
    // restPath is the rest of the path if any.

    ret = FindFileInDir(gTempName, flags, fileInode, dirInode);
    if (ret == -1) return -1;

    if ((*restPath != '\0') && ((*flags & kFileTypeMask) == kFileTypeDirectory))
        ret = ResolvePathToInode(restPath, flags, fileInode, fileInode);

    return ret;
}

static long ReadDirEntry( InodePtr dirInode, long * fileInodeNum,
                          long * dirIndex, char ** name )
{
    struct direct *dir;
    char          *buffer;
    long          index;
    long          dirBlockNum, dirBlockOffset;

    while (1) {
        index = *dirIndex;
    
        dirBlockOffset = index % DIRBLKSIZ;
        dirBlockNum    = index / DIRBLKSIZ;

        buffer = ReadFileBlock(dirInode, dirBlockNum, 0, DIRBLKSIZ, 0, 1);
        if (buffer == 0) return -1;

        dir = (struct direct *)(buffer + dirBlockOffset);
        byte_swap_dir_block_in((char *)dir, 1);

        *dirIndex += dir->d_reclen;
        
        if (dir->d_ino != 0) break;
        
        if (dirBlockOffset != 0) return -1;
    }

    *fileInodeNum = dir->d_ino;
    *name = strncpy(gTempName2, dir->d_name, dir->d_namlen);

    return 0;
}

static long FindFileInDir( char * fileName, long * flags,
                           InodePtr fileInode, InodePtr dirInode )
{
    long ret, inodeNum, index = 0;
    char *name;

    while (1) {
        ret = ReadDirEntry(dirInode, &inodeNum, &index, &name);
        if (ret == -1) return -1;

        if (strcmp(fileName, name) == 0) break;
    }

    ReadInode(inodeNum, fileInode, flags, 0);

    return 0;
}

static char * ReadFileBlock( InodePtr fileInode, long fragNum, long blockOffset,
                             long length, char * buffer, long cache )
{
    long fragCount, blockNum;
    long diskFragNum, indFragNum, indBlockOff, refsPerBlock;
    char *indBlock;

    fragCount = (fileInode->di_size + gFragSize - 1) / gFragSize;
    if (fragNum >= fragCount) return 0;

    refsPerBlock = gBlockSize / sizeof(ufs_daddr_t);

    blockNum = fragNum / gFragsPerBlock;
    fragNum -= blockNum * gFragsPerBlock;
    
    // Get Direct Block Number.
    if (blockNum < NDADDR) {
        diskFragNum = fileInode->di_db[blockNum];
    } else {
        blockNum -= NDADDR;

        // Get Single Indirect Fragment Number.
        if (blockNum < refsPerBlock) {
            indFragNum = fileInode->di_ib[0];
        } else {
            blockNum -= refsPerBlock;

            // Get Double Indirect Fragment Number.
            if (blockNum < (refsPerBlock * refsPerBlock)) {
                indFragNum = fileInode->di_ib[1];
            } else {
                blockNum -= refsPerBlock * refsPerBlock;

                // Get Triple Indirect Fragment Number.
                indFragNum = fileInode->di_ib[2];

                indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1);
                indBlockOff = blockNum / (refsPerBlock * refsPerBlock);
                blockNum %= (refsPerBlock * refsPerBlock);
                indFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[indBlockOff]);
            }

            indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1);
            indBlockOff = blockNum / refsPerBlock;
            blockNum %= refsPerBlock;
            indFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[indBlockOff]);
        }

        indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1);
        diskFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[blockNum]);
    }

    buffer = ReadBlock(diskFragNum+fragNum, blockOffset, length, buffer, cache);

    return buffer;
}

static long ReadFile( InodePtr fileInode, long * length )
{
    long bytesLeft, curSize, curFrag = 0;
    char *buffer, *curAddr = (char *)kLoadAddr;

#ifdef __i386__
    curAddr = gFSLoadAddress;
#endif

    bytesLeft = *length = fileInode->di_size;

    if (*length > kLoadSize) {
        printf("File is too large.\n");
        return -1;
    }

    while (bytesLeft) {
        if (bytesLeft > gBlockSize) curSize = gBlockSize;
        else curSize = bytesLeft;

        buffer = ReadFileBlock(fileInode, curFrag, 0, curSize, curAddr, 0);
        if (buffer == 0) break;

        curFrag += gFragsPerBlock;
        curAddr += curSize;
        bytesLeft -= curSize;
    }

    return bytesLeft;
}
Commit	Line	Data
75b89a82 A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* ufs.c - File System Module for UFS.
	24	*
	25	* Copyright (c) 1998-2002 Apple Computer, Inc.
	26	*
	27	* DRI: Josh de Cesare
	28	*/
	29
	30	#include <sl.h>
	31
	32	#include "ufs_byteorder.h"
	33
	34	typedef struct dinode Inode, *InodePtr;
	35
	36	// Private function prototypes
	37
	38	static char *ReadBlock(long fragNum, long fragOffset, long length,
	39	char *buffer, long cache);
	40	static long ReadInode(long inodeNum, InodePtr inode, long flags, long time);
	41	static long ResolvePathToInode(char filePath, long flags,
	42	InodePtr fileInode, InodePtr dirInode);
	43	static long ReadDirEntry(InodePtr dirInode, long *fileInodeNum,
	44	long dirIndex, char *name);
	45	static long FindFileInDir(char fileName, long flags,
	46	InodePtr fileInode, InodePtr dirInode);
	47	static char *ReadFileBlock(InodePtr fileInode, long fragNum, long blockOffset,
	48	long length, char *buffer, long cache);
	49	static long ReadFile(InodePtr fileInode, long *length);
	50
	51	#define kDevBlockSize (0x200) // Size of each disk block.
	52	#define kDiskLableBlock (15) // Block the DL is in.
	53
	54	#ifdef __i386__
	55
	56	static CICell gCurrentIH;
	57	static long long gPartitionBase;
	58	static char *gDLBuf;
	59	static char *gFSBuf;
	60	static struct fs *gFS;
	61	static long gBlockSize;
	62	static long gFragSize;
	63	static long gFragsPerBlock;
	64	static char *gTempBlock;
65	static char *gTempName;
66	static char *gTempName2;
67	static InodePtr gRootInodePtr;
68	static InodePtr gFileInodePtr;
69
70	#else /* !__i386__ */
71
72	static CICell gCurrentIH;
73	static long long gPartitionBase;
74	static char gDLBuf[8192];
75	static char gFSBuf[SBSIZE];
76	static struct fs *gFS;
77	static long gBlockSize;
78	static long gFragSize;
79	static long gFragsPerBlock;
80	static char *gTempBlock;
81	static char gTempName[MAXNAMLEN + 1];
82	static char gTempName2[MAXNAMLEN + 1];
83	static Inode _gRootInode;
84	static Inode _gFileInode;
85	static InodePtr gRootInodePtr = &_gRootInode;
86	static InodePtr gFileInodePtr = &_gFileInode;
87
88	#endif /* !__i386__ */
89
90	// Public functions
91
92	long UFSInitPartition( CICell ih )
93	{
94	if (ih == gCurrentIH) {
95	#ifdef __i386__
96	CacheInit(ih, gBlockSize);
97	#endif
98	return 0;
99	}
100
101	verbose("UFSInitPartition: %x\n", ih);
102
103	gCurrentIH = 0;
104
105	#ifdef __i386__
106	if (!gDLBuf) gDLBuf = (char *) malloc(8192);
107	if (!gFSBuf) gFSBuf = (char *) malloc(SBSIZE);
108	if (!gTempName) gTempName = (char *) malloc(MAXNAMLEN + 1);
109	if (!gTempName2) gTempName2 = (char *) malloc(MAXNAMLEN + 1);
110	if (!gRootInodePtr) gRootInodePtr = (InodePtr) malloc(sizeof(Inode));
111	if (!gFileInodePtr) gFileInodePtr = (InodePtr) malloc(sizeof(Inode));
112	if (!gDLBuf \|\| !gFSBuf \|\| !gTempName \|\| !gTempName2 \|\|
113	!gRootInodePtr \|\| !gFileInodePtr) return -1;
114	#endif
115
116	// Assume there is no Disk Label
117	gPartitionBase = 0;
118
119	// Look for the Super Block
120	Seek(ih, gPartitionBase + SBOFF);
121	Read(ih, (long)gFSBuf, SBSIZE);
122
123	gFS = (struct fs *)gFSBuf;
124	byte_swap_superblock(gFS);
125
126	if (gFS->fs_magic != FS_MAGIC) {
127	#ifdef __i386__
128	return -1; // not yet for Intel
129	#else /* !__i386__ */
130	disk_label_t *dl;
131	partition_t *part;
132
133	// Did not find it... Look for the Disk Label.
134	// Look for the Disk Label
135	Seek(ih, 1ULL * kDevBlockSize * kDiskLableBlock);
136	Read(ih, (long)gDLBuf, 8192);
137
138	dl = (disk_label_t *)gDLBuf;
139	byte_swap_disklabel_in(dl);
140
141	if (dl->dl_version != DL_VERSION) {
142	return -1;
143	}
144
145	part = &dl->dl_part[0];
146	gPartitionBase = (1ULL * (dl->dl_front + part->p_base) * dl->dl_secsize) -
147	(1ULL * (dl->dl_label_blkno - kDiskLableBlock) * kDevBlockSize);
148
149	// Re-read the Super Block.
150	Seek(ih, gPartitionBase + SBOFF);
151	Read(ih, (long)gFSBuf, SBSIZE);
152
153	gFS = (struct fs *)gFSBuf;
154	if (gFS->fs_magic != FS_MAGIC) {
155	return -1;
156	}
157	#endif /* !__i386__ */
158	}
159
160	// Calculate the block size and set up the block cache.
161	gBlockSize = gFS->fs_bsize;
162	gFragSize = gFS->fs_fsize;
163	gFragsPerBlock = gBlockSize / gFragSize;
164	if (gTempBlock != 0) free(gTempBlock);
165	gTempBlock = malloc(gBlockSize);
166	CacheInit(ih, gBlockSize);
167
168	gCurrentIH = ih;
169
170	// Read the Root Inode
171	ReadInode(ROOTINO, gRootInodePtr, 0, 0);
172
173	return 0;
174	}
175
176	long UFSLoadFile( CICell ih, char * filePath )
177	{
178	long ret, length, flags;
179
180	if (UFSInitPartition(ih) == -1) return -1;
181
182	verbose("Loading UFS file: [%s] from %x.\n", filePath, (unsigned)ih);
183
184	// Skip one or two leading '/'.
185	if (*filePath == '/') filePath++;
186	if (*filePath == '/') filePath++;
187
188	ret = ResolvePathToInode(filePath, &flags, gFileInodePtr, gRootInodePtr);
189	if ((ret == -1) \|\| ((flags & kFileTypeMask) != kFileTypeFlat)) return -1;
190
191	#if 0
192	// System.config/Default.table will fail this check.
193	// Turn this back on when usage of System.config is deprecated.
194	if (flags & (kOwnerNotRoot \| kPermGroupWrite \| kPermOtherWrite)) return -1;
195	#endif
196
197	ret = ReadFile(gFileInodePtr, &length);
198	if (ret == -1) return -1;
199
200	return length;
201	}
202
203	long UFSGetDirEntry( CICell ih, char * dirPath, long * dirIndex,
204	char ** name, long * flags, long * time )
205	{
206	long ret, fileInodeNum, dirFlags;
207	Inode tmpInode;
208
209	if (UFSInitPartition(ih) == -1) return -1;
210
211	// Skip a leading '/' if present
212	if (*dirPath == '/') dirPath++;
213	if (*dirPath == '/') dirPath++;
214
215	ret = ResolvePathToInode(dirPath, &dirFlags, gFileInodePtr, gRootInodePtr);
216	if ((ret == -1) \|\| ((dirFlags & kFileTypeMask) != kFileTypeDirectory))
217	return -1;
218
219	ret = ReadDirEntry(gFileInodePtr, &fileInodeNum, dirIndex, name);
220	if (ret != 0) return ret;
221
222	ReadInode(fileInodeNum, &tmpInode, flags, time);
223
224	return 0;
225	}
226
227	// Private functions
228
229	static char * ReadBlock( long fragNum, long blockOffset, long length,
230	char * buffer, long cache )
231	{
232	long long offset;
233	long blockNum;
234
235	blockNum = fragNum / gFragsPerBlock;
236	fragNum -= blockNum * gFragsPerBlock;
237
238	blockOffset += fragNum * gFragSize;
239
240	offset = gPartitionBase + 1ULL * blockNum * gBlockSize;
241
242	if (cache && ((blockOffset + length) <= gBlockSize)) {
243	CacheRead(gCurrentIH, gTempBlock, offset, gBlockSize, 1);
244	if (buffer != 0) bcopy(gTempBlock + blockOffset, buffer, length);
245	else buffer = gTempBlock + blockOffset;
246	} else {
247	offset += blockOffset;
248	CacheRead(gCurrentIH, buffer, offset, length, 0);
249	}
250
251	return buffer;
252	}
253
254	static long ReadInode( long inodeNum, InodePtr inode, long * flags, long * time )
255	{
256	long fragNum = ino_to_fsba(gFS, inodeNum);
257	long blockOffset = ino_to_fsbo(gFS, inodeNum) * sizeof(Inode);
258
259	ReadBlock(fragNum, blockOffset, sizeof(Inode), (char *)inode, 1);
260	byte_swap_dinode_in(inode);
261
262	if (time != 0) *time = inode->di_mtime;
263
264	if (flags != 0) {
265	switch (inode->di_mode & IFMT) {
266	case IFREG: *flags = kFileTypeFlat; break;
267	case IFDIR: *flags = kFileTypeDirectory; break;
268	case IFLNK: *flags = kFileTypeLink; break;
269	default : *flags = kFileTypeUnknown; break;
270	}
271
272	*flags \|= inode->di_mode & kPermMask;
273
274	if (inode->di_uid != 0) *flags \|= kOwnerNotRoot;
275	}
276
277	return 0;
278	}
279
280	static long ResolvePathToInode( char * filePath, long * flags,
281	InodePtr fileInode, InodePtr dirInode )
282	{
283	char * restPath;
284	long ret, cnt;
285
286	// if filePath is empty the we want this directory.
287	if (*filePath == '\0') {
288	bcopy((char )dirInode, (char )fileInode, sizeof(Inode));
289	return 0;
290	}
291
292	// Copy the file name to gTempName
293	cnt = 0;
294	while ((filePath[cnt] != '/') && (filePath[cnt] != '\0')) cnt++;
295	strncpy(gTempName, filePath, cnt);
296
297	// Move restPath to the right place.
298	if (filePath[cnt] != '\0') cnt++;
299	restPath = filePath + cnt;
300
301	// gTempName is a name in the current Dir.
302	// restPath is the rest of the path if any.
303
304	ret = FindFileInDir(gTempName, flags, fileInode, dirInode);
305	if (ret == -1) return -1;
306
307	if ((restPath != '\0') && ((flags & kFileTypeMask) == kFileTypeDirectory))
308	ret = ResolvePathToInode(restPath, flags, fileInode, fileInode);
309
310	return ret;
311	}
312
313	static long ReadDirEntry( InodePtr dirInode, long * fileInodeNum,
314	long * dirIndex, char ** name )
315	{
316	struct direct *dir;
317	char *buffer;
318	long index;
319	long dirBlockNum, dirBlockOffset;
320
321	while (1) {
322	index = *dirIndex;
323
324	dirBlockOffset = index % DIRBLKSIZ;
325	dirBlockNum = index / DIRBLKSIZ;
326
327	buffer = ReadFileBlock(dirInode, dirBlockNum, 0, DIRBLKSIZ, 0, 1);
328	if (buffer == 0) return -1;
329
330	dir = (struct direct *)(buffer + dirBlockOffset);
331	byte_swap_dir_block_in((char *)dir, 1);
332
333	*dirIndex += dir->d_reclen;
334
335	if (dir->d_ino != 0) break;
336
337	if (dirBlockOffset != 0) return -1;
338	}
339
340	*fileInodeNum = dir->d_ino;
341	*name = strncpy(gTempName2, dir->d_name, dir->d_namlen);
342
343	return 0;
344	}
345
346	static long FindFileInDir( char * fileName, long * flags,
347	InodePtr fileInode, InodePtr dirInode )
348	{
349	long ret, inodeNum, index = 0;
350	char *name;
351
352	while (1) {
353	ret = ReadDirEntry(dirInode, &inodeNum, &index, &name);
354	if (ret == -1) return -1;
355
356	if (strcmp(fileName, name) == 0) break;
357	}
358
359	ReadInode(inodeNum, fileInode, flags, 0);
360
361	return 0;
362	}
363
364	static char * ReadFileBlock( InodePtr fileInode, long fragNum, long blockOffset,
365	long length, char * buffer, long cache )
366	{
367	long fragCount, blockNum;
368	long diskFragNum, indFragNum, indBlockOff, refsPerBlock;
369	char *indBlock;
370
371	fragCount = (fileInode->di_size + gFragSize - 1) / gFragSize;
372	if (fragNum >= fragCount) return 0;
373
374	refsPerBlock = gBlockSize / sizeof(ufs_daddr_t);
375
376	blockNum = fragNum / gFragsPerBlock;
377	fragNum -= blockNum * gFragsPerBlock;
378
379	// Get Direct Block Number.
380	if (blockNum < NDADDR) {
381	diskFragNum = fileInode->di_db[blockNum];
382	} else {
383	blockNum -= NDADDR;
384
385	// Get Single Indirect Fragment Number.
386	if (blockNum < refsPerBlock) {
387	indFragNum = fileInode->di_ib[0];
388	} else {
389	blockNum -= refsPerBlock;
390
391	// Get Double Indirect Fragment Number.
392	if (blockNum < (refsPerBlock * refsPerBlock)) {
393	indFragNum = fileInode->di_ib[1];
394	} else {
395	blockNum -= refsPerBlock * refsPerBlock;
396
397	// Get Triple Indirect Fragment Number.
398	indFragNum = fileInode->di_ib[2];
399
400	indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1);
401	indBlockOff = blockNum / (refsPerBlock * refsPerBlock);
402	blockNum %= (refsPerBlock * refsPerBlock);
403	indFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[indBlockOff]);
404	}
405
406	indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1);
407	indBlockOff = blockNum / refsPerBlock;
408	blockNum %= refsPerBlock;
409	indFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[indBlockOff]);
410	}
411
412	indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1);
413	diskFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[blockNum]);
414	}
415
416	buffer = ReadBlock(diskFragNum+fragNum, blockOffset, length, buffer, cache);
417
418	return buffer;
419	}
420
421	static long ReadFile( InodePtr fileInode, long * length )
422	{
423	long bytesLeft, curSize, curFrag = 0;
424	char buffer, curAddr = (char *)kLoadAddr;
425
426	#ifdef __i386__
427	curAddr = gFSLoadAddress;
428	#endif
429
430	bytesLeft = *length = fileInode->di_size;
431
432	if (*length > kLoadSize) {
433	printf("File is too large.\n");
434	return -1;
435	}
436
437	while (bytesLeft) {
438	if (bytesLeft > gBlockSize) curSize = gBlockSize;
439	else curSize = bytesLeft;
440
441	buffer = ReadFileBlock(fileInode, curFrag, 0, curSize, curAddr, 0);
442	if (buffer == 0) break;
443
444	curFrag += gFragsPerBlock;
445	curAddr += curSize;
446	bytesLeft -= curSize;
447	}
448
449	return bytesLeft;
450	}