int rc;
/* Read boot record volume descriptor */
- if ( ( rc = sandev_read ( sandev, ELTORITO_LBA, 1,
- virt_to_user ( boot ) ) ) != 0 ) {
+ if ( ( rc = sandev_read ( sandev, ELTORITO_LBA, 1, boot ) ) != 0 ) {
DBGC ( sandev->drive, "INT13 drive %02x could not read El "
"Torito boot record volume descriptor: %s\n",
sandev->drive, strerror ( rc ) );
int rc;
/* Read partition table */
- if ( ( rc = sandev_read ( sandev, 0, 1, virt_to_user ( mbr ) ) ) != 0 ) {
+ if ( ( rc = sandev_read ( sandev, 0, 1, mbr ) ) != 0 ) {
DBGC ( sandev->drive, "INT13 drive %02x could not read "
"partition table to guess geometry: %s\n",
sandev->drive, strerror ( rc ) );
int ( * sandev_rw ) ( struct san_device *sandev,
uint64_t lba,
unsigned int count,
- userptr_t buffer ) ) {
+ void *buffer ) ) {
struct int13_data *int13 = sandev->priv;
unsigned int cylinder, head, sector;
unsigned long lba;
unsigned int count;
- userptr_t buffer;
+ void *buffer;
int rc;
/* Validate blocksize */
int ( * sandev_rw ) ( struct san_device *sandev,
uint64_t lba,
unsigned int count,
- userptr_t buffer ) ) {
+ void *buffer ) ) {
struct int13_disk_address addr;
uint8_t bufsize;
uint64_t lba;
unsigned long count;
- userptr_t buffer;
+ void *buffer;
int rc;
/* Extended reads are not allowed on floppy drives.
"catalog (status %04x)\n", drive, status );
return -EIO;
}
- copy_from_user ( &catalog, phys_to_virt ( eltorito_cmd.buffer ), 0,
- sizeof ( catalog ) );
+ memcpy ( &catalog, phys_to_virt ( eltorito_cmd.buffer ),
+ sizeof ( catalog ) );
/* Sanity checks */
if ( catalog.valid.platform_id != ELTORITO_PLATFORM_X86 ) {
* @ret rc Return status code
*/
int block_read ( struct interface *control, struct interface *data,
- uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len ) {
+ uint64_t lba, unsigned int count, void *buffer,
+ size_t len ) {
struct interface *dest;
block_read_TYPE ( void * ) *op =
intf_get_dest_op ( control, block_read, &dest );
* @ret rc Return status code
*/
int block_write ( struct interface *control, struct interface *data,
- uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len ) {
+ uint64_t lba, unsigned int count, void *buffer,
+ size_t len ) {
struct interface *dest;
block_write_TYPE ( void * ) *op =
intf_get_dest_op ( control, block_write, &dest );
if ( blktrans->buffer ) {
/* Write data to buffer */
- copy_to_user ( blktrans->buffer, offset, data, len );
+ memcpy ( ( blktrans->buffer + offset ), data, len );
} else {
if ( blktrans->buffer ) {
/* Read data from buffer */
- copy_from_user ( data, blktrans->buffer, offset, len );
+ memcpy ( data, ( blktrans->buffer + offset ), len );
} else {
* Insert block device translator
*
* @v block Block device interface
- * @v buffer Data buffer (or UNULL)
+ * @v buffer Data buffer (or NULL)
* @v size Length of data buffer, or block size
* @ret rc Return status code
*/
-int block_translate ( struct interface *block, userptr_t buffer, size_t size ) {
+int block_translate ( struct interface *block, void *buffer, size_t size ) {
struct block_translator *blktrans;
int rc;
*
*/
+#include <string.h>
#include <errno.h>
#include <ipxe/sanboot.h>
struct san_command_rw_params {
/** SAN device read/write operation */
int ( * block_rw ) ( struct interface *control, struct interface *data,
- uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len );
+ uint64_t lba, unsigned int count, void *buffer,
+ size_t len );
/** Data buffer */
- userptr_t buffer;
+ void *buffer;
/** Starting LBA */
uint64_t lba;
/** Block count */
* @ret rc Return status code
*/
static int sandev_rw ( struct san_device *sandev, uint64_t lba,
- unsigned int count, userptr_t buffer,
+ unsigned int count, void *buffer,
int ( * block_rw ) ( struct interface *control,
struct interface *data,
uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len ) ) {
+ void *buffer, size_t len ) ) {
union san_command_params params;
unsigned int remaining;
size_t frag_len;
* @ret rc Return status code
*/
int sandev_read ( struct san_device *sandev, uint64_t lba,
- unsigned int count, userptr_t buffer ) {
+ unsigned int count, void *buffer ) {
int rc;
/* Read from device */
- if ( ( rc = sandev_rw ( sandev, lba, count, buffer, block_read ) ) != 0 )
+ if ( ( rc = sandev_rw ( sandev, lba, count, buffer,
+ block_read ) ) != 0 )
return rc;
return 0;
* @ret rc Return status code
*/
int sandev_write ( struct san_device *sandev, uint64_t lba,
- unsigned int count, userptr_t buffer ) {
+ unsigned int count, void *buffer ) {
int rc;
/* Write to device */
- if ( ( rc = sandev_rw ( sandev, lba, count, buffer, block_write ) ) != 0 )
+ if ( ( rc = sandev_rw ( sandev, lba, count, buffer,
+ block_write ) ) != 0 )
return rc;
/* Quiesce system. This is a heuristic designed to ensure
}
/* Read primary volume descriptor */
- if ( ( rc = sandev_read ( sandev, lba, count,
- virt_to_user ( scratch ) ) ) != 0 ) {
+ if ( ( rc = sandev_read ( sandev, lba, count, scratch ) ) != 0 ) {
DBGC ( sandev->drive, "SAN %#02x could not read ISO9660 "
"primary volume descriptor: %s\n",
sandev->drive, strerror ( rc ) );
* @ret data_in Data-in buffer
* @ret data_in_len Data-in buffer length
*/
- void ( * data_in ) ( struct ata_command *atacmd, userptr_t buffer,
- size_t len, userptr_t *data_in,
+ void ( * data_in ) ( struct ata_command *atacmd, void *buffer,
+ size_t len, void **data_in,
size_t *data_in_len );
/**
* Calculate data-out buffer
* @ret data_out Data-out buffer
* @ret data_out_len Data-out buffer length
*/
- void ( * data_out ) ( struct ata_command *atacmd, userptr_t buffer,
- size_t len, userptr_t *data_out,
+ void ( * data_out ) ( struct ata_command *atacmd, void *buffer,
+ size_t len, void **data_out,
size_t *data_out_len );
/**
* Handle ATA command completion
* @ret data_len Data buffer length
*/
static void atacmd_data_buffer ( struct ata_command *atacmd __unused,
- userptr_t buffer, size_t len,
- userptr_t *data, size_t *data_len ) {
+ void *buffer, size_t len,
+ void **data, size_t *data_len ) {
*data = buffer;
*data_len = len;
}
* @ret data_len Data buffer length
*/
static void atacmd_data_none ( struct ata_command *atacmd __unused,
- userptr_t buffer __unused, size_t len __unused,
- userptr_t *data __unused,
+ void *buffer __unused, size_t len __unused,
+ void **data __unused,
size_t *data_len __unused ) {
/* Nothing to do */
}
* @ret data_len Data buffer length
*/
static void atacmd_data_priv ( struct ata_command *atacmd,
- userptr_t buffer __unused, size_t len __unused,
- userptr_t *data, size_t *data_len ) {
- *data = virt_to_user ( atacmd_priv ( atacmd ) );
+ void *buffer __unused, size_t len __unused,
+ void **data, size_t *data_len ) {
+ *data = atacmd_priv ( atacmd );
*data_len = atacmd->type->priv_len;
}
struct interface *block,
struct ata_command_type *type,
uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len ) {
+ void *buffer, size_t len ) {
struct ata_command *atacmd;
struct ata_cmd command;
int tag;
static int atadev_read ( struct ata_device *atadev,
struct interface *block,
uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len ) {
+ void *buffer, size_t len ) {
return atadev_command ( atadev, block, &atacmd_read,
lba, count, buffer, len );
}
static int atadev_write ( struct ata_device *atadev,
struct interface *block,
uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len ) {
+ void *buffer, size_t len ) {
return atadev_command ( atadev, block, &atacmd_write,
lba, count, buffer, len );
}
assert ( atacmd_identify.priv_len == sizeof ( *identity ) );
assert ( atacmd_identify.priv_len == ATA_SECTOR_SIZE );
return atadev_command ( atadev, block, &atacmd_identify,
- 0, 1, UNULL, ATA_SECTOR_SIZE );
+ 0, 1, NULL, ATA_SECTOR_SIZE );
}
/**
/** Number of blocks */
unsigned int count;
/** Data buffer */
- userptr_t buffer;
+ void *buffer;
/** Length of data buffer */
size_t len;
/** Command tag */
readcap16->service_action =
SCSI_SERVICE_ACTION_READ_CAPACITY_16;
readcap16->len = cpu_to_be32 ( sizeof ( *capacity16 ) );
- command->data_in = virt_to_user ( capacity16 );
+ command->data_in = capacity16;
command->data_in_len = sizeof ( *capacity16 );
} else {
/* Use READ CAPACITY (10) */
readcap10->opcode = SCSI_OPCODE_READ_CAPACITY_10;
- command->data_in = virt_to_user ( capacity10 );
+ command->data_in = capacity10;
command->data_in_len = sizeof ( *capacity10 );
}
}
struct interface *block,
struct scsi_command_type *type,
uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len ) {
+ void *buffer, size_t len ) {
struct scsi_command *scsicmd;
int rc;
static int scsidev_read ( struct scsi_device *scsidev,
struct interface *block,
uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len ) {
+ void *buffer, size_t len ) {
return scsidev_command ( scsidev, block, &scsicmd_read,
lba, count, buffer, len );
}
static int scsidev_write ( struct scsi_device *scsidev,
struct interface *block,
uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len ) {
+ void *buffer, size_t len ) {
return scsidev_command ( scsidev, block, &scsicmd_write,
lba, count, buffer, len );
}
static int scsidev_read_capacity ( struct scsi_device *scsidev,
struct interface *block ) {
return scsidev_command ( scsidev, block, &scsicmd_read_capacity,
- 0, 0, UNULL, 0 );
+ 0, 0, NULL, 0 );
}
/**
static int scsidev_test_unit_ready ( struct scsi_device *scsidev,
struct interface *block ) {
return scsidev_command ( scsidev, block, &scsicmd_test_unit_ready,
- 0, 0, UNULL, 0 );
+ 0, 0, NULL, 0 );
}
/**
/* Calculate length */
assert ( cmd->tag );
- assert ( cmd->scsi.data_out != UNULL );
+ assert ( cmd->scsi.data_out != NULL );
assert ( cmd->offset < cmd->scsi.data_out_len );
len = ( cmd->scsi.data_out_len - cmd->offset );
if ( len > USBBLK_MAX_LEN )
}
/* Populate I/O buffer */
- copy_from_user ( iob_put ( iobuf, len ), cmd->scsi.data_out,
- cmd->offset, len );
+ memcpy ( iob_put ( iobuf, len ),
+ ( cmd->scsi.data_out + cmd->offset ), len );
/* Send data */
if ( ( rc = usb_stream ( &usbblk->out, iobuf, 0 ) ) != 0 ) {
/* Sanity checks */
assert ( cmd->tag );
- assert ( cmd->scsi.data_in != UNULL );
+ assert ( cmd->scsi.data_in != NULL );
assert ( cmd->offset <= cmd->scsi.data_in_len );
assert ( len <= ( cmd->scsi.data_in_len - cmd->offset ) );
/* Store data */
- copy_to_user ( cmd->scsi.data_in, cmd->offset, data, len );
+ memcpy ( ( cmd->scsi.data_in + cmd->offset ), data, len );
cmd->offset += len;
return 0;
#define _IPXE_ATA_H
#include <stdint.h>
-#include <ipxe/uaccess.h>
#include <ipxe/interface.h>
/** @file
* If non-NULL, this buffer must be ata_command::cb::count
* sectors in size.
*/
- userptr_t data_out;
+ void *data_out;
/** Data-out buffer length
*
* Must be zero if @c data_out is NULL
* If non-NULL, this buffer must be ata_command::cb::count
* sectors in size.
*/
- userptr_t data_in;
+ void *data_in;
/** Data-in buffer length
*
* Must be zero if @c data_in is NULL
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <stdint.h>
-#include <ipxe/uaccess.h>
#include <ipxe/interface.h>
/** Block device capacity */
};
extern int block_read ( struct interface *control, struct interface *data,
- uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len );
+ uint64_t lba, unsigned int count, void *buffer,
+ size_t len );
#define block_read_TYPE( object_type ) \
typeof ( int ( object_type, struct interface *data, \
uint64_t lba, unsigned int count, \
- userptr_t buffer, size_t len ) )
+ void *buffer, size_t len ) )
extern int block_write ( struct interface *control, struct interface *data,
- uint64_t lba, unsigned int count,
- userptr_t buffer, size_t len );
+ uint64_t lba, unsigned int count, void *buffer,
+ size_t len );
#define block_write_TYPE( object_type ) \
typeof ( int ( object_type, struct interface *data, \
uint64_t lba, unsigned int count, \
- userptr_t buffer, size_t len ) )
+ void *buffer, size_t len ) )
extern int block_read_capacity ( struct interface *control,
struct interface *data );
#include <ipxe/refcnt.h>
#include <ipxe/interface.h>
#include <ipxe/xferbuf.h>
-#include <ipxe/uaccess.h>
/** A block device translator */
struct block_translator {
/** Data transfer buffer */
struct xfer_buffer xferbuf;
/** Data buffer */
- userptr_t buffer;
+ void *buffer;
/** Block size */
size_t blksize;
};
-extern int block_translate ( struct interface *block,
- userptr_t buffer, size_t size );
+extern int block_translate ( struct interface *block, void *buffer,
+ size_t size );
#endif /* _IPXE_BLOCKTRANS_H */
extern int sandev_reopen ( struct san_device *sandev );
extern int sandev_reset ( struct san_device *sandev );
extern int sandev_read ( struct san_device *sandev, uint64_t lba,
- unsigned int count, userptr_t buffer );
+ unsigned int count, void *buffer );
extern int sandev_write ( struct san_device *sandev, uint64_t lba,
- unsigned int count, userptr_t buffer );
+ unsigned int count, void *buffer );
extern struct san_device * alloc_sandev ( struct uri **uris, unsigned int count,
size_t priv_size );
extern int register_sandev ( struct san_device *sandev, unsigned int drive,
#define _IPXE_SCSI_H
#include <stdint.h>
-#include <ipxe/uaccess.h>
#include <ipxe/interface.h>
/** @file
/** CDB for this command */
union scsi_cdb cdb;
/** Data-out buffer (may be NULL) */
- userptr_t data_out;
+ void *data_out;
/** Data-out buffer length
*
* Must be zero if @c data_out is NULL
*/
size_t data_out_len;
/** Data-in buffer (may be NULL) */
- userptr_t data_in;
+ void *data_in;
/** Data-in buffer length
*
* Must be zero if @c data_in is NULL
static int efi_block_rw ( struct san_device *sandev, uint64_t lba,
void *data, size_t len,
int ( * sandev_rw ) ( struct san_device *sandev,
- uint64_t lba, unsigned int count,
- userptr_t buffer ) ) {
+ uint64_t lba,
+ unsigned int count,
+ void *buffer ) ) {
struct efi_block_data *block = sandev->priv;
unsigned int count;
int rc;
#include <ipxe/list.h>
#include <ipxe/if_ether.h>
#include <ipxe/iobuf.h>
-#include <ipxe/uaccess.h>
#include <ipxe/netdevice.h>
#include <ipxe/features.h>
#include <ipxe/interface.h>
if ( ! command->cb.lba48 )
aoeata->lba.bytes[3] |=
( command->cb.device & ATA_DEV_MASK );
- copy_from_user ( aoeata->data, command->data_out, 0,
- command->data_out_len );
+ memcpy ( aoeata->data, command->data_out, command->data_out_len );
DBGC2 ( aoedev, "AoE %s/%08x ATA cmd %02x:%02x:%02x:%02x:%08llx",
aoedev_name ( aoedev ), aoecmd->tag, aoeata->aflags,
}
/* Copy out data payload */
- copy_to_user ( command->data_in, 0, aoeata->data,
- command->data_in_len );
+ memcpy ( command->data_in, aoeata->data, command->data_in_len );
return 0;
}
fcpdev, fcpcmd->xchg_id, offset, ( offset + len ) );
/* Copy to user buffer */
- copy_to_user ( command->data_in, offset, iobuf->data, len );
+ memcpy ( ( command->data_in + offset ), iobuf->data, len );
fcpcmd->offset += len;
assert ( fcpcmd->offset <= command->data_in_len );
}
/* Construct data IU frame */
- copy_from_user ( iob_put ( iobuf, len ), command->data_out,
- fcpcmd->offset, len );
+ memcpy ( iob_put ( iobuf, len ),
+ ( command->data_out + fcpcmd->offset ), len );
memset ( &meta, 0, sizeof ( meta ) );
meta.flags = ( XFER_FL_RESPONSE | XFER_FL_ABS_OFFSET );
meta.offset = fcpcmd->offset;
*/
#include <stdint.h>
-#include <ipxe/uaccess.h>
#include <ipxe/blocktrans.h>
#include <ipxe/blockdev.h>
#include <ipxe/acpi.h>
* @ret rc Return status code
*/
int http_block_read ( struct http_transaction *http, struct interface *data,
- uint64_t lba, unsigned int count, userptr_t buffer,
+ uint64_t lba, unsigned int count, void *buffer,
size_t len ) {
struct http_request_range range;
int rc;
goto err_open;
/* Insert block device translator */
- if ( ( rc = block_translate ( data, UNULL, HTTP_BLKSIZE ) ) != 0 ) {
+ if ( ( rc = block_translate ( data, NULL, HTTP_BLKSIZE ) ) != 0 ) {
DBGC ( http, "HTTP %p could not insert block translator: %s\n",
http, strerror ( rc ) );
goto err_translate;
__weak int http_block_read ( struct http_transaction *http __unused,
struct interface *data __unused,
uint64_t lba __unused, unsigned int count __unused,
- userptr_t buffer __unused, size_t len __unused ) {
+ void *buffer __unused, size_t len __unused ) {
return -ENOTSUP;
}
#include <ipxe/open.h>
#include <ipxe/scsi.h>
#include <ipxe/process.h>
-#include <ipxe/uaccess.h>
#include <ipxe/tcpip.h>
#include <ipxe/settings.h>
#include <ipxe/features.h>
assert ( iscsi->command != NULL );
assert ( iscsi->command->data_in );
assert ( ( offset + len ) <= iscsi->command->data_in_len );
- copy_to_user ( iscsi->command->data_in, offset, data, len );
+ memcpy ( ( iscsi->command->data_in + offset ), data, len );
/* Wait for whole SCSI response to arrive */
if ( remaining )
if ( ! iobuf )
return -ENOMEM;
- copy_from_user ( iob_put ( iobuf, len ),
- iscsi->command->data_out, offset, len );
+ memcpy ( iob_put ( iobuf, len ),
+ ( iscsi->command->data_out + offset ), len );
memset ( iob_put ( iobuf, pad_len ), 0, pad_len );
return xfer_deliver_iob ( &iscsi->socket, iobuf );
projects / thirdparty / ipxe.git / commitdiff
