internal.h 50 KB
Newer Older
1
/* internal AFS stuff
Linus Torvalds's avatar
Linus Torvalds committed
2
 *
3
 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11 12 13
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/compiler.h>
#include <linux/kernel.h>
14
#include <linux/ktime.h>
Linus Torvalds's avatar
Linus Torvalds committed
15 16
#include <linux/fs.h>
#include <linux/pagemap.h>
17
#include <linux/rxrpc.h>
18
#include <linux/key.h>
19
#include <linux/workqueue.h>
Andrew Morton's avatar
Andrew Morton committed
20
#include <linux/sched.h>
Christoph Hellwig's avatar
Christoph Hellwig committed
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 28
#include <net/netns/generic.h>
#include <net/sock.h>
29
#include <net/af_rxrpc.h>
Andrew Morton's avatar
Andrew Morton committed
30

31 32 33 34 35
#include "afs.h"
#include "afs_vl.h"

#define AFS_CELL_MAX_ADDRS 15

36
struct pagevec;
37 38
struct afs_call;

39 40 41
struct afs_mount_params {
	bool			rwpath;		/* T if the parent should be considered R/W */
	bool			force;		/* T to force cell type */
42
	bool			autocell;	/* T if set auto mount operation */
43
	bool			dyn_root;	/* T if dynamic root */
44 45 46
	afs_voltype_t		type;		/* type of volume requested */
	int			volnamesz;	/* size of volume name */
	const char		*volname;	/* name of volume to mount */
47 48
	struct net		*net_ns;	/* Network namespace in effect */
	struct afs_net		*net;		/* the AFS net namespace stuff */
49 50 51 52 53
	struct afs_cell		*cell;		/* cell in which to find volume */
	struct afs_volume	*volume;	/* volume record */
	struct key		*key;		/* key to use for secure mounting */
};

54 55 56 57 58
struct afs_iget_data {
	struct afs_fid		fid;
	struct afs_volume	*volume;	/* volume on which resides */
};

59
enum afs_call_state {
60 61 62 63 64 65 66 67
	AFS_CALL_CL_REQUESTING,		/* Client: Request is being sent */
	AFS_CALL_CL_AWAIT_REPLY,	/* Client: Awaiting reply */
	AFS_CALL_CL_PROC_REPLY,		/* Client: rxrpc call complete; processing reply */
	AFS_CALL_SV_AWAIT_OP_ID,	/* Server: Awaiting op ID */
	AFS_CALL_SV_AWAIT_REQUEST,	/* Server: Awaiting request data */
	AFS_CALL_SV_REPLYING,		/* Server: Replying */
	AFS_CALL_SV_AWAIT_ACK,		/* Server: Awaiting final ACK */
	AFS_CALL_COMPLETE,		/* Completed or failed */
68
};
69

70 71 72 73 74 75
/*
 * List of server addresses.
 */
struct afs_addr_list {
	struct rcu_head		rcu;		/* Must be first */
	refcount_t		usage;
76
	u32			version;	/* Version */
77 78
	unsigned char		max_addrs;
	unsigned char		nr_addrs;
79
	unsigned char		preferred;	/* Preferred address */
80
	unsigned char		nr_ipv4;	/* Number of IPv4 addresses */
81 82
	enum dns_record_source	source:8;
	enum dns_lookup_status	status:8;
83
	unsigned long		probed;		/* Mask of servers that have been probed */
84 85
	unsigned long		failed;		/* Mask of addrs that failed locally/ICMP */
	unsigned long		responded;	/* Mask of addrs that responded */
86
	struct sockaddr_rxrpc	addrs[];
87
#define AFS_MAX_ADDRESSES ((unsigned int)(sizeof(unsigned long) * 8))
88 89
};

90 91 92 93 94
/*
 * a record of an in-progress RxRPC call
 */
struct afs_call {
	const struct afs_call_type *type;	/* type of call */
95
	struct afs_addr_list	*alist;		/* Address is alist[addr_ix] */
96
	wait_queue_head_t	waitq;		/* processes awaiting completion */
97
	struct work_struct	async_work;	/* async I/O processor */
98 99 100
	struct work_struct	work;		/* actual work processor */
	struct rxrpc_call	*rxcall;	/* RxRPC call handle */
	struct key		*key;		/* security for this call */
101
	struct afs_net		*net;		/* The network namespace */
102
	struct afs_server	*cm_server;	/* Server affected by incoming CM call */
103
	struct afs_cb_interest	*cbi;		/* Callback interest for server used */
104
	void			*request;	/* request data (first part) */
105
	struct address_space	*mapping;	/* Pages being written from */
106 107 108 109 110 111
	struct iov_iter		iter;		/* Buffer iterator */
	struct iov_iter		*_iter;		/* Iterator currently in use */
	union {	/* Convenience for ->iter */
		struct kvec	kvec[1];
		struct bio_vec	bvec[1];
	};
112
	void			*buffer;	/* reply receive buffer */
113
	void			*reply[4];	/* Where to put the reply */
114 115
	pgoff_t			first;		/* first page in mapping to deal with */
	pgoff_t			last;		/* last page in mapping to deal with */
116
	atomic_t		usage;
117
	enum afs_call_state	state;
118
	spinlock_t		state_lock;
119
	int			error;		/* error code */
120
	u32			abort_code;	/* Remote abort ID or 0 */
121
	u32			epoch;
122 123
	unsigned		request_size;	/* size of request data */
	unsigned		reply_max;	/* maximum size of reply */
124
	unsigned		first_offset;	/* offset into mapping[first] */
125
	unsigned int		cb_break;	/* cb_break + cb_s_break before the call */
126 127 128 129
	union {
		unsigned	last_to;	/* amount of mapping[last] */
		unsigned	count2;		/* count used in unmarshalling */
	};
130
	unsigned char		unmarshall;	/* unmarshalling phase */
131
	unsigned char		addr_ix;	/* Address in ->alist */
132
	bool			incoming;	/* T if incoming call */
133
	bool			send_pages;	/* T if data from mapping should be sent */
134
	bool			need_attention;	/* T if RxRPC poked us */
David Howells's avatar
David Howells committed
135
	bool			async;		/* T if asynchronous */
136
	bool			ret_reply0;	/* T if should return reply[0] on success */
137
	bool			upgrade;	/* T to request service upgrade */
138
	bool			want_reply_time; /* T if want reply_time */
139
	u16			service_id;	/* Actual service ID (after upgrade) */
140
	unsigned int		debug_id;	/* Trace ID */
141
	u32			operation_ID;	/* operation ID for an incoming call */
142
	u32			count;		/* count for use in unmarshalling */
143 144 145 146 147 148 149
	union {					/* place to extract temporary data */
		struct {
			__be32	tmp_u;
			__be32	tmp;
		} __attribute__((packed));
		__be64		tmp64;
	};
150 151
	afs_dataversion_t	expected_version; /* Updated version expected from store */
	afs_dataversion_t	expected_version_2; /* 2nd updated version expected from store */
152
	ktime_t			reply_time;	/* Time of first reply packet */
153 154 155
};

struct afs_call_type {
156
	const char *name;
157
	unsigned int op; /* Really enum afs_fs_operation */
158

159 160 161
	/* deliver request or reply data to an call
	 * - returning an error will cause the call to be aborted
	 */
162
	int (*deliver)(struct afs_call *call);
163 164 165

	/* clean up a call */
	void (*destructor)(struct afs_call *call);
166 167 168

	/* Work function */
	void (*work)(struct work_struct *work);
169 170 171

