Merge branch 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc
[linux-2.6] / drivers / staging / pohmelfs / net.c
1 /*
2  * 2007+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
3  * All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  */
15
16 #include <linux/fsnotify.h>
17 #include <linux/jhash.h>
18 #include <linux/in.h>
19 #include <linux/in6.h>
20 #include <linux/kthread.h>
21 #include <linux/pagemap.h>
22 #include <linux/poll.h>
23 #include <linux/swap.h>
24 #include <linux/syscalls.h>
25 #include <linux/vmalloc.h>
26
27 #include "netfs.h"
28
29 /*
30  * Async machinery lives here.
31  * All commands being sent to server do _not_ require sync reply,
32  * instead, if it is really needed, like readdir or readpage, caller
33  * sleeps waiting for data, which will be placed into provided buffer
34  * and caller will be awakened.
35  *
36  * Every command response can come without some listener. For example
37  * readdir response will add new objects into cache without appropriate
38  * request from userspace. This is used in cache coherency.
39  *
40  * If object is not found for given data, it is discarded.
41  *
42  * All requests are received by dedicated kernel thread.
43  */
44
45 /*
46  * Basic network sending/receiving functions.
47  * Blocked mode is used.
48  */
49 static int netfs_data_recv(struct netfs_state *st, void *buf, u64 size)
50 {
51         struct msghdr msg;
52         struct kvec iov;
53         int err;
54
55         BUG_ON(!size);
56
57         iov.iov_base = buf;
58         iov.iov_len = size;
59
60         msg.msg_iov = (struct iovec *)&iov;
61         msg.msg_iovlen = 1;
62         msg.msg_name = NULL;
63         msg.msg_namelen = 0;
64         msg.msg_control = NULL;
65         msg.msg_controllen = 0;
66         msg.msg_flags = MSG_DONTWAIT;
67
68         err = kernel_recvmsg(st->socket, &msg, &iov, 1, iov.iov_len,
69                         msg.msg_flags);
70         if (err <= 0) {
71                 printk("%s: failed to recv data: size: %llu, err: %d.\n", __func__, size, err);
72                 if (err == 0)
73                         err = -ECONNRESET;
74         }
75
76         return err;
77 }
78
79 static int pohmelfs_data_recv(struct netfs_state *st, void *data, unsigned int size)
80 {
81         unsigned int revents = 0;
82         unsigned int err_mask = POLLERR | POLLHUP | POLLRDHUP;
83         unsigned int mask = err_mask | POLLIN;
84         int err = 0;
85
86         while (size && !err) {
87                 revents = netfs_state_poll(st);
88
89                 if (!(revents & mask)) {
90                         DEFINE_WAIT(wait);
91
92                         for (;;) {
93                                 prepare_to_wait(&st->thread_wait, &wait, TASK_INTERRUPTIBLE);
94                                 if (kthread_should_stop())
95                                         break;
96
97                                 revents = netfs_state_poll(st);
98
99                                 if (revents & mask)
100                                         break;
101
102                                 if (signal_pending(current))
103                                         break;
104
105                                 schedule();
106                                 continue;
107                         }
108                         finish_wait(&st->thread_wait, &wait);
109                 }
110
111                 err = 0;
112                 netfs_state_lock(st);
113                 if (st->socket && (st->read_socket == st->socket) && (revents & POLLIN)) {
114                         err = netfs_data_recv(st, data, size);
115                         if (err > 0) {
116                                 data += err;
117                                 size -= err;
118                                 err = 0;
119                         } else if (err == 0)
120                                 err = -ECONNRESET;
121                 }
122
123                 if (revents & err_mask) {
124                         printk("%s: revents: %x, socket: %p, size: %u, err: %d.\n",
125                                         __func__, revents, st->socket, size, err);
126                         err = -ECONNRESET;
127                 }
128                 netfs_state_unlock(st);
129
130                 if (err < 0) {
131                         if (netfs_state_trylock_send(st)) {
132                                 netfs_state_exit(st);
133                                 err = netfs_state_init(st);
134                                 if (!err)
135                                         err = -EAGAIN;
136                                 netfs_state_unlock_send(st);
137                         } else {
138                                 st->need_reset = 1;
139                         }
140                 }
141
142                 if (kthread_should_stop())
143                         err = -ENODEV;
144
145                 if (err)
146                         printk("%s: socket: %p, read_socket: %p, revents: %x, rev_error: %d, "
147                                         "should_stop: %d, size: %u, err: %d.\n",
148                                 __func__, st->socket, st->read_socket,
149                                 revents, revents & err_mask, kthread_should_stop(), size, err);
150         }
151
152         return err;
153 }
154
155 int pohmelfs_data_recv_and_check(struct netfs_state *st, void *data, unsigned int size)
156 {
157         struct netfs_cmd *cmd = &st->cmd;
158         int err;
159
160         err = pohmelfs_data_recv(st, data, size);
161         if (err)
162                 return err;
163
164         return pohmelfs_crypto_process_input_data(&st->eng, cmd->iv, data, NULL, size);
165 }
166
167 /*
168  * Polling machinery.
169  */
170
171 struct netfs_poll_helper
172 {
173         poll_table              pt;
174         struct netfs_state      *st;
175 };
176
177 static int netfs_queue_wake(wait_queue_t *wait, unsigned mode, int sync, void *key)
178 {
179         struct netfs_state *st = container_of(wait, struct netfs_state, wait);
180
181         wake_up(&st->thread_wait);
182         return 1;
183 }
184
185 static void netfs_queue_func(struct file *file, wait_queue_head_t *whead,
186                                  poll_table *pt)
187 {
188         struct netfs_state *st = container_of(pt, struct netfs_poll_helper, pt)->st;
189
190         st->whead = whead;
191         init_waitqueue_func_entry(&st->wait, netfs_queue_wake);
192         add_wait_queue(whead, &st->wait);
193 }
194
195 static void netfs_poll_exit(struct netfs_state *st)
196 {
197         if (st->whead) {
198                 remove_wait_queue(st->whead, &st->wait);
199                 st->whead = NULL;
200         }
201 }
202
203 static int netfs_poll_init(struct netfs_state *st)
204 {
205         struct netfs_poll_helper ph;
206
207         ph.st = st;
208         init_poll_funcptr(&ph.pt, &netfs_queue_func);
209
210         st->socket->ops->poll(NULL, st->socket, &ph.pt);
211         return 0;
212 }
213
214 /*
215  * Get response for readpage command. We search inode and page in its mapping
216  * and copy data into. If it was async request, then we queue page into shared
217  * data and wakeup listener, who will copy it to userspace.
218  *
219  * There is a work in progress of allowing to call copy_to_user() directly from
220  * async receiving kernel thread.
221  */
222 static int pohmelfs_read_page_response(struct netfs_state *st)
223 {
224         struct pohmelfs_sb *psb = st->psb;
225         struct netfs_cmd *cmd = &st->cmd;
226         struct inode *inode;
227         struct page *page;
228         int err = 0;
229
230         if (cmd->size > PAGE_CACHE_SIZE) {
231                 err = -EINVAL;
232                 goto err_out_exit;
233         }
234
235         inode = ilookup(st->psb->sb, cmd->id);
236         if (!inode) {
237                 printk("%s: failed to find inode: id: %llu.\n", __func__, cmd->id);
238                 err = -ENOENT;
239                 goto err_out_exit;
240         }
241
242         page = find_get_page(inode->i_mapping, cmd->start >> PAGE_CACHE_SHIFT);
243         if (!page || !PageLocked(page)) {
244                 printk("%s: failed to find/lock page: page: %p, id: %llu, start: %llu, index: %llu.\n",
245                                 __func__, page, cmd->id, cmd->start, cmd->start >> PAGE_CACHE_SHIFT);
246
247                 while (cmd->size) {
248                         unsigned int sz = min(cmd->size, st->size);
249
250                         err = pohmelfs_data_recv(st, st->data, sz);
251                         if (err)
252                                 break;
253
254                         cmd->size -= sz;
255                 }
256
257                 err = -ENODEV;
258                 if (page)
259                         goto err_out_page_put;
260                 goto err_out_put;
261         }
262
263         if (cmd->size) {
264                 void *addr;
265
266                 addr = kmap(page);
267                 err = pohmelfs_data_recv(st, addr, cmd->size);
268                 kunmap(page);
269
270                 if (err)
271                         goto err_out_page_unlock;
272         }
273
274         dprintk("%s: page: %p, start: %llu, size: %u, locked: %d.\n",
275                 __func__, page, cmd->start, cmd->size, PageLocked(page));
276
277         SetPageChecked(page);
278         if ((psb->hash_string || psb->cipher_string) && psb->perform_crypto && cmd->size) {
279                 err = pohmelfs_crypto_process_input_page(&st->eng, page, cmd->size, cmd->iv);
280                 if (err < 0)
281                         goto err_out_page_unlock;
282         } else {
283                 SetPageUptodate(page);
284                 unlock_page(page);
285                 page_cache_release(page);
286         }
287
288         pohmelfs_put_inode(POHMELFS_I(inode));
289         wake_up(&st->psb->wait);
290
291         return 0;
292
293 err_out_page_unlock:
294         SetPageError(page);
295         unlock_page(page);
296 err_out_page_put:
297         page_cache_release(page);
298 err_out_put:
299         pohmelfs_put_inode(POHMELFS_I(inode));
300 err_out_exit:
301         wake_up(&st->psb->wait);
302         return err;
303 }
304
305 static int pohmelfs_check_name(struct pohmelfs_inode *parent, struct qstr *str,
306                 struct netfs_inode_info *info)
307 {
308         struct inode *inode;
309         struct pohmelfs_name *n;
310         int err = 0;
311         u64 ino = 0;
312
313         mutex_lock(&parent->offset_lock);
314         n = pohmelfs_search_hash(parent, str->hash);
315         if (n)
316                 ino = n->ino;
317         mutex_unlock(&parent->offset_lock);
318
319         if (!ino)
320                 goto out;
321
322         inode = ilookup(parent->vfs_inode.i_sb, ino);
323         if (!inode)
324                 goto out;
325
326         dprintk("%s: parent: %llu, inode: %llu.\n", __func__, parent->ino, ino);
327
328         pohmelfs_fill_inode(inode, info);
329         pohmelfs_put_inode(POHMELFS_I(inode));
330         err = -EEXIST;
331 out:
332         return err;
333 }
334
335 /*
336  * Readdir response from server. If special field is set, we wakeup
337  * listener (readdir() call), which will copy data to userspace.
338  */
339 static int pohmelfs_readdir_response(struct netfs_state *st)
340 {
341         struct inode *inode;
342         struct netfs_cmd *cmd = &st->cmd;
343         struct netfs_inode_info *info;
344         struct pohmelfs_inode *parent = NULL, *npi;
345         int err = 0, last = cmd->ext;
346         struct qstr str;
347
348         if (cmd->size > st->size)
349                 return -EINVAL;
350
351         inode = ilookup(st->psb->sb, cmd->id);
352         if (!inode) {
353                 printk("%s: failed to find inode: id: %llu.\n", __func__, cmd->id);
354                 return -ENOENT;
355         }
356         parent = POHMELFS_I(inode);
357
358         if (!cmd->size && cmd->start) {
359                 err = -cmd->start;
360                 goto out;
361         }
362
363         if (cmd->size) {
364                 char *name;
365
366                 err = pohmelfs_data_recv_and_check(st, st->data, cmd->size);
367                 if (err)
368                         goto err_out_put;
369
370                 info = (struct netfs_inode_info *)(st->data);
371
372                 name = (char *)(info + 1);
373                 str.len = cmd->size - sizeof(struct netfs_inode_info) - 1 - cmd->cpad;
374                 name[str.len] = 0;
375                 str.name = name;
376                 str.hash = jhash(str.name, str.len, 0);
377
378                 netfs_convert_inode_info(info);
379
380                 if (parent) {
381                         err = pohmelfs_check_name(parent, &str, info);
382                         if (err) {
383                                 if (err == -EEXIST)
384                                         err = 0;
385                                 goto out;
386                         }
387                 }
388
389                 info->ino = cmd->start;
390                 if (!info->ino)
391                         info->ino = pohmelfs_new_ino(st->psb);
392
393                 dprintk("%s: parent: %llu, ino: %llu, name: '%s', hash: %x, len: %u, mode: %o.\n",
394                                 __func__, parent->ino, info->ino, str.name, str.hash, str.len,
395                                 info->mode);
396
397                 npi = pohmelfs_new_inode(st->psb, parent, &str, info, 0);
398                 if (IS_ERR(npi)) {
399                         err = PTR_ERR(npi);
400
401                         if (err != -EEXIST)
402                                 goto err_out_put;
403                 } else {
404                         struct dentry *dentry, *alias, *pd;
405
406                         set_bit(NETFS_INODE_REMOTE_SYNCED, &npi->state);
407                         clear_bit(NETFS_INODE_OWNED, &npi->state);
408
409                         pd = d_find_alias(&parent->vfs_inode);
410                         if (pd) {
411                                 str.hash = full_name_hash(str.name, str.len);
412                                 dentry = d_alloc(pd, &str);
413                                 if (dentry) {
414                                         alias = d_materialise_unique(dentry, &npi->vfs_inode);
415                                         if (alias)
416                                                 dput(dentry);
417                                 }
418
419                                 dput(dentry);
420                                 dput(pd);
421                         }
422                 }
423         }
424 out:
425         if (last) {
426                 set_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &parent->state);
427                 set_bit(NETFS_INODE_REMOTE_SYNCED, &parent->state);
428                 wake_up(&st->psb->wait);
429         }
430         pohmelfs_put_inode(parent);
431
432         return err;
433
434 err_out_put:
435         clear_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &parent->state);
436         printk("%s: parent: %llu, ino: %llu, cmd_id: %llu.\n", __func__, parent->ino, cmd->start, cmd->id);
437         pohmelfs_put_inode(parent);
438         wake_up(&st->psb->wait);
439         return err;
440 }
441
442 /*
443  * Lookup command response.
444  * It searches for inode to be looked at (if it exists) and substitutes
445  * its inode information (size, permission, mode and so on), if inode does
446  * not exist, new one will be created and inserted into caches.
447  */
448 static int pohmelfs_lookup_response(struct netfs_state *st)
449 {
450         struct inode *inode = NULL;
451         struct netfs_cmd *cmd = &st->cmd;
452         struct netfs_inode_info *info;
453         struct pohmelfs_inode *parent = NULL, *npi;
454         int err = -EINVAL;
455         char *name;
456
457         inode = ilookup(st->psb->sb, cmd->id);
458         if (!inode) {
459                 printk("%s: lookup response: id: %llu, start: %llu, size: %u.\n",
460                                 __func__, cmd->id, cmd->start, cmd->size);
461                 err = -ENOENT;
462                 goto err_out_exit;
463         }
464         parent = POHMELFS_I(inode);
465
466         if (!cmd->size) {
467                 err = -cmd->start;
468                 goto err_out_put;
469         }
470
471         if (cmd->size < sizeof(struct netfs_inode_info)) {
472                 printk("%s: broken lookup response: id: %llu, start: %llu, size: %u.\n",
473                                 __func__, cmd->id, cmd->start, cmd->size);
474                 err = -EINVAL;
475                 goto err_out_put;
476         }
477
478         err = pohmelfs_data_recv_and_check(st, st->data, cmd->size);
479         if (err)
480                 goto err_out_put;
481
482         info = (struct netfs_inode_info *)(st->data);
483         name = (char *)(info + 1);
484
485         netfs_convert_inode_info(info);
486
487         info->ino = cmd->start;
488         if (!info->ino)
489                 info->ino = pohmelfs_new_ino(st->psb);
490
491         dprintk("%s: parent: %llu, ino: %llu, name: '%s', start: %llu.\n",
492                         __func__, parent->ino, info->ino, name, cmd->start);
493
494         if (cmd->start)
495                 npi = pohmelfs_new_inode(st->psb, parent, NULL, info, 0);
496         else {
497                 struct qstr str;
498
499                 str.name = name;
500                 str.len = cmd->size - sizeof(struct netfs_inode_info) - 1 - cmd->cpad;
501                 str.hash = jhash(name, str.len, 0);
502
503                 npi = pohmelfs_new_inode(st->psb, parent, &str, info, 0);
504         }
505         if (IS_ERR(npi)) {
506                 err = PTR_ERR(npi);
507
508                 if (err != -EEXIST)
509                         goto err_out_put;
510         } else {
511                 set_bit(NETFS_INODE_REMOTE_SYNCED, &npi->state);
512                 clear_bit(NETFS_INODE_OWNED, &npi->state);
513         }
514
515         clear_bit(NETFS_COMMAND_PENDING, &parent->state);
516         pohmelfs_put_inode(parent);
517
518         wake_up(&st->psb->wait);
519
520         return 0;
521
522 err_out_put:
523         pohmelfs_put_inode(parent);
524 err_out_exit:
525         clear_bit(NETFS_COMMAND_PENDING, &parent->state);
526         wake_up(&st->psb->wait);
527         printk("%s: inode: %p, id: %llu, start: %llu, size: %u, err: %d.\n",
528                         __func__, inode, cmd->id, cmd->start, cmd->size, err);
529         return err;
530 }
531
532 /*
533  * Create response, just marks local inode as 'created', so that writeback
534  * for any of its children (or own) would not try to sync it again.
535  */
536 static int pohmelfs_create_response(struct netfs_state *st)
537 {
538         struct inode *inode;
539         struct netfs_cmd *cmd = &st->cmd;
540         struct pohmelfs_inode *pi;
541
542         inode = ilookup(st->psb->sb, cmd->id);
543         if (!inode) {
544                 printk("%s: failed to find inode: id: %llu, start: %llu.\n",
545                                 __func__, cmd->id, cmd->start);
546                 goto err_out_exit;
547         }
548
549         pi = POHMELFS_I(inode);
550
551         /*
552          * To lock or not to lock?
553          * We actually do not care if it races...
554          */
555         if (cmd->start)
556                 make_bad_inode(inode);
557         set_bit(NETFS_INODE_REMOTE_SYNCED, &pi->state);
558
559         pohmelfs_put_inode(pi);
560
561         wake_up(&st->psb->wait);
562         return 0;
563
564 err_out_exit:
565         wake_up(&st->psb->wait);
566         return -ENOENT;
567 }
568
569 /*
570  * Object remove response. Just says that remove request has been received.
571  * Used in cache coherency protocol.
572  */
573 static int pohmelfs_remove_response(struct netfs_state *st)
574 {
575         struct netfs_cmd *cmd = &st->cmd;
576         int err;
577
578         err = pohmelfs_data_recv_and_check(st, st->data, cmd->size);
579         if (err)
580                 return err;
581
582         dprintk("%s: parent: %llu, path: '%s'.\n", __func__, cmd->id, (char *)st->data);
583
584         return 0;
585 }
586
587 /*
588  * Transaction reply processing.
589  *
590  * Find transaction based on its generation number, bump its reference counter,
591  * so that none could free it under us, drop from the trees and lists and
592  * drop reference counter. When it hits zero (when all destinations replied
593  * and all timeout handled by async scanning code), completion will be called
594  * and transaction will be freed.
595  */
596 static int pohmelfs_transaction_response(struct netfs_state *st)
597 {
598         struct netfs_trans_dst *dst;
599         struct netfs_trans *t = NULL;
600         struct netfs_cmd *cmd = &st->cmd;
601         short err = (signed)cmd->ext;
602
603         mutex_lock(&st->trans_lock);
604         dst = netfs_trans_search(st, cmd->start);
605         if (dst) {
606                 netfs_trans_remove_nolock(dst, st);
607                 t = dst->trans;
608         }
609         mutex_unlock(&st->trans_lock);
610
611         if (!t) {
612                 printk("%s: failed to find transaction: start: %llu: id: %llu, size: %u, ext: %u.\n",
613                                 __func__, cmd->start, cmd->id, cmd->size, cmd->ext);
614                 err = -EINVAL;
615                 goto out;
616         }
617
618         t->result = err;
619         netfs_trans_drop_dst_nostate(dst);
620
621 out:
622         wake_up(&st->psb->wait);
623         return err;
624 }
625
626 /*
627  * Inode metadata cache coherency message.
628  */
629 static int pohmelfs_page_cache_response(struct netfs_state *st)
630 {
631         struct netfs_cmd *cmd = &st->cmd;
632         struct inode *inode;
633
634         dprintk("%s: st: %p, id: %llu, start: %llu, size: %u.\n", __func__, st, cmd->id, cmd->start, cmd->size);
635
636         inode = ilookup(st->psb->sb, cmd->id);
637         if (!inode) {
638                 printk("%s: failed to find inode: id: %llu.\n", __func__, cmd->id);
639                 return -ENOENT;
640         }
641
642         set_bit(NETFS_INODE_NEED_FLUSH, &POHMELFS_I(inode)->state);
643         pohmelfs_put_inode(POHMELFS_I(inode));
644
645         return 0;
646 }
647
648 /*
649  * Root capabilities response: export statistics
650  * like used and available size, number of files and dirs,
651  * permissions.
652  */
653 static int pohmelfs_root_cap_response(struct netfs_state *st)
654 {
655         struct netfs_cmd *cmd = &st->cmd;
656         struct netfs_root_capabilities *cap;
657         struct pohmelfs_sb *psb = st->psb;
658
659         if (cmd->size != sizeof(struct netfs_root_capabilities)) {
660                 psb->flags = EPROTO;
661                 wake_up(&psb->wait);
662                 return -EPROTO;
663         }
664
665         cap = st->data;
666
667         netfs_convert_root_capabilities(cap);
668
669         if (psb->total_size < cap->used + cap->avail)
670                 psb->total_size = cap->used + cap->avail;
671         if (cap->avail)
672                 psb->avail_size = cap->avail;
673         psb->state_flags = cap->flags;
674
675         if (psb->state_flags & POHMELFS_FLAGS_RO) {
676                 psb->sb->s_flags |= MS_RDONLY;
677                 printk(KERN_INFO "Mounting POHMELFS (%d) read-only.\n", psb->idx);
678         }
679
680         if (psb->state_flags & POHMELFS_FLAGS_XATTR)
681                 printk(KERN_INFO "Mounting POHMELFS (%d) "
682                         "with extended attributes support.\n", psb->idx);
683
684         if (atomic_read(&psb->total_inodes) <= 1)
685                 atomic_long_set(&psb->total_inodes, cap->nr_files);
686
687         dprintk("%s: total: %llu, avail: %llu, flags: %llx, inodes: %llu.\n",
688                 __func__, psb->total_size, psb->avail_size, psb->state_flags, cap->nr_files);
689
690         psb->flags = 0;
691         wake_up(&psb->wait);
692         return 0;
693 }
694
695 /*
696  * Crypto capabilities of the server, where it says that
697  * it supports or does not requested hash/cipher algorithms.
698  */
699 static int pohmelfs_crypto_cap_response(struct netfs_state *st)
700 {
701         struct netfs_cmd *cmd = &st->cmd;
702         struct netfs_crypto_capabilities *cap;
703         struct pohmelfs_sb *psb = st->psb;
704         int err = 0;
705
706         if (cmd->size != sizeof(struct netfs_crypto_capabilities)) {
707                 psb->flags = EPROTO;
708                 wake_up(&psb->wait);
709                 return -EPROTO;
710         }
711
712         cap = st->data;
713
714         dprintk("%s: cipher '%s': %s, hash: '%s': %s.\n",
715                         __func__,
716                         psb->cipher_string, (cap->cipher_strlen)?"SUPPORTED":"NOT SUPPORTED",
717                         psb->hash_string, (cap->hash_strlen)?"SUPPORTED":"NOT SUPPORTED");
718
719         if (!cap->hash_strlen) {
720                 if (psb->hash_strlen && psb->crypto_fail_unsupported)
721                         err = -ENOTSUPP;
722                 psb->hash_strlen = 0;
723                 kfree(psb->hash_string);
724                 psb->hash_string = NULL;
725         }
726
727         if (!cap->cipher_strlen) {
728                 if (psb->cipher_strlen && psb->crypto_fail_unsupported)
729                         err = -ENOTSUPP;
730                 psb->cipher_strlen = 0;
731                 kfree(psb->cipher_string);
732                 psb->cipher_string = NULL;
733         }
734
735         return err;
736 }
737
738 /*
739  * Capabilities handshake response.
740  */
741 static int pohmelfs_capabilities_response(struct netfs_state *st)
742 {
743         struct netfs_cmd *cmd = &st->cmd;
744         int err = 0;
745
746         err = pohmelfs_data_recv(st, st->data, cmd->size);
747         if (err)
748                 return err;
749
750         switch (cmd->id) {
751                 case POHMELFS_CRYPTO_CAPABILITIES:
752                         return pohmelfs_crypto_cap_response(st);
753                 case POHMELFS_ROOT_CAPABILITIES:
754                         return pohmelfs_root_cap_response(st);
755                 default:
756                         break;
757         }
758         return -EINVAL;
759 }
760
761 /*
762  * Receiving extended attribute.
763  * Does not work properly if received size is more than requested one,
764  * it should not happen with current request/reply model though.
765  */
766 static int pohmelfs_getxattr_response(struct netfs_state *st)
767 {
768         struct pohmelfs_sb *psb = st->psb;
769         struct netfs_cmd *cmd = &st->cmd;
770         struct pohmelfs_mcache *m;
771         short error = (signed short)cmd->ext, err;
772         unsigned int sz, total_size;
773
774         m = pohmelfs_mcache_search(psb, cmd->id);
775
776         dprintk("%s: id: %llu, gen: %llu, err: %d.\n",
777                 __func__, cmd->id, (m)?m->gen:0, error);
778
779         if (!m) {
780                 printk("%s: failed to find getxattr cache entry: id: %llu.\n", __func__, cmd->id);
781                 return -ENOENT;
782         }
783
784         if (cmd->size) {
785                 sz = min_t(unsigned int, cmd->size, m->size);
786                 err = pohmelfs_data_recv_and_check(st, m->data, sz);
787                 if (err) {
788                         error = err;
789                         goto out;
790                 }
791
792                 m->size = sz;
793                 total_size = cmd->size - sz;
794
795                 while (total_size) {
796                         sz = min(total_size, st->size);
797
798                         err = pohmelfs_data_recv_and_check(st, st->data, sz);
799                         if (err) {
800                                 error = err;
801                                 break;
802                         }
803
804                         total_size -= sz;
805                 }
806         }
807
808 out:
809         m->err = error;
810         complete(&m->complete);
811         pohmelfs_mcache_put(psb, m);
812
813         return error;
814 }
815
816 int pohmelfs_data_lock_response(struct netfs_state *st)
817 {
818         struct pohmelfs_sb *psb = st->psb;
819         struct netfs_cmd *cmd = &st->cmd;
820         struct pohmelfs_mcache *m;
821         short err = (signed short)cmd->ext;
822         u64 id = cmd->id;
823
824         m = pohmelfs_mcache_search(psb, id);
825
826         dprintk("%s: id: %llu, gen: %llu, err: %d.\n",
827                 __func__, cmd->id, (m)?m->gen:0, err);
828
829         if (!m) {
830                 pohmelfs_data_recv(st, st->data, cmd->size);
831                 printk("%s: failed to find data lock response: id: %llu.\n", __func__, cmd->id);
832                 return -ENOENT;
833         }
834
835         if (cmd->size)
836                 err = pohmelfs_data_recv_and_check(st, &m->info, cmd->size);
837
838         m->err = err;
839         complete(&m->complete);
840         pohmelfs_mcache_put(psb, m);
841
842         return err;
843 }
844
845 static void __inline__ netfs_state_reset(struct netfs_state *st)
846 {
847         netfs_state_lock_send(st);
848         netfs_state_exit(st);
849         netfs_state_init(st);
850         netfs_state_unlock_send(st);
851 }
852
853 /*
854  * Main receiving function, called from dedicated kernel thread.
855  */
856 static int pohmelfs_recv(void *data)
857 {
858         int err = -EINTR;
859         struct netfs_state *st = data;
860         struct netfs_cmd *cmd = &st->cmd;
861
862         while (!kthread_should_stop()) {
863                 /*
864                  * If socket will be reset after this statement, then
865                  * pohmelfs_data_recv() will just fail and loop will
866                  * start again, so it can be done without any locks.
867                  *
868                  * st->read_socket is needed to prevents state machine
869                  * breaking between this data reading and subsequent one
870                  * in protocol specific functions during connection reset.
871                  * In case of reset we have to read next command and do
872                  * not expect data for old command to magically appear in
873                  * new connection.
874                  */
875                 st->read_socket = st->socket;
876                 err = pohmelfs_data_recv(st, cmd, sizeof(struct netfs_cmd));
877                 if (err) {
878                         msleep(1000);
879                         continue;
880                 }
881
882                 netfs_convert_cmd(cmd);
883
884                 dprintk("%s: cmd: %u, id: %llu, start: %llu, size: %u, "
885                                 "ext: %u, csize: %u, cpad: %u.\n",
886                                 __func__, cmd->cmd, cmd->id, cmd->start,
887                                 cmd->size, cmd->ext, cmd->csize, cmd->cpad);
888
889                 if (cmd->csize) {
890                         struct pohmelfs_crypto_engine *e = &st->eng;
891
892                         if (unlikely(cmd->csize > e->size/2)) {
893                                 netfs_state_reset(st);
894                                 continue;
895                         }
896
897                         if (e->hash && unlikely(cmd->csize != st->psb->crypto_attached_size)) {
898                                 dprintk("%s: cmd: cmd: %u, id: %llu, start: %llu, size: %u, "
899                                                 "csize: %u != digest size %u.\n",
900                                                 __func__, cmd->cmd, cmd->id, cmd->start, cmd->size,
901                                                 cmd->csize, st->psb->crypto_attached_size);
902                                 netfs_state_reset(st);
903                                 continue;
904                         }
905
906                         err = pohmelfs_data_recv(st, e->data, cmd->csize);
907                         if (err) {
908                                 netfs_state_reset(st);
909                                 continue;
910                         }
911
912 #ifdef CONFIG_POHMELFS_DEBUG
913                         {
914                                 unsigned int i;
915                                 unsigned char *hash = e->data;
916
917                                 dprintk("%s: received hash: ", __func__);
918                                 for (i=0; i<cmd->csize; ++i) {
919                                         printk("%02x ", hash[i]);
920                                 }
921                                 printk("\n");
922                         }
923 #endif
924                         cmd->size -= cmd->csize;
925                 }
926
927                 /*
928                  * This should catch protocol breakage and random garbage instead of commands.
929                  */
930                 if (unlikely((cmd->size > st->size) && (cmd->cmd != NETFS_XATTR_GET))) {
931                         netfs_state_reset(st);
932                         continue;
933                 }
934
935                 switch (cmd->cmd) {
936                         case NETFS_READ_PAGE:
937                                 err = pohmelfs_read_page_response(st);
938                                 break;
939                         case NETFS_READDIR:
940                                 err = pohmelfs_readdir_response(st);
941                                 break;
942                         case NETFS_LOOKUP:
943                                 err = pohmelfs_lookup_response(st);
944                                 break;
945                         case NETFS_CREATE:
946                                 err = pohmelfs_create_response(st);
947                                 break;
948                         case NETFS_REMOVE:
949                                 err = pohmelfs_remove_response(st);
950                                 break;
951                         case NETFS_TRANS:
952                                 err = pohmelfs_transaction_response(st);
953                                 break;
954                         case NETFS_PAGE_CACHE:
955                                 err = pohmelfs_page_cache_response(st);
956                                 break;
957                         case NETFS_CAPABILITIES:
958                                 err = pohmelfs_capabilities_response(st);
959                                 break;
960                         case NETFS_LOCK:
961                                 err = pohmelfs_data_lock_response(st);
962                                 break;
963                         case NETFS_XATTR_GET:
964                                 err = pohmelfs_getxattr_response(st);
965                                 break;
966                         default:
967                                 printk("%s: wrong cmd: %u, id: %llu, start: %llu, size: %u, ext: %u.\n",
968                                         __func__, cmd->cmd, cmd->id, cmd->start, cmd->size, cmd->ext);
969                                 netfs_state_reset(st);
970                                 break;
971                 }
972         }
973
974         while (!kthread_should_stop())
975                 schedule_timeout_uninterruptible(msecs_to_jiffies(10));
976
977         return err;
978 }
979
980 int netfs_state_init(struct netfs_state *st)
981 {
982         int err;
983         struct pohmelfs_ctl *ctl = &st->ctl;
984
985         err = sock_create(ctl->addr.sa_family, ctl->type, ctl->proto, &st->socket);
986         if (err) {
987                 printk("%s: failed to create a socket: family: %d, type: %d, proto: %d, err: %d.\n",
988                                 __func__, ctl->addr.sa_family, ctl->type, ctl->proto, err);
989                 goto err_out_exit;
990         }
991
992         st->socket->sk->sk_allocation = GFP_NOIO;
993         st->socket->sk->sk_sndtimeo = st->socket->sk->sk_rcvtimeo = msecs_to_jiffies(60000);
994
995         err = kernel_connect(st->socket, (struct sockaddr *)&ctl->addr, ctl->addrlen, 0);
996         if (err) {
997                 printk("%s: failed to connect to server: idx: %u, err: %d.\n",
998                                 __func__, st->psb->idx, err);
999                 goto err_out_release;
1000         }
1001         st->socket->sk->sk_sndtimeo = st->socket->sk->sk_rcvtimeo = msecs_to_jiffies(60000);
1002
1003         err = netfs_poll_init(st);
1004         if (err)
1005                 goto err_out_release;
1006
1007         if (st->socket->ops->family == AF_INET) {
1008                 struct sockaddr_in *sin = (struct sockaddr_in *)&ctl->addr;
1009                 printk(KERN_INFO "%s: (re)connected to peer %u.%u.%u.%u:%d.\n", __func__,
1010                         NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));
1011         } else if (st->socket->ops->family == AF_INET6) {
1012                 struct sockaddr_in6 *sin = (struct sockaddr_in6 *)&ctl->addr;
1013                 printk(KERN_INFO "%s: (re)connected to peer "
1014                         "%pi6:%d",
1015                         __func__, &sin->sin6_addr, ntohs(sin->sin6_port));
1016         }
1017
1018         return 0;
1019
1020 err_out_release:
1021         sock_release(st->socket);
1022 err_out_exit:
1023         st->socket = NULL;
1024         return err;
1025 }
1026
1027 void netfs_state_exit(struct netfs_state *st)
1028 {
1029         if (st->socket) {
1030                 netfs_poll_exit(st);
1031                 st->socket->ops->shutdown(st->socket, 2);
1032
1033                 if (st->socket->ops->family == AF_INET) {
1034                         struct sockaddr_in *sin = (struct sockaddr_in *)&st->ctl.addr;
1035                         printk("%s: disconnected from peer %u.%u.%u.%u:%d.\n", __func__,
1036                                 NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));
1037                 } else if (st->socket->ops->family == AF_INET6) {
1038                         struct sockaddr_in6 *sin = (struct sockaddr_in6 *)&st->ctl.addr;
1039                         printk("%s: disconnected from peer "
1040                                 "%pi6:%d",
1041                                 __func__, &sin->sin6_addr, ntohs(sin->sin6_port));
1042                 }
1043
1044                 sock_release(st->socket);
1045                 st->socket = NULL;
1046                 st->read_socket = NULL;
1047                 st->need_reset = 0;
1048         }
1049 }
1050
1051 int pohmelfs_state_init_one(struct pohmelfs_sb *psb, struct pohmelfs_config *conf)
1052 {
1053         struct netfs_state *st = &conf->state;
1054         int err = -ENOMEM;
1055
1056         mutex_init(&st->__state_lock);
1057         mutex_init(&st->__state_send_lock);
1058         init_waitqueue_head(&st->thread_wait);
1059
1060         st->psb = psb;
1061         st->trans_root = RB_ROOT;
1062         mutex_init(&st->trans_lock);
1063
1064         st->size = psb->trans_data_size;
1065         st->data = kmalloc(st->size, GFP_KERNEL);
1066         if (!st->data)
1067                 goto err_out_exit;
1068
1069         if (psb->perform_crypto) {
1070                 err = pohmelfs_crypto_engine_init(&st->eng, psb);
1071                 if (err)
1072                         goto err_out_free_data;
1073         }
1074
1075         err = netfs_state_init(st);
1076         if (err)
1077                 goto err_out_free_engine;
1078
1079         st->thread = kthread_run(pohmelfs_recv, st, "pohmelfs/%u", psb->idx);
1080         if (IS_ERR(st->thread)) {
1081                 err = PTR_ERR(st->thread);
1082                 goto err_out_netfs_exit;
1083         }
1084
1085         if (!psb->active_state)
1086                 psb->active_state = conf;
1087
1088         dprintk("%s: conf: %p, st: %p, socket: %p.\n",
1089                         __func__, conf, st, st->socket);
1090         return 0;
1091
1092 err_out_netfs_exit:
1093         netfs_state_exit(st);
1094 err_out_free_engine:
1095         pohmelfs_crypto_engine_exit(&st->eng);
1096 err_out_free_data:
1097         kfree(st->data);
1098 err_out_exit:
1099         return err;
1100
1101 }
1102
1103 void pohmelfs_state_flush_transactions(struct netfs_state *st)
1104 {
1105         struct rb_node *rb_node;
1106         struct netfs_trans_dst *dst;
1107
1108         mutex_lock(&st->trans_lock);
1109         for (rb_node = rb_first(&st->trans_root); rb_node; ) {
1110                 dst = rb_entry(rb_node, struct netfs_trans_dst, state_entry);
1111                 rb_node = rb_next(rb_node);
1112
1113                 dst->trans->result = -EINVAL;
1114                 netfs_trans_remove_nolock(dst, st);
1115                 netfs_trans_drop_dst_nostate(dst);
1116         }
1117         mutex_unlock(&st->trans_lock);
1118 }
1119
1120 static void pohmelfs_state_exit_one(struct pohmelfs_config *c)
1121 {
1122         struct netfs_state *st = &c->state;
1123
1124         dprintk("%s: exiting, st: %p.\n", __func__, st);
1125         if (st->thread) {
1126                 kthread_stop(st->thread);
1127                 st->thread = NULL;
1128         }
1129
1130         netfs_state_lock_send(st);
1131         netfs_state_exit(st);
1132         netfs_state_unlock_send(st);
1133
1134         pohmelfs_state_flush_transactions(st);
1135
1136         pohmelfs_crypto_engine_exit(&st->eng);
1137         kfree(st->data);
1138
1139         kfree(c);
1140 }
1141
1142 /*
1143  * Initialize network stack. It searches for given ID in global
1144  * configuration table, this contains information of the remote server
1145  * (address (any supported by socket interface) and port, protocol and so on).
1146  */
1147 int pohmelfs_state_init(struct pohmelfs_sb *psb)
1148 {
1149         int err = -ENOMEM;
1150
1151         err = pohmelfs_copy_config(psb);
1152         if (err) {
1153                 pohmelfs_state_exit(psb);
1154                 return err;
1155         }
1156
1157         return 0;
1158 }
1159
1160 void pohmelfs_state_exit(struct pohmelfs_sb *psb)
1161 {
1162         struct pohmelfs_config *c, *tmp;
1163
1164         list_for_each_entry_safe(c, tmp, &psb->state_list, config_entry) {
1165                 list_del(&c->config_entry);
1166                 pohmelfs_state_exit_one(c);
1167         }
1168 }
1169
1170 void pohmelfs_switch_active(struct pohmelfs_sb *psb)
1171 {
1172         struct pohmelfs_config *c = psb->active_state;
1173
1174         if (!list_empty(&psb->state_list)) {
1175                 if (c->config_entry.next != &psb->state_list) {
1176                         psb->active_state = list_entry(c->config_entry.next,
1177                                 struct pohmelfs_config, config_entry);
1178                 } else {
1179                         psb->active_state = list_entry(psb->state_list.next,
1180                                 struct pohmelfs_config, config_entry);
1181                 }
1182
1183                 dprintk("%s: empty: %d, active %p -> %p.\n",
1184                         __func__, list_empty(&psb->state_list), c,
1185                         psb->active_state);
1186         } else
1187                 psb->active_state = NULL;
1188 }
1189
1190 void pohmelfs_check_states(struct pohmelfs_sb *psb)
1191 {
1192         struct pohmelfs_config *c, *tmp;
1193         LIST_HEAD(delete_list);
1194
1195         mutex_lock(&psb->state_lock);
1196         list_for_each_entry_safe(c, tmp, &psb->state_list, config_entry) {
1197                 if (pohmelfs_config_check(c, psb->idx)) {
1198
1199                         if (psb->active_state == c)
1200                                 pohmelfs_switch_active(psb);
1201                         list_move(&c->config_entry, &delete_list);
1202                 }
1203         }
1204         pohmelfs_copy_config(psb);
1205         mutex_unlock(&psb->state_lock);
1206
1207         list_for_each_entry_safe(c, tmp, &delete_list, config_entry) {
1208                 list_del(&c->config_entry);
1209                 pohmelfs_state_exit_one(c);
1210         }
1211 }