internal.h 36.8 KB
Newer Older
D
David Howells 已提交
1
/* internal AFS stuff
L
Linus Torvalds 已提交
2
 *
3
 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
15 16
#include <linux/fs.h>
#include <linux/pagemap.h>
17
#include <linux/rxrpc.h>
D
David Howells 已提交
18
#include <linux/key.h>
A
Alexey Dobriyan 已提交
19
#include <linux/workqueue.h>
A
Andrew Morton 已提交
20
#include <linux/sched.h>
C
Christoph Hellwig 已提交
21
#include <linux/fscache.h>
22
#include <linux/backing-dev.h>
23
#include <linux/uuid.h>
24
#include <net/net_namespace.h>
25
#include <net/af_rxrpc.h>
A
Andrew Morton 已提交
26

27 28 29 30 31
#include "afs.h"
#include "afs_vl.h"

#define AFS_CELL_MAX_ADDRS 15

32
struct pagevec;
33 34
struct afs_call;

D
David Howells 已提交
35 36 37
struct afs_mount_params {
	bool			rwpath;		/* T if the parent should be considered R/W */
	bool			force;		/* T to force cell type */
38
	bool			autocell;	/* T if set auto mount operation */
D
David Howells 已提交
39 40 41
	afs_voltype_t		type;		/* type of volume requested */
	int			volnamesz;	/* size of volume name */
	const char		*volname;	/* name of volume to mount */
42
	struct afs_net		*net;		/* Network namespace in effect */
D
David Howells 已提交
43 44 45 46 47
	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 */
};

48 49 50 51 52
struct afs_iget_data {
	struct afs_fid		fid;
	struct afs_volume	*volume;	/* volume on which resides */
};

D
David Howells 已提交
53
enum afs_call_state {
54 55 56 57 58 59 60 61
	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 */
D
David Howells 已提交
62
};
63

D
David Howells 已提交
64 65 66 67 68 69
/*
 * List of server addresses.
 */
struct afs_addr_list {
	struct rcu_head		rcu;		/* Must be first */
	refcount_t		usage;
70
	u32			version;	/* Version */
D
David Howells 已提交
71 72
	unsigned short		nr_addrs;
	unsigned short		index;		/* Address currently in use */
73
	unsigned short		nr_ipv4;	/* Number of IPv4 addresses */
74 75
	unsigned long		probed;		/* Mask of servers that have been probed */
	unsigned long		yfs;		/* Mask of servers that are YFS */
D
David Howells 已提交
76 77 78
	struct sockaddr_rxrpc	addrs[];
};

79 80 81 82 83 84
/*
 * a record of an in-progress RxRPC call
 */
struct afs_call {
	const struct afs_call_type *type;	/* type of call */
	wait_queue_head_t	waitq;		/* processes awaiting completion */
85
	struct work_struct	async_work;	/* async I/O processor */
86 87 88
	struct work_struct	work;		/* actual work processor */
	struct rxrpc_call	*rxcall;	/* RxRPC call handle */
	struct key		*key;		/* security for this call */
89
	struct afs_net		*net;		/* The network namespace */
90
	struct afs_server	*cm_server;	/* Server affected by incoming CM call */
91
	struct afs_cb_interest	*cbi;		/* Callback interest for server used */
92
	void			*request;	/* request data (first part) */
93
	struct address_space	*mapping;	/* Pages being written from */
94
	void			*buffer;	/* reply receive buffer */
95
	void			*reply[4];	/* Where to put the reply */
96 97
	pgoff_t			first;		/* first page in mapping to deal with */
	pgoff_t			last;		/* last page in mapping to deal with */
98
	size_t			offset;		/* offset into received data store */
99
	atomic_t		usage;
D
David Howells 已提交
100
	enum afs_call_state	state;
101
	spinlock_t		state_lock;
102
	int			error;		/* error code */
103
	u32			abort_code;	/* Remote abort ID or 0 */
104 105
	unsigned		request_size;	/* size of request data */
	unsigned		reply_max;	/* maximum size of reply */
106
	unsigned		first_offset;	/* offset into mapping[first] */
107
	unsigned int		cb_break;	/* cb_break + cb_s_break before the call */
108 109 110 111
	union {
		unsigned	last_to;	/* amount of mapping[last] */
		unsigned	count2;		/* count used in unmarshalling */
	};
112 113
	unsigned char		unmarshall;	/* unmarshalling phase */
	bool			incoming;	/* T if incoming call */
114
	bool			send_pages;	/* T if data from mapping should be sent */
115
	bool			need_attention;	/* T if RxRPC poked us */
D
David Howells 已提交
116
	bool			async;		/* T if asynchronous */
117
	bool			ret_reply0;	/* T if should return reply[0] on success */
118
	bool			upgrade;	/* T to request service upgrade */
119
	u16			service_id;	/* Actual service ID (after upgrade) */
120
	u32			operation_ID;	/* operation ID for an incoming call */
121 122
	u32			count;		/* count for use in unmarshalling */
	__be32			tmp;		/* place to extract temporary data */
123
	afs_dataversion_t	store_version;	/* updated version expected from store */
124 125 126
};