	/* Call done function (gets called immediately on success or failure) */
	void (*done)(struct afs_call *call);
172 173
};

174 175 176 177 178 179 180 181 182
/*
 * Key available for writeback on a file.
 */
struct afs_wb_key {
	refcount_t		usage;
	struct key		*key;
	struct list_head	vnode_link;	/* Link in vnode->wb_keys */
};

183 184 185 186 187
/*
 * AFS open file information record.  Pointed to by file->private_data.
 */
struct afs_file {
	struct key		*key;		/* The key this file was opened with */
188
	struct afs_wb_key	*wb;		/* Writeback key record for this file */
189 190 191 192 193 194 195 196 197
};

static inline struct key *afs_file_key(struct file *file)
{
	struct afs_file *af = file->private_data;

	return af->key;
}

198 199 200 201 202
/*
 * Record of an outstanding read operation on a vnode.
 */
struct afs_read {
	loff_t			pos;		/* Where to start reading */
203
	loff_t			len;		/* How much we're asking for */
204
	loff_t			actual_len;	/* How much we're actually getting */
205
	loff_t			remain;		/* Amount remaining */
206 207 208
	loff_t			file_size;	/* File size returned by server */
	afs_dataversion_t	data_version;	/* Version number returned by server */
	refcount_t		usage;
209 210
	unsigned int		index;		/* Which page we're reading into */
	unsigned int		nr_pages;
211
	unsigned int		offset;		/* offset into current page */
212
	void (*page_done)(struct afs_call *, struct afs_read *);
213 214
	struct page		**pages;
	struct page		*array[];
215 216
};

217 218 219 220 221
/*
 * AFS superblock private data
 * - there's one superblock per volume
 */
struct afs_super_info {
222
	struct net		*net_ns;	/* Network namespace */
223
	struct afs_cell		*cell;		/* The cell in which the volume resides */
224
	struct afs_volume	*volume;	/* volume record */
225
	bool			dyn_root;	/* True if dynamic root */
226
};
Linus Torvalds's avatar
Linus Torvalds committed
227

228 229 230
static inline struct afs_super_info *AFS_FS_S(struct super_block *sb)
{
	return sb->s_fs_info;
Linus Torvalds's avatar
Linus Torvalds committed
231 232
}

233 234
extern struct file_system_type afs_fs_type;

235 236 237 238 239 240 241 242 243 244 245
/*
 * Set of substitutes for @sys.
 */
struct afs_sysnames {
#define AFS_NR_SYSNAME 16
	char			*subs[AFS_NR_SYSNAME];
	refcount_t		usage;
	unsigned short		nr;
	char			blank[1];
};

246 247 248 249
/*
 * AFS network namespace record.
 */
struct afs_net {
250
	struct net		*net;		/* Backpointer to the owning net namespace */
251 252 253 254 255 256 257 258 259 260 261 262
	struct afs_uuid		uuid;
	bool			live;		/* F if this namespace is being removed */

	/* AF_RXRPC I/O stuff */
	struct socket		*socket;
	struct afs_call		*spare_incoming_call;
	struct work_struct	charge_preallocation_work;
	struct mutex		socket_mutex;
	atomic_t		nr_outstanding_calls;
	atomic_t		nr_superblocks;

	/* Cell database */
263
	struct rb_root		cells;
264
	struct afs_cell __rcu	*ws_cell;
265 266 267 268
	struct work_struct	cells_manager;
	struct timer_list	cells_timer;
	atomic_t		cells_outstanding;
	seqlock_t		cells_lock;
269

270
	struct mutex		proc_cells_lock;
David Howells's avatar
David Howells committed
271
	struct hlist_head	proc_cells;
272

273 274 275 276 277 278 279 280
	/* Known servers.  Theoretically each fileserver can only be in one
	 * cell, but in practice, people create aliases and subsets and there's
	 * no easy way to distinguish them.
	 */
	seqlock_t		fs_lock;	/* For fs_servers */
	struct rb_root		fs_servers;	/* afs_server (by server UUID or address) */
	struct list_head	fs_updates;	/* afs_server (by update_at) */
	struct hlist_head	fs_proc;	/* procfs servers list */
281

282 283 284
	struct hlist_head	fs_addresses4;	/* afs_server (by lowest IPv4 addr) */
	struct hlist_head	fs_addresses6;	/* afs_server (by lowest IPv6 addr) */
	seqlock_t		fs_addr_lock;	/* For fs_addresses[46] */
285

286 287
	struct work_struct	fs_manager;
	struct timer_list	fs_timer;
David Howells's avatar
David Howells committed
288
	atomic_t		servers_outstanding;
289

290 291 292
	/* File locking renewal management */
	struct mutex		lock_manager_mutex;

293
	/* Misc */
294
	struct super_block	*dynroot_sb;	/* Dynamic root mount superblock */
295
	struct proc_dir_entry	*proc_afs;	/* /proc/net/afs directory */
296 297
	struct afs_sysnames	*sysnames;
	rwlock_t		sysnames_lock;
298 299 300 301 302

	/* Statistics counters */
	atomic_t		n_lookup;	/* Number of lookups done */
	atomic_t		n_reval;	/* Number of dentries needing revalidation */
	atomic_t		n_inval;	/* Number of invalidations by the server */
303
	atomic_t		n_relpg;	/* Number of invalidations by releasepage */
304
	atomic_t		n_read_dir;	/* Number of directory pages read */
305 306
	atomic_t		n_dir_cr;	/* Number of directory entry creation edits */
	atomic_t		n_dir_rm;	/* Number of directory entry removal edits */
307 308 309 310
	atomic_t		n_stores;	/* Number of store ops */
	atomic_long_t		n_store_bytes;	/* Number of bytes stored */
	atomic_long_t		n_fetch_bytes;	/* Number of bytes fetched */
	atomic_t		n_fetches;	/* Number of data fetch ops */
311 312
};

313
extern const char afs_init_sysname[];
314

315 316 317 318 319 320 321 322 323
enum afs_cell_state {
	AFS_CELL_UNSET,
	AFS_CELL_ACTIVATING,
	AFS_CELL_ACTIVE,
	AFS_CELL_DEACTIVATING,
	AFS_CELL_INACTIVE,
	AFS_CELL_FAILED,
};

324
/*
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
 * AFS cell record.
 *
 * This is a tricky concept to get right as it is possible to create aliases
 * simply by pointing AFSDB/SRV records for two names at the same set of VL
 * servers; it is also possible to do things like setting up two sets of VL
 * servers, one of which provides a superset of the volumes provided by the
 * other (for internal/external division, for example).
 *
 * Cells only exist in the sense that (a) a cell's name maps to a set of VL
 * servers and (b) a cell's name is used by the client to select the key to use
 * for authentication and encryption.  The cell name is not typically used in
 * the protocol.
 *
 * There is no easy way to determine if two cells are aliases or one is a
 * subset of another.
340 341
 */
