int main(int argc, char **argv) {
const char *rootfs = "/";
char *result;
if(argc > 1 )
result = find_block_device(argv[1]);
else
result = find_block_device(rootfs);
/* not likely but better safe than sorry */
if(result == NULL)
return 1;
printf("%s",result);
return 0;
}
int mountpoint_main(int argc UNUSED_PARAM, char **argv)
{
struct stat st;
const char *msg;
char *arg;
int rc, opt;
opt_complementary = "=1"; /* must have one argument */
opt = getopt32(argv, "qdxn");
#define OPT_q (1)
#define OPT_d (2)
#define OPT_x (4)
#define OPT_n (8)
arg = argv[optind];
msg = "%s";
rc = (opt & OPT_x) ? stat(arg, &st) : lstat(arg, &st);
if (rc != 0)
goto err;
if (opt & OPT_x) {
if (S_ISBLK(st.st_mode)) {
printf("%u:%u\n", major(st.st_rdev),
minor(st.st_rdev));
return EXIT_SUCCESS;
}
errno = 0; /* make perror_msg work as error_msg */
msg = "%s: not a block device";
goto err;
}
errno = ENOTDIR;
if (S_ISDIR(st.st_mode)) {
dev_t st_dev = st.st_dev;
ino_t st_ino = st.st_ino;
char *p = xasprintf("%s/..", arg);
if (stat(p, &st) == 0) {
//int is_mnt = (st_dev != st.st_dev) || (st_dev == st.st_dev && st_ino == st.st_ino);
int is_not_mnt = (st_dev == st.st_dev) && (st_ino != st.st_ino);
if (opt & OPT_d)
printf("%u:%u\n", major(st_dev), minor(st_dev));
if (opt & OPT_n)
printf("%s %s\n", find_block_device(arg), arg);
if (!(opt & (OPT_q | OPT_d | OPT_n)))
printf("%s is %sa mountpoint\n", arg, is_not_mnt ? "not " : "");
return is_not_mnt;
}
arg = p;
/* else: stat had set errno, just fall through */
}
err:
if (!(opt & OPT_q))
bb_perror_msg(msg, arg);
return EXIT_FAILURE;
}
static int uncrypt(const char* input_path, const char* map_file, int status_fd) {
ALOGI("update package is \"%s\"", input_path);
// Turn the name of the file we're supposed to convert into an
// absolute path, so we can find what filesystem it's on.
char path[PATH_MAX+1];
if (realpath(input_path, path) == NULL) {
ALOGE("failed to convert \"%s\" to absolute path: %s", input_path, strerror(errno));
return 1;
}
if (read_fstab() == NULL) {
return 1;
}
bool encryptable;
bool encrypted;
const char* blk_dev = find_block_device(path, &encryptable, &encrypted);
if (blk_dev == NULL) {
ALOGE("failed to find block device for %s", path);
return 1;
}
// If the filesystem it's on isn't encrypted, we only produce the
// block map, we don't rewrite the file contents (it would be
// pointless to do so).
ALOGI("encryptable: %s", encryptable ? "yes" : "no");
ALOGI(" encrypted: %s", encrypted ? "yes" : "no");
// Recovery supports installing packages from 3 paths: /cache,
// /data, and /sdcard. (On a particular device, other locations
// may work, but those are three we actually expect.)
//
// On /data we want to convert the file to a block map so that we
// can read the package without mounting the partition. On /cache
// and /sdcard we leave the file alone.
if (strncmp(path, "/data/", 6) == 0) {
ALOGI("writing block map %s", map_file);
if (produce_block_map(path, map_file, blk_dev, encrypted, status_fd) != 0) {
return 1;
}
}
return 0;
}
static int uncrypt(const char* input_path, const char* map_file, const int socket) {
LOG(INFO) << "update package is \"" << input_path << "\"";
// Turn the name of the file we're supposed to convert into an absolute path, so we can find
// what filesystem it's on.
char path[PATH_MAX+1];
if (realpath(input_path, path) == nullptr) {
PLOG(ERROR) << "failed to convert \"" << input_path << "\" to absolute path";
return kUncryptRealpathFindError;
}
bool encryptable;
bool encrypted;
bool f2fs_fs;
const char* blk_dev = find_block_device(path, &encryptable, &encrypted, &f2fs_fs);
if (blk_dev == nullptr) {
LOG(ERROR) << "failed to find block device for " << path;
return kUncryptBlockDeviceFindError;
}
// If the filesystem it's on isn't encrypted, we only produce the
// block map, we don't rewrite the file contents (it would be
// pointless to do so).
LOG(INFO) << "encryptable: " << (encryptable ? "yes" : "no");
LOG(INFO) << " encrypted: " << (encrypted ? "yes" : "no");
// Recovery supports installing packages from 3 paths: /cache,
// /data, and /sdcard. (On a particular device, other locations
// may work, but those are three we actually expect.)
//
// On /data we want to convert the file to a block map so that we
// can read the package without mounting the partition. On /cache
// and /sdcard we leave the file alone.
if (strncmp(path, "/data/", 6) == 0) {
LOG(INFO) << "writing block map " << map_file;
return produce_block_map(path, map_file, blk_dev, encrypted, f2fs_fs, socket);
}
return 0;
}
int df_main(int argc, char **argv)
{
long blocks_used;
long blocks_percent_used;
#ifdef CONFIG_FEATURE_HUMAN_READABLE
unsigned long df_disp_hr = 1024;
#endif
int status = EXIT_SUCCESS;
unsigned opt;
FILE *mount_table;
struct mntent *mount_entry;
struct statfs s;
static const char hdr_1k[] = "1k-blocks"; /* default display is kilobytes */
const char *disp_units_hdr = hdr_1k;
#ifdef CONFIG_FEATURE_HUMAN_READABLE
opt_complementary = "h-km:k-hm:m-hk";
opt = getopt32(argc, argv, "hmk");
if (opt & 1) {
df_disp_hr = 0;
disp_units_hdr = " Size";
}
if (opt & 2) {
df_disp_hr = 1024*1024;
disp_units_hdr = "1M-blocks";
}
#else
opt = getopt32(argc, argv, "k");
#endif
printf("Filesystem%11s%-15sUsed Available Use%% Mounted on\n",
"", disp_units_hdr);
mount_table = NULL;
argv += optind;
if (optind >= argc) {
mount_table = setmntent(bb_path_mtab_file, "r");
if (!mount_table) {
bb_perror_msg_and_die(bb_path_mtab_file);
}
}
do {
const char *device;
const char *mount_point;
if (mount_table) {
mount_entry = getmntent(mount_table);
if (!mount_entry) {
endmntent(mount_table);
break;
}
} else {
mount_point = *argv++;
if (!mount_point) {
break;
}
mount_entry = find_mount_point(mount_point, bb_path_mtab_file);
if (!mount_entry) {
bb_error_msg("%s: can't find mount point", mount_point);
SET_ERROR:
status = EXIT_FAILURE;
continue;
}
}
device = mount_entry->mnt_fsname;
mount_point = mount_entry->mnt_dir;
if (statfs(mount_point, &s) != 0) {
bb_perror_msg("%s", mount_point);
goto SET_ERROR;
}
if ((s.f_blocks > 0) || !mount_table){
blocks_used = s.f_blocks - s.f_bfree;
blocks_percent_used = 0;
if (blocks_used + s.f_bavail) {
blocks_percent_used = (((long long) blocks_used) * 100
+ (blocks_used + s.f_bavail)/2
) / (blocks_used + s.f_bavail);
}
if (strcmp(device, "rootfs") == 0) {
continue;
} else if (strcmp(device, "/dev/root") == 0) {
/* Adjusts device to be the real root device,
* or leaves device alone if it can't find it */
device = find_block_device("/");
if (!device) {
goto SET_ERROR;
}
}
#ifdef CONFIG_FEATURE_HUMAN_READABLE
printf("%-20s %9s ", device,
make_human_readable_str(s.f_blocks, s.f_bsize, df_disp_hr));
printf("%9s ",
make_human_readable_str( (s.f_blocks - s.f_bfree),
s.f_bsize, df_disp_hr));
printf("%9s %3ld%% %s\n",
make_human_readable_str(s.f_bavail, s.f_bsize, df_disp_hr),
blocks_percent_used, mount_point);
#else
printf("%-20s %9ld %9ld %9ld %3ld%% %s\n",
device,
kscale(s.f_blocks, s.f_bsize),
kscale(s.f_blocks-s.f_bfree, s.f_bsize),
kscale(s.f_bavail, s.f_bsize),
blocks_percent_used, mount_point);
#endif
}
} while (1);
fflush_stdout_and_exit(status);
}
int mountpoint_main(int argc UNUSED_PARAM, char **argv)
{
struct stat st;
const char *msg;
char *arg;
int rc, opt;
opt_complementary = "=1"; /* must have one argument */
opt = getopt32(argv, "qdxn");
#define OPT_q (1)
#define OPT_d (2)
#define OPT_x (4)
#define OPT_n (8)
arg = argv[optind];
msg = "%s";
rc = (opt & OPT_x) ? stat(arg, &st) : lstat(arg, &st);
if (rc != 0)
goto err;
if (opt & OPT_x) {
if (S_ISBLK(st.st_mode)) {
printf("%u:%u\n", major(st.st_rdev),
minor(st.st_rdev));
return EXIT_SUCCESS;
}
errno = 0; /* make perror_msg work as error_msg */
msg = "%s: not a block device";
goto err;
}
errno = ENOTDIR;
if (S_ISDIR(st.st_mode)) {
dev_t st_dev = st.st_dev;
ino_t st_ino = st.st_ino;
char *p = xasprintf("%s/..", arg);
if (stat(p, &st) == 0) {
//int is_mnt = (st_dev != st.st_dev) || (st_dev == st.st_dev && st_ino == st.st_ino);
int is_not_mnt = (st_dev == st.st_dev) && (st_ino != st.st_ino);
if (opt & OPT_d)
printf("%u:%u\n", major(st_dev), minor(st_dev));
if (opt & OPT_n) {
const char *d = find_block_device(arg);
/* name is undefined, but device is mounted -> anonymous superblock! */
/* happens with btrfs */
if (!d) {
d = "UNKNOWN";
/* TODO: iterate /proc/mounts, or /proc/self/mountinfo
* to find out the device name */
}
printf("%s %s\n", d, arg);
}
if (!(opt & (OPT_q | OPT_d | OPT_n)))
printf("%s is %sa mountpoint\n", arg, is_not_mnt ? "not " : "");
return is_not_mnt;
}
arg = p;
/* else: stat had set errno, just fall through */
}
err:
if (!(opt & OPT_q))
bb_perror_msg(msg, arg);
return EXIT_FAILURE;
}
int main(int argc, char** argv)
{
const char* input_path;
const char* map_file;
int do_reboot = 1;
if (argc != 1 && argc != 3) {
fprintf(stderr, "usage: %s [<transform_path> <map_file>]\n", argv[0]);
return 2;
}
if (argc == 3) {
// when command-line args are given this binary is being used
// for debugging; don't reboot to recovery at the end.
input_path = argv[1];
map_file = argv[2];
do_reboot = 0;
} else {
input_path = parse_recovery_command_file();
if (input_path == NULL) {
// if we're rebooting to recovery without a package (say,
// to wipe data), then we don't need to do anything before
// going to recovery.
ALOGI("no recovery command file or no update package arg");
reboot_to_recovery();
return 1;
}
map_file = CACHE_BLOCK_MAP;
}
ALOGI("update package is %s", input_path);
// Turn the name of the file we're supposed to convert into an
// absolute path, so we can find what filesystem it's on.
char path[PATH_MAX+1];
if (realpath(input_path, path) == NULL) {
ALOGE("failed to convert %s to absolute path: %s", input_path, strerror(errno));
return 1;
}
int encryptable;
int encrypted;
if (read_fstab() == NULL) {
return 1;
}
const char* blk_dev = find_block_device(path, &encryptable, &encrypted);
if (blk_dev == NULL) {
ALOGE("failed to find block device for %s", path);
return 1;
}
// If the filesystem it's on isn't encrypted, we only produce the
// block map, we don't rewrite the file contents (it would be
// pointless to do so).
ALOGI("encryptable: %s\n", encryptable ? "yes" : "no");
ALOGI(" encrypted: %s\n", encrypted ? "yes" : "no");
// Recovery supports installing packages from 3 paths: /cache,
// /data, and /sdcard. (On a particular device, other locations
// may work, but those are three we actually expect.)
//
// On /data we want to convert the file to a block map so that we
// can read the package without mounting the partition. On /cache
// and /sdcard we leave the file alone.
if (strncmp(path, "/data/", 6) != 0) {
// path does not start with "/data/"; leave it alone.
unlink(RECOVERY_COMMAND_FILE_TMP);
} else {
ALOGI("writing block map %s", map_file);
if (produce_block_map(path, map_file, blk_dev, encrypted) != 0) {
return 1;
}
}
wipe_misc();
rename(RECOVERY_COMMAND_FILE_TMP, RECOVERY_COMMAND_FILE);
if (do_reboot) reboot_to_recovery();
return 0;
}
*
* Copyright (c) 2008 Nuovation System Designs, LLC
* Grant Erickson <*****@*****.**>
*
* Licensed under GPLv2, see file LICENSE in this source tree.
*
*/
//usage:#define rdev_trivial_usage
//usage: ""
//usage:#define rdev_full_usage "\n\n"
//usage: "Print the device node associated with the filesystem mounted at '/'"
//usage:
//usage:#define rdev_example_usage
//usage: "$ rdev\n"
//usage: "/dev/mtdblock9 /\n"
#include "libbb.h"
int rdev_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int rdev_main(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
{
char const * const root_device = find_block_device("/");
if (root_device != NULL) {
printf("%s /\n", root_device);
return EXIT_SUCCESS;
}
return EXIT_FAILURE;
}
