1 #include "fs.h"
2 
3 
4 #include <errno.h>
5 #include <fcntl.h>
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <sys/stat.h>
10 #include <sys/types.h>
11 #ifndef _WIN32
12 #include <sys/wait.h>
13 #else
14 #include <tchar.h>
15 #include <windows.h>
16 #endif
17 #include <unistd.h>
18 #include <vector>
19 
20 #include <android-base/errors.h>
21 #include <android-base/file.h>
22 #include <android-base/macros.h>
23 #include <android-base/stringprintf.h>
24 #include <android-base/unique_fd.h>
25 
26 using android::base::GetExecutableDirectory;
27 using android::base::StringPrintf;
28 using android::base::unique_fd;
29 
30 #ifdef _WIN32
exec_cmd(const char * path,const char ** argv,const char ** envp)31 static int exec_cmd(const char* path, const char** argv, const char** envp) {
32     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 
48     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     }
55 
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
62                         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
66     ) {
67         fprintf(stderr, "CreateProcess failed: %s\n",
68                 android::base::SystemErrorCodeToString(GetLastError()).c_str());
69         return -1;
70     }
71 
72     WaitForSingleObject(pi.hProcess, INFINITE);
73 
74     GetExitCodeProcess(pi.hProcess, &exit_code);
75 
76     CloseHandle(pi.hProcess);
77     CloseHandle(pi.hThread);
78 
79     if (exit_code != 0) {
80         fprintf(stderr, "%s failed: %lu\n", path, exit_code);
81         return -1;
82     }
83     return 0;
84 }
85 #else
exec_cmd(const char * path,const char ** argv,const char ** envp)86 static int exec_cmd(const char* path, const char** argv, const char** envp) {
87     int status;
88     pid_t child;
89     if ((child = fork()) == 0) {
90         execve(path, const_cast<char**>(argv), const_cast<char**>(envp));
91         _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);
104     }
105 
106     if (ret != 0) {
107         fprintf(stderr, "%s failed with status %d\n", path, ret);
108         return -1;
109     }
110     return 0;
111 }
112 #endif
113 
generate_ext4_image(const char * fileName,long long partSize,unsigned eraseBlkSize,unsigned logicalBlkSize,const unsigned fsOptions)114 static int generate_ext4_image(const char* fileName, long long partSize, unsigned eraseBlkSize,
115                                unsigned logicalBlkSize, const unsigned fsOptions) {
116     static constexpr int block_size = 4096;
117     const std::string exec_dir = android::base::GetExecutableDirectory();
118 
119     const std::string mke2fs_path = exec_dir + "/mke2fs";
120     std::vector<const char*> mke2fs_args = {mke2fs_path.c_str(), "-t", "ext4", "-b"};
121 
122     std::string block_size_str = std::to_string(block_size);
123     mke2fs_args.push_back(block_size_str.c_str());
124 
125     std::string ext_attr = "android_sparse";
126     if (eraseBlkSize != 0 && logicalBlkSize != 0) {
127         int raid_stride = logicalBlkSize / block_size;
128         int raid_stripe_width = eraseBlkSize / block_size;
129         // stride should be the max of 8kb and logical block size
130         if (logicalBlkSize != 0 && logicalBlkSize < 8192) raid_stride = 8192 / block_size;
131         // stripe width should be >= stride
132         if (raid_stripe_width < raid_stride) raid_stripe_width = raid_stride;
133         ext_attr += StringPrintf(",stride=%d,stripe-width=%d", raid_stride, raid_stripe_width);
134     }
135     mke2fs_args.push_back("-E");
136     mke2fs_args.push_back(ext_attr.c_str());
137     mke2fs_args.push_back("-O");
138     mke2fs_args.push_back("uninit_bg");
139 
140     if (fsOptions & (1 << FS_OPT_PROJID)) {
141         mke2fs_args.push_back("-I");
142         mke2fs_args.push_back("512");
143     }
144 
145     if (fsOptions & (1 << FS_OPT_CASEFOLD)) {
146         mke2fs_args.push_back("-O");
147         mke2fs_args.push_back("casefold");
148         mke2fs_args.push_back("-E");
149         mke2fs_args.push_back("encoding=utf8");
150     }
151 
152     mke2fs_args.push_back(fileName);
153 
154     std::string size_str = std::to_string(partSize / block_size);
155     mke2fs_args.push_back(size_str.c_str());
156     mke2fs_args.push_back(nullptr);
157 
158     const std::string mke2fs_env = "MKE2FS_CONFIG=" + GetExecutableDirectory() + "/mke2fs.conf";
159     std::vector<const char*> mke2fs_envp = {mke2fs_env.c_str(), nullptr};
160 
161     int ret = exec_cmd(mke2fs_args[0], mke2fs_args.data(), mke2fs_envp.data());
162     if (ret != 0) {
163         return -1;
164     }
165     return 0;
166 }
167 
168 enum {
169     // clang-format off
170     FSCK_SUCCESS                 = 0,
171     FSCK_ERROR_CORRECTED         = 1 << 0,
172     FSCK_SYSTEM_SHOULD_REBOOT    = 1 << 1,
173     FSCK_ERRORS_LEFT_UNCORRECTED = 1 << 2,
174     FSCK_OPERATIONAL_ERROR       = 1 << 3,
175     FSCK_USAGE_OR_SYNTAX_ERROR   = 1 << 4,
176     FSCK_USER_CANCELLED          = 1 << 5,
177     FSCK_SHARED_LIB_ERROR        = 1 << 7,
178     // clang-format on
179 };
180 
generate_f2fs_image(const char * fileName,long long partSize,unsigned,unsigned,const unsigned fsOptions)181 static int generate_f2fs_image(const char* fileName, long long partSize, unsigned /* unused */,
182                                unsigned /* unused */, const unsigned fsOptions) {
183     const std::string exec_dir = android::base::GetExecutableDirectory();
184     const std::string mkf2fs_path = exec_dir + "/make_f2fs";
185     std::vector<const char*> mkf2fs_args = {mkf2fs_path.c_str()};
186 
187     mkf2fs_args.push_back("-S");
188     std::string size_str = std::to_string(partSize);
189     mkf2fs_args.push_back(size_str.c_str());
190     mkf2fs_args.push_back("-g");
191     mkf2fs_args.push_back("android");
192 
193     if (fsOptions & (1 << FS_OPT_PROJID)) {
194         mkf2fs_args.push_back("-O");
195         mkf2fs_args.push_back("project_quota,extra_attr");
196     }
197 
198     if (fsOptions & (1 << FS_OPT_CASEFOLD)) {
199         mkf2fs_args.push_back("-O");
200         mkf2fs_args.push_back("casefold");
201         mkf2fs_args.push_back("-C");
202         mkf2fs_args.push_back("utf8");
203     }
204 
205     if (fsOptions & (1 << FS_OPT_COMPRESS)) {
206         mkf2fs_args.push_back("-O");
207         mkf2fs_args.push_back("compression");
208         mkf2fs_args.push_back("-O");
209         mkf2fs_args.push_back("extra_attr");
210     }
211 
212     mkf2fs_args.push_back(fileName);
213     mkf2fs_args.push_back(nullptr);
214 
215     int ret = exec_cmd(mkf2fs_args[0], mkf2fs_args.data(), nullptr);
216     if (ret != 0) {
217         return -1;
218     }
219     return 0;
220 }
221 
222 static const struct fs_generator {
223     const char* fs_type;  //must match what fastboot reports for partition type
224 
225     //returns 0 or error value
226     int (*generate)(const char* fileName, long long partSize, unsigned eraseBlkSize,
227                     unsigned logicalBlkSize, const unsigned fsOptions);
228 
229 } generators[] = {
230     { "ext4", generate_ext4_image},
231     { "f2fs", generate_f2fs_image},
232 };
233 
fs_get_generator(const std::string & fs_type)234 const struct fs_generator* fs_get_generator(const std::string& fs_type) {
235     for (size_t i = 0; i < sizeof(generators) / sizeof(*generators); i++) {
236         if (fs_type == generators[i].fs_type) {
237             return generators + i;
238         }
239     }
240     return nullptr;
241 }
242 
fs_generator_generate(const struct fs_generator * gen,const char * fileName,long long partSize,unsigned eraseBlkSize,unsigned logicalBlkSize,const unsigned fsOptions)243 int fs_generator_generate(const struct fs_generator* gen, const char* fileName, long long partSize,
244                           unsigned eraseBlkSize, unsigned logicalBlkSize,
245                           const unsigned fsOptions) {
246     return gen->generate(fileName, partSize, eraseBlkSize, logicalBlkSize, fsOptions);
247 }
248