Asterisk - The Open Source Telephony Project GIT-master-f3e88d3
Macros | Functions
hash_buf.c File Reference
#include <sys/param.h>
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include "../include/db.h"
#include "hash.h"
#include "page.h"
#include "extern.h"
Include dependency graph for hash_buf.c:

Go to the source code of this file.

Macros

#define BUF_INSERT(B, P)
 
#define BUF_REMOVE(B)
 
#define LRU   hashp->bufhead.prev
 
#define LRU_INSERT(B)   BUF_INSERT((B), LRU)
 
#define MRU   hashp->bufhead.next
 
#define MRU_INSERT(B)   BUF_INSERT((B), &hashp->bufhead)
 

Functions

int __buf_free (HTAB *hashp, int do_free, int to_disk)
 
void __buf_init (HTAB *hashp, int nbytes)
 
BUFHEAD__get_buf (HTAB *hashp, u_int32_t addr, BUFHEAD *prev_bp, int newpage)
 
static BUFHEAD *newbuf __P ((HTAB *, u_int32_t, BUFHEAD *))
 
void __reclaim_buf (HTAB *hashp, BUFHEAD *bp)
 
static BUFHEADnewbuf (HTAB *hashp, u_int32_t addr, BUFHEAD *prev_bp)
 

Macro Definition Documentation

◆ BUF_INSERT

#define BUF_INSERT (   B,
  P 
)

Definition at line 82 of file hash_buf.c.

◆ BUF_REMOVE

#define BUF_REMOVE (   B)
Value:
{ \
(B)->prev->next = (B)->next; \
(B)->next->prev = (B)->prev; \
}

Definition at line 76 of file hash_buf.c.

◆ LRU

#define LRU   hashp->bufhead.prev

Definition at line 90 of file hash_buf.c.

◆ LRU_INSERT

#define LRU_INSERT (   B)    BUF_INSERT((B), LRU)

Definition at line 93 of file hash_buf.c.

◆ MRU

#define MRU   hashp->bufhead.next

Definition at line 89 of file hash_buf.c.

◆ MRU_INSERT

#define MRU_INSERT (   B)    BUF_INSERT((B), &hashp->bufhead)

Definition at line 92 of file hash_buf.c.

Function Documentation

◆ __buf_free()

int __buf_free ( HTAB hashp,
int  do_free,
int  to_disk 
)

Definition at line 315 of file hash_buf.c.

318{
319 BUFHEAD *bp;
320
321 /* Need to make sure that buffer manager has been initialized */
322 if (!LRU)
323 return (0);
324 for (bp = LRU; bp != &hashp->bufhead;) {
325 /* Check that the buffer is valid */
326 if (bp->addr || IS_BUCKET(bp->flags)) {
327 if (to_disk && (bp->flags & BUF_MOD) &&
328 __put_page(hashp, bp->page,
329 bp->addr, IS_BUCKET(bp->flags), 0))
330 return (-1);
331 }
332 /* Check if we are freeing stuff */
333 if (do_free) {
334 if (bp->page)
335 free(bp->page);
336 BUF_REMOVE(bp);
337 free(bp);
338 bp = LRU;
339 } else
340 bp = bp->prev;
341 }
342 return (0);
343}
void free()
#define IS_BUCKET(X)
Definition: hash.h:60
#define BUF_MOD
Definition: hash.h:54
#define LRU
Definition: hash_buf.c:90
#define BUF_REMOVE(B)
Definition: hash_buf.c:76
int __put_page(HTAB *hashp, char *p, u_int32_t bucket, int is_bucket, int is_bitmap)
Definition: hash_page.c:578
Definition: hash.h:47
char * page
Definition: hash.h:52
char flags
Definition: hash.h:53
u_int32_t addr
Definition: hash.h:51
BUFHEAD * prev
Definition: hash.h:48
BUFHEAD bufhead
Definition: hash.h:116

References __put_page(), _bufhead::addr, BUF_MOD, BUF_REMOVE, htab::bufhead, _bufhead::flags, free(), IS_BUCKET, LRU, _bufhead::page, and _bufhead::prev.

Referenced by hash_sync(), and hdestroy().

◆ __buf_init()

void __buf_init ( HTAB hashp,
int  nbytes 
)

Definition at line 290 of file hash_buf.c.

293{
294 BUFHEAD *bfp;
295 int npages;
296
297 bfp = &(hashp->bufhead);
298 npages = (nbytes + hashp->BSIZE - 1) >> hashp->BSHIFT;
299 npages = MAX(npages, MIN_BUFFERS);
300
301 hashp->nbufs = npages;
302 bfp->next = bfp;
303 bfp->prev = bfp;
304 /*
305 * This space is calloc'd so these are already null.
306 *
307 * bfp->ovfl = NULL;
308 * bfp->flags = 0;
309 * bfp->page = NULL;
310 * bfp->addr = 0;
311 */
312}
#define MIN_BUFFERS
Definition: hash.h:124
BUFHEAD * next
Definition: hash.h:49
int nbufs
Definition: hash.h:114
#define MAX(a, b)
Definition: utils.h:233

