pnfs.h 23.0 KB
Newer Older
R
Ricardo Labiaga 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
/*
 *  pNFS client data structures.
 *
 *  Copyright (c) 2002
 *  The Regents of the University of Michigan
 *  All Rights Reserved
 *
 *  Dean Hildebrand <dhildebz@umich.edu>
 *
 *  Permission is granted to use, copy, create derivative works, and
 *  redistribute this software and such derivative works for any purpose,
 *  so long as the name of the University of Michigan is not used in
 *  any advertising or publicity pertaining to the use or distribution
 *  of this software without specific, written prior authorization. If
 *  the above copyright notice or any other identification of the
 *  University of Michigan is included in any copy of any portion of
 *  this software, then the disclaimer below must also be included.
 *
 *  This software is provided as is, without representation or warranty
 *  of any kind either express or implied, including without limitation
 *  the implied warranties of merchantability, fitness for a particular
 *  purpose, or noninfringement.  The Regents of the University of
 *  Michigan shall not be liable for any damages, including special,
 *  indirect, incidental, or consequential damages, with respect to any
 *  claim arising out of or in connection with the use of the software,
 *  even if it has been or is hereafter advised of the possibility of
 *  such damages.
 */

#ifndef FS_NFS_PNFS_H
#define FS_NFS_PNFS_H

33
#include <linux/nfs_fs.h>
34
#include <linux/nfs_page.h>
35
#include <linux/workqueue.h>
36

37 38
enum {
	NFS_LSEG_VALID = 0,	/* cleared when lseg is recalled/returned */
F
Fred Isaman 已提交
39
	NFS_LSEG_ROC,		/* roc bit received from server */
40
	NFS_LSEG_LAYOUTCOMMIT,	/* layoutcommit bit set for layoutcommit */
41
	NFS_LSEG_LAYOUTRETURN,	/* layoutreturn bit set for layoutreturn */
42 43
};

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
/* Individual ip address */
struct nfs4_pnfs_ds_addr {
	struct sockaddr_storage	da_addr;
	size_t			da_addrlen;
	struct list_head	da_node;  /* nfs4_pnfs_dev_hlist dev_dslist */
	char			*da_remotestr;	/* human readable addr+port */
};

struct nfs4_pnfs_ds {
	struct list_head	ds_node;  /* nfs4_pnfs_dev_hlist dev_dslist */
	char			*ds_remotestr;	/* comma sep list of addrs */
	struct list_head	ds_addrs;
	struct nfs_client	*ds_clp;
	atomic_t		ds_count;
	unsigned long		ds_state;
#define NFS4DS_CONNECTING	0	/* ds is establishing connection */
60 61
};

62
struct pnfs_layout_segment {
63
	struct list_head pls_list;
64
	struct list_head pls_lc_list;
65
	struct pnfs_layout_range pls_range;
66
	atomic_t pls_refcount;
67
	u32 pls_seq;
68
	unsigned long pls_flags;
69
	struct pnfs_layout_hdr *pls_layout;
70
	struct work_struct pls_work;
71 72
};

A
Andy Adamson 已提交
73 74 75
enum pnfs_try_status {
	PNFS_ATTEMPTED     = 0,
	PNFS_NOT_ATTEMPTED = 1,
76
	PNFS_TRY_AGAIN     = 2,
A
Andy Adamson 已提交
77 78
};

R
Ricardo Labiaga 已提交
79 80 81 82
#ifdef CONFIG_NFS_V4_1

#define LAYOUT_NFSV4_1_MODULE_PREFIX "nfs-layouttype4"

83 84 85 86 87 88 89 90 91 92 93
/*
 * Default data server connection timeout and retrans vaules.
 * Set by module parameters dataserver_timeo and dataserver_retrans.
 */
#define NFS4_DEF_DS_TIMEO   600 /* in tenths of a second */
#define NFS4_DEF_DS_RETRANS 5

/* error codes for internal use */
#define NFS4ERR_RESET_TO_MDS   12001
#define NFS4ERR_RESET_TO_PNFS  12002

