vold/blkdev.c - AOSPA/android_system_core - Gitiles


 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * 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.
  */

 #include <stdlib.h>
 #include <string.h>
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>

 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/mman.h>

 #include <linux/fs.h>

 #include "vold.h"
 #include "blkdev.h"
 #include "diskmbr.h"

 #define DEBUG_BLKDEV 0

 static blkdev_list_t *list_root = NULL;

 static blkdev_t *_blkdev_create(blkdev_t *disk, char *devpath, int major,
                                 int minor, char *type, struct media *media, char *dev_fspath);
 static void blkdev_dev_fspath_set(blkdev_t *blk, char *dev_fspath);

 int blkdev_handle_devicefile_removed(blkdev_t *blk, char *dev_fspath)
 {
 #if DEBUG_BLKDEV
     LOG_VOL("blkdev_handle_devicefile_removed(%s):\n", dev_fspath);
 #endif
     blkdev_dev_fspath_set(blk, NULL);
     return 0;
 }

 int blkdev_handle_devicefile_created(blkdev_t *blk, char *dev_fspath)
 {
     int rc = 0;
     blkdev_t *disk;

 #if DEBUG_BLKDEV
     LOG_VOL("blkdev_handle_devicefile_created(%s):\n", dev_fspath);
 #endif

     if (!blk) {
         /*
          * This device does not yet have a backing blkdev associated with it.
          * Create a new one in the pending state and fill in the information
          * we have.
          */
         struct stat sbuf;

         if (stat(dev_fspath, &sbuf) < 0) {
             LOGE("Unable to stat device '%s' (%s)\n", dev_fspath, strerror(errno));
             return -errno;
         }

         int major = (sbuf.st_rdev & 0xfff00) >> 8;
         int minor = (sbuf.st_rdev & 0xff) | ((sbuf.st_rdev >> 12) & 0xfff00);

         disk = blkdev_lookup_by_devno(major, 0);

         if (!disk) {
             /*
              * If there isn't a disk associated with this device, then
              * its not what we're looking for
              */
 #if DEBUG_BLKDEV
             LOG_VOL("Ignoring device file '%s' (no disk found)\n", dev_fspath);
 #endif
             return 0;
         }

         if (!(blk = blkdev_create_pending_partition(disk, dev_fspath, major,
                                                     minor, disk->media))) {
             LOGE("Unable to create pending blkdev\n");
             return -1;
         }
     } else
         blkdev_dev_fspath_set(blk, dev_fspath);

     /*
      * If we're a disk, then read the partition table. Otherwise we're
      * a partition so get the partition type
      */
     disk = blk->disk;

     int fd;

     if ((fd = open(disk->dev_fspath, O_RDWR)) < 0) {
         LOGE("Unable to open device '%s' (%s)\n", disk->dev_fspath, strerror(errno));
         return -errno;
     }

     if (ioctl(fd, BLKGETSIZE, &blk->nr_sec)) {
         LOGE("Unable to get device size (%m)\n");
         return -errno;
     }

 #if DEBUG_BLKDEV
     LOG_VOL("New device '%s' size = %u sectors\n", dev_fspath, blk->nr_sec);
 #endif

     void *raw_pt;
     unsigned char *chr_pt;
     int i;

     raw_pt = chr_pt = mmap(NULL, 512, PROT_READ, MAP_PRIVATE, fd, 0);
     if (raw_pt == MAP_FAILED) {
         LOGE("Unable to mmap device paritition table (%m)\n");
         goto out_nommap;
     }

     if (blk->type == blkdev_disk) {
         blk->nr_parts = 0;

         if ((chr_pt[0x1fe] != 0x55) && (chr_pt[0x1ff] != 0xAA)) {
             LOG_VOL("Disk '%s' does not contain a partition table\n", dev_fspath);
             goto out;
         }

         for (i = 0; i < 4; i++) {
             struct dos_partition part;

             dos_partition_dec(raw_pt + DOSPARTOFF + i * sizeof(struct dos_partition), &part);
             if (part.dp_size != 0 && part.dp_typ != 0)
                 blk->nr_parts++;
         }
         LOG_VOL("Disk device '%s' (blkdev %s) contains %d partitions\n",
                 dev_fspath, blk->devpath, blk->nr_parts);
     } else if (blk->type == blkdev_partition) {
         struct dos_partition part;
         int part_no = blk->minor -1;

         dos_partition_dec(raw_pt + DOSPARTOFF + part_no * sizeof(struct dos_partition), &part);

         if (!part.dp_typ)
             LOG_VOL("Warning - Partition device '%s' (blkdev %s) has no partition type set\n",
                     dev_fspath, blk->devpath);
         blk->part_type = part.dp_typ;

         LOG_VOL("Partition device '%s' (blkdev %s) partition type 0x%x\n",
                  dev_fspath, blk->devpath, blk->part_type);
     } else {
         LOGE("Bad blkdev type '%d'\n", blk->type);
         rc = -EINVAL;
         goto out;
     }

  out:
     munmap(raw_pt, 512);
  out_nommap:
     close(fd);
     return rc;
 }

 blkdev_t *blkdev_create_pending_partition(blkdev_t *disk, char *dev_fspath, int major,
                                 int minor, struct media *media)
 {
     return _blkdev_create(disk, NULL, major, minor, "partition", media, dev_fspath);
 }

 blkdev_t *blkdev_create(blkdev_t *disk, char *devpath, int major, int minor, struct media *media, char *type)
 {
     return _blkdev_create(disk, devpath, major, minor, type, media, NULL);
 }

 static blkdev_t *_blkdev_create(blkdev_t *disk, char *devpath, int major,
                                 int minor, char *type, struct media *media, char *dev_fspath)
 {
     blkdev_t *new;
     struct blkdev_list *list_entry;

     if (disk && disk->type != blkdev_disk) {
         LOGE("Non disk parent specified for blkdev!\n");
         return NULL;
     }

     if (!(new = malloc(sizeof(blkdev_t))))
         return NULL;

     memset(new, 0, sizeof(blkdev_t));

     if (!(list_entry = malloc(sizeof(struct blkdev_list)))) {
         free (new);
         return NULL;
     }
     list_entry->dev = new;
     list_entry->next = NULL;

     if (!list_root)
         list_root = list_entry;
     else {
         struct blkdev_list *list_scan = list_root;
         while (list_scan->next)
             list_scan = list_scan->next;
         list_scan->next = list_entry;
     }

     if (devpath)
         new->devpath = strdup(devpath);
     new->major = major;
     new->minor = minor;
     new->media = media;
     if (dev_fspath)
         new->dev_fspath = strdup(dev_fspath);
     new->nr_sec = 0xffffffff;

     if (disk)
         new->disk = disk;
     else
         new->disk = new; // Note the self disk pointer

     if (!strcmp(type, "disk"))
         new->type = blkdev_disk;
     else if (!strcmp(type, "partition"))
         new->type = blkdev_partition;
     else {
         LOGE("Unknown block device type '%s'\n", type);
         new->type = blkdev_unknown;
     }

     return new;
 }

 void blkdev_destroy(blkdev_t *blkdev)
 {
     struct blkdev_list *list_next;

     if (list_root->dev == blkdev) {
         list_next = list_root->next;
         free (list_root);
         list_root = list_next;
     } else {
         struct blkdev_list *list_scan = list_root;
         while (list_scan->next->dev != blkdev)
             list_scan = list_scan -> next;
         list_next = list_scan->next->next;
         free(list_scan->next);
         list_scan->next = list_next;
     }

     if (blkdev->devpath)
         free(blkdev->devpath);
     if (blkdev->dev_fspath)
         free(blkdev->dev_fspath);
     free(blkdev);
 }

 blkdev_t *blkdev_lookup_by_path(char *devpath)
 {
     struct blkdev_list *list_scan = list_root;

     while (list_scan) {
         if (!strcmp(list_scan->dev->devpath, devpath))
             return list_scan->dev;
         list_scan = list_scan->next;
     }
 #if DEBUG_BLKDEV
     LOG_VOL("blkdev_lookup_by_path(): No blkdev found @ %s\n", devpath);
 #endif
     return NULL;
 }

 blkdev_t *blkdev_lookup_by_devno(int maj, int min)
 {
     struct blkdev_list *list_scan = list_root;

     while (list_scan) {
         if ((list_scan->dev->major == maj) &&
             (list_scan->dev->minor == min))
             return list_scan->dev;
         list_scan = list_scan->next;
     }
 #if DEBUG_BLKDEV
     LOG_VOL("blkdev_lookup_by_devno(): No blkdev found for %d.%d\n", maj, min);
 #endif
     return NULL;
 }

 blkdev_t *blkdev_lookup_by_dev_fspath(char *dev_fspath)
 {
     struct blkdev_list *list_scan = list_root;

     while (list_scan) {
         if (list_scan->dev->dev_fspath) {
             if (!strcmp(list_scan->dev->dev_fspath, dev_fspath))
                 return list_scan->dev;
         }

         list_scan = list_scan->next;
     }
 //    LOG_VOL("blkdev_lookup_by_devno(): No blkdev found for %d.%d\n", maj, min);
     return NULL;
 }


 /*
  * Given a disk device, return the number of partitions yet to be
  * processed.
  */
 int blkdev_get_num_pending_partitions(blkdev_t *blk)
 {
     struct blkdev_list *list_scan = list_root;
     int num = blk->nr_parts;

     if (blk->type != blkdev_disk)
         return -EINVAL;

     while (list_scan) {
         if (list_scan->dev->type != blkdev_partition)
             goto next;

         if (list_scan->dev->major != blk->major)
             goto next;

         if (list_scan->dev->nr_sec != 0xffffffff)
             num--;
  next:
         list_scan = list_scan->next;
     }
     return num;
 }

 void blkdev_devpath_set(blkdev_t *blk, char *devpath)
 {
     blk->devpath = strdup(devpath);
 }

 static void blkdev_dev_fspath_set(blkdev_t *blk, char *dev_fspath)
 {
     if (dev_fspath)
         blk->dev_fspath = strdup(dev_fspath);
     else {
         free(blk->dev_fspath);
         blk->dev_fspath = NULL;
     }
 }

	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* 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.
	*/

	#include <stdlib.h>
	#include <string.h>
	#include <dirent.h>
	#include <errno.h>
	#include <fcntl.h>

	#include <sys/types.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <sys/mman.h>

	#include <linux/fs.h>

	#include "vold.h"
	#include "blkdev.h"
	#include "diskmbr.h"

	#define DEBUG_BLKDEV 0

	static blkdev_list_t *list_root = NULL;

	static blkdev_t _blkdev_create(blkdev_t disk, char *devpath, int major,
	int minor, char type, struct media media, char *dev_fspath);
	static void blkdev_dev_fspath_set(blkdev_t blk, char dev_fspath);

	int blkdev_handle_devicefile_removed(blkdev_t blk, char dev_fspath)
	{
	#if DEBUG_BLKDEV
	LOG_VOL("blkdev_handle_devicefile_removed(%s):\n", dev_fspath);
	#endif
	blkdev_dev_fspath_set(blk, NULL);
	return 0;
	}

	int blkdev_handle_devicefile_created(blkdev_t blk, char dev_fspath)
	{
	int rc = 0;
	blkdev_t *disk;

	#if DEBUG_BLKDEV
	LOG_VOL("blkdev_handle_devicefile_created(%s):\n", dev_fspath);
	#endif

	if (!blk) {
	/*
	* This device does not yet have a backing blkdev associated with it.
	* Create a new one in the pending state and fill in the information
	* we have.
	*/
	struct stat sbuf;

	if (stat(dev_fspath, &sbuf) < 0) {
	LOGE("Unable to stat device '%s' (%s)\n", dev_fspath, strerror(errno));
	return -errno;
	}

	int major = (sbuf.st_rdev & 0xfff00) >> 8;
	int minor = (sbuf.st_rdev & 0xff) \| ((sbuf.st_rdev >> 12) & 0xfff00);

	disk = blkdev_lookup_by_devno(major, 0);

	if (!disk) {
	/*
	* If there isn't a disk associated with this device, then
	* its not what we're looking for
	*/
	#if DEBUG_BLKDEV
	LOG_VOL("Ignoring device file '%s' (no disk found)\n", dev_fspath);
	#endif
	return 0;
	}

	if (!(blk = blkdev_create_pending_partition(disk, dev_fspath, major,
	minor, disk->media))) {
	LOGE("Unable to create pending blkdev\n");
	return -1;
	}
	} else
	blkdev_dev_fspath_set(blk, dev_fspath);

	/*
	* If we're a disk, then read the partition table. Otherwise we're
	* a partition so get the partition type
	*/
	disk = blk->disk;

	int fd;

	if ((fd = open(disk->dev_fspath, O_RDWR)) < 0) {
	LOGE("Unable to open device '%s' (%s)\n", disk->dev_fspath, strerror(errno));
	return -errno;
	}

	if (ioctl(fd, BLKGETSIZE, &blk->nr_sec)) {
	LOGE("Unable to get device size (%m)\n");
	return -errno;
	}

	#if DEBUG_BLKDEV
	LOG_VOL("New device '%s' size = %u sectors\n", dev_fspath, blk->nr_sec);
	#endif

	void *raw_pt;
	unsigned char *chr_pt;
	int i;

	raw_pt = chr_pt = mmap(NULL, 512, PROT_READ, MAP_PRIVATE, fd, 0);
	if (raw_pt == MAP_FAILED) {
	LOGE("Unable to mmap device paritition table (%m)\n");
	goto out_nommap;
	}

	if (blk->type == blkdev_disk) {
	blk->nr_parts = 0;

	if ((chr_pt[0x1fe] != 0x55) && (chr_pt[0x1ff] != 0xAA)) {
	LOG_VOL("Disk '%s' does not contain a partition table\n", dev_fspath);
	goto out;
	}

	for (i = 0; i < 4; i++) {
	struct dos_partition part;

	dos_partition_dec(raw_pt + DOSPARTOFF + i * sizeof(struct dos_partition), &part);
	if (part.dp_size != 0 && part.dp_typ != 0)
	blk->nr_parts++;
	}
	LOG_VOL("Disk device '%s' (blkdev %s) contains %d partitions\n",
	dev_fspath, blk->devpath, blk->nr_parts);
	} else if (blk->type == blkdev_partition) {
	struct dos_partition part;
	int part_no = blk->minor -1;

	dos_partition_dec(raw_pt + DOSPARTOFF + part_no * sizeof(struct dos_partition), &part);

	if (!part.dp_typ)
	LOG_VOL("Warning - Partition device '%s' (blkdev %s) has no partition type set\n",
	dev_fspath, blk->devpath);
	blk->part_type = part.dp_typ;

	LOG_VOL("Partition device '%s' (blkdev %s) partition type 0x%x\n",
	dev_fspath, blk->devpath, blk->part_type);
	} else {
	LOGE("Bad blkdev type '%d'\n", blk->type);
	rc = -EINVAL;
	goto out;
	}

	out:
	munmap(raw_pt, 512);
	out_nommap:
	close(fd);
	return rc;
	}

	blkdev_t blkdev_create_pending_partition(blkdev_t disk, char *dev_fspath, int major,
	int minor, struct media *media)
	{
	return _blkdev_create(disk, NULL, major, minor, "partition", media, dev_fspath);
	}

	blkdev_t blkdev_create(blkdev_t disk, char devpath, int major, int minor, struct media media, char *type)
	{
	return _blkdev_create(disk, devpath, major, minor, type, media, NULL);
	}

	static blkdev_t _blkdev_create(blkdev_t disk, char *devpath, int major,
	int minor, char type, struct media media, char *dev_fspath)
	{
	blkdev_t *new;
	struct blkdev_list *list_entry;

	if (disk && disk->type != blkdev_disk) {
	LOGE("Non disk parent specified for blkdev!\n");
	return NULL;
	}

	if (!(new = malloc(sizeof(blkdev_t))))
	return NULL;

	memset(new, 0, sizeof(blkdev_t));

	if (!(list_entry = malloc(sizeof(struct blkdev_list)))) {
	free (new);
	return NULL;
	}
	list_entry->dev = new;
	list_entry->next = NULL;

	if (!list_root)
	list_root = list_entry;
	else {
	struct blkdev_list *list_scan = list_root;
	while (list_scan->next)
	list_scan = list_scan->next;
	list_scan->next = list_entry;
	}

	if (devpath)
	new->devpath = strdup(devpath);
	new->major = major;
	new->minor = minor;
	new->media = media;
	if (dev_fspath)
	new->dev_fspath = strdup(dev_fspath);
	new->nr_sec = 0xffffffff;

	if (disk)
	new->disk = disk;
	else
	new->disk = new; // Note the self disk pointer

	if (!strcmp(type, "disk"))
	new->type = blkdev_disk;
	else if (!strcmp(type, "partition"))
	new->type = blkdev_partition;
	else {
	LOGE("Unknown block device type '%s'\n", type);
	new->type = blkdev_unknown;
	}

	return new;
	}

	void blkdev_destroy(blkdev_t *blkdev)
	{
	struct blkdev_list *list_next;

	if (list_root->dev == blkdev) {
	list_next = list_root->next;
	free (list_root);
	list_root = list_next;
	} else {
	struct blkdev_list *list_scan = list_root;
	while (list_scan->next->dev != blkdev)
	list_scan = list_scan -> next;
	list_next = list_scan->next->next;
	free(list_scan->next);
	list_scan->next = list_next;
	}

	if (blkdev->devpath)
	free(blkdev->devpath);
	if (blkdev->dev_fspath)
	free(blkdev->dev_fspath);
	free(blkdev);
	}

	blkdev_t blkdev_lookup_by_path(char devpath)
	{
	struct blkdev_list *list_scan = list_root;

	while (list_scan) {
	if (!strcmp(list_scan->dev->devpath, devpath))
	return list_scan->dev;
	list_scan = list_scan->next;
	}
	#if DEBUG_BLKDEV
	LOG_VOL("blkdev_lookup_by_path(): No blkdev found @ %s\n", devpath);
	#endif
	return NULL;
	}

	blkdev_t *blkdev_lookup_by_devno(int maj, int min)
	{
	struct blkdev_list *list_scan = list_root;

	while (list_scan) {
	if ((list_scan->dev->major == maj) &&
	(list_scan->dev->minor == min))
	return list_scan->dev;
	list_scan = list_scan->next;
	}
	#if DEBUG_BLKDEV
	LOG_VOL("blkdev_lookup_by_devno(): No blkdev found for %d.%d\n", maj, min);
	#endif
	return NULL;
	}

	blkdev_t blkdev_lookup_by_dev_fspath(char dev_fspath)
	{
	struct blkdev_list *list_scan = list_root;

	while (list_scan) {
	if (list_scan->dev->dev_fspath) {
	if (!strcmp(list_scan->dev->dev_fspath, dev_fspath))
	return list_scan->dev;
	}

	list_scan = list_scan->next;
	}
	// LOG_VOL("blkdev_lookup_by_devno(): No blkdev found for %d.%d\n", maj, min);
	return NULL;
	}


	/*
	* Given a disk device, return the number of partitions yet to be
	* processed.
	*/
	int blkdev_get_num_pending_partitions(blkdev_t *blk)
	{
	struct blkdev_list *list_scan = list_root;
	int num = blk->nr_parts;

	if (blk->type != blkdev_disk)
	return -EINVAL;

	while (list_scan) {
	if (list_scan->dev->type != blkdev_partition)
	goto next;

	if (list_scan->dev->major != blk->major)
	goto next;

	if (list_scan->dev->nr_sec != 0xffffffff)
	num--;
	next:
	list_scan = list_scan->next;
	}
	return num;
	}

	void blkdev_devpath_set(blkdev_t blk, char devpath)
	{
	blk->devpath = strdup(devpath);
	}

	static void blkdev_dev_fspath_set(blkdev_t blk, char dev_fspath)
	{
	if (dev_fspath)
	blk->dev_fspath = strdup(dev_fspath);
	else {
	free(blk->dev_fspath);
	blk->dev_fspath = NULL;
	}
	}