struct afs_cell {
342 343 344 345 346
	union {
		struct rcu_head	rcu;
		struct rb_node	net_node;	/* Node in net->cells */
	};
	struct afs_net		*net;
347
	struct key		*anonymous_key;	/* anonymous user key for this cell */
348
	struct work_struct	manager;	/* Manager for init/deinit/dns */
David Howells's avatar
David Howells committed
349
	struct hlist_node	proc_link;	/* /proc cell list link */
350 351
#ifdef CONFIG_AFS_FSCACHE
	struct fscache_cookie	*cache;		/* caching cookie */
352
#endif
353 354 355 356 357 358 359 360
	time64_t		dns_expiry;	/* Time AFSDB/SRV record expires */
	time64_t		last_inactive;	/* Time of last drop of usage count */
	atomic_t		usage;
	unsigned long		flags;
#define AFS_CELL_FL_NOT_READY	0		/* The cell record is not ready for use */
#define AFS_CELL_FL_NO_GC	1		/* The cell was added manually, don't auto-gc */
#define AFS_CELL_FL_NOT_FOUND	2		/* Permanent DNS error */
#define AFS_CELL_FL_DNS_FAIL	3		/* Failed to access DNS */
361
#define AFS_CELL_FL_NO_LOOKUP_YET 4		/* Not completed first DNS lookup yet */
362 363 364
	enum afs_cell_state	state;
	short			error;

365 366 367
	/* Active fileserver interaction state. */
	struct list_head	proc_volumes;	/* procfs volume list */
	rwlock_t		proc_lock;
368

369
	/* VL server list. */
370 371 372
	rwlock_t		vl_servers_lock; /* Lock on vl_servers */
	struct afs_vlserver_list __rcu *vl_servers;

373 374
	u8			name_len;	/* Length of name */
	char			name[64 + 1];	/* Cell name, case-flattened and NUL-padded */
375 376
};

377 378 379 380 381 382 383 384 385
/*
 * Volume Location server record.
 */
struct afs_vlserver {
	struct rcu_head		rcu;
	struct afs_addr_list	__rcu *addresses; /* List of addresses for this VL server */
	unsigned long		flags;
#define AFS_VLSERVER_FL_PROBED	0		/* The VL server has been probed */
#define AFS_VLSERVER_FL_PROBING	1		/* VL server is being probed */
386
#define AFS_VLSERVER_FL_IS_YFS	2		/* Server is YFS not AFS */
387 388
	rwlock_t		lock;		/* Lock on addresses */
	atomic_t		usage;
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404

	/* Probe state */
	wait_queue_head_t	probe_wq;
	atomic_t		probe_outstanding;
	spinlock_t		probe_lock;
	struct {
		unsigned int	rtt;		/* RTT as ktime/64 */
		u32		abort_code;
		short		error;
		bool		have_result;
		bool		responded:1;
		bool		is_yfs:1;
		bool		not_yfs:1;
		bool		local_failure:1;
	} probe;

405
	u16			port;
406
	u16			name_len;	/* Length of name */
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
	char			name[];		/* Server name, case-flattened */
};

/*
 * Weighted list of Volume Location servers.
 */
struct afs_vlserver_entry {
	u16			priority;	/* Preference (as SRV) */
	u16			weight;		/* Weight (as SRV) */
	enum dns_record_source	source:8;
	enum dns_lookup_status	status:8;
	struct afs_vlserver	*server;
};

struct afs_vlserver_list {
	struct rcu_head		rcu;
	atomic_t		usage;
	u8			nr_servers;
	u8			index;		/* Server currently in use */
426
	u8			preferred;	/* Preferred server */
427 428 429 430 431 432
	enum dns_record_source	source:8;
	enum dns_lookup_status	status:8;
	rwlock_t		lock;
	struct afs_vlserver_entry servers[];
};

433
/*
434 435 436
 * Cached VLDB entry.
 *
 * This is pointed to by cell->vldb_entries, indexed by name.
437
 */
438 439
struct afs_vldb_entry {
	afs_volid_t		vid[3];		/* Volume IDs for R/W, R/O and Bak volumes */
440

441 442 443 444 445 446 447 448 449
	unsigned long		flags;
#define AFS_VLDB_HAS_RW		0		/* - R/W volume exists */
#define AFS_VLDB_HAS_RO		1		/* - R/O volume exists */
#define AFS_VLDB_HAS_BAK	2		/* - Backup volume exists */
#define AFS_VLDB_QUERY_VALID	3		/* - Record is valid */
#define AFS_VLDB_QUERY_ERROR	4		/* - VL server returned error */

	uuid_t			fs_server[AFS_NMAXNSERVERS];
	u8			fs_mask[AFS_NMAXNSERVERS];
450 451 452
#define AFS_VOL_VTM_RW	0x01 /* R/W version of the volume is available (on this server) */
#define AFS_VOL_VTM_RO	0x02 /* R/O version of the volume is available (on this server) */
#define AFS_VOL_VTM_BAK	0x04 /* backup version of the volume is available (on this server) */
453 454 455 456
	short			error;
	u8			nr_servers;	/* Number of server records */
	u8			name_len;
	u8			name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
457 458 459
};

/*
460
 * Record of fileserver with which we're actively communicating.
461 462
 */
struct afs_server {
463 464 465 466 467 468 469 470 471 472 473 474 475 476
	struct rcu_head		rcu;
	union {
		uuid_t		uuid;		/* Server ID */
		struct afs_uuid	_uuid;
	};

	struct afs_addr_list	__rcu *addresses;
	struct rb_node		uuid_rb;	/* Link in net->servers */
	struct hlist_node	addr4_link;	/* Link in net->fs_addresses4 */
	struct hlist_node	addr6_link;	/* Link in net->fs_addresses6 */
	struct hlist_node	proc_link;	/* Link in net->fs_proc */
	struct afs_server	*gc_next;	/* Next server in manager's list */
	time64_t		put_time;	/* Time at which last put */
	time64_t		update_at;	/* Time at which to next update the record */
477
	unsigned long		flags;
478 479 480 481 482 483 484
#define AFS_SERVER_FL_NEW	0		/* New server, don't inc cb_s_break */
#define AFS_SERVER_FL_NOT_READY	1		/* The record is not ready for use */
#define AFS_SERVER_FL_NOT_FOUND	2		/* VL server says no such server */
#define AFS_SERVER_FL_VL_FAIL	3		/* Failed to access VL server */
#define AFS_SERVER_FL_UPDATING	4
#define AFS_SERVER_FL_PROBED	5		/* The fileserver has been probed */
#define AFS_SERVER_FL_PROBING	6		/* Fileserver is being probed */
485
#define AFS_SERVER_FL_NO_IBULK	7		/* Fileserver doesn't support FS.InlineBulkStatus */
486
#define AFS_SERVER_FL_MAY_HAVE_CB 8		/* May have callbacks on this fileserver */
487 488
#define AFS_SERVER_FL_IS_YFS	9		/* Server is YFS not AFS */
#define AFS_SERVER_FL_NO_RM2	10		/* Fileserver doesn't support YFS.RemoveFile2 */
489
#define AFS_SERVER_FL_HAVE_EPOCH 11		/* ->epoch is valid */
490 491
	atomic_t		usage;
	u32			addr_version;	/* Address list version */
492
	u32			cm_epoch;	/* Server RxRPC epoch */
493 494

	/* file service access */
495
	rwlock_t		fs_lock;	/* access lock */
496 497

	/* callback promise management */
498
	struct hlist_head	cb_volumes;	/* List of volume interests on this server */
499 500
	unsigned		cb_s_break;	/* Break-everything counter. */
	rwlock_t		cb_break_lock;	/* Volume finding lock */
501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520

	/* Probe state */
	wait_queue_head_t	probe_wq;
	atomic_t		probe_outstanding;
	spinlock_t		probe_lock;
	struct {
		unsigned int	rtt;		/* RTT as ktime/64 */
		u32		abort_code;
		u32		cm_epoch;
		short		error;
		bool		have_result;
		bool		responded:1;
		bool		is_yfs:1;
		bool		not_yfs:1;
		bool		local_failure:1;
		bool		no_epoch:1;
		bool		cm_probed:1;
		bool		said_rebooted:1;
		bool		said_inconsistent:1;
	} probe;
521 522
};

