~drizzle-trunk/drizzle/development

/* Copyright (C) 2003 MySQL AB

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */

#include <config.h>

#include <drizzled/internal/my_sys.h>

#include <errno.h>

#include <fcntl.h>

#include <drizzled/error.h>

namespace drizzled

{

namespace internal

{

/*

  Sync data in file to disk

  SYNOPSIS

    my_sync()

    fd			File descritor to sync

    my_flags		Flags (now only MY_WME is supported)

  NOTE

    If file system supports its, only file data is synced, not inode data.

    MY_IGNORE_BADFD is useful when fd is "volatile" - not protected by a

    mutex. In this case by the time of fsync(), fd may be already closed by

    another thread, or even reassigned to a different file. With this flag -

    MY_IGNORE_BADFD - such a situation will not be considered an error.

    (which is correct behaviour, if we know that the other thread synced the

    file before closing)

  RETURN

    0 ok

    -1 error

*/

int my_sync(int fd, myf my_flags)

{

  int res;

  do

  {

#if defined(F_FULLFSYNC)

    /*

      In Mac OS X >= 10.3 this call is safer than fsync() (it forces the

      disk's cache and guarantees ordered writes).

    */

    if (!(res= fcntl(fd, F_FULLFSYNC, 0)))

      break; /* ok */

    /* Some file systems don't support F_FULLFSYNC and fail above: */

#endif

#if defined(HAVE_FDATASYNC)

    res= fdatasync(fd);

#else

    res= fsync(fd);

#endif

  } while (res == -1 && errno == EINTR);

  if (res)

  {

    int er= errno;

    if (!(errno= er))

      errno= -1;                             /* Unknown error */

    if ((my_flags & MY_IGNORE_BADFD) &&

        (er == EBADF || er == EINVAL || er == EROFS))

    {

      res= 0;

    }

    else if (my_flags & MY_WME)

      my_error(EE_SYNC, MYF(ME_BELL+ME_WAITTANG), "unknown", errno);

  }

  return res;

} /* my_sync */

static const char cur_dir_name[]= {FN_CURLIB, 0};

/*

  Force directory information to disk.

  SYNOPSIS

    my_sync_dir()

    dir_name             the name of the directory

    my_flags             flags (MY_WME etc)

  RETURN

    0 if ok, !=0 if error

*/

#ifdef NEED_EXPLICIT_SYNC_DIR

int my_sync_dir(const char *dir_name, myf my_flags)

{

  int dir_fd;

  int res= 0;

  const char *correct_dir_name;

  /* Sometimes the path does not contain an explicit directory */

  correct_dir_name= (dir_name[0] == 0) ? cur_dir_name : dir_name;

  /*

    Syncing a dir may give EINVAL on tmpfs on Linux, which is ok.

    EIO on the other hand is very important. Hence MY_IGNORE_BADFD.

  */

  if ((dir_fd= my_open(correct_dir_name, O_RDONLY, MYF(my_flags))) >= 0)

  {

    if (my_sync(dir_fd, MYF(my_flags | MY_IGNORE_BADFD)))

      res= 2;

    if (my_close(dir_fd, MYF(my_flags)))

      res= 3;

  }

  else

    res= 1;

  return res;

}

#else

int my_sync_dir(const char *, myf)

{

  return 0;

}

#endif

/*

  Force directory information to disk.

  SYNOPSIS

    my_sync_dir_by_file()

    file_name            the name of a file in the directory

    my_flags             flags (MY_WME etc)

  RETURN

    0 if ok, !=0 if error

*/

#ifdef NEED_EXPLICIT_SYNC_DIR

int my_sync_dir_by_file(const char *file_name, myf my_flags)

{

  char dir_name[FN_REFLEN];

  size_t dir_name_length;

  dirname_part(dir_name, file_name, &dir_name_length);

  return my_sync_dir(dir_name, my_flags);

}

#else

int my_sync_dir_by_file(const char *, myf)

{

  return 0;

}

#endif

} /* namespace internal */

} /* namespace drizzled */