コード例 #1
0
ファイル: afs_buffer.c プロジェクト: jisqyv/openafs
int
DRead(struct dcache *adc, int page, struct DirBuffer *entry)
{
    /* Read a page from the disk. */
    struct buffer *tb, *tb2;
    struct osi_file *tfile;
    int code;

    AFS_STATCNT(DRead);

    memset(entry, 0, sizeof(struct DirBuffer));

    ObtainWriteLock(&afs_bufferLock, 256);

#define bufmatch(tb) (tb->page == page && tb->fid == adc->index)
#define buf_Front(head,parent,p) {(parent)->hashNext = (p)->hashNext; (p)->hashNext= *(head);*(head)=(p);}

    /* this apparently-complicated-looking code is simply an example of
     * a little bit of loop unrolling, and is a standard linked-list
     * traversal trick. It saves a few assignments at the the expense
     * of larger code size.  This could be simplified by better use of
     * macros.
     */
    if ((tb = phTable[pHash(adc->index, page)])) {
	if (bufmatch(tb)) {
	    ObtainWriteLock(&tb->lock, 257);
	    tb->lockers++;
	    ReleaseWriteLock(&afs_bufferLock);
	    tb->accesstime = timecounter++;
	    AFS_STATS(afs_stats_cmperf.bufHits++);
	    ReleaseWriteLock(&tb->lock);
	    entry->buffer = tb;
	    entry->data = tb->data;
	    return 0;
	} else {
	    struct buffer **bufhead;
	    bufhead = &(phTable[pHash(adc->index, page)]);
	    while ((tb2 = tb->hashNext)) {
		if (bufmatch(tb2)) {
		    buf_Front(bufhead, tb, tb2);
		    ObtainWriteLock(&tb2->lock, 258);
		    tb2->lockers++;
		    ReleaseWriteLock(&afs_bufferLock);
		    tb2->accesstime = timecounter++;
		    AFS_STATS(afs_stats_cmperf.bufHits++);
		    ReleaseWriteLock(&tb2->lock);
		    entry->buffer = tb2;
		    entry->data = tb2->data;
		    return 0;
		}
		if ((tb = tb2->hashNext)) {
		    if (bufmatch(tb)) {
			buf_Front(bufhead, tb2, tb);
			ObtainWriteLock(&tb->lock, 259);
			tb->lockers++;
			ReleaseWriteLock(&afs_bufferLock);
			tb->accesstime = timecounter++;
			AFS_STATS(afs_stats_cmperf.bufHits++);
			ReleaseWriteLock(&tb->lock);
			entry->buffer = tb;
			entry->data = tb->data;
			return 0;
		    }
		} else
		    break;
	    }
	}
    } else
	tb2 = NULL;

    AFS_STATS(afs_stats_cmperf.bufMisses++);
    /* can't find it */
    /* The last thing we looked at was either tb or tb2 (or nothing). That
     * is at least the oldest buffer on one particular hash chain, so it's
     * a pretty good place to start looking for the truly oldest buffer.
     */
    tb = afs_newslot(adc, page, (tb ? tb : tb2));
    if (!tb) {
	ReleaseWriteLock(&afs_bufferLock);
	return EIO;
    }
    ObtainWriteLock(&tb->lock, 260);
    tb->lockers++;
    ReleaseWriteLock(&afs_bufferLock);
    if (page * AFS_BUFFER_PAGESIZE >= adc->f.chunkBytes) {
	tb->fid = NULLIDX;
	afs_reset_inode(&tb->inode);
	tb->lockers--;
	ReleaseWriteLock(&tb->lock);
	return EIO;
    }
    tfile = afs_CFileOpen(&adc->f.inode);
    code =
	afs_CFileRead(tfile, tb->page * AFS_BUFFER_PAGESIZE, tb->data,
		      AFS_BUFFER_PAGESIZE);
    afs_CFileClose(tfile);
    if (code < AFS_BUFFER_PAGESIZE) {
	tb->fid = NULLIDX;
	afs_reset_inode(&tb->inode);
	tb->lockers--;
	ReleaseWriteLock(&tb->lock);
	return EIO;
    }
    /* Note that findslot sets the page field in the buffer equal to
     * what it is searching for. */
    ReleaseWriteLock(&tb->lock);
    entry->buffer = tb;
    entry->data = tb->data;
    return 0;
}
コード例 #2
0
ファイル: buffer.c プロジェクト: SimonWilkinson/openafs
/**
 * read a page out of a directory object.
 *
 * @param[in] fid   directory object fid
 * @param[in] page  page in hash table to be read
 *
 * @return pointer to requested page in directory cache
 *    @retval NULL read failed
 */
