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