Fairly straightforward conversions in all spots. In a couple of cases any error gets propogated up should sg_map fail. In other cases a warning is issued if the kmap fails seeing there's no clear error path. This should not be an issue until someone tries to use unmappable memory in the sgl with this driver.

Signed-off-by: Logan Gunthorpe logang@deltatee.com Cc: "Nicholas A. Bellinger" nab@linux-iscsi.org --- drivers/target/iscsi/iscsi_target.c | 29 +++++++--- drivers/target/target_core_rd.c | 3 +- drivers/target/target_core_sbc.c | 103 +++++++++++++++++++++------------ drivers/target/target_core_transport.c | 18 ++++-- drivers/target/target_core_user.c | 45 +++++++++----- include/target/target_core_backend.h | 4 +- 6 files changed, 134 insertions(+), 68 deletions(-)

diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c index e3f9ed3..3ab8d21 100644 --- a/drivers/target/iscsi/iscsi_target.c +++ b/drivers/target/iscsi/iscsi_target.c @@ -578,7 +578,7 @@ iscsit_xmit_nondatain_pdu(struct iscsi_conn *conn, struct iscsi_cmd *cmd, }

static int iscsit_map_iovec(struct iscsi_cmd *, struct kvec *, u32, u32); -static void iscsit_unmap_iovec(struct iscsi_cmd *); +static void iscsit_unmap_iovec(struct iscsi_cmd *, struct kvec *); static u32 iscsit_do_crypto_hash_sg(struct ahash_request *, struct iscsi_cmd *, u32, u32, u32, u8 *); static int @@ -645,7 +645,7 @@ iscsit_xmit_datain_pdu(struct iscsi_conn *conn, struct iscsi_cmd *cmd,

ret = iscsit_fe_sendpage_sg(cmd, conn);

- iscsit_unmap_iovec(cmd); + iscsit_unmap_iovec(cmd, &cmd->iov_data[1]);

if (ret < 0) { iscsit_tx_thread_wait_for_tcp(conn); @@ -924,7 +924,10 @@ static int iscsit_map_iovec( while (data_length) { u32 cur_len = min_t(u32, data_length, sg->length - page_off);

- iov[i].iov_base = kmap(sg_page(sg)) + sg->offset + page_off; + iov[i].iov_base = sg_map(sg, page_off, SG_KMAP); + if (IS_ERR(iov[i].iov_base)) + goto map_err; + iov[i].iov_len = cur_len;

data_length -= cur_len; @@ -936,17 +939,25 @@ static int iscsit_map_iovec( cmd->kmapped_nents = i;

return i; + +map_err: + cmd->kmapped_nents = i - 1; + iscsit_unmap_iovec(cmd, iov); + return -1; }

-static void iscsit_unmap_iovec(struct iscsi_cmd *cmd) +static void iscsit_unmap_iovec(struct iscsi_cmd *cmd, struct kvec *iov) { u32 i; struct scatterlist *sg; + unsigned int page_off = cmd->first_data_sg_off;

sg = cmd->first_data_sg;

- for (i = 0; i < cmd->kmapped_nents; i++) - kunmap(sg_page(&sg[i])); + for (i = 0; i < cmd->kmapped_nents; i++) { + sg_unmap(&sg[i], iov[i].iov_base, page_off, SG_KMAP); + page_off = 0; + } }

static void iscsit_ack_from_expstatsn(struct iscsi_conn *conn, u32 exp_statsn) @@ -1609,7 +1620,7 @@ iscsit_get_dataout(struct iscsi_conn *conn, struct iscsi_cmd *cmd,

rx_got = rx_data(conn, &cmd->iov_data[0], iov_count, rx_size);

- iscsit_unmap_iovec(cmd); + iscsit_unmap_iovec(cmd, iov);

if (rx_got != rx_size) return -1; @@ -1710,7 +1721,7 @@ int iscsit_setup_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd, if (!cmd) return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR, (unsigned char *)hdr); - + return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, (unsigned char *)hdr); } @@ -2625,7 +2636,7 @@ static int iscsit_handle_immediate_data(

rx_got = rx_data(conn, &cmd->iov_data[0], iov_count, rx_size);

- iscsit_unmap_iovec(cmd); + iscsit_unmap_iovec(cmd, cmd->iov_data);

if (rx_got != rx_size) { iscsit_rx_thread_wait_for_tcp(conn); diff --git a/drivers/target/target_core_rd.c b/drivers/target/target_core_rd.c index 5f23f34..348211c 100644 --- a/drivers/target/target_core_rd.c +++ b/drivers/target/target_core_rd.c @@ -432,7 +432,8 @@ static sense_reason_t rd_do_prot_rw(struct se_cmd *cmd, bool is_read) cmd->t_prot_sg, 0); } if (!rc) - sbc_dif_copy_prot(cmd, sectors, is_read, prot_sg, prot_offset); + rc = sbc_dif_copy_prot(cmd, sectors, is_read, prot_sg, + prot_offset);

return rc; } diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c index ee35c90..8ac07c6 100644 --- a/drivers/target/target_core_sbc.c +++ b/drivers/target/target_core_sbc.c @@ -420,17 +420,17 @@ static sense_reason_t xdreadwrite_callback(struct se_cmd *cmd, bool success,

offset = 0; for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) { - addr = kmap_atomic(sg_page(sg)); - if (!addr) { + addr = sg_map(sg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(addr)) { ret = TCM_OUT_OF_RESOURCES; goto out; }

for (i = 0; i < sg->length; i++) - *(addr + sg->offset + i) ^= *(buf + offset + i); + *(addr + i) ^= *(buf + offset + i);

offset += sg->length; - kunmap_atomic(addr); + sg_unmap(sg, addr, 0, SG_KMAP_ATOMIC); }

out: @@ -541,8 +541,8 @@ static sense_reason_t compare_and_write_callback(struct se_cmd *cmd, bool succes * Compare against SCSI READ payload against verify payload */ for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, i) { - addr = (unsigned char *)kmap_atomic(sg_page(sg)); - if (!addr) { + addr = sg_map(sg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(addr)) { ret = TCM_OUT_OF_RESOURCES; goto out; } @@ -552,10 +552,10 @@ static sense_reason_t compare_and_write_callback(struct se_cmd *cmd, bool succes if (memcmp(addr, buf + offset, len)) { pr_warn("Detected MISCOMPARE for addr: %p buf: %p\n", addr, buf + offset); - kunmap_atomic(addr); + sg_unmap(sg, addr, 0, SG_KMAP_ATOMIC); goto miscompare; } - kunmap_atomic(addr); + sg_unmap(sg, addr, 0, SG_KMAP_ATOMIC);

offset += len; compare_len -= len; @@ -1315,8 +1315,8 @@ sbc_dif_generate(struct se_cmd *cmd) unsigned int block_size = dev->dev_attrib.block_size;

for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) { - paddr = kmap_atomic(sg_page(psg)) + psg->offset; - daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; + paddr = sg_map(psg, 0, SG_KMAP_ATOMIC | SG_MAP_MUST_NOT_FAIL); + daddr = sg_map(dsg, 0, SG_KMAP_ATOMIC | SG_MAP_MUST_NOT_FAIL);

for (j = 0; j < psg->length; j += sizeof(*sdt)) { @@ -1325,26 +1325,30 @@ sbc_dif_generate(struct se_cmd *cmd)

if (offset >= dsg->length) { offset -= dsg->length; - kunmap_atomic(daddr - dsg->offset); + sg_unmap(dsg, daddr, 0, SG_KMAP_ATOMIC); dsg = sg_next(dsg); if (!dsg) { - kunmap_atomic(paddr - psg->offset); + sg_unmap(psg, paddr, 0, SG_KMAP_ATOMIC); return; } - daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; + daddr = sg_map(dsg, 0, SG_KMAP_ATOMIC | + SG_MAP_MUST_NOT_FAIL); }

sdt = paddr + j; avail = min(block_size, dsg->length - offset); crc = crc_t10dif(daddr + offset, avail); if (avail < block_size) { - kunmap_atomic(daddr - dsg->offset); + sg_unmap(dsg, daddr, 0, SG_KMAP_ATOMIC); dsg = sg_next(dsg); if (!dsg) { - kunmap_atomic(paddr - psg->offset); + sg_unmap(psg, paddr, 0, SG_KMAP_ATOMIC); return; } - daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; + + daddr = sg_map(dsg, 0, SG_KMAP_ATOMIC | + SG_MAP_MUST_NOT_FAIL); + offset = block_size - avail; crc = crc_t10dif_update(crc, daddr, offset); } else { @@ -1366,8 +1370,8 @@ sbc_dif_generate(struct se_cmd *cmd) sector++; }

- kunmap_atomic(daddr - dsg->offset); - kunmap_atomic(paddr - psg->offset); + sg_unmap(dsg, daddr, 0, SG_KMAP_ATOMIC); + sg_unmap(psg, paddr, 0, SG_KMAP_ATOMIC); } }

@@ -1412,8 +1416,8 @@ sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt, return 0; }

-void sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read, - struct scatterlist *sg, int sg_off) +int sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read, + struct scatterlist *sg, int sg_off) { struct se_device *dev = cmd->se_dev; struct scatterlist *psg; @@ -1422,18 +1426,25 @@ void sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read, unsigned int offset = sg_off;

if (!sg) - return; + return 0;

left = sectors * dev->prot_length;

for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) { unsigned int psg_len, copied = 0;

- paddr = kmap_atomic(sg_page(psg)) + psg->offset; + paddr = sg_map(psg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(paddr)) + return TCM_OUT_OF_RESOURCES; + psg_len = min(left, psg->length); while (psg_len) { len = min(psg_len, sg->length - offset); - addr = kmap_atomic(sg_page(sg)) + sg->offset + offset; + addr = sg_map(sg, offset, SG_KMAP_ATOMIC); + if (IS_ERR(addr)) { + sg_unmap(psg, paddr, 0, SG_KMAP_ATOMIC); + return TCM_OUT_OF_RESOURCES; + }

if (read) memcpy(paddr + copied, addr, len); @@ -1445,15 +1456,17 @@ void sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read, copied += len; psg_len -= len;

- kunmap_atomic(addr - sg->offset - offset); + sg_unmap(sg, addr, offset, SG_KMAP_ATOMIC);

if (offset >= sg->length) { sg = sg_next(sg); offset = 0; } } - kunmap_atomic(paddr - psg->offset); + sg_unmap(psg, paddr, 0, SG_KMAP_ATOMIC); } + + return 0; } EXPORT_SYMBOL(sbc_dif_copy_prot);

