void
AsyncFile::writeReq( Request * request)
{
int page_num = 0;
bool write_not_complete = true;
while(write_not_complete) {
int totsize = 0;
off_t offset = request->par.readWrite.pages[page_num].offset;
char* bufptr = theWriteBuffer;
write_not_complete = false;
if (request->par.readWrite.numberOfPages > 1) {
off_t page_offset = offset;
// Multiple page write, copy to buffer for one write
for(int i=page_num; i < request->par.readWrite.numberOfPages; i++) {
memcpy(bufptr,
request->par.readWrite.pages[i].buf,
request->par.readWrite.pages[i].size);
bufptr += request->par.readWrite.pages[i].size;
totsize += request->par.readWrite.pages[i].size;
if (((i + 1) < request->par.readWrite.numberOfPages)) {
// There are more pages to write
// Check that offsets are consequtive
off_t tmp = page_offset + request->par.readWrite.pages[i].size;
if (tmp != request->par.readWrite.pages[i+1].offset) {
// Next page is not aligned with previous, not allowed
DEBUG(ndbout_c("Page offsets are not aligned"));
request->error = EINVAL;
return;
}
if ((unsigned)(totsize + request->par.readWrite.pages[i+1].size) > (unsigned)theWriteBufferSize) {
// We are not finished and the buffer is full
write_not_complete = true;
// Start again with next page
page_num = i + 1;
break;
}
}
page_offset += request->par.readWrite.pages[i].size;
}
bufptr = theWriteBuffer;
} else {
// One page write, write page directly
bufptr = request->par.readWrite.pages[0].buf;
totsize = request->par.readWrite.pages[0].size;
}
int err = writeBuffer(bufptr, totsize, offset);
if(err != 0){
request->error = err;
return;
}
} // while(write_not_complete)
if(m_auto_sync_freq && m_write_wo_sync > m_auto_sync_freq){
syncReq(request);
}
}
/**
* Report connection broken
*/
void
reportDisconnect(void * callbackObj, NodeId nodeId, Uint32 error){
#ifdef REPORT_TRANSPORTER
ndbout_c("REPORT_TRANSP: API reportDisconnect (nodeId=%d)", (int)nodeId);
#endif
((TransporterFacade*)(callbackObj))->reportDisconnected(nodeId);
//TransporterFacade::instance()->reportDisconnected(nodeId);
}
bool
TCP_Transporter::setSocketNonBlocking(NDB_SOCKET_TYPE socket){
int flags;
flags = fcntl(socket, F_GETFL, 0);
if (flags < 0) {
#ifdef DEBUG_TRANSPORTER
ndbout_c("Set non-blocking server error1: %s", strerror(InetErrno));
#endif
}//if
flags |= NDB_NONBLOCK;
if (fcntl(socket, F_SETFL, flags) == -1) {
#ifdef DEBUG_TRANSPORTER
ndbout_c("Set non-blocking server error2: %s", strerror(InetErrno));
#endif
}//if
return true;
}
/*
* Lock failed (after delay) in ACC. Probably means somebody ahead of
* us in lock queue deleted the tuple.
*/
void
Dbtup::execACCKEYREF(Signal* signal)
{
jamEntry();
ScanOpPtr scanPtr;
scanPtr.i = signal->theData[0];
c_scanOpPool.getPtr(scanPtr);
ScanOp& scan = *scanPtr.p;
ndbrequire(scan.m_bits & ScanOp::SCAN_LOCK_WAIT && scan.m_accLockOp != RNIL);
scan.m_bits &= ~ ScanOp::SCAN_LOCK_WAIT;
if (scan.m_state != ScanOp::Aborting) {
jam();
// release the operation
AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend();
lockReq->returnCode = RNIL;
lockReq->requestInfo = AccLockReq::Abort;
lockReq->accOpPtr = scan.m_accLockOp;
EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::UndoSignalLength);
jamEntry();
ndbrequire(lockReq->returnCode == AccLockReq::Success);
scan.m_accLockOp = RNIL;
// scan position should already have been moved (assert only)
if (scan.m_state == ScanOp::Blocked) {
jam();
//ndbassert(false);
if (scan.m_bits & ScanOp::SCAN_NR)
{
jam();
scan.m_state = ScanOp::Next;
scan.m_scanPos.m_get = ScanPos::Get_tuple;
ndbout_c("Ignoring scan.m_state == ScanOp::Blocked, refetch");
}
else
{
jam();
scan.m_state = ScanOp::Next;
ndbout_c("Ignoring scan.m_state == ScanOp::Blocked");
}
}
// LQH has the ball
return;
}
// lose the lock
scan.m_accLockOp = RNIL;
// continue at ACC_ABORTCONF
}
int
AsyncFile::check_odirect_read(Uint32 flags, int &new_flags, int mode)
{
#ifdef O_DIRECT
int ret;
char * bufptr = (char*)((UintPtr(g_odirect_readbuf)+(GLOBAL_PAGE_SIZE - 1)) & ~(GLOBAL_PAGE_SIZE - 1));
while (((ret = ::read(theFd, bufptr, GLOBAL_PAGE_SIZE)) == -1) &&
(errno == EINTR));
if (ret == -1)
{
ndbout_c("%s Failed to read using O_DIRECT, disabling",
theFileName.c_str());
goto reopen;
}
if(lseek(theFd, 0, SEEK_SET) != 0)
{
return errno;
}
if ((flags & FsOpenReq::OM_CHECK_SIZE) == 0)
{
struct stat buf;
if ((fstat(theFd, &buf) == -1))
{
return errno;
}
else if ((buf.st_size % GLOBAL_PAGE_SIZE) != 0)
{
ndbout_c("%s filesize not a multiple of %d, disabling O_DIRECT",
theFileName.c_str(), GLOBAL_PAGE_SIZE);
goto reopen;
}
}
return 0;
reopen:
close(theFd);
new_flags &= ~O_DIRECT;
theFd = ::open(theFileName.c_str(), new_flags, mode);
if (theFd == -1)
return errno;
#endif
return 0;
}
int
AsyncFile::extendfile(Request* request) {
#if ! defined(HAVE_PWRITE)
// Find max size of this file in this request
int maxOffset = 0;
int maxSize = 0;
for(int i=0; i < request->par.readWrite.numberOfPages ; i++) {
if (request->par.readWrite.pages[i].offset > maxOffset) {
maxOffset = request->par.readWrite.pages[i].offset;
maxSize = request->par.readWrite.pages[i].size;
}
}
DEBUG(ndbout_c("extendfile: maxOffset=%d, size=%d", maxOffset, maxSize));
// Allocate a buffer and fill it with zeros
void* pbuf = ndbd_malloc(maxSize);
memset(pbuf, 0, maxSize);
for (int p = 0; p <= maxOffset; p = p + maxSize) {
int return_value;
return_value = lseek(theFd,
p,
SEEK_SET);
if((return_value == -1 ) || (return_value != p)) {
ndbd_free(pbuf,maxSize);
return -1;
}
return_value = ::write(theFd,
pbuf,
maxSize);
if ((return_value == -1) || (return_value != maxSize)) {
ndbd_free(pbuf,maxSize);
return -1;
}
}
ndbd_free(pbuf,maxSize);
DEBUG(ndbout_c("extendfile: \"%s\" OK!", theFileName.c_str()));
return 0;
#else
request = request;
DEBUG(ndbout_c("no pwrite"));
abort();
return -1;
#endif
}
void
AsyncFile::detach(AsyncIoThread* thr)
{
#if 0
ndbout_c("%p:%s detach from %p", this, theFileName.c_str(), thr);
#endif
assert(m_thread == thr);
m_thread = 0;
}
bool
TCP_Transporter::doSend() {
// If no sendbuffers are used nothing is done
// Sends the contents of the SendBuffers until they are empty
// or until select does not select the socket for write.
// Before calling send, the socket must be selected for write
// using "select"
// It writes on the external TCP/IP interface until the send buffer is empty
// and as long as write is possible (test it using select)
// Empty the SendBuffers
bool sent_any = true;
while (m_sendBuffer.dataSize > 0)
{
const char * const sendPtr = m_sendBuffer.sendPtr;
const Uint32 sizeToSend = m_sendBuffer.sendDataSize;
const int nBytesSent = inet_send(theSocket, sendPtr, sizeToSend, 0);
if (nBytesSent > 0)
{
sent_any = true;
m_sendBuffer.bytesSent(nBytesSent);
sendCount ++;
sendSize += nBytesSent;
if(sendCount == reportFreq)
{
reportSendLen(get_callback_obj(), remoteNodeId, sendCount, sendSize);
sendCount = 0;
sendSize = 0;
}
}
else
{
if (nBytesSent < 0 && InetErrno == EAGAIN && sent_any)
break;
// Send failed
#if defined DEBUG_TRANSPORTER
ndbout_c("Send Failure(disconnect==%d) to node = %d nBytesSent = %d "
"errno = %d strerror = %s",
DISCONNECT_ERRNO(InetErrno, nBytesSent),
remoteNodeId, nBytesSent, InetErrno,
(char*)ndbstrerror(InetErrno));
#endif
if(DISCONNECT_ERRNO(InetErrno, nBytesSent)){
doDisconnect();
report_disconnect(InetErrno);
}
return false;
}
}
return true;
}
int Ndb_cluster_connection::connect(int no_retries, int retry_delay_in_seconds,
int verbose)
{
struct ndb_mgm_reply mgm_reply;
DBUG_ENTER("Ndb_cluster_connection::connect");
do {
if (m_impl.m_config_retriever == 0)
DBUG_RETURN(-1);
if (m_impl.m_config_retriever->do_connect(no_retries,
retry_delay_in_seconds,
verbose))
DBUG_RETURN(1); // mgmt server not up yet
Uint32 nodeId = m_impl.m_config_retriever->allocNodeId(4/*retries*/,
3/*delay*/);
if(nodeId == 0)
break;
ndb_mgm_configuration * props = m_impl.m_config_retriever->getConfig();
if(props == 0)
break;
m_impl.m_transporter_facade->start_instance(nodeId, props);
if (m_impl.init_nodes_vector(nodeId, *props))
{
ndbout_c("Ndb_cluster_connection::connect: malloc failure");
DBUG_RETURN(-1);
}
for(unsigned i=0;
i<m_impl.m_transporter_facade->get_registry()->m_transporter_interface.size();
i++)
ndb_mgm_set_connection_int_parameter(m_impl.m_config_retriever->get_mgmHandle(),
nodeId,
m_impl.m_transporter_facade->get_registry()
->m_transporter_interface[i]
.m_remote_nodeId,
CFG_CONNECTION_SERVER_PORT,
m_impl.m_transporter_facade->get_registry()
->m_transporter_interface[i]
.m_s_service_port,
&mgm_reply);
ndb_mgm_destroy_configuration(props);
m_impl.m_transporter_facade->connected();
DBUG_RETURN(0);
} while(0);
ndbout << "Configuration error: ";
const char* erString = m_impl.m_config_retriever->getErrorString();
if (erString == 0) {
erString = "No error specified!";
}
ndbout << erString << endl;
DBUG_RETURN(-1);
}
static int
checkThreadResults(ThreadData* pt){
for (unsigned int i = 0; i < tNoOfThreads; i++){
if(pt[i].threadResult != 0){
ndbout_c("Thread%d reported fatal error %d", i, pt[i].threadResult);
return -1;
}
}
return 0;
}
static Uint32
switchRef(Uint32 block, Uint32 node)
{
const Uint32 ref = numberToRef(block, node);
#ifdef DBINFO_SCAN_TRACE
ndbout_c("Dbinfo: switching to %s in node %d, ref: 0x%.8x",
getBlockName(block, "<unknown>"), node, ref);
#endif
return ref;
}
void
WOPool::init(const Record_info& ri, const Pool_context& pc)
{
m_ctx = pc;
m_record_info = ri;
m_record_info.m_size = ((ri.m_size + 3) >> 2); // Align to word boundary
m_record_info.m_offset_magic = ((ri.m_offset_magic + 3) >> 2);
m_memroot = (WOPage*)m_ctx.get_memroot();
ndbout_c("WOPool::init(%x, %d)",ri.m_type_id, m_record_info.m_size);
}
void
AsyncFile::attach(AsyncIoThread* thr)
{
#if 0
ndbout_c("%p:%s attach to %p (m_thread: %p)", this, theFileName.c_str(), thr,
m_thread);
#endif
assert(m_thread == 0);
m_thread = thr;
}
/**
* Report average send length in bytes (4096 last sends)
*/
void
reportSendLen(void * callbackObj, NodeId nodeId, Uint32 count, Uint64 bytes){
#ifdef REPORT_TRANSPORTER
ndbout_c("REPORT_TRANSP: reportSendLen (nodeId=%d, bytes/count=%d)",
(int)nodeId, (Uint32)(bytes/count));
#endif
(void)nodeId;
(void)count;
(void)bytes;
}
int
main(void) {
g_client.connect();
srand(time(0));
for(int i = 0; i<1000; i++) {
int sz = g_procs.size();
int test = rand() % 100;
if(sz == 0 || test < 10) {
define();
continue;
}
list();
int proc = rand() % g_procs.size();
SimpleCpcClient::Process & p = g_procs[proc];
if(p.m_status == "running" && test > 50) {
ndbout_c("undefine %d: %s (running)", p.m_id, p.m_name.c_str());
undefine(p);
g_procs.erase(proc);
continue;
}
if(p.m_status == "running" && test <= 50) {
ndbout_c("stop %d: %s(running)", p.m_id, p.m_name.c_str());
stop(p);
continue;
}
if(p.m_status == "stopped" && test > 50) {
ndbout_c("undefine %d: %s(stopped)", p.m_id, p.m_name.c_str());
undefine(p);
g_procs.erase(proc);
continue;
}
if(p.m_status == "stopped" && test <= 50) {
ndbout_c("start %d %s(stopped)", p.m_id, p.m_name.c_str());
start(p);
continue;
}
ndbout_c("Unknown: %s", p.m_status.c_str());
}
}
bool
TCP_Transporter::setSocketNonBlocking(NDB_SOCKET_TYPE socket){
unsigned long ul = 1;
if(ioctlsocket(socket, FIONBIO, &ul))
{
#ifdef DEBUG_TRANSPORTER
ndbout_c("Set non-blocking server error3: %d", InetErrno);
#endif
}//if
return true;
}
int
connect(Vector<SimpleCpcClient*>& list){
for(size_t i = 0; i<list.size(); i++){
if(list[i]->connect() != 0){
ndbout_c("Failed to connect to %s:%d",
list[i]->getHost(), list[i]->getPort());
delete list[i]; list[i] = 0;
}
}
return 0;
}
static
void usage(const char *prog)
{
ndbout_c(
"Usage: %s [-l]\n"
" -l Use logging and checkpointing on tables\n",
prog);
exit(1);
}
void Cmvmi::execCONNECT_REP(Signal *signal){
const Uint32 hostId = signal->theData[0];
jamEntry();
const NodeInfo::NodeType type = (NodeInfo::NodeType)getNodeInfo(hostId).m_type;
ndbrequire(type != NodeInfo::INVALID);
globalData.m_nodeInfo[hostId].m_version = 0;
globalData.m_nodeInfo[hostId].m_signalVersion = 0;
if(type == NodeInfo::DB || globalData.theStartLevel >= NodeState::SL_STARTED){
jam();
/**
* Inform QMGR that client has connected
*/
signal->theData[0] = hostId;
sendSignal(QMGR_REF, GSN_CONNECT_REP, signal, 1, JBA);
} else if(globalData.theStartLevel == NodeState::SL_CMVMI ||
globalData.theStartLevel == NodeState::SL_STARTING) {
jam();
/**
* Someone connected before start was finished
*/
if(type == NodeInfo::MGM){
jam();
signal->theData[0] = hostId;
sendSignal(QMGR_REF, GSN_CONNECT_REP, signal, 1, JBA);
} else {
/**
* Dont allow api nodes to connect
*/
ndbout_c("%d %d %d", hostId, type, globalData.theStartLevel);
abort();
globalTransporterRegistry.do_disconnect(hostId);
}
}
/* Automatically subscribe events for MGM nodes.
*/
if(type == NodeInfo::MGM){
jam();
globalTransporterRegistry.setIOState(hostId, NoHalt);
}
//------------------------------------------
// Also report this event to the Event handler
//------------------------------------------
signal->theData[0] = NDB_LE_Connected;
signal->theData[1] = hostId;
signal->header.theLength = 2;
execEVENT_REP(signal);
}
void
checkData(SignalHeader * const header, Uint8 prio, Uint32 * const theData,
LinearSectionPtr ptr[3]){
Uint32 expectedLength = 0;
if(prio == 0)
expectedLength = 17;
else
expectedLength = 19;
if(header->theLength != expectedLength){
ndbout << "Unexpected signal length: " << header->theLength
<< " expected: " << expectedLength << endl;
abort();
}
if(header->theVerId_signalNumber != expectedLength + 1)
abort();
if(header->theReceiversBlockNumber != expectedLength + 2)
abort();
if(refToBlock(header->theSendersBlockRef) != expectedLength + 3)
abort();
if(header->theSendersSignalId != expectedLength + 5)
abort();
if(header->theTrace != expectedLength + 6)
abort();
if(header->m_noOfSections != (prio == 0 ? 0 : 1))
abort();
if(header->m_fragmentInfo != (prio + 1))
abort();
Uint32 dataWordStart = header->theLength ;
for(unsigned i = 0; i<header->theLength; i++){
if(theData[i] != i){ //dataWordStart){
ndbout << "data corrupt!\n" << endl;
abort();
}
dataWordStart ^= (~i*i);
}
if(prio != 0){
ndbout_c("Found section");
if(ptr[0].sz != header->theLength)
abort();
if(memcmp(ptr[0].p, theData, (ptr[0].sz * 4)) != 0)
abort();
}
}
void
ndbSetOwnVersion() {
char buf[256];
if (NdbEnv_GetEnv("NDB_SETVERSION", buf, sizeof(buf))) {
Uint32 _v1,_v2,_v3;
if (sscanf(buf, "%u.%u.%u", &_v1, &_v2, &_v3) == 3) {
ndbOwnVersionTesting = MAKE_VERSION(_v1,_v2,_v3);
ndbout_c("Testing: Version set to 0x%x", ndbOwnVersionTesting);
}
}
}
inline
bool
FsBuffer::getWritePtr(Uint32 ** ptr, Uint32 sz){
assert(sz <= m_maxWrite);
Uint32 * Tp = m_start;
const Uint32 Tw = m_writeIndex;
const Uint32 sz1 = m_free;
if(sz1 > sz){ // Note at least 1 word of slack
* ptr = &Tp[Tw];
DEBUG(ndbout_c("getWritePtr(%d) Tw: %d sz1: %d -> true",
sz, Tw, sz1));
return true;
}
DEBUG(ndbout_c("getWritePtr(%d) Tw: %d sz1: %d -> false",
sz, Tw, sz1));
return false;
}
NdbObjectIdMap::NdbObjectIdMap(NdbMutex* mutex, Uint32 sz, Uint32 eSz)
{
m_size = 0;
m_firstFree = InvalidId;
m_map = 0;
m_mutex = mutex;
m_expandSize = eSz;
expand(sz);
#ifdef DEBUG_OBJECTMAP
ndbout_c("NdbObjectIdMap:::NdbObjectIdMap(%u)", sz);
#endif
}
void Dbinfo::execDUMP_STATE_ORD(Signal* signal)
{
jamEntry();
switch(signal->theData[0])
{
case DumpStateOrd::DbinfoListTables:
jam();
ndbout_c("--- BEGIN NDB$INFO.TABLES ---");
for(int i = 0; i < Ndbinfo::getNumTables(); i++)
{
const Ndbinfo::Table& tab = Ndbinfo::getTable(i);
ndbout_c("%d,%s", i, tab.m.name);
}
ndbout_c("--- END NDB$INFO.TABLES ---");
break;
case DumpStateOrd::DbinfoListColumns:
jam();
ndbout_c("--- BEGIN NDB$INFO.COLUMNS ---");
for(int i = 0; i < Ndbinfo::getNumTables(); i++)
{
const Ndbinfo::Table& tab = Ndbinfo::getTable(i);
for(int j = 0; j < tab.m.ncols; j++)
ndbout_c("%d,%d,%s,%d", i, j,
tab.col[j].name, tab.col[j].coltype);
}
ndbout_c("--- END NDB$INFO.COLUMNS ---");
break;
};
}
/**
* Move to the first operation performed on this tuple
*/
void
Dbtup::findFirstOp(OperationrecPtr & firstPtr)
{
jam();
printf("Detect out-of-order commit(%u) -> ", firstPtr.i);
ndbassert(!firstPtr.p->is_first_operation());
while(firstPtr.p->prevActiveOp != RNIL)
{
firstPtr.i = firstPtr.p->prevActiveOp;
c_operation_pool.getPtr(firstPtr);
}
ndbout_c("%u", firstPtr.i);
}
void print(Uint32 i, ConfigValues::ConstIterator & cf){
ndbout_c("---");
for(Uint32 j = 2; j<=7; j++){
switch(cf.getTypeOf(j)){
case ConfigValues::IntType:
ndbout_c("Node %d : CFG(%d) : %d",
i, j, cf.get(j, 999));
break;
case ConfigValues::Int64Type:
ndbout_c("Node %d : CFG(%d) : %lld (64)",
i, j, cf.get64(j, 999));
break;
case ConfigValues::StringType:
ndbout_c("Node %d : CFG(%d) : %s",
i, j, cf.get(j, "<NOT FOUND>"));
break;
default:
ndbout_c("Node %d : CFG(%d) : TYPE: %d",
i, j, cf.getTypeOf(j));
}
}
}
inline
void
FsBuffer::updateWritePtr(Uint32 sz){
assert(sz <= m_maxWrite);
Uint32 * Tp = m_start;
const Uint32 Tw = m_writeIndex;
const Uint32 Ts = m_size;
const Uint32 Tnew = (Tw + sz);
m_free -= sz;
if(Tnew < Ts){
m_writeIndex = Tnew;
DEBUG(ndbout_c("updateWritePtr(%d) m_writeIndex: %d",
sz, m_writeIndex));
return;
}
memcpy(Tp, &Tp[Ts], (Tnew - Ts) << 2);
m_writeIndex = Tnew - Ts;
DEBUG(ndbout_c("updateWritePtr(%d) m_writeIndex: %d",
sz, m_writeIndex));
}
void
RWPool::init(const Record_info& ri, const Pool_context& pc)
{
m_ctx = pc;
m_record_info = ri;
m_record_info.m_size = ((ri.m_size + 3) >> 2); // Align to word boundary
m_record_info.m_offset_magic = ((ri.m_offset_magic + 3) >> 2);
m_record_info.m_offset_next_pool = ((ri.m_offset_next_pool + 3) >> 2);
m_memroot = (RWPage*)m_ctx.get_memroot();
#ifdef VM_TRACE
ndbout_c("RWPool::init(%x, %d)",ri.m_type_id, m_record_info.m_size);
#endif
}
void FileDescriptor::printARecord( Uint32 recordIndex ) const {
ndbout << "------------------FILE DESCRIPTOR " << recordIndex
<<" ---------------------" << endl << endl;
ndbout_c("%-30s%-12s%-12s\n", "", "Decimal", "Hex");
for(int i = 1; i <= NO_MBYTE_IN_FILE; i++) {
ndbout_c("%s%2d%s%-12u%-12x", "Max GCI completed, mbyte ", i, ": ",
m_fdRecord[recordIndex].m_maxGciCompleted[i-1],
m_fdRecord[recordIndex].m_maxGciCompleted[i-1]);
}
for(int i = 1; i <= NO_MBYTE_IN_FILE; i++) {
ndbout_c("%s%2d%s%-12u%-12x", "Max GCI started, mbyte ", i, ": ",
m_fdRecord[recordIndex].m_maxGciStarted[i-1],
m_fdRecord[recordIndex].m_maxGciStarted[i-1]);
}
for(int i = 1; i <= NO_MBYTE_IN_FILE; i++) {
ndbout_c("%s%2d%s%-12u%-12x", "Last prepared ref, mbyte ", i, ": ",
m_fdRecord[recordIndex].m_lastPreparedReference[i-1],
m_fdRecord[recordIndex].m_lastPreparedReference[i-1]);
}
ndbout << endl;
}
void printErrorAndFlags(Uint32 used_flags) {
char buf[255];
sprintf(buf, "PEAF: errno=%d \"", errno);
strcat(buf, strerror(errno));
strcat(buf, "\" ");
strcat(buf, " flags: ");
switch(used_flags & 3){
case O_RDONLY:
strcat(buf, "O_RDONLY, ");
break;
case O_WRONLY:
strcat(buf, "O_WRONLY, ");
break;
case O_RDWR:
strcat(buf, "O_RDWR, ");
break;
default:
strcat(buf, "Unknown!!, ");
}
if((used_flags & O_APPEND)==O_APPEND)
strcat(buf, "O_APPEND, ");
if((used_flags & O_CREAT)==O_CREAT)
strcat(buf, "O_CREAT, ");
if((used_flags & O_EXCL)==O_EXCL)
strcat(buf, "O_EXCL, ");
if((used_flags & O_NOCTTY) == O_NOCTTY)
strcat(buf, "O_NOCTTY, ");
if((used_flags & O_NONBLOCK)==O_NONBLOCK)
strcat(buf, "O_NONBLOCK, ");
if((used_flags & O_TRUNC)==O_TRUNC)
strcat(buf, "O_TRUNC, ");
#ifdef O_DSYNC /* At least Darwin 7.9 doesn't have it */
if((used_flags & O_DSYNC)==O_DSYNC)
strcat(buf, "O_DSYNC, ");
#endif
if((used_flags & O_NDELAY)==O_NDELAY)
strcat(buf, "O_NDELAY, ");
#ifdef O_RSYNC /* At least Darwin 7.9 doesn't have it */
if((used_flags & O_RSYNC)==O_RSYNC)
strcat(buf, "O_RSYNC, ");
#endif
#ifdef O_SYNC
if((used_flags & O_SYNC)==O_SYNC)
strcat(buf, "O_SYNC, ");
#endif
DEBUG(ndbout_c(buf));
}