internal.h 21.1 KB
Newer Older
D
David Howells 已提交
1 2 3 4
/*
 * NFS internal definitions
 */

5
#include "nfs4_fs.h"
D
David Howells 已提交
6
#include <linux/mount.h>
7
#include <linux/security.h>
8
#include <linux/crc32.h>
9
#include <linux/nfs_page.h>
D
David Howells 已提交
10

11 12
#define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)

13 14 15 16 17 18 19 20 21 22
struct nfs_string;

/* Maximum number of readahead requests
 * FIXME: this should really be a sysctl so that users may tune it to suit
 *        their needs. People that do NFS over a slow network, might for
 *        instance want to reduce it to something closer to 1 for improved
 *        interactive response.
 */
#define NFS_MAX_READAHEAD	(RPC_DEF_SLOT_TABLE - 1)

23 24 25 26 27 28
static inline void nfs_attr_check_mountpoint(struct super_block *parent, struct nfs_fattr *fattr)
{
	if (!nfs_fsid_equal(&NFS_SB(parent)->fsid, &fattr->fsid))
		fattr->valid |= NFS_ATTR_FATTR_MOUNTPOINT;
}

29 30 31 32 33 34 35 36 37
static inline int nfs_attr_use_mounted_on_fileid(struct nfs_fattr *fattr)
{
	if (((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) == 0) ||
	    (((fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT) == 0) &&
	     ((fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) == 0)))
		return 0;
	return 1;
}

D
David Howells 已提交
38 39 40 41 42 43 44
struct nfs_clone_mount {
	const struct super_block *sb;
	const struct dentry *dentry;
	struct nfs_fh *fh;
	struct nfs_fattr *fattr;
	char *hostname;
	char *mnt_path;
45 46
	struct sockaddr *addr;
	size_t addrlen;
D
David Howells 已提交
47 48 49
	rpc_authflavor_t authflavor;
};

50 51 52 53 54 55
/*
 * Note: RFC 1813 doesn't limit the number of auth flavors that
 * a server can return, so make something up.
 */
#define NFS_MAX_SECFLAVORS	(12)

56 57 58 59 60
/*
 * Value used if the user did not specify a port value.
 */
#define NFS_UNSPEC_PORT		(-1)

B
Bryan Schumaker 已提交
61 62 63 64 65 66
/*
 * Maximum number of pages that readdir can use for creating
 * a vmapped array of pages.
 */
#define NFS_MAX_READDIR_PAGES 8

67 68 69 70 71
struct nfs_client_initdata {
	unsigned long init_flags;
	const char *hostname;
	const struct sockaddr *addr;
	size_t addrlen;
72
	struct nfs_subversion *nfs_mod;
73 74 75 76 77
	int proto;
	u32 minorversion;
	struct net *net;
};

78 79 80 81 82
/*
 * In-kernel mount arguments
 */
struct nfs_parsed_mount_data {
	int			flags;
83 84 85
	unsigned int		rsize, wsize;
	unsigned int		timeo, retrans;
	unsigned int		acregmin, acregmax,
86
				acdirmin, acdirmax;
87
	unsigned int		namlen;
88
	unsigned int		options;
89
	unsigned int		bsize;
90 91
	struct nfs_auth_info	auth_info;
	rpc_authflavor_t	selected_flavor;
92
	char			*client_address;
93
	unsigned int		version;
94
	unsigned int		minorversion;
95
	char			*fscache_uniq;
96
	bool			need_mount;
97 98

	struct {
99 100
		struct sockaddr_storage	address;
		size_t			addrlen;
101
		char			*hostname;
102
		u32			version;
103
		int			port;
104
		unsigned short		protocol;
105 106 107
	} mount_server;

	struct {
108 109
		struct sockaddr_storage	address;
		size_t			addrlen;
110 111
		char			*hostname;
		char			*export_path;
112
		int			port;
113
		unsigned short		protocol;
114
	} nfs_server;
115 116

	struct security_mnt_opts lsm_opts;
117
	struct net		*net;
118 119
};