94 95 96
enum {
	NFS_LAYOUT_RO_FAILED = 0,	/* get ro layout failed stop trying */
	NFS_LAYOUT_RW_FAILED,		/* get rw layout failed stop trying */
F
Fred Isaman 已提交
97
	NFS_LAYOUT_BULK_RECALL,		/* bulk recall affecting layout */
98
	NFS_LAYOUT_RETURN,		/* layoutreturn in progress */
99
	NFS_LAYOUT_RETURN_LOCK,		/* Serialise layoutreturn */
100
	NFS_LAYOUT_RETURN_REQUESTED,	/* Return this layout ASAP */
101
	NFS_LAYOUT_INVALID_STID,	/* layout stateid id is invalid */
102
	NFS_LAYOUT_FIRST_LAYOUTGET,	/* Serialize first layoutget */
103 104
};

B
Benny Halevy 已提交
105
enum layoutdriver_policy_flags {
106 107
	/* Should the pNFS client commit and return the layout upon truncate to
	 * a smaller size */
B
Benny Halevy 已提交
108
	PNFS_LAYOUTRET_ON_SETATTR	= 1 << 0,
109
	PNFS_LAYOUTRET_ON_ERROR		= 1 << 1,
110
	PNFS_READ_WHOLE_PAGE		= 1 << 2,
B
Benny Halevy 已提交
111 112
};

113 114
struct nfs4_deviceid_node;

R
Ricardo Labiaga 已提交
115 116
/* Per-layout driver specific registration structure */
struct pnfs_layoutdriver_type {
117 118 119 120
	struct list_head pnfs_tblid;
	const u32 id;
	const char *name;
	struct module *owner;
B
Benny Halevy 已提交
121
	unsigned flags;
122
	unsigned max_deviceinfo_size;
123

124 125 126
	int (*set_layoutdriver) (struct nfs_server *, const struct nfs_fh *);
	int (*clear_layoutdriver) (struct nfs_server *);

127 128 129
	struct pnfs_layout_hdr * (*alloc_layout_hdr) (struct inode *inode, gfp_t gfp_flags);
	void (*free_layout_hdr) (struct pnfs_layout_hdr *);

130
	struct pnfs_layout_segment * (*alloc_lseg) (struct pnfs_layout_hdr *layoutid, struct nfs4_layoutget_res *lgr, gfp_t gfp_flags);
131
	void (*free_lseg) (struct pnfs_layout_segment *lseg);
132 133 134
	void (*add_lseg) (struct pnfs_layout_hdr *layoutid,
			struct pnfs_layout_segment *lseg,
			struct list_head *free_me);
135

136 137 138
	void (*return_range) (struct pnfs_layout_hdr *lo,
			      struct pnfs_layout_range *range);

139
	/* test for nfs page cache coalescing */
140 141
	const struct nfs_pageio_ops *pg_read_ops;
	const struct nfs_pageio_ops *pg_write_ops;
A
Andy Adamson 已提交
142

F
Fred Isaman 已提交
143
	struct pnfs_ds_commit_info *(*get_ds_info) (struct inode *inode);
144
	void (*mark_request_commit) (struct nfs_page *req,
F
Fred Isaman 已提交
145
				     struct pnfs_layout_segment *lseg,
146 147
				     struct nfs_commit_info *cinfo,
				     u32 ds_commit_idx);
F
Fred Isaman 已提交
148 149 150 151
	void (*clear_request_commit) (struct nfs_page *req,
				      struct nfs_commit_info *cinfo);
	int (*scan_commit_lists) (struct nfs_commit_info *cinfo,
				  int max);
152 153
	void (*recover_commit_reqs) (struct list_head *list,
				     struct nfs_commit_info *cinfo);
154 155
	struct nfs_page * (*search_commit_reqs)(struct nfs_commit_info *cinfo,
						struct page *page);
F
Fred Isaman 已提交
156 157 158 159
	int (*commit_pagelist)(struct inode *inode,
			       struct list_head *mds_pages,
			       int how,
			       struct nfs_commit_info *cinfo);
160

161 162
	int (*sync)(struct inode *inode, bool datasync);

A
Andy Adamson 已提交
163 164 165 166
	/*
	 * Return PNFS_ATTEMPTED to indicate the layout code has attempted
	 * I/O, else return PNFS_NOT_ATTEMPTED to fall back to normal NFS
	 */
167 168
	enum pnfs_try_status (*read_pagelist)(struct nfs_pgio_header *);
	enum pnfs_try_status (*write_pagelist)(struct nfs_pgio_header *, int);
169 170

