blob: 8c0aa6bf4edc37b8192d8b88bfe78dea221ed6b7 [file] [log] [blame]
Paul Crowley8f7f56e2015-11-27 09:29:37 +00001#include "fs.h"
2
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07003
4#include <errno.h>
Jin Qian4a335822017-04-18 16:23:18 -07005#include <fcntl.h>
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07006#include <stdio.h>
7#include <stdlib.h>
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07008#include <string.h>
9#include <sys/stat.h>
10#include <sys/types.h>
David Andersonc3ade7f2018-08-23 10:42:02 -070011#ifndef _WIN32
Jin Qian4afba662017-04-18 18:19:12 -070012#include <sys/wait.h>
Jin Qian29fc8592017-07-10 16:04:41 -070013#else
14#include <tchar.h>
15#include <windows.h>
Jin Qian4afba662017-04-18 18:19:12 -070016#endif
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -070017#include <unistd.h>
Jin Qian4afba662017-04-18 18:19:12 -070018#include <vector>
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -070019
Jin Qian29fc8592017-07-10 16:04:41 -070020#include <android-base/errors.h>
Jin Qian4afba662017-04-18 18:19:12 -070021#include <android-base/file.h>
Elliott Hughes7678ffd2018-04-10 18:01:08 -070022#include <android-base/macros.h>
Jin Qian4afba662017-04-18 18:19:12 -070023#include <android-base/stringprintf.h>
Jin Qian4a335822017-04-18 16:23:18 -070024#include <android-base/unique_fd.h>
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -070025
Jin Qian03c73e12017-12-04 16:17:46 -080026using android::base::GetExecutableDirectory;
Jin Qian4afba662017-04-18 18:19:12 -070027using android::base::StringPrintf;
Jin Qian4a335822017-04-18 16:23:18 -070028using android::base::unique_fd;
29
David Andersonc3ade7f2018-08-23 10:42:02 -070030#ifdef _WIN32
Jaegeuk Kim899ad552017-11-28 19:26:34 -080031static int exec_cmd(const char* path, const char** argv, const char** envp) {
Jin Qian29fc8592017-07-10 16:04:41 -070032 std::string cmd;
33 int i = 0;
34 while (argv[i] != nullptr) {
35 cmd += argv[i++];
36 cmd += " ";
37 }
38 cmd = cmd.substr(0, cmd.size() - 1);
39
40 STARTUPINFO si;
41 PROCESS_INFORMATION pi;
42 DWORD exit_code = 0;
43
44 ZeroMemory(&si, sizeof(si));
45 si.cb = sizeof(si);
46 ZeroMemory(&pi, sizeof(pi));
47
Jin Qian03c73e12017-12-04 16:17:46 -080048 std::string env_str;
49 if (envp != nullptr) {
50 while (*envp != nullptr) {
51 env_str += std::string(*envp) + std::string("\0", 1);
52 envp++;
53 }
54 }
Jin Qian29fc8592017-07-10 16:04:41 -070055
56 if (!CreateProcessA(nullptr, // No module name (use command line)
57 const_cast<char*>(cmd.c_str()), // Command line
58 nullptr, // Process handle not inheritable
59 nullptr, // Thread handle not inheritable
60 FALSE, // Set handle inheritance to FALSE
61 0, // No creation flags
Jin Qian03c73e12017-12-04 16:17:46 -080062 env_str.empty() ? nullptr : LPSTR(env_str.c_str()),
63 nullptr, // Use parent's starting directory
64 &si, // Pointer to STARTUPINFO structure
65 &pi) // Pointer to PROCESS_INFORMATION structure
Jin Qian29fc8592017-07-10 16:04:41 -070066 ) {
67 fprintf(stderr, "CreateProcess failed: %s\n",
68 android::base::SystemErrorCodeToString(GetLastError()).c_str());
Jin Qian4a335822017-04-18 16:23:18 -070069 return -1;
70 }
Jin Qian29fc8592017-07-10 16:04:41 -070071
72 WaitForSingleObject(pi.hProcess, INFINITE);
73
74 GetExitCodeProcess(pi.hProcess, &exit_code);
75
76 CloseHandle(pi.hProcess);
77 CloseHandle(pi.hThread);
78
Jaegeuk Kim899ad552017-11-28 19:26:34 -080079 if (exit_code != 0) {
80 fprintf(stderr, "%s failed: %lu\n", path, exit_code);
81 return -1;
82 }
83 return 0;
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -070084}
Jin Qian4afba662017-04-18 18:19:12 -070085#else
Jaegeuk Kim899ad552017-11-28 19:26:34 -080086static int exec_cmd(const char* path, const char** argv, const char** envp) {
Jin Qian4afba662017-04-18 18:19:12 -070087 int status;
88 pid_t child;
89 if ((child = fork()) == 0) {
Jin Qian0c04f782017-12-05 21:39:40 -080090 execve(path, const_cast<char**>(argv), const_cast<char**>(envp));
Jin Qian4afba662017-04-18 18:19:12 -070091 _exit(EXIT_FAILURE);
92 }
93 if (child < 0) {
94 fprintf(stderr, "%s failed with fork %s\n", path, strerror(errno));
95 return -1;
96 }
97 if (TEMP_FAILURE_RETRY(waitpid(child, &status, 0)) == -1) {
98 fprintf(stderr, "%s failed with waitpid %s\n", path, strerror(errno));
99 return -1;
100 }
101 int ret = -1;
102 if (WIFEXITED(status)) {
103 ret = WEXITSTATUS(status);
Jin Qian4afba662017-04-18 18:19:12 -0700104 }
Jaegeuk Kim899ad552017-11-28 19:26:34 -0800105
106 if (ret != 0) {
107 fprintf(stderr, "%s failed with status %d\n", path, ret);
108 return -1;
109 }
110 return 0;
Jin Qian4afba662017-04-18 18:19:12 -0700111}
Jin Qian29fc8592017-07-10 16:04:41 -0700112#endif
Jin Qian4afba662017-04-18 18:19:12 -0700113
114static int generate_ext4_image(const char* fileName, long long partSize,
115 const std::string& initial_dir, unsigned eraseBlkSize,
116 unsigned logicalBlkSize) {
117 static constexpr int block_size = 4096;
118 const std::string exec_dir = android::base::GetExecutableDirectory();
119
120 const std::string mke2fs_path = exec_dir + "/mke2fs";
121 std::vector<const char*> mke2fs_args = {mke2fs_path.c_str(), "-t", "ext4", "-b"};
122
123 std::string block_size_str = std::to_string(block_size);
124 mke2fs_args.push_back(block_size_str.c_str());
125
126 std::string ext_attr = "android_sparse";
127 if (eraseBlkSize != 0 && logicalBlkSize != 0) {
128 int raid_stride = logicalBlkSize / block_size;
129 int raid_stripe_width = eraseBlkSize / block_size;
130 // stride should be the max of 8kb and logical block size
131 if (logicalBlkSize != 0 && logicalBlkSize < 8192) raid_stride = 8192 / block_size;
Connor O'Brien6ef5c242017-11-01 17:37:32 -0700132 // stripe width should be >= stride
133 if (raid_stripe_width < raid_stride) raid_stripe_width = raid_stride;
Jin Qian4afba662017-04-18 18:19:12 -0700134 ext_attr += StringPrintf(",stride=%d,stripe-width=%d", raid_stride, raid_stripe_width);
135 }
136 mke2fs_args.push_back("-E");
137 mke2fs_args.push_back(ext_attr.c_str());
Jin Qian99e39642017-07-27 16:17:17 -0700138 mke2fs_args.push_back("-O");
139 mke2fs_args.push_back("uninit_bg");
Jin Qian4afba662017-04-18 18:19:12 -0700140 mke2fs_args.push_back(fileName);
141
142 std::string size_str = std::to_string(partSize / block_size);
143 mke2fs_args.push_back(size_str.c_str());
144 mke2fs_args.push_back(nullptr);
145
Jin Qian03c73e12017-12-04 16:17:46 -0800146 const std::string mke2fs_env = "MKE2FS_CONFIG=" + GetExecutableDirectory() + "/mke2fs.conf";
147 std::vector<const char*> mke2fs_envp = {mke2fs_env.c_str(), nullptr};
148
Jaegeuk Kim899ad552017-11-28 19:26:34 -0800149 int ret = exec_cmd(mke2fs_args[0], mke2fs_args.data(), mke2fs_envp.data());
Jin Qian4afba662017-04-18 18:19:12 -0700150 if (ret != 0) {
Jin Qian4afba662017-04-18 18:19:12 -0700151 return -1;
152 }
153
154 if (initial_dir.empty()) {
155 return 0;
156 }
157
158 const std::string e2fsdroid_path = exec_dir + "/e2fsdroid";
159 std::vector<const char*> e2fsdroid_args = {e2fsdroid_path.c_str(), "-f", initial_dir.c_str(),
160 fileName, nullptr};
161
Jaegeuk Kim899ad552017-11-28 19:26:34 -0800162 return exec_cmd(e2fsdroid_args[0], e2fsdroid_args.data(), nullptr);
Jin Qian4afba662017-04-18 18:19:12 -0700163}
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -0700164
Jin Qian4a335822017-04-18 16:23:18 -0700165static int generate_f2fs_image(const char* fileName, long long partSize, const std::string& initial_dir,
Connor O'Brience16a8a2017-02-06 14:39:31 -0800166 unsigned /* unused */, unsigned /* unused */)
JP Abgrall12351582014-06-17 17:01:14 -0700167{
Jaegeuk Kimd8721182017-10-02 18:51:48 -0700168 const std::string exec_dir = android::base::GetExecutableDirectory();
169 const std::string mkf2fs_path = exec_dir + "/make_f2fs";
170 std::vector<const char*> mkf2fs_args = {mkf2fs_path.c_str()};
171
172 mkf2fs_args.push_back("-S");
173 std::string size_str = std::to_string(partSize);
174 mkf2fs_args.push_back(size_str.c_str());
Jaegeuk Kim46542f92018-11-21 12:55:19 -0800175 mkf2fs_args.push_back("-g");
176 mkf2fs_args.push_back("android");
Jaegeuk Kimd8721182017-10-02 18:51:48 -0700177 mkf2fs_args.push_back(fileName);
178 mkf2fs_args.push_back(nullptr);
179
Jaegeuk Kim899ad552017-11-28 19:26:34 -0800180 int ret = exec_cmd(mkf2fs_args[0], mkf2fs_args.data(), nullptr);
Jaegeuk Kimd8721182017-10-02 18:51:48 -0700181 if (ret != 0) {
Jaegeuk Kimd8721182017-10-02 18:51:48 -0700182 return -1;
183 }
184
Jaegeuk Kim899ad552017-11-28 19:26:34 -0800185 if (initial_dir.empty()) {
Jaegeuk Kim8d9b6ee2017-11-15 10:55:07 -0800186 return 0;
Jin Qian4a335822017-04-18 16:23:18 -0700187 }
Jaegeuk Kim899ad552017-11-28 19:26:34 -0800188
189 const std::string sload_path = exec_dir + "/sload_f2fs";
190 std::vector<const char*> sload_args = {sload_path.c_str(), "-S",
191 "-f", initial_dir.c_str(), fileName, nullptr};
192
193 return exec_cmd(sload_args[0], sload_args.data(), nullptr);
Jaegeuk Kim8d9b6ee2017-11-15 10:55:07 -0800194}
JP Abgrall12351582014-06-17 17:01:14 -0700195
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -0700196static const struct fs_generator {
Elliott Hughesb3748de2015-06-23 20:27:58 -0700197 const char* fs_type; //must match what fastboot reports for partition type
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000198
199 //returns 0 or error value
Jin Qian4a335822017-04-18 16:23:18 -0700200 int (*generate)(const char* fileName, long long partSize, const std::string& initial_dir,
Connor O'Brience16a8a2017-02-06 14:39:31 -0800201 unsigned eraseBlkSize, unsigned logicalBlkSize);
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -0700202
203} generators[] = {
JP Abgrall12351582014-06-17 17:01:14 -0700204 { "ext4", generate_ext4_image},
205 { "f2fs", generate_f2fs_image},
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -0700206};
207
Elliott Hughes8ab9a322015-11-02 14:05:57 -0800208const struct fs_generator* fs_get_generator(const std::string& fs_type) {
Elliott Hughesfc797672015-04-07 20:12:50 -0700209 for (size_t i = 0; i < sizeof(generators) / sizeof(*generators); i++) {
Elliott Hughes8ab9a322015-11-02 14:05:57 -0800210 if (fs_type == generators[i].fs_type) {
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -0700211 return generators + i;
Elliott Hughesfc797672015-04-07 20:12:50 -0700212 }
213 }
214 return nullptr;
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -0700215}
216
Jin Qian4a335822017-04-18 16:23:18 -0700217int fs_generator_generate(const struct fs_generator* gen, const char* fileName, long long partSize,
Connor O'Brience16a8a2017-02-06 14:39:31 -0800218 const std::string& initial_dir, unsigned eraseBlkSize, unsigned logicalBlkSize)
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -0700219{
Jin Qian4a335822017-04-18 16:23:18 -0700220 return gen->generate(fileName, partSize, initial_dir, eraseBlkSize, logicalBlkSize);
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -0700221}