rtems_status_code rtems_disk_create_log(
dev_t dev,
dev_t phys,
rtems_blkdev_bnum begin_block,
rtems_blkdev_bnum block_count,
const char *name
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
rtems_blkdev_bnum end_block = begin_block + block_count;
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
physical_disk = get_disk_entry(phys, true);
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
disk_unlock();
return RTEMS_INVALID_ID;
}
if (
begin_block >= physical_disk->size
|| end_block <= begin_block
|| end_block > physical_disk->size
) {
disk_unlock();
return RTEMS_INVALID_NUMBER;
}
sc = create_disk(dev, name, &dd);
if (sc != RTEMS_SUCCESSFUL) {
disk_unlock();
return sc;
}
dd->phys_dev = physical_disk;
dd->start = begin_block;
dd->size = block_count;
dd->block_size = physical_disk->block_size;
dd->media_block_size = physical_disk->media_block_size;
dd->block_to_media_block_shift = physical_disk->block_to_media_block_shift;
dd->bds_per_group = physical_disk->bds_per_group;
dd->ioctl = physical_disk->ioctl;
dd->driver_data = physical_disk->driver_data;
++physical_disk->uses;
disk_unlock();
return RTEMS_SUCCESSFUL;
}
int FileSys_make(char *disk_name) {
char buf[BLOCK_SIZE];
if (create_disk(disk_name) == -1) return -1; // It creates a disk for the file system.
if (Disk_open(disk_name) == -1) return -1; // It opens the disk .
strcpy(buf, disk_name);
if (writeBlock(0, buf) == -1) return -1; // It writes the name of the file system to the disk.
Disk_close(); // It closes the disk .
return 0; //The disk operations used are created in disk.c
}
rtems_status_code rtems_disk_create_log(
dev_t dev,
dev_t phys,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count,
const char *name
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *phys_dd = NULL;
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
phys_dd = get_disk_entry(phys, true);
if (phys_dd == NULL) {
disk_unlock();
return RTEMS_INVALID_ID;
}
sc = create_disk(dev, name, &dd, &alloc_name);
if (sc != RTEMS_SUCCESSFUL) {
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
dd,
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
dd->name = alloc_name;
++phys_dd->uses;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
rtems_disk_delete(dev);
disk_unlock();
return sc;
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_disk_create_phys(
dev_t dev,
uint32_t block_size,
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
rtems_disk_device *dd = NULL;
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
return RTEMS_INVALID_ADDRESS;
}
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
sc = create_disk(dev, name, &dd);
if (sc != RTEMS_SUCCESSFUL) {
disk_unlock();
return sc;
}
dd->phys_dev = dd;
dd->start = 0;
dd->size = block_count;
dd->media_block_size = block_size;
dd->ioctl = handler;
dd->driver_data = driver_data;
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) < 0) {
dd->capabilities = 0;
}
sc = rtems_bdbuf_set_block_size(dd, block_size);
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
rtems_disk_delete(dev);
disk_unlock();
return sc;
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_disk_create_phys(
dev_t dev,
uint32_t block_size,
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
rtems_disk_device *dd = NULL;
rtems_status_code sc = RTEMS_SUCCESSFUL;
char *alloc_name = NULL;
if (handler == NULL) {
return RTEMS_INVALID_ADDRESS;
}
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
sc = create_disk(dev, name, &dd, &alloc_name);
if (sc != RTEMS_SUCCESSFUL) {
disk_unlock();
return sc;
}
sc = rtems_disk_init_phys(
dd,
block_size,
block_count,
handler,
driver_data
);
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
rtems_disk_delete(dev);
disk_unlock();
return sc;
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
int main(int argc, char *argv[]){
disk_info_t *disk_info, *disk_list;
partition_info_t *partition_info;
char buf[PATH_MAX];
usb_dbg("%d: Using myself to get information:\n", VERSION);
if(argc == 3){
get_mount_path("sdb1", buf, PATH_MAX);
printf("buf=%s.\n", buf);
}
else if(argc == 2){
if(is_disk_name(argv[1])){ // Disk
usb_dbg("%d: Get disk(%s)'s information:\n", VERSION, argv[1]);
create_disk(argv[1], &disk_info);
print_disk(disk_info);
free_disk_data(&disk_info);
}
else{
usb_dbg("%d: Get partition(%s)'s information:\n", VERSION, argv[1]);
create_partition(argv[1], &partition_info);
print_partition(partition_info);
free_partition_data(&partition_info);
}
}
else{
usb_dbg("%d: Get all Disk information:\n", VERSION);
disk_list = read_disk_data();
print_disks(disk_list);
free_disk_data(&disk_list);
}
return 0;
}
disk_info_t *read_disk_data(void)
{
FILE *fp;
char line[64], device_name[32];
u32 major, minor;
disk_info_t *disk_info_list, *parent_disk_info, **follow_disk_info_list;
partition_info_t *new_partition_info, **follow_partition_list;
unsigned long long device_size;
fp = fopen(PARTITION_FILE, "r");
if (!fp)
return NULL;
if (!fgets(line, sizeof(line), fp)) {
fclose(fp);
return NULL;
}
fgets(line, sizeof(line), fp);
disk_info_list = NULL;
while (fgets(line, sizeof(line), fp))
{
device_name[0] = 0;
if (sscanf(line, "%u %u %llu %[^\n ]", &major, &minor, &device_size, device_name) != 4)
continue;
if(major != USB_DISK_MAJOR)
continue;
if(device_size < 10)
continue;
if (is_disk_name(device_name))
{
follow_disk_info_list = &disk_info_list;
while(*follow_disk_info_list)
follow_disk_info_list = &((*follow_disk_info_list)->next);
create_disk(device_name, follow_disk_info_list);
}
else if (is_partition_name(device_name, NULL))
{
parent_disk_info = disk_info_list;
while(1)
{
if (!parent_disk_info)
goto info_exit;
if (!strncmp(device_name, parent_disk_info->device, 3))
break;
parent_disk_info = parent_disk_info->next;
}
follow_partition_list = &(parent_disk_info->partitions);
while(*follow_partition_list)
follow_partition_list = &((*follow_partition_list)->next);
new_partition_info = create_partition(device_name, follow_partition_list);
if(new_partition_info)
new_partition_info->disk = parent_disk_info;
}
}
info_exit:
fclose(fp);
return disk_info_list;
}
disk_info_t *read_disk_data(){
disk_info_t *disk_info_list = NULL, *new_disk_info, **follow_disk_info_list;
char *partition_info = read_whole_file(PARTITION_FILE);
char *follow_info;
char line[64], device_name[16];
u32 major;
disk_info_t *parent_disk_info;
partition_info_t *new_partition_info, **follow_partition_list;
u64 device_size;
if(partition_info == NULL){
usb_dbg("Failed to open \"%s\"!!\n", PARTITION_FILE);
return disk_info_list;
}
follow_info = partition_info;
memset(device_name, 0, 16);
while(get_line_from_buffer(follow_info, line, 64) != NULL){
follow_info += strlen(line);
if(sscanf(line, "%u %*u %llu %[^\n ]", &major, &device_size, device_name) != 3)
continue;
if(major != USB_DISK_MAJOR)
continue;
if(device_size == 1) // extend partition.
continue;
if(is_disk_name(device_name)){ // Disk
follow_disk_info_list = &disk_info_list;
while(*follow_disk_info_list != NULL)
follow_disk_info_list = &((*follow_disk_info_list)->next);
new_disk_info = create_disk(device_name, follow_disk_info_list);
}
else if(is_partition_name(device_name, NULL)){ // Partition
// Found a partition device.
// Find the parent disk.
parent_disk_info = disk_info_list;
while(1){
if(parent_disk_info == NULL){
usb_dbg("Error while parsing %s: found "
"partition '%s' but haven't seen the disk device "
"of which it is a part.\n", PARTITION_FILE, device_name);
free(partition_info);
return disk_info_list;
}
if(!strncmp(device_name, parent_disk_info->device, 3))
break;
parent_disk_info = parent_disk_info->next;
}
follow_partition_list = &(parent_disk_info->partitions);
while(*follow_partition_list != NULL){
if((*follow_partition_list)->partition_order == 0){
free_partition_data(follow_partition_list);
parent_disk_info->partitions = NULL;
follow_partition_list = &(parent_disk_info->partitions);
}
else
follow_partition_list = &((*follow_partition_list)->next);
}
new_partition_info = create_partition(device_name, follow_partition_list);
if(new_partition_info != NULL)
new_partition_info->disk = parent_disk_info;
}
}
free(partition_info);
return disk_info_list;
}
int main(int argc, char *argv[]) {
_cleanup_strv_free_ char **disks_done = NULL;
_cleanup_fclose_ FILE *f = NULL;
unsigned n = 0;
int r = EXIT_FAILURE, r2 = EXIT_FAILURE;
char **i;
if (argc > 1 && argc != 4) {
log_error("This program takes three or no arguments.");
return EXIT_FAILURE;
}
if (argc > 1)
arg_dest = argv[1];
log_set_target(LOG_TARGET_SAFE);
log_parse_environment();
log_open();
umask(0022);
if (parse_proc_cmdline(parse_proc_cmdline_item) < 0)
goto cleanup;
if (!arg_enabled) {
r = r2 = EXIT_SUCCESS;
goto cleanup;
}
strv_uniq(arg_disks);
if (arg_read_crypttab) {
struct stat st;
f = fopen("/etc/crypttab", "re");
if (!f) {
if (errno == ENOENT)
r = EXIT_SUCCESS;
else
log_error("Failed to open /etc/crypttab: %m");
goto next;
}
if (fstat(fileno(f), &st) < 0) {
log_error("Failed to stat /etc/crypttab: %m");
goto next;
}
/* If we readd support for specifying passphrases
* directly in crypttabe we should upgrade the warning
* below, though possibly only if a passphrase is
* specified directly. */
if (st.st_mode & 0005)
log_debug("/etc/crypttab is world-readable. This is usually not a good idea.");
for (;;) {
char line[LINE_MAX], *l;
_cleanup_free_ char *name = NULL, *device = NULL, *password = NULL, *options = NULL;
int k;
if (!fgets(line, sizeof(line), f))
break;
n++;
l = strstrip(line);
if (*l == '#' || *l == 0)
continue;
k = sscanf(l, "%ms %ms %ms %ms", &name, &device, &password, &options);
if (k < 2 || k > 4) {
log_error("Failed to parse /etc/crypttab:%u, ignoring.", n);
continue;
}
/*
If options are specified on the kernel commandline, let them override
the ones from crypttab.
*/
STRV_FOREACH(i, arg_options) {
_cleanup_free_ char *proc_uuid = NULL, *proc_options = NULL;
const char *p = *i;
k = sscanf(p, "%m[0-9a-fA-F-]=%ms", &proc_uuid, &proc_options);
if (k == 2 && streq(proc_uuid, device + 5)) {
free(options);
options = strdup(p);
if (!proc_options) {
log_oom();
goto cleanup;
}
}
}
if (arg_disks) {
/*
If luks UUIDs are specified on the kernel command line, use them as a filter
for /etc/crypttab and only generate units for those.
*/
STRV_FOREACH(i, arg_disks) {
_cleanup_free_ char *proc_device = NULL, *proc_name = NULL;
const char *p = *i;
if (startswith(p, "luks-"))
p += 5;
proc_name = strappend("luks-", p);
proc_device = strappend("UUID=", p);
if (!proc_name || !proc_device) {
log_oom();
goto cleanup;
}
if (streq(proc_device, device) || streq(proc_name, name)) {
if (create_disk(name, device, password, options) < 0)
goto cleanup;
if (strv_extend(&disks_done, p) < 0) {
log_oom();
goto cleanup;
}
}
}
} else if (create_disk(name, device, password, options) < 0)
static int
add_devs(di_node_t node, di_minor_t minor, void *arg)
{
struct search_args *args;
int result = DI_WALK_CONTINUE;
args = (struct search_args *)arg;
if (dm_debug > 1) {
/* This is all just debugging code */
char *devpath;
char dev_name[MAXPATHLEN];
devpath = di_devfs_path(node);
(void) snprintf(dev_name, sizeof (dev_name), "%s:%s", devpath,
di_minor_name(minor));
di_devfs_path_free((void *) devpath);
(void) fprintf(stderr,
"INFO: dev: %s, node: %s%d, minor: 0x%x, type: %s\n",
dev_name, di_node_name(node), di_instance(node),
di_minor_spectype(minor),
(di_minor_nodetype(minor) != NULL ?
di_minor_nodetype(minor) : "NULL"));
}
if (bus_type(node, minor, args->ph) != NULL) {
if (add_bus(args, node, minor, NULL) == NULL) {
args->dev_walk_status = ENOMEM;
result = DI_WALK_TERMINATE;
}
} else if (is_ctrl(node, minor)) {
if (add_controller(args, node, minor) == NULL) {
args->dev_walk_status = ENOMEM;
result = DI_WALK_TERMINATE;
}
} else if (di_minor_spectype(minor) == S_IFCHR &&
(is_drive(minor) || is_zvol(node, minor))) {
char *devidstr;
char kernel_name[MAXPATHLEN];
disk_t *diskp;
(void) snprintf(kernel_name, sizeof (kernel_name), "%s%d",
di_node_name(node), di_instance(node));
devidstr = get_str_prop(DEVICE_ID_PROP, node);
args->node = node;
args->minor = minor;
/*
* Check if we already got this disk and
* this is another slice.
*/
if (!have_disk(args, devidstr, kernel_name, &diskp)) {
args->dev_walk_status = 0;
/*
* This is a newly found disk, create the
* disk structure.
*/
diskp = create_disk(devidstr, kernel_name, args);
if (diskp == NULL) {
args->dev_walk_status = ENOMEM;
}
if (diskp->drv_type != DM_DT_FLOPPY) {
/* add the controller relationship */
if (args->dev_walk_status == 0) {
if (add_disk2controller(diskp,
args) != 0) {
args->dev_walk_status = ENOMEM;
}
}
}
}
if (is_zvol(node, minor)) {
char zvdsk[MAXNAMELEN];
char *str;
alias_t *ap;
if (di_prop_lookup_strings(di_minor_devt(minor),
node, "name", &str) == -1)
return (DI_WALK_CONTINUE);
(void) snprintf(zvdsk, MAXNAMELEN, "/dev/zvol/rdsk/%s",
str);
if ((ap = find_alias(diskp, kernel_name)) == NULL) {
if (new_alias(diskp, kernel_name,
zvdsk, args) != 0) {
args->dev_walk_status = ENOMEM;
}
} else {
/*
* It is possible that we have already added
* this devpath.
* Do not add it again. new_devpath will
* return a 0 if found, and not add the path.
*/
if (new_devpath(ap, zvdsk) != 0) {
args->dev_walk_status = ENOMEM;
}
}
}
/* Add the devpaths for the drive. */
if (args->dev_walk_status == 0) {
char *devpath;
char slice_path[MAXPATHLEN];
char *pattern;
/*
* We will come through here once for each of
* the raw slice device names.
*/
devpath = di_devfs_path(node);
(void) snprintf(slice_path,
sizeof (slice_path), "%s:%s",
devpath, di_minor_name(minor));
di_devfs_path_free((void *) devpath);
if (libdiskmgt_str_eq(di_minor_nodetype(minor),
DDI_NT_FD)) {
pattern = DEVLINK_FLOPPY_REGEX;
} else {
pattern = DEVLINK_REGEX;
}
/* Walk the /dev tree to get the devlinks. */
(void) di_devlink_walk(args->handle, pattern,
slice_path, DI_PRIMARY_LINK, arg, add_devpath);
}
if (args->dev_walk_status != 0) {
result = DI_WALK_TERMINATE;
}
}
return (result);
}