	void (*free_deviceid_node) (struct nfs4_deviceid_node *);
171 172 173
	struct nfs4_deviceid_node * (*alloc_deviceid_node)
			(struct nfs_server *server, struct pnfs_device *pdev,
			gfp_t gfp_flags);
A
Andy Adamson 已提交
174 175 176 177

	void (*encode_layoutreturn) (struct pnfs_layout_hdr *layoutid,
				     struct xdr_stream *xdr,
				     const struct nfs4_layoutreturn_args *args);
B
Benny Halevy 已提交
178

A
Andy Adamson 已提交
179
	void (*cleanup_layoutcommit) (struct nfs4_layoutcommit_data *data);
180 181
	int (*prepare_layoutcommit) (struct nfs4_layoutcommit_args *args);
	void (*encode_layoutcommit) (struct pnfs_layout_hdr *lo,
B
Benny Halevy 已提交
182 183
				     struct xdr_stream *xdr,
				     const struct nfs4_layoutcommit_args *args);
184 185
	int (*prepare_layoutstats) (struct nfs42_layoutstat_args *args);
	void (*cleanup_layoutstats) (struct nfs42_layoutstat_data *data);
R
Ricardo Labiaga 已提交
186 187
};

188
struct pnfs_layout_hdr {
189
	atomic_t		plh_refcount;
190
	atomic_t		plh_outstanding; /* number of RPCs out */
191
	struct list_head	plh_layouts;   /* other client layouts */
192
	struct list_head	plh_bulk_destroy;
193
	struct list_head	plh_segs;      /* layout segments list */
F
Fred Isaman 已提交
194
	unsigned long		plh_block_lgets; /* block LAYOUTGET if >0 */
195
	unsigned long		plh_retry_timestamp;
196
	unsigned long		plh_flags;
197 198
	nfs4_stateid		plh_stateid;
	u32			plh_barrier; /* ignore lower seqids */
199
	u32			plh_return_seq;
200
	enum pnfs_iomode	plh_return_iomode;
201
	loff_t			plh_lwb; /* last write byte for layoutcommit */
202
	struct rpc_cred		*plh_lc_cred; /* layoutcommit cred */
203
	struct inode		*plh_inode;
204 205
};

206 207 208 209
struct pnfs_device {
	struct nfs4_deviceid dev_id;
	unsigned int  layout_type;
	unsigned int  mincount;
210
	unsigned int  maxcount;	/* gdia_maxcount */
211 212
	struct page **pages;
	unsigned int  pgbase;
213
	unsigned int  pglen;	/* reply buffer length */
214
	unsigned char nocache : 1;/* May not be cached */
215 216
};

A
Andy Adamson 已提交
217 218 219 220 221 222 223 224
#define NFS4_PNFS_GETDEVLIST_MAXNUM 16

struct pnfs_devicelist {
	unsigned int		eof;
	unsigned int		num_devs;
	struct nfs4_deviceid	dev_id[NFS4_PNFS_GETDEVLIST_MAXNUM];
};

225 226 227
extern int pnfs_register_layoutdriver(struct pnfs_layoutdriver_type *);
extern void pnfs_unregister_layoutdriver(struct pnfs_layoutdriver_type *);

228 229
/* nfs4proc.c */
extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,
230 231
				   struct pnfs_device *dev,
				   struct rpc_cred *cred);
232
extern struct pnfs_layout_segment* nfs4_proc_layoutget(struct nfs4_layoutget *lgp, long *timeout, gfp_t gfp_flags);
233
extern int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync);
234 235

/* pnfs.c */
236
void pnfs_get_layout_hdr(struct pnfs_layout_hdr *lo);
237
void pnfs_put_lseg(struct pnfs_layout_segment *lseg);
238
void pnfs_put_lseg_locked(struct pnfs_layout_segment *lseg);
239

240
void set_pnfs_layoutdriver(struct nfs_server *, const struct nfs_fh *, struct nfs_fsinfo *);
R
Ricardo Labiaga 已提交
241
void unset_pnfs_layoutdriver(struct nfs_server *);
242
void pnfs_generic_pg_init_read(struct nfs_pageio_descriptor *, struct nfs_page *);
243
int pnfs_generic_pg_readpages(struct nfs_pageio_descriptor *desc);
244 245
void pnfs_generic_pg_init_write(struct nfs_pageio_descriptor *pgio,
			        struct nfs_page *req, u64 wb_size);