120
/* mount_clnt.c */
121 122 123 124 125 126 127 128
struct nfs_mount_request {
	struct sockaddr		*sap;
	size_t			salen;
	char			*hostname;
	char			*dirpath;
	u32			version;
	unsigned short		protocol;
	struct nfs_fh		*fh;
129
	int			noresvport;
130 131
	unsigned int		*auth_flav_len;
	rpc_authflavor_t	*auth_flavs;
132
	struct net		*net;
133 134
};

135 136 137 138 139 140 141 142
struct nfs_mount_info {
	void (*fill_super)(struct super_block *, struct nfs_mount_info *);
	int (*set_security)(struct super_block *, struct dentry *, struct nfs_mount_info *);
	struct nfs_parsed_mount_data *parsed;
	struct nfs_clone_mount *cloned;
	struct nfs_fh *mntfh;
};

143
extern int nfs_mount(struct nfs_mount_request *info);
144
extern void nfs_umount(const struct nfs_mount_request *info);
145

146
/* client.c */
147
extern const struct rpc_program nfs_program;
148
extern void nfs_clients_init(struct net *net);
149
extern struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *);
150
int nfs_create_rpc_client(struct nfs_client *, const struct rpc_timeout *, rpc_authflavor_t);
151 152 153 154 155
struct nfs_client *nfs_get_client(const struct nfs_client_initdata *,
				  const struct rpc_timeout *, const char *,
				  rpc_authflavor_t);
int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *, struct nfs_fattr *);
void nfs_server_insert_lists(struct nfs_server *);
C
Chuck Lever 已提交
156
void nfs_server_remove_lists(struct nfs_server *);
157 158 159 160 161
void nfs_init_timeout_values(struct rpc_timeout *, int, unsigned int, unsigned int);
int nfs_init_server_rpcclient(struct nfs_server *, const struct rpc_timeout *t,
		rpc_authflavor_t);
struct nfs_server *nfs_alloc_server(void);
void nfs_server_copy_userdata(struct nfs_server *, struct nfs_server *);
162

163
extern void nfs_cleanup_cb_ident_idr(struct net *);
164
extern void nfs_put_client(struct nfs_client *);
165
extern void nfs_free_client(struct nfs_client *);
166
extern struct nfs_client *nfs4_find_client_ident(struct net *, int);
167
extern struct nfs_client *
168
nfs4_find_client_sessionid(struct net *, const struct sockaddr *,
169
				struct nfs4_sessionid *, u32);
170
extern struct nfs_server *nfs_create_server(struct nfs_mount_info *,
171
					struct nfs_subversion *);
172
extern struct nfs_server *nfs4_create_server(
173 174
					struct nfs_mount_info *,
					struct nfs_subversion *);
175 176
extern struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *,
						      struct nfs_fh *);
C
Chuck Lever 已提交
177
extern int nfs4_update_server(struct nfs_server *server, const char *hostname,
178 179
					struct sockaddr *sap, size_t salen,
					struct net *net);
180 181 182
extern void nfs_free_server(struct nfs_server *server);
extern struct nfs_server *nfs_clone_server(struct nfs_server *,
					   struct nfs_fh *,
183 184
					   struct nfs_fattr *,
					   rpc_authflavor_t);
185
extern int nfs_wait_client_init_complete(const struct nfs_client *clp);
186
extern void nfs_mark_client_ready(struct nfs_client *clp, int state);
A
Andy Adamson 已提交
187 188
extern struct nfs_client *nfs4_set_ds_client(struct nfs_client* mds_clp,
					     const struct sockaddr *ds_addr,
189 190
					     int ds_addrlen, int ds_proto,
					     unsigned int ds_timeo,
191
					     unsigned int ds_retrans,
192
					     u32 minor_version,
193
					     rpc_authflavor_t au_flavor);
194 195
extern struct rpc_clnt *nfs4_find_or_create_ds_client(struct nfs_client *,
						struct inode *);
P
Peng Tao 已提交
196 197 198 199
extern struct nfs_client *nfs3_set_ds_client(struct nfs_client *mds_clp,
			const struct sockaddr *ds_addr, int ds_addrlen,
			int ds_proto, unsigned int ds_timeo,
			unsigned int ds_retrans, rpc_authflavor_t au_flavor);