struct afs_call_type {
D
David Howells 已提交
127
	const char *name;
128
	unsigned int op; /* Really enum afs_fs_operation */
D
David Howells 已提交
129

130 131 132
	/* deliver request or reply data to an call
	 * - returning an error will cause the call to be aborted
	 */
133
	int (*deliver)(struct afs_call *call);
134 135 136

	/* clean up a call */
	void (*destructor)(struct afs_call *call);
137 138 139

	/* Work function */
	void (*work)(struct work_struct *work);
140 141
};

142 143 144 145 146 147 148 149 150
/*
 * 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 */
};

151 152 153 154 155
/*
 * AFS open file information record.  Pointed to by file->private_data.
 */
struct afs_file {
	struct key		*key;		/* The key this file was opened with */
156
	struct afs_wb_key	*wb;		/* Writeback key record for this file */
157 158 159 160 161 162 163 164 165
};

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

	return af->key;
}

166 167 168 169 170
/*
 * Record of an outstanding read operation on a vnode.
 */
struct afs_read {
	loff_t			pos;		/* Where to start reading */
171
	loff_t			len;		/* How much we're asking for */
172
	loff_t			actual_len;	/* How much we're actually getting */
173
	loff_t			remain;		/* Amount remaining */
174 175 176 177 178 179 180
	atomic_t		usage;
	unsigned int		index;		/* Which page we're reading into */
	unsigned int		nr_pages;
	void (*page_done)(struct afs_call *, struct afs_read *);
	struct page		*pages[];
};

181 182 183 184 185
/*
 * AFS superblock private data
 * - there's one superblock per volume
 */
struct afs_super_info {
186
	struct afs_net		*net;		/* Network namespace */
187
	struct afs_cell		*cell;		/* The cell in which the volume resides */
188 189
	struct afs_volume	*volume;	/* volume record */
};
L
Linus Torvalds 已提交
190

191 192 193
static inline struct afs_super_info *AFS_FS_S(struct super_block *sb)
{
	return sb->s_fs_info;
L
Linus Torvalds 已提交
194 195
}

196 197
extern struct file_system_type afs_fs_type;

198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
/*
 * AFS network namespace record.
 */
struct afs_net {
	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 */
214
	struct rb_root		cells;
215
	struct afs_cell		*ws_cell;
216 217 218 219
	struct work_struct	cells_manager;
	struct timer_list	cells_timer;
	atomic_t		cells_outstanding;
	seqlock_t		cells_lock;
220

221
	spinlock_t		proc_cells_lock;
222 223
	struct list_head	proc_cells;

224 225 226 227 228 229 230 231
	/* 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 */
232

233 234 235
	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] */
236

237 238
	struct work_struct	fs_manager;
	struct timer_list	fs_timer;
D
David Howells 已提交
239
	atomic_t		servers_outstanding;
240

241 242 243
	/* File locking renewal management */
	struct mutex		lock_manager_mutex;

244 245 246 247 248 249
	/* Misc */
	struct proc_dir_entry	*proc_afs;		/* /proc/net/afs directory */
};

extern struct afs_net __afs_net;// Dummy AFS network namespace; TODO: replace with real netns

250 251 252 253 254 255 256 257 258
enum afs_cell_state {
	AFS_CELL_UNSET,
	AFS_CELL_ACTIVATING,
	AFS_CELL_ACTIVE,
	AFS_CELL_DEACTIVATING,
	AFS_CELL_INACTIVE,
	AFS_CELL_FAILED,
};

259
/*
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
 * 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.
275 276
 */
