]> git.saurik.com Git - apple/hfs.git/blob - core/FileIDsServices.c
projects / apple / hfs.git / blob
? search:


aba89400d4f5e99b5c74d9be0bc9b59ace7af14c
[apple/hfs.git] / core / FileIDsServices.c
1 /*
2 * Copyright (c) 2000-2015 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
29 #include "hfs_macos_defs.h"
30 #include "hfs_format.h"
31
32 #include "FileMgrInternal.h"
33 #include "HFSUnicodeWrappers.h"
34 #include "CatalogPrivate.h"
35 #include <sys/kernel.h>
36 #include <sys/malloc.h>
37 #include <libkern/libkern.h>
38
39 #include "hfs_dbg.h"
40
41 struct ExtentsRecBuffer {
42 ExtentKey extentKey;
43 ExtentRecord extentData;
44 };
45 typedef struct ExtentsRecBuffer ExtentsRecBuffer;
46
47
48 static u_int32_t CheckExtents( void *extents, u_int32_t blocks, Boolean isHFSPlus );
49 static OSErr DeleteExtents( ExtendedVCB *vcb, u_int32_t fileNumber, int quitEarly, u_int8_t forkType, Boolean isHFSPlus );
50 static OSErr MoveExtents( ExtendedVCB *vcb, u_int32_t srcFileID, u_int32_t destFileID, int quitEarly, u_int8_t forkType, Boolean isHFSPlus );
51
52 #if CONFIG_HFS_STD
53 static void CopyCatalogNodeInfo( CatalogRecord *src, CatalogRecord *dest );
54 #endif
55
56 static void CopyBigCatalogNodeInfo( CatalogRecord *src, CatalogRecord *dest );
57 static void CopyExtentInfo( ExtentKey *key, ExtentRecord *data, ExtentsRecBuffer *buffer, u_int16_t bufferCount );
58
59 /*
60 * This function moves the overflow extents associated with srcID into the file associated with dstID.
61 * We should have already verified that 'srcID' has overflow extents. So now we move all of the overflow
62 * extent records.
63 */
64 OSErr MoveData( ExtendedVCB *vcb, HFSCatalogNodeID srcID, HFSCatalogNodeID destID, int rsrc) {
65
66 OSErr err;
67
68 /*
69 * Only the source file should have extents, so we just track those.
70 * We operate on the fork represented by the open FD that was used to call into this
71 * function
72 */
73 if (rsrc) {
74 /* Copy the extent overflow blocks. */
75 err = MoveExtents( vcb, srcID, destID, 1, (u_int8_t)0xff, 1);
76 if ( err != noErr ) {
77 if ( err != dskFulErr ) {
78 return( err );
79 }
80 /*
81 * In case of error, we would have probably run into problems
82 * growing the extents b-tree. Since the move is actually a copy + delete
83 * just delete the new entries. Same for below.
84 */
85 err = DeleteExtents( vcb, destID, 1, (u_int8_t)0xff, 1);
86 ReturnIfError( err ); // we are doomed. Just QUIT!
87 goto FlushAndReturn;
88 }
89 }
90 else {
91 /* Copy the extent overflow blocks. */
92 err = MoveExtents( vcb, srcID, destID, 1, 0, 1);
93 if ( err != noErr ) {
94 if ( err != dskFulErr ) {
95 return( err );
96 }
97 err = DeleteExtents( vcb, destID, 1, 0, 1);
98 ReturnIfError( err ); // we are doomed. Just QUIT!
99 goto FlushAndReturn;
100 }
101 }
102
103 FlushAndReturn:
104 /* Write out the catalog and extent overflow B-Tree changes */
105 err = FlushCatalog( vcb );
106 err = FlushExtentFile( vcb );
107
108 return( err );
109 }
110
111
112 OSErr ExchangeFileIDs( ExtendedVCB *vcb, ConstUTF8Param srcName, ConstUTF8Param destName, HFSCatalogNodeID srcID, HFSCatalogNodeID destID, u_int32_t srcHint, u_int32_t destHint )
113 {
114 CatalogKey srcKey; // 518 bytes
115 CatalogKey destKey; // 518 bytes
116 CatalogRecord srcData; // 520 bytes
117 CatalogRecord destData; // 520 bytes
118 CatalogRecord swapData; // 520 bytes
119 int16_t numSrcExtentBlocks;
120 int16_t numDestExtentBlocks;
121 OSErr err;
122 Boolean isHFSPlus = ( vcb->vcbSigWord == kHFSPlusSigWord );
123
124 err = BuildCatalogKeyUTF8(vcb, srcID, srcName, kUndefinedStrLen, &srcKey);
125 ReturnIfError(err);
126
127 err = BuildCatalogKeyUTF8(vcb, destID, destName, kUndefinedStrLen, &destKey);
128 ReturnIfError(err);
129
130 if ( isHFSPlus )
131 {
132 //-- Step 1: Check the catalog nodes for extents
133
134 //-- locate the source file, test for extents in extent file, and copy the cat record for later
135 err = LocateCatalogNodeByKey( vcb, srcHint, &srcKey, &srcData, &srcHint );
136 ReturnIfError( err );
137
138 if ( srcData.recordType != kHFSPlusFileRecord )
139 return( cmFThdDirErr ); // Error "cmFThdDirErr = it is a directory"
140
141 //-- Check if there are any extents in the source file
142 //\80\80 I am only checling the extents in the low 32 bits, routine will fail if files extents after 2 gig are in overflow
143 numSrcExtentBlocks = CheckExtents( srcData.hfsPlusFile.dataFork.extents, srcData.hfsPlusFile.dataFork.totalBlocks, isHFSPlus );
144 if ( numSrcExtentBlocks == 0 ) // then check the resource fork extents
145 numSrcExtentBlocks = CheckExtents( srcData.hfsPlusFile.resourceFork.extents, srcData.hfsPlusFile.resourceFork.totalBlocks, isHFSPlus );
146
147 //-- Check if there are any extents in the destination file
148 err = LocateCatalogNodeByKey( vcb, destHint, &destKey, &destData, &destHint );
149 ReturnIfError( err );
150
151 if ( destData.recordType != kHFSPlusFileRecord )
152 return( cmFThdDirErr ); // Error "cmFThdDirErr = it is a directory"
153
154 numDestExtentBlocks = CheckExtents( destData.hfsPlusFile.dataFork.extents, destData.hfsPlusFile.dataFork.totalBlocks, isHFSPlus );
155 if ( numDestExtentBlocks == 0 ) // then check the resource fork extents
156 numDestExtentBlocks = CheckExtents( destData.hfsPlusFile.resourceFork.extents, destData.hfsPlusFile.resourceFork.totalBlocks, isHFSPlus );
157
158 //-- Step 2: Exchange the Extent key in the extent file
159
160 //-- Exchange the extents key in the extent file
161 err = DeleteExtents( vcb, kHFSBogusExtentFileID, 0, 0, isHFSPlus );
162 ReturnIfError( err );
163
164 if ( numSrcExtentBlocks && numDestExtentBlocks ) // if both files have extents
165 {
166 //-- Change the source extents file ids to our known bogus value
167 err = MoveExtents( vcb, srcData.hfsPlusFile.fileID, kHFSBogusExtentFileID, 0,0, isHFSPlus );
168 if ( err != noErr )
169 {
170 if ( err != dskFulErr ) {
171 return( err );
172 }
173 else {
174 err = DeleteExtents( vcb, kHFSBogusExtentFileID, 0, 0, isHFSPlus );
175 ReturnIfError( err ); // we are doomed. Just QUIT!
176
177 err = FlushCatalog( vcb ); // flush the catalog
178 err = FlushExtentFile( vcb ); // flush the extent file (unneeded for common case, but it's cheap)
179 return( dskFulErr );
180 }
181 }
182
183 //-- Change the destination extents file id's to the source id's
184 err = MoveExtents( vcb, destData.hfsPlusFile.fileID, srcData.hfsPlusFile.fileID, 0, 0, isHFSPlus );
185 if ( err != noErr )
186 {
187 if ( err != dskFulErr )
188 return( err );
189
190 ExUndo2aPlus: err = DeleteExtents( vcb, srcData.hfsPlusFile.fileID, 0, 0, isHFSPlus );
191 ReturnIfError( err ); // we are doomed. Just QUIT!
192
193 err = MoveExtents( vcb, kHFSBogusExtentFileID, srcData.hfsPlusFile.fileID, 0, 0, isHFSPlus ); // Move the extents back
194 ReturnIfError( err ); // we are doomed. Just QUIT!
195
196 err = DeleteExtents( vcb, kHFSBogusExtentFileID, 0, 0, isHFSPlus );
197 ReturnIfError( err ); // we are doomed. Just QUIT!
198
199 err = FlushCatalog( vcb ); // flush the catalog
200 err = FlushExtentFile( vcb ); // flush the extent file (unneeded for common case, but it's cheap)
201 return( dskFulErr );
202
203 }
204
205 //-- Change the bogus extents file id's to the dest id's
206 err = MoveExtents( vcb, kHFSBogusExtentFileID, destData.hfsPlusFile.fileID, 0, 0, isHFSPlus );
207 if ( err != noErr )
208 {
209 if ( err != dskFulErr )
210 return( err );
211
212 err = DeleteExtents( vcb, destData.hfsPlusFile.fileID, 0, 0, isHFSPlus );
213 ReturnIfError( err ); // we are doomed. Just QUIT!
214
215 err = MoveExtents( vcb, srcData.hfsPlusFile.fileID, destData.hfsPlusFile.fileID, 0, 0, isHFSPlus ); // Move the extents back
216 ReturnIfError( err ); // we are doomed. Just QUIT!
217
218 goto ExUndo2aPlus;
219 }
220
221 }
222 else if ( numSrcExtentBlocks ) // just the source file has extents
223 {
224 err = MoveExtents( vcb, srcData.hfsPlusFile.fileID, destData.hfsPlusFile.fileID, 0, 0, isHFSPlus );
225 if ( err != noErr )
226 {
227 if ( err != dskFulErr )
228 return( err );
229
230 err = DeleteExtents( vcb, srcData.hfsPlusFile.fileID, 0, 0, isHFSPlus );
231 ReturnIfError( err ); // we are doomed. Just QUIT!
232
233 goto FlushAndReturn;
234 }
235 }
236 else if ( numDestExtentBlocks ) // just the destination file has extents
237 {
238 err = MoveExtents( vcb, destData.hfsPlusFile.fileID, srcData.hfsPlusFile.fileID, 0, 0, isHFSPlus );
239 if ( err != noErr )
240 {
241 if ( err != dskFulErr )
242 return( err );
243
244 err = DeleteExtents( vcb, destData.hfsPlusFile.fileID, 0, 0, isHFSPlus );
245 ReturnIfError( err ); // we are doomed. Just QUIT!
246
247 goto FlushAndReturn;
248 }
249 }
250
251 //-- Step 3: Change the data in the catalog nodes
252
253 //-- find the source cnode and put dest info in it
254 err = LocateCatalogNodeByKey( vcb, srcHint, &srcKey, &srcData, &srcHint );
255 if ( err != noErr )
256 return( cmBadNews );
257
258 BlockMoveData( &srcData, &swapData, sizeof(CatalogRecord) );
259 CopyBigCatalogNodeInfo( &destData, &srcData );
260
261 err = ReplaceBTreeRecord( vcb->catalogRefNum, &srcKey, srcHint, &srcData, sizeof(HFSPlusCatalogFile), &srcHint );
262 ReturnIfError( err );
263
264 // find the destination cnode and put source info in it
265 err = LocateCatalogNodeByKey( vcb, destHint, &destKey, &destData, &destHint );
266 if ( err != noErr )
267 return( cmBadNews );
268
269 CopyBigCatalogNodeInfo( &swapData, &destData );
270 err = ReplaceBTreeRecord( vcb->catalogRefNum, &destKey, destHint, &destData, sizeof(HFSPlusCatalogFile), &destHint );
271 ReturnIfError( err );
272 }
273 #if CONFIG_HFS_STD
274 else // HFS //
275 {
276 //-- Step 1: Check the catalog nodes for extents
277
278 //-- locate the source file, test for extents in extent file, and copy the cat record for later
279 err = LocateCatalogNodeByKey( vcb, srcHint, &srcKey, &srcData, &srcHint );
280 ReturnIfError( err );
281
282 if ( srcData.recordType != kHFSFileRecord )
283 return( cmFThdDirErr ); // Error "cmFThdDirErr = it is a directory"
284
285 //-- Check if there are any extents in the source file
286 numSrcExtentBlocks = CheckExtents( srcData.hfsFile.dataExtents, srcData.hfsFile.dataPhysicalSize / vcb->blockSize, isHFSPlus );
287 if ( numSrcExtentBlocks == 0 ) // then check the resource fork extents
288 numSrcExtentBlocks = CheckExtents( srcData.hfsFile.rsrcExtents, srcData.hfsFile.rsrcPhysicalSize / vcb->blockSize, isHFSPlus );
289
290
291 //\80\80 Do we save the found source node for later use?
292
293
294 //-- Check if there are any extents in the destination file
295 err = LocateCatalogNodeByKey( vcb, destHint, &destKey, &destData, &destHint );
296 ReturnIfError( err );
297
298 if ( destData.recordType != kHFSFileRecord )
299 return( cmFThdDirErr ); // Error "cmFThdDirErr = it is a directory"
300
301 numDestExtentBlocks = CheckExtents( destData.hfsFile.dataExtents, destData.hfsFile.dataPhysicalSize / vcb->blockSize, isHFSPlus );
302 if ( numDestExtentBlocks == 0 ) // then check the resource fork extents
303 numDestExtentBlocks = CheckExtents( destData.hfsFile.rsrcExtents, destData.hfsFile.rsrcPhysicalSize / vcb->blockSize, isHFSPlus );
304
305 //\80\80 Do we save the found destination node for later use?
306
307
308 //-- Step 2: Exchange the Extent key in the extent file
309
310 //-- Exchange the extents key in the extent file
311 err = DeleteExtents( vcb, kHFSBogusExtentFileID, 0, 0, isHFSPlus );
312 ReturnIfError( err );
313
314 if ( numSrcExtentBlocks && numDestExtentBlocks ) // if both files have extents
315 {
316 //-- Change the source extents file ids to our known bogus value
317 err = MoveExtents( vcb, srcData.hfsFile.fileID, kHFSBogusExtentFileID, 0, 0, isHFSPlus );
318 if ( err != noErr )
319 {
320 if ( err != dskFulErr )
321 return( err );
322
323 ExUndo1a: err = DeleteExtents( vcb, kHFSBogusExtentFileID, 0, 0, isHFSPlus );
324 ReturnIfError( err ); // we are doomed. Just QUIT!
325
326 err = FlushCatalog( vcb ); // flush the catalog
327 err = FlushExtentFile( vcb ); // flush the extent file (unneeded for common case, but it's cheap)
328 return( dskFulErr );
329 }
330
331 //-- Change the destination extents file id's to the source id's
332 err = MoveExtents( vcb, destData.hfsFile.fileID, srcData.hfsFile.fileID, 0, 0, isHFSPlus );
333 if ( err != noErr )
334 {
335 if ( err != dskFulErr )
336 return( err );
337
338 ExUndo2a: err = DeleteExtents( vcb, srcData.hfsFile.fileID, 0, 0, isHFSPlus );
339 ReturnIfError( err ); // we are doomed. Just QUIT!
340
341 err = MoveExtents( vcb, kHFSBogusExtentFileID, srcData.hfsFile.fileID, 0, 0, isHFSPlus ); // Move the extents back
342 ReturnIfError( err ); // we are doomed. Just QUIT!
343
344 goto ExUndo1a;
345 }
346
347 //-- Change the bogus extents file id's to the dest id's
348 err = MoveExtents( vcb, kHFSBogusExtentFileID, destData.hfsFile.fileID, 0, 0, isHFSPlus );
349 if ( err != noErr )
350 {
351 if ( err != dskFulErr )
352 return( err );
353
354 err = DeleteExtents( vcb, destData.hfsFile.fileID, 0, 0, isHFSPlus );
355 ReturnIfError( err ); // we are doomed. Just QUIT!
356
357 err = MoveExtents( vcb, srcData.hfsFile.fileID, destData.hfsFile.fileID, 0, 0, isHFSPlus ); // Move the extents back
358 ReturnIfError( err ); // we are doomed. Just QUIT!
359
360 goto ExUndo2a;
361 }
362
363 }
364 else if ( numSrcExtentBlocks ) // just the source file has extents
365 {
366 err = MoveExtents( vcb, srcData.hfsFile.fileID, destData.hfsFile.fileID, 0, 0, isHFSPlus );
367 if ( err != noErr )
368 {
369 if ( err != dskFulErr )
370 return( err );
371
372 err = DeleteExtents( vcb, srcData.hfsFile.fileID, 0, 0, isHFSPlus );
373 ReturnIfError( err ); // we are doomed. Just QUIT!
374
375 goto FlushAndReturn;
376 }
377 }
378 else if ( numDestExtentBlocks ) // just the destination file has extents
379 {
380 err = MoveExtents( vcb, destData.hfsFile.fileID, srcData.hfsFile.fileID, 0, 0, isHFSPlus );
381 if ( err != noErr )
382 {
383 if ( err != dskFulErr )
384 return( err );
385
386 err = DeleteExtents( vcb, destData.hfsFile.fileID, 0, 0, isHFSPlus );
387 ReturnIfError( err ); // we are doomed. Just QUIT!
388
389 goto FlushAndReturn;
390 }
391 }
392
393 //-- Step 3: Change the data in the catalog nodes
394
395 //-- find the source cnode and put dest info in it
396 err = LocateCatalogNodeByKey( vcb, srcHint, &srcKey, &srcData, &srcHint );
397 if ( err != noErr )
398 return( cmBadNews );
399
400 BlockMoveData( &srcData, &swapData, sizeof(CatalogRecord) );
401 //\80\80 Asm source copies from the saved dest catalog node
402 CopyCatalogNodeInfo( &destData, &srcData );
403
404 err = ReplaceBTreeRecord( vcb->catalogRefNum, &srcKey, srcHint, &srcData, sizeof(HFSCatalogFile), &srcHint );
405 ReturnIfError( err );
406
407
408 // find the destination cnode and put source info in it
409 err = LocateCatalogNodeByKey( vcb, destHint, &destKey, &destData, &destHint );
410 if ( err != noErr )
411 return( cmBadNews );
412
413 CopyCatalogNodeInfo( &swapData, &destData );
414 err = ReplaceBTreeRecord( vcb->catalogRefNum, &destKey, destHint, &destData, sizeof(HFSCatalogFile), &destHint );
415 ReturnIfError( err );
416 }
417 #endif
418
419 err = noErr;
420
421 //-- Step 4: Error Handling section
422
423
424 FlushAndReturn:
425 err = FlushCatalog( vcb ); // flush the catalog
426 err = FlushExtentFile( vcb ); // flush the extent file (unneeded for common case, but it's cheap)
427 return( err );
428 }
429
430
431 #if CONFIG_HFS_STD
432 static void CopyCatalogNodeInfo( CatalogRecord *src, CatalogRecord *dest )
433 {
434 dest->hfsFile.dataLogicalSize = src->hfsFile.dataLogicalSize;
435 dest->hfsFile.dataPhysicalSize = src->hfsFile.dataPhysicalSize;
436 dest->hfsFile.rsrcLogicalSize = src->hfsFile.rsrcLogicalSize;
437 dest->hfsFile.rsrcPhysicalSize = src->hfsFile.rsrcPhysicalSize;
438 dest->hfsFile.modifyDate = src->hfsFile.modifyDate;
439 BlockMoveData( src->hfsFile.dataExtents, dest->hfsFile.dataExtents, sizeof(HFSExtentRecord) );
440 BlockMoveData( src->hfsFile.rsrcExtents, dest->hfsFile.rsrcExtents, sizeof(HFSExtentRecord) );
441 }
442 #endif
443
444 static void CopyBigCatalogNodeInfo( CatalogRecord *src, CatalogRecord *dest )
445 {
446 BlockMoveData( &src->hfsPlusFile.dataFork, &dest->hfsPlusFile.dataFork, sizeof(HFSPlusForkData) );
447 BlockMoveData( &src->hfsPlusFile.resourceFork, &dest->hfsPlusFile.resourceFork, sizeof(HFSPlusForkData) );
448 dest->hfsPlusFile.contentModDate = src->hfsPlusFile.contentModDate;
449 }
450
451
452 static OSErr MoveExtents( ExtendedVCB *vcb, u_int32_t srcFileID, u_int32_t destFileID, int quitEarly, u_int8_t forkType, Boolean isHFSPlus )
453 {
454 FCB * fcb;
455 ExtentsRecBuffer extentsBuffer[kNumExtentsToCache];
456 ExtentKey * extentKeyPtr;
457 ExtentRecord extentData;
458 struct BTreeIterator *btIterator = NULL;
459 struct BTreeIterator *tmpIterator = NULL;
460 FSBufferDescriptor btRecord;
461 u_int16_t btKeySize;
462 u_int16_t btRecordSize;
463 int16_t i, j;
464 OSErr err;
465
466 btIterator = hfs_mallocz(sizeof(struct BTreeIterator));
467 tmpIterator = hfs_mallocz(sizeof(struct BTreeIterator));
468
469 fcb = GetFileControlBlock(vcb->extentsRefNum);
470
471 (void) BTInvalidateHint(btIterator);
472 extentKeyPtr = (ExtentKey*) &btIterator->key;
473 btRecord.bufferAddress = &extentData;
474 btRecord.itemCount = 1;
475
476 //-- Collect the extent records
477
478 //
479 // A search on the following key will cause the BTree to be positioned immediately
480 // before the first extent record for file #srcFileID, but not actually positioned
481 // on any record. This is because there cannot be an extent record with FABN = 0
482 // (the first extent of the fork, which would be in the catalog entry, not an extent
483 // record).
484 //
485 // Using BTIterateRecord with kBTreeNextRecord will then get that first extent record.
486 //
487 if (isHFSPlus) {
488 btRecord.itemSize = sizeof(HFSPlusExtentRecord);
489 btKeySize = sizeof(HFSPlusExtentKey);
490
491 extentKeyPtr->hfsPlus.keyLength = kHFSPlusExtentKeyMaximumLength;
492 extentKeyPtr->hfsPlus.forkType = forkType;
493 extentKeyPtr->hfsPlus.pad = 0;
494 extentKeyPtr->hfsPlus.fileID = srcFileID;
495 extentKeyPtr->hfsPlus.startBlock = 0;
496 }
497 #if CONFIG_HFS_STD
498 else {
499 btRecord.itemSize = sizeof(HFSExtentRecord);
500 btKeySize = sizeof(HFSExtentKey);
501
502 extentKeyPtr->hfs.keyLength = kHFSExtentKeyMaximumLength;
503 extentKeyPtr->hfs.forkType = 0;
504 extentKeyPtr->hfs.fileID = srcFileID;
505 extentKeyPtr->hfs.startBlock = 0;
506 }
507 #else
508 else {
509 hfs_free(tmpIterator, sizeof(*tmpIterator));
510 hfs_free(btIterator, sizeof(*btIterator));
511 return cmBadNews;
512 }
513 #endif
514
515 //
516 // We do an initial BTSearchRecord to position the BTree's iterator just before any extent
517 // records for srcFileID. We then do a few BTIterateRecord and BTInsertRecord of those found
518 // records, but with destFileID as the file number in the key. Keep doing this sequence of
519 // BTIterateRecord and BTInsertRecord until we find an extent for another file, or there are
520 // no more extent records in the tree.
521 //
522 // Basically, we're copying records kNumExtentsToCache at a time. The copies have their file ID
523 // set to destFileID.
524 //
525 // This depends on BTInsertRecord not effecting the iterator used by BTIterateRecord. If it
526 // _did_ effect the iterator, then we would need to do a BTSearchRecord before each series
527 // of BTIterateRecord. We'd need to set up the key for BTSearchRecord to find the last record
528 // we found, so that BTIterateRecord would get the next one (the first we haven't processed).
529 //
530
531 err = BTSearchRecord(fcb, btIterator, &btRecord, &btRecordSize, btIterator);
532
533 // We expect a btNotFound here, since there shouldn't be an extent record with FABN = 0.
534 if (err != btNotFound)
535 {
536 hfs_debug("hfs: unexpected error from SearchBTreeRecord\n");
537
538 if (err == noErr) // If we found such a bogus extent record, then the tree is really messed up
539 err = cmBadNews; // so return an error that conveys the disk is hosed.
540
541 hfs_free(tmpIterator, sizeof(*tmpIterator));
542 hfs_free(btIterator, sizeof(*btIterator));
543 return err;
544 }
545
546 do
547 {
548 btRecord.bufferAddress = &extentData;
549 btRecord.itemCount = 1;
550
551 for ( i=0 ; i<kNumExtentsToCache ; i++ )
552 {
553 HFSCatalogNodeID foundFileID = 0;
554
555 err = BTIterateRecord(fcb, kBTreeNextRecord, btIterator, &btRecord, &btRecordSize);
556 if ( err == btNotFound ) // Did we run out of extent records in the extents tree?
557 break; // if xkrFNum(A0) is cleared on this error, then this test is bogus!
558 else if ( err != noErr ) {
559 hfs_free(btIterator, sizeof(*btIterator));
560 hfs_free(tmpIterator, sizeof(*tmpIterator));
561 return( err ); // must be ioError
562 }
563 if (isHFSPlus) {
564 foundFileID = extentKeyPtr->hfsPlus.fileID;
565 }
566 #if CONFIG_HFS_STD
567 else {
568 foundFileID = extentKeyPtr->hfs.fileID;
569 }
570 #endif
571 if ( foundFileID == srcFileID ) {
572 /* Check if we need to quit early. */
573 if (quitEarly && isHFSPlus) {
574 if (extentKeyPtr->hfsPlus.forkType != forkType) {
575 break;
576 }
577 }
578 CopyExtentInfo(extentKeyPtr, &extentData, extentsBuffer, i);
579 }
580 else{
581 /* The fileID's are of a different file. We're done here. */
582 break;
583 }
584 }
585
586
587
588 //-- edit each extent key, and reinsert each extent record in the extent file
589 if (isHFSPlus)
590 btRecordSize = sizeof(HFSPlusExtentRecord);
591 #if CONFIG_HFS_STD
592 else
593 btRecordSize = sizeof(HFSExtentRecord);
594 #endif
595
596 for ( j=0 ; j<i ; j++ )
597 {
598
599 if (isHFSPlus)
600 extentsBuffer[j].extentKey.hfsPlus.fileID = destFileID; // change only the id in the key to dest ID
601 #if CONFIG_HFS_STD
602 else
603 extentsBuffer[j].extentKey.hfs.fileID = destFileID; // change only the id in the key to dest ID
604 #endif
605
606 // get iterator and buffer descriptor ready...
607 (void) BTInvalidateHint(tmpIterator);
608 BlockMoveData(&(extentsBuffer[j].extentKey), &tmpIterator->key, btKeySize);
609 btRecord.bufferAddress = &(extentsBuffer[j].extentData);
610
611 err = BTInsertRecord(fcb, tmpIterator, &btRecord, btRecordSize);
612 if ( err != noErr ) {
613 /* Parse the error and free iterators */
614 hfs_free(btIterator, sizeof(*btIterator));
615 hfs_free(tmpIterator, sizeof(*tmpIterator));
616 if ( err == btExists )
617 {
618 hfs_debug("hfs: can't insert record -- already exists\n");
619 return( cmBadNews );
620 }
621 else {
622 return( err );
623 }
624 }
625 }
626
627 //-- okay, done with this buffered batch, go get the next set of extent records
628 // If our buffer is not full, we must be done, or recieved an error
629
630 if ( i != kNumExtentsToCache ) // if the buffer is not full, we must be done
631 {
632 err = DeleteExtents( vcb, srcFileID, quitEarly, forkType, isHFSPlus ); // Now delete all the extent entries with the sourceID
633 if (err != noErr )
634 hfs_debug("hfs: error from DeleteExtents (%d)\n", err);
635 break; // we're done!
636 }
637 } while ( true );
638
639 hfs_free(tmpIterator, sizeof(*tmpIterator));
640 hfs_free(btIterator, sizeof(*btIterator));
641
642 return( err );
643 }
644
645
646 static void CopyExtentInfo( ExtentKey *key, ExtentRecord *data, ExtentsRecBuffer *buffer, u_int16_t bufferCount )
647 {
648 BlockMoveData( key, &(buffer[bufferCount].extentKey), sizeof( ExtentKey ) );
649 BlockMoveData( data, &(buffer[bufferCount].extentData), sizeof( ExtentRecord ) );
650 }
651
652
653 //-- Delete all extents in extent file that have the ID given.
654 static OSErr DeleteExtents( ExtendedVCB *vcb, u_int32_t fileID, int quitEarly, u_int8_t forkType, Boolean isHFSPlus )
655 {
656 FCB * fcb;
657 ExtentKey * extentKeyPtr;
658 ExtentRecord extentData;
659 struct BTreeIterator *btIterator = NULL;
660 struct BTreeIterator *tmpIterator = NULL;
661 FSBufferDescriptor btRecord;
662 u_int16_t btRecordSize;
663 OSErr err;
664
665 btIterator = hfs_mallocz(sizeof(struct BTreeIterator));
666 tmpIterator = hfs_mallocz(sizeof(struct BTreeIterator));
667
668 fcb = GetFileControlBlock(vcb->extentsRefNum);
669
670 (void) BTInvalidateHint(btIterator);
671 extentKeyPtr = (ExtentKey*) &btIterator->key;
672 btRecord.bufferAddress = &extentData;
673 btRecord.itemCount = 1;
674
675 // The algorithm is to position the BTree just before any extent records for fileID.
676 // Then just keep getting successive records. If the record is still for fileID,
677 // then delete it.
678
679 if (isHFSPlus) {
680 btRecord.itemSize = sizeof(HFSPlusExtentRecord);
681
682 extentKeyPtr->hfsPlus.keyLength = kHFSPlusExtentKeyMaximumLength;
683 extentKeyPtr->hfsPlus.forkType = forkType;
684 extentKeyPtr->hfsPlus.pad = 0;
685 extentKeyPtr->hfsPlus.fileID = fileID;
686 extentKeyPtr->hfsPlus.startBlock = 0;
687 }
688 #if CONFIG_HFS_STD
689 else {
690 btRecord.itemSize = sizeof(HFSExtentRecord);
691
692 extentKeyPtr->hfs.keyLength = kHFSExtentKeyMaximumLength;
693 extentKeyPtr->hfs.forkType = forkType;
694 extentKeyPtr->hfs.fileID = fileID;
695 extentKeyPtr->hfs.startBlock = 0;
696 }
697 #else
698 else {
699 err = cmBadNews;
700 goto exit;
701 }
702 #endif
703
704 err = BTSearchRecord(fcb, btIterator, &btRecord, &btRecordSize, btIterator);
705 if ( err != btNotFound )
706 {
707 if (err == noErr) { // Did we find a bogus extent record?
708 err = cmBadNews; // Yes, so indicate things are messed up.
709 }
710
711 goto exit;
712 }
713
714 do
715 {
716 HFSCatalogNodeID foundFileID = 0;
717
718 err = BTIterateRecord(fcb, kBTreeNextRecord, btIterator, &btRecord, &btRecordSize);
719 if ( err != noErr )
720 {
721 if (err == btNotFound) // If we hit the end of the BTree
722 err = noErr; // then it's OK
723
724 break; // We're done now.
725 }
726 if (isHFSPlus) {
727 foundFileID = extentKeyPtr->hfsPlus.fileID;
728 }
729 #if CONFIG_HFS_STD
730 else {
731 foundFileID = extentKeyPtr->hfs.fileID;
732 }
733 #endif
734
735 if ( foundFileID != fileID ) {
736 break; // numbers don't match, we must be done
737 }
738 if (quitEarly && isHFSPlus) {
739 /* If we're only deleting one type of fork, then quit early if it doesn't match */
740 if (extentKeyPtr->hfsPlus.forkType != forkType) {
741 break;
742 }
743 }
744
745 *tmpIterator = *btIterator;
746 err = BTDeleteRecord( fcb, tmpIterator );
747 if (err != noErr)
748 break;
749 } while ( true );
750
751 exit:
752
753 hfs_free(tmpIterator, sizeof(*tmpIterator));
754 hfs_free(btIterator, sizeof(*btIterator));
755
756 return( err );
757 }
758
759
760 // Check if there are extents represented in the extents overflow file.
761 static u_int32_t CheckExtents( void *extents, u_int32_t totalBlocks, Boolean isHFSPlus )
762 {
763 u_int32_t extentAllocationBlocks;
764 u_int16_t i;
765
766
767 if ( totalBlocks == 0 )
768 return( 0 );
769
770 extentAllocationBlocks = 0;
771
772 if ( isHFSPlus )
773 {
774 for ( i = 0 ; i < kHFSPlusExtentDensity ; i++ )
775 {
776 extentAllocationBlocks += ((HFSPlusExtentDescriptor *)extents)[i].blockCount;
777 if ( extentAllocationBlocks >= totalBlocks ) // greater than or equal (extents can add past eof if 'Close" crashes w/o truncating new clump)
778 return( 0 );
779 }
780 }
781 #if CONFIG_HFS_STD
782 else
783 {
784 for ( i = 0 ; i < kHFSExtentDensity ; i++ )
785 {
786 extentAllocationBlocks += ((HFSExtentDescriptor *)extents)[i].blockCount;
787 if ( extentAllocationBlocks >= totalBlocks ) // greater than or equal (extents can add past eof if 'Close" crashes w/o truncating new clump)
788 return( 0 );
789 }
790 }
791 #endif
792
793 return( extentAllocationBlocks );
794 }
mirror of hfs