From: Bryan Henderson Date: Fri, 27 Dec 1996 22:57:51 +0000 (+0000) Subject: Add asserts to check for file descriptor ring corruption. X-Git-Tag: REL6_1~830 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=634b38aa864459d00baed8e2968e74747e63a134;p=postgresql Add asserts to check for file descriptor ring corruption. --- diff --git a/src/backend/storage/file/fd.c b/src/backend/storage/file/fd.c index d02ffcf19f..45c1dd7cff 100644 --- a/src/backend/storage/file/fd.c +++ b/src/backend/storage/file/fd.c @@ -6,7 +6,7 @@ * Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Id: fd.c,v 1.10 1996/12/04 03:05:58 bryanh Exp $ + * $Id: fd.c,v 1.11 1996/12/27 22:57:51 bryanh Exp $ * * NOTES: * @@ -48,7 +48,7 @@ #include #include "postgres.h" -#include "miscadmin.h" /* for DataDir */ +#include "miscadmin.h" /* for DataDir */ #include "utils/palloc.h" #include "storage/fd.h" @@ -81,7 +81,7 @@ * equivalent, the OS must still open several files to perform the * dynamic loading. Keep this here.) */ -#define RESERVE_FOR_LD 10 +#define RESERVE_FOR_LD 10 /* * If we are using weird storage managers, we may need to keep real @@ -93,10 +93,10 @@ * these descriptors at whim, we must make allowances for them. */ #ifdef HP_JUKEBOX -#define RESERVE_FOR_JB 25 -#define MAXFILES ((NOFILE - RESERVE_FOR_LD) - RESERVE_FOR_JB) +#define RESERVE_FOR_JB 25 +#define MAXFILES ((NOFILE - RESERVE_FOR_LD) - RESERVE_FOR_JB) #else /* HP_JUKEBOX */ -#define MAXFILES (NOFILE - RESERVE_FOR_LD) +#define MAXFILES (NOFILE - RESERVE_FOR_LD) #endif /* HP_JUKEBOX */ /* Debugging.... */ @@ -115,36 +115,36 @@ #define FileIsNotOpen(file) (VfdCache[file].fd == VFD_CLOSED) typedef struct vfd { - signed short fd; - unsigned short fdstate; - -#define FD_DIRTY (1 << 0) - - File nextFree; - File lruMoreRecently; - File lruLessRecently; - long seekPos; - char *fileName; - int fileFlags; - int fileMode; + signed short fd; + unsigned short fdstate; + +#define FD_DIRTY (1 << 0) + + File nextFree; + File lruMoreRecently; + File lruLessRecently; + long seekPos; + char *fileName; + int fileFlags; + int fileMode; } Vfd; /* * Virtual File Descriptor array pointer and size. This grows as * needed. */ -static Vfd *VfdCache; -static Size SizeVfdCache = 0; +static Vfd *VfdCache; +static Size SizeVfdCache = 0; /* * Minimum number of file descriptors known to be free. */ -static int FreeFd = 0; +static int FreeFd = 0; /* * Number of file descriptors known to be open. */ -static int nfile = 0; +static int nfile = 0; /* * we use the name of the null device in various places, mostly so @@ -162,14 +162,16 @@ static char Sep_char = '\\'; /* * Private Routines * - * Delete - delete a file from the Lru ring - * LruDelete - remove a file from the Lru ring and close - * Insert - put a file at the front of the Lru ring - * LruInsert - put a file at the front of the Lru ring and open + * Delete - delete a file from the Lru ring + * LruDelete - remove a file from the Lru ring and close + * Insert - put a file at the front of the Lru ring + * LruInsert - put a file at the front of the Lru ring and open * AssertLruRoom - make sure that there is a free fd. * * the Last Recently Used ring is a doubly linked list that begins and - * ends on element zero. + * ends on element zero. Element zero is special -- it doesn't represent + * a file and its "fd" field always == VFD_CLOSED. Element zero is just an + * anchor that shows us the beginning/end of the ring. * * example: * @@ -180,8 +182,8 @@ static char Sep_char = '\\'; * \\less--> MostRecentlyUsedFile <---/ | * \more---/ \--less--/ * - * AllocateVfd - grab a free (or new) file record (from VfdArray) - * FreeVfd - free a file record + * AllocateVfd - grab a free (or new) file record (from VfdArray) + * FreeVfd - free a file record * */ static void Delete(File file); @@ -213,11 +215,11 @@ _dump_lru() printf("MOST %d ", mru); while (mru != 0) - { - mru = vfdP->lruLessRecently; - vfdP = &VfdCache[mru]; - printf("%d ", mru); - } + { + mru = vfdP->lruLessRecently; + vfdP = &VfdCache[mru]; + printf("%d ", mru); + } printf("LEAST\n"); } #endif /* FDDEBUG */ @@ -225,10 +227,10 @@ _dump_lru() static void Delete(File file) { - Vfd *fileP; + Vfd *fileP; - DO_DB(printf("DEBUG: Delete %d (%s)\n", - file, VfdCache[file].fileName)); + DO_DB(printf("DEBUG: Delete %d (%s)\n", + file, VfdCache[file].fileName)); DO_DB(_dump_lru()); Assert(file != 0); @@ -236,9 +238,9 @@ Delete(File file) fileP = &VfdCache[file]; VfdCache[fileP->lruLessRecently].lruMoreRecently = - VfdCache[file].lruMoreRecently; + VfdCache[file].lruMoreRecently; VfdCache[fileP->lruMoreRecently].lruLessRecently = - VfdCache[file].lruLessRecently; + VfdCache[file].lruLessRecently; DO_DB(_dump_lru()); } @@ -247,10 +249,10 @@ static void LruDelete(File file) { Vfd *fileP; - int returnValue; + int returnValue; - DO_DB(printf("DEBUG: LruDelete %d (%s)\n", - file, VfdCache[file].fileName)); + DO_DB(printf("DEBUG: LruDelete %d (%s)\n", + file, VfdCache[file].fileName)); Assert(file != 0); @@ -265,9 +267,9 @@ LruDelete(File file) /* if we have written to the file, sync it */ if (fileP->fdstate & FD_DIRTY) { - returnValue = fsync(fileP->fd); - Assert(returnValue != -1); - fileP->fdstate &= ~FD_DIRTY; + returnValue = fsync(fileP->fd); + Assert(returnValue != -1); + fileP->fdstate &= ~FD_DIRTY; } /* close the file */ @@ -284,10 +286,10 @@ LruDelete(File file) static void Insert(File file) { - Vfd *vfdP; + Vfd *vfdP; - DO_DB(printf("DEBUG: Insert %d (%s)\n", - file, VfdCache[file].fileName)); + DO_DB(printf("DEBUG: Insert %d (%s)\n", + file, VfdCache[file].fileName)); DO_DB(_dump_lru()); vfdP = &VfdCache[file]; @@ -303,58 +305,58 @@ Insert(File file) static int LruInsert (File file) { - Vfd *vfdP; - int returnValue; + Vfd *vfdP; + int returnValue; - DO_DB(printf("DEBUG: LruInsert %d (%s)\n", - file, VfdCache[file].fileName)); + DO_DB(printf("DEBUG: LruInsert %d (%s)\n", + file, VfdCache[file].fileName)); vfdP = &VfdCache[file]; if (FileIsNotOpen(file)) { - int tmpfd; - + int tmpfd; + /* - * Note, we check to see if there's a free file descriptor - * before attempting to open a file. One general way to do - * this is to try to open the null device which everybody - * should be able to open all the time. If this fails, we - * assume this is because there's no free file descriptors. - */ + * Note, we check to see if there's a free file descriptor + * before attempting to open a file. One general way to do + * this is to try to open the null device which everybody + * should be able to open all the time. If this fails, we + * assume this is because there's no free file descriptors. + */ tryAgain: - tmpfd = open(Nulldev, O_CREAT|O_RDWR, 0666); - if (tmpfd < 0) { - FreeFd = 0; - errno = 0; - AssertLruRoom(); - goto tryAgain; - } else { - close(tmpfd); - } - vfdP->fd = open(vfdP->fileName,vfdP->fileFlags,vfdP->fileMode); - - if (vfdP->fd < 0) { - DO_DB(printf("RE_OPEN FAILED: %d\n", - errno)); - return (vfdP->fd); - } else { - DO_DB(printf("RE_OPEN SUCCESS\n")); - ++nfile; - } - - /* seek to the right position */ - if (vfdP->seekPos != 0L) { - returnValue = - lseek(vfdP->fd, vfdP->seekPos, SEEK_SET); - Assert(returnValue != -1); - } - - /* init state on open */ - vfdP->fdstate = 0x0; - - /* note that a file descriptor has been used up */ - if (FreeFd > 0) - FreeFd--; + tmpfd = open(Nulldev, O_CREAT|O_RDWR, 0666); + if (tmpfd < 0) { + FreeFd = 0; + errno = 0; + AssertLruRoom(); + goto tryAgain; + } else { + close(tmpfd); + } + vfdP->fd = open(vfdP->fileName,vfdP->fileFlags,vfdP->fileMode); + + if (vfdP->fd < 0) { + DO_DB(printf("RE_OPEN FAILED: %d\n", + errno)); + return (vfdP->fd); + } else { + DO_DB(printf("RE_OPEN SUCCESS\n")); + ++nfile; + } + + /* seek to the right position */ + if (vfdP->seekPos != 0L) { + returnValue = + lseek(vfdP->fd, vfdP->seekPos, SEEK_SET); + Assert(returnValue != -1); + } + + /* init state on open */ + vfdP->fdstate = 0x0; + + /* note that a file descriptor has been used up */ + if (FreeFd > 0) + FreeFd--; } /* @@ -369,69 +371,73 @@ LruInsert (File file) static void AssertLruRoom() { - DO_DB(printf("DEBUG: AssertLruRoom (FreeFd = %d)\n", - FreeFd)); + DO_DB(printf("DEBUG: AssertLruRoom (FreeFd = %d)\n", + FreeFd)); if (FreeFd <= 0 || nfile >= MAXFILES) { - LruDelete(VfdCache[0].lruMoreRecently); + /* We supposedly are using more vfds than we want to be. First + assert that there is at least one used vfd in the ring. + */ + Assert(VfdCache[0].lruMoreRecently ! 0); + LruDelete(VfdCache[0].lruMoreRecently); } } static File AllocateVfd() { - Index i; - File file; + Index i; + File file; - DO_DB(printf("DEBUG: AllocateVfd\n")); + DO_DB(printf("DEBUG: AllocateVfd\n")); if (SizeVfdCache == 0) { - - /* initialize */ - VfdCache = (Vfd *)malloc(sizeof(Vfd)); - - VfdCache->nextFree = 0; - VfdCache->lruMoreRecently = 0; - VfdCache->lruLessRecently = 0; - VfdCache->fd = VFD_CLOSED; - VfdCache->fdstate = 0x0; - - SizeVfdCache = 1; + + /* initialize */ + VfdCache = (Vfd *)malloc(sizeof(Vfd)); + + VfdCache->nextFree = 0; + VfdCache->lruMoreRecently = 0; + VfdCache->lruLessRecently = 0; + VfdCache->fd = VFD_CLOSED; + VfdCache->fdstate = 0x0; + + SizeVfdCache = 1; } if (VfdCache[0].nextFree == 0) { - - /* - * The free list is empty so it is time to increase the - * size of the array - */ - - VfdCache =(Vfd *)realloc(VfdCache, sizeof(Vfd)*SizeVfdCache*2); - Assert(VfdCache != NULL); - - /* - * Set up the free list for the new entries - */ - - for (i = SizeVfdCache; i < 2*SizeVfdCache; i++) { - memset((char *) &(VfdCache[i]), 0, sizeof(VfdCache[0])); - VfdCache[i].nextFree = i+1; - VfdCache[i].fd = VFD_CLOSED; - } - - /* - * Element 0 is the first and last element of the free - * list - */ - - VfdCache[0].nextFree = SizeVfdCache; - VfdCache[2*SizeVfdCache-1].nextFree = 0; - - /* - * Record the new size - */ - - SizeVfdCache *= 2; + + /* + * The free list is empty so it is time to increase the + * size of the array + */ + + VfdCache =(Vfd *)realloc(VfdCache, sizeof(Vfd)*SizeVfdCache*2); + Assert(VfdCache != NULL); + + /* + * Set up the free list for the new entries + */ + + for (i = SizeVfdCache; i < 2*SizeVfdCache; i++) { + memset((char *) &(VfdCache[i]), 0, sizeof(VfdCache[0])); + VfdCache[i].nextFree = i+1; + VfdCache[i].fd = VFD_CLOSED; + } + + /* + * Element 0 is the first and last element of the free + * list + */ + + VfdCache[0].nextFree = SizeVfdCache; + VfdCache[2*SizeVfdCache-1].nextFree = 0; + + /* + * Record the new size + */ + + SizeVfdCache *= 2; } file = VfdCache[0].nextFree; @@ -444,7 +450,7 @@ static void FreeVfd(File file) { DO_DB(printf("DB: FreeVfd: %d (%s)\n", - file, VfdCache[file].fileName)); + file, VfdCache[file].fileName)); VfdCache[file].nextFree = VfdCache[0].nextFree; VfdCache[0].nextFree = file; @@ -461,19 +467,19 @@ filepath(char *filename) if (*filename != Sep_char) { #else if (!(filename[1] == ':' && filename[2] == Sep_char)) { -#endif /* WIN32 */ +#endif /* WIN32 */ - /* Either /base/ or \base\ */ - sprintf(basename, "%cbase%c", Sep_char, Sep_char); + /* Either /base/ or \base\ */ + sprintf(basename, "%cbase%c", Sep_char, Sep_char); - len = strlen(DataDir) + strlen(basename) + strlen(GetDatabaseName()) - + strlen(filename) + 2; - buf = (char*) palloc(len); - sprintf(buf, "%s%s%s%c%s", - DataDir, basename, GetDatabaseName(), Sep_char, filename); + len = strlen(DataDir) + strlen(basename) + strlen(GetDatabaseName()) + + strlen(filename) + 2; + buf = (char*) palloc(len); + sprintf(buf, "%s%s%s%c%s", + DataDir, basename, GetDatabaseName(), Sep_char, filename); } else { - buf = (char *) palloc(strlen(filename) + 1); - strcpy(buf, filename); + buf = (char *) palloc(strlen(filename) + 1); + strcpy(buf, filename); } return(buf); @@ -482,10 +488,10 @@ filepath(char *filename) static int FileAccess(File file) { - int returnValue; + int returnValue; DO_DB(printf("DB: FileAccess %d (%s)\n", - file, VfdCache[file].fileName)); + file, VfdCache[file].fileName)); /* * Is the file open? If not, close the least recently used, @@ -493,23 +499,23 @@ FileAccess(File file) */ if (FileIsNotOpen(file)) { - - AssertLruRoom(); - - returnValue = LruInsert(file); - if (returnValue != 0) - return returnValue; - + + AssertLruRoom(); + + returnValue = LruInsert(file); + if (returnValue != 0) + return returnValue; + } else { - - /* - * We now know that the file is open and that it is not the - * last one accessed, so we need to more it to the head of - * the Lru ring. - */ - - Delete(file); - Insert(file); + + /* + * We now know that the file is open and that it is not the + * last one accessed, so we need to more it to the head of + * the Lru ring. + */ + + Delete(file); + Insert(file); } return (0); @@ -521,44 +527,45 @@ FileAccess(File file) void FileInvalidate(File file) { + Assert(file > 0); if (!FileIsNotOpen(file)) { - LruDelete(file); + LruDelete(file); } } /* VARARGS2 */ static File fileNameOpenFile(FileName fileName, - int fileFlags, - int fileMode) + int fileFlags, + int fileMode) { static int osRanOut = 0; - File file; - Vfd *vfdP; + File file; + Vfd *vfdP; int tmpfd; DO_DB(printf("DEBUG: FileNameOpenFile: %s %x %o\n", - fileName, fileFlags, fileMode)); + fileName, fileFlags, fileMode)); file = AllocateVfd(); vfdP = &VfdCache[file]; if (nfile >= MAXFILES || (FreeFd == 0 && osRanOut)) { - AssertLruRoom(); + AssertLruRoom(); } tryAgain: tmpfd = open(Nulldev, O_CREAT|O_RDWR, 0666); if (tmpfd < 0) { - DO_DB(printf("DB: not enough descs, retry, er= %d\n", - errno)); - errno = 0; - FreeFd = 0; - osRanOut = 1; - AssertLruRoom(); - goto tryAgain; + DO_DB(printf("DB: not enough descs, retry, er= %d\n", + errno)); + errno = 0; + FreeFd = 0; + osRanOut = 1; + AssertLruRoom(); + goto tryAgain; } else { - close(tmpfd); + close(tmpfd); } #ifdef WIN32 @@ -568,17 +575,17 @@ fileNameOpenFile(FileName fileName, vfdP->fdstate = 0x0; if (vfdP->fd < 0) { - FreeVfd(file); - return -1; + FreeVfd(file); + return -1; } ++nfile; DO_DB(printf("DB: FNOF success %d\n", - vfdP->fd)); + vfdP->fd)); (void)LruInsert(file); if (fileName==NULL) { - elog(WARN, "fileNameOpenFile: NULL fname"); + elog(WARN, "fileNameOpenFile: NULL fname"); } vfdP->fileName = malloc(strlen(fileName)+1); strcpy(vfdP->fileName,fileName); @@ -617,32 +624,32 @@ PathNameOpenFile(FileName fileName, int fileFlags, int fileMode) void FileClose(File file) { - int returnValue; + int returnValue; DO_DB(printf("DEBUG: FileClose: %d (%s)\n", - file, VfdCache[file].fileName)); + file, VfdCache[file].fileName)); if (!FileIsNotOpen(file)) { - - /* remove the file from the lru ring */ - Delete(file); - - /* record the new free operating system file descriptor */ - FreeFd++; - - /* if we did any writes, sync the file before closing */ - if (VfdCache[file].fdstate & FD_DIRTY) { - returnValue = fsync(VfdCache[file].fd); - Assert(returnValue != -1); - VfdCache[file].fdstate &= ~FD_DIRTY; - } - - /* close the file */ - returnValue = close(VfdCache[file].fd); - Assert(returnValue != -1); - - --nfile; - VfdCache[file].fd = VFD_CLOSED; + + /* remove the file from the lru ring */ + Delete(file); + + /* record the new free operating system file descriptor */ + FreeFd++; + + /* if we did any writes, sync the file before closing */ + if (VfdCache[file].fdstate & FD_DIRTY) { + returnValue = fsync(VfdCache[file].fd); + Assert(returnValue != -1); + VfdCache[file].fdstate &= ~FD_DIRTY; + } + + /* close the file */ + returnValue = close(VfdCache[file].fd); + Assert(returnValue != -1); + + --nfile; + VfdCache[file].fd = VFD_CLOSED; } /* * Add the Vfd slot to the free list @@ -660,29 +667,29 @@ FileUnlink(File file) int returnValue; DO_DB(printf("DB: FileClose: %d (%s)\n", - file, VfdCache[file].fileName)); + file, VfdCache[file].fileName)); if (!FileIsNotOpen(file)) { - - /* remove the file from the lru ring */ - Delete(file); - - /* record the new free operating system file descriptor */ - FreeFd++; - - /* if we did any writes, sync the file before closing */ - if (VfdCache[file].fdstate & FD_DIRTY) { - returnValue = fsync(VfdCache[file].fd); - Assert(returnValue != -1); - VfdCache[file].fdstate &= ~FD_DIRTY; - } - - /* close the file */ - returnValue = close(VfdCache[file].fd); - Assert(returnValue != -1); - - --nfile; - VfdCache[file].fd = VFD_CLOSED; + + /* remove the file from the lru ring */ + Delete(file); + + /* record the new free operating system file descriptor */ + FreeFd++; + + /* if we did any writes, sync the file before closing */ + if (VfdCache[file].fdstate & FD_DIRTY) { + returnValue = fsync(VfdCache[file].fd); + Assert(returnValue != -1); + VfdCache[file].fdstate &= ~FD_DIRTY; + } + + /* close the file */ + returnValue = close(VfdCache[file].fd); + Assert(returnValue != -1); + + --nfile; + VfdCache[file].fd = VFD_CLOSED; } /* add the Vfd slot to the free list */ FreeVfd(file); @@ -695,15 +702,15 @@ FileUnlink(File file) int FileRead(File file, char *buffer, int amount) { - int returnCode; + int returnCode; DO_DB(printf("DEBUG: FileRead: %d (%s) %d 0x%x\n", - file, VfdCache[file].fileName, amount, buffer)); + file, VfdCache[file].fileName, amount, buffer)); FileAccess(file); returnCode = read(VfdCache[file].fd, buffer, amount); if (returnCode > 0) { - VfdCache[file].seekPos += returnCode; + VfdCache[file].seekPos += returnCode; } return returnCode; @@ -712,15 +719,15 @@ FileRead(File file, char *buffer, int amount) int FileWrite(File file, char *buffer, int amount) { - int returnCode; + int returnCode; DO_DB(printf("DB: FileWrite: %d (%s) %d 0x%lx\n", - file, VfdCache[file].fileName, amount, buffer)); + file, VfdCache[file].fileName, amount, buffer)); FileAccess(file); returnCode = write(VfdCache[file].fd, buffer, amount); if (returnCode > 0) { /* changed by Boris with Mao's advice */ - VfdCache[file].seekPos += returnCode; + VfdCache[file].seekPos += returnCode; } /* record the write */ @@ -732,32 +739,32 @@ FileWrite(File file, char *buffer, int amount) long FileSeek(File file, long offset, int whence) { - int returnCode; + int returnCode; DO_DB(printf("DEBUG: FileSeek: %d (%s) %d %d\n", - file, VfdCache[file].fileName, offset, whence)); + file, VfdCache[file].fileName, offset, whence)); if (FileIsNotOpen(file)) { - switch(whence) { - case SEEK_SET: - VfdCache[file].seekPos = offset; - return offset; - case SEEK_CUR: - VfdCache[file].seekPos = VfdCache[file].seekPos +offset; - return VfdCache[file].seekPos; - case SEEK_END: - FileAccess(file); - returnCode = VfdCache[file].seekPos = - lseek(VfdCache[file].fd, offset, whence); - return returnCode; - default: - elog(WARN, "FileSeek: invalid whence: %d", whence); - break; - } + switch(whence) { + case SEEK_SET: + VfdCache[file].seekPos = offset; + return offset; + case SEEK_CUR: + VfdCache[file].seekPos = VfdCache[file].seekPos +offset; + return VfdCache[file].seekPos; + case SEEK_END: + FileAccess(file); + returnCode = VfdCache[file].seekPos = + lseek(VfdCache[file].fd, offset, whence); + return returnCode; + default: + elog(WARN, "FileSeek: invalid whence: %d", whence); + break; + } } else { - returnCode = VfdCache[file].seekPos = - lseek(VfdCache[file].fd, offset, whence); - return returnCode; + returnCode = VfdCache[file].seekPos = + lseek(VfdCache[file].fd, offset, whence); + return returnCode; } /*NOTREACHED*/ return(-1L); @@ -770,7 +777,7 @@ long FileTell(File file) { DO_DB(printf("DEBUG: FileTell %d (%s)\n", - file, VfdCache[file].fileName)); + file, VfdCache[file].fileName)); return VfdCache[file].seekPos; } @@ -780,7 +787,7 @@ FileTruncate(File file, int offset) int returnCode; DO_DB(printf("DEBUG: FileTruncate %d (%s)\n", - file, VfdCache[file].fileName)); + file, VfdCache[file].fileName)); (void) FileSync(file); (void) FileAccess(file); @@ -791,7 +798,7 @@ FileTruncate(File file, int offset) int FileSync(File file) { - int returnCode; + int returnCode; /* * If the file isn't open, then we don't need to sync it; we @@ -801,10 +808,10 @@ FileSync(File file) */ if (VfdCache[file].fd < 0 || !(VfdCache[file].fdstate & FD_DIRTY)) { - returnCode = 0; + returnCode = 0; } else { - returnCode = fsync(VfdCache[file].fd); - VfdCache[file].fdstate &= ~FD_DIRTY; + returnCode = fsync(VfdCache[file].fd); + VfdCache[file].fdstate &= ~FD_DIRTY; } return returnCode; @@ -840,24 +847,24 @@ AllocateFile() int fdleft; while ((fd = open(Nulldev,O_WRONLY,0)) < 0) { - if (errno == EMFILE) { - errno = 0; - FreeFd = 0; - AssertLruRoom(); - } else { - elog(WARN,"Open: %s in %s line %d\n", Nulldev, - __FILE__, __LINE__); - } + if (errno == EMFILE) { + errno = 0; + FreeFd = 0; + AssertLruRoom(); + } else { + elog(WARN,"Open: %s in %s line %d\n", Nulldev, + __FILE__, __LINE__); + } } close(fd); ++allocatedFiles; fdleft = MAXFILES - allocatedFiles; if (fdleft < 6) { - elog(DEBUG,"warning: few usable file descriptors left (%d)", fdleft); + elog(DEBUG,"warning: few usable file descriptors left (%d)", fdleft); } DO_DB(printf("DEBUG: AllocatedFile. FreeFd = %d\n", - FreeFd)); + FreeFd)); } /* @@ -868,9 +875,9 @@ void FreeFile() { DO_DB(printf("DEBUG: FreeFile. FreeFd now %d\n", - FreeFd)); + FreeFd)); FreeFd++; - nfile++; /* dangerous */ + nfile++; /* dangerous */ Assert(allocatedFiles > 0); --allocatedFiles; } @@ -879,9 +886,10 @@ void closeAllVfds() { int i; - for (i=0; i