@@ -1472,8 +1485,13 @@ sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors, unsigned int block_size = dev->dev_attrib.block_size;

for (; psg && sector < start + sectors; psg = sg_next(psg)) { - paddr = kmap_atomic(sg_page(psg)) + psg->offset; - daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; + paddr = sg_map(psg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(paddr)) + goto sg_map_err; + + daddr = sg_map(dsg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(daddr)) + goto sg_map_err;

for (i = psg_off; i < psg->length && sector < start + sectors; @@ -1483,13 +1501,15 @@ sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors,

if (dsg_off >= dsg->length) { dsg_off -= dsg->length; - kunmap_atomic(daddr - dsg->offset); + sg_unmap(dsg, daddr, 0, SG_KMAP_ATOMIC); dsg = sg_next(dsg); if (!dsg) { - kunmap_atomic(paddr - psg->offset); + sg_unmap(psg, paddr, 0, SG_KMAP_ATOMIC); return 0; } - daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; + daddr = sg_map(dsg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(daddr)) + goto sg_map_err; }

sdt = paddr + i; @@ -1507,13 +1527,16 @@ sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors, avail = min(block_size, dsg->length - dsg_off); crc = crc_t10dif(daddr + dsg_off, avail); if (avail < block_size) { - kunmap_atomic(daddr - dsg->offset); + sg_unmap(dsg, daddr, 0, SG_KMAP_ATOMIC); dsg = sg_next(dsg); if (!dsg) { - kunmap_atomic(paddr - psg->offset); + sg_unmap(psg, paddr, 0, SG_KMAP_ATOMIC); return 0; } - daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; + daddr = sg_map(dsg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(daddr)) + goto sg_map_err; + dsg_off = block_size - avail; crc = crc_t10dif_update(crc, daddr, dsg_off); } else { @@ -1522,8 +1545,8 @@ sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors,

rc = sbc_dif_v1_verify(cmd, sdt, crc, sector, ei_lba); if (rc) { - kunmap_atomic(daddr - dsg->offset); - kunmap_atomic(paddr - psg->offset); + sg_unmap(dsg, daddr, 0, SG_KMAP_ATOMIC); + sg_unmap(psg, paddr, 0, SG_KMAP_ATOMIC); cmd->bad_sector = sector; return rc; } @@ -1533,10 +1556,16 @@ sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors, }

psg_off = 0; - kunmap_atomic(daddr - dsg->offset); - kunmap_atomic(paddr - psg->offset); + sg_unmap(dsg, daddr, 0, SG_KMAP_ATOMIC); + sg_unmap(psg, paddr, 0, SG_KMAP_ATOMIC); }

return 0; + +sg_map_err: + if (!IS_ERR_OR_NULL(paddr)) + sg_unmap(psg, paddr, 0, SG_KMAP_ATOMIC); + + return TCM_OUT_OF_RESOURCES; } EXPORT_SYMBOL(sbc_dif_verify); diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c index a0cd56e..345e547 100644 --- a/drivers/target/target_core_transport.c +++ b/drivers/target/target_core_transport.c @@ -1506,11 +1506,11 @@ int target_submit_cmd_map_sgls(struct se_cmd *se_cmd, struct se_session *se_sess unsigned char *buf = NULL;

if (sgl) - buf = kmap(sg_page(sgl)) + sgl->offset; + buf = sg_map(sgl, 0, SG_KMAP);

- if (buf) { + if (buf && !IS_ERR(buf)) { memset(buf, 0, sgl->length); - kunmap(sg_page(sgl)); + sg_unmap(sgl, buf, 0, SG_KMAP); } }

@@ -2307,8 +2307,14 @@ void *transport_kmap_data_sg(struct se_cmd *cmd) return NULL;

BUG_ON(!sg); - if (cmd->t_data_nents == 1) - return kmap(sg_page(sg)) + sg->offset; + if (cmd->t_data_nents == 1) { + cmd->t_data_vmap = sg_map(sg, 0, SG_KMAP); + if (IS_ERR(cmd->t_data_vmap)) { + cmd->t_data_vmap = NULL; + return NULL; + } + return cmd->t_data_vmap; + }

/* >1 page. use vmap */ pages = kmalloc(sizeof(*pages) * cmd->t_data_nents, GFP_KERNEL); @@ -2334,7 +2340,7 @@ void transport_kunmap_data_sg(struct se_cmd *cmd) if (!cmd->t_data_nents) { return; } else if (cmd->t_data_nents == 1) { - kunmap(sg_page(cmd->t_data_sg)); + sg_unmap(cmd->t_data_sg, cmd->t_data_vmap, 0, SG_KMAP); return; }

diff --git a/drivers/target/target_core_user.c b/drivers/target/target_core_user.c index f615c3b..b55f7e2 100644 --- a/drivers/target/target_core_user.c +++ b/drivers/target/target_core_user.c @@ -260,7 +260,7 @@ static inline size_t iov_tail(struct tcmu_dev *udev, struct iovec *iov) return (size_t)iov->iov_base + iov->iov_len; }

