1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/centralrepository/cenrepsrv/obsrvr_noc.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,955 @@
1.4 +// Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "obsrvr_noc.h"
1.20 +#include "panic.h"
1.21 +#include "shrepos.h"
1.22 +#include "srvrepos_noc.h"
1.23 +#include "log.h"
1.24 +#include "cachemgr.h"
1.25 +
1.26 +#define TRAP_UNIFIED(_unifiedLeave, _function) \
1.27 + { \
1.28 + TInt _returnValue = 0; \
1.29 + TRAP(_unifiedLeave, _returnValue = _function); \
1.30 + TInt& __rref = _unifiedLeave; \
1.31 + __rref = _unifiedLeave | _returnValue; \
1.32 + }
1.33 +
1.34 +CObservable::~CObservable()
1.35 + {
1.36 + iObservers.Close();
1.37 + // cleanup owned objects if there's any left
1.38 + iOpenRepositories.ResetAndDestroy();
1.39 + iRepositoryInfo.ResetAndDestroy();
1.40 +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
1.41 + TInt multiRofsUidCount=iMultiRofsUidList.Count();
1.42 + for (TInt i=0;i<multiRofsUidCount;i++)
1.43 + {
1.44 + iMultiRofsUidList[i].iMountFlagList.Close();
1.45 + }
1.46 + iMultiRofsUidList.Close();
1.47 +#endif
1.48 + }
1.49 +
1.50 +CObservable* CObservable::NewLC()
1.51 + {
1.52 + CObservable* self = new(ELeave) CObservable;
1.53 + CleanupStack::PushL(self);
1.54 +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
1.55 + self->ConstructL();
1.56 +#endif
1.57 + return self;
1.58 + }
1.59 +
1.60 +void CObservable::AddObserverL(TUid aUid, CServerRepository* aRepositoryPointer)
1.61 + {
1.62 + TRepositoryObserverInfo info;
1.63 +
1.64 + info.iRepositoryUid = aUid;
1.65 + info.iRepositoryPointer = aRepositoryPointer;
1.66 +
1.67 + TLinearOrder<TRepositoryObserverInfo> observerSortOrder(CObservable::ObserverSortOrder);
1.68 + TInt err = iObservers.InsertInOrder(info, observerSortOrder);
1.69 + if ((err != KErrNone)&&(err != KErrAlreadyExists))
1.70 + {
1.71 + User::Leave(err);
1.72 + }
1.73 + }
1.74 +
1.75 +void CObservable::RemoveObserver(TUid aUid, CServerRepository* aRepositoryPointer, TInt aInMemoryIndex)
1.76 + {
1.77 + TRepositoryObserverInfo info;
1.78 +
1.79 + info.iRepositoryUid = aUid;
1.80 + info.iRepositoryPointer = aRepositoryPointer;
1.81 +
1.82 + TLinearOrder<TRepositoryObserverInfo> observerSortOrder(CObservable::ObserverSortOrder);
1.83 +
1.84 + TInt i = iObservers.FindInOrder(info, observerSortOrder);
1.85 + if (i!=KErrNotFound)
1.86 + {
1.87 + // we remove the observer we find listening on the repository
1.88 + iObservers.Remove(i);
1.89 + if (iObservers.SpecificFindInSignedKeyOrder(info, EArrayFindMode_Any)!=KErrNotFound)
1.90 + {
1.91 + //if there are more
1.92 + __CENTREP_TRACE1("CENTREP: Observer Removed when closing repository %x", aUid);
1.93 + }
1.94 + else
1.95 + {
1.96 + // removed the last observer with the given uid
1.97 + // if the repository is in memory, try evicting it
1.98 + if (aInMemoryIndex>=0)
1.99 + {
1.100 + // Check cache size and carry out forced eviction if necessary
1.101 + // Start Eviction if the repository fits in the cache
1.102 + if (TServerResources::iCacheManager->Enabled()&&
1.103 + TServerResources::iCacheManager->StartEviction(GetOpenRepository(aInMemoryIndex)))
1.104 + {
1.105 + // Repository added to the idle list in eviction order
1.106 + __CENTREP_TRACE2("CENTREP: Repository Became Idle when closing repository %x size %d", aUid, GetOpenRepository(aInMemoryIndex)->Size());
1.107 + }
1.108 + else
1.109 + {
1.110 + __CENTREP_TRACE1("CENTREP: Repository Delete when closing repository %x", aUid);
1.111 + // Remove and Delete Open Repository
1.112 + delete iOpenRepositories[aInMemoryIndex];
1.113 + iOpenRepositories.Remove(aInMemoryIndex);
1.114 + }
1.115 + }
1.116 + // if no clients are connected on this repository, we no longer need the transaction information
1.117 + RemoveSharedRepositoryInfo(aUid);
1.118 + }
1.119 + }
1.120 + }
1.121 +
1.122 +void CObservable::Notify(TUid aUid, TUint32 aVal) const
1.123 + {
1.124 + TInt i = FindConnectedRepository(aUid);
1.125 + if (i != KErrNotFound)
1.126 + {
1.127 + for(;(i<iObservers.Count())&&(iObservers[i].iRepositoryUid == aUid);i++)
1.128 + {
1.129 + iObservers[i].iRepositoryPointer->Notifier()->Notify(aVal);
1.130 + }
1.131 + }
1.132 + }
1.133 +
1.134 +TInt CObservable::FindConnectedRepository(TUid aUid) const
1.135 + {
1.136 + TRepositoryObserverInfo info;
1.137 + info.iRepositoryUid = aUid;
1.138 +
1.139 + return iObservers.SpecificFindInSignedKeyOrder(info, EArrayFindMode_First);
1.140 + }
1.141 +
1.142 +#ifdef CACHE_OOM_TESTABILITY
1.143 +void CObservable::Reset()
1.144 + {
1.145 + iObservers.Reset();
1.146 + iOpenRepositories.Reset();
1.147 + iRepositoryInfo.Reset();
1.148 + }
1.149 +
1.150 +void CObservable::CloseiOpenRepositories()
1.151 + {
1.152 + for(TInt i=iOpenRepositories.Count()-1; i>=0; i--)
1.153 + {
1.154 + delete iOpenRepositories[i];
1.155 + iOpenRepositories.Remove(i);
1.156 + }
1.157 + ASSERT(iOpenRepositories.Count()==0);
1.158 + iOpenRepositories.Close();
1.159 + }
1.160 +
1.161 +void CObservable::CloseiRepositoryInfo()
1.162 + {
1.163 + for(TInt i=iRepositoryInfo.Count()-1; i>=0; i--)
1.164 + {
1.165 + delete iRepositoryInfo[i];
1.166 + iRepositoryInfo.Remove(i);
1.167 + }
1.168 + ASSERT(iRepositoryInfo.Count()==0);
1.169 + iRepositoryInfo.Close();
1.170 + }
1.171 +
1.172 +#endif
1.173 +
1.174 +/**
1.175 +This function compares two UID's and indicates their sorting order. This
1.176 +implementation avoids overflow problems inherent in 'return aUid1-aUid2'
1.177 +implementations.
1.178 +*/
1.179 +TInt CObservable::CompareTUidValues(TInt aUid1, TInt aUid2)
1.180 + {
1.181 + if (aUid1 > aUid2)
1.182 + return 1;
1.183 + if (aUid1 < aUid2)
1.184 + return -1;
1.185 + return 0;
1.186 + }
1.187 +
1.188 +
1.189 +TInt CObservable::ObserverSortOrder(const TRepositoryObserverInfo &aRepository1, const TRepositoryObserverInfo &aRepository2)
1.190 + {
1.191 + TInt result;
1.192 +
1.193 + result = CompareTUidValues(aRepository1.iRepositoryUid.iUid, aRepository2.iRepositoryUid.iUid);
1.194 + if (result == 0)
1.195 + {
1.196 + if (aRepository1.iRepositoryPointer > aRepository2.iRepositoryPointer)
1.197 + return 1;
1.198 + if (aRepository1.iRepositoryPointer < aRepository2.iRepositoryPointer)
1.199 + return -1;
1.200 + }
1.201 +
1.202 + return result;
1.203 + }
1.204 +
1.205 +void CObservable::RemoveOpenRepository(CSharedRepository* aRepository)
1.206 + {
1.207 + TInt index = iOpenRepositories.Find(aRepository);
1.208 +
1.209 + if (index>=0)
1.210 + {
1.211 + // we don't fail any transactions here anymore, because transactions can now survive NOC repository
1.212 + // unloads. The shared information about transactions is kept in memory seperately as long as a
1.213 + // client is connected.
1.214 + iOpenRepositories.Remove(index);
1.215 + delete aRepository;
1.216 + }
1.217 + }
1.218 +
1.219 +TInt CObservable::FindOpenRepository(TUid aUid) const
1.220 + {
1.221 + TInt i;
1.222 + TInt count=iOpenRepositories.Count();
1.223 + for(i=count-1; i>=0; i--)
1.224 + {
1.225 + if(iOpenRepositories[i]->Uid()==aUid)
1.226 + {
1.227 + break;
1.228 + }
1.229 + }
1.230 + return i;
1.231 + }
1.232 +
1.233 +TInt CObservable::ReadIniFileL(CSharedRepository*& aRepository, TCentRepLocation aLocation)
1.234 + {
1.235 + TInt r=KErrNone;
1.236 + CIniFileIn* inifile = 0;
1.237 +
1.238 + HBufC* fileName(NULL);
1.239 + //allocates memory on the heap
1.240 + TServerResources::CreateRepositoryFileNameLC(fileName, aRepository->Uid(), aLocation, EIni);
1.241 + r = CIniFileIn::NewLC(TServerResources::iFs,inifile,*fileName);
1.242 + if(r==KErrNone)
1.243 + {
1.244 + r=ReadSettingsL(inifile, aRepository);
1.245 + if(r==KErrCorrupt)
1.246 + {
1.247 + // File is corrupt, if it's not the ROM file, delete it
1.248 + if(fileName && aLocation != ERom)
1.249 + User::LeaveIfError(TServerResources::iFs.Delete(*fileName));
1.250 + // Delete any repository settings that may have been read in
1.251 + aRepository->GetSettings().Reset();
1.252 + }
1.253 + }
1.254 +
1.255 + CleanupStack::PopAndDestroy(inifile); // inifile
1.256 + CleanupStack::PopAndDestroy(fileName); // filename
1.257 + return r;
1.258 + }
1.259 +
1.260 +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
1.261 +
1.262 +// Function to compare two TMultiRofsList's.
1.263 +TInt CObservable::CompareUid(const TMultiRofsList& aUid1, const TMultiRofsList& aUid2)
1.264 + {
1.265 + if (aUid1.iRepUid.iUid < aUid2.iRepUid.iUid)
1.266 + return -1 ;
1.267 + if (aUid1.iRepUid.iUid > aUid2.iRepUid.iUid)
1.268 + return 1 ;
1.269 + return 0 ;
1.270 + }
1.271 +
1.272 +void CObservable::ConstructL()
1.273 + {
1.274 + //now search for repositories uid that might be composed of multi rofs
1.275 +#ifndef CENTREP_CONV_TOOL
1.276 + if (TServerResources::iRomDirectory)
1.277 + {
1.278 + TFileName searchFileFormat;
1.279 + searchFileFormat.Append(*(TServerResources::iRomDirectory));
1.280 + searchFileFormat.Append(_L("????????.???[*-00]"));
1.281 + CDir* entryList=NULL;
1.282 + User::LeaveIfError(TServerResources::iFs.GetDir(searchFileFormat,KEntryAttNormal,ESortByName,entryList));
1.283 + CleanupStack::PushL(entryList);
1.284 + ProcessMultiRofsListL(*entryList);
1.285 + CleanupStack::PopAndDestroy(entryList);
1.286 + }
1.287 +#endif
1.288 + }
1.289 +
1.290 +void CObservable::ProcessMultiRofsListL(const CDir& aList)
1.291 + {
1.292 + TLex parser;
1.293 + TUint32 uidNum;
1.294 + TUint8 mountId;
1.295 + TLinearOrder<TMultiRofsList> reposSortOrder(CompareUid);
1.296 + TInt count=aList.Count();
1.297 + iMultiRofsUidList.ReserveL(count);
1.298 + for (TInt i=0;i<count;i++)
1.299 + {
1.300 + //file format as following XXXXYYYY.<cre/txt>[id-00]
1.301 + //Extract the Uid first
1.302 + parser.Assign(aList[i].iName.Left(8));
1.303 + User::LeaveIfError(parser.Val(uidNum,EHex));
1.304 +
1.305 + //Extract the Mount id now, see the file format above
1.306 + parser.Assign(aList[i].iName.Mid(13,2));
1.307 + User::LeaveIfError(parser.Val(mountId,EHex));
1.308 +
1.309 + //Now find whether this uid is already in the list
1.310 + TMultiRofsList find(TUid::Uid(uidNum));
1.311 + //passing it the extension of the file
1.312 + TRofsFlag newFlag(aList[i].iName.Mid(9,3),mountId);
1.313 +
1.314 + TInt err=iMultiRofsUidList.FindInOrder(find,reposSortOrder);
1.315 + if (err==KErrNotFound)
1.316 + {
1.317 + //new entry
1.318 + find.iMountFlagList.AppendL(newFlag);
1.319 + iMultiRofsUidList.InsertInOrderL(find,reposSortOrder);
1.320 + }
1.321 + else
1.322 + {
1.323 + //entry exist, just need to update the array inside TMultiRofsList
1.324 + err=iMultiRofsUidList[err].iMountFlagList.InsertInOrder(newFlag,TRofsFlag::CompareFlag);
1.325 + //ignore KErrAlreadyExists which might be the case if a txt and cre found on the same
1.326 + //rofs but the cre is preferred.
1.327 + if (err!=KErrNone && err!=KErrAlreadyExists)
1.328 + {
1.329 + User::Leave(err);
1.330 + }
1.331 + }
1.332 + }
1.333 + }
1.334 +
1.335 +
1.336 +void CObservable::OverrideSettingL(TServerSetting& aBaseSetting,const TServerSetting& aOvSetting,CSharedRepository* aCoreRepository,TBool aNewOv,TBool aNewOvIndivPolicy)
1.337 + {
1.338 + TUint32 ovId=aOvSetting.Key();
1.339 +
1.340 + //---------------------CHECK AND SET THE META----------------------------
1.341 + TBool indivOvMeta=aOvSetting.IsIndividualMeta()!=0;
1.342 + //if individually specified meta override this
1.343 + if (indivOvMeta)
1.344 + {
1.345 + aBaseSetting.SetMeta(aOvSetting.Meta());
1.346 + }
1.347 + //if not specified only when it is new we set it from the default meta
1.348 + else
1.349 + {
1.350 + if (aNewOv)
1.351 + aCoreRepository->SetMetaDataOnRead(aBaseSetting,EFalse);
1.352 + }
1.353 +
1.354 + //----------------------CHECK AND SET THE PLATSEC----------------------------
1.355 + TLinearOrder<TSettingsAccessPolicy> order(&CHeapRepository::CompareKeyIds);
1.356 + TSettingsAccessPolicy* ovTs=aOvSetting.AccessPolicy();
1.357 + TSettingsAccessPolicy* coreTs=aCoreRepository->GetFallbackAccessPolicy(ovId,ETrue);
1.358 + //new setting defined
1.359 + if (aNewOv)
1.360 + {
1.361 + //specify own settings
1.362 + if (aNewOvIndivPolicy)
1.363 + {
1.364 + TSettingsAccessPolicy* newPol=new (ELeave)TSettingsAccessPolicy(*(const_cast<TSecurityPolicy*>
1.365 + (aOvSetting.GetReadAccessPolicy())),*(const_cast<TSecurityPolicy*>(aOvSetting.GetWriteAccessPolicy())),ovId,ovTs->HighKey(),ovTs->KeyMask());
1.366 + CleanupStack::PushL(newPol);
1.367 + //for single setting policy, the highkey is used to indicate whether the setting define its own read policy or it is just a fallback
1.368 + if (ovTs->HighKey()==0)
1.369 + {
1.370 + newPol->iReadAccessPolicy=*(coreTs->GetReadAccessPolicy());
1.371 + }
1.372 + //for single setting policy, the keymask is used to indicate whether the setting define its own write policy or it is just a fallback
1.373 + if (ovTs->KeyMask()==0)
1.374 + {
1.375 + newPol->iWriteAccessPolicy=*(coreTs->GetWriteAccessPolicy());
1.376 + }
1.377 + //insert the new one and set the setting policy to point to this
1.378 + aCoreRepository->iSimRep->SinglePolicyArray().InsertInOrderL(newPol,order);
1.379 + aBaseSetting.SetAccessPolicy(newPol);
1.380 + CleanupStack::Pop(newPol);
1.381 + }
1.382 + //no individual setting policy specified so revert to the default policy in the base
1.383 + else
1.384 + {
1.385 + aBaseSetting.SetAccessPolicy(coreTs);
1.386 + }
1.387 + }
1.388 + //old setting
1.389 + else
1.390 + {
1.391 + //if no individual policy specified do nothing as this keeps what we have in the base setting
1.392 + if (aNewOvIndivPolicy)
1.393 + {
1.394 + TInt baseIndividualPol=aCoreRepository->iSimRep->SinglePolicyArray().Find(aBaseSetting.AccessPolicy());
1.395 + if (baseIndividualPol==KErrNotFound)
1.396 + {
1.397 + //no base individual but overriding specify one so create one and insert into list
1.398 + //point the old base setting to this newly defined invididual setting
1.399 + TSettingsAccessPolicy* newPol=new (ELeave)TSettingsAccessPolicy(*(const_cast<TSecurityPolicy*>
1.400 + (aOvSetting.GetReadAccessPolicy())),*(const_cast<TSecurityPolicy*>(aOvSetting.GetWriteAccessPolicy())),ovId,ovTs->HighKey(),ovTs->KeyMask());
1.401 + CleanupStack::PushL(newPol);
1.402 + //for single setting policy, the highkey is used to indicate whether the setting define its own read policy or it is just a fallback
1.403 + if (ovTs->HighKey()==0)
1.404 + {
1.405 + newPol->iReadAccessPolicy=*(coreTs->GetReadAccessPolicy());
1.406 + }
1.407 + //for single setting policy, the keymask is used to indicate whether the setting define its own write policy or it is just a fallback
1.408 + if (ovTs->KeyMask()==0)
1.409 + {
1.410 + newPol->iWriteAccessPolicy=*(coreTs->GetWriteAccessPolicy());
1.411 + }
1.412 + //insert the new one and set the setting policy to point to this
1.413 + aCoreRepository->iSimRep->SinglePolicyArray().InsertInOrderL(newPol,order);
1.414 + aBaseSetting.SetAccessPolicy(newPol);
1.415 + CleanupStack::Pop(newPol);
1.416 + }
1.417 + else
1.418 + {
1.419 + TSettingsAccessPolicy* oldPol=aBaseSetting.AccessPolicy();
1.420 + //existing individual already exist, just update them
1.421 + //for single setting policy, the highkey is used to indicate whether the setting define its own read policy or it is just a fallback
1.422 + if (ovTs->HighKey()!=0)
1.423 + {
1.424 + oldPol->iReadAccessPolicy=*(aOvSetting.GetReadAccessPolicy());
1.425 + }
1.426 + //for single setting policy, the keymask is used to indicate whether the setting define its own write policy or it is just a fallback
1.427 + if (ovTs->KeyMask()!=0)
1.428 + {
1.429 + oldPol->iWriteAccessPolicy=*(aOvSetting.GetWriteAccessPolicy());
1.430 + }
1.431 + }
1.432 + }
1.433 + }
1.434 +
1.435 + //---------------------SET THE VALUE---------------------------------------
1.436 + //override the value only if it is a new setting or an old setting with value modified
1.437 + if (aNewOv || (!aNewOv && aBaseSetting!=aOvSetting))
1.438 + User::LeaveIfError(aBaseSetting.CopyTypeValue(aOvSetting));
1.439 +
1.440 + //need to set it clean as this is still ROM settings
1.441 + aBaseSetting.SetClean();
1.442 + }
1.443 +
1.444 +//Function containing the rule of merging repositories to a core repository
1.445 +//such as -ignoring of the global properties(non-overriden)
1.446 +// -type cannot be overriden
1.447 +void CObservable::MergeRepositoryL(CSharedRepository* aCoreRepository,CHeapRepository* aOverrideRepository)
1.448 + {
1.449 + /**
1.450 + We may want to verify that the following global properties match
1.451 + -OwnerUid
1.452 + -Uid
1.453 + We may want to give warning if they try to have global propertie section in the overriding layers
1.454 + although this obviously now can be ignored now, just need to make sure that repository follows the format
1.455 + and not corrupted
1.456 + */
1.457 + TSettingsAccessPolicy defaultTs=aOverrideRepository->GetDefaultAccessPolicy();
1.458 + //here we panic immediately if there is any defined in the range meta/policy(we can check individually if
1.459 + //they do override later on,we will assume any definiton of global policy is invalid here
1.460 + if ( aOverrideRepository->Owner() != aCoreRepository->iSimRep->Owner()
1.461 + || (aOverrideRepository->DefaultMeta()!=0 && aOverrideRepository->DefaultMeta()!= aCoreRepository->iSimRep->DefaultMeta())
1.462 + || (defaultTs.HighKey()!=0 && aOverrideRepository->GetDefaultReadAccessPolicy().Package() != aCoreRepository->iSimRep->GetDefaultReadAccessPolicy().Package())
1.463 + || (defaultTs.KeyMask()!=0 && aOverrideRepository->GetDefaultWriteAccessPolicy().Package()!= aCoreRepository->iSimRep->GetDefaultWriteAccessPolicy().Package())
1.464 + || (aOverrideRepository->RangeMetaArray().Count()!=0 && !(aCoreRepository->iSimRep->RangeMetaArray().IsEqual(aOverrideRepository->RangeMetaArray())))
1.465 + || (aOverrideRepository->RangePolicyArray().Count()!=0 && !(aCoreRepository->iSimRep->RangePolicyArray().IsEqual(aOverrideRepository->RangePolicyArray())
1.466 + )))
1.467 + {
1.468 + #ifdef _DEBUG
1.469 + RDebug::Printf("Illegal Global Properties Overriding");
1.470 + #endif
1.471 + User::Leave(KErrMultiRofsGlobalOverride);
1.472 + }
1.473 +
1.474 + TInt single_count=aOverrideRepository->SettingsArray().Count();
1.475 + for (TInt i=0;i<single_count;i++)
1.476 + {
1.477 + //get the overriding setting
1.478 + TServerSetting& ovTs=aOverrideRepository->SettingsArray()[i];
1.479 + TUint32 ovId=ovTs.Key();
1.480 +
1.481 + //find whether it exist in the core
1.482 + TServerSetting* coreTs=aCoreRepository->GetSettings().Find(ovId);
1.483 + //check whether in the overriding repository,the policy is individually specified policy
1.484 + TInt ovIndividualPol=aOverrideRepository->SinglePolicyArray().Find(ovTs.AccessPolicy());
1.485 + if (coreTs)
1.486 + {
1.487 + //found in core, need to check the type is the same else Panic
1.488 + if (coreTs->Type()!=ovTs.Type())
1.489 + {
1.490 + #ifdef _DEBUG
1.491 + RDebug::Printf("Illegal Setting Type Overriding");
1.492 + #endif
1.493 + User::Leave(KErrMultiRofsTypeOverride);
1.494 + }
1.495 + OverrideSettingL(*coreTs,ovTs,aCoreRepository,EFalse,ovIndividualPol!=KErrNotFound);
1.496 + }
1.497 + else
1.498 + {
1.499 + //this is a newly defined setting
1.500 + TServerSetting newTs(ovTs.Key());
1.501 + OverrideSettingL(newTs,ovTs,aCoreRepository,ETrue,ovIndividualPol!=KErrNotFound);
1.502 + //finally insert into the RSettingsArray for this new setting
1.503 + aCoreRepository->iSimRep->SettingsArray().OrderedInsertL(newTs);
1.504 + }
1.505 + }
1.506 +
1.507 + }
1.508 +
1.509 +/**Function on initialising a repository of multi ROFS files
1.510 +aCoreInitialized indicate whether there is already existing keyspace file in the core layer
1.511 +otherwise the first one in the rofs layer will be the core repository
1.512 +*/
1.513 +void CObservable::MergeMultiRofsL(TBool aCoreInitialized,CSharedRepository* aCoreRepository,const RArray<TRofsFlag>& aOverridingFileList)
1.514 + {
1.515 + //load all the files and construct an array of CHeapRepository to merge content into it
1.516 + TInt sortedCount=aOverridingFileList.Count();
1.517 + TFileName repFileName;
1.518 + for (TInt i=0;i<sortedCount;i++)
1.519 + {
1.520 + repFileName.Zero();
1.521 + TRofsFlag rofsFlag=aOverridingFileList[i];
1.522 + TPtrC extPointer(*(TServerResources::iCreExt));
1.523 + TBool isTxt=rofsFlag.iFlag & 0x80000000;
1.524 + if (isTxt)
1.525 + {
1.526 + extPointer.Set(*(TServerResources::iIniExt));
1.527 + }
1.528 + repFileName.Format(_L("z:\\private\\10202be9\\%08x%S[%02x-00]"),aCoreRepository->Uid().iUid,&extPointer,rofsFlag.iFlag & 0xFF);
1.529 + //only when the core is not initialized, the first item in the list now becomes the core
1.530 + if (!aCoreInitialized && i==0)
1.531 + {
1.532 + if (isTxt)
1.533 + {
1.534 + CIniFileIn* iniFile;
1.535 + TInt err=CIniFileIn::NewLC(TServerResources::iFs,iniFile,repFileName);
1.536 + User::LeaveIfError(err);
1.537 + err=aCoreRepository->ReloadContentL(*iniFile,ETrue);
1.538 + User::LeaveIfError(err);
1.539 + CleanupStack::PopAndDestroy(iniFile);//iniFile
1.540 + }
1.541 + else
1.542 + {
1.543 + aCoreRepository->iSimRep->CreateRepositoryFromCreFileL(TServerResources::iFs,repFileName);
1.544 + }
1.545 + }
1.546 + else
1.547 + {
1.548 + CHeapRepository* repos=CHeapRepository::NewL(aCoreRepository->Uid());
1.549 + CleanupStack::PushL(repos);
1.550 +
1.551 + if (isTxt)
1.552 + {
1.553 + CIniFileIn* iniFile;
1.554 + TInt err=CIniFileIn::NewLC(TServerResources::iFs,iniFile,repFileName);
1.555 + User::LeaveIfError(err);
1.556 + repos->ReloadContentL(*iniFile);
1.557 + CleanupStack::PopAndDestroy(iniFile);//iniFile
1.558 + }
1.559 + else
1.560 + {
1.561 + TUint8 creVersion;
1.562 + repos->CreateRepositoryFromCreFileL(TServerResources::iFs,repFileName,creVersion);
1.563 + //need to check the CRE version in the overloading layer
1.564 + if (creVersion<KPersistFormatSupportsIndMetaIndicator)
1.565 + {
1.566 + #ifdef _DEBUG
1.567 + RDebug::Printf("Use of Cre version less than 2 in the overriding layer");
1.568 + #endif
1.569 + //this macro is used for testing existing regression test with multi-rofs
1.570 + //so we allow older cre to be used in higher rofs
1.571 + #ifndef PDS_TEST_MULTIROFS
1.572 + User::Leave(KErrMultiRofsOldCreUsed);
1.573 + #endif
1.574 + }
1.575 + }
1.576 + //Now that the repository is initialized and at this stage the repository file has been
1.577 + //checked whether they are corrupt
1.578 + repos->SettingsArray().SetIsDefault(ETrue);
1.579 + MergeRepositoryL(aCoreRepository,repos);
1.580 +
1.581 + CleanupStack::PopAndDestroy(repos); //repos
1.582 + }
1.583 + }
1.584 + }
1.585 +#endif
1.586 +
1.587 +TInt CObservable::CreateRepositoryL(CSharedRepository* aRepository, TCentRepLocation aLocation)
1.588 + {
1.589 + aRepository->GetSettings().SetIsDefault(aLocation!=EPersists);
1.590 + TInt err(KErrNotFound);
1.591 +
1.592 + err = aRepository->CreateRepositoryFromCreFileL(aLocation);
1.593 + if(err==KErrNotFound)
1.594 + {
1.595 + if (aLocation!=EPersists)
1.596 + err = ReadIniFileL(aRepository,aLocation);
1.597 + }
1.598 + //for ROM might want to consider the possibility of multi rofs file
1.599 +#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
1.600 + if (aLocation==ERom && iMultiRofsUidList.Count()!=0)
1.601 + {
1.602 + //if there is error and not because of non-existant we should return error immediately
1.603 + //and if it is fine but the uid does not match one of the multirofsuidlsit this means that
1.604 + //repository is not composed of multi file.
1.605 + if (err==KErrNone || err==KErrNotFound)
1.606 + {
1.607 + TMultiRofsList find(aRepository->Uid());
1.608 + TLinearOrder<TMultiRofsList> sort_order(CompareUid);
1.609 + TInt index=iMultiRofsUidList.FindInOrder(find,sort_order);
1.610 + if (index==KErrNotFound)
1.611 + return err;
1.612 + //if the first layer has already got the exattrib=U we should leave with KErrMultiRofsIllegalRofs
1.613 + if (err==KErrNotFound && index!=KErrNotFound)
1.614 + User::Leave(KErrMultiRofsIllegalRofs);
1.615 + //the list exist in one of the mappings stored earlier, get the name and construct them
1.616 + TRAP(err,MergeMultiRofsL(err==KErrNone,aRepository,iMultiRofsUidList[index].iMountFlagList));
1.617 + if (err==KErrNoMemory)
1.618 + User::LeaveNoMemory();
1.619 + }
1.620 + }
1.621 +#endif
1.622 + return( err);
1.623 + }
1.624 +
1.625 +/**
1.626 +In order to create a repository this routine looks for a .cre or .txt file.
1.627 +Txt and cre files can co-exist in install and ROM but not in persists location.
1.628 +If a persists txt file exists, the first write to the repository will cause a
1.629 +cre file to be created and the txt file to be deleted.
1.630 +If both files exist in the same location, the .cre is picked up first.
1.631 +If the .cre file is not found,a .txt file from the same location is tried.
1.632 +Otherwise if the .cre file is corrupted,it tries a .cre file from a next location.
1.633 +
1.634 +Note:
1.635 +If a cre file exists at a particular location, even if the cre file is corrupt a txt
1.636 +file will not be searched for in the same location.
1.637 +*/
1.638 +
1.639 +TInt CObservable::CreateRepositoryL(CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode)
1.640 + {
1.641 + TInt err(KErrNotFound);
1.642 +
1.643 + switch (aIniFileOpenMode)
1.644 + {
1.645 + case CIniFileIn::EAuto:
1.646 + {
1.647 + // Look in persists dir
1.648 + err=CreateRepositoryL(aRepository, EPersists);
1.649 +
1.650 + if(err==KErrNone)
1.651 + {
1.652 + return err;
1.653 + }
1.654 +
1.655 + // No persists file - look in ROM dir
1.656 + // Do this before looking in the install dir, because if there is
1.657 + // a ROM file, an install file and no persists file then this
1.658 + // repository is being opened after a SW install but before the
1.659 + // merge. In this case the install file shouldn't be opened
1.660 + // until after the merge.
1.661 + err=CreateRepositoryL(aRepository, ERom);
1.662 +
1.663 + if(err==KErrNone)
1.664 + {
1.665 + break;
1.666 + }
1.667 + else if(err==KErrNotFound)
1.668 + {
1.669 + // Look in install directory only if there was no ROM or persists file
1.670 + err=CreateRepositoryL(aRepository, EInstall);
1.671 + if(err==KErrNone)
1.672 + {
1.673 + TTime installFileTimeStamp=TServerResources::CentrepFileTimeStampL(aRepository->Uid(), EInstall);
1.674 + aRepository->SetInstallTime(installFileTimeStamp);
1.675 + }
1.676 + }
1.677 + break;
1.678 + }
1.679 +
1.680 + case CIniFileIn::EInstallOnly:
1.681 + {
1.682 + err=CreateRepositoryL(aRepository, EInstall);
1.683 + break;
1.684 + }
1.685 +
1.686 + case CIniFileIn::ERomOnly:
1.687 + {
1.688 + err=CreateRepositoryL(aRepository, ERom);
1.689 + break;
1.690 + }
1.691 + }
1.692 +
1.693 + return err;
1.694 + }
1.695 +
1.696 +TInt CObservable::ReadSettingsL(CIniFileIn *aIniFile, CSharedRepository* aRep)
1.697 + {
1.698 + return aRep->ReloadContentL(*aIniFile, ETrue);
1.699 + }
1.700 +
1.701 +void CObservable::LoadRepositoryLC(TUid aUid, TBool aFailIfNotFound, CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode)
1.702 + {
1.703 + // Calculate the amount of memory this repository will take in the heap
1.704 + // by checking the heap size before and after the internalization
1.705 + RHeap& myHeap = User::Heap();
1.706 + TInt firstSize = myHeap.Size();
1.707 + TInt biggestBlock;
1.708 + TInt firstAvail = myHeap.Available(biggestBlock);
1.709 +
1.710 + TRAPD(err, aRepository = CSharedRepository::NewL(aUid));
1.711 +#ifdef CACHE_OOM_TESTABILITY
1.712 + if ((err!=KErrNone)&&!iTrapOOMOnOpen)
1.713 + {
1.714 + User::Leave(err);
1.715 + }
1.716 +#endif
1.717 + if ((err!=KErrNone)&&TServerResources::iCacheManager->Enabled())
1.718 + {
1.719 + // If cache enabled, try recovery by releasing the cache
1.720 + TServerResources::iCacheManager->FlushCache(EFalse);
1.721 + // retry
1.722 + aRepository = CSharedRepository::NewL(aUid);
1.723 + err = KErrNone;
1.724 + }
1.725 + User::LeaveIfError(err);
1.726 +
1.727 + // Now that we have enough memory for the object and constructed it properly
1.728 + // we try to load it. We trap all errors, either from leaving functions or error code
1.729 + // returning functions and unify them (in all cases only one of these codes will
1.730 + // contain a valid value and the other will be 0, and for our purposes we treat
1.731 + // all errors the same no matter if they're thrown or returned)
1.732 +
1.733 + TInt unifiedErrorCode;
1.734 + TRAP_UNIFIED(unifiedErrorCode, CreateRepositoryL(aRepository, aIniFileOpenMode));
1.735 +
1.736 + if (unifiedErrorCode!=KErrNone)
1.737 + {
1.738 + switch(unifiedErrorCode)
1.739 + {
1.740 + case KErrNoMemory:
1.741 + {
1.742 + if (TServerResources::iCacheManager->Enabled()) // cache enabled
1.743 + {
1.744 +#ifdef CACHE_OOM_TESTABILITY
1.745 + if (!iTrapOOMOnOpen)
1.746 + {
1.747 + delete aRepository;
1.748 + aRepository = NULL;
1.749 + User::Leave(KErrNoMemory);
1.750 + }
1.751 +#endif
1.752 + // Flush cache
1.753 + TServerResources::iCacheManager->FlushCache(ETrue);
1.754 +
1.755 + firstSize = myHeap.Size();
1.756 + firstAvail = myHeap.Available(biggestBlock);
1.757 +
1.758 + //retry
1.759 + TRAP_UNIFIED(unifiedErrorCode, CreateRepositoryL(aRepository, aIniFileOpenMode));
1.760 + }
1.761 + }
1.762 + break;
1.763 + case KErrNotFound:
1.764 + case KErrPathNotFound:
1.765 + {
1.766 + if (!aFailIfNotFound) // backup open
1.767 + {
1.768 + // override error condition and continue normally
1.769 + unifiedErrorCode = KErrNone;
1.770 + }
1.771 + }
1.772 + break;
1.773 + }
1.774 + }
1.775 + // If unhandled, leave
1.776 + if(unifiedErrorCode != KErrNone)
1.777 + {
1.778 + delete aRepository;
1.779 + aRepository = NULL;
1.780 + }
1.781 + User::LeaveIfError(unifiedErrorCode);
1.782 + CleanupStack::PushL(aRepository);
1.783 +
1.784 + // Otherwise, finalize calulations
1.785 + TInt lastSize = myHeap.Size();
1.786 + TInt lastAvail = myHeap.Available(biggestBlock);
1.787 +
1.788 + TInt calcSize = (lastSize - lastAvail) - (firstSize - firstAvail);
1.789 + // record repository size for cache algorithm purposes
1.790 + aRepository->SetSize(calcSize);
1.791 + }
1.792 +
1.793 +CSharedRepository* CObservable::AccessL(TUid aUid, TBool aFailIfNotFound)
1.794 + {
1.795 + CSharedRepository* rep = NULL;
1.796 +
1.797 + TInt i = FindOpenRepository(aUid);
1.798 + if(i!=KErrNotFound)
1.799 + {
1.800 + rep = GetOpenRepository(i);
1.801 + // repository still open, can safely call RestoreConsistencyL
1.802 + rep->RestoreConsistencyL();
1.803 + }
1.804 + else
1.805 + {
1.806 + // For memory usage testing purposes
1.807 + RECORD_HEAP_SIZE(EMemLcnRepositoryOpen, aUid.iUid);
1.808 + // Various error conditions are handled in this function
1.809 + LoadRepositoryLC(aUid, aFailIfNotFound, rep, CIniFileIn::EAuto);
1.810 + __CENTREP_TRACE1("CENTREP: Repository Load when opening repository %x", aUid.iUid);
1.811 + // For memory usage testing purposes
1.812 + RECORD_HEAP_SIZE(EMemLcnRepositoryOpen, aUid.iUid);
1.813 +
1.814 + AddOpenRepositoryL(rep);
1.815 +
1.816 + // We pop the rep here because if later call of TServerResources::AddOwnerIdLookupMapping fails of OOM
1.817 + // the call of RemoveOpenRepository() will delete the repository before leave.
1.818 + CleanupStack::Pop(rep);
1.819 +
1.820 + // Add owner mapping to list - Will fail if an entry already exists
1.821 + // with this Repository UID but this doesn't matter
1.822 + TUid owner = rep->Owner() ;
1.823 + TInt err = TServerResources::AddOwnerIdLookupMapping(aUid.iUid, owner.iUid);
1.824 + if (err == KErrNoMemory)
1.825 + {
1.826 + RemoveOpenRepository(rep);
1.827 + User::Leave(err);
1.828 + }
1.829 +
1.830 + //Find the location of the current transaction for this repository
1.831 + const TInt offset (FindRepositoryInfo(aUid));
1.832 + if (offset >=0) //If there are no outstanding transactions
1.833 + {
1.834 + RefreshTransactorAccessPolicies(rep,offset);
1.835 + }
1.836 + }
1.837 +
1.838 + // re-start the timer
1.839 + if (TServerResources::iCacheManager->Enabled())
1.840 + {
1.841 + TServerResources::iCacheManager->StartEviction(rep);
1.842 + }
1.843 +
1.844 + return rep;
1.845 + }
1.846 +
1.847 +TInt CObservable::FindRepositoryInfo(TUid aUid)
1.848 + {
1.849 + TSharedRepositoryInfo info(aUid);
1.850 + TLinearOrder<TSharedRepositoryInfo> infoSortOrder(CObservable::InfoSortOrder);
1.851 +
1.852 + return iRepositoryInfo.FindInOrder(&info, infoSortOrder);
1.853 + }
1.854 +
1.855 +CObservable::TSharedRepositoryInfo* CObservable::SharedRepositoryInfo(TUid aUid)
1.856 + {
1.857 + TInt pos = FindRepositoryInfo(aUid);
1.858 + return (pos!=KErrNotFound) ? iRepositoryInfo[pos] : NULL;
1.859 + }
1.860 +
1.861 +void CObservable::CancelTransaction(CRepositoryTransactor& aTransactor,TUid aRepositoryUid)
1.862 + {
1.863 + if (aTransactor.IsInTransaction())
1.864 + {
1.865 + ReleaseTransactionLock(aTransactor,aRepositoryUid);
1.866 + CObservable::TSharedRepositoryInfo* shrepinfo =SharedRepositoryInfo(aRepositoryUid);
1.867 + ASSERT(shrepinfo);
1.868 + shrepinfo->iTransactors.Remove(aTransactor);
1.869 + //Remove the link to the next transaction
1.870 + aTransactor.iLink.iNext = NULL;
1.871 + aTransactor.Deque();
1.872 + }
1.873 + }
1.874 +
1.875 +/** Private helper method which releases any read/write locks held in the shared repository
1.876 +by this transactor. Caller must set transactor's state or remove from queue as appropriate.
1.877 +@param aTransactor transactor whose read/write locks are to be released.
1.878 +@post Any read/write locks held by transactor are released.
1.879 +*/
1.880 +void CObservable::ReleaseTransactionLock(CRepositoryTransactor& aTransactor,TUid aRepositoryUid)
1.881 + {
1.882 + CObservable::TSharedRepositoryInfo* shrepinfo = SharedRepositoryInfo(aRepositoryUid);
1.883 + ASSERT(shrepinfo);
1.884 + if (aTransactor.IsInActiveConcurrentReadWriteTransaction())
1.885 + {
1.886 + shrepinfo->iNumActiveConcurrentReadWriteTransactions--;
1.887 + ASSERT(shrepinfo->iNumActiveConcurrentReadWriteTransactions >= 0); // sanity check
1.888 + }
1.889 + else if (aTransactor.IsInActiveReadTransaction())
1.890 + {
1.891 + shrepinfo->iPessimisticTransactionLockCount--;
1.892 + ASSERT(shrepinfo->iPessimisticTransactionLockCount >= 0); // sanity check
1.893 + }
1.894 + else if (aTransactor.IsInActiveExclusiveReadWriteTransaction())
1.895 + {
1.896 + // can only be one exclusive read/write transaction active (lock value -1)
1.897 + ASSERT(shrepinfo->iPessimisticTransactionLockCount == -1);
1.898 + shrepinfo->iPessimisticTransactionLockCount = 0;
1.899 + }
1.900 + }
1.901 +CObservable::TSharedRepositoryInfo::TSharedRepositoryInfo(TUid aUid) :
1.902 + iRepositoryUid(aUid), iTransactors(_FOFF(CRepositoryTransactor, iLink)),
1.903 + iPessimisticTransactionLockCount(0), iNumActiveConcurrentReadWriteTransactions(0)
1.904 + {
1.905 + }
1.906 +
1.907 +TInt CObservable::InfoSortOrder(const TSharedRepositoryInfo &aRepository1, const TSharedRepositoryInfo &aRepository2)
1.908 + {
1.909 + return CompareTUidValues(aRepository1.iRepositoryUid.iUid, aRepository2.iRepositoryUid.iUid);
1.910 + }
1.911 +
1.912 +void CObservable::AddSharedRepositoryInfoL(TUid aUid)
1.913 + {
1.914 + TSharedRepositoryInfo* shinfo = new(ELeave) TSharedRepositoryInfo(aUid);
1.915 +
1.916 + TLinearOrder<TSharedRepositoryInfo> infoSortOrder(CObservable::InfoSortOrder);
1.917 + // Inserts if not already in the array, otherwise returns KErrAlreadyExists, which we handle gracefully
1.918 + TInt err = iRepositoryInfo.InsertInOrder(shinfo, infoSortOrder);
1.919 + if (err==KErrAlreadyExists)
1.920 + {
1.921 + delete shinfo;
1.922 + }
1.923 + else
1.924 + {
1.925 + if (err!=KErrNone)
1.926 + delete shinfo;
1.927 + User::LeaveIfError(err);
1.928 + }
1.929 + }
1.930 +
1.931 +void CObservable::RemoveSharedRepositoryInfo(TUid aUid)
1.932 + {
1.933 + TInt pos = FindRepositoryInfo(aUid);
1.934 + if (pos!=KErrNotFound)
1.935 + {
1.936 + delete iRepositoryInfo[pos];
1.937 + iRepositoryInfo.Remove(pos);
1.938 + }
1.939 + }
1.940 +
1.941 +
1.942 +void CObservable::RefreshTransactorAccessPolicies(CSharedRepository* aRepository,const TInt offset)
1.943 + {
1.944 + TSglQueIter<CRepositoryTransactor> iter(iRepositoryInfo[offset]->iTransactors);
1.945 + CRepositoryTransactor* t (iter);
1.946 +
1.947 + while (iter++ != NULL)
1.948 + {
1.949 + const TInt count = t->iTransactionSettings.Count();
1.950 + for (TInt i=0; i<count;i++) //for the no. of changed settings in the transaction
1.951 + {
1.952 + TServerSetting temp = t->iTransactionSettings[i];
1.953 + t->iTransactionSettings[i].SetAccessPolicy(aRepository->GetFallbackAccessPolicy(temp.Key()));
1.954 + //Correct the access policy pointer so that its pointing to the new valid location
1.955 + }
1.956 + t = iter;
1.957 + }
1.958 + }