523 524 525 526 527 528 529 530 531 532
/*
 * Volume collation in the server's callback interest list.
 */
struct afs_vol_interest {
	struct hlist_node	srv_link;	/* Link in server->cb_volumes */
	struct hlist_head	cb_interests;	/* List of callback interests on the server */
	afs_volid_t		vid;		/* Volume ID to match */
	unsigned int		usage;
};

533 534 535 536
/*
 * Interest by a superblock on a server.
 */
struct afs_cb_interest {
537 538
	struct hlist_node	cb_vlink;	/* Link in vol_interest->cb_interests */
	struct afs_vol_interest	*vol_interest;
539 540 541 542
	struct afs_server	*server;	/* Server on which this interest resides */
	struct super_block	*sb;		/* Superblock on which inodes reside */
	afs_volid_t		vid;		/* Volume ID to match */
	refcount_t		usage;
543 544 545
};

/*
546 547 548 549 550 551 552 553 554
 * Replaceable server list.
 */
struct afs_server_entry {
	struct afs_server	*server;
	struct afs_cb_interest	*cb_interest;
};

struct afs_server_list {
	refcount_t		usage;
555 556
	unsigned char		nr_servers;
	unsigned char		preferred;	/* Preferred server */
557 558
	unsigned short		vnovol_mask;	/* Servers to be skipped due to VNOVOL */
	unsigned int		seq;		/* Set to ->servers_seq when installed */
559
	rwlock_t		lock;
560 561 562 563 564
	struct afs_server_entry	servers[];
};

/*
 * Live AFS volume management.
565 566
 */
struct afs_volume {
567
	afs_volid_t		vid;		/* volume ID */
568
	atomic_t		usage;
569 570 571 572 573 574 575 576 577 578
	time64_t		update_at;	/* Time at which to next update */
	struct afs_cell		*cell;		/* Cell to which belongs (pins ref) */
	struct list_head	proc_link;	/* Link in cell->vl_proc */
	unsigned long		flags;
#define AFS_VOLUME_NEEDS_UPDATE	0	/* - T if an update needs performing */
#define AFS_VOLUME_UPDATING	1	/* - T if an update is in progress */
#define AFS_VOLUME_WAIT		2	/* - T if users must wait for update */
#define AFS_VOLUME_DELETED	3	/* - T if volume appears deleted */
#define AFS_VOLUME_OFFLINE	4	/* - T if volume offline notice given */
#define AFS_VOLUME_BUSY		5	/* - T if volume busy notice given */
579 580
#ifdef CONFIG_AFS_FSCACHE
	struct fscache_cookie	*cache;		/* caching cookie */
581
#endif
582 583 584 585
	struct afs_server_list	*servers;	/* List of servers on which volume resides */
	rwlock_t		servers_lock;	/* Lock for ->servers */
	unsigned int		servers_seq;	/* Incremented each time ->servers changes */

586 587 588
	unsigned		cb_v_break;	/* Break-everything counter. */
	rwlock_t		cb_break_lock;

589
	afs_voltype_t		type;		/* type of volume */
590
	short			error;
591
	char			type_force;	/* force volume type (suppress R/O -> R/W) */
592 593
	u8			name_len;
	u8			name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
594 595
};

David Howells's avatar
David Howells committed
596 597 598 599 600 601 602 603 604 605
enum afs_lock_state {
	AFS_VNODE_LOCK_NONE,		/* The vnode has no lock on the server */
	AFS_VNODE_LOCK_WAITING_FOR_CB,	/* We're waiting for the server to break the callback */
	AFS_VNODE_LOCK_SETTING,		/* We're asking the server for a lock */
	AFS_VNODE_LOCK_GRANTED,		/* We have a lock on the server */
	AFS_VNODE_LOCK_EXTENDING,	/* We're extending a lock on the server */
	AFS_VNODE_LOCK_NEED_UNLOCK,	/* We need to unlock on the server */
	AFS_VNODE_LOCK_UNLOCKING,	/* We're telling the server to unlock */
};

606
/*
607 608 609 610
 * AFS inode private data.
 *
 * Note that afs_alloc_inode() *must* reset anything that could incorrectly
 * leak from one inode to another.
611 612 613 614 615 616 617
 */
struct afs_vnode {
	struct inode		vfs_inode;	/* the VFS's inode record */

	struct afs_volume	*volume;	/* volume on which vnode resides */
	struct afs_fid		fid;		/* the file identifier for this inode */
	struct afs_file_status	status;		/* AFS status info for this file */
618
	afs_dataversion_t	invalid_before;	/* Child dentries are invalid before this */
619 620
#ifdef CONFIG_AFS_FSCACHE
	struct fscache_cookie	*cache;		/* caching cookie */
621
#endif
622
	struct afs_permits __rcu *permit_cache;	/* cache of permits so far obtained */
623
	struct mutex		io_lock;	/* Lock for serialising I/O on this mutex */
624
	struct rw_semaphore	validate_lock;	/* lock for validating this vnode */
625
	spinlock_t		wb_lock;	/* lock for wb_keys */
626 627
	spinlock_t		lock;		/* waitqueue/flags lock */
	unsigned long		flags;
628
#define AFS_VNODE_CB_PROMISED	0		/* Set if vnode has a callback promise */
629
#define AFS_VNODE_UNSET		1		/* set if vnode attributes not yet set */
630
#define AFS_VNODE_DIR_VALID	2		/* Set if dir contents are valid */
631 632 633
#define AFS_VNODE_ZAP_DATA	3		/* set if vnode's data should be invalidated */
#define AFS_VNODE_DELETED	4		/* set if vnode deleted on server */
#define AFS_VNODE_MOUNTPOINT	5		/* set if vnode is a mountpoint symlink */
David Howells's avatar
David Howells committed
634 635
#define AFS_VNODE_AUTOCELL	6		/* set if Vnode is an auto mount point */
#define AFS_VNODE_PSEUDODIR	7 		/* set if Vnode is a pseudo directory */
636
#define AFS_VNODE_NEW_CONTENT	8		/* Set if file has new content (create/trunc-0) */
637

638
	struct list_head	wb_keys;	/* List of keys available for writeback */
639 640 641
	struct list_head	pending_locks;	/* locks waiting to be granted */
	struct list_head	granted_locks;	/* locks granted on this file */
	struct delayed_work	lock_work;	/* work to be done in locking */
David Howells's avatar
David Howells committed
642 643 644
	struct key		*lock_key;	/* Key to be used in lock ops */
	enum afs_lock_state	lock_state : 8;
	afs_lock_type_t		lock_type : 8;
645

646
	/* outstanding callback notification on this file */
647 648
	struct afs_cb_interest	*cb_interest;	/* Server on which this resides */
	unsigned int		cb_s_break;	/* Mass break counter on ->server */
649
	unsigned int		cb_v_break;	/* Mass break counter on ->volume */
650 651 652 653
	unsigned int		cb_break;	/* Break counter on vnode */
	seqlock_t		cb_lock;	/* Lock for ->cb_interest, ->status, ->cb_*break */

	time64_t		cb_expires_at;	/* time at which callback expires */
654 655 656 657
	unsigned		cb_version;	/* callback version */
	afs_callback_type_t	cb_type;	/* type of callback */
};

658 659 660 661 662 663 664 665 666
static inline struct fscache_cookie *afs_vnode_cache(struct afs_vnode *vnode)
{
#ifdef CONFIG_AFS_FSCACHE
	return vnode->cache;
#else
	return NULL;
#endif
}

