file.h

/***************************************************************************
 * include/stxxl/bits/io/file.h
 *
 * Part of the STXXL. See http://stxxl.sourceforge.net
 *
 * Copyright (C) 2002 Roman Dementiev <[email protected]>
 * Copyright (C) 2008, 2010 Andreas Beckmann <[email protected]>
 * Copyright (C) 2008, 2009 Johannes Singler <[email protected]>
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 **************************************************************************/

#ifndef STXXL_IO_FILE_HEADER
#define STXXL_IO_FILE_HEADER

#ifdef STXXL_BOOST_CONFIG
 #include <boost/config.hpp>
#endif

#if defined (__linux__)
 #define STXXL_CHECK_BLOCK_ALIGNING
#endif

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

#ifdef BOOST_MSVC
// this is not stxxl/bits/io/io.h !
 #include <io.h>
#else
 #include <unistd.h>
 #include <sys/resource.h>
 #include <sys/wait.h>
#endif


//#ifdef __sun__
//#define O_DIRECT 0
//#endif

#ifndef O_SYNC
 #define O_SYNC 0
#endif
#ifndef O_RSYNC
 #define O_RSYNC 0
#endif
#ifndef O_DSYNC
 #define O_DSYNC 0
#endif

#if defined (__linux__)
 #if ! defined(O_DIRECT)
 #error O_DIRECT is not defined while __linux__ is - PLEASE REPORT THIS BUG
 #endif
//#include <asm/fcntl.h>
// FIXME: In which conditions is this not defined? Why only i386 and alpha? Why not amd64?
 #if !defined (O_DIRECT) && (defined (__alpha__) || defined (__i386__))
 #define O_DIRECT 040000 /* direct disk access */
 #endif
#endif

#ifndef O_DIRECT
 #define O_DIRECT O_SYNC
#endif


#include <cassert>

#include <stxxl/bits/libstxxl.h>
#include <stxxl/bits/namespace.h>
#include <stxxl/bits/noncopyable.h>
#include <stxxl/bits/common/exceptions.h>
#include <stxxl/bits/common/mutex.h>
#include <stxxl/bits/io/request.h>
#include <stxxl/bits/io/request_ptr.h>


__STXXL_BEGIN_NAMESPACE



class file : private noncopyable
{
 mutex request_ref_cnt_mutex;
 int request_ref_cnt;

protected:
 file() : request_ref_cnt(0) { }

public:
 // the offset of a request, also the size of the file
 typedef request::offset_type offset_type;
 // the size of a request
 typedef request::size_type size_type;


 enum open_mode
 {
 RDONLY = 1, 
 WRONLY = 2, 
 RDWR = 4, 
 CREAT = 8, 
 DIRECT = 16, 
 TRUNC = 32, 
 SYNC = 64, 
 NO_LOCK = 128, 
 };

 static const int DEFAULT_QUEUE = -1;
 static const int NO_QUEUE = -2;
 static const int NO_ALLOCATOR = -1;

 virtual request_ptr aread(void * buffer, offset_type pos, size_type bytes,
 const completion_handler & on_cmpl) = 0;

 virtual request_ptr awrite(void * buffer, offset_type pos, size_type bytes,
 const completion_handler & on_cmpl) = 0;

 virtual void serve(const request * req) throw (io_error) = 0;

 void add_request_ref()
 {
 scoped_mutex_lock Lock(request_ref_cnt_mutex);
 ++request_ref_cnt;
 }

 void delete_request_ref()
 {
 scoped_mutex_lock Lock(request_ref_cnt_mutex);
 assert(request_ref_cnt > 0);
 --request_ref_cnt;
 }

 int get_request_nref()
 {
 scoped_mutex_lock Lock(request_ref_cnt_mutex);
 return request_ref_cnt;
 }

 virtual void set_size(offset_type newsize) = 0;
 virtual offset_type size() = 0;
 virtual int get_queue_id() const = 0;
 virtual int get_allocator_id() const = 0;

 virtual int get_physical_device_id() const
 {
 return get_queue_id();
 }

 virtual void lock() = 0;

 virtual void discard(offset_type offset, offset_type size)
 {
 STXXL_UNUSED(offset);
 STXXL_UNUSED(size);
 }

 virtual void export_files(offset_type offset, offset_type length, std::string prefix)
 {
 STXXL_UNUSED(offset);
 STXXL_UNUSED(length);
 STXXL_UNUSED(prefix);
 }

 virtual void remove() { }

 virtual ~file()
 {
 int nr = get_request_nref();
 if (nr != 0)
 STXXL_ERRMSG("stxxl::file is being deleted while there are still " << nr << " (unfinished) requests referencing it");
 }

 virtual const char * io_type() const
 {
 return "none";
 }
};


__STXXL_END_NAMESPACE

#endif // !STXXL_IO_FILE_HEADER
// vim: et:ts=4:sw=4