linux-imx

// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Asynchronous Cryptographic Hash operations.

 *

 * This is the asynchronous version of hash.c with notification of

 * completion via a callback.

 *

 * Copyright (c) 2008 Loc Ho <lho@amcc.com>

 */

​

#include <crypto/internal/hash.h>

#include <crypto/scatterwalk.h>

#include <linux/bug.h>

#include <linux/err.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/sched.h>

#include <linux/slab.h>

#include <linux/seq_file.h>

#include <linux/cryptouser.h>

#include <linux/compiler.h>

#include <net/netlink.h>

​

#include "internal.h"

​

struct ahash_request_priv {

    crypto_completion_t complete;

    void *data;

    u8 *result;

    u32 flags;

    void *ubuf[] CRYPTO_MINALIGN_ATTR;

};

​

static inline struct ahash_alg *crypto_ahash_alg(struct crypto_ahash *hash)

{

    return container_of(crypto_hash_alg_common(hash), struct ahash_alg,

                halg);

}

​

static int hash_walk_next(struct crypto_hash_walk *walk)

{

    unsigned int alignmask = walk->alignmask;

    unsigned int offset = walk->offset;

    unsigned int nbytes = min(walk->entrylen,

                  ((unsigned int)(PAGE_SIZE)) - offset);

​

    if (walk->flags & CRYPTO_ALG_ASYNC)

        walk->data = kmap(walk->pg);

    else

        walk->data = kmap_atomic(walk->pg);

    walk->data += offset;

​

    if (offset & alignmask) {

        unsigned int unaligned = alignmask + 1 - (offset & alignmask);

​

        if (nbytes > unaligned)

            nbytes = unaligned;

    }

​

    walk->entrylen -= nbytes;

    return nbytes;

}

​

static int hash_walk_new_entry(struct crypto_hash_walk *walk)

{

    struct scatterlist *sg;

​

    sg = walk->sg;

    walk->offset = sg->offset;

    walk->pg = sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);

    walk->offset = offset_in_page(walk->offset);

    walk->entrylen = sg->length;

​

    if (walk->entrylen > walk->total)

        walk->entrylen = walk->total;

    walk->total -= walk->entrylen;

​

    return hash_walk_next(walk);

}

​

int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err)

{

    unsigned int alignmask = walk->alignmask;

​

    walk->data -= walk->offset;

​

    if (walk->entrylen && (walk->offset & alignmask) && !err) {

        unsigned int nbytes;

​

        walk->offset = ALIGN(walk->offset, alignmask + 1);

        nbytes = min(walk->entrylen,

                 (unsigned int)(PAGE_SIZE - walk->offset));