drivers/staging/pohmelfs/netfs.h

   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 #ifndef __NETFS_H
  17 #define __NETFS_H
  18
  19 #include <linux/types.h>
  20 #include <linux/connector.h>
  21 #include <linux/backing-dev.h>
  22
  23 #define POHMELFS_CN_IDX                 5
  24 #define POHMELFS_CN_VAL                 0
  25
  26 #define POHMELFS_CTLINFO_ACK            1
  27 #define POHMELFS_NOINFO_ACK             2
  28
  29 #define POHMELFS_NULL_IDX               65535
  30
  31 /*
  32  * Network command structure.
  33  * Will be extended.
  34  */
  35 struct netfs_cmd {
  36         __u16                   cmd;    /* Command number */
  37         __u16                   csize;  /* Attached crypto information size */
  38         __u16                   cpad;   /* Attached padding size */
  39         __u16                   ext;    /* External flags */
  40         __u32                   size;   /* Size of the attached data */
  41         __u32                   trans;  /* Transaction id */
  42         __u64                   id;     /* Object ID to operate on. Used for feedback.*/
  43         __u64                   start;  /* Start of the object. */
  44         __u64                   iv;     /* IV sequence */
  45         __u8                    data[0];
  46 };
  47
  48 static inline void netfs_convert_cmd(struct netfs_cmd *cmd)
  49 {
  50         cmd->id = __be64_to_cpu(cmd->id);
  51         cmd->start = __be64_to_cpu(cmd->start);
  52         cmd->iv = __be64_to_cpu(cmd->iv);
  53         cmd->cmd = __be16_to_cpu(cmd->cmd);
  54         cmd->ext = __be16_to_cpu(cmd->ext);
  55         cmd->csize = __be16_to_cpu(cmd->csize);
  56         cmd->cpad = __be16_to_cpu(cmd->cpad);
  57         cmd->size = __be32_to_cpu(cmd->size);
  58 }
  59
  60 #define NETFS_TRANS_SINGLE_DST          (1<<0)
  61
  62 enum {
  63         NETFS_READDIR   = 1,    /* Read directory for given inode number */
  64         NETFS_READ_PAGE,        /* Read data page from the server */
  65         NETFS_WRITE_PAGE,       /* Write data page to the server */
  66         NETFS_CREATE,           /* Create directory entry */
  67         NETFS_REMOVE,           /* Remove directory entry */
  68
  69         NETFS_LOOKUP,           /* Lookup single object */
  70         NETFS_LINK,             /* Create a link */
  71         NETFS_TRANS,            /* Transaction */
  72         NETFS_OPEN,             /* Open intent */
  73         NETFS_INODE_INFO,       /* Metadata cache coherency synchronization message */
  74
  75         NETFS_PAGE_CACHE,       /* Page cache invalidation message */
  76         NETFS_READ_PAGES,       /* Read multiple contiguous pages in one go */
  77         NETFS_RENAME,           /* Rename object */
  78         NETFS_CAPABILITIES,     /* Capabilities of the client, for example supported crypto */
  79         NETFS_LOCK,             /* Distributed lock message */
  80
  81         NETFS_XATTR_SET,        /* Set extended attribute */
  82         NETFS_XATTR_GET,        /* Get extended attribute */
  83         NETFS_CMD_MAX
  84 };
  85
  86 enum {
  87         POHMELFS_FLAGS_ADD = 0, /* Network state control message for ADD */
  88         POHMELFS_FLAGS_DEL,     /* Network state control message for DEL */
  89         POHMELFS_FLAGS_SHOW,    /* Network state control message for SHOW */
  90         POHMELFS_FLAGS_CRYPTO,  /* Crypto data control message */
  91         POHMELFS_FLAGS_MODIFY,  /* Network state modification message */
  92         POHMELFS_FLAGS_DUMP,    /* Network state control message for SHOW ALL */
  93         POHMELFS_FLAGS_FLUSH,   /* Network state control message for FLUSH */
  94 };
  95
  96 /*
  97  * Always wanted to copy it from socket headers into public one,
  98  * since they are __KERNEL__ protected there.
  99  */
 100 #define _K_SS_MAXSIZE   128
 101
 102 struct saddr {
 103         unsigned short          sa_family;
 104         char                    addr[_K_SS_MAXSIZE];
 105 };
 106
 107 enum {
 108         POHMELFS_CRYPTO_HASH = 0,
 109         POHMELFS_CRYPTO_CIPHER,
 110 };
 111
 112 struct pohmelfs_crypto {
 113         unsigned int            idx;            /* Config index */
 114         unsigned short          strlen;         /* Size of the attached crypto string including 0-byte
 115                                                  * "cbc(aes)" for example */
 116         unsigned short          type;           /* HMAC, cipher, both */
 117         unsigned int            keysize;        /* Key size */
 118         unsigned char           data[0];        /* Algorithm string, key and IV */
 119 };
 120
 121 #define POHMELFS_IO_PERM_READ           (1<<0)
 122 #define POHMELFS_IO_PERM_WRITE          (1<<1)
 123
 124 /*
 125  * Configuration command used to create table of different remote servers.
 126  */
 127 struct pohmelfs_ctl {
 128         __u32                   idx;            /* Config index */
 129         __u32                   type;           /* Socket type */
 130         __u32                   proto;          /* Socket protocol */
 131         __u16                   addrlen;        /* Size of the address */
 132         __u16                   perm;           /* IO permission */
 133         __u16                   prio;           /* IO priority */
 134         struct saddr            addr;           /* Remote server address */
 135 };
 136
 137 /*
 138  * Ack for userspace about requested command.
 139  */
 140 struct pohmelfs_cn_ack {
 141         struct cn_msg           msg;
 142         int                     error;
 143         int                     msg_num;
 144         int                     unused[3];
 145         struct pohmelfs_ctl     ctl;
 146 };
 147
 148 /*
 149  * Inode info structure used to sync with server.
 150  * Check what stat() returns.
 151  */
 152 struct netfs_inode_info {
 153         unsigned int            mode;
 154         unsigned int            nlink;
 155         unsigned int            uid;
 156         unsigned int            gid;
 157         unsigned int            blocksize;
 158         unsigned int            padding;
 159         __u64                   ino;
 160         __u64                   blocks;
 161         __u64                   rdev;
 162         __u64                   size;
 163         __u64                   version;
 164 };
 165
 166 static inline void netfs_convert_inode_info(struct netfs_inode_info *info)
 167 {
 168         info->mode = __cpu_to_be32(info->mode);
 169         info->nlink = __cpu_to_be32(info->nlink);
 170         info->uid = __cpu_to_be32(info->uid);
 171         info->gid = __cpu_to_be32(info->gid);
 172         info->blocksize = __cpu_to_be32(info->blocksize);
 173         info->blocks = __cpu_to_be64(info->blocks);
 174         info->rdev = __cpu_to_be64(info->rdev);
 175         info->size = __cpu_to_be64(info->size);
 176         info->version = __cpu_to_be64(info->version);
 177         info->ino = __cpu_to_be64(info->ino);
 178 }
 179
 180 /*
 181  * Cache state machine.
 182  */
 183 enum {
 184         NETFS_COMMAND_PENDING = 0,      /* Command is being executed */
 185         NETFS_INODE_REMOTE_SYNCED,      /* Inode was synced to server */
 186         NETFS_INODE_REMOTE_DIR_SYNCED,  /* Inode (directory) was synced from the server */
 187         NETFS_INODE_OWNED,              /* Inode is owned by given host */
 188         NETFS_INODE_NEED_FLUSH,         /* Inode has to be flushed to the server */
 189 };
 190
 191 /*
 192  * POHMELFS capabilities: information about supported
 193  * crypto operations (hash/cipher, modes, key sizes and so on),
 194  * root informaion (used/available size, number of objects, permissions)
 195  */
 196 enum pohmelfs_capabilities {
 197         POHMELFS_CRYPTO_CAPABILITIES = 0,
 198         POHMELFS_ROOT_CAPABILITIES,
 199 };
 200
 201 /* Read-only mount */
 202 #define POHMELFS_FLAGS_RO               (1<<0)
 203 /* Extended attributes support on/off */
 204 #define POHMELFS_FLAGS_XATTR            (1<<1)
 205
 206 struct netfs_root_capabilities {
 207         __u64                   nr_files;
 208         __u64                   used, avail;
 209         __u64                   flags;
 210 };
 211
 212 static inline void netfs_convert_root_capabilities(struct netfs_root_capabilities *cap)
 213 {
 214         cap->nr_files = __cpu_to_be64(cap->nr_files);
 215         cap->used = __cpu_to_be64(cap->used);
 216         cap->avail = __cpu_to_be64(cap->avail);
 217         cap->flags = __cpu_to_be64(cap->flags);
 218 }
 219
 220 struct netfs_crypto_capabilities {
 221         unsigned short          hash_strlen;    /* Hash string length, like "hmac(sha1) including 0 byte "*/
 222         unsigned short          cipher_strlen;  /* Cipher string length with the same format */
 223         unsigned int            cipher_keysize; /* Cipher key size */
 224 };
 225
 226 static inline void netfs_convert_crypto_capabilities(struct netfs_crypto_capabilities *cap)
 227 {
 228         cap->hash_strlen = __cpu_to_be16(cap->hash_strlen);
 229         cap->cipher_strlen = __cpu_to_be16(cap->cipher_strlen);
 230         cap->cipher_keysize = __cpu_to_be32(cap->cipher_keysize);
 231 }
 232
 233 enum pohmelfs_lock_type {
 234         POHMELFS_LOCK_GRAB      = (1<<15),
 235
 236         POHMELFS_READ_LOCK      = 0,
 237         POHMELFS_WRITE_LOCK,
 238 };
 239
 240 struct netfs_lock {
 241         __u64                   start;
 242         __u64                   ino;
 243         __u32                   size;
 244         __u32                   type;
 245 };
 246
 247 static inline void netfs_convert_lock(struct netfs_lock *lock)
 248 {
 249         lock->start = __cpu_to_be64(lock->start);
 250         lock->ino = __cpu_to_be64(lock->ino);
 251         lock->size = __cpu_to_be32(lock->size);
 252         lock->type = __cpu_to_be32(lock->type);
 253 }
 254
 255 #ifdef __KERNEL__
 256
 257 #include <linux/kernel.h>
 258 #include <linux/completion.h>
 259 #include <linux/rbtree.h>
 260 #include <linux/net.h>
 261 #include <linux/poll.h>
 262
 263 /*
 264  * Private POHMELFS cache of objects in directory.
 265  */
 266 struct pohmelfs_name {
 267         struct rb_node          hash_node;
 268
 269         struct list_head        sync_create_entry;
 270
 271         u64                     ino;
 272
 273         u32                     hash;
 274         u32                     mode;
 275         u32                     len;
 276
 277         char                    *data;
 278 };
 279
 280 /*
 281  * POHMELFS inode. Main object.
 282  */
 283 struct pohmelfs_inode {
 284         struct list_head        inode_entry;            /* Entry in superblock list.
 285                                                          * Objects which are not bound to dentry require to be dropped
 286                                                          * in ->put_super()
 287                                                          */
 288         struct rb_root          hash_root;              /* The same, but indexed by name hash and len */
 289         struct mutex            offset_lock;            /* Protect both above trees */
 290
 291         struct list_head        sync_create_list;       /* List of created but not yet synced to the server children */
 292
 293         unsigned int            drop_count;
 294
 295         int                     lock_type;              /* How this inode is locked: read or write */
 296
 297         int                     error;                  /* Transaction error for given inode */
 298
 299         long                    state;                  /* State machine above */
 300
 301         u64                     ino;                    /* Inode number */
 302         u64                     total_len;              /* Total length of all children names, used to create offsets */
 303
 304         struct inode            vfs_inode;
 305 };
 306
 307 struct netfs_trans;
 308 typedef int (*netfs_trans_complete_t)(struct page **pages, unsigned int page_num,
 309                 void *private, int err);
 310
 311 struct netfs_state;
 312 struct pohmelfs_sb;
 313
 314 struct netfs_trans {
 315         /*
 316          * Transaction header and attached contiguous data live here.
 317          */
 318         struct iovec                    iovec;
 319
 320         /*
 321          * Pages attached to transaction.
 322          */
 323         struct page                     **pages;
 324
 325         /*
 326          * List and protecting lock for transaction destination
 327          * network states.
 328          */
 329         spinlock_t                      dst_lock;
 330         struct list_head                dst_list;
 331
 332         /*
 333          * Number of users for given transaction.
 334          * For example each network state attached to transaction
 335          * via dst_list increases it.
 336          */
 337         atomic_t                        refcnt;
 338
 339         /*
 340          * Number of pages attached to given transaction.
 341          * Some slots in above page array can be NULL, since
 342          * for example page can be under writeback already,
 343          * so we skip it in this transaction.
 344          */
 345         unsigned int                    page_num;
 346
 347         /*
 348          * Transaction flags: single dst or broadcast and so on.
 349          */
 350         unsigned int                    flags;
 351
 352         /*
 353          * Size of the data, which can be placed into
 354          * iovec.iov_base area.
 355          */
 356         unsigned int                    total_size;
 357
 358         /*
 359          * Number of pages to be sent to remote server.
 360          * Usually equal to above page_num, but in case of partial
 361          * writeback it can accumulate only pages already completed
 362          * previous writeback.
 363          */
 364         unsigned int                    attached_pages;
 365
 366         /*
 367          * Attached number of bytes in all above pages.
 368          */
 369         unsigned int                    attached_size;
 370
 371         /*
 372          * Unique transacton generation number.
 373          * Used as identity in the network state tree of transactions.
 374          */
 375         unsigned int                    gen;
 376
 377         /*
 378          * Transaction completion status.
 379          */
 380         int                             result;
 381
 382         /*
 383          * Superblock this transaction belongs to
 384          */
 385         struct pohmelfs_sb              *psb;
 386
 387         /*
 388          * Crypto engine, which processed this transaction.
 389          * Can be not NULL only if crypto engine holds encrypted pages.
 390          */
 391         struct pohmelfs_crypto_engine   *eng;
 392
 393         /* Private data */
 394         void                            *private;
 395
 396         /* Completion callback, invoked just before transaction is destroyed */
 397         netfs_trans_complete_t          complete;
 398 };
 399
 400 static inline int netfs_trans_cur_len(struct netfs_trans *t)
 401 {
 402         return (signed)(t->total_size - t->iovec.iov_len);
 403 }
 404
 405 static inline void *netfs_trans_current(struct netfs_trans *t)
 406 {
 407         return t->iovec.iov_base + t->iovec.iov_len;
 408 }
 409
 410 struct netfs_trans *netfs_trans_alloc(struct pohmelfs_sb *psb, unsigned int size,
 411                 unsigned int flags, unsigned int nr);
 412 void netfs_trans_free(struct netfs_trans *t);
 413 int netfs_trans_finish(struct netfs_trans *t, struct pohmelfs_sb *psb);
 414 int netfs_trans_finish_send(struct netfs_trans *t, struct pohmelfs_sb *psb);
 415
 416 static inline void netfs_trans_reset(struct netfs_trans *t)
 417 {
 418         t->complete = NULL;
 419 }
 420
 421 struct netfs_trans_dst {
 422         struct list_head                trans_entry;
 423         struct rb_node                  state_entry;
 424
 425         unsigned long                   send_time;
 426
 427         /*
 428          * Times this transaction was resent to its old or new,
 429          * depending on flags, destinations. When it reaches maximum
 430          * allowed number, specified in superblock->trans_retries,
 431          * transaction will be freed with ETIMEDOUT error.
 432          */
 433         unsigned int                    retries;
 434
 435         struct netfs_trans              *trans;
 436         struct netfs_state              *state;
 437 };
 438
 439 struct netfs_trans_dst *netfs_trans_search(struct netfs_state *st, unsigned int gen);
 440 void netfs_trans_drop_dst(struct netfs_trans_dst *dst);
 441 void netfs_trans_drop_dst_nostate(struct netfs_trans_dst *dst);
 442 void netfs_trans_drop_trans(struct netfs_trans *t, struct netfs_state *st);
 443 void netfs_trans_drop_last(struct netfs_trans *t, struct netfs_state *st);
 444 int netfs_trans_resend(struct netfs_trans *t, struct pohmelfs_sb *psb);
 445 int netfs_trans_remove_nolock(struct netfs_trans_dst *dst, struct netfs_state *st);
 446
 447 int netfs_trans_init(void);
 448 void netfs_trans_exit(void);
 449
 450 struct pohmelfs_crypto_engine {
 451         u64                             iv;             /* Crypto IV for current operation */
 452         unsigned long                   timeout;        /* Crypto waiting timeout */
 453         unsigned int                    size;           /* Size of crypto scratchpad */
 454         void                            *data;          /* Temporal crypto scratchpad */
 455         /*
 456          * Crypto operations performed on objects.
 457          */
 458         struct crypto_hash              *hash;
 459         struct crypto_ablkcipher        *cipher;
 460
 461         struct pohmelfs_crypto_thread   *thread;        /* Crypto thread which hosts this engine */
 462
 463         struct page                     **pages;
 464         unsigned int                    page_num;
 465 };
 466
 467 struct pohmelfs_crypto_thread {
 468         struct list_head                thread_entry;
 469
 470         struct task_struct              *thread;
 471         struct pohmelfs_sb              *psb;
 472
 473         struct pohmelfs_crypto_engine   eng;
 474
 475         struct netfs_trans              *trans;
 476
 477         wait_queue_head_t               wait;
 478         int                             error;
 479
 480         unsigned int                    size;
 481         struct page                     *page;
 482 };
 483
 484 void pohmelfs_crypto_thread_make_ready(struct pohmelfs_crypto_thread *th);
 485
 486 /*
 487  * Network state, attached to one server.
 488  */
 489 struct netfs_state {
 490         struct mutex            __state_lock;           /* Can not allow to use the same socket simultaneously */
 491         struct mutex            __state_send_lock;
 492         struct netfs_cmd        cmd;                    /* Cached command */
 493         struct netfs_inode_info info;                   /* Cached inode info */
 494
 495         void                    *data;                  /* Cached some data */
 496         unsigned int            size;                   /* Size of that data */
 497
 498         struct pohmelfs_sb      *psb;                   /* Superblock */
 499
 500         struct task_struct      *thread;                /* Async receiving thread */
 501
 502         /* Waiting/polling machinery */
 503         wait_queue_t            wait;
 504         wait_queue_head_t       *whead;
 505         wait_queue_head_t       thread_wait;
 506
 507         struct mutex            trans_lock;
 508         struct rb_root          trans_root;
 509
 510         struct pohmelfs_ctl     ctl;                    /* Remote peer */
 511
 512         struct socket           *socket;                /* Socket object */
 513         struct socket           *read_socket;           /* Cached pointer to socket object.
 514                                                          * Used to determine if between lock drops socket was changed.
 515                                                          * Never used to read data or any kind of access.
 516                                                          */
 517         /*
 518          * Crypto engines to process incoming data.
 519          */
 520         struct pohmelfs_crypto_engine   eng;
 521
 522         int                     need_reset;
 523 };
 524
 525 int netfs_state_init(struct netfs_state *st);
 526 void netfs_state_exit(struct netfs_state *st);
 527
 528 static inline void netfs_state_lock_send(struct netfs_state *st)
 529 {
 530         mutex_lock(&st->__state_send_lock);
 531 }
 532
 533 static inline int netfs_state_trylock_send(struct netfs_state *st)
 534 {
 535         return mutex_trylock(&st->__state_send_lock);
 536 }
 537
 538 static inline void netfs_state_unlock_send(struct netfs_state *st)
 539 {
 540         BUG_ON(!mutex_is_locked(&st->__state_send_lock));
 541
 542         mutex_unlock(&st->__state_send_lock);
 543 }
 544
 545 static inline void netfs_state_lock(struct netfs_state *st)
 546 {
 547         mutex_lock(&st->__state_lock);
 548 }
 549
 550 static inline void netfs_state_unlock(struct netfs_state *st)
 551 {
 552         BUG_ON(!mutex_is_locked(&st->__state_lock));
 553
 554         mutex_unlock(&st->__state_lock);
 555 }
 556
 557 static inline unsigned int netfs_state_poll(struct netfs_state *st)
 558 {
 559         unsigned int revents = POLLHUP | POLLERR;
 560
 561         netfs_state_lock(st);
 562         if (st->socket)
 563                 revents = st->socket->ops->poll(NULL, st->socket, NULL);
 564         netfs_state_unlock(st);
 565
 566         return revents;
 567 }
 568
 569 struct pohmelfs_config;
 570
 571 struct pohmelfs_sb {
 572         struct rb_root          mcache_root;
 573         struct mutex            mcache_lock;
 574         atomic_long_t           mcache_gen;
 575         unsigned long           mcache_timeout;
 576
 577         unsigned int            idx;
 578
 579         unsigned int            trans_retries;
 580
 581         atomic_t                trans_gen;
 582
 583         unsigned int            crypto_attached_size;
 584         unsigned int            crypto_align_size;
 585
 586         unsigned int            crypto_fail_unsupported;
 587
 588         unsigned int            crypto_thread_num;
 589         struct list_head        crypto_active_list, crypto_ready_list;
 590         struct mutex            crypto_thread_lock;
 591
 592         unsigned int            trans_max_pages;
 593         unsigned long           trans_data_size;
 594         unsigned long           trans_timeout;
 595
 596         unsigned long           drop_scan_timeout;
 597         unsigned long           trans_scan_timeout;
 598
 599         unsigned long           wait_on_page_timeout;
 600
 601         struct list_head        flush_list;
 602         struct list_head        drop_list;
 603         spinlock_t              ino_lock;
 604         u64                     ino;
 605
 606         /*
 607          * Remote nodes POHMELFS connected to.
 608          */
 609         struct list_head        state_list;
 610         struct mutex            state_lock;
 611
 612         /*
 613          * Currently active state to request data from.
 614          */
 615         struct pohmelfs_config  *active_state;
 616
 617
 618         wait_queue_head_t       wait;
 619
 620         /*
 621          * Timed checks: stale transactions, inodes to be freed and so on.
 622          */
 623         struct delayed_work     dwork;
 624         struct delayed_work     drop_dwork;
 625
 626         struct super_block      *sb;
 627
 628         struct backing_dev_info bdi;
 629
 630         /*
 631          * Algorithm strings.
 632          */
 633         char                    *hash_string;
 634         char                    *cipher_string;
 635
 636         u8                      *hash_key;
 637         u8                      *cipher_key;
 638
 639         /*
 640          * Algorithm string lengths.
 641          */
 642         unsigned int            hash_strlen;
 643         unsigned int            cipher_strlen;
 644         unsigned int            hash_keysize;
 645         unsigned int            cipher_keysize;
 646
 647         /*
 648          * Controls whether to perfrom crypto processing or not.
 649          */
 650         int                     perform_crypto;
 651
 652         /*
 653          * POHMELFS statistics.
 654          */
 655         u64                     total_size;
 656         u64                     avail_size;
 657         atomic_long_t           total_inodes;
 658
 659         /*
 660          * Xattr support, read-only and so on.
 661          */
 662         u64                     state_flags;
 663
 664         /*
 665          * Temporary storage to detect changes in the wait queue.
 666          */
 667         long                    flags;
 668 };
 669
 670 static inline void netfs_trans_update(struct netfs_cmd *cmd,
 671                 struct netfs_trans *t, unsigned int size)
 672 {
 673         unsigned int sz = ALIGN(size, t->psb->crypto_align_size);
 674
 675         t->iovec.iov_len += sizeof(struct netfs_cmd) + sz;
 676         cmd->cpad = __cpu_to_be16(sz - size);
 677 }
 678
 679 static inline struct pohmelfs_sb *POHMELFS_SB(struct super_block *sb)
 680 {
 681         return sb->s_fs_info;
 682 }
 683
 684 static inline struct pohmelfs_inode *POHMELFS_I(struct inode *inode)
 685 {
 686         return container_of(inode, struct pohmelfs_inode, vfs_inode);
 687 }
 688
 689 static inline u64 pohmelfs_new_ino(struct pohmelfs_sb *psb)
 690 {
 691         u64 ino;
 692
 693         spin_lock(&psb->ino_lock);
 694         ino = psb->ino++;
 695         spin_unlock(&psb->ino_lock);
 696
 697         return ino;
 698 }
 699
 700 static inline void pohmelfs_put_inode(struct pohmelfs_inode *pi)
 701 {
 702         struct pohmelfs_sb *psb = POHMELFS_SB(pi->vfs_inode.i_sb);
 703
 704         spin_lock(&psb->ino_lock);
 705         list_move_tail(&pi->inode_entry, &psb->drop_list);
 706         pi->drop_count++;
 707         spin_unlock(&psb->ino_lock);
 708 }
 709
 710 struct pohmelfs_config {
 711         struct list_head        config_entry;
 712
 713         struct netfs_state      state;
 714 };
 715
 716 struct pohmelfs_config_group {
 717         /*
 718          * Entry in the global config group list.
 719          */
 720         struct list_head        group_entry;
 721
 722         /*
 723          * Index of the current group.
 724          */
 725         unsigned int            idx;
 726         /*
 727          * Number of config_list entries in this group entry.
 728          */
 729         unsigned int            num_entry;
 730         /*
 731          * Algorithm strings.
 732          */
 733         char                    *hash_string;
 734         char                    *cipher_string;
 735
 736         /*
 737          * Algorithm string lengths.
 738          */
 739         unsigned int            hash_strlen;
 740         unsigned int            cipher_strlen;
 741
 742         /*
 743          * Key and its size.
 744          */
 745         unsigned int            hash_keysize;
 746         unsigned int            cipher_keysize;
 747         u8                      *hash_key;
 748         u8                      *cipher_key;
 749
 750         /*
 751          * List of config entries (network state info) for given idx.
 752          */
 753         struct list_head        config_list;
 754 };
 755
 756 int __init pohmelfs_config_init(void);
 757 void pohmelfs_config_exit(void);
 758 int pohmelfs_copy_config(struct pohmelfs_sb *psb);
 759 int pohmelfs_copy_crypto(struct pohmelfs_sb *psb);
 760 int pohmelfs_config_check(struct pohmelfs_config *config, int idx);
 761 int pohmelfs_state_init_one(struct pohmelfs_sb *psb, struct pohmelfs_config *conf);
 762
 763 extern const struct file_operations pohmelfs_dir_fops;
 764 extern const struct inode_operations pohmelfs_dir_inode_ops;
 765
 766 int pohmelfs_state_init(struct pohmelfs_sb *psb);
 767 void pohmelfs_state_exit(struct pohmelfs_sb *psb);
 768 void pohmelfs_state_flush_transactions(struct netfs_state *st);
 769
 770 void pohmelfs_fill_inode(struct inode *inode, struct netfs_inode_info *info);
 771
 772 void pohmelfs_name_del(struct pohmelfs_inode *parent, struct pohmelfs_name *n);
 773 void pohmelfs_free_names(struct pohmelfs_inode *parent);
 774 struct pohmelfs_name *pohmelfs_search_hash(struct pohmelfs_inode *pi, u32 hash);
 775
 776 void pohmelfs_inode_del_inode(struct pohmelfs_sb *psb, struct pohmelfs_inode *pi);
 777
 778 struct pohmelfs_inode *pohmelfs_create_entry_local(struct pohmelfs_sb *psb,
 779         struct pohmelfs_inode *parent, struct qstr *str, u64 start, int mode);
 780
 781 int pohmelfs_write_create_inode(struct pohmelfs_inode *pi);
 782
 783 int pohmelfs_write_inode_create(struct inode *inode, struct netfs_trans *trans);
 784 int pohmelfs_remove_child(struct pohmelfs_inode *parent, struct pohmelfs_name *n);
 785
 786 struct pohmelfs_inode *pohmelfs_new_inode(struct pohmelfs_sb *psb,
 787                 struct pohmelfs_inode *parent, struct qstr *str,
 788                 struct netfs_inode_info *info, int link);
 789
 790 int pohmelfs_setattr(struct dentry *dentry, struct iattr *attr);
 791 int pohmelfs_setattr_raw(struct inode *inode, struct iattr *attr);
 792
 793 int pohmelfs_meta_command(struct pohmelfs_inode *pi, unsigned int cmd_op, unsigned int flags,
 794                 netfs_trans_complete_t complete, void *priv, u64 start);
 795 int pohmelfs_meta_command_data(struct pohmelfs_inode *pi, u64 id, unsigned int cmd_op, char *addon,
 796                 unsigned int flags, netfs_trans_complete_t complete, void *priv, u64 start);
 797
 798 void pohmelfs_check_states(struct pohmelfs_sb *psb);
 799 void pohmelfs_switch_active(struct pohmelfs_sb *psb);
 800
 801 int pohmelfs_construct_path_string(struct pohmelfs_inode *pi, void *data, int len);
 802 int pohmelfs_path_length(struct pohmelfs_inode *pi);
 803
 804 struct pohmelfs_crypto_completion {
 805         struct completion       complete;
 806         int                     error;
 807 };
 808
 809 int pohmelfs_trans_crypt(struct netfs_trans *t, struct pohmelfs_sb *psb);
 810 void pohmelfs_crypto_exit(struct pohmelfs_sb *psb);
 811 int pohmelfs_crypto_init(struct pohmelfs_sb *psb);
 812
 813 int pohmelfs_crypto_engine_init(struct pohmelfs_crypto_engine *e, struct pohmelfs_sb *psb);
 814 void pohmelfs_crypto_engine_exit(struct pohmelfs_crypto_engine *e);
 815
 816 int pohmelfs_crypto_process_input_data(struct pohmelfs_crypto_engine *e, u64 iv,
 817                 void *data, struct page *page, unsigned int size);
 818 int pohmelfs_crypto_process_input_page(struct pohmelfs_crypto_engine *e,
 819                 struct page *page, unsigned int size, u64 iv);
 820
 821 static inline u64 pohmelfs_gen_iv(struct netfs_trans *t)
 822 {
 823         u64 iv = t->gen;
 824
 825         iv <<= 32;
 826         iv |= ((unsigned long)t) & 0xffffffff;
 827
 828         return iv;
 829 }
 830
 831 int pohmelfs_data_lock(struct pohmelfs_inode *pi, u64 start, u32 size, int type);
 832 int pohmelfs_data_unlock(struct pohmelfs_inode *pi, u64 start, u32 size, int type);
 833 int pohmelfs_data_lock_response(struct netfs_state *st);
 834
 835 static inline int pohmelfs_need_lock(struct pohmelfs_inode *pi, int type)
 836 {
 837         if (test_bit(NETFS_INODE_OWNED, &pi->state)) {
 838                 if (type == pi->lock_type)
 839                         return 0;
 840                 if ((type == POHMELFS_READ_LOCK) && (pi->lock_type == POHMELFS_WRITE_LOCK))
 841                         return 0;
 842         }
 843
 844         if (!test_bit(NETFS_INODE_REMOTE_SYNCED, &pi->state))
 845                 return 0;
 846
 847         return 1;
 848 }
 849
 850 int __init pohmelfs_mcache_init(void);
 851 void pohmelfs_mcache_exit(void);
 852
 853 /* #define CONFIG_POHMELFS_DEBUG */
 854
 855 #ifdef CONFIG_POHMELFS_DEBUG
 856 #define dprintka(f, a...) printk(f, ##a)
 857 #define dprintk(f, a...) printk("%d: " f, task_pid_vnr(current), ##a)
 858 #else
 859 #define dprintka(f, a...) do {} while (0)
 860 #define dprintk(f, a...) do {} while (0)
 861 #endif
 862
 863 static inline void netfs_trans_get(struct netfs_trans *t)
 864 {
 865         atomic_inc(&t->refcnt);
 866 }
 867
 868 static inline void netfs_trans_put(struct netfs_trans *t)
 869 {
 870         if (atomic_dec_and_test(&t->refcnt)) {
 871                 dprintk("%s: t: %p, gen: %u, err: %d.\n",
 872                         __func__, t, t->gen, t->result);
 873                 if (t->complete)
 874                         t->complete(t->pages, t->page_num,
 875                                 t->private, t->result);
 876                 netfs_trans_free(t);
 877         }
 878 }
 879
 880 struct pohmelfs_mcache {
 881         struct rb_node                  mcache_entry;
 882         struct completion               complete;
 883
 884         atomic_t                        refcnt;
 885
 886         u64                             gen;
 887
 888         void                            *data;
 889         u64                             start;
 890         u32                             size;
 891         int                             err;
 892
 893         struct netfs_inode_info         info;
 894 };
 895
 896 struct pohmelfs_mcache *pohmelfs_mcache_alloc(struct pohmelfs_sb *psb, u64 start,
 897                 unsigned int size, void *data);
 898 void pohmelfs_mcache_free(struct pohmelfs_sb *psb, struct pohmelfs_mcache *m);
 899 struct pohmelfs_mcache *pohmelfs_mcache_search(struct pohmelfs_sb *psb, u64 gen);
 900 void pohmelfs_mcache_remove_locked(struct pohmelfs_sb *psb, struct pohmelfs_mcache *m);
 901
 902 static inline void pohmelfs_mcache_get(struct pohmelfs_mcache *m)
 903 {
 904         atomic_inc(&m->refcnt);
 905 }
 906
 907 static inline void pohmelfs_mcache_put(struct pohmelfs_sb *psb,
 908                 struct pohmelfs_mcache *m)
 909 {
 910         if (atomic_dec_and_test(&m->refcnt))
 911                 pohmelfs_mcache_free(psb, m);
 912 }
 913
 914 /*#define POHMELFS_TRUNCATE_ON_INODE_FLUSH
 915  */
 916
 917 #endif /* __KERNEL__*/
 918
 919 #endif /* __NETFS_H */