void *
DRead(afs_int32 *fid, int page)
{
    /* Read a page from the disk. */
    struct buffer *tb, *tb2, **bufhead;

    ObtainWriteLock(&afs_bufferLock);
    calls++;

#define bufmatch(tb) (tb->page == page && FidEq(tb->fid, fid))
#define buf_Front(head,parent,p) {(parent)->hashNext = (p)->hashNext; (p)->hashNext= *(head);*(head)=(p);}

    /* this apparently-complicated-looking code is simply an example of
     * a little bit of loop unrolling, and is a standard linked-list
     * traversal trick. It saves a few assignments at the the expense
     * of larger code size.  This could be simplified by better use of
     * macros.  With the use of these LRU queues, the old one-cache is
     * probably obsolete.
     */
    if ((tb = phTable[pHash(fid)])) {	/* ASSMT HERE */
	if (bufmatch(tb)) {
	    ObtainWriteLock(&tb->lock);
	    tb->lockers++;
	    ReleaseWriteLock(&afs_bufferLock);
	    tb->accesstime = ++timecounter;
	    ReleaseWriteLock(&tb->lock);
	    return tb->data;
	} else {
	    bufhead = &(phTable[pHash(fid)]);
	    while ((tb2 = tb->hashNext)) {
		if (bufmatch(tb2)) {
		    buf_Front(bufhead, tb, tb2);
		    ObtainWriteLock(&tb2->lock);
		    tb2->lockers++;
		    ReleaseWriteLock(&afs_bufferLock);
		    tb2->accesstime = ++timecounter;
		    ReleaseWriteLock(&tb2->lock);
		    return tb2->data;
		}
		if ((tb = tb2->hashNext)) {	/* ASSIGNMENT HERE! */
		    if (bufmatch(tb)) {
			buf_Front(bufhead, tb2, tb);
			ObtainWriteLock(&tb->lock);
			tb->lockers++;
			ReleaseWriteLock(&afs_bufferLock);
			tb->accesstime = ++timecounter;
			ReleaseWriteLock(&tb->lock);
			return tb->data;
		    }
		} else
		    break;
	    }
	}
    } else
	tb2 = NULL;

    /* can't find it */
    /* The last thing we looked at was either tb or tb2 (or nothing). That
     * is at least the oldest buffer on one particular hash chain, so it's
     * a pretty good place to start looking for the truly oldest buffer.
     */
    tb = newslot(fid, page, (tb ? tb : tb2));
    ios++;
    ObtainWriteLock(&tb->lock);
    tb->lockers++;
    ReleaseWriteLock(&afs_bufferLock);
    if (ReallyRead(tb->fid, tb->page, tb->data)) {
	tb->lockers--;
	FidZap(tb->fid);	/* disaster */
	ReleaseWriteLock(&tb->lock);
	return 0;
    }
    /* Note that findslot sets the page field in the buffer equal to
     * what it is searching for.
     */
    ReleaseWriteLock(&tb->lock);
    return tb->data;
}
コード例 #3
0
static short ppm_image_init_rev( LPBJF_IMAGEINFO lpbjfimage )
{
	FILE			*readfp;
	FILE			*tmpfp;
	unsigned char	buffer[50];
	unsigned char	*buf = NULL;
	unsigned char	**rawbuf = NULL;
	short			tmpflg;
	short			tmpformat;
	short			retbyte = 0;
	short			bpp = 3;
	long			width = 0;
	long			length = 0;
	long			maxvalue = 0;
	long			rstep = 0;
	long			RasterLength = 0;
	long			i;
	short			result = -1;
	char			ch;
	long			fp_offset;

	/*---
		We must init global parameters again, without isfirstcall and 
			ppm imageformat is inited in ppmraw_image_open
	---*/
	tmpflg    = lpbjfimage->isfirstcall;
	tmpformat = lpbjfimage->imageformat;
	tmpfp     = lpbjfimage->bmp;

	memset( (LPBJF_IMAGEINFO)lpbjfimage, 0, sizeof(BJF_IMAGEINFO) );

	lpbjfimage->isfirstcall = tmpflg;
	lpbjfimage->imageformat = tmpformat;
	lpbjfimage->bmp			= tmpfp;

	
	readfp = lpbjfimage->bmp;

	/*--- 
		when second page,
	---*/
	if ( lpbjfimage->isfirstcall ){
		lpbjfimage->isfirstcall = 0;
	}
	else{
		retbyte = fread( buffer, 2, 1, readfp );

		if ( !retbyte ){	/* end document */
			result = 0;
			goto onErr;
		}

		if ( bufmatch( (char *)PPMRAWSTART, (char*)buffer, 2 ) < 0 ) goto onErr;
	}

	/* skip "0x0A" after "P6" */
	if ( (ch = fgetc( readfp )) == EOF ) goto onErr;	

	readPPMParam( readfp, &width, &length, &maxvalue );
	
	if ( (!width) || (!length) ) goto onErr;
	
	RasterLength = width * bpp;
	
	/* parameter check */
	if ( maxvalue != 255 ) goto onErr;

	/*--- Get image raw data ( by MAXBUFSIZE unit ) ---*/
	rstep = MAXBUF / RasterLength;

	if ( rstep > length ){
		rstep = length;
	}

	if ( (buf = (unsigned char *)malloc( MAXBUF )) == NULL ) goto onErr;

	rawbuf = (unsigned char **)calloc( sizeof(unsigned char *), rstep );
	if ( rawbuf == NULL ) goto onErr;

	for( i=0; i<rstep; i++ ){
		rawbuf[i] = buf + RasterLength * i;
	} 

	fp_offset = RasterLength * ( length - rstep );
	
	if ( fseek( readfp, fp_offset, SEEK_CUR ) != 0 ){
		goto onErr;
	}
	if ( !fread( buf, RasterLength, rstep,  readfp ) ){
		goto onErr;
	}
	lpbjfimage->readraster += rstep;

	/* go back to read start point */
	if ( fseek( readfp, -( RasterLength * rstep ) , SEEK_CUR ) != 0 ){
		goto onErr;
	}


	/*--- Set cif Parameter ---*/
	lpbjfimage->width        = width;
	lpbjfimage->length       = length;
	lpbjfimage->bpp          = bpp;
	lpbjfimage->rasterlength = width * bpp;
	lpbjfimage->outputtype   = BJFOUTPUT_COLOR;
	lpbjfimage->xresolution  = 0;
	lpbjfimage->yresolution  = 0;
	lpbjfimage->bmpraw       = rawbuf;
	lpbjfimage->rstep        = rstep;
	lpbjfimage->top          = 0;

	result = 1;
onErr:
	return result;	
}	
コード例 #4
0
/*---------------------------------------------------------------*/
int ppm_write_tmpfile( LPBJF_IMAGEINFO lpbjfimage, char *filename , char *outfile)
{
	FILE			*readfp = NULL;
	unsigned char	buffer[5];
	long			width = 0;
	long			length = 0;
	long			maxvalue = 0;
	short			bpp = 3;
	long			RasterLength = 0;	/* width of a raster */
	long			read_len = 0;
	long			imagesize = 0;
	short			retbyte;
	char			ch;
	unsigned char	*buf = NULL;
	long			parm_len = 0;
	int				fd = -1;
	int				w_size;
	long			block_num = 0;
	long			lastblock_size = 0;
	short			i;
	
	
	if ( filename != NULL ){
		if ( (readfp = fopen( filename, "rb" )) == NULL ) goto onErr;
		fread( buffer, 2, 1, readfp );
	}
	else {
		readfp = stdin;
	}

	
	/* check header */
	retbyte = fread( buffer, 2, 1, readfp );

	if ( !retbyte ){	/* end document */
		return CIF_FILE_END;	/* end document --> return */
	}

	if ( bufmatch( (char *)PPMRAWSTART, (char*)buffer, 2 ) < 0 ) goto onErr;

	/* make tempfile to output */
	fd = mkstemp(outfile);
	if(  fd  < 0 ){
		goto onErr;
	}

	/* write "P6" */
	w_size = write( fd , PPMRAWSTART , 2 );

	/* skip "0x0A" after "P6" */
	if ( (ch = fgetc( readfp )) == EOF ) goto onErr;	
	w_size = write( fd , &ch , 1 );


	/* read and write PPM parameter */
	parm_len = readwritePPMParam( readfp, &width, &length, &maxvalue , fd );

	if ( (!width) || (!length) ) goto onErr;
	
	/* parameter check */
	if ( maxvalue != 255 ) goto onErr;

	RasterLength = width * bpp;
	imagesize = RasterLength * length;

	/* allocate read buffer */
	if ( (buf = (unsigned char *)malloc( MAXBUF )) == NULL ) goto onErr;
	block_num = imagesize / MAXBUF;
	lastblock_size = imagesize % MAXBUF;

	/* read and write image raw data ( by MAXBUFSIZE unit ) */
	for( i=0 ; i<block_num ; i++ ){
		if ( !(read_len = fread( buf, 1, MAXBUF, readfp ) )){
			goto onErr;
		}
		w_size = write( fd , buf , MAXBUF );
	}
	
	if( lastblock_size > 0 ){
		if ( !(read_len = fread( buf, 1, lastblock_size, readfp ) )){
			goto onErr;
		}
		w_size = write( fd , buf , lastblock_size );
	}
	
	if( buf ) free(buf);
	close( fd );
	return fd;


onErr:
	if( fd >= 0 ){
		close( fd );
		unlink(outfile);
	}
	if( buf ) free(buf);
	return -1;
}
コード例 #5
0
/*-------------------------------------------------------------*/
short bjf_image_open( LPBJF_IMAGEINFO lpbjfimage, char *filename )
/*-------------------------------------------------------------*/
{
	FILE				*tf = NULL;
	unsigned char		tbuf[10];
	short				result = -1;
	
	/*--- initialize image work parameter ---*/
	memset( (LPBJF_IMAGEINFO)lpbjfimage, 0, sizeof(BJF_IMAGEINFO) );
	
	/*-------------------------------*/
	/*		Select Image Format		 */
	/*-------------------------------*/
	/*---- in case input is stdin ---*/
	if ( filename == NULL ){
		if ( !fread( tbuf, 2, 1, stdin ) ) goto onErr;

		/*-- support ppm stdin --*/
		if ( bufmatch( (char *)PPMRAWSTART, (char *)tbuf, 2 ) > 0 ){
			lpbjfimage->imageformat = BJFIMAGE_PPM;
		}
		else {
			fprintf( stderr, "Error : not support this image format\n");
			goto onErr;
		}
	}
	/*--- in case input is file ---*/
	else{
		if ( (tf=fopen( filename, "rb" )) == NULL ) goto onErr; 

		/* top 4 byte of file */
		if ( !fread( tbuf, 8, 1, tf ) ) goto onErr;
		
		if ( tf != NULL ){
			fclose( tf );
			tf = NULL;
		}
	
		if ( bufmatch( (char*)PPMRAWSTART, (char *)tbuf, 2 ) > 0 )
			lpbjfimage->imageformat = BJFIMAGE_PPM;
		else{
			fprintf( stderr, "Error : not support this image format\n");
			goto onErr;
		}
	}

	/*--------------------------*/
	/*		Open Read Image		*/
	/*--------------------------*/
	switch( lpbjfimage->imageformat ){
		case BJFIMAGE_PPM:
			if ( ppm_image_open( lpbjfimage, filename  ) < 0 ) goto onErr;
			break;
		default:
			fprintf( stderr, "Error : not support this image format\n");
			goto onErr;
	}


	result = 0;
	return result;
	
onErr:
	if ( tf != NULL ) fclose( tf );
	return result;
}