246
void pnfs_generic_pg_cleanup(struct nfs_pageio_descriptor *);
247
int pnfs_generic_pg_writepages(struct nfs_pageio_descriptor *desc);
248 249
size_t pnfs_generic_pg_test(struct nfs_pageio_descriptor *pgio,
			    struct nfs_page *prev, struct nfs_page *req);
P
Peng Tao 已提交
250
void pnfs_set_lo_fail(struct pnfs_layout_segment *lseg);
251
struct pnfs_layout_segment *pnfs_layout_process(struct nfs4_layoutget *lgp);
F
Fred Isaman 已提交
252
void pnfs_free_lseg_list(struct list_head *tmp_list);
253
void pnfs_destroy_layout(struct nfs_inode *);
254
void pnfs_destroy_all_layouts(struct nfs_client *);
255 256 257 258 259
int pnfs_destroy_layouts_byfsid(struct nfs_client *clp,
		struct nfs_fsid *fsid,
		bool is_recall);
int pnfs_destroy_layouts_byclid(struct nfs_client *clp,
		bool is_recall);
260
void pnfs_put_layout_hdr(struct pnfs_layout_hdr *lo);
F
Fred Isaman 已提交
261 262 263
void pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo,
			     const nfs4_stateid *new,
			     bool update_barrier);
264
int pnfs_mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
F
Fred Isaman 已提交
265
				struct list_head *tmp_list,
266 267
				const struct pnfs_layout_range *recall_range,
				u32 seq);
268
int pnfs_mark_matching_lsegs_return(struct pnfs_layout_hdr *lo,
269
				struct list_head *tmp_list,
270 271
				const struct pnfs_layout_range *recall_range,
				u32 seq);
272 273
int pnfs_mark_layout_stateid_invalid(struct pnfs_layout_hdr *lo,
		struct list_head *lseg_list);
F
Fred Isaman 已提交
274 275 276
bool pnfs_roc(struct inode *ino);
void pnfs_roc_release(struct inode *ino);
void pnfs_roc_set_barrier(struct inode *ino, u32 barrier);
277
void pnfs_roc_get_barrier(struct inode *ino, u32 *barrier);
278
bool pnfs_wait_on_layoutreturn(struct inode *ino, struct rpc_task *task);
279
void pnfs_set_layoutcommit(struct inode *, struct pnfs_layout_segment *, loff_t);
A
Andy Adamson 已提交
280
void pnfs_cleanup_layoutcommit(struct nfs4_layoutcommit_data *data);
281
int pnfs_layoutcommit_inode(struct inode *inode, bool sync);
282 283
int pnfs_generic_sync(struct inode *inode, bool datasync);
int pnfs_nfs_generic_sync(struct inode *inode, bool datasync);
B
Benny Halevy 已提交
284
int _pnfs_return_layout(struct inode *);
285
int pnfs_commit_and_return_layout(struct inode *);
286 287
void pnfs_ld_write_done(struct nfs_pgio_header *);
void pnfs_ld_read_done(struct nfs_pgio_header *);
288
void pnfs_read_resend_pnfs(struct nfs_pgio_header *);
289 290 291 292 293
struct pnfs_layout_segment *pnfs_update_layout(struct inode *ino,
					       struct nfs_open_context *ctx,
					       loff_t pos,
					       u64 count,
					       enum pnfs_iomode iomode,
294
					       bool strict_iomode,
295
					       gfp_t gfp_flags);
296
void pnfs_clear_layoutreturn_waitbit(struct pnfs_layout_hdr *lo);
297

298 299 300 301 302 303 304 305
void pnfs_generic_layout_insert_lseg(struct pnfs_layout_hdr *lo,
		   struct pnfs_layout_segment *lseg,
		   bool (*is_after)(const struct pnfs_layout_range *lseg_range,
			   const struct pnfs_layout_range *old),
		   bool (*do_merge)(struct pnfs_layout_segment *lseg,
			   struct pnfs_layout_segment *old),
		   struct list_head *free_me);

306
void nfs4_deviceid_mark_client_invalid(struct nfs_client *clp);
307 308
int pnfs_read_done_resend_to_mds(struct nfs_pgio_header *);
int pnfs_write_done_resend_to_mds(struct nfs_pgio_header *);
309
struct nfs4_threshold *pnfs_mdsthreshold_alloc(void);
310 311
void pnfs_error_mark_layout_for_return(struct inode *inode,
				       struct pnfs_layout_segment *lseg);
