return ERR_PTR(err);
}
-static struct crypto_ablkcipher *dst_init_cipher(struct dst_crypto_ctl *ctl, u8 *key)
+static struct crypto_ablkcipher *dst_init_cipher(struct dst_crypto_ctl *ctl,
+ u8 *key)
{
int err = -EINVAL;
struct crypto_ablkcipher *cipher;
{
unsigned int i;
- for (i=0; i<e->page_num; ++i)
+ for (i = 0; i < e->page_num; ++i)
__free_page(e->pages[i]);
kfree(e->pages);
}
if (!e->pages)
return -ENOMEM;
- for (i=0; i<num; ++i) {
+ for (i = 0; i < num; ++i) {
e->pages[i] = alloc_page(GFP_KERNEL);
if (!e->pages[i])
goto err_out_free_pages;
* Initialize crypto engine for given node.
* Setup cipher/hash, keys, pool of threads and private data.
*/
-static int dst_crypto_engine_init(struct dst_crypto_engine *e, struct dst_node *n)
+static int dst_crypto_engine_init(struct dst_crypto_engine *e,
+ struct dst_node *n)
{
int err;
struct dst_crypto_ctl *ctl = &n->crypto;
/*
* Waiting for cipher processing to be completed.
*/
-struct dst_crypto_completion
-{
+struct dst_crypto_completion {
struct completion complete;
int error;
};
err = crypto_ablkcipher_decrypt(req);
switch (err) {
- case -EINPROGRESS:
- case -EBUSY:
- err = wait_for_completion_interruptible_timeout(&c.complete,
- timeout);
- if (!err)
- err = -ETIMEDOUT;
- else
- err = c.error;
- break;
- default:
- break;
+ case -EINPROGRESS:
+ case -EBUSY:
+ err = wait_for_completion_interruptible_timeout(&c.complete,
+ timeout);
+ if (!err)
+ err = -ETIMEDOUT;
+ else
+ err = c.error;
+ break;
+ default:
+ break;
}
return err;
* temporary storage, which is then being sent to the remote peer.
*/
static int dst_trans_iter_out(struct bio *bio, struct dst_crypto_engine *e,
- int (* iterator) (struct dst_crypto_engine *e,
+ int (*iterator) (struct dst_crypto_engine *e,
struct scatterlist *dst,
struct scatterlist *src))
{
}
static int dst_trans_iter_in(struct bio *bio, struct dst_crypto_engine *e,
- int (* iterator) (struct dst_crypto_engine *e,
+ int (*iterator) (struct dst_crypto_engine *e,
struct scatterlist *dst,
struct scatterlist *src))
{
* Initialize crypto engine for given node: store keys, create pool
* of threads, initialize each one.
*
- * Each thread has unique ID, but 0 and 1 are reserved for receiving and accepting
- * threads (if export node), so IDs could start from 2, but starting them
- * from 10 allows easily understand what this thread is for.
+ * Each thread has unique ID, but 0 and 1 are reserved for receiving and
+ * accepting threads (if export node), so IDs could start from 2, but starting
+ * them from 10 allows easily understand what this thread is for.
*/
int dst_node_crypto_init(struct dst_node *n, struct dst_crypto_ctl *ctl)
{
}
memcpy(&n->crypto, ctl, sizeof(struct dst_crypto_ctl));
- for (i=0; i<ctl->thread_num; ++i) {
+ for (i = 0; i < ctl->thread_num; ++i) {
snprintf(name, sizeof(name), "%s-crypto-%d", n->name, i);
/* Unique ids... */
- err = thread_pool_add_worker(n->pool, name, i+10,
+ err = thread_pool_add_worker(n->pool, name, i + 10,
dst_crypto_thread_init, dst_crypto_thread_cleanup, n);
if (err)
goto err_out_free_threads;
bv->bv_len, bv->bv_offset);
p = kmap(bv->bv_page) + bv->bv_offset;
- for (i=0; i<bv->bv_len; ++i)
- printk("%02x ", p[i]);
+ for (i = 0; i < bv->bv_len; ++i)
+ printk(KERN_DEBUG "%02x ", p[i]);
kunmap(bv->bv_page);
printk("\n");
}
printk(KERN_DEBUG "%s: bio: %llu/%u, rw: %lu, hash: ",
__func__, (u64)bio->bi_sector,
bio->bi_size, bio_data_dir(bio));
- for (i=0; i<crypto_hash_digestsize(e->hash); ++i)
+ for (i = 0; i < crypto_hash_digestsize(e->hash); ++i)
printk("%02x ", hash[i]);
printk("\n");
}
unsigned int i;
printk(", recv/calc: ");
- for (i=0; i<crypto_hash_digestsize(e->hash); ++i) {
+ for (i = 0; i < crypto_hash_digestsize(e->hash); ++i)
printk("%02x/%02x ", recv_hash[i], hash[i]);
- }
+
}
printk("\n");
#endif
struct dst_export_priv *p = bio->bi_private;
int err;
- dprintk("%s: e: %p, data: %p, bio: %llu/%u, dir: %lu.\n", __func__,
- e, e->data, (u64)bio->bi_sector, bio->bi_size, bio_data_dir(bio));
+ dprintk("%s: e: %p, data: %p, bio: %llu/%u, dir: %lu.\n",
+ __func__, e, e->data, (u64)bio->bi_sector,
+ bio->bi_size, bio_data_dir(bio));
e->enc = (bio_data_dir(bio) == READ);
e->iv = p->cmd.id;
* bio_rw_flagged(bio, BIO_RW_DISCARD) only, which does not
* work in this case.
*/
- //err = -EOPNOTSUPP;
+ /* err = -EOPNOTSUPP; */
err = 0;
goto end_io;
}
n->disk->fops = &dst_blk_ops;
n->disk->queue = n->queue;
n->disk->private_data = n;
- snprintf(n->disk->disk_name, sizeof(n->disk->disk_name), "dst-%s", n->name);
+ snprintf(n->disk->disk_name, sizeof(n->disk->disk_name),
+ "dst-%s", n->name);
return 0;
return sprintf(buf, "%u.%u.%u.%u:%d\n",
NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));
} else if (family == AF_INET6) {
- struct sockaddr_in6 *sin = (struct sockaddr_in6 *)&info->net.addr;
+ struct sockaddr_in6 *sin = (struct sockaddr_in6 *)
+ &info->net.addr;
return sprintf(buf,
"%pi6:%d\n",
&sin->sin6_addr, ntohs(sin->sin6_port));
sz -= size;
buf += size;
- for (i=0; i<addrlen; ++i) {
+ for (i = 0; i < addrlen; ++i) {
if (sz < 3)
break;
{
int err, i;
- for (i=0; i<ARRAY_SIZE(dst_node_attrs); ++i) {
+ for (i = 0; i < ARRAY_SIZE(dst_node_attrs); ++i) {
err = device_create_file(&n->info->device,
&dst_node_attrs[i]);
if (err)
{
int i;
- for (i=0; i<ARRAY_SIZE(dst_node_attrs); ++i)
+ for (i = 0; i < ARRAY_SIZE(dst_node_attrs); ++i)
device_remove_file(&n->info->device,
&dst_node_attrs[i]);
}
*/
static inline unsigned int dst_hash(char *str, unsigned int size)
{
- return (jhash(str, size, 0) % dst_hashtable_size);
+ return jhash(str, size, 0) % dst_hashtable_size;
}
static void dst_node_remove(struct dst_node *n)
dst_node_set_size(n);
add_disk(n->disk);
- dprintk("DST: started remote node '%s', minor: %d.\n", n->name, n->disk->first_minor);
+ dprintk("DST: started remote node '%s', minor: %d.\n",
+ n->name, n->disk->first_minor);
return 0;
}
* counter will be equal to 1),
* and subsequent dst_node_put() calls will free the node.
*/
- dprintk("%s: going to sleep with %d refcnt.\n", __func__, atomic_read(&n->refcnt));
+ dprintk("%s: going to sleep with %d refcnt.\n",
+ __func__, atomic_read(&n->refcnt));
wait_event(n->wait, atomic_read(&n->refcnt) <= 2);
dst_node_put(n);
if (!dst_hashtable)
return -ENOMEM;
- for (i=0; i<dst_hashtable_size; ++i)
+ for (i = 0; i < dst_hashtable_size; ++i)
INIT_LIST_HEAD(&dst_hashtable[i]);
return 0;
unsigned int i;
struct dst_node *n, *tmp;
- for (i=0; i<dst_hashtable_size; ++i) {
+ for (i = 0; i < dst_hashtable_size; ++i) {
list_for_each_entry_safe(n, tmp, &dst_hashtable[i], node_entry) {
dst_node_remove_unload(n);
}
* its permissions are checked in a security attributes and sent
* back.
*/
-static unsigned int dst_check_permissions(struct dst_state *main, struct dst_state *st)
+static unsigned int dst_check_permissions(struct dst_state *main,
+ struct dst_state *st)
{
struct dst_node *n = main->node;
struct dst_secure *sentry;
/*
* This '2' below is a port field. This may be very wrong to do
- * in atalk for example though. If there will be any need to extent
- * protocol to something else, I can create per-family helpers and
- * use them instead of this memcmp.
+ * in atalk for example though. If there will be any need
+ * to extent protocol to something else, I can create
+ * per-family helpers and use them instead of this memcmp.
*/
if (memcmp(s->addr.sa_data + 2, sa->sa_data + 2,
sa->sa_data_len - 2))
* Magic HZ? Polling check above is not safe in
* all cases (like socket reset in BH context),
* so it is simpler just to postpone it to the
- * process context instead of implementing special
- * locking there.
+ * process context instead of implementing
+ * special locking there.
*/
schedule_timeout(HZ);
}
if (p)
bio_put(p->bio);
- dprintk("%s: st: %p, refcnt: %d, list_empty: %d, p: %p.\n",
- __func__, st, atomic_read(&st->refcnt),
+ dprintk("%s: st: %p, refcnt: %d, list_empty: %d, p: "
+ "%p.\n", __func__, st, atomic_read(&st->refcnt),
list_empty(&st->request_list), p);
}
}
if (!err) {
while (n->trans_scan_timeout) {
err = wait_event_interruptible_timeout(st->thread_wait,
- !list_empty(&st->request_list) ||
- !n->trans_scan_timeout ||
- st->need_exit,
+ !list_empty(&st->request_list) ||
+ !n->trans_scan_timeout ||
+ st->need_exit,
HZ);
if (!n->trans_scan_timeout || st->need_exit)
int dst_start_export(struct dst_node *n)
{
if (list_empty(&n->security_list)) {
- printk(KERN_ERR "You are trying to export node '%s' without security attributes.\n"
- "No clients will be allowed to connect. Exiting.\n", n->name);
+ printk(KERN_ERR "You are trying to export node '%s' "
+ "without security attributes.\nNo clients will "
+ "be allowed to connect. Exiting.\n", n->name);
return -EINVAL;
}
return dst_node_trans_init(n, sizeof(struct dst_export_priv));
if (!bio)
goto err_out_exit;
- priv = (struct dst_export_priv *)(((void *)bio) - sizeof (struct dst_export_priv));
+ priv = (struct dst_export_priv *)(((void *)bio) -
+ sizeof (struct dst_export_priv));
priv->state = dst_state_get(st);
priv->bio = bio;
* Polling machinery.
*/
-struct dst_poll_helper
-{
- poll_table pt;
+struct dst_poll_helper {
+ poll_table pt;
struct dst_state *st;
};
-static int dst_queue_wake(wait_queue_t *wait, unsigned mode, int sync, void *key)
+static int dst_queue_wake(wait_queue_t *wait, unsigned mode,
+ int sync, void *key)
{
struct dst_state *st = container_of(wait, struct dst_state, wait);
msg.msg_namelen = 0;
msg.msg_control = NULL;
msg.msg_controllen = 0;
- msg.msg_flags = (block)?MSG_WAITALL:MSG_DONTWAIT;
+ msg.msg_flags = (block) ? MSG_WAITALL : MSG_DONTWAIT;
err = kernel_recvmsg(sock, &msg, &iov, 1, iov.iov_len,
msg.msg_flags);
{
if (sk->ops->family == AF_INET) {
struct sockaddr_in *sin = (struct sockaddr_in *)sa;
- printk(KERN_INFO "%s %u.%u.%u.%u:%d.\n",
- str, NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));
+ printk(KERN_INFO "%s %u.%u.%u.%u:%d.\n", str,
+ NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));
} else if (sk->ops->family == AF_INET6) {
struct sockaddr_in6 *sin = (struct sockaddr_in6 *)sa;
printk(KERN_INFO "%s %pi6:%d",
* State reset is used to reconnect to the remote peer.
* May fail, but who cares, we will try again later.
*/
-static void inline dst_state_reset_nolock(struct dst_state *st)
+static inline void dst_state_reset_nolock(struct dst_state *st)
{
dst_state_exit_connected(st);
dst_state_init_connected(st);
}
-static void inline dst_state_reset(struct dst_state *st)
+static inline void dst_state_reset(struct dst_state *st)
{
dst_state_lock(st);
dst_state_reset_nolock(st);
cmd->cmd = __cpu_to_be32(DST_PING);
- err = dst_data_send_header(st->socket, cmd, sizeof(struct dst_cmd), 0);
+ err = dst_data_send_header(st->socket, cmd,
+ sizeof(struct dst_cmd), 0);
}
- dprintk("%s: st: %p, socket: %p, err: %d.\n", __func__, st, st->socket, err);
+ dprintk("%s: st: %p, socket: %p, err: %d.\n", __func__,
+ st, st->socket, err);
dst_state_unlock(st);
return err;
err = -ECONNRESET;
dst_state_lock(st);
- if ( st->socket &&
- (st->read_socket == st->socket) &&
+ if (st->socket && (st->read_socket == st->socket) &&
(revents & POLLIN)) {
err = dst_data_recv_raw(st, data, size);
if (err > 0) {
}
if (revents & err_mask || !st->socket) {
- dprintk("%s: revents: %x, socket: %p, size: %u, err: %d.\n",
- __func__, revents, st->socket, size, err);
+ dprintk("%s: revents: %x, socket: %p, size: %u, "
+ "err: %d.\n", __func__, revents,
+ st->socket, size, err);
err = -ECONNRESET;
}
/*
* Receive block IO from the network.
*/
-static int dst_recv_bio(struct dst_state *st, struct bio *bio, unsigned int total_size)
+static int dst_recv_bio(struct dst_state *st, struct bio *bio,
+ unsigned int total_size)
{
struct bio_vec *bv;
int i, err;
bio_for_each_segment(bv, bio, i) {
sz = min(total_size, bv->bv_len);
- dprintk("%s: bio: %llu/%u, total: %u, len: %u, sz: %u, off: %u.\n",
- __func__, (u64)bio->bi_sector, bio->bi_size, total_size,
- bv->bv_len, sz, bv->bv_offset);
+ dprintk("%s: bio: %llu/%u, total: %u, len: %u, sz: %u, "
+ "off: %u.\n", __func__, (u64)bio->bi_sector,
+ bio->bi_size, total_size, bv->bv_len, sz,
+ bv->bv_offset);
data = kmap(bv->bv_page) + bv->bv_offset;
err = dst_data_recv(st, data, sz);
cmd->flags, cmd->rw);
/*
- * This should catch protocol breakage and random garbage instead of commands.
+ * This should catch protocol breakage and random garbage
+ * instead of commands.
*/
if (unlikely(cmd->csize > st->size - sizeof(struct dst_cmd))) {
err = -EBADMSG;
err = -EPROTO;
switch (cmd->cmd) {
- case DST_IO_RESPONSE:
- err = dst_process_io_response(st);
- break;
- case DST_IO:
- err = dst_process_io(st);
- break;
- case DST_CFG:
- err = dst_process_cfg(st);
- break;
- case DST_PING:
- err = 0;
- break;
- default:
- break;
+ case DST_IO_RESPONSE:
+ err = dst_process_io_response(st);
+ break;
+ case DST_IO:
+ err = dst_process_io(st);
+ break;
+ case DST_CFG:
+ err = dst_process_cfg(st);
+ break;
+ case DST_PING:
+ err = 0;
+ break;
+ default:
+ break;
}
out_exit:
* When action is being performed, thread can not be used by other users,
* instead they will sleep until there is free thread to pick their work.
*/
-struct thread_pool_worker
-{
+struct thread_pool_worker {
struct list_head worker_entry;
struct task_struct *thread;
void *private;
void *schedule_data;
- int (* action)(void *private, void *schedule_data);
- void (* cleanup)(void *private);
+ int (*action)(void *private, void *schedule_data);
+ void (*cleanup)(void *private);
};
static void thread_pool_exit_worker(struct thread_pool_worker *w)
struct thread_pool_worker *w = NULL;
while (!w && p->thread_num) {
- wait_event(p->wait, !list_empty(&p->ready_list) || !p->thread_num);
+ wait_event(p->wait, !list_empty(&p->ready_list) ||
+ !p->thread_num);
dprintk("%s: locking list_empty: %d, thread_num: %d.\n",
- __func__, list_empty(&p->ready_list), p->thread_num);
+ __func__, list_empty(&p->ready_list),
+ p->thread_num);
mutex_lock(&p->thread_lock);
if (!list_empty(&p->ready_list)) {
struct thread_pool_worker,
worker_entry);
- dprintk("%s: deleting w: %p, thread_num: %d, list: %p [%p.%p].\n",
- __func__, w, p->thread_num, &p->ready_list,
+ dprintk("%s: deleting w: %p, thread_num: %d, "
+ "list: %p [%p.%p].\n", __func__,
+ w, p->thread_num, &p->ready_list,
p->ready_list.prev, p->ready_list.next);
p->thread_num--;
int thread_pool_add_worker(struct thread_pool *p,
char *name,
unsigned int id,
- void *(* init)(void *private),
- void (* cleanup)(void *private),
+ void *(*init)(void *private),
+ void (*cleanup)(void *private),
void *private)
{
struct thread_pool_worker *w;
* They will have sequential IDs started from zero.
*/
struct thread_pool *thread_pool_create(int num, char *name,
- void *(* init)(void *private),
- void (* cleanup)(void *private),
+ void *(*init)(void *private),
+ void (*cleanup)(void *private),
void *private)
{
struct thread_pool_worker *w, *tmp;
INIT_LIST_HEAD(&p->active_list);
p->thread_num = 0;
- for (i=0; i<num; ++i) {
+ for (i = 0; i < num; ++i) {
err = thread_pool_add_worker(p, name, i, init,
cleanup, private);
if (err)
* private data.
*/
int thread_pool_schedule_private(struct thread_pool *p,
- int (* setup)(void *private, void *data),
- int (* action)(void *private, void *data),
+ int (*setup)(void *private, void *data),
+ int (*action)(void *private, void *data),
void *data, long timeout, void *id)
{
struct thread_pool_worker *w, *tmp, *worker = NULL;
w->has_data = 1;
wake_up(&w->wait);
} else {
- list_move_tail(&w->worker_entry, &p->ready_list);
+ list_move_tail(&w->worker_entry,
+ &p->ready_list);
}
break;
* Schedule execution on arbitrary thread from the pool.
*/
int thread_pool_schedule(struct thread_pool *p,
- int (* setup)(void *private, void *data),
- int (* action)(void *private, void *data),
+ int (*setup)(void *private, void *data),
+ int (*action)(void *private, void *data),
void *data, long timeout)
{
return thread_pool_schedule_private(p, setup,
}
dprintk("%s: %s transaction: id: %llu.\n", __func__,
- (ret)?"found":"not found", gen);
+ (ret) ? "found" : "not found", gen);
return ret;
}
new->send_time = jiffies;
if (ret) {
- printk("%s: exist: old: gen: %llu, bio: %llu/%u, send_time: %lu, "
- "new: gen: %llu, bio: %llu/%u, send_time: %lu.\n",
- __func__,
+ printk(KERN_DEBUG "%s: exist: old: gen: %llu, bio: %llu/%u, "
+ "send_time: %lu, new: gen: %llu, bio: %llu/%u, "
+ "send_time: %lu.\n", __func__,
ret->gen, (u64)ret->bio->bi_sector,
ret->bio->bi_size, ret->send_time,
new->gen, (u64)new->bio->bi_sector,
*/
static void dst_trans_scan(struct work_struct *work)
{
- struct dst_node *n = container_of(work, struct dst_node, trans_work.work);
+ struct dst_node *n = container_of(work, struct dst_node,
+ trans_work.work);
struct rb_node *rb_node;
struct dst_trans *t;
unsigned long timeout = n->trans_scan_timeout;
mutex_unlock(&n->trans_lock);
/*
- * If no timeout specified then system is in the middle of exiting process,
- * so no need to reschedule scanning process again.
+ * If no timeout specified then system is in the middle of exiting
+ * process, so no need to reschedule scanning process again.
*/
if (timeout) {
if (!num)
if (!n->trans_cache)
goto err_out_exit;
- n->trans_pool = mempool_create_slab_pool(dst_mempool_num, n->trans_cache);
+ n->trans_pool = mempool_create_slab_pool(dst_mempool_num,
+ n->trans_cache);
if (!n->trans_pool)
goto err_out_cache_destroy;
git://ftp.safe.ca / safe / jmp / linux-2.6 / commitdiff