crypto/hctr2.c

164

sg_miter_start(&miter, sgl, sg_nents(sgl),

crypto/krb5/rfc3961_simplified.c

90

sg_miter_start(&miter, sg, sg_nents(sg),

drivers/base/devcoredump.c

315

return sg_pcopy_to_buffer(table, sg_nents(table), buffer, buf_len,

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

108

sg_miter_start(&mo, areq->dst, sg_nents(areq->dst),

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

272

sg_miter_start(&mi, areq->src, sg_nents(areq->src),

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

326

sg_miter_start(&mo, areq->dst, sg_nents(areq->dst),

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

80

sg_miter_start(&mi, areq->src, sg_nents(areq->src),

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-hash.c

220

copied = sg_pcopy_to_buffer(areq->src, sg_nents(areq->src),

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-hash.c

272

sg_miter_start(&mi, areq->src, sg_nents(areq->src),

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-hash.c

365

if (sg_nents(areq->src) > MAX_SG - 1) {

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-hash.c

526

nr_sgs = dma_map_sg(ss->dev, areq->src, sg_nents(areq->src), DMA_TO_DEVICE);

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-hash.c

691

dma_unmap_sg(ss->dev, areq->src, sg_nents(areq->src),

drivers/crypto/amlogic/amlogic-gxl-cipher.c

178

nr_sgs = dma_map_sg(mc->dev, areq->src, sg_nents(areq->src),

drivers/crypto/amlogic/amlogic-gxl-cipher.c

187

nr_sgs = dma_map_sg(mc->dev, areq->src, sg_nents(areq->src),

drivers/crypto/amlogic/amlogic-gxl-cipher.c

194

nr_sgd = dma_map_sg(mc->dev, areq->dst, sg_nents(areq->dst),

drivers/crypto/amlogic/amlogic-gxl-cipher.c

239

dma_unmap_sg(mc->dev, areq->src, sg_nents(areq->src), DMA_BIDIRECTIONAL);

drivers/crypto/amlogic/amlogic-gxl-cipher.c

241

dma_unmap_sg(mc->dev, areq->src, sg_nents(areq->src), DMA_TO_DEVICE);

drivers/crypto/amlogic/amlogic-gxl-cipher.c

242

dma_unmap_sg(mc->dev, areq->dst, sg_nents(areq->dst), DMA_FROM_DEVICE);

drivers/crypto/amlogic/amlogic-gxl-cipher.c

33

if (sg_nents(src_sg) != sg_nents(dst_sg))

drivers/crypto/amlogic/amlogic-gxl-cipher.c

37

if (sg_nents(src_sg) > MAXDESC - 3 || sg_nents(dst_sg) > MAXDESC - 3)

drivers/crypto/aspeed/aspeed-hace-crypto.c

380

rctx->dst_nents = sg_nents(req->dst);

drivers/crypto/aspeed/aspeed-hace-crypto.c

381

rctx->src_nents = sg_nents(req->src);

drivers/crypto/atmel-aes.c

1398

sg_copy_to_buffer(req->src, sg_nents(req->src), dd->buf, req->assoclen);

drivers/crypto/atmel-aes.c

610

if (!sg_copy_from_buffer(dd->real_dst, sg_nents(dd->real_dst),

drivers/crypto/atmel-aes.c

631

sg_copy_to_buffer(src, sg_nents(src), dd->buf, len);

drivers/crypto/atmel-aes.c

722

sg_copy_to_buffer(src, sg_nents(src), dd->buf, len);

drivers/crypto/atmel-aes.c

785

sg_copy_from_buffer(dd->real_dst, sg_nents(dd->real_dst),

drivers/crypto/axis/artpec6_crypto.c

1439

sg_pcopy_to_buffer(areq->src, sg_nents(areq->src),

drivers/crypto/axis/artpec6_crypto.c

2198

sg_nents(areq->src),

drivers/crypto/bcm/cipher.c

2100

nents = sg_nents(req->src);

drivers/crypto/bcm/cipher.c

2194

nents = sg_nents(req->src);

drivers/crypto/bcm/util.c

106

sg_nents++;

drivers/crypto/bcm/util.c

111

return sg_nents;

drivers/crypto/bcm/util.c

54

unsigned int nents = sg_nents(src);

drivers/crypto/bcm/util.c

73

unsigned int nents = sg_nents(dest);

drivers/crypto/bcm/util.c

96

int sg_nents = 0;

drivers/crypto/caam/desc_constr.h

79

static inline int pad_sg_nents(int sg_nents)

drivers/crypto/caam/desc_constr.h

81

return ALIGN(sg_nents, 4);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

165

nents = dma_map_sg(dev, req->src, sg_nents(req->src),

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

182

dma_unmap_sg(dev, req->src, sg_nents(req->src), DMA_BIDIRECTIONAL);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

193

nents = dma_map_sg(dev, req->dst, sg_nents(req->dst),

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

207

dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_BIDIRECTIONAL);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

61

dma_unmap_sg(dev, sr->in.sg, sg_nents(sr->in.sg),

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

69

dma_unmap_sg(dev, sr->out.sg, sg_nents(sr->out.sg),

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

211

int nents = sg_nents(skreq->src) + 1;

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

229

int nents = sg_nents(skreq->dst) + 3;

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

107

sg_count = (nbytes) ? sg_nents(req->src) + 2 : 2;

drivers/crypto/ccp/ccp-crypto-sha.c

104

sg_count = sg_nents(req->src) + 1;

drivers/crypto/ccree/cc_aead.c

235

sg_zero_buffer(areq->dst, sg_nents(areq->dst),

drivers/crypto/ccree/cc_buffer_mgr.c

1238

int sg_nents;

drivers/crypto/ccree/cc_buffer_mgr.c

1252

sg_nents = sg_nents_for_len(src, nbytes);

drivers/crypto/ccree/cc_buffer_mgr.c

1253

if (sg_nents < 0)

drivers/crypto/ccree/cc_buffer_mgr.c

1254

return sg_nents;

drivers/crypto/ccree/cc_buffer_mgr.c

1255

areq_ctx->in_nents = sg_nents;

drivers/crypto/chelsio/chcr_algo.c

1647

sg_pcopy_to_buffer(req->src, sg_nents(req->src), req_ctx->reqbfr

drivers/crypto/chelsio/chcr_algo.c

1698

sg_pcopy_to_buffer(req->src, sg_nents(req->src),

drivers/crypto/chelsio/chcr_algo.c

184

sg_pcopy_to_buffer(req->src, sg_nents(req->src), temp,

drivers/crypto/chelsio/chcr_algo.c

2605

sg_pcopy_to_buffer(req->src, sg_nents(req->src),

drivers/crypto/chelsio/chcr_algo.c

2651

sg_pcopy_to_buffer(req->src, sg_nents(req->src),

drivers/crypto/chelsio/chcr_algo.c

2700

sg_nents(reqctx->hctx_wr.srcsg), buf,

drivers/crypto/chelsio/chcr_algo.c

2723

error = dma_map_sg(dev, req->src, sg_nents(req->src),

drivers/crypto/chelsio/chcr_algo.c

2739

dma_unmap_sg(dev, req->src, sg_nents(req->src),

drivers/crypto/chelsio/chcr_algo.c

2751

error = dma_map_sg(dev, req->src, sg_nents(req->src),

drivers/crypto/chelsio/chcr_algo.c

2756

error = dma_map_sg(dev, req->src, sg_nents(req->src),

drivers/crypto/chelsio/chcr_algo.c

2760

error = dma_map_sg(dev, req->dst, sg_nents(req->dst),

drivers/crypto/chelsio/chcr_algo.c

2763

dma_unmap_sg(dev, req->src, sg_nents(req->src),

drivers/crypto/chelsio/chcr_algo.c

2778

dma_unmap_sg(dev, req->src, sg_nents(req->src),

drivers/crypto/chelsio/chcr_algo.c

2781

dma_unmap_sg(dev, req->src, sg_nents(req->src),

drivers/crypto/chelsio/chcr_algo.c

2783

dma_unmap_sg(dev, req->dst, sg_nents(req->dst),

drivers/crypto/chelsio/chcr_algo.c

861

sg_nents(wrparam->req->src), wrparam->req->iv, 16,

drivers/crypto/gemini/sl3516-ce-cipher.c

154

nr_sgs = dma_map_sg(ce->dev, areq->src, sg_nents(areq->src),

drivers/crypto/gemini/sl3516-ce-cipher.c

163

nr_sgs = dma_map_sg(ce->dev, areq->src, sg_nents(areq->src),

drivers/crypto/gemini/sl3516-ce-cipher.c

170

nr_sgd = dma_map_sg(ce->dev, areq->dst, sg_nents(areq->dst),

drivers/crypto/gemini/sl3516-ce-cipher.c

251

dma_unmap_sg(ce->dev, areq->src, sg_nents(areq->src),

drivers/crypto/gemini/sl3516-ce-cipher.c

254

dma_unmap_sg(ce->dev, areq->src, sg_nents(areq->src),

drivers/crypto/gemini/sl3516-ce-cipher.c

256

dma_unmap_sg(ce->dev, areq->dst, sg_nents(areq->dst),

drivers/crypto/gemini/sl3516-ce-cipher.c

43

if (sg_nents(areq->src) > MAXDESC / 2) {

drivers/crypto/gemini/sl3516-ce-cipher.c

48

if (sg_nents(areq->dst) > MAXDESC) {

drivers/crypto/hisilicon/sec/sec_algs.c

460

sg_nents(sec_req_el->sgl_out),

drivers/crypto/hisilicon/sec/sec_algs.c

467

sg_nents(sec_req_el->sgl_in),

drivers/crypto/hisilicon/sec/sec_algs.c

730

sec_req->len_in = sg_nents(skreq->src);

drivers/crypto/hisilicon/sec/sec_algs.c

744

sec_req->len_out = sg_nents(skreq->dst);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1029

pbuf_length = sg_copy_from_buffer(dst, sg_nents(dst), buf->pbuf, copy_size);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1031

pbuf_length = sg_copy_from_buffer(dst, sg_nents(dst), qp_ctx->res[req_id].pbuf,

drivers/crypto/hisilicon/sec2/sec_crypto.c

1052

copy_size = sg_pcopy_to_buffer(sgl, sg_nents(sgl), mac_out, authsize, skip_size);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1075

sg_n = sg_nents(src);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1108

dma_unmap_sg(dev, src, sg_nents(src), dma_dir);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1663

sz = sg_pcopy_to_buffer(sgl, sg_nents(sgl), iv, iv_size,

drivers/crypto/hisilicon/sec2/sec_crypto.c

1933

sz = sg_pcopy_from_buffer(a_req->dst, sg_nents(a_req->dst), req->aead_req.out_mac,

drivers/crypto/hisilicon/sec2/sec_crypto.c

986

pbuf_length = sg_copy_to_buffer(src, sg_nents(src), pbuf, copy_size);

drivers/crypto/hisilicon/sgl.c

233

sg_n = sg_nents(sgl);

drivers/crypto/hisilicon/sgl.c

284

dma_unmap_sg(dev, sgl, sg_nents(sgl), dir);

drivers/crypto/img-hash.c

258

ctx->bufcnt = sg_copy_to_buffer(hdev->req->src, sg_nents(ctx->sg),

drivers/crypto/img-hash.c

676

ctx->nents = sg_nents(ctx->sg);

drivers/crypto/inside-secure/eip93/eip93-common.c

172

sg_copy_to_buffer(src, sg_nents(src), pages, len);

drivers/crypto/inside-secure/eip93/eip93-common.c

678

sg_copy_from_buffer(reqdst, sg_nents(reqdst),

drivers/crypto/inside-secure/eip93/eip93-hash.c

341

read = sg_pcopy_to_buffer(req->src, sg_nents(req->src),

drivers/crypto/inside-secure/eip93/eip93-hash.c

361

read = sg_pcopy_to_buffer(req->src, sg_nents(req->src),

drivers/crypto/inside-secure/safexcel_hash.c

339

sg_pcopy_to_buffer(areq->src, sg_nents(areq->src),

drivers/crypto/inside-secure/safexcel_hash.c

366

sg_nents(areq->src),

drivers/crypto/inside-secure/safexcel_hash.c

677

sg_pcopy_to_buffer(areq->src, sg_nents(areq->src),

drivers/crypto/intel/iaa/iaa_crypto_main.c

1091

dma_unmap_sg(dev, ctx->req->dst, sg_nents(ctx->req->dst), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1092

dma_unmap_sg(dev, ctx->req->src, sg_nents(ctx->req->src), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1097

dma_unmap_sg(dev, ctx->req->dst, sg_nents(ctx->req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1098

dma_unmap_sg(dev, ctx->req->src, sg_nents(ctx->req->src), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1229

dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1230

dma_unmap_sg(dev, req->src, sg_nents(req->src), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1232

nr_sgs = dma_map_sg(dev, req->src, sg_nents(req->src), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1245

nr_sgs = dma_map_sg(dev, req->dst, sg_nents(req->dst), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1251

dma_unmap_sg(dev, req->src, sg_nents(req->src), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1510

nr_sgs = dma_map_sg(dev, req->src, sg_nents(req->src), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1523

nr_sgs = dma_map_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1553

dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1554

dma_unmap_sg(dev, req->src, sg_nents(req->src), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1562

dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1564

dma_unmap_sg(dev, req->src, sg_nents(req->src), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1608

nr_sgs = dma_map_sg(dev, req->src, sg_nents(req->src), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1621

nr_sgs = dma_map_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1642

dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1644

dma_unmap_sg(dev, req->src, sg_nents(req->src), DMA_TO_DEVICE);

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

992

if (sg_nents(req->src) > 1 || sg_nents(req->dst) > 1)

drivers/crypto/intel/qat/qat_common/qat_bl.c

130

int n_sglout = sg_nents(sglout);

drivers/crypto/intel/qat/qat_common/qat_bl.c

200

n = sg_nents(sglout);

drivers/crypto/intel/qat/qat_common/qat_bl.c

217

n = sg_nents(sgl);

drivers/crypto/intel/qat/qat_common/qat_bl.c

62

int n = sg_nents(sgl);

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1079

status = sg_copy_to_buffer(req->src, sg_nents(req->src), ptr,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1085

status = sg_copy_from_buffer(req->dst, sg_nents(req->dst), ptr,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1116

status = sg_copy_buffer(req->src, sg_nents(req->src),

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1160

status = sg_copy_to_buffer(req->src, sg_nents(req->src), ptr,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1166

status = sg_copy_from_buffer(req->dst, sg_nents(req->dst), ptr,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1195

status = sg_copy_buffer(req->src, sg_nents(req->src),

drivers/crypto/mxs-dcp.c

323

int dst_nents = sg_nents(dst);

drivers/crypto/mxs-dcp.c

354

for_each_sg(req->src, src, sg_nents(req->src), i) {

drivers/crypto/omap-crypto.c

20

int n = sg_nents(*sg);

drivers/crypto/omap-sham.c

630

int n = sg_nents(sg);

drivers/crypto/rockchip/rk3288_crypto_ahash.c

242

ret = dma_map_sg(rkc->dev, areq->src, sg_nents(areq->src), DMA_TO_DEVICE);

drivers/crypto/rockchip/rk3288_crypto_ahash.c

257

dma_unmap_sg(rkc->dev, areq->src, sg_nents(areq->src), DMA_TO_DEVICE);

drivers/crypto/s5p-sss.c

1052

unsigned int skip = ctx->skip, n = sg_nents(sg);

drivers/crypto/sa2ul.c

1088

int sg_nents, src_nents, dst_nents;

drivers/crypto/sa2ul.c

1152

sg_nents = sg_nents_for_len(src, req->size);

drivers/crypto/sa2ul.c

1157

if (sg_nents == 1 && split_size <= req->src->length) {

drivers/crypto/sa2ul.c

1176

mapped_sg->sgt.orig_nents = sg_nents;

drivers/crypto/sahara.c

548

sg_pcopy_to_buffer(req->dst, sg_nents(req->dst), req->iv,

drivers/crypto/sahara.c

585

sg_pcopy_to_buffer(req->src, sg_nents(req->src),

drivers/crypto/starfive/jh7110-aes.c

679

sg_zero_buffer(rctx->in_sg, sg_nents(rctx->in_sg),

drivers/crypto/starfive/jh7110-aes.c

756

for_each_sg(src, tsg, sg_nents(src), i)

drivers/crypto/starfive/jh7110-aes.c

763

for_each_sg(dst, tsg, sg_nents(dst), i)

drivers/crypto/starfive/jh7110-rsa.c

262

rctx->total = sg_copy_to_buffer(rctx->in_sg, sg_nents(rctx->in_sg),

drivers/crypto/starfive/jh7110-rsa.c

278

sg_copy_buffer(rctx->out_sg, sg_nents(rctx->out_sg),

drivers/crypto/stm32/stm32-cryp.c

1432

for_each_sg(test_sg, sg, sg_nents(test_sg), i) {

drivers/crypto/virtio/virtio_crypto_akcipher_algs.c

235

sg_copy_to_buffer(req->src, sg_nents(req->src), src_buf, req->src_len);

drivers/crypto/virtio/virtio_crypto_akcipher_algs.c

92

sg_copy_from_buffer(akcipher_req->dst, sg_nents(akcipher_req->dst),

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

347

dst_nents = sg_nents(req->dst);

drivers/crypto/xilinx/zynqmp-aes-gcm.c

228

sg_copy_from_buffer(req->dst, sg_nents(req->dst),

drivers/crypto/xilinx/zynqmp-aes-gcm.c

354

sg_copy_from_buffer(req->dst, sg_nents(req->dst),

drivers/firmware/arm_ffa/driver.c

688

u32 idx, frag_len, length, buf_sz = 0, num_entries = sg_nents(args->sg);

drivers/infiniband/core/verbs.c

2772

int ib_map_mr_sg(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/core/verbs.c

2780

return mr->device->ops.map_mr_sg(mr, sg, sg_nents, sg_offset);

drivers/infiniband/core/verbs.c

2806

int ib_sg_to_pages(struct ib_mr *mr, struct scatterlist *sgl, int sg_nents,

drivers/infiniband/core/verbs.c

2816

if (unlikely(sg_nents <= 0 || sg_offset > sg_dma_len(&sgl[0])))

drivers/infiniband/core/verbs.c

2822

for_each_sg(sgl, sg, sg_nents, i) {

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4109

int bnxt_re_map_mr_sg(struct ib_mr *ib_mr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4115

return ib_sg_to_pages(ib_mr, sg, sg_nents, sg_offset, bnxt_re_set_page);

drivers/infiniband/hw/bnxt_re/ib_verbs.h

256

int bnxt_re_map_mr_sg(struct ib_mr *ib_mr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/cxgb4/iw_cxgb4.h

1004

int c4iw_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/cxgb4/mem.c

694

int c4iw_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/cxgb4/mem.c

701

return ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset, c4iw_set_page);

drivers/infiniband/hw/erdma/erdma_verbs.c

1219

int erdma_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/erdma/erdma_verbs.c

1227

num = ib_sg_to_pages(&mr->ibmr, sg, sg_nents, sg_offset,

drivers/infiniband/hw/erdma/erdma_verbs.h

472

int erdma_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/hns/hns_roce_device.h

1252

int hns_roce_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/hns/hns_roce_mr.c

445

int hns_roce_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/hns/hns_roce_mr.c

466

sg_num = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset_p, hns_roce_set_page);

drivers/infiniband/hw/ionic/ionic_controlpath.c

1087

int ionic_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/ionic/ionic_controlpath.c

1104

ibdev_dbg(&dev->ibdev, "sg %p nent %d\n", sg, sg_nents);

drivers/infiniband/hw/ionic/ionic_controlpath.c

1105

rc = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset, ionic_map_mr_page);

drivers/infiniband/hw/ionic/ionic_ibdev.h

479

int ionic_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/irdma/verbs.c

3236

int sg_nents, unsigned int *sg_offset)

drivers/infiniband/hw/irdma/verbs.c

3242

return ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset, irdma_set_page);

drivers/infiniband/hw/mlx4/mlx4_ib.h

769

int mlx4_ib_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/mlx4/mr.c

442

int mlx4_ib_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/mlx4/mr.c

453

rc = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset, mlx4_set_page);

drivers/infiniband/hw/mlx5/mlx5_ib.h

1411

int mlx5_ib_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/mlx5/mr.c

2708

unsigned short sg_nents,

drivers/infiniband/hw/mlx5/mr.c

2723

for_each_sg(sgl, sg, sg_nents, i) {

drivers/infiniband/hw/mlx5/mr.c

2954

int mlx5_ib_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/mlx5/mr.c

2967

n = mlx5_ib_sg_to_klms(mr, sg, sg_nents, sg_offset, NULL, 0,

drivers/infiniband/hw/mlx5/mr.c

2970

n = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset,

drivers/infiniband/hw/ocrdma/ocrdma_verbs.c

2963

int ocrdma_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/ocrdma/ocrdma_verbs.c

2970

return ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset, ocrdma_set_page);

drivers/infiniband/hw/ocrdma/ocrdma_verbs.h

105

int ocrdma_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/qedr/verbs.c

3205

int sg_nents, unsigned int *sg_offset)

drivers/infiniband/hw/qedr/verbs.c

3212

return ib_sg_to_pages(ibmr, sg, sg_nents, NULL, qedr_set_page);

drivers/infiniband/hw/qedr/verbs.h

86

int sg_nents, unsigned int *sg_offset);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_mr.c

318

int pvrdma_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,

drivers/infiniband/hw/vmw_pvrdma/pvrdma_mr.c

327

ret = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset, pvrdma_set_page);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_verbs.h

375

int sg_nents, unsigned int *sg_offset);

drivers/infiniband/sw/rdmavt/mr.c

594

int sg_nents, unsigned int *sg_offset)

drivers/infiniband/sw/rdmavt/mr.c

601

ret = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset, rvt_set_page);

drivers/infiniband/sw/rdmavt/mr.c

606

trace_rvt_map_mr_sg(ibmr, sg_nents, sg_offset);

drivers/infiniband/sw/rdmavt/mr.h

35

int sg_nents, unsigned int *sg_offset);

drivers/infiniband/sw/rdmavt/trace_mr.h

144

TP_PROTO(struct ib_mr *ibmr, int sg_nents, unsigned int *sg_offset),

drivers/infiniband/sw/rdmavt/trace_mr.h

145

TP_ARGS(ibmr, sg_nents, sg_offset),

drivers/infiniband/sw/rdmavt/trace_mr.h

152

__field(int, sg_nents)

drivers/infiniband/sw/rdmavt/trace_mr.h

161

__entry->sg_nents = sg_nents;

drivers/infiniband/sw/rdmavt/trace_mr.h

171

__entry->sg_nents,

drivers/infiniband/sw/rxe/rxe_loc.h

72

int sg_nents, unsigned int *sg_offset);

drivers/infiniband/sw/rxe/rxe_mr.c

288

int sg_nents, unsigned int *sg_offset)

drivers/infiniband/sw/rxe/rxe_mr.c

322

return ib_sg_to_pages(ibmr, sgl, sg_nents, sg_offset, rxe_set_page);

drivers/infiniband/ulp/isert/ib_isert.c

1049

int imm_data, imm_data_len, unsol_data, sg_nents, rc;

drivers/infiniband/ulp/isert/ib_isert.c

1076

sg_nents = max(1UL, DIV_ROUND_UP(imm_data_len, PAGE_SIZE));

drivers/infiniband/ulp/isert/ib_isert.c

1077

sg_copy_from_buffer(cmd->se_cmd.t_data_sg, sg_nents,

drivers/infiniband/ulp/isert/ib_isert.c

1080

sg_nents, imm_data_len);

drivers/infiniband/ulp/isert/ib_isert.c

1120

int rc, sg_nents, sg_off, page_off;

drivers/infiniband/ulp/isert/ib_isert.c

1143

sg_nents = max(1UL, DIV_ROUND_UP(unsol_data_len, PAGE_SIZE));

drivers/infiniband/ulp/isert/ib_isert.c

1155

sg_nents, isert_get_data(rx_desc), unsol_data_len);

drivers/infiniband/ulp/isert/ib_isert.c

1157

sg_copy_from_buffer(sg_start, sg_nents, isert_get_data(rx_desc),

drivers/infiniband/ulp/srp/ib_srp.c

1423

struct srp_rdma_ch *ch, int sg_nents,

drivers/infiniband/ulp/srp/ib_srp.c

1442

if (sg_nents == 1 && target->global_rkey) {

drivers/infiniband/ulp/srp/ib_srp.c

1460

n = ib_map_mr_sg(desc->mr, state->sg, sg_nents, sg_offset_p,

drivers/infiniband/ulp/srp/ib_srp.c

1465

dev_name(&req->scmnd->device->sdev_gendev), sg_nents,

drivers/mailbox/bcm-flexrm-mailbox.c

622

rc = dma_map_sg(dev, msg->spu.src, sg_nents(msg->spu.src),

drivers/mailbox/bcm-flexrm-mailbox.c

627

rc = dma_map_sg(dev, msg->spu.dst, sg_nents(msg->spu.dst),

drivers/mailbox/bcm-flexrm-mailbox.c

630

dma_unmap_sg(dev, msg->spu.src, sg_nents(msg->spu.src),

drivers/mailbox/bcm-flexrm-mailbox.c

640

dma_unmap_sg(dev, msg->spu.dst, sg_nents(msg->spu.dst),

drivers/mailbox/bcm-flexrm-mailbox.c

642

dma_unmap_sg(dev, msg->spu.src, sg_nents(msg->spu.src),

drivers/mailbox/bcm-pdc-mailbox.c

1205

src_nent = sg_nents(mssg->spu.src);

drivers/mailbox/bcm-pdc-mailbox.c

1212

dst_nent = sg_nents(mssg->spu.dst);

drivers/mailbox/bcm-pdc-mailbox.c

608

sg_nents(pdcs->src_sg[pdcs->txin]), DMA_TO_DEVICE);

drivers/mailbox/bcm-pdc-mailbox.c

623

dma_unmap_sg(dev, rx_ctx->dst_sg, sg_nents(rx_ctx->dst_sg),

drivers/mailbox/bcm-pdc-mailbox.c

717

num_desc = (u32)sg_nents(sg);

drivers/mailbox/bcm-pdc-mailbox.c

884

num_desc = (u32)sg_nents(sg);

drivers/memstick/core/ms_block.c

100

sg_miter_start(&miter, sg, sg_nents(sg),

drivers/memstick/core/ms_block.c

1639

sg_copy_to_buffer(sg_tmp, sg_nents(sg_tmp),

drivers/memstick/core/ms_block.c

1662

sg_copy_from_buffer(sg_tmp, sg_nents(sg_tmp),

drivers/memstick/core/ms_block.c

872

sg_miter_start(&miter, sg, sg_nents(sg),

drivers/misc/mei/bus.c

956

sg_out_nents = sg_nents(sg_out);

drivers/misc/mei/bus.c

957

sg_in_nents = sg_nents(sg_in);

drivers/mmc/host/litex_mmc.c

426

sg_copy_from_buffer(data->sg, sg_nents(data->sg),

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

2830

sg_nents(sg_dump_data),

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

2835

sg_nents(sg_dump_data),

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

2877

int sg_entries = sg_nents(sg_dump_data);

drivers/s390/scsi/zfcp_fsf.c

1162

zfcp_qdio_set_data_div(qdio, &req->qdio_req, sg_nents(sg_req));

drivers/scsi/NCR5380.c

1745

sg_nents(ncmd->buffer));

drivers/scsi/aha152x.c

2544

sg_nents(acp->buffer) - 1);

drivers/scsi/qla2xxx/qla_iocb.c

1167

sg_pcopy_to_buffer(sgl, sg_nents(sgl),

drivers/target/iscsi/cxgbit/cxgbit_target.c

1006

int rc, sg_nents, sg_off;

drivers/target/iscsi/cxgbit/cxgbit_target.c

1059

sg_nents = max(1UL, DIV_ROUND_UP(skip + data_len, PAGE_SIZE));

drivers/target/iscsi/cxgbit/cxgbit_target.c

1061

cxgbit_skb_copy_to_sg(csk->skb, sg_start, sg_nents, skip);

drivers/target/iscsi/cxgbit/cxgbit_target.c

895

u32 sg_nents = max(1UL, DIV_ROUND_UP(pdu_cb->dlen, PAGE_SIZE));

drivers/target/iscsi/cxgbit/cxgbit_target.c

897

cxgbit_skb_copy_to_sg(csk->skb, sg, sg_nents, 0);

drivers/target/target_core_user.c

704

struct scatterlist *sg, unsigned int sg_nents,

drivers/target/target_core_user.c

720

sg_miter_start(&sg_iter, sg, sg_nents, sg_flags);

drivers/usb/storage/protocol.c

131

nents = sg_nents(sg);

include/linux/devcoredump.h

34

for_each_sg(table, iter, sg_nents(table), i) {

include/linux/scatterlist.h

442

int sg_nents(struct scatterlist *sg);

include/rdma/ib_verbs.h

2588

int (*map_mr_sg)(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,

include/rdma/ib_verbs.h

4638

int ib_map_mr_sg(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,

include/rdma/ib_verbs.h

4646

ib_map_mr_sg_zbva(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,

include/rdma/ib_verbs.h

4651

n = ib_map_mr_sg(mr, sg, sg_nents, sg_offset, page_size);

include/rdma/ib_verbs.h

4657

int ib_sg_to_pages(struct ib_mr *mr, struct scatterlist *sgl, int sg_nents,

include/trace/events/rpcrdma.h

1168

int sg_nents

include/trace/events/rpcrdma.h

1171

TP_ARGS(mr, sg_nents),

include/trace/events/rpcrdma.h

1184

__entry->nents = sg_nents;

lib/crypto/chacha20poly1305.c

258

sg_miter_start(&miter, src, sg_nents(src), flags);

lib/crypto/chacha20poly1305.c

323

sg_copy_buffer(src, sg_nents(src), b.mac[encrypt],

lib/scatterlist.c

32

EXPORT_SYMBOL(sg_nents);

lib/sg_split.c

159

ret = sg_calculate_split(in, sg_nents(in), nb_splits, skip, split_sizes,

net/tls/tls_sw.c

1551

n_sgout = sg_nents(out_sg);