davinci: audio clocks: use struct device instead of clock names

[linux-ginger.git] / include / linux / dst.h

/*
 * 2007+ Copyright (c) Evgeniy Polyakov <johnpol@2ka.mipt.ru>
 * All rights reserved.
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#ifndef __DST_H
#define __DST_H

#include <linux/types.h>
#include <linux/connector.h>

#define DST_NAMELEN             32
#define DST_NAME                "dst"

enum {
        /* Remove node with given id from storage */
        DST_DEL_NODE    = 0,
        /* Add remote node with given id to the storage */
        DST_ADD_REMOTE,
        /* Add local node with given id to the storage to be exported and used by remote peers */
        DST_ADD_EXPORT,
        /* Crypto initialization command (hash/cipher used to protect the connection) */
        DST_CRYPTO,
        /* Security attributes for given connection (permissions for example) */
        DST_SECURITY,
        /* Register given node in the block layer subsystem */
        DST_START,
        DST_CMD_MAX
};

struct dst_ctl
{
        /* Storage name */
        char                    name[DST_NAMELEN];
        /* Command flags */
        __u32                   flags;
        /* Command itself (see above) */
        __u32                   cmd;
        /* Maximum number of pages per single request in this device */
        __u32                   max_pages;
        /* Stale/error transaction scanning timeout in milliseconds */
        __u32                   trans_scan_timeout;
        /* Maximum number of retry sends before completing transaction as broken */
        __u32                   trans_max_retries;
        /* Storage size */
        __u64                   size;
};

/* Reply command carries completion status */
struct dst_ctl_ack
{
        struct cn_msg           msg;
        int                     error;
        int                     unused[3];
};

/*
 * Unfortunaltely socket address structure is not exported to userspace
 * and is redefined there.
 */
#define SADDR_MAX_DATA  128

struct saddr {
        /* address family, AF_xxx       */
        unsigned short          sa_family;
        /* 14 bytes of protocol address */
        char                    sa_data[SADDR_MAX_DATA];
        /* Number of bytes used in sa_data */
        unsigned short          sa_data_len;
};

/* Address structure */
struct dst_network_ctl
{
        /* Socket type: datagram, stream...*/
        unsigned int            type;
        /* Let me guess, is it a Jupiter diameter? */
        unsigned int            proto;
        /* Peer's address */
        struct saddr            addr;
};

struct dst_crypto_ctl
{
        /* Cipher and hash names */
        char                    cipher_algo[DST_NAMELEN];
        char                    hash_algo[DST_NAMELEN];

        /* Key sizes. Can be zero for digest for example */
        unsigned int            cipher_keysize, hash_keysize;
        /* Alignment. Calculated by the DST itself. */
        unsigned int            crypto_attached_size;
        /* Number of threads to perform crypto operations */
        int                     thread_num;
};

/* Export security attributes have this bits checked in when client connects */
#define DST_PERM_READ           (1<<0)
#define DST_PERM_WRITE          (1<<1)

/*
 * Right now it is simple model, where each remote address
 * is assigned to set of permissions it is allowed to perform.
 * In real world block device does not know anything but
 * reading and writing, so it should be more than enough.
 */
struct dst_secure_user
{
        unsigned int            permissions;
        struct saddr            addr;
};

/*
 * Export control command: device to export and network address to accept
 * clients to work with given device
 */
struct dst_export_ctl
{
        char                    device[DST_NAMELEN];
        struct dst_network_ctl  ctl;
};

enum {
        DST_CFG = 1,            /* Request remote configuration */
        DST_IO,                 /* IO command */
        DST_IO_RESPONSE,        /* IO response */
        DST_PING,               /* Keepalive message */
        DST_NCMD_MAX,
};