667 668 669 670 671
/*
 * cached security record for one user's attempt to access a vnode
 */
struct afs_permit {
	struct key		*key;		/* RxRPC ticket holding a security context */
672
	afs_access_t		access;		/* CallerAccess value for this key */
673 674 675
};

/*
676 677
 * Immutable cache of CallerAccess records from attempts to access vnodes.
 * These may be shared between multiple vnodes.
678 679
 */
struct afs_permits {
680 681 682 683 684 685 686
	struct rcu_head		rcu;
	struct hlist_node	hash_node;	/* Link in hash */
	unsigned long		h;		/* Hash value for this permit list */
	refcount_t		usage;
	unsigned short		nr_permits;	/* Number of records */
	bool			invalidated;	/* Invalidated due to key change */
	struct afs_permit	permits[];	/* List of permits sorted by key pointer */
687 688
};

689 690 691 692 693 694 695 696 697
/*
 * record of one of a system's set of network interfaces
 */
struct afs_interface {
	struct in_addr	address;	/* IPv4 address bound to interface */
	struct in_addr	netmask;	/* netmask applied to address */
	unsigned	mtu;		/* MTU of interface */
};

698 699 700 701 702 703 704 705
/*
 * Error prioritisation and accumulation.
 */
struct afs_error {
	short	error;			/* Accumulated error */
	bool	responded;		/* T if server responded */
};

706 707 708 709 710
/*
 * Cursor for iterating over a server's address list.
 */
struct afs_addr_cursor {
	struct afs_addr_list	*alist;		/* Current address list (pins ref) */
711 712
	unsigned long		tried;		/* Tried addresses */
	signed char		index;		/* Current address */
713
	bool			responded;	/* T if the current address responded */
714
	unsigned short		nr_iterations;	/* Number of address iterations */
715 716
	short			error;
	u32			abort_code;
717 718
};

719 720 721 722 723 724 725
/*
 * Cursor for iterating over a set of volume location servers.
 */
struct afs_vl_cursor {
	struct afs_addr_cursor	ac;
	struct afs_cell		*cell;		/* The cell we're querying */
	struct afs_vlserver_list *server_list;	/* Current server list (pins ref) */
726
	struct afs_vlserver	*server;	/* Server on which this resides */
727
	struct key		*key;		/* Key for the server */
728 729
	unsigned long		untried;	/* Bitmask of untried servers */
	short			index;		/* Current server */
730 731 732 733 734
	short			error;
	unsigned short		flags;
#define AFS_VL_CURSOR_STOP	0x0001		/* Set to cease iteration */
#define AFS_VL_CURSOR_RETRY	0x0002		/* Set to do a retry */
#define AFS_VL_CURSOR_RETRIED	0x0004		/* Set if started a retry */
735
	unsigned short		nr_iterations;	/* Number of server iterations */
736 737
};

738 739 740 741 742
/*
 * Cursor for iterating over a set of fileservers.
 */
struct afs_fs_cursor {
	struct afs_addr_cursor	ac;
743 744 745 746
	struct afs_vnode	*vnode;
	struct afs_server_list	*server_list;	/* Current server list (pins ref) */
	struct afs_cb_interest	*cbi;		/* Server on which this resides (pins ref) */
	struct key		*key;		/* Key for the server */
747
	unsigned long		untried;	/* Bitmask of untried servers */
748 749
	unsigned int		cb_break;	/* cb_break + cb_s_break before the call */
	unsigned int		cb_break_2;	/* cb_break + cb_s_break (2nd vnode) */
750
	short			index;		/* Current server */
751
	short			error;
752 753 754 755 756 757 758
	unsigned short		flags;
#define AFS_FS_CURSOR_STOP	0x0001		/* Set to cease iteration */
#define AFS_FS_CURSOR_VBUSY	0x0002		/* Set if seen VBUSY */
#define AFS_FS_CURSOR_VMOVED	0x0004		/* Set if seen VMOVED */
#define AFS_FS_CURSOR_VNOVOL	0x0008		/* Set if seen VNOVOL */
#define AFS_FS_CURSOR_CUR_ONLY	0x0010		/* Set if current server only (file lock held) */
#define AFS_FS_CURSOR_NO_VSLEEP	0x0020		/* Set to prevent sleep on VBUSY, VOFFLINE, ... */
759
	unsigned short		nr_iterations;	/* Number of server iterations */
760 761
};

762 763 764 765 766 767 768
/*
 * Cache auxiliary data.
 */
struct afs_vnode_cache_aux {
	u64			data_version;
} __packed;

769 770
#include <trace/events/afs.h>

771
/*****************************************************************************/
772 773 774 775 776 777 778 779 780 781 782 783 784
/*
 * addr_list.c
 */
static inline struct afs_addr_list *afs_get_addrlist(struct afs_addr_list *alist)
{
	if (alist)
		refcount_inc(&alist->usage);
	return alist;
}
extern struct afs_addr_list *afs_alloc_addrlist(unsigned int,
						unsigned short,
						unsigned short);
extern void afs_put_addrlist(struct afs_addr_list *);
785 786 787 788
extern struct afs_vlserver_list *afs_parse_text_addrs(struct afs_net *,
						      const char *, size_t, char,
						      unsigned short, unsigned short);
extern struct afs_vlserver_list *afs_dns_query(struct afs_cell *, time64_t *);
789 790 791
extern bool afs_iterate_addresses(struct afs_addr_cursor *);
extern int afs_end_cursor(struct afs_addr_cursor *);

792 793
extern void afs_merge_fs_addr4(struct afs_addr_list *, __be32, u16);
extern void afs_merge_fs_addr6(struct afs_addr_list *, __be32 *, u16);
794

795 796 797 798 799 800 801 802 803 804 805 806 807 808
/*
 * cache.c
 */
#ifdef CONFIG_AFS_FSCACHE
extern struct fscache_netfs afs_cache_netfs;
extern struct fscache_cookie_def afs_cell_cache_index_def;
extern struct fscache_cookie_def afs_volume_cache_index_def;
extern struct fscache_cookie_def afs_vnode_cache_index_def;
#else
#define afs_cell_cache_index_def	(*(struct fscache_cookie_def *) NULL)
#define afs_volume_cache_index_def	(*(struct fscache_cookie_def *) NULL)
#define afs_vnode_cache_index_def	(*(struct fscache_cookie_def *) NULL)
#endif

809 810 811 812
/*
 * callback.c
 */
extern void afs_init_callback_state(struct afs_server *);
813
extern void __afs_break_callback(struct afs_vnode *);
814
extern void afs_break_callback(struct afs_vnode *);
815
extern void afs_break_callbacks(struct afs_server *, size_t, struct afs_callback_break*);
816

817 818
extern int afs_register_server_cb_interest(struct afs_vnode *,
					   struct afs_server_list *, unsigned int);
819
extern void afs_put_cb_interest(struct afs_net *, struct afs_cb_interest *);
820
extern void afs_clear_callback_interests(struct afs_net *, struct afs_server_list *);
821 822 823

static inline struct afs_cb_interest *afs_get_cb_interest(struct afs_cb_interest *cbi)
{
824 825
	if (cbi)
		refcount_inc(&cbi->usage);
826 827
	return cbi;
}
828

829 830 831 832 833
static inline unsigned int afs_calc_vnode_cb_break(struct afs_vnode *vnode)
{
	return vnode->cb_break + vnode->cb_s_break + vnode->cb_v_break;
}

834 835 836
static inline bool afs_cb_is_broken(unsigned int cb_break,
				    const struct afs_vnode *vnode,
				    const struct afs_cb_interest *cbi)
