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
29namespace chromeos_update_engine {
30
31bool 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
36bool EintrSafeFileDescriptor::Open(const char* path, int flags) {
37  CHECK_EQ(fd_, -1);
38  return ((fd_ = HANDLE_EINTR(open(path, flags))) >= 0);
39}
40
41ssize_t EintrSafeFileDescriptor::Read(void* buf, size_t count) {
42  CHECK_GE(fd_, 0);
43  return HANDLE_EINTR(read(fd_, buf, count));
44}
45
46ssize_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
65off64_t EintrSafeFileDescriptor::Seek(off64_t offset, int whence) {
66  CHECK_GE(fd_, 0);
67  return lseek64(fd_, offset, whence);
68}
69
70uint64_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
84bool 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
126bool EintrSafeFileDescriptor::Close() {
127  CHECK_GE(fd_, 0);
128  if (IGNORE_EINTR(close(fd_)))
129    return false;
130  Reset();
131  return true;
132}
133
134void EintrSafeFileDescriptor::Reset() {
135  fd_ = -1;
136}
137
138}  // namespace chromeos_update_engine
139