Home | History | Annotate | Download | only in payload_consumer 
      1 //
      2 // Copyright (C) 2012 The Android Open Source Project
      3 //
      4 // Licensed under the Apache License, Version 2.0 (the "License");
      5 // you may not use this file except in compliance with the License.
      6 // You may obtain a copy of the License at
      7 //
      8 //      http://www.apache.org/licenses/LICENSE-2.0
      9 //
     10 // Unless required by applicable law or agreed to in writing, software
     11 // distributed under the License is distributed on an "AS IS" BASIS,
     12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 // See the License for the specific language governing permissions and
     14 // limitations under the License.
     15 //
     16 
     17 #include "update_engine/payload_consumer/file_descriptor.h"
     18 
     19 #include <fcntl.h>
     20 #include <linux/fs.h>
     21 #include <sys/ioctl.h>
     22 #include <sys/stat.h>
     23 #include <sys/types.h>
     24 
     25 #include <base/posix/eintr_wrapper.h>
     26 
     27 #include "update_engine/common/utils.h"
     28 
     29 namespace chromeos_update_engine {
     30 
     31 bool EintrSafeFileDescriptor::Open(const char* path, int flags, mode_t mode) {
     32   CHECK_EQ(fd_, -1);
     33   return ((fd_ = HANDLE_EINTR(open(path, flags, mode))) >= 0);
     34 }
     35 
     36 bool EintrSafeFileDescriptor::Open(const char* path, int flags) {
     37   CHECK_EQ(fd_, -1);
     38   return ((fd_ = HANDLE_EINTR(open(path, flags))) >= 0);
     39 }
     40 
     41 ssize_t EintrSafeFileDescriptor::Read(void* buf, size_t count) {
     42   CHECK_GE(fd_, 0);
     43   return HANDLE_EINTR(read(fd_, buf, count));
     44 }
     45 
     46 ssize_t EintrSafeFileDescriptor::Write(const void* buf, size_t count) {
     47   CHECK_GE(fd_, 0);
     48 
     49   // Attempt repeated writes, as long as some progress is being made.
     50   char* char_buf = const_cast<char*>(reinterpret_cast<const char*>(buf));
     51   ssize_t written = 0;
     52   while (count > 0) {
     53     ssize_t ret = HANDLE_EINTR(write(fd_, char_buf, count));
     54 
     55     // Fail on either an error or no progress.
     56     if (ret <= 0)
     57       return (written ? written : ret);
     58     written += ret;
     59     count -= ret;
     60     char_buf += ret;
     61   }
     62   return written;
     63 }
     64 
     65 off64_t EintrSafeFileDescriptor::Seek(off64_t offset, int whence) {
     66   CHECK_GE(fd_, 0);
     67   return lseek64(fd_, offset, whence);
     68 }
     69 
     70 uint64_t EintrSafeFileDescriptor::BlockDevSize() {
     71   if (fd_ < 0)
     72     return 0;
     73   struct stat stbuf;
     74   if (fstat(fd_, &stbuf) < 0) {
     75     PLOG(ERROR) << "Error stat-ing fd " << fd_;
     76     return 0;
     77   }
     78   if (!S_ISBLK(stbuf.st_mode))
     79     return 0;
     80   off_t block_size = utils::BlockDevSize(fd_);
     81   return block_size < 0 ? 0 : block_size;
     82 }
     83 
     84 bool EintrSafeFileDescriptor::BlkIoctl(int request,
     85                                        uint64_t start,
     86                                        uint64_t length,
     87                                        int* result) {
     88   // If the ioctl BLKZEROOUT is not defined, just fail to perform any of these
     89   // operations.
     90 #ifndef BLKZEROOUT
     91   return false;
     92 #else  // defined(BLKZEROOUT)
     93   DCHECK(request == BLKDISCARD || request == BLKZEROOUT ||
     94          request == BLKSECDISCARD);
     95   // On some devices, the BLKDISCARD will actually read back as zeros, instead
     96   // of "undefined" data. The BLKDISCARDZEROES ioctl tells whether that's the
     97   // case, so we issue a BLKDISCARD in those cases to speed up the writes.
     98   unsigned int arg;
     99   if (request == BLKZEROOUT && ioctl(fd_, BLKDISCARDZEROES, &arg) == 0 && arg)
    100     request = BLKDISCARD;
    101 
    102   // Ensure the |fd_| is in O_DIRECT mode during this operation, so the write
    103   // cache for this region is invalidated. This is required since otherwise
    104   // reading back this region could consume stale data from the cache.
    105   int flags = fcntl(fd_, F_GETFL, 0);
    106   if (flags == -1) {
    107     PLOG(WARNING) << "Couldn't get flags on fd " << fd_;
    108     return false;
    109   }
    110   if ((flags & O_DIRECT) == 0 && fcntl(fd_, F_SETFL, flags | O_DIRECT) == -1) {
    111     PLOG(WARNING) << "Couldn't set O_DIRECT on fd " << fd_;
    112     return false;
    113   }
    114 
    115   uint64_t range[2] = {start, length};
    116   *result = ioctl(fd_, request, range);
    117 
    118   if ((flags & O_DIRECT) == 0 && fcntl(fd_, F_SETFL, flags) == -1) {
    119     PLOG(WARNING) << "Couldn't remove O_DIRECT on fd " << fd_;
    120     return false;
    121   }
    122   return true;
    123 #endif  // defined(BLKZEROOUT)
    124 }
    125 
    126 bool EintrSafeFileDescriptor::Flush() {
    127   CHECK_GE(fd_, 0);
    128   return true;
    129 }
    130 
    131 bool EintrSafeFileDescriptor::Close() {
    132   CHECK_GE(fd_, 0);
    133   if (IGNORE_EINTR(close(fd_)))
    134     return false;
    135   fd_ = -1;
    136   return true;
    137 }
    138 
    139 }  // namespace chromeos_update_engine
    140