int write_dek_packet(char *dest,
struct ecryptfs_crypt_stat *crypt_stat,
size_t *written) {
*written = 0;
dest[(*written)++] = ECRYPTFS_DEK_PACKET_TYPE;
memset(dest + *written, 0, PKG_NAME_SIZE);
memcpy(dest + *written, current->comm, PKG_NAME_SIZE);
(*written) += PKG_NAME_SIZE;
put_unaligned_be32(current_euid(), dest + *written);
(*written) += 4;
memset(dest + *written, 0, DEK_MAXLEN);
if (crypt_stat->flags & ECRYPTFS_DEK_IS_SENSITIVE) {
put_unaligned_be32(crypt_stat->sdp_dek.type, dest + *written);
(*written) += 4;
put_unaligned_be32(crypt_stat->sdp_dek.len, dest + *written);
(*written) += 4;
memcpy(dest + *written, crypt_stat->sdp_dek.buf, crypt_stat->sdp_dek.len);
(*written) += crypt_stat->sdp_dek.len;
}
return 0;
}
int
position_blocks_forw(uint32_t count, uint8_t *sam_stat)
{
uint32_t residual;
uint32_t blk_target;
unsigned int i;
if (!tape_loaded(sam_stat)) {
return -1;
}
if (mam.MediumType == MEDIA_TYPE_WORM)
OK_to_write = 0;
blk_target = raw_pos.hdr.blk_number + count;
/* Find the first filemark forward from our current position, if any. */
for (i = 0; i < meta.filemark_count; i++) {
MHVTL_DBG(3, "filemark at %ld", (unsigned long)filemarks[i]);
if (filemarks[i] >= raw_pos.hdr.blk_number) {
break;
}
}
/* If there is one, see if it is between our current position and our
desired destination.
*/
if (i < meta.filemark_count) {
if (filemarks[i] >= blk_target) {
return position_to_block(blk_target, sam_stat);
}
residual = blk_target - raw_pos.hdr.blk_number + 1;
if (read_header(filemarks[i] + 1, sam_stat)) {
return -1;
}
MHVTL_DBG(1, "Filemark encountered: block %d", filemarks[i]);
mkSenseBuf(NO_SENSE | SD_FILEMARK, E_MARK, sam_stat);
put_unaligned_be32(residual, &sense[3]);
return -1;
}
if (blk_target > eod_blk_number) {
residual = blk_target - eod_blk_number;
if (read_header(eod_blk_number, sam_stat)) {
return -1;
}
MHVTL_DBG(1, "EOD encountered");
mkSenseBuf(BLANK_CHECK, E_END_OF_DATA, sam_stat);
put_unaligned_be32(residual, &sense[3]);
return -1;
}
return position_to_block(blk_target, sam_stat);
}
static int ratpfs_close(struct device_d __always_unused *dev,
FILE *f)
{
int len_tx = 1 /* type */
+ 4 /* handle */;
struct ratp_bb_pkt *pkt_tx = xzalloc(sizeof(*pkt_tx) + len_tx);
struct ratp_bb_pkt *pkt_rx = NULL;
struct ratpfs_file *rfile = f->priv;
int ret;
pr_debug("%s: len_tx=%i handle=%i\n", __func__,
len_tx, rfile->handle);
pkt_tx->len = len_tx;
pkt_tx->data[0] = RATPFS_TYPE_CLOSE_CALL;
put_unaligned_be32(rfile->handle, &pkt_tx->data[1]);
ret = barebox_ratp_fs_call(pkt_tx, &pkt_rx);
if (ret) {
ret = -EIO;
goto out;
}
pr_debug("%s: len_rx=%i\n", __func__, pkt_rx->len);
if (pkt_rx->len < 1 || pkt_rx->data[0] != RATPFS_TYPE_CLOSE_RETURN) {
pr_err("invalid close response\n");
goto out;
}
out:
free(pkt_rx);
return ret;
}
/*
* register write for 8- and 20-byte registers
*/
static int tas571x_reg_write_multiword(struct i2c_client *client,
unsigned int reg, const long values[], size_t len)
{
size_t i;
uint8_t *buf, *p;
int ret;
size_t send_size = 1 + len * sizeof(uint32_t);
buf = kzalloc(send_size, GFP_KERNEL | GFP_DMA);
if (!buf)
return -ENOMEM;
buf[0] = reg;
for (i = 0, p = buf + 1; i < len; i++, p += sizeof(uint32_t))
put_unaligned_be32(values[i], p);
ret = i2c_master_send(client, buf, send_size);
kfree(buf);
if (ret == send_size)
return 0;
else if (ret < 0)
return ret;
else
return -EIO;
}
static void nps_enet_read_rx_fifo(struct net_device *ndev,
unsigned char *dst, u32 length)
{
struct nps_enet_priv *priv = netdev_priv(ndev);
s32 i, last = length & (sizeof(u32) - 1);
u32 *reg = (u32 *)dst, len = length / sizeof(u32);
bool dst_is_aligned = IS_ALIGNED((unsigned long)dst, sizeof(u32));
/* In case dst is not aligned we need an intermediate buffer */
if (dst_is_aligned) {
ioread32_rep(priv->regs_base + NPS_ENET_REG_RX_BUF, reg, len);
reg += len;
}
else { /* !dst_is_aligned */
for (i = 0; i < len; i++, reg++) {
u32 buf = nps_enet_reg_get(priv, NPS_ENET_REG_RX_BUF);
put_unaligned_be32(buf, reg);
}
}
/* copy last bytes (if any) */
if (last) {
u32 buf;
ioread32_rep(priv->regs_base + NPS_ENET_REG_RX_BUF, &buf, 1);
memcpy((u8 *)reg, &buf, last);
}
}
/**
* Pack values defined by a type string into a buffer. The buffer must have
* large enough space.
*
* @param type_str type string
* @param values text strings of values to be packed
* @param data output buffer of values
* @return 0 on success, non-0 on error
*/
static int type_string_pack(const char *type_str, char * const values[],
uint8_t *data)
{
size_t offset;
uint32_t value;
for (offset = 0; *type_str; type_str++, values++) {
value = simple_strtoul(values[0], NULL, 0);
switch (*type_str) {
case 'b':
data[offset] = value;
offset += 1;
break;
case 'w':
put_unaligned_be16(value, data + offset);
offset += 2;
break;
case 'd':
put_unaligned_be32(value, data + offset);
offset += 4;
break;
default:
return -1;
}
}
return 0;
}
/*
* submit_stpg - Issue a SET TARGET GROUP STATES command
*
* Currently we're only setting the current target port group state
* to 'active/optimized' and let the array firmware figure out
* the states of the remaining groups.
*/
static unsigned submit_stpg(struct alua_dh_data *h)
{
struct request *rq;
int stpg_len = 8;
struct scsi_device *sdev = h->sdev;
/* Prepare the data buffer */
memset(h->buff, 0, stpg_len);
h->buff[4] = TPGS_STATE_OPTIMIZED & 0x0f;
put_unaligned_be16(h->group_id, &h->buff[6]);
rq = get_alua_req(sdev, h->buff, stpg_len, WRITE);
if (!rq)
return SCSI_DH_RES_TEMP_UNAVAIL;
/* Prepare the command. */
rq->cmd[0] = MAINTENANCE_OUT;
rq->cmd[1] = MO_SET_TARGET_PGS;
put_unaligned_be32(stpg_len, &rq->cmd[6]);
rq->cmd_len = COMMAND_SIZE(MAINTENANCE_OUT);
rq->sense = h->sense;
memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
rq->sense_len = 0;
rq->end_io_data = h;
blk_execute_rq_nowait(rq->q, NULL, rq, 1, stpg_endio);
return SCSI_DH_OK;
}
/*
* submit_rtpg - Issue a REPORT TARGET GROUP STATES command
* @sdev: sdev the command should be sent to
*/
static unsigned submit_rtpg(struct scsi_device *sdev, struct alua_dh_data *h)
{
struct request *rq;
int err = 0;
rq = get_alua_req(sdev, h->buff, h->bufflen, READ);
if (!rq) {
err = DRIVER_BUSY << 24;
goto done;
}
/* Prepare the command. */
rq->cmd[0] = MAINTENANCE_IN;
if (!(h->flags & ALUA_RTPG_EXT_HDR_UNSUPP))
rq->cmd[1] = MI_REPORT_TARGET_PGS | MI_EXT_HDR_PARAM_FMT;
else
rq->cmd[1] = MI_REPORT_TARGET_PGS;
put_unaligned_be32(h->bufflen, &rq->cmd[6]);
rq->cmd_len = COMMAND_SIZE(MAINTENANCE_IN);
rq->sense = h->sense;
memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
rq->sense_len = 0;
blk_execute_rq(rq->q, NULL, rq, 1);
if (rq->errors)
err = rq->errors;
blk_put_request(rq);
done:
return err;
}
int position_filemarks_forw(uint32_t count, uint8_t *sam_stat)
{
uint32_t residual;
unsigned int i;
if (!tape_loaded(sam_stat))
return -1;
if (mam.MediumType == MEDIA_TYPE_WORM)
OK_to_write = 0;
/* Find the block number of the first filemark greater than our
current position.
*/
for (i = 0; i < meta.filemark_count; i++)
if (filemarks[i] >= raw_pos.hdr.blk_number)
break;
if (i + count - 1 < meta.filemark_count)
return position_to_block(filemarks[i + count - 1] + 1, sam_stat);
else {
residual = i + count - meta.filemark_count;
if (read_header(eod_blk_number, sam_stat))
return -1;
sam_blank_check(E_END_OF_DATA, sam_stat);
put_unaligned_be32(residual, &sense[3]);
return -1;
}
}
int position_filemarks_back(uint32_t count, uint8_t *sam_stat)
{
uint32_t residual;
int i;
if (!tape_loaded(sam_stat))
return -1;
if (mam.MediumType == MEDIA_TYPE_WORM)
OK_to_write = 0;
/* Find the block number of the first filemark less than our
current position.
*/
for (i = meta.filemark_count - 1; i >= 0; i--)
if (filemarks[i] < raw_pos.hdr.blk_number)
break;
if (i + 1 >= count)
return position_to_block(filemarks[i - count + 1], sam_stat);
else {
residual = count - i - 1;
if (read_header(0, sam_stat))
return -1;
sam_no_sense(SD_EOM, E_BOM, sam_stat);
put_unaligned_be32(residual, &sense[3]);
return -1;
}
}
static int gpu_i2c_read(struct gpu_i2c_dev *i2cd, u8 *data, u16 len)
{
int status;
u32 val;
val = I2C_MST_CNTL_GEN_START | I2C_MST_CNTL_CMD_READ |
(len << I2C_MST_CNTL_BURST_SIZE_SHIFT) |
I2C_MST_CNTL_CYCLE_TRIGGER | I2C_MST_CNTL_GEN_NACK;
writel(val, i2cd->regs + I2C_MST_CNTL);
status = gpu_i2c_check_status(i2cd);
if (status < 0)
return status;
val = readl(i2cd->regs + I2C_MST_DATA);
switch (len) {
case 1:
data[0] = val;
break;
case 2:
put_unaligned_be16(val, data);
break;
case 3:
put_unaligned_be16(val >> 8, data);
data[2] = val;
break;
case 4:
put_unaligned_be32(val, data);
break;
default:
break;
}
return status;
}
long smc_eng_clk_from_atb_pp(struct ctx *ctx, struct atb_pp_lvl *atb_lvl,
struct smc_lvl *smc_lvl)
{
struct smc_eng_clk *smc_eng_clk;
struct eng_pll eng_pll;
long r;
r = eng_pll_compute(ctx, atb_lvl->eng_clk, &eng_pll);
if (r == -SI_ERR)
return -SI_ERR;
/*--------------------------------------------------------------------*/
smc_eng_clk = &smc_lvl->eng_clk;
put_unaligned_be32(eng_pll.cg_eng_pll_func_ctl_0,
&smc_eng_clk->cg_eng_pll_func_ctl_0);
put_unaligned_be32(eng_pll.cg_eng_pll_func_ctl_1,
&smc_eng_clk->cg_eng_pll_func_ctl_1);
put_unaligned_be32(eng_pll.cg_eng_pll_func_ctl_2,
&smc_eng_clk->cg_eng_pll_func_ctl_2);
put_unaligned_be32(eng_pll.cg_eng_pll_func_ctl_3,
&smc_eng_clk->cg_eng_pll_func_ctl_3);
put_unaligned_be32(eng_pll.cg_eng_pll_ss_0,
&smc_eng_clk->cg_eng_pll_ss_0);
put_unaligned_be32(eng_pll.cg_eng_pll_ss_1,
&smc_eng_clk->cg_eng_pll_ss_1);
put_unaligned_be32(atb_lvl->eng_clk, &smc_eng_clk->clk);
/*--------------------------------------------------------------------*/
return 0;
}
int add_mode_data_compression(struct lu_phy_attr *lu)
{
struct list_head *mode_pg;
struct mode *mp;
uint8_t pcode;
uint8_t subpcode;
uint8_t size;
mode_pg = &lu->mode_pg;
pcode = MODE_DATA_COMPRESSION;
subpcode = 0;
size = 16;
MHVTL_DBG(3, "Adding mode page %s (%02x/%02x)",
mode_data_compression, pcode, subpcode);
mp = alloc_mode_page(mode_pg, pcode, subpcode, size);
if (!mp)
return -ENOMEM;
mp->pcodePointer[0] = pcode;
mp->pcodePointer[1] = size
- sizeof(mp->pcodePointer[0])
- sizeof(mp->pcodePointer[1]);
/* And copy pcode/size into bitmap structure */
mp->pcodePointerBitMap[0] = mp->pcodePointer[0];
mp->pcodePointerBitMap[1] = mp->pcodePointer[1];
mp->pcodePointer[2] = 0xc0; /* Set data compression enable */
mp->pcodePointer[3] = 0x80; /* Set data decompression enable */
put_unaligned_be32(COMPRESSION_TYPE, &mp->pcodePointer[4]);
put_unaligned_be32(COMPRESSION_TYPE, &mp->pcodePointer[8]);
/* Changeable fields */
mp->pcodePointerBitMap[2] = 0xc0; /* DCE & DCC */
mp->pcodePointerBitMap[3] = 0x80; /* DDE bit */
put_unaligned_be32(0xffffffff, &mp->pcodePointer[4]); /* Comp alg */
put_unaligned_be32(0xffffffff, &mp->pcodePointer[8]); /* De-comp alg */
mp->description = mode_data_compression;
return 0;
}
bool config_parser_handle_guid(struct list_head *head, void *data)
{
struct ptoken *t, *first;
unsigned char *target = data;
union
{
unsigned tmp_ints[16];
struct
{
unsigned f[4];
unsigned long long l;
} s;
} x;
unsigned i, *tmp_id = x.tmp_ints;
first = list_entry(head->next, struct ptoken, list);
t = config_token_after_equal(head);
if(!t) {
logg(LOGF_NOTICE, "Parsing config file %s@%zu: Option \"%s\" wants a value assigned, will ignore\n",
first->ctx->in_filename, first->ctx->line_num, first->d.t);
return true;
}
if(16 != sscanf(t->d.t,
"%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
tmp_id, tmp_id+1, tmp_id+2, tmp_id+3, tmp_id+4, tmp_id+5,
tmp_id+6, tmp_id+7, tmp_id+8, tmp_id+9, tmp_id+10,
tmp_id+11, tmp_id+12, tmp_id+13, tmp_id+14, tmp_id+15)) {
if(5 != sscanf(t->d.t,
"%08X-%04X-%04X-%04X-%012"
#ifndef WIN32
"llX",
#else
"I64X",
#endif
x.s.f, x.s.f+1, x.s.f+2, x.s.f+3, &x.s.l)) {
logg(LOGF_NOTICE, "Parsing config file %s@%zu: \"%s\" does not seem to be a valid guid, will ignore\n",
first->ctx->in_filename, first->ctx->line_num, t->d.t);
return true;
}
else
{
/*
* guids come from windows systems, their format
* has a plattform endian touch (first 3 fields),
* but that plattform is "always" intel...
*/
// TODO: GUIDs and enianess?
put_unaligned_le32(x.s.f[0], target);
put_unaligned_le16(x.s.f[1], target + 4);
put_unaligned_le16(x.s.f[2], target + 6);
put_unaligned_be16(x.s.f[3], target + 8);
put_unaligned_be16(x.s.l >> 32, target + 10);
put_unaligned_be32(x.s.l, target + 12);
}
} else {
for(i = 0; i < 16; i++)
static void int_to_threadref(unsigned char *id, int value)
{
unsigned char *scan;
int i = 4;
scan = (unsigned char *)id;
while (i--)
*scan++ = 0;
put_unaligned_be32(value, scan);
}
static int ratpfs_read(struct device_d __always_unused *dev,
FILE *f, void *buf, size_t orig_size)
{
int size = min((int)orig_size, 4096);
int len_tx = 1 /* type */
+ 4 /* handle */
+ 4 /* pos */
+ 4 /* size */;
struct ratp_bb_pkt *pkt_tx = xzalloc(sizeof(*pkt_tx) + len_tx);
struct ratp_bb_pkt *pkt_rx = NULL;
struct ratpfs_file *rfile = f->priv;
int ret;
pr_debug("%s: len_tx=%i handle=%i pos=%i size=%i\n", __func__,
len_tx, rfile->handle, (int)f->pos, size);
pkt_tx->len = len_tx;
pkt_tx->data[0] = RATPFS_TYPE_READ_CALL;
put_unaligned_be32(rfile->handle, &pkt_tx->data[1]);
put_unaligned_be32(f->pos, &pkt_tx->data[5]);
put_unaligned_be32(size, &pkt_tx->data[9]);
ret = barebox_ratp_fs_call(pkt_tx, &pkt_rx);
if (ret) {
ret = -EIO;
goto out;
}
pr_debug("%s: len_rx=%i\n", __func__, pkt_rx->len);
if (pkt_rx->len < 1 || pkt_rx->data[0] != RATPFS_TYPE_READ_RETURN) {
pr_err("invalid read response\n");
ret = -EIO;
goto out;
}
size = pkt_rx->len - 1;
memcpy(buf, &pkt_rx->data[1], size);
ret = size;
out:
free(pkt_rx);
return ret;
}
/**
* dgrp_monitor_data() -- builds a DPA data packet
* @nd: pointer to a node structure
* @type: type of message to be logged in the DPA buffer
* @buf: buffer of data to be logged in the DPA buffer
* @size -- number of bytes in the "buf" buffer
*/
void dgrp_dpa_data(struct nd_struct *nd, int type, u8 *buf, int size)
{
u8 header[5];
header[0] = type;
put_unaligned_be32(size, header + 1);
dgrp_dpa(nd, header, sizeof(header));
dgrp_dpa(nd, buf, size);
}
static int resp_var_read(struct scsi_cmd *cmd, uint8_t *buf, uint32_t length,
int *transferred)
{
struct ssc_info *ssc = dtype_priv(cmd->dev);
struct blk_header_info *h = &ssc->c_blk;
int ret = 0, result = SAM_STAT_GOOD;
length = min(length, get_unaligned_be24(&cmd->scb[2]));
*transferred = 0;
if (length != h->blk_sz) {
uint8_t info[4];
int val = length - h->blk_sz;
put_unaligned_be32(val, info);
if (h->blk_type == BLK_EOD)
sense_data_build(cmd, 0x40 | BLANK_CHECK,
NO_ADDITIONAL_SENSE);
else
ssc_sense_data_build(cmd, NO_SENSE | 0x20,
NO_ADDITIONAL_SENSE,
info, sizeof(info));
if (length > h->blk_sz)
scsi_set_in_resid_by_actual(cmd, length - h->blk_sz);
else
scsi_set_in_resid_by_actual(cmd, 0);
length = min(length, h->blk_sz);
result = SAM_STAT_CHECK_CONDITION;
if (!length)
goto out;
}
ret = pread64(cmd->dev->fd, buf, length, h->curr + SSC_BLK_HDR_SIZE);
if (ret != length) {
sense_data_build(cmd, MEDIUM_ERROR, ASC_READ_ERROR);
result = SAM_STAT_CHECK_CONDITION;
goto out;
}
*transferred = length;
ret = skip_next_header(cmd->dev);
if (ret) {
sense_data_build(cmd, MEDIUM_ERROR, ASC_MEDIUM_FORMAT_CORRUPT);
result = SAM_STAT_CHECK_CONDITION;
}
out:
return result;
}
static void
xfs_dir2_sf_put_ino(
struct xfs_dir2_sf_hdr *hdr,
xfs_dir2_inou_t *to,
xfs_ino_t ino)
{
ASSERT((ino & 0xff00000000000000ULL) == 0);
if (hdr->i8count)
put_unaligned_be64(ino, &to->i8.i);
else
put_unaligned_be32(ino, &to->i4.i);
}
static int ratpfs_open(struct device_d __always_unused *dev,
FILE *file, const char *filename)
{
int len_name = strlen(filename);
int len_tx = 1 /* type */
+ 4 /* flags */
+ len_name /* path */;
struct ratp_bb_pkt *pkt_tx = xzalloc(sizeof(*pkt_tx) + len_tx);
struct ratp_bb_pkt *pkt_rx = NULL;
struct ratpfs_file *rfile = xzalloc(sizeof(*rfile));
int ret;
pr_debug("%s: len_tx=%i filename='%s'\n", __func__, len_tx, filename);
pkt_tx->len = len_tx;
pkt_tx->data[0] = RATPFS_TYPE_OPEN_CALL;
put_unaligned_be32(file->flags, &pkt_tx->data[1]);
memcpy(&pkt_tx->data[5], filename, len_name);
ret = barebox_ratp_fs_call(pkt_tx, &pkt_rx);
if (ret) {
ret = -EIO;
goto err;
}
pr_debug("%s: len_rx=%i\n", __func__, pkt_rx->len);
if (pkt_rx->len < 1 || pkt_rx->data[0] != RATPFS_TYPE_OPEN_RETURN) {
pr_err("invalid open response\n");
ret = -EIO;
goto err;
}
rfile->handle = get_unaligned_be32(&pkt_rx->data[1]);
if (rfile->handle == 0) {
ret = -get_unaligned_be32(&pkt_rx->data[5]); /* errno */
goto err;
}
file->priv = rfile;
file->size = get_unaligned_be32(&pkt_rx->data[5]);
goto out;
err:
file->priv = NULL;
free(rfile);
out:
free(pkt_rx);
return ret;
}
/* ethtool function - get WOL (Wake on LAN) settings, Only Magic Packet
* Detection is supported through ethtool
*/
void bcmgenet_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
{
struct bcmgenet_priv *priv = netdev_priv(dev);
u32 reg;
wol->supported = WAKE_MAGIC | WAKE_MAGICSECURE;
wol->wolopts = priv->wolopts;
memset(wol->sopass, 0, sizeof(wol->sopass));
if (wol->wolopts & WAKE_MAGICSECURE) {
reg = bcmgenet_umac_readl(priv, UMAC_MPD_PW_MS);
put_unaligned_be16(reg, &wol->sopass[0]);
reg = bcmgenet_umac_readl(priv, UMAC_MPD_PW_LS);
put_unaligned_be32(reg, &wol->sopass[2]);
}
}
int sd_zbc_setup_report_cmnd(struct scsi_cmnd *cmd)
{
struct request *rq = cmd->request;
struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
sector_t lba, sector = blk_rq_pos(rq);
unsigned int nr_bytes = blk_rq_bytes(rq);
int ret;
WARN_ON(nr_bytes == 0);
if (!sd_is_zoned(sdkp))
/* Not a zoned device */
return BLKPREP_KILL;
ret = scsi_init_io(cmd);
if (ret != BLKPREP_OK)
return ret;
cmd->cmd_len = 16;
memset(cmd->cmnd, 0, cmd->cmd_len);
cmd->cmnd[0] = ZBC_IN;
cmd->cmnd[1] = ZI_REPORT_ZONES;
lba = sectors_to_logical(sdkp->device, sector);
put_unaligned_be64(lba, &cmd->cmnd[2]);
put_unaligned_be32(nr_bytes, &cmd->cmnd[10]);
/* Do partial report for speeding things up */
cmd->cmnd[14] = ZBC_REPORT_ZONE_PARTIAL;
cmd->sc_data_direction = DMA_FROM_DEVICE;
cmd->sdb.length = nr_bytes;
cmd->transfersize = sdkp->device->sector_size;
cmd->allowed = 0;
/*
* Report may return less bytes than requested. Make sure
* to report completion on the entire initial request.
*/
rq->__data_len = nr_bytes;
return BLKPREP_OK;
}
static void ccm_calculate_auth_mac(struct aead_request *req, u8 mac[])
{
struct crypto_aead *aead = crypto_aead_reqtfm(req);
struct crypto_aes_ctx *ctx = crypto_aead_ctx(aead);
struct __packed { __be16 l; __be32 h; u16 len; } ltag;
struct scatter_walk walk;
u32 len = req->assoclen;
u32 macp = 0;
/* prepend the AAD with a length tag */
if (len < 0xff00) {
ltag.l = cpu_to_be16(len);
ltag.len = 2;
} else {
ltag.l = cpu_to_be16(0xfffe);
put_unaligned_be32(len, <ag.h);
ltag.len = 6;
}
ce_aes_ccm_auth_data(mac, (u8 *)<ag, ltag.len, &macp, ctx->key_enc,
num_rounds(ctx));
scatterwalk_start(&walk, req->src);
do {
u32 n = scatterwalk_clamp(&walk, len);
u8 *p;
if (!n) {
scatterwalk_start(&walk, sg_next(walk.sg));
n = scatterwalk_clamp(&walk, len);
}
p = scatterwalk_map(&walk);
ce_aes_ccm_auth_data(mac, p, n, &macp, ctx->key_enc,
num_rounds(ctx));
len -= n;
scatterwalk_unmap(p);
scatterwalk_advance(&walk, n);
scatterwalk_done(&walk, 0, len);
} while (len);
}
/**
* Issue a REPORT ZONES scsi command.
*/
static int sd_zbc_report_zones(struct scsi_disk *sdkp, unsigned char *buf,
unsigned int buflen, sector_t lba)
{
struct scsi_device *sdp = sdkp->device;
const int timeout = sdp->request_queue->rq_timeout;
struct scsi_sense_hdr sshdr;
unsigned char cmd[16];
unsigned int rep_len;
int result;
memset(cmd, 0, 16);
cmd[0] = ZBC_IN;
cmd[1] = ZI_REPORT_ZONES;
put_unaligned_be64(lba, &cmd[2]);
put_unaligned_be32(buflen, &cmd[10]);
memset(buf, 0, buflen);
result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
buf, buflen, &sshdr,
timeout, SD_MAX_RETRIES, NULL);
if (result) {
sd_printk(KERN_ERR, sdkp,
"REPORT ZONES lba %llu failed with %d/%d\n",
(unsigned long long)lba,
host_byte(result), driver_byte(result));
return -EIO;
}
rep_len = get_unaligned_be32(&buf[0]);
if (rep_len < 64) {
sd_printk(KERN_ERR, sdkp,
"REPORT ZONES report invalid length %u\n",
rep_len);
return -EIO;
}
return 0;
}
void tso_build_hdr(struct sk_buff *skb, char *hdr, struct tso_t *tso,
int size, bool is_last)
{
struct iphdr *iph;
struct tcphdr *tcph;
int hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
int mac_hdr_len = skb_network_offset(skb);
memcpy(hdr, skb->data, hdr_len);
iph = (struct iphdr *)(hdr + mac_hdr_len);
iph->id = htons(tso->ip_id);
iph->tot_len = htons(size + hdr_len - mac_hdr_len);
tcph = (struct tcphdr *)(hdr + skb_transport_offset(skb));
put_unaligned_be32(tso->tcp_seq, &tcph->seq);
tso->ip_id++;
if (!is_last) {
/* Clear all special flags for not last packet */
tcph->psh = 0;
tcph->fin = 0;
tcph->rst = 0;
}
}
static void
skd_prep_discard_cdb(struct skd_scsi_request *scsi_req,
struct skd_request_context *skreq,
struct page *page,
u32 lba, u32 count)
{
char *buf;
unsigned long len;
struct request *req;
buf = page_address(page);
len = SKD_DISCARD_CDB_LENGTH;
scsi_req->cdb[0] = UNMAP;
scsi_req->cdb[8] = len;
put_unaligned_be16(6 + 16, &buf[0]);
put_unaligned_be16(16, &buf[2]);
put_unaligned_be64(lba, &buf[8]);
put_unaligned_be32(count, &buf[16]);
req = skreq->req;
blk_add_request_payload(req, page, len);
}
static void sd_normal_rw(struct realtek_pci_sdmmc *host,
struct mmc_request *mrq)
{
struct mmc_command *cmd = mrq->cmd;
struct mmc_data *data = mrq->data;
u8 _cmd[5], *buf;
_cmd[0] = 0x40 | (u8)cmd->opcode;
put_unaligned_be32(cmd->arg, (u32 *)(&_cmd[1]));
buf = kzalloc(data->blksz, GFP_NOIO);
if (!buf) {
cmd->error = -ENOMEM;
return;
}
if (data->flags & MMC_DATA_READ) {
if (host->initial_mode)
sd_disable_initial_mode(host);
cmd->error = sd_read_data(host, _cmd, (u16)data->blksz, buf,
data->blksz, 200);
if (host->initial_mode)
sd_enable_initial_mode(host);
sg_copy_from_buffer(data->sg, data->sg_len, buf, data->blksz);
} else {
sg_copy_to_buffer(data->sg, data->sg_len, buf, data->blksz);
cmd->error = sd_write_data(host, _cmd, (u16)data->blksz, buf,
data->blksz, 200);
}
kfree(buf);
}
/**
* scsi_set_sense_information - set the information field in a
* formatted sense data buffer
* @buf: Where to build sense data
* @buf_len: buffer length
* @info: 64-bit information value to be set
*
* Return value:
* 0 on success or EINVAL for invalid sense buffer length
**/
int scsi_set_sense_information(u8 *buf, int buf_len, u64 info)
{
if ((buf[0] & 0x7f) == 0x72) {
u8 *ucp, len;
len = buf[7];
ucp = (char *)scsi_sense_desc_find(buf, len + 8, 0);
if (!ucp) {
buf[7] = len + 0xc;
ucp = buf + 8 + len;
}
if (buf_len < len + 0xc)
/* Not enough room for info */
return -EINVAL;
ucp[0] = 0;
ucp[1] = 0xa;
ucp[2] = 0x80; /* Valid bit */
ucp[3] = 0;
put_unaligned_be64(info, &ucp[4]);
} else if ((buf[0] & 0x7f) == 0x70) {
/*
* Only set the 'VALID' bit if we can represent the value
* correctly; otherwise just fill out the lower bytes and
* clear the 'VALID' flag.
*/
if (info <= 0xffffffffUL)
buf[0] |= 0x80;
else
buf[0] &= 0x7f;
put_unaligned_be32((u32)info, &buf[3]);
}
return 0;
}
int position_blocks_back(uint32_t count, uint8_t *sam_stat)
{
uint32_t residual;
uint32_t blk_target;
int i = -1;
unsigned int num_filemarks = meta.filemark_count;
if (!tape_loaded(sam_stat))
return -1;
if (mam.MediumType == MEDIA_TYPE_WORM)
OK_to_write = 0;
MHVTL_DBG(2, "Position before movement: %d", raw_pos.hdr.blk_number);
if (count < raw_pos.hdr.blk_number)
blk_target = raw_pos.hdr.blk_number - count;
else
blk_target = 0;
/* Find the first filemark prior to our current position, if any. */
if (num_filemarks > 0) {
for (i = num_filemarks - 1; i >= 0; i--) {
MHVTL_DBG(3, "filemark at %ld",
(unsigned long)filemarks[i]);
if (filemarks[i] < raw_pos.hdr.blk_number)
break;
}
}
/* If there is one, see if it is between our current position and our
desired destination.
*/
if (i >= 0) {
if (filemarks[i] < blk_target)
return position_to_block(blk_target, sam_stat);
residual = raw_pos.hdr.blk_number - blk_target;
if (read_header(filemarks[i], sam_stat))
return -1;
MHVTL_DBG(2, "Filemark encountered: block %d", filemarks[i]);
sam_no_sense(SD_FILEMARK, E_MARK, sam_stat);
put_unaligned_be32(residual, &sense[3]);
return -1;
}
if (count > raw_pos.hdr.blk_number) {
residual = count - raw_pos.hdr.blk_number;
if (read_header(0, sam_stat))
return -1;
MHVTL_DBG(1, "BOM encountered");
sam_no_sense(SD_EOM, E_BOM, sam_stat);
put_unaligned_be32(residual, &sense[3]);
return -1;
}
return position_to_block(blk_target, sam_stat);
}
int ip_options_compile(struct net *net,
struct ip_options * opt, struct sk_buff * skb)
{
int l;
unsigned char * iph;
unsigned char * optptr;
int optlen;
unsigned char * pp_ptr = NULL;
struct rtable *rt = NULL;
if (skb != NULL) {
rt = skb_rtable(skb);
optptr = (unsigned char *)&(ip_hdr(skb)[1]);
} else
optptr = opt->__data;
iph = optptr - sizeof(struct iphdr);
for (l = opt->optlen; l > 0; ) {
switch (*optptr) {
case IPOPT_END:
for (optptr++, l--; l>0; optptr++, l--) {
if (*optptr != IPOPT_END) {
*optptr = IPOPT_END;
opt->is_changed = 1;
}
}
goto eol;
case IPOPT_NOOP:
l--;
optptr++;
continue;
}
if (unlikely(l < 2)) {
pp_ptr = optptr;
goto error;
}
optlen = optptr[1];
if (optlen<2 || optlen>l) {
pp_ptr = optptr;
goto error;
}
switch (*optptr) {
case IPOPT_SSRR:
case IPOPT_LSRR:
if (optlen < 3) {
pp_ptr = optptr + 1;
goto error;
}
if (optptr[2] < 4) {
pp_ptr = optptr + 2;
goto error;
}
/* NB: cf RFC-1812 5.2.4.1 */
if (opt->srr) {
pp_ptr = optptr;
goto error;
}
if (!skb) {
if (optptr[2] != 4 || optlen < 7 || ((optlen-3) & 3)) {
pp_ptr = optptr + 1;
goto error;
}
memcpy(&opt->faddr, &optptr[3], 4);
if (optlen > 7)
memmove(&optptr[3], &optptr[7], optlen-7);
}
opt->is_strictroute = (optptr[0] == IPOPT_SSRR);
opt->srr = optptr - iph;
break;
case IPOPT_RR:
if (opt->rr) {
pp_ptr = optptr;
goto error;
}
if (optlen < 3) {
pp_ptr = optptr + 1;
goto error;
}
if (optptr[2] < 4) {
pp_ptr = optptr + 2;
goto error;
}
if (optptr[2] <= optlen) {
if (optptr[2]+3 > optlen) {
pp_ptr = optptr + 2;
goto error;
}
if (rt) {
memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);
opt->is_changed = 1;
}
optptr[2] += 4;
opt->rr_needaddr = 1;
}
opt->rr = optptr - iph;
break;
case IPOPT_TIMESTAMP:
if (opt->ts) {
pp_ptr = optptr;
goto error;
}
if (optlen < 4) {
pp_ptr = optptr + 1;
goto error;
}
if (optptr[2] < 5) {
pp_ptr = optptr + 2;
goto error;
}
if (optptr[2] <= optlen) {
unsigned char *timeptr = NULL;
if (optptr[2]+3 > optptr[1]) {
pp_ptr = optptr + 2;
goto error;
}
switch (optptr[3]&0xF) {
case IPOPT_TS_TSONLY:
if (skb)
timeptr = &optptr[optptr[2]-1];
opt->ts_needtime = 1;
optptr[2] += 4;
break;
case IPOPT_TS_TSANDADDR:
if (optptr[2]+7 > optptr[1]) {
pp_ptr = optptr + 2;
goto error;
}
if (rt) {
memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);
timeptr = &optptr[optptr[2]+3];
}
opt->ts_needaddr = 1;
opt->ts_needtime = 1;
optptr[2] += 8;
break;
case IPOPT_TS_PRESPEC:
if (optptr[2]+7 > optptr[1]) {
pp_ptr = optptr + 2;
goto error;
}
{
__be32 addr;
memcpy(&addr, &optptr[optptr[2]-1], 4);
if (inet_addr_type(net, addr) == RTN_UNICAST)
break;
if (skb)
timeptr = &optptr[optptr[2]+3];
}
opt->ts_needtime = 1;
optptr[2] += 8;
break;
default:
if (!skb && !capable(CAP_NET_RAW)) {
pp_ptr = optptr + 3;
goto error;
}
break;
}
if (timeptr) {
struct timespec tv;
u32 midtime;
getnstimeofday(&tv);
midtime = (tv.tv_sec % 86400) * MSEC_PER_SEC + tv.tv_nsec / NSEC_PER_MSEC;
put_unaligned_be32(midtime, timeptr);
opt->is_changed = 1;
}
} else {
unsigned overflow = optptr[3]>>4;
if (overflow == 15) {
pp_ptr = optptr + 3;
goto error;
}
if (skb) {
optptr[3] = (optptr[3]&0xF)|((overflow+1)<<4);
opt->is_changed = 1;
}
}
opt->ts = optptr - iph;
break;
case IPOPT_RA:
if (optlen < 4) {
pp_ptr = optptr + 1;
goto error;
}
if (optptr[2] == 0 && optptr[3] == 0)
opt->router_alert = optptr - iph;
break;
case IPOPT_CIPSO:
if ((!skb && !capable(CAP_NET_RAW)) || opt->cipso) {
pp_ptr = optptr;
goto error;
}
opt->cipso = optptr - iph;
if (cipso_v4_validate(skb, &optptr)) {
pp_ptr = optptr;
goto error;
}
break;
case IPOPT_SEC:
case IPOPT_SID:
default:
if (!skb && !capable(CAP_NET_RAW)) {
pp_ptr = optptr;
goto error;
}
break;
}
l -= optlen;
optptr += optlen;
}
eol:
if (!pp_ptr)
return 0;
error:
if (skb) {
icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((pp_ptr-iph)<<24));
}
return -EINVAL;
}