837
{
838 839 840
	return !cbi || cb_break != (vnode->cb_break +
				    cbi->server->cb_s_break +
				    vnode->volume->cb_v_break);
841 842
}

Linus Torvalds's avatar
Linus Torvalds committed
843 844 845
/*
 * cell.c
 */
846 847 848 849
extern int afs_cell_init(struct afs_net *, const char *);
extern struct afs_cell *afs_lookup_cell_rcu(struct afs_net *, const char *, unsigned);
extern struct afs_cell *afs_lookup_cell(struct afs_net *, const char *, unsigned,
					const char *, bool);
850
extern struct afs_cell *afs_get_cell(struct afs_cell *);
851
extern void afs_put_cell(struct afs_net *, struct afs_cell *);
852 853
extern void afs_manage_cells(struct work_struct *);
extern void afs_cells_timer(struct timer_list *);
854
extern void __net_exit afs_cell_purge(struct afs_net *);
855 856 857 858 859 860

/*
 * cmservice.c
 */
extern bool afs_cm_incoming_call(struct afs_call *);

Linus Torvalds's avatar
Linus Torvalds committed
861 862 863
/*
 * dir.c
 */
864
extern const struct file_operations afs_dir_file_operations;
865
extern const struct inode_operations afs_dir_inode_operations;
866
extern const struct address_space_operations afs_dir_aops;
Al Viro's avatar
Al Viro committed
867
extern const struct dentry_operations afs_fs_dentry_operations;
868

869 870
extern void afs_d_release(struct dentry *);

871 872 873 874 875 876 877
/*
 * dir_edit.c
 */
extern void afs_edit_dir_add(struct afs_vnode *, struct qstr *, struct afs_fid *,
			     enum afs_edit_dir_reason);
extern void afs_edit_dir_remove(struct afs_vnode *, struct qstr *, enum afs_edit_dir_reason);

878 879 880 881 882 883 884 885
/*
 * dynroot.c
 */
extern const struct file_operations afs_dynroot_file_operations;
extern const struct inode_operations afs_dynroot_inode_operations;
extern const struct dentry_operations afs_dynroot_dentry_operations;

extern struct inode *afs_try_auto_mntpt(struct dentry *, struct inode *);
886 887 888 889
extern int afs_dynroot_mkdir(struct afs_net *, struct afs_cell *);
extern void afs_dynroot_rmdir(struct afs_net *, struct afs_cell *);
extern int afs_dynroot_populate(struct super_block *);
extern void afs_dynroot_depopulate(struct super_block *);
Linus Torvalds's avatar
Linus Torvalds committed
890 891 892 893

/*
 * file.c
 */
894
extern const struct address_space_operations afs_fs_aops;
895
extern const struct inode_operations afs_file_inode_operations;
896 897
extern const struct file_operations afs_file_operations;

898 899
extern int afs_cache_wb_key(struct afs_vnode *, struct afs_file *);
extern void afs_put_wb_key(struct afs_wb_key *);
900 901
extern int afs_open(struct inode *, struct file *);
extern int afs_release(struct inode *, struct file *);
902
extern int afs_fetch_data(struct afs_vnode *, struct key *, struct afs_read *);
903
extern int afs_page_filler(void *, struct page *);
904
extern void afs_put_read(struct afs_read *);
Linus Torvalds's avatar
Linus Torvalds committed
905

906 907 908
/*
 * flock.c
 */
909 910
extern struct workqueue_struct *afs_lock_manager;

911 912 913 914 915
extern void afs_lock_work(struct work_struct *);
extern void afs_lock_may_be_available(struct afs_vnode *);
extern int afs_lock(struct file *, int, struct file_lock *);
extern int afs_flock(struct file *, int, struct file_lock *);

916 917 918
/*
 * fsclient.c
 */
919 920 921 922 923 924
#define AFS_VNODE_NOT_YET_SET	0x01
#define AFS_VNODE_META_CHANGED	0x02
#define AFS_VNODE_DATA_CHANGED	0x04
extern void afs_update_inode_from_status(struct afs_vnode *, struct afs_file_status *,
					 const afs_dataversion_t *, u8);

925
extern int afs_fs_fetch_file_status(struct afs_fs_cursor *, struct afs_volsync *, bool);
926 927
extern int afs_fs_give_up_callbacks(struct afs_net *, struct afs_server *);
extern int afs_fs_fetch_data(struct afs_fs_cursor *, struct afs_read *);
928
extern int afs_fs_create(struct afs_fs_cursor *, const char *, umode_t, u64,
929
			 struct afs_fid *, struct afs_file_status *, struct afs_callback *);
930
extern int afs_fs_remove(struct afs_fs_cursor *, struct afs_vnode *, const char *, bool, u64);
931 932
extern int afs_fs_link(struct afs_fs_cursor *, struct afs_vnode *, const char *, u64);
extern int afs_fs_symlink(struct afs_fs_cursor *, const char *, const char *, u64,
933 934
			  struct afs_fid *, struct afs_file_status *);
extern int afs_fs_rename(struct afs_fs_cursor *, const char *,
935
			 struct afs_vnode *, const char *, u64, u64);
936
extern int afs_fs_store_data(struct afs_fs_cursor *, struct address_space *,
937 938 939 940 941 942 943 944 945
			     pgoff_t, pgoff_t, unsigned, unsigned);
extern int afs_fs_setattr(struct afs_fs_cursor *, struct iattr *);
extern int afs_fs_get_volume_status(struct afs_fs_cursor *, struct afs_volume_status *);
extern int afs_fs_set_lock(struct afs_fs_cursor *, afs_lock_type_t);
extern int afs_fs_extend_lock(struct afs_fs_cursor *);
extern int afs_fs_release_lock(struct afs_fs_cursor *);
extern int afs_fs_give_up_all_callbacks(struct afs_net *, struct afs_server *,
					struct afs_addr_cursor *, struct key *);
extern int afs_fs_get_capabilities(struct afs_net *, struct afs_server *,
946
				   struct afs_addr_cursor *, struct key *, unsigned int, bool);
947 948 949 950 951 952 953
extern int afs_fs_inline_bulk_status(struct afs_fs_cursor *, struct afs_net *,
				     struct afs_fid *, struct afs_file_status *,
				     struct afs_callback *, unsigned int,
				     struct afs_volsync *);
extern int afs_fs_fetch_status(struct afs_fs_cursor *, struct afs_net *,
			       struct afs_fid *, struct afs_file_status *,
			       struct afs_callback *, struct afs_volsync *);
954

955 956 957 958 959 960 961
/*
 * fs_probe.c
 */
extern void afs_fileserver_probe_result(struct afs_call *);
extern int afs_probe_fileservers(struct afs_net *, struct key *, struct afs_server_list *);
extern int afs_wait_for_fs_probes(struct afs_server_list *, unsigned long);

Linus Torvalds's avatar
Linus Torvalds committed
962 963 964
/*
 * inode.c
 */
965
extern int afs_fetch_status(struct afs_vnode *, struct key *, bool);
966
extern int afs_iget5_test(struct inode *, void *);
967
extern struct inode *afs_iget_pseudo_dir(struct super_block *, bool);
968
extern struct inode *afs_iget(struct super_block *, struct key *,
969
			      struct afs_fid *, struct afs_file_status *,
970 971
			      struct afs_callback *,
			      struct afs_cb_interest *);
