drivers/staging/pohmelfs/trans.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/module.h>
  17 #include <linux/crypto.h>
  18 #include <linux/fs.h>
  19 #include <linux/jhash.h>
  20 #include <linux/hash.h>
  21 #include <linux/ktime.h>
  22 #include <linux/mempool.h>
  23 #include <linux/mm.h>
  24 #include <linux/mount.h>
  25 #include <linux/pagemap.h>
  26 #include <linux/parser.h>
  27 #include <linux/poll.h>
  28 #include <linux/swap.h>
  29 #include <linux/slab.h>
  30 #include <linux/statfs.h>
  31 #include <linux/writeback.h>
  32
  33 #include "netfs.h"
  34
  35 static struct kmem_cache *netfs_trans_dst;
  36 static mempool_t *netfs_trans_dst_pool;
  37
  38 static void netfs_trans_init_static(struct netfs_trans *t, int num, int size)
  39 {
  40         t->page_num = num;
  41         t->total_size = size;
  42         atomic_set(&t->refcnt, 1);
  43
  44         spin_lock_init(&t->dst_lock);
  45         INIT_LIST_HEAD(&t->dst_list);
  46 }
  47
  48 static int netfs_trans_send_pages(struct netfs_trans *t, struct netfs_state *st)
  49 {
  50         int err = 0;
  51         unsigned int i, attached_pages = t->attached_pages, ci;
  52         struct msghdr msg;
  53         struct page **pages = (t->eng)?t->eng->pages:t->pages;
  54         struct page *p;
  55         unsigned int size;
  56
  57         msg.msg_name = NULL;
  58         msg.msg_namelen = 0;
  59         msg.msg_control = NULL;
  60         msg.msg_controllen = 0;
  61         msg.msg_flags = MSG_WAITALL | MSG_MORE;
  62
  63         ci = 0;
  64         for (i=0; i<t->page_num; ++i) {
  65                 struct page *page = pages[ci];
  66                 struct netfs_cmd cmd;
  67                 struct iovec io;
  68
  69                 p = t->pages[i];
  70
  71                 if (!p)
  72                         continue;
  73
  74                 size = page_private(p);
  75
  76                 io.iov_base = &cmd;
  77                 io.iov_len = sizeof(struct netfs_cmd);
  78
  79                 cmd.cmd = NETFS_WRITE_PAGE;
  80                 cmd.ext = 0;
  81                 cmd.id = 0;
  82                 cmd.size = size;
  83                 cmd.start = p->index;
  84                 cmd.start <<= PAGE_CACHE_SHIFT;
  85                 cmd.csize = 0;
  86                 cmd.cpad = 0;
  87                 cmd.iv = pohmelfs_gen_iv(t);
  88
  89                 netfs_convert_cmd(&cmd);
  90
  91                 msg.msg_iov = &io;
  92                 msg.msg_iovlen = 1;
  93                 msg.msg_flags = MSG_WAITALL | MSG_MORE;
  94
  95                 err = kernel_sendmsg(st->socket, &msg, (struct kvec *)msg.msg_iov, 1, sizeof(struct netfs_cmd));
  96                 if (err <= 0) {
  97                         printk("%s: %d/%d failed to send transaction header: t: %p, gen: %u, err: %d.\n",
  98                                         __func__, i, t->page_num, t, t->gen, err);
  99                         if (err == 0)
 100                                 err = -ECONNRESET;
 101                         goto err_out;
 102                 }
 103
 104                 msg.msg_flags = MSG_WAITALL|(attached_pages == 1)?0:MSG_MORE;
 105
 106                 err = kernel_sendpage(st->socket, page, 0, size, msg.msg_flags);
 107                 if (err <= 0) {
 108                         printk("%s: %d/%d failed to send transaction page: t: %p, gen: %u, size: %u, err: %d.\n",
 109                                         __func__, i, t->page_num, t, t->gen, size, err);
 110                         if (err == 0)
 111                                 err = -ECONNRESET;
 112                         goto err_out;
 113                 }
 114
 115                 dprintk("%s: %d/%d sent t: %p, gen: %u, page: %p/%p, size: %u.\n",
 116                         __func__, i, t->page_num, t, t->gen, page, p, size);
 117
 118                 err = 0;
 119                 attached_pages--;
 120                 if (!attached_pages)
 121                         break;
 122                 ci++;
 123
 124                 continue;
 125
 126 err_out:
 127                 printk("%s: t: %p, gen: %u, err: %d.\n", __func__, t, t->gen, err);
 128                 netfs_state_exit(st);
 129                 break;
 130         }
 131
 132         return err;
 133 }
 134
 135 int netfs_trans_send(struct netfs_trans *t, struct netfs_state *st)
 136 {
 137         int err;
 138         struct msghdr msg;
 139
 140         BUG_ON(!t->iovec.iov_len);
 141         BUG_ON(t->iovec.iov_len > 1024*1024*1024);
 142
 143         netfs_state_lock_send(st);
 144         if (!st->socket) {
 145                 err = netfs_state_init(st);
 146                 if (err)
 147                         goto err_out_unlock_return;
 148         }
 149
 150         msg.msg_iov = &t->iovec;
 151         msg.msg_iovlen = 1;
 152         msg.msg_name = NULL;
 153         msg.msg_namelen = 0;
 154         msg.msg_control = NULL;
 155         msg.msg_controllen = 0;
 156         msg.msg_flags = MSG_WAITALL;
 157
 158         if (t->attached_pages)
 159                 msg.msg_flags |= MSG_MORE;
 160
 161         err = kernel_sendmsg(st->socket, &msg, (struct kvec *)msg.msg_iov, 1, t->iovec.iov_len);
 162         if (err <= 0) {
 163                 printk("%s: failed to send contig transaction: t: %p, gen: %u, size: %zu, err: %d.\n",
 164                                 __func__, t, t->gen, t->iovec.iov_len, err);
 165                 if (err == 0)
 166                         err = -ECONNRESET;
 167                 goto err_out_unlock_return;
 168         }
 169
 170         dprintk("%s: sent %s transaction: t: %p, gen: %u, size: %zu, page_num: %u.\n",
 171                         __func__, (t->page_num)?"partial":"full",
 172                         t, t->gen, t->iovec.iov_len, t->page_num);
 173
 174         err = 0;
 175         if (t->attached_pages)
 176                 err = netfs_trans_send_pages(t, st);
 177
 178 err_out_unlock_return:
 179
 180         if (st->need_reset) {
 181                 netfs_state_exit(st);
 182         }
 183         netfs_state_unlock_send(st);
 184
 185         dprintk("%s: t: %p, gen: %u, err: %d.\n",
 186                 __func__, t, t->gen, err);
 187
 188         t->result = err;
 189         return err;
 190 }
 191
 192 static inline int netfs_trans_cmp(unsigned int gen, unsigned int new)
 193 {
 194         if (gen < new)
 195                 return 1;
 196         if (gen > new)
 197                 return -1;
 198         return 0;
 199 }
 200
 201 struct netfs_trans_dst *netfs_trans_search(struct netfs_state *st, unsigned int gen)
 202 {
 203         struct rb_root *root = &st->trans_root;
 204         struct rb_node *n = root->rb_node;
 205         struct netfs_trans_dst *tmp, *ret = NULL;
 206         struct netfs_trans *t;
 207         int cmp;
 208
 209         while (n) {
 210                 tmp = rb_entry(n, struct netfs_trans_dst, state_entry);
 211                 t = tmp->trans;
 212
 213                 cmp = netfs_trans_cmp(t->gen, gen);
 214                 if (cmp < 0)
 215                         n = n->rb_left;
 216                 else if (cmp > 0)
 217                         n = n->rb_right;
 218                 else {
 219                         ret = tmp;
 220                         break;
 221                 }
 222         }
 223
 224         return ret;
 225 }
 226
 227 static int netfs_trans_insert(struct netfs_trans_dst *ndst, struct netfs_state *st)
 228 {
 229         struct rb_root *root = &st->trans_root;
 230         struct rb_node **n = &root->rb_node, *parent = NULL;
 231         struct netfs_trans_dst *ret = NULL, *tmp;
 232         struct netfs_trans *t = NULL, *new = ndst->trans;
 233         int cmp;
 234
 235         while (*n) {
 236                 parent = *n;
 237
 238                 tmp = rb_entry(parent, struct netfs_trans_dst, state_entry);
 239                 t = tmp->trans;
 240
 241                 cmp = netfs_trans_cmp(t->gen, new->gen);
 242                 if (cmp < 0)
 243                         n = &parent->rb_left;
 244                 else if (cmp > 0)
 245                         n = &parent->rb_right;
 246                 else {
 247                         ret = tmp;
 248                         break;
 249                 }
 250         }
 251
 252         if (ret) {
 253                 printk("%s: exist: old: gen: %u, flags: %x, send_time: %lu, "
 254                                 "new: gen: %u, flags: %x, send_time: %lu.\n",
 255                         __func__, t->gen, t->flags, ret->send_time,
 256                         new->gen, new->flags, ndst->send_time);
 257                 return -EEXIST;
 258         }
 259
 260         rb_link_node(&ndst->state_entry, parent, n);
 261         rb_insert_color(&ndst->state_entry, root);
 262         ndst->send_time = jiffies;
 263
 264         return 0;
 265 }
 266
 267 int netfs_trans_remove_nolock(struct netfs_trans_dst *dst, struct netfs_state *st)
 268 {
 269         if (dst && dst->state_entry.rb_parent_color) {
 270                 rb_erase(&dst->state_entry, &st->trans_root);
 271                 dst->state_entry.rb_parent_color = 0;
 272                 return 1;
 273         }
 274         return 0;
 275 }
 276
 277 static int netfs_trans_remove_state(struct netfs_trans_dst *dst)
 278 {
 279         int ret;
 280         struct netfs_state *st = dst->state;
 281
 282         mutex_lock(&st->trans_lock);
 283         ret = netfs_trans_remove_nolock(dst, st);
 284         mutex_unlock(&st->trans_lock);
 285
 286         return ret;
 287 }
 288
 289 /*
 290  * Create new destination for given transaction associated with given network state.
 291  * Transaction's reference counter is bumped and will be dropped when either
 292  * reply is received or when async timeout detection task will fail resending
 293  * and drop transaction.
 294  */
 295 static int netfs_trans_push_dst(struct netfs_trans *t, struct netfs_state *st)
 296 {
 297         struct netfs_trans_dst *dst;
 298         int err;
 299
 300         dst = mempool_alloc(netfs_trans_dst_pool, GFP_KERNEL);
 301         if (!dst)
 302                 return -ENOMEM;
 303
 304         dst->retries = 0;
 305         dst->send_time = 0;
 306         dst->state = st;
 307         dst->trans = t;
 308         netfs_trans_get(t);
 309
 310         mutex_lock(&st->trans_lock);
 311         err = netfs_trans_insert(dst, st);
 312         mutex_unlock(&st->trans_lock);
 313
 314         if (err)
 315                 goto err_out_free;
 316
 317         spin_lock(&t->dst_lock);
 318         list_add_tail(&dst->trans_entry, &t->dst_list);
 319         spin_unlock(&t->dst_lock);
 320
 321         return 0;
 322
 323 err_out_free:
 324         t->result = err;
 325         netfs_trans_put(t);
 326         mempool_free(dst, netfs_trans_dst_pool);
 327         return err;
 328 }
 329
 330 static void netfs_trans_free_dst(struct netfs_trans_dst *dst)
 331 {
 332         netfs_trans_put(dst->trans);
 333         mempool_free(dst, netfs_trans_dst_pool);
 334 }
 335
 336 static void netfs_trans_remove_dst(struct netfs_trans_dst *dst)
 337 {
 338         if (netfs_trans_remove_state(dst))
 339                 netfs_trans_free_dst(dst);
 340 }
 341
 342 /*
 343  * Drop destination transaction entry when we know it.
 344  */
 345 void netfs_trans_drop_dst(struct netfs_trans_dst *dst)
 346 {
 347         struct netfs_trans *t = dst->trans;
 348
 349         spin_lock(&t->dst_lock);
 350         list_del_init(&dst->trans_entry);
 351         spin_unlock(&t->dst_lock);
 352
 353         netfs_trans_remove_dst(dst);
 354 }
 355
 356 /*
 357  * Drop destination transaction entry when we know it and when we
 358  * already removed dst from state tree.
 359  */
 360 void netfs_trans_drop_dst_nostate(struct netfs_trans_dst *dst)
 361 {
 362         struct netfs_trans *t = dst->trans;
 363
 364         spin_lock(&t->dst_lock);
 365         list_del_init(&dst->trans_entry);
 366         spin_unlock(&t->dst_lock);
 367
 368         netfs_trans_free_dst(dst);
 369 }
 370
 371 /*
 372  * This drops destination transaction entry from appropriate network state
 373  * tree and drops related reference counter. It is possible that transaction
 374  * will be freed here if its reference counter hits zero.
 375  * Destination transaction entry will be freed.
 376  */
 377 void netfs_trans_drop_trans(struct netfs_trans *t, struct netfs_state *st)
 378 {
 379         struct netfs_trans_dst *dst, *tmp, *ret = NULL;
 380
 381         spin_lock(&t->dst_lock);
 382         list_for_each_entry_safe(dst, tmp, &t->dst_list, trans_entry) {
 383                 if (dst->state == st) {
 384                         ret = dst;
 385                         list_del(&dst->trans_entry);
 386                         break;
 387                 }
 388         }
 389         spin_unlock(&t->dst_lock);
 390
 391         if (ret)
 392                 netfs_trans_remove_dst(ret);
 393 }
 394
 395 /*
 396  * This drops destination transaction entry from appropriate network state
 397  * tree and drops related reference counter. It is possible that transaction
 398  * will be freed here if its reference counter hits zero.
 399  * Destination transaction entry will be freed.
 400  */
 401 void netfs_trans_drop_last(struct netfs_trans *t, struct netfs_state *st)
 402 {
 403         struct netfs_trans_dst *dst, *tmp, *ret;
 404
 405         spin_lock(&t->dst_lock);
 406         ret = list_entry(t->dst_list.prev, struct netfs_trans_dst, trans_entry);
 407         if (ret->state != st) {
 408                 ret = NULL;
 409                 list_for_each_entry_safe(dst, tmp, &t->dst_list, trans_entry) {
 410                         if (dst->state == st) {
 411                                 ret = dst;
 412                                 list_del_init(&dst->trans_entry);
 413                                 break;
 414                         }
 415                 }
 416         } else {
 417                 list_del(&ret->trans_entry);
 418         }
 419         spin_unlock(&t->dst_lock);
 420
 421         if (ret)
 422                 netfs_trans_remove_dst(ret);
 423 }
 424
 425 static int netfs_trans_push(struct netfs_trans *t, struct netfs_state *st)
 426 {
 427         int err;
 428
 429         err = netfs_trans_push_dst(t, st);
 430         if (err)
 431                 return err;
 432
 433         err = netfs_trans_send(t, st);
 434         if (err)
 435                 goto err_out_free;
 436
 437         if (t->flags & NETFS_TRANS_SINGLE_DST)
 438                 pohmelfs_switch_active(st->psb);
 439
 440         return 0;
 441
 442 err_out_free:
 443         t->result = err;
 444         netfs_trans_drop_last(t, st);
 445
 446         return err;
 447 }
 448
 449 int netfs_trans_finish_send(struct netfs_trans *t, struct pohmelfs_sb *psb)
 450 {
 451         struct pohmelfs_config *c;
 452         int err = -ENODEV;
 453         struct netfs_state *st;
 454 #if 0
 455         dprintk("%s: t: %p, gen: %u, size: %u, page_num: %u, active: %p.\n",
 456                 __func__, t, t->gen, t->iovec.iov_len, t->page_num, psb->active_state);
 457 #endif
 458         mutex_lock(&psb->state_lock);
 459         list_for_each_entry(c, &psb->state_list, config_entry) {
 460                 st = &c->state;
 461
 462                 if (t->flags & NETFS_TRANS_SINGLE_DST) {
 463                         if (!(st->ctl.perm & POHMELFS_IO_PERM_READ))
 464                                 continue;
 465                 } else {
 466                         if (!(st->ctl.perm & POHMELFS_IO_PERM_WRITE))
 467                                 continue;
 468                 }
 469
 470                 err = netfs_trans_push(t, st);
 471                 if (!err && (t->flags & NETFS_TRANS_SINGLE_DST))
 472                         break;
 473         }
 474
 475         mutex_unlock(&psb->state_lock);
 476 #if 0
 477         dprintk("%s: fully sent t: %p, gen: %u, size: %u, page_num: %u, err: %d.\n",
 478                 __func__, t, t->gen, t->iovec.iov_len, t->page_num, err);
 479 #endif
 480         if (err)
 481                 t->result = err;
 482         return err;
 483 }
 484
 485 int netfs_trans_finish(struct netfs_trans *t, struct pohmelfs_sb *psb)
 486 {
 487         int err;
 488         struct netfs_cmd *cmd = t->iovec.iov_base;
 489
 490         t->gen = atomic_inc_return(&psb->trans_gen);
 491
 492         cmd->size = t->iovec.iov_len - sizeof(struct netfs_cmd) +
 493                 t->attached_size + t->attached_pages * sizeof(struct netfs_cmd);
 494         cmd->cmd = NETFS_TRANS;
 495         cmd->start = t->gen;
 496         cmd->id = 0;
 497
 498         if (psb->perform_crypto) {
 499                 cmd->ext = psb->crypto_attached_size;
 500                 cmd->csize = psb->crypto_attached_size;
 501         }
 502
 503         dprintk("%s: t: %u, size: %u, iov_len: %zu, attached_size: %u, attached_pages: %u.\n",
 504                         __func__, t->gen, cmd->size, t->iovec.iov_len, t->attached_size, t->attached_pages);
 505         err = pohmelfs_trans_crypt(t, psb);
 506         if (err) {
 507                 t->result = err;
 508                 netfs_convert_cmd(cmd);
 509                 dprintk("%s: trans: %llu, crypto_attached_size: %u, attached_size: %u, attached_pages: %d, trans_size: %u, err: %d.\n",
 510                         __func__, cmd->start, psb->crypto_attached_size, t->attached_size, t->attached_pages, cmd->size, err);
 511         }
 512         netfs_trans_put(t);
 513         return err;
 514 }
 515
 516 /*
 517  * Resend transaction to remote server(s).
 518  * If new servers were added into superblock, we can try to send data
 519  * to them too.
 520  *
 521  * It is called under superblock's state_lock, so we can safely
 522  * dereference psb->state_list. Also, transaction's reference counter is
 523  * bumped, so it can not go away under us, thus we can safely access all
 524  * its members. State is locked.
 525  *
 526  * This function returns 0 if transaction was successfully sent to at
 527  * least one destination target.
 528  */
 529 int netfs_trans_resend(struct netfs_trans *t, struct pohmelfs_sb *psb)
 530 {
 531         struct netfs_trans_dst *dst;
 532         struct netfs_state *st;
 533         struct pohmelfs_config *c;
 534         int err, exist, error = -ENODEV;
 535
 536         list_for_each_entry(c, &psb->state_list, config_entry) {
 537                 st = &c->state;
 538
 539                 exist = 0;
 540                 spin_lock(&t->dst_lock);
 541                 list_for_each_entry(dst, &t->dst_list, trans_entry) {
 542                         if (st == dst->state) {
 543                                 exist = 1;
 544                                 break;
 545                         }
 546                 }
 547                 spin_unlock(&t->dst_lock);
 548
 549                 if (exist) {
 550                         if (!(t->flags & NETFS_TRANS_SINGLE_DST) ||
 551                                         (c->config_entry.next == &psb->state_list)) {
 552                                 dprintk("%s: resending st: %p, t: %p, gen: %u.\n",
 553                                                 __func__, st, t, t->gen);
 554                                 err = netfs_trans_send(t, st);
 555                                 if (!err)
 556                                         error = 0;
 557                         }
 558                         continue;
 559                 }
 560
 561                 dprintk("%s: pushing/resending st: %p, t: %p, gen: %u.\n",
 562                                 __func__, st, t, t->gen);
 563                 err = netfs_trans_push(t, st);
 564                 if (err)
 565                         continue;
 566                 error = 0;
 567                 if (t->flags & NETFS_TRANS_SINGLE_DST)
 568                         break;
 569         }
 570
 571         t->result = error;
 572         return error;
 573 }
 574
 575 void *netfs_trans_add(struct netfs_trans *t, unsigned int size)
 576 {
 577         struct iovec *io = &t->iovec;
 578         void *ptr;
 579
 580         if (size > t->total_size) {
 581                 ptr = ERR_PTR(-EINVAL);
 582                 goto out;
 583         }
 584
 585         if (io->iov_len + size > t->total_size) {
 586                 dprintk("%s: too big size t: %p, gen: %u, iov_len: %zu, size: %u, total: %u.\n",
 587                                 __func__, t, t->gen, io->iov_len, size, t->total_size);
 588                 ptr = ERR_PTR(-E2BIG);
 589                 goto out;
 590         }
 591
 592         ptr = io->iov_base + io->iov_len;
 593         io->iov_len += size;
 594
 595 out:
 596         dprintk("%s: t: %p, gen: %u, size: %u, total: %zu.\n",
 597                 __func__, t, t->gen, size, io->iov_len);
 598         return ptr;
 599 }
 600
 601 void netfs_trans_free(struct netfs_trans *t)
 602 {
 603         if (t->eng)
 604                 pohmelfs_crypto_thread_make_ready(t->eng->thread);
 605         kfree(t);
 606 }
 607
 608 struct netfs_trans *netfs_trans_alloc(struct pohmelfs_sb *psb, unsigned int size,
 609                 unsigned int flags, unsigned int nr)
 610 {
 611         struct netfs_trans *t;
 612         unsigned int num, cont, pad, size_no_trans;
 613         unsigned int crypto_added = 0;
 614         struct netfs_cmd *cmd;
 615
 616         if (psb->perform_crypto)
 617                 crypto_added = psb->crypto_attached_size;
 618
 619         /*
 620          * |sizeof(struct netfs_trans)|
 621          * |sizeof(struct netfs_cmd)| - transaction header
 622          * |size| - buffer with requested size
 623          * |padding| - crypto padding, zero bytes
 624          * |nr * sizeof(struct page *)| - array of page pointers
 625          *
 626          * Overall size should be less than PAGE_SIZE for guaranteed allocation.
 627          */
 628
 629         cont = size;
 630         size = ALIGN(size, psb->crypto_align_size);
 631         pad = size - cont;
 632
 633         size_no_trans = size + sizeof(struct netfs_cmd) * 2 + crypto_added;
 634
 635         cont = sizeof(struct netfs_trans) + size_no_trans;
 636
 637         num = (PAGE_SIZE - cont)/sizeof(struct page *);
 638
 639         if (nr > num)
 640                 nr = num;
 641
 642         t = kzalloc(cont + nr*sizeof(struct page *), GFP_NOIO);
 643         if (!t)
 644                 goto err_out_exit;
 645
 646         t->iovec.iov_base = (void *)(t + 1);
 647         t->pages = (struct page **)(t->iovec.iov_base + size_no_trans);
 648
 649         /*
 650          * Reserving space for transaction header.
 651          */
 652         t->iovec.iov_len = sizeof(struct netfs_cmd) + crypto_added;
 653
 654         netfs_trans_init_static(t, nr, size_no_trans);
 655
 656         t->flags = flags;
 657         t->psb = psb;
 658
 659         cmd = (struct netfs_cmd *)t->iovec.iov_base;
 660
 661         cmd->size = size;
 662         cmd->cpad = pad;
 663         cmd->csize = crypto_added;
 664
 665         dprintk("%s: t: %p, gen: %u, size: %u, padding: %u, align_size: %u, flags: %x, "
 666                         "page_num: %u, base: %p, pages: %p.\n",
 667                         __func__, t, t->gen, size, pad, psb->crypto_align_size, flags, nr,
 668                         t->iovec.iov_base, t->pages);
 669
 670         return t;
 671
 672 err_out_exit:
 673         return NULL;
 674 }
 675
 676 int netfs_trans_init(void)
 677 {
 678         int err = -ENOMEM;
 679
 680         netfs_trans_dst = kmem_cache_create("netfs_trans_dst", sizeof(struct netfs_trans_dst),
 681                         0, 0, NULL);
 682         if (!netfs_trans_dst)
 683                 goto err_out_exit;
 684
 685         netfs_trans_dst_pool = mempool_create_slab_pool(256, netfs_trans_dst);
 686         if (!netfs_trans_dst_pool)
 687                 goto err_out_free;
 688
 689         return 0;
 690
 691 err_out_free:
 692         kmem_cache_destroy(netfs_trans_dst);
 693 err_out_exit:
 694         return err;
 695 }
 696
 697 void netfs_trans_exit(void)
 698 {
 699         mempool_destroy(netfs_trans_dst_pool);
 700         kmem_cache_destroy(netfs_trans_dst);
 701 }