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 */
119 #define POHMELFS_IO_PERM_READ (1<<0)
120 #define POHMELFS_IO_PERM_WRITE (1<<1)
123 * Configuration command used to create table of different remote servers.
127 __u32 idx
; /* Config index */
128 __u32 type
; /* Socket type */
129 __u32 proto
; /* Socket protocol */
130 __u16 addrlen
; /* Size of the address */
131 __u16 perm
; /* IO permission */
132 __u16 prio
; /* IO priority */
133 struct saddr addr
; /* Remote server address */
137 * Ack for userspace about requested command.
139 struct pohmelfs_cn_ack
145 struct pohmelfs_ctl ctl
;
149 * Inode info structure used to sync with server.
150 * Check what stat() returns.
152 struct netfs_inode_info
158 unsigned int blocksize
;
159 unsigned int padding
;
167 static inline void netfs_convert_inode_info(struct netfs_inode_info
*info
)
169 info
->mode
= __cpu_to_be32(info
->mode
);
170 info
->nlink
= __cpu_to_be32(info
->nlink
);
171 info
->uid
= __cpu_to_be32(info
->uid
);
172 info
->gid
= __cpu_to_be32(info
->gid
);
173 info
->blocksize
= __cpu_to_be32(info
->blocksize
);
174 info
->blocks
= __cpu_to_be64(info
->blocks
);
175 info
->rdev
= __cpu_to_be64(info
->rdev
);
176 info
->size
= __cpu_to_be64(info
->size
);
177 info
->version
= __cpu_to_be64(info
->version
);
178 info
->ino
= __cpu_to_be64(info
->ino
);
182 * Cache state machine.
185 NETFS_COMMAND_PENDING
= 0, /* Command is being executed */
186 NETFS_INODE_REMOTE_SYNCED
, /* Inode was synced to server */
187 NETFS_INODE_REMOTE_DIR_SYNCED
, /* Inode (directory) was synced from the server */
188 NETFS_INODE_OWNED
, /* Inode is owned by given host */
189 NETFS_INODE_NEED_FLUSH
, /* Inode has to be flushed to the server */
193 * POHMELFS capabilities: information about supported
194 * crypto operations (hash/cipher, modes, key sizes and so on),
195 * root informaion (used/available size, number of objects, permissions)
197 enum pohmelfs_capabilities
{
198 POHMELFS_CRYPTO_CAPABILITIES
= 0,
199 POHMELFS_ROOT_CAPABILITIES
,
202 /* Read-only mount */
203 #define POHMELFS_FLAGS_RO (1<<0)
204 /* Extended attributes support on/off */
205 #define POHMELFS_FLAGS_XATTR (1<<1)
207 struct netfs_root_capabilities
214 static inline void netfs_convert_root_capabilities(struct netfs_root_capabilities
*cap
)
216 cap
->nr_files
= __cpu_to_be64(cap
->nr_files
);
217 cap
->used
= __cpu_to_be64(cap
->used
);
218 cap
->avail
= __cpu_to_be64(cap
->avail
);
219 cap
->flags
= __cpu_to_be64(cap
->flags
);
222 struct netfs_crypto_capabilities
224 unsigned short hash_strlen
; /* Hash string length, like "hmac(sha1) including 0 byte "*/
225 unsigned short cipher_strlen
; /* Cipher string length with the same format */
226 unsigned int cipher_keysize
; /* Cipher key size */
229 static inline void netfs_convert_crypto_capabilities(struct netfs_crypto_capabilities
*cap
)
231 cap
->hash_strlen
= __cpu_to_be16(cap
->hash_strlen
);
232 cap
->cipher_strlen
= __cpu_to_be16(cap
->cipher_strlen
);
233 cap
->cipher_keysize
= __cpu_to_be32(cap
->cipher_keysize
);
236 enum pohmelfs_lock_type
{
237 POHMELFS_LOCK_GRAB
= (1<<15),
239 POHMELFS_READ_LOCK
= 0,
251 static inline void netfs_convert_lock(struct netfs_lock
*lock
)
253 lock
->start
= __cpu_to_be64(lock
->start
);
254 lock
->ino
= __cpu_to_be64(lock
->ino
);
255 lock
->size
= __cpu_to_be32(lock
->size
);
256 lock
->type
= __cpu_to_be32(lock
->type
);
261 #include <linux/kernel.h>
262 #include <linux/completion.h>
263 #include <linux/rbtree.h>
264 #include <linux/net.h>
265 #include <linux/poll.h>
268 * Private POHMELFS cache of objects in directory.
272 struct rb_node hash_node
;
274 struct list_head sync_create_entry
;
286 * POHMELFS inode. Main object.
288 struct pohmelfs_inode
290 struct list_head inode_entry
; /* Entry in superblock list.
291 * Objects which are not bound to dentry require to be dropped
294 struct rb_root hash_root
; /* The same, but indexed by name hash and len */
295 struct mutex offset_lock
; /* Protect both above trees */
297 struct list_head sync_create_list
; /* List of created but not yet synced to the server children */
299 unsigned int drop_count
;
301 int lock_type
; /* How this inode is locked: read or write */
303 int error
; /* Transaction error for given inode */
305 long state
; /* State machine above */
307 u64 ino
; /* Inode number */
308 u64 total_len
; /* Total length of all children names, used to create offsets */
310 struct inode vfs_inode
;
314 typedef int (* netfs_trans_complete_t
)(struct page
**pages
, unsigned int page_num
,
315 void *private, int err
);
323 * Transaction header and attached contiguous data live here.
328 * Pages attached to transaction.
333 * List and protecting lock for transaction destination
337 struct list_head dst_list
;
340 * Number of users for given transaction.
341 * For example each network state attached to transaction
342 * via dst_list increases it.
347 * Number of pages attached to given transaction.
348 * Some slots in above page array can be NULL, since
349 * for example page can be under writeback already,
350 * so we skip it in this transaction.
352 unsigned int page_num
;
355 * Transaction flags: single dst or broadcast and so on.
360 * Size of the data, which can be placed into
361 * iovec.iov_base area.
363 unsigned int total_size
;
366 * Number of pages to be sent to remote server.
367 * Usually equal to above page_num, but in case of partial
368 * writeback it can accumulate only pages already completed
369 * previous writeback.
371 unsigned int attached_pages
;
374 * Attached number of bytes in all above pages.
376 unsigned int attached_size
;
379 * Unique transacton generation number.
380 * Used as identity in the network state tree of transactions.
385 * Transaction completion status.
390 * Superblock this transaction belongs to
392 struct pohmelfs_sb
*psb
;
395 * Crypto engine, which processed this transaction.
396 * Can be not NULL only if crypto engine holds encrypted pages.
398 struct pohmelfs_crypto_engine
*eng
;
403 /* Completion callback, invoked just before transaction is destroyed */
404 netfs_trans_complete_t complete
;
407 static inline int netfs_trans_cur_len(struct netfs_trans
*t
)
409 return (signed)(t
->total_size
- t
->iovec
.iov_len
);
412 static inline void *netfs_trans_current(struct netfs_trans
*t
)
414 return t
->iovec
.iov_base
+ t
->iovec
.iov_len
;
417 struct netfs_trans
*netfs_trans_alloc(struct pohmelfs_sb
*psb
, unsigned int size
,
418 unsigned int flags
, unsigned int nr
);
419 void netfs_trans_free(struct netfs_trans
*t
);
420 int netfs_trans_finish(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
421 int netfs_trans_finish_send(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
423 static inline void netfs_trans_reset(struct netfs_trans
*t
)
428 struct netfs_trans_dst
430 struct list_head trans_entry
;
431 struct rb_node state_entry
;
433 unsigned long send_time
;
436 * Times this transaction was resent to its old or new,
437 * depending on flags, destinations. When it reaches maximum
438 * allowed number, specified in superblock->trans_retries,
439 * transaction will be freed with ETIMEDOUT error.
441 unsigned int retries
;
443 struct netfs_trans
*trans
;
444 struct netfs_state
*state
;
447 struct netfs_trans_dst
*netfs_trans_search(struct netfs_state
*st
, unsigned int gen
);
448 void netfs_trans_drop_dst(struct netfs_trans_dst
*dst
);
449 void netfs_trans_drop_dst_nostate(struct netfs_trans_dst
*dst
);
450 void netfs_trans_drop_trans(struct netfs_trans
*t
, struct netfs_state
*st
);
451 void netfs_trans_drop_last(struct netfs_trans
*t
, struct netfs_state
*st
);
452 int netfs_trans_resend(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
453 int netfs_trans_remove_nolock(struct netfs_trans_dst
*dst
, struct netfs_state
*st
);
455 int netfs_trans_init(void);
456 void netfs_trans_exit(void);
458 struct pohmelfs_crypto_engine
460 u64 iv
; /* Crypto IV for current operation */
461 unsigned long timeout
; /* Crypto waiting timeout */
462 unsigned int size
; /* Size of crypto scratchpad */
463 void *data
; /* Temporal crypto scratchpad */
465 * Crypto operations performed on objects.
467 struct crypto_hash
*hash
;
468 struct crypto_ablkcipher
*cipher
;
470 struct pohmelfs_crypto_thread
*thread
; /* Crypto thread which hosts this engine */
473 unsigned int page_num
;
476 struct pohmelfs_crypto_thread
478 struct list_head thread_entry
;
480 struct task_struct
*thread
;
481 struct pohmelfs_sb
*psb
;
483 struct pohmelfs_crypto_engine eng
;
485 struct netfs_trans
*trans
;
487 wait_queue_head_t wait
;
494 void pohmelfs_crypto_thread_make_ready(struct pohmelfs_crypto_thread
*th
);
497 * Network state, attached to one server.
501 struct mutex __state_lock
; /* Can not allow to use the same socket simultaneously */
502 struct mutex __state_send_lock
;
503 struct netfs_cmd cmd
; /* Cached command */
504 struct netfs_inode_info info
; /* Cached inode info */
506 void *data
; /* Cached some data */
507 unsigned int size
; /* Size of that data */
509 struct pohmelfs_sb
*psb
; /* Superblock */
511 struct task_struct
*thread
; /* Async receiving thread */
513 /* Waiting/polling machinery */
515 wait_queue_head_t
*whead
;
516 wait_queue_head_t thread_wait
;
518 struct mutex trans_lock
;
519 struct rb_root trans_root
;
521 struct pohmelfs_ctl ctl
; /* Remote peer */
523 struct socket
*socket
; /* Socket object */
524 struct socket
*read_socket
; /* Cached pointer to socket object.
525 * Used to determine if between lock drops socket was changed.
526 * Never used to read data or any kind of access.
529 * Crypto engines to process incoming data.
531 struct pohmelfs_crypto_engine eng
;
536 int netfs_state_init(struct netfs_state
*st
);
537 void netfs_state_exit(struct netfs_state
*st
);
539 static inline void netfs_state_lock_send(struct netfs_state
*st
)
541 mutex_lock(&st
->__state_send_lock
);
544 static inline int netfs_state_trylock_send(struct netfs_state
*st
)
546 return mutex_trylock(&st
->__state_send_lock
);
549 static inline void netfs_state_unlock_send(struct netfs_state
*st
)
551 BUG_ON(!mutex_is_locked(&st
->__state_send_lock
));
553 mutex_unlock(&st
->__state_send_lock
);
556 static inline void netfs_state_lock(struct netfs_state
*st
)
558 mutex_lock(&st
->__state_lock
);
561 static inline void netfs_state_unlock(struct netfs_state
*st
)
563 BUG_ON(!mutex_is_locked(&st
->__state_lock
));
565 mutex_unlock(&st
->__state_lock
);
568 static inline unsigned int netfs_state_poll(struct netfs_state
*st
)
570 unsigned int revents
= POLLHUP
| POLLERR
;
572 netfs_state_lock(st
);
574 revents
= st
->socket
->ops
->poll(NULL
, st
->socket
, NULL
);
575 netfs_state_unlock(st
);
580 struct pohmelfs_config
;
584 struct rb_root mcache_root
;
585 struct mutex mcache_lock
;
586 atomic_long_t mcache_gen
;
587 unsigned long mcache_timeout
;
591 unsigned int trans_retries
;
595 unsigned int crypto_attached_size
;
596 unsigned int crypto_align_size
;
598 unsigned int crypto_fail_unsupported
;
600 unsigned int crypto_thread_num
;
601 struct list_head crypto_active_list
, crypto_ready_list
;
602 struct mutex crypto_thread_lock
;
604 unsigned int trans_max_pages
;
605 unsigned long trans_data_size
;
606 unsigned long trans_timeout
;
608 unsigned long drop_scan_timeout
;
609 unsigned long trans_scan_timeout
;
611 unsigned long wait_on_page_timeout
;
613 struct list_head flush_list
;
614 struct list_head drop_list
;
619 * Remote nodes POHMELFS connected to.
621 struct list_head state_list
;
622 struct mutex state_lock
;
625 * Currently active state to request data from.
627 struct pohmelfs_config
*active_state
;
630 wait_queue_head_t wait
;
633 * Timed checks: stale transactions, inodes to be freed and so on.
635 struct delayed_work dwork
;
636 struct delayed_work drop_dwork
;
638 struct super_block
*sb
;
650 * Algorithm string lengths.
652 unsigned int hash_strlen
;
653 unsigned int cipher_strlen
;
654 unsigned int hash_keysize
;
655 unsigned int cipher_keysize
;
658 * Controls whether to perfrom crypto processing or not.
663 * POHMELFS statistics.
667 atomic_long_t total_inodes
;
670 * Xattr support, read-only and so on.
675 * Temporary storage to detect changes in the wait queue.
680 static inline void netfs_trans_update(struct netfs_cmd
*cmd
,
681 struct netfs_trans
*t
, unsigned int size
)
683 unsigned int sz
= ALIGN(size
, t
->psb
->crypto_align_size
);
685 t
->iovec
.iov_len
+= sizeof(struct netfs_cmd
) + sz
;
686 cmd
->cpad
= __cpu_to_be16(sz
- size
);
689 static inline struct pohmelfs_sb
*POHMELFS_SB(struct super_block
*sb
)
691 return sb
->s_fs_info
;
694 static inline struct pohmelfs_inode
*POHMELFS_I(struct inode
*inode
)
696 return container_of(inode
, struct pohmelfs_inode
, vfs_inode
);
699 static inline u64
pohmelfs_new_ino(struct pohmelfs_sb
*psb
)
703 spin_lock(&psb
->ino_lock
);
705 spin_unlock(&psb
->ino_lock
);
710 static inline void pohmelfs_put_inode(struct pohmelfs_inode
*pi
)
712 struct pohmelfs_sb
*psb
= POHMELFS_SB(pi
->vfs_inode
.i_sb
);
714 spin_lock(&psb
->ino_lock
);
715 list_move_tail(&pi
->inode_entry
, &psb
->drop_list
);
717 spin_unlock(&psb
->ino_lock
);
720 struct pohmelfs_config
722 struct list_head config_entry
;
724 struct netfs_state state
;
727 struct pohmelfs_config_group
730 * Entry in the global config group list.
732 struct list_head group_entry
;
735 * Index of the current group.
739 * Number of config_list entries in this group entry.
741 unsigned int num_entry
;
749 * Algorithm string lengths.
751 unsigned int hash_strlen
;
752 unsigned int cipher_strlen
;
757 unsigned int hash_keysize
;
758 unsigned int cipher_keysize
;
763 * List of config entries (network state info) for given idx.
765 struct list_head config_list
;
768 int __init
pohmelfs_config_init(void);
769 void pohmelfs_config_exit(void);
770 int pohmelfs_copy_config(struct pohmelfs_sb
*psb
);
771 int pohmelfs_copy_crypto(struct pohmelfs_sb
*psb
);
772 int pohmelfs_config_check(struct pohmelfs_config
*config
, int idx
);
773 int pohmelfs_state_init_one(struct pohmelfs_sb
*psb
, struct pohmelfs_config
*conf
);
775 extern const struct file_operations pohmelfs_dir_fops
;
776 extern const struct inode_operations pohmelfs_dir_inode_ops
;
778 int pohmelfs_state_init(struct pohmelfs_sb
*psb
);
779 void pohmelfs_state_exit(struct pohmelfs_sb
*psb
);
780 void pohmelfs_state_flush_transactions(struct netfs_state
*st
);
782 void pohmelfs_fill_inode(struct inode
*inode
, struct netfs_inode_info
*info
);
784 void pohmelfs_name_del(struct pohmelfs_inode
*parent
, struct pohmelfs_name
*n
);
785 void pohmelfs_free_names(struct pohmelfs_inode
*parent
);
786 struct pohmelfs_name
*pohmelfs_search_hash(struct pohmelfs_inode
*pi
, u32 hash
);
788 void pohmelfs_inode_del_inode(struct pohmelfs_sb
*psb
, struct pohmelfs_inode
*pi
);
790 struct pohmelfs_inode
*pohmelfs_create_entry_local(struct pohmelfs_sb
*psb
,
791 struct pohmelfs_inode
*parent
, struct qstr
*str
, u64 start
, int mode
);
793 int pohmelfs_write_create_inode(struct pohmelfs_inode
*pi
);
795 int pohmelfs_write_inode_create(struct inode
*inode
, struct netfs_trans
*trans
);
796 int pohmelfs_remove_child(struct pohmelfs_inode
*parent
, struct pohmelfs_name
*n
);
798 struct pohmelfs_inode
*pohmelfs_new_inode(struct pohmelfs_sb
*psb
,
799 struct pohmelfs_inode
*parent
, struct qstr
*str
,
800 struct netfs_inode_info
*info
, int link
);
802 int pohmelfs_setattr(struct dentry
*dentry
, struct iattr
*attr
);
803 int pohmelfs_setattr_raw(struct inode
*inode
, struct iattr
*attr
);
805 int pohmelfs_meta_command(struct pohmelfs_inode
*pi
, unsigned int cmd_op
, unsigned int flags
,
806 netfs_trans_complete_t complete
, void *priv
, u64 start
);
807 int pohmelfs_meta_command_data(struct pohmelfs_inode
*pi
, u64 id
, unsigned int cmd_op
, char *addon
,
808 unsigned int flags
, netfs_trans_complete_t complete
, void *priv
, u64 start
);
810 void pohmelfs_check_states(struct pohmelfs_sb
*psb
);
811 void pohmelfs_switch_active(struct pohmelfs_sb
*psb
);
813 int pohmelfs_construct_path_string(struct pohmelfs_inode
*pi
, void *data
, int len
);
814 int pohmelfs_path_length(struct pohmelfs_inode
*pi
);
816 struct pohmelfs_crypto_completion
818 struct completion complete
;
822 int pohmelfs_trans_crypt(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
823 void pohmelfs_crypto_exit(struct pohmelfs_sb
*psb
);
824 int pohmelfs_crypto_init(struct pohmelfs_sb
*psb
);
826 int pohmelfs_crypto_engine_init(struct pohmelfs_crypto_engine
*e
, struct pohmelfs_sb
*psb
);
827 void pohmelfs_crypto_engine_exit(struct pohmelfs_crypto_engine
*e
);
829 int pohmelfs_crypto_process_input_data(struct pohmelfs_crypto_engine
*e
, u64 iv
,
830 void *data
, struct page
*page
, unsigned int size
);
831 int pohmelfs_crypto_process_input_page(struct pohmelfs_crypto_engine
*e
,
832 struct page
*page
, unsigned int size
, u64 iv
);
834 static inline u64
pohmelfs_gen_iv(struct netfs_trans
*t
)
839 iv
|= ((unsigned long)t
) & 0xffffffff;
844 int pohmelfs_data_lock(struct pohmelfs_inode
*pi
, u64 start
, u32 size
, int type
);
845 int pohmelfs_data_unlock(struct pohmelfs_inode
*pi
, u64 start
, u32 size
, int type
);
846 int pohmelfs_data_lock_response(struct netfs_state
*st
);
848 static inline int pohmelfs_need_lock(struct pohmelfs_inode
*pi
, int type
)
850 if (test_bit(NETFS_INODE_OWNED
, &pi
->state
)) {
851 if (type
== pi
->lock_type
)
853 if ((type
== POHMELFS_READ_LOCK
) && (pi
->lock_type
== POHMELFS_WRITE_LOCK
))
857 if (!test_bit(NETFS_INODE_REMOTE_SYNCED
, &pi
->state
))
863 int __init
pohmelfs_mcache_init(void);
864 void pohmelfs_mcache_exit(void);
866 //#define CONFIG_POHMELFS_DEBUG
868 #ifdef CONFIG_POHMELFS_DEBUG
869 #define dprintka(f, a...) printk(f, ##a)
870 #define dprintk(f, a...) printk("%d: " f, task_pid_vnr(current), ##a)
872 #define dprintka(f, a...) do {} while (0)
873 #define dprintk(f, a...) do {} while (0)
876 static inline void netfs_trans_get(struct netfs_trans
*t
)
878 atomic_inc(&t
->refcnt
);
881 static inline void netfs_trans_put(struct netfs_trans
*t
)
883 if (atomic_dec_and_test(&t
->refcnt
)) {
884 dprintk("%s: t: %p, gen: %u, err: %d.\n",
885 __func__
, t
, t
->gen
, t
->result
);
887 t
->complete(t
->pages
, t
->page_num
,
888 t
->private, t
->result
);
893 struct pohmelfs_mcache
895 struct rb_node mcache_entry
;
896 struct completion complete
;
907 struct netfs_inode_info info
;
910 struct pohmelfs_mcache
*pohmelfs_mcache_alloc(struct pohmelfs_sb
*psb
, u64 start
,
911 unsigned int size
, void *data
);
912 void pohmelfs_mcache_free(struct pohmelfs_sb
*psb
, struct pohmelfs_mcache
*m
);
913 struct pohmelfs_mcache
*pohmelfs_mcache_search(struct pohmelfs_sb
*psb
, u64 gen
);
914 void pohmelfs_mcache_remove_locked(struct pohmelfs_sb
*psb
, struct pohmelfs_mcache
*m
);
916 static inline void pohmelfs_mcache_get(struct pohmelfs_mcache
*m
)
918 atomic_inc(&m
->refcnt
);
921 static inline void pohmelfs_mcache_put(struct pohmelfs_sb
*psb
,
922 struct pohmelfs_mcache
*m
)
924 if (atomic_dec_and_test(&m
->refcnt
))
925 pohmelfs_mcache_free(psb
, m
);
928 #endif /* __KERNEL__*/
930 #endif /* __NETFS_H */