Subversion Repositories or1k

/*

 * iobuf.c

 *

 * Keep track of the general-purpose IO-buffer structures used to track

 * abstract kernel-space io buffers.

 *

 */

#include <linux/iobuf.h>

#include <linux/slab.h>

#include <linux/vmalloc.h>

static kmem_cache_t *kiobuf_cachep;

void end_kio_request(struct kiobuf *kiobuf, int uptodate)

{

        if ((!uptodate) && !kiobuf->errno)

                kiobuf->errno = -EIO;

        if (atomic_dec_and_test(&kiobuf->io_count)) {

                if (kiobuf->end_io)

                        kiobuf->end_io(kiobuf);

                wake_up(&kiobuf->wait_queue);

        }

}

static int kiobuf_init(struct kiobuf *iobuf)

{

        init_waitqueue_head(&iobuf->wait_queue);

        iobuf->array_len = 0;

        iobuf->nr_pages = 0;

        iobuf->locked = 0;

        iobuf->bh = NULL;

        iobuf->blocks = NULL;

        atomic_set(&iobuf->io_count, 0);

        iobuf->end_io = NULL;

        return expand_kiobuf(iobuf, KIO_STATIC_PAGES);

}

int alloc_kiobuf_bhs(struct kiobuf * kiobuf)

{

        int i;

        kiobuf->blocks =

                kmalloc(sizeof(*kiobuf->blocks) * KIO_MAX_SECTORS, GFP_KERNEL);

        if (unlikely(!kiobuf->blocks))

                goto nomem;

        kiobuf->bh =

                kmalloc(sizeof(*kiobuf->bh) * KIO_MAX_SECTORS, GFP_KERNEL);

        if (unlikely(!kiobuf->bh))

                goto nomem;

        for (i = 0; i < KIO_MAX_SECTORS; i++) {

                kiobuf->bh[i] = kmem_cache_alloc(bh_cachep, GFP_KERNEL);

                if (unlikely(!kiobuf->bh[i]))

                        goto nomem2;

        }

        return 0;

nomem2:

        while (i--) {

                kmem_cache_free(bh_cachep, kiobuf->bh[i]);

                kiobuf->bh[i] = NULL;

        }

        memset(kiobuf->bh, 0, sizeof(*kiobuf->bh) * KIO_MAX_SECTORS);

nomem:

        free_kiobuf_bhs(kiobuf);

        return -ENOMEM;

}

void free_kiobuf_bhs(struct kiobuf * kiobuf)

{

        int i;

        if (kiobuf->bh) {

                for (i = 0; i < KIO_MAX_SECTORS; i++)

                        if (kiobuf->bh[i])

                                kmem_cache_free(bh_cachep, kiobuf->bh[i]);

                kfree(kiobuf->bh);

                kiobuf->bh = NULL;

        }

        if (kiobuf->blocks) {

                kfree(kiobuf->blocks);

                kiobuf->blocks = NULL;

        }

}

int alloc_kiovec(int nr, struct kiobuf **bufp)

{

        int i;

        struct kiobuf *iobuf;

        for (i = 0; i < nr; i++) {

                iobuf = kmem_cache_alloc(kiobuf_cachep, GFP_KERNEL);

                if (unlikely(!iobuf))

                        goto nomem;

                if (unlikely(kiobuf_init(iobuf)))

                        goto nomem2;

                if (unlikely(alloc_kiobuf_bhs(iobuf)))

                        goto nomem2;

                bufp[i] = iobuf;

        }

        return 0;

nomem2:

        kmem_cache_free(kiobuf_cachep, iobuf);

nomem:

        free_kiovec(i, bufp);

        return -ENOMEM;

}

void free_kiovec(int nr, struct kiobuf **bufp)

{

        int i;

        struct kiobuf *iobuf;

        for (i = 0; i < nr; i++) {

                iobuf = bufp[i];

                if (iobuf->locked)

                        unlock_kiovec(1, &iobuf);

                kfree(iobuf->maplist);

                free_kiobuf_bhs(iobuf);

                kmem_cache_free(kiobuf_cachep, bufp[i]);

        }

}

int expand_kiobuf(struct kiobuf *iobuf, int wanted)

{

        struct page ** maplist;

        if (iobuf->array_len >= wanted)

                return 0;

        maplist = kmalloc(wanted * sizeof(struct page **), GFP_KERNEL);

        if (unlikely(!maplist))

                return -ENOMEM;

        /* Did it grow while we waited? */

        if (unlikely(iobuf->array_len >= wanted)) {

                kfree(maplist);

                return 0;

        }

        if (iobuf->array_len) {

                memcpy(maplist, iobuf->maplist, iobuf->array_len * sizeof(*maplist));

                kfree(iobuf->maplist);

        }

        iobuf->maplist   = maplist;

        iobuf->array_len = wanted;

        return 0;

}

void kiobuf_wait_for_io(struct kiobuf *kiobuf)

{

        struct task_struct *tsk = current;

        DECLARE_WAITQUEUE(wait, tsk);

        if (atomic_read(&kiobuf->io_count) == 0)

                return;

        add_wait_queue(&kiobuf->wait_queue, &wait);

repeat:

        set_task_state(tsk, TASK_UNINTERRUPTIBLE);

        if (atomic_read(&kiobuf->io_count) != 0) {

                run_task_queue(&tq_disk);

                schedule();

                if (atomic_read(&kiobuf->io_count) != 0)

                        goto repeat;

        }

        tsk->state = TASK_RUNNING;

        remove_wait_queue(&kiobuf->wait_queue, &wait);

}

void __init iobuf_cache_init(void)

{

        kiobuf_cachep = kmem_cache_create("kiobuf", sizeof(struct kiobuf),

                                          0, SLAB_HWCACHE_ALIGN, NULL, NULL);

        if (!kiobuf_cachep)

                panic("Cannot create kiobuf SLAB cache");

}