References htab::bufhead, MAX, MIN_BUFFERS, htab::nbufs, _bufhead::next, and _bufhead::prev.

Referenced by __hash_open().

◆ __get_buf()

BUFHEAD * __get_buf ( HTAB hashp,
u_int32_t  addr,
BUFHEAD prev_bp,
int  newpage 
)

Definition at line 105 of file hash_buf.c.

110{
111 register BUFHEAD *bp;
112 register u_int32_t is_disk_mask;
113 register int is_disk, segment_ndx = 0;
114 SEGMENT segp = 0;
115
116 is_disk = 0;
117 is_disk_mask = 0;
118 if (prev_bp) {
119 bp = prev_bp->ovfl;
120 if (!bp || (bp->addr != addr))
121 bp = NULL;
122 if (!newpage)
123 is_disk = BUF_DISK;
124 } else {
125 /* Grab buffer out of directory */
126 segment_ndx = addr & (hashp->SGSIZE - 1);
127
128 /* valid segment ensured by __call_hash() */
129 segp = hashp->dir[addr >> hashp->SSHIFT];
130#ifdef DEBUG
131 assert(segp != NULL);
132#endif
133 bp = PTROF(segp[segment_ndx]);
134 is_disk_mask = ISDISK(segp[segment_ndx]);
135 is_disk = is_disk_mask || !hashp->new_file;
136 }
137
138 if (!bp) {
139 bp = newbuf(hashp, addr, prev_bp);
140 if (!bp ||
141 __get_page(hashp, bp->page, addr, !prev_bp, is_disk, 0))
142 return (NULL);
143 if (!prev_bp)
144 segp[segment_ndx] =
145 (BUFHEAD *)((ptrdiff_t)bp | is_disk_mask);
146 } else {
147 BUF_REMOVE(bp);
148 MRU_INSERT(bp);
149 }
150 return (bp);
151}
#define PTROF(X)
Definition: hash.h:143
#define BUF_DISK
Definition: hash.h:55
#define ISDISK(X)
Definition: hash.h:146
static BUFHEAD * newbuf(HTAB *hashp, u_int32_t addr, BUFHEAD *prev_bp)
Definition: hash_buf.c:160
#define MRU_INSERT(B)
Definition: hash_buf.c:92
int __get_page(HTAB *hashp, char *p, u_int32_t bucket, int is_bucket, int is_disk, int is_bitmap)
Definition: hash_page.c:518
unsigned int u_int32_t
#define NULL
Definition: resample.c:96
BUFHEAD * ovfl
Definition: hash.h:50
int new_file
Definition: hash.h:107
SEGMENT * dir
Definition: hash.h:117

References __get_page(), _bufhead::addr, BUF_DISK, BUF_REMOVE, htab::dir, ISDISK, MRU_INSERT, htab::new_file, newbuf(), NULL, _bufhead::ovfl, _bufhead::page, and PTROF.

Referenced by __add_ovflpage(), __addel(), __big_delete(), __big_return(), __big_split(), __find_bigpair(), __find_last_page(), __split_page(), collect_data(), collect_key(), hash_access(), hash_seq(), and ugly_split().

◆ __P()

static BUFHEAD *newbuf __P ( (HTAB *, u_int32_t, BUFHEAD *)  )
static

◆ __reclaim_buf()

void __reclaim_buf ( HTAB hashp,
BUFHEAD bp 
)

Definition at line 346 of file hash_buf.c.

349{
350 bp->ovfl = 0;
351 bp->addr = 0;
352 bp->flags = 0;
353 BUF_REMOVE(bp);
354 LRU_INSERT(bp);
355}
#define LRU_INSERT(B)
Definition: hash_buf.c:93

References _bufhead::addr, BUF_REMOVE, _bufhead::flags, LRU_INSERT, and _bufhead::ovfl.

Referenced by __free_ovflpage().

◆ newbuf()

static BUFHEAD * newbuf ( HTAB hashp,
u_int32_t  addr,
BUFHEAD prev_bp 
)
static

Definition at line 160 of file hash_buf.c.