struct dst_cmd
{
        /* Network command itself, see above */
        __u32                   cmd;
        /*
         * Size of the attached data
         * (in most cases, for READ command it means how many bytes were requested)
         */
        __u32                   size;
        /* Crypto size: number of attached bytes with digest/hmac */
        __u32                   csize;
        /* Here we can carry secret data */
        __u32                   reserved;
        /* Read/write bits, see how they are encoded in bio structure */
        __u64                   rw;
        /* BIO flags */
        __u64                   flags;
        /* Unique command id (like transaction ID) */
        __u64                   id;
        /* Sector to start IO from */
        __u64                   sector;
        /* Hash data is placed after this header */
        __u8                    hash[0];
};

/*
 * Convert command to/from network byte order.
 * We do not use hton*() functions, since there is
 * no 64-bit implementation.
 */
static inline void dst_convert_cmd(struct dst_cmd *c)
{
        c->cmd = __cpu_to_be32(c->cmd);
        c->csize = __cpu_to_be32(c->csize);
        c->size = __cpu_to_be32(c->size);
        c->sector = __cpu_to_be64(c->sector);
        c->id = __cpu_to_be64(c->id);
        c->flags = __cpu_to_be64(c->flags);
        c->rw = __cpu_to_be64(c->rw);
}

/* Transaction id */
typedef __u64 dst_gen_t;

#ifdef __KERNEL__

#include <linux/blkdev.h>
#include <linux/bio.h>
#include <linux/device.h>
#include <linux/mempool.h>
#include <linux/net.h>
#include <linux/poll.h>
#include <linux/rbtree.h>

#ifdef CONFIG_DST_DEBUG
#define dprintk(f, a...) printk(KERN_NOTICE f, ##a)
#else
static inline void __attribute__ ((format (printf, 1, 2)))
        dprintk(const char *fmt, ...) {}
#endif

struct dst_node;

struct dst_trans
{
        /* DST node we are working with */
        struct dst_node         *n;

        /* Entry inside transaction tree */
        struct rb_node          trans_entry;

        /* Merlin kills this transaction when this memory cell equals zero */
        atomic_t                refcnt;

        /* How this transaction should be processed by crypto engine */
        short                   enc;
        /* How many times this transaction was resent */
        short                   retries;
        /* Completion status */
        int                     error;

        /* When did we send it to the remote peer */
        long                    send_time;

        /* My name is...
         * Well, computers does not speak, they have unique id instead */
        dst_gen_t               gen;

        /* Block IO we are working with */
        struct bio              *bio;

        /* Network command for above block IO request */
        struct dst_cmd          cmd;
};

struct dst_crypto_engine
{
        /* What should we do with all block requests */
        struct crypto_hash      *hash;
        struct crypto_ablkcipher        *cipher;

        /* Pool of pages used to encrypt data into before sending */
        int                     page_num;
        struct page             **pages;

        /* What to do with current request */
        int                     enc;
        /* Who we are and where do we go */
        struct scatterlist      *src, *dst;

        /* Maximum timeout waiting for encryption to be completed */
        long                    timeout;
        /* IV is a 64-bit sequential counter */
        u64                     iv;

        /* Secret data */
        void                    *private;

        /* Cached temporary data lives here */
        int                     size;
        void                    *data;
};

struct dst_state
{
        /* The main state protection */
        struct mutex            state_lock;

        /* Polling machinery for sockets */
        wait_queue_t            wait;
        wait_queue_head_t       *whead;
        /* Most of events are being waited here */
        wait_queue_head_t       thread_wait;

        /* Who owns this? */
        struct dst_node         *node;

        /* Network address for this state */
        struct dst_network_ctl  ctl;

        /* Permissions to work with: read-only or rw connection */
        u32                     permissions;

        /* Called when we need to clean private data */
        void                    (* cleanup)(struct dst_state *st);

        /* Used by the server: BIO completion queues BIOs here */
        struct list_head        request_list;
        spinlock_t              request_lock;

        /* Guess what? No, it is not number of planets */
        atomic_t                refcnt;

        /* This flags is set when connection should be dropped */
        int                     need_exit;

        /*
         * Socket to work with. Second pointer is used for
         * lockless check if socket was changed before performing
         * next action (like working with cached polling result)
         */
        struct socket           *socket, *read_socket;