312 313 314
/* nfs4_deviceid_flags */
enum {
	NFS_DEVICEID_INVALID = 0,       /* set when MDS clientid recalled */
315
	NFS_DEVICEID_UNAVAILABLE,	/* device temporarily unavailable */
316
	NFS_DEVICEID_NOCACHE,		/* device may not be cached */
317 318
};

319 320 321
/* pnfs_dev.c */
struct nfs4_deviceid_node {
	struct hlist_node		node;
322
	struct hlist_node		tmpnode;
323
	const struct pnfs_layoutdriver_type *ld;
324
	const struct nfs_client		*nfs_client;
325
	unsigned long 			flags;
326
	unsigned long			timestamp_unavailable;
327
	struct nfs4_deviceid		deviceid;
328
	struct rcu_head			rcu;
329 330 331
	atomic_t			ref;
};

332 333 334 335
struct nfs4_deviceid_node *
nfs4_find_get_deviceid(struct nfs_server *server,
		const struct nfs4_deviceid *id, struct rpc_cred *cred,
		gfp_t gfp_mask);
336
void nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
337
void nfs4_init_deviceid_node(struct nfs4_deviceid_node *, struct nfs_server *,
338 339
			     const struct nfs4_deviceid *);
bool nfs4_put_deviceid_node(struct nfs4_deviceid_node *);
340 341
void nfs4_mark_deviceid_unavailable(struct nfs4_deviceid_node *node);
bool nfs4_test_deviceid_unavailable(struct nfs4_deviceid_node *node);
342
void nfs4_deviceid_purge_client(const struct nfs_client *);
343

344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
/* pnfs_nfs.c */
void pnfs_generic_clear_request_commit(struct nfs_page *req,
				       struct nfs_commit_info *cinfo);
void pnfs_generic_commit_release(void *calldata);
void pnfs_generic_prepare_to_resend_writes(struct nfs_commit_data *data);
void pnfs_generic_rw_release(void *data);
void pnfs_generic_recover_commit_reqs(struct list_head *dst,
				      struct nfs_commit_info *cinfo);
int pnfs_generic_commit_pagelist(struct inode *inode,
				 struct list_head *mds_pages,
				 int how,
				 struct nfs_commit_info *cinfo,
				 int (*initiate_commit)(struct nfs_commit_data *data,
							int how));
int pnfs_generic_scan_commit_lists(struct nfs_commit_info *cinfo, int max);
void pnfs_generic_write_commit_done(struct rpc_task *task, void *data);
360 361 362
void nfs4_pnfs_ds_put(struct nfs4_pnfs_ds *ds);
struct nfs4_pnfs_ds *nfs4_pnfs_ds_add(struct list_head *dsaddrs,
				      gfp_t gfp_flags);
363
void nfs4_pnfs_v3_ds_connect_unload(void);
364 365
void nfs4_pnfs_ds_connect(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds,
			  struct nfs4_deviceid_node *devid, unsigned int timeo,
366
			  unsigned int retrans, u32 version, u32 minor_version,
367
			  rpc_authflavor_t au_flavor);
368 369 370
struct nfs4_pnfs_ds_addr *nfs4_decode_mp_ds_addr(struct net *net,
						 struct xdr_stream *xdr,
						 gfp_t gfp_flags);
371 372 373 374
void pnfs_layout_mark_request_commit(struct nfs_page *req,
				     struct pnfs_layout_segment *lseg,
				     struct nfs_commit_info *cinfo,
				     u32 ds_commit_idx);
375

376 377 378 379 380
static inline bool nfs_have_layout(struct inode *inode)
{
	return NFS_I(inode)->layout != NULL;
}

381 382 383 384 385
static inline bool pnfs_layout_is_valid(const struct pnfs_layout_hdr *lo)
{
	return test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) == 0;
}

386 387 388 389 390 391 392
static inline struct nfs4_deviceid_node *
nfs4_get_deviceid(struct nfs4_deviceid_node *d)
{
	atomic_inc(&d->ref);
	return d;
}