200 201 202
#ifdef CONFIG_PROC_FS
extern int __init nfs_fs_proc_init(void);
extern void nfs_fs_proc_exit(void);
203 204
extern int nfs_fs_proc_net_init(struct net *net);
extern void nfs_fs_proc_net_exit(struct net *net);
205
#else
206 207 208 209 210 211 212
static inline int nfs_fs_proc_net_init(struct net *net)
{
	return 0;
}
static inline void nfs_fs_proc_net_exit(struct net *net)
{
}
213 214 215 216 217 218 219 220
static inline int nfs_fs_proc_init(void)
{
	return 0;
}
static inline void nfs_fs_proc_exit(void)
{
}
#endif
221

222 223 224 225
#ifdef CONFIG_NFS_V4_1
int nfs_sockaddr_match_ipaddr(const struct sockaddr *, const struct sockaddr *);
#endif

D
David Howells 已提交
226 227
/* callback_xdr.c */
extern struct svc_version nfs4_callback_version1;
228
extern struct svc_version nfs4_callback_version4;
D
David Howells 已提交
229

230
struct nfs_pageio_descriptor;
D
David Howells 已提交
231 232
/* pagelist.c */
extern int __init nfs_init_nfspagecache(void);
233
extern void nfs_destroy_nfspagecache(void);
D
David Howells 已提交
234
extern int __init nfs_init_readpagecache(void);
235
extern void nfs_destroy_readpagecache(void);
D
David Howells 已提交
236
extern int __init nfs_init_writepagecache(void);
237
extern void nfs_destroy_writepagecache(void);
D
David Howells 已提交
238 239

extern int __init nfs_init_directcache(void);
240
extern void nfs_destroy_directcache(void);
241 242 243 244
extern void nfs_pgheader_init(struct nfs_pageio_descriptor *desc,
			      struct nfs_pgio_header *hdr,
			      void (*release)(struct nfs_pgio_header *hdr));
void nfs_set_pgio_error(struct nfs_pgio_header *hdr, int error, loff_t pos);
245 246
int nfs_iocounter_wait(struct nfs_io_counter *c);

247
extern const struct nfs_pageio_ops nfs_pgio_rw_ops;
248 249
struct nfs_pgio_header *nfs_pgio_header_alloc(const struct nfs_rw_ops *);
void nfs_pgio_header_free(struct nfs_pgio_header *);
250
void nfs_pgio_data_destroy(struct nfs_pgio_header *);
251
int nfs_generic_pgio(struct nfs_pageio_descriptor *, struct nfs_pgio_header *);
252 253 254
int nfs_initiate_pgio(struct rpc_clnt *clnt, struct nfs_pgio_header *hdr,
		      struct rpc_cred *cred, const struct nfs_rpc_ops *rpc_ops,
		      const struct rpc_call_ops *call_ops, int how, int flags);
255
void nfs_free_request(struct nfs_page *req);
256 257
struct nfs_pgio_mirror *
nfs_pgio_current_mirror(struct nfs_pageio_descriptor *desc);
258

259 260 261 262 263
static inline void nfs_iocounter_init(struct nfs_io_counter *c)
{
	c->flags = 0;
	atomic_set(&c->io_count, 0);
}
D
David Howells 已提交
264

265 266 267 268 269 270
static inline bool nfs_pgio_has_mirroring(struct nfs_pageio_descriptor *desc)
{
	WARN_ON_ONCE(desc->pg_mirror_count < 1);
	return desc->pg_mirror_count > 1;
}

D
David Howells 已提交
271 272
/* nfs2xdr.c */
extern struct rpc_procinfo nfs_procedures[];
273 274
extern int nfs2_decode_dirent(struct xdr_stream *,
				struct nfs_entry *, int);
D
David Howells 已提交
275 276 277

/* nfs3xdr.c */
extern struct rpc_procinfo nfs3_procedures[];
278 279
extern int nfs3_decode_dirent(struct xdr_stream *,
				struct nfs_entry *, int);
D
David Howells 已提交
280 281

/* nfs4xdr.c */
B
Bryan Schumaker 已提交
282
#if IS_ENABLED(CONFIG_NFS_V4)
283 284
extern int nfs4_decode_dirent(struct xdr_stream *,
				struct nfs_entry *, int);
285
#endif
286 287 288
#ifdef CONFIG_NFS_V4_1
extern const u32 nfs41_maxread_overhead;
extern const u32 nfs41_maxwrite_overhead;
289
extern const u32 nfs41_maxgetdevinfo_overhead;
290
#endif
D
David Howells 已提交
291 292

