linux scsi命令读取文件

weixin_38849487

已于 2023-12-14 09:13:33 修改

阅读量493

点赞数

文章标签： linux 算法数据库

于 2023-10-07 18:46:27 首次发布

本文链接：https://blog.csdn.net/weixin_38849487/article/details/133651436

版权

SCSI Read(10)是一种用于从SCSI设备读取数据的命令。下面是一个简单的示例代码，演示如何使用SCSI Read(10)命令来读取指定大小的文件：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define READ_CAPACITY_CMD    0x25
#define READ_10_CMD          0x28

#define DATA_BUFFER_SIZE     4096

void scsi_read(FILE* scsi_device, unsigned long long start_sector, unsigned int block_size, unsigned int num_blocks)
{
    unsigned char read_buffer[DATA_BUFFER_SIZE];
    unsigned char read_cmd[10] = {
        READ_10_CMD,
        0x00,
        (start_sector >> 24) & 0xFF,
        (start_sector >> 16) & 0xFF,
        (start_sector >> 8) & 0xFF,
        start_sector & 0xFF,
        0x00,
        (num_blocks >> 8) & 0xFF,
        num_blocks & 0xFF,
        0x00
    };

    memset(read_buffer, 0, sizeof(read_buffer));

    fseek(scsi_device, 0, SEEK_SET);  // 将文件指针移到开始位置

    // 发送SCSI命令
    fwrite(read_cmd, 1, sizeof(read_cmd), scsi_device);
    fflush(scsi_device);

    // 读取数据
    fread(read_buffer, block_size, num_blocks, scsi_device);

    // 可以在这里对读取到的数据进行处理或保存

    // 打印读取到的内容（仅用于示例）
    printf("Read Data:\n");
    for (int i = 0; i < num_blocks * block_size; i++)
    {
        printf("%02X ", read_buffer[i]);
        if ((i + 1) % block_size == 0)
            printf("\n");
    }
}

int main()
{
    // 打开SCSI设备文件（假设为/dev/sdc）
    FILE* scsi_device = fopen("/dev/sdc", "rb");
    if (scsi_device == NULL)
    {
        printf("Failed to open SCSI device.\n");
        return 1;
    }

    unsigned long long start_sector = 0;   // 起始扇区
    unsigned int block_size = 512;         // 块大小（字节）
    unsigned int num_blocks = 10;          // 读取的块数

    // 调用SCSI读取函数
    scsi_read(scsi_device, start_sector, block_size, num_blocks);

    // 关闭SCSI设备文件
    fclose(scsi_device);
    
    return 0;
}

注意：上述代码仅为演示目的，请谨慎操作并确保对SCSI设备的访问有合法的权限。在实际使用时，请根据您的需求和环境进行相应的修改和错误处理。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define READ_CAPACITY_CMD    0x25
#define READ_10_CMD          0x28

#define DATA_BUFFER_SIZE     4096

int scsi_read(FILE* scsi_device, unsigned long long start_sector, unsigned int block_size, unsigned int num_blocks, unsigned char* data_buffer)
{
    unsigned char read_cmd[10] = {
        READ_10_CMD,
        0x00,
        (start_sector >> 24) & 0xFF,
        (start_sector >> 16) & 0xFF,
        (start_sector >> 8) & 0xFF,
        start_sector & 0xFF,
        0x00,
        (num_blocks >> 8) & 0xFF,
        num_blocks & 0xFF,
        0x00
    };

    fseek(scsi_device, 0, SEEK_SET);  // 将文件指针移到开始位置

    // 发送SCSI命令
    fwrite(read_cmd, 1, sizeof(read_cmd), scsi_device);
    fflush(scsi_device);

    // 读取数据
    int bytes_read = fread(data_buffer, block_size, num_blocks, scsi_device);

    return bytes_read;
}

int main()
{
    // 打开SCSI设备文件（假设为/dev/sdc）
    FILE* scsi_device = fopen("/dev/sdc", "rb");
    if (scsi_device == NULL)
    {
        printf("Failed to open SCSI device.\n");
        return 1;
    }

    unsigned long long start_sector = 0;   // 起始扇区
    unsigned int block_size = 512;         // 块大小（字节）
    unsigned int num_blocks = 10;          // 读取的块数

    unsigned char data_buffer[DATA_BUFFER_SIZE];  // 存储读取到的数据

    // 调用SCSI读取函数
    int bytes_read = scsi_read(scsi_device, start_sector, block_size, num_blocks, data_buffer);
    if (bytes_read <= 0)
    {
        printf("Failed to read data from SCSI device.\n");
        fclose(scsi_device);
        return 1;
    }
    
    // 打印读取到的数据（仅用于示例）
    printf("Read Data:\n");
    for (int i = 0; i < bytes_read; i++)
    {
        printf("%02X ", data_buffer[i]);
        if ((i + 1) % block_size == 0)
            printf("\n");
    }

    // 关闭SCSI设备文件
    fclose(scsi_device);
    
    return 0;
}