struct afs_cell {
277 278 279 280 281
	union {
		struct rcu_head	rcu;
		struct rb_node	net_node;	/* Node in net->cells */
	};
	struct afs_net		*net;
D
David Howells 已提交
282
	struct key		*anonymous_key;	/* anonymous user key for this cell */
283
	struct work_struct	manager;	/* Manager for init/deinit/dns */
284
	struct list_head	proc_link;	/* /proc cell list link */
D
David Howells 已提交
285 286
#ifdef CONFIG_AFS_FSCACHE
	struct fscache_cookie	*cache;		/* caching cookie */
287
#endif
288 289 290 291 292 293 294 295
	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 */
D
David Howells 已提交
296
#define AFS_CELL_FL_NO_LOOKUP_YET 4		/* Not completed first DNS lookup yet */
297 298 299
	enum afs_cell_state	state;
	short			error;

300 301 302
	/* Active fileserver interaction state. */
	struct list_head	proc_volumes;	/* procfs volume list */
	rwlock_t		proc_lock;
303

304
	/* VL server list. */
D
David Howells 已提交
305 306
	rwlock_t		vl_addrs_lock;	/* Lock on vl_addrs */
	struct afs_addr_list	__rcu *vl_addrs; /* List of VL servers */
307 308
	u8			name_len;	/* Length of name */
	char			name[64 + 1];	/* Cell name, case-flattened and NUL-padded */
309 310 311
};

/*
312 313 314
 * Cached VLDB entry.
 *
 * This is pointed to by cell->vldb_entries, indexed by name.
315
 */
316 317
struct afs_vldb_entry {
	afs_volid_t		vid[3];		/* Volume IDs for R/W, R/O and Bak volumes */
D
David Howells 已提交
318

319 320 321 322 323 324 325 326 327
	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];
328 329 330
#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) */
331 332 333 334
	short			error;
	u8			nr_servers;	/* Number of server records */
	u8			name_len;
	u8			name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
335 336 337
};

/*
338
 * Record of fileserver with which we're actively communicating.
339 340
 */
struct afs_server {
341 342 343 344 345 346 347 348 349 350 351 352 353 354
	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 */
355
	unsigned long		flags;
356 357 358 359 360 361 362 363 364
#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 */
	atomic_t		usage;
	u32			addr_version;	/* Address list version */
365 366

	/* file service access */
367
	rwlock_t		fs_lock;	/* access lock */
368 369

	/* callback promise management */
370 371 372 373 374 375 376 377 378 379 380 381 382 383
	struct list_head	cb_interests;	/* List of superblocks using this server */
	unsigned		cb_s_break;	/* Break-everything counter. */
	rwlock_t		cb_break_lock;	/* Volume finding lock */
};

/*
 * Interest by a superblock on a server.
 */
struct afs_cb_interest {
	struct list_head	cb_link;	/* Link in server->cb_interests */
	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;
384 385 386
};

/*
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
 * Replaceable server list.
 */
struct afs_server_entry {
	struct afs_server	*server;
	struct afs_cb_interest	*cb_interest;
};

struct afs_server_list {
	refcount_t		usage;
	unsigned short		nr_servers;
	unsigned short		index;		/* Server currently in use */
	unsigned short		vnovol_mask;	/* Servers to be skipped due to VNOVOL */
	unsigned int		seq;		/* Set to ->servers_seq when installed */
	struct afs_server_entry	servers[];
};

/*
 * Live AFS volume management.
405 406
 */
struct afs_volume {
407
	afs_volid_t		vid;		/* volume ID */
408
	atomic_t		usage;
409 410 411 412 413 414 415 416 417 418
	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 */
D
David Howells 已提交
419 420
#ifdef CONFIG_AFS_FSCACHE
	struct fscache_cookie	*cache;		/* caching cookie */
421
#endif
422 423 424 425
	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 */

426
	afs_voltype_t		type;		/* type of volume */
427
	short			error;
428
	char			type_force;	/* force volume type (suppress R/O -> R/W) */
429 430
	u8			name_len;
	u8			name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
431 432
};

D
David Howells 已提交
433 434 435 436 437 438 439 440 441 442
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 */
};

443 444 445 446 447 448 449 450 451
/*
 * AFS inode private data
 */
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 */
D
David Howells 已提交
452 453
#ifdef CONFIG_AFS_FSCACHE
	struct fscache_cookie	*cache;		/* caching cookie */
