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