/* nfs4proc.c */
B
Bryan Schumaker 已提交
293
#if IS_ENABLED(CONFIG_NFS_V4)
D
David Howells 已提交
294
extern struct rpc_procinfo nfs4_procedures[];
A
Andrew Morton 已提交
295
#endif
D
David Howells 已提交
296

297 298 299 300 301 302 303 304 305 306
#ifdef CONFIG_NFS_V4_SECURITY_LABEL
extern struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags);
static inline void nfs4_label_free(struct nfs4_label *label)
{
	if (label) {
		kfree(label->label);
		kfree(label);
	}
	return;
}
307 308 309 310 311 312

static inline void nfs_zap_label_cache_locked(struct nfs_inode *nfsi)
{
	if (nfs_server_capable(&nfsi->vfs_inode, NFS_CAP_SECURITY_LABEL))
		nfsi->cache_validity |= NFS_INO_INVALID_LABEL;
}
313 314 315
#else
static inline struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags) { return NULL; }
static inline void nfs4_label_free(void *label) {}
316 317 318
static inline void nfs_zap_label_cache_locked(struct nfs_inode *nfsi)
{
}
319 320
#endif /* CONFIG_NFS_V4_SECURITY_LABEL */

T
Trond Myklebust 已提交
321 322
/* proc.c */
void nfs_close_context(struct nfs_open_context *ctx, int is_sync);
323
extern struct nfs_client *nfs_init_client(struct nfs_client *clp,
324
			   const struct rpc_timeout *timeparms,
325
			   const char *ip_addr);
T
Trond Myklebust 已提交
326

327
/* dir.c */
328
extern void nfs_force_use_readdirplus(struct inode *dir);
329 330 331 332
extern unsigned long nfs_access_cache_count(struct shrinker *shrink,
					    struct shrink_control *sc);
extern unsigned long nfs_access_cache_scan(struct shrinker *shrink,
					   struct shrink_control *sc);
333 334 335 336 337 338 339 340 341
struct dentry *nfs_lookup(struct inode *, struct dentry *, unsigned int);
int nfs_create(struct inode *, struct dentry *, umode_t, bool);
int nfs_mkdir(struct inode *, struct dentry *, umode_t);
int nfs_rmdir(struct inode *, struct dentry *);
int nfs_unlink(struct inode *, struct dentry *);
int nfs_symlink(struct inode *, struct dentry *, const char *);
int nfs_link(struct dentry *, struct inode *, struct dentry *);
int nfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
int nfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
342

343 344 345 346
/* file.c */
int nfs_file_fsync_commit(struct file *, loff_t, loff_t, int);
loff_t nfs_file_llseek(struct file *, loff_t, int);
int nfs_file_flush(struct file *, fl_owner_t);
A
Al Viro 已提交
347
ssize_t nfs_file_read(struct kiocb *, struct iov_iter *);
348 349 350
ssize_t nfs_file_splice_read(struct file *, loff_t *, struct pipe_inode_info *,
			     size_t, unsigned int);
int nfs_file_mmap(struct file *, struct vm_area_struct *);
A
Al Viro 已提交
351
ssize_t nfs_file_write(struct kiocb *, struct iov_iter *);
352 353 354 355 356
int nfs_file_release(struct inode *, struct file *);
int nfs_lock(struct file *, int, struct file_lock *);
int nfs_flock(struct file *, int, struct file_lock *);
int nfs_check_flags(int);

D
David Howells 已提交
357
/* inode.c */
T
Trond Myklebust 已提交
358
extern struct workqueue_struct *nfsiod_workqueue;
D
David Howells 已提交
359 360
extern struct inode *nfs_alloc_inode(struct super_block *sb);
extern void nfs_destroy_inode(struct inode *);
361
extern int nfs_write_inode(struct inode *, struct writeback_control *);
362
extern int nfs_drop_inode(struct inode *);
363
extern void nfs_clear_inode(struct inode *);
364
extern void nfs_evict_inode(struct inode *);
365
void nfs_zap_acl_cache(struct inode *inode);
366
extern int nfs_wait_bit_killable(struct wait_bit_key *key);
D
David Howells 已提交
367 368