454
#endif
D
David Howells 已提交
455
	struct afs_permits	*permit_cache;	/* cache of permits so far obtained */
456
	struct mutex		io_lock;	/* Lock for serialising I/O on this mutex */
457
	struct mutex		validate_lock;	/* lock for validating this vnode */
458
	spinlock_t		wb_lock;	/* lock for wb_keys */
459 460
	spinlock_t		lock;		/* waitqueue/flags lock */
	unsigned long		flags;
461
#define AFS_VNODE_CB_PROMISED	0		/* Set if vnode has a callback promise */
462
#define AFS_VNODE_UNSET		1		/* set if vnode attributes not yet set */
463
#define AFS_VNODE_DIR_MODIFIED	2		/* set if dir vnode's data modified */
464 465 466
#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 */
D
David Howells 已提交
467 468
#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 */
469

470
	struct list_head	wb_keys;	/* List of keys available for writeback */
D
David Howells 已提交
471 472 473
	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 */
D
David Howells 已提交
474 475 476
	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;
477

478
	/* outstanding callback notification on this file */
479 480 481 482 483 484
	struct afs_cb_interest	*cb_interest;	/* Server on which this resides */
	unsigned int		cb_s_break;	/* Mass break counter on ->server */
	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 */
485 486 487 488
	unsigned		cb_version;	/* callback version */
	afs_callback_type_t	cb_type;	/* type of callback */
};

D
David Howells 已提交
489 490 491 492 493
/*
 * cached security record for one user's attempt to access a vnode
 */
struct afs_permit {
	struct key		*key;		/* RxRPC ticket holding a security context */
D
David Howells 已提交
494
	afs_access_t		access;		/* CallerAccess value for this key */
D
David Howells 已提交
495 496 497
};

/*
D
David Howells 已提交
498 499
 * Immutable cache of CallerAccess records from attempts to access vnodes.
 * These may be shared between multiple vnodes.
D
David Howells 已提交
500 501
 */
struct afs_permits {
D
David Howells 已提交
502 503 504 505 506 507 508
	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 */
D
David Howells 已提交
509 510
};

511 512 513 514 515 516 517 518 519
/*
 * 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 */
};

D
David Howells 已提交
520 521 522 523 524 525
/*
 * Cursor for iterating over a server's address list.
 */
struct afs_addr_cursor {
	struct afs_addr_list	*alist;		/* Current address list (pins ref) */
	struct sockaddr_rxrpc	*addr;
526
	u32			abort_code;
D
David Howells 已提交
527 528 529 530 531 532 533 534 535 536 537 538
	unsigned short		start;		/* Starting point in alist->addrs[] */
	unsigned short		index;		/* Wrapping offset from start to current addr */
	short			error;
	bool			begun;		/* T if we've begun iteration */
	bool			responded;	/* T if the current address responded */
};

/*
 * Cursor for iterating over a set of fileservers.
 */
struct afs_fs_cursor {
	struct afs_addr_cursor	ac;
539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
	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 */
	unsigned int		cb_break;	/* cb_break + cb_s_break before the call */
	unsigned int		cb_break_2;	/* cb_break + cb_s_break (2nd vnode) */
	unsigned char		start;		/* Initial index in server list */
	unsigned char		index;		/* Number of servers tried beyond start */
	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, ... */
D
David Howells 已提交
554 555
};

556 557
#include <trace/events/afs.h>

558
/*****************************************************************************/
D
David Howells 已提交
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
/*
 * 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 *);
extern struct afs_addr_list *afs_parse_text_addrs(const char *, size_t, char,
						  unsigned short, unsigned short);
extern struct afs_addr_list *afs_dns_query(struct afs_cell *, time64_t *);
extern bool afs_iterate_addresses(struct afs_addr_cursor *);
extern int afs_end_cursor(struct afs_addr_cursor *);
extern int afs_set_vl_cursor(struct afs_addr_cursor *, struct afs_cell *);

579 580
extern void afs_merge_fs_addr4(struct afs_addr_list *, __be32, u16);
extern void afs_merge_fs_addr6(struct afs_addr_list *, __be32 *, u16);
581

D
David Howells 已提交
582 583 584 585 586 587 588 589 590 591 592 593 594 595
/*
 * 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

596 597 598 599
/*
 * callback.c
 */
