Chameleon

Chameleon Svn Source Tree

Root/branches/azimutz/Chazi/i386/libsaio/ufs.c

1/*␊
2 * Copyright (c) 2000-2003 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 2.0 (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#include "sl.h" //Azi:???␊
32␊
33#include "ufs.h"␊
34#include "ufs_byteorder.h"␊
35␊
36#if !defined(MAXNAMLEN) && defined(UFSMAXNAMLEN)␊
37#define MAXNAMLEN UFSMAXNAMLEN␊
38#endif␊
39␊
40typedef struct dinode Inode, *InodePtr;␊
41␊
42// Private function prototypes␊
43␊
44static char *ReadBlock(long fragNum, long fragOffset, long length,␊
45 char *buffer, long cache);␊
46static long ReadInode(long inodeNum, InodePtr inode, long *flags, long *time);␊
47static long ResolvePathToInode(char *filePath, long *flags,␊
48 InodePtr fileInode, InodePtr dirInode);␊
49static long ReadDirEntry(InodePtr dirInode, long *fileInodeNum,␊
50 long long *dirIndex, char **name);␊
51static long FindFileInDir(char *fileName, long *flags,␊
52 InodePtr fileInode, InodePtr dirInode);␊
53static char *ReadFileBlock(InodePtr fileInode, long fragNum, long blockOffset,␊
54 long length, char *buffer, long cache);␊
55static long ReadFile(InodePtr fileInode, uint64_t *length, void *base, uint64_t offset);␊
56␊
57#define kDevBlockSize (0x200) // Size of each disk block.␊
58#define kDiskLabelBlock (15) // Block the DL is in.␊
59␊
60#ifdef __i386__␊
61␊
62static CICell gCurrentIH;␊
63static long long gPartitionBase;␊
64static char *gULBuf;␊
65static char *gFSBuf;␊
66static struct fs *gFS;␊
67#if !BOOT1␊
68static struct ufslabel gUFSLabel; // for UUID␊
69#endif␊
70static long gBlockSize;␊
71static long gFragSize;␊
72static long gFragsPerBlock;␊
73static char *gTempBlock;␊
74static char *gTempName;␊
75static char *gTempName2;␊
76static InodePtr gRootInodePtr;␊
77static InodePtr gFileInodePtr;␊
78␊
79#else /* !__i386__ */␊
80␊
81static CICell gCurrentIH;␊
82static long long gPartitionBase;␊
83static char gDLBuf[8192];␊
84static char gFSBuf[SBSIZE];␊
85static struct fs *gFS;␊
86#if !BOOT1␊
87static struct ufslabel gUFSLabel; // for UUID␊
88#endif␊
89static long gBlockSize;␊
90static long gFragSize;␊
91static long gFragsPerBlock;␊
92static char *gTempBlock;␊
93static char gTempName[MAXNAMLEN + 1];␊
94static char gTempName2[MAXNAMLEN + 1];␊
95static Inode _gRootInode;␊
96static Inode _gFileInode;␊
97static InodePtr gRootInodePtr = &_gRootInode;␊
98static InodePtr gFileInodePtr = &_gFileInode;␊
99␊
100#endif /* !__i386__ */␊
101␊
102// Public functions␊
103␊
104void UFSFree(CICell ih)␊
105{␊
106 if(gCurrentIH == ih)␊
107 gCurrentIH = 0;␊
108 free(ih);␊
109}␊
110␊
111long UFSInitPartition( CICell ih )␊
112{␊
113#if !BOOT1␊
114 long ret;␊
115#endif␊
116␊
117 if (ih == gCurrentIH) {␊
118#ifdef __i386__␊
119 CacheInit(ih, gBlockSize);␊
120#endif␊
121 return 0;␊
122 }␊
123␊
124#if !BOOT1␊
125 verbose("UFSInitPartition: %x\n", ih);␊
126#endif␊
127␊
128 gCurrentIH = 0;␊
129␊
130#ifdef __i386__␊
131 if (!gULBuf) gULBuf = (char *) malloc(UFS_LABEL_SIZE);␊
132 if (!gFSBuf) gFSBuf = (char *) malloc(SBSIZE);␊
133 if (!gTempName) gTempName = (char *) malloc(MAXNAMLEN + 1);␊
134 if (!gTempName2) gTempName2 = (char *) malloc(MAXNAMLEN + 1);␊
135 if (!gRootInodePtr) gRootInodePtr = (InodePtr) malloc(sizeof(Inode));␊
136 if (!gFileInodePtr) gFileInodePtr = (InodePtr) malloc(sizeof(Inode));␊
137 if (!gULBuf || !gFSBuf || !gTempName || !gTempName2 ||␊
138 !gRootInodePtr || !gFileInodePtr) return -1;␊
139#endif␊
140␊
141 // Assume there is no Disk Label␊
142 gPartitionBase = 0;␊
143␊
144#if !BOOT1␊
145 // read the disk label to get the UUID␊
146 // (rumor has it that UFS headers can be either-endian on disk; hopefully␊
147 // that isn't true for this UUID field).␊
148 Seek(ih, gPartitionBase + UFS_LABEL_OFFSET);␊
149 ret = Read(ih, (long)&gUFSLabel, UFS_LABEL_SIZE);␊
150 if(ret != 0)␊
151 bzero(&gUFSLabel, UFS_LABEL_SIZE);␊
152#endif /* !BOOT1 */␊
153␊
154 // Look for the Super Block␊
155 Seek(ih, gPartitionBase + SBOFF);␊
156 Read(ih, (long)gFSBuf, SBSIZE);␊
157␊
158 gFS = (struct fs *)gFSBuf;␊
159 byte_swap_superblock(gFS);␊
160␊
161 if (gFS->fs_magic != FS_MAGIC) {␊
162 return -1;␊
163 }␊
164␊
165␉ih->modTime = gFS->fs_time;␊
166␉␊
167 // Calculate the block size and set up the block cache.␊
168 gBlockSize = gFS->fs_bsize;␊
169 gFragSize = gFS->fs_fsize;␊
170 gFragsPerBlock = gBlockSize / gFragSize;␊
171 if (gTempBlock != 0) free(gTempBlock);␊
172 gTempBlock = malloc(gBlockSize);␊
173 CacheInit(ih, gBlockSize);␊
174␊
175 gCurrentIH = ih;␊
176␊
177 // Read the Root Inode␊
178 ReadInode(ROOTINO, gRootInodePtr, 0, 0);␊
179␊
180 return 0;␊
181}␊
182␊
183#if !BOOT1␊
184␊
185long UFSGetUUID(CICell ih, char *uuidStr)␊
186{␊
187 long long uuid = gUFSLabel.ul_uuid;␊
188␊
189 if (UFSInitPartition(ih) == -1) return -1;␊
190 if (uuid == 0LL) return -1;␊
191␊
192 return CreateUUIDString((uint8_t*)(&uuid), sizeof(uuid), uuidStr);␊
193}␊
194␊
195#endif /* !BOOT1 */␊
196␊
197long UFSLoadFile( CICell ih, char * filePath )␊
198{␊
199 return UFSReadFile(ih, filePath, (void *)gFSLoadAddress, 0, 0);␊
200}␊
201␊
202long UFSReadFile( CICell ih, char * filePath, void * base, uint64_t offset, uint64_t length )␊
203{␊
204 long ret, flags;␊
205␊
206#if !BOOT1␊
207 verbose("Loading UFS file: [%s] from %x.\n", filePath, (unsigned)ih);␊
208#endif␊
209␊
210 if (UFSInitPartition(ih) == -1) return -1;␊
211␊
212 // Skip one or two leading '/'.␊
213 if (*filePath == '/') filePath++;␊
214 if (*filePath == '/') filePath++;␊
215␊
216 ret = ResolvePathToInode(filePath, &flags, gFileInodePtr, gRootInodePtr);␊
217 if ((ret == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) return -1;␊
218␊
219 ret = ReadFile(gFileInodePtr, &length, base, offset);␊
220 if (ret == -1) return -1;␊
221 ␊
222 return length;␊
223}␊
224␊
225#ifndef BOOT1␊
226␊
227long UFSGetDirEntry( CICell ih, char * dirPath, long long * dirIndex,␊
228 char ** name, long * flags, long * time,␊
229 FinderInfo * finderInfo, long * infoValid)␊
230{␊
231 long ret, fileInodeNum, dirFlags;␊
232 Inode tmpInode;␊
233␊
234 if (UFSInitPartition(ih) == -1) return -1;␊
235␊
236 if (infoValid) *infoValid = 0;␊
237␊
238 // Skip a leading '/' if present␊
239 if (*dirPath == '/') dirPath++;␊
240 if (*dirPath == '/') dirPath++;␊
241␊
242 ret = ResolvePathToInode(dirPath, &dirFlags, gFileInodePtr, gRootInodePtr);␊
243 if ((ret == -1) || ((dirFlags & kFileTypeMask) != kFileTypeDirectory))␊
244 return -1;␊
245␊
246 ret = ReadDirEntry(gFileInodePtr, &fileInodeNum, dirIndex, name);␊
247 if (ret != 0) return ret;␊
248␊
249 ReadInode(fileInodeNum, &tmpInode, flags, time);␊
250␊
251 return 0;␊
252}␊
253␊
254void␊
255UFSGetDescription(CICell ih, char *str, long strMaxLen)␊
256{␊
257 if (UFSInitPartition(ih) == -1) { return; }␊
258␊
259 struct ufslabel *ul;␊
260␊
261 // Look for the Disk Label␊
262 Seek(ih, 1ULL * UFS_LABEL_OFFSET);␊
263 Read(ih, (long)gULBuf, UFS_LABEL_SIZE);␊
264 ␊
265 ul = (struct ufslabel *)gULBuf;␊
266 ␊
267 unsigned char magic_bytes[] = UFS_LABEL_MAGIC;␊
268 int i;␊
269 unsigned char *p = (unsigned char *)&ul->ul_magic;␊
270 ␊
271 for (i=0; i<sizeof(magic_bytes); i++, p++) {␊
272 if (*p != magic_bytes[i])␊
273 return;␊
274 }␊
275 strncpy(str, (const char *)ul->ul_name, strMaxLen);␊
276}␊
277␊
278long␊
279UFSGetFileBlock(CICell ih, char *filePath, unsigned long long *firstBlock)␊
280{␊
281 long ret, flags;␊
282␊
283 if (UFSInitPartition(ih) == -1) return -1;␊
284␊
285 // Skip one or two leading '/'.␊
286 if (*filePath == '/') filePath++;␊
287 if (*filePath == '/') filePath++;␊
288␊
289 ret = ResolvePathToInode(filePath, &flags, gFileInodePtr, gRootInodePtr);␊
290 if ((ret == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) return -1;␊
291␊
292 *firstBlock = (gPartitionBase + 1ULL * gFileInodePtr->di_db[0] * gBlockSize) / 512ULL;␊
293␊
294 return 0;␊
295}␊
296␊
297␊
298#endif /* !BOOT1 */␊
299␊
300// Private functions␊
301␊
302static char * ReadBlock( long fragNum, long blockOffset, long length,␊
303 char * buffer, long cache )␊
304{␊
305 long long offset;␊
306 long blockNum;␊
307␊
308 blockNum = fragNum / gFragsPerBlock;␊
309 fragNum -= blockNum * gFragsPerBlock;␊
310 ␊
311 blockOffset += fragNum * gFragSize;␊
312 ␊
313 offset = gPartitionBase + 1ULL * blockNum * gBlockSize;␊
314␊
315 if (cache && ((blockOffset + length) <= gBlockSize)) {␊
316 CacheRead(gCurrentIH, gTempBlock, offset, gBlockSize, 1);␊
317 if (buffer != 0) bcopy(gTempBlock + blockOffset, buffer, length);␊
318 else buffer = gTempBlock + blockOffset;␊
319 } else {␊
320 offset += blockOffset;␊
321 CacheRead(gCurrentIH, buffer, offset, length, 0);␊
322 }␊
323␊
324 return buffer;␊
325}␊
326␊
327static long ReadInode( long inodeNum, InodePtr inode, long * flags, long * time )␊
328{␊
329 long fragNum = ino_to_fsba(gFS, inodeNum);␊
330 long blockOffset = ino_to_fsbo(gFS, inodeNum) * sizeof(Inode);␊
331␊
332 ReadBlock(fragNum, blockOffset, sizeof(Inode), (char *)inode, 1);␊
333 byte_swap_dinode_in(inode);␊
334␊
335 if (time != 0) *time = inode->di_mtime;␊
336␊
337 if (flags != 0) {␊
338 switch (inode->di_mode & IFMT) {␊
339 case IFREG: *flags = kFileTypeFlat; break;␊
340 case IFDIR: *flags = kFileTypeDirectory; break;␊
341 case IFLNK: *flags = kFileTypeLink; break;␊
342 default : *flags = kFileTypeUnknown; break;␊
343 }␊
344␊
345 *flags |= inode->di_mode & kPermMask;␊
346␊
347 if (inode->di_uid != 0) *flags |= kOwnerNotRoot;␊
348 }␊
349␊
350 return 0;␊
351}␊
352␊
353static long ResolvePathToInode( char * filePath, long * flags,␊
354 InodePtr fileInode, InodePtr dirInode )␊
355{␊
356 char * restPath;␊
357 long ret, cnt;␊
358␊
359 // if filePath is empty the we want this directory.␊
360 if (*filePath == '\0') {␊
361 bcopy((char *)dirInode, (char *)fileInode, sizeof(Inode));␊
362 return 0;␊
363 }␊
364␊
365 // Copy the file name to gTempName␊
366 cnt = 0;␊
367 while ((filePath[cnt] != '/') && (filePath[cnt] != '\0')) cnt++;␊
368 strlcpy(gTempName, filePath, cnt+1);␊
369␊
370 // Move restPath to the right place.␊
371 if (filePath[cnt] != '\0') cnt++;␊
372 restPath = filePath + cnt;␊
373␊
374 // gTempName is a name in the current Dir.␊
375 // restPath is the rest of the path if any.␊
376␊
377 ret = FindFileInDir(gTempName, flags, fileInode, dirInode);␊
378 if (ret == -1) return -1;␊
379␊
380 if ((*restPath != '\0') && ((*flags & kFileTypeMask) == kFileTypeDirectory))␊
381 ret = ResolvePathToInode(restPath, flags, fileInode, fileInode);␊
382␊
383 return ret;␊
384}␊
385␊
386static long ReadDirEntry( InodePtr dirInode, long * fileInodeNum,␊
387 long long * dirIndex, char ** name )␊
388{␊
389 struct direct *dir;␊
390 char *buffer;␊
391 long long index;␊
392 long dirBlockNum, dirBlockOffset;␊
393␊
394 while (1) {␊
395 index = *dirIndex;␊
396 ␊
397 dirBlockOffset = (long) (index % DIRBLKSIZ);␊
398 dirBlockNum = (long) (index / DIRBLKSIZ);␊
399␊
400 buffer = ReadFileBlock(dirInode, dirBlockNum, 0, DIRBLKSIZ, 0, 1);␊
401 if (buffer == 0) return -1;␊
402␊
403 dir = (struct direct *)(buffer + dirBlockOffset);␊
404 byte_swap_dir_block_in((char *)dir, 1);␊
405␊
406 *dirIndex += dir->d_reclen;␊
407 ␊
408 if (dir->d_ino != 0) break;␊
409 ␊
410 if (dirBlockOffset != 0) return -1;␊
411 }␊
412␊
413 *fileInodeNum = dir->d_ino;␊
414 *name = strlcpy(gTempName2, dir->d_name, dir->d_namlen+1);␊
415␊
416 return 0;␊
417}␊
418␊
419static long FindFileInDir( char * fileName, long * flags,␊
420 InodePtr fileInode, InodePtr dirInode )␊
421{␊
422 long ret, inodeNum;␊
423 long long index = 0;␊
424 char *name;␊
425␊
426 while (1) {␊
427 ret = ReadDirEntry(dirInode, &inodeNum, &index, &name);␊
428 if (ret == -1) return -1;␊
429␊
430 if (strcmp(fileName, name) == 0) break;␊
431 }␊
432␊
433 ReadInode(inodeNum, fileInode, flags, 0);␊
434␊
435 return 0;␊
436}␊
437␊
438static char * ReadFileBlock( InodePtr fileInode, long fragNum, long blockOffset,␊
439 long length, char * buffer, long cache )␊
440{␊
441 long fragCount, blockNum;␊
442 long diskFragNum, indFragNum, indBlockOff, refsPerBlock;␊
443 char *indBlock;␊
444␊
445 fragCount = (fileInode->di_size + gFragSize - 1) / gFragSize;␊
446 if (fragNum >= fragCount) return 0;␊
447␊
448 refsPerBlock = gBlockSize / sizeof(ufs_daddr_t);␊
449␊
450 blockNum = fragNum / gFragsPerBlock;␊
451 fragNum -= blockNum * gFragsPerBlock;␊
452 ␊
453 // Get Direct Block Number.␊
454 if (blockNum < NDADDR) {␊
455 diskFragNum = fileInode->di_db[blockNum];␊
456 } else {␊
457 blockNum -= NDADDR;␊
458␊
459 // Get Single Indirect Fragment Number.␊
460 if (blockNum < refsPerBlock) {␊
461 indFragNum = fileInode->di_ib[0];␊
462 } else {␊
463 blockNum -= refsPerBlock;␊
464␊
465 // Get Double Indirect Fragment Number.␊
466 if (blockNum < (refsPerBlock * refsPerBlock)) {␊
467 indFragNum = fileInode->di_ib[1];␊
468 } else {␊
469 blockNum -= refsPerBlock * refsPerBlock;␊
470␊
471 // Get Triple Indirect Fragment Number.␊
472 indFragNum = fileInode->di_ib[2];␊
473␊
474 indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1);␊
475 indBlockOff = blockNum / (refsPerBlock * refsPerBlock);␊
476 blockNum %= (refsPerBlock * refsPerBlock);␊
477 indFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[indBlockOff]);␊
478 }␊
479␊
480 indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1);␊
481 indBlockOff = blockNum / refsPerBlock;␊
482 blockNum %= refsPerBlock;␊
483 indFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[indBlockOff]);␊
484 }␊
485␊
486 indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1);␊
487 diskFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[blockNum]);␊
488 }␊
489␊
490 buffer = ReadBlock(diskFragNum+fragNum, blockOffset, length, buffer, cache);␊
491␊
492 return buffer;␊
493}␊
494␊
495static long ReadFile( InodePtr fileInode, uint64_t * length, void * base, uint64_t offset )␊
496{␊
497 long bytesLeft, curSize, curFrag;␊
498 char *buffer, *curAddr = (char *)base;␊
499␊
500 bytesLeft = fileInode->di_size;␊
501␊
502 if (offset > bytesLeft) {␊
503 printf("Offset is too large.\n");␊
504 return -1;␊
505 }␊
506␊
507 if ((*length == 0) || ((offset + *length) > bytesLeft)) {␊
508 *length = bytesLeft - offset;␊
509 }␊
510/*␊
511 if (bytesLeft > kLoadSize) {␊
512 printf("File is too large.\n");␊
513 return -1;␊
514 }␊
515*/␊
516 bytesLeft = *length;␊
517 curFrag = (offset / gBlockSize) * gFragsPerBlock;␊
518 offset %= gBlockSize;␊
519␊
520 while (bytesLeft) {␊
521 curSize = gBlockSize;␊
522 if (curSize > bytesLeft) curSize = bytesLeft;␊
523 if ((offset + curSize) > gBlockSize) curSize = (gBlockSize - offset);␊
524␊
525 buffer = ReadFileBlock(fileInode, curFrag, offset, curSize, curAddr, 0);␊
526 if (buffer == 0) break;␊
527␊
528 if (offset != 0) offset = 0;␊
529␊
530 curFrag += gFragsPerBlock;␊
531 curAddr += curSize;␊
532 bytesLeft -= curSize;␊
533 }␊
534␊
535 return bytesLeft;␊
536}␊
537

Archive Download this file

Revision: 515