138 lines
3.2 KiB
C++
Executable File
138 lines
3.2 KiB
C++
Executable File
/* By YZBruh */
|
|
|
|
/**
|
|
* Copyright 2024 Partition Manager
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define INC_MAIN_LIBS 1
|
|
#define INC_STRINGKEYS 1
|
|
#define INC_DEBUGERS 1
|
|
#define INC_PTHREAD 1
|
|
|
|
/* using by new devices */
|
|
#define DEFAULT_DEVICE_NEW "/dev/block/sda"
|
|
|
|
/* using by old devices */
|
|
#define DEFAULT_DEVICE_OLD "/dev/block/mmcblk0"
|
|
|
|
/**
|
|
* These macros will be added/deleted/modified
|
|
* according to user feedback.
|
|
*/
|
|
|
|
#include <PartitionManager/PartitionManager.h>
|
|
#include <PartitionManager/Parted.h>
|
|
|
|
static bool started = false, o_ended = false;
|
|
static int ret = 0;
|
|
static pthread_mutex_t plock = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
extern "C" void* __start_parted(void* dummy_arg);
|
|
extern "C" void* __watch_parted(void* dummy_arg);
|
|
|
|
bool PartitionManager::SearchDevice(const string& DevicePath)
|
|
{
|
|
VLOGD("Check '%s'.\n", DevicePath.c_str());
|
|
|
|
if (PartitionManager::GetState(DevicePath, "none") != 0) {
|
|
VLOGD("Cannot find '%s'.\n", DevicePath.c_str());
|
|
return false;
|
|
} else VLOGD("Founded: '%s'.\n", DevicePath.c_str());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool PartitionManager::SearchDefaultDevices(void)
|
|
{
|
|
VLOGD("Searching '%s'.\n", DEFAULT_DEVICE_NEW);
|
|
if (PartitionManager::SearchDevice(DEFAULT_DEVICE_NEW)) {
|
|
PartitionManager::Strings::Device = DEFAULT_DEVICE_NEW;
|
|
return true;
|
|
}
|
|
|
|
VLOGD("Searching '%s'.\n", DEFAULT_DEVICE_NEW);
|
|
if (PartitionManager::SearchDevice(DEFAULT_DEVICE_OLD)) {
|
|
PartitionManager::Strings::Device = DEFAULT_DEVICE_OLD;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void* __watch_parted(void* dummy_arg)
|
|
{
|
|
while (1) {
|
|
pthread_mutex_lock(&plock);
|
|
|
|
if (started) {
|
|
if (o_ended) {
|
|
pthread_mutex_unlock(&plock);
|
|
return NULL;
|
|
}
|
|
if (set_ret) {
|
|
LOGD("%s: %d.\n",
|
|
PartitionManager::Display::UsingDispString->exited_with,
|
|
parted_ret);
|
|
pthread_mutex_unlock(&plock);
|
|
return NULL;
|
|
}
|
|
} else {
|
|
VLOGD("Parted is still not started...\n");
|
|
sleep(1);
|
|
}
|
|
|
|
pthread_mutex_unlock(&plock);
|
|
usleep(1000);
|
|
}
|
|
}
|
|
|
|
void* __start_parted(void* dummy_arg)
|
|
{
|
|
VLOGD("Generating arguments...\n");
|
|
char* arguments[] = {
|
|
"parted-pmt",
|
|
(char*)PartitionManager::Strings::Device.c_str(),
|
|
};
|
|
|
|
LOGD("%s...\n", PartitionManager::Display::UsingDispString->starting_parted);
|
|
VLOGD("Calling parted_main...\n");
|
|
|
|
pthread_mutex_lock(&plock);
|
|
started = true;
|
|
pthread_mutex_unlock(&plock);
|
|
ret = parted_main(2, arguments);
|
|
pthread_mutex_lock(&plock);
|
|
o_ended = true;
|
|
pthread_mutex_unlock(&plock);
|
|
sleep(1);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int PartitionManager::StartParted(void)
|
|
{
|
|
pthread_t t1, t2;
|
|
|
|
pthread_create(&t1, NULL, __start_parted, NULL);
|
|
pthread_create(&t2, NULL, __watch_parted, NULL);
|
|
|
|
pthread_join(t1, NULL);
|
|
pthread_join(t2, NULL);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* end of code */
|