NFSv4 reduce attribute requests for open reclaim

From: Andy Adamson <[email protected]>

We currently make no distinction in attribute requests between normal OPENs and OPEN with CLAIM_PREVIOUS. This offers more possibility of failures in the GETATTR response which foils OPEN reclaim attempts.

Reduce the requested attributes to the bare minimum needed to update the reclaim open stateid and split nfs4_opendata_to_nfs4_state processing accordingly.

---

Version 2:
As per Tronds suggestion, use nfs_refresh_inode instead of nfs_update_inode.

 fs/nfs/nfs4proc.c |  108 ++++++++++++++++++++++++++++++++++++++++-------------
 fs/nfs/nfs4xdr.c  |    2 +-
 2 files changed, 83 insertions(+), 27 deletions(-)

index 50e79c9..0437703 100644
@@ -152,6 +152,12 @@ static const u32 nfs4_pnfs_open_bitmap[3] = {
 	FATTR4_WORD2_MDSTHRESHOLD
 };
 
+static const u32 nfs4_open_noattr_bitmap[3] = {
+	FATTR4_WORD0_TYPE
+	| FATTR4_WORD0_CHANGE
+	| FATTR4_WORD0_FILEID,
+};
+
 const u32 nfs4_statfs_bitmap[2] = {
 	FATTR4_WORD0_FILES_AVAIL
 	| FATTR4_WORD0_FILES_FREE

@@ -1120,11 +1126,74 @@ out_return_state:
 	return state;
 }
 
-static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
+static void
+nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state)
+{
+	struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client;
+	struct nfs_delegation *delegation;
+	int delegation_flags = 0;
+
+	rcu_read_lock();
+	delegation = rcu_dereference(NFS_I(state->inode)->delegation);
+	if (delegation)
+		delegation_flags = delegation->flags;
+	rcu_read_unlock();
+	if (data->o_arg.claim == NFS4_OPEN_CLAIM_DELEGATE_CUR) {
+		pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
+				   "returning a delegation for "
+				   "OPEN(CLAIM_DELEGATE_CUR)\n",
+				   clp->cl_hostname);
+	} else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
+		nfs_inode_set_delegation(state->inode,
+					 data->owner->so_cred,
+					 &data->o_res);
+	else
+		nfs_inode_reclaim_delegation(state->inode,
+					     data->owner->so_cred,
+					     &data->o_res);
+}
+
+/*
+ * Check the inode attributes against the CLAIM_PREVIOUS returned attributes
+ * and update the nfs4_state.
+ */
+static struct nfs4_state *
+_nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
+{
+	struct inode *inode = data->state->inode;
+	struct nfs4_state *state = data->state;
+	int ret = -ESTALE;
+
+	if (!data->rpc_done || !(data->f_attr.valid & NFS_ATTR_FATTR) ||
+	    !(data->f_attr.valid & NFS_ATTR_FATTR_TYPE) ||
+	    !(data->f_attr.valid & NFS_ATTR_FATTR_CHANGE) ||
+	    !(data->f_attr.valid & NFS_ATTR_FATTR_FILEID))
+		goto err;
+
+	ret = -ENOMEM;
+	state = nfs4_get_open_state(inode, data->owner);
+	if (state == NULL)
+		goto err;
+
+	ret = nfs_refresh_inode(inode, &data->f_attr);
+	if (ret)
+		goto err;
+	if (data->o_res.delegation_type != 0)
+		nfs4_opendata_check_deleg(data, state);
+	update_open_stateid(state, &data->o_res.stateid, NULL,
+			    data->o_arg.fmode);
+
+	return state;
+err:
+	return ERR_PTR(ret);
+
+}
+
+static struct nfs4_state *
+_nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
 {
 	struct inode *inode;
 	struct nfs4_state *state = NULL;
-	struct nfs_delegation *delegation;
 	int ret;
 
 	if (!data->rpc_done) {

@@ -1143,30 +1212,8 @@ static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data
 	state = nfs4_get_open_state(inode, data->owner);
 	if (state == NULL)
 		goto err_put_inode;
-	if (data->o_res.delegation_type != 0) {
-		struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
-		int delegation_flags = 0;
-
-		rcu_read_lock();
-		delegation = rcu_dereference(NFS_I(inode)->delegation);
-		if (delegation)
-			delegation_flags = delegation->flags;
-		rcu_read_unlock();
-		if (data->o_arg.claim == NFS4_OPEN_CLAIM_DELEGATE_CUR) {
-			pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
-					"returning a delegation for "
-					"OPEN(CLAIM_DELEGATE_CUR)\n",
-					clp->cl_hostname);
-		} else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
-			nfs_inode_set_delegation(state->inode,
-					data->owner->so_cred,
-					&data->o_res);
-		else
-			nfs_inode_reclaim_delegation(state->inode,
-					data->owner->so_cred,
-					&data->o_res);
-	}
-
+	if (data->o_res.delegation_type != 0)
+		nfs4_opendata_check_deleg(data, state);
 	update_open_stateid(state, &data->o_res.stateid, NULL,
 			data->o_arg.fmode);
 	iput(inode);

@@ -1178,6 +1225,14 @@ err:
 	return ERR_PTR(ret);
 }
 
