1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
25*b1cdbd2cSJim Jagielski #include "precompiled_sot.hxx"
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski #if defined(_MSC_VER) && (_MSC_VER<1200)
28*b1cdbd2cSJim Jagielski #include <tools/presys.h>
29*b1cdbd2cSJim Jagielski #endif
30*b1cdbd2cSJim Jagielski #include <hash_map>
31*b1cdbd2cSJim Jagielski #if defined(_MSC_VER) && (_MSC_VER<1200)
32*b1cdbd2cSJim Jagielski #include <tools/postsys.h>
33*b1cdbd2cSJim Jagielski #endif
34*b1cdbd2cSJim Jagielski #include <vos/macros.hxx>
35*b1cdbd2cSJim Jagielski
36*b1cdbd2cSJim Jagielski #include <string.h>
37*b1cdbd2cSJim Jagielski #include <osl/endian.h>
38*b1cdbd2cSJim Jagielski #include <tools/string.hxx>
39*b1cdbd2cSJim Jagielski
40*b1cdbd2cSJim Jagielski #include "sot/stg.hxx"
41*b1cdbd2cSJim Jagielski #include "stgelem.hxx"
42*b1cdbd2cSJim Jagielski #include "stgcache.hxx"
43*b1cdbd2cSJim Jagielski #include "stgstrms.hxx"
44*b1cdbd2cSJim Jagielski #include "stgdir.hxx"
45*b1cdbd2cSJim Jagielski #include "stgio.hxx"
46*b1cdbd2cSJim Jagielski
47*b1cdbd2cSJim Jagielski /*************************************************************************/
48*b1cdbd2cSJim Jagielski //-----------------------------------------------------------------------------
49*b1cdbd2cSJim Jagielski typedef std::hash_map
50*b1cdbd2cSJim Jagielski <
51*b1cdbd2cSJim Jagielski sal_Int32,
52*b1cdbd2cSJim Jagielski StgPage *,
53*b1cdbd2cSJim Jagielski std::hash< sal_Int32 >,
54*b1cdbd2cSJim Jagielski NAMESPACE_STD(equal_to)< sal_Int32 >
55*b1cdbd2cSJim Jagielski > UsrStgPagePtr_Impl;
56*b1cdbd2cSJim Jagielski #ifdef _MSC_VER
57*b1cdbd2cSJim Jagielski #pragma warning( disable: 4786 )
58*b1cdbd2cSJim Jagielski #endif
59*b1cdbd2cSJim Jagielski
60*b1cdbd2cSJim Jagielski //#define CHECK_DIRTY 1
61*b1cdbd2cSJim Jagielski //#define READ_AFTER_WRITE 1
62*b1cdbd2cSJim Jagielski
63*b1cdbd2cSJim Jagielski ////////////////////////////// class StgPage /////////////////////////////
64*b1cdbd2cSJim Jagielski // This class implements buffer functionality. The cache will always return
65*b1cdbd2cSJim Jagielski // a page buffer, even if a read fails. It is up to the caller to determine
66*b1cdbd2cSJim Jagielski // the correctness of the I/O.
67*b1cdbd2cSJim Jagielski
StgPage(StgCache * p,short n)68*b1cdbd2cSJim Jagielski StgPage::StgPage( StgCache* p, short n )
69*b1cdbd2cSJim Jagielski {
70*b1cdbd2cSJim Jagielski OSL_ENSURE( n >= 512, "Unexpected page size is provided!" );
71*b1cdbd2cSJim Jagielski pCache = p;
72*b1cdbd2cSJim Jagielski nData = n;
73*b1cdbd2cSJim Jagielski bDirty = sal_False;
74*b1cdbd2cSJim Jagielski nPage = 0;
75*b1cdbd2cSJim Jagielski pData = new sal_uInt8[ nData ];
76*b1cdbd2cSJim Jagielski pNext1 =
77*b1cdbd2cSJim Jagielski pNext2 =
78*b1cdbd2cSJim Jagielski pLast1 =
79*b1cdbd2cSJim Jagielski pLast2 = NULL;
80*b1cdbd2cSJim Jagielski pOwner = NULL;
81*b1cdbd2cSJim Jagielski }
82*b1cdbd2cSJim Jagielski
~StgPage()83*b1cdbd2cSJim Jagielski StgPage::~StgPage()
84*b1cdbd2cSJim Jagielski {
85*b1cdbd2cSJim Jagielski delete [] pData;
86*b1cdbd2cSJim Jagielski }
87*b1cdbd2cSJim Jagielski
SetPage(short nOff,sal_Int32 nVal)88*b1cdbd2cSJim Jagielski void StgPage::SetPage( short nOff, sal_Int32 nVal )
89*b1cdbd2cSJim Jagielski {
90*b1cdbd2cSJim Jagielski if( ( nOff < (short) ( nData / sizeof( sal_Int32 ) ) ) && nOff >= 0 )
91*b1cdbd2cSJim Jagielski {
92*b1cdbd2cSJim Jagielski #ifdef OSL_BIGENDIAN
93*b1cdbd2cSJim Jagielski nVal = SWAPLONG(nVal);
94*b1cdbd2cSJim Jagielski #endif
95*b1cdbd2cSJim Jagielski ((sal_Int32*) pData )[ nOff ] = nVal;
96*b1cdbd2cSJim Jagielski bDirty = sal_True;
97*b1cdbd2cSJim Jagielski }
98*b1cdbd2cSJim Jagielski }
99*b1cdbd2cSJim Jagielski
100*b1cdbd2cSJim Jagielski //////////////////////////////// class StgCache ////////////////////////////
101*b1cdbd2cSJim Jagielski
102*b1cdbd2cSJim Jagielski // The disk cache holds the cached sectors. The sector type differ according
103*b1cdbd2cSJim Jagielski // to their purpose.
104*b1cdbd2cSJim Jagielski
lcl_GetPageCount(sal_uLong nFileSize,short nPageSize)105*b1cdbd2cSJim Jagielski sal_Int32 lcl_GetPageCount( sal_uLong nFileSize, short nPageSize )
106*b1cdbd2cSJim Jagielski {
107*b1cdbd2cSJim Jagielski // return (nFileSize >= 512) ? (nFileSize - 512) / nPageSize : 0;
108*b1cdbd2cSJim Jagielski // #i61980# reallife: last page may be incomplete, return number of *started* pages
109*b1cdbd2cSJim Jagielski return (nFileSize >= 512) ? (nFileSize - 512 + nPageSize - 1) / nPageSize : 0;
110*b1cdbd2cSJim Jagielski }
111*b1cdbd2cSJim Jagielski
StgCache()112*b1cdbd2cSJim Jagielski StgCache::StgCache()
113*b1cdbd2cSJim Jagielski {
114*b1cdbd2cSJim Jagielski nRef = 0;
115*b1cdbd2cSJim Jagielski pStrm = NULL;
116*b1cdbd2cSJim Jagielski pCur = pElem1 = NULL;
117*b1cdbd2cSJim Jagielski nPageSize = 512;
118*b1cdbd2cSJim Jagielski nError = SVSTREAM_OK;
119*b1cdbd2cSJim Jagielski bMyStream = sal_False;
120*b1cdbd2cSJim Jagielski bFile = sal_False;
121*b1cdbd2cSJim Jagielski pLRUCache = NULL;
122*b1cdbd2cSJim Jagielski pStorageStream = NULL;
123*b1cdbd2cSJim Jagielski }
124*b1cdbd2cSJim Jagielski
~StgCache()125*b1cdbd2cSJim Jagielski StgCache::~StgCache()
126*b1cdbd2cSJim Jagielski {
127*b1cdbd2cSJim Jagielski Clear();
128*b1cdbd2cSJim Jagielski SetStrm( NULL, sal_False );
129*b1cdbd2cSJim Jagielski delete (UsrStgPagePtr_Impl*)pLRUCache;
130*b1cdbd2cSJim Jagielski }
131*b1cdbd2cSJim Jagielski
SetPhysPageSize(short n)132*b1cdbd2cSJim Jagielski void StgCache::SetPhysPageSize( short n )
133*b1cdbd2cSJim Jagielski {
134*b1cdbd2cSJim Jagielski OSL_ENSURE( n >= 512, "Unexpecte page size is provided!" );
135*b1cdbd2cSJim Jagielski if ( n >= 512 )
136*b1cdbd2cSJim Jagielski {
137*b1cdbd2cSJim Jagielski nPageSize = n;
138*b1cdbd2cSJim Jagielski sal_uLong nPos = pStrm->Tell();
139*b1cdbd2cSJim Jagielski sal_uLong nFileSize = pStrm->Seek( STREAM_SEEK_TO_END );
140*b1cdbd2cSJim Jagielski nPages = lcl_GetPageCount( nFileSize, nPageSize );
141*b1cdbd2cSJim Jagielski pStrm->Seek( nPos );
142*b1cdbd2cSJim Jagielski }
143*b1cdbd2cSJim Jagielski }
144*b1cdbd2cSJim Jagielski
145*b1cdbd2cSJim Jagielski // Create a new cache element
146*b1cdbd2cSJim Jagielski // pCur points to this element
147*b1cdbd2cSJim Jagielski
Create(sal_Int32 nPg)148*b1cdbd2cSJim Jagielski StgPage* StgCache::Create( sal_Int32 nPg )
149*b1cdbd2cSJim Jagielski {
150*b1cdbd2cSJim Jagielski StgPage* pElem = new StgPage( this, nPageSize );
151*b1cdbd2cSJim Jagielski pElem->nPage = nPg;
152*b1cdbd2cSJim Jagielski // For data security, clear the buffer contents
153*b1cdbd2cSJim Jagielski memset( pElem->pData, 0, pElem->nData );
154*b1cdbd2cSJim Jagielski
155*b1cdbd2cSJim Jagielski // insert to LRU
156*b1cdbd2cSJim Jagielski if( pCur )
157*b1cdbd2cSJim Jagielski {
158*b1cdbd2cSJim Jagielski pElem->pNext1 = pCur;
159*b1cdbd2cSJim Jagielski pElem->pLast1 = pCur->pLast1;
160*b1cdbd2cSJim Jagielski pElem->pNext1->pLast1 =
161*b1cdbd2cSJim Jagielski pElem->pLast1->pNext1 = pElem;
162*b1cdbd2cSJim Jagielski }
163*b1cdbd2cSJim Jagielski else
164*b1cdbd2cSJim Jagielski pElem->pNext1 = pElem->pLast1 = pElem;
165*b1cdbd2cSJim Jagielski if( !pLRUCache )
166*b1cdbd2cSJim Jagielski pLRUCache = new UsrStgPagePtr_Impl();
167*b1cdbd2cSJim Jagielski (*(UsrStgPagePtr_Impl*)pLRUCache)[pElem->nPage] = pElem;
168*b1cdbd2cSJim Jagielski pCur = pElem;
169*b1cdbd2cSJim Jagielski
170*b1cdbd2cSJim Jagielski // insert to Sorted
171*b1cdbd2cSJim Jagielski if( !pElem1 )
172*b1cdbd2cSJim Jagielski pElem1 = pElem->pNext2 = pElem->pLast2 = pElem;
173*b1cdbd2cSJim Jagielski else
174*b1cdbd2cSJim Jagielski {
175*b1cdbd2cSJim Jagielski StgPage* p = pElem1;
176*b1cdbd2cSJim Jagielski do
177*b1cdbd2cSJim Jagielski {
178*b1cdbd2cSJim Jagielski if( pElem->nPage < p->nPage )
179*b1cdbd2cSJim Jagielski break;
180*b1cdbd2cSJim Jagielski p = p->pNext2;
181*b1cdbd2cSJim Jagielski } while( p != pElem1 );
182*b1cdbd2cSJim Jagielski pElem->pNext2 = p;
183*b1cdbd2cSJim Jagielski pElem->pLast2 = p->pLast2;
184*b1cdbd2cSJim Jagielski pElem->pNext2->pLast2 =
185*b1cdbd2cSJim Jagielski pElem->pLast2->pNext2 = pElem;
186*b1cdbd2cSJim Jagielski if( p->nPage < pElem1->nPage )
187*b1cdbd2cSJim Jagielski pElem1 = pElem;
188*b1cdbd2cSJim Jagielski }
189*b1cdbd2cSJim Jagielski return pElem;
190*b1cdbd2cSJim Jagielski }
191*b1cdbd2cSJim Jagielski
192*b1cdbd2cSJim Jagielski // Delete the given element
193*b1cdbd2cSJim Jagielski
Erase(StgPage * pElem)194*b1cdbd2cSJim Jagielski void StgCache::Erase( StgPage* pElem )
195*b1cdbd2cSJim Jagielski {
196*b1cdbd2cSJim Jagielski OSL_ENSURE( pElem, "The pointer should not be NULL!" );
197*b1cdbd2cSJim Jagielski if ( pElem )
198*b1cdbd2cSJim Jagielski {
199*b1cdbd2cSJim Jagielski OSL_ENSURE( pElem->pNext1 && pElem->pLast1, "The pointers may not be NULL!" );
200*b1cdbd2cSJim Jagielski //remove from LRU
201*b1cdbd2cSJim Jagielski pElem->pNext1->pLast1 = pElem->pLast1;
202*b1cdbd2cSJim Jagielski pElem->pLast1->pNext1 = pElem->pNext1;
203*b1cdbd2cSJim Jagielski if( pCur == pElem )
204*b1cdbd2cSJim Jagielski pCur = ( pElem->pNext1 == pElem ) ? NULL : pElem->pNext1;
205*b1cdbd2cSJim Jagielski if( pLRUCache )
206*b1cdbd2cSJim Jagielski ((UsrStgPagePtr_Impl*)pLRUCache)->erase( pElem->nPage );
207*b1cdbd2cSJim Jagielski // remove from Sorted
208*b1cdbd2cSJim Jagielski pElem->pNext2->pLast2 = pElem->pLast2;
209*b1cdbd2cSJim Jagielski pElem->pLast2->pNext2 = pElem->pNext2;
210*b1cdbd2cSJim Jagielski if( pElem1 == pElem )
211*b1cdbd2cSJim Jagielski pElem1 = ( pElem->pNext2 == pElem ) ? NULL : pElem->pNext2;
212*b1cdbd2cSJim Jagielski delete pElem;
213*b1cdbd2cSJim Jagielski }
214*b1cdbd2cSJim Jagielski }
215*b1cdbd2cSJim Jagielski
216*b1cdbd2cSJim Jagielski // remove all cache elements without flushing them
217*b1cdbd2cSJim Jagielski
Clear()218*b1cdbd2cSJim Jagielski void StgCache::Clear()
219*b1cdbd2cSJim Jagielski {
220*b1cdbd2cSJim Jagielski StgPage* pElem = pCur;
221*b1cdbd2cSJim Jagielski if( pCur ) do
222*b1cdbd2cSJim Jagielski {
223*b1cdbd2cSJim Jagielski StgPage* pDelete = pElem;
224*b1cdbd2cSJim Jagielski pElem = pElem->pNext1;
225*b1cdbd2cSJim Jagielski delete pDelete;
226*b1cdbd2cSJim Jagielski }
227*b1cdbd2cSJim Jagielski while( pCur != pElem );
228*b1cdbd2cSJim Jagielski pCur = NULL;
229*b1cdbd2cSJim Jagielski pElem1 = NULL;
230*b1cdbd2cSJim Jagielski delete (UsrStgPagePtr_Impl*)pLRUCache;
231*b1cdbd2cSJim Jagielski pLRUCache = NULL;
232*b1cdbd2cSJim Jagielski }
233*b1cdbd2cSJim Jagielski
234*b1cdbd2cSJim Jagielski // Look for a cached page
235*b1cdbd2cSJim Jagielski
Find(sal_Int32 nPage)236*b1cdbd2cSJim Jagielski StgPage* StgCache::Find( sal_Int32 nPage )
237*b1cdbd2cSJim Jagielski {
238*b1cdbd2cSJim Jagielski if( !pLRUCache )
239*b1cdbd2cSJim Jagielski return NULL;
240*b1cdbd2cSJim Jagielski UsrStgPagePtr_Impl::iterator aIt = ((UsrStgPagePtr_Impl*)pLRUCache)->find( nPage );
241*b1cdbd2cSJim Jagielski if( aIt != ((UsrStgPagePtr_Impl*)pLRUCache)->end() )
242*b1cdbd2cSJim Jagielski {
243*b1cdbd2cSJim Jagielski // page found
244*b1cdbd2cSJim Jagielski StgPage* pFound = (*aIt).second;
245*b1cdbd2cSJim Jagielski OSL_ENSURE( pFound, "The pointer may not be NULL!" );
246*b1cdbd2cSJim Jagielski
247*b1cdbd2cSJim Jagielski if( pFound != pCur )
248*b1cdbd2cSJim Jagielski {
249*b1cdbd2cSJim Jagielski OSL_ENSURE( pFound->pNext1 && pFound->pLast1, "The pointers may not be NULL!" );
250*b1cdbd2cSJim Jagielski // remove from LRU
251*b1cdbd2cSJim Jagielski pFound->pNext1->pLast1 = pFound->pLast1;
252*b1cdbd2cSJim Jagielski pFound->pLast1->pNext1 = pFound->pNext1;
253*b1cdbd2cSJim Jagielski // insert to LRU
254*b1cdbd2cSJim Jagielski pFound->pNext1 = pCur;
255*b1cdbd2cSJim Jagielski pFound->pLast1 = pCur->pLast1;
256*b1cdbd2cSJim Jagielski pFound->pNext1->pLast1 =
257*b1cdbd2cSJim Jagielski pFound->pLast1->pNext1 = pFound;
258*b1cdbd2cSJim Jagielski }
259*b1cdbd2cSJim Jagielski return pFound;
260*b1cdbd2cSJim Jagielski }
261*b1cdbd2cSJim Jagielski return NULL;
262*b1cdbd2cSJim Jagielski }
263*b1cdbd2cSJim Jagielski
264*b1cdbd2cSJim Jagielski // Load a page into the cache
265*b1cdbd2cSJim Jagielski
Get(sal_Int32 nPage,sal_Bool bForce)266*b1cdbd2cSJim Jagielski StgPage* StgCache::Get( sal_Int32 nPage, sal_Bool bForce )
267*b1cdbd2cSJim Jagielski {
268*b1cdbd2cSJim Jagielski StgPage* p = Find( nPage );
269*b1cdbd2cSJim Jagielski if( !p )
270*b1cdbd2cSJim Jagielski {
271*b1cdbd2cSJim Jagielski p = Create( nPage );
272*b1cdbd2cSJim Jagielski if( !Read( nPage, p->pData, 1 ) && bForce )
273*b1cdbd2cSJim Jagielski {
274*b1cdbd2cSJim Jagielski Erase( p );
275*b1cdbd2cSJim Jagielski p = NULL;
276*b1cdbd2cSJim Jagielski SetError( SVSTREAM_READ_ERROR );
277*b1cdbd2cSJim Jagielski }
278*b1cdbd2cSJim Jagielski }
279*b1cdbd2cSJim Jagielski return p;
280*b1cdbd2cSJim Jagielski }
281*b1cdbd2cSJim Jagielski
282*b1cdbd2cSJim Jagielski // Copy an existing page into a new page. Use this routine
283*b1cdbd2cSJim Jagielski // to duplicate an existing stream or to create new entries.
284*b1cdbd2cSJim Jagielski // The new page is initially marked dirty. No owner is copied.
285*b1cdbd2cSJim Jagielski
Copy(sal_Int32 nNew,sal_Int32 nOld)286*b1cdbd2cSJim Jagielski StgPage* StgCache::Copy( sal_Int32 nNew, sal_Int32 nOld )
287*b1cdbd2cSJim Jagielski {
288*b1cdbd2cSJim Jagielski StgPage* p = Find( nNew );
289*b1cdbd2cSJim Jagielski if( !p )
290*b1cdbd2cSJim Jagielski p = Create( nNew );
291*b1cdbd2cSJim Jagielski if( nOld >= 0 )
292*b1cdbd2cSJim Jagielski {
293*b1cdbd2cSJim Jagielski // old page: we must have this data!
294*b1cdbd2cSJim Jagielski StgPage* q = Get( nOld, sal_True );
295*b1cdbd2cSJim Jagielski if( q )
296*b1cdbd2cSJim Jagielski {
297*b1cdbd2cSJim Jagielski OSL_ENSURE( p->nData == q->nData, "Unexpected page size!" );
298*b1cdbd2cSJim Jagielski memcpy( p->pData, q->pData, p->nData );
299*b1cdbd2cSJim Jagielski }
300*b1cdbd2cSJim Jagielski }
301*b1cdbd2cSJim Jagielski p->SetDirty();
302*b1cdbd2cSJim Jagielski return p;
303*b1cdbd2cSJim Jagielski }
304*b1cdbd2cSJim Jagielski
305*b1cdbd2cSJim Jagielski // Flush the cache whose owner is given. NULL flushes all.
306*b1cdbd2cSJim Jagielski
Commit(StgDirEntry *)307*b1cdbd2cSJim Jagielski sal_Bool StgCache::Commit( StgDirEntry* )
308*b1cdbd2cSJim Jagielski {
309*b1cdbd2cSJim Jagielski StgPage* p = pElem1;
310*b1cdbd2cSJim Jagielski if( p ) do
311*b1cdbd2cSJim Jagielski {
312*b1cdbd2cSJim Jagielski if( p->bDirty )
313*b1cdbd2cSJim Jagielski {
314*b1cdbd2cSJim Jagielski sal_Bool b = Write( p->nPage, p->pData, 1 );
315*b1cdbd2cSJim Jagielski if( !b )
316*b1cdbd2cSJim Jagielski return sal_False;
317*b1cdbd2cSJim Jagielski p->bDirty = sal_False;
318*b1cdbd2cSJim Jagielski }
319*b1cdbd2cSJim Jagielski p = p->pNext2;
320*b1cdbd2cSJim Jagielski } while( p != pElem1 );
321*b1cdbd2cSJim Jagielski pStrm->Flush();
322*b1cdbd2cSJim Jagielski SetError( pStrm->GetError() );
323*b1cdbd2cSJim Jagielski #ifdef CHECK_DIRTY
324*b1cdbd2cSJim Jagielski p = pElem1;
325*b1cdbd2cSJim Jagielski if( p ) do
326*b1cdbd2cSJim Jagielski {
327*b1cdbd2cSJim Jagielski if( p->bDirty )
328*b1cdbd2cSJim Jagielski {
329*b1cdbd2cSJim Jagielski ErrorBox( NULL, WB_OK, String("SO2: Dirty Block in Ordered List") ).Execute();
330*b1cdbd2cSJim Jagielski sal_Bool b = Write( p->nPage, p->pData, 1 );
331*b1cdbd2cSJim Jagielski if( !b )
332*b1cdbd2cSJim Jagielski return sal_False;
333*b1cdbd2cSJim Jagielski p->bDirty = sal_False;
334*b1cdbd2cSJim Jagielski }
335*b1cdbd2cSJim Jagielski p = p->pNext2;
336*b1cdbd2cSJim Jagielski } while( p != pElem1 );
337*b1cdbd2cSJim Jagielski p = pElem1;
338*b1cdbd2cSJim Jagielski if( p ) do
339*b1cdbd2cSJim Jagielski {
340*b1cdbd2cSJim Jagielski if( p->bDirty )
341*b1cdbd2cSJim Jagielski {
342*b1cdbd2cSJim Jagielski ErrorBox( NULL, WB_OK, String("SO2: Dirty Block in LRU List") ).Execute();
343*b1cdbd2cSJim Jagielski sal_Bool b = Write( p->nPage, p->pData, 1 );
344*b1cdbd2cSJim Jagielski if( !b )
345*b1cdbd2cSJim Jagielski return sal_False;
346*b1cdbd2cSJim Jagielski p->bDirty = sal_False;
347*b1cdbd2cSJim Jagielski }
348*b1cdbd2cSJim Jagielski p = p->pNext1;
349*b1cdbd2cSJim Jagielski } while( p != pElem1 );
350*b1cdbd2cSJim Jagielski #endif
351*b1cdbd2cSJim Jagielski return sal_True;
352*b1cdbd2cSJim Jagielski }
353*b1cdbd2cSJim Jagielski
Revert(StgDirEntry *)354*b1cdbd2cSJim Jagielski void StgCache::Revert( StgDirEntry* )
355*b1cdbd2cSJim Jagielski {}
356*b1cdbd2cSJim Jagielski
357*b1cdbd2cSJim Jagielski // Set a stream
358*b1cdbd2cSJim Jagielski
SetStrm(SvStream * p,sal_Bool bMy)359*b1cdbd2cSJim Jagielski void StgCache::SetStrm( SvStream* p, sal_Bool bMy )
360*b1cdbd2cSJim Jagielski {
361*b1cdbd2cSJim Jagielski if( pStorageStream )
362*b1cdbd2cSJim Jagielski {
363*b1cdbd2cSJim Jagielski pStorageStream->ReleaseRef();
364*b1cdbd2cSJim Jagielski pStorageStream = NULL;
365*b1cdbd2cSJim Jagielski }
366*b1cdbd2cSJim Jagielski
367*b1cdbd2cSJim Jagielski if( bMyStream )
368*b1cdbd2cSJim Jagielski delete pStrm;
369*b1cdbd2cSJim Jagielski pStrm = p;
370*b1cdbd2cSJim Jagielski bMyStream = bMy;
371*b1cdbd2cSJim Jagielski }
372*b1cdbd2cSJim Jagielski
SetStrm(UCBStorageStream * pStgStream)373*b1cdbd2cSJim Jagielski void StgCache::SetStrm( UCBStorageStream* pStgStream )
374*b1cdbd2cSJim Jagielski {
375*b1cdbd2cSJim Jagielski if( pStorageStream )
376*b1cdbd2cSJim Jagielski pStorageStream->ReleaseRef();
377*b1cdbd2cSJim Jagielski pStorageStream = pStgStream;
378*b1cdbd2cSJim Jagielski
379*b1cdbd2cSJim Jagielski if( bMyStream )
380*b1cdbd2cSJim Jagielski delete pStrm;
381*b1cdbd2cSJim Jagielski
382*b1cdbd2cSJim Jagielski pStrm = NULL;
383*b1cdbd2cSJim Jagielski
384*b1cdbd2cSJim Jagielski if ( pStorageStream )
385*b1cdbd2cSJim Jagielski {
386*b1cdbd2cSJim Jagielski pStorageStream->AddRef();
387*b1cdbd2cSJim Jagielski pStrm = pStorageStream->GetModifySvStream();
388*b1cdbd2cSJim Jagielski }
389*b1cdbd2cSJim Jagielski
390*b1cdbd2cSJim Jagielski bMyStream = sal_False;
391*b1cdbd2cSJim Jagielski }
392*b1cdbd2cSJim Jagielski
393*b1cdbd2cSJim Jagielski // Open/close the disk file
394*b1cdbd2cSJim Jagielski
Open(const String & rName,StreamMode nMode)395*b1cdbd2cSJim Jagielski sal_Bool StgCache::Open( const String& rName, StreamMode nMode )
396*b1cdbd2cSJim Jagielski {
397*b1cdbd2cSJim Jagielski // do not open in exclusive mode!
398*b1cdbd2cSJim Jagielski if( nMode & STREAM_SHARE_DENYALL )
399*b1cdbd2cSJim Jagielski nMode = ( ( nMode & ~STREAM_SHARE_DENYALL ) | STREAM_SHARE_DENYWRITE );
400*b1cdbd2cSJim Jagielski SvFileStream* pFileStrm = new SvFileStream( rName, nMode );
401*b1cdbd2cSJim Jagielski // SvStream "Feature" Write Open auch erfolgreich, wenns nicht klappt
402*b1cdbd2cSJim Jagielski sal_Bool bAccessDenied = sal_False;
403*b1cdbd2cSJim Jagielski if( ( nMode & STREAM_WRITE ) && !pFileStrm->IsWritable() )
404*b1cdbd2cSJim Jagielski {
405*b1cdbd2cSJim Jagielski pFileStrm->Close();
406*b1cdbd2cSJim Jagielski bAccessDenied = sal_True;
407*b1cdbd2cSJim Jagielski }
408*b1cdbd2cSJim Jagielski SetStrm( pFileStrm, sal_True );
409*b1cdbd2cSJim Jagielski if( pFileStrm->IsOpen() )
410*b1cdbd2cSJim Jagielski {
411*b1cdbd2cSJim Jagielski sal_uLong nFileSize = pStrm->Seek( STREAM_SEEK_TO_END );
412*b1cdbd2cSJim Jagielski nPages = lcl_GetPageCount( nFileSize, nPageSize );
413*b1cdbd2cSJim Jagielski pStrm->Seek( 0L );
414*b1cdbd2cSJim Jagielski }
415*b1cdbd2cSJim Jagielski else
416*b1cdbd2cSJim Jagielski nPages = 0;
417*b1cdbd2cSJim Jagielski bFile = sal_True;
418*b1cdbd2cSJim Jagielski SetError( bAccessDenied ? ERRCODE_IO_ACCESSDENIED : pStrm->GetError() );
419*b1cdbd2cSJim Jagielski return Good();
420*b1cdbd2cSJim Jagielski }
421*b1cdbd2cSJim Jagielski
Close()422*b1cdbd2cSJim Jagielski void StgCache::Close()
423*b1cdbd2cSJim Jagielski {
424*b1cdbd2cSJim Jagielski if( bFile )
425*b1cdbd2cSJim Jagielski {
426*b1cdbd2cSJim Jagielski ((SvFileStream*) pStrm)->Close();
427*b1cdbd2cSJim Jagielski SetError( pStrm->GetError() );
428*b1cdbd2cSJim Jagielski }
429*b1cdbd2cSJim Jagielski }
430*b1cdbd2cSJim Jagielski
431*b1cdbd2cSJim Jagielski // low level I/O
432*b1cdbd2cSJim Jagielski
Read(sal_Int32 nPage,void * pBuf,sal_Int32 nPg)433*b1cdbd2cSJim Jagielski sal_Bool StgCache::Read( sal_Int32 nPage, void* pBuf, sal_Int32 nPg )
434*b1cdbd2cSJim Jagielski {
435*b1cdbd2cSJim Jagielski if( Good() )
436*b1cdbd2cSJim Jagielski {
437*b1cdbd2cSJim Jagielski /* #i73846# real life: a storage may refer to a page one-behind the
438*b1cdbd2cSJim Jagielski last valid page (see document attached to the issue). In that case
439*b1cdbd2cSJim Jagielski (if nPage==nPages), just do nothing here and let the caller work on
440*b1cdbd2cSJim Jagielski the empty zero-filled buffer. */
441*b1cdbd2cSJim Jagielski if ( nPage > nPages )
442*b1cdbd2cSJim Jagielski SetError( SVSTREAM_READ_ERROR );
443*b1cdbd2cSJim Jagielski else if ( nPage < nPages )
444*b1cdbd2cSJim Jagielski {
445*b1cdbd2cSJim Jagielski sal_uLong nPos = Page2Pos( nPage );
446*b1cdbd2cSJim Jagielski sal_Int32 nPg2 = ( ( nPage + nPg ) > nPages ) ? nPages - nPage : nPg;
447*b1cdbd2cSJim Jagielski sal_uLong nBytes = nPg2 * nPageSize;
448*b1cdbd2cSJim Jagielski // fixed address and size for the header
449*b1cdbd2cSJim Jagielski if( nPage == -1 )
450*b1cdbd2cSJim Jagielski {
451*b1cdbd2cSJim Jagielski nPos = 0L, nBytes = 512;
452*b1cdbd2cSJim Jagielski nPg2 = nPg;
453*b1cdbd2cSJim Jagielski }
454*b1cdbd2cSJim Jagielski if( pStrm->Tell() != nPos )
455*b1cdbd2cSJim Jagielski {
456*b1cdbd2cSJim Jagielski if( pStrm->Seek( nPos ) != nPos ) {
457*b1cdbd2cSJim Jagielski #ifdef CHECK_DIRTY
458*b1cdbd2cSJim Jagielski ErrorBox( NULL, WB_OK, String("SO2: Seek failed") ).Execute();
459*b1cdbd2cSJim Jagielski #endif
460*b1cdbd2cSJim Jagielski }
461*b1cdbd2cSJim Jagielski }
462*b1cdbd2cSJim Jagielski pStrm->Read( pBuf, nBytes );
463*b1cdbd2cSJim Jagielski if ( nPg != nPg2 )
464*b1cdbd2cSJim Jagielski SetError( SVSTREAM_READ_ERROR );
465*b1cdbd2cSJim Jagielski else
466*b1cdbd2cSJim Jagielski SetError( pStrm->GetError() );
467*b1cdbd2cSJim Jagielski }
468*b1cdbd2cSJim Jagielski }
469*b1cdbd2cSJim Jagielski return Good();
470*b1cdbd2cSJim Jagielski }
471*b1cdbd2cSJim Jagielski
Write(sal_Int32 nPage,void * pBuf,sal_Int32 nPg)472*b1cdbd2cSJim Jagielski sal_Bool StgCache::Write( sal_Int32 nPage, void* pBuf, sal_Int32 nPg )
473*b1cdbd2cSJim Jagielski {
474*b1cdbd2cSJim Jagielski if( Good() )
475*b1cdbd2cSJim Jagielski {
476*b1cdbd2cSJim Jagielski sal_uLong nPos = Page2Pos( nPage );
477*b1cdbd2cSJim Jagielski sal_uLong nBytes = 0;
478*b1cdbd2cSJim Jagielski if ( SAL_MAX_INT32 / nPg > nPageSize )
479*b1cdbd2cSJim Jagielski nBytes = nPg * nPageSize;
480*b1cdbd2cSJim Jagielski
481*b1cdbd2cSJim Jagielski // fixed address and size for the header
482*b1cdbd2cSJim Jagielski // nPageSize must be >= 512, otherwise the header can not be written here, we check it on import
483*b1cdbd2cSJim Jagielski if( nPage == -1 )
484*b1cdbd2cSJim Jagielski nPos = 0L, nBytes = 512;
485*b1cdbd2cSJim Jagielski if( pStrm->Tell() != nPos )
486*b1cdbd2cSJim Jagielski {
487*b1cdbd2cSJim Jagielski if( pStrm->Seek( nPos ) != nPos ) {
488*b1cdbd2cSJim Jagielski #ifdef CHECK_DIRTY
489*b1cdbd2cSJim Jagielski ErrorBox( NULL, WB_OK, String("SO2: Seek failed") ).Execute();
490*b1cdbd2cSJim Jagielski #endif
491*b1cdbd2cSJim Jagielski }
492*b1cdbd2cSJim Jagielski }
493*b1cdbd2cSJim Jagielski sal_uLong nRes = pStrm->Write( pBuf, nBytes );
494*b1cdbd2cSJim Jagielski if( nRes != nBytes )
495*b1cdbd2cSJim Jagielski SetError( SVSTREAM_WRITE_ERROR );
496*b1cdbd2cSJim Jagielski else
497*b1cdbd2cSJim Jagielski SetError( pStrm->GetError() );
498*b1cdbd2cSJim Jagielski #ifdef READ_AFTER_WRITE
499*b1cdbd2cSJim Jagielski sal_uInt8 cBuf[ 512 ];
500*b1cdbd2cSJim Jagielski pStrm->Flush();
501*b1cdbd2cSJim Jagielski pStrm->Seek( nPos );
502*b1cdbd2cSJim Jagielski sal_Bool bRes = ( pStrm->Read( cBuf, 512 ) == 512 );
503*b1cdbd2cSJim Jagielski if( bRes )
504*b1cdbd2cSJim Jagielski bRes = !memcmp( cBuf, pBuf, 512 );
505*b1cdbd2cSJim Jagielski if( !bRes )
506*b1cdbd2cSJim Jagielski {
507*b1cdbd2cSJim Jagielski ErrorBox( NULL, WB_OK, String("SO2: Read after Write failed") ).Execute();
508*b1cdbd2cSJim Jagielski pStrm->SetError( SVSTREAM_WRITE_ERROR );
509*b1cdbd2cSJim Jagielski }
510*b1cdbd2cSJim Jagielski #endif
511*b1cdbd2cSJim Jagielski }
512*b1cdbd2cSJim Jagielski return Good();
513*b1cdbd2cSJim Jagielski }
514*b1cdbd2cSJim Jagielski
515*b1cdbd2cSJim Jagielski // set the file size in pages
516*b1cdbd2cSJim Jagielski
SetSize(sal_Int32 n)517*b1cdbd2cSJim Jagielski sal_Bool StgCache::SetSize( sal_Int32 n )
518*b1cdbd2cSJim Jagielski {
519*b1cdbd2cSJim Jagielski // Add the file header
520*b1cdbd2cSJim Jagielski sal_Int32 nSize = n * nPageSize + 512;
521*b1cdbd2cSJim Jagielski pStrm->SetStreamSize( nSize );
522*b1cdbd2cSJim Jagielski SetError( pStrm->GetError() );
523*b1cdbd2cSJim Jagielski if( !nError )
524*b1cdbd2cSJim Jagielski nPages = n;
525*b1cdbd2cSJim Jagielski return Good();
526*b1cdbd2cSJim Jagielski }
527*b1cdbd2cSJim Jagielski
SetError(sal_uLong n)528*b1cdbd2cSJim Jagielski void StgCache::SetError( sal_uLong n )
529*b1cdbd2cSJim Jagielski {
530*b1cdbd2cSJim Jagielski if( n && !nError )
531*b1cdbd2cSJim Jagielski nError = n;
532*b1cdbd2cSJim Jagielski }
533*b1cdbd2cSJim Jagielski
ResetError()534*b1cdbd2cSJim Jagielski void StgCache::ResetError()
535*b1cdbd2cSJim Jagielski {
536*b1cdbd2cSJim Jagielski nError = SVSTREAM_OK;
537*b1cdbd2cSJim Jagielski pStrm->ResetError();
538*b1cdbd2cSJim Jagielski }
539*b1cdbd2cSJim Jagielski
MoveError(StorageBase & r)540*b1cdbd2cSJim Jagielski void StgCache::MoveError( StorageBase& r )
541*b1cdbd2cSJim Jagielski {
542*b1cdbd2cSJim Jagielski if( nError != SVSTREAM_OK )
543*b1cdbd2cSJim Jagielski {
544*b1cdbd2cSJim Jagielski r.SetError( nError );
545*b1cdbd2cSJim Jagielski ResetError();
546*b1cdbd2cSJim Jagielski }
547*b1cdbd2cSJim Jagielski }
548*b1cdbd2cSJim Jagielski
549*b1cdbd2cSJim Jagielski // Utility functions
550*b1cdbd2cSJim Jagielski
Page2Pos(sal_Int32 nPage)551*b1cdbd2cSJim Jagielski sal_Int32 StgCache::Page2Pos( sal_Int32 nPage )
552*b1cdbd2cSJim Jagielski {
553*b1cdbd2cSJim Jagielski if( nPage < 0 ) nPage = 0;
554*b1cdbd2cSJim Jagielski return( nPage * nPageSize ) + nPageSize;
555*b1cdbd2cSJim Jagielski }
556*b1cdbd2cSJim Jagielski
Pos2Page(sal_Int32 nPos)557*b1cdbd2cSJim Jagielski sal_Int32 StgCache::Pos2Page( sal_Int32 nPos )
558*b1cdbd2cSJim Jagielski {
559*b1cdbd2cSJim Jagielski return ( ( nPos + nPageSize - 1 ) / nPageSize ) * nPageSize - 1;
560*b1cdbd2cSJim Jagielski }
561*b1cdbd2cSJim Jagielski
562