]> git.ipfire.org Git - thirdparty/linux.git/blob - fs/afs/internal.h
projects / thirdparty / linux.git / blob
? search:


6ed7d4df4ec61b2f9e1fe4c155bf4776874000a4
[thirdparty/linux.git] / fs / afs / internal.h
1 /* internal AFS stuff
2 *
3 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12 #include <linux/compiler.h>
13 #include <linux/kernel.h>
14 #include <linux/ktime.h>
15 #include <linux/fs.h>
16 #include <linux/pagemap.h>
17 #include <linux/rxrpc.h>
18 #include <linux/key.h>
19 #include <linux/workqueue.h>
20 #include <linux/sched.h>
21 #include <linux/fscache.h>
22 #include <linux/backing-dev.h>
23 #include <linux/uuid.h>
24 #include <linux/mm_types.h>
25 #include <linux/dns_resolver.h>
26 #include <net/net_namespace.h>
27 #include <net/netns/generic.h>
28 #include <net/sock.h>
29 #include <net/af_rxrpc.h>
30
31 #include "afs.h"
32 #include "afs_vl.h"
33
34 #define AFS_CELL_MAX_ADDRS 15
35
36 struct pagevec;
37 struct afs_call;
38
39 /*
40 * Partial file-locking emulation mode. (The problem being that AFS3 only
41 * allows whole-file locks and no upgrading/downgrading).
42 */
43 enum afs_flock_mode {
44 afs_flock_mode_unset,
45 afs_flock_mode_local, /* Local locking only */
46 afs_flock_mode_openafs, /* Don't get server lock for a partial lock */
47 afs_flock_mode_strict, /* Always get a server lock for a partial lock */
48 afs_flock_mode_write, /* Get an exclusive server lock for a partial lock */
49 };
50
51 struct afs_fs_context {
52 bool force; /* T to force cell type */
53 bool autocell; /* T if set auto mount operation */
54 bool dyn_root; /* T if dynamic root */
55 bool no_cell; /* T if the source is "none" (for dynroot) */
56 enum afs_flock_mode flock_mode; /* Partial file-locking emulation mode */
57 afs_voltype_t type; /* type of volume requested */
58 unsigned int volnamesz; /* size of volume name */
59 const char *volname; /* name of volume to mount */
60 struct afs_net *net; /* the AFS net namespace stuff */
61 struct afs_cell *cell; /* cell in which to find volume */
62 struct afs_volume *volume; /* volume record */
63 struct key *key; /* key to use for secure mounting */
64 };
65
66 struct afs_iget_data {
67 struct afs_fid fid;
68 struct afs_volume *volume; /* volume on which resides */
69 };
70
71 enum afs_call_state {
72 AFS_CALL_CL_REQUESTING, /* Client: Request is being sent */
73 AFS_CALL_CL_AWAIT_REPLY, /* Client: Awaiting reply */
74 AFS_CALL_CL_PROC_REPLY, /* Client: rxrpc call complete; processing reply */
75 AFS_CALL_SV_AWAIT_OP_ID, /* Server: Awaiting op ID */
76 AFS_CALL_SV_AWAIT_REQUEST, /* Server: Awaiting request data */
77 AFS_CALL_SV_REPLYING, /* Server: Replying */
78 AFS_CALL_SV_AWAIT_ACK, /* Server: Awaiting final ACK */
79 AFS_CALL_COMPLETE, /* Completed or failed */
80 };
81
82 /*
83 * List of server addresses.
84 */
85 struct afs_addr_list {
86 struct rcu_head rcu; /* Must be first */
87 refcount_t usage;
88 u32 version; /* Version */
89 unsigned char max_addrs;
90 unsigned char nr_addrs;
91 unsigned char preferred; /* Preferred address */
92 unsigned char nr_ipv4; /* Number of IPv4 addresses */
93 enum dns_record_source source:8;
94 enum dns_lookup_status status:8;
95 unsigned long probed; /* Mask of servers that have been probed */
96 unsigned long failed; /* Mask of addrs that failed locally/ICMP */
97 unsigned long responded; /* Mask of addrs that responded */
98 struct sockaddr_rxrpc addrs[];
99 #define AFS_MAX_ADDRESSES ((unsigned int)(sizeof(unsigned long) * 8))
100 };
101
102 /*
103 * a record of an in-progress RxRPC call
104 */
105 struct afs_call {
106 const struct afs_call_type *type; /* type of call */
107 struct afs_addr_list *alist; /* Address is alist[addr_ix] */
108 wait_queue_head_t waitq; /* processes awaiting completion */
109 struct work_struct async_work; /* async I/O processor */
110 struct work_struct work; /* actual work processor */
111 struct rxrpc_call *rxcall; /* RxRPC call handle */
112 struct key *key; /* security for this call */
113 struct afs_net *net; /* The network namespace */
114 union {
115 struct afs_server *server;
116 struct afs_vlserver *vlserver;
117 };
118 struct afs_cb_interest *cbi; /* Callback interest for server used */
119 struct afs_vnode *lvnode; /* vnode being locked */
120 void *request; /* request data (first part) */
121 struct address_space *mapping; /* Pages being written from */
122 struct iov_iter iter; /* Buffer iterator */
123 struct iov_iter *_iter; /* Iterator currently in use */
124 union { /* Convenience for ->iter */
125 struct kvec kvec[1];
126 struct bio_vec bvec[1];
127 };
128 void *buffer; /* reply receive buffer */
129 union {
130 long ret0; /* Value to reply with instead of 0 */
131 struct afs_addr_list *ret_alist;
132 struct afs_vldb_entry *ret_vldb;
133 struct afs_acl *ret_acl;
134 };
135 struct afs_fid *out_fid;
136 struct afs_status_cb *out_dir_scb;
137 struct afs_status_cb *out_scb;
138 struct yfs_acl *out_yacl;
139 struct afs_volsync *out_volsync;
140 struct afs_volume_status *out_volstatus;
141 struct afs_read *read_request;
142 unsigned int server_index;
143 pgoff_t first; /* first page in mapping to deal with */
144 pgoff_t last; /* last page in mapping to deal with */
145 atomic_t usage;
146 enum afs_call_state state;
147 spinlock_t state_lock;
148 int error; /* error code */
149 u32 abort_code; /* Remote abort ID or 0 */
150 u32 epoch;
151 unsigned int max_lifespan; /* Maximum lifespan to set if not 0 */
152 unsigned request_size; /* size of request data */
153 unsigned reply_max; /* maximum size of reply */
154 unsigned first_offset; /* offset into mapping[first] */
155 union {
156 unsigned last_to; /* amount of mapping[last] */
157 unsigned count2; /* count used in unmarshalling */
158 };
159 unsigned char unmarshall; /* unmarshalling phase */
160 unsigned char addr_ix; /* Address in ->alist */
161 bool incoming; /* T if incoming call */
162 bool send_pages; /* T if data from mapping should be sent */
163 bool need_attention; /* T if RxRPC poked us */
164 bool async; /* T if asynchronous */
165 bool upgrade; /* T to request service upgrade */
166 bool have_reply_time; /* T if have got reply_time */
167 bool intr; /* T if interruptible */
168 u16 service_id; /* Actual service ID (after upgrade) */
169 unsigned int debug_id; /* Trace ID */
170 u32 operation_ID; /* operation ID for an incoming call */
171 u32 count; /* count for use in unmarshalling */
172 union { /* place to extract temporary data */
173 struct {
174 __be32 tmp_u;
175 __be32 tmp;
176 } __attribute__((packed));
177 __be64 tmp64;
178 };
179 ktime_t reply_time; /* Time of first reply packet */
180 };
181
182 struct afs_call_type {
183 const char *name;
184 unsigned int op; /* Really enum afs_fs_operation */
185
186 /* deliver request or reply data to an call
187 * - returning an error will cause the call to be aborted
188 */
189 int (*deliver)(struct afs_call *call);
190
191 /* clean up a call */
192 void (*destructor)(struct afs_call *call);
193
194 /* Work function */
195 void (*work)(struct work_struct *work);
196
197 /* Call done function (gets called immediately on success or failure) */
198 void (*done)(struct afs_call *call);
199 };
200
201 /*
202 * Key available for writeback on a file.
203 */
204 struct afs_wb_key {
205 refcount_t usage;
206 struct key *key;
207 struct list_head vnode_link; /* Link in vnode->wb_keys */
208 };
209
210 /*
211 * AFS open file information record. Pointed to by file->private_data.
212 */
213 struct afs_file {
214 struct key *key; /* The key this file was opened with */
215 struct afs_wb_key *wb; /* Writeback key record for this file */
216 };
217
218 static inline struct key *afs_file_key(struct file *file)
219 {
220 struct afs_file *af = file->private_data;
221
222 return af->key;
223 }
224
225 /*
226 * Record of an outstanding read operation on a vnode.
227 */
228 struct afs_read {
229 loff_t pos; /* Where to start reading */
230 loff_t len; /* How much we're asking for */
231 loff_t actual_len; /* How much we're actually getting */
232 loff_t remain; /* Amount remaining */
233 loff_t file_size; /* File size returned by server */
234 afs_dataversion_t data_version; /* Version number returned by server */
235 refcount_t usage;
236 unsigned int index; /* Which page we're reading into */
237 unsigned int nr_pages;
238 unsigned int offset; /* offset into current page */
239 struct afs_vnode *vnode;
240 void (*page_done)(struct afs_read *);
241 struct page **pages;
242 struct page *array[];
243 };
244
245 /*
246 * AFS superblock private data
247 * - there's one superblock per volume
248 */
249 struct afs_super_info {
250 struct net *net_ns; /* Network namespace */
251 struct afs_cell *cell; /* The cell in which the volume resides */
252 struct afs_volume *volume; /* volume record */
253 enum afs_flock_mode flock_mode:8; /* File locking emulation mode */
254 bool dyn_root; /* True if dynamic root */
255 };
256
257 static inline struct afs_super_info *AFS_FS_S(struct super_block *sb)
258 {
259 return sb->s_fs_info;
260 }
261
262 extern struct file_system_type afs_fs_type;
263
264 /*
265 * Set of substitutes for @sys.
266 */
267 struct afs_sysnames {
268 #define AFS_NR_SYSNAME 16
269 char *subs[AFS_NR_SYSNAME];
270 refcount_t usage;
271 unsigned short nr;
272 char blank[1];
273 };
274
275 /*
276 * AFS network namespace record.
277 */
278 struct afs_net {
279 struct net *net; /* Backpointer to the owning net namespace */
280 struct afs_uuid uuid;
281 bool live; /* F if this namespace is being removed */
282
283 /* AF_RXRPC I/O stuff */
284 struct socket *socket;
285 struct afs_call *spare_incoming_call;
286 struct work_struct charge_preallocation_work;
287 struct mutex socket_mutex;
288 atomic_t nr_outstanding_calls;
289 atomic_t nr_superblocks;
290
291 /* Cell database */
292 struct rb_root cells;
293 struct afs_cell __rcu *ws_cell;
294 struct work_struct cells_manager;
295 struct timer_list cells_timer;
296 atomic_t cells_outstanding;
297 seqlock_t cells_lock;
298
299 struct mutex proc_cells_lock;
300 struct hlist_head proc_cells;
301
302 /* Known servers. Theoretically each fileserver can only be in one
303 * cell, but in practice, people create aliases and subsets and there's
304 * no easy way to distinguish them.
305 */
306 seqlock_t fs_lock; /* For fs_servers */
307 struct rb_root fs_servers; /* afs_server (by server UUID or address) */
308 struct list_head fs_updates; /* afs_server (by update_at) */
309 struct hlist_head fs_proc; /* procfs servers list */
310
311 struct hlist_head fs_addresses4; /* afs_server (by lowest IPv4 addr) */
312 struct hlist_head fs_addresses6; /* afs_server (by lowest IPv6 addr) */
313 seqlock_t fs_addr_lock; /* For fs_addresses[46] */
314
315 struct work_struct fs_manager;
316 struct timer_list fs_timer;
317 atomic_t servers_outstanding;
318
319 /* File locking renewal management */
320 struct mutex lock_manager_mutex;
321
322 /* Misc */
323 struct super_block *dynroot_sb; /* Dynamic root mount superblock */
324 struct proc_dir_entry *proc_afs; /* /proc/net/afs directory */
325 struct afs_sysnames *sysnames;
326 rwlock_t sysnames_lock;
327
328 /* Statistics counters */
329 atomic_t n_lookup; /* Number of lookups done */
330 atomic_t n_reval; /* Number of dentries needing revalidation */
331 atomic_t n_inval; /* Number of invalidations by the server */
332 atomic_t n_relpg; /* Number of invalidations by releasepage */
333 atomic_t n_read_dir; /* Number of directory pages read */
334 atomic_t n_dir_cr; /* Number of directory entry creation edits */
335 atomic_t n_dir_rm; /* Number of directory entry removal edits */
336 atomic_t n_stores; /* Number of store ops */
337 atomic_long_t n_store_bytes; /* Number of bytes stored */
338 atomic_long_t n_fetch_bytes; /* Number of bytes fetched */
339 atomic_t n_fetches; /* Number of data fetch ops */
340 };
341
342 extern const char afs_init_sysname[];
343
344 enum afs_cell_state {
345 AFS_CELL_UNSET,
346 AFS_CELL_ACTIVATING,
347 AFS_CELL_ACTIVE,
348 AFS_CELL_DEACTIVATING,
349 AFS_CELL_INACTIVE,
350 AFS_CELL_FAILED,
351 };
352
353 /*
354 * AFS cell record.
355 *
356 * This is a tricky concept to get right as it is possible to create aliases
357 * simply by pointing AFSDB/SRV records for two names at the same set of VL
358 * servers; it is also possible to do things like setting up two sets of VL
359 * servers, one of which provides a superset of the volumes provided by the
360 * other (for internal/external division, for example).
361 *
362 * Cells only exist in the sense that (a) a cell's name maps to a set of VL
363 * servers and (b) a cell's name is used by the client to select the key to use
364 * for authentication and encryption. The cell name is not typically used in
365 * the protocol.
366 *
367 * There is no easy way to determine if two cells are aliases or one is a
368 * subset of another.
369 */
370 struct afs_cell {
371 union {
372 struct rcu_head rcu;
373 struct rb_node net_node; /* Node in net->cells */
374 };
375 struct afs_net *net;
376 struct key *anonymous_key; /* anonymous user key for this cell */
377 struct work_struct manager; /* Manager for init/deinit/dns */
378 struct hlist_node proc_link; /* /proc cell list link */
379 #ifdef CONFIG_AFS_FSCACHE
380 struct fscache_cookie *cache; /* caching cookie */
381 #endif
382 time64_t dns_expiry; /* Time AFSDB/SRV record expires */
383 time64_t last_inactive; /* Time of last drop of usage count */
384 atomic_t usage;
385 unsigned long flags;
386 #define AFS_CELL_FL_NO_GC 0 /* The cell was added manually, don't auto-gc */
387 #define AFS_CELL_FL_DO_LOOKUP 1 /* DNS lookup requested */
388 enum afs_cell_state state;
389 short error;
390 enum dns_record_source dns_source:8; /* Latest source of data from lookup */
391 enum dns_lookup_status dns_status:8; /* Latest status of data from lookup */
392 unsigned int dns_lookup_count; /* Counter of DNS lookups */
393
394 /* Active fileserver interaction state. */
395 struct list_head proc_volumes; /* procfs volume list */
396 rwlock_t proc_lock;
397
398 /* VL server list. */
399 rwlock_t vl_servers_lock; /* Lock on vl_servers */
400 struct afs_vlserver_list __rcu *vl_servers;
401
402 u8 name_len; /* Length of name */
403 char name[64 + 1]; /* Cell name, case-flattened and NUL-padded */
404 };
405
406 /*
407 * Volume Location server record.
408 */
409 struct afs_vlserver {
410 struct rcu_head rcu;
411 struct afs_addr_list __rcu *addresses; /* List of addresses for this VL server */
412 unsigned long flags;
413 #define AFS_VLSERVER_FL_PROBED 0 /* The VL server has been probed */
414 #define AFS_VLSERVER_FL_PROBING 1 /* VL server is being probed */
415 #define AFS_VLSERVER_FL_IS_YFS 2 /* Server is YFS not AFS */
416 rwlock_t lock; /* Lock on addresses */
417 atomic_t usage;
418
419 /* Probe state */
420 wait_queue_head_t probe_wq;
421 atomic_t probe_outstanding;
422 spinlock_t probe_lock;
423 struct {
424 unsigned int rtt; /* RTT as ktime/64 */
425 u32 abort_code;
426 short error;
427 bool have_result;
428 bool responded:1;
429 bool is_yfs:1;
430 bool not_yfs:1;
431 bool local_failure:1;
432 } probe;
433
434 u16 port;
435 u16 name_len; /* Length of name */
436 char name[]; /* Server name, case-flattened */
437 };
438
439 /*
440 * Weighted list of Volume Location servers.
441 */
442 struct afs_vlserver_entry {
443 u16 priority; /* Preference (as SRV) */
444 u16 weight; /* Weight (as SRV) */
445 enum dns_record_source source:8;
446 enum dns_lookup_status status:8;
447 struct afs_vlserver *server;
448 };
449
450 struct afs_vlserver_list {
451 struct rcu_head rcu;
452 atomic_t usage;
453 u8 nr_servers;
454 u8 index; /* Server currently in use */
455 u8 preferred; /* Preferred server */
456 enum dns_record_source source:8;
457 enum dns_lookup_status status:8;
458 rwlock_t lock;
459 struct afs_vlserver_entry servers[];
460 };
461
462 /*
463 * Cached VLDB entry.
464 *
465 * This is pointed to by cell->vldb_entries, indexed by name.
466 */
467 struct afs_vldb_entry {
468 afs_volid_t vid[3]; /* Volume IDs for R/W, R/O and Bak volumes */
469
470 unsigned long flags;
471 #define AFS_VLDB_HAS_RW 0 /* - R/W volume exists */
472 #define AFS_VLDB_HAS_RO 1 /* - R/O volume exists */
473 #define AFS_VLDB_HAS_BAK 2 /* - Backup volume exists */
474 #define AFS_VLDB_QUERY_VALID 3 /* - Record is valid */
475 #define AFS_VLDB_QUERY_ERROR 4 /* - VL server returned error */
476
477 uuid_t fs_server[AFS_NMAXNSERVERS];
478 u8 fs_mask[AFS_NMAXNSERVERS];
479 #define AFS_VOL_VTM_RW 0x01 /* R/W version of the volume is available (on this server) */
480 #define AFS_VOL_VTM_RO 0x02 /* R/O version of the volume is available (on this server) */
481 #define AFS_VOL_VTM_BAK 0x04 /* backup version of the volume is available (on this server) */
482 short error;
483 u8 nr_servers; /* Number of server records */
484 u8 name_len;
485 u8 name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
486 };
487
488 /*
489 * Record of fileserver with which we're actively communicating.
490 */
491 struct afs_server {
492 struct rcu_head rcu;
493 union {
494 uuid_t uuid; /* Server ID */
495 struct afs_uuid _uuid;
496 };
497
498 struct afs_addr_list __rcu *addresses;
499 struct rb_node uuid_rb; /* Link in net->servers */
500 struct hlist_node addr4_link; /* Link in net->fs_addresses4 */
501 struct hlist_node addr6_link; /* Link in net->fs_addresses6 */
502 struct hlist_node proc_link; /* Link in net->fs_proc */
503 struct afs_server *gc_next; /* Next server in manager's list */
504 time64_t put_time; /* Time at which last put */
505 time64_t update_at; /* Time at which to next update the record */
506 unsigned long flags;
507 #define AFS_SERVER_FL_NOT_READY 1 /* The record is not ready for use */
508 #define AFS_SERVER_FL_NOT_FOUND 2 /* VL server says no such server */
509 #define AFS_SERVER_FL_VL_FAIL 3 /* Failed to access VL server */
510 #define AFS_SERVER_FL_UPDATING 4
511 #define AFS_SERVER_FL_PROBED 5 /* The fileserver has been probed */
512 #define AFS_SERVER_FL_PROBING 6 /* Fileserver is being probed */
513 #define AFS_SERVER_FL_NO_IBULK 7 /* Fileserver doesn't support FS.InlineBulkStatus */
514 #define AFS_SERVER_FL_MAY_HAVE_CB 8 /* May have callbacks on this fileserver */
515 #define AFS_SERVER_FL_IS_YFS 9 /* Server is YFS not AFS */
516 #define AFS_SERVER_FL_NO_RM2 10 /* Fileserver doesn't support YFS.RemoveFile2 */
517 #define AFS_SERVER_FL_HAVE_EPOCH 11 /* ->epoch is valid */
518 atomic_t usage;
519 u32 addr_version; /* Address list version */
520 u32 cm_epoch; /* Server RxRPC epoch */
521
522 /* file service access */
523 rwlock_t fs_lock; /* access lock */
524
525 /* callback promise management */
526 struct hlist_head cb_volumes; /* List of volume interests on this server */
527 unsigned cb_s_break; /* Break-everything counter. */
528 rwlock_t cb_break_lock; /* Volume finding lock */
529
530 /* Probe state */
531 wait_queue_head_t probe_wq;
532 atomic_t probe_outstanding;
533 spinlock_t probe_lock;
534 struct {
535 unsigned int rtt; /* RTT as ktime/64 */
536 u32 abort_code;
537 u32 cm_epoch;
538 short error;
539 bool have_result;
540 bool responded:1;
541 bool is_yfs:1;
542 bool not_yfs:1;
543 bool local_failure:1;
544 bool no_epoch:1;
545 bool cm_probed:1;
546 bool said_rebooted:1;
547 bool said_inconsistent:1;
548 } probe;
549 };
550
551 /*
552 * Volume collation in the server's callback interest list.
553 */
554 struct afs_vol_interest {
555 struct hlist_node srv_link; /* Link in server->cb_volumes */
556 struct hlist_head cb_interests; /* List of callback interests on the server */
557 afs_volid_t vid; /* Volume ID to match */
558 unsigned int usage;
559 };
560
561 /*
562 * Interest by a superblock on a server.
563 */
564 struct afs_cb_interest {
565 struct hlist_node cb_vlink; /* Link in vol_interest->cb_interests */
566 struct afs_vol_interest *vol_interest;
567 struct afs_server *server; /* Server on which this interest resides */
568 struct super_block *sb; /* Superblock on which inodes reside */
569 afs_volid_t vid; /* Volume ID to match */
570 refcount_t usage;
571 };
572
573 /*
574 * Replaceable server list.
575 */
576 struct afs_server_entry {
577 struct afs_server *server;
578 struct afs_cb_interest *cb_interest;
579 };
580
581 struct afs_server_list {
582 refcount_t usage;
583 unsigned char nr_servers;
584 unsigned char preferred; /* Preferred server */
585 unsigned short vnovol_mask; /* Servers to be skipped due to VNOVOL */
586 unsigned int seq; /* Set to ->servers_seq when installed */
587 rwlock_t lock;
588 struct afs_server_entry servers[];
589 };
590
591 /*
592 * Live AFS volume management.
593 */
594 struct afs_volume {
595 afs_volid_t vid; /* volume ID */
596 atomic_t usage;
597 time64_t update_at; /* Time at which to next update */
598 struct afs_cell *cell; /* Cell to which belongs (pins ref) */
599 struct list_head proc_link; /* Link in cell->vl_proc */
600 unsigned long flags;
601 #define AFS_VOLUME_NEEDS_UPDATE 0 /* - T if an update needs performing */
602 #define AFS_VOLUME_UPDATING 1 /* - T if an update is in progress */
603 #define AFS_VOLUME_WAIT 2 /* - T if users must wait for update */
604 #define AFS_VOLUME_DELETED 3 /* - T if volume appears deleted */
605 #define AFS_VOLUME_OFFLINE 4 /* - T if volume offline notice given */
606 #define AFS_VOLUME_BUSY 5 /* - T if volume busy notice given */
607 #ifdef CONFIG_AFS_FSCACHE
608 struct fscache_cookie *cache; /* caching cookie */
609 #endif
610 struct afs_server_list *servers; /* List of servers on which volume resides */
611 rwlock_t servers_lock; /* Lock for ->servers */
612 unsigned int servers_seq; /* Incremented each time ->servers changes */
613
614 unsigned cb_v_break; /* Break-everything counter. */
615 rwlock_t cb_break_lock;
616
617 afs_voltype_t type; /* type of volume */
618 short error;
619 char type_force; /* force volume type (suppress R/O -> R/W) */
620 u8 name_len;
621 u8 name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
622 };
623
624 enum afs_lock_state {
625 AFS_VNODE_LOCK_NONE, /* The vnode has no lock on the server */
626 AFS_VNODE_LOCK_WAITING_FOR_CB, /* We're waiting for the server to break the callback */
627 AFS_VNODE_LOCK_SETTING, /* We're asking the server for a lock */
628 AFS_VNODE_LOCK_GRANTED, /* We have a lock on the server */
629 AFS_VNODE_LOCK_EXTENDING, /* We're extending a lock on the server */
630 AFS_VNODE_LOCK_NEED_UNLOCK, /* We need to unlock on the server */
631 AFS_VNODE_LOCK_UNLOCKING, /* We're telling the server to unlock */
632 AFS_VNODE_LOCK_DELETED, /* The vnode has been deleted whilst we have a lock */
633 };
634
635 /*
636 * AFS inode private data.
637 *
638 * Note that afs_alloc_inode() *must* reset anything that could incorrectly
639 * leak from one inode to another.
640 */
641 struct afs_vnode {
642 struct inode vfs_inode; /* the VFS's inode record */
643
644 struct afs_volume *volume; /* volume on which vnode resides */
645 struct afs_fid fid; /* the file identifier for this inode */
646 struct afs_file_status status; /* AFS status info for this file */
647 afs_dataversion_t invalid_before; /* Child dentries are invalid before this */
648 #ifdef CONFIG_AFS_FSCACHE
649 struct fscache_cookie *cache; /* caching cookie */
650 #endif
651 struct afs_permits __rcu *permit_cache; /* cache of permits so far obtained */
652 struct mutex io_lock; /* Lock for serialising I/O on this mutex */
653 struct rw_semaphore validate_lock; /* lock for validating this vnode */
654 struct rw_semaphore rmdir_lock; /* Lock for rmdir vs sillyrename */
655 struct key *silly_key; /* Silly rename key */
656 spinlock_t wb_lock; /* lock for wb_keys */
657 spinlock_t lock; /* waitqueue/flags lock */
658 unsigned long flags;
659 #define AFS_VNODE_CB_PROMISED 0 /* Set if vnode has a callback promise */
660 #define AFS_VNODE_UNSET 1 /* set if vnode attributes not yet set */
661 #define AFS_VNODE_DIR_VALID 2 /* Set if dir contents are valid */
662 #define AFS_VNODE_ZAP_DATA 3 /* set if vnode's data should be invalidated */
663 #define AFS_VNODE_DELETED 4 /* set if vnode deleted on server */
664 #define AFS_VNODE_MOUNTPOINT 5 /* set if vnode is a mountpoint symlink */
665 #define AFS_VNODE_AUTOCELL 6 /* set if Vnode is an auto mount point */
666 #define AFS_VNODE_PSEUDODIR 7 /* set if Vnode is a pseudo directory */
667 #define AFS_VNODE_NEW_CONTENT 8 /* Set if file has new content (create/trunc-0) */
668
669 struct list_head wb_keys; /* List of keys available for writeback */
670 struct list_head pending_locks; /* locks waiting to be granted */
671 struct list_head granted_locks; /* locks granted on this file */
672 struct delayed_work lock_work; /* work to be done in locking */
673 struct key *lock_key; /* Key to be used in lock ops */
674 ktime_t locked_at; /* Time at which lock obtained */
675 enum afs_lock_state lock_state : 8;
676 afs_lock_type_t lock_type : 8;
677
678 /* outstanding callback notification on this file */
679 struct afs_cb_interest *cb_interest; /* Server on which this resides */
680 unsigned int cb_s_break; /* Mass break counter on ->server */
681 unsigned int cb_v_break; /* Mass break counter on ->volume */
682 unsigned int cb_break; /* Break counter on vnode */
683 seqlock_t cb_lock; /* Lock for ->cb_interest, ->status, ->cb_*break */
684
685 time64_t cb_expires_at; /* time at which callback expires */
686 unsigned cb_version; /* callback version */
687 afs_callback_type_t cb_type; /* type of callback */
688 };
689
690 static inline struct fscache_cookie *afs_vnode_cache(struct afs_vnode *vnode)
691 {
692 #ifdef CONFIG_AFS_FSCACHE
693 return vnode->cache;
694 #else
695 return NULL;
696 #endif
697 }
698
699 /*
700 * cached security record for one user's attempt to access a vnode
701 */
702 struct afs_permit {
703 struct key *key; /* RxRPC ticket holding a security context */
704 afs_access_t access; /* CallerAccess value for this key */
705 };
706
707 /*
708 * Immutable cache of CallerAccess records from attempts to access vnodes.
709 * These may be shared between multiple vnodes.
710 */
711 struct afs_permits {
712 struct rcu_head rcu;
713 struct hlist_node hash_node; /* Link in hash */
714 unsigned long h; /* Hash value for this permit list */
715 refcount_t usage;
716 unsigned short nr_permits; /* Number of records */
717 bool invalidated; /* Invalidated due to key change */
718 struct afs_permit permits[]; /* List of permits sorted by key pointer */
719 };
720
721 /*
722 * record of one of a system's set of network interfaces
723 */
724 struct afs_interface {
725 struct in_addr address; /* IPv4 address bound to interface */
726 struct in_addr netmask; /* netmask applied to address */
727 unsigned mtu; /* MTU of interface */
728 };
729
730 /*
731 * Error prioritisation and accumulation.
732 */
733 struct afs_error {
734 short error; /* Accumulated error */
735 bool responded; /* T if server responded */
736 };
737
738 /*
739 * Cursor for iterating over a server's address list.
740 */
741 struct afs_addr_cursor {
742 struct afs_addr_list *alist; /* Current address list (pins ref) */
743 unsigned long tried; /* Tried addresses */
744 signed char index; /* Current address */
745 bool responded; /* T if the current address responded */
746 unsigned short nr_iterations; /* Number of address iterations */
747 short error;
748 u32 abort_code;
749 };
750
751 /*
752 * Cursor for iterating over a set of volume location servers.
753 */
754 struct afs_vl_cursor {
755 struct afs_addr_cursor ac;
756 struct afs_cell *cell; /* The cell we're querying */
757 struct afs_vlserver_list *server_list; /* Current server list (pins ref) */
758 struct afs_vlserver *server; /* Server on which this resides */
759 struct key *key; /* Key for the server */
760 unsigned long untried; /* Bitmask of untried servers */
761 short index; /* Current server */
762 short error;
763 unsigned short flags;
764 #define AFS_VL_CURSOR_STOP 0x0001 /* Set to cease iteration */
765 #define AFS_VL_CURSOR_RETRY 0x0002 /* Set to do a retry */
766 #define AFS_VL_CURSOR_RETRIED 0x0004 /* Set if started a retry */
767 unsigned short nr_iterations; /* Number of server iterations */
768 };
769
770 /*
771 * Cursor for iterating over a set of fileservers.
772 */
773 struct afs_fs_cursor {
774 const struct afs_call_type *type; /* Type of call done */
775 struct afs_addr_cursor ac;
776 struct afs_vnode *vnode;
777 struct afs_server_list *server_list; /* Current server list (pins ref) */
778 struct afs_cb_interest *cbi; /* Server on which this resides (pins ref) */
779 struct key *key; /* Key for the server */
780 unsigned long untried; /* Bitmask of untried servers */
781 unsigned int cb_break; /* cb_break + cb_s_break before the call */
782 unsigned int cb_break_2; /* cb_break + cb_s_break (2nd vnode) */
783 short index; /* Current server */
784 short error;
785 unsigned short flags;
786 #define AFS_FS_CURSOR_STOP 0x0001 /* Set to cease iteration */
787 #define AFS_FS_CURSOR_VBUSY 0x0002 /* Set if seen VBUSY */
788 #define AFS_FS_CURSOR_VMOVED 0x0004 /* Set if seen VMOVED */
789 #define AFS_FS_CURSOR_VNOVOL 0x0008 /* Set if seen VNOVOL */
790 #define AFS_FS_CURSOR_CUR_ONLY 0x0010 /* Set if current server only (file lock held) */
791 #define AFS_FS_CURSOR_NO_VSLEEP 0x0020 /* Set to prevent sleep on VBUSY, VOFFLINE, ... */
792 #define AFS_FS_CURSOR_INTR 0x0040 /* Set if op is interruptible */
793 unsigned short nr_iterations; /* Number of server iterations */
794 };
795
796 /*
797 * Cache auxiliary data.
798 */
799 struct afs_vnode_cache_aux {
800 u64 data_version;
801 } __packed;
802
803 #include <trace/events/afs.h>
804
805 /*****************************************************************************/
806 /*
807 * addr_list.c
808 */
809 static inline struct afs_addr_list *afs_get_addrlist(struct afs_addr_list *alist)
810 {
811 if (alist)
812 refcount_inc(&alist->usage);
813 return alist;
814 }
815 extern struct afs_addr_list *afs_alloc_addrlist(unsigned int,
816 unsigned short,
817 unsigned short);
818 extern void afs_put_addrlist(struct afs_addr_list *);
819 extern struct afs_vlserver_list *afs_parse_text_addrs(struct afs_net *,
820 const char *, size_t, char,
821 unsigned short, unsigned short);
822 extern struct afs_vlserver_list *afs_dns_query(struct afs_cell *, time64_t *);
823 extern bool afs_iterate_addresses(struct afs_addr_cursor *);
824 extern int afs_end_cursor(struct afs_addr_cursor *);
825
826 extern void afs_merge_fs_addr4(struct afs_addr_list *, __be32, u16);
827 extern void afs_merge_fs_addr6(struct afs_addr_list *, __be32 *, u16);
828
829 /*
830 * cache.c
831 */
832 #ifdef CONFIG_AFS_FSCACHE
833 extern struct fscache_netfs afs_cache_netfs;
834 extern struct fscache_cookie_def afs_cell_cache_index_def;
835 extern struct fscache_cookie_def afs_volume_cache_index_def;
836 extern struct fscache_cookie_def afs_vnode_cache_index_def;
837 #else
838 #define afs_cell_cache_index_def (*(struct fscache_cookie_def *) NULL)
839 #define afs_volume_cache_index_def (*(struct fscache_cookie_def *) NULL)
840 #define afs_vnode_cache_index_def (*(struct fscache_cookie_def *) NULL)
841 #endif
842
843 /*
844 * callback.c
845 */
846 extern void afs_init_callback_state(struct afs_server *);
847 extern void __afs_break_callback(struct afs_vnode *);
848 extern void afs_break_callback(struct afs_vnode *);
849 extern void afs_break_callbacks(struct afs_server *, size_t, struct afs_callback_break*);
850
851 extern int afs_register_server_cb_interest(struct afs_vnode *,
852 struct afs_server_list *, unsigned int);
853 extern void afs_put_cb_interest(struct afs_net *, struct afs_cb_interest *);
854 extern void afs_clear_callback_interests(struct afs_net *, struct afs_server_list *);
855
856 static inline struct afs_cb_interest *afs_get_cb_interest(struct afs_cb_interest *cbi)
857 {
858 if (cbi)
859 refcount_inc(&cbi->usage);
860 return cbi;
861 }
862
863 static inline unsigned int afs_calc_vnode_cb_break(struct afs_vnode *vnode)
864 {
865 return vnode->cb_break + vnode->cb_v_break;
866 }
867
868 static inline bool afs_cb_is_broken(unsigned int cb_break,
869 const struct afs_vnode *vnode,
870 const struct afs_cb_interest *cbi)
871 {
872 return !cbi || cb_break != (vnode->cb_break +
873 vnode->volume->cb_v_break);
874 }
875
876 /*
877 * cell.c
878 */
879 extern int afs_cell_init(struct afs_net *, const char *);
880 extern struct afs_cell *afs_lookup_cell_rcu(struct afs_net *, const char *, unsigned);
881 extern struct afs_cell *afs_lookup_cell(struct afs_net *, const char *, unsigned,
882 const char *, bool);
883 extern struct afs_cell *afs_get_cell(struct afs_cell *);
884 extern void afs_put_cell(struct afs_net *, struct afs_cell *);
885 extern void afs_manage_cells(struct work_struct *);
886 extern void afs_cells_timer(struct timer_list *);
887 extern void __net_exit afs_cell_purge(struct afs_net *);
888
889 /*
890 * cmservice.c
891 */
892 extern bool afs_cm_incoming_call(struct afs_call *);
893
894 /*
895 * dir.c
896 */
897 extern const struct file_operations afs_dir_file_operations;
898 extern const struct inode_operations afs_dir_inode_operations;
899 extern const struct address_space_operations afs_dir_aops;
900 extern const struct dentry_operations afs_fs_dentry_operations;
901
902 extern void afs_d_release(struct dentry *);
903 extern int afs_dir_remove_link(struct dentry *, struct key *, unsigned long, unsigned long);
904
905 /*
906 * dir_edit.c
907 */
908 extern void afs_edit_dir_add(struct afs_vnode *, struct qstr *, struct afs_fid *,
909 enum afs_edit_dir_reason);
910 extern void afs_edit_dir_remove(struct afs_vnode *, struct qstr *, enum afs_edit_dir_reason);
911
912 /*
913 * dir_silly.c
914 */
915 extern int afs_sillyrename(struct afs_vnode *, struct afs_vnode *,
916 struct dentry *, struct key *);
917 extern int afs_silly_iput(struct dentry *, struct inode *);
918
919 /*
920 * dynroot.c
921 */
922 extern const struct file_operations afs_dynroot_file_operations;
923 extern const struct inode_operations afs_dynroot_inode_operations;
924 extern const struct dentry_operations afs_dynroot_dentry_operations;
925
926 extern struct inode *afs_try_auto_mntpt(struct dentry *, struct inode *);
927 extern int afs_dynroot_mkdir(struct afs_net *, struct afs_cell *);
928 extern void afs_dynroot_rmdir(struct afs_net *, struct afs_cell *);
929 extern int afs_dynroot_populate(struct super_block *);
930 extern void afs_dynroot_depopulate(struct super_block *);
931
932 /*
933 * file.c
934 */
935 extern const struct address_space_operations afs_fs_aops;
936 extern const struct inode_operations afs_file_inode_operations;
937 extern const struct file_operations afs_file_operations;
938
939 extern int afs_cache_wb_key(struct afs_vnode *, struct afs_file *);
940 extern void afs_put_wb_key(struct afs_wb_key *);
941 extern int afs_open(struct inode *, struct file *);
942 extern int afs_release(struct inode *, struct file *);
943 extern int afs_fetch_data(struct afs_vnode *, struct key *, struct afs_read *);
944 extern int afs_page_filler(void *, struct page *);
945 extern void afs_put_read(struct afs_read *);
946
947 /*
948 * flock.c
949 */
950 extern struct workqueue_struct *afs_lock_manager;
951
952 extern void afs_lock_op_done(struct afs_call *);
953 extern void afs_lock_work(struct work_struct *);
954 extern void afs_lock_may_be_available(struct afs_vnode *);
955 extern int afs_lock(struct file *, int, struct file_lock *);
956 extern int afs_flock(struct file *, int, struct file_lock *);
957
958 /*
959 * fsclient.c
960 */
961 extern int afs_fs_fetch_file_status(struct afs_fs_cursor *, struct afs_status_cb *,
962 struct afs_volsync *);
963 extern int afs_fs_give_up_callbacks(struct afs_net *, struct afs_server *);
964 extern int afs_fs_fetch_data(struct afs_fs_cursor *, struct afs_status_cb *, struct afs_read *);
965 extern int afs_fs_create(struct afs_fs_cursor *, const char *, umode_t,
966 struct afs_status_cb *, struct afs_fid *, struct afs_status_cb *);
967 extern int afs_fs_remove(struct afs_fs_cursor *, struct afs_vnode *, const char *, bool,
968 struct afs_status_cb *);
969 extern int afs_fs_link(struct afs_fs_cursor *, struct afs_vnode *, const char *,
970 struct afs_status_cb *, struct afs_status_cb *);
971 extern int afs_fs_symlink(struct afs_fs_cursor *, const char *, const char *,
972 struct afs_status_cb *, struct afs_fid *, struct afs_status_cb *);
973 extern int afs_fs_rename(struct afs_fs_cursor *, const char *,
974 struct afs_vnode *, const char *,
975 struct afs_status_cb *, struct afs_status_cb *);
976 extern int afs_fs_store_data(struct afs_fs_cursor *, struct address_space *,
977 pgoff_t, pgoff_t, unsigned, unsigned, struct afs_status_cb *);
978 extern int afs_fs_setattr(struct afs_fs_cursor *, struct iattr *, struct afs_status_cb *);
979 extern int afs_fs_get_volume_status(struct afs_fs_cursor *, struct afs_volume_status *);
980 extern int afs_fs_set_lock(struct afs_fs_cursor *, afs_lock_type_t, struct afs_status_cb *);
981 extern int afs_fs_extend_lock(struct afs_fs_cursor *, struct afs_status_cb *);
982 extern int afs_fs_release_lock(struct afs_fs_cursor *, struct afs_status_cb *);
983 extern int afs_fs_give_up_all_callbacks(struct afs_net *, struct afs_server *,
984 struct afs_addr_cursor *, struct key *);
985 extern struct afs_call *afs_fs_get_capabilities(struct afs_net *, struct afs_server *,
986 struct afs_addr_cursor *, struct key *,
987 unsigned int);
988 extern int afs_fs_inline_bulk_status(struct afs_fs_cursor *, struct afs_net *,
989 struct afs_fid *, struct afs_status_cb *,
990 unsigned int, struct afs_volsync *);
991 extern int afs_fs_fetch_status(struct afs_fs_cursor *, struct afs_net *,
992 struct afs_fid *, struct afs_status_cb *,
993 struct afs_volsync *);
994
995 struct afs_acl {
996 u32 size;
997 u8 data[];
998 };
999
1000 extern struct afs_acl *afs_fs_fetch_acl(struct afs_fs_cursor *, struct afs_status_cb *);
1001 extern int afs_fs_store_acl(struct afs_fs_cursor *, const struct afs_acl *,
1002 struct afs_status_cb *);
1003
1004 /*
1005 * fs_probe.c
1006 */
1007 extern void afs_fileserver_probe_result(struct afs_call *);
1008 extern int afs_probe_fileservers(struct afs_net *, struct key *, struct afs_server_list *);
1009 extern int afs_wait_for_fs_probes(struct afs_server_list *, unsigned long);
1010
1011 /*
1012 * inode.c
1013 */
1014 extern void afs_vnode_commit_status(struct afs_fs_cursor *,
1015 struct afs_vnode *,
1016 unsigned int,
1017 const afs_dataversion_t *,
1018 struct afs_status_cb *);
1019 extern int afs_fetch_status(struct afs_vnode *, struct key *, bool, afs_access_t *);
1020 extern int afs_iget5_test(struct inode *, void *);
1021 extern struct inode *afs_iget_pseudo_dir(struct super_block *, bool);
1022 extern struct inode *afs_iget(struct super_block *, struct key *,
1023 struct afs_fid *, struct afs_status_cb *,
1024 struct afs_cb_interest *,
1025 struct afs_vnode *);
1026 extern void afs_zap_data(struct afs_vnode *);
1027 extern int afs_validate(struct afs_vnode *, struct key *);
1028 extern int afs_getattr(const struct path *, struct kstat *, u32, unsigned int);
1029 extern int afs_setattr(struct dentry *, struct iattr *);
1030 extern void afs_evict_inode(struct inode *);
1031 extern int afs_drop_inode(struct inode *);
1032
1033 /*
1034 * main.c
1035 */
1036 extern struct workqueue_struct *afs_wq;
1037 extern int afs_net_id;
1038
1039 static inline struct afs_net *afs_net(struct net *net)
1040 {
1041 return net_generic(net, afs_net_id);
1042 }
1043
1044 static inline struct afs_net *afs_sb2net(struct super_block *sb)
1045 {
1046 return afs_net(AFS_FS_S(sb)->net_ns);
1047 }
1048
1049 static inline struct afs_net *afs_d2net(struct dentry *dentry)
1050 {
1051 return afs_sb2net(dentry->d_sb);
1052 }
1053
1054 static inline struct afs_net *afs_i2net(struct inode *inode)
1055 {
1056 return afs_sb2net(inode->i_sb);
1057 }
1058
1059 static inline struct afs_net *afs_v2net(struct afs_vnode *vnode)
1060 {
1061 return afs_i2net(&vnode->vfs_inode);
1062 }
1063
1064 static inline struct afs_net *afs_sock2net(struct sock *sk)
1065 {
1066 return net_generic(sock_net(sk), afs_net_id);
1067 }
1068
1069 static inline void __afs_stat(atomic_t *s)
1070 {
1071 atomic_inc(s);
1072 }
1073
1074 #define afs_stat_v(vnode, n) __afs_stat(&afs_v2net(vnode)->n)
1075
1076 /*
1077 * misc.c
1078 */
1079 extern int afs_abort_to_error(u32);
1080 extern void afs_prioritise_error(struct afs_error *, int, u32);
1081
1082 /*
1083 * mntpt.c
1084 */
1085 extern const struct inode_operations afs_mntpt_inode_operations;
1086 extern const struct inode_operations afs_autocell_inode_operations;
1087 extern const struct file_operations afs_mntpt_file_operations;
1088
1089 extern struct vfsmount *afs_d_automount(struct path *);
1090 extern void afs_mntpt_kill_timer(void);
1091
1092 /*
1093 * netdevices.c
1094 */
1095 extern int afs_get_ipv4_interfaces(struct afs_net *, struct afs_interface *,
1096 size_t, bool);
1097
1098 /*
1099 * proc.c
1100 */
1101 #ifdef CONFIG_PROC_FS
1102 extern int __net_init afs_proc_init(struct afs_net *);
1103 extern void __net_exit afs_proc_cleanup(struct afs_net *);
1104 extern int afs_proc_cell_setup(struct afs_cell *);
1105 extern void afs_proc_cell_remove(struct afs_cell *);
1106 extern void afs_put_sysnames(struct afs_sysnames *);
1107 #else
1108 static inline int afs_proc_init(struct afs_net *net) { return 0; }
1109 static inline void afs_proc_cleanup(struct afs_net *net) {}
1110 static inline int afs_proc_cell_setup(struct afs_cell *cell) { return 0; }
1111 static inline void afs_proc_cell_remove(struct afs_cell *cell) {}
1112 static inline void afs_put_sysnames(struct afs_sysnames *sysnames) {}
1113 #endif
1114
1115 /*
1116 * rotate.c
1117 */
1118 extern bool afs_begin_vnode_operation(struct afs_fs_cursor *, struct afs_vnode *,
1119 struct key *, bool);
1120 extern bool afs_select_fileserver(struct afs_fs_cursor *);
1121 extern bool afs_select_current_fileserver(struct afs_fs_cursor *);
1122 extern int afs_end_vnode_operation(struct afs_fs_cursor *);
1123
1124 /*
1125 * rxrpc.c
1126 */
1127 extern struct workqueue_struct *afs_async_calls;
1128
1129 extern int __net_init afs_open_socket(struct afs_net *);
1130 extern void __net_exit afs_close_socket(struct afs_net *);
1131 extern void afs_charge_preallocation(struct work_struct *);
1132 extern void afs_put_call(struct afs_call *);
1133 extern void afs_make_call(struct afs_addr_cursor *, struct afs_call *, gfp_t);
1134 extern long afs_wait_for_call_to_complete(struct afs_call *, struct afs_addr_cursor *);
1135 extern struct afs_call *afs_alloc_flat_call(struct afs_net *,
1136 const struct afs_call_type *,
1137 size_t, size_t);
1138 extern void afs_flat_call_destructor(struct afs_call *);
1139 extern void afs_send_empty_reply(struct afs_call *);
1140 extern void afs_send_simple_reply(struct afs_call *, const void *, size_t);
1141 extern int afs_extract_data(struct afs_call *, bool);
1142 extern int afs_protocol_error(struct afs_call *, int, enum afs_eproto_cause);
1143
1144 static inline void afs_set_fc_call(struct afs_call *call, struct afs_fs_cursor *fc)
1145 {
1146 call->intr = fc->flags & AFS_FS_CURSOR_INTR;
1147 fc->type = call->type;
1148 }
1149
1150 static inline void afs_extract_begin(struct afs_call *call, void *buf, size_t size)
1151 {
1152 call->kvec[0].iov_base = buf;
1153 call->kvec[0].iov_len = size;
1154 iov_iter_kvec(&call->iter, READ, call->kvec, 1, size);
1155 }
1156
1157 static inline void afs_extract_to_tmp(struct afs_call *call)
1158 {
1159 afs_extract_begin(call, &call->tmp, sizeof(call->tmp));
1160 }
1161
1162 static inline void afs_extract_to_tmp64(struct afs_call *call)
1163 {
1164 afs_extract_begin(call, &call->tmp64, sizeof(call->tmp64));
1165 }
1166
1167 static inline void afs_extract_discard(struct afs_call *call, size_t size)
1168 {
1169 iov_iter_discard(&call->iter, READ, size);
1170 }
1171
1172 static inline void afs_extract_to_buf(struct afs_call *call, size_t size)
1173 {
1174 afs_extract_begin(call, call->buffer, size);
1175 }
1176
1177 static inline int afs_transfer_reply(struct afs_call *call)
1178 {
1179 return afs_extract_data(call, false);
1180 }
1181
1182 static inline bool afs_check_call_state(struct afs_call *call,
1183 enum afs_call_state state)
1184 {
1185 return READ_ONCE(call->state) == state;
1186 }
1187
1188 static inline bool afs_set_call_state(struct afs_call *call,
1189 enum afs_call_state from,
1190 enum afs_call_state to)
1191 {
1192 bool ok = false;
1193
1194 spin_lock_bh(&call->state_lock);
1195 if (call->state == from) {
1196 call->state = to;
1197 trace_afs_call_state(call, from, to, 0, 0);
1198 ok = true;
1199 }
1200 spin_unlock_bh(&call->state_lock);
1201 return ok;
1202 }
1203
1204 static inline void afs_set_call_complete(struct afs_call *call,
1205 int error, u32 remote_abort)
1206 {
1207 enum afs_call_state state;
1208 bool ok = false;
1209
1210 spin_lock_bh(&call->state_lock);
1211 state = call->state;
1212 if (state != AFS_CALL_COMPLETE) {
1213 call->abort_code = remote_abort;
1214 call->error = error;
1215 call->state = AFS_CALL_COMPLETE;
1216 trace_afs_call_state(call, state, AFS_CALL_COMPLETE,
1217 error, remote_abort);
1218 ok = true;
1219 }
1220 spin_unlock_bh(&call->state_lock);
1221 if (ok)
1222 trace_afs_call_done(call);
1223 }
1224
1225 /*
1226 * security.c
1227 */
1228 extern void afs_put_permits(struct afs_permits *);
1229 extern void afs_clear_permits(struct afs_vnode *);
1230 extern void afs_cache_permit(struct afs_vnode *, struct key *, unsigned int,
1231 struct afs_status_cb *);
1232 extern void afs_zap_permits(struct rcu_head *);
1233 extern struct key *afs_request_key(struct afs_cell *);
1234 extern int afs_check_permit(struct afs_vnode *, struct key *, afs_access_t *);
1235 extern int afs_permission(struct inode *, int);
1236 extern void __exit afs_clean_up_permit_cache(void);
1237
1238 /*
1239 * server.c
1240 */
1241 extern spinlock_t afs_server_peer_lock;
1242
1243 static inline struct afs_server *afs_get_server(struct afs_server *server)
1244 {
1245 atomic_inc(&server->usage);
1246 return server;
1247 }
1248
1249 extern struct afs_server *afs_find_server(struct afs_net *,
1250 const struct sockaddr_rxrpc *);
1251 extern struct afs_server *afs_find_server_by_uuid(struct afs_net *, const uuid_t *);
1252 extern struct afs_server *afs_lookup_server(struct afs_cell *, struct key *, const uuid_t *);
1253 extern void afs_put_server(struct afs_net *, struct afs_server *);
1254 extern void afs_manage_servers(struct work_struct *);
1255 extern void afs_servers_timer(struct timer_list *);
1256 extern void __net_exit afs_purge_servers(struct afs_net *);
1257 extern bool afs_check_server_record(struct afs_fs_cursor *, struct afs_server *);
1258
1259 /*
1260 * server_list.c
1261 */
1262 static inline struct afs_server_list *afs_get_serverlist(struct afs_server_list *slist)
1263 {
1264 refcount_inc(&slist->usage);
1265 return slist;
1266 }
1267
1268 extern void afs_put_serverlist(struct afs_net *, struct afs_server_list *);
1269 extern struct afs_server_list *afs_alloc_server_list(struct afs_cell *, struct key *,
1270 struct afs_vldb_entry *,
1271 u8);
1272 extern bool afs_annotate_server_list(struct afs_server_list *, struct afs_server_list *);
1273
1274 /*
1275 * super.c
1276 */
1277 extern int __init afs_fs_init(void);
1278 extern void afs_fs_exit(void);
1279
1280 /*
1281 * vlclient.c
1282 */
1283 extern struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *,
1284 const char *, int);
1285 extern struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *, const uuid_t *);
1286 extern struct afs_call *afs_vl_get_capabilities(struct afs_net *, struct afs_addr_cursor *,
1287 struct key *, struct afs_vlserver *, unsigned int);
1288 extern struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *, const uuid_t *);
1289
1290 /*
1291 * vl_probe.c
1292 */
1293 extern void afs_vlserver_probe_result(struct afs_call *);
1294 extern int afs_send_vl_probes(struct afs_net *, struct key *, struct afs_vlserver_list *);
1295 extern int afs_wait_for_vl_probes(struct afs_vlserver_list *, unsigned long);
1296
1297 /*
1298 * vl_rotate.c
1299 */
1300 extern bool afs_begin_vlserver_operation(struct afs_vl_cursor *,
1301 struct afs_cell *, struct key *);
1302 extern bool afs_select_vlserver(struct afs_vl_cursor *);
1303 extern bool afs_select_current_vlserver(struct afs_vl_cursor *);
1304 extern int afs_end_vlserver_operation(struct afs_vl_cursor *);
1305
1306 /*
1307 * vlserver_list.c
1308 */
1309 static inline struct afs_vlserver *afs_get_vlserver(struct afs_vlserver *vlserver)
1310 {
1311 atomic_inc(&vlserver->usage);
1312 return vlserver;
1313 }
1314
1315 static inline struct afs_vlserver_list *afs_get_vlserverlist(struct afs_vlserver_list *vllist)
1316 {
1317 if (vllist)
1318 atomic_inc(&vllist->usage);
1319 return vllist;
1320 }
1321
1322 extern struct afs_vlserver *afs_alloc_vlserver(const char *, size_t, unsigned short);
1323 extern void afs_put_vlserver(struct afs_net *, struct afs_vlserver *);
1324 extern struct afs_vlserver_list *afs_alloc_vlserver_list(unsigned int);
1325 extern void afs_put_vlserverlist(struct afs_net *, struct afs_vlserver_list *);
1326 extern struct afs_vlserver_list *afs_extract_vlserver_list(struct afs_cell *,
1327 const void *, size_t);
1328
1329 /*
1330 * volume.c
1331 */
1332 static inline struct afs_volume *__afs_get_volume(struct afs_volume *volume)
1333 {
1334 if (volume)
1335 atomic_inc(&volume->usage);
1336 return volume;
1337 }
1338
1339 extern struct afs_volume *afs_create_volume(struct afs_fs_context *);
1340 extern void afs_activate_volume(struct afs_volume *);
1341 extern void afs_deactivate_volume(struct afs_volume *);
1342 extern void afs_put_volume(struct afs_cell *, struct afs_volume *);
1343 extern int afs_check_volume_status(struct afs_volume *, struct key *);
1344
1345 /*
1346 * write.c
1347 */
1348 extern int afs_set_page_dirty(struct page *);
1349 extern int afs_write_begin(struct file *file, struct address_space *mapping,
1350 loff_t pos, unsigned len, unsigned flags,
1351 struct page **pagep, void **fsdata);
1352 extern int afs_write_end(struct file *file, struct address_space *mapping,
1353 loff_t pos, unsigned len, unsigned copied,
1354 struct page *page, void *fsdata);
1355 extern int afs_writepage(struct page *, struct writeback_control *);
1356 extern int afs_writepages(struct address_space *, struct writeback_control *);
1357 extern ssize_t afs_file_write(struct kiocb *, struct iov_iter *);
1358 extern int afs_fsync(struct file *, loff_t, loff_t, int);
1359 extern vm_fault_t afs_page_mkwrite(struct vm_fault *vmf);
1360 extern void afs_prune_wb_keys(struct afs_vnode *);
1361 extern int afs_launder_page(struct page *);
1362
1363 /*
1364 * xattr.c
1365 */
1366 extern const struct xattr_handler *afs_xattr_handlers[];
1367 extern ssize_t afs_listxattr(struct dentry *, char *, size_t);
1368
1369 /*
1370 * yfsclient.c
1371 */
1372 extern int yfs_fs_fetch_file_status(struct afs_fs_cursor *, struct afs_status_cb *,
1373 struct afs_volsync *);
1374 extern int yfs_fs_fetch_data(struct afs_fs_cursor *, struct afs_status_cb *, struct afs_read *);
1375 extern int yfs_fs_create_file(struct afs_fs_cursor *, const char *, umode_t, struct afs_status_cb *,
1376 struct afs_fid *, struct afs_status_cb *);
1377 extern int yfs_fs_make_dir(struct afs_fs_cursor *, const char *, umode_t, struct afs_status_cb *,
1378 struct afs_fid *, struct afs_status_cb *);
1379 extern int yfs_fs_remove_file2(struct afs_fs_cursor *, struct afs_vnode *, const char *,
1380 struct afs_status_cb *, struct afs_status_cb *);
1381 extern int yfs_fs_remove(struct afs_fs_cursor *, struct afs_vnode *, const char *, bool,
1382 struct afs_status_cb *);
1383 extern int yfs_fs_link(struct afs_fs_cursor *, struct afs_vnode *, const char *,
1384 struct afs_status_cb *, struct afs_status_cb *);
1385 extern int yfs_fs_symlink(struct afs_fs_cursor *, const char *, const char *,
1386 struct afs_status_cb *, struct afs_fid *, struct afs_status_cb *);
1387 extern int yfs_fs_rename(struct afs_fs_cursor *, const char *, struct afs_vnode *, const char *,
1388 struct afs_status_cb *, struct afs_status_cb *);
1389 extern int yfs_fs_store_data(struct afs_fs_cursor *, struct address_space *,
1390 pgoff_t, pgoff_t, unsigned, unsigned, struct afs_status_cb *);
1391 extern int yfs_fs_setattr(struct afs_fs_cursor *, struct iattr *, struct afs_status_cb *);
1392 extern int yfs_fs_get_volume_status(struct afs_fs_cursor *, struct afs_volume_status *);
1393 extern int yfs_fs_set_lock(struct afs_fs_cursor *, afs_lock_type_t, struct afs_status_cb *);
1394 extern int yfs_fs_extend_lock(struct afs_fs_cursor *, struct afs_status_cb *);
1395 extern int yfs_fs_release_lock(struct afs_fs_cursor *, struct afs_status_cb *);
1396 extern int yfs_fs_fetch_status(struct afs_fs_cursor *, struct afs_net *,
1397 struct afs_fid *, struct afs_status_cb *,
1398 struct afs_volsync *);
1399 extern int yfs_fs_inline_bulk_status(struct afs_fs_cursor *, struct afs_net *,
1400 struct afs_fid *, struct afs_status_cb *,
1401 unsigned int, struct afs_volsync *);
1402
1403 struct yfs_acl {
1404 struct afs_acl *acl; /* Dir/file/symlink ACL */
1405 struct afs_acl *vol_acl; /* Whole volume ACL */
1406 u32 inherit_flag; /* True if ACL is inherited from parent dir */
1407 u32 num_cleaned; /* Number of ACEs removed due to subject removal */
1408 unsigned int flags;
1409 #define YFS_ACL_WANT_ACL 0x01 /* Set if caller wants ->acl */
1410 #define YFS_ACL_WANT_VOL_ACL 0x02 /* Set if caller wants ->vol_acl */
1411 };
1412
1413 extern void yfs_free_opaque_acl(struct yfs_acl *);
1414 extern struct yfs_acl *yfs_fs_fetch_opaque_acl(struct afs_fs_cursor *, struct yfs_acl *,
1415 struct afs_status_cb *);
1416 extern int yfs_fs_store_opaque_acl2(struct afs_fs_cursor *, const struct afs_acl *,
1417 struct afs_status_cb *);
1418
1419 /*
1420 * Miscellaneous inline functions.
1421 */
1422 static inline struct afs_vnode *AFS_FS_I(struct inode *inode)
1423 {
1424 return container_of(inode, struct afs_vnode, vfs_inode);
1425 }
1426
1427 static inline struct inode *AFS_VNODE_TO_I(struct afs_vnode *vnode)
1428 {
1429 return &vnode->vfs_inode;
1430 }
1431
1432 static inline void afs_check_for_remote_deletion(struct afs_fs_cursor *fc,
1433 struct afs_vnode *vnode)
1434 {
1435 if (fc->ac.error == -ENOENT) {
1436 set_bit(AFS_VNODE_DELETED, &vnode->flags);
1437 afs_break_callback(vnode);
1438 }
1439 }
1440
1441 static inline int afs_io_error(struct afs_call *call, enum afs_io_error where)
1442 {
1443 trace_afs_io_error(call->debug_id, -EIO, where);
1444 return -EIO;
1445 }
1446
1447 static inline int afs_bad(struct afs_vnode *vnode, enum afs_file_error where)
1448 {
1449 trace_afs_file_error(vnode, -EIO, where);
1450 return -EIO;
1451 }
1452
1453 /*****************************************************************************/
1454 /*
1455 * debug tracing
1456 */
1457 extern unsigned afs_debug;
1458
1459 #define dbgprintk(FMT,...) \
1460 printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
1461
1462 #define kenter(FMT,...) dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1463 #define kleave(FMT,...) dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1464 #define kdebug(FMT,...) dbgprintk(" "FMT ,##__VA_ARGS__)
1465
1466
1467 #if defined(__KDEBUG)
1468 #define _enter(FMT,...) kenter(FMT,##__VA_ARGS__)
1469 #define _leave(FMT,...) kleave(FMT,##__VA_ARGS__)
1470 #define _debug(FMT,...) kdebug(FMT,##__VA_ARGS__)
1471
1472 #elif defined(CONFIG_AFS_DEBUG)
1473 #define AFS_DEBUG_KENTER 0x01
1474 #define AFS_DEBUG_KLEAVE 0x02
1475 #define AFS_DEBUG_KDEBUG 0x04
1476
1477 #define _enter(FMT,...) \
1478 do { \
1479 if (unlikely(afs_debug & AFS_DEBUG_KENTER)) \
1480 kenter(FMT,##__VA_ARGS__); \
1481 } while (0)
1482
1483 #define _leave(FMT,...) \
1484 do { \
1485 if (unlikely(afs_debug & AFS_DEBUG_KLEAVE)) \
1486 kleave(FMT,##__VA_ARGS__); \
1487 } while (0)
1488
1489 #define _debug(FMT,...) \
1490 do { \
1491 if (unlikely(afs_debug & AFS_DEBUG_KDEBUG)) \
1492 kdebug(FMT,##__VA_ARGS__); \
1493 } while (0)
1494
1495 #else
1496 #define _enter(FMT,...) no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1497 #define _leave(FMT,...) no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1498 #define _debug(FMT,...) no_printk(" "FMT ,##__VA_ARGS__)
1499 #endif
1500
1501 /*
1502 * debug assertion checking
1503 */
1504 #if 1 // defined(__KDEBUGALL)
1505
1506 #define ASSERT(X) \
1507 do { \
1508 if (unlikely(!(X))) { \
1509 printk(KERN_ERR "\n"); \
1510 printk(KERN_ERR "AFS: Assertion failed\n"); \
1511 BUG(); \
1512 } \
1513 } while(0)
1514
1515 #define ASSERTCMP(X, OP, Y) \
1516 do { \
1517 if (unlikely(!((X) OP (Y)))) { \
1518 printk(KERN_ERR "\n"); \
1519 printk(KERN_ERR "AFS: Assertion failed\n"); \
1520 printk(KERN_ERR "%lu " #OP " %lu is false\n", \
1521 (unsigned long)(X), (unsigned long)(Y)); \
1522 printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n", \
1523 (unsigned long)(X), (unsigned long)(Y)); \
1524 BUG(); \
1525 } \
1526 } while(0)
1527
1528 #define ASSERTRANGE(L, OP1, N, OP2, H) \
1529 do { \
1530 if (unlikely(!((L) OP1 (N)) || !((N) OP2 (H)))) { \
1531 printk(KERN_ERR "\n"); \
1532 printk(KERN_ERR "AFS: Assertion failed\n"); \
1533 printk(KERN_ERR "%lu "#OP1" %lu "#OP2" %lu is false\n", \
1534 (unsigned long)(L), (unsigned long)(N), \
1535 (unsigned long)(H)); \
1536 printk(KERN_ERR "0x%lx "#OP1" 0x%lx "#OP2" 0x%lx is false\n", \
1537 (unsigned long)(L), (unsigned long)(N), \
1538 (unsigned long)(H)); \
1539 BUG(); \
1540 } \
1541 } while(0)
1542
1543 #define ASSERTIF(C, X) \
1544 do { \
1545 if (unlikely((C) && !(X))) { \
1546 printk(KERN_ERR "\n"); \
1547 printk(KERN_ERR "AFS: Assertion failed\n"); \
1548 BUG(); \
1549 } \
1550 } while(0)
1551
1552 #define ASSERTIFCMP(C, X, OP, Y) \
1553 do { \
1554 if (unlikely((C) && !((X) OP (Y)))) { \
1555 printk(KERN_ERR "\n"); \
1556 printk(KERN_ERR "AFS: Assertion failed\n"); \
1557 printk(KERN_ERR "%lu " #OP " %lu is false\n", \
1558 (unsigned long)(X), (unsigned long)(Y)); \
1559 printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n", \
1560 (unsigned long)(X), (unsigned long)(Y)); \
1561 BUG(); \
1562 } \
1563 } while(0)
1564
1565 #else
1566
1567 #define ASSERT(X) \
1568 do { \
1569 } while(0)
1570
1571 #define ASSERTCMP(X, OP, Y) \
1572 do { \
1573 } while(0)
1574
1575 #define ASSERTRANGE(L, OP1, N, OP2, H) \
1576 do { \
1577 } while(0)
1578
1579 #define ASSERTIF(C, X) \
1580 do { \
1581 } while(0)
1582
1583 #define ASSERTIFCMP(C, X, OP, Y) \
1584 do { \
1585 } while(0)
1586
1587 #endif /* __KDEBUGALL */
A mirror of Linus' kernel repository