F
Fred Isaman 已提交
393
static inline struct pnfs_layout_segment *
394
pnfs_get_lseg(struct pnfs_layout_segment *lseg)
F
Fred Isaman 已提交
395 396 397
{
	if (lseg) {
		atomic_inc(&lseg->pls_refcount);
398
		smp_mb__after_atomic();
F
Fred Isaman 已提交
399 400 401 402
	}
	return lseg;
}

403 404 405 406 407 408
static inline bool
pnfs_is_valid_lseg(struct pnfs_layout_segment *lseg)
{
	return test_bit(NFS_LSEG_VALID, &lseg->pls_flags) != 0;
}

409 410 411 412 413
/* Return true if a layout driver is being used for this mountpoint */
static inline int pnfs_enabled_sb(struct nfs_server *nfss)
{
	return nfss->pnfs_curr_ld != NULL;
}
R
Ricardo Labiaga 已提交
414

415
static inline int
F
Fred Isaman 已提交
416 417
pnfs_commit_list(struct inode *inode, struct list_head *mds_pages, int how,
		 struct nfs_commit_info *cinfo)
418
{
F
Fred Isaman 已提交
419
	if (cinfo->ds == NULL || cinfo->ds->ncommitting == 0)
420
		return PNFS_NOT_ATTEMPTED;
F
Fred Isaman 已提交
421 422 423 424 425 426 427 428 429 430 431
	return NFS_SERVER(inode)->pnfs_curr_ld->commit_pagelist(inode, mds_pages, how, cinfo);
}

static inline struct pnfs_ds_commit_info *
pnfs_get_ds_info(struct inode *inode)
{
	struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;

	if (ld == NULL || ld->get_ds_info == NULL)
		return NULL;
	return ld->get_ds_info(inode);
432 433
}

434 435 436 437 438 439
static inline void
pnfs_generic_mark_devid_invalid(struct nfs4_deviceid_node *node)
{
	set_bit(NFS_DEVICEID_INVALID, &node->flags);
}

440
static inline bool
F
Fred Isaman 已提交
441
pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
442
			 struct nfs_commit_info *cinfo, u32 ds_commit_idx)
443
{
444
	struct inode *inode = d_inode(req->wb_context->dentry);
445
	struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
446

447 448
	if (lseg == NULL || ld->mark_request_commit == NULL)
		return false;
449
	ld->mark_request_commit(req, lseg, cinfo, ds_commit_idx);
450
	return true;
451 452
}

453
static inline bool
F
Fred Isaman 已提交
454
pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
455
{
456
	struct inode *inode = d_inode(req->wb_context->dentry);
457
	struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
F
Fred Isaman 已提交
458

459 460
	if (ld == NULL || ld->clear_request_commit == NULL)
		return false;
F
Fred Isaman 已提交
461
	ld->clear_request_commit(req, cinfo);
462
	return true;
F
Fred Isaman 已提交
463 464 465
}

static inline int
F
Fred Isaman 已提交
466 467
pnfs_scan_commit_lists(struct inode *inode, struct nfs_commit_info *cinfo,
		       int max)
F
Fred Isaman 已提交
468
{
F
Fred Isaman 已提交
469
	if (cinfo->ds == NULL || cinfo->ds->nwritten == 0)
F
Fred Isaman 已提交
470
		return 0;
F
Fred Isaman 已提交
471 472
	else
		return NFS_SERVER(inode)->pnfs_curr_ld->scan_commit_lists(cinfo, max);
473 474
}

475 476 477 478 479 480 481 482 483 484 485
static inline struct nfs_page *
pnfs_search_commit_reqs(struct inode *inode, struct nfs_commit_info *cinfo,
			struct page *page)
{
	struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;

	if (ld == NULL || ld->search_commit_reqs == NULL)
		return NULL;
	return ld->search_commit_reqs(cinfo, page);
}

B
Benny Halevy 已提交
486 487 488 489 490 491 492 493 494 495
/* Should the pNFS client commit and return the layout upon a setattr */
static inline bool
pnfs_ld_layoutret_on_setattr(struct inode *inode)
{
	if (!pnfs_enabled_sb(NFS_SERVER(inode)))
		return false;
	return NFS_SERVER(inode)->pnfs_curr_ld->flags &
		PNFS_LAYOUTRET_ON_SETATTR;
}

