Home | History | Annotate | Download | only in payload_consumer 
      1 //
      2 // Copyright (C) 2011 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/postinstall_runner_action.h"
     18 
     19 #include <fcntl.h>
     20 #include <signal.h>
     21 #include <stdlib.h>
     22 #include <sys/mount.h>
     23 #include <sys/types.h>
     24 #include <unistd.h>
     25 
     26 #include <cmath>
     27 
     28 #include <base/files/file_path.h>
     29 #include <base/files/file_util.h>
     30 #include <base/logging.h>
     31 #include <base/strings/string_split.h>
     32 #include <base/strings/string_util.h>
     33 
     34 #include "update_engine/common/action_processor.h"
     35 #include "update_engine/common/boot_control_interface.h"
     36 #include "update_engine/common/platform_constants.h"
     37 #include "update_engine/common/subprocess.h"
     38 #include "update_engine/common/utils.h"
     39 
     40 namespace {
     41 
     42 // The file descriptor number from the postinstall program's perspective where
     43 // it can report status updates. This can be any number greater than 2 (stderr),
     44 // but must be kept in sync with the "bin/postinst_progress" defined in the
     45 // sample_images.sh file.
     46 const int kPostinstallStatusFd = 3;
     47 
     48 }  // namespace
     49 
     50 namespace chromeos_update_engine {
     51 
     52 using brillo::MessageLoop;
     53 using std::string;
     54 using std::vector;
     55 
     56 void PostinstallRunnerAction::PerformAction() {
     57   CHECK(HasInputObject());
     58   install_plan_ = GetInputObject();
     59 
     60   if (install_plan_.powerwash_required) {
     61     if (hardware_->SchedulePowerwash()) {
     62       powerwash_scheduled_ = true;
     63     } else {
     64       return CompletePostinstall(ErrorCode::kPostinstallPowerwashError);
     65     }
     66   }
     67 
     68   // Initialize all the partition weights.
     69   partition_weight_.resize(install_plan_.partitions.size());
     70   total_weight_ = 0;
     71   for (size_t i = 0; i < install_plan_.partitions.size(); ++i) {
     72     // TODO(deymo): This code sets the weight to all the postinstall commands,
     73     // but we could remember how long they took in the past and use those
     74     // values.
     75     partition_weight_[i] = install_plan_.partitions[i].run_postinstall;
     76     total_weight_ += partition_weight_[i];
     77   }
     78   accumulated_weight_ = 0;
     79   ReportProgress(0);
     80 
     81   PerformPartitionPostinstall();
     82 }
     83 
     84 void PostinstallRunnerAction::PerformPartitionPostinstall() {
     85   if (!install_plan_.run_post_install) {
     86     LOG(INFO) << "Skipping post-install according to install plan.";
     87     return CompletePostinstall(ErrorCode::kSuccess);
     88   }
     89 
     90   if (install_plan_.download_url.empty()) {
     91     LOG(INFO) << "Skipping post-install during rollback";
     92     return CompletePostinstall(ErrorCode::kSuccess);
     93   }
     94 
     95   // Skip all the partitions that don't have a post-install step.
     96   while (current_partition_ < install_plan_.partitions.size() &&
     97          !install_plan_.partitions[current_partition_].run_postinstall) {
     98     VLOG(1) << "Skipping post-install on partition "
     99             << install_plan_.partitions[current_partition_].name;
    100     current_partition_++;
    101   }
    102   if (current_partition_ == install_plan_.partitions.size())
    103     return CompletePostinstall(ErrorCode::kSuccess);
    104 
    105   const InstallPlan::Partition& partition =
    106       install_plan_.partitions[current_partition_];
    107 
    108   const string mountable_device =
    109       utils::MakePartitionNameForMount(partition.target_path);
    110   if (mountable_device.empty()) {
    111     LOG(ERROR) << "Cannot make mountable device from " << partition.target_path;
    112     return CompletePostinstall(ErrorCode::kPostinstallRunnerError);
    113   }
    114 
    115   // Perform post-install for the current_partition_ partition. At this point we
    116   // need to call CompletePartitionPostinstall to complete the operation and
    117   // cleanup.
    118 #ifdef __ANDROID__
    119   fs_mount_dir_ = "/postinstall";
    120 #else   // __ANDROID__
    121   base::FilePath temp_dir;
    122   TEST_AND_RETURN(base::CreateNewTempDirectory("au_postint_mount", &temp_dir));
    123   fs_mount_dir_ = temp_dir.value();
    124 #endif  // __ANDROID__
    125 
    126   // Double check that the fs_mount_dir is not busy with a previous mounted
    127   // filesystem from a previous crashed postinstall step.
    128   if (utils::IsMountpoint(fs_mount_dir_)) {
    129     LOG(INFO) << "Found previously mounted filesystem at " << fs_mount_dir_;
    130     utils::UnmountFilesystem(fs_mount_dir_);
    131   }
    132 
    133   base::FilePath postinstall_path(partition.postinstall_path);
    134   if (postinstall_path.IsAbsolute()) {
    135     LOG(ERROR) << "Invalid absolute path passed to postinstall, use a relative"
    136                   "path instead: "
    137                << partition.postinstall_path;
    138     return CompletePostinstall(ErrorCode::kPostinstallRunnerError);
    139   }
    140 
    141   string abs_path =
    142       base::FilePath(fs_mount_dir_).Append(postinstall_path).value();
    143   if (!base::StartsWith(
    144           abs_path, fs_mount_dir_, base::CompareCase::SENSITIVE)) {
    145     LOG(ERROR) << "Invalid relative postinstall path: "
    146                << partition.postinstall_path;
    147     return CompletePostinstall(ErrorCode::kPostinstallRunnerError);
    148   }
    149 
    150 #ifdef __ANDROID__
    151   // In Chromium OS, the postinstall step is allowed to write to the block
    152   // device on the target image, so we don't mark it as read-only and should
    153   // be read-write since we just wrote to it during the update.
    154 
    155   // Mark the block device as read-only before mounting for post-install.
    156   if (!utils::SetBlockDeviceReadOnly(mountable_device, true)) {
    157     return CompletePartitionPostinstall(
    158         1, "Error marking the device " + mountable_device + " read only.");
    159   }
    160 #endif  // __ANDROID__
    161 
    162   if (!utils::MountFilesystem(mountable_device,
    163                               fs_mount_dir_,
    164                               MS_RDONLY,
    165                               partition.filesystem_type,
    166                               constants::kPostinstallMountOptions)) {
    167     return CompletePartitionPostinstall(
    168         1, "Error mounting the device " + mountable_device);
    169   }
    170 
    171   LOG(INFO) << "Performing postinst (" << partition.postinstall_path << " at "
    172             << abs_path << ") installed on device " << partition.target_path
    173             << " and mountable device " << mountable_device;
    174 
    175   // Logs the file format of the postinstall script we are about to run. This
    176   // will help debug when the postinstall script doesn't match the architecture
    177   // of our build.
    178   LOG(INFO) << "Format file for new " << partition.postinstall_path
    179             << " is: " << utils::GetFileFormat(abs_path);
    180 
    181   // Runs the postinstall script asynchronously to free up the main loop while
    182   // it's running.
    183   vector<string> command = {abs_path};
    184 #ifdef __ANDROID__
    185   // In Brillo and Android, we pass the slot number and status fd.
    186   command.push_back(std::to_string(install_plan_.target_slot));
    187   command.push_back(std::to_string(kPostinstallStatusFd));
    188 #else
    189   // Chrome OS postinstall expects the target rootfs as the first parameter.
    190   command.push_back(partition.target_path);
    191 #endif  // __ANDROID__
    192 
    193   current_command_ = Subprocess::Get().ExecFlags(
    194       command,
    195       Subprocess::kRedirectStderrToStdout,
    196       {kPostinstallStatusFd},
    197       base::Bind(&PostinstallRunnerAction::CompletePartitionPostinstall,
    198                  base::Unretained(this)));
    199   // Subprocess::Exec should never return a negative process id.
    200   CHECK_GE(current_command_, 0);
    201 
    202   if (!current_command_) {
    203     CompletePartitionPostinstall(1, "Postinstall didn't launch");
    204     return;
    205   }
    206 
    207   // Monitor the status file descriptor.
    208   progress_fd_ =
    209       Subprocess::Get().GetPipeFd(current_command_, kPostinstallStatusFd);
    210   int fd_flags = fcntl(progress_fd_, F_GETFL, 0) | O_NONBLOCK;
    211   if (HANDLE_EINTR(fcntl(progress_fd_, F_SETFL, fd_flags)) < 0) {
    212     PLOG(ERROR) << "Unable to set non-blocking I/O mode on fd " << progress_fd_;
    213   }
    214 
    215   progress_task_ = MessageLoop::current()->WatchFileDescriptor(
    216       FROM_HERE,
    217       progress_fd_,
    218       MessageLoop::WatchMode::kWatchRead,
    219       true,
    220       base::Bind(&PostinstallRunnerAction::OnProgressFdReady,
    221                  base::Unretained(this)));
    222 }
    223 
    224 void PostinstallRunnerAction::OnProgressFdReady() {
    225   char buf[1024];
    226   size_t bytes_read;
    227   do {
    228     bytes_read = 0;
    229     bool eof;
    230     bool ok =
    231         utils::ReadAll(progress_fd_, buf, arraysize(buf), &bytes_read, &eof);
    232     progress_buffer_.append(buf, bytes_read);
    233     // Process every line.
    234     vector<string> lines = base::SplitString(
    235         progress_buffer_, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
    236     if (!lines.empty()) {
    237       progress_buffer_ = lines.back();
    238       lines.pop_back();
    239       for (const auto& line : lines) {
    240         ProcessProgressLine(line);
    241       }
    242     }
    243     if (!ok || eof) {
    244       // There was either an error or an EOF condition, so we are done watching
    245       // the file descriptor.
    246       MessageLoop::current()->CancelTask(progress_task_);
    247       progress_task_ = MessageLoop::kTaskIdNull;
    248       return;
    249     }
    250   } while (bytes_read);
    251 }
    252 
    253 bool PostinstallRunnerAction::ProcessProgressLine(const string& line) {
    254   double frac = 0;
    255   if (sscanf(line.c_str(), "global_progress %lf", &frac) == 1 &&
    256       !std::isnan(frac)) {
    257     ReportProgress(frac);
    258     return true;
    259   }
    260 
    261   return false;
    262 }
    263 
    264 void PostinstallRunnerAction::ReportProgress(double frac) {
    265   if (!delegate_)
    266     return;
    267   if (current_partition_ >= partition_weight_.size()) {
    268     delegate_->ProgressUpdate(1.);
    269     return;
    270   }
    271   if (!std::isfinite(frac) || frac < 0)
    272     frac = 0;
    273   if (frac > 1)
    274     frac = 1;
    275   double postinst_action_progress =
    276       (accumulated_weight_ + partition_weight_[current_partition_] * frac) /
    277       total_weight_;
    278   delegate_->ProgressUpdate(postinst_action_progress);
    279 }
    280 
    281 void PostinstallRunnerAction::Cleanup() {
    282   utils::UnmountFilesystem(fs_mount_dir_);
    283 #ifndef __ANDROID__
    284   if (!base::DeleteFile(base::FilePath(fs_mount_dir_), false)) {
    285     PLOG(WARNING) << "Not removing temporary mountpoint " << fs_mount_dir_;
    286   }
    287 #endif  // !__ANDROID__
    288   fs_mount_dir_.clear();
    289 
    290   progress_fd_ = -1;
    291   if (progress_task_ != MessageLoop::kTaskIdNull) {
    292     MessageLoop::current()->CancelTask(progress_task_);
    293     progress_task_ = MessageLoop::kTaskIdNull;
    294   }
    295   progress_buffer_.clear();
    296 }
    297 
    298 void PostinstallRunnerAction::CompletePartitionPostinstall(
    299     int return_code, const string& output) {
    300   current_command_ = 0;
    301   Cleanup();
    302 
    303   if (return_code != 0) {
    304     LOG(ERROR) << "Postinst command failed with code: " << return_code;
    305     ErrorCode error_code = ErrorCode::kPostinstallRunnerError;
    306 
    307     if (return_code == 3) {
    308       // This special return code means that we tried to update firmware,
    309       // but couldn't because we booted from FW B, and we need to reboot
    310       // to get back to FW A.
    311       error_code = ErrorCode::kPostinstallBootedFromFirmwareB;
    312     }
    313 
    314     if (return_code == 4) {
    315       // This special return code means that we tried to update firmware,
    316       // but couldn't because we booted from FW B, and we need to reboot
    317       // to get back to FW A.
    318       error_code = ErrorCode::kPostinstallFirmwareRONotUpdatable;
    319     }
    320 
    321     // If postinstall script for this partition is optional we can ignore the
    322     // result.
    323     if (install_plan_.partitions[current_partition_].postinstall_optional) {
    324       LOG(INFO) << "Ignoring postinstall failure since it is optional";
    325     } else {
    326       return CompletePostinstall(error_code);
    327     }
    328   }
    329   accumulated_weight_ += partition_weight_[current_partition_];
    330   current_partition_++;
    331   ReportProgress(0);
    332 
    333   PerformPartitionPostinstall();
    334 }
    335 
    336 void PostinstallRunnerAction::CompletePostinstall(ErrorCode error_code) {
    337   // We only attempt to mark the new slot as active if all the postinstall
    338   // steps succeeded.
    339   if (error_code == ErrorCode::kSuccess) {
    340     if (install_plan_.switch_slot_on_reboot) {
    341       if (!boot_control_->SetActiveBootSlot(install_plan_.target_slot)) {
    342         error_code = ErrorCode::kPostinstallRunnerError;
    343       }
    344     } else {
    345       error_code = ErrorCode::kUpdatedButNotActive;
    346     }
    347   }
    348 
    349   ScopedActionCompleter completer(processor_, this);
    350   completer.set_code(error_code);
    351 
    352   if (error_code != ErrorCode::kSuccess &&
    353       error_code != ErrorCode::kUpdatedButNotActive) {
    354     LOG(ERROR) << "Postinstall action failed.";
    355 
    356     // Undo any changes done to trigger Powerwash.
    357     if (powerwash_scheduled_)
    358       hardware_->CancelPowerwash();
    359 
    360     return;
    361   }
    362 
    363   LOG(INFO) << "All post-install commands succeeded";
    364   if (HasOutputPipe()) {
    365     SetOutputObject(install_plan_);
    366   }
    367 }
    368 
    369 void PostinstallRunnerAction::SuspendAction() {
    370   if (!current_command_)
    371     return;
    372   if (kill(current_command_, SIGSTOP) != 0) {
    373     PLOG(ERROR) << "Couldn't pause child process " << current_command_;
    374   } else {
    375     is_current_command_suspended_ = true;
    376   }
    377 }
    378 
    379 void PostinstallRunnerAction::ResumeAction() {
    380   if (!current_command_)
    381     return;
    382   if (kill(current_command_, SIGCONT) != 0) {
    383     PLOG(ERROR) << "Couldn't resume child process " << current_command_;
    384   } else {
    385     is_current_command_suspended_ = false;
    386   }
    387 }
    388 
    389 void PostinstallRunnerAction::TerminateProcessing() {
    390   if (!current_command_)
    391     return;
    392   // Calling KillExec() will discard the callback we registered and therefore
    393   // the unretained reference to this object.
    394   Subprocess::Get().KillExec(current_command_);
    395 
    396   // If the command has been suspended, resume it after KillExec() so that the
    397   // process can process the SIGTERM sent by KillExec().
    398   if (is_current_command_suspended_) {
    399     ResumeAction();
    400   }
    401 
    402   current_command_ = 0;
    403   Cleanup();
    404 }
    405 
    406 }  // namespace chromeos_update_engine
    407