memset(bp->page, 0xff, hashp->BSIZE);
memset(bp->page, 0xff, (size_t)hashp->BSIZE);
static BUFHEAD *newbuf __P((HTAB *, uint32, BUFHEAD *));/* Unlink B from its place in the lru */#define BUF_REMOVE(B) { \	(B)->prev->next = (B)->next; \	(B)->next->prev = (B)->prev; \}/* Insert B after P */#define BUF_INSERT(B, P) { \	(B)->next = (P)->next; \	(B)->prev = (P); \	(P)->next = (B); \	(B)->next->prev = (B); \}#define	MRU	hashp->bufhead.next#define	LRU	hashp->bufhead.prev#define MRU_INSERT(B)	BUF_INSERT((B), &hashp->bufhead)#define LRU_INSERT(B)	BUF_INSERT((B), LRU)/* * We are looking for a buffer with address "addr".  If prev_bp is NULL, then * address is a bucket index.  If prev_bp is not NULL, then it points to the * page previous to an overflow page that we are trying to find. * * CAVEAT:  The buffer header accessed via prev_bp's ovfl field may no longer * be valid.  Therefore, you must always verify that its address matches the * address you are seeking. */extern BUFHEAD *__get_buf(HTAB *hashp, uint32 addr, BUFHEAD *prev_bp, int newpage)/* If prev_bp set, indicates a new overflow page. */{	register BUFHEAD *bp;	register uint32 is_disk_mask;	register int is_disk, segment_ndx = 0;	SEGMENT segp = 0;	is_disk = 0;	is_disk_mask = 0;	if (prev_bp) {		bp = prev_bp->ovfl;		if (!bp || (bp->addr != addr))			bp = NULL;		if (!newpage)			is_disk = BUF_DISK;	} else {		/* Grab buffer out of directory */		segment_ndx = addr & (hashp->SGSIZE - 1);		/* valid segment ensured by __call_hash() */		segp = hashp->dir[addr >> hashp->SSHIFT];#ifdef DEBUG		assert(segp != NULL);#endif  		bp = PTROF(segp[segment_ndx]);		is_disk_mask = ISDISK(segp[segment_ndx]);		is_disk = is_disk_mask || !hashp->new_file;	}	if (!bp) {		bp = newbuf(hashp, addr, prev_bp);		if (!bp)			return(NULL);		if(__get_page(hashp, bp->page, addr, !prev_bp, is_disk, 0))		  {			/* free bp and its page */			if(prev_bp)			  {				/* if prev_bp is set then the new page that				 * failed is hooked onto prev_bp as an overflow page.				 * if we don't remove the pointer to the bad page				 * we may try and access it later and we will die				 * horribly because it will have already been				 * free'd and overwritten with bogus data.				 */				prev_bp->ovfl = NULL;			  }			BUF_REMOVE(bp);			free(bp->page);			free(bp);			return (NULL);		  }		if (!prev_bp)					  {#if 0			/* 16 bit windows and mac can't handle the			 * oring of the is disk flag.		 	 */						segp[segment_ndx] =			    (BUFHEAD *)((ptrdiff_t)bp | is_disk_mask);#else   			/* set the is_disk thing inside the structure			 */			bp->is_disk = is_disk_mask;			segp[segment_ndx] = bp;#endif		  }	} else {  		BUF_REMOVE(bp);		MRU_INSERT(bp);                 	}	return (bp);}/* * We need a buffer for this page. Either allocate one, or evict a resident * one (if we have as many buffers as we're allowed) and put this one in. * * If newbuf finds an error (returning NULL), it also sets errno. */static BUFHEAD *newbuf(HTAB *hashp, uint32 addr, BUFHEAD *prev_bp){	register BUFHEAD *bp;		/* The buffer we're going to use */	register BUFHEAD *xbp;		/* Temp pointer */	register BUFHEAD *next_xbp;	SEGMENT segp;	int segment_ndx;	uint16 oaddr, *shortp;	oaddr = 0;	bp = LRU;	/*	 * If LRU buffer is pinned, the buffer pool is too small. We need to	 * allocate more buffers.	 */	if (hashp->nbufs || (bp->flags & BUF_PIN)) {		/* Allocate a new one */		if ((bp = (BUFHEAD *)malloc(sizeof(BUFHEAD))) == NULL)			return (NULL);		/* this memset is supposedly unnecessary but lets add		 * it anyways.		 */		memset(bp, 0xff, sizeof(BUFHEAD));		if ((bp->page = (char *)malloc(hashp->BSIZE)) == NULL) {			free(bp);			return (NULL);		}		/* this memset is supposedly unnecessary but lets add		 * it anyways.		 */		memset(bp->page, 0xff, hashp->BSIZE);		if (hashp->nbufs)			hashp->nbufs--;	} else {		/* Kick someone out */		BUF_REMOVE(bp);		/*		 * If this is an overflow page with addr 0, it's already been		 * flushed back in an overflow chain and initialized.		 */		if ((bp->addr != 0) || (bp->flags & BUF_BUCKET)) {			/*			 * Set oaddr before __put_page so that you get it			 * before bytes are swapped.			 */			shortp = (uint16 *)bp->page;			if (shortp[0])			  {				if(shortp[0] > (hashp->BSIZE / sizeof(uint16)))				  {					return(NULL);				  }				oaddr = shortp[shortp[0] - 1];			  }			if ((bp->flags & BUF_MOD) && __put_page(hashp, bp->page,			    bp->addr, (int)IS_BUCKET(bp->flags), 0))				return (NULL);			/*			 * Update the pointer to this page (i.e. invalidate it).			 *			 * If this is a new file (i.e. we created it at open			 * time), make sure that we mark pages which have been			 * written to disk so we retrieve them from disk later,			 * rather than allocating new pages.			 */			if (IS_BUCKET(bp->flags)) {				segment_ndx = bp->addr & (hashp->SGSIZE - 1);				segp = hashp->dir[bp->addr >> hashp->SSHIFT];#ifdef DEBUG				assert(segp != NULL);#endif				if (hashp->new_file &&				    ((bp->flags & BUF_MOD) ||				    ISDISK(segp[segment_ndx])))					segp[segment_ndx] = (BUFHEAD *)BUF_DISK;				else					segp[segment_ndx] = NULL;			}			/*			 * Since overflow pages can only be access by means of			 * their bucket, free overflow pages associated with			 * this bucket.			 */			for (xbp = bp; xbp->ovfl;) {				next_xbp = xbp->ovfl;				xbp->ovfl = 0;				xbp = next_xbp;				/* Check that ovfl pointer is up date. */				if (IS_BUCKET(xbp->flags) ||				    (oaddr != xbp->addr))					break;				shortp = (uint16 *)xbp->page;				if (shortp[0])				  {					/* LJM is the number of reported					 * pages way too much?					 */					if(shortp[0] > hashp->BSIZE/sizeof(uint16))						return NULL;					/* set before __put_page */					oaddr = shortp[shortp[0] - 1];				  }				if ((xbp->flags & BUF_MOD) && __put_page(hashp,				    xbp->page, xbp->addr, 0, 0))					return (NULL);				xbp->addr = 0;				xbp->flags = 0;				BUF_REMOVE(xbp);				LRU_INSERT(xbp);			}		}	}	/* Now assign this buffer */	bp->addr = addr;#ifdef DEBUG1	(void)fprintf(stderr, "NEWBUF1: %d->ovfl was %d is now %d\n",	    bp->addr, (bp->ovfl ? bp->ovfl->addr : 0), 0);#endif	bp->ovfl = NULL;	if (prev_bp) {		/*		 * If prev_bp is set, this is an overflow page, hook it in to		 * the buffer overflow links.		 */#ifdef DEBUG1		(void)fprintf(stderr, "NEWBUF2: %d->ovfl was %d is now %d\n",		    prev_bp->addr, (prev_bp->ovfl ? bp->ovfl->addr : 0),		    (bp ? bp->addr : 0));#endif		prev_bp->ovfl = bp;		bp->flags = 0;	} else		bp->flags = BUF_BUCKET;	MRU_INSERT(bp);	return (bp);}