        /* Cached preallocated data */
        void                    *data;
        unsigned int            size;

        /* Currently processed command */
        struct dst_cmd          cmd;
};

struct dst_info
{
        /* Device size */
        u64                     size;

        /* Local device name for export devices */
        char                    local[DST_NAMELEN];

        /* Network setup */
        struct dst_network_ctl  net;

        /* Sysfs bits use this */
        struct device           device;
};

struct dst_node
{
        struct list_head        node_entry;

        /* Hi, my name is stored here */
        char                    name[DST_NAMELEN];
        /* My cache name is stored here */
        char                    cache_name[DST_NAMELEN];

        /* Block device attached to given node.
         * Only valid for exporting nodes */
        struct block_device     *bdev;
        /* Network state machine for given peer */
        struct dst_state        *state;

        /* Block IO machinery */
        struct request_queue    *queue;
        struct gendisk          *disk;

        /* Number of threads in processing pool */
        int                     thread_num;
        /* Maximum number of pages in single IO */
        int                     max_pages;

        /* I'm that big in bytes */
        loff_t                  size;

        /* Exported to userspace node information */
        struct dst_info         *info;

        /*
         * Security attribute list.
         * Used only by exporting node currently.
         */
        struct list_head        security_list;
        struct mutex            security_lock;

        /*
         * When this unerflows below zero, university collapses.
         * But this will not happen, since node will be freed,
         * when reference counter reaches zero.
         */
        atomic_t                refcnt;

        /* How precisely should I be started? */
        int                     (*start)(struct dst_node *);

        /* Crypto capabilities */
        struct dst_crypto_ctl   crypto;
        u8                      *hash_key;
        u8                      *cipher_key;

        /* Pool of processing thread */
        struct thread_pool      *pool;

        /* Transaction IDs live here */
        atomic_long_t           gen;

        /*
         * How frequently and how many times transaction
         * tree should be scanned to drop stale objects.
         */
        long                    trans_scan_timeout;
        int                     trans_max_retries;

        /* Small gnomes live here */
        struct rb_root          trans_root;
        struct mutex            trans_lock;

        /*
         * Transaction cache/memory pool.
         * It is big enough to contain not only transaction
         * itself, but additional crypto data (digest/hmac).
         */
        struct kmem_cache       *trans_cache;
        mempool_t               *trans_pool;

        /* This entity scans transaction tree */
        struct delayed_work     trans_work;

        wait_queue_head_t       wait;
};

/* Kernel representation of the security attribute */
struct dst_secure
{
        struct list_head        sec_entry;
        struct dst_secure_user  sec;
};

int dst_process_bio(struct dst_node *n, struct bio *bio);

int dst_node_init_connected(struct dst_node *n, struct dst_network_ctl *r);
int dst_node_init_listened(struct dst_node *n, struct dst_export_ctl *le);

static inline struct dst_state *dst_state_get(struct dst_state *st)
{
        BUG_ON(atomic_read(&st->refcnt) == 0);
        atomic_inc(&st->refcnt);
        return st;
}

void dst_state_put(struct dst_state *st);

struct dst_state *dst_state_alloc(struct dst_node *n);
int dst_state_socket_create(struct dst_state *st);
void dst_state_socket_release(struct dst_state *st);

void dst_state_exit_connected(struct dst_state *st);

int dst_state_schedule_receiver(struct dst_state *st);

void dst_dump_addr(struct socket *sk, struct sockaddr *sa, char *str);

static inline void dst_state_lock(struct dst_state *st)
{
        mutex_lock(&st->state_lock);
}

static inline void dst_state_unlock(struct dst_state *st)
{
        mutex_unlock(&st->state_lock);
}

void dst_poll_exit(struct dst_state *st);
int dst_poll_init(struct dst_state *st);

static inline unsigned int dst_state_poll(struct dst_state *st)
{
        unsigned int revents = POLLHUP | POLLERR;

        dst_state_lock(st);
        if (st->socket)
                revents = st->socket->ops->poll(NULL, st->socket, NULL);
        dst_state_unlock(st);

        return revents;
}

