]>
git.ipfire.org Git - thirdparty/squid.git/blob - src/stmem.cc
5 * DEBUG: section 19 Store Memory Primitives
6 * AUTHOR: Harvest Derived
8 * SQUID Web Proxy Cache http://www.squid-cache.org/
9 * ----------------------------------------------------------
11 * Squid is the result of efforts by numerous individuals from
12 * the Internet community; see the CONTRIBUTORS file for full
13 * details. Many organizations have provided support for Squid's
14 * development; see the SPONSORS file for full details. Squid is
15 * Copyrighted (C) 2001 by the Regents of the University of
16 * California; see the COPYRIGHT file for full details. Squid
17 * incorporates software developed and/or copyrighted by other
18 * sources; see the CREDITS file for full details.
20 * This program is free software; you can redistribute it and/or modify
21 * it under the terms of the GNU General Public License as published by
22 * the Free Software Foundation; either version 2 of the License, or
23 * (at your option) any later version.
25 * This program is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 * GNU General Public License for more details.
30 * You should have received a copy of the GNU General Public License
31 * along with this program; if not, write to the Free Software
32 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
34 * Copyright (c) 2003, Robert Collins <robertc@squid-cache.org>
37 #include "squid-old.h"
40 #include "MemObject.h"
44 * NodeGet() is called to get the data buffer to pass to storeIOWrite().
45 * By setting the write_pending flag here we are assuming that there
46 * will be no other users of NodeGet(). The storeIOWrite() callback
47 * is memNodeWriteComplete(), which, for whatever reason, lives in
51 mem_hdr :: NodeGet ( mem_node
* aNode
)
53 assert (! aNode
-> write_pending
);
54 aNode
-> write_pending
= 1 ;
59 mem_hdr :: lowestOffset () const
61 const SplayNode
< mem_node
*> * theStart
= nodes
. start ();
64 return theStart
-> data
-> nodeBuffer
. offset
;
70 mem_hdr :: endOffset () const
73 const SplayNode
< mem_node
*> * theEnd
= nodes
. finish ();
76 result
= theEnd
-> data
-> dataRange (). end
;
78 assert ( result
== inmem_hi
);
84 mem_hdr :: freeContent ()
86 nodes
. destroy ( SplayNode
< mem_node
*>:: DefaultFree
);
88 debugs ( 19 , 9 , HERE
<< this << " hi: " << inmem_hi
);
92 mem_hdr :: unlink ( mem_node
* aNode
)
94 if ( aNode
-> write_pending
) {
95 debugs ( 0 , 0 , "cannot unlink mem_node " << aNode
<< " while write_pending" );
99 nodes
. remove ( aNode
, NodeCompare
);
105 mem_hdr :: freeDataUpto ( int64_t target_offset
)
107 /* keep the last one to avoid change to other part of code */
109 SplayNode
< mem_node
*> const * theStart
= nodes
. start ();
111 while (( theStart
= nodes
. start ())) {
112 if ( theStart
== nodes
. finish ())
115 if ( theStart
-> data
-> end () > target_offset
)
118 if (! unlink ( theStart
-> data
))
122 assert ( lowestOffset () <= target_offset
);
124 return lowestOffset ();
128 mem_hdr :: appendToNode ( mem_node
* aNode
, const char * data
, int maxLength
)
130 size_t result
= writeAvailable ( aNode
, aNode
-> nodeBuffer
. offset
+ aNode
-> nodeBuffer
. length
, maxLength
, data
);
135 mem_hdr :: writeAvailable ( mem_node
* aNode
, int64_t location
, size_t amount
, char const * source
)
137 /* if we attempt to overwrite existing data or leave a gap within a node */
138 assert ( location
== aNode
-> nodeBuffer
. offset
+ ( int64_t ) aNode
-> nodeBuffer
. length
);
139 /* And we are not at the end of the node */
140 assert ( aNode
-> canAccept ( location
));
142 /* these two can go I think */
143 assert ( location
- aNode
-> nodeBuffer
. offset
== ( int64_t ) aNode
-> nodeBuffer
. length
);
144 size_t copyLen
= min ( amount
, aNode
-> space ());
146 memcpy ( aNode
-> nodeBuffer
. data
+ aNode
-> nodeBuffer
. length
, source
, copyLen
);
148 debugs ( 19 , 9 , HERE
<< this << " hi: " << inmem_hi
);
149 if ( inmem_hi
<= location
)
150 inmem_hi
= location
+ copyLen
;
152 /* Adjust the ptr and len according to what was deposited in the page */
153 aNode
-> nodeBuffer
. length
+= copyLen
;
155 debugs ( 19 , 9 , HERE
<< this << " hi: " << inmem_hi
);
156 debugs ( 19 , 9 , HERE
<< this << " hi: " << endOffset ());
161 mem_hdr :: appendNode ( mem_node
* aNode
)
163 nodes
. insert ( aNode
, NodeCompare
);
167 mem_hdr :: makeAppendSpace ()
170 appendNode ( new mem_node ( 0 ));
174 if (! nodes
. finish ()-> data
-> space ())
175 appendNode ( new mem_node ( endOffset ()));
177 assert ( nodes
. finish ()-> data
-> space ());
181 mem_hdr :: internalAppend ( const char * data
, int len
)
183 debugs ( 19 , 6 , "memInternalAppend: " << this << " len " << len
);
187 int copied
= appendToNode ( nodes
. finish ()-> data
, data
, len
);
195 /* returns a mem_node that contains location..
196 * If no node contains the start, it returns NULL.
199 mem_hdr :: getBlockContainingLocation ( int64_t location
) const
201 // Optimize: do not create a whole mem_node just to store location
202 mem_node
target ( location
);
203 target
. nodeBuffer
. length
= 1 ;
204 mem_node
* const * result
= nodes
. find (& target
, NodeCompare
);
213 mem_hdr :: copyAvailable ( mem_node
* aNode
, int64_t location
, size_t amount
, char * target
) const
215 if ( aNode
-> nodeBuffer
. offset
> location
)
218 assert ( aNode
-> nodeBuffer
. offset
<= location
);
220 assert ( aNode
-> end () > location
);
222 size_t copyOffset
= location
- aNode
-> nodeBuffer
. offset
;
224 size_t copyLen
= min ( amount
, aNode
-> nodeBuffer
. length
- copyOffset
);
226 memcpy ( target
, aNode
-> nodeBuffer
. data
+ copyOffset
, copyLen
);
232 mem_hdr :: debugDump () const
234 debugs ( 19 , 0 , "mem_hdr::debugDump: lowest offset: " << lowestOffset () << " highest offset + 1: " << endOffset () << "." );
235 std :: ostringstream result
;
236 PointerPrinter
< mem_node
*> foo ( result
, " - " );
237 for_each ( getNodes (). begin (), getNodes (). end (), foo
);
238 debugs ( 19 , 0 , "mem_hdr::debugDump: Current available data is: " << result
. str () << "." );
241 /* FIXME: how do we deal with sparse results -
242 * where we have (say)
243 * 0-500 and 1000-1500, but are asked for
246 * we supply 0-500 and stop.
249 mem_hdr :: copy ( StoreIOBuffer
const & target
) const
252 assert ( target
. range (). end
> target
. range (). start
);
253 debugs ( 19 , 6 , "memCopy: " << this << " " << target
. range ());
255 /* we shouldn't ever ask for absent offsets */
257 if ( nodes
. size () == 0 ) {
258 debugs ( 19 , 1 , "mem_hdr::copy: No data to read" );
264 /* RC: the next assert is nearly useless */
265 assert ( target
. length
> 0 );
267 /* Seek our way into store */
268 mem_node
* p
= getBlockContainingLocation ( target
. offset
);
271 debugs ( 19 , 1 , "memCopy: could not find start of " << target
. range () <<
274 fatal ( "Squid has attempted to read data from memory that is not present. This is an indication of of (pre-3.0) code that hasn't been updated to deal with sparse objects in memory. Squid should coredump.allowing to review the cause. Immediately preceeding this message is a dump of the available data in the format [start,end). The [ means from the value, the ) means up to the value. I.e. [1,5) means that there are 4 bytes of data, at offsets 1,2,3,4. \n " );
278 size_t bytes_to_go
= target
. length
;
279 char * ptr_to_buf
= target
. data
;
280 int64_t location
= target
. offset
;
282 /* Start copying begining with this block until
285 while ( p
&& bytes_to_go
> 0 ) {
286 size_t bytes_to_copy
= copyAvailable ( p
,
287 location
, bytes_to_go
, ptr_to_buf
);
289 /* hit a sparse patch */
291 if ( bytes_to_copy
== 0 )
292 return target
. length
- bytes_to_go
;
294 location
+= bytes_to_copy
;
296 ptr_to_buf
+= bytes_to_copy
;
298 bytes_to_go
-= bytes_to_copy
;
300 p
= getBlockContainingLocation ( location
);
303 return target
. length
- bytes_to_go
;
307 mem_hdr :: hasContigousContentRange ( Range
< int64_t > const & range
) const
309 int64_t currentStart
= range
. start
;
311 while ( mem_node
* curr
= getBlockContainingLocation ( currentStart
)) {
312 currentStart
= curr
-> end ();
314 if ( currentStart
>= range
. end
)
322 mem_hdr :: unionNotEmpty ( StoreIOBuffer
const & candidate
)
324 assert ( candidate
. offset
>= 0 );
325 mem_node
target ( candidate
. offset
);
326 target
. nodeBuffer
. length
= candidate
. length
;
327 return nodes
. find (& target
, NodeCompare
);
331 mem_hdr :: nodeToRecieve ( int64_t offset
)
333 /* case 1: Nothing in memory */
336 appendNode ( new mem_node ( offset
));
337 return nodes
. start ()-> data
;
340 mem_node
* candidate
= NULL
;
341 /* case 2: location fits within an extant node */
344 mem_node
search ( offset
- 1 );
345 search
. nodeBuffer
. length
= 1 ;
346 mem_node
* const * leadup
= nodes
. find (& search
, NodeCompare
);
352 if ( candidate
&& candidate
-> canAccept ( offset
))
355 /* candidate can't accept, so we need a new node */
356 candidate
= new mem_node ( offset
);
358 appendNode ( candidate
);
360 /* simpler to write than a indented if */
366 mem_hdr :: write ( StoreIOBuffer
const & writeBuffer
)
368 PROF_start ( mem_hdr_write
);
369 debugs ( 19 , 6 , "mem_hdr::write: " << this << " " << writeBuffer
. range () << " object end " << endOffset ());
371 if ( unionNotEmpty ( writeBuffer
)) {
372 debugs ( 19 , 0 , "mem_hdr::write: writeBuffer: " << writeBuffer
. range ());
374 fatal ( "Attempt to overwrite already in-memory data. Preceeding this there should be a mem_hdr::write output that lists the attempted write, and the currently present data. Please get a 'backtrace full' from this error - using the generated core, and file a bug report with the squid developers including the last 10 lines of cache.log and the backtrace. \n " );
375 PROF_stop ( mem_hdr_write
);
379 assert ( writeBuffer
. offset
>= 0 );
382 int64_t currentOffset
= writeBuffer
. offset
;
383 char * currentSource
= writeBuffer
. data
;
384 size_t len
= writeBuffer
. length
;
386 while ( len
&& ( target
= nodeToRecieve ( currentOffset
))) {
387 size_t wrote
= writeAvailable ( target
, currentOffset
, len
, currentSource
);
390 currentOffset
+= wrote
;
391 currentSource
+= wrote
;
394 PROF_stop ( mem_hdr_write
);
398 mem_hdr :: mem_hdr () : inmem_hi ( 0 )
400 debugs ( 19 , 9 , HERE
<< this << " hi: " << inmem_hi
);
408 /* splay of mem nodes:
410 * a = b if a.intersection(b).size > 0;
414 mem_hdr :: NodeCompare ( mem_node
* const & left
, mem_node
* const & right
)
416 // possibly Range can help us at some point.
418 if ( left
-> dataRange (). intersection ( right
-> dataRange ()). size () > 0 )
421 return * left
< * right
? - 1 : 1 ;
425 mem_hdr :: dump () const
427 debugs ( 20 , 1 , "mem_hdr: " << ( void *) this << " nodes.start() " << nodes
. start ());
428 debugs ( 20 , 1 , "mem_hdr: " << ( void *) this << " nodes.finish() " << nodes
. finish ());
432 mem_hdr :: size () const
438 mem_hdr :: start () const
440 const SplayNode
< mem_node
*> * result
= nodes
. start ();
448 const Splay
< mem_node
*> &
449 mem_hdr :: getNodes () const