496 497 498 499 500 501 502 503
static inline bool
pnfs_ld_read_whole_page(struct inode *inode)
{
	if (!pnfs_enabled_sb(NFS_SERVER(inode)))
		return false;
	return NFS_SERVER(inode)->pnfs_curr_ld->flags & PNFS_READ_WHOLE_PAGE;
}

504 505 506 507 508 509 510 511
static inline int
pnfs_sync_inode(struct inode *inode, bool datasync)
{
	if (!pnfs_enabled_sb(NFS_SERVER(inode)))
		return 0;
	return NFS_SERVER(inode)->pnfs_curr_ld->sync(inode, datasync);
}

512 513 514 515 516 517 518 519 520
static inline bool
pnfs_layoutcommit_outstanding(struct inode *inode)
{
	struct nfs_inode *nfsi = NFS_I(inode);

	return test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags) != 0 ||
		test_bit(NFS_INO_LAYOUTCOMMITTING, &nfsi->flags) != 0;
}

B
Benny Halevy 已提交
521 522 523 524 525 526 527 528 529 530 531
static inline int pnfs_return_layout(struct inode *ino)
{
	struct nfs_inode *nfsi = NFS_I(ino);
	struct nfs_server *nfss = NFS_SERVER(ino);

	if (pnfs_enabled_sb(nfss) && nfsi->layout)
		return _pnfs_return_layout(ino);

	return 0;
}

532 533 534 535
static inline bool
pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,
		   struct nfs_server *nfss)
{
536
	return (dst && src && src->bm != 0 && nfss->pnfs_curr_ld &&
537 538 539
					nfss->pnfs_curr_ld->id == src->l_type);
}

540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
static inline u64
pnfs_calc_offset_end(u64 offset, u64 len)
{
	if (len == NFS4_MAX_UINT64 || len >= NFS4_MAX_UINT64 - offset)
		return NFS4_MAX_UINT64;
	return offset + len - 1;
}

static inline u64
pnfs_calc_offset_length(u64 offset, u64 end)
{
	if (end == NFS4_MAX_UINT64 || end <= offset)
		return NFS4_MAX_UINT64;
	return 1 + end - offset;
}

556 557 558 559 560 561 562
static inline void
pnfs_copy_range(struct pnfs_layout_range *dst,
		const struct pnfs_layout_range *src)
{
	memcpy(dst, src, sizeof(*dst));
}

563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594
static inline u64
pnfs_end_offset(u64 start, u64 len)
{
	if (NFS4_MAX_UINT64 - start <= len)
		return NFS4_MAX_UINT64;
	return start + len;
}

/*
 * Are 2 ranges intersecting?
 *   start1                             end1
 *   [----------------------------------)
 *                                start2           end2
 *                                [----------------)
 */
static inline bool
pnfs_is_range_intersecting(u64 start1, u64 end1, u64 start2, u64 end2)
{
	return (end1 == NFS4_MAX_UINT64 || start2 < end1) &&
		(end2 == NFS4_MAX_UINT64 || start1 < end2);
}

static inline bool
pnfs_lseg_range_intersecting(const struct pnfs_layout_range *l1,
		const struct pnfs_layout_range *l2)
{
	u64 end1 = pnfs_end_offset(l1->offset, l1->length);
	u64 end2 = pnfs_end_offset(l2->offset, l2->length);

	return pnfs_is_range_intersecting(l1->offset, end1, l2->offset, end2);
}

595 596
extern unsigned int layoutstats_timer;

597 598 599 600 601 602
#ifdef NFS_DEBUG
void nfs4_print_deviceid(const struct nfs4_deviceid *dev_id);
#else
static inline void nfs4_print_deviceid(const struct nfs4_deviceid *dev_id)
{
}
603

604
#endif /* NFS_DEBUG */
R
Ricardo Labiaga 已提交
605 606
#else  /* CONFIG_NFS_V4_1 */

607 608 609 610 611
static inline bool nfs_have_layout(struct inode *inode)
{
	return false;
}

612 613 614 615
static inline void pnfs_destroy_all_layouts(struct nfs_client *clp)
{
}

616 617 618 619
static inline void pnfs_destroy_layout(struct nfs_inode *nfsi)
{
}

F
Fred Isaman 已提交
620
static inline struct pnfs_layout_segment *
621
pnfs_get_lseg(struct pnfs_layout_segment *lseg)
F
Fred Isaman 已提交
622 623 624 625
{
	return NULL;
}

