1 /* |
|
2 * Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0"" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: CMMCScBkupStateValidateDiskSpace implementation |
|
15 * |
|
16 * |
|
17 */ |
|
18 |
|
19 #include "CMMCScBkupStateValidateDiskSpace.h" |
|
20 |
|
21 // System includes |
|
22 #include <e32std.h> |
|
23 #include <s32strm.h> |
|
24 #include <s32mem.h> |
|
25 |
|
26 // User includes |
|
27 #include "MMCScBkupLogger.h" |
|
28 #include "CMMCScBkupFileInfo.h" |
|
29 #include "CMMCScBkupArchive.h" |
|
30 #include "CMMCScBkupArchiveFooter.h" |
|
31 #include "CMMCScBkupArchiveHeader.h" |
|
32 #include "CMMCScBkupDataOwnerInfo.h" |
|
33 #include "RMMCScBkupProgressSizer.h" |
|
34 #include "MMMCScBkupProgressObserver.h" |
|
35 #include "CMMCScBkupFileListCollection.h" |
|
36 #include "CMMCScBkupDataOwnerCollection.h" |
|
37 #include "CMMCScBkupIndexPublicDataFiles.h" |
|
38 #include "CMMCScBkupDataStrategies.h" |
|
39 #include "MMCScBkupSBEUtils.h" |
|
40 |
|
41 // ========================= MEMBER FUNCTIONS ================================ |
|
42 |
|
43 // --------------------------------------------------------------------------- |
|
44 // CMMCScBkupStateValidateDiskSpace::~CMMCScBkupStateValidateDiskSpace() |
|
45 // |
|
46 // Destructor. |
|
47 // --------------------------------------------------------------------------- |
|
48 CMMCScBkupStateValidateDiskSpace::~CMMCScBkupStateValidateDiskSpace() |
|
49 { |
|
50 iDriveSizes.Close(); |
|
51 iDriveMaxFileSizes.Close(); |
|
52 } |
|
53 |
|
54 // --------------------------------------------------------------------------- |
|
55 // CMMCScBkupStateValidateDiskSpace::CMMCScBkupStateValidateDiskSpace() |
|
56 // |
|
57 // C++ constructor. |
|
58 // --------------------------------------------------------------------------- |
|
59 CMMCScBkupStateValidateDiskSpace::CMMCScBkupStateValidateDiskSpace( MMMCScBkupDriver& aDriver ) |
|
60 : CMMCScBkupState( aDriver ), iCumulatedSize(0) |
|
61 { |
|
62 __LOG1("CMMCScBkupStateValidateDiskSpace::CMMCScBkupStateValidateDiskSpace() - 0x%08x", StateId().iUid ); |
|
63 } |
|
64 |
|
65 |
|
66 // --------------------------------------------------------------------------- |
|
67 // CMMCScBkupStateValidateDiskSpace::NewL() |
|
68 // |
|
69 // |
|
70 // --------------------------------------------------------------------------- |
|
71 CMMCScBkupStateValidateDiskSpace* CMMCScBkupStateValidateDiskSpace::NewL( MMMCScBkupDriver& aDriver ) |
|
72 { |
|
73 CMMCScBkupStateValidateDiskSpace* self = new(ELeave) CMMCScBkupStateValidateDiskSpace( aDriver ); |
|
74 CleanupStack::PushL(self); |
|
75 self->ConstructL(); |
|
76 CleanupStack::Pop(); |
|
77 return self; |
|
78 } |
|
79 |
|
80 // --------------------------------------------------------------------------- |
|
81 // CMMCScBkupStateValidateDiskSpace::ConstructL() |
|
82 // |
|
83 // |
|
84 // --------------------------------------------------------------------------- |
|
85 void CMMCScBkupStateValidateDiskSpace::ConstructL( ) |
|
86 { |
|
87 for( TInt i = EDriveA; i<=EDriveZ; i++ ) |
|
88 { |
|
89 const TDriveNumber drive = static_cast< TDriveNumber >( i ); |
|
90 |
|
91 // Zero-initialize max. file sizing info arrays |
|
92 TMMCScBkupDriveAndSize newEntry( drive, 0 ); |
|
93 iDriveSizes.AppendL( newEntry ); |
|
94 TMMCScBkupDriveAndSize maxEntry( drive, 0 ); |
|
95 iDriveMaxFileSizes.AppendL( maxEntry ); |
|
96 } |
|
97 } |
|
98 |
|
99 // --------------------------------------------------------------------------- |
|
100 // CMMCScBkupStateValidateDiskSpace::StateId() |
|
101 // |
|
102 // |
|
103 // --------------------------------------------------------------------------- |
|
104 TMMCScBkupStateId CMMCScBkupStateValidateDiskSpace::StateId() const |
|
105 { |
|
106 return KMMCScBkupStateIdValidateDiskSpace; |
|
107 } |
|
108 |
|
109 |
|
110 // --------------------------------------------------------------------------- |
|
111 // CMMCScBkupStateValidateDiskSpace::NextStateId() |
|
112 // |
|
113 // |
|
114 // --------------------------------------------------------------------------- |
|
115 TMMCScBkupStateId CMMCScBkupStateValidateDiskSpace::NextStateId() const |
|
116 { |
|
117 TMMCScBkupStateId nextState = KMMCScBkupStateIdOperationComplete; |
|
118 // |
|
119 const TMMCScBkupOperationType type = Driver().DrvOperation(); |
|
120 switch(type) |
|
121 { |
|
122 case EMMCScBkupOperationTypeFullBackup: |
|
123 nextState = KMMCScBkupStateIdArchiveOpPublicDataFiles; |
|
124 break; |
|
125 case EMMCScBkupOperationTypeFullRestore: |
|
126 nextState = KMMCScBkupStateIdSetPhoneMode; |
|
127 break; |
|
128 default: |
|
129 ASSERT( EFalse ); |
|
130 break; |
|
131 } |
|
132 // |
|
133 return nextState; |
|
134 } |
|
135 |
|
136 |
|
137 // --------------------------------------------------------------------------- |
|
138 // CMMCScBkupStateValidateDiskSpace::PerformStateInitL() |
|
139 // |
|
140 // |
|
141 // --------------------------------------------------------------------------- |
|
142 void CMMCScBkupStateValidateDiskSpace::PerformStateInitL() |
|
143 { |
|
144 CompleteSelf(); |
|
145 } |
|
146 |
|
147 |
|
148 // --------------------------------------------------------------------------- |
|
149 // CMMCScBkupStateValidateDiskSpace::PerformAsynchronousStateStepL() |
|
150 // |
|
151 // |
|
152 // --------------------------------------------------------------------------- |
|
153 void CMMCScBkupStateValidateDiskSpace::PerformAsynchronousStateStepL() |
|
154 { |
|
155 const TMMCScBkupOperationType type = Driver().DrvOperation(); |
|
156 |
|
157 switch(type) |
|
158 { |
|
159 case EMMCScBkupOperationTypeFullBackup: |
|
160 { |
|
161 ValidateFreeSpaceBeforeBackupL(); |
|
162 break; |
|
163 } |
|
164 case EMMCScBkupOperationTypeFullRestore: |
|
165 { |
|
166 ValidateFreeSpaceBeforeRestoreL(); |
|
167 break; |
|
168 } |
|
169 default: |
|
170 User::Leave(KErrNotSupported); |
|
171 break; |
|
172 } |
|
173 } |
|
174 |
|
175 |
|
176 // --------------------------------------------------------------------------- |
|
177 // CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() |
|
178 // |
|
179 // |
|
180 // --------------------------------------------------------------------------- |
|
181 void CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() |
|
182 { |
|
183 CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners(); |
|
184 TInt64 uncompressedSize; |
|
185 |
|
186 __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - START"); |
|
187 |
|
188 // Calculate the total progress required for the entire backup operation |
|
189 uncompressedSize = dataOwners.TotalOperationalSizeL(); |
|
190 __LOG1("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - Total estimated uncompressed size for archive %Ld", uncompressedSize); |
|
191 const TInt ownerCount = dataOwners.Count(); |
|
192 |
|
193 for( TInt i=0; i<ownerCount; i++ ) |
|
194 { |
|
195 CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( i ); |
|
196 // Reset the size of public data to 0. We update this value |
|
197 // with the compressed size during the compression stage. This |
|
198 // is needed in order to create accurate restore information (since |
|
199 // all of the data owner sizing info is written to disk). |
|
200 // owner.ResetOperationalSize( EMMCScBkupOwnerDataTypePublicData ); |
|
201 } |
|
202 |
|
203 // Let's check do public files fit in target drive |
|
204 TInt driveNumber; |
|
205 TDriveInfo driveInfo; |
|
206 TVolumeInfo volInfo; |
|
207 TInt8 percentFree(100); |
|
208 |
|
209 // First get the drive number, where archive resides and then get drive's free space. |
|
210 TInt err = ADI().ADIRawArchiveFile().Drive( driveNumber, driveInfo ); |
|
211 if( err == KErrNone) |
|
212 { |
|
213 err = ADI().ADIFsSession().Volume( volInfo, driveNumber ); |
|
214 if( err == KErrNone) |
|
215 { |
|
216 iCumulatedSize += uncompressedSize; |
|
217 |
|
218 if(Driver().DrvLastCategory()) |
|
219 { |
|
220 __LOG3("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - Final cumulated size %Ld, free size on drive %c is %Ld", |
|
221 iCumulatedSize, driveNumber + 'A', volInfo.iFree); |
|
222 |
|
223 if( iCumulatedSize > volInfo.iFree) |
|
224 { |
|
225 percentFree = TInt( (volInfo.iFree * 100 ) / iCumulatedSize ); // accurate enough, no rounding |
|
226 } |
|
227 |
|
228 err = Driver().DrvProgressHandler().MMCScBkupHandleFreeSpace( percentFree ); |
|
229 if( err != KErrNone ) |
|
230 { |
|
231 // Error indicates backup creation no more allowed |
|
232 Driver().DrvProgressHandler().MMCScBkupStartBackuping( EFalse ); |
|
233 User::Leave( err ); |
|
234 } |
|
235 else |
|
236 { |
|
237 Driver().DrvProgressHandler().MMCScBkupStartBackuping( ETrue ); |
|
238 } |
|
239 } |
|
240 else |
|
241 { |
|
242 __LOG3("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - Cumulated size now %Ld, free size on drive %c is %Ld", |
|
243 iCumulatedSize, driveNumber + 'A', volInfo.iFree); |
|
244 } |
|
245 } |
|
246 else |
|
247 { |
|
248 __LOG1("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - Volume info error %d", err); |
|
249 } |
|
250 } |
|
251 |
|
252 __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - END"); |
|
253 } |
|
254 |
|
255 |
|
256 // --------------------------------------------------------------------------- |
|
257 // CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() |
|
258 // |
|
259 // |
|
260 // --------------------------------------------------------------------------- |
|
261 void CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() |
|
262 { |
|
263 CMMCScBkupArchiveFooter& footer = Driver().DrvArchive().Footer(); |
|
264 CMMCScBkupIndexPublicDataFiles& index = static_cast<CMMCScBkupIndexPublicDataFiles&>( footer.IndexByType( EMMCScBkupOwnerDataTypePublicData ) ); |
|
265 CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners(); |
|
266 CMMCScBkupFileListCollection& fileList = Driver().DrvFileList(); |
|
267 TInt indexValueCurrent(0); |
|
268 |
|
269 __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - START"); |
|
270 |
|
271 const TInt ownerCount = dataOwners.Count(); |
|
272 |
|
273 // We can only make a direct comparison for public data |
|
274 for( TInt i=0; i<ownerCount; i++ ) |
|
275 { |
|
276 CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( i ); |
|
277 const CDataOwnerInfo& sbeDataOwner = owner.Owner(); |
|
278 |
|
279 if ( MMCScBkupSBEUtils::HasPublicDataL( sbeDataOwner ) ) |
|
280 { |
|
281 for( TInt i = EDriveA; i<=EDriveZ; i++ ) |
|
282 { |
|
283 const TDriveNumber drive = static_cast< TDriveNumber >( i ); |
|
284 |
|
285 const TInt64 size = owner.OperationalSize( EMMCScBkupOwnerDataTypePublicData, drive ); |
|
286 TMMCScBkupDriveAndSize& entry = iDriveSizes[ drive ]; |
|
287 entry.SetSize(entry.Size() + size); |
|
288 __LOG4("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - DO: 0x%08x has %Ld bytes for drive %c (total %Ld)", |
|
289 owner.SecureId().iId, size, entry.Drive() + 'A', entry.Size()); |
|
290 } |
|
291 } |
|
292 } |
|
293 |
|
294 #if defined(__MMCSCBKUPLOGGING_ENABLED__) |
|
295 for( TInt i = EDriveA; i<=EDriveZ; i++ ) |
|
296 { |
|
297 TMMCScBkupDriveAndSize& entry = iDriveSizes[ i ]; |
|
298 __LOG2("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Initially %Ld bytes required on drive %c", |
|
299 entry.Size(), entry.Drive() + 'A'); |
|
300 } |
|
301 #endif |
|
302 |
|
303 const TInt count = index.Count(); |
|
304 |
|
305 __LOG1("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Public files to compare %d", count); |
|
306 |
|
307 // Check needed size by comparing archived public files to files in disk - decrease size if matching file found |
|
308 while( ++indexValueCurrent < count ) |
|
309 { |
|
310 // Get the entry to restore |
|
311 TMMCScBkupArchiveVector entryInfo; |
|
312 //const CMMCScBkupFileInfo& fileInfo = index.At( indexValueCurrent, entryInfo ); |
|
313 const CMMCScBkupFileInfo& fileInfo = fileList.Entry(indexValueCurrent); |
|
314 const TDriveNumber drive = fileInfo.Drive(); |
|
315 |
|
316 __LOG2("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Archived file: %S, of size %d", &fileInfo.FileName(), fileInfo.Size()); |
|
317 |
|
318 // Check file (if any) size in disk |
|
319 RFile64 restoreFile; |
|
320 TInt64 fileSize = 0; |
|
321 TInt error = restoreFile.Open(ADI().ADIFsSession(), fileInfo.FileName(), EFileShareReadersOnly | EFileRead); |
|
322 if(error == KErrNone) |
|
323 { |
|
324 error = restoreFile.Size(fileSize); |
|
325 if(error == KErrNone) |
|
326 { |
|
327 __LOG1("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Found matching file of size %d", fileInfo.Size()); |
|
328 |
|
329 // Take into account biggest file already on disk, because reserves that much space temporarily |
|
330 if(iDriveMaxFileSizes[ drive ].Size() < fileSize && KMMCScBkupUseTempFile) |
|
331 { |
|
332 TMMCScBkupDriveAndSize& bigFile = iDriveMaxFileSizes[ drive ]; |
|
333 bigFile.SetSize(fileSize); |
|
334 } |
|
335 } |
|
336 else |
|
337 { |
|
338 fileSize = 0; |
|
339 __LOG1("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Error % requesting file size", error); |
|
340 } |
|
341 |
|
342 restoreFile.Close(); |
|
343 } |
|
344 |
|
345 TMMCScBkupDriveAndSize& entry = iDriveSizes[ drive ]; |
|
346 entry.SetSize(entry.Size() - fileSize); |
|
347 |
|
348 __LOG2("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - %Ld bytes required now on drive %c", entry.Size(), entry.Drive() + 'A'); |
|
349 } |
|
350 |
|
351 __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - No estimation for private and system files"); |
|
352 |
|
353 if(Driver().DrvLastCategory()) |
|
354 { |
|
355 TVolumeInfo volInfo; |
|
356 TInt spaceCheck(KErrNone); |
|
357 |
|
358 // Let user interrupt restore if necessary in future. Currently if any of drives cannot be restored, we interrupt restore. |
|
359 for( TInt i = EDriveA; i<=EDriveZ; i++ ) |
|
360 { |
|
361 // Check whether data fits into this drive. |
|
362 const TDriveNumber drive = static_cast< TDriveNumber >( i ); |
|
363 |
|
364 TInt err = ADI().ADIFsSession().Volume( volInfo, drive ); |
|
365 if( err == KErrNone) |
|
366 { |
|
367 // Total compressed size. If this exceeds total size of drive, then restore does not succeed for sure. |
|
368 const TInt64 size = dataOwners.DiskSpaceRequiredForRestore( drive ); |
|
369 __LOG3("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - drive %c requires %Ld + %Ld for temporary file", |
|
370 iDriveSizes[ drive ].Drive() + 'A', iDriveSizes[ drive ].Size(), iDriveMaxFileSizes[ drive ].Size()); |
|
371 |
|
372 if ( (( iDriveSizes[ drive ].Size() + iDriveMaxFileSizes[ drive ].Size() ) > volInfo.iFree ) || |
|
373 ( size > volInfo.iSize ) ) |
|
374 { |
|
375 __LOG2("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Not enough space (%Ld) on drive %c", |
|
376 TInt(volInfo.iFree), iDriveSizes[ drive ].Drive() + 'A'); |
|
377 spaceCheck = KErrDiskFull; |
|
378 break; |
|
379 } |
|
380 } |
|
381 } |
|
382 |
|
383 User::LeaveIfError(spaceCheck); |
|
384 } |
|
385 else |
|
386 { |
|
387 __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Checking next category..."); |
|
388 } |
|
389 |
|
390 __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - END"); |
|
391 } |
|
392 |
|
393 |
|