From: Andy Adamson <[email protected]>
We only support one layout type per file system, so one threshold_item4 per
mdsthreshold4.
Signed-off-by: Andy Adamson <[email protected]>
---
fs/nfs/nfs4xdr.c | 125 ++++++++++++++++++++++++++++++++++++++++++++++-
include/linux/nfs4.h | 7 +++
include/linux/nfs_xdr.h | 10 ++++
3 files changed, 140 insertions(+), 2 deletions(-)
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index db040e9..27eb873 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -99,9 +99,12 @@ static int nfs4_stat_to_errno(int);
#define nfs4_path_maxsz (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
#define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
#define nfs4_group_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
+/* We support only one layout type per file system */
+#define decode_mdsthreshold_maxsz (1 + 1 + nfs4_fattr_bitmap_maxsz + 1 + 8)
/* This is based on getfattr, which uses the most attributes: */
#define nfs4_fattr_value_maxsz (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
- 3 + 3 + 3 + nfs4_owner_maxsz + nfs4_group_maxsz))
+ 3 + 3 + 3 + nfs4_owner_maxsz + \
+ nfs4_group_maxsz + decode_mdsthreshold_maxsz))
#define nfs4_fattr_maxsz (nfs4_fattr_bitmap_maxsz + \
nfs4_fattr_value_maxsz)
#define decode_getattr_maxsz (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
@@ -1170,6 +1173,16 @@ static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct c
bitmask[1] & nfs4_fattr_bitmap[1], hdr);
}
+static void encode_getfattr_open(struct xdr_stream *xdr, const u32 *bitmask,
+ struct compound_hdr *hdr)
+{
+ encode_getattr_three(xdr,
+ bitmask[0] & nfs4_fattr_bitmap[0],
+ bitmask[1] & nfs4_fattr_bitmap[1],
+ bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD,
+ hdr);
+}
+
static void encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
{
encode_getattr_three(xdr,
@@ -2197,7 +2210,7 @@ static void nfs4_xdr_enc_open_noattr(struct rpc_rqst *req,
encode_sequence(xdr, &args->seq_args, &hdr);
encode_putfh(xdr, args->fh, &hdr);
encode_open(xdr, args, &hdr);
- encode_getfattr(xdr, args->bitmask, &hdr);
+ encode_getfattr_open(xdr, args->bitmask, &hdr);
encode_nops(&hdr);
}
@@ -4183,6 +4196,110 @@ xdr_error:
return status;
}
+static int decode_threshold_hint(struct xdr_stream *xdr,
+ uint32_t *bitmap,
+ uint64_t *res,
+ uint32_t hint_bit)
+{
+ __be32 *p;
+
+ *res = 0;
+ if (likely(bitmap[0] & hint_bit)) {
+ p = xdr_inline_decode(xdr, 8);
+ if (unlikely(!p))
+ goto out_overflow;
+ xdr_decode_hyper(p, res);
+ }
+ return 0;
+out_overflow:
+ print_overflow_msg(__func__, xdr);
+ return -EIO;
+}
+
+static int decode_first_threshold_item4(struct xdr_stream *xdr,
+ struct nfs4_threshold *res)
+{
+ __be32 *p, *savep;
+ uint32_t bitmap[3] = {0,}, attrlen;
+ int status;
+
+ /* layout type */
+ p = xdr_inline_decode(xdr, 4);
+ if (unlikely(!p)) {
+ print_overflow_msg(__func__, xdr);
+ return -EIO;
+ }
+ res->l_type = be32_to_cpup(p);
+
+ /* thi_hintset bitmap */
+ status = decode_attr_bitmap(xdr, bitmap);
+ if (status < 0)
+ goto xdr_error;
+
+ /* thi_hintlist length */
+ status = decode_attr_length(xdr, &attrlen, &savep);
+ if (status < 0)
+ goto xdr_error;
+ /* thi_hintlist */
+ status = decode_threshold_hint(xdr, bitmap, &res->rd_sz, THRESHOLD_RD);
+ if (status < 0)
+ goto xdr_error;
+ status = decode_threshold_hint(xdr, bitmap, &res->wr_sz, THRESHOLD_WR);
+ if (status < 0)
+ goto xdr_error;
+ status = decode_threshold_hint(xdr, bitmap, &res->rd_io_sz,
+ THRESHOLD_RD_IO);
+ if (status < 0)
+ goto xdr_error;
+ status = decode_threshold_hint(xdr, bitmap, &res->wr_io_sz,
+ THRESHOLD_WR_IO);
+ if (status < 0)
+ goto xdr_error;
+
+ status = verify_attr_len(xdr, savep, attrlen);
+ res->bm = bitmap[0];
+
+ dprintk("%s bm=0x%x rd_sz=%llu wr_sz=%llu rd_io=%llu wr_io=%llu\n",
+ __func__, res->bm, res->rd_sz, res->wr_sz, res->rd_io_sz,
+ res->wr_io_sz);
+xdr_error:
+ dprintk("%s ret=%d!\n", __func__, status);
+ return status;
+}
+
+/*
+ * Thresholds on pNFS direct I/O vrs MDS I/O
+ */
+static int decode_attr_mdsthreshold(struct xdr_stream *xdr,
+ uint32_t *bitmap,
+ struct nfs4_threshold *res)
+{
+ __be32 *p;
+ int status = 0;
+ uint32_t num;
+
+ if (unlikely(bitmap[2] & (FATTR4_WORD2_MDSTHRESHOLD - 1U)))
+ return -EIO;
+ if (likely(bitmap[2] & FATTR4_WORD2_MDSTHRESHOLD)) {
+ p = xdr_inline_decode(xdr, 4);
+ if (unlikely(!p))
+ goto out_overflow;
+ num = be32_to_cpup(p);
+ if (num == 0)
+ return 0;
+ if (num > 1)
+ printk(KERN_INFO "%s: Warning: Multiple pNFS layout "
+ "drivers per filesystem not supported\n",
+ __func__);
+
+ status = decode_first_threshold_item4(xdr, res);
+ }
+ return status;
+out_overflow:
+ print_overflow_msg(__func__, xdr);
+ return -EIO;
+}
+
static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
struct nfs_fattr *fattr, struct nfs_fh *fh,
struct nfs4_fs_locations *fs_loc,
@@ -4289,6 +4406,10 @@ static int decode_getfattr_attrs(struct xdr_stream *xdr, uint32_t *bitmap,
goto xdr_error;
fattr->valid |= status;
+ status = decode_attr_mdsthreshold(xdr, bitmap, &fattr->mdsthreshold);
+ if (status < 0)
+ goto xdr_error;
+
xdr_error:
dprintk("%s: xdr returned %d\n", __func__, -status);
return status;
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 0987146..72b6bad 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -526,6 +526,13 @@ enum lock_type4 {
#define FATTR4_WORD1_MOUNTED_ON_FILEID (1UL << 23)
#define FATTR4_WORD1_FS_LAYOUT_TYPES (1UL << 30)
#define FATTR4_WORD2_LAYOUT_BLKSIZE (1UL << 1)
+#define FATTR4_WORD2_MDSTHRESHOLD (1UL << 4)
+
+/* MDS threshold bitmap bits */
+#define THRESHOLD_RD (1UL << 0)
+#define THRESHOLD_WR (1UL << 1)
+#define THRESHOLD_RD_IO (1UL << 2)
+#define THRESHOLD_WR_IO (1UL << 3)
#define NFSPROC4_NULL 0
#define NFSPROC4_COMPOUND 1
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 2e53a3f..d23379d 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -35,6 +35,15 @@ static inline int nfs_fsid_equal(const struct nfs_fsid *a, const struct nfs_fsid
return a->major == b->major && a->minor == b->minor;
}
+struct nfs4_threshold {
+ __u32 bm;
+ __u32 l_type;
+ __u64 rd_sz;
+ __u64 wr_sz;
+ __u64 rd_io_sz;
+ __u64 wr_io_sz;
+};
+
struct nfs_fattr {
unsigned int valid; /* which fields are valid */
umode_t mode;
@@ -67,6 +76,7 @@ struct nfs_fattr {
unsigned long gencount;
struct nfs4_string *owner_name;
struct nfs4_string *group_name;
+ struct nfs4_threshold mdsthreshold; /* pNFS threshold hints */
};
#define NFS_ATTR_FATTR_TYPE (1U << 0)
--
1.7.7.6
From: Andy Adamson <[email protected]>
Keep track of the number of bytes read or written, including those queued
up to be flushed. For use by mdsthreshold i/o size hints.
No locking needed as this is used as hint information.
Signed-off-by: Andy Adamson <[email protected]>
---
fs/nfs/file.c | 8 ++++++--
fs/nfs/inode.c | 2 ++
fs/nfs/pnfs.c | 3 +++
include/linux/nfs_fs.h | 3 +++
4 files changed, 14 insertions(+), 2 deletions(-)
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 8eda8a6..c4cc096 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -203,8 +203,10 @@ nfs_file_read(struct kiocb *iocb, const struct iovec *iov,
result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping);
if (!result) {
result = generic_file_aio_read(iocb, iov, nr_segs, pos);
- if (result > 0)
+ if (result > 0) {
+ NFS_I(inode)->read_io += result;
nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
+ }
}
return result;
}
@@ -613,8 +615,10 @@ static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
if (err < 0)
result = err;
}
- if (result > 0)
+ if (result > 0) {
+ NFS_I(inode)->write_io += written;
nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
+ }
out:
return result;
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 850d158..cc5ee55 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -323,6 +323,8 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
inode->i_gid = -2;
inode->i_blocks = 0;
memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
+ nfsi->write_io = 0;
+ nfsi->read_io = 0;
nfsi->read_cache_jiffies = fattr->time_start;
nfsi->attr_gencount = fattr->gencount;
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index 5d78a90..924dce1 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -395,6 +395,9 @@ mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
dprintk("%s:Begin lo %p\n", __func__, lo);
if (list_empty(&lo->plh_segs)) {
+ /* Reset MDS Threshold I/O counters */
+ NFS_I(lo->plh_inode)->write_io = 0;
+ NFS_I(lo->plh_inode)->read_io = 0;
if (!test_and_set_bit(NFS_LAYOUT_DESTROYED, &lo->plh_flags))
put_layout_hdr_locked(lo);
return 0;
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index ca4a707..c6954ac 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -201,6 +201,9 @@ struct nfs_inode {
/* pNFS layout information */
struct pnfs_layout_hdr *layout;
+ /* how many bytes have been written/read and how many bytes queued up */
+ __u64 write_io;
+ __u64 read_io;
#endif /* CONFIG_NFS_V4*/
#ifdef CONFIG_NFS_FSCACHE
struct fscache_cookie *fscache;
--
1.7.7.6
Looks like this patch set got malformed somehow.
I'll resend after responding to the comments.
-->Andy
On May 19, 2012, at 4:50 PM, Myklebust, Trond wrote:
> On Thu, 2012-05-17 at 15:48 -0400, [email protected] wrote:
>> From: Andy Adamson <[email protected]>
>>
>> Signed-off-by: Andy Adamson <[email protected]>
>>
>> net/sunrpc/xprt.c.rej
>
> ?????
>
> --
> Trond Myklebust
> Linux NFS client maintainer
>
> NetApp
> [email protected]
> http://www.netapp.com
>
T24gVGh1LCAyMDEyLTA1LTE3IGF0IDE1OjQ4IC0wNDAwLCBhbmRyb3NAbmV0YXBwLmNvbSB3cm90
ZToNCj4gRnJvbTogQW5keSBBZGFtc29uIDxhbmRyb3NAbmV0YXBwLmNvbT4NCj4gDQo+IFNpZ25l
ZC1vZmYtYnk6IEFuZHkgQWRhbXNvbiA8YW5kcm9zQG5ldGFwcC5jb20+DQo+IA0KPiAJbmV0L3N1
bnJwYy94cHJ0LmMucmVqDQoNCj8/Pz8/DQoNCi0tIA0KVHJvbmQgTXlrbGVidXN0DQpMaW51eCBO
RlMgY2xpZW50IG1haW50YWluZXINCg0KTmV0QXBwDQpUcm9uZC5NeWtsZWJ1c3RAbmV0YXBwLmNv
bQ0Kd3d3Lm5ldGFwcC5jb20NCg0K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From: Andy Adamson <[email protected]>
Signed-off-by: Andy Adamson <[email protected]>
---
fs/nfs/pnfs.c | 78 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 78 insertions(+), 0 deletions(-)
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index 924dce1..1db7416 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -934,6 +934,80 @@ pnfs_find_lseg(struct pnfs_layout_hdr *lo,
}
/*
+ * Use mdsthreshold hints set at each OPEN to determine if I/O should go
+ * to the MDS or over pNFS
+ *
+ * The nfs_inode read_io and write_io fields are cumulative counters reset
+ * before each LAYOUTGET. Note that in pnfs_update_layout iomode is set to
+ * IOMODE_READ for a READ request, and set to IOMODE_RW for a WRITE request.
+ * A return of true means use MDS I/O.
+ *
+ * From rfc 5661:
+ * If a file's length is less than the value of threshold4 read or write size,
+ * then it is RECOMMENDED that the client read from the file via the MDS and
+ * not a storage device.
+ *
+ * For I/O sizes below the threshold4 read or write iosize, it is RECOMMENDED
+ * to access data through the MDS.
+ */
+static bool pnfs_within_mdsthreshold(struct nfs_open_context *ctx,
+ struct inode *ino, int iomode)
+{
+ struct nfs4_threshold *t = ctx->mdsthreshold;
+ struct nfs_inode *nfsi = NFS_I(ino);
+ loff_t fsize = i_size_read(ino);
+ bool size = false, size_set = false, io = false, io_set = false;
+ bool ret = false;
+
+ if (t == NULL || t->bm == 0)
+ return ret;
+
+ dprintk("%s bm=0x%x rd_sz=%llu wr_sz=%llu rd_io=%llu wr_io=%llu\n",
+ __func__, t->bm, t->rd_sz, t->wr_sz, t->rd_io_sz, t->wr_io_sz);
+
+ switch (iomode) {
+ case IOMODE_READ:
+ if (t->bm & THRESHOLD_RD) {
+ dprintk("%s fsize %llu\n", __func__, fsize);
+ size_set = true;
+ if (fsize < t->rd_sz)
+ size = true;
+ }
+ if (t->bm & THRESHOLD_RD_IO) {
+ dprintk("%s nfsi->read_io %llu\n", __func__,
+ nfsi->read_io);
+ io_set = true;
+ if (nfsi->read_io < t->rd_io_sz)
+ io = true;
+ }
+ break;
+ case IOMODE_RW:
+ if (t->bm & THRESHOLD_WR) {
+ dprintk("%s fsize %llu\n", __func__, fsize);
+ size_set = true;
+ if (fsize < t->wr_sz)
+ size = true;
+ }
+ if (t->bm & THRESHOLD_WR_IO) {
+ dprintk("%s nfsi->write_io %llu\n", __func__,
+ nfsi->write_io);
+ io_set = true;
+ if (nfsi->write_io < t->wr_io_sz)
+ io = true;
+ }
+ break;
+ }
+ if (size_set && io_set) {
+ if (size && io)
+ ret = true;
+ } else if (size || io)
+ ret = true;
+
+ dprintk("<-- %s size %d io %d ret %d\n", __func__, size, io, ret);
+ return ret;
+}
+
+/*
* Layout segment is retreived from the server if not cached.
* The appropriate layout segment is referenced and returned to the caller.
*/
@@ -960,6 +1034,10 @@ pnfs_update_layout(struct inode *ino,
if (!pnfs_enabled_sb(NFS_SERVER(ino)))
return NULL;
+
+ if (pnfs_within_mdsthreshold(ctx, ino, iomode))
+ return NULL;
+
spin_lock(&ino->i_lock);
lo = pnfs_find_alloc_layout(ino, ctx, gfp_flags);
if (lo == NULL) {
--
1.7.7.6
From: Andy Adamson <[email protected]>
Signed-off-by: Andy Adamson <[email protected]>
net/sunrpc/xprt.c.rej
---
fs/nfs/inode.c | 2 ++
fs/nfs/nfs4proc.c | 26 +++++++++++++++++++++-----
fs/nfs/pnfs.c | 35 +++++++++++++++++++++++++++++++++++
fs/nfs/pnfs.h | 9 +++++++++
include/linux/nfs_fs.h | 1 +
5 files changed, 68 insertions(+), 5 deletions(-)
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 9f17cd1..850d158 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -641,6 +641,7 @@ struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f
nfs_init_lock_context(&ctx->lock_context);
ctx->lock_context.open_context = ctx;
INIT_LIST_HEAD(&ctx->list);
+ ctx->mdsthreshold = NULL;
return ctx;
}
@@ -669,6 +670,7 @@ static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
put_rpccred(ctx->cred);
dput(ctx->dentry);
nfs_sb_deactive(sb);
+ kfree(ctx->mdsthreshold);
kfree(ctx);
}
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index e6ab15f..ec782f9 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -1781,7 +1781,14 @@ static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct
/*
* Returns a referenced nfs4_state
*/
-static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
+static int _nfs4_do_open(struct inode *dir,
+ struct dentry *dentry,
+ fmode_t fmode,
+ int flags,
+ struct iattr *sattr,
+ struct rpc_cred *cred,
+ struct nfs4_state **res,
+ struct nfs4_threshold **ctx_th)
{
struct nfs4_state_owner *sp;
struct nfs4_state *state = NULL;
@@ -1831,6 +1838,7 @@ static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, fmode_t fmode
nfs_setattr_update_inode(state->inode, sattr);
nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);
}
+ pnfs_cache_mdsthreshold(server, ctx_th, &opendata->f_attr.mdsthreshold);
nfs4_opendata_put(opendata);
nfs4_put_state_owner(sp);
*res = state;
@@ -1845,14 +1853,21 @@ out_err:
}
-static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry, fmode_t fmode, int flags, struct iattr *sattr, struct rpc_cred *cred)
+static struct nfs4_state *nfs4_do_open(struct inode *dir,
+ struct dentry *dentry,
+ fmode_t fmode,
+ int flags,
+ struct iattr *sattr,
+ struct rpc_cred *cred,
+ struct nfs4_threshold **ctx_th)
{
struct nfs4_exception exception = { };
struct nfs4_state *res;
int status;
do {
- status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred, &res);
+ status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred,
+ &res, ctx_th);
if (status == 0)
break;
/* NOTE: BAD_SEQID means the server and client disagree about the
@@ -2176,7 +2191,8 @@ nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags
struct nfs4_state *state;
/* Protect against concurrent sillydeletes */
- state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr, ctx->cred);
+ state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr,
+ ctx->cred, &ctx->mdsthreshold);
if (IS_ERR(state))
return ERR_CAST(state);
ctx->state = state;
@@ -2778,7 +2794,7 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
fmode = ctx->mode;
}
sattr->ia_mode &= ~current_umask();
- state = nfs4_do_open(dir, de, fmode, flags, sattr, cred);
+ state = nfs4_do_open(dir, de, fmode, flags, sattr, cred, NULL);
d_drop(dentry);
if (IS_ERR(state)) {
status = PTR_ERR(state);
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index 6fdeca2..5d78a90 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -1626,3 +1626,38 @@ out_free:
kfree(data);
goto out;
}
+
+/*
+ * Cache the mdsthreshold values from OPEN. Always overwrite old values.
+ *
+ * dst@: the nfs_open_context mdsthreshold pointer
+ * src@: the mdsthreshold from the server
+ */
+void
+pnfs_cache_mdsthreshold(struct nfs_server *server, struct nfs4_threshold **dst,
+ struct nfs4_threshold *src)
+{
+ dprintk("--> %s dst %p\n", __func__, dst);
+
+ if (!pnfs_enabled_sb(server) || !dst || src->bm == 0 ||
+ server->pnfs_curr_ld->id != src->l_type)
+ return;
+
+ if (*dst == NULL) {
+ struct nfs4_threshold *th;
+
+ /* The threshold is a hint: just return if allocation fails */
+ th = kzalloc(sizeof(*th), GFP_NOFS);
+ if (!th) {
+ dprintk("%s mdsthreshold allocation failed\n",
+ __func__);
+ return;
+ }
+ *dst = th;
+ }
+ memcpy(*dst, src, sizeof(struct nfs4_threshold));
+
+ dprintk("%s bm=0x%x rd_sz=%llu wr_sz=%llu rd_io=%llu wr_io=%llu\n",
+ __func__, (*dst)->bm, (*dst)->rd_sz, (*dst)->wr_sz,
+ (*dst)->rd_io_sz, (*dst)->wr_io_sz);
+}
diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h
index f20054b..21ff8cd 100644
--- a/fs/nfs/pnfs.h
+++ b/fs/nfs/pnfs.h
@@ -222,6 +222,9 @@ struct pnfs_layout_segment *pnfs_update_layout(struct inode *ino,
gfp_t gfp_flags);
void nfs4_deviceid_mark_client_invalid(struct nfs_client *clp);
+void pnfs_cache_mdsthreshold(struct nfs_server *server,
+ struct nfs4_threshold **dst,
+ struct nfs4_threshold *src);
/* nfs4_deviceid_flags */
enum {
@@ -480,6 +483,12 @@ static inline int pnfs_layoutcommit_inode(struct inode *inode, bool sync)
return 0;
}
+static inline void
+pnfs_cache_mdsthreshold(struct nfs_server *server, struct nfs4_threshold **dst,
+ struct nfs4_threshold *src)
+{
+}
+
#endif /* CONFIG_NFS_V4_1 */
#endif /* FS_NFS_PNFS_H */
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 6cc7dba..ca4a707 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -102,6 +102,7 @@ struct nfs_open_context {
int error;
struct list_head list;
+ struct nfs4_threshold *mdsthreshold;
};
struct nfs_open_dir_context {
--
1.7.7.6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=