static void ExClose( void ) {
//=========================
byte cl_stat;
byte op_stat;
if( IOCB->flags & BAD_UNIT ) {
IOErr( IO_IUNIT );
}
FindFtnFile();
if( IOCB->fileinfo != NULL ) {
CloseFile( IOCB->fileinfo );
cl_stat = FindKWord( ClStatTab, STAT_SPEC, STATUS_UNKNOWN,
( IOCB->set_flags & SET_STATPTR ) ? IOCB->statptr : NULL );
op_stat = IOCB->fileinfo->status;
if( cl_stat == STATUS_UNKNOWN ) {
cl_stat = STATUS_KEEP;
if( op_stat == STATUS_SCRATCH ) {
cl_stat = STATUS_DELETE;
}
}
if( ( cl_stat == STATUS_KEEP ) && ( op_stat == STATUS_SCRATCH ) ) {
IOErr( IO_ISTAT );
}
if( (cl_stat == STATUS_DELETE) && (IOCB->fileinfo->flags & FTN_FSEXIST) ) {
CloseDeleteFile( IOCB->fileinfo );
} else {
CloseFile( IOCB->fileinfo );
}
DiscoFile( IOCB->fileinfo );
}
}
static void InCplx( void ) {
//========================
ftnfile *fcb;
uint rpt;
xcomplex value;
fcb = IOCB->fileinfo;
fcb->col++;
Blanks();
GetFloat( &value.realpart, ( IOCB->typ - PT_CPLX_8 ) );
Blanks();
CheckEor();
if( fcb->buffer[ fcb->col ] != ',' ) {
IOErr( IO_BAD_CHAR );
}
fcb->col++;
Blanks();
CheckEor();
GetFloat( &value.imagpart, ( IOCB->typ - PT_CPLX_8 ) );
Blanks();
if( fcb->buffer[ fcb->col ] != ')' ) {
IOErr( IO_BAD_CHAR );
}
fcb->col++;
rpt = IOCB->rptnum;
for(;;) {
switch( IOCB->typ ) {
case PT_CPLX_8:
((scomplex PGM *)(IORslt.pgm_ptr))->realpart = value.realpart;
((scomplex PGM *)(IORslt.pgm_ptr))->imagpart = value.imagpart;
break;
case PT_CPLX_16:
((dcomplex PGM *)(IORslt.pgm_ptr))->realpart = value.realpart;
((dcomplex PGM *)(IORslt.pgm_ptr))->imagpart = value.imagpart;
break;
case PT_CPLX_32:
((xcomplex PGM *)(IORslt.pgm_ptr))->realpart = value.realpart;
((xcomplex PGM *)(IORslt.pgm_ptr))->imagpart = value.imagpart;
break;
default:
IOErr( IO_FREE_MISMATCH );
break;
}
FreeIOType();
if( ( rpt-- <= 1 ) || ( IOCB->typ == PT_NOTYPE ) ) break;
}
}
static void FOString( uint width ) {
//==================================
ftnfile *fcb;
uint length;
fcb = IOCB->fileinfo;
if( IOCB->typ != PT_CHAR ) {
length = GetLen();
} else {
length = IORslt.string.len;
}
if( width == 0 ) {
width = length;
}
if( fcb->col + width > fcb->bufflen ) {
IOErr( IO_BUFF_LEN );
}
if( width > length ) {
SendChar( ' ', width - length );
width = length;
}
if( IOCB->typ == PT_CHAR ) {
SendStrRtn( IORslt.string.strptr, width );
} else {
SendStrRtn( (char *)&IORslt, width );
}
}
void R_ChkType( PTYPE lower, PTYPE upper ) {
//===========================================
if( ( IOCB->typ < lower ) || ( IOCB->typ > upper ) ) {
IOErr( IO_FMT_MISMATCH );
}
}
static void IUnBytes( char HPGM *dst, unsigned long len ) {
//=============================================================
uint amt;
ftnfile *fcb;
char *src;
fcb = IOCB->fileinfo;
if( IsFixed() && ( fcb->col + len > fcb->len ) ) {
IOErr( IO_UNFMT_RECL );
}
src = fcb->buffer + fcb->col;
for(;;) {
amt = fcb->len - fcb->col;
if( amt > len ) {
amt = len;
}
pgm_memput( dst, src, amt );
fcb->col += amt;
len -= amt;
if( len == 0 ) break;
dst += amt;
src = fcb->buffer;
NextUnFmtRec();
}
}
void CloseFile( ftnfile *fcb ) {
//=================================
// Close a 'ftnfile'.
file_handle fh;
if( fcb->fileptr == NULL ) return;
if( fcb->fileptr == FStdIn ) return;
if( fcb->fileptr == FStdOut ) {
// check if standard output device redirected to a disk file
if( ((a_file *)(fcb->fileptr))->attrs & BUFFERED ) {
FlushBuffer( fcb->fileptr );
ChkIOErr( fcb );
}
return;
}
if( fcb->fileptr == FStdErr ) return;
Closef( fcb->fileptr );
// save file handle
fh = fcb->fileptr;
// set file handle in fcb to NULL - we don't want
// to get the i/o status from the file handle since
// it will no longer be valid if the close succeeded
fcb->fileptr = NULL;
if( GetIOErr( fcb ) ) {
// close failed so restore file handle in fcb
fcb->fileptr = fh;
IOErr( IO_FILE_PROBLEM );
}
}
static void StreamUnFmtIn( void ) {
//===============================
ftnfile *fcb;
fcb = IOCB->fileinfo;
for(;;) {
IOCB->typ = IOTypeRtn();
if( IOCB->typ == PT_NOTYPE ) break;
if( IOCB->typ == PT_CHAR ) {
IUnStream( IORslt.string.strptr, IORslt.string.len );
} else if( IOCB->typ == PT_ARRAY ) {
uint elmt_size;
if( IORslt.arr_desc.typ == PT_CHAR ) {
elmt_size = IORslt.arr_desc.elmt_size;
} else {
elmt_size = SizeVars[ IORslt.arr_desc.typ ];
}
IUnStream( IORslt.arr_desc.data,
IORslt.arr_desc.num_elmts * elmt_size );
} else {
fcb->len = SizeVars[ IOCB->typ ];
if( fcb->len > fcb->bufflen ) {
IOErr( IO_UNFMT_RECL );
}
NextRec();
UnFmtItem( fcb->buffer );
}
}
}
void ChkBuffLen( uint width ) {
//================================
if( IOCB->fileinfo->col + width > IOCB->fileinfo->len ) {
IOErr( IO_BUFF_LEN );
}
}
static void RecordUnFmtIn( void ) {
//===============================
ftnfile *fcb;
int len;
fcb = IOCB->fileinfo;
NextRec();
for(;;) {
IOCB->typ = IOTypeRtn();
if( IOCB->typ == PT_NOTYPE ) break;
if( fcb->col == fcb->len ) {
NextUnFmtRec();
}
if( IOCB->typ == PT_CHAR ) {
IUnString();
} else if( IOCB->typ == PT_ARRAY ) {
IUnArray();
} else {
len = SizeVars[ IOCB->typ ];
if( fcb->col + len > fcb->len ) {
IOErr( IO_UNFMT_RECL );
}
UnFmtItem( fcb->buffer + fcb->col );
fcb->col += len;
}
}
}
static void InNumber( void ) {
//==========================
extended value;
intstar4 intval;
int col;
col = IOCB->fileinfo->col; // save position in case of repeat specifier
for(;;) {
IOCB->fileinfo->col = col;
if( IOCB->typ >= PT_REAL_4 ) {
GetFloat( &value, ( IOCB->typ - PT_REAL_4 ) );
switch( IOCB->typ ) {
case PT_REAL_4:
*(single PGM *)(IORslt.pgm_ptr) = value;
break;
case PT_REAL_8:
*(double PGM *)(IORslt.pgm_ptr) = value;
break;
case PT_REAL_16:
*(extended PGM *)(IORslt.pgm_ptr) = value;
break;
default:
IOErr( IO_FREE_MISMATCH );
break;
}
} else {
GetInt( &intval );
switch( IOCB->typ ) {
case PT_INT_1:
*(intstar1 PGM *)(IORslt.pgm_ptr) = intval;
break;
case PT_INT_2:
*(intstar2 PGM *)(IORslt.pgm_ptr) = intval;
break;
case PT_INT_4:
*(intstar4 PGM *)(IORslt.pgm_ptr) = intval;
break;
default:
IOErr( IO_FREE_MISMATCH );
break;
}
}
FreeIOType();
if( ( IOCB->rptnum-- <= 1 ) || ( IOCB->typ == PT_NOTYPE ) ) break;
}
}
void SendEOR( void ) {
//=================
ftnfile *fcb;
int len;
bool ifile;
fcb = IOCB->fileinfo;
ifile = fcb->internal != NULL;
if( ifile ) {
if( fcb->flags & FTN_EOF ) {
IOErr( IO_IFULL );
}
if( fcb->recnum >= IOCB->elmts ) {
fcb->flags |= FTN_EOF;
SendIFBuff( fcb->buffer, fcb->bufflen, fcb->recnum, fcb->internal );
} else {
SendIFBuff( fcb->buffer, fcb->bufflen, fcb->recnum, fcb->internal );
memset( fcb->buffer, ' ', fcb->bufflen );
}
} else {
if( IsFixed() ) {
fcb->col = fcb->bufflen;
}
if( fcb->fileptr != NULL ) {
FPutBuff( fcb );
ChkIOErr( fcb );
}
}
// Write to the listing file after we've written to DB_STD_OUTPUT so
// that if we get an error writing to the listing file, the buffer for
// DB_STD_OUTPUT will be empty (i.e. when we report the error writing
// to the listing file we will need to use DB_STD_OUTPUT's buffer).
// Note that we have to set fcb->col to 0 so that the error message
// will go at the beginning of the buffer.
len = fcb->col;
fcb->col = 0;
if( ( IOCB->flags & IOF_NOCR ) == 0 ) {
UpdateRecNum( fcb );
// eofrecnum used to be updated in ExWrite().
// We MUST set eofrecnum here in case we abort the WRITE and
// suicide which will NOT return to ExWrite().
// If we don't do this here, the next time a WRITE is executed
// on this unit, we get IO_PAST_EOF error.
if( !ifile && !NoEOF( fcb ) ) {
if( fcb->accmode <= ACCM_SEQUENTIAL ) {
fcb->eofrecnum = fcb->recnum;
}
}
if( !ifile ) {
memset( fcb->buffer, ' ', fcb->bufflen );
}
}
IOCB->flags &= ~IOF_NOCR;
}
static void NextUnFmtRec( void ) {
//================================
if( _LogicalRecordOrganization( IOCB->fileinfo ) ) {
if( CheckLogicalRecord( IOCB->fileinfo ) ) {
NextRec();
return;
}
}
IOErr( IO_UNFMT_RECL );
}
static void GetInt( intstar4 *result ) {
//==========================================
ftnfile *fcb;
char *start;
uint len;
int status;
fcb = IOCB->fileinfo;
start = fcb->buffer + fcb->col;
len = GetDelim( start, fcb->buffer + fcb->len ) - start;
status = FmtS2I( start, len, false, result, false, NULL );
if( status == INT_OK ) {
fcb->col += len;
} else if( status == INT_INVALID ) {
IOErr( IO_BAD_CHAR );
} else {
IOErr( IO_IOVERFLOW );
}
}
static void FreeIOErr( uint err ) {
//=====================================
// Report error during list-directed or NAMELIST-directed i/o.
if( IOCB->flags & NML_DIRECTED ) {
IOCB->flags |= NML_CONTINUE;
RTSuicide();
}
IOErr( err );
}
static void FmtPrepOp( void ) {
//===========================
ftnfile *fcb;
byte width;
fcb = IOCB->fileinfo;
width = IOCB->fmtptr->fmt1.fld1;
if( width + fcb->col > fcb->bufflen ) {
IOErr( IO_BUFF_LEN );
}
}
void R_FIInt( void ) {
//=================
intstar4 value;
uint width;
uint new_width;
int status;
ftnfile *fcb;
bool comma;
fcb = IOCB->fileinfo;
width = IOCB->fmtptr->fmt2.fld1;
ChkBuffLen( width );
comma = __AllowCommaSep();
status = FmtS2I( fcb->buffer + fcb->col, width, ( fcb->blanks == BLANK_ZERO ), &value, comma, &new_width );
if( status == INT_INVALID ) {
IOErr( IO_BAD_CHAR );
} else if( status == INT_OVERFLOW ) {
IOErr( IO_IOVERFLOW );
} else {
if( comma && ( width != new_width ) ) { // use comma as field separator
fcb->col += new_width;
if( fcb->buffer[ fcb->col ] == ',' ) {
fcb->col++;
} else {
IOErr( IO_BAD_CHAR );
}
} else {
fcb->col += width;
}
if( IOCB->typ == PT_INT_1 ) {
*(intstar1 PGM *)(IORslt.pgm_ptr) = value;
} else if( IOCB->typ == PT_INT_2 ) {
*(intstar2 PGM *)(IORslt.pgm_ptr) = value;
} else {
*(intstar4 PGM *)(IORslt.pgm_ptr) = value;
}
}
}
static void GetFloat( extended *result, int prec ) {
//======================================================
ftnfile *fcb;
char *start;
uint len;
int status;
fcb = IOCB->fileinfo;
start = fcb->buffer + fcb->col;
len = GetDelim( start, fcb->buffer + fcb->len ) - start;
status = FmtS2F( start, len, 0, false, 0, prec, result, false, NULL, false );
if( status == FLT_OK ) {
fcb->col += len;
} else {
if( status == FLT_INVALID ) {
IOErr( IO_BAD_CHAR );
} else { // FLT_RANGE_EXCEEDED
IOErr( IO_FRANGE_EXCEEDED );
}
}
}
void SysCreateFile( ftnfile *fcb ) {
//=====================================
// Cause the file to exist in the file system.
fcb->fileptr = Openf( fcb->filename, REC_TEXT | WRONLY );
if( fcb->fileptr != NULL ) {
Closef( fcb->fileptr );
fcb->fileptr = NULL;
fcb->flags |= FTN_FSEXIST;
} else {
IOErr( IO_FILE_PROBLEM );
}
}
static void InString( void ) {
//===========================
int save_col;
if( IOCB->rptnum == 0 ) {
if( IOCB->typ != PT_CHAR ) {
IOErr( IO_FREE_MISMATCH );
}
GetString();
FreeIOType();
} else {
save_col = IOCB->fileinfo->col;
for(;;) {
if( IOCB->typ != PT_CHAR ) {
IOErr( IO_FREE_MISMATCH );
}
IOCB->fileinfo->col = save_col;
GetString();
FreeIOType();
if( ( IOCB->rptnum-- <= 1 ) || ( IOCB->typ == PT_NOTYPE ) ) break;
}
}
}
static int do_revert(int err, struct dentry *wh_dentry, struct dentry *dentry,
aufs_bindex_t bwh, struct dtime *dt, int dlgt)
{
int rerr;
rerr = au_unlink_wh_dentry(wh_dentry->d_parent->d_inode, wh_dentry,
dentry, dlgt);
//rerr = -1;
if (!rerr) {
set_dbwh(dentry, bwh);
dtime_revert(dt, !CPUP_LOCKED_GHDIR);
return 0;
}
IOErr("%.*s reverting whiteout failed(%d, %d)\n",
DLNPair(dentry), err, rerr);
return -EIO;
}
void R_FILog( void ) {
//=================
ftnfile *fcb;
uint width;
char ch;
fcb = IOCB->fileinfo;
width = IOCB->fmtptr->fmt1.fld1;
ChkBuffLen( width );
for(;;) {
if( fcb->buffer[ fcb->col ] != ' ' ) break;
fcb->col++;
if( --width == 0 ) break;
}
if( fcb->buffer[ fcb->col ] == '.' ) {
--width;
fcb->col++;
}
if( width == 0 ) {
IOErr( IO_BAD_CHAR );
} else {
ch = toupper( fcb->buffer[ fcb->col ] );
if( ch == 'F' ) {
SetLogValue( _LogValue( false ) );
} else if( ch == 'T' ) {
SetLogValue( _LogValue( true ) );
}
}
if( __AllowCommaSep() ) { // don't flush but search for comma separator
fcb->col++;
width--;
while( width > 0 ) {
if( fcb->buffer[ fcb->col ] == ',' ) {
fcb->col++;
break;
}
fcb->col++;
width--;
}
} else {
fcb->col += width; // flush over other stuff
}
}
static void InLog( void ) {
//=======================
ftnfile *fcb;
logstar4 value;
char *chptr;
fcb = IOCB->fileinfo;
chptr = &fcb->buffer[ fcb->col ];
if( toupper( *chptr ) == 'T' ) {
value = _LogValue( true );
} else {
value = _LogValue( false );
}
for(;;) {
chptr++;
fcb->col++;
if( fcb->col == fcb->len )
break;
switch( *chptr ) {
case ' ':
case '\t':
case '/':
case ',':
goto big_break;
}
}
big_break:
for(;;) {
switch( IOCB->typ ) {
case PT_LOG_1:
*(logstar1 PGM *)(IORslt.pgm_ptr) = value;
break;
case PT_LOG_4:
*(logstar4 PGM *)(IORslt.pgm_ptr) = value;
break;
default:
IOErr( IO_FREE_MISMATCH );
break;
}
FreeIOType();
if( ( IOCB->rptnum-- <= 1 ) || ( IOCB->typ == PT_NOTYPE ) ) break;
}
}
void CloseDeleteFile( ftnfile *fcb ) {
//=======================================
// Close and delete 'ftnfile'.
bool win_con = false;
#if defined( __IS_WINDOWED__ )
if( fcb->fileptr ) {
win_con = _dwDeleteOnClose( ((a_file *)(fcb->fileptr))->handle );
}
#endif
CloseFile( fcb );
if( win_con )
return;
if( Scrtched( fcb ) )
return;
IOErr( IO_FILE_PROBLEM );
}
static void R_FEH( uint dummy1 , char dummy2 ) {
//======================
ftnfile *fcb;
uint len;
char PGM *str;
fcb = IOCB->fileinfo;
if( IOCB->flags & IOF_OUTPT ) {
len = IOCB->fmtptr->fmtstring.fld1;
if( fcb->col + len > fcb->bufflen ) {
IOErr( IO_BUFF_LEN );
}
str = IOCB->fmtptr->fmtstring.str;
SendStr( str, len );
} else {
RTErr( FM_NOT_INP );
}
R_ChkRecLen();
IOCB->fmtptr = (fmt_desc PGM *)((char PGM *)IOCB->fmtptr + sizeof( fmt4 ) +
len * sizeof( char ));
}
static void RptNum( void ) {
//========================
ftnfile *fcb;
int col;
signed_32 num;
fcb = IOCB->fileinfo;
col = fcb->col;
num = GetNum();
if( fcb->buffer[ fcb->col ] == '*' ) {
if( num > 0 ) {
fcb->col++;
} else {
IOErr( IO_BAD_CHAR );
}
} else {
fcb->col = col;
num = 0;
}
IOCB->rptnum = num;
}
void R_FIHex( void ) {
//=================
uint width;
int len;
ftnfile *fcb;
PTYPE typ;
void PGM *ptr;
fcb = IOCB->fileinfo;
width = IOCB->fmtptr->fmt1.fld1;
len = GetLen();
typ = IOCB->typ;
ChkBuffLen( width );
if( typ == PT_CHAR ) {
ptr = IORslt.string.strptr;
} else {
ptr = IORslt.pgm_ptr;
if( typ == PT_CPLX_8 ) {
if( IOCB->flags & IOF_FMTREALPART ) {
ptr = &((scomplex *)ptr)->realpart;
} else {
ptr = &((scomplex *)ptr)->imagpart;
}
} else if( typ == PT_CPLX_16 ) {
if( IOCB->flags & IOF_FMTREALPART ) {
ptr = &((dcomplex *)ptr)->imagpart;
} else {
ptr = &((dcomplex *)ptr)->imagpart;
}
}
}
if( !FmtH2B( &fcb->buffer[ fcb->col ], width, ptr, len, typ ) ) {
IOErr( IO_BAD_CHAR );
}
fcb->col += width;
}
static int renwh_and_rmdir(struct dentry *dentry, aufs_bindex_t bindex,
struct aufs_nhash *whlist, struct inode *dir)
{
int rmdir_later, err;
struct dentry *hidden_dentry;
LKTRTrace("%.*s, b%d\n", DLNPair(dentry), bindex);
err = rename_whtmp(dentry, bindex);
//err = -1;
//todo: bug
if (unlikely(err)) {
au_direval_inc(dentry->d_parent);
return err;
}
hidden_dentry = au_h_dptr_i(dentry, bindex);
if (!au_is_nfs(hidden_dentry->d_sb)) {
const int dirwh = stosi(dentry->d_sb)->si_dirwh;
rmdir_later = (dirwh <= 1);
if (!rmdir_later)
rmdir_later = is_longer_wh(whlist, bindex, dirwh);
if (rmdir_later)
return rmdir_later;
}
err = rmdir_whtmp(hidden_dentry, whlist, bindex, dir, dentry->d_inode);
//err = -1;
if (unlikely(err)) {
IOErr("rmdir %.*s, b%d failed, %d. ignored\n",
DLNPair(hidden_dentry), bindex, err);
err = 0;
}
TraceErr(err);
return err;
}
static void SysIOInfo( ftnfile *fcb ) {
//=========================================
// Get system file information.
struct stat info;
char *sys_name;
bool exist = true;
if( fcb->bufflen == 0 ) {
fcb->bufflen = SYS_DFLT_RECSIZE;
}
if( fcb->blocksize == 0 ) {
fcb->blocksize = IO_BUFFER;
}
fcb->device = 0;
if( fcb->fileptr != NULL ) { // file is open
#if defined( __NETWARE__ )
if( ( ((a_file *)(fcb->fileptr))->handle == STDIN_FILENO ) ||
( ((a_file *)(fcb->fileptr))->handle == STDOUT_FILENO ) ||
( ((a_file *)(fcb->fileptr))->handle == STDERR_FILENO ) ) {
fcb->device |= INFO_DEV;
} else {
#endif
// for stdin, don't use file name "CON" since information will always
// indicate it's a device even if stdin is redirected
if( fstat( ((a_file *)(fcb->fileptr))->handle, &info ) == -1 ) {
FSetSysErr( fcb->fileptr );
IOErr( IO_FILE_PROBLEM );
return;
}
if( S_ISCHR( info.st_mode ) ) {
fcb->device |= INFO_DEV;
#if defined( __DOS__ ) || defined( __WINDOWS__ )
} else {
fcb->device |= INFO_VALID_DRIVE;
#endif
}
#if defined( __NETWARE__ )
}
#endif
} else {
if( stat( fcb->filename, &info ) == -1 ) {
// if we are trying to open a file in a non-existent
// directory we don't want to issue an error
if( fcb->flags & FTN_FSEXIST ) {
FSetSysErr( fcb->fileptr );
IOErr( IO_FILE_PROBLEM );
return;
}
exist = false;
} else if( S_ISCHR( info.st_mode ) ) {
fcb->device |= INFO_DEV;
// devices always exist
fcb->flags |= FTN_FSEXIST;
#if !defined( __UNIX__ )
} else {
fcb->device |= INFO_VALID_DRIVE;
#endif
}
}
if( ( fcb->flags & FTN_FSEXIST ) && !IsDevice( fcb ) ) {
#if !defined( __UNIX__ )
// Assume the two most significant bits contain no useful information
fcb->device = INFO_DRIVE & info.st_dev; // save drive letter
#endif
if( ( info.st_mode & S_IRUSR ) && ( info.st_mode & S_IWUSR ) ) {
fcb->action = ACTION_RW;
} else if( info.st_mode & S_IRUSR ) {
fcb->action = ACTION_READ;
} else if( info.st_mode & S_IWUSR ) {
fcb->action = ACTION_WRITE;
} else {
// if none of the above are set,
// assume read/write
fcb->action = ACTION_RW;
}
}
sys_name = GetSysName( fcb );
if( sys_name == NULL ) {
if( exist ) {
FSetSysErr( fcb->fileptr );
IOErr( IO_FILE_PROBLEM );
}
return;
}
RMemFree( fcb->filename );
fcb->filename = sys_name;
}
void IOPrologue( void ) {
//====================
ftnfile *fcb;
byte form;
byte accm;
IOCB->typ = PT_NOT_STARTED;
if( IOCB->flags & BAD_REC ) {
IOErr( IO_IREC );
}
if( IOCB->set_flags & SET_INTERNAL ) {
F_Connect();
} else {
ChkUnitId();
FindFtnFile();
if( IOCB->fileinfo == NULL ) {
IOCB->set_flags &= ~SET_FILENAME;
ConnectFile();
}
}
fcb = IOCB->fileinfo;
if( fcb->action == ACT_DEFAULT ) {
fcb->action = ACTION_RW;
}
ChkIOOperation( fcb );
if( fcb->cctrl == CC_DEFAULT ) {
fcb->cctrl = CC_NO;
}
accm = fcb->accmode;
if( accm == ACCM_DEFAULT ) {
if( IOCB->set_flags & SET_RECORDNUM ) {
accm = ACCM_DIRECT;
} else {
accm = ACCM_SEQUENTIAL;
}
fcb->accmode = accm;
} else {
if( ( accm == ACCM_DIRECT ) && (IOCB->set_flags & SET_RECORDNUM) == 0 ) {
IOErr( IO_REC1_ACCM );
} else if( ( ( accm == ACCM_SEQUENTIAL ) || ( accm == ACCM_APPEND ) ) &&
(IOCB->set_flags & SET_RECORDNUM) ) {
IOErr( IO_REC2_ACCM );
}
}
if( accm == ACCM_DIRECT ) {
fcb->recnum = IOCB->recordnum; // set up recordnumber
}
form = fcb->formatted;
if( form == 0 ) { // set up format if it was
if( (IOCB->flags & IOF_NOFMT) == 0 ) { // not previously set
form = FORMATTED_IO;
} else {
form = UNFORMATTED_IO;
}
fcb->formatted = form;
} else {
if( (form == FORMATTED_IO) && (IOCB->flags & IOF_NOFMT) ) {
IOErr( IO_AF1 );
} else if( (form == UNFORMATTED_IO) && (IOCB->flags & IOF_NOFMT) == 0 ) {
IOErr( IO_AF2 );
}
}
if( fcb->internal != NULL ) {
fcb->bufflen = fcb->internal->len;
fcb->buffer = RChkAlloc( fcb->bufflen );
} else {
if( ( accm <= ACCM_SEQUENTIAL ) &&
( fcb->eofrecnum != 0 ) &&
( fcb->recnum >= fcb->eofrecnum ) &&
// Consider: READ( 1, *, END=10 )
// ...
// 10 WRITE( 1, * ) 'write after EOF'
// if an EOF condition was encounterd, we don't want IO_PAST_EOF
// on the write
(IOCB->flags & IOF_OUTPT) == 0 ) {
if( fcb->recnum != fcb->eofrecnum ) {
IOErr( IO_PAST_EOF );
} else {
fcb->recnum++;
SysEOF();
}
}
_AllocBuffer( fcb );
if( fcb->fileptr == NULL ) {
DoOpen();
}
if( fcb->accmode == ACCM_DIRECT ) {
SeekFile( fcb );
ChkIOErr( fcb );
}
fcb->col = 0;
}
if( (IOCB->flags & IOF_OUTPT) && ( fcb->col == 0 ) ) {
memset( fcb->buffer, ' ', fcb->bufflen );
}
}
/*
* copyup the deleted file for writing.
*/
static int cpup_wh_file(struct file *file, aufs_bindex_t bdst, loff_t len)
{
int err;
struct dentry *dentry, *parent, *hidden_parent, *tmp_dentry;
struct dentry *hidden_dentry_bstart, *hidden_dentry_bdst;
struct inode *hidden_dir;
aufs_bindex_t bstart;
struct aufs_dinfo *dinfo;
struct dtime dt;
struct lkup_args lkup;
struct super_block *sb;
dentry = file->f_dentry;
LKTRTrace("%.*s, bdst %d, len %Lu\n", DLNPair(dentry), bdst, len);
DEBUG_ON(S_ISDIR(dentry->d_inode->i_mode)
|| !(file->f_mode & FMODE_WRITE));
DiMustWriteLock(dentry);
parent = dentry->d_parent;
IiMustAnyLock(parent->d_inode);
hidden_parent = au_h_dptr_i(parent, bdst);
DEBUG_ON(!hidden_parent);
hidden_dir = hidden_parent->d_inode;
DEBUG_ON(!hidden_dir);
IMustLock(hidden_dir);
sb = parent->d_sb;
lkup.nfsmnt = au_nfsmnt(sb, bdst);
lkup.dlgt = need_dlgt(sb);
tmp_dentry = lkup_whtmp(hidden_parent, &dentry->d_name, &lkup);
//if (LktrCond) {dput(tmp_dentry); tmp_dentry = ERR_PTR(-1);}
err = PTR_ERR(tmp_dentry);
if (IS_ERR(tmp_dentry))
goto out;
dtime_store(&dt, parent, hidden_parent);
dinfo = dtodi(dentry);
bstart = dinfo->di_bstart;
hidden_dentry_bdst = dinfo->di_hdentry[0 + bdst].hd_dentry;
hidden_dentry_bstart = dinfo->di_hdentry[0 + bstart].hd_dentry;
dinfo->di_bstart = bdst;
dinfo->di_hdentry[0 + bdst].hd_dentry = tmp_dentry;
dinfo->di_hdentry[0 + bstart].hd_dentry = au_h_fptr(file)->f_dentry;
err = cpup_single(dentry, bdst, bstart, len,
au_flags_cpup(!CPUP_DTIME, parent));
//if (LktrCond) err = -1;
if (!err)
err = au_reopen_nondir(file);
//err = -1;
if (unlikely(err)) {
dinfo->di_hdentry[0 + bstart].hd_dentry = hidden_dentry_bstart;
dinfo->di_hdentry[0 + bdst].hd_dentry = hidden_dentry_bdst;
dinfo->di_bstart = bstart;
goto out_tmp;
}
DEBUG_ON(!d_unhashed(dentry));
err = vfsub_unlink(hidden_dir, tmp_dentry, lkup.dlgt);
//if (LktrCond) err = -1;
if (unlikely(err)) {
IOErr("failed remove copied-up tmp file %.*s(%d)\n",
DLNPair(tmp_dentry), err);
err = -EIO;
}
dtime_revert(&dt, !CPUP_LOCKED_GHDIR);
out_tmp:
dput(tmp_dentry);
out:
TraceErr(err);
return err;
}