/* super.c */
369
extern const struct super_operations nfs_sops;
370
extern struct file_system_type nfs_fs_type;
371
extern struct file_system_type nfs_xdev_fs_type;
B
Bryan Schumaker 已提交
372
#if IS_ENABLED(CONFIG_NFS_V4)
373 374
extern struct file_system_type nfs4_xdev_fs_type;
extern struct file_system_type nfs4_referral_fs_type;
D
David Howells 已提交
375
#endif
376
bool nfs_auth_info_match(const struct nfs_auth_info *, rpc_authflavor_t);
B
Bryan Schumaker 已提交
377 378
struct dentry *nfs_try_mount(int, const char *, struct nfs_mount_info *,
			struct nfs_subversion *);
379 380 381
void nfs_initialise_sb(struct super_block *);
int nfs_set_sb_security(struct super_block *, struct dentry *, struct nfs_mount_info *);
int nfs_clone_sb_security(struct super_block *, struct dentry *, struct nfs_mount_info *);
382 383
struct dentry *nfs_fs_mount_common(struct nfs_server *, int, const char *,
				   struct nfs_mount_info *, struct nfs_subversion *);
384 385 386 387 388
struct dentry *nfs_fs_mount(struct file_system_type *, int, const char *, void *);
struct dentry * nfs_xdev_mount_common(struct file_system_type *, int,
		const char *, struct nfs_mount_info *);
void nfs_kill_super(struct super_block *);
void nfs_fill_super(struct super_block *, struct nfs_mount_info *);
389

D
David Howells 已提交
390
extern struct rpc_stat nfs_rpcstat;
391

D
David Howells 已提交
392 393
extern int __init register_nfs_fs(void);
extern void __exit unregister_nfs_fs(void);
394 395
extern void nfs_sb_active(struct super_block *sb);
extern void nfs_sb_deactive(struct super_block *sb);
D
David Howells 已提交
396 397

/* namespace.c */
398
#define NFS_PATH_CANONICAL 1
399
extern char *nfs_path(char **p, struct dentry *dentry,
400
		      char *buffer, ssize_t buflen, unsigned flags);
401
extern struct vfsmount *nfs_d_automount(struct path *path);
B
Bryan Schumaker 已提交
402 403 404 405
struct vfsmount *nfs_submount(struct nfs_server *, struct dentry *,
			      struct nfs_fh *, struct nfs_fattr *);
struct vfsmount *nfs_do_submount(struct dentry *, struct nfs_fh *,
				 struct nfs_fattr *, rpc_authflavor_t);
D
David Howells 已提交
406

407
/* getroot.c */
408 409
extern struct dentry *nfs_get_root(struct super_block *, struct nfs_fh *,
				   const char *);
B
Bryan Schumaker 已提交
410
#if IS_ENABLED(CONFIG_NFS_V4)
411 412
extern struct dentry *nfs4_get_root(struct super_block *, struct nfs_fh *,
				    const char *);
413

414
extern int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh, bool);
415
#endif
D
David Howells 已提交
416

417
struct nfs_pgio_completion_ops;
418
/* read.c */
419
extern void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio,
420
			struct inode *inode, bool force_mds,
421
			const struct nfs_pgio_completion_ops *compl_ops);
422
extern void nfs_read_prepare(struct rpc_task *task, void *calldata);
423
extern void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio);
424

425 426 427 428 429 430 431 432 433 434 435
/* super.c */
void nfs_clone_super(struct super_block *, struct nfs_mount_info *);
void nfs_umount_begin(struct super_block *);
int  nfs_statfs(struct dentry *, struct kstatfs *);
int  nfs_show_options(struct seq_file *, struct dentry *);
int  nfs_show_devname(struct seq_file *, struct dentry *);
int  nfs_show_path(struct seq_file *, struct dentry *);
int  nfs_show_stats(struct seq_file *, struct dentry *);
void nfs_put_super(struct super_block *);
int nfs_remount(struct super_block *sb, int *flags, char *raw_data);

436
/* write.c */
437
extern void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
438
			struct inode *inode, int ioflags, bool force_mds,
439
			const struct nfs_pgio_completion_ops *compl_ops);