extern void afs_init_callback_state(struct afs_server *);
600 601 602
extern void afs_break_callback(struct afs_vnode *);
extern void afs_break_callbacks(struct afs_server *, size_t,struct afs_callback[]);

603
extern int afs_register_server_cb_interest(struct afs_vnode *, struct afs_server_entry *);
604
extern void afs_put_cb_interest(struct afs_net *, struct afs_cb_interest *);
605
extern void afs_clear_callback_interests(struct afs_net *, struct afs_server_list *);
606 607 608 609 610 611

static inline struct afs_cb_interest *afs_get_cb_interest(struct afs_cb_interest *cbi)
{
	refcount_inc(&cbi->usage);
	return cbi;
}
612

L
Linus Torvalds 已提交
613 614 615
/*
 * cell.c
 */
616 617 618 619
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);
D
David Howells 已提交
620
extern struct afs_cell *afs_get_cell(struct afs_cell *);
621
extern void afs_put_cell(struct afs_net *, struct afs_cell *);
622 623
extern void afs_manage_cells(struct work_struct *);
extern void afs_cells_timer(struct timer_list *);
624
extern void __net_exit afs_cell_purge(struct afs_net *);
625 626 627 628 629 630

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

L
Linus Torvalds 已提交
631 632 633
/*
 * dir.c
 */
634
extern bool afs_dir_check_page(struct inode *, struct page *);
635
extern const struct inode_operations afs_dir_inode_operations;
A
Al Viro 已提交
636
extern const struct dentry_operations afs_fs_dentry_operations;
637
extern const struct file_operations afs_dir_file_operations;
L
Linus Torvalds 已提交
638 639 640 641

/*
 * file.c
 */
642
extern const struct address_space_operations afs_fs_aops;
643
extern const struct inode_operations afs_file_inode_operations;
D
David Howells 已提交
644 645
extern const struct file_operations afs_file_operations;

646 647
extern int afs_cache_wb_key(struct afs_vnode *, struct afs_file *);
extern void afs_put_wb_key(struct afs_wb_key *);
D
David Howells 已提交
648 649
extern int afs_open(struct inode *, struct file *);
extern int afs_release(struct inode *, struct file *);
650
extern int afs_fetch_data(struct afs_vnode *, struct key *, struct afs_read *);
651
extern int afs_page_filler(void *, struct page *);
652
extern void afs_put_read(struct afs_read *);
L
Linus Torvalds 已提交
653

D
David Howells 已提交
654 655 656
/*
 * flock.c
 */
657 658
extern struct workqueue_struct *afs_lock_manager;

D
David Howells 已提交
659 660 661 662 663
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 *);

664 665 666
/*
 * fsclient.c
 */
667 668 669 670 671 672 673 674 675 676 677
extern int afs_fs_fetch_file_status(struct afs_fs_cursor *, struct afs_volsync *);
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 *);
extern int afs_fs_create(struct afs_fs_cursor *, const char *, umode_t,
			 struct afs_fid *, struct afs_file_status *, struct afs_callback *);
extern int afs_fs_remove(struct afs_fs_cursor *, const char *, bool);
extern int afs_fs_link(struct afs_fs_cursor *, struct afs_vnode *, const char *);
extern int afs_fs_symlink(struct afs_fs_cursor *, const char *, const char *,
			  struct afs_fid *, struct afs_file_status *);
extern int afs_fs_rename(struct afs_fs_cursor *, const char *,
			 struct afs_vnode *, const char *);
678
extern int afs_fs_store_data(struct afs_fs_cursor *, struct address_space *,
679 680 681 682 683 684 685 686 687 688
			     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 *,
				   struct afs_addr_cursor *, struct key *);
689

L
Linus Torvalds 已提交
690 691 692
/*
 * inode.c
 */
693
extern int afs_fetch_status(struct afs_vnode *, struct key *);
694
extern int afs_iget5_test(struct inode *, void *);
695 696
extern struct inode *afs_iget_autocell(struct inode *, const char *, int,
				       struct key *);
D
David Howells 已提交
697
extern struct inode *afs_iget(struct super_block *, struct key *,
698
			      struct afs_fid *, struct afs_file_status *,
699 700
			      struct afs_callback *,
			      struct afs_cb_interest *);
