]> git.saurik.com Git - apple/xnu.git/blob - bsd/hfs/hfscommon/Catalog/FileIDsServices.c
projects / apple / xnu.git / blob
? search:


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