164{
165 register BUFHEAD *bp; /* The buffer we're going to use */
166 register BUFHEAD *xbp; /* Temp pointer */
167 register BUFHEAD *next_xbp;
168 SEGMENT segp;
169 int segment_ndx;
170 u_int16_t oaddr, *shortp;
171
172 oaddr = 0;
173 bp = LRU;
174 /*
175 * If LRU buffer is pinned, the buffer pool is too small. We need to
176 * allocate more buffers.
177 */
178 if (hashp->nbufs || (bp->flags & BUF_PIN)) {
179 /* Allocate a new one */
180 if ((bp = (BUFHEAD *)malloc(sizeof(BUFHEAD))) == NULL)
181 return (NULL);
182#ifdef PURIFY
183 memset(bp, 0xff, sizeof(BUFHEAD));
184#endif
185 if ((bp->page = (char *)malloc(hashp->BSIZE)) == NULL) {
186 free(bp);
187 return (NULL);
188 }
189#ifdef PURIFY
190 memset(bp->page, 0xff, hashp->BSIZE);
191#endif
192 if (hashp->nbufs)
193 hashp->nbufs--;
194 } else {
195 /* Kick someone out */
196 BUF_REMOVE(bp);
197 /*
198 * If this is an overflow page with addr 0, it's already been
199 * flushed back in an overflow chain and initialized.
200 */
201 if ((bp->addr != 0) || (bp->flags & BUF_BUCKET)) {
202 /*
203 * Set oaddr before __put_page so that you get it
204 * before bytes are swapped.
205 */
206 shortp = (u_int16_t *)bp->page;
207 if (shortp[0])
208 oaddr = shortp[shortp[0] - 1];
209 if ((bp->flags & BUF_MOD) && __put_page(hashp, bp->page,
210 bp->addr, (int)IS_BUCKET(bp->flags), 0))
211 return (NULL);
212 /*
213 * Update the pointer to this page (i.e. invalidate it).
214 *
215 * If this is a new file (i.e. we created it at open
216 * time), make sure that we mark pages which have been
217 * written to disk so we retrieve them from disk later,
218 * rather than allocating new pages.
219 */
220 if (IS_BUCKET(bp->flags)) {
221 segment_ndx = bp->addr & (hashp->SGSIZE - 1);
222 segp = hashp->dir[bp->addr >> hashp->SSHIFT];
223#ifdef DEBUG
224 assert(segp != NULL);
225#endif
226
227 if (hashp->new_file &&
228 ((bp->flags & BUF_MOD) ||
229 ISDISK(segp[segment_ndx])))
230 segp[segment_ndx] = (BUFHEAD *)BUF_DISK;
231 else
232 segp[segment_ndx] = NULL;
233 }
234 /*
235 * Since overflow pages can only be access by means of
236 * their bucket, free overflow pages associated with
237 * this bucket.
238 */
239 for (xbp = bp; xbp->ovfl;) {
240 next_xbp = xbp->ovfl;
241 xbp->ovfl = 0;
242 xbp = next_xbp;
243
244 /* Check that ovfl pointer is up date. */
245 if (IS_BUCKET(xbp->flags) ||
246 (oaddr != xbp->addr))
247 break;
248
249 shortp = (u_int16_t *)xbp->page;
250 if (shortp[0])
251 /* set before __put_page */
252 oaddr = shortp[shortp[0] - 1];
253 if ((xbp->flags & BUF_MOD) && __put_page(hashp,
254 xbp->page, xbp->addr, 0, 0))
255 return (NULL);
256 xbp->addr = 0;
257 xbp->flags = 0;
258 BUF_REMOVE(xbp);
259 LRU_INSERT(xbp);
260 }
261 }
262 }
263
264 /* Now assign this buffer */
265 bp->addr = addr;
266#ifdef DEBUG1
267 (void)fprintf(stderr, "NEWBUF1: %d->ovfl was %d is now %d\n",
268 bp->addr, (bp->ovfl ? bp->ovfl->addr : 0), 0);
269#endif
270 bp->ovfl = NULL;
271 if (prev_bp) {
272 /*
273 * If prev_bp is set, this is an overflow page, hook it in to
274 * the buffer overflow links.
275 */
276#ifdef DEBUG1
277 (void)fprintf(stderr, "NEWBUF2: %d->ovfl was %d is now %d\n",
278 prev_bp->addr, (prev_bp->ovfl ? bp->ovfl->addr : 0),
279 (bp ? bp->addr : 0));
280#endif
281 prev_bp->ovfl = bp;
282 bp->flags = 0;
283 } else
284 bp->flags = BUF_BUCKET;
285 MRU_INSERT(bp);
286 return (bp);
287}
if(!yyg->yy_init)
Definition: ast_expr2f.c:854
char * malloc()
#define BUF_BUCKET
Definition: hash.h:56
#define BUF_PIN
Definition: hash.h:57
unsigned short u_int16_t

References __put_page(), _bufhead::addr, BUF_BUCKET, BUF_DISK, BUF_MOD, BUF_PIN, BUF_REMOVE, htab::dir, _bufhead::flags, free(), if(), IS_BUCKET, ISDISK, LRU, LRU_INSERT, malloc(), MRU_INSERT, htab::nbufs, htab::new_file, NULL, _bufhead::ovfl, and _bufhead::page.

Referenced by __get_buf(), and xmpp_client_receive().