D
David Howells 已提交
701
extern void afs_zap_data(struct afs_vnode *);
702
extern int afs_validate(struct afs_vnode *, struct key *);
703
extern int afs_getattr(const struct path *, struct kstat *, u32, unsigned int);
704
extern int afs_setattr(struct dentry *, struct iattr *);
705
extern void afs_evict_inode(struct inode *);
706
extern int afs_drop_inode(struct inode *);
L
Linus Torvalds 已提交
707 708 709 710

/*
 * main.c
 */
711
extern struct workqueue_struct *afs_wq;
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740

static inline struct afs_net *afs_d2net(struct dentry *dentry)
{
	return &__afs_net;
}

static inline struct afs_net *afs_i2net(struct inode *inode)
{
	return &__afs_net;
}

static inline struct afs_net *afs_v2net(struct afs_vnode *vnode)
{
	return &__afs_net;
}

static inline struct afs_net *afs_sock2net(struct sock *sk)
{
	return &__afs_net;
}

static inline struct afs_net *afs_get_net(struct afs_net *net)
{
	return net;
}

static inline void afs_put_net(struct afs_net *net)
{
}
L
Linus Torvalds 已提交
741

742 743 744 745 746
/*
 * misc.c
 */
extern int afs_abort_to_error(u32);

L
Linus Torvalds 已提交
747 748 749
/*
 * mntpt.c
 */
750
extern const struct inode_operations afs_mntpt_inode_operations;
751
extern const struct inode_operations afs_autocell_inode_operations;
752
extern const struct file_operations afs_mntpt_file_operations;
L
Linus Torvalds 已提交
753

754
extern struct vfsmount *afs_d_automount(struct path *);
755
extern void afs_mntpt_kill_timer(void);
L
Linus Torvalds 已提交
756

757 758 759 760 761
/*
 * netdevices.c
 */
extern int afs_get_ipv4_interfaces(struct afs_interface *, size_t, bool);

L
Linus Torvalds 已提交
762 763 764
/*
 * proc.c
 */
765 766 767 768
extern int __net_init afs_proc_init(struct afs_net *);
extern void __net_exit afs_proc_cleanup(struct afs_net *);
extern int afs_proc_cell_setup(struct afs_net *, struct afs_cell *);
extern void afs_proc_cell_remove(struct afs_net *, struct afs_cell *);
L
Linus Torvalds 已提交
769

770 771 772 773 774 775 776 777 778
/*
 * 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 *);

779 780 781
/*
 * rxrpc.c
 */
782
extern struct workqueue_struct *afs_async_calls;
783

784 785 786
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 *);
787 788
extern void afs_put_call(struct afs_call *);
extern int afs_queue_call_work(struct afs_call *);
D
David Howells 已提交
789
extern long afs_make_call(struct afs_addr_cursor *, struct afs_call *, gfp_t, bool);
790 791
extern struct afs_call *afs_alloc_flat_call(struct afs_net *,
					    const struct afs_call_type *,
792 793 794
					    size_t, size_t);
extern void afs_flat_call_destructor(struct afs_call *);
extern void afs_send_empty_reply(struct afs_call *);
795
extern void afs_send_simple_reply(struct afs_call *, const void *, size_t);
796
extern int afs_extract_data(struct afs_call *, void *, size_t, bool);
797

798
static inline int afs_transfer_reply(struct afs_call *call)
799
{
800
	return afs_extract_data(call, call->buffer, call->reply_max, false);
801 802
}

803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
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);
}

D
David Howells 已提交
846 847 848
/*
 * security.c
 */
D
David Howells 已提交
849
extern void afs_put_permits(struct afs_permits *);
D
David Howells 已提交
850
extern void afs_clear_permits(struct afs_vnode *);
D
David Howells 已提交
851
extern void afs_cache_permit(struct afs_vnode *, struct key *, unsigned int);
D
David Howells 已提交
852
extern void afs_zap_permits(struct rcu_head *);
D
David Howells 已提交
853
extern struct key *afs_request_key(struct afs_cell *);
D
David Howells 已提交
854
extern int afs_check_permit(struct afs_vnode *, struct key *, afs_access_t *);
855
extern int afs_permission(struct inode *, int);
D
David Howells 已提交
856
extern void __exit afs_clean_up_permit_cache(void);
D
David Howells 已提交
857

858 859 860 861 862
/*
 * server.c
 */
extern spinlock_t afs_server_peer_lock;

863 864 865 866 867
static inline struct afs_server *afs_get_server(struct afs_server *server)
{
	atomic_inc(&server->usage);
	return server;
}
868

