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 */
90 POHMELFS_FLAGS_MODIFY
, /* Network state modification message */
94 * Always wanted to copy it from socket headers into public one,
95 * since they are __KERNEL__ protected there.
97 #define _K_SS_MAXSIZE 128
101 unsigned short sa_family
;
102 char addr
[_K_SS_MAXSIZE
];
106 POHMELFS_CRYPTO_HASH
= 0,
107 POHMELFS_CRYPTO_CIPHER
,
110 struct pohmelfs_crypto
112 unsigned int idx
; /* Config index */
113 unsigned short strlen
; /* Size of the attached crypto string including 0-byte
114 * "cbc(aes)" for example */
115 unsigned short type
; /* HMAC, cipher, both */
116 unsigned int keysize
; /* Key size */
117 unsigned char data
[0]; /* Algorithm string, key and IV */
120 #define POHMELFS_IO_PERM_READ (1<<0)
121 #define POHMELFS_IO_PERM_WRITE (1<<1)
124 * Configuration command used to create table of different remote servers.
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 */
138 * Ack for userspace about requested command.
140 struct pohmelfs_cn_ack
146 struct pohmelfs_ctl ctl
;
150 * Inode info structure used to sync with server.
151 * Check what stat() returns.
153 struct netfs_inode_info
159 unsigned int blocksize
;
160 unsigned int padding
;
168 static inline void netfs_convert_inode_info(struct netfs_inode_info
*info
)
170 info
->mode
= __cpu_to_be32(info
->mode
);
171 info
->nlink
= __cpu_to_be32(info
->nlink
);
172 info
->uid
= __cpu_to_be32(info
->uid
);
173 info
->gid
= __cpu_to_be32(info
->gid
);
174 info
->blocksize
= __cpu_to_be32(info
->blocksize
);
175 info
->blocks
= __cpu_to_be64(info
->blocks
);
176 info
->rdev
= __cpu_to_be64(info
->rdev
);
177 info
->size
= __cpu_to_be64(info
->size
);
178 info
->version
= __cpu_to_be64(info
->version
);
179 info
->ino
= __cpu_to_be64(info
->ino
);
183 * Cache state machine.
186 NETFS_COMMAND_PENDING
= 0, /* Command is being executed */
187 NETFS_INODE_REMOTE_SYNCED
, /* Inode was synced to server */
188 NETFS_INODE_REMOTE_DIR_SYNCED
, /* Inode (directory) was synced from the server */
189 NETFS_INODE_OWNED
, /* Inode is owned by given host */
190 NETFS_INODE_NEED_FLUSH
, /* Inode has to be flushed to the server */
194 * POHMELFS capabilities: information about supported
195 * crypto operations (hash/cipher, modes, key sizes and so on),
196 * root informaion (used/available size, number of objects, permissions)
198 enum pohmelfs_capabilities
{
199 POHMELFS_CRYPTO_CAPABILITIES
= 0,
200 POHMELFS_ROOT_CAPABILITIES
,
203 /* Read-only mount */
204 #define POHMELFS_FLAGS_RO (1<<0)
205 /* Extended attributes support on/off */
206 #define POHMELFS_FLAGS_XATTR (1<<1)
208 struct netfs_root_capabilities
215 static inline void netfs_convert_root_capabilities(struct netfs_root_capabilities
*cap
)
217 cap
->nr_files
= __cpu_to_be64(cap
->nr_files
);
218 cap
->used
= __cpu_to_be64(cap
->used
);
219 cap
->avail
= __cpu_to_be64(cap
->avail
);
220 cap
->flags
= __cpu_to_be64(cap
->flags
);
223 struct netfs_crypto_capabilities
225 unsigned short hash_strlen
; /* Hash string length, like "hmac(sha1) including 0 byte "*/
226 unsigned short cipher_strlen
; /* Cipher string length with the same format */
227 unsigned int cipher_keysize
; /* Cipher key size */
230 static inline void netfs_convert_crypto_capabilities(struct netfs_crypto_capabilities
*cap
)
232 cap
->hash_strlen
= __cpu_to_be16(cap
->hash_strlen
);
233 cap
->cipher_strlen
= __cpu_to_be16(cap
->cipher_strlen
);
234 cap
->cipher_keysize
= __cpu_to_be32(cap
->cipher_keysize
);
237 enum pohmelfs_lock_type
{
238 POHMELFS_LOCK_GRAB
= (1<<15),
240 POHMELFS_READ_LOCK
= 0,
252 static inline void netfs_convert_lock(struct netfs_lock
*lock
)
254 lock
->start
= __cpu_to_be64(lock
->start
);
255 lock
->ino
= __cpu_to_be64(lock
->ino
);
256 lock
->size
= __cpu_to_be32(lock
->size
);
257 lock
->type
= __cpu_to_be32(lock
->type
);
262 #include <linux/kernel.h>
263 #include <linux/completion.h>
264 #include <linux/rbtree.h>
265 #include <linux/net.h>
266 #include <linux/poll.h>
269 * Private POHMELFS cache of objects in directory.
273 struct rb_node hash_node
;
275 struct list_head sync_create_entry
;
287 * POHMELFS inode. Main object.
289 struct pohmelfs_inode
291 struct list_head inode_entry
; /* Entry in superblock list.
292 * Objects which are not bound to dentry require to be dropped
295 struct rb_root hash_root
; /* The same, but indexed by name hash and len */
296 struct mutex offset_lock
; /* Protect both above trees */
298 struct list_head sync_create_list
; /* List of created but not yet synced to the server children */
300 unsigned int drop_count
;
302 int lock_type
; /* How this inode is locked: read or write */
304 int error
; /* Transaction error for given inode */
306 long state
; /* State machine above */
308 u64 ino
; /* Inode number */
309 u64 total_len
; /* Total length of all children names, used to create offsets */
311 struct inode vfs_inode
;
315 typedef int (* netfs_trans_complete_t
)(struct page
**pages
, unsigned int page_num
,
316 void *private, int err
);
324 * Transaction header and attached contiguous data live here.
329 * Pages attached to transaction.
334 * List and protecting lock for transaction destination
338 struct list_head dst_list
;
341 * Number of users for given transaction.
342 * For example each network state attached to transaction
343 * via dst_list increases it.
348 * Number of pages attached to given transaction.
349 * Some slots in above page array can be NULL, since
350 * for example page can be under writeback already,
351 * so we skip it in this transaction.
353 unsigned int page_num
;
356 * Transaction flags: single dst or broadcast and so on.
361 * Size of the data, which can be placed into
362 * iovec.iov_base area.
364 unsigned int total_size
;
367 * Number of pages to be sent to remote server.
368 * Usually equal to above page_num, but in case of partial
369 * writeback it can accumulate only pages already completed
370 * previous writeback.
372 unsigned int attached_pages
;
375 * Attached number of bytes in all above pages.
377 unsigned int attached_size
;
380 * Unique transacton generation number.
381 * Used as identity in the network state tree of transactions.
386 * Transaction completion status.
391 * Superblock this transaction belongs to
393 struct pohmelfs_sb
*psb
;
396 * Crypto engine, which processed this transaction.
397 * Can be not NULL only if crypto engine holds encrypted pages.
399 struct pohmelfs_crypto_engine
*eng
;
404 /* Completion callback, invoked just before transaction is destroyed */
405 netfs_trans_complete_t complete
;
408 static inline int netfs_trans_cur_len(struct netfs_trans
*t
)
410 return (signed)(t
->total_size
- t
->iovec
.iov_len
);
413 static inline void *netfs_trans_current(struct netfs_trans
*t
)
415 return t
->iovec
.iov_base
+ t
->iovec
.iov_len
;
418 struct netfs_trans
*netfs_trans_alloc(struct pohmelfs_sb
*psb
, unsigned int size
,
419 unsigned int flags
, unsigned int nr
);
420 void netfs_trans_free(struct netfs_trans
*t
);
421 int netfs_trans_finish(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
422 int netfs_trans_finish_send(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
424 static inline void netfs_trans_reset(struct netfs_trans
*t
)
429 struct netfs_trans_dst
431 struct list_head trans_entry
;
432 struct rb_node state_entry
;
434 unsigned long send_time
;
437 * Times this transaction was resent to its old or new,
438 * depending on flags, destinations. When it reaches maximum
439 * allowed number, specified in superblock->trans_retries,
440 * transaction will be freed with ETIMEDOUT error.
442 unsigned int retries
;
444 struct netfs_trans
*trans
;
445 struct netfs_state
*state
;
448 struct netfs_trans_dst
*netfs_trans_search(struct netfs_state
*st
, unsigned int gen
);
449 void netfs_trans_drop_dst(struct netfs_trans_dst
*dst
);
450 void netfs_trans_drop_dst_nostate(struct netfs_trans_dst
*dst
);
451 void netfs_trans_drop_trans(struct netfs_trans
*t
, struct netfs_state
*st
);
452 void netfs_trans_drop_last(struct netfs_trans
*t
, struct netfs_state
*st
);
453 int netfs_trans_resend(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
454 int netfs_trans_remove_nolock(struct netfs_trans_dst
*dst
, struct netfs_state
*st
);
456 int netfs_trans_init(void);
457 void netfs_trans_exit(void);
459 struct pohmelfs_crypto_engine
461 u64 iv
; /* Crypto IV for current operation */
462 unsigned long timeout
; /* Crypto waiting timeout */
463 unsigned int size
; /* Size of crypto scratchpad */
464 void *data
; /* Temporal crypto scratchpad */
466 * Crypto operations performed on objects.
468 struct crypto_hash
*hash
;
469 struct crypto_ablkcipher
*cipher
;
471 struct pohmelfs_crypto_thread
*thread
; /* Crypto thread which hosts this engine */
474 unsigned int page_num
;
477 struct pohmelfs_crypto_thread
479 struct list_head thread_entry
;
481 struct task_struct
*thread
;
482 struct pohmelfs_sb
*psb
;
484 struct pohmelfs_crypto_engine eng
;
486 struct netfs_trans
*trans
;
488 wait_queue_head_t wait
;
495 void pohmelfs_crypto_thread_make_ready(struct pohmelfs_crypto_thread
*th
);
498 * Network state, attached to one server.
502 struct mutex __state_lock
; /* Can not allow to use the same socket simultaneously */
503 struct mutex __state_send_lock
;
504 struct netfs_cmd cmd
; /* Cached command */
505 struct netfs_inode_info info
; /* Cached inode info */
507 void *data
; /* Cached some data */
508 unsigned int size
; /* Size of that data */
510 struct pohmelfs_sb
*psb
; /* Superblock */
512 struct task_struct
*thread
; /* Async receiving thread */
514 /* Waiting/polling machinery */
516 wait_queue_head_t
*whead
;
517 wait_queue_head_t thread_wait
;
519 struct mutex trans_lock
;
520 struct rb_root trans_root
;
522 struct pohmelfs_ctl ctl
; /* Remote peer */
524 struct socket
*socket
; /* Socket object */
525 struct socket
*read_socket
; /* Cached pointer to socket object.
526 * Used to determine if between lock drops socket was changed.
527 * Never used to read data or any kind of access.
530 * Crypto engines to process incoming data.
532 struct pohmelfs_crypto_engine eng
;
537 int netfs_state_init(struct netfs_state
*st
);
538 void netfs_state_exit(struct netfs_state
*st
);
540 static inline void netfs_state_lock_send(struct netfs_state
*st
)
542 mutex_lock(&st
->__state_send_lock
);
545 static inline int netfs_state_trylock_send(struct netfs_state
*st
)
547 return mutex_trylock(&st
->__state_send_lock
);
550 static inline void netfs_state_unlock_send(struct netfs_state
*st
)
552 BUG_ON(!mutex_is_locked(&st
->__state_send_lock
));
554 mutex_unlock(&st
->__state_send_lock
);
557 static inline void netfs_state_lock(struct netfs_state
*st
)
559 mutex_lock(&st
->__state_lock
);
562 static inline void netfs_state_unlock(struct netfs_state
*st
)
564 BUG_ON(!mutex_is_locked(&st
->__state_lock
));
566 mutex_unlock(&st
->__state_lock
);
569 static inline unsigned int netfs_state_poll(struct netfs_state
*st
)
571 unsigned int revents
= POLLHUP
| POLLERR
;
573 netfs_state_lock(st
);
575 revents
= st
->socket
->ops
->poll(NULL
, st
->socket
, NULL
);
576 netfs_state_unlock(st
);
581 struct pohmelfs_config
;
585 struct rb_root mcache_root
;
586 struct mutex mcache_lock
;
587 atomic_long_t mcache_gen
;
588 unsigned long mcache_timeout
;
592 unsigned int trans_retries
;
596 unsigned int crypto_attached_size
;
597 unsigned int crypto_align_size
;
599 unsigned int crypto_fail_unsupported
;
601 unsigned int crypto_thread_num
;
602 struct list_head crypto_active_list
, crypto_ready_list
;
603 struct mutex crypto_thread_lock
;
605 unsigned int trans_max_pages
;
606 unsigned long trans_data_size
;
607 unsigned long trans_timeout
;
609 unsigned long drop_scan_timeout
;
610 unsigned long trans_scan_timeout
;
612 unsigned long wait_on_page_timeout
;
614 struct list_head flush_list
;
615 struct list_head drop_list
;
620 * Remote nodes POHMELFS connected to.
622 struct list_head state_list
;
623 struct mutex state_lock
;
626 * Currently active state to request data from.
628 struct pohmelfs_config
*active_state
;
631 wait_queue_head_t wait
;
634 * Timed checks: stale transactions, inodes to be freed and so on.
636 struct delayed_work dwork
;
637 struct delayed_work drop_dwork
;
639 struct super_block
*sb
;
651 * Algorithm string lengths.
653 unsigned int hash_strlen
;
654 unsigned int cipher_strlen
;
655 unsigned int hash_keysize
;
656 unsigned int cipher_keysize
;
659 * Controls whether to perfrom crypto processing or not.
664 * POHMELFS statistics.
668 atomic_long_t total_inodes
;
671 * Xattr support, read-only and so on.
676 * Temporary storage to detect changes in the wait queue.
681 static inline void netfs_trans_update(struct netfs_cmd
*cmd
,
682 struct netfs_trans
*t
, unsigned int size
)
684 unsigned int sz
= ALIGN(size
, t
->psb
->crypto_align_size
);
686 t
->iovec
.iov_len
+= sizeof(struct netfs_cmd
) + sz
;
687 cmd
->cpad
= __cpu_to_be16(sz
- size
);
690 static inline struct pohmelfs_sb
*POHMELFS_SB(struct super_block
*sb
)
692 return sb
->s_fs_info
;
695 static inline struct pohmelfs_inode
*POHMELFS_I(struct inode
*inode
)
697 return container_of(inode
, struct pohmelfs_inode
, vfs_inode
);
700 static inline u64
pohmelfs_new_ino(struct pohmelfs_sb
*psb
)
704 spin_lock(&psb
->ino_lock
);
706 spin_unlock(&psb
->ino_lock
);
711 static inline void pohmelfs_put_inode(struct pohmelfs_inode
*pi
)
713 struct pohmelfs_sb
*psb
= POHMELFS_SB(pi
->vfs_inode
.i_sb
);
715 spin_lock(&psb
->ino_lock
);
716 list_move_tail(&pi
->inode_entry
, &psb
->drop_list
);
718 spin_unlock(&psb
->ino_lock
);
721 struct pohmelfs_config
723 struct list_head config_entry
;
725 struct netfs_state state
;
728 struct pohmelfs_config_group
731 * Entry in the global config group list.
733 struct list_head group_entry
;
736 * Index of the current group.
740 * Number of config_list entries in this group entry.
742 unsigned int num_entry
;
750 * Algorithm string lengths.
752 unsigned int hash_strlen
;
753 unsigned int cipher_strlen
;
758 unsigned int hash_keysize
;
759 unsigned int cipher_keysize
;
764 * List of config entries (network state info) for given idx.
766 struct list_head config_list
;
769 int __init
pohmelfs_config_init(void);
770 void pohmelfs_config_exit(void);
771 int pohmelfs_copy_config(struct pohmelfs_sb
*psb
);
772 int pohmelfs_copy_crypto(struct pohmelfs_sb
*psb
);
773 int pohmelfs_config_check(struct pohmelfs_config
*config
, int idx
);
774 int pohmelfs_state_init_one(struct pohmelfs_sb
*psb
, struct pohmelfs_config
*conf
);
776 extern const struct file_operations pohmelfs_dir_fops
;
777 extern const struct inode_operations pohmelfs_dir_inode_ops
;
779 int pohmelfs_state_init(struct pohmelfs_sb
*psb
);
780 void pohmelfs_state_exit(struct pohmelfs_sb
*psb
);
781 void pohmelfs_state_flush_transactions(struct netfs_state
*st
);
783 void pohmelfs_fill_inode(struct inode
*inode
, struct netfs_inode_info
*info
);
785 void pohmelfs_name_del(struct pohmelfs_inode
*parent
, struct pohmelfs_name
*n
);
786 void pohmelfs_free_names(struct pohmelfs_inode
*parent
);
787 struct pohmelfs_name
*pohmelfs_search_hash(struct pohmelfs_inode
*pi
, u32 hash
);
789 void pohmelfs_inode_del_inode(struct pohmelfs_sb
*psb
, struct pohmelfs_inode
*pi
);
791 struct pohmelfs_inode
*pohmelfs_create_entry_local(struct pohmelfs_sb
*psb
,
792 struct pohmelfs_inode
*parent
, struct qstr
*str
, u64 start
, int mode
);
794 int pohmelfs_write_create_inode(struct pohmelfs_inode
*pi
);
796 int pohmelfs_write_inode_create(struct inode
*inode
, struct netfs_trans
*trans
);
797 int pohmelfs_remove_child(struct pohmelfs_inode
*parent
, struct pohmelfs_name
*n
);
799 struct pohmelfs_inode
*pohmelfs_new_inode(struct pohmelfs_sb
*psb
,
800 struct pohmelfs_inode
*parent
, struct qstr
*str
,
801 struct netfs_inode_info
*info
, int link
);
803 int pohmelfs_setattr(struct dentry
*dentry
, struct iattr
*attr
);
804 int pohmelfs_setattr_raw(struct inode
*inode
, struct iattr
*attr
);
806 int pohmelfs_meta_command(struct pohmelfs_inode
*pi
, unsigned int cmd_op
, unsigned int flags
,
807 netfs_trans_complete_t complete
, void *priv
, u64 start
);
808 int pohmelfs_meta_command_data(struct pohmelfs_inode
*pi
, u64 id
, unsigned int cmd_op
, char *addon
,
809 unsigned int flags
, netfs_trans_complete_t complete
, void *priv
, u64 start
);
811 void pohmelfs_check_states(struct pohmelfs_sb
*psb
);
812 void pohmelfs_switch_active(struct pohmelfs_sb
*psb
);
814 int pohmelfs_construct_path_string(struct pohmelfs_inode
*pi
, void *data
, int len
);
815 int pohmelfs_path_length(struct pohmelfs_inode
*pi
);
817 struct pohmelfs_crypto_completion
819 struct completion complete
;
823 int pohmelfs_trans_crypt(struct netfs_trans
*t
, struct pohmelfs_sb
*psb
);
824 void pohmelfs_crypto_exit(struct pohmelfs_sb
*psb
);
825 int pohmelfs_crypto_init(struct pohmelfs_sb
*psb
);
827 int pohmelfs_crypto_engine_init(struct pohmelfs_crypto_engine
*e
, struct pohmelfs_sb
*psb
);
828 void pohmelfs_crypto_engine_exit(struct pohmelfs_crypto_engine
*e
);
830 int pohmelfs_crypto_process_input_data(struct pohmelfs_crypto_engine
*e
, u64 iv
,
831 void *data
, struct page
*page
, unsigned int size
);
832 int pohmelfs_crypto_process_input_page(struct pohmelfs_crypto_engine
*e
,
833 struct page
*page
, unsigned int size
, u64 iv
);
835 static inline u64
pohmelfs_gen_iv(struct netfs_trans
*t
)
840 iv
|= ((unsigned long)t
) & 0xffffffff;
845 int pohmelfs_data_lock(struct pohmelfs_inode
*pi
, u64 start
, u32 size
, int type
);
846 int pohmelfs_data_unlock(struct pohmelfs_inode
*pi
, u64 start
, u32 size
, int type
);
847 int pohmelfs_data_lock_response(struct netfs_state
*st
);
849 static inline int pohmelfs_need_lock(struct pohmelfs_inode
*pi
, int type
)
851 if (test_bit(NETFS_INODE_OWNED
, &pi
->state
)) {
852 if (type
== pi
->lock_type
)
854 if ((type
== POHMELFS_READ_LOCK
) && (pi
->lock_type
== POHMELFS_WRITE_LOCK
))
858 if (!test_bit(NETFS_INODE_REMOTE_SYNCED
, &pi
->state
))
864 int __init
pohmelfs_mcache_init(void);
865 void pohmelfs_mcache_exit(void);
867 //#define CONFIG_POHMELFS_DEBUG
869 #ifdef CONFIG_POHMELFS_DEBUG
870 #define dprintka(f, a...) printk(f, ##a)
871 #define dprintk(f, a...) printk("%d: " f, task_pid_vnr(current), ##a)
873 #define dprintka(f, a...) do {} while (0)
874 #define dprintk(f, a...) do {} while (0)
877 static inline void netfs_trans_get(struct netfs_trans
*t
)
879 atomic_inc(&t
->refcnt
);
882 static inline void netfs_trans_put(struct netfs_trans
*t
)
884 if (atomic_dec_and_test(&t
->refcnt
)) {
885 dprintk("%s: t: %p, gen: %u, err: %d.\n",
886 __func__
, t
, t
->gen
, t
->result
);
888 t
->complete(t
->pages
, t
->page_num
,
889 t
->private, t
->result
);
894 struct pohmelfs_mcache
896 struct rb_node mcache_entry
;
897 struct completion complete
;
908 struct netfs_inode_info info
;
911 struct pohmelfs_mcache
*pohmelfs_mcache_alloc(struct pohmelfs_sb
*psb
, u64 start
,
912 unsigned int size
, void *data
);
913 void pohmelfs_mcache_free(struct pohmelfs_sb
*psb
, struct pohmelfs_mcache
*m
);
914 struct pohmelfs_mcache
*pohmelfs_mcache_search(struct pohmelfs_sb
*psb
, u64 gen
);
915 void pohmelfs_mcache_remove_locked(struct pohmelfs_sb
*psb
, struct pohmelfs_mcache
*m
);
917 static inline void pohmelfs_mcache_get(struct pohmelfs_mcache
*m
)
919 atomic_inc(&m
->refcnt
);
922 static inline void pohmelfs_mcache_put(struct pohmelfs_sb
*psb
,
923 struct pohmelfs_mcache
*m
)
925 if (atomic_dec_and_test(&m
->refcnt
))
926 pohmelfs_mcache_free(psb
, m
);
929 #endif /* __KERNEL__*/
931 #endif /* __NETFS_H */