如果你想在自己的程序中实现SCSI Read(10)命令来读取磁盘的物理扇区内容，你可以使用Linux提供的系统调用或库来完成。

一种常见的方法是使用open、ioctl和read函数。下面是一个简单的C语言示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/fs.h>
#include <unistd.h>

#define SECTOR_SIZE 512

int main() {
    int disk_fd;
    unsigned char buffer[SECTOR_SIZE];

    // 打开磁盘设备文件
    disk_fd = open("/dev/sdX", O_RDONLY);
    if (disk_fd == -1) {
        perror("Failed to open disk");
        exit(1);
    }

    // 定义 SCSI 命令
    struct hd_geometry geom;
    geom.start = 0;
    geom.length = 1;
  
    // 发送 SCSI 命令
    if (ioctl(disk_fd, HDIO_GETGEO, &geom) == -1) {
        perror("Failed to send SCSI command");
        close(disk_fd);
        exit(1);
    }

    // 读取物理扇区内容
    if (read(disk_fd, buffer, SECTOR_SIZE) == -1) {
        perror("Failed to read sector");
        close(disk_fd);
        exit(1);
    }

    // 关闭磁盘设备文件
    close(disk_fd);

    // 打印扇区内容
    for (int i = 0; i < SECTOR_SIZE; i++) {
        printf("%02X ", buffer[i]);
        if ((i + 1) % 16 == 0) {
            printf("\n");
        }
    }

    return 0;
}

read(disk_fd, buffer, SECTOR_SIZE) 是一种直接使用系统调用来读取磁盘设备文件中数据的方法。它会从文件描述符 disk_fd 指定的文件中读取 SECTOR_SIZE 字节的数据，并将其存储在 buffer 中。

以下是一个示例代码，演示如何使用 read 函数来读取磁盘设备文件：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

#define SECTOR_SIZE 512

int main() {
    int disk_fd;
    unsigned char buffer[SECTOR_SIZE];

    // 打开磁盘设备文件
    disk_fd = open("/dev/sdX", O_RDONLY | O_NONBLOCK);
    if (disk_fd == -1) {
        perror("Failed to open disk");
        exit(1);
    }

    // 读取扇区数据
    ssize_t num_bytes_read = read(disk_fd, buffer, SECTOR_SIZE);
    if (num_bytes_read == -1) {
        perror("Failed to read disk");
        close(disk_fd);
        exit(1);
    }

    // 打印读取到的数据
    for (int i = 0; i < num_bytes_read; i++) {
        printf("%02X ", buffer[i]);
        if ((i + 1) % 16 == 0) {
            printf("\n");
        }
    }

    // 关闭磁盘设备文件
    close(disk_fd);

    return 0;
}

请注意，这段代码中的 "/dev/sdX" 需要替换为你想读取的磁盘设备文件名。

这段代码打开指定的磁盘设备文件，然后使用 read 函数从文件中读取一个扇区的内容，并将其存储在 buffer 中。最后，将读取到的数据以十六进制形式打印出来。

使用 read 函数需要谨慎操作，并确保你了解磁盘读取的工作原理和可能带来的后果。同样，应该备份重要数据，并在测试或实验环境中进行尝试。
ret = ioctl(disk_fd, SG_IO, &io_hdr); 是一种使用 ioctl 系统调用，发送 SCSI 命令来控制磁盘设备的方法。它可以让你执行一些高级操作，如读取磁盘的 SMART 数据或发送 ATA 命令。

以下是一个示例代码，演示如何使用 ioctl 函数来发送 SCSI 命令：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/hdreg.h>
#include <linux/sg.h>

#define BUFFER_SIZE 512

