linux-imx

/*

 * Asynchronous block chaining cipher operations.

 *

 * This is the asynchronous version of blkcipher.c indicating completion

 * via a callback.

 *

 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published by the Free

 * Software Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 */

​

#include <crypto/internal/skcipher.h>

#include <linux/err.h>

#include <linux/kernel.h>

#include <linux/slab.h>

#include <linux/seq_file.h>

#include <linux/cryptouser.h>

#include <linux/compiler.h>

#include <net/netlink.h>

​

#include <crypto/scatterwalk.h>

​

#include "internal.h"

​

struct ablkcipher_buffer {

    struct list_head    entry;

    struct scatter_walk dst;

    unsigned int        len;

    void            *data;

};

​

enum {

    ABLKCIPHER_WALK_SLOW = 1 << 0,

};

​

static inline void ablkcipher_buffer_write(struct ablkcipher_buffer *p)

{

    scatterwalk_copychunks(p->data, &p->dst, p->len, 1);

}

​

void __ablkcipher_walk_complete(struct ablkcipher_walk *walk)

{

    struct ablkcipher_buffer *p, *tmp;

​

    list_for_each_entry_safe(p, tmp, &walk->buffers, entry) {

        ablkcipher_buffer_write(p);

        list_del(&p->entry);

        kfree(p);

    }

}

EXPORT_SYMBOL_GPL(__ablkcipher_walk_complete);

​

static inline void ablkcipher_queue_write(struct ablkcipher_walk *walk,

                      struct ablkcipher_buffer *p)

{

    p->dst = walk->out;

    list_add_tail(&p->entry, &walk->buffers);

}

​

/* Get a spot of the specified length that does not straddle a page.

 * The caller needs to ensure that there is enough space for this operation.

 */

static inline u8 *ablkcipher_get_spot(u8 *start, unsigned int len)

{

    u8 *end_page = (u8 *)(((unsigned long)(start + len - 1)) & PAGE_MASK);

​

    return max(start, end_page);

}

​

static inline void ablkcipher_done_slow(struct ablkcipher_walk *walk,

                    unsigned int n)

{

    for (;;) {

        unsigned int len_this_page = scatterwalk_pagelen(&walk->out);

​

        if (len_this_page > n)

            len_this_page = n;

        scatterwalk_advance(&walk->out, n);

        if (n == len_this_page)

            break;

        n -= len_this_page;

        scatterwalk_start(&walk->out, sg_next(walk->out.sg));

    }

}

​

static inline void ablkcipher_done_fast(struct ablkcipher_walk *walk,

                    unsigned int n)

{