get_unaligned_be64
ctr64 = le_ctr[0] = get_unaligned_be64(&req->iv[8]);
le_ctr[1] = get_unaligned_be64(&req->iv[0]);
kl = get_unaligned_be64(key);
kr = get_unaligned_be64(key + 8);
krl = get_unaligned_be64(key + 16);
krr = get_unaligned_be64(key + 24);
kl = get_unaligned_be64(key);
kr = get_unaligned_be64(key + 8);
if (MAGIC_TOCBLOCK != get_unaligned_be64(data)) {
toc->bitmap1_start = get_unaligned_be64(data + 0x2E);
toc->bitmap1_size = get_unaligned_be64(data + 0x36);
toc->bitmap2_start = get_unaligned_be64(data + 0x50);
toc->bitmap2_size = get_unaligned_be64(data + 0x58);
if (MAGIC_PRIVHEAD != get_unaligned_be64(data)) {
ph->logical_disk_start = get_unaligned_be64(data + 0x011B);
ph->logical_disk_size = get_unaligned_be64(data + 0x0123);
ph->config_start = get_unaligned_be64(data + 0x012B);
ph->config_size = get_unaligned_be64(data + 0x0133);
part->start = get_unaligned_be64(buffer + 0x24 + r_name);
part->volume_offset = get_unaligned_be64(buffer + 0x2C + r_name);
u64 guard = get_unaligned_be64(&pi->guard_tag);
dest[i] = get_unaligned_be64(&from[ndigits - 1 - i]);
K2 = get_unaligned_be64(&in_key[0]);
K1 = get_unaligned_be64(&in_key[8]);
state = get_unaligned_be64(src) ^ roundKey[0];
block[i] = get_unaligned_be64(buffer + i * 8);
*plba = get_unaligned_be64(&cdb[2]);
val = (len == 4) ? (u64)be32_to_cpup(prop) : get_unaligned_be64(prop);
energy = get_unaligned_be64(raw) >> 16;
val = occ_get_powr_avg(get_unaligned_be64(&power->accumulator),
val = occ_get_powr_avg(get_unaligned_be64(&power->system.accumulator),
val = occ_get_powr_avg(get_unaligned_be64(&power->proc.accumulator),
val = occ_get_powr_avg(get_unaligned_be64(&power->vdd.accumulator),
val = occ_get_powr_avg(get_unaligned_be64(&power->vdn.accumulator),
u64 val = get_unaligned_be64(data);
*guid = get_unaligned_be64(w);
nonce = get_unaligned_be64(nonce_addr);
vcn = get_unaligned_be64(vcn_addr);
return get_unaligned_be64(&name->name[VOLUME_INDEX_BYTES_OFFSET]);
*val = get_unaligned_be64(buf);
result = clamp_val(get_unaligned_be64(blocks), 0, UINT_MAX);
correction = (s64)get_unaligned_be64(&ptp_hdr->correction);
hwtstamps->hwtstamp = ns_to_ktime(get_unaligned_be64(data));
((u64 *)dst)[0] = get_unaligned_be64(src);
((u64 *)dst)[1] = get_unaligned_be64(src + 8);
rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr);
rekey_data->replay_ctr = get_unaligned_be64(data->replay_ctr);
return get_unaligned_be64(p);
return get_unaligned_be64(p);
*wwp = get_unaligned_be64(b);
if (get_unaligned_be64(&wp->fd_wwn) != fcf->switch_name)
get_unaligned_be64(&vp->fd_wwpn) !=
get_unaligned_be64(&wwn->fd_wwn);
get_unaligned_be64(&vn->fd_wwpn);
get_unaligned_be64(&wwn->fd_wwn);
fcf->switch_name = get_unaligned_be64(&wwn->fd_wwn);
fcf->fabric_name = get_unaligned_be64(&fab->fd_wwn);
frame_wwnn = get_unaligned_be64(&adisc_rsp->els.adisc_wwnn);
frame_wwpn = get_unaligned_be64(&adisc_rsp->els.adisc_wwpn);
tport->wwpn = get_unaligned_be64(&FNIC_LOGI_PORT_NAME(plogi_rsp->els));
tport->wwnn = get_unaligned_be64(&FNIC_LOGI_NODE_NAME(plogi_rsp->els));
get_unaligned_be64(&FNIC_LOGI_NODE_NAME(flogi_rsp->els));
sa = get_unaligned_be64(buf+12);
sa = get_unaligned_be64(&physdev->LUN[i].wwid[0]);
sa = get_unaligned_be64(ssi->primary_world_wide_id);
first_block = get_unaligned_be64(&cmd->cmnd[2]);
res->lun_wwn = get_unaligned_be64(cfgtew->u.cfgte->lun_wwn);
port_name = get_unaligned_be64(&pn->fn_wwpn);
get_unaligned_be64(
get_unaligned_be64(
get_unaligned_be64(&flp->fl_wwnn);
remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
get_unaligned_be64(&flp->fl_wwnn));
rdata->ids.port_name = get_unaligned_be64(&plp->fl_wwpn);
rdata->ids.node_name = get_unaligned_be64(&plp->fl_wwnn);
get_unaligned_be64(&adisc->adisc_wwpn) != rdata->ids.port_name ||
get_unaligned_be64(&adisc->adisc_wwnn) != rdata->ids.node_name) {
rdata->ids.port_name = get_unaligned_be64(&pl->fl_wwpn);
rdata->ids.node_name = get_unaligned_be64(&pl->fl_wwnn);
v_lba = get_unaligned_be64(&mpi_request->CDB.CDB32[2]);
switch_name = get_unaligned_be64(&wp->fd_wwn);
get_unaligned_be64(&vp->fd_wwpn));
if ((get_unaligned_be64(&vp->fd_wwpn) ==
lba = get_unaligned_be64(cmd + 2);
lba = get_unaligned_be64(cmd + 12);
lba = get_unaligned_be64(cmd + 2);
lba = get_unaligned_be64(cmd + 12);
lba = get_unaligned_be64(up + 0);
lba = get_unaligned_be64(cmd + 2);
lba = get_unaligned_be64(cmd + 2);
unsigned long long lba = get_unaligned_be64(&desc[i].lba);
lba = get_unaligned_be64(cmd + 2);
lba = get_unaligned_be64(cmd + 2);
lba = get_unaligned_be64(cmd + 2);
lba = get_unaligned_be64(cmd + 2);
zs_lba = get_unaligned_be64(cmd + 2);
lba = get_unaligned_be64(cmd + 2);
z_id = get_unaligned_be64(cmd + 2);
z_id = get_unaligned_be64(cmd + 2);
z_id = get_unaligned_be64(cmd + 2);
z_id = get_unaligned_be64(cmd + 2);
*info_out = get_unaligned_be64(&ucp[4]);
lba = get_unaligned_be64(&cdb[12]);
lba = get_unaligned_be64(&cdb[2]);
zone_id = get_unaligned_be64(&cdb[2]);
zone_id = get_unaligned_be64(&cdb[2]);
lba = get_unaligned_be64(&cdb[2]);
lba = get_unaligned_be64(&cdb[2]);
keys_info->keys[i] = get_unaligned_be64(&data[data_offset]);
rsv->key = get_unaligned_be64(&data[8]);
lba = get_unaligned_be64(&buffer[0]);
sdkp->max_ws_blocks = (u32)get_unaligned_be64(&vpd->data[36]);
return logical_to_sectors(sdkp->device, get_unaligned_be64(buf));
start_lba = get_unaligned_be64(&buf[offset + 16]);
zone_length = get_unaligned_be64(&buf[offset + 8]);
zone_starting_lba_gran = get_unaligned_be64(&buf[24]);
max_lba = get_unaligned_be64(&buf[8]);
zone_blocks = get_unaligned_be64(&rec[8]);
start_lba = get_unaligned_be64(&buf[16]);
zone.capacity = logical_to_sectors(sdp, get_unaligned_be64(&buf[8]));
zone.wp = logical_to_sectors(sdp, get_unaligned_be64(&buf[24]));
unsigned long long id = get_unaligned_be64(ses_dev->page1+8+4);
get_unaligned_be64(&device->wwid[0]),
get_unaligned_be64(&device->wwid[8]));
get_unaligned_be64(&device->wwid[0]));
get_unaligned_be64(&device->wwid[0]));
get_unaligned_be64(&phys_lun->wwid[0]),
get_unaligned_be64(&phys_lun->wwid[8]));
device->sas_address = get_unaligned_be64(&device->wwid[0]);
rmd->first_block = get_unaligned_be64(&scmd->cmnd[2]);
*identifier = get_unaligned_be64(&found_device->wwid[8]);
get_unaligned_be64(&device->wwid[8]);
*identifier = get_unaligned_be64(&device->wwid[8]);
get_unaligned_be64(gl->va),
res_key = get_unaligned_be64(&buf[0]);
sa_res_key = get_unaligned_be64(&buf[8]);
pr_reg->pr_reg_bin_isid = get_unaligned_be64(isid);
pr_reg->pr_reg_bin_isid = get_unaligned_be64(isid);
cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
lba = get_unaligned_be64(&ptr[0]);
return get_unaligned_be64(&cdb[2]);
cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
se_sess->sess_bin_isid = get_unaligned_be64(&buf[0]);
xop->src_lba = get_unaligned_be64(&desc[12]);
xop->dst_lba = get_unaligned_be64(&desc[20]);
get_unaligned_be64(desc_buf));
*attr_val = get_unaligned_be64(&upiu_resp->osf3);
(get_unaligned_be64(desc_buf
u64 lba = get_unaligned_be64(&common->cmnd[2]);
lba = get_unaligned_be64(&common->cmnd[2]);
lba = get_unaligned_be64(&common->cmnd[2]);
file_size = get_unaligned_be64(page_virt);
uint64_t l0 = get_unaligned_be64(&rec->l0);
uint64_t l1 = get_unaligned_be64(&rec->l1);
return get_unaligned_be64(hdr->parent) & XFS_MAXINUMBER;
return get_unaligned_be64(from) & XFS_MAXINUMBER;
out[i] = get_unaligned_be64(&src[ndigits - 1 - i]);
*valp = get_unaligned_be64(p);
*ptr = get_unaligned_be64(p);
*ptr = get_unaligned_be64(p);
put_unaligned_le64(get_unaligned_be64(be64_src), le64_dst);
return get_unaligned_be64(p);
return get_unaligned_be64(wwn);
cpu_to_le64(get_unaligned_be64((__be64 *)(data + 8)));
acc->hi ^= cpu_to_le64(get_unaligned_be64((__be64 *)data));
u64 hi = get_unaligned_be64(&in[0]);
u64 lo = get_unaligned_be64(&in[8]);
out->lo = cpu_to_le64(get_unaligned_be64(&in[8]));
out->hi = cpu_to_le64(get_unaligned_be64(&in[0]));
W[j] = get_unaligned_be64(data + j * sizeof(u64));
return get_unaligned_be64(memPtr);
correction = (s64)get_unaligned_be64(&ptp_hdr->correction);
u64 a = get_unaligned_be64(pad);
u64 b = get_unaligned_be64(pad + 8);
mp_opt->thmac = get_unaligned_be64(ptr);
mp_opt->data_ack = get_unaligned_be64(ptr);
mp_opt->data_seq = get_unaligned_be64(ptr);
mp_opt->ahmac = get_unaligned_be64(ptr);
mp_opt->rcvr_key = get_unaligned_be64(ptr);
mp_opt->fail_seq = get_unaligned_be64(ptr);
return get_unaligned_be64(&hmac[SHA256_DIGEST_SIZE - sizeof(u64)]);
mp_opt->sndr_key = get_unaligned_be64(ptr);
mp_opt->rcvr_key = get_unaligned_be64(ptr);
thmac = get_unaligned_be64(hmac);
subflow_req->thmac = get_unaligned_be64(hmac);
__entry->rec_no = get_unaligned_be64(rec_no);
__entry->rec_no = get_unaligned_be64(rec_no);
__entry->rec_no = get_unaligned_be64(rec_no);
__entry->rec_no = get_unaligned_be64(rec_no);
return get_unaligned_be64(x);
data64 = get_unaligned_be64(fw->data + 24);
get_unaligned_be64(&dtl->timebase),