crypto: acomp - Simplify folio handling

+2 -40

crypto/acompress.c

··· 33 33 enum { 34 34 ACOMP_WALK_SLEEP = 1 << 0, 35 35 ACOMP_WALK_SRC_LINEAR = 1 << 1, 36 - ACOMP_WALK_SRC_FOLIO = 1 << 2, 37 - ACOMP_WALK_DST_LINEAR = 1 << 3, 38 - ACOMP_WALK_DST_FOLIO = 1 << 4, 36 + ACOMP_WALK_DST_LINEAR = 1 << 2, 39 37 }; 40 38 41 39 static const struct crypto_type crypto_acomp_type; ··· 193 195 194 196 if (state->flags & CRYPTO_ACOMP_REQ_SRC_VIRT) 195 197 acomp_request_set_src_dma(req, state->src, slen); 196 - else if (state->flags & CRYPTO_ACOMP_REQ_SRC_FOLIO) 197 - acomp_request_set_src_folio(req, state->sfolio, req->soff, slen); 198 198 if (state->flags & CRYPTO_ACOMP_REQ_DST_VIRT) 199 199 acomp_request_set_dst_dma(req, state->dst, dlen); 200 - else if (state->flags & CRYPTO_ACOMP_REQ_DST_FOLIO) 201 - acomp_request_set_dst_folio(req, state->dfolio, req->doff, dlen); 202 200 } 203 201 204 202 static void acomp_virt_to_sg(struct acomp_req *req) ··· 202 208 struct acomp_req_chain *state = &req->chain; 203 209 204 210 state->flags = req->base.flags & (CRYPTO_ACOMP_REQ_SRC_VIRT | 205 - CRYPTO_ACOMP_REQ_DST_VIRT | 206 - CRYPTO_ACOMP_REQ_SRC_FOLIO | 207 - CRYPTO_ACOMP_REQ_DST_FOLIO); 211 + CRYPTO_ACOMP_REQ_DST_VIRT); 208 212 209 213 if (acomp_request_src_isvirt(req)) { 210 214 unsigned int slen = req->slen; ··· 210 218 211 219 state->src = svirt; 212 220 sg_init_one(&state->ssg, svirt, slen); 213 - acomp_request_set_src_sg(req, &state->ssg, slen); 214 - } else if (acomp_request_src_isfolio(req)) { 215 - struct folio *folio = req->sfolio; 216 - unsigned int slen = req->slen; 217 - size_t off = req->soff; 218 - 219 - state->sfolio = folio; 220 - sg_init_table(&state->ssg, 1); 221 - sg_set_page(&state->ssg, folio_page(folio, off / PAGE_SIZE), 222 - slen, off % PAGE_SIZE); 223 221 acomp_request_set_src_sg(req, &state->ssg, slen); 224 222 } 225 223 ··· 220 238 state->dst = dvirt; 221 239 sg_init_one(&state->dsg, dvirt, dlen); 222 240 acomp_request_set_dst_sg(req, &state->dsg, dlen); 223 - } else if (acomp_request_dst_isfolio(req)) { 224 - struct folio *folio = req->dfolio; 225 - unsigned int dlen = req->dlen; 226 - size_t off = req->doff; 227 - 228 - state->dfolio = folio; 229 - sg_init_table(&state->dsg, 1); 230 - sg_set_page(&state->dsg, folio_page(folio, off / PAGE_SIZE), 231 - dlen, off % PAGE_SIZE); 232 - acomp_request_set_src_sg(req, &state->dsg, dlen); 233 241 } 234 242 } 235 243 ··· 551 579 walk->flags |= ACOMP_WALK_SLEEP; 552 580 if ((req->base.flags & CRYPTO_ACOMP_REQ_SRC_VIRT)) 553 581 walk->flags |= ACOMP_WALK_SRC_LINEAR; 554 - else if ((req->base.flags & CRYPTO_ACOMP_REQ_SRC_FOLIO)) { 555 - src = &req->chain.ssg; 556 - sg_init_table(src, 1); 557 - sg_set_folio(src, req->sfolio, walk->slen, req->soff); 558 - } 559 582 if ((req->base.flags & CRYPTO_ACOMP_REQ_DST_VIRT)) 560 583 walk->flags |= ACOMP_WALK_DST_LINEAR; 561 - else if ((req->base.flags & CRYPTO_ACOMP_REQ_DST_FOLIO)) { 562 - dst = &req->chain.dsg; 563 - sg_init_table(dst, 1); 564 - sg_set_folio(dst, req->dfolio, walk->dlen, req->doff); 565 - } 566 584 567 585 if ((walk->flags & ACOMP_WALK_SRC_LINEAR)) { 568 586 walk->in.sg = (void *)req->svirt;

+2 -8

crypto/scompress.c

··· 193 193 if (dst_isvirt) 194 194 dst = req->dvirt; 195 195 else { 196 - if (acomp_request_dst_isfolio(req)) { 197 - dpage = folio_page(req->dfolio, 0); 198 - doff = req->doff; 199 - } else if (dlen <= req->dst->length) { 196 + if (dlen <= req->dst->length) { 200 197 dpage = sg_page(req->dst); 201 198 doff = req->dst->offset; 202 199 } else ··· 215 218 else { 216 219 src = NULL; 217 220 do { 218 - if (acomp_request_src_isfolio(req)) { 219 - spage = folio_page(req->sfolio, 0); 220 - soff = req->soff; 221 - } else if (slen <= req->src->length) { 221 + if (slen <= req->src->length) { 222 222 spage = sg_page(req->src); 223 223 soff = req->src->offset; 224 224 } else

+7 -38

include/crypto/acompress.h

··· 32 32 /* Set this bit for if virtual address destination cannot be used for DMA. */ 33 33 #define CRYPTO_ACOMP_REQ_DST_NONDMA 0x00000010 34 34 35 - /* Set this bit if source is a folio. */ 36 - #define CRYPTO_ACOMP_REQ_SRC_FOLIO 0x00000020 37 - 38 - /* Set this bit if destination is a folio. */ 39 - #define CRYPTO_ACOMP_REQ_DST_FOLIO 0x00000040 40 - 41 35 /* Private flags that should not be touched by the user. */ 42 36 #define CRYPTO_ACOMP_REQ_PRIVATE \ 43 37 (CRYPTO_ACOMP_REQ_SRC_VIRT | CRYPTO_ACOMP_REQ_SRC_NONDMA | \ 44 - CRYPTO_ACOMP_REQ_DST_VIRT | CRYPTO_ACOMP_REQ_DST_NONDMA | \ 45 - CRYPTO_ACOMP_REQ_SRC_FOLIO | CRYPTO_ACOMP_REQ_DST_FOLIO) 38 + CRYPTO_ACOMP_REQ_DST_VIRT | CRYPTO_ACOMP_REQ_DST_NONDMA) 46 39 47 40 #define CRYPTO_ACOMP_DST_MAX 131072 48 41 ··· 77 84 * @dst: Destination scatterlist 78 85 * @svirt: Source virtual address 79 86 * @dvirt: Destination virtual address 80 - * @sfolio: Source folio 81 - * @soff: Source folio offset 82 - * @dfolio: Destination folio 83 - * @doff: Destination folio offset 84 87 * @slen: Size of the input buffer 85 88 * @dlen: Size of the output buffer and number of bytes produced 86 89 * @chain: Private API code data, do not use ··· 87 98 union { 88 99 struct scatterlist *src; 89 100 const u8 *svirt; 90 - struct folio *sfolio; 91 101 }; 92 102 union { 93 103 struct scatterlist *dst; 94 104 u8 *dvirt; 95 - struct folio *dfolio; 96 105 }; 97 - size_t soff; 98 - size_t doff; 99 106 unsigned int slen; 100 107 unsigned int dlen; 101 108 ··· 358 373 359 374 req->base.flags &= ~(CRYPTO_ACOMP_REQ_SRC_VIRT | 360 375 CRYPTO_ACOMP_REQ_SRC_NONDMA | 361 - CRYPTO_ACOMP_REQ_SRC_FOLIO | 362 - CRYPTO_ACOMP_REQ_DST_FOLIO | 363 376 CRYPTO_ACOMP_REQ_DST_VIRT | 364 377 CRYPTO_ACOMP_REQ_DST_NONDMA); 365 378 } ··· 380 397 381 398 req->base.flags &= ~CRYPTO_ACOMP_REQ_SRC_NONDMA; 382 399 req->base.flags &= ~CRYPTO_ACOMP_REQ_SRC_VIRT; 383 - req->base.flags &= ~CRYPTO_ACOMP_REQ_SRC_FOLIO; 384 400 } 385 401 386 402 /** ··· 399 417 req->slen = slen; 400 418 401 419 req->base.flags &= ~CRYPTO_ACOMP_REQ_SRC_NONDMA; 402 - req->base.flags &= ~CRYPTO_ACOMP_REQ_SRC_FOLIO; 403 420 req->base.flags |= CRYPTO_ACOMP_REQ_SRC_VIRT; 404 421 } 405 422 ··· 419 438 req->svirt = src; 420 439 req->slen = slen; 421 440 422 - req->base.flags &= ~CRYPTO_ACOMP_REQ_SRC_FOLIO; 423 441 req->base.flags |= CRYPTO_ACOMP_REQ_SRC_NONDMA; 424 442 req->base.flags |= CRYPTO_ACOMP_REQ_SRC_VIRT; 425 443 } ··· 437 457 struct folio *folio, size_t off, 438 458 unsigned int len) 439 459 { 440 - req->sfolio = folio; 441 - req->soff = off; 442 - req->slen = len; 443 - 444 - req->base.flags &= ~CRYPTO_ACOMP_REQ_SRC_NONDMA; 445 - req->base.flags &= ~CRYPTO_ACOMP_REQ_SRC_VIRT; 446 - req->base.flags |= CRYPTO_ACOMP_REQ_SRC_FOLIO; 460 + sg_init_table(&req->chain.ssg, 1); 461 + sg_set_folio(&req->chain.ssg, folio, len, off); 462 + acomp_request_set_src_sg(req, &req->chain.ssg, len); 447 463 } 448 464 449 465 /** ··· 460 484 461 485 req->base.flags &= ~CRYPTO_ACOMP_REQ_DST_NONDMA; 462 486 req->base.flags &= ~CRYPTO_ACOMP_REQ_DST_VIRT; 463 - req->base.flags &= ~CRYPTO_ACOMP_REQ_DST_FOLIO; 464 487 } 465 488 466 489 /** ··· 479 504 req->dlen = dlen; 480 505 481 506 req->base.flags &= ~CRYPTO_ACOMP_REQ_DST_NONDMA; 482 - req->base.flags &= ~CRYPTO_ACOMP_REQ_DST_FOLIO; 483 507 req->base.flags |= CRYPTO_ACOMP_REQ_DST_VIRT; 484 508 } 485 509 ··· 498 524 req->dvirt = dst; 499 525 req->dlen = dlen; 500 526 501 - req->base.flags &= ~CRYPTO_ACOMP_REQ_DST_FOLIO; 502 527 req->base.flags |= CRYPTO_ACOMP_REQ_DST_NONDMA; 503 528 req->base.flags |= CRYPTO_ACOMP_REQ_DST_VIRT; 504 529 } ··· 516 543 struct folio *folio, size_t off, 517 544 unsigned int len) 518 545 { 519 - req->dfolio = folio; 520 - req->doff = off; 521 - req->dlen = len; 522 - 523 - req->base.flags &= ~CRYPTO_ACOMP_REQ_DST_NONDMA; 524 - req->base.flags &= ~CRYPTO_ACOMP_REQ_DST_VIRT; 525 - req->base.flags |= CRYPTO_ACOMP_REQ_DST_FOLIO; 546 + sg_init_table(&req->chain.dsg, 1); 547 + sg_set_folio(&req->chain.dsg, folio, len, off); 548 + acomp_request_set_dst_sg(req, &req->chain.dsg, len); 526 549 } 527 550 528 551 /**

+1 -15

include/crypto/internal/acompress.h

··· 154 154 static inline bool acomp_request_issg(struct acomp_req *req) 155 155 { 156 156 return !(req->base.flags & (CRYPTO_ACOMP_REQ_SRC_VIRT | 157 - CRYPTO_ACOMP_REQ_DST_VIRT | 158 - CRYPTO_ACOMP_REQ_SRC_FOLIO | 159 - CRYPTO_ACOMP_REQ_DST_FOLIO)); 157 + CRYPTO_ACOMP_REQ_DST_VIRT)); 160 158 } 161 159 162 160 static inline bool acomp_request_src_isvirt(struct acomp_req *req) ··· 187 189 { 188 190 return req->base.flags & (CRYPTO_ACOMP_REQ_SRC_NONDMA | 189 191 CRYPTO_ACOMP_REQ_DST_NONDMA); 190 - } 191 - 192 - static inline bool acomp_request_src_isfolio(struct acomp_req *req) 193 - { 194 - return req->base.flags & CRYPTO_ACOMP_REQ_SRC_FOLIO; 195 - } 196 - 197 - static inline bool acomp_request_dst_isfolio(struct acomp_req *req) 198 - { 199 - return req->base.flags & CRYPTO_ACOMP_REQ_DST_FOLIO; 200 192 } 201 193 202 194 static inline bool crypto_acomp_req_chain(struct crypto_acomp *tfm) ··· 238 250 req->dst = old->dst; 239 251 req->slen = old->slen; 240 252 req->dlen = old->dlen; 241 - req->soff = old->soff; 242 - req->doff = old->doff; 243 253 244 254 return req; 245 255 }