1
2
3
4
5
6
7
8#include <linux/compiler.h>
9#include <linux/kernel.h>
10#include <linux/ktime.h>
11#include <linux/fs.h>
12#include <linux/pagemap.h>
13#include <linux/rxrpc.h>
14#include <linux/key.h>
15#include <linux/workqueue.h>
16#include <linux/sched.h>
17#include <linux/fscache.h>
18#include <linux/backing-dev.h>
19#include <linux/uuid.h>
20#include <linux/mm_types.h>
21#include <linux/dns_resolver.h>
22#include <net/net_namespace.h>
23#include <net/netns/generic.h>
24#include <net/sock.h>
25#include <net/af_rxrpc.h>
26
27#include "afs.h"
28#include "afs_vl.h"
29
30#define AFS_CELL_MAX_ADDRS 15
31
32struct pagevec;
33struct afs_call;
34
35
36
37
38
39enum afs_flock_mode {
40 afs_flock_mode_unset,
41 afs_flock_mode_local,
42 afs_flock_mode_openafs,
43 afs_flock_mode_strict,
44 afs_flock_mode_write,
45};
46
47struct afs_fs_context {
48 bool force;
49 bool autocell;
50 bool dyn_root;
51 bool no_cell;
52 enum afs_flock_mode flock_mode;
53 afs_voltype_t type;
54 unsigned int volnamesz;
55 const char *volname;
56 struct afs_net *net;
57 struct afs_cell *cell;
58 struct afs_volume *volume;
59 struct key *key;
60};
61
62enum afs_call_state {
63 AFS_CALL_CL_REQUESTING,
64 AFS_CALL_CL_AWAIT_REPLY,
65 AFS_CALL_CL_PROC_REPLY,
66 AFS_CALL_SV_AWAIT_OP_ID,
67 AFS_CALL_SV_AWAIT_REQUEST,
68 AFS_CALL_SV_REPLYING,
69 AFS_CALL_SV_AWAIT_ACK,
70 AFS_CALL_COMPLETE,
71};
72
73
74
75
76struct afs_addr_list {
77 struct rcu_head rcu;
78 refcount_t usage;
79 u32 version;
80 unsigned char max_addrs;
81 unsigned char nr_addrs;
82 unsigned char preferred;
83 unsigned char nr_ipv4;
84 enum dns_record_source source:8;
85 enum dns_lookup_status status:8;
86 unsigned long failed;
87 unsigned long responded;
88 struct sockaddr_rxrpc addrs[];
89#define AFS_MAX_ADDRESSES ((unsigned int)(sizeof(unsigned long) * 8))
90};
91
92
93
94
95struct afs_call {
96 const struct afs_call_type *type;
97 struct afs_addr_list *alist;
98 wait_queue_head_t waitq;
99 struct work_struct async_work;
100 struct work_struct work;
101 struct rxrpc_call *rxcall;
102 struct key *key;
103 struct afs_net *net;
104 struct afs_server *server;
105 struct afs_vlserver *vlserver;
106 void *request;
107 struct iov_iter def_iter;
108 struct iov_iter *iter;
109 union {
110 struct kvec kvec[1];
111 struct bio_vec bvec[1];
112 };
113 void *buffer;
114 union {
115 long ret0;
116 struct afs_addr_list *ret_alist;
117 struct afs_vldb_entry *ret_vldb;
118 char *ret_str;
119 };
120 struct afs_operation *op;
121 unsigned int server_index;
122 atomic_t usage;
123 enum afs_call_state state;
124 spinlock_t state_lock;
125 int error;
126 u32 abort_code;
127 unsigned int max_lifespan;
128 unsigned request_size;
129 unsigned reply_max;
130 unsigned count2;
131 unsigned char unmarshall;
132 unsigned char addr_ix;
133 bool drop_ref;
134 bool send_pages;
135 bool need_attention;
136 bool async;
137 bool upgrade;
138 bool have_reply_time;
139 bool intr;
140 bool unmarshalling_error;
141 u16 service_id;
142 unsigned int debug_id;
143 u32 operation_ID;
144 u32 count;
145 union {
146 struct {
147 __be32 tmp_u;
148 __be32 tmp;
149 } __attribute__((packed));
150 __be64 tmp64;
151 };
152 ktime_t reply_time;
153};
154
155struct afs_call_type {
156 const char *name;
157 unsigned int op;
158
159
160
161
162 int (*deliver)(struct afs_call *call);
163
164
165 void (*destructor)(struct afs_call *call);
166
167
168 void (*work)(struct work_struct *work);
169
170
171 void (*done)(struct afs_call *call);
172};
173
174
175
176
177struct afs_wb_key {
178 refcount_t usage;
179 struct key *key;
180 struct list_head vnode_link;
181};
182
183
184
185
186struct afs_file {
187 struct key *key;
188 struct afs_wb_key *wb;
189};
190
191static inline struct key *afs_file_key(struct file *file)
192{
193 struct afs_file *af = file->private_data;
194
195 return af->key;
196}
197
198
199
200
201struct afs_read {
202 loff_t pos;
203 loff_t len;
204 loff_t actual_len;
205 loff_t remain;
206 loff_t file_size;
207 afs_dataversion_t data_version;
208 refcount_t usage;
209 unsigned int index;
210 unsigned int nr_pages;
211 unsigned int offset;
212 struct afs_vnode *vnode;
213 void (*page_done)(struct afs_read *);
214 struct page **pages;
215 struct page *array[];
216};
217
218
219
220
221
222struct afs_super_info {
223 struct net *net_ns;
224 struct afs_cell *cell;
225 struct afs_volume *volume;
226 enum afs_flock_mode flock_mode:8;
227 bool dyn_root;
228};
229
230static inline struct afs_super_info *AFS_FS_S(struct super_block *sb)
231{
232 return sb->s_fs_info;
233}
234
235extern struct file_system_type afs_fs_type;
236
237
238
239
240struct afs_sysnames {
241#define AFS_NR_SYSNAME 16
242 char *subs[AFS_NR_SYSNAME];
243 refcount_t usage;
244 unsigned short nr;
245 char blank[1];
246};
247
248
249
250
251struct afs_net {
252 struct net *net;
253 struct afs_uuid uuid;
254 bool live;
255
256
257 struct socket *socket;
258 struct afs_call *spare_incoming_call;
259 struct work_struct charge_preallocation_work;
260 struct mutex socket_mutex;
261 atomic_t nr_outstanding_calls;
262 atomic_t nr_superblocks;
263
264
265 struct rb_root cells;
266 struct afs_cell __rcu *ws_cell;
267 struct work_struct cells_manager;
268 struct timer_list cells_timer;
269 atomic_t cells_outstanding;
270 seqlock_t cells_lock;
271 struct mutex cells_alias_lock;
272
273 struct mutex proc_cells_lock;
274 struct hlist_head proc_cells;
275
276
277
278
279
280 seqlock_t fs_lock;
281 struct rb_root fs_servers;
282 struct list_head fs_probe_fast;
283 struct list_head fs_probe_slow;
284 struct hlist_head fs_proc;
285
286 struct hlist_head fs_addresses4;
287 struct hlist_head fs_addresses6;
288 seqlock_t fs_addr_lock;
289
290 struct work_struct fs_manager;
291 struct timer_list fs_timer;
292
293 struct work_struct fs_prober;
294 struct timer_list fs_probe_timer;
295 atomic_t servers_outstanding;
296
297
298 struct mutex lock_manager_mutex;
299
300
301 struct super_block *dynroot_sb;
302 struct proc_dir_entry *proc_afs;
303 struct afs_sysnames *sysnames;
304 rwlock_t sysnames_lock;
305
306
307 atomic_t n_lookup;
308 atomic_t n_reval;
309 atomic_t n_inval;
310 atomic_t n_relpg;
311 atomic_t n_read_dir;
312 atomic_t n_dir_cr;
313 atomic_t n_dir_rm;
314 atomic_t n_stores;
315 atomic_long_t n_store_bytes;
316 atomic_long_t n_fetch_bytes;
317 atomic_t n_fetches;
318};
319
320extern const char afs_init_sysname[];
321
322enum afs_cell_state {
323 AFS_CELL_UNSET,
324 AFS_CELL_ACTIVATING,
325 AFS_CELL_ACTIVE,
326 AFS_CELL_DEACTIVATING,
327 AFS_CELL_INACTIVE,
328 AFS_CELL_FAILED,
329};
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350struct afs_cell {
351 union {
352 struct rcu_head rcu;
353 struct rb_node net_node;
354 };
355 struct afs_net *net;
356 struct afs_cell *alias_of;
357 struct afs_volume *root_volume;
358 struct key *anonymous_key;
359 struct work_struct manager;
360 struct hlist_node proc_link;
361#ifdef CONFIG_AFS_FSCACHE
362 struct fscache_cookie *cache;
363#endif
364 time64_t dns_expiry;
365 time64_t last_inactive;
366 atomic_t usage;
367 unsigned long flags;
368#define AFS_CELL_FL_NO_GC 0
369#define AFS_CELL_FL_DO_LOOKUP 1
370#define AFS_CELL_FL_CHECK_ALIAS 2
371 enum afs_cell_state state;
372 short error;
373 enum dns_record_source dns_source:8;
374 enum dns_lookup_status dns_status:8;
375 unsigned int dns_lookup_count;
376
377
378 struct rb_root volumes;
379 struct hlist_head proc_volumes;
380 seqlock_t volume_lock;
381
382
383 struct rb_root fs_servers;
384 seqlock_t fs_lock;
385
386
387 rwlock_t vl_servers_lock;
388 struct afs_vlserver_list __rcu *vl_servers;
389
390 u8 name_len;
391 char *name;
392};
393
394
395
396
397struct afs_vlserver {
398 struct rcu_head rcu;
399 struct afs_addr_list __rcu *addresses;
400 unsigned long flags;
401#define AFS_VLSERVER_FL_PROBED 0
402#define AFS_VLSERVER_FL_PROBING 1
403#define AFS_VLSERVER_FL_IS_YFS 2
404#define AFS_VLSERVER_FL_RESPONDING 3
405 rwlock_t lock;
406 atomic_t usage;
407 unsigned int rtt;
408
409
410 wait_queue_head_t probe_wq;
411 atomic_t probe_outstanding;
412 spinlock_t probe_lock;
413 struct {
414 unsigned int rtt;
415 u32 abort_code;
416 short error;
417 unsigned short flags;
418#define AFS_VLSERVER_PROBE_RESPONDED 0x01
419#define AFS_VLSERVER_PROBE_IS_YFS 0x02
420#define AFS_VLSERVER_PROBE_NOT_YFS 0x04
421#define AFS_VLSERVER_PROBE_LOCAL_FAILURE 0x08
422 } probe;
423
424 u16 port;
425 u16 name_len;
426 char name[];
427};
428
429
430
431
432struct afs_vlserver_entry {
433 u16 priority;
434 u16 weight;
435 enum dns_record_source source:8;
436 enum dns_lookup_status status:8;
437 struct afs_vlserver *server;
438};
439
440struct afs_vlserver_list {
441 struct rcu_head rcu;
442 atomic_t usage;
443 u8 nr_servers;
444 u8 index;
445 u8 preferred;
446 enum dns_record_source source:8;
447 enum dns_lookup_status status:8;
448 rwlock_t lock;
449 struct afs_vlserver_entry servers[];
450};
451
452
453
454
455
456
457struct afs_vldb_entry {
458 afs_volid_t vid[3];
459
460 unsigned long flags;
461#define AFS_VLDB_HAS_RW 0
462#define AFS_VLDB_HAS_RO 1
463#define AFS_VLDB_HAS_BAK 2
464#define AFS_VLDB_QUERY_VALID 3
465#define AFS_VLDB_QUERY_ERROR 4
466
467 uuid_t fs_server[AFS_NMAXNSERVERS];
468 u32 addr_version[AFS_NMAXNSERVERS];
469 u8 fs_mask[AFS_NMAXNSERVERS];
470#define AFS_VOL_VTM_RW 0x01
471#define AFS_VOL_VTM_RO 0x02
472#define AFS_VOL_VTM_BAK 0x04
473 short error;
474 u8 nr_servers;
475 u8 name_len;
476 u8 name[AFS_MAXVOLNAME + 1];
477};
478
479
480
481
482struct afs_server {
483 struct rcu_head rcu;
484 union {
485 uuid_t uuid;
486 struct afs_uuid _uuid;
487 };
488
489 struct afs_addr_list __rcu *addresses;
490 struct afs_cell *cell;
491 struct rb_node uuid_rb;
492 struct afs_server __rcu *uuid_next;
493 struct afs_server *uuid_prev;
494 struct list_head probe_link;
495 struct hlist_node addr4_link;
496 struct hlist_node addr6_link;
497 struct hlist_node proc_link;
498 struct afs_server *gc_next;
499 time64_t unuse_time;
500 unsigned long flags;
501#define AFS_SERVER_FL_RESPONDING 0
502#define AFS_SERVER_FL_UPDATING 1
503#define AFS_SERVER_FL_NEEDS_UPDATE 2
504#define AFS_SERVER_FL_NOT_READY 4
505#define AFS_SERVER_FL_NOT_FOUND 5
506#define AFS_SERVER_FL_VL_FAIL 6
507#define AFS_SERVER_FL_MAY_HAVE_CB 8
508#define AFS_SERVER_FL_IS_YFS 16
509#define AFS_SERVER_FL_NO_IBULK 17
510#define AFS_SERVER_FL_NO_RM2 18
511 atomic_t ref;
512 atomic_t active;
513 u32 addr_version;
514 unsigned int rtt;
515 unsigned int debug_id;
516
517
518 rwlock_t fs_lock;
519
520
521 unsigned cb_s_break;
522
523
524 unsigned long probed_at;
525 wait_queue_head_t probe_wq;
526 atomic_t probe_outstanding;
527 spinlock_t probe_lock;
528 struct {
529 unsigned int rtt;
530 u32 abort_code;
531 short error;
532 bool responded:1;
533 bool is_yfs:1;
534 bool not_yfs:1;
535 bool local_failure:1;
536 } probe;
537};
538
539
540
541
542struct afs_server_entry {
543 struct afs_server *server;
544};
545
546struct afs_server_list {
547 afs_volid_t vids[AFS_MAXTYPES];
548 refcount_t usage;
549 unsigned char nr_servers;
550 unsigned char preferred;
551 unsigned short vnovol_mask;
552 unsigned int seq;
553 rwlock_t lock;
554 struct afs_server_entry servers[];
555};
556
557
558
559
560struct afs_volume {
561 union {
562 struct rcu_head rcu;
563 afs_volid_t vid;
564 };
565 atomic_t usage;
566 time64_t update_at;
567 struct afs_cell *cell;
568 struct rb_node cell_node;
569 struct hlist_node proc_link;
570 struct super_block __rcu *sb;
571 unsigned long flags;
572#define AFS_VOLUME_NEEDS_UPDATE 0
573#define AFS_VOLUME_UPDATING 1
574#define AFS_VOLUME_WAIT 2
575#define AFS_VOLUME_DELETED 3
576#define AFS_VOLUME_OFFLINE 4
577#define AFS_VOLUME_BUSY 5
578#define AFS_VOLUME_MAYBE_NO_IBULK 6
579#ifdef CONFIG_AFS_FSCACHE
580 struct fscache_cookie *cache;
581#endif
582 struct afs_server_list __rcu *servers;
583 rwlock_t servers_lock;
584 unsigned int servers_seq;
585
586 unsigned cb_v_break;
587 rwlock_t cb_v_break_lock;
588
589 afs_voltype_t type;
590 char type_force;
591 u8 name_len;
592 u8 name[AFS_MAXVOLNAME + 1];
593};
594
595enum afs_lock_state {
596 AFS_VNODE_LOCK_NONE,
597 AFS_VNODE_LOCK_WAITING_FOR_CB,
598 AFS_VNODE_LOCK_SETTING,
599 AFS_VNODE_LOCK_GRANTED,
600 AFS_VNODE_LOCK_EXTENDING,
601 AFS_VNODE_LOCK_NEED_UNLOCK,
602 AFS_VNODE_LOCK_UNLOCKING,
603 AFS_VNODE_LOCK_DELETED,
604};
605
606
607
608
609
610
611
612struct afs_vnode {
613 struct inode vfs_inode;
614
615 struct afs_volume *volume;
616 struct afs_fid fid;
617 struct afs_file_status status;
618 afs_dataversion_t invalid_before;
619#ifdef CONFIG_AFS_FSCACHE
620 struct fscache_cookie *cache;
621#endif
622 struct afs_permits __rcu *permit_cache;
623 struct mutex io_lock;
624 struct rw_semaphore validate_lock;
625 struct rw_semaphore rmdir_lock;
626 struct key *silly_key;
627 spinlock_t wb_lock;
628 spinlock_t lock;
629 unsigned long flags;
630#define AFS_VNODE_CB_PROMISED 0
631#define AFS_VNODE_UNSET 1
632#define AFS_VNODE_DIR_VALID 2
633#define AFS_VNODE_ZAP_DATA 3
634#define AFS_VNODE_DELETED 4
635#define AFS_VNODE_MOUNTPOINT 5
636#define AFS_VNODE_AUTOCELL 6
637#define AFS_VNODE_PSEUDODIR 7
638#define AFS_VNODE_NEW_CONTENT 8
639#define AFS_VNODE_SILLY_DELETED 9
640
641 struct list_head wb_keys;
642 struct list_head pending_locks;
643 struct list_head granted_locks;
644 struct delayed_work lock_work;
645 struct key *lock_key;
646 ktime_t locked_at;
647 enum afs_lock_state lock_state : 8;
648 afs_lock_type_t lock_type : 8;
649
650
651 void *cb_server;
652 unsigned int cb_s_break;
653 unsigned int cb_v_break;
654 unsigned int cb_break;
655 seqlock_t cb_lock;
656
657 time64_t cb_expires_at;
658};
659
660static inline struct fscache_cookie *afs_vnode_cache(struct afs_vnode *vnode)
661{
662#ifdef CONFIG_AFS_FSCACHE
663 return vnode->cache;
664#else
665 return NULL;
666#endif
667}
668
669
670
671
672struct afs_permit {
673 struct key *key;
674 afs_access_t access;
675};
676
677
678
679
680
681struct afs_permits {
682 struct rcu_head rcu;
683 struct hlist_node hash_node;
684 unsigned long h;
685 refcount_t usage;
686 unsigned short nr_permits;
687 bool invalidated;
688 struct afs_permit permits[];
689};
690
691
692
693
694struct afs_error {
695 short error;
696 bool responded;
697};
698
699
700
701
702struct afs_addr_cursor {
703 struct afs_addr_list *alist;
704 unsigned long tried;
705 signed char index;
706 bool responded;
707 unsigned short nr_iterations;
708 short error;
709 u32 abort_code;
710};
711
712
713
714
715struct afs_vl_cursor {
716 struct afs_addr_cursor ac;
717 struct afs_cell *cell;
718 struct afs_vlserver_list *server_list;
719 struct afs_vlserver *server;
720 struct key *key;
721 unsigned long untried;
722 short index;
723 short error;
724 unsigned short flags;
725#define AFS_VL_CURSOR_STOP 0x0001
726#define AFS_VL_CURSOR_RETRY 0x0002
727#define AFS_VL_CURSOR_RETRIED 0x0004
728 unsigned short nr_iterations;
729};
730
731
732
733
734struct afs_operation_ops {
735 void (*issue_afs_rpc)(struct afs_operation *op);
736 void (*issue_yfs_rpc)(struct afs_operation *op);
737 void (*success)(struct afs_operation *op);
738 void (*aborted)(struct afs_operation *op);
739 void (*edit_dir)(struct afs_operation *op);
740 void (*put)(struct afs_operation *op);
741};
742
743struct afs_vnode_param {
744 struct afs_vnode *vnode;
745 struct afs_fid fid;
746 struct afs_status_cb scb;
747 afs_dataversion_t dv_before;
748 unsigned int cb_break_before;
749 u8 dv_delta;
750 bool put_vnode:1;
751 bool need_io_lock:1;
752 bool update_ctime:1;
753 bool set_size:1;
754 bool op_unlinked:1;
755};
756
757
758
759
760
761struct afs_operation {
762 struct afs_net *net;
763 struct key *key;
764 const struct afs_call_type *type;
765 const struct afs_operation_ops *ops;
766
767
768 struct afs_volume *volume;
769 struct afs_vnode_param file[2];
770 struct afs_vnode_param *more_files;
771 struct afs_volsync volsync;
772 struct dentry *dentry;
773 struct dentry *dentry_2;
774 struct timespec64 mtime;
775 struct timespec64 ctime;
776 short nr_files;
777 short error;
778 unsigned int debug_id;
779
780 unsigned int cb_v_break;
781 unsigned int cb_s_break;
782
783 union {
784 struct {
785 int which;
786 } fetch_status;
787 struct {
788 int reason;
789 mode_t mode;
790 const char *symlink;
791 } create;
792 struct {
793 bool need_rehash;
794 } unlink;
795 struct {
796 struct dentry *rehash;
797 struct dentry *tmp;
798 bool new_negative;
799 } rename;
800 struct {
801 struct afs_read *req;
802 } fetch;
803 struct {
804 afs_lock_type_t type;
805 } lock;
806 struct {
807 struct address_space *mapping;
808 pgoff_t first;
809 pgoff_t last;
810 unsigned first_offset;
811 unsigned last_to;
812 } store;
813 struct {
814 struct iattr *attr;
815 loff_t old_i_size;
816 } setattr;
817 struct afs_acl *acl;
818 struct yfs_acl *yacl;
819 struct {
820 struct afs_volume_status vs;
821 struct kstatfs *buf;
822 } volstatus;
823 };
824
825
826 struct afs_addr_cursor ac;
827 struct afs_server_list *server_list;
828 struct afs_server *server;
829 struct afs_call *call;
830 unsigned long untried;
831 short index;
832 unsigned short nr_iterations;
833
834 unsigned int flags;
835#define AFS_OPERATION_STOP 0x0001
836#define AFS_OPERATION_VBUSY 0x0002
837#define AFS_OPERATION_VMOVED 0x0004
838#define AFS_OPERATION_VNOVOL 0x0008
839#define AFS_OPERATION_CUR_ONLY 0x0010
840#define AFS_OPERATION_NO_VSLEEP 0x0020
841#define AFS_OPERATION_UNINTR 0x0040
842#define AFS_OPERATION_DOWNGRADE 0x0080
843#define AFS_OPERATION_LOCK_0 0x0100
844#define AFS_OPERATION_LOCK_1 0x0200
845#define AFS_OPERATION_TRIED_ALL 0x0400
846#define AFS_OPERATION_RETRY_SERVER 0x0800
847#define AFS_OPERATION_DIR_CONFLICT 0x1000
848};
849
850
851
852
853struct afs_vnode_cache_aux {
854 u64 data_version;
855} __packed;
856
857#include <trace/events/afs.h>
858
859
860
861
862
863static inline struct afs_addr_list *afs_get_addrlist(struct afs_addr_list *alist)
864{
865 if (alist)
866 refcount_inc(&alist->usage);
867 return alist;
868}
869extern struct afs_addr_list *afs_alloc_addrlist(unsigned int,
870 unsigned short,
871 unsigned short);
872extern void afs_put_addrlist(struct afs_addr_list *);
873extern struct afs_vlserver_list *afs_parse_text_addrs(struct afs_net *,
874 const char *, size_t, char,
875 unsigned short, unsigned short);
876extern struct afs_vlserver_list *afs_dns_query(struct afs_cell *, time64_t *);
877extern bool afs_iterate_addresses(struct afs_addr_cursor *);
878extern int afs_end_cursor(struct afs_addr_cursor *);
879
880extern void afs_merge_fs_addr4(struct afs_addr_list *, __be32, u16);
881extern void afs_merge_fs_addr6(struct afs_addr_list *, __be32 *, u16);
882
883
884
885
886#ifdef CONFIG_AFS_FSCACHE
887extern struct fscache_netfs afs_cache_netfs;
888extern struct fscache_cookie_def afs_cell_cache_index_def;
889extern struct fscache_cookie_def afs_volume_cache_index_def;
890extern struct fscache_cookie_def afs_vnode_cache_index_def;
891#else
892#define afs_cell_cache_index_def (*(struct fscache_cookie_def *) NULL)
893#define afs_volume_cache_index_def (*(struct fscache_cookie_def *) NULL)
894#define afs_vnode_cache_index_def (*(struct fscache_cookie_def *) NULL)
895#endif
896
897
898
899
900extern void afs_init_callback_state(struct afs_server *);
901extern void __afs_break_callback(struct afs_vnode *, enum afs_cb_break_reason);
902extern void afs_break_callback(struct afs_vnode *, enum afs_cb_break_reason);
903extern void afs_break_callbacks(struct afs_server *, size_t, struct afs_callback_break *);
904
905static inline unsigned int afs_calc_vnode_cb_break(struct afs_vnode *vnode)
906{
907 return vnode->cb_break + vnode->cb_v_break;
908}
909
910static inline bool afs_cb_is_broken(unsigned int cb_break,
911 const struct afs_vnode *vnode)
912{
913 return cb_break != (vnode->cb_break + vnode->volume->cb_v_break);
914}
915
916
917
918
919extern int afs_cell_init(struct afs_net *, const char *);
920extern struct afs_cell *afs_lookup_cell_rcu(struct afs_net *, const char *, unsigned);
921extern struct afs_cell *afs_lookup_cell(struct afs_net *, const char *, unsigned,
922 const char *, bool);
923extern struct afs_cell *afs_get_cell(struct afs_cell *);
924extern void afs_put_cell(struct afs_net *, struct afs_cell *);
925extern void afs_manage_cells(struct work_struct *);
926extern void afs_cells_timer(struct timer_list *);
927extern void __net_exit afs_cell_purge(struct afs_net *);
928
929
930
931
932extern bool afs_cm_incoming_call(struct afs_call *);
933
934
935
936
937extern const struct file_operations afs_dir_file_operations;
938extern const struct inode_operations afs_dir_inode_operations;
939extern const struct address_space_operations afs_dir_aops;
940extern const struct dentry_operations afs_fs_dentry_operations;
941
942extern void afs_d_release(struct dentry *);
943extern void afs_check_for_remote_deletion(struct afs_operation *);
944
945
946
947
948extern void afs_edit_dir_add(struct afs_vnode *, struct qstr *, struct afs_fid *,
949 enum afs_edit_dir_reason);
950extern void afs_edit_dir_remove(struct afs_vnode *, struct qstr *, enum afs_edit_dir_reason);
951
952
953
954
955extern int afs_sillyrename(struct afs_vnode *, struct afs_vnode *,
956 struct dentry *, struct key *);
957extern int afs_silly_iput(struct dentry *, struct inode *);
958
959
960
961
962extern const struct inode_operations afs_dynroot_inode_operations;
963extern const struct dentry_operations afs_dynroot_dentry_operations;
964
965extern struct inode *afs_try_auto_mntpt(struct dentry *, struct inode *);
966extern int afs_dynroot_mkdir(struct afs_net *, struct afs_cell *);
967extern void afs_dynroot_rmdir(struct afs_net *, struct afs_cell *);
968extern int afs_dynroot_populate(struct super_block *);
969extern void afs_dynroot_depopulate(struct super_block *);
970
971
972
973
974extern const struct address_space_operations afs_fs_aops;
975extern const struct inode_operations afs_file_inode_operations;
976extern const struct file_operations afs_file_operations;
977
978extern int afs_cache_wb_key(struct afs_vnode *, struct afs_file *);
979extern void afs_put_wb_key(struct afs_wb_key *);
980extern int afs_open(struct inode *, struct file *);
981extern int afs_release(struct inode *, struct file *);
982extern int afs_fetch_data(struct afs_vnode *, struct key *, struct afs_read *);
983extern int afs_page_filler(void *, struct page *);
984extern void afs_put_read(struct afs_read *);
985
986static inline struct afs_read *afs_get_read(struct afs_read *req)
987{
988 refcount_inc(&req->usage);
989 return req;
990}
991
992
993
994
995extern struct workqueue_struct *afs_lock_manager;
996
997extern void afs_lock_op_done(struct afs_call *);
998extern void afs_lock_work(struct work_struct *);
999extern void afs_lock_may_be_available(struct afs_vnode *);
1000extern int afs_lock(struct file *, int, struct file_lock *);
1001extern int afs_flock(struct file *, int, struct file_lock *);
1002
1003
1004
1005
1006extern void afs_fs_fetch_status(struct afs_operation *);
1007extern void afs_fs_fetch_data(struct afs_operation *);
1008extern void afs_fs_create_file(struct afs_operation *);
1009extern void afs_fs_make_dir(struct afs_operation *);
1010extern void afs_fs_remove_file(struct afs_operation *);
1011extern void afs_fs_remove_dir(struct afs_operation *);
1012extern void afs_fs_link(struct afs_operation *);
1013extern void afs_fs_symlink(struct afs_operation *);
1014extern void afs_fs_rename(struct afs_operation *);
1015extern void afs_fs_store_data(struct afs_operation *);
1016extern void afs_fs_setattr(struct afs_operation *);
1017extern void afs_fs_get_volume_status(struct afs_operation *);
1018extern void afs_fs_set_lock(struct afs_operation *);
1019extern void afs_fs_extend_lock(struct afs_operation *);
1020extern void afs_fs_release_lock(struct afs_operation *);
1021extern int afs_fs_give_up_all_callbacks(struct afs_net *, struct afs_server *,
1022 struct afs_addr_cursor *, struct key *);
1023extern bool afs_fs_get_capabilities(struct afs_net *, struct afs_server *,
1024 struct afs_addr_cursor *, struct key *);
1025extern void afs_fs_inline_bulk_status(struct afs_operation *);
1026
1027struct afs_acl {
1028 u32 size;
1029 u8 data[];
1030};
1031
1032extern void afs_fs_fetch_acl(struct afs_operation *);
1033extern void afs_fs_store_acl(struct afs_operation *);
1034
1035
1036
1037
1038extern struct afs_operation *afs_alloc_operation(struct key *, struct afs_volume *);
1039extern int afs_put_operation(struct afs_operation *);
1040extern bool afs_begin_vnode_operation(struct afs_operation *);
1041extern void afs_wait_for_operation(struct afs_operation *);
1042extern int afs_do_sync_operation(struct afs_operation *);
1043
1044static inline void afs_op_nomem(struct afs_operation *op)
1045{
1046 op->error = -ENOMEM;
1047}
1048
1049static inline void afs_op_set_vnode(struct afs_operation *op, unsigned int n,
1050 struct afs_vnode *vnode)
1051{
1052 op->file[n].vnode = vnode;
1053 op->file[n].need_io_lock = true;
1054}
1055
1056static inline void afs_op_set_fid(struct afs_operation *op, unsigned int n,
1057 const struct afs_fid *fid)
1058{
1059 op->file[n].fid = *fid;
1060}
1061
1062
1063
1064
1065extern void afs_fileserver_probe_result(struct afs_call *);
1066extern void afs_fs_probe_fileserver(struct afs_net *, struct afs_server *, struct key *, bool);
1067extern int afs_wait_for_fs_probes(struct afs_server_list *, unsigned long);
1068extern void afs_probe_fileserver(struct afs_net *, struct afs_server *);
1069extern void afs_fs_probe_dispatcher(struct work_struct *);
1070extern int afs_wait_for_one_fs_probe(struct afs_server *, bool);
1071extern void afs_fs_probe_cleanup(struct afs_net *);
1072
1073
1074
1075
1076extern const struct afs_operation_ops afs_fetch_status_operation;
1077
1078extern void afs_vnode_commit_status(struct afs_operation *, struct afs_vnode_param *);
1079extern int afs_fetch_status(struct afs_vnode *, struct key *, bool, afs_access_t *);
1080extern int afs_ilookup5_test_by_fid(struct inode *, void *);
1081extern struct inode *afs_iget_pseudo_dir(struct super_block *, bool);
1082extern struct inode *afs_iget(struct afs_operation *, struct afs_vnode_param *);
1083extern struct inode *afs_root_iget(struct super_block *, struct key *);
1084extern bool afs_check_validity(struct afs_vnode *);
1085extern int afs_validate(struct afs_vnode *, struct key *);
1086extern int afs_getattr(const struct path *, struct kstat *, u32, unsigned int);
1087extern int afs_setattr(struct dentry *, struct iattr *);
1088extern void afs_evict_inode(struct inode *);
1089extern int afs_drop_inode(struct inode *);
1090
1091
1092
1093
1094extern struct workqueue_struct *afs_wq;
1095extern int afs_net_id;
1096
1097static inline struct afs_net *afs_net(struct net *net)
1098{
1099 return net_generic(net, afs_net_id);
1100}
1101
1102static inline struct afs_net *afs_sb2net(struct super_block *sb)
1103{
1104 return afs_net(AFS_FS_S(sb)->net_ns);
1105}
1106
1107static inline struct afs_net *afs_d2net(struct dentry *dentry)
1108{
1109 return afs_sb2net(dentry->d_sb);
1110}
1111
1112static inline struct afs_net *afs_i2net(struct inode *inode)
1113{
1114 return afs_sb2net(inode->i_sb);
1115}
1116
1117static inline struct afs_net *afs_v2net(struct afs_vnode *vnode)
1118{
1119 return afs_i2net(&vnode->vfs_inode);
1120}
1121
1122static inline struct afs_net *afs_sock2net(struct sock *sk)
1123{
1124 return net_generic(sock_net(sk), afs_net_id);
1125}
1126
1127static inline void __afs_stat(atomic_t *s)
1128{
1129 atomic_inc(s);
1130}
1131
1132#define afs_stat_v(vnode, n) __afs_stat(&afs_v2net(vnode)->n)
1133
1134
1135
1136
1137extern int afs_abort_to_error(u32);
1138extern void afs_prioritise_error(struct afs_error *, int, u32);
1139
1140
1141
1142
1143extern const struct inode_operations afs_mntpt_inode_operations;
1144extern const struct inode_operations afs_autocell_inode_operations;
1145extern const struct file_operations afs_mntpt_file_operations;
1146
1147extern struct vfsmount *afs_d_automount(struct path *);
1148extern void afs_mntpt_kill_timer(void);
1149
1150
1151
1152
1153#ifdef CONFIG_PROC_FS
1154extern int __net_init afs_proc_init(struct afs_net *);
1155extern void __net_exit afs_proc_cleanup(struct afs_net *);
1156extern int afs_proc_cell_setup(struct afs_cell *);
1157extern void afs_proc_cell_remove(struct afs_cell *);
1158extern void afs_put_sysnames(struct afs_sysnames *);
1159#else
1160static inline int afs_proc_init(struct afs_net *net) { return 0; }
1161static inline void afs_proc_cleanup(struct afs_net *net) {}
1162static inline int afs_proc_cell_setup(struct afs_cell *cell) { return 0; }
1163static inline void afs_proc_cell_remove(struct afs_cell *cell) {}
1164static inline void afs_put_sysnames(struct afs_sysnames *sysnames) {}
1165#endif
1166
1167
1168
1169
1170extern bool afs_select_fileserver(struct afs_operation *);
1171extern void afs_dump_edestaddrreq(const struct afs_operation *);
1172
1173
1174
1175
1176extern struct workqueue_struct *afs_async_calls;
1177
1178extern int __net_init afs_open_socket(struct afs_net *);
1179extern void __net_exit afs_close_socket(struct afs_net *);
1180extern void afs_charge_preallocation(struct work_struct *);
1181extern void afs_put_call(struct afs_call *);
1182extern void afs_make_call(struct afs_addr_cursor *, struct afs_call *, gfp_t);
1183extern long afs_wait_for_call_to_complete(struct afs_call *, struct afs_addr_cursor *);
1184extern struct afs_call *afs_alloc_flat_call(struct afs_net *,
1185 const struct afs_call_type *,
1186 size_t, size_t);
1187extern void afs_flat_call_destructor(struct afs_call *);
1188extern void afs_send_empty_reply(struct afs_call *);
1189extern void afs_send_simple_reply(struct afs_call *, const void *, size_t);
1190extern int afs_extract_data(struct afs_call *, bool);
1191extern int afs_protocol_error(struct afs_call *, enum afs_eproto_cause);
1192
1193static inline void afs_make_op_call(struct afs_operation *op, struct afs_call *call,
1194 gfp_t gfp)
1195{
1196 op->call = call;
1197 op->type = call->type;
1198 call->op = op;
1199 call->key = op->key;
1200 call->intr = !(op->flags & AFS_OPERATION_UNINTR);
1201 afs_make_call(&op->ac, call, gfp);
1202}
1203
1204static inline void afs_extract_begin(struct afs_call *call, void *buf, size_t size)
1205{
1206 call->kvec[0].iov_base = buf;
1207 call->kvec[0].iov_len = size;
1208 iov_iter_kvec(&call->def_iter, READ, call->kvec, 1, size);
1209}
1210
1211static inline void afs_extract_to_tmp(struct afs_call *call)
1212{
1213 afs_extract_begin(call, &call->tmp, sizeof(call->tmp));
1214}
1215
1216static inline void afs_extract_to_tmp64(struct afs_call *call)
1217{
1218 afs_extract_begin(call, &call->tmp64, sizeof(call->tmp64));
1219}
1220
1221static inline void afs_extract_discard(struct afs_call *call, size_t size)
1222{
1223 iov_iter_discard(&call->def_iter, READ, size);
1224}
1225
1226static inline void afs_extract_to_buf(struct afs_call *call, size_t size)
1227{
1228 afs_extract_begin(call, call->buffer, size);
1229}
1230
1231static inline int afs_transfer_reply(struct afs_call *call)
1232{
1233 return afs_extract_data(call, false);
1234}
1235
1236static inline bool afs_check_call_state(struct afs_call *call,
1237 enum afs_call_state state)
1238{
1239 return READ_ONCE(call->state) == state;
1240}
1241
1242static inline bool afs_set_call_state(struct afs_call *call,
1243 enum afs_call_state from,
1244 enum afs_call_state to)
1245{
1246 bool ok = false;
1247
1248 spin_lock_bh(&call->state_lock);
1249 if (call->state == from) {
1250 call->state = to;
1251 trace_afs_call_state(call, from, to, 0, 0);
1252 ok = true;
1253 }
1254 spin_unlock_bh(&call->state_lock);
1255 return ok;
1256}
1257
1258static inline void afs_set_call_complete(struct afs_call *call,
1259 int error, u32 remote_abort)
1260{
1261 enum afs_call_state state;
1262 bool ok = false;
1263
1264 spin_lock_bh(&call->state_lock);
1265 state = call->state;
1266 if (state != AFS_CALL_COMPLETE) {
1267 call->abort_code = remote_abort;
1268 call->error = error;
1269 call->state = AFS_CALL_COMPLETE;
1270 trace_afs_call_state(call, state, AFS_CALL_COMPLETE,
1271 error, remote_abort);
1272 ok = true;
1273 }
1274 spin_unlock_bh(&call->state_lock);
1275 if (ok) {
1276 trace_afs_call_done(call);
1277
1278
1279
1280
1281
1282 if (call->drop_ref)
1283 afs_put_call(call);
1284 }
1285}
1286
1287
1288
1289
1290extern void afs_put_permits(struct afs_permits *);
1291extern void afs_clear_permits(struct afs_vnode *);
1292extern void afs_cache_permit(struct afs_vnode *, struct key *, unsigned int,
1293 struct afs_status_cb *);
1294extern void afs_zap_permits(struct rcu_head *);
1295extern struct key *afs_request_key(struct afs_cell *);
1296extern struct key *afs_request_key_rcu(struct afs_cell *);
1297extern int afs_check_permit(struct afs_vnode *, struct key *, afs_access_t *);
1298extern int afs_permission(struct inode *, int);
1299extern void __exit afs_clean_up_permit_cache(void);
1300
1301
1302
1303
1304extern spinlock_t afs_server_peer_lock;
1305
1306extern struct afs_server *afs_find_server(struct afs_net *,
1307 const struct sockaddr_rxrpc *);
1308extern struct afs_server *afs_find_server_by_uuid(struct afs_net *, const uuid_t *);
1309extern struct afs_server *afs_lookup_server(struct afs_cell *, struct key *, const uuid_t *, u32);
1310extern struct afs_server *afs_get_server(struct afs_server *, enum afs_server_trace);
1311extern struct afs_server *afs_use_server(struct afs_server *, enum afs_server_trace);
1312extern void afs_unuse_server(struct afs_net *, struct afs_server *, enum afs_server_trace);
1313extern void afs_unuse_server_notime(struct afs_net *, struct afs_server *, enum afs_server_trace);
1314extern void afs_put_server(struct afs_net *, struct afs_server *, enum afs_server_trace);
1315extern void afs_manage_servers(struct work_struct *);
1316extern void afs_servers_timer(struct timer_list *);
1317extern void afs_fs_probe_timer(struct timer_list *);
1318extern void __net_exit afs_purge_servers(struct afs_net *);
1319extern bool afs_check_server_record(struct afs_operation *, struct afs_server *);
1320
1321static inline void afs_inc_servers_outstanding(struct afs_net *net)
1322{
1323 atomic_inc(&net->servers_outstanding);
1324}
1325
1326static inline void afs_dec_servers_outstanding(struct afs_net *net)
1327{
1328 if (atomic_dec_and_test(&net->servers_outstanding))
1329 wake_up_var(&net->servers_outstanding);
1330}
1331
1332static inline bool afs_is_probing_server(struct afs_server *server)
1333{
1334 return list_empty(&server->probe_link);
1335}
1336
1337
1338
1339
1340static inline struct afs_server_list *afs_get_serverlist(struct afs_server_list *slist)
1341{
1342 refcount_inc(&slist->usage);
1343 return slist;
1344}
1345
1346extern void afs_put_serverlist(struct afs_net *, struct afs_server_list *);
1347extern struct afs_server_list *afs_alloc_server_list(struct afs_cell *, struct key *,
1348 struct afs_vldb_entry *,
1349 u8);
1350extern bool afs_annotate_server_list(struct afs_server_list *, struct afs_server_list *);
1351
1352
1353
1354
1355extern int __init afs_fs_init(void);
1356extern void afs_fs_exit(void);
1357
1358
1359
1360
1361extern struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *,
1362 const char *, int);
1363extern struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *, const uuid_t *);
1364extern struct afs_call *afs_vl_get_capabilities(struct afs_net *, struct afs_addr_cursor *,
1365 struct key *, struct afs_vlserver *, unsigned int);
1366extern struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *, const uuid_t *);
1367extern char *afs_yfsvl_get_cell_name(struct afs_vl_cursor *);
1368
1369
1370
1371
1372extern int afs_cell_detect_alias(struct afs_cell *, struct key *);
1373
1374
1375
1376
1377extern void afs_vlserver_probe_result(struct afs_call *);
1378extern int afs_send_vl_probes(struct afs_net *, struct key *, struct afs_vlserver_list *);
1379extern int afs_wait_for_vl_probes(struct afs_vlserver_list *, unsigned long);
1380
1381
1382
1383
1384extern bool afs_begin_vlserver_operation(struct afs_vl_cursor *,
1385 struct afs_cell *, struct key *);
1386extern bool afs_select_vlserver(struct afs_vl_cursor *);
1387extern bool afs_select_current_vlserver(struct afs_vl_cursor *);
1388extern int afs_end_vlserver_operation(struct afs_vl_cursor *);
1389
1390
1391
1392
1393static inline struct afs_vlserver *afs_get_vlserver(struct afs_vlserver *vlserver)
1394{
1395 atomic_inc(&vlserver->usage);
1396 return vlserver;
1397}
1398
1399static inline struct afs_vlserver_list *afs_get_vlserverlist(struct afs_vlserver_list *vllist)
1400{
1401 if (vllist)
1402 atomic_inc(&vllist->usage);
1403 return vllist;
1404}
1405
1406extern struct afs_vlserver *afs_alloc_vlserver(const char *, size_t, unsigned short);
1407extern void afs_put_vlserver(struct afs_net *, struct afs_vlserver *);
1408extern struct afs_vlserver_list *afs_alloc_vlserver_list(unsigned int);
1409extern void afs_put_vlserverlist(struct afs_net *, struct afs_vlserver_list *);
1410extern struct afs_vlserver_list *afs_extract_vlserver_list(struct afs_cell *,
1411 const void *, size_t);
1412
1413
1414
1415
1416extern struct afs_volume *afs_create_volume(struct afs_fs_context *);
1417extern void afs_activate_volume(struct afs_volume *);
1418extern void afs_deactivate_volume(struct afs_volume *);
1419extern struct afs_volume *afs_get_volume(struct afs_volume *, enum afs_volume_trace);
1420extern void afs_put_volume(struct afs_net *, struct afs_volume *, enum afs_volume_trace);
1421extern int afs_check_volume_status(struct afs_volume *, struct afs_operation *);
1422
1423
1424
1425
1426extern int afs_set_page_dirty(struct page *);
1427extern int afs_write_begin(struct file *file, struct address_space *mapping,
1428 loff_t pos, unsigned len, unsigned flags,
1429 struct page **pagep, void **fsdata);
1430extern int afs_write_end(struct file *file, struct address_space *mapping,
1431 loff_t pos, unsigned len, unsigned copied,
1432 struct page *page, void *fsdata);
1433extern int afs_writepage(struct page *, struct writeback_control *);
1434extern int afs_writepages(struct address_space *, struct writeback_control *);
1435extern ssize_t afs_file_write(struct kiocb *, struct iov_iter *);
1436extern int afs_fsync(struct file *, loff_t, loff_t, int);
1437extern vm_fault_t afs_page_mkwrite(struct vm_fault *vmf);
1438extern void afs_prune_wb_keys(struct afs_vnode *);
1439extern int afs_launder_page(struct page *);
1440
1441
1442
1443
1444extern const struct xattr_handler *afs_xattr_handlers[];
1445extern ssize_t afs_listxattr(struct dentry *, char *, size_t);
1446
1447
1448
1449
1450extern void yfs_fs_fetch_data(struct afs_operation *);
1451extern void yfs_fs_create_file(struct afs_operation *);
1452extern void yfs_fs_make_dir(struct afs_operation *);
1453extern void yfs_fs_remove_file2(struct afs_operation *);
1454extern void yfs_fs_remove_file(struct afs_operation *);
1455extern void yfs_fs_remove_dir(struct afs_operation *);
1456extern void yfs_fs_link(struct afs_operation *);
1457extern void yfs_fs_symlink(struct afs_operation *);
1458extern void yfs_fs_rename(struct afs_operation *);
1459extern void yfs_fs_store_data(struct afs_operation *);
1460extern void yfs_fs_setattr(struct afs_operation *);
1461extern void yfs_fs_get_volume_status(struct afs_operation *);
1462extern void yfs_fs_set_lock(struct afs_operation *);
1463extern void yfs_fs_extend_lock(struct afs_operation *);
1464extern void yfs_fs_release_lock(struct afs_operation *);
1465extern void yfs_fs_fetch_status(struct afs_operation *);
1466extern void yfs_fs_inline_bulk_status(struct afs_operation *);
1467
1468struct yfs_acl {
1469 struct afs_acl *acl;
1470 struct afs_acl *vol_acl;
1471 u32 inherit_flag;
1472 u32 num_cleaned;
1473 unsigned int flags;
1474#define YFS_ACL_WANT_ACL 0x01
1475#define YFS_ACL_WANT_VOL_ACL 0x02
1476};
1477
1478extern void yfs_free_opaque_acl(struct yfs_acl *);
1479extern void yfs_fs_fetch_opaque_acl(struct afs_operation *);
1480extern void yfs_fs_store_opaque_acl2(struct afs_operation *);
1481
1482
1483
1484
1485static inline struct afs_vnode *AFS_FS_I(struct inode *inode)
1486{
1487 return container_of(inode, struct afs_vnode, vfs_inode);
1488}
1489
1490static inline struct inode *AFS_VNODE_TO_I(struct afs_vnode *vnode)
1491{
1492 return &vnode->vfs_inode;
1493}
1494
1495
1496
1497
1498
1499
1500static inline void afs_update_dentry_version(struct afs_operation *op,
1501 struct afs_vnode_param *dir_vp,
1502 struct dentry *dentry)
1503{
1504 if (!op->error)
1505 dentry->d_fsdata =
1506 (void *)(unsigned long)dir_vp->scb.status.data_version;
1507}
1508
1509
1510
1511
1512
1513
1514static inline void afs_check_dir_conflict(struct afs_operation *op,
1515 struct afs_vnode_param *dvp)
1516{
1517 if (dvp->dv_before + dvp->dv_delta != dvp->scb.status.data_version)
1518 op->flags |= AFS_OPERATION_DIR_CONFLICT;
1519}
1520
1521static inline int afs_io_error(struct afs_call *call, enum afs_io_error where)
1522{
1523 trace_afs_io_error(call->debug_id, -EIO, where);
1524 return -EIO;
1525}
1526
1527static inline int afs_bad(struct afs_vnode *vnode, enum afs_file_error where)
1528{
1529 trace_afs_file_error(vnode, -EIO, where);
1530 return -EIO;
1531}
1532
1533
1534
1535
1536
1537extern unsigned afs_debug;
1538
1539#define dbgprintk(FMT,...) \
1540 printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
1541
1542#define kenter(FMT,...) dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1543#define kleave(FMT,...) dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1544#define kdebug(FMT,...) dbgprintk(" "FMT ,##__VA_ARGS__)
1545
1546
1547#if defined(__KDEBUG)
1548#define _enter(FMT,...) kenter(FMT,##__VA_ARGS__)
1549#define _leave(FMT,...) kleave(FMT,##__VA_ARGS__)
1550#define _debug(FMT,...) kdebug(FMT,##__VA_ARGS__)
1551
1552#elif defined(CONFIG_AFS_DEBUG)
1553#define AFS_DEBUG_KENTER 0x01
1554#define AFS_DEBUG_KLEAVE 0x02
1555#define AFS_DEBUG_KDEBUG 0x04
1556
1557#define _enter(FMT,...) \
1558do { \
1559 if (unlikely(afs_debug & AFS_DEBUG_KENTER)) \
1560 kenter(FMT,##__VA_ARGS__); \
1561} while (0)
1562
1563#define _leave(FMT,...) \
1564do { \
1565 if (unlikely(afs_debug & AFS_DEBUG_KLEAVE)) \
1566 kleave(FMT,##__VA_ARGS__); \
1567} while (0)
1568
1569#define _debug(FMT,...) \
1570do { \
1571 if (unlikely(afs_debug & AFS_DEBUG_KDEBUG)) \
1572 kdebug(FMT,##__VA_ARGS__); \
1573} while (0)
1574
1575#else
1576#define _enter(FMT,...) no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1577#define _leave(FMT,...) no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1578#define _debug(FMT,...) no_printk(" "FMT ,##__VA_ARGS__)
1579#endif
1580
1581
1582
1583
1584#if 1
1585
1586#define ASSERT(X) \
1587do { \
1588 if (unlikely(!(X))) { \
1589 printk(KERN_ERR "\n"); \
1590 printk(KERN_ERR "AFS: Assertion failed\n"); \
1591 BUG(); \
1592 } \
1593} while(0)
1594
1595#define ASSERTCMP(X, OP, Y) \
1596do { \
1597 if (unlikely(!((X) OP (Y)))) { \
1598 printk(KERN_ERR "\n"); \
1599 printk(KERN_ERR "AFS: Assertion failed\n"); \
1600 printk(KERN_ERR "%lu " #OP " %lu is false\n", \
1601 (unsigned long)(X), (unsigned long)(Y)); \
1602 printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n", \
1603 (unsigned long)(X), (unsigned long)(Y)); \
1604 BUG(); \
1605 } \
1606} while(0)
1607
1608#define ASSERTRANGE(L, OP1, N, OP2, H) \
1609do { \
1610 if (unlikely(!((L) OP1 (N)) || !((N) OP2 (H)))) { \
1611 printk(KERN_ERR "\n"); \
1612 printk(KERN_ERR "AFS: Assertion failed\n"); \
1613 printk(KERN_ERR "%lu "#OP1" %lu "#OP2" %lu is false\n", \
1614 (unsigned long)(L), (unsigned long)(N), \
1615 (unsigned long)(H)); \
1616 printk(KERN_ERR "0x%lx "#OP1" 0x%lx "#OP2" 0x%lx is false\n", \
1617 (unsigned long)(L), (unsigned long)(N), \
1618 (unsigned long)(H)); \
1619 BUG(); \
1620 } \
1621} while(0)
1622
1623#define ASSERTIF(C, X) \
1624do { \
1625 if (unlikely((C) && !(X))) { \
1626 printk(KERN_ERR "\n"); \
1627 printk(KERN_ERR "AFS: Assertion failed\n"); \
1628 BUG(); \
1629 } \
1630} while(0)
1631
1632#define ASSERTIFCMP(C, X, OP, Y) \
1633do { \
1634 if (unlikely((C) && !((X) OP (Y)))) { \
1635 printk(KERN_ERR "\n"); \
1636 printk(KERN_ERR "AFS: Assertion failed\n"); \
1637 printk(KERN_ERR "%lu " #OP " %lu is false\n", \
1638 (unsigned long)(X), (unsigned long)(Y)); \
1639 printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n", \
1640 (unsigned long)(X), (unsigned long)(Y)); \
1641 BUG(); \
1642 } \
1643} while(0)
1644
1645#else
1646
1647#define ASSERT(X) \
1648do { \
1649} while(0)
1650
1651#define ASSERTCMP(X, OP, Y) \
1652do { \
1653} while(0)
1654
1655#define ASSERTRANGE(L, OP1, N, OP2, H) \
1656do { \
1657} while(0)
1658
1659#define ASSERTIF(C, X) \
1660do { \
1661} while(0)
1662
1663#define ASSERTIFCMP(C, X, OP, Y) \
1664do { \
1665} while(0)
1666
1667#endif
1668