2 * 2007+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
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.
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.
19 #include <linux/types.h>
20 #include <linux/connector.h>
22 #define POHMELFS_CN_IDX 5
23 #define POHMELFS_CN_VAL 0
25 #define POHMELFS_CTLINFO_ACK 1
26 #define POHMELFS_NOINFO_ACK 2
30 * Network command structure.
35 __u16 cmd
; /* Command number */
36 __u16 csize
; /* Attached crypto information size */
37 __u16 cpad
; /* Attached padding size */
38 __u16 ext
; /* External flags */
39 __u32 size
; /* Size of the attached data */
40 __u32 trans
; /* Transaction id */
41 __u64 id
; /* Object ID to operate on. Used for feedback.*/
42 __u64 start
; /* Start of the object. */
43 __u64 iv
; /* IV sequence */
47 static inline void netfs_convert_cmd(struct netfs_cmd
*cmd
)
49 cmd
->id
= __be64_to_cpu(cmd
->id
);
50 cmd
->start
= __be64_to_cpu(cmd
->start
);
51 cmd
->iv
= __be64_to_cpu(cmd
->iv
);
52 cmd
->cmd
= __be16_to_cpu(cmd
->cmd
);
53 cmd
->ext
= __be16_to_cpu(cmd
->ext
);
54 cmd
->csize
= __be16_to_cpu(cmd
->csize
);
55 cmd
->cpad
= __be16_to_cpu(cmd
->cpad
);
56 cmd
->size
= __be32_to_cpu(cmd
->size
);
59 #define NETFS_TRANS_SINGLE_DST (1<<0)
62 NETFS_READDIR
= 1, /* Read directory for given inode number */
63 NETFS_READ_PAGE
, /* Read data page from the server */
64 NETFS_WRITE_PAGE
, /* Write data page to the server */
65 NETFS_CREATE
, /* Create directory entry */
66 NETFS_REMOVE
, /* Remove directory entry */
68 NETFS_LOOKUP
, /* Lookup single object */
69 NETFS_LINK
, /* Create a link */
70 NETFS_TRANS
, /* Transaction */
71 NETFS_OPEN
, /* Open intent */
72 NETFS_INODE_INFO
, /* Metadata cache coherency synchronization message */
74 NETFS_PAGE_CACHE
, /* Page cache invalidation message */
75 NETFS_READ_PAGES
, /* Read multiple contiguous pages in one go */
76 NETFS_RENAME
, /* Rename object */
77 NETFS_CAPABILITIES
, /* Capabilities of the client, for example supported crypto */
78 NETFS_LOCK
, /* Distributed lock message */
80 NETFS_XATTR_SET
, /* Set extended attribute */
81 NETFS_XATTR_GET
, /* Get extended attribute */
86 POHMELFS_FLAGS_ADD
= 0, /* Network state control message for ADD */
87 POHMELFS_FLAGS_DEL
, /* Network state control message for DEL */
88 POHMELFS_FLAGS_SHOW
, /* Network state control message for SHOW */
89 POHMELFS_FLAGS_CRYPTO
, /* Crypto data control message */
93 * Always wanted to copy it from socket headers into public one,
94 * since they are __KERNEL__ protected there.
96 #define _K_SS_MAXSIZE 128
100 unsigned short sa_family
;
101 char addr
[_K_SS_MAXSIZE
];
105 POHMELFS_CRYPTO_HASH
= 0,
106 POHMELFS_CRYPTO_CIPHER
,
109 struct pohmelfs_crypto
111 unsigned int idx
; /* Config index */
112 unsigned short strlen
; /* Size of the attached crypto string including 0-byte
113 * "cbc(aes)" for example */
114 unsigned short type
; /* HMAC, cipher, both */
115 unsigned int keysize
; /* Key size */
116 unsigned char data
[0]; /* Algorithm string, key and IV */
120 * Configuration command used to create table of different remote servers.
124 unsigned int idx
; /* Config index */
125 unsigned int type
; /* Socket type */
126 unsigned int proto
; /* Socket protocol */
127 unsigned int addrlen
; /* Size of the address */
128 unsigned short unused
; /* Align structure by 4 bytes */
129 struct saddr addr
; /* Remote server address */
133 * Ack for userspace about requested command.
135 struct pohmelfs_cn_ack
141 struct pohmelfs_ctl ctl
;
145 * Inode info structure used to sync with server.
146 * Check what stat() returns.
148 struct netfs_inode_info
154 unsigned int blocksize
;
155 unsigned int padding
;
163 static inline void netfs_convert_inode_info(struct netfs_inode_info
*info
)
165 info
->mode
= __cpu_to_be32(info
->mode
);
166 info
->nlink
= __cpu_to_be32(info
->nlink
);
167 info
->uid
= __cpu_to_be32(info
->uid
);
168 info
->gid
= __cpu_to_be32(info
->gid
);
169 info
->blocksize
= __cpu_to_be32(info
->blocksize
);
170 info
->blocks
= __cpu_to_be64(info
->blocks
);
171 info
->rdev
= __cpu_to_be64(info
->rdev
);
172 info
->size
= __cpu_to_be64(info
->size
);
173 info
->version
= __cpu_to_be64(info
->version
);
174 info
->ino
= __cpu_to_be64(info
->ino
);
178 * Cache state machine.
181 NETFS_COMMAND_PENDING
= 0, /* Command is being executed */
182 NETFS_INODE_REMOTE_SYNCED
, /* Inode was synced to server */
183 NETFS_INODE_REMOTE_DIR_SYNCED
, /* Inode (directory) was synced from the server */
184 NETFS_INODE_OWNED
, /* Inode is owned by given host */
185 NETFS_INODE_NEED_FLUSH
, /* Inode has to be flushed to the server */
189 * POHMELFS capabilities: information about supported
190 * crypto operations (hash/cipher, modes, key sizes and so on),
191 * root informaion (used/available size, number of objects, permissions)
193 enum pohmelfs_capabilities
{
194 POHMELFS_CRYPTO_CAPABILITIES
= 0,
195 POHMELFS_ROOT_CAPABILITIES
,
198 /* Read-only mount */
199 #define POHMELFS_FLAGS_RO (1<<0)
200 /* Extended attributes support on/off */
201 #define POHMELFS_FLAGS_XATTR (1<<1)
203 struct netfs_root_capabilities
210 static inline void netfs_convert_root_capabilities(struct netfs_root_capabilities
*cap
)
212 cap
->nr_files
= __cpu_to_be64(cap
->nr_files
);
213 cap
->used
= __cpu_to_be64(cap
->used
);
214 cap
->avail
= __cpu_to_be64(cap
->avail
);
215 cap
->flags
= __cpu_to_be64(cap
->flags
);
218 struct netfs_crypto_capabilities
220 unsigned short hash_strlen
; /* Hash string length, like "hmac(sha1) including 0 byte "*/
221 unsigned short cipher_strlen
; /* Cipher string length with the same format */
222 unsigned int cipher_keysize
; /* Cipher key size */
225 static inline void netfs_convert_crypto_capabilities(struct netfs_crypto_capabilities
*cap
)
227 cap
->hash_strlen
= __cpu_to_be16(cap
->hash_strlen
);
228 cap
->cipher_strlen
= __cpu_to_be16(cap
->cipher_strlen
);
229 cap
->cipher_keysize
= __cpu_to_be32(cap
->cipher_keysize
);
232 enum pohmelfs_lock_type
{
233 POHMELFS_LOCK_GRAB
= (1<<15),
235 POHMELFS_READ_LOCK
= 0,
247 static inline void netfs_convert_lock(struct netfs_lock
*lock
)
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
);
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>
264 * Private POHMELFS cache of objects in directory.
268 struct rb_node hash_node
;
270 struct list_head sync_create_entry
;
282 * POHMELFS inode. Main object.
284 struct pohmelfs_inode
286 struct list_head inode_entry
; /* Entry in superblock list.
287 * Objects which are not bound to dentry require to be dropped
290 struct rb_root hash_root
; /* The same, but indexed by name hash and len */
291 struct mutex offset_lock
; /* Protect both above trees */
293 struct list_head sync_create_list
; /* List of created but not yet synced to the server children */
295 unsigned int drop_count
;
297 int lock_type
; /* How this inode is locked: read or write */
299 int error
; /* Transaction error for given inode */
301 long state
; /* State machine above */
303 u64 ino
; /* Inode number */
304 u64 total_len
; /* Total length of all children names, used to create offsets */
306 struct inode vfs_inode
;
310 typedef int (* netfs_trans_complete_t
)(struct page
**pages
, unsigned int page_num
,
311 void *private, int err
);
319 * Transaction header and attached contiguous data live here.
324 * Pages attached to transaction.
329 * List and protecting lock for transaction destination
333 struct list_head dst_list
;
336 * Number of users for given transaction.
337 * For example each network state attached to transaction
338 * via dst_list increases it.
343 * Number of pages attached to given transaction.
344 * Some slots in above page array can be NULL, since
345 * for example page can be under writeback already,
346 * so we skip it in this transaction.
348 unsigned int page_num
;
351 * Transaction flags: single dst or broadcast and so on.
356 * Size of the data, which can be placed into
357 * iovec.iov_base area.
359 unsigned int total_size
;
362 * Number of pages to be sent to remote server.
363 * Usually equal to above page_num, but in case of partial
364 * writeback it can accumulate only pages already completed
365 * previous writeback.
367 unsigned int attached_pages
;
370 * Attached number of bytes in all above pages.
372 unsigned int attached_size
;
375 * Unique transacton generation number.
376 * Used as identity in the network state tree of transactions.
381 * Transaction completion status.
386 * Superblock this transaction belongs to
388 struct pohmelfs_sb
*psb
;
391 * Crypto engine, which processed this transaction.
392 * Can be not NULL only if crypto engine holds encrypted pages.
394 struct pohmelfs_crypto_engine
*eng
;
399 /* Completion callback, invoked just before transaction is destroyed */
400 netfs_trans_complete_t complete
;
403 static inline int netfs_trans_cur_len(struct netfs_trans
*t
)
405 return (signed)(t
->total_size
- t
->iovec
.iov_len
);
408 static inline void *netfs_trans_current(struct netfs_trans
*t
)
410 return t
->iovec
.iov_base
+ t
->iovec
.iov_len
;
413 struct netfs_trans
*netfs_trans_alloc(struct pohmelfs_sb
*psb
, unsigned int size
,
414 unsigned int flags
, unsigned int nr
);
415 void netfs_trans_free(struct netfs_trans
*t
);
416 int netfs_trans_finish(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
417 int netfs_trans_finish_send(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
419 static inline void netfs_trans_reset(struct netfs_trans
*t
)
424 struct netfs_trans_dst
426 struct list_head trans_entry
;
427 struct rb_node state_entry
;
429 unsigned long send_time
;
432 * Times this transaction was resent to its old or new,
433 * depending on flags, destinations. When it reaches maximum
434 * allowed number, specified in superblock->trans_retries,
435 * transaction will be freed with ETIMEDOUT error.
437 unsigned int retries
;
439 struct netfs_trans
*trans
;
440 struct netfs_state
*state
;
443 struct netfs_trans_dst
*netfs_trans_search(struct netfs_state
*st
, unsigned int gen
);
444 void netfs_trans_drop_dst(struct netfs_trans_dst
*dst
);
445 void netfs_trans_drop_dst_nostate(struct netfs_trans_dst
*dst
);
446 void netfs_trans_drop_trans(struct netfs_trans
*t
, struct netfs_state
*st
);
447 void netfs_trans_drop_last(struct netfs_trans
*t
, struct netfs_state
*st
);
448 int netfs_trans_resend(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
449 int netfs_trans_remove_nolock(struct netfs_trans_dst
*dst
, struct netfs_state
*st
);
451 int netfs_trans_init(void);
452 void netfs_trans_exit(void);
454 struct pohmelfs_crypto_engine
456 u64 iv
; /* Crypto IV for current operation */
457 unsigned long timeout
; /* Crypto waiting timeout */
458 unsigned int size
; /* Size of crypto scratchpad */
459 void *data
; /* Temporal crypto scratchpad */
461 * Crypto operations performed on objects.
463 struct crypto_hash
*hash
;
464 struct crypto_ablkcipher
*cipher
;
466 struct pohmelfs_crypto_thread
*thread
; /* Crypto thread which hosts this engine */
469 unsigned int page_num
;
472 struct pohmelfs_crypto_thread
474 struct list_head thread_entry
;
476 struct task_struct
*thread
;
477 struct pohmelfs_sb
*psb
;
479 struct pohmelfs_crypto_engine eng
;
481 struct netfs_trans
*trans
;
483 wait_queue_head_t wait
;
490 void pohmelfs_crypto_thread_make_ready(struct pohmelfs_crypto_thread
*th
);
493 * Network state, attached to one server.
497 struct mutex __state_lock
; /* Can not allow to use the same socket simultaneously */
498 struct mutex __state_send_lock
;
499 struct netfs_cmd cmd
; /* Cached command */
500 struct netfs_inode_info info
; /* Cached inode info */
502 void *data
; /* Cached some data */
503 unsigned int size
; /* Size of that data */
505 struct pohmelfs_sb
*psb
; /* Superblock */
507 struct task_struct
*thread
; /* Async receiving thread */
509 /* Waiting/polling machinery */
511 wait_queue_head_t
*whead
;
512 wait_queue_head_t thread_wait
;
514 struct mutex trans_lock
;
515 struct rb_root trans_root
;
517 struct pohmelfs_ctl ctl
; /* Remote peer */
519 struct socket
*socket
; /* Socket object */
520 struct socket
*read_socket
; /* Cached pointer to socket object.
521 * Used to determine if between lock drops socket was changed.
522 * Never used to read data or any kind of access.
525 * Crypto engines to process incoming data.
527 struct pohmelfs_crypto_engine eng
;
532 int netfs_state_init(struct netfs_state
*st
);
533 void netfs_state_exit(struct netfs_state
*st
);
535 static inline void netfs_state_lock_send(struct netfs_state
*st
)
537 mutex_lock(&st
->__state_send_lock
);
540 static inline int netfs_state_trylock_send(struct netfs_state
*st
)
542 return mutex_trylock(&st
->__state_send_lock
);
545 static inline void netfs_state_unlock_send(struct netfs_state
*st
)
547 BUG_ON(!mutex_is_locked(&st
->__state_send_lock
));
549 mutex_unlock(&st
->__state_send_lock
);
552 static inline void netfs_state_lock(struct netfs_state
*st
)
554 mutex_lock(&st
->__state_lock
);
557 static inline void netfs_state_unlock(struct netfs_state
*st
)
559 BUG_ON(!mutex_is_locked(&st
->__state_lock
));
561 mutex_unlock(&st
->__state_lock
);
564 static inline unsigned int netfs_state_poll(struct netfs_state
*st
)
566 unsigned int revents
= POLLHUP
| POLLERR
;
568 netfs_state_lock(st
);
570 revents
= st
->socket
->ops
->poll(NULL
, st
->socket
, NULL
);
571 netfs_state_unlock(st
);
576 struct pohmelfs_config
;
580 struct rb_root mcache_root
;
581 struct mutex mcache_lock
;
582 atomic_long_t mcache_gen
;
583 unsigned long mcache_timeout
;
587 unsigned int trans_retries
;
591 unsigned int crypto_attached_size
;
592 unsigned int crypto_align_size
;
594 unsigned int crypto_fail_unsupported
;
596 unsigned int crypto_thread_num
;
597 struct list_head crypto_active_list
, crypto_ready_list
;
598 struct mutex crypto_thread_lock
;
600 unsigned int trans_max_pages
;
601 unsigned long trans_data_size
;
602 unsigned long trans_timeout
;
604 unsigned long drop_scan_timeout
;
605 unsigned long trans_scan_timeout
;
607 unsigned long wait_on_page_timeout
;
609 struct list_head flush_list
;
610 struct list_head drop_list
;
615 * Remote nodes POHMELFS connected to.
617 struct list_head state_list
;
618 struct mutex state_lock
;
621 * Currently active state to request data from.
623 struct pohmelfs_config
*active_state
;
626 wait_queue_head_t wait
;
629 * Timed checks: stale transactions, inodes to be freed and so on.
631 struct delayed_work dwork
;
632 struct delayed_work drop_dwork
;
634 struct super_block
*sb
;
646 * Algorithm string lengths.
648 unsigned int hash_strlen
;
649 unsigned int cipher_strlen
;
650 unsigned int hash_keysize
;
651 unsigned int cipher_keysize
;
654 * Controls whether to perfrom crypto processing or not.
659 * POHMELFS statistics.
663 atomic_long_t total_inodes
;
666 * Xattr support, read-only and so on.
671 * Temporary storage to detect changes in the wait queue.
676 static inline void netfs_trans_update(struct netfs_cmd
*cmd
,
677 struct netfs_trans
*t
, unsigned int size
)
679 unsigned int sz
= ALIGN(size
, t
->psb
->crypto_align_size
);
681 t
->iovec
.iov_len
+= sizeof(struct netfs_cmd
) + sz
;
682 cmd
->cpad
= __cpu_to_be16(sz
- size
);
685 static inline struct pohmelfs_sb
*POHMELFS_SB(struct super_block
*sb
)
687 return sb
->s_fs_info
;
690 static inline struct pohmelfs_inode
*POHMELFS_I(struct inode
*inode
)
692 return container_of(inode
, struct pohmelfs_inode
, vfs_inode
);
695 static inline u64
pohmelfs_new_ino(struct pohmelfs_sb
*psb
)
699 spin_lock(&psb
->ino_lock
);
701 spin_unlock(&psb
->ino_lock
);
706 static inline void pohmelfs_put_inode(struct pohmelfs_inode
*pi
)
708 struct pohmelfs_sb
*psb
= POHMELFS_SB(pi
->vfs_inode
.i_sb
);
710 spin_lock(&psb
->ino_lock
);
711 list_move_tail(&pi
->inode_entry
, &psb
->drop_list
);
713 spin_unlock(&psb
->ino_lock
);
716 struct pohmelfs_config
718 struct list_head config_entry
;
720 struct netfs_state state
;
723 struct pohmelfs_config_group
726 * Entry in the global config group list.
728 struct list_head group_entry
;
731 * Index of the current group.
735 * Number of config_list entries in this group entry.
737 unsigned int num_entry
;
745 * Algorithm string lengths.
747 unsigned int hash_strlen
;
748 unsigned int cipher_strlen
;
753 unsigned int hash_keysize
;
754 unsigned int cipher_keysize
;
759 * List of config entries (network state info) for given idx.
761 struct list_head config_list
;
764 int __init
pohmelfs_config_init(void);
765 void pohmelfs_config_exit(void);
766 int pohmelfs_copy_config(struct pohmelfs_sb
*psb
);
767 int pohmelfs_copy_crypto(struct pohmelfs_sb
*psb
);
768 int pohmelfs_config_check(struct pohmelfs_config
*config
, int idx
);
769 int pohmelfs_state_init_one(struct pohmelfs_sb
*psb
, struct pohmelfs_config
*conf
);
771 extern const struct file_operations pohmelfs_dir_fops
;
772 extern const struct inode_operations pohmelfs_dir_inode_ops
;
774 int pohmelfs_state_init(struct pohmelfs_sb
*psb
);
775 void pohmelfs_state_exit(struct pohmelfs_sb
*psb
);
776 void pohmelfs_state_flush_transactions(struct netfs_state
*st
);
778 void pohmelfs_fill_inode(struct inode
*inode
, struct netfs_inode_info
*info
);
780 void pohmelfs_name_del(struct pohmelfs_inode
*parent
, struct pohmelfs_name
*n
);
781 void pohmelfs_free_names(struct pohmelfs_inode
*parent
);
782 struct pohmelfs_name
*pohmelfs_search_hash(struct pohmelfs_inode
*pi
, u32 hash
);
784 void pohmelfs_inode_del_inode(struct pohmelfs_sb
*psb
, struct pohmelfs_inode
*pi
);
786 struct pohmelfs_inode
*pohmelfs_create_entry_local(struct pohmelfs_sb
*psb
,
787 struct pohmelfs_inode
*parent
, struct qstr
*str
, u64 start
, int mode
);
789 int pohmelfs_write_create_inode(struct pohmelfs_inode
*pi
);
791 int pohmelfs_write_inode_create(struct inode
*inode
, struct netfs_trans
*trans
);
792 int pohmelfs_remove_child(struct pohmelfs_inode
*parent
, struct pohmelfs_name
*n
);
794 struct pohmelfs_inode
*pohmelfs_new_inode(struct pohmelfs_sb
*psb
,
795 struct pohmelfs_inode
*parent
, struct qstr
*str
,
796 struct netfs_inode_info
*info
, int link
);
798 int pohmelfs_setattr(struct dentry
*dentry
, struct iattr
*attr
);
799 int pohmelfs_setattr_raw(struct inode
*inode
, struct iattr
*attr
);
801 int pohmelfs_meta_command(struct pohmelfs_inode
*pi
, unsigned int cmd_op
, unsigned int flags
,
802 netfs_trans_complete_t complete
, void *priv
, u64 start
);
803 int pohmelfs_meta_command_data(struct pohmelfs_inode
*pi
, u64 id
, unsigned int cmd_op
, char *addon
,
804 unsigned int flags
, netfs_trans_complete_t complete
, void *priv
, u64 start
);
806 void pohmelfs_check_states(struct pohmelfs_sb
*psb
);
807 void pohmelfs_switch_active(struct pohmelfs_sb
*psb
);
809 int pohmelfs_construct_path_string(struct pohmelfs_inode
*pi
, void *data
, int len
);
810 int pohmelfs_path_length(struct pohmelfs_inode
*pi
);
812 struct pohmelfs_crypto_completion
814 struct completion complete
;
818 int pohmelfs_trans_crypt(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
819 void pohmelfs_crypto_exit(struct pohmelfs_sb
*psb
);
820 int pohmelfs_crypto_init(struct pohmelfs_sb
*psb
);
822 int pohmelfs_crypto_engine_init(struct pohmelfs_crypto_engine
*e
, struct pohmelfs_sb
*psb
);
823 void pohmelfs_crypto_engine_exit(struct pohmelfs_crypto_engine
*e
);
825 int pohmelfs_crypto_process_input_data(struct pohmelfs_crypto_engine
*e
, u64 iv
,
826 void *data
, struct page
*page
, unsigned int size
);
827 int pohmelfs_crypto_process_input_page(struct pohmelfs_crypto_engine
*e
,
828 struct page
*page
, unsigned int size
, u64 iv
);
830 static inline u64
pohmelfs_gen_iv(struct netfs_trans
*t
)
835 iv
|= ((unsigned long)t
) & 0xffffffff;
840 int pohmelfs_data_lock(struct pohmelfs_inode
*pi
, u64 start
, u32 size
, int type
);
841 int pohmelfs_data_unlock(struct pohmelfs_inode
*pi
, u64 start
, u32 size
, int type
);
842 int pohmelfs_data_lock_response(struct netfs_state
*st
);
844 static inline int pohmelfs_need_lock(struct pohmelfs_inode
*pi
, int type
)
846 if (test_bit(NETFS_INODE_OWNED
, &pi
->state
)) {
847 if (type
== pi
->lock_type
)
849 if ((type
== POHMELFS_READ_LOCK
) && (pi
->lock_type
== POHMELFS_WRITE_LOCK
))
853 if (!test_bit(NETFS_INODE_REMOTE_SYNCED
, &pi
->state
))
859 int __init
pohmelfs_mcache_init(void);
860 void pohmelfs_mcache_exit(void);
862 //#define CONFIG_POHMELFS_DEBUG
864 #ifdef CONFIG_POHMELFS_DEBUG
865 #define dprintka(f, a...) printk(f, ##a)
866 #define dprintk(f, a...) printk("%d: " f, task_pid_vnr(current), ##a)
868 #define dprintka(f, a...) do {} while (0)
869 #define dprintk(f, a...) do {} while (0)
872 static inline void netfs_trans_get(struct netfs_trans
*t
)
874 atomic_inc(&t
->refcnt
);
877 static inline void netfs_trans_put(struct netfs_trans
*t
)
879 if (atomic_dec_and_test(&t
->refcnt
)) {
880 dprintk("%s: t: %p, gen: %u, err: %d.\n",
881 __func__
, t
, t
->gen
, t
->result
);
883 t
->complete(t
->pages
, t
->page_num
,
884 t
->private, t
->result
);
889 struct pohmelfs_mcache
891 struct rb_node mcache_entry
;
892 struct completion complete
;
903 struct netfs_inode_info info
;
906 struct pohmelfs_mcache
*pohmelfs_mcache_alloc(struct pohmelfs_sb
*psb
, u64 start
,
907 unsigned int size
, void *data
);
908 void pohmelfs_mcache_free(struct pohmelfs_sb
*psb
, struct pohmelfs_mcache
*m
);
909 struct pohmelfs_mcache
*pohmelfs_mcache_search(struct pohmelfs_sb
*psb
, u64 gen
);
910 void pohmelfs_mcache_remove_locked(struct pohmelfs_sb
*psb
, struct pohmelfs_mcache
*m
);
912 static inline void pohmelfs_mcache_get(struct pohmelfs_mcache
*m
)
914 atomic_inc(&m
->refcnt
);
917 static inline void pohmelfs_mcache_put(struct pohmelfs_sb
*psb
,
918 struct pohmelfs_mcache
*m
)
920 if (atomic_dec_and_test(&m
->refcnt
))
921 pohmelfs_mcache_free(psb
, m
);
924 int pohmelfs_ftrans_init(void);
925 void pohmelfs_ftrans_exit(void);
926 void pohmelfs_ftrans_update(u64 id
);
927 int pohmelfs_ftrans_check(u64 id
);
928 void pohmelfs_ftrans_clean(u64 id
);
930 #endif /* __KERNEL__*/
932 #endif /* __NETFS_H */