440
extern void nfs_pageio_reset_write_mds(struct nfs_pageio_descriptor *pgio);
441
extern void nfs_commit_free(struct nfs_commit_data *p);
442
extern void nfs_write_prepare(struct rpc_task *task, void *calldata);
443 444 445
extern void nfs_commit_prepare(struct rpc_task *task, void *calldata);
extern int nfs_initiate_commit(struct rpc_clnt *clnt,
			       struct nfs_commit_data *data,
446
			       const struct nfs_rpc_ops *nfs_ops,
447
			       const struct rpc_call_ops *call_ops,
448
			       int how, int flags);
449
extern void nfs_init_commit(struct nfs_commit_data *data,
450
			    struct list_head *head,
451 452
			    struct pnfs_layout_segment *lseg,
			    struct nfs_commit_info *cinfo);
453 454
int nfs_scan_commit_list(struct list_head *src, struct list_head *dst,
			 struct nfs_commit_info *cinfo, int max);
455
unsigned long nfs_reqs_to_commit(struct nfs_commit_info *);
456 457 458 459
int nfs_scan_commit(struct inode *inode, struct list_head *dst,
		    struct nfs_commit_info *cinfo);
void nfs_mark_request_commit(struct nfs_page *req,
			     struct pnfs_layout_segment *lseg,
460 461
			     struct nfs_commit_info *cinfo,
			     u32 ds_commit_idx);
462
int nfs_write_need_commit(struct nfs_pgio_header *);
463 464
int nfs_generic_commit_list(struct inode *inode, struct list_head *head,
			    int how, struct nfs_commit_info *cinfo);
465
void nfs_retry_commit(struct list_head *page_list,
F
Fred Isaman 已提交
466
		      struct pnfs_layout_segment *lseg,
467 468
		      struct nfs_commit_info *cinfo,
		      u32 ds_commit_idx);
469
void nfs_commitdata_release(struct nfs_commit_data *data);
F
Fred Isaman 已提交
470 471 472 473 474 475 476
void nfs_request_add_commit_list(struct nfs_page *req, struct list_head *dst,
				 struct nfs_commit_info *cinfo);
void nfs_request_remove_commit_list(struct nfs_page *req,
				    struct nfs_commit_info *cinfo);
void nfs_init_cinfo(struct nfs_commit_info *cinfo,
		    struct inode *inode,
		    struct nfs_direct_req *dreq);
477 478
int nfs_key_timeout_notify(struct file *filp, struct inode *inode);
bool nfs_ctx_key_to_expire(struct nfs_open_context *ctx);
479
void nfs_pageio_stop_mirroring(struct nfs_pageio_descriptor *pgio);
480

481 482
#ifdef CONFIG_MIGRATION
extern int nfs_migrate_page(struct address_space *,
483
		struct page *, struct page *, enum migrate_mode);
484 485 486
#else
#define nfs_migrate_page NULL
#endif
487

488 489 490 491 492 493 494
/* unlink.c */
extern struct rpc_task *
nfs_async_rename(struct inode *old_dir, struct inode *new_dir,
		 struct dentry *old_dentry, struct dentry *new_dentry,
		 void (*complete)(struct rpc_task *, struct nfs_renamedata *));
extern int nfs_sillyrename(struct inode *dir, struct dentry *dentry);

495 496 497
/* direct.c */
void nfs_init_cinfo_from_dreq(struct nfs_commit_info *cinfo,
			      struct nfs_direct_req *dreq);
498 499 500 501
static inline void nfs_inode_dio_wait(struct inode *inode)
{
	inode_dio_wait(inode);
}
502
extern ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq);
503
extern void nfs_direct_set_resched_writes(struct nfs_direct_req *dreq);
504

A
Andy Adamson 已提交
505
/* nfs4proc.c */
506
extern void __nfs4_read_done_cb(struct nfs_pgio_header *);
507
extern struct nfs_client *nfs4_init_client(struct nfs_client *clp,
508
			    const struct rpc_timeout *timeparms,
509
			    const char *ip_addr);
510 511 512 513 514 515
extern int nfs40_walk_client_list(struct nfs_client *clp,
				struct nfs_client **result,
				struct rpc_cred *cred);
extern int nfs41_walk_client_list(struct nfs_client *clp,
				struct nfs_client **result,
				struct rpc_cred *cred);
