自学教程：C++ FlushFileBuffers函数代码示例

void bt_mgrclose (BtMgr *mgr){BtPool *pool;uint slot;	// release mapped pages	//	note that slot zero is never used	for( slot = 1; slot < mgr->poolmax; slot++ ) {		pool = mgr->pool + slot;		if( pool->slot )#ifdef unix			munmap (pool->map, (mgr->poolmask+1) << mgr->page_bits);#else		{			FlushViewOfFile(pool->map, 0);			UnmapViewOfFile(pool->map);			CloseHandle(pool->hmap);		}#endif	}#ifdef unix	close (mgr->idx);	free (mgr->pool);	free (mgr->hash);	free (mgr->latch);	free (mgr->pooladvise);	free (mgr);#else	FlushFileBuffers(mgr->idx);	CloseHandle(mgr->idx);	GlobalFree (mgr->pool);	GlobalFree (mgr->hash);	GlobalFree (mgr->latch);	GlobalFree (mgr);#endif}

bool FileSystem::FlushDirBuffers(const char* filename, CString& errmsg){#ifdef WIN32	FILE* file = _wfopen(UtfPathToWidePath(filename), WString(FOPEN_RBP));#else	BString<1024> parentPath = filename;	char* p = (char*)strrchr(parentPath, PATH_SEPARATOR);	if (p)	{		*p = '/0';	}	FILE* file = fopen(parentPath, FOPEN_RB);#endif	if (!file)	{		errmsg = GetLastErrorMessage();		return false;	}	bool ok = FlushFileBuffers(fileno(file), errmsg);	fclose(file);	return ok;}

bool SendAck(HANDLE pipe){	DWORD written, ack = 0;	if (!WriteFile(pipe, &ack, sizeof(DWORD), &written, NULL) && written != sizeof(DWORD)) {#ifdef DEBUG_IPC		CUtils::Log(_T("SendAck: WriteFile failed. (%d)"), GetLastError());#endif		return false;	}	if (!FlushFileBuffers(pipe)) {#ifdef DEBUG_IPC		CUtils::Log(_T("SendAck: FlushFileBuffers failed. (%d)"), GetLastError());#endif		return false;	}	if (!DisconnectNamedPipe(pipe)) {#ifdef DEBUG_IPC		CUtils::Log(_T("SendAck: DisconnectNamedPipe failed. (%d)"), GetLastError());#endif		return false;	}	return true;}

/** * Flushes the file buffers, writing all data immediately. * @return Returns 1 on success, 0 on error.*/short LbFileFlush(TbFileHandle handle){#if defined(WIN32)  int result;  // Crappy Windows has its own  result = FlushFileBuffers((HANDLE)handle);  // It returns 'invalid handle' error sometimes for no reason.. so disabling this error  if (result != 0)      return 1;  result = GetLastError();  return ((result == 0) || (result == 6));#else#if defined(DOS)||defined(GO32)  // No idea how to do this on old systems  return 1;#else  // For normal POSIX systems  // (should also work on Win, as its IEEE standard... but it currently isn't)  return (ioctl(handle,I_FLUSH,FLUSHRW) != -1);#endif#endif}

bool PipeReader::CheckATR() {	//SectionLocker lock(dataSection);	if (pipe==NULL)		return false;	DWORD read=0;	DWORD command=1;	if (!WriteFile(pipe,&command,sizeof(DWORD),&read,NULL)) {		return false;	}	FlushFileBuffers(pipe);	DWORD size=0;	if (!ReadFile(pipe,&size,sizeof(DWORD),&read,NULL)) {		return false;	}	if (size==0)		return false;	BYTE ATR[100];	if (!ReadFile(pipe,ATR,size,&read,NULL)) {		return false;	}	return true;}

bool EtfArduinoService::SendMessage(LPVOID lpvMessage, DWORD bufferSize) {	if (hPipe == 0)		if (!OpenPipeConnection())			return false;	DWORD cbToWrite = bufferSize * sizeof(message_t);	DWORD cbWritten = 0;	BOOL fSuccess = WriteFile( 		hPipe,               // pipe handle 		lpvMessage,             // message 		cbToWrite,              // message length 		&cbWritten,             // bytes written 		NULL);                  // not overlapped 	// Make sure the message got through the pipe before returning.	FlushFileBuffers(hPipe);	if (!fSuccess) {		_tprintf(TEXT("WriteFile to pipe failed. GLE=%d/n"), GetLastError()); 		return false;	}	if (cbWritten != cbToWrite) {		return false;	}	return true;}

RS232_LIB unsigned intrs232_flush(struct rs232_port_t *p){	struct rs232_windows_t *wx = p->pt;	DBG("p=%p p->pt=%p/n", (void *)p, p->pt);	if (!rs232_port_open(p))		return RS232_ERR_PORT_CLOSED;	if (!FlushFileBuffers(wx->fd)) {		DBG("FlushFileBuffers() %s/n", last_error());		return RS232_ERR_FLUSH;	}	if (!PurgeComm(wx->fd, PURGE_TXABORT | PURGE_RXABORT |		       PURGE_TXCLEAR | PURGE_RXCLEAR)) {		DBG("PurgeComm() %s/n", last_error());		return RS232_ERR_FLUSH;	}	return RS232_ERR_NOERROR;}

void ADIOI_NTFS_Flush(ADIO_File fd, int *error_code){    int err;    static char myname[] = "ADIOI_NTFS_Flush";    err = (fd->access_mode & ADIO_RDONLY) ? TRUE :	FlushFileBuffers(fd->fd_sys);    /* --BEGIN ERROR HANDLING-- */    if (err == FALSE)    {    char errMsg[ADIOI_NTFS_ERR_MSG_MAX];	err = GetLastError();    ADIOI_NTFS_Strerror(err, errMsg, ADIOI_NTFS_ERR_MSG_MAX);	*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,					   myname, __LINE__, MPI_ERR_IO,					   "**io",					   "**io %s", errMsg);	return;    }    /* --END ERROR HANDLING-- */    *error_code = MPI_SUCCESS;}

int CTreeHandler::Dbg_DumpTree(){	HANDLE hfile;	int ret = 0;	CTreeElem* rootelem = 0;	int errcnt = 0;	hfile = CreateFile( (LPCTSTR)"dbgdump.txt", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS,		FILE_FLAG_SEQUENTIAL_SCAN, NULL );	if( hfile == INVALID_HANDLE_VALUE ){		return 1;	}		rootelem = (*this)( 0 );	if( rootelem ){		rootelem->Dbg_DumpReq( hfile, errcnt );		_ASSERT( !errcnt );		if( errcnt ){			DbgOut( "CTreeHandler : Dbg_DumpTree : Dbg_DumpReq error !!!/n" );			return 1;		}	}else{		DbgOut( "CTreeHandler : Dbg_DumpTree : rootelem error !!!/n" );		return 1;	}		FlushFileBuffers( hfile );	CloseHandle( hfile );		DbgOut( "CTreeHandler : DumpTree : CloseHandle/n" );	return ret;}

/* *---------------------------------------------------------------------- * * OS_IpcClose * *	OS IPC routine to close an IPC connection. * * Results: * * * Side effects: *      IPC connection is closed. * *---------------------------------------------------------------------- */int OS_IpcClose(int ipcFd, int shutdown){    if (ipcFd == -1) return 0;    /*     * Catch it if fd is a bogus value     */    ASSERT((ipcFd >= 0) && (ipcFd < WIN32_OPEN_MAX));    ASSERT(fdTable[ipcFd].type != FD_UNUSED);    switch (listenType)     {    case FD_PIPE_SYNC:	    /*	     * Make sure that the client (ie. a Web Server in this case) has	     * read all data from the pipe before we disconnect.	     */	    if (! FlushFileBuffers(fdTable[ipcFd].fid.fileHandle)) return -1;	    if (! DisconnectNamedPipe(fdTable[ipcFd].fid.fileHandle)) return -1;        /* fall through */    case FD_SOCKET_SYNC:	    OS_Close(ipcFd, shutdown);	    break;    case FD_UNUSED:    default:	    exit(106);	    break;    }    return 0; }

DWORDAPIENTRYBasepCrossVolumeMoveHelper(    LARGE_INTEGER TotalFileSize,    LARGE_INTEGER TotalBytesTransferred,    LARGE_INTEGER StreamSize,    LARGE_INTEGER StreamBytesTransferred,    DWORD dwStreamNumber,    DWORD dwCallbackReason,    HANDLE SourceFile,    HANDLE DestinationFile,    LPVOID lpData OPTIONAL    ){    PHELPER_CONTEXT Context = (PHELPER_CONTEXT)lpData;    if ( dwCallbackReason == CALLBACK_STREAM_SWITCH ) {#ifdef _CAIRO_        OBJECTID *poid;        if ( poid = Context->pObjectId ) {            RtlSetObjectId(DestinationFile, poid);            Context->pObjectId = NULL;            }#endif        if ( !(Context->dwFlags & MOVEFILE_WRITE_THROUGH) ) {            return PROGRESS_QUIET;            }        }    else if ( dwCallbackReason == CALLBACK_CHUNK_FINISHED ) {        if ( StreamBytesTransferred.QuadPart == StreamSize.QuadPart ) {            FlushFileBuffers(DestinationFile);            }        }    return PROGRESS_CONTINUE;}

void PackFile::closePakFile(void){	//清空所有打开的文件	while(!m_listStream.empty())	{		(*m_listStream.begin())->close();	}	//remove edit flag	if(m_fileHead.nEditFlag != 0)	{		m_fileHead.nEditFlag = 0;		writeFileHead();	}	//Close handle	if(m_hPakFile)	{		FlushFileBuffers(m_hPakFile);		CloseHandle(m_hPakFile); m_hPakFile = 0;	}	//清空Stream打开的文件句柄	FileHandleMap::iterator it;	for(it=m_mapFileHandle.begin(); it!=m_mapFileHandle.end(); it++)	{		::CloseHandle(it->second);	}	m_mapFileHandle.clear();	//清空表	memset(&m_fileHead, 0, sizeof(FILE_HEAD));	memset(m_hashTable, 0, sizeof(FILE_HASHNODE)*HASH_TABLE_SIZE);	m_blockTable.clear();	m_mapFreeBlock.clear();	m_bConst = true;}

/*----------------------------------------------------------------------------------------------	Flush the file's buffer. Since we are dealing with a file opened in director mode, we	just flush the buffer and ignore the grfCommitFlags.----------------------------------------------------------------------------------------------*/STDMETHODIMP FileStream::Commit(DWORD grfCommitFlags){	BEGIN_COM_METHOD;#if WIN32		// FlushFileBuffers may return an error if m_hfile doesn't have GENERIC_WRITE access.	if (!(m_grfstgm & (kfstgmReadWrite | kfstgmWrite)))		ThrowHr(WarnHr(STG_E_INVALIDFUNCTION));	if (!FlushFileBuffers(m_hfile))	{		// REVIEW JohnL: Should we check for medium full before returning this code?		ThrowHr(WarnHr(STG_E_MEDIUMFULL));	}#else	// FlushFileBuffers may return an error if m_hfile doesn't have GENERIC_WRITE access.	if (!(m_flags & (O_RDWR | O_WRONLY)))		ThrowHr(WarnHr(STG_E_INVALIDFUNCTION));	if (fsync(m_file))		return S_OK;#endif	END_COM_METHOD(g_fact, IID_IStream);}

bool SerialPort::openPort(const char *device, int baudrate, bool bXonXoff, int DTRtime){    close();    d->m_time	  = DTRtime;    d->m_baudrate = baudrate;    d->m_bXonXoff = bXonXoff;    string port; // = "////.//";    port += device;    port += ":";    d->hPort = CreateFileA(port.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);    if (d->hPort == INVALID_HANDLE_VALUE){        close();        log(L_WARN, "Can' open %s", port.c_str());        return false;    }    FlushFileBuffers(d->hPort);    if (!EscapeCommFunction(d->hPort, CLRDTR)){        close();        log(L_WARN, "Clear DTR error");        return false;    }    d->m_timer->start(d->m_time, true);    return true;}

ssize_t diag_tty_write(struct diag_l0_device *dl0d, const void *buf, const size_t count) {    DWORD byteswritten;    OVERLAPPED *pOverlap;    struct tty_int *wti = (struct tty_int *)dl0d->tty_int;    pOverlap=NULL;		//note : if overlap is eventually enabled, the CreateFile flags should be adjusted    if (wti->fd == INVALID_HANDLE_VALUE) {        fprintf(stderr, FLFMT "Error. Is the port open ?/n", FL);        return diag_iseterr(DIAG_ERR_GENERAL);    }    if (count <= 0)        return diag_iseterr(DIAG_ERR_BADLEN);    if (! WriteFile(wti->fd, buf, count, &byteswritten, pOverlap)) {        fprintf(stderr, FLFMT "WriteFile error:%s. %u bytes written, %u requested/n", FL, diag_os_geterr(0), (unsigned int) byteswritten, count);        return diag_iseterr(DIAG_ERR_GENERAL);    }    if (!FlushFileBuffers(wti->fd)) {        fprintf(stderr, FLFMT "tty_write : could not flush buffers, %s/n", FL, diag_os_geterr(0));        return diag_iseterr(DIAG_ERR_GENERAL);    }    return byteswritten;} //diag_tty_write

int Open_ProIn(){ 	char com_str[10];	sprintf(com_str,"%s:",DeviceNameIN); 	LPSTR lpszPortName = _T(com_str);	com_handle_IN = CreateFile(		lpszPortName, 		GENERIC_READ | GENERIC_WRITE, 		0,								// DWORD dwShareMode, 		NULL,							// LPSECURITY_ATTRIBUTES lpSecurityAttributes, 		OPEN_EXISTING,					// DWORD dwCreationDispostion, 		0, //FILE_FLAG_OVERLAPPED,		// DWORD dwFlagsAndAttributes, 		NULL							// HANDLE hTemplateFile	);		int iRetIn = (int)(com_handle_IN );		if (iRetIn<0)	{    com_handle_IN = NULL;	sprintf(string_display_dmx_params,"Impossible to open interface, is it PLUGGED ?");    return(0);	}	 else {sprintf(string_display_dmx_params,"Enttec Pro IN  %s is now Open",DeviceNameIN);} 	// SetCommState & Timeout    Enttec_Pro_SetCommParamsIN();	// flush rx & tx buffers	resIn = FlushFileBuffers(com_handle_IN);	if (!resIn)	{     sprintf(string_display_dmx_params,"/ENTTEC PRO IN %s: Flush file buffers failed...",DeviceNameIN);	CloseHandle(com_handle_IN); com_handle_IN = NULL;	return(0);	}

void Channel::Destroy(){    if (m_creator)    {        FlushFileBuffers(m_pipe);        DisconnectNamedPipe(m_pipe);        m_creator = false;    }    if (m_doneEvent != INVALID_HANDLE_VALUE)    {                // Signal the done event so that if we're currently blocked reading,        // we'll stop.        SetEvent(m_doneEvent);        CloseHandle(m_doneEvent);        m_doneEvent = INVALID_HANDLE_VALUE;    }    if (m_readEvent != INVALID_HANDLE_VALUE)    {        CloseHandle(m_readEvent);        m_readEvent = INVALID_HANDLE_VALUE;    }    if (m_pipe != INVALID_HANDLE_VALUE)    {        CloseHandle(m_pipe);        m_pipe = INVALID_HANDLE_VALUE;    }}

int32_tomrfile_sync(struct OMRPortLibrary *portLibrary, intptr_t fd){	HANDLE handle = toHandle(portLibrary, fd);	Trc_PRT_file_sync_Entry(fd);	/*	 * According to MSDN:	 * 1) If hFile is a handle to the server end of a named pipe, the function does not return until the client has read all buffered data from the pipe.	 * 2) The function fails if hFile is a handle to the console output. That is because the console output is not buffered. The function returns FALSE, and GetLastError returns ERROR_INVALID_HANDLE.	 *	 * This behaviour caused JAZZ 44899 defect: Test_SimpleTenantLimitXmt would freeze while waiting for process to terminate while child	 * was waiting for parent to read from STDIN and STDOUT streams of a child.	 *	 * Manual testing showed that even if we called System.out.print('X') and System.err.print('Y') a parent process would still get receive 'X' and 'Y'	 * (with and without flushing) after child process in terminated.	 *	 * This check does not modify original behaviour of the port library because we never actually flushed STDIN and STDOUT handles but	 * some arbitrary handles 1 & 2.	 */	if (((HANDLE)OMRPORT_TTY_OUT == (HANDLE)fd) || ((HANDLE)OMRPORT_TTY_ERR == (HANDLE)fd)) {		Trc_PRT_file_sync_Exit(0);		return 0;	}	if (FlushFileBuffers(handle)) {		Trc_PRT_file_sync_Exit(0);		return 0;	} else {		int32_t error = GetLastError();		error = portLibrary->error_set_last_error(portLibrary, error, findError(error));		Trc_PRT_file_sync_Exit(error);		return -1;	}}

bool PipeReader::QueryATR(BYTE *ATR,DWORD *ATRsize,bool reset) {	if (pipe==NULL)		return false;	DWORD command=reset ? 0 : 1;	DWORD read=0;	if (!WriteFile(pipe,&command,sizeof(DWORD),&read,NULL)) {		pipe=NULL;		return false;	}	FlushFileBuffers(pipe);	DWORD size=0;	if (!ReadFile(pipe,&size,sizeof(DWORD),&read,NULL)) {		pipe=NULL;		return false;	}	if (size==0)		return false;	if (!ReadFile(pipe,ATR,size,&read,NULL)) {		pipe=NULL;		return false;	}	(*ATRsize)=size;	return true;}

 bool FlushPlatformFile(PlatformFile file) {     ThreadRestrictions::AssertIOAllowed();     return ((file!=kInvalidPlatformFileValue) && FlushFileBuffers(file)); }

int main(int argc, char* argv[]){    BOOL dwResult;    DWORD dwRead;    DWORD dwWrite;    CHAR chBuf[BUFSIZE];    HANDLE inputFile;    HANDLE outputFile;    BOOL firstRead = TRUE;    char* pathVar = argv[1];    char* inFilename = argv[2];    char* outFilename = argv[3];    inputFile = CreateFileA(        inFilename,        GENERIC_READ,        0,        NULL,        OPEN_ALWAYS,        FILE_ATTRIBUTE_NORMAL,        NULL);    if (inputFile == INVALID_HANDLE_VALUE)    {        PrintErrorMsg("CreateFile");        return -1;    }    outputFile = CreateFileA(        outFilename,        GENERIC_READ | GENERIC_WRITE,        0,        NULL,        CREATE_ALWAYS,        FILE_ATTRIBUTE_NORMAL,        NULL);    if (outputFile == INVALID_HANDLE_VALUE)    {        PrintErrorMsg("CreateFile");        return -1;    }    while (true)    {        dwResult = ReadFile(inputFile, chBuf, BUFSIZE, &dwRead, NULL);        if (!dwResult || dwRead == 0)        {            break;        }        if (firstRead)        {            WriteFile(outputFile, pathVar, (DWORD)strlen(pathVar), &dwWrite, NULL);            firstRead = FALSE;        }        for (size_t i = 0; i < dwRead; i++)        {            if (chBuf[i] == '/')            {                chBuf[i] = '//';            }        }        WriteFile(outputFile, chBuf, dwRead, &dwWrite, NULL);    }    FlushFileBuffers(outputFile);    CloseHandle(outputFile);    return 0;}

//.........这里部分代码省略.........        if (dwRecSign != LOGFILE_SIGNATURE ||            dwRecSize + dwFilePointer > GetFileSize(LogFile->hFile, NULL) + 1 ||            dwRecSize < sizeof(EVENTLOGRECORD))        {            break;        }        if (SetFilePointer(LogFile->hFile,                           -((LONG) sizeof(DWORD) * 2),                           NULL,                           FILE_CURRENT) == INVALID_SET_FILE_POINTER)        {            DPRINT1("SetFilePointer() failed! %d", GetLastError());            return STATUS_EVENTLOG_FILE_CORRUPT;        }        RecBuf = (PEVENTLOGRECORD) HeapAlloc(MyHeap, 0, dwRecSize);        if (RecBuf == NULL)        {            DPRINT1("Can't allocate heap!/n");            return STATUS_NO_MEMORY;        }        if (!ReadFile(LogFile->hFile, RecBuf, dwRecSize, &dwRead, NULL))        {            DPRINT1("ReadFile() failed! %d/n", GetLastError());            HeapFree(MyHeap, 0, RecBuf);            return STATUS_EVENTLOG_FILE_CORRUPT;        }        if (dwRead != dwRecSize)        {            HeapFree(MyHeap, 0, RecBuf);            break;        }        /* if OvewrWrittenRecords is TRUE and this record has already been read */        if ((OvewrWrittenRecords == TRUE) && (RecBuf->RecordNumber == LogFile->Header.OldestRecordNumber))        {            HeapFree(MyHeap, 0, RecBuf);            break;        }        pdwRecSize2 = (PDWORD) (((PBYTE) RecBuf) + dwRecSize - 4);        if (*pdwRecSize2 != dwRecSize)        {            DPRINT1("Invalid RecordSizeEnd of record %d (%x) in %S/n",                    dwRecordsNumber, *pdwRecSize2, LogFile->LogName);            HeapFree(MyHeap, 0, RecBuf);            break;        }        dwRecordsNumber++;        if (!LogfAddOffsetInformation(LogFile,                                      RecBuf->RecordNumber,                                      dwFilePointer))        {            DPRINT1("LogfAddOffsetInformation() failed!/n");            HeapFree(MyHeap, 0, RecBuf);            return STATUS_EVENTLOG_FILE_CORRUPT;        }        HeapFree(MyHeap, 0, RecBuf);    }    LogFile->Header.CurrentRecordNumber = dwRecordsNumber + LogFile->Header.OldestRecordNumber;    if (LogFile->Header.CurrentRecordNumber == 0)        LogFile->Header.CurrentRecordNumber = 1;    if (!Backup)    {        if (SetFilePointer(LogFile->hFile, 0, NULL, FILE_BEGIN) ==            INVALID_SET_FILE_POINTER)        {            DPRINT1("SetFilePointer() failed! %d/n", GetLastError());            return STATUS_EVENTLOG_FILE_CORRUPT;        }        if (!WriteFile(LogFile->hFile,                       &LogFile->Header,                       sizeof(EVENTLOGHEADER),                       &dwRead,                       NULL))        {            DPRINT1("WriteFile failed! %d/n", GetLastError());            return STATUS_EVENTLOG_FILE_CORRUPT;        }        if (!FlushFileBuffers(LogFile->hFile))        {            DPRINT1("FlushFileBuffers failed! %d/n", GetLastError());            return STATUS_EVENTLOG_FILE_CORRUPT;        }    }    return STATUS_SUCCESS;}

//.........这里部分代码省略.........                break;            }        }        HeapFree(GetProcessHeap(), 0, RecBuf);    }    else        WriteOffSet = LogFile->Header.EndOffset;    if (SetFilePointer(LogFile->hFile,                       WriteOffSet,                       NULL,                       FILE_BEGIN) == INVALID_SET_FILE_POINTER)    {        DPRINT1("SetFilePointer() failed! %d/n", GetLastError());        RtlReleaseResource(&LogFile->Lock);        return FALSE;    }    if (!WriteFile(LogFile->hFile, Buffer, BufSize, &dwWritten, NULL))    {        DPRINT1("WriteFile() failed! %d/n", GetLastError());        RtlReleaseResource(&LogFile->Lock);        return FALSE;    }    if (!LogfAddOffsetInformation(LogFile,                                  LogFile->Header.CurrentRecordNumber,                                  WriteOffSet))    {        RtlReleaseResource(&LogFile->Lock);        return FALSE;    }    LogFile->Header.CurrentRecordNumber++;    if (WriteOffSet == LogFile->Header.EndOffset)    {        LogFile->Header.EndOffset += dwWritten;    }    if (SetFilePointer(LogFile->hFile,                       LogFile->Header.EndOffset,                       NULL,                       FILE_BEGIN) == INVALID_SET_FILE_POINTER)    {        DPRINT1("SetFilePointer() failed! %d/n", GetLastError());        RtlReleaseResource(&LogFile->Lock);        return FALSE;    }    EofRec.Ones = 0x11111111;    EofRec.Twos = 0x22222222;    EofRec.Threes = 0x33333333;    EofRec.Fours = 0x44444444;    EofRec.RecordSizeBeginning = sizeof(EVENTLOGEOF);    EofRec.RecordSizeEnd = sizeof(EVENTLOGEOF);    EofRec.CurrentRecordNumber = LogFile->Header.CurrentRecordNumber;    EofRec.OldestRecordNumber = LogFile->Header.OldestRecordNumber;    EofRec.BeginRecord = LogFile->Header.StartOffset;    EofRec.EndRecord = LogFile->Header.EndOffset;    if (!WriteFile(LogFile->hFile,                   &EofRec,                   sizeof(EVENTLOGEOF),                   &dwWritten,                   NULL))    {        DPRINT1("WriteFile() failed! %d/n", GetLastError());        RtlReleaseResource(&LogFile->Lock);        return FALSE;    }    if (SetFilePointer(LogFile->hFile, 0, NULL, FILE_BEGIN) ==        INVALID_SET_FILE_POINTER)    {        DPRINT1("SetFilePointer() failed! %d/n", GetLastError());        RtlReleaseResource(&LogFile->Lock);        return FALSE;    }    if (!WriteFile(LogFile->hFile,                   &LogFile->Header,                   sizeof(EVENTLOGHEADER),                   &dwWritten,                   NULL))    {        DPRINT1("WriteFile failed! LastError = %d/n", GetLastError());        RtlReleaseResource(&LogFile->Lock);        return FALSE;    }    if (!FlushFileBuffers(LogFile->hFile))    {        DPRINT1("FlushFileBuffers() failed! %d/n", GetLastError());        RtlReleaseResource(&LogFile->Lock);        return FALSE;    }    RtlReleaseResource(&LogFile->Lock);    return TRUE;}

//.........这里部分代码省略.........					if (!volParams->bForceOperation && (Silent || (IDNO == MessageBoxW (volParams->hwndDlg, GetString ("DEVICE_IN_USE_FORMAT"), lpszTitle, MB_YESNO|MB_ICONWARNING|MB_DEFBUTTON2))))					{						nStatus = ERR_DONT_REPORT; 						goto error;					}				}				else				{					handleWin32Error (volParams->hwndDlg, SRC_POS);					Error ("CANT_ACCESS_VOL", hwndDlg);					nStatus = ERR_DONT_REPORT; 					goto error;				}			}			if (volParams->hiddenVol || bInstantRetryOtherFilesys)				break;	// The following "quick format" operation would damage the outer volume			if (nPass == 0)			{				char buf [2 * TC_MAX_VOLUME_SECTOR_SIZE];				DWORD bw;				// Perform pseudo "quick format" so that the filesystem driver does not prevent us from 				// formatting hidden sectors				memset (buf, 0, sizeof (buf));				if (!WriteFile (dev, buf, sizeof (buf), &bw, NULL))				{					nStatus = ERR_OS_ERROR; 					goto error;				}				FlushFileBuffers (dev);				CloseHandle (dev);				dev = INVALID_HANDLE_VALUE;			}		}		if (DeviceIoControl (dev, FSCTL_IS_VOLUME_MOUNTED, NULL, 0, NULL, 0, &dwResult, NULL))		{			Error ("FORMAT_CANT_DISMOUNT_FILESYS", hwndDlg);			nStatus = ERR_DONT_REPORT; 			goto error;		}	}	else	{		/* File-hosted volume */		dev = CreateFile (volParams->volumePath, GENERIC_READ | GENERIC_WRITE,			(volParams->hiddenVol || bInstantRetryOtherFilesys) ? (FILE_SHARE_READ | FILE_SHARE_WRITE) : 0,			NULL, (volParams->hiddenVol || bInstantRetryOtherFilesys) ? OPEN_EXISTING : CREATE_ALWAYS, 0, NULL);		if (dev == INVALID_HANDLE_VALUE)		{			nStatus = ERR_OS_ERROR; 			goto error;		}		DisableFileCompression (dev);		if (!volParams->hiddenVol && !bInstantRetryOtherFilesys)		{			LARGE_INTEGER volumeSize;			volumeSize.QuadPart = dataAreaSize + TC_VOLUME_HEADER_GROUP_SIZE;

void OsFile::flush(){	ASSERT(nullptr != m_impl);	FlushFileBuffers(m_impl->m_file);}

/** Truncates the current log file content so when adding some new text the *  file size won't exceed the maximum size specified in init(). * /param[in] iAdd - size of the new string to be added to the log file * /return True if truncate succeeded or false if not. */bool log_file::truncate(int_t iAdd) const{	assert(m_pszPath);	if(!m_pszPath)		return false;	// if we doesn't need to truncate anything	if (m_iMaxSize <= 0)		return true;		// make some checks	int_t iSize=size();	if (iSize <= 0 || iSize+iAdd < m_iMaxSize)		return false;		// establish the new file size (1/3rd of the current size or max_size-add_size)	int_t iNewSize=minval((int_t)(iSize*0.66), m_iMaxSize-iAdd) & ~1;	#ifdef _WIN32	// win32 does not have the ftruncate function, so we have to make some API calls	HANDLE hFile=CreateFile(m_pszPath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);	if (hFile != INVALID_HANDLE_VALUE)	{		// seek		if (SetFilePointer(hFile, iSize-iNewSize, NULL, FILE_BEGIN) != INVALID_SET_FILE_POINTER)		{			// read the string to the eol			DWORD dwRD;			tchar_t szBuffer[4096/sizeof(tchar_t)];			if (ReadFile(hFile, szBuffer, 4096, &dwRD, NULL))			{				dwRD/=sizeof(tchar_t);				szBuffer[(dwRD > 0) ? dwRD-1 : 0]=_t('/0');				// replace the /r and /n in the log to the /0				for (DWORD i=0;i<dwRD;i++)				{					if (szBuffer[i] == _t('/r') || szBuffer[i] == _t('/n'))					{						szBuffer[i]=_t('/0');						break;					}				}				iNewSize-=(int_t)(_tcslen(szBuffer)+1)*sizeof(tchar_t);			// new size correction				if (SetFilePointer(hFile, iSize-iNewSize, NULL, FILE_BEGIN) != INVALID_SET_FILE_POINTER)				{					long_t lSrc=(long_t)SetFilePointer(hFile, 0, NULL, FILE_CURRENT);					long_t lDst=0;					DWORD tRD, tWR;					do					{						// seek to src						SetFilePointer(hFile, lSrc, NULL, FILE_BEGIN);						// read 4k chars from source offset						if (ReadFile(hFile, szBuffer, 4096, &tRD, NULL))						{							// seek to the dst							SetFilePointer(hFile, lDst, NULL, FILE_BEGIN);							FlushFileBuffers(hFile);							// write the buffer to the dest offset							WriteFile(hFile, szBuffer, tRD, &tWR, NULL);							lDst+=(long_t)tWR;						}						lSrc+=(long_t)tRD;					}					while(tRD != 0);					// now truncate the file to the needed size					SetEndOfFile(hFile);				}			}			CloseHandle(hFile);			return true;		}	}#else	FILE* pFile=fopen(m_pszPath, _t("r+"));	if (pFile)	{		// seek		if (fseek(pFile, iSize-iNewSize, SEEK_SET) == 0)		{			// read the string to the eol			tchar_t szBuffer[4096];			fgets(szBuffer, 4096, pFile);			iNewSize-=_tcslen(szBuffer);			// new size correction			int_t iSrc=ftell(pFile);//.........这里部分代码省略.........

static void worker_fsync(struct job_fsync *job){  if (!FlushFileBuffers(job->handle))    job->error_code = GetLastError();}

//.........这里部分代码省略.........    	//    	stCrashBufferPtr = stCrashBuffer;    	stCrashBufferLeft = CRASH_BUFFER_SIZE - 10;       	// Title    	MyAddToBuffer ("*** ENVIRONMENT CRASH ***/r/n/r/n");    	    	// Get environment information    	MyGetEnvironmentInfo ();    	// Add the reason for the crash    	MyAddToBuffer ("/r/n/r/n");    	MyAddToBuffer ("Cause of Crash: ");        EdCrash_GetExceptionName (stCrashBufferPtr,     			pmExceptionInfo -> ExceptionRecord -> ExceptionCode);    	stCrashBufferLeft -= strlen (stCrashBufferPtr);    	stCrashBufferPtr += strlen (stCrashBufferPtr);	// Add previous operations	MyAddPreviousCommandsToBuffer ();	        	// Add the register dump    	EdCrash_RegisterDump (stCrashBufferPtr, pmExceptionInfo -> ContextRecord);    	stCrashBufferLeft -= strlen (stCrashBufferPtr);    	stCrashBufferPtr += strlen (stCrashBufferPtr);    	MyAddToBuffer ("/r/n/r/n");    	// Add the stack dump        	EdCrash_StackDump (stCrashBufferPtr, stCrashBufferLeft,     		           pmExceptionInfo -> ContextRecord);    	stCrashBufferLeft -= strlen (stCrashBufferPtr);    	stCrashBufferPtr += strlen (stCrashBufferPtr);	MyAddToBuffer (LINE_OF_DASHES);    	MyAddToBuffer ("/r/n");    }    if (stMyFileOpenStatus != OPEN_SUCCESS)    {    	if (stMyFileOpenStatus == OPEN_FAIL_CURRENT_IS_STARTUP)    	{    	    EdGUI_Message ("Panic log failure",     	        "Unable to open /"%s/" for writing./nError = %d",     	        stMyPanicLogName, stMyFileOpenError);    	}    	else    	{	    EdGUI_Message ("Panic log failure", 	    	"Unable to open /"%s/" or /"%s/" for writing./nError = %d", 	    	stMyPanicLogName, stMyAltPanicLogName, stMyFileOpenError);	}	    	    	return EXCEPTION_EXECUTE_HANDLER;    }    stMyPanicFile = CreateFile (stMyPanicLogName, GENERIC_WRITE, 0, NULL,    	OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);    if (stMyPanicFile == (HANDLE) INVALID_HANDLE_VALUE)    {    	EdGUI_Message ("Panic log failure",     	    "Unable to open /"%s/" for writing./nError = %d",     	    stMyPanicLogName, GetLastError ());    	return EXCEPTION_EXECUTE_HANDLER;    }        // Move to the end of the file    SetFilePointer (stMyPanicFile, 0, NULL, FILE_END);    if (!WriteFile (stMyPanicFile, stCrashBuffer, strlen (stCrashBuffer),    		    &stMyNumBytesWritten, NULL))    {    	EdGUI_Message ("Panic log failure",    	    "Unable to write to /"%s/"/nError = %d",     	    stMyPanicLogName, GetLastError ());    	return EXCEPTION_EXECUTE_HANDLER;    }    if (stMyNumBytesWritten != strlen (stCrashBuffer))    {    	EdGUI_Message ("Panic log failure",    	    "Unable to write to /"%s/"/n%d bytes written instead of %d bytes",    	    stMyPanicLogName, stMyNumBytesWritten, strlen (stCrashBuffer));    	return EXCEPTION_EXECUTE_HANDLER;    }    if (!FlushFileBuffers (stMyPanicFile))    {    	EdGUI_Message ("Panic log failure",    	    "Unable to flush buffers of /"%s/"/nError = %d",     	    stMyPanicLogName, GetLastError ());    	return EXCEPTION_EXECUTE_HANDLER;    }    if (!CloseHandle (stMyPanicFile))    {    	EdGUI_Message ("Panic log failure",    	    "Unable to close /"%s/"/nError = %d",     	    stMyPanicLogName, GetLastError ());    	return EXCEPTION_EXECUTE_HANDLER;    }    return EXCEPTION_EXECUTE_HANDLER;} // EdFail_CrashHandler

void FileOutputStream::flush(){	FlushFileBuffers(this->file);}