869 870
extern struct afs_server *afs_find_server(struct afs_net *,
					  const struct sockaddr_rxrpc *);
871 872
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 *);
873
extern void afs_put_server(struct afs_net *, struct afs_server *);
874 875
extern void afs_manage_servers(struct work_struct *);
extern void afs_servers_timer(struct timer_list *);
876
extern void __net_exit afs_purge_servers(struct afs_net *);
877 878
extern bool afs_probe_fileserver(struct afs_fs_cursor *);
extern bool afs_check_server_record(struct afs_fs_cursor *, struct afs_server *);
879

D
David Howells 已提交
880
/*
881
 * server_list.c
D
David Howells 已提交
882
 */
883 884 885 886 887
static inline struct afs_server_list *afs_get_serverlist(struct afs_server_list *slist)
{
	refcount_inc(&slist->usage);
	return slist;
}
D
David Howells 已提交
888

889 890 891 892 893
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 *);
894 895

/*
896
 * super.c
897
 */
898 899
extern int __init afs_fs_init(void);
extern void __exit afs_fs_exit(void);
900 901

/*
902
 * vlclient.c
903
 */
904 905 906 907 908
extern struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_net *,
							 struct afs_addr_cursor *,
							 struct key *, const char *, int);
extern struct afs_addr_list *afs_vl_get_addrs_u(struct afs_net *, struct afs_addr_cursor *,
						struct key *, const uuid_t *);
909 910 911
extern int afs_vl_get_capabilities(struct afs_net *, struct afs_addr_cursor *, struct key *);
extern struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_net *, struct afs_addr_cursor *,
						     struct key *, const uuid_t *);
912 913 914 915

/*
 * volume.c
 */
916
static inline struct afs_volume *__afs_get_volume(struct afs_volume *volume)
917 918 919 920 921
{
	if (volume)
		atomic_inc(&volume->usage);
	return volume;
}
922

923 924 925
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 *);
926
extern void afs_put_volume(struct afs_cell *, struct afs_volume *);
927
extern int afs_check_volume_status(struct afs_volume *, struct key *);
928

929 930 931 932
/*
 * write.c
 */
extern int afs_set_page_dirty(struct page *);
N
Nick Piggin 已提交
933 934 935 936 937 938
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);
939 940 941
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 *);
A
Al Viro 已提交
942
extern ssize_t afs_file_write(struct kiocb *, struct iov_iter *);
943
extern int afs_flush(struct file *, fl_owner_t);
944
extern int afs_fsync(struct file *, loff_t, loff_t, int);
945
extern int afs_page_mkwrite(struct vm_fault *);
946 947
extern void afs_prune_wb_keys(struct afs_vnode *);
extern int afs_launder_page(struct page *);
948

D
David Howells 已提交
949 950 951 952 953
/*
 * xattr.c
 */
extern const struct xattr_handler *afs_xattr_handlers[];
extern ssize_t afs_listxattr(struct dentry *, char *, size_t);
954

955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986

/*
 * Miscellaneous inline functions.
 */
static inline struct afs_vnode *AFS_FS_I(struct inode *inode)
{
	return container_of(inode, struct afs_vnode, vfs_inode);
}

static inline struct inode *AFS_VNODE_TO_I(struct afs_vnode *vnode)
{
	return &vnode->vfs_inode;
}

static inline void afs_vnode_commit_status(struct afs_fs_cursor *fc,
					   struct afs_vnode *vnode,
					   unsigned int cb_break)
{
	if (fc->ac.error == 0)
		afs_cache_permit(vnode, fc->key, cb_break);
}

static inline void afs_check_for_remote_deletion(struct afs_fs_cursor *fc,
						 struct afs_vnode *vnode)
{
	if (fc->ac.error == -ENOENT) {
		set_bit(AFS_VNODE_DELETED, &vnode->flags);
		afs_break_callback(vnode);
	}
}


987 988 989 990 991 992 993
/*****************************************************************************/
/*
 * debug tracing
 */
extern unsigned afs_debug;

#define dbgprintk(FMT,...) \
994
	printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
995

996 997
#define kenter(FMT,...)	dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
#define kleave(FMT,...)	dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
#define kdebug(FMT,...)	dbgprintk("    "FMT ,##__VA_ARGS__)