+static struct nfs4_state *
+nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
+{
+	if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
+		return _nfs4_opendata_reclaim_to_nfs4_state(data);
+	return _nfs4_opendata_to_nfs4_state(data);
+}
+
 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
 {
 	struct nfs_inode *nfsi = NFS_I(state->inode);

@@ -1499,6 +1554,7 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
 	data->o_arg.clientid = sp->so_server->nfs_client->cl_clientid;
 	if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) {
 		task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
+		data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0];
 		nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
 	}
 	data->timestamp = jiffies;

index 657483c..ba5b195 100644
@@ -2262,7 +2262,7 @@ static void nfs4_xdr_enc_open_noattr(struct rpc_rqst *req,
 	encode_putfh(xdr, args->fh, &hdr);
 	encode_open(xdr, args, &hdr);
 	encode_access(xdr, args->access, &hdr);
-	encode_getfattr(xdr, args->bitmask, &hdr);
+	encode_getfattr_open(xdr, args->bitmask, args->open_bitmap, &hdr);
 	encode_nops(&hdr);
 }
 

1.7.7.6

T24gVHVlLCAyMDEyLTEwLTAyIGF0IDExOjM0IC0wNDAwLCBhbmRyb3NAbmV0YXBwLmNvbSB3cm90 ZToNCj4gRnJvbTogQW5keSBBZGFtc29uIDxhbmRyb3NAbmV0YXBwLmNvbT4NCj4gDQo+IFdlIGN1 cnJlbnRseSBtYWtlIG5vIGRpc3RpbmN0aW9uIGluIGF0dHJpYnV0ZSByZXF1ZXN0cyBiZXR3ZWVu IG5vcm1hbCBPUEVOcw0KPiBhbmQgT1BFTiB3aXRoIENMQUlNX1BSRVZJT1VTLiAgVGhpcyBvZmZl cnMgbW9yZSBwb3NzaWJpbGl0eSBvZiBmYWlsdXJlcyBpbg0KPiB0aGUgR0VUQVRUUiByZXNwb25z ZSB3aGljaCBmb2lscyBPUEVOIHJlY2xhaW0gYXR0ZW1wdHMuDQo+IA0KPiBSZWR1Y2UgdGhlIHJl cXVlc3RlZCBhdHRyaWJ1dGVzIHRvIHRoZSBiYXJlIG1pbmltdW0gbmVlZGVkIHRvIHVwZGF0ZSB0 aGUNCj4gcmVjbGFpbSBvcGVuIHN0YXRlaWQgYW5kIHNwbGl0IG5mczRfb3BlbmRhdGFfdG9fbmZz NF9zdGF0ZSBwcm9jZXNzaW5nDQo+IGFjY29yZGluZ2x5Lg0KPiANCj4gU2lnbmVkLW9mZi1ieTog QW5keSBBZGFtc29uIDxhbmRyb3NAbmV0YXBwLmNvbT4NCj4gLS0tDQo+IA0KPiBWZXJzaW9uIDI6 DQo+IEFzIHBlciBUcm9uZHMgc3VnZ2VzdGlvbiwgdXNlIG5mc19yZWZyZXNoX2lub2RlIGluc3Rl YWQgb2YgbmZzX3VwZGF0ZV9pbm9kZS4NCj4gDQo+ICBmcy9uZnMvbmZzNHByb2MuYyB8ICAxMDgg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0NCj4g IGZzL25mcy9uZnM0eGRyLmMgIHwgICAgMiArLQ0KPiAgMiBmaWxlcyBjaGFuZ2VkLCA4MyBpbnNl cnRpb25zKCspLCAyNyBkZWxldGlvbnMoLSkNCj4gDQo+IGRpZmYgLS1naXQgYS9mcy9uZnMvbmZz NHByb2MuYyBiL2ZzL25mcy9uZnM0cHJvYy5jDQo+IGluZGV4IDUwZTc5YzkuLjA0Mzc3MDMgMTAw NjQ0DQo+IC0tLSBhL2ZzL25mcy9uZnM0cHJvYy5jDQo+ICsrKyBiL2ZzL25mcy9uZnM0cHJvYy5j DQo+IEBAIC0xNTIsNiArMTUyLDEyIEBAIHN0YXRpYyBjb25zdCB1MzIgbmZzNF9wbmZzX29wZW5f Yml0bWFwWzNdID0gew0KPiAgCUZBVFRSNF9XT1JEMl9NRFNUSFJFU0hPTEQNCj4gIH07DQo+ICAN Cj4gK3N0YXRpYyBjb25zdCB1MzIgbmZzNF9vcGVuX25vYXR0cl9iaXRtYXBbM10gPSB7DQo+ICsJ RkFUVFI0X1dPUkQwX1RZUEUNCj4gKwl8IEZBVFRSNF9XT1JEMF9DSEFOR0UNCj4gKwl8IEZBVFRS NF9XT1JEMF9GSUxFSUQsDQo+ICt9Ow0KPiArDQo+ICBjb25zdCB1MzIgbmZzNF9zdGF0ZnNfYml0 bWFwWzJdID0gew0KPiAgCUZBVFRSNF9XT1JEMF9GSUxFU19BVkFJTA0KPiAgCXwgRkFUVFI0X1dP UkQwX0ZJTEVTX0ZSRUUNCj4gQEAgLTExMjAsMTEgKzExMjYsNzQgQEAgb3V0X3JldHVybl9zdGF0 ZToNCj4gIAlyZXR1cm4gc3RhdGU7DQo+ICB9DQo+ICANCj4gLXN0YXRpYyBzdHJ1Y3QgbmZzNF9z dGF0ZSAqbmZzNF9vcGVuZGF0YV90b19uZnM0X3N0YXRlKHN0cnVjdCBuZnM0X29wZW5kYXRhICpk YXRhKQ0KPiArc3RhdGljIHZvaWQNCj4gK25mczRfb3BlbmRhdGFfY2hlY2tfZGVsZWcoc3RydWN0 IG5mczRfb3BlbmRhdGEgKmRhdGEsIHN0cnVjdCBuZnM0X3N0YXRlICpzdGF0ZSkNCj4gK3sNCj4g KwlzdHJ1Y3QgbmZzX2NsaWVudCAqY2xwID0gTkZTX1NFUlZFUihzdGF0ZS0+aW5vZGUpLT5uZnNf Y2xpZW50Ow0KPiArCXN0cnVjdCBuZnNfZGVsZWdhdGlvbiAqZGVsZWdhdGlvbjsNCj4gKwlpbnQg ZGVsZWdhdGlvbl9mbGFncyA9IDA7DQo+ICsNCj4gKwlyY3VfcmVhZF9sb2NrKCk7DQo+ICsJZGVs ZWdhdGlvbiA9IHJjdV9kZXJlZmVyZW5jZShORlNfSShzdGF0ZS0+aW5vZGUpLT5kZWxlZ2F0aW9u KTsNCj4gKwlpZiAoZGVsZWdhdGlvbikNCj4gKwkJZGVsZWdhdGlvbl9mbGFncyA9IGRlbGVnYXRp b24tPmZsYWdzOw0KPiArCXJjdV9yZWFkX3VubG9jaygpOw0KPiArCWlmIChkYXRhLT5vX2FyZy5j bGFpbSA9PSBORlM0X09QRU5fQ0xBSU1fREVMRUdBVEVfQ1VSKSB7DQo+ICsJCXByX2Vycl9yYXRl bGltaXRlZCgiTkZTOiBCcm9rZW4gTkZTdjQgc2VydmVyICVzIGlzICINCj4gKwkJCQkgICAicmV0 dXJuaW5nIGEgZGVsZWdhdGlvbiBmb3IgIg0KPiArCQkJCSAgICJPUEVOKENMQUlNX0RFTEVHQVRF X0NVUilcbiIsDQo+ICsJCQkJICAgY2xwLT5jbF9ob3N0bmFtZSk7DQo+ICsJfSBlbHNlIGlmICgo ZGVsZWdhdGlvbl9mbGFncyAmIDFVTDw8TkZTX0RFTEVHQVRJT05fTkVFRF9SRUNMQUlNKSA9PSAw KQ0KPiArCQluZnNfaW5vZGVfc2V0X2RlbGVnYXRpb24oc3RhdGUtPmlub2RlLA0KPiArCQkJCQkg ZGF0YS0+b3duZXItPnNvX2NyZWQsDQo+ICsJCQkJCSAmZGF0YS0+b19yZXMpOw0KPiArCWVsc2UN Cj4gKwkJbmZzX2lub2RlX3JlY2xhaW1fZGVsZWdhdGlvbihzdGF0ZS0+aW5vZGUsDQo+ICsJCQkJ CSAgICAgZGF0YS0+b3duZXItPnNvX2NyZWQsDQo+ICsJCQkJCSAgICAgJmRhdGEtPm9fcmVzKTsN Cj4gK30NCj4gKw0KPiArLyoNCj4gKyAqIENoZWNrIHRoZSBpbm9kZSBhdHRyaWJ1dGVzIGFnYWlu c3QgdGhlIENMQUlNX1BSRVZJT1VTIHJldHVybmVkIGF0dHJpYnV0ZXMNCj4gKyAqIGFuZCB1cGRh dGUgdGhlIG5mczRfc3RhdGUuDQo+ICsgKi8NCj4gK3N0YXRpYyBzdHJ1Y3QgbmZzNF9zdGF0ZSAq DQo+ICtfbmZzNF9vcGVuZGF0YV9yZWNsYWltX3RvX25mczRfc3RhdGUoc3RydWN0IG5mczRfb3Bl bmRhdGEgKmRhdGEpDQo+ICt7DQo+ICsJc3RydWN0IGlub2RlICppbm9kZSA9IGRhdGEtPnN0YXRl LT5pbm9kZTsNCj4gKwlzdHJ1Y3QgbmZzNF9zdGF0ZSAqc3RhdGUgPSBkYXRhLT5zdGF0ZTsNCj4g KwlpbnQgcmV0ID0gLUVTVEFMRTsNCj4gKw0KPiArCWlmICghZGF0YS0+cnBjX2RvbmUgfHwgIShk YXRhLT5mX2F0dHIudmFsaWQgJiBORlNfQVRUUl9GQVRUUikgfHwNCg0KSXNuJ3QgdGhlIHRlc3Qg Zm9yIE5GU19BVFRSX0ZBVFRSIHJlZHVuZGFudCBpZiB3ZSBwYXNzIGFueSBvbmUgb2YgdGhlDQpi ZWxvdz8NCg0KPiArCSAgICAhKGRhdGEtPmZfYXR0ci52YWxpZCAmIE5GU19BVFRSX0ZBVFRSX1RZ UEUpIHx8DQo+ICsJICAgICEoZGF0YS0+Zl9hdHRyLnZhbGlkICYgTkZTX0FUVFJfRkFUVFJfQ0hB TkdFKSB8fA0KPiArCSAgICAhKGRhdGEtPmZfYXR0ci52YWxpZCAmIE5GU19BVFRSX0ZBVFRSX0ZJ TEVJRCkpDQo+ICsJCWdvdG8gZXJyOw0KDQpJZiAhZGF0YS0+cnBjX2RvbmUsIHdlIGRvbid0IHJl YWxseSB3YW50IHRvIHJldHVybiBFU1RBTEUuDQoNCj4gKw0KPiArCXJldCA9IC1FTk9NRU07DQo+ ICsJc3RhdGUgPSBuZnM0X2dldF9vcGVuX3N0YXRlKGlub2RlLCBkYXRhLT5vd25lcik7DQo+ICsJ aWYgKHN0YXRlID09IE5VTEwpDQo+ICsJCWdvdG8gZXJyOw0KPiArDQo+ICsJcmV0ID0gbmZzX3Jl ZnJlc2hfaW5vZGUoaW5vZGUsICZkYXRhLT5mX2F0dHIpOw0KPiArCWlmIChyZXQpDQo+ICsJCWdv dG8gZXJyOw0KPiArCWlmIChkYXRhLT5vX3Jlcy5kZWxlZ2F0aW9uX3R5cGUgIT0gMCkNCj4gKwkJ bmZzNF9vcGVuZGF0YV9jaGVja19kZWxlZyhkYXRhLCBzdGF0ZSk7DQo+ICsJdXBkYXRlX29wZW5f c3RhdGVpZChzdGF0ZSwgJmRhdGEtPm9fcmVzLnN0YXRlaWQsIE5VTEwsDQo+ICsJCQkgICAgZGF0 YS0+b19hcmcuZm1vZGUpOw0KPiArDQo+ICsJcmV0dXJuIHN0YXRlOw0KPiArZXJyOg0KPiArCXJl dHVybiBFUlJfUFRSKHJldCk7DQo+ICsNCj4gK30NCj4gKw0KPiArc3RhdGljIHN0cnVjdCBuZnM0 X3N0YXRlICoNCj4gK19uZnM0X29wZW5kYXRhX3RvX25mczRfc3RhdGUoc3RydWN0IG5mczRfb3Bl bmRhdGEgKmRhdGEpDQo+ICB7DQo+ICAJc3RydWN0IGlub2RlICppbm9kZTsNCj4gIAlzdHJ1Y3Qg bmZzNF9zdGF0ZSAqc3RhdGUgPSBOVUxMOw0KPiAtCXN0cnVjdCBuZnNfZGVsZWdhdGlvbiAqZGVs ZWdhdGlvbjsNCj4gIAlpbnQgcmV0Ow0KPiAgDQo+ICAJaWYgKCFkYXRhLT5ycGNfZG9uZSkgew0K PiBAQCAtMTE0MywzMCArMTIxMiw4IEBAIHN0YXRpYyBzdHJ1Y3QgbmZzNF9zdGF0ZSAqbmZzNF9v cGVuZGF0YV90b19uZnM0X3N0YXRlKHN0cnVjdCBuZnM0X29wZW5kYXRhICpkYXRhDQo+ICAJc3Rh dGUgPSBuZnM0X2dldF9vcGVuX3N0YXRlKGlub2RlLCBkYXRhLT5vd25lcik7DQo+ICAJaWYgKHN0 YXRlID09IE5VTEwpDQo+ICAJCWdvdG8gZXJyX3B1dF9pbm9kZTsNCj4gLQlpZiAoZGF0YS0+b19y ZXMuZGVsZWdhdGlvbl90eXBlICE9IDApIHsNCj4gLQkJc3RydWN0IG5mc19jbGllbnQgKmNscCA9 IE5GU19TRVJWRVIoaW5vZGUpLT5uZnNfY2xpZW50Ow0KPiAtCQlpbnQgZGVsZWdhdGlvbl9mbGFn cyA9IDA7DQo+IC0NCj4gLQkJcmN1X3JlYWRfbG9jaygpOw0KPiAtCQlkZWxlZ2F0aW9uID0gcmN1 X2RlcmVmZXJlbmNlKE5GU19JKGlub2RlKS0+ZGVsZWdhdGlvbik7DQo+IC0JCWlmIChkZWxlZ2F0 aW9uKQ0KPiAtCQkJZGVsZWdhdGlvbl9mbGFncyA9IGRlbGVnYXRpb24tPmZsYWdzOw0KPiAtCQly Y3VfcmVhZF91bmxvY2soKTsNCj4gLQkJaWYgKGRhdGEtPm9fYXJnLmNsYWltID09IE5GUzRfT1BF Tl9DTEFJTV9ERUxFR0FURV9DVVIpIHsNCj4gLQkJCXByX2Vycl9yYXRlbGltaXRlZCgiTkZTOiBC cm9rZW4gTkZTdjQgc2VydmVyICVzIGlzICINCj4gLQkJCQkJInJldHVybmluZyBhIGRlbGVnYXRp b24gZm9yICINCj4gLQkJCQkJIk9QRU4oQ0xBSU1fREVMRUdBVEVfQ1VSKVxuIiwNCj4gLQkJCQkJ Y2xwLT5jbF9ob3N0bmFtZSk7DQo+IC0JCX0gZWxzZSBpZiAoKGRlbGVnYXRpb25fZmxhZ3MgJiAx VUw8PE5GU19ERUxFR0FUSU9OX05FRURfUkVDTEFJTSkgPT0gMCkNCj4gLQkJCW5mc19pbm9kZV9z ZXRfZGVsZWdhdGlvbihzdGF0ZS0+aW5vZGUsDQo+IC0JCQkJCWRhdGEtPm93bmVyLT5zb19jcmVk LA0KPiAtCQkJCQkmZGF0YS0+b19yZXMpOw0KPiAtCQllbHNlDQo+IC0JCQluZnNfaW5vZGVfcmVj bGFpbV9kZWxlZ2F0aW9uKHN0YXRlLT5pbm9kZSwNCj4gLQkJCQkJZGF0YS0+b3duZXItPnNvX2Ny ZWQsDQo+IC0JCQkJCSZkYXRhLT5vX3Jlcyk7DQo+IC0JfQ0KPiAtDQo+ICsJaWYgKGRhdGEtPm9f cmVzLmRlbGVnYXRpb25fdHlwZSAhPSAwKQ0KPiArCQluZnM0X29wZW5kYXRhX2NoZWNrX2RlbGVn KGRhdGEsIHN0YXRlKTsNCj4gIAl1cGRhdGVfb3Blbl9zdGF0ZWlkKHN0YXRlLCAmZGF0YS0+b19y ZXMuc3RhdGVpZCwgTlVMTCwNCj4gIAkJCWRhdGEtPm9fYXJnLmZtb2RlKTsNCj4gIAlpcHV0KGlu b2RlKTsNCj4gQEAgLTExNzgsNiArMTIyNSwxNCBAQCBlcnI6DQo+ICAJcmV0dXJuIEVSUl9QVFIo cmV0KTsNCj4gIH0NCj4gIA0KPiArc3RhdGljIHN0cnVjdCBuZnM0X3N0YXRlICoNCj4gK25mczRf b3BlbmRhdGFfdG9fbmZzNF9zdGF0ZShzdHJ1Y3QgbmZzNF9vcGVuZGF0YSAqZGF0YSkNCj4gK3sN Cj4gKwlpZiAoZGF0YS0+b19hcmcuY2xhaW0gPT0gTkZTNF9PUEVOX0NMQUlNX1BSRVZJT1VTKQ0K PiArCQlyZXR1cm4gX25mczRfb3BlbmRhdGFfcmVjbGFpbV90b19uZnM0X3N0YXRlKGRhdGEpOw0K PiArCXJldHVybiBfbmZzNF9vcGVuZGF0YV90b19uZnM0X3N0YXRlKGRhdGEpOw0KPiArfQ0KPiAr DQo+ICBzdGF0aWMgc3RydWN0IG5mc19vcGVuX2NvbnRleHQgKm5mczRfc3RhdGVfZmluZF9vcGVu X2NvbnRleHQoc3RydWN0IG5mczRfc3RhdGUgKnN0YXRlKQ0KPiAgew0KPiAgCXN0cnVjdCBuZnNf aW5vZGUgKm5mc2kgPSBORlNfSShzdGF0ZS0+aW5vZGUpOw0KPiBAQCAtMTQ5OSw2ICsxNTU0LDcg QEAgc3RhdGljIHZvaWQgbmZzNF9vcGVuX3ByZXBhcmUoc3RydWN0IHJwY190YXNrICp0YXNrLCB2 b2lkICpjYWxsZGF0YSkNCj4gIAlkYXRhLT5vX2FyZy5jbGllbnRpZCA9IHNwLT5zb19zZXJ2ZXIt Pm5mc19jbGllbnQtPmNsX2NsaWVudGlkOw0KPiAgCWlmIChkYXRhLT5vX2FyZy5jbGFpbSA9PSBO RlM0X09QRU5fQ0xBSU1fUFJFVklPVVMpIHsNCj4gIAkJdGFzay0+dGtfbXNnLnJwY19wcm9jID0g Jm5mczRfcHJvY2VkdXJlc1tORlNQUk9DNF9DTE5UX09QRU5fTk9BVFRSXTsNCj4gKwkJZGF0YS0+ b19hcmcub3Blbl9iaXRtYXAgPSAmbmZzNF9vcGVuX25vYXR0cl9iaXRtYXBbMF07DQo+ICAJCW5m c19jb3B5X2ZoKCZkYXRhLT5vX3Jlcy5maCwgZGF0YS0+b19hcmcuZmgpOw0KPiAgCX0NCj4gIAlk YXRhLT50aW1lc3RhbXAgPSBqaWZmaWVzOw0KPiBkaWZmIC0tZ2l0IGEvZnMvbmZzL25mczR4ZHIu YyBiL2ZzL25mcy9uZnM0eGRyLmMNCj4gaW5kZXggNjU3NDgzYy4uYmE1YjE5NSAxMDA2NDQNCj4g LS0tIGEvZnMvbmZzL25mczR4ZHIuYw0KPiArKysgYi9mcy9uZnMvbmZzNHhkci5jDQo+IEBAIC0y MjYyLDcgKzIyNjIsNyBAQCBzdGF0aWMgdm9pZCBuZnM0X3hkcl9lbmNfb3Blbl9ub2F0dHIoc3Ry dWN0IHJwY19ycXN0ICpyZXEsDQo+ICAJZW5jb2RlX3B1dGZoKHhkciwgYXJncy0+ZmgsICZoZHIp Ow0KPiAgCWVuY29kZV9vcGVuKHhkciwgYXJncywgJmhkcik7DQo+ICAJZW5jb2RlX2FjY2Vzcyh4 ZHIsIGFyZ3MtPmFjY2VzcywgJmhkcik7DQo+IC0JZW5jb2RlX2dldGZhdHRyKHhkciwgYXJncy0+ Yml0bWFzaywgJmhkcik7DQo+ICsJZW5jb2RlX2dldGZhdHRyX29wZW4oeGRyLCBhcmdzLT5iaXRt YXNrLCBhcmdzLT5vcGVuX2JpdG1hcCwgJmhkcik7DQo+ICAJZW5jb2RlX25vcHMoJmhkcik7DQo+ ICB9DQo+ICANCg0KLS0gDQpUcm9uZCBNeWtsZWJ1c3QNCkxpbnV4IE5GUyBjbGllbnQgbWFpbnRh aW5lcg0KDQpOZXRBcHANClRyb25kLk15a2xlYnVzdEBuZXRhcHAuY29tDQp3d3cubmV0YXBwLmNv bQ0K