static inline int dst_thread_setup(void *private, void *data)
{
        return 0;
}

void dst_node_put(struct dst_node *n);

static inline struct dst_node *dst_node_get(struct dst_node *n)
{
        atomic_inc(&n->refcnt);
        return n;
}

int dst_data_recv(struct dst_state *st, void *data, unsigned int size);
int dst_recv_cdata(struct dst_state *st, void *cdata);
int dst_data_send_header(struct socket *sock,
                void *data, unsigned int size, int more);

int dst_send_bio(struct dst_state *st, struct dst_cmd *cmd, struct bio *bio);

int dst_process_io(struct dst_state *st);
int dst_export_crypto(struct dst_node *n, struct bio *bio);
int dst_export_send_bio(struct bio *bio);
int dst_start_export(struct dst_node *n);

int __init dst_export_init(void);
void dst_export_exit(void);

/* Private structure for export block IO requests */
struct dst_export_priv
{
        struct list_head                request_entry;
        struct dst_state                *state;
        struct bio                      *bio;
        struct dst_cmd                  cmd;
};

static inline void dst_trans_get(struct dst_trans *t)
{
        atomic_inc(&t->refcnt);
}

struct dst_trans *dst_trans_search(struct dst_node *node, dst_gen_t gen);
int dst_trans_remove(struct dst_trans *t);
int dst_trans_remove_nolock(struct dst_trans *t);
void dst_trans_put(struct dst_trans *t);

/*
 * Convert bio into network command.
 */
static inline void dst_bio_to_cmd(struct bio *bio, struct dst_cmd *cmd,
                u32 command, u64 id)
{
        cmd->cmd = command;
        cmd->flags = (bio->bi_flags << BIO_POOL_BITS) >> BIO_POOL_BITS;
        cmd->rw = bio->bi_rw;
        cmd->size = bio->bi_size;
        cmd->csize = 0;
        cmd->id = id;
        cmd->sector = bio->bi_sector;
};

int dst_trans_send(struct dst_trans *t);
int dst_trans_crypto(struct dst_trans *t);

int dst_node_crypto_init(struct dst_node *n, struct dst_crypto_ctl *ctl);
void dst_node_crypto_exit(struct dst_node *n);

static inline int dst_need_crypto(struct dst_node *n)
{
        struct dst_crypto_ctl *c = &n->crypto;
        /*
         * Logical OR is appropriate here, but boolean one produces
         * more optimal code, so it is used instead.
         */
        return (c->hash_algo[0] | c->cipher_algo[0]);
}

int dst_node_trans_init(struct dst_node *n, unsigned int size);
void dst_node_trans_exit(struct dst_node *n);

/*
 * Pool of threads.
 * Ready list contains threads currently free to be used,
 * active one contains threads with some work scheduled for them.
 * Caller can wait in given queue when thread is ready.
 */
struct thread_pool
{
        int                     thread_num;
        struct mutex            thread_lock;
        struct list_head        ready_list, active_list;

        wait_queue_head_t       wait;
};

void thread_pool_del_worker(struct thread_pool *p);
void thread_pool_del_worker_id(struct thread_pool *p, unsigned int id);
int thread_pool_add_worker(struct thread_pool *p,
                char *name,
                unsigned int id,
                void *(* init)(void *data),
                void (* cleanup)(void *data),
                void *data);

void thread_pool_destroy(struct thread_pool *p);
struct thread_pool *thread_pool_create(int num, char *name,
                void *(* init)(void *data),
                void (* cleanup)(void *data),
                void *data);

int thread_pool_schedule(struct thread_pool *p,
                int (* setup)(void *stored_private, void *setup_data),
                int (* action)(void *stored_private, void *setup_data),
                void *setup_data, long timeout);
int thread_pool_schedule_private(struct thread_pool *p,
                int (* setup)(void *private, void *data),
                int (* action)(void *private, void *data),
                void *data, long timeout, void *id);

#endif /* __KERNEL__ */
#endif /* __DST_H */