#if defined(__KDEBUG)
#define _enter(FMT,...)	kenter(FMT,##__VA_ARGS__)
#define _leave(FMT,...)	kleave(FMT,##__VA_ARGS__)
#define _debug(FMT,...)	kdebug(FMT,##__VA_ARGS__)

#elif defined(CONFIG_AFS_DEBUG)
#define AFS_DEBUG_KENTER	0x01
#define AFS_DEBUG_KLEAVE	0x02
#define AFS_DEBUG_KDEBUG	0x04

#define _enter(FMT,...)					\
do {							\
	if (unlikely(afs_debug & AFS_DEBUG_KENTER))	\
		kenter(FMT,##__VA_ARGS__);		\
} while (0)

#define _leave(FMT,...)					\
do {							\
	if (unlikely(afs_debug & AFS_DEBUG_KLEAVE))	\
		kleave(FMT,##__VA_ARGS__);		\
} while (0)

#define _debug(FMT,...)					\
do {							\
	if (unlikely(afs_debug & AFS_DEBUG_KDEBUG))	\
		kdebug(FMT,##__VA_ARGS__);		\
} while (0)

#else
1030 1031 1032
#define _enter(FMT,...)	no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
#define _leave(FMT,...)	no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
#define _debug(FMT,...)	no_printk("    "FMT ,##__VA_ARGS__)
1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
#endif

/*
 * debug assertion checking
 */
#if 1 // defined(__KDEBUGALL)

#define ASSERT(X)						\
do {								\
	if (unlikely(!(X))) {					\
		printk(KERN_ERR "\n");				\
		printk(KERN_ERR "AFS: Assertion failed\n");	\
		BUG();						\
	}							\
} while(0)

#define ASSERTCMP(X, OP, Y)						\
do {									\
	if (unlikely(!((X) OP (Y)))) {					\
		printk(KERN_ERR "\n");					\
		printk(KERN_ERR "AFS: Assertion failed\n");		\
		printk(KERN_ERR "%lu " #OP " %lu is false\n",		\
		       (unsigned long)(X), (unsigned long)(Y));		\
		printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n",	\
		       (unsigned long)(X), (unsigned long)(Y));		\
		BUG();							\
	}								\
} while(0)

D
David Howells 已提交
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
#define ASSERTRANGE(L, OP1, N, OP2, H)					\
do {									\
	if (unlikely(!((L) OP1 (N)) || !((N) OP2 (H)))) {		\
		printk(KERN_ERR "\n");					\
		printk(KERN_ERR "AFS: Assertion failed\n");		\
		printk(KERN_ERR "%lu "#OP1" %lu "#OP2" %lu is false\n",	\
		       (unsigned long)(L), (unsigned long)(N),		\
		       (unsigned long)(H));				\
		printk(KERN_ERR "0x%lx "#OP1" 0x%lx "#OP2" 0x%lx is false\n", \
		       (unsigned long)(L), (unsigned long)(N),		\
		       (unsigned long)(H));				\
		BUG();							\
	}								\
} while(0)

1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108
#define ASSERTIF(C, X)						\
do {								\
	if (unlikely((C) && !(X))) {				\
		printk(KERN_ERR "\n");				\
		printk(KERN_ERR "AFS: Assertion failed\n");	\
		BUG();						\
	}							\
} while(0)

#define ASSERTIFCMP(C, X, OP, Y)					\
do {									\
	if (unlikely((C) && !((X) OP (Y)))) {				\
		printk(KERN_ERR "\n");					\
		printk(KERN_ERR "AFS: Assertion failed\n");		\
		printk(KERN_ERR "%lu " #OP " %lu is false\n",		\
		       (unsigned long)(X), (unsigned long)(Y));		\
		printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n",	\
		       (unsigned long)(X), (unsigned long)(Y));		\
		BUG();							\
	}								\
} while(0)

#else

#define ASSERT(X)				\
do {						\
} while(0)

#define ASSERTCMP(X, OP, Y)			\
do {						\
} while(0)

D
David Howells 已提交
1109 1110 1111 1112
#define ASSERTRANGE(L, OP1, N, OP2, H)		\
do {						\
} while(0)

1113 1114 1115 1116 1117 1118 1119 1120 1121
#define ASSERTIF(C, X)				\
do {						\
} while(0)

#define ASSERTIFCMP(C, X, OP, Y)		\
do {						\
} while(0)

#endif /* __KDEBUGALL */