-static void alloc_and_scatter_data_area(struct tcmu_dev *udev, +static int alloc_and_scatter_data_area(struct tcmu_dev *udev, struct scatterlist *data_sg, unsigned int data_nents, struct iovec **iov, int *iov_cnt, bool copy_data) { @@ -272,7 +272,10 @@ static void alloc_and_scatter_data_area(struct tcmu_dev *udev,

for_each_sg(data_sg, sg, data_nents, i) { int sg_remaining = sg->length; - from = kmap_atomic(sg_page(sg)) + sg->offset; + from = sg_map(sg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(from)) + return PTR_ERR(from); + while (sg_remaining > 0) { if (block_remaining == 0) { block = find_first_zero_bit(udev->data_bitmap, @@ -301,8 +304,10 @@ static void alloc_and_scatter_data_area(struct tcmu_dev *udev, sg_remaining -= copy_bytes; block_remaining -= copy_bytes; } - kunmap_atomic(from - sg->offset); + sg_unmap(sg, from, 0, SG_KMAP_ATOMIC); } + + return 0; }

static void free_data_area(struct tcmu_dev *udev, struct tcmu_cmd *cmd) @@ -311,8 +316,8 @@ static void free_data_area(struct tcmu_dev *udev, struct tcmu_cmd *cmd) DATA_BLOCK_BITS); }

-static void gather_data_area(struct tcmu_dev *udev, struct tcmu_cmd *cmd, - bool bidi) +static int gather_data_area(struct tcmu_dev *udev, struct tcmu_cmd *cmd, + bool bidi) { struct se_cmd *se_cmd = cmd->se_cmd; int i, block; @@ -348,7 +353,10 @@ static void gather_data_area(struct tcmu_dev *udev, struct tcmu_cmd *cmd,

for_each_sg(data_sg, sg, data_nents, i) { int sg_remaining = sg->length; - to = kmap_atomic(sg_page(sg)) + sg->offset; + to = sg_map(sg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(to)) + return PTR_ERR(to); + while (sg_remaining > 0) { if (block_remaining == 0) { block = find_first_bit(bitmap, @@ -368,8 +376,10 @@ static void gather_data_area(struct tcmu_dev *udev, struct tcmu_cmd *cmd, sg_remaining -= copy_bytes; block_remaining -= copy_bytes; } - kunmap_atomic(to - sg->offset); + sg_unmap(sg, to, 0, SG_KMAP_ATOMIC); } + + return 0; }

static inline size_t spc_bitmap_free(unsigned long *bitmap) @@ -546,8 +556,12 @@ tcmu_queue_cmd_ring(struct tcmu_cmd *tcmu_cmd) iov_cnt = 0; copy_to_data_area = (se_cmd->data_direction == DMA_TO_DEVICE || se_cmd->se_cmd_flags & SCF_BIDI); - alloc_and_scatter_data_area(udev, se_cmd->t_data_sg, - se_cmd->t_data_nents, &iov, &iov_cnt, copy_to_data_area); + if (alloc_and_scatter_data_area(udev, se_cmd->t_data_sg, + se_cmd->t_data_nents, &iov, &iov_cnt, copy_to_data_area)) { + spin_unlock_irq(&udev->cmdr_lock); + return TCM_OUT_OF_RESOURCES; + } + entry->req.iov_cnt = iov_cnt; entry->req.iov_dif_cnt = 0;

@@ -555,9 +569,12 @@ tcmu_queue_cmd_ring(struct tcmu_cmd *tcmu_cmd) if (se_cmd->se_cmd_flags & SCF_BIDI) { iov_cnt = 0; iov++; - alloc_and_scatter_data_area(udev, se_cmd->t_bidi_data_sg, + if (alloc_and_scatter_data_area(udev, se_cmd->t_bidi_data_sg, se_cmd->t_bidi_data_nents, &iov, &iov_cnt, - false); + false)) { + spin_unlock_irq(&udev->cmdr_lock); + return TCM_OUT_OF_RESOURCES; + } entry->req.iov_bidi_cnt = iov_cnt; } /* cmd's data_bitmap is what changed in process */ @@ -637,10 +654,12 @@ static void tcmu_handle_completion(struct tcmu_cmd *cmd, struct tcmu_cmd_entry * free_data_area(udev, cmd); } else if (se_cmd->se_cmd_flags & SCF_BIDI) { /* Get Data-In buffer before clean up */ - gather_data_area(udev, cmd, true); + if (gather_data_area(udev, cmd, true)) + entry->rsp.scsi_status = SAM_STAT_CHECK_CONDITION; free_data_area(udev, cmd); } else if (se_cmd->data_direction == DMA_FROM_DEVICE) { - gather_data_area(udev, cmd, false); + if (gather_data_area(udev, cmd, false)) + entry->rsp.scsi_status = SAM_STAT_CHECK_CONDITION; free_data_area(udev, cmd); } else if (se_cmd->data_direction == DMA_TO_DEVICE) { free_data_area(udev, cmd); diff --git a/include/target/target_core_backend.h b/include/target/target_core_backend.h index 1b0f447..c39ecd9 100644 --- a/include/target/target_core_backend.h +++ b/include/target/target_core_backend.h @@ -82,8 +82,8 @@ sector_t sbc_get_write_same_sectors(struct se_cmd *cmd); void sbc_dif_generate(struct se_cmd *); sense_reason_t sbc_dif_verify(struct se_cmd *, sector_t, unsigned int, unsigned int, struct scatterlist *, int); -void sbc_dif_copy_prot(struct se_cmd *, unsigned int, bool, - struct scatterlist *, int); +int sbc_dif_copy_prot(struct se_cmd *, unsigned int, bool, + struct scatterlist *, int); void transport_set_vpd_proto_id(struct t10_vpd *, unsigned char *); int transport_set_vpd_assoc(struct t10_vpd *, unsigned char *); int transport_set_vpd_ident_type(struct t10_vpd *, unsigned char *);

Conversion of a couple kmap_atomic instances to the sg_map helper function.

However, it looks like there was a bug in the original code: the source scatter lists offset (t->offset) was passed to ablkcipher_get which added it to the destination address. This doesn't make a lot of sense, but t->offset is likely always zero anyway. So, this patch cleans that brokeness up.

Also, a change to the error path: if ablkcipher_get failed, everything seemed to proceed as if it hadn't. Setting 'error' should hopefully clear that up.

Signed-off-by: Logan Gunthorpe logang@deltatee.com Cc: Herbert Xu herbert@gondor.apana.org.au Cc: "David S. Miller" davem@davemloft.net --- drivers/crypto/hifn_795x.c | 32 +++++++++++++++++++++----------- 1 file changed, 21 insertions(+), 11 deletions(-)

diff --git a/drivers/crypto/hifn_795x.c b/drivers/crypto/hifn_795x.c index e09d405..34b1870 100644 --- a/drivers/crypto/hifn_795x.c +++ b/drivers/crypto/hifn_795x.c @@ -1619,7 +1619,7 @@ static int hifn_start_device(struct hifn_device *dev) return 0; }

-static int ablkcipher_get(void *saddr, unsigned int *srestp, unsigned int offset, +static int ablkcipher_get(void *saddr, unsigned int *srestp, struct scatterlist *dst, unsigned int size, unsigned int *nbytesp) { unsigned int srest = *srestp, nbytes = *nbytesp, copy; @@ -1632,15 +1632,17 @@ static int ablkcipher_get(void *saddr, unsigned int *srestp, unsigned int offset while (size) { copy = min3(srest, dst->length, size);

- daddr = kmap_atomic(sg_page(dst)); - memcpy(daddr + dst->offset + offset, saddr, copy); - kunmap_atomic(daddr); + daddr = sg_map(dst, 0, SG_KMAP_ATOMIC); + if (IS_ERR(daddr)) + return PTR_ERR(daddr); + + memcpy(daddr, saddr, copy); + sg_unmap(dst, daddr, 0, SG_KMAP_ATOMIC);

nbytes -= copy; size -= copy; srest -= copy; saddr += copy; - offset = 0;

pr_debug("%s: copy: %u, size: %u, srest: %u, nbytes: %u.\n", __func__, copy, size, srest, nbytes); @@ -1671,11 +1673,12 @@ static inline void hifn_complete_sa(struct hifn_device *dev, int i)

static void hifn_process_ready(struct ablkcipher_request *req, int error) { + int err; struct hifn_request_context *rctx = ablkcipher_request_ctx(req);

if (rctx->walk.flags & ASYNC_FLAGS_MISALIGNED) { unsigned int nbytes = req->nbytes; - int idx = 0, err; + int idx = 0; struct scatterlist *dst, *t; void *saddr;

@@ -1695,17 +1698,24 @@ static void hifn_process_ready(struct ablkcipher_request *req, int error) continue; }

- saddr = kmap_atomic(sg_page(t)); + saddr = sg_map(t, 0, SG_KMAP_ATOMIC); + if (IS_ERR(saddr)) { + if (!error) + error = PTR_ERR(saddr); + break; + } + + err = ablkcipher_get(saddr, &t->length, + dst, nbytes, &nbytes); + sg_unmap(t, saddr, 0, SG_KMAP_ATOMIC);

- err = ablkcipher_get(saddr, &t->length, t->offset, - dst, nbytes, &nbytes); if (err < 0) { - kunmap_atomic(saddr); + if (!error) + error = err; break; }

idx += err; - kunmap_atomic(saddr); }

hifn_cipher_walk_exit(&rctx->walk);

Very straightforward conversion to the new function in all four spots.

Signed-off-by: Logan Gunthorpe logang@deltatee.com Cc: Alasdair Kergon agk@redhat.com Cc: Mike Snitzer snitzer@redhat.com --- drivers/md/dm-crypt.c | 39 ++++++++++++++++++++++++++------------- 1 file changed, 26 insertions(+), 13 deletions(-)

diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c index 8dbecf1..841f1fc 100644 --- a/drivers/md/dm-crypt.c +++ b/drivers/md/dm-crypt.c @@ -635,9 +635,12 @@ static int crypt_iv_lmk_gen(struct crypt_config *cc, u8 *iv,

if (bio_data_dir(dmreq->ctx->bio_in) == WRITE) { sg = crypt_get_sg_data(cc, dmreq->sg_in); - src = kmap_atomic(sg_page(sg)); - r = crypt_iv_lmk_one(cc, iv, dmreq, src + sg->offset); - kunmap_atomic(src); + src = sg_map(sg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(src)) + return PTR_ERR(src); + + r = crypt_iv_lmk_one(cc, iv, dmreq, src); + sg_unmap(sg, src, 0, SG_KMAP_ATOMIC); } else memset(iv, 0, cc->iv_size);

@@ -655,14 +658,18 @@ static int crypt_iv_lmk_post(struct crypt_config *cc, u8 *iv, return 0;

sg = crypt_get_sg_data(cc, dmreq->sg_out); - dst = kmap_atomic(sg_page(sg)); - r = crypt_iv_lmk_one(cc, iv, dmreq, dst + sg->offset); + dst = sg_map(sg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(dst)) + return PTR_ERR(dst); + + r = crypt_iv_lmk_one(cc, iv, dmreq, dst);

/* Tweak the first block of plaintext sector */ if (!r) - crypto_xor(dst + sg->offset, iv, cc->iv_size); + crypto_xor(dst, iv, cc->iv_size); + + sg_unmap(sg, dst, 0, SG_KMAP_ATOMIC);

- kunmap_atomic(dst); return r; }

@@ -786,9 +793,12 @@ static int crypt_iv_tcw_gen(struct crypt_config *cc, u8 *iv, /* Remove whitening from ciphertext */ if (bio_data_dir(dmreq->ctx->bio_in) != WRITE) { sg = crypt_get_sg_data(cc, dmreq->sg_in); - src = kmap_atomic(sg_page(sg)); - r = crypt_iv_tcw_whitening(cc, dmreq, src + sg->offset); - kunmap_atomic(src); + src = sg_map(sg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(src)) + return PTR_ERR(src); + + r = crypt_iv_tcw_whitening(cc, dmreq, src); + sg_unmap(sg, src, 0, SG_KMAP_ATOMIC); }

/* Calculate IV */ @@ -812,9 +822,12 @@ static int crypt_iv_tcw_post(struct crypt_config *cc, u8 *iv,

/* Apply whitening on ciphertext */ sg = crypt_get_sg_data(cc, dmreq->sg_out); - dst = kmap_atomic(sg_page(sg)); - r = crypt_iv_tcw_whitening(cc, dmreq, dst + sg->offset); - kunmap_atomic(dst); + dst = sg_map(sg, 0, SG_KMAP_ATOMIC); + if (IS_ERR(dst)) + return PTR_ERR(dst); + + r = crypt_iv_tcw_whitening(cc, dmreq, dst); + sg_unmap(sg, dst, 0, SG_KMAP_ATOMIC);

return r; }

Straightforward conversion except there's no error path, so we make use of SG_MAP_MUST_NOT_FAIL which may BUG_ON in certain cases in the future.

Signed-off-by: Logan Gunthorpe logang@deltatee.com Cc: Santosh Shilimkar santosh.shilimkar@oracle.com Cc: "David S. Miller" davem@davemloft.net --- net/rds/ib_recv.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c index e10624a..c665689 100644 --- a/net/rds/ib_recv.c +++ b/net/rds/ib_recv.c @@ -800,10 +800,10 @@ static void rds_ib_cong_recv(struct rds_connection *conn,

to_copy = min(RDS_FRAG_SIZE - frag_off, PAGE_SIZE - map_off); BUG_ON(to_copy & 7); /* Must be 64bit aligned. */ + addr = sg_map(&frag->f_sg, 0, + SG_KMAP_ATOMIC | SG_MAP_MUST_NOT_FAIL);

- addr = kmap_atomic(sg_page(&frag->f_sg)); - - src = addr + frag->f_sg.offset + frag_off; + src = addr + frag_off; dst = (void *)map->m_page_addrs[map_page] + map_off; for (k = 0; k < to_copy; k += 8) { /* Record ports that became uncongested, ie @@ -811,7 +811,7 @@ static void rds_ib_cong_recv(struct rds_connection *conn, uncongested |= ~(*src) & *dst; *dst++ = *src++; } - kunmap_atomic(addr); + sg_unmap(&frag->f_sg, addr, 0, SG_KMAP_ATOMIC);

copied += to_copy;

Very straightforward conversion of three scsi drivers.

Signed-off-by: Logan Gunthorpe logang@deltatee.com Cc: Achim Leubner achim_leubner@adaptec.com Cc: John Garry john.garry@huawei.com --- drivers/scsi/gdth.c | 9 +++++++-- drivers/scsi/hisi_sas/hisi_sas_v1_hw.c | 14 +++++++++----- drivers/scsi/hisi_sas/hisi_sas_v2_hw.c | 13 +++++++++---- drivers/scsi/mvsas/mv_sas.c | 10 +++++----- 4 files changed, 30 insertions(+), 16 deletions(-)

diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c index d020a13..c70248a2 100644 --- a/drivers/scsi/gdth.c +++ b/drivers/scsi/gdth.c @@ -2301,10 +2301,15 @@ static void gdth_copy_internal_data(gdth_ha_str *ha, Scsi_Cmnd *scp, return; } local_irq_save(flags); - address = kmap_atomic(sg_page(sl)) + sl->offset; + address = sg_map(sl, 0, SG_KMAP_ATOMIC); + if (IS_ERR(address)) { + scp->result = DID_ERROR << 16; + return; + } + memcpy(address, buffer, cpnow); flush_dcache_page(sg_page(sl)); - kunmap_atomic(address); + sg_unmap(sl, address, 0, SG_KMAP_ATOMIC); local_irq_restore(flags); if (cpsum == cpcount) break; diff --git a/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c index fc1c1b2..b3953e3 100644 --- a/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c +++ b/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c @@ -1381,18 +1381,22 @@ static int slot_complete_v1_hw(struct hisi_hba *hisi_hba, void *to; struct scatterlist *sg_resp = &task->smp_task.smp_resp;

- ts->stat = SAM_STAT_GOOD; - to = kmap_atomic(sg_page(sg_resp)); + to = sg_map(sg_resp, 0, SG_KMAP_ATOMIC); + if (IS_ERR(to)) { + dev_err(dev, "slot complete: error mapping memory"); + ts->stat = SAS_SG_ERR; + break; + }

+ ts->stat = SAM_STAT_GOOD; dma_unmap_sg(dev, &task->smp_task.smp_resp, 1, DMA_FROM_DEVICE); dma_unmap_sg(dev, &task->smp_task.smp_req, 1, DMA_TO_DEVICE); - memcpy(to + sg_resp->offset, - slot->status_buffer + + memcpy(to, slot->status_buffer + sizeof(struct hisi_sas_err_record), sg_dma_len(sg_resp)); - kunmap_atomic(to); + sg_unmap(sg_resp, to, 0, SG_KMAP_ATOMIC); break; } case SAS_PROTOCOL_SATA: diff --git a/drivers/scsi/hisi_sas/hisi_sas_v2_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v2_hw.c index e241921..3e674a4 100644 --- a/drivers/scsi/hisi_sas/hisi_sas_v2_hw.c +++ b/drivers/scsi/hisi_sas/hisi_sas_v2_hw.c @@ -2307,18 +2307,23 @@ slot_complete_v2_hw(struct hisi_hba *hisi_hba, struct hisi_sas_slot *slot) struct scatterlist *sg_resp = &task->smp_task.smp_resp; void *to;

+ to = sg_map(sg_resp, 0, SG_KMAP_ATOMIC); + if (IS_ERR(to)) { + dev_err(dev, "slot complete: error mapping memory"); + ts->stat = SAS_SG_ERR; + break; + } + ts->stat = SAM_STAT_GOOD; - to = kmap_atomic(sg_page(sg_resp));

dma_unmap_sg(dev, &task->smp_task.smp_resp, 1, DMA_FROM_DEVICE); dma_unmap_sg(dev, &task->smp_task.smp_req, 1, DMA_TO_DEVICE); - memcpy(to + sg_resp->offset, - slot->status_buffer + + memcpy(to, slot->status_buffer + sizeof(struct hisi_sas_err_record), sg_dma_len(sg_resp)); - kunmap_atomic(to); + sg_unmap(sg_resp, to, 0, SG_KMAP_ATOMIC); break; } case SAS_PROTOCOL_SATA: diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c index c7cc803..a72e0ce 100644 --- a/drivers/scsi/mvsas/mv_sas.c +++ b/drivers/scsi/mvsas/mv_sas.c @@ -1798,11 +1798,11 @@ int mvs_slot_complete(struct mvs_info *mvi, u32 rx_desc, u32 flags) case SAS_PROTOCOL_SMP: { struct scatterlist *sg_resp = &task->smp_task.smp_resp; tstat->stat = SAM_STAT_GOOD; - to = kmap_atomic(sg_page(sg_resp)); - memcpy(to + sg_resp->offset, - slot->response + sizeof(struct mvs_err_info), - sg_dma_len(sg_resp)); - kunmap_atomic(to); + to = sg_map(sg_resp, 0, SG_KMAP_ATOMIC); + memcpy(to, + slot->response + sizeof(struct mvs_err_info), + sg_dma_len(sg_resp)); + sg_unmap(sg_resp, to, 0, SG_KMAP_ATOMIC); break; }

These two drivers appear to duplicate the functionality of sg_copy_buffer. So we clean them up to use the common code.

This helps us remove a couple of instances that would otherwise be slightly tricky sg_map usages.

Signed-off-by: Logan Gunthorpe logang@deltatee.com Cc: Johannes Thumshirn jth@kernel.org --- drivers/scsi/csiostor/csio_scsi.c | 54 +++------------------------------------ drivers/scsi/libfc/fc_libfc.c | 49 ++++++++--------------------------- 2 files changed, 14 insertions(+), 89 deletions(-)

diff --git a/drivers/scsi/csiostor/csio_scsi.c b/drivers/scsi/csiostor/csio_scsi.c index a1ff75f..bd9d062 100644 --- a/drivers/scsi/csiostor/csio_scsi.c +++ b/drivers/scsi/csiostor/csio_scsi.c @@ -1489,60 +1489,14 @@ static inline uint32_t csio_scsi_copy_to_sgl(struct csio_hw *hw, struct csio_ioreq *req) { struct scsi_cmnd *scmnd = (struct scsi_cmnd *)csio_scsi_cmnd(req); - struct scatterlist *sg; - uint32_t bytes_left; - uint32_t bytes_copy; - uint32_t buf_off = 0; - uint32_t start_off = 0; - uint32_t sg_off = 0; - void *sg_addr; - void *buf_addr; struct csio_dma_buf *dma_buf; + size_t copied;

- bytes_left = scsi_bufflen(scmnd); - sg = scsi_sglist(scmnd); dma_buf = (struct csio_dma_buf *)csio_list_next(&req->gen_list); + copied = sg_copy_from_buffer(scsi_sglist(scmnd), scsi_sg_count(scmnd), + dma_buf->vaddr, scsi_bufflen(scmnd));

- /* Copy data from driver buffer to SGs of SCSI CMD */ - while (bytes_left > 0 && sg && dma_buf) { - if (buf_off >= dma_buf->len) { - buf_off = 0; - dma_buf = (struct csio_dma_buf *) - csio_list_next(dma_buf); - continue; - } - - if (start_off >= sg->length) { - start_off -= sg->length; - sg = sg_next(sg); - continue; - } - - buf_addr = dma_buf->vaddr + buf_off; - sg_off = sg->offset + start_off; - bytes_copy = min((dma_buf->len - buf_off), - sg->length - start_off); - bytes_copy = min((uint32_t)(PAGE_SIZE - (sg_off & ~PAGE_MASK)), - bytes_copy); - - sg_addr = kmap_atomic(sg_page(sg) + (sg_off >> PAGE_SHIFT)); - if (!sg_addr) { - csio_err(hw, "failed to kmap sg:%p of ioreq:%p\n", - sg, req); - break; - } - - csio_dbg(hw, "copy_to_sgl:sg_addr %p sg_off %d buf %p len %d\n", - sg_addr, sg_off, buf_addr, bytes_copy); - memcpy(sg_addr + (sg_off & ~PAGE_MASK), buf_addr, bytes_copy); - kunmap_atomic(sg_addr); - - start_off += bytes_copy; - buf_off += bytes_copy; - bytes_left -= bytes_copy; - } - - if (bytes_left > 0) + if (copied != scsi_bufflen(scmnd)) return DID_ERROR; else return DID_OK; diff --git a/drivers/scsi/libfc/fc_libfc.c b/drivers/scsi/libfc/fc_libfc.c index d623d08..ce0805a 100644 --- a/drivers/scsi/libfc/fc_libfc.c +++ b/drivers/scsi/libfc/fc_libfc.c @@ -113,45 +113,16 @@ u32 fc_copy_buffer_to_sglist(void *buf, size_t len, u32 *nents, size_t *offset, u32 *crc) { - size_t remaining = len; - u32 copy_len = 0; - - while (remaining > 0 && sg) { - size_t off, sg_bytes; - void *page_addr; - - if (*offset >= sg->length) { - /* - * Check for end and drop resources - * from the last iteration. - */ - if (!(*nents)) - break; - --(*nents); - *offset -= sg->length; - sg = sg_next(sg); - continue; - } - sg_bytes = min(remaining, sg->length - *offset); - - /* - * The scatterlist item may be bigger than PAGE_SIZE, - * but we are limited to mapping PAGE_SIZE at a time. - */ - off = *offset + sg->offset; - sg_bytes = min(sg_bytes, - (size_t)(PAGE_SIZE - (off & ~PAGE_MASK))); - page_addr = kmap_atomic(sg_page(sg) + (off >> PAGE_SHIFT)); - if (crc) - *crc = crc32(*crc, buf, sg_bytes); - memcpy((char *)page_addr + (off & ~PAGE_MASK), buf, sg_bytes); - kunmap_atomic(page_addr); - buf += sg_bytes; - *offset += sg_bytes; - remaining -= sg_bytes; - copy_len += sg_bytes; - } - return copy_len; + size_t copied; + + copied = sg_pcopy_from_buffer(sg, sg_nents(sg), + buf, len, *offset); + + *offset += copied; + if (crc) + *crc = crc32(*crc, buf, copied); + + return copied; }

/**

Straightforward conversion, except due to the lack of an error path we have to use SG_MAP_MUST_NOT_FAIL which may BUG_ON in certain cases in the future.

Signed-off-by: Logan Gunthorpe logang@deltatee.com Cc: Adrian Hunter adrian.hunter@intel.com Cc: Ulf Hansson ulf.hansson@linaro.org --- drivers/mmc/host/sdhci.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c index ecd0d43..239507f 100644 --- a/drivers/mmc/host/sdhci.c +++ b/drivers/mmc/host/sdhci.c @@ -513,15 +513,19 @@ static int sdhci_pre_dma_transfer(struct sdhci_host *host, return sg_count; }

+/* + * Note this function may return PTR_ERR and must be checked. + */ static char *sdhci_kmap_atomic(struct scatterlist *sg, unsigned long *flags) { local_irq_save(*flags); - return kmap_atomic(sg_page(sg)) + sg->offset; + return sg_map(sg, 0, SG_KMAP_ATOMIC | SG_MAP_MUST_NOT_FAIL); }

-static void sdhci_kunmap_atomic(void *buffer, unsigned long *flags) +static void sdhci_kunmap_atomic(struct scatterlist *sg, void *buffer, + unsigned long *flags) { - kunmap_atomic(buffer); + sg_unmap(sg, buffer, 0, SG_KMAP_ATOMIC); local_irq_restore(*flags); }

@@ -585,7 +589,7 @@ static void sdhci_adma_table_pre(struct sdhci_host *host, if (data->flags & MMC_DATA_WRITE) { buffer = sdhci_kmap_atomic(sg, &flags); memcpy(align, buffer, offset); - sdhci_kunmap_atomic(buffer, &flags); + sdhci_kunmap_atomic(sg, buffer, &flags); }

/* tran, valid */ @@ -663,7 +667,7 @@ static void sdhci_adma_table_post(struct sdhci_host *host,

buffer = sdhci_kmap_atomic(sg, &flags); memcpy(buffer, align, size); - sdhci_kunmap_atomic(buffer, &flags); + sdhci_kunmap_atomic(sg, buffer, &flags);

align += SDHCI_ADMA2_ALIGN; }

Straightforward conversion to sg_map helper. Seeing there is no cleare error path, SG_MAP_MUST_NOT_FAIL which may BUG_ON in certain cases in the future.

Signed-off-by: Logan Gunthorpe logang@deltatee.com Cc: Wolfram Sang wsa+renesas@sang-engineering.com Cc: Ulf Hansson ulf.hansson@linaro.org --- drivers/mmc/host/tmio_mmc.h | 7 +++++-- drivers/mmc/host/tmio_mmc_pio.c | 12 ++++++++++++ 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/drivers/mmc/host/tmio_mmc.h b/drivers/mmc/host/tmio_mmc.h index d0edb57..bc43eb0 100644 --- a/drivers/mmc/host/tmio_mmc.h +++ b/drivers/mmc/host/tmio_mmc.h @@ -202,17 +202,20 @@ void tmio_mmc_enable_mmc_irqs(struct tmio_mmc_host *host, u32 i); void tmio_mmc_disable_mmc_irqs(struct tmio_mmc_host *host, u32 i); irqreturn_t tmio_mmc_irq(int irq, void *devid);

+/* Note: this function may return PTR_ERR and must be checked! */ static inline char *tmio_mmc_kmap_atomic(struct scatterlist *sg, unsigned long *flags) { + void *ret; + local_irq_save(*flags); - return kmap_atomic(sg_page(sg)) + sg->offset; + return sg_map(sg, 0, SG_KMAP_ATOMIC | SG_MAP_MUST_NOT_FAIL); }

static inline void tmio_mmc_kunmap_atomic(struct scatterlist *sg, unsigned long *flags, void *virt) { - kunmap_atomic(virt - sg->offset); + sg_unmap(sg, virt, 0, SG_KMAP_ATOMIC); local_irq_restore(*flags); }

diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c index a2d92f1..bbb4f19 100644 --- a/drivers/mmc/host/tmio_mmc_pio.c +++ b/drivers/mmc/host/tmio_mmc_pio.c @@ -506,6 +506,18 @@ static void tmio_mmc_check_bounce_buffer(struct tmio_mmc_host *host) if (host->sg_ptr == &host->bounce_sg) { unsigned long flags; void *sg_vaddr = tmio_mmc_kmap_atomic(host->sg_orig, &flags); + if (IS_ERR(sg_vaddr)) { + /* + * This should really never happen unless + * the code is changed to use memory that is + * not mappable in the sg. Seeing there doesn't + * seem to be any error path out of here, + * we can only WARN. + */ + WARN(1, "Non-mappable memory used in sg!"); + return; + } + memcpy(sg_vaddr, host->bounce_buf, host->bounce_sg.length); tmio_mmc_kunmap_atomic(host->sg_orig, &flags, sg_vaddr); }

This conversion is a bit complicated. We modiy the read_fifo, write_fifo and copy_page functions to take a scatterlist instead of a page. Thus we can use sg_map instead of kmap_atomic. There's a bit of accounting that needed to be done for the offset for this to work. (Seeing sg_map takes care of the offset but it's already added and used earlier in the code.)

There's also no error path, so we use SG_MAP_MUST_NOT_FAIL which may BUG_ON in certain cases in the future.

Signed-off-by: Logan Gunthorpe logang@deltatee.com Cc: Alex Dubov oakad@yahoo.com Cc: Ulf Hansson ulf.hansson@linaro.org --- drivers/mmc/host/tifm_sd.c | 50 +++++++++++++++++++++++++++------------------- 1 file changed, 29 insertions(+), 21 deletions(-)

diff --git a/drivers/mmc/host/tifm_sd.c b/drivers/mmc/host/tifm_sd.c index 93c4b40..e64345a 100644 --- a/drivers/mmc/host/tifm_sd.c +++ b/drivers/mmc/host/tifm_sd.c @@ -111,14 +111,16 @@ struct tifm_sd { };

/* for some reason, host won't respond correctly to readw/writew */ -static void tifm_sd_read_fifo(struct tifm_sd *host, struct page *pg, +static void tifm_sd_read_fifo(struct tifm_sd *host, struct scatterlist *sg, unsigned int off, unsigned int cnt) { struct tifm_dev *sock = host->dev; unsigned char *buf; unsigned int pos = 0, val;

- buf = kmap_atomic(pg) + off; + buf = sg_map(sg, off - sg->offset, + SG_KMAP_ATOMIC | SG_MAP_MUST_NOT_FAIL); + if (host->cmd_flags & DATA_CARRY) { buf[pos++] = host->bounce_buf_data[0]; host->cmd_flags &= ~DATA_CARRY; @@ -134,17 +136,19 @@ static void tifm_sd_read_fifo(struct tifm_sd *host, struct page *pg, } buf[pos++] = (val >> 8) & 0xff; } - kunmap_atomic(buf - off); + sg_unmap(sg, buf, off - sg->offset, SG_KMAP_ATOMIC); }

-static void tifm_sd_write_fifo(struct tifm_sd *host, struct page *pg, +static void tifm_sd_write_fifo(struct tifm_sd *host, struct scatterlist *sg, unsigned int off, unsigned int cnt) { struct tifm_dev *sock = host->dev; unsigned char *buf; unsigned int pos = 0, val;

- buf = kmap_atomic(pg) + off; + buf = sg_map(sg, off - sg->offset, + SG_KMAP_ATOMIC | SG_MAP_MUST_NOT_FAIL); + if (host->cmd_flags & DATA_CARRY) { val = host->bounce_buf_data[0] | ((buf[pos++] << 8) & 0xff00); writel(val, sock->addr + SOCK_MMCSD_DATA); @@ -161,7 +165,7 @@ static void tifm_sd_write_fifo(struct tifm_sd *host, struct page *pg, val |= (buf[pos++] << 8) & 0xff00; writel(val, sock->addr + SOCK_MMCSD_DATA); } - kunmap_atomic(buf - off); + sg_unmap(sg, buf, off - sg->offset, SG_KMAP_ATOMIC); }

static void tifm_sd_transfer_data(struct tifm_sd *host) @@ -170,7 +174,6 @@ static void tifm_sd_transfer_data(struct tifm_sd *host) struct scatterlist *sg = r_data->sg; unsigned int off, cnt, t_size = TIFM_MMCSD_FIFO_SIZE * 2; unsigned int p_off, p_cnt; - struct page *pg;

if (host->sg_pos == host->sg_len) return; @@ -192,33 +195,39 @@ static void tifm_sd_transfer_data(struct tifm_sd *host) } off = sg[host->sg_pos].offset + host->block_pos;

- pg = nth_page(sg_page(&sg[host->sg_pos]), off >> PAGE_SHIFT); p_off = offset_in_page(off); p_cnt = PAGE_SIZE - p_off; p_cnt = min(p_cnt, cnt); p_cnt = min(p_cnt, t_size);

if (r_data->flags & MMC_DATA_READ) - tifm_sd_read_fifo(host, pg, p_off, p_cnt); + tifm_sd_read_fifo(host, &sg[host->sg_pos], p_off, + p_cnt); else if (r_data->flags & MMC_DATA_WRITE) - tifm_sd_write_fifo(host, pg, p_off, p_cnt); + tifm_sd_write_fifo(host, &sg[host->sg_pos], p_off, + p_cnt);

t_size -= p_cnt; host->block_pos += p_cnt; } }

-static void tifm_sd_copy_page(struct page *dst, unsigned int dst_off, - struct page *src, unsigned int src_off, +static void tifm_sd_copy_page(struct scatterlist *dst, unsigned int dst_off, + struct scatterlist *src, unsigned int src_off, unsigned int count) { - unsigned char *src_buf = kmap_atomic(src) + src_off; - unsigned char *dst_buf = kmap_atomic(dst) + dst_off; + unsigned char *src_buf, *dst_buf; + + src_off -= src->offset; + dst_off -= dst->offset; + + src_buf = sg_map(src, src_off, SG_KMAP_ATOMIC | SG_MAP_MUST_NOT_FAIL); + dst_buf = sg_map(dst, dst_off, SG_KMAP_ATOMIC | SG_MAP_MUST_NOT_FAIL);

memcpy(dst_buf, src_buf, count);

- kunmap_atomic(dst_buf - dst_off); - kunmap_atomic(src_buf - src_off); + sg_unmap(dst, dst_buf, dst_off, SG_KMAP_ATOMIC); + sg_unmap(src, src_buf, src_off, SG_KMAP_ATOMIC); }

static void tifm_sd_bounce_block(struct tifm_sd *host, struct mmc_data *r_data) @@ -227,7 +236,6 @@ static void tifm_sd_bounce_block(struct tifm_sd *host, struct mmc_data *r_data) unsigned int t_size = r_data->blksz; unsigned int off, cnt; unsigned int p_off, p_cnt; - struct page *pg;

dev_dbg(&host->dev->dev, "bouncing block\n"); while (t_size) { @@ -241,18 +249,18 @@ static void tifm_sd_bounce_block(struct tifm_sd *host, struct mmc_data *r_data) } off = sg[host->sg_pos].offset + host->block_pos;

- pg = nth_page(sg_page(&sg[host->sg_pos]), off >> PAGE_SHIFT); p_off = offset_in_page(off); p_cnt = PAGE_SIZE - p_off; p_cnt = min(p_cnt, cnt); p_cnt = min(p_cnt, t_size);

if (r_data->flags & MMC_DATA_WRITE) - tifm_sd_copy_page(sg_page(&host->bounce_buf), + tifm_sd_copy_page(&host->bounce_buf, r_data->blksz - t_size, - pg, p_off, p_cnt); + &sg[host->sg_pos], p_off, p_cnt); else if (r_data->flags & MMC_DATA_READ) - tifm_sd_copy_page(pg, p_off, sg_page(&host->bounce_buf), + tifm_sd_copy_page(&sg[host->sg_pos], p_off, + &host->bounce_buf, r_data->blksz - t_size, p_cnt);

t_size -= p_cnt;