int64
FileSeek(File file, int64 offset, int whence)
{
int returnCode;
Assert(FileIsValid(file));
DO_DB(elog(LOG, "FileSeek: %d (%s) " INT64_FORMAT " " INT64_FORMAT " %d",
file, VfdCache[file].fileName,
VfdCache[file].seekPos, offset, whence));
if (FileIsNotOpen(file))
{
switch (whence)
{
case SEEK_SET:
Assert(offset >= INT64CONST(0));
VfdCache[file].seekPos = offset;
break;
case SEEK_CUR:
VfdCache[file].seekPos += offset;
break;
case SEEK_END:
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
VfdCache[file].seekPos = pg_lseek64(VfdCache[file].fd,
offset, whence);
break;
default:
Assert(!"invalid whence");
break;
}
}
else
{
switch (whence)
{
case SEEK_SET:
Assert(offset >= INT64CONST(0));
if (VfdCache[file].seekPos != offset)
VfdCache[file].seekPos = pg_lseek64(VfdCache[file].fd,
offset, whence);
break;
case SEEK_CUR:
if (offset != 0 || VfdCache[file].seekPos == FileUnknownPos)
VfdCache[file].seekPos = pg_lseek64(VfdCache[file].fd,
offset, whence);
break;
case SEEK_END:
VfdCache[file].seekPos = pg_lseek64(VfdCache[file].fd,
offset, whence);
break;
default:
Assert(!"invalid whence");
break;
}
}
return VfdCache[file].seekPos;
}
int
FileTruncate(File file, int64 offset)
{
int returnCode;
Assert(FileIsValid(file));
DO_DB(elog(LOG, "FileTruncate %d (%s)",
file, VfdCache[file].fileName));
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
/*
* Call ftruncate with a int64 value.
*
* WARNING:DO NOT typecast this down to a 32-bit long or
* append-only vacuum full adjustment of the eof will erroneously remove
* table data.
*/
returnCode = ftruncate(VfdCache[file].fd, offset);
/* Assume we don't know the file position anymore */
VfdCache[file].seekPos = FileUnknownPos;
return returnCode;
}
long
FileSeek(File file, long offset, int whence)
{
int returnCode;
DO_DB(printf("DEBUG: FileSeek: %d (%s) %d %d\n",
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;
}
} else {
returnCode = VfdCache[file].seekPos =
lseek(VfdCache[file].fd, offset, whence);
return returnCode;
}
/*NOTREACHED*/
return(-1L);
}
static void getNameAndVersion( const QString& str, const QString& lineStart, QString& fileName, QString& version )
{
if ( str.left( lineStart.length() )==lineStart && fileName.isEmpty() )
{
unsigned int pos = lineStart.length();
while ( pos<str.length() && (str[pos]==' ' || str[pos]=='\t') ) ++pos;
unsigned int pos2 = str.length()-1;
while ( pos2>pos )
{
while (pos2>pos && str[pos2]!=' ' && str[pos2]!='\t') --pos2;
fileName = str.mid( pos, pos2-pos );
std::cerr << "KDiff3: " << fileName.latin1() << std::endl;
if ( FileAccess(fileName).exists() ) break;
--pos2;
}
int vpos = str.findRev("\t", -1);
if ( vpos>0 && vpos>(int)pos2 )
{
version = str.mid( vpos+1 );
while( !version.right(1)[0].isLetterOrNumber() )
version.truncate( version.length()-1 );
}
}
}
int
FileRead(File file, char *buffer, int amount)
{
int returnCode;
Assert(FileIsValid(file));
DO_DB(elog(LOG, "FileRead: %d (%s) " INT64_FORMAT " %d %p",
file, VfdCache[file].fileName,
VfdCache[file].seekPos, amount, buffer));
if (Debug_filerep_print)
(elog(LOG, "FileRead: %d (%s) " INT64_FORMAT " %d %p",
file, VfdCache[file].fileName,
VfdCache[file].seekPos, amount, buffer));
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
retry:
returnCode = read(VfdCache[file].fd, buffer, amount);
if (returnCode >= 0)
VfdCache[file].seekPos += returnCode;
else
{
/*
* Windows may run out of kernel buffers and return "Insufficient
* system resources" error. Wait a bit and retry to solve it.
*
* It is rumored that EINTR is also possible on some Unix filesystems,
* in which case immediate retry is indicated.
*/
#ifdef WIN32
DWORD error = GetLastError();
switch (error)
{
case ERROR_NO_SYSTEM_RESOURCES:
pg_usleep(1000L);
errno = EINTR;
break;
default:
_dosmaperr(error);
break;
}
#endif
/* OK to retry if interrupted */
if (errno == EINTR)
goto retry;
/* Trouble, so assume we don't know the file position anymore */
VfdCache[file].seekPos = FileUnknownPos;
}
return returnCode;
}
HANDLE FileCreate(LPCTSTR FileName)
{
HANDLE hFile;
if (FileAccess( FileName, 0) == 0)
hFile = CreateFile( FileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, TRUNCATE_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
else
hFile = CreateFile( FileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
return hFile;
}
int
FileWrite(File file, char *buffer, int amount)
{
int returnCode;
Assert(FileIsValid(file));
DO_DB(elog(LOG, "FileWrite: %d (%s) %ld %d %p",
file, VfdCache[file].fileName,
VfdCache[file].seekPos, amount, buffer));
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
retry:
errno = 0;
returnCode = write(VfdCache[file].fd, buffer, amount);
/* if write didn't set errno, assume problem is no disk space */
if (returnCode != amount && errno == 0)
errno = ENOSPC;
if (returnCode >= 0)
VfdCache[file].seekPos += returnCode;
else
{
/*
* See comments in FileRead()
*/
#ifdef WIN32
DWORD error = GetLastError();
switch (error)
{
case ERROR_NO_SYSTEM_RESOURCES:
pg_usleep(1000L);
errno = EINTR;
break;
default:
_dosmaperr(error);
break;
}
#endif
/* OK to retry if interrupted */
if (errno == EINTR)
goto retry;
/* Trouble, so assume we don't know the file position anymore */
VfdCache[file].seekPos = FileUnknownPos;
}
return returnCode;
}
int
FileTruncate(File file, int offset)
{
int returnCode;
DO_DB(printf("DEBUG: FileTruncate %d (%s)\n",
file, VfdCache[file].fileName));
(void) FileSync(file);
(void) FileAccess(file);
returnCode = ftruncate(VfdCache[file].fd, offset);
return(returnCode);
}
/*
* Get the size of a physical file by using fstat()
*
* Returns size in bytes if successful, < 0 otherwise
*/
int64
FileDiskSize(File file)
{
int returnCode = 0;
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
struct stat buf;
returnCode = fstat(VfdCache[file].fd, &buf);
if (returnCode < 0)
return returnCode;
return (int64) buf.st_size;
}
int
FileRead(File file, char *buffer, int amount)
{
int returnCode;
DO_DB(printf("DEBUG: FileRead: %d (%s) %d 0x%x\n",
file, VfdCache[file].fileName, amount, buffer));
FileAccess(file);
returnCode = read(VfdCache[file].fd, buffer, amount);
if (returnCode > 0) {
VfdCache[file].seekPos += returnCode;
}
return returnCode;
}
int
FileSync(File file)
{
int returnCode;
Assert(FileIsValid(file));
DO_DB(elog(LOG, "FileSync: %d (%s)",
file, VfdCache[file].fileName));
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
return pg_fsync(VfdCache[file].fd);
}
int64
FileNonVirtualCurSeek(File file)
{
int returnCode;
Assert(FileIsValid(file));
DO_DB(elog(LOG, "FileNonVirtualCurSeek: %d (%s) virtual position" INT64_FORMAT,
file, VfdCache[file].fileName,
VfdCache[file].seekPos));
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
return pg_lseek64(VfdCache[file].fd, 0, SEEK_CUR);
}
int
FileTruncate(File file, long offset)
{
int returnCode;
Assert(FileIsValid(file));
DO_DB(elog(LOG, "FileTruncate %d (%s)",
file, VfdCache[file].fileName));
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
returnCode = ftruncate(VfdCache[file].fd, (size_t) offset);
return returnCode;
}
int
FileSync(File file)
{
int returnCode;
FileRepGpmonRecord_s gpmonRecord;
FileRepGpmonStatType_e whichStat;
if (fileRepRole == FileRepPrimaryRole)
{
whichStat = FileRepGpmonStatType_PrimaryFsyncSyscall;
FileRepGpmonStat_OpenRecord(whichStat, &gpmonRecord);
} else
{
whichStat = FileRepGpmonStatType_MirrorFsyncSyscall;
FileRepGpmonStat_OpenRecord(whichStat, &gpmonRecord);
}
Assert(FileIsValid(file));
DO_DB(elog(LOG, "FileSync: %d (%s)",
file, VfdCache[file].fileName));
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
#ifdef FAULT_INJECTOR
FaultInjector_InjectFaultIfSet(
FileRepFlush,
DDLNotSpecified,
"", //databaseName
""); // tableName
#endif
returnCode = pg_fsync(VfdCache[file].fd);
if (returnCode >= 0)
{
//only include stats if successful
if ((fileRepRole == FileRepPrimaryRole) ||
(fileRepRole == FileRepMirrorRole))
{
FileRepGpmonStat_CloseRecord(whichStat, &gpmonRecord);
}
}
return returnCode;
}
int
FileWrite(File file, char *buffer, int amount)
{
int returnCode;
DO_DB(printf("DB: FileWrite: %d (%s) %d 0x%lx\n",
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;
}
/* record the write */
VfdCache[file].fdstate |= FD_DIRTY;
return returnCode;
}
long
FileSeek(File file, long offset, int whence)
{
int returnCode;
Assert(FileIsValid(file));
DO_DB(elog(LOG, "FileSeek: %d (%s) %ld %ld %d",
file, VfdCache[file].fileName,
VfdCache[file].seekPos, offset, whence));
if (FileIsNotOpen(file))
{
switch (whence)
{
case SEEK_SET:
if (offset < 0)
elog(ERROR, "invalid seek offset: %ld", offset);
VfdCache[file].seekPos = offset;
break;
case SEEK_CUR:
VfdCache[file].seekPos += offset;
break;
case SEEK_END:
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
VfdCache[file].seekPos = lseek(VfdCache[file].fd,
offset, whence);
break;
default:
elog(ERROR, "invalid whence: %d", whence);
break;
}
}
else
{
switch (whence)
{
case SEEK_SET:
if (offset < 0)
elog(ERROR, "invalid seek offset: %ld", offset);
if (VfdCache[file].seekPos != offset)
VfdCache[file].seekPos = lseek(VfdCache[file].fd,
offset, whence);
break;
case SEEK_CUR:
if (offset != 0 || VfdCache[file].seekPos == FileUnknownPos)
VfdCache[file].seekPos = lseek(VfdCache[file].fd,
offset, whence);
break;
case SEEK_END:
VfdCache[file].seekPos = lseek(VfdCache[file].fd,
offset, whence);
break;
default:
elog(ERROR, "invalid whence: %d", whence);
break;
}
}
return VfdCache[file].seekPos;
}
int
FileWrite(File file, char *buffer, int amount)
{
int returnCode;
FileRepGpmonRecord_s gpmonRecord;
FileRepGpmonStatType_e whichStat =0;
if (fileRepRole == FileRepPrimaryRole)
{
whichStat = FileRepGpmonStatType_PrimaryWriteSyscall;
FileRepGpmonStat_OpenRecord(whichStat, &gpmonRecord);
gpmonRecord.size = amount;
} else if (fileRepRole == FileRepMirrorRole)
{
whichStat = FileRepGpmonStatType_MirrorWriteSyscall;
FileRepGpmonStat_OpenRecord(whichStat, &gpmonRecord);
gpmonRecord.size = amount;
}
Assert(FileIsValid(file));
DO_DB(elog(LOG, "FileWrite: %d (%s) " INT64_FORMAT " %d %p",
file, VfdCache[file].fileName,
VfdCache[file].seekPos, amount, buffer));
/* Added temporary for troubleshooting */
if (Debug_filerep_print)
elog(LOG, "FileWrite: %d (%s) " INT64_FORMAT " %d %p",
file, VfdCache[file].fileName,
VfdCache[file].seekPos, amount, buffer);
else
FileRep_InsertLogEntry(
"FileWrite",
FileRep_GetFlatFileIdentifier(VfdCache[file].fileName, ""),
FileRepRelationTypeFlatFile,
FileRepOperationWrite,
FILEREP_UNDEFINED,
FILEREP_UNDEFINED,
FileRepAckStateNotInitialized,
VfdCache[file].seekPos,
amount);
returnCode = FileAccess(file);
if (returnCode < 0)
return returnCode;
#ifdef FAULT_INJECTOR
if (! strcmp(VfdCache[file].fileName, "global/pg_control"))
{
if (FaultInjector_InjectFaultIfSet(
PgControl,
DDLNotSpecified,
"" /* databaseName */,
"" /* tableName */) == FaultInjectorTypeDataCorruption)
{
MemSet(buffer, 0, amount);
}
}
if (strstr(VfdCache[file].fileName, "pg_xlog/"))
{
if (FaultInjector_InjectFaultIfSet(
PgXlog,
DDLNotSpecified,
"" /* databaseName */,
"" /* tableName */) == FaultInjectorTypeDataCorruption)
{
MemSet(buffer, 0, amount);
}
}
#endif
retry:
errno = 0;
returnCode = write(VfdCache[file].fd, buffer, amount);
/* if write didn't set errno, assume problem is no disk space */
if (returnCode != amount && errno == 0)
errno = ENOSPC;
if (returnCode >= 0)
VfdCache[file].seekPos += returnCode;
else
{
/*
* See comments in FileRead()
*/
#ifdef WIN32
DWORD error = GetLastError();
switch (error)
{
case ERROR_NO_SYSTEM_RESOURCES:
pg_usleep(1000L);
errno = EINTR;
break;
default:
_dosmaperr(error);
break;
}
#endif
/* OK to retry if interrupted */
if (errno == EINTR)
goto retry;
/* Trouble, so assume we don't know the file position anymore */
VfdCache[file].seekPos = FileUnknownPos;
}
if (returnCode >= 0)
{
//only include stat if successful
if ((fileRepRole == FileRepPrimaryRole) ||
(fileRepRole == FileRepMirrorRole))
{
FileRepGpmonStat_CloseRecord(whichStat, &gpmonRecord);
}
}
return returnCode;
}