David Howells's avatar
David Howells committed
972
extern void afs_zap_data(struct afs_vnode *);
973
extern int afs_validate(struct afs_vnode *, struct key *);
974
extern int afs_getattr(const struct path *, struct kstat *, u32, unsigned int);
975
extern int afs_setattr(struct dentry *, struct iattr *);
976
extern void afs_evict_inode(struct inode *);
977
extern int afs_drop_inode(struct inode *);
Linus Torvalds's avatar
Linus Torvalds committed
978 979 980 981

/*
 * main.c
 */
982
extern struct workqueue_struct *afs_wq;
983
extern int afs_net_id;
984

985
static inline struct afs_net *afs_net(struct net *net)
986
{
987
	return net_generic(net, afs_net_id);
988 989
}

990
static inline struct afs_net *afs_sb2net(struct super_block *sb)
991
{
992
	return afs_net(AFS_FS_S(sb)->net_ns);
993 994
}

995
static inline struct afs_net *afs_d2net(struct dentry *dentry)
996
{
997
	return afs_sb2net(dentry->d_sb);
998 999
}

1000
static inline struct afs_net *afs_i2net(struct inode *inode)
1001
{
1002
	return afs_sb2net(inode->i_sb);
1003 1004
}

1005
static inline struct afs_net *afs_v2net(struct afs_vnode *vnode)
1006
{
1007
	return afs_i2net(&vnode->vfs_inode);
1008 1009
}

1010
static inline struct afs_net *afs_sock2net(struct sock *sk)
1011
{
1012
	return net_generic(sock_net(sk), afs_net_id);
1013
}
Linus Torvalds's avatar
Linus Torvalds committed
1014

1015 1016 1017 1018 1019 1020 1021
static inline void __afs_stat(atomic_t *s)
{
	atomic_inc(s);
}

#define afs_stat_v(vnode, n) __afs_stat(&afs_v2net(vnode)->n)

1022 1023 1024 1025
/*
 * misc.c
 */
extern int afs_abort_to_error(u32);
1026
extern void afs_prioritise_error(struct afs_error *, int, u32);
1027

Linus Torvalds's avatar
Linus Torvalds committed
1028 1029 1030
/*
 * mntpt.c
 */
1031
extern const struct inode_operations afs_mntpt_inode_operations;
1032
extern const struct inode_operations afs_autocell_inode_operations;
1033
extern const struct file_operations afs_mntpt_file_operations;
Linus Torvalds's avatar
Linus Torvalds committed
1034

1035
extern struct vfsmount *afs_d_automount(struct path *);
1036
extern void afs_mntpt_kill_timer(void);
Linus Torvalds's avatar
Linus Torvalds committed
1037

1038 1039 1040
/*
 * netdevices.c
 */
1041 1042
extern int afs_get_ipv4_interfaces(struct afs_net *, struct afs_interface *,
				   size_t, bool);
1043

Linus Torvalds's avatar
Linus Torvalds committed
1044 1045 1046
/*
 * proc.c
 */
1047
#ifdef CONFIG_PROC_FS
1048 1049
extern int __net_init afs_proc_init(struct afs_net *);
extern void __net_exit afs_proc_cleanup(struct afs_net *);
1050 1051
extern int afs_proc_cell_setup(struct afs_cell *);
extern void afs_proc_cell_remove(struct afs_cell *);
1052
extern void afs_put_sysnames(struct afs_sysnames *);
1053 1054 1055 1056 1057 1058 1059
#else
static inline int afs_proc_init(struct afs_net *net) { return 0; }
static inline void afs_proc_cleanup(struct afs_net *net) {}
static inline int afs_proc_cell_setup(struct afs_cell *cell) { return 0; }
static inline void afs_proc_cell_remove(struct afs_cell *cell) {}
static inline void afs_put_sysnames(struct afs_sysnames *sysnames) {}
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1060

1061 1062 1063 1064 1065 1066 1067 1068 1069
/*
 * rotate.c
 */
extern bool afs_begin_vnode_operation(struct afs_fs_cursor *, struct afs_vnode *,
				      struct key *);
extern bool afs_select_fileserver(struct afs_fs_cursor *);
extern bool afs_select_current_fileserver(struct afs_fs_cursor *);
extern int afs_end_vnode_operation(struct afs_fs_cursor *);

1070 1071 1072
/*
 * rxrpc.c
 */
1073
extern struct workqueue_struct *afs_async_calls;
1074

1075 1076 1077
extern int __net_init afs_open_socket(struct afs_net *);
extern void __net_exit afs_close_socket(struct afs_net *);
extern void afs_charge_preallocation(struct work_struct *);
1078
extern void afs_put_call(struct afs_call *);
1079
extern long afs_make_call(struct afs_addr_cursor *, struct afs_call *, gfp_t, bool);
1080 1081
extern struct afs_call *afs_alloc_flat_call(struct afs_net *,
					    const struct afs_call_type *,
1082 1083 1084
					    size_t, size_t);
extern void afs_flat_call_destructor(struct afs_call *);
extern void afs_send_empty_reply(struct afs_call *);
1085
extern void afs_send_simple_reply(struct afs_call *, const void *, size_t);
1086
extern int afs_extract_data(struct afs_call *, bool);
1087
extern int afs_protocol_error(struct afs_call *, int, enum afs_eproto_cause);
1088

1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
static inline void afs_extract_begin(struct afs_call *call, void *buf, size_t size)
{
	call->kvec[0].iov_base = buf;
	call->kvec[0].iov_len = size;
	iov_iter_kvec(&call->iter, READ, call->kvec, 1, size);
}

static inline void afs_extract_to_tmp(struct afs_call *call)
{
	afs_extract_begin(call, &call->tmp, sizeof(call->tmp));
}

static inline void afs_extract_to_tmp64(struct afs_call *call)
{
	afs_extract_begin(call, &call->tmp64, sizeof(call->tmp64));
}

static inline void afs_extract_discard(struct afs_call *call, size_t size)
{
	iov_iter_discard(&call->iter, READ, size);
}

static inline void afs_extract_to_buf(struct afs_call *call, size_t size)
{
	afs_extract_begin(call, call->buffer, size);
}

1116
static inline int afs_transfer_reply(struct afs_call *call)
1117
{
1118
	return afs_extract_data(call, false);
1119 1120
}

1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
static inline bool afs_check_call_state(struct afs_call *call,
					enum afs_call_state state)
{
	return READ_ONCE(call->state) == state;
}

static inline bool afs_set_call_state(struct afs_call *call,
				      enum afs_call_state from,
				      enum afs_call_state to)
{
	bool ok = false;

	spin_lock_bh(&call->state_lock);
	if (call->state == from) {
		call->state = to;
		trace_afs_call_state(call, from, to, 0, 0);
		ok = true;
	}
	spin_unlock_bh(&call->state_lock);
	return ok;
}

static inline void afs_set_call_complete(struct afs_call *call,
					 int error, u32 remote_abort)
{
	enum afs_call_state state;
	bool ok = false;

	spin_lock_bh(&call->state_lock);
	state = call->state;
	if (state != AFS_CALL_COMPLETE) {
		call->abort_code = remote_abort;
		call->error = error;
		call->state = AFS_CALL_COMPLETE;
		trace_afs_call_state(call, state, AFS_CALL_COMPLETE,
				     error, remote_abort);
		ok = true;
	}
	spin_unlock_bh(&call->state_lock);
	if (ok)
		trace_afs_call_done(call);
}

1164 1165 1166
/*
 * security.c
 */