int main() {
    int disk_fd;
    unsigned char buffer[BUFFER_SIZE];
    struct sg_io_hdr io_hdr;
    int ret;

    // 打开磁盘设备文件
    disk_fd = open("/dev/sdX", O_RDWR | O_NONBLOCK);
    if (disk_fd == -1) {
        perror("Failed to open disk");
        exit(1);
    }

    // 构造 SCSI 命令
    unsigned char scsi_cmd[16] = {0x12, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
    struct sg_iovec iov = {scsi_cmd, sizeof(scsi_cmd)};
    struct sg_iovec iov_out = {buffer, sizeof(buffer)};
    struct sg_scsi_id scsi_id = {0};
    io_hdr.interface_id = 'S';
    io_hdr.cmd_len = sizeof(scsi_cmd);
    io_hdr.mx_sb_len = 0;
    io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
    io_hdr.dxfer_len = BUFFER_SIZE;
    io_hdr.dxferp = buffer;
    io_hdr.cmdp = scsi_cmd;
    io_hdr.sbp = NULL;
    io_hdr.timeout = 5000;
    io_hdr.pack_id = 0;
    io_hdr.pack_len = 0;
    io_hdr.status = 0;
    io_hdr.masked_status = 0;
    io_hdr.msg_len = 0;
    io_hdr.sb_len = 0;
    io_hdr.mx_sb_len = 0;
    io_hdr.driver_status = 0;
    io_hdr.host_status = 0;
    io_hdr.protocol = 0;
    io_hdr.subprotocol = 0;
    io_hdr.request_len = sizeof(struct sg_io_hdr);
    io_hdr.request = (unsigned char *) &io_hdr;
    io_hdr.max_response_len = sizeof(struct sg_io_hdr);
    io_hdr.dummy = 0;

    // 发送 SCSI 命令
    ret = ioctl(disk_fd, SG_IO, &io_hdr);
    if (ret == -1) {
        perror("Failed to send SCSI command");
        close(disk_fd);
        exit(1);
    }

    // 打印读取到的数据
    for (int i = 0; i < BUFFER_SIZE; i++) {
        printf("%02X ", buffer[i]);
        if ((i + 1) % 16 == 0) {
            printf("\n");
        }
    }

    // 关闭磁盘设备文件
    close(disk_fd);

    return 0;
}

请注意，这段代码中的 "/dev/sdX" 需要替换为你想控制的磁盘设备文件名。在这个例子中，我们向设备发送了一个 SCSI READ CAPACITY 命令，来获取设备的容量信息。

以上是个示例，发送 SCSI 命令可能具有危险性，因此确保你了解 SCSI 命令的含义，并知道你要发送的命令的具体内容和效果。同样，应该备份重要数据，并在测试或实验环境中进行尝试。

在 Linux 系统中，你可以使用 C 语言和系统调用 read 来读取 U 盘的所有扇区，并将它们保存到一个 .iso 文件中。在这里，没有 “read10” 系统调用，但标准的 read 函数足以完成工作。

在编写程序之前，请注意以下几点：

确保你拥有足够的权限来直接从 U 盘设备读取数据。
U 盘设备通常可以在 /dev 目录下找到，例如 /dev/sdb。
你需要知道要读取的扇区数。

下面是执行此任务的 C 程序的简化示例。请注意，此代码仅用于说明，并且在执行前需要更多的错误检查和处理。

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

#define SECTOR_SIZE     512   // 一个扇区大小通常是512字节
#define BUFFER_SIZE     1024  // 定义一个合适的缓冲区大小

int main(int argc, char *argv[]) {
    int usb_fd, iso_fd, read_ret;
    char *usb_device_path, *iso_file_path;
    char buffer[BUFFER_SIZE];
    off_t num_sectors = 0; // 你需要填写 U 盘的扇区数

    if (argc != 4) {
        printf("使用方法: %s <U盘设备路径> <扇区数> <输出ISO文件路径>\n", argv[0]);
        return 1;
    }

    usb_device_path = argv[1];
    num_sectors = atoll(argv[2]);
    iso_file_path = argv[3];

    usb_fd = open(usb_device_path, O_RDONLY);
    if (usb_fd < 0) {
        perror("打开 U 盘设备失败");
        return 2;
    }

    iso_fd = open(iso_file_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (iso_fd < 0) {
        perror("创建 ISO 文件失败");
        close(usb_fd);
        return 3;
    }

    for (off_t i = 0; i < num_sectors; i++) {
        read_ret = read(usb_fd, buffer, SECTOR_SIZE);
        if (read_ret < 0) {
            perror("读取 U 盘数据失败");
            break;
        }

        if (write(iso_fd, buffer, read_ret) != read_ret) {
            perror("写入 ISO 文件失败");
            break;
        }
    }

    close(usb_fd);
    close(iso_fd);

    return 0;
}

在这个示例代码中，请注意以下几点：

我们假设了 U 盘的一个扇区是 512 字节。这是大多数情况下安全的假定，但是一些现代的存储设备可能会有不同的扇区大小。
read 系统调用被用来从 U 盘读取数据，write 系统调用用于将数据写入 .iso 文件。
此代码假设在启动前你已经知道要读取的扇区数，并将其通过命令行参数传递给程序。
错误处理非常基础，并且在生产环境中可能需要更复杂的错误处理策略。
你必须执行该程序时有适当的权限，否则将无法读取设备文件或者创建新的文件。

编译这个程序，你可以使用如下命令：

gcc -o read_usb read_usb.c

然后执行它（假设 /dev/sdb 是你的 U 盘设备路径，10000 是要读取的扇区数，output.iso 是你想保存的 ISO 文件名）：

sudo ./read_usb /dev/sdb 10000 output.iso

确保在实际的环境中用正确的设备文件和你设备的确切扇区数替换这些值。使用 sudo 是因为通常需要管理员权限才能直接从 USB 设备读取。请小心行事，错误的路径或设备文件可能会导致数据丢失。

要通过SCSI Read(10)命令在 Linux 上读取 U 盘的所有扇区并以 16 进制形式打印出来，需要用到 SCSI generic (sg) 设备接口，这通常需要安装sg3_utils包来提供相关的工具和库。

以下是一个简单的 C 程序示例，它打开了一个 sg 设备，发送了 Read(10)命令并打印读取的数据。

注意，这个示例代码并未完全错误检查，并且很可能需要在 root 模式下运行或需要适当权限，因为直接与 SCSI 设备通信通常需要特别权限。

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <scsi/sg.h>

#define SECTOR_SIZE 512
#define READ_10_COMMAND_LEN 10

int main(int argc, char *argv[]) {
    int sg_fd, sector_count, result;
    unsigned char read10_cmd[READ_10_COMMAND_LEN] = {
        0x28, // READ(10) command byte
        0,    // reserved
        0, 0, 0, 0, // logical block address set to zero means start from beginning
        0,    // reserved
        0, 1, // number of blocks to read
        0     // control byte
    };
    unsigned char buffer[SECTOR_SIZE];
    sg_io_hdr_t io_hdr;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <sg device>\n", argv[0]);
        return 1;
    }

    sg_fd = open(argv[1], O_RDONLY);
    if (sg_fd < 0) {
        perror("Error opening sg device");
        return 1;
    }

    for (sector_count = 0; ; ++sector_count) {
        memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
        io_hdr.interface_id = 'S'; // This must be set to 'S' for sg_io_hdr_t
        io_hdr.cmd_len = sizeof(read10_cmd);
        io_hdr.mx_sb_len = 0;
        io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
        io_hdr.dxfer_len = SECTOR_SIZE;
        io_hdr.dxferp = buffer;
        io_hdr.cmdp = read10_cmd;
        io_hdr.timeout = 20000;  // 20000 millisecs == 20 seconds

        // Perform the IO
        result = ioctl(sg_fd, SG_IO, &io_hdr);

        // Handle the result
        if (result < 0) {
            perror("SG_IO ioctl failed");
            break;
        }

        // Check for SCSI error
        if ((io_hdr.info & SG_INFO_OK_MASK) != SG_INFO_OK) {
            if (io_hdr.sb_len_wr > 0) {
                printf("SCSI error\n");
            } else {
                printf("Unknown error\n");
            }
            break;
        }

        // Dump data
        for (int i = 0; i < SECTOR_SIZE; ++i) {
            printf("%02x ", buffer[i]);
            // Newline for each sector
            if ((i + 1) % 16 == 0)
                printf("\n");
        }

        // Early exit for this example
        if(sector_count >= 5) break; // Remove this line in a real scenario
        
        // Increment LBA for next sector. This simplistic code assumes we only deal with small numbers of sectors.
        read10_cmd[2] = ((sector_count >> 24) & 0xFF);
        read10_cmd[3] = ((sector_count >> 16) & 0xFF);
        read10_cmd[4] = ((sector_count >> 8) & 0xFF);
        read10_cmd[5] = (sector_count & 0xFF);
    }

    // Close file descriptor
    close(sg_fd);

    return 0;
}

运行这个程序之前，确保你知道要与之通信的 USB 驱动器的 sg 设备路径。在大多数情况下，它将是/dev/sgX，其中X是一个数字，例如 /dev/sg2。

然而，这是一个非常基础的示例，只是为了演示如何构造和发送 SCSI 命令。在实际使用中，编写这样的程序时应采取额外的错误检查和异常处理措施，并确保完全理解对 SCSI 设备的操作和可能的后果。使用此代码前应在安全的环境下（如使用了非重要数据的 U 盘）进行测试。

weixin_38849487

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
linux scsi命令读取文件

SCSI Read(10)是一种用于从SCSI设备读取数据的命令。注意：上述代码仅为演示目的，请谨慎操作并确保对SCSI设备的访问有合法的权限。在实际使用时，请根据您的需求和环境进行相应的修改和错误处理。
复制链接

扫一扫