ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add storageproxyd UFS support

Browse source 
This CL enables storageproxyd to run on UFS device.
The proxy prepares and sends SECURITY PROTOCOL IN/OUT commands to UFS
device.

Bug: 143636526
Test: Trusty storage tests
Change-Id: Ibe16578c12b978c9a95deccfb1873081e8d0e994
This commit is contained in:
Wenhao Wang 2019-12-11 15:22:03 -08:00
parent 1ef36b7491
commit ce2f1a4761
2 changed files with 130 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

130
trusty/storage/proxy/rpmb.c
View file

@ -16,6 +16,7 @@
#include <errno.h>
#include <fcntl.h>
#include <scsi/sg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
@ -51,6 +52,50 @@
#define MMC_BLOCK_SIZE 512
/*
* There should be no timeout for security protocol ioctl call, so we choose a
* large number for timeout.
* 20000 millisecs == 20 seconds
*/
#define TIMEOUT 20000
/*
* The sg device driver that supports new interface has a major version number of "3".
* SG_GET_VERSION_NUM ioctl() will yield a number greater than or 30000.
*/
#define RPMB_MIN_SG_VERSION_NUM 30000
/*
* CDB format of SECURITY PROTOCOL IN/OUT commands
* (JEDEC Standard No. 220D, Page 264)
*/
struct sec_proto_cdb {
/*
* OPERATION CODE = A2h for SECURITY PROTOCOL IN command,
* OPERATION CODE = B5h for SECURITY PROTOCOL OUT command.
*/
uint8_t opcode;
/* SECURITY PROTOCOL = ECh (JEDEC Universal Flash Storage) */
uint8_t sec_proto;
/*
* The SECURITY PROTOCOL SPECIFIC field specifies the RPMB Protocol ID.
* CDB Byte 2 = 00h and CDB Byte 3 = 01h for RPMB Region 0.
*/
uint8_t cdb_byte_2;
uint8_t cdb_byte_3;
/*
* Byte 4 and 5 are reserved.
*/
uint8_t cdb_byte_4;
uint8_t cdb_byte_5;
/* ALLOCATION/TRANSFER LENGTH in big-endian */
uint32_t length;
/* Byte 9 is reserved. */
uint8_t cdb_byte_10;
/* CONTROL = 00h. */
uint8_t ctrl;
} __packed;
static int rpmb_fd = -1;
static uint8_t read_buf[4096];
static enum dev_type dev_type = UNKNOWN_RPMB;
@ -71,6 +116,21 @@ static void print_buf(const char* prefix, const uint8_t* buf, size_t size) {
#endif
static void set_sg_io_hdr(sg_io_hdr_t* io_hdrp, int dxfer_direction, unsigned char cmd_len,
unsigned char mx_sb_len, unsigned int dxfer_len, void* dxferp,
unsigned char* cmdp, void* sbp) {
memset(io_hdrp, 0, sizeof(sg_io_hdr_t));
io_hdrp->interface_id = 'S';
io_hdrp->dxfer_direction = dxfer_direction;
io_hdrp->cmd_len = cmd_len;
io_hdrp->mx_sb_len = mx_sb_len;
io_hdrp->dxfer_len = dxfer_len;
io_hdrp->dxferp = dxferp;
io_hdrp->cmdp = cmdp;
io_hdrp->sbp = sbp;
io_hdrp->timeout = TIMEOUT;
}
static int send_mmc_rpmb_req(int mmc_fd, const struct storage_rpmb_send_req* req) {
struct {
struct mmc_ioc_multi_cmd multi;
@ -132,6 +192,57 @@ static int send_mmc_rpmb_req(int mmc_fd, const struct storage_rpmb_send_req* req
return rc;
}
static int send_ufs_rpmb_req(int sg_fd, const struct storage_rpmb_send_req* req) {
int rc;
const uint8_t* write_buf = req->payload;
/*
* Meaning of member values are stated on the definition of struct sec_proto_cdb.
*/
struct sec_proto_cdb in_cdb = {0xA2, 0xEC, 0x00, 0x01, 0x00, 0x00, 0, 0x00, 0x00};
struct sec_proto_cdb out_cdb = {0xB5, 0xEC, 0x00, 0x01, 0x00, 0x00, 0, 0x00, 0x00};
unsigned char sense_buffer[32];
if (req->reliable_write_size) {
/* Prepare SECURITY PROTOCOL OUT command. */
out_cdb.length = __builtin_bswap32(req->reliable_write_size);
sg_io_hdr_t io_hdr;
set_sg_io_hdr(&io_hdr, SG_DXFER_TO_DEV, sizeof(out_cdb), sizeof(sense_buffer),
req->reliable_write_size, (void*)write_buf, (unsigned char*)&out_cdb,
sense_buffer);
rc = ioctl(sg_fd, SG_IO, &io_hdr);
if (rc < 0) {
ALOGE("%s: ufs ioctl failed: %d, %s\n", __func__, rc, strerror(errno));
}
write_buf += req->reliable_write_size;
}
if (req->write_size) {
/* Prepare SECURITY PROTOCOL OUT command. */
out_cdb.length = __builtin_bswap32(req->write_size);
sg_io_hdr_t io_hdr;
set_sg_io_hdr(&io_hdr, SG_DXFER_TO_DEV, sizeof(out_cdb), sizeof(sense_buffer),
req->write_size, (void*)write_buf, (unsigned char*)&out_cdb, sense_buffer);
rc = ioctl(sg_fd, SG_IO, &io_hdr);
if (rc < 0) {
ALOGE("%s: ufs ioctl failed: %d, %s\n", __func__, rc, strerror(errno));
}
write_buf += req->write_size;
}
if (req->read_size) {
/* Prepare SECURITY PROTOCOL IN command. */
out_cdb.length = __builtin_bswap32(req->read_size);
sg_io_hdr_t io_hdr;
set_sg_io_hdr(&io_hdr, SG_DXFER_FROM_DEV, sizeof(in_cdb), sizeof(sense_buffer),
req->read_size, read_buf, (unsigned char*)&in_cdb, sense_buffer);
rc = ioctl(sg_fd, SG_IO, &io_hdr);
if (rc < 0) {
ALOGE("%s: ufs ioctl failed: %d, %s\n", __func__, rc, strerror(errno));
}
}
return rc;
}
static int send_virt_rpmb_req(int rpmb_fd, void* read_buf, size_t read_size, const void* payload,
size_t payload_size) {
int rc;
@ -194,6 +305,13 @@ int rpmb_send(struct storage_msg* msg, const void* r, size_t req_len) {
msg->result = STORAGE_ERR_GENERIC;
goto err_response;
}
} else if (dev_type == UFS_RPMB) {
rc = send_ufs_rpmb_req(rpmb_fd, req);
if (rc < 0) {
ALOGE("send_ufs_rpmb_req failed: %d, %s\n", rc, strerror(errno));
msg->result = STORAGE_ERR_GENERIC;
goto err_response;
}
} else if ((dev_type == VIRT_RPMB) || (dev_type == SOCK_RPMB)) {
size_t payload_size = req->reliable_write_size + req->write_size;
rc = send_virt_rpmb_req(rpmb_fd, read_buf, req->read_size, req->payload, payload_size);
@ -233,7 +351,7 @@ err_response:
}
int rpmb_open(const char* rpmb_devname, enum dev_type open_dev_type) {
int rc;
int rc, sg_version_num;
dev_type = open_dev_type;
if (dev_type != SOCK_RPMB) {
@ -263,6 +381,16 @@ int rpmb_open(const char* rpmb_devname, enum dev_type open_dev_type) {
return rc;
}
}
/* For UFS, it is prudent to check we hava a sg device by calling an ioctl */
if (dev_type == UFS_RPMB) {
if ((ioctl(rc, SG_GET_VERSION_NUM, &sg_version_num) < 0) ||
(sg_version_num < RPMB_MIN_SG_VERSION_NUM)) {
ALOGE("%s is not a sg device, or old sg driver\n", rpmb_devname);
return -1;
}
}
rpmb_fd = rc;
return 0;
}

2
trusty/storage/proxy/rpmb.h
View file

@ -18,7 +18,7 @@
#include <stdint.h>
#include <trusty/interface/storage.h>
enum dev_type { UNKNOWN_RPMB, MMC_RPMB, VIRT_RPMB, SOCK_RPMB };
enum dev_type { UNKNOWN_RPMB, MMC_RPMB, VIRT_RPMB, UFS_RPMB, SOCK_RPMB };
int rpmb_open(const char* rpmb_devname, enum dev_type dev_type);
int rpmb_send(struct storage_msg* msg, const void* r, size_t req_len);