A
Andy Adamson 已提交
516

D
David Howells 已提交
517 518 519
/*
 * Determine the device name as a string
 */
520
static inline char *nfs_devname(struct dentry *dentry,
521
				char *buffer, ssize_t buflen)
D
David Howells 已提交
522
{
523
	char *dummy;
524
	return nfs_path(&dummy, dentry, buffer, buflen, NFS_PATH_CANONICAL);
D
David Howells 已提交
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
}

/*
 * Determine the actual block size (and log2 thereof)
 */
static inline
unsigned long nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp)
{
	/* make sure blocksize is a power of two */
	if ((bsize & (bsize - 1)) || nrbitsp) {
		unsigned char	nrbits;

		for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--)
			;
		bsize = 1 << nrbits;
		if (nrbitsp)
			*nrbitsp = nrbits;
	}

	return bsize;
}

/*
 * Calculate the number of 512byte blocks used.
 */
550
static inline blkcnt_t nfs_calc_block_size(u64 tsize)
D
David Howells 已提交
551
{
552
	blkcnt_t used = (tsize + 511) >> 9;
D
David Howells 已提交
553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
	return (used > ULONG_MAX) ? ULONG_MAX : used;
}

/*
 * Compute and set NFS server blocksize
 */
static inline
unsigned long nfs_block_size(unsigned long bsize, unsigned char *nrbitsp)
{
	if (bsize < NFS_MIN_FILE_IO_SIZE)
		bsize = NFS_DEF_FILE_IO_SIZE;
	else if (bsize >= NFS_MAX_FILE_IO_SIZE)
		bsize = NFS_MAX_FILE_IO_SIZE;

	return nfs_block_bits(bsize, nrbitsp);
}

/*
 * Determine the maximum file size for a superblock
 */
static inline
void nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize)
{
	sb->s_maxbytes = (loff_t)maxfilesize;
	if (sb->s_maxbytes > MAX_LFS_FILESIZE || sb->s_maxbytes <= 0)
		sb->s_maxbytes = MAX_LFS_FILESIZE;
}
580 581 582 583 584 585 586

/*
 * Determine the number of bytes of data the page contains
 */
static inline
unsigned int nfs_page_length(struct page *page)
{
587
	loff_t i_size = i_size_read(page_file_mapping(page)->host);
588 589

	if (i_size > 0) {
590
		pgoff_t page_index = page_file_index(page);
591
		pgoff_t end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
592
		if (page_index < end_index)
593
			return PAGE_CACHE_SIZE;
594
		if (page_index == end_index)
595 596 597 598
			return ((i_size - 1) & ~PAGE_CACHE_MASK) + 1;
	}
	return 0;
}
599

600 601 602 603 604 605 606 607 608
/*
 * Convert a umode to a dirent->d_type
 */
static inline
unsigned char nfs_umode_to_dtype(umode_t mode)
{
	return (mode >> 12) & 15;
}

609 610 611 612 613 614 615 616 617 618
/*
 * Determine the number of pages in an array of length 'len' and
 * with a base offset of 'base'
 */
static inline
unsigned int nfs_page_array_len(unsigned int base, size_t len)
{
	return ((unsigned long)len + (unsigned long)base +
		PAGE_SIZE - 1) >> PAGE_SHIFT;
}
619

620 621 622 623 624 625 626 627 628 629 630 631
/*
 * Convert a struct timespec into a 64-bit change attribute
 *
 * This does approximately the same thing as timespec_to_ns(),
 * but for calculation efficiency, we multiply the seconds by
 * 1024*1024*1024.
 */
static inline
u64 nfs_timespec_to_change_attr(const struct timespec *ts)
{
	return ((u64)ts->tv_sec << 30) + ts->tv_nsec;
}
632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650

#ifdef CONFIG_CRC32
/**
 * nfs_fhandle_hash - calculate the crc32 hash for the filehandle
 * @fh - pointer to filehandle
 *
 * returns a crc32 hash for the filehandle that is compatible with
 * the one displayed by "wireshark".
 */
static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
{
	return ~crc32_le(0xFFFFFFFF, &fh->data[0], fh->size);
}
#else
static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
{
	return 0;
}
#endif