626
static inline void pnfs_put_lseg(struct pnfs_layout_segment *lseg)
F
Fred Isaman 已提交
627 628 629
{
}

B
Benny Halevy 已提交
630 631 632 633 634
static inline int pnfs_return_layout(struct inode *ino)
{
	return 0;
}

635 636 637 638 639
static inline int pnfs_commit_and_return_layout(struct inode *inode)
{
	return 0;
}

B
Benny Halevy 已提交
640 641 642 643 644 645
static inline bool
pnfs_ld_layoutret_on_setattr(struct inode *inode)
{
	return false;
}

646 647 648 649 650 651
static inline bool
pnfs_ld_read_whole_page(struct inode *inode)
{
	return false;
}

652 653 654 655 656 657
static inline int
pnfs_sync_inode(struct inode *inode, bool datasync)
{
	return 0;
}

658 659 660 661 662 663 664
static inline bool
pnfs_layoutcommit_outstanding(struct inode *inode)
{
	return false;
}


F
Fred Isaman 已提交
665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
static inline bool
pnfs_roc(struct inode *ino)
{
	return false;
}

static inline void
pnfs_roc_release(struct inode *ino)
{
}

static inline void
pnfs_roc_set_barrier(struct inode *ino, u32 barrier)
{
}

681 682
static inline void
pnfs_roc_get_barrier(struct inode *ino, u32 *barrier)
F
Fred Isaman 已提交
683 684 685
{
}

686 687 688 689 690 691
static inline bool
pnfs_wait_on_layoutreturn(struct inode *ino, struct rpc_task *task)
{
	return false;
}

692
static inline void set_pnfs_layoutdriver(struct nfs_server *s,
693 694
					 const struct nfs_fh *mntfh,
					 struct nfs_fsinfo *fsinfo)
R
Ricardo Labiaga 已提交
695 696 697 698 699 700 701
{
}

static inline void unset_pnfs_layoutdriver(struct nfs_server *s)
{
}

702
static inline int
F
Fred Isaman 已提交
703 704
pnfs_commit_list(struct inode *inode, struct list_head *mds_pages, int how,
		 struct nfs_commit_info *cinfo)
705 706 707 708
{
	return PNFS_NOT_ATTEMPTED;
}

F
Fred Isaman 已提交
709 710 711 712 713 714
static inline struct pnfs_ds_commit_info *
pnfs_get_ds_info(struct inode *inode)
{
	return NULL;
}

715
static inline bool
F
Fred Isaman 已提交
716
pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
717
			 struct nfs_commit_info *cinfo, u32 ds_commit_idx)
718
{
719
	return false;
720 721
}

722
static inline bool
F
Fred Isaman 已提交
723
pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
724
{
725
	return false;
F
Fred Isaman 已提交
726 727 728
}

static inline int
F
Fred Isaman 已提交
729 730
pnfs_scan_commit_lists(struct inode *inode, struct nfs_commit_info *cinfo,
		       int max)
F
Fred Isaman 已提交
731 732
{
	return 0;
733 734
}

735 736 737 738 739 740 741
static inline struct nfs_page *
pnfs_search_commit_reqs(struct inode *inode, struct nfs_commit_info *cinfo,
			struct page *page)
{
	return NULL;
}

742
static inline int pnfs_layoutcommit_inode(struct inode *inode, bool sync)
A
Andy Adamson 已提交
743 744 745
{
	return 0;
}
746

747 748 749 750 751 752 753 754 755 756 757 758
static inline bool
pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,
		   struct nfs_server *nfss)
{
	return false;
}

static inline struct nfs4_threshold *pnfs_mdsthreshold_alloc(void)
{
	return NULL;
}

759 760 761 762
static inline void nfs4_pnfs_v3_ds_connect_unload(void)
{
}

R
Ricardo Labiaga 已提交
763 764
#endif /* CONFIG_NFS_V4_1 */

765
#if IS_ENABLED(CONFIG_NFS_V4_2)
766
int pnfs_report_layoutstat(struct inode *inode, gfp_t gfp_flags);
767 768
#else
static inline int
769
pnfs_report_layoutstat(struct inode *inode, gfp_t gfp_flags)
770 771 772 773 774
{
	return 0;
}
#endif

R
Ricardo Labiaga 已提交
775
#endif /* FS_NFS_PNFS_H */