/* * ----------------------------------------------------------------- * cfsd_fscache_destroy * * Description: * Arguments: * Returns: * Preconditions: */ void cfsd_fscache_destroy(cfsd_fscache_object_t *fscache_object_p) { int xx; dbug_enter("cfsd_fscache_destroy"); dbug_precond(fscache_object_p); /* dbug_assert(fscache_object_p->i_refcnt == 0); */ /* close down the message file descriptor */ if (fscache_object_p->i_ofd >= 0) { if (close(fscache_object_p->i_ofd)) dbug_print(("error", "cannot close fscache fd error %d", errno)); fscache_object_p->i_ofd = -1; } /* destroy the locking mutex */ xx = mutex_destroy(&fscache_object_p->i_lock); dbug_assert(xx == 0); /* destroy the conditional variable */ xx = cond_destroy(&fscache_object_p->i_cvwait); dbug_assert(xx == 0); cfsd_free(fscache_object_p); dbug_leave("cfsd_fscache_destroy"); }
/* * fscache_fsproblem * * Description: * Arguments: * kmodp * Returns: * Preconditions: * precond(kmodp) */ void fscache_fsproblem(cfsd_fscache_object_t *fscache_object_p, cfsd_kmod_object_t *kmod_object_p) { #if 0 int xx; #endif dbug_enter("fscache_fsproblem"); dbug_precond(fscache_object_p); dbug_precond(kmod_object_p); #if 0 /* first try to put all modified files in lost+found */ xx = kmod_lostfoundall(kmod_object_p); if (xx) { /* if that failed, put file system in read-only mode */ kmod_rofs(kmod_object_p); #endif fscache_lock(fscache_object_p); fscache_object_p->i_disconnectable = 0; fscache_object_p->i_modify++; fscache_unlock(fscache_object_p); #if 0 } #endif dbug_leave("fscache_fsproblem"); }
/* * logfile_dumpstats * * Description: * Prints out various stats about the hashing. * Arguments: * Returns: * Preconditions: */ void logfile_dumpstats(cfsd_logfile_object_t *logfile_object_p) { int xx; double dd; dbug_enter("logfile_dumpstats"); dbug_print(("dump", "Request - next %d", logfile_object_p->i_stat_nextcnt)); dbug_print(("dump", "Request - offset %d", logfile_object_p->i_stat_offcnt)); dbug_print(("dump", "Map Moves %d", logfile_object_p->i_stat_mapmove)); dbug_print(("dump", "Mapping Size %d", logfile_object_p->i_maplen)); dbug_print(("dump", "Item Size %d", logfile_object_p->i_maxmap)); dbug_print(("dump", "File Size %d", logfile_object_p->i_size)); if (logfile_object_p->i_stat_mapmove == 0) { dbug_leave("logfile_dumpstats"); return; } dd = (double)logfile_object_p->i_stat_mapmove / (logfile_object_p->i_stat_nextcnt + logfile_object_p->i_stat_offcnt); dbug_print(("dump", "Mmap moves per Request %.2f", dd)); xx = logfile_object_p->i_stat_mapdist / logfile_object_p->i_stat_mapmove; dbug_print(("dump", "Average distance per mmap moves %d", xx)); dbug_leave("logfile_dumpstats"); }
static void rdbuf_bop(PLStream *pls) { dbug_enter("rdbuf_bop"); pls->nplwin = 0; }
void plD_bop_plm(PLStream *pls) { PLmDev *dev = (PLmDev *) pls->dev; int isfile = (pls->output_type == 0); FPOS_T pp_offset = dev->lp_offset;; dbug_enter("plD_bop_plm"); dev->xold = PL_UNDEFINED; dev->yold = PL_UNDEFINED; /* Update previous page header */ if (isfile) UpdatePrevPagehdr(pls); /* Start next family file if necessary. */ pls->bytecnt = pls->pdfs->bp; plGetFam(pls); /* Update page counter */ pls->page++; /* Update table of contents info & write new page header. */ WritePageInfo(pls, pp_offset); }
void plio_fgets( char *buf, int size, FILE *stream ) { char *s; dbug_enter( "plio_fgets" ); // If the buffer has a size of zero, we should complain if ( size == 0 ) { plwarn( "Zero length buffer size in plio_fgets, returning" ); return; } // Clear the error flag for this steam clearerr( stream ); s = fgets( buf, size, stream ); if ( s == NULL && ferror( stream ) ) { // The read resulted in an error plabort( "Error reading from file" ); } }
/* * logfile_getaddr * * Description: * Returns an address of a particular offset in the file. * The size of the item to map is i_maxmap * This routine assumes that if we have to remap that i_maxmap * will fit inside the default mapping size. * Arguments: * start offset in the file to map * map 0 means use map_entry, 1 means use map_offset * Returns: * Returns NULL for a failure with the mapping file. * Preconditions: */ caddr_t logfile_getaddr(cfsd_logfile_object_t *logfile_object_p, off_t start, int map) { mmap_info_t *mmp; caddr_t pa; off_t end; dbug_enter("logfile_getaddr"); mmp = (map == 0) ? &logfile_object_p->i_map_entry : &logfile_object_p->i_map_offset; /* determine the end of the item */ end = start + logfile_object_p->i_maxmap - 1; /* map the entry in if necessary */ if ((start < mmp->i_paoff) || (mmp->i_paend < end)) { if (logfile_domap(logfile_object_p, start & logfile_object_p->i_pagemask, map)) { dbug_leave("logfile_getaddr"); return (NULL); } dbug_assert((mmp->i_paoff <= start) && (end <= mmp->i_paend)); } /* make an address and return it */ pa = mmp->i_pa + (start - mmp->i_paoff); dbug_leave("logfile_getaddr"); return (pa); }
void plio_fread( void *buf, size_t size, size_t nmemb, FILE *stream ) { size_t bytes; dbug_enter( "plio_fread" ); // If the buffer has a size of zero, we should complain if ( size == 0 || nmemb == 0 ) { plwarn( "Zero length buffer size in plio_fread, returning" ); return; } // Clear the error flag for this steam clearerr( stream ); bytes = fread( buf, size, nmemb, stream ); if ( ( bytes < nmemb ) && ferror( stream ) ) { // The read resulted in an error plabort( "Error reading from file" ); } }
/* * ------------------------------------------------------------ * cfsd_all_destroy * * Description: * Arguments: * Returns: * Preconditions: */ void cfsd_all_destroy(cfsd_all_object_t *all_object_p) { cfsd_cache_object_t *cache_object_p; cfsd_cache_object_t *tmp_cache_object_p; int xx; dbug_enter("cfsd_all_destroy"); /* dbug_assert(all_object_p->i_hoardp == NULL); */ /* get rid of any cache objects */ cache_object_p = all_object_p->i_cachelist; while (cache_object_p != NULL) { tmp_cache_object_p = cache_object_p->i_next; cfsd_cache_destroy(cache_object_p); cache_object_p = tmp_cache_object_p; } /* destroy the locking mutex */ xx = mutex_destroy(&all_object_p->i_lock); dbug_assert(xx == 0); cfsd_free(all_object_p); dbug_leave("cfsd_all_destroy"); }
/* * ------------------------------------------------------------ * all_cachefstab_update * * Description: * Arguments: * Returns: * Preconditions: */ void all_cachefstab_update(cfsd_all_object_t *all_object_p) { cfsd_cache_object_t *cache_object_p; FILE *fout; dbug_enter("all_cachefstab_update"); fout = fopen(CACHEFSTAB, "w"); if (fout == NULL) { dbug_print(("error", "cannot write %s", CACHEFSTAB)); } else { cache_object_p = all_object_p->i_cachelist; while (cache_object_p != NULL) { dbug_assert(cache_object_p); fprintf(fout, "%s\n", cache_object_p->i_cachedir); cache_object_p = cache_object_p->i_next; } if (fclose(fout)) dbug_print(("error", "cannot close %s error %d", CACHEFSTAB, errno)); } dbug_leave("all_cachefstab_update"); }
/* * ------------------------------------------------------------ * all_unlock * * Description: * Arguments: * Returns: * Preconditions: */ void all_unlock(cfsd_all_object_t *all_object_p) { dbug_enter("all_unlock"); mutex_unlock(&all_object_p->i_lock); dbug_leave("all_unlock"); }
/* * fscache_changes * * Description: * Used to specify whether or not there are changes to roll to the * server. * Arguments: * tt * Returns: * Preconditions: */ void fscache_changes(cfsd_fscache_object_t *fscache_object_p, int tt) { dbug_enter("fscache_changes"); dbug_precond(fscache_object_p); fscache_object_p->i_changes = tt; fscache_object_p->i_modify++; dbug_leave("fscache_changes"); }
/* * cfsd_logfile_destroy * * Description: * Arguments: * Returns: * Preconditions: */ void cfsd_logfile_destroy(cfsd_logfile_object_t *logfile_object_p) { dbug_enter("cfsd_logfile_destroy"); logfile_sync(logfile_object_p); logfile_teardown(logfile_object_p); cfsd_free(logfile_object_p); dbug_leave("cfsd_logfile_destroy"); }
/* * ----------------------------------------------------------------- * fscache_unlock * * Description: * Arguments: * Returns: * Preconditions: */ void fscache_unlock(cfsd_fscache_object_t *fscache_object_p) { dbug_enter("fscache_unlock"); dbug_precond(fscache_object_p); mutex_unlock(&fscache_object_p->i_lock); dbug_leave("fscache_unlock"); }
void plD_init_plm(PLStream *pls) { PLmDev *dev; U_CHAR c = (U_CHAR) INITIALIZE; dbug_enter("plD_init_plm"); pls->color = 1; /* Is a color device */ pls->dev_fill0 = 1; /* Handle solid fills */ pls->dev_fill1 = 1; /* Handle pattern fills */ /* Initialize family file info */ plFamInit(pls); /* Prompt for a file name if not already set */ plOpenFile(pls); pls->pdfs = pdf_finit(pls->OutFile); /* Allocate and initialize device-specific data */ pls->dev = calloc(1, (size_t) sizeof(PLmDev)); if (pls->dev == NULL) plexit("plD_init_plm: Out of memory."); dev = (PLmDev *) pls->dev; dev->xold = PL_UNDEFINED; dev->yold = PL_UNDEFINED; dev->xmin = 0; dev->xmax = PIXELS_X - 1; dev->ymin = 0; dev->ymax = PIXELS_Y - 1; dev->pxlx = (double) PIXELS_X / (double) LPAGE_X; dev->pxly = (double) PIXELS_Y / (double) LPAGE_Y; plP_setpxl(dev->pxlx, dev->pxly); plP_setphy(dev->xmin, dev->xmax, dev->ymin, dev->ymax); /* Write Metafile header. */ WriteFileHeader(pls); /* Write color map state info */ plD_state_plm(pls, PLSTATE_CMAP0); plD_state_plm(pls, PLSTATE_CMAP1); /* Write initialization command. */ DEBUG_PRINT_LOCATION("before init"); plm_wr( pdf_wr_1byte(pls->pdfs, c) ); }
static void plbuf_fill(PLStream *pls) { dbug_enter("plbuf_fill"); fwrite(&pls->dev_npts, sizeof(PLINT), 1, pls->plbufFile); fwrite(pls->dev_x, sizeof(short), pls->dev_npts, pls->plbufFile); fwrite(pls->dev_y, sizeof(short), pls->dev_npts, pls->plbufFile); }
void plbuf_init(PLStream *pls) { dbug_enter("plbuf_init"); pls->plbuf_read = FALSE; if (pls->plbufFile != NULL) pls->plbuf_write = FALSE; }
/* * logfile_domap * * Description: * Maps in the specified section of the file. * Arguments: * off The offset to map in. Must be i_pagesize aligned. * map 0 means use map_entry, 1 means use map_offset * Returns: * Returns 0 for success or an errno value on failure. * Preconditions: */ int logfile_domap(cfsd_logfile_object_t *logfile_object_p, off_t off, int map) { int xx; int len; mmap_info_t *mmp; dbug_enter("logfile_domap"); dbug_precond(logfile_object_p->i_fid >= 0); len = logfile_object_p->i_maplen; mmp = (map == 0) ? &logfile_object_p->i_map_entry : &logfile_object_p->i_map_offset; logfile_object_p->i_stat_mapmove++; /* destroy old mapping if it exists */ if (mmp->i_pa) { /* determine how far we have to move the map */ logfile_object_p->i_stat_mapdist += abs(mmp->i_paoff - off); /* remove the map */ xx = munmap(mmp->i_pa, mmp->i_palen); if (xx == -1) { xx = errno; dbug_print(("error", "Could not unmap %s, %d, %p, %d", logfile_object_p->i_name, xx, mmp->i_pa, mmp->i_palen)); } mmp->i_pa = NULL; mmp->i_palen = 0; mmp->i_paoff = 0; mmp->i_paend = 0; } /* do the mapping */ mmp->i_pa = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, logfile_object_p->i_fid, off); if (mmp->i_pa == MAP_FAILED) { xx = errno; dbug_print(("error", "Could not map %s, error %d, off %d, len %d", logfile_object_p->i_name, xx, off, len)); mmp->i_pa = NULL; dbug_leave("logfile_domap"); return (xx); } mmp->i_palen = len; mmp->i_paoff = off; mmp->i_paend = off + len - 1; dbug_leave("logfile_domap"); return (0); }
/* * logfile_entry * * Description: * Sets addrp to the address of the log entry at offset * The mapping remains in effect until: * a) this routine is called again * b) logfile_teardown is called * c) this object is destroyed * Arguments: * offset offset to start of entry * entpp place to store address * Returns: * Returns 0 for success, 1 for EOF, -1 if a fatal error occurs. * Preconditions: * precond(addrp) */ int logfile_entry(cfsd_logfile_object_t *logfile_object_p, off_t offset, cfs_dlog_entry_t **entpp) { cfs_dlog_entry_t *entp; dbug_enter("logfile_entry"); dbug_precond(entpp); dbug_precond(offset >= sizeof (long)); logfile_object_p->i_stat_nextcnt++; /* check for eof */ if (offset >= logfile_object_p->i_size) { dbug_leave("logfile_entry"); return (1); } dbug_assert((offset & 3) == 0); /* get the address of the entry */ entp = (cfs_dlog_entry_t *)logfile_getaddr(logfile_object_p, offset, 0); if (entp == NULL) { dbug_leave("logfile_entry"); return (-1); } /* sanity check, record should be alligned */ if (entp->dl_len & 3) { dbug_print(("error", "Record at offset %d length is not alligned %d", offset, entp->dl_len)); dbug_leave("logfile_entry"); return (-1); } /* sanity check record should a reasonable size */ if ((entp->dl_len < CFS_DLOG_ENTRY_MINSIZE) || (entp->dl_len > CFS_DLOG_ENTRY_MAXSIZE)) { dbug_print(("error", "Record at offset %d has an invalid size %d", offset, entp->dl_len)); dbug_leave("logfile_entry"); return (-1); } /* preserve offset and pointer */ logfile_object_p->i_cur_offset = offset; logfile_object_p->i_cur_entry = entp; /* return success */ *entpp = entp; dbug_leave("logfile_entry"); return (0); }
void plD_tidy_plm(PLStream *pls) { U_CHAR c = (U_CHAR) CLOSE; dbug_enter("plD_tidy_plm"); plm_wr( pdf_wr_1byte(pls->pdfs, c) ); pdf_close(pls->pdfs); free_mem(pls->dev); }
void plD_state_plm(PLStream *pls, PLINT op) { U_CHAR c = (U_CHAR) CHANGE_STATE; int i; dbug_enter("plD_state_plm"); plm_wr( pdf_wr_1byte(pls->pdfs, c) ); plm_wr( pdf_wr_1byte(pls->pdfs, op) ); switch (op) { case PLSTATE_WIDTH: plm_wr( pdf_wr_2bytes(pls->pdfs, (U_SHORT) (pls->width)) ); break; case PLSTATE_COLOR0: plm_wr( pdf_wr_2bytes(pls->pdfs, (short) pls->icol0) ); if (pls->icol0 == PL_RGB_COLOR) { plm_wr( pdf_wr_1byte(pls->pdfs, pls->curcolor.r) ); plm_wr( pdf_wr_1byte(pls->pdfs, pls->curcolor.g) ); plm_wr( pdf_wr_1byte(pls->pdfs, pls->curcolor.b) ); } break; case PLSTATE_COLOR1: plm_wr( pdf_wr_2bytes(pls->pdfs, (U_SHORT) pls->icol1) ); break; case PLSTATE_FILL: plm_wr( pdf_wr_1byte(pls->pdfs, (U_CHAR) pls->patt) ); break; case PLSTATE_CMAP0: plm_wr( pdf_wr_2bytes(pls->pdfs, (U_SHORT) pls->ncol0) ); for (i = 0; i < pls->ncol0; i++) { plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap0[i].r) ); plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap0[i].g) ); plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap0[i].b) ); } break; case PLSTATE_CMAP1: plm_wr( pdf_wr_2bytes(pls->pdfs, (U_SHORT) pls->ncol1) ); for (i = 0; i < pls->ncol1; i++) { plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap1[i].r) ); plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap1[i].g) ); plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap1[i].b) ); } break; } }
void plbuf_polyline(PLStream *pls, short *xa, short *ya, PLINT npts) { dbug_enter("plbuf_polyline"); wr_command(pls, (U_CHAR) POLYLINE); fwrite(&npts, sizeof(PLINT), 1, pls->plbufFile); fwrite(xa, sizeof(short), npts, pls->plbufFile); fwrite(ya, sizeof(short), npts, pls->plbufFile); }
void plbuf_tidy(PLStream *pls) { dbug_enter("plbuf_tidy"); if (pls->plbufFile == NULL) return; fclose(pls->plbufFile); pls->plbufFile = NULL; }
static void rdbuf_line(PLStream *pls) { short xpl[2], ypl[2]; PLINT npts = 2; dbug_enter("rdbuf_line"); fread(xpl, sizeof(short), npts, pls->plbufFile); fread(ypl, sizeof(short), npts, pls->plbufFile); plP_line(xpl, ypl); }
/* * ------------------------------------------------------------ * all_cachelist_add * * Description: * Arguments: * cachep * Returns: * Preconditions: * precond(cachep) */ void all_cachelist_add(cfsd_all_object_t *all_object_p, cfsd_cache_object_t *cache_object_p) { dbug_enter("all_cachelist_add"); dbug_precond(cache_object_p); cache_object_p->i_next = all_object_p->i_cachelist; all_object_p->i_cachelist = cache_object_p; all_object_p->i_modify++; all_object_p->i_cachecount++; dbug_leave("all_cachelist_add"); }
static void rdbuf_fill(PLStream *pls) { short xpl[PL_MAXPOLY], ypl[PL_MAXPOLY]; PLINT npts; dbug_enter("rdbuf_fill"); fread(&npts, sizeof(PLINT), 1, pls->plbufFile); fread(xpl, sizeof(short), npts, pls->plbufFile); fread(ypl, sizeof(short), npts, pls->plbufFile); plP_fill(xpl, ypl, npts); }
/* * logfile_teardown * * Description: * Uninitializes the object. * Call logfile_setup before using this object again. * Arguments: * Returns: * Preconditions: */ void logfile_teardown(cfsd_logfile_object_t *logfile_object_p) { int xx; dbug_enter("logfile_teardown"); if (logfile_object_p->i_map_entry.i_pa) { xx = munmap(logfile_object_p->i_map_entry.i_pa, logfile_object_p->i_map_entry.i_palen); if (xx == -1) { xx = errno; dbug_print(("error", "Could not unmap %s, %d, %p, %d", logfile_object_p->i_name, xx, logfile_object_p->i_map_entry.i_pa, logfile_object_p->i_map_entry.i_palen)); } logfile_object_p->i_map_entry.i_pa = NULL; } logfile_object_p->i_map_entry.i_paoff = 0; logfile_object_p->i_map_entry.i_paend = 0; logfile_object_p->i_map_entry.i_palen = 0; if (logfile_object_p->i_map_offset.i_pa) { xx = munmap(logfile_object_p->i_map_offset.i_pa, logfile_object_p->i_map_offset.i_palen); if (xx == -1) { xx = errno; dbug_print(("error", "Could not unmap %s, %d, %p, %d", logfile_object_p->i_name, xx, logfile_object_p->i_map_offset.i_pa, logfile_object_p->i_map_offset.i_palen)); } logfile_object_p->i_map_offset.i_pa = NULL; } logfile_object_p->i_map_offset.i_paoff = 0; logfile_object_p->i_map_offset.i_paend = 0; logfile_object_p->i_map_offset.i_palen = 0; if (logfile_object_p->i_fid != -1) { if (close(logfile_object_p->i_fid)) dbug_print(("error", "Could not close %s, %d", logfile_object_p->i_name, errno)); logfile_object_p->i_fid = -1; } logfile_object_p->i_cur_offset = 0; logfile_object_p->i_cur_entry = NULL; dbug_leave("logfile_teardown"); }
void plbuf_bop(PLStream *pls) { dbug_enter("plbuf_bop"); plbuf_tidy(pls); pls->plbufFile = tmpfile(); if (pls->plbufFile == NULL) plexit("plbuf_init: Error opening plot data storage file."); wr_command(pls, (U_CHAR) BOP); plbuf_state(pls, PLSTATE_COLOR0); plbuf_state(pls, PLSTATE_WIDTH); }
static void plm_fill(PLStream *pls) { PLmDev *dev = (PLmDev *) pls->dev; dbug_enter("plm_fill"); plm_wr( pdf_wr_2bytes(pls->pdfs, (U_SHORT) pls->dev_npts) ); plm_wr( pdf_wr_2nbytes(pls->pdfs, (U_SHORT *) pls->dev_x, pls->dev_npts) ); plm_wr( pdf_wr_2nbytes(pls->pdfs, (U_SHORT *) pls->dev_y, pls->dev_npts) ); dev->xold = PL_UNDEFINED; dev->yold = PL_UNDEFINED; }
void plbuf_state(PLStream *pls, PLINT op) { dbug_enter("plbuf_state"); wr_command(pls, (U_CHAR) CHANGE_STATE); wr_command(pls, (U_CHAR) op); switch (op) { case PLSTATE_WIDTH: { U_CHAR width = pls->width; fwrite(&width, sizeof(U_CHAR), 1, pls->plbufFile); break; } case PLSTATE_COLOR0: { U_CHAR icol0 = pls->icol0; U_CHAR r = pls->curcolor.r; U_CHAR g = pls->curcolor.g; U_CHAR b = pls->curcolor.b; fwrite(&icol0, sizeof(U_CHAR), 1, pls->plbufFile); if (icol0 == PL_RGB_COLOR) { fwrite(&r, sizeof(U_CHAR), 1, pls->plbufFile); fwrite(&g, sizeof(U_CHAR), 1, pls->plbufFile); fwrite(&b, sizeof(U_CHAR), 1, pls->plbufFile); } break; } case PLSTATE_COLOR1: { U_CHAR icol1 = pls->icol1; fwrite(&icol1, sizeof(U_CHAR), 1, pls->plbufFile); break; } case PLSTATE_FILL:{ signed char patt = pls->patt; fwrite(&patt, sizeof(signed char), 1, pls->plbufFile); break; } } }