base/files/file_posix.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/file.h"
   6
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <sys/stat.h>
  10 #include <unistd.h>
  11
  12 #include "base/files/file_path.h"
  13 #include "base/logging.h"
  14 #include "base/metrics/sparse_histogram.h"
  15 // TODO(rvargas): remove this (needed for kInvalidPlatformFileValue).
  16 #include "base/platform_file.h"
  17 #include "base/posix/eintr_wrapper.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/threading/thread_restrictions.h"
  20
  21 #if defined(OS_ANDROID)
  22 #include "base/os_compat_android.h"
  23 #endif
  24
  25 namespace base {
  26
  27 // Make sure our Whence mappings match the system headers.
  28 COMPILE_ASSERT(File::FROM_BEGIN   == SEEK_SET &&
  29                File::FROM_CURRENT == SEEK_CUR &&
  30                File::FROM_END     == SEEK_END, whence_matches_system);
  31
  32 namespace {
  33
  34 #if defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL)
  35 static int CallFstat(int fd, stat_wrapper_t *sb) {
  36   base::ThreadRestrictions::AssertIOAllowed();
  37   return fstat(fd, sb);
  38 }
  39 #else
  40 static int CallFstat(int fd, stat_wrapper_t *sb) {
  41   base::ThreadRestrictions::AssertIOAllowed();
  42   return fstat64(fd, sb);
  43 }
  44 #endif
  45
  46 // NaCl doesn't provide the following system calls, so either simulate them or
  47 // wrap them in order to minimize the number of #ifdef's in this file.
  48 #if !defined(OS_NACL)
  49 static bool IsOpenAppend(PlatformFile file) {
  50   return (fcntl(file, F_GETFL) & O_APPEND) != 0;
  51 }
  52
  53 static int CallFtruncate(PlatformFile file, int64 length) {
  54   return HANDLE_EINTR(ftruncate(file, length));
  55 }
  56
  57 static int CallFsync(PlatformFile file) {
  58   return HANDLE_EINTR(fsync(file));
  59 }
  60
  61 static int CallFutimes(PlatformFile file, const struct timeval times[2]) {
  62 #ifdef __USE_XOPEN2K8
  63   // futimens should be available, but futimes might not be
  64   // http://pubs.opengroup.org/onlinepubs/9699919799/
  65
  66   timespec ts_times[2];
  67   ts_times[0].tv_sec  = times[0].tv_sec;
  68   ts_times[0].tv_nsec = times[0].tv_usec * 1000;
  69   ts_times[1].tv_sec  = times[1].tv_sec;
  70   ts_times[1].tv_nsec = times[1].tv_usec * 1000;
  71
  72   return futimens(file, ts_times);
  73 #else
  74   return futimes(file, times);
  75 #endif
  76 }
  77
  78 static File::Error CallFctnlFlock(PlatformFile file, bool do_lock) {
  79   struct flock lock;
  80   lock.l_type = F_WRLCK;
  81   lock.l_whence = SEEK_SET;
  82   lock.l_start = 0;
  83   lock.l_len = 0;  // Lock entire file.
  84   if (HANDLE_EINTR(fcntl(file, do_lock ? F_SETLK : F_UNLCK, &lock)) == -1)
  85     return File::OSErrorToFileError(errno);
  86   return File::FILE_OK;
  87 }
  88 #else  // defined(OS_NACL)
  89
  90 static bool IsOpenAppend(PlatformFile file) {
  91   // NaCl doesn't implement fcntl. Since NaCl's write conforms to the POSIX
  92   // standard and always appends if the file is opened with O_APPEND, just
  93   // return false here.
  94   return false;
  95 }
  96
  97 static int CallFtruncate(PlatformFile file, int64 length) {
  98   NOTIMPLEMENTED();  // NaCl doesn't implement ftruncate.
  99   return 0;
 100 }
 101
 102 static int CallFsync(PlatformFile file) {
 103   NOTIMPLEMENTED();  // NaCl doesn't implement fsync.
 104   return 0;
 105 }
 106
 107 static int CallFutimes(PlatformFile file, const struct timeval times[2]) {
 108   NOTIMPLEMENTED();  // NaCl doesn't implement futimes.
 109   return 0;
 110 }
 111
 112 static File::Error CallFctnlFlock(PlatformFile file, bool do_lock) {
 113   NOTIMPLEMENTED();  // NaCl doesn't implement flock struct.
 114   return File::FILE_ERROR_INVALID_OPERATION;
 115 }
 116 #endif  // defined(OS_NACL)
 117
 118 }  // namespace
 119
 120 void File::Info::FromStat(const stat_wrapper_t& stat_info) {
 121   is_directory = S_ISDIR(stat_info.st_mode);
 122   is_symbolic_link = S_ISLNK(stat_info.st_mode);
 123   size = stat_info.st_size;
 124
 125 #if defined(OS_LINUX)
 126   time_t last_modified_sec = stat_info.st_mtim.tv_sec;
 127   int64 last_modified_nsec = stat_info.st_mtim.tv_nsec;
 128   time_t last_accessed_sec = stat_info.st_atim.tv_sec;
 129   int64 last_accessed_nsec = stat_info.st_atim.tv_nsec;
 130   time_t creation_time_sec = stat_info.st_ctim.tv_sec;
 131   int64 creation_time_nsec = stat_info.st_ctim.tv_nsec;
 132 #elif defined(OS_ANDROID)
 133   time_t last_modified_sec = stat_info.st_mtime;
 134   int64 last_modified_nsec = stat_info.st_mtime_nsec;
 135   time_t last_accessed_sec = stat_info.st_atime;
 136   int64 last_accessed_nsec = stat_info.st_atime_nsec;
 137   time_t creation_time_sec = stat_info.st_ctime;
 138   int64 creation_time_nsec = stat_info.st_ctime_nsec;
 139 #elif defined(OS_MACOSX) || defined(OS_IOS) || defined(OS_BSD)
 140   time_t last_modified_sec = stat_info.st_mtimespec.tv_sec;
 141   int64 last_modified_nsec = stat_info.st_mtimespec.tv_nsec;
 142   time_t last_accessed_sec = stat_info.st_atimespec.tv_sec;
 143   int64 last_accessed_nsec = stat_info.st_atimespec.tv_nsec;
 144   time_t creation_time_sec = stat_info.st_ctimespec.tv_sec;
 145   int64 creation_time_nsec = stat_info.st_ctimespec.tv_nsec;
 146 #else
 147   time_t last_modified_sec = stat_info.st_mtime;
 148   int64 last_modified_nsec = 0;
 149   time_t last_accessed_sec = stat_info.st_atime;
 150   int64 last_accessed_nsec = 0;
 151   time_t creation_time_sec = stat_info.st_ctime;
 152   int64 creation_time_nsec = 0;
 153 #endif
 154
 155   last_modified =
 156       Time::FromTimeT(last_modified_sec) +
 157       TimeDelta::FromMicroseconds(last_modified_nsec /
 158                                   Time::kNanosecondsPerMicrosecond);
 159
 160   last_accessed =
 161       Time::FromTimeT(last_accessed_sec) +
 162       TimeDelta::FromMicroseconds(last_accessed_nsec /
 163                                   Time::kNanosecondsPerMicrosecond);
 164
 165   creation_time =
 166       Time::FromTimeT(creation_time_sec) +
 167       TimeDelta::FromMicroseconds(creation_time_nsec /
 168                                   Time::kNanosecondsPerMicrosecond);
 169 }
 170
 171 // NaCl doesn't implement system calls to open files directly.
 172 #if !defined(OS_NACL)
 173 // TODO(erikkay): does it make sense to support FLAG_EXCLUSIVE_* here?
 174 void File::InitializeUnsafe(const FilePath& name, uint32 flags) {
 175   base::ThreadRestrictions::AssertIOAllowed();
 176   DCHECK(!IsValid());
 177
 178   int open_flags = 0;
 179   if (flags & FLAG_CREATE)
 180     open_flags = O_CREAT | O_EXCL;
 181
 182   created_ = false;
 183
 184   if (flags & FLAG_CREATE_ALWAYS) {
 185     DCHECK(!open_flags);
 186     DCHECK(flags & FLAG_WRITE);
 187     open_flags = O_CREAT | O_TRUNC;
 188   }
 189
 190   if (flags & FLAG_OPEN_TRUNCATED) {
 191     DCHECK(!open_flags);
 192     DCHECK(flags & FLAG_WRITE);
 193     open_flags = O_TRUNC;
 194   }
 195
 196   if (!open_flags && !(flags & FLAG_OPEN) && !(flags & FLAG_OPEN_ALWAYS)) {
 197     NOTREACHED();
 198     errno = EOPNOTSUPP;
 199     error_details_ = FILE_ERROR_FAILED;
 200     return;
 201   }
 202
 203   if (flags & FLAG_WRITE && flags & FLAG_READ) {
 204     open_flags |= O_RDWR;
 205   } else if (flags & FLAG_WRITE) {
 206     open_flags |= O_WRONLY;
 207   } else if (!(flags & FLAG_READ) &&
 208              !(flags & FLAG_WRITE_ATTRIBUTES) &&
 209              !(flags & FLAG_APPEND) &&
 210              !(flags & FLAG_OPEN_ALWAYS)) {
 211     NOTREACHED();
 212   }
 213
 214   if (flags & FLAG_TERMINAL_DEVICE)
 215     open_flags |= O_NOCTTY | O_NDELAY;
 216
 217   if (flags & FLAG_APPEND && flags & FLAG_READ)
 218     open_flags |= O_APPEND | O_RDWR;
 219   else if (flags & FLAG_APPEND)
 220     open_flags |= O_APPEND | O_WRONLY;
 221
 222   COMPILE_ASSERT(O_RDONLY == 0, O_RDONLY_must_equal_zero);
 223
 224   int mode = S_IRUSR | S_IWUSR;
 225 #if defined(OS_CHROMEOS)
 226   mode |= S_IRGRP | S_IROTH;
 227 #endif
 228
 229   int descriptor = HANDLE_EINTR(open(name.value().c_str(), open_flags, mode));
 230
 231   if (flags & FLAG_OPEN_ALWAYS) {
 232     if (descriptor < 0) {
 233       open_flags |= O_CREAT;
 234       if (flags & FLAG_EXCLUSIVE_READ || flags & FLAG_EXCLUSIVE_WRITE)
 235         open_flags |= O_EXCL;   // together with O_CREAT implies O_NOFOLLOW
 236
 237       descriptor = HANDLE_EINTR(open(name.value().c_str(), open_flags, mode));
 238       if (descriptor >= 0)
 239         created_ = true;
 240     }
 241   }
 242
 243   if (descriptor < 0) {
 244     error_details_ = File::OSErrorToFileError(errno);
 245     return;
 246   }
 247
 248   if (flags & (FLAG_CREATE_ALWAYS | FLAG_CREATE))
 249     created_ = true;
 250
 251   if (flags & FLAG_DELETE_ON_CLOSE)
 252     unlink(name.value().c_str());
 253
 254   async_ = ((flags & FLAG_ASYNC) == FLAG_ASYNC);
 255   error_details_ = FILE_OK;
 256   file_.reset(descriptor);
 257 }
 258 #endif  // !defined(OS_NACL)
 259
 260 bool File::IsValid() const {
 261   return file_.is_valid();
 262 }
 263
 264 PlatformFile File::GetPlatformFile() const {
 265   return file_.get();
 266 }
 267
 268 PlatformFile File::TakePlatformFile() {
 269   return file_.release();
 270 }
 271
 272 void File::Close() {
 273   if (!IsValid())
 274     return;
 275
 276   base::ThreadRestrictions::AssertIOAllowed();
 277   file_.reset();
 278 }
 279
 280 int64 File::Seek(Whence whence, int64 offset) {
 281   base::ThreadRestrictions::AssertIOAllowed();
 282   DCHECK(IsValid());
 283   if (offset < 0)
 284     return -1;
 285
 286   return lseek(file_.get(), static_cast<off_t>(offset),
 287                static_cast<int>(whence));
 288 }
 289
 290 int File::Read(int64 offset, char* data, int size) {
 291   base::ThreadRestrictions::AssertIOAllowed();
 292   DCHECK(IsValid());
 293   if (size < 0)
 294     return -1;
 295
 296   int bytes_read = 0;
 297   int rv;
 298   do {
 299     rv = HANDLE_EINTR(pread(file_.get(), data + bytes_read,
 300                             size - bytes_read, offset + bytes_read));
 301     if (rv <= 0)
 302       break;
 303
 304     bytes_read += rv;
 305   } while (bytes_read < size);
 306
 307   return bytes_read ? bytes_read : rv;
 308 }
 309
 310 int File::ReadAtCurrentPos(char* data, int size) {
 311   base::ThreadRestrictions::AssertIOAllowed();
 312   DCHECK(IsValid());
 313   if (size < 0)
 314     return -1;
 315
 316   int bytes_read = 0;
 317   int rv;
 318   do {
 319     rv = HANDLE_EINTR(read(file_.get(), data + bytes_read, size - bytes_read));
 320     if (rv <= 0)
 321       break;
 322
 323     bytes_read += rv;
 324   } while (bytes_read < size);
 325
 326   return bytes_read ? bytes_read : rv;
 327 }
 328
 329 int File::ReadNoBestEffort(int64 offset, char* data, int size) {
 330   base::ThreadRestrictions::AssertIOAllowed();
 331   DCHECK(IsValid());
 332
 333   return HANDLE_EINTR(pread(file_.get(), data, size, offset));
 334 }
 335
 336 int File::ReadAtCurrentPosNoBestEffort(char* data, int size) {
 337   base::ThreadRestrictions::AssertIOAllowed();
 338   DCHECK(IsValid());
 339   if (size < 0)
 340     return -1;
 341
 342   return HANDLE_EINTR(read(file_.get(), data, size));
 343 }
 344
 345 int File::Write(int64 offset, const char* data, int size) {
 346   base::ThreadRestrictions::AssertIOAllowed();
 347
 348   if (IsOpenAppend(file_.get()))
 349     return WriteAtCurrentPos(data, size);
 350
 351   DCHECK(IsValid());
 352   if (size < 0)
 353     return -1;
 354
 355   int bytes_written = 0;
 356   int rv;
 357   do {
 358     rv = HANDLE_EINTR(pwrite(file_.get(), data + bytes_written,
 359                              size - bytes_written, offset + bytes_written));
 360     if (rv <= 0)
 361       break;
 362
 363     bytes_written += rv;
 364   } while (bytes_written < size);
 365
 366   return bytes_written ? bytes_written : rv;
 367 }
 368
 369 int File::WriteAtCurrentPos(const char* data, int size) {
 370   base::ThreadRestrictions::AssertIOAllowed();
 371   DCHECK(IsValid());
 372   if (size < 0)
 373     return -1;
 374
 375   int bytes_written = 0;
 376   int rv;
 377   do {
 378     rv = HANDLE_EINTR(write(file_.get(), data + bytes_written,
 379                             size - bytes_written));
 380     if (rv <= 0)
 381       break;
 382
 383     bytes_written += rv;
 384   } while (bytes_written < size);
 385
 386   return bytes_written ? bytes_written : rv;
 387 }
 388
 389 int File::WriteAtCurrentPosNoBestEffort(const char* data, int size) {
 390   base::ThreadRestrictions::AssertIOAllowed();
 391   DCHECK(IsValid());
 392   if (size < 0)
 393     return -1;
 394
 395   return HANDLE_EINTR(write(file_.get(), data, size));
 396 }
 397
 398 int64 File::GetLength() {
 399   DCHECK(IsValid());
 400
 401   stat_wrapper_t file_info;
 402   if (CallFstat(file_.get(), &file_info))
 403     return false;
 404
 405   return file_info.st_size;
 406 }
 407
 408 bool File::SetLength(int64 length) {
 409   base::ThreadRestrictions::AssertIOAllowed();
 410   DCHECK(IsValid());
 411   return !CallFtruncate(file_.get(), length);
 412 }
 413
 414 bool File::Flush() {
 415   base::ThreadRestrictions::AssertIOAllowed();
 416   DCHECK(IsValid());
 417   return !CallFsync(file_.get());
 418 }
 419
 420 bool File::SetTimes(Time last_access_time, Time last_modified_time) {
 421   base::ThreadRestrictions::AssertIOAllowed();
 422   DCHECK(IsValid());
 423
 424   timeval times[2];
 425   times[0] = last_access_time.ToTimeVal();
 426   times[1] = last_modified_time.ToTimeVal();
 427
 428   return !CallFutimes(file_.get(), times);
 429 }
 430
 431 bool File::GetInfo(Info* info) {
 432   DCHECK(IsValid());
 433
 434   stat_wrapper_t file_info;
 435   if (CallFstat(file_.get(), &file_info))
 436     return false;
 437
 438   info->FromStat(file_info);
 439   return true;
 440 }
 441
 442 File::Error File::Lock() {
 443   return CallFctnlFlock(file_.get(), true);
 444 }
 445
 446 File::Error File::Unlock() {
 447   return CallFctnlFlock(file_.get(), false);
 448 }
 449
 450 // Static.
 451 File::Error File::OSErrorToFileError(int saved_errno) {
 452   switch (saved_errno) {
 453     case EACCES:
 454     case EISDIR:
 455     case EROFS:
 456     case EPERM:
 457       return FILE_ERROR_ACCESS_DENIED;
 458 #if !defined(OS_NACL)  // ETXTBSY not defined by NaCl.
 459     case ETXTBSY:
 460       return FILE_ERROR_IN_USE;
 461 #endif
 462     case EEXIST:
 463       return FILE_ERROR_EXISTS;
 464     case ENOENT:
 465       return FILE_ERROR_NOT_FOUND;
 466     case EMFILE:
 467       return FILE_ERROR_TOO_MANY_OPENED;
 468     case ENOMEM:
 469       return FILE_ERROR_NO_MEMORY;
 470     case ENOSPC:
 471       return FILE_ERROR_NO_SPACE;
 472     case ENOTDIR:
 473       return FILE_ERROR_NOT_A_DIRECTORY;
 474     default:
 475 #if !defined(OS_NACL)  // NaCl build has no metrics code.
 476       UMA_HISTOGRAM_SPARSE_SLOWLY("PlatformFile.UnknownErrors.Posix",
 477                                   saved_errno);
 478 #endif
 479       return FILE_ERROR_FAILED;
 480   }
 481 }
 482
 483 void File::SetPlatformFile(PlatformFile file) {
 484   DCHECK(!file_.is_valid());
 485   file_.reset(file);
 486 }
 487
 488 }  // namespace base