1167
extern void afs_put_permits(struct afs_permits *);
1168
extern void afs_clear_permits(struct afs_vnode *);
1169
extern void afs_cache_permit(struct afs_vnode *, struct key *, unsigned int);
David Howells's avatar
David Howells committed
1170
extern void afs_zap_permits(struct rcu_head *);
1171
extern struct key *afs_request_key(struct afs_cell *);
David Howells's avatar
David Howells committed
1172
extern int afs_check_permit(struct afs_vnode *, struct key *, afs_access_t *);
1173
extern int afs_permission(struct inode *, int);
1174
extern void __exit afs_clean_up_permit_cache(void);
1175

1176 1177 1178 1179 1180
/*
 * server.c
 */
extern spinlock_t afs_server_peer_lock;

1181 1182 1183 1184 1185
static inline struct afs_server *afs_get_server(struct afs_server *server)
{
	atomic_inc(&server->usage);
	return server;
}
1186

1187 1188
extern struct afs_server *afs_find_server(struct afs_net *,
					  const struct sockaddr_rxrpc *);
1189 1190
extern struct afs_server *afs_find_server_by_uuid(struct afs_net *, const uuid_t *);
extern struct afs_server *afs_lookup_server(struct afs_cell *, struct key *, const uuid_t *);
1191
extern void afs_put_server(struct afs_net *, struct afs_server *);
1192 1193
extern void afs_manage_servers(struct work_struct *);
extern void afs_servers_timer(struct timer_list *);
1194
extern void __net_exit afs_purge_servers(struct afs_net *);
1195
extern bool afs_check_server_record(struct afs_fs_cursor *, struct afs_server *);
1196

1197
/*
1198
 * server_list.c
1199
 */
1200 1201 1202 1203 1204
static inline struct afs_server_list *afs_get_serverlist(struct afs_server_list *slist)
{
	refcount_inc(&slist->usage);
	return slist;
}
1205

1206 1207 1208 1209 1210
extern void afs_put_serverlist(struct afs_net *, struct afs_server_list *);
extern struct afs_server_list *afs_alloc_server_list(struct afs_cell *, struct key *,
						     struct afs_vldb_entry *,
						     u8);
extern bool afs_annotate_server_list(struct afs_server_list *, struct afs_server_list *);
1211 1212

/*
1213
 * super.c
1214
 */
1215
extern int __init afs_fs_init(void);
1216
extern void afs_fs_exit(void);
1217 1218

/*
1219
 * vlclient.c
1220
 */
1221 1222 1223
extern struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *,
							 const char *, int);
extern struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *, const uuid_t *);
1224 1225
extern int afs_vl_get_capabilities(struct afs_net *, struct afs_addr_cursor *, struct key *,
				   struct afs_vlserver *, unsigned int, bool);
1226 1227
extern struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *, const uuid_t *);

1228 1229 1230 1231 1232 1233 1234
/*
 * vl_probe.c
 */
extern void afs_vlserver_probe_result(struct afs_call *);
extern int afs_send_vl_probes(struct afs_net *, struct key *, struct afs_vlserver_list *);
extern int afs_wait_for_vl_probes(struct afs_vlserver_list *, unsigned long);

1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
/*
 * vl_rotate.c
 */
extern bool afs_begin_vlserver_operation(struct afs_vl_cursor *,
					 struct afs_cell *, struct key *);
extern bool afs_select_vlserver(struct afs_vl_cursor *);
extern bool afs_select_current_vlserver(struct afs_vl_cursor *);
extern int afs_end_vlserver_operation(struct afs_vl_cursor *);

/*
 * vlserver_list.c
 */
static inline struct afs_vlserver *afs_get_vlserver(struct afs_vlserver *vlserver)
{
	atomic_inc(&vlserver->usage);
	return vlserver;
}

static inline struct afs_vlserver_list *afs_get_vlserverlist(struct afs_vlserver_list *vllist)
{
	if (vllist)
		atomic_inc(&vllist->usage);
	return vllist;
}

extern struct afs_vlserver *afs_alloc_vlserver(const char *, size_t, unsigned short);
extern void afs_put_vlserver(struct afs_net *, struct afs_vlserver *);
extern struct afs_vlserver_list *afs_alloc_vlserver_list(unsigned int);
extern void afs_put_vlserverlist(struct afs_net *, struct afs_vlserver_list *);
extern struct afs_vlserver_list *afs_extract_vlserver_list(struct afs_cell *,
							   const void *, size_t);
1266 1267 1268 1269

/*
 * volume.c
 */
1270
static inline struct afs_volume *__afs_get_volume(struct afs_volume *volume)
1271 1272 1273 1274 1275
{
	if (volume)
		atomic_inc(&volume->usage);
	return volume;
}
1276

1277 1278 1279
extern struct afs_volume *afs_create_volume(struct afs_mount_params *);
extern void afs_activate_volume(struct afs_volume *);
extern void afs_deactivate_volume(struct afs_volume *);
1280
extern void afs_put_volume(struct afs_cell *, struct afs_volume *);
1281
extern int afs_check_volume_status(struct afs_volume *, struct key *);
1282

1283 1284 1285 1286
/*
 * write.c
 */
extern int afs_set_page_dirty(struct page *);
Nick Piggin's avatar
Nick Piggin committed
1287 1288 1289 1290 1291 1292
extern int afs_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata);
extern int afs_write_end(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned copied,
			struct page *page, void *fsdata);
1293 1294 1295
extern int afs_writepage(struct page *, struct writeback_control *);
extern int afs_writepages(struct address_space *, struct writeback_control *);
extern void afs_pages_written_back(struct afs_vnode *, struct afs_call *);
Al Viro's avatar
Al Viro committed
1296
extern ssize_t afs_file_write(struct kiocb *, struct iov_iter *);
1297
extern int afs_fsync(struct file *, loff_t, loff_t, int);
1298
extern vm_fault_t afs_page_mkwrite(struct vm_fault *vmf);
1299 1300
extern void afs_prune_wb_keys(struct afs_vnode *);
extern int afs_launder_page(struct page *);
1301

David Howells's avatar
David Howells committed
1302 1303 1304 1305 1306
/*
 * xattr.c
 */
extern const struct xattr_handler *afs_xattr_handlers[];
extern ssize_t afs_listxattr(struct dentry *, char *, size_t);
1307

1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
/*
 * yfsclient.c
 */
extern int yfs_fs_fetch_file_status(struct afs_fs_cursor *, struct afs_volsync *, bool);
extern int yfs_fs_fetch_data(struct afs_fs_cursor *, struct afs_read *);
extern int yfs_fs_create_file(struct afs_fs_cursor *, const char *, umode_t, u64,
			      struct afs_fid *, struct afs_file_status *, struct afs_callback *);
extern int yfs_fs_make_dir(struct afs_fs_cursor *, const char *, umode_t, u64,
			 struct afs_fid *, struct afs_file_status *, struct afs_callback *);
extern int yfs_fs_remove_file2(struct afs_fs_cursor *, struct afs_vnode *, const char *, u64);
extern int yfs_fs_remove(struct afs_fs_cursor *, struct afs_vnode *, const char *, bool, u64);
extern int yfs_fs_link(struct afs_fs_cursor *, struct afs_vnode *, const char *, u64);
extern int yfs_fs_symlink(struct afs_fs_cursor *, const char *, const char *, u64,
			  struct afs_fid *, struct afs_file_status *);
extern int yfs_fs_rename(struct afs_fs_cursor *, const char *,
			 struct afs_vnode *, const char *, u64, u64);
extern int yfs_fs_store_data(struct afs_fs_cursor *, struct address_space *,
			     pgoff_t, pgoff_t, unsigned, unsigned);
extern int yfs_fs_setattr(