Signed-off-by: Peng Tao <[email protected]>
---
fs/nfs/direct.c | 5 +++++
1 files changed, 5 insertions(+), 0 deletions(-)
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 34a6282..c39f775 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -78,6 +78,7 @@ struct nfs_direct_req {
atomic_t io_count; /* i/os we're waiting for */
spinlock_t lock; /* protect completion state */
ssize_t count, /* bytes actually processed */
+ bytes_left, /* bytes left to be sent */
error; /* any reported error */
struct completion completion; /* wait for i/o completion */
@@ -390,6 +391,7 @@ static ssize_t nfs_direct_read_schedule_segment(struct nfs_pageio_descriptor *de
user_addr += req_len;
pos += req_len;
count -= req_len;
+ dreq->bytes_left -= req_len;
}
/* The nfs_page now hold references to these pages */
nfs_direct_release_pages(pagevec, npages);
@@ -456,6 +458,7 @@ static ssize_t nfs_direct_read(struct kiocb *iocb, const struct iovec *iov,
goto out;
dreq->inode = inode;
+ dreq->bytes_left = iov_length(iov, nr_segs);
dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp));
dreq->l_ctx = nfs_get_lock_context(dreq->ctx);
if (dreq->l_ctx == NULL)
@@ -706,6 +709,7 @@ static ssize_t nfs_direct_write_schedule_segment(struct nfs_pageio_descriptor *d
user_addr += req_len;
pos += req_len;
count -= req_len;
+ dreq->bytes_left -= req_len;
}
/* The nfs_page now hold references to these pages */
nfs_direct_release_pages(pagevec, npages);
@@ -855,6 +859,7 @@ static ssize_t nfs_direct_write(struct kiocb *iocb, const struct iovec *iov,
goto out;
dreq->inode = inode;
+ dreq->bytes_left = count;
dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp));
dreq->l_ctx = nfs_get_lock_context(dreq->ctx);
if (dreq->l_ctx == NULL)
--
1.7.1.262.g5ef3d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==
PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiBGcm9tOiBNeWtsZWJ1c3QsIFRyb25kIFtt
YWlsdG86VHJvbmQuTXlrbGVidXN0QG5ldGFwcC5jb21dDQo+IFNlbnQ6IFR1ZXNkYXksIEF1Z3Vz
dCAxNCwgMjAxMiA4OjQzIEFNDQo+IFRvOiBQZW5nIFRhbw0KPiBDYzogbGludXgtbmZzQHZnZXIu
a2VybmVsLm9yZzsgYmhhcnJvc2hAcGFuYXNhcy5jb207IFBlbmcsIFRhbw0KPiBTdWJqZWN0OiBS
ZTogW1BBVENILXYyIDIvM10gTkZTNDE6IHNlbmQgcmVhbCB3cml0ZSBzaXplIGluIGxheW91dGdl
dA0KPiANCj4gUGxlYXNlIGp1c3QgY2FsY3VsYXRlIHRoZSBjb3JyZWN0IHZhbHVlIGZvciB3Yl9z
aXplIGluc2lkZQ0KPiBibF9wZ19pbml0X3dyaXRlKCksIGFuZCBwYXNzIGl0IGFzIGFuIGV4dHJh
IHBhcmFtZXRlciB0bw0KPiBwbmZzX2dlbmVyaWNfcGdfaW5pdF93cml0ZSgpLg0KPiANCj4gVGhl
biBhZGQgcG5mc19wZ19pbml0X29iamVjdF93cml0ZSBmb3Igb2JqZWN0cywgdGhhdCBjYWxscyB0
aGUgbW9kaWZpZWQNCj4gcG5mc19nZW5lcmljX3BnX2luaXRfd3JpdGUoKSB3aXRoIHRoZSBQTkZT
X0xBWU9VVEdFVF9JU0laRSB2YWx1ZS4NCj4gDQo+IEZpbGVzIGRvbid0IGNhbGwgdGhpcyBmdW5j
dGlvbiwgc28gYWRkaW5nIHRoZSBQTkZTX0xBWU9VVEdFVF9BTExfRklMRQ0KPiBpc24ndCBuZWVk
ZWQuDQpJdCB3YXMganVzdCBmb3IgY29uc2lzdGVuY3kgdG8gYWRkIHRoZSBmbGFnIGZvciBmaWxl
IGxheW91dC4gQW55d2F5LCBJIHNlZSB5b3VyIHBvaW50cy4gV2lsbCBwdXQgYWxsIHRoZXNlIGlu
IGJsb2NrL29iamVjdCBMRCBjb2RlLg0KDQpUaGFua3MsDQpUYW8NCg0K
PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiBGcm9tOiBCb2F6IEhhcnJvc2ggW21haWx0
bzpiaGFycm9zaEBwYW5hc2FzLmNvbV0NCj4gU2VudDogVHVlc2RheSwgQXVndXN0IDE0LCAyMDEy
IDc6NTQgQU0NCj4gVG86IFBlbmcgVGFvDQo+IENjOiBUcm9uZC5NeWtsZWJ1c3RAbmV0YXBwLmNv
bTsgbGludXgtbmZzQHZnZXIua2VybmVsLm9yZzsgUGVuZywgVGFvDQo+IFN1YmplY3Q6IFJlOiBb
UEFUQ0gtdjIgMi8zXSBORlM0MTogc2VuZCByZWFsIHdyaXRlIHNpemUgaW4gbGF5b3V0Z2V0DQo+
IA0KPiBPbiAwOC8xMy8yMDEyIDA1OjM5IFBNLCBQZW5nIFRhbyB3cm90ZToNCj4gDQo+ID4gRm9y
IGJ1ZmZlciB3cml0ZSwgdXNlIHBvbGljeSBiYXNlZCBtZWNoYW5pc20gdG8gZGV0ZXJtaW5lIGxh
eW91dGdldCBzaXplLg0KPiA+IEN1cnJlbnRseSBmaWxlcyB1c2Ugd2hvbGUgZmlsZSBsYXlvdXQs
IG9iamVjdHMgdXNlIG9mZnNldC10by1pc2l6ZSwgYW5kDQo+ID4gYmxvY2tzIHNlYXJjaCBuZXh0
IGhvbGUgaW4gaW5vZGUgbWFwcGluZyBhbmQgdXNlIG9mZnNldC10by1ob2xlLg0KPiA+DQo+ID4g
Rm9yIGRpcmVjdCB3cml0ZSwganVzdCB1c2UgZHJlcS0+Ynl0ZXNfbGVmdC4NCj4gPg0KPiA+IFNp
Z25lZC1vZmYtYnk6IFBlbmcgVGFvIDx0YW8ucGVuZ0BlbWMuY29tPg0KPiA+IC0tLQ0KPiA+ICBm
cy9uZnMvYmxvY2tsYXlvdXQvYmxvY2tsYXlvdXQuYyB8ICAgIDEgKw0KPiA+ICBmcy9uZnMvZGly
ZWN0LmMgICAgICAgICAgICAgICAgICB8ICAgIDcgKysrKysNCj4gPiAgZnMvbmZzL2ludGVybmFs
LmggICAgICAgICAgICAgICAgfCAgICAxICsNCj4gPiAgZnMvbmZzL25mczRmaWxlbGF5b3V0LmMg
ICAgICAgICAgfCAgICAxICsNCj4gPiAgZnMvbmZzL29iamxheW91dC9vYmppb19vc2QuYyAgICAg
fCAgICAzICstDQo+ID4gIGZzL25mcy9wbmZzLmMgICAgICAgICAgICAgICAgICAgIHwgICA1MSAr
KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQ0KPiA+ICBmcy9uZnMvcG5mcy5o
ICAgICAgICAgICAgICAgICAgICB8ICAgMTMgKysrKysrKysrDQo+ID4gIDcgZmlsZXMgY2hhbmdl
ZCwgNzUgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkNCj4gPg0KPiA+IGRpZmYgLS1naXQg
YS9mcy9uZnMvYmxvY2tsYXlvdXQvYmxvY2tsYXlvdXQuYyBiL2ZzL25mcy9ibG9ja2xheW91dC9i
bG9ja2xheW91dC5jDQo+ID4gaW5kZXggMTA5Mzk2OC4uYzQyMTVjZiAxMDA2NDQNCj4gPiAtLS0g
YS9mcy9uZnMvYmxvY2tsYXlvdXQvYmxvY2tsYXlvdXQuYw0KPiA+ICsrKyBiL2ZzL25mcy9ibG9j
a2xheW91dC9ibG9ja2xheW91dC5jDQo+ID4gQEAgLTEyNDAsNiArMTI0MCw3IEBAIHN0YXRpYyBj
b25zdCBzdHJ1Y3QgbmZzX3BhZ2Vpb19vcHMgYmxfcGdfd3JpdGVfb3BzID0gew0KPiA+ICBzdGF0
aWMgc3RydWN0IHBuZnNfbGF5b3V0ZHJpdmVyX3R5cGUgYmxvY2tsYXlvdXRfdHlwZSA9IHsNCj4g
PiAgCS5pZAkJCQk9IExBWU9VVF9CTE9DS19WT0xVTUUsDQo+ID4gIAkubmFtZQkJCQk9ICJMQVlP
VVRfQkxPQ0tfVk9MVU1FIiwNCj4gPiArCS5mbGFncwkJCQk9IFBORlNfTEFZT1VUR0VUX1NFQVJD
SF9IT0xFLA0KPiA+ICAJLnJlYWRfcGFnZWxpc3QJCQk9IGJsX3JlYWRfcGFnZWxpc3QsDQo+ID4g
IAkud3JpdGVfcGFnZWxpc3QJCQk9IGJsX3dyaXRlX3BhZ2VsaXN0LA0KPiA+ICAJLmFsbG9jX2xh
eW91dF9oZHIJCT0gYmxfYWxsb2NfbGF5b3V0X2hkciwNCj4gPiBkaWZmIC0tZ2l0IGEvZnMvbmZz
L2RpcmVjdC5jIGIvZnMvbmZzL2RpcmVjdC5jDQo+ID4gaW5kZXggYzM5Zjc3NS4uYzE4OTlkZCAx
MDA2NDQNCj4gPiAtLS0gYS9mcy9uZnMvZGlyZWN0LmMNCj4gPiArKysgYi9mcy9uZnMvZGlyZWN0
LmMNCj4gPiBAQCAtNDYsNiArNDYsNyBAQA0KPiA+ICAjaW5jbHVkZSA8bGludXgva3JlZi5oPg0K
PiA+ICAjaW5jbHVkZSA8bGludXgvc2xhYi5oPg0KPiA+ICAjaW5jbHVkZSA8bGludXgvdGFza19p
b19hY2NvdW50aW5nX29wcy5oPg0KPiA+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQo+ID4N
Cj4gPiAgI2luY2x1ZGUgPGxpbnV4L25mc19mcy5oPg0KPiA+ICAjaW5jbHVkZSA8bGludXgvbmZz
X3BhZ2UuaD4NCj4gPiBAQCAtMTkxLDYgKzE5MiwxMiBAQCBzdGF0aWMgdm9pZCBuZnNfZGlyZWN0
X3JlcV9yZWxlYXNlKHN0cnVjdCBuZnNfZGlyZWN0X3JlcSAqZHJlcSkNCj4gPiAgCWtyZWZfcHV0
KCZkcmVxLT5rcmVmLCBuZnNfZGlyZWN0X3JlcV9mcmVlKTsNCj4gPiAgfQ0KPiA+DQo+ID4gK3Nz
aXplX3QgbmZzX2RyZXFfYnl0ZXNfbGVmdChzdHJ1Y3QgbmZzX2RpcmVjdF9yZXEgKmRyZXEpDQo+
ID4gK3sNCj4gPiArCXJldHVybiBkcmVxLT5ieXRlc19sZWZ0Ow0KPiA+ICt9DQo+ID4gK0VYUE9S
VF9TWU1CT0xfR1BMKG5mc19kcmVxX2J5dGVzX2xlZnQpOw0KPiA+ICsNCj4gPiAgLyoNCj4gPiAg
ICogQ29sbGVjdHMgYW5kIHJldHVybnMgdGhlIGZpbmFsIGVycm9yIHZhbHVlL2J5dGUtY291bnQu
DQo+ID4gICAqLw0KPiA+IGRpZmYgLS1naXQgYS9mcy9uZnMvaW50ZXJuYWwuaCBiL2ZzL25mcy9p
bnRlcm5hbC5oDQo+ID4gaW5kZXggMzFmZGIwMy4uZTY4ZDMyOSAxMDA2NDQNCj4gPiAtLS0gYS9m
cy9uZnMvaW50ZXJuYWwuaA0KPiA+ICsrKyBiL2ZzL25mcy9pbnRlcm5hbC5oDQo+ID4gQEAgLTQ2
NCw2ICs0NjQsNyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgbmZzX2lub2RlX2Rpb193YWl0KHN0cnVj
dCBpbm9kZSAqaW5vZGUpDQo+ID4gIHsNCj4gPiAgCWlub2RlX2Rpb193YWl0KGlub2RlKTsNCj4g
PiAgfQ0KPiA+ICtleHRlcm4gc3NpemVfdCBuZnNfZHJlcV9ieXRlc19sZWZ0KHN0cnVjdCBuZnNf
ZGlyZWN0X3JlcSAqZHJlcSk7DQo+ID4NCj4gPiAgLyogbmZzNHByb2MuYyAqLw0KPiA+ICBleHRl
cm4gdm9pZCBfX25mczRfcmVhZF9kb25lX2NiKHN0cnVjdCBuZnNfcmVhZF9kYXRhICopOw0KPiA+
IGRpZmYgLS1naXQgYS9mcy9uZnMvbmZzNGZpbGVsYXlvdXQuYyBiL2ZzL25mcy9uZnM0ZmlsZWxh
eW91dC5jDQo+ID4gaW5kZXggNTNmOTRkOS4uZjgxZWRkNyAxMDA2NDQNCj4gPiAtLS0gYS9mcy9u
ZnMvbmZzNGZpbGVsYXlvdXQuYw0KPiA+ICsrKyBiL2ZzL25mcy9uZnM0ZmlsZWxheW91dC5jDQo+
ID4gQEAgLTEyODksNiArMTI4OSw3IEBAIGZpbGVsYXlvdXRfZ2V0X2RzX2luZm8oc3RydWN0IGlu
b2RlICppbm9kZSkNCj4gPiAgc3RhdGljIHN0cnVjdCBwbmZzX2xheW91dGRyaXZlcl90eXBlIGZp
bGVsYXlvdXRfdHlwZSA9IHsNCj4gPiAgCS5pZAkJCT0gTEFZT1VUX05GU1Y0XzFfRklMRVMsDQo+
ID4gIAkubmFtZQkJCT0gIkxBWU9VVF9ORlNWNF8xX0ZJTEVTIiwNCj4gPiArCS5mbGFncwkJCT0g
UE5GU19MQVlPVVRHRVRfQUxMX0ZJTEUsDQo+ID4gIAkub3duZXIJCQk9IFRISVNfTU9EVUxFLA0K
PiA+ICAJLmFsbG9jX2xheW91dF9oZHIJPSBmaWxlbGF5b3V0X2FsbG9jX2xheW91dF9oZHIsDQo+
ID4gIAkuZnJlZV9sYXlvdXRfaGRyCT0gZmlsZWxheW91dF9mcmVlX2xheW91dF9oZHIsDQo+ID4g
ZGlmZiAtLWdpdCBhL2ZzL25mcy9vYmpsYXlvdXQvb2JqaW9fb3NkLmMgYi9mcy9uZnMvb2JqbGF5
b3V0L29iamlvX29zZC5jDQo+ID4gaW5kZXggZWE2ZDExMS4uZTQ4N2ZiOCAxMDA2NDQNCj4gPiAt
LS0gYS9mcy9uZnMvb2JqbGF5b3V0L29iamlvX29zZC5jDQo+ID4gKysrIGIvZnMvbmZzL29iamxh
eW91dC9vYmppb19vc2QuYw0KPiA+IEBAIC02MzgsNyArNjM4LDggQEAgc3RhdGljIHN0cnVjdCBw
bmZzX2xheW91dGRyaXZlcl90eXBlIG9iamxheW91dF90eXBlID0gew0KPiA+ICAJLmlkID0gTEFZ
T1VUX09TRDJfT0JKRUNUUywNCj4gPiAgCS5uYW1lID0gIkxBWU9VVF9PU0QyX09CSkVDVFMiLA0K
PiA+ICAJLmZsYWdzICAgICAgICAgICAgICAgICAgID0gUE5GU19MQVlPVVRSRVRfT05fU0VUQVRU
UiB8DQo+ID4gLQkJCQkgICBQTkZTX0xBWU9VVFJFVF9PTl9FUlJPUiwNCj4gPiArCQkJCSAgIFBO
RlNfTEFZT1VUUkVUX09OX0VSUk9SIHwNCj4gPiArCQkJCSAgIFBORlNfTEFZT1VUR0VUX0lTSVpF
LA0KPiA+DQo+ID4gIAkuYWxsb2NfbGF5b3V0X2hkciAgICAgICAgPSBvYmpsYXlvdXRfYWxsb2Nf
bGF5b3V0X2hkciwNCj4gPiAgCS5mcmVlX2xheW91dF9oZHIgICAgICAgICA9IG9iamxheW91dF9m
cmVlX2xheW91dF9oZHIsDQo+ID4gZGlmZiAtLWdpdCBhL2ZzL25mcy9wbmZzLmMgYi9mcy9uZnMv
cG5mcy5jDQo+ID4gaW5kZXggMmUwMGZlYS4uZDFkYTIzYSAxMDA2NDQNCj4gPiAtLS0gYS9mcy9u
ZnMvcG5mcy5jDQo+ID4gKysrIGIvZnMvbmZzL3BuZnMuYw0KPiA+IEBAIC0yOSw2ICsyOSw3IEBA
DQo+ID4NCj4gPiAgI2luY2x1ZGUgPGxpbnV4L25mc19mcy5oPg0KPiA+ICAjaW5jbHVkZSA8bGlu
dXgvbmZzX3BhZ2UuaD4NCj4gPiArI2luY2x1ZGUgPGxpbnV4L3BhZ2V2ZWMuaD4NCj4gPiAgI2lu
Y2x1ZGUgPGxpbnV4L21vZHVsZS5oPg0KPiA+ICAjaW5jbHVkZSAiaW50ZXJuYWwuaCINCj4gPiAg
I2luY2x1ZGUgInBuZnMuaCINCj4gPiBAQCAtMTE3MiwxOSArMTE3Myw2NyBAQCBwbmZzX2dlbmVy
aWNfcGdfaW5pdF9yZWFkKHN0cnVjdCBuZnNfcGFnZWlvX2Rlc2NyaXB0b3IgKnBnaW8sIHN0cnVj
dA0KPiBuZnNfcGFnZSAqcg0KPiA+ICB9DQo+ID4gIEVYUE9SVF9TWU1CT0xfR1BMKHBuZnNfZ2Vu
ZXJpY19wZ19pbml0X3JlYWQpOw0KPiA+DQo+ID4gKy8qDQo+ID4gKyAqIFJldHVybiB0aGUgbnVt
YmVyIG9mIGNvbnRpZ3VvdXMgYnl0ZXMgZm9yIGEgZ2l2ZW4gaW5vZGUNCj4gPiArICogc3RhcnRp
bmcgYXQgcGFnZSBmcmFtZSBpZHguDQo+ID4gKyAqLw0KPiA+ICtzdGF0aWMgdTY0IHBuZnNfbnVt
X2NvbnRfYnl0ZXMoc3RydWN0IGlub2RlICppbm9kZSwgcGdvZmZfdCBpZHgpDQo+ID4gK3sNCj4g
PiArCXN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nID0gaW5vZGUtPmlfbWFwcGluZzsNCj4g
PiArCXBnb2ZmX3QgZW5kOw0KPiA+ICsNCj4gPiArCS8qIE9wdGltaXplIGNvbW1vbiBjYXNlIHRo
YXQgd3JpdGVzIGZyb20gMCB0byBlbmQgb2YgZmlsZSAqLw0KPiA+ICsJZW5kID0gRElWX1JPVU5E
X1VQKGlfc2l6ZV9yZWFkKGlub2RlKSwgUEFHRV9DQUNIRV9TSVpFKTsNCj4gPiArCWlmIChlbmQg
IT0gTkZTX0koaW5vZGUpLT5ucGFnZXMpIHsNCj4gPiArCQlyY3VfcmVhZF9sb2NrKCk7DQo+ID4g
KwkJZW5kID0gcmFkaXhfdHJlZV9uZXh0X2hvbGUoJm1hcHBpbmctPnBhZ2VfdHJlZSwgaWR4ICsg
MSwgVUxPTkdfTUFYKTsNCj4gPiArCQlyY3VfcmVhZF91bmxvY2soKTsNCj4gPiArCX0NCj4gPiAr
DQo+ID4gKwlpZiAoIWVuZCkNCj4gPiArCQlyZXR1cm4gaV9zaXplX3JlYWQoaW5vZGUpIC0gKGlk
eCA8PCBQQUdFX0NBQ0hFX1NISUZUKTsNCj4gPiArCWVsc2UNCj4gPiArCQlyZXR1cm4gKGVuZCAt
IGlkeCkgPDwgUEFHRV9DQUNIRV9TSElGVDsNCj4gPiArfQ0KPiA+ICsNCj4gPiAgdm9pZA0KPiA+
ICBwbmZzX2dlbmVyaWNfcGdfaW5pdF93cml0ZShzdHJ1Y3QgbmZzX3BhZ2Vpb19kZXNjcmlwdG9y
ICpwZ2lvLCBzdHJ1Y3QgbmZzX3BhZ2UgKnJlcSkNCj4gPiAgew0KPiA+ICsJdTY0IHdiX3NpemU7
DQo+ID4gKwl1bnNpZ25lZCBwb2xpY3kgPSBORlNfU0VSVkVSKHBnaW8tPnBnX2lub2RlKS0+cG5m
c19jdXJyX2xkLT5mbGFncyAmDQo+ID4gKwkJCQkJCVBORlNfTEFZT1VUR0VUX1BPTElDWV9NQVNL
Ow0KPiA+ICsNCj4gPiAgCUJVR19PTihwZ2lvLT5wZ19sc2VnICE9IE5VTEwpOw0KPiA+DQo+ID4g
IAlpZiAocmVxLT53Yl9vZmZzZXQgIT0gcmVxLT53Yl9wZ2Jhc2UpIHsNCj4gPiAgCQluZnNfcGFn
ZWlvX3Jlc2V0X3dyaXRlX21kcyhwZ2lvKTsNCj4gPiAgCQlyZXR1cm47DQo+ID4gIAl9DQo+ID4g
Kw0KPiA+ICsJaWYgKHBnaW8tPnBnX2RyZXEgPT0gTlVMTCkgew0KPiA+ICsJCXN3aXRjaChwb2xp
Y3kpIHsNCj4gPiArCQljYXNlIFBORlNfTEFZT1VUR0VUX0lTSVpFOg0KPiA+ICsJCQl3Yl9zaXpl
ID0gaV9zaXplX3JlYWQocGdpby0+cGdfaW5vZGUpIC0gcmVxX29mZnNldChyZXEpOw0KPiA+ICsJ
CQlicmVhazsNCj4gPiArCQljYXNlIFBORlNfTEFZT1VUR0VUX1NFQVJDSF9IT0xFOg0KPiA+ICsJ
CQl3Yl9zaXplID0gcG5mc19udW1fY29udF9ieXRlcyhwZ2lvLT5wZ19pbm9kZSwgcmVxLT53Yl9p
bmRleCk7DQo+ID4gKwkJCWJyZWFrOw0KPiA+ICsJCWNhc2UgUE5GU19MQVlPVVRHRVRfQUxMX0ZJ
TEU6DQo+ID4gKwkJCXdiX3NpemUgPSBORlM0X01BWF9VSU5UNjQ7DQo+ID4gKwkJCWJyZWFrOw0K
PiA+ICsJCWRlZmF1bHQ6DQo+ID4gKwkJCVdBUk5fT05DRSgxLCAiaW52YWxpZCBsYXlvdXRnZXQg
cG9saWN5ICV1IiwgcG9saWN5KTsNCj4gPiArCQkJd2Jfc2l6ZSA9IFBBR0VfQ0FDSEVfU0laRTsN
Cj4gPiArCQkJYnJlYWs7DQo+ID4gKwkJfQ0KPiA+ICsJfSBlbHNlIHsNCj4gPiArCQl3Yl9zaXpl
ID0gbmZzX2RyZXFfYnl0ZXNfbGVmdChwZ2lvLT5wZ19kcmVxKTsNCj4gPiArCX0NCj4gPiArDQo+
ID4gIAlwZ2lvLT5wZ19sc2VnID0gcG5mc191cGRhdGVfbGF5b3V0KHBnaW8tPnBnX2lub2RlLA0K
PiA+ICAJCQkJCSAgIHJlcS0+d2JfY29udGV4dCwNCj4gPiAgCQkJCQkgICByZXFfb2Zmc2V0KHJl
cSksDQo+ID4gLQkJCQkJICAgcmVxLT53Yl9ieXRlcywNCj4gPiArCQkJCQkgICB3Yl9zaXplLA0K
PiA+ICAJCQkJCSAgIElPTU9ERV9SVywNCj4gPiAgCQkJCQkgICBHRlBfTk9GUyk7DQo+ID4gIAkv
KiBJZiBubyBsc2VnLCBmYWxsIGJhY2sgdG8gd3JpdGUgdGhyb3VnaCBtZHMgKi8NCj4gPiBkaWZm
IC0tZ2l0IGEvZnMvbmZzL3BuZnMuaCBiL2ZzL25mcy9wbmZzLmgNCj4gPiBpbmRleCA3NDVhYTFi
Li5jZTg2ODk0IDEwMDY0NA0KPiA+IC0tLSBhL2ZzL25mcy9wbmZzLmgNCj4gPiArKysgYi9mcy9u
ZnMvcG5mcy5oDQo+ID4gQEAgLTcxLDggKzcxLDIxIEBAIGVudW0gbGF5b3V0ZHJpdmVyX3BvbGlj
eV9mbGFncyB7DQo+ID4gIAkvKiBTaG91bGQgdGhlIHBORlMgY2xpZW50IGNvbW1pdCBhbmQgcmV0
dXJuIHRoZSBsYXlvdXQgdXBvbiBhIHNldGF0dHIgKi8NCj4gPiAgCVBORlNfTEFZT1VUUkVUX09O
X1NFVEFUVFIJPSAxIDw8IDAsDQo+ID4gIAlQTkZTX0xBWU9VVFJFVF9PTl9FUlJPUgkJPSAxIDw8
IDEsDQo+ID4gKw0KPiA+ICsJLyogTGF5b3V0Z2V0KHdyaXRlKSBsZW5ndGggcG9saWN5Og0KPiA+
ICsJICogUE5GU19MQVlPVVRHRVRfSVNJWkUsIHVzZSBvZmZzZXQtdG8taXNpemUNCj4gPiArCSAq
IFBORlNfTEFZT1VUR0VUX1NFQVJDSF9IT0xFLCB1c2Ugb2Zmc2V0LXRvLWhvbGUNCj4gPiArCSAq
IFBORlNfTEFZT1VUR0VUX0FMTF9GSUxFLCB1c2UgTkZTNF9NQVhfVUlOVDY0DQo+ID4gKwkgKi8N
Cj4gPiArCVBORlNfTEFZT1VUR0VUX0lTSVpFCQk9IDEgPDwgMiwNCj4gPiArCVBORlNfTEFZT1VU
R0VUX1NFQVJDSF9IT0xFCT0gMSA8PCAzLA0KPiA+ICsJUE5GU19MQVlPVVRHRVRfQUxMX0ZJTEUJ
CT0gMSA8PCA0LA0KPiA+ICB9Ow0KPiA+DQo+ID4gKyNkZWZpbmUgUE5GU19MQVlPVVRHRVRfUE9M
SUNZX01BU0sJKFBORlNfTEFZT1VUR0VUX0lTSVpFIHwJCVwNCj4gPiArCQkJCQkgUE5GU19MQVlP
VVRHRVRfU0VBUkNIX0hPTEUgfAlcDQo+ID4gKwkJCQkJIFBORlNfTEFZT1VUR0VUX0FMTF9GSUxF
KQ0KPiA+ICsNCj4gPiAgc3RydWN0IG5mczRfZGV2aWNlaWRfbm9kZTsNCj4gPg0KPiA+ICAvKiBQ
ZXItbGF5b3V0IGRyaXZlciBzcGVjaWZpYyByZWdpc3RyYXRpb24gc3RydWN0dXJlICovDQo+IA0K
PiANCj4gQWxsIDMgbG9va3MgdmVyeSBnb29kIG5vdyAoZmFzdCBzY2FuIHRocm91Z2gpLiBIb3dl
dmVyIHRoZXkgbmVlZCBoZWF2eQ0KPiB0ZXN0aW5nLiBJIHdpbGwgb25seSBnZXQgdG8gdGhlbSBl
YXJseSBuZXh0IHdlZWsuDQo+IA0KPiBIb3cgZG8gdGhleSBwZXJmb3JtIGZvciB5b3U/IHBsZWFz
ZSByZXBvcnQgeW91ciBmaW5kaW5nIHdpdGggdGhlIEVNQw0KPiBzZXJ2ZXIgaXQgaXMgaW50ZXJl
c3RpbmcgdG8ga25vdy4NCj4gDQpXaXRob3V0IG9wdGltaXphdGlvbiBpbiBzZXJ2ZXIsIHRoZSBw
YXRjaHNldCBtYWtlcyBodWdlIGRpZmZlcmVuY2UgZm9yIHNlcXVlbnRpYWwgSU8uIFdpdGggcHJv
cGVyIHNlcnZlciBvcHRpbWl6YXRpb24sIEkgc3RpbGwgZ290IG5vdGljZWFibGUgcGVyZm9ybWFu
Y2UgaW1wcm92ZW1lbnQuIEJsb2NrIGxheW91dCBzZXJ2ZXIgdGVuZHMgbm90IHRvIHByZS1hbGxv
Y2F0ZSBzZWdtZW50cyB2ZXJ5IGFnZ3Jlc3NpdmVseS4gQW5kIHNlbmRpbmcgcmVhbCBJTyBzaXpl
IGhlbHBzIHNlcnZlciB0byBtYWtlIGJldHRlciBkZWNpc2lvbnMuDQoNClRoYW5rcywNClRhbw0K
DQo=
For buffer read, use offst-to-isize.
For direct read, use dreq->bytes_left.
Signed-off-by: Peng Tao <[email protected]>
---
fs/nfs/pnfs.c | 10 +++++++++-
1 files changed, 9 insertions(+), 1 deletions(-)
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index d1da23a..49d2f2d 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -1154,16 +1154,24 @@ out_forget_reply:
void
pnfs_generic_pg_init_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
{
+ u64 rd_size = req->wb_bytes;
+
BUG_ON(pgio->pg_lseg != NULL);
if (req->wb_offset != req->wb_pgbase) {
nfs_pageio_reset_read_mds(pgio);
return;
}
+
+ if (pgio->pg_dreq == NULL)
+ rd_size = i_size_read(pgio->pg_inode) - req_offset(req);
+ else
+ rd_size = nfs_dreq_bytes_left(pgio->pg_dreq);
+
pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
req->wb_context,
req_offset(req),
- req->wb_bytes,
+ rd_size,
IOMODE_READ,
GFP_KERNEL);
/* If no lseg, fall back to read through mds */
--
1.7.1.262.g5ef3d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On 08/13/2012 05:39 PM, Peng Tao wrote:
> For buffer write, use policy based mechanism to determine layoutget size.
> Currently files use whole file layout, objects use offset-to-isize, and
> blocks search next hole in inode mapping and use offset-to-hole.
>
> For direct write, just use dreq->bytes_left.
>
> Signed-off-by: Peng Tao <[email protected]>
> ---
> fs/nfs/blocklayout/blocklayout.c | 1 +
> fs/nfs/direct.c | 7 +++++
> fs/nfs/internal.h | 1 +
> fs/nfs/nfs4filelayout.c | 1 +
> fs/nfs/objlayout/objio_osd.c | 3 +-
> fs/nfs/pnfs.c | 51 +++++++++++++++++++++++++++++++++++++-
> fs/nfs/pnfs.h | 13 +++++++++
> 7 files changed, 75 insertions(+), 2 deletions(-)
>
> diff --git a/fs/nfs/blocklayout/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
> index 1093968..c4215cf 100644
> --- a/fs/nfs/blocklayout/blocklayout.c
> +++ b/fs/nfs/blocklayout/blocklayout.c
> @@ -1240,6 +1240,7 @@ static const struct nfs_pageio_ops bl_pg_write_ops = {
> static struct pnfs_layoutdriver_type blocklayout_type = {
> .id = LAYOUT_BLOCK_VOLUME,
> .name = "LAYOUT_BLOCK_VOLUME",
> + .flags = PNFS_LAYOUTGET_SEARCH_HOLE,
> .read_pagelist = bl_read_pagelist,
> .write_pagelist = bl_write_pagelist,
> .alloc_layout_hdr = bl_alloc_layout_hdr,
> diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
> index c39f775..c1899dd 100644
> --- a/fs/nfs/direct.c
> +++ b/fs/nfs/direct.c
> @@ -46,6 +46,7 @@
> #include <linux/kref.h>
> #include <linux/slab.h>
> #include <linux/task_io_accounting_ops.h>
> +#include <linux/module.h>
>
> #include <linux/nfs_fs.h>
> #include <linux/nfs_page.h>
> @@ -191,6 +192,12 @@ static void nfs_direct_req_release(struct nfs_direct_req *dreq)
> kref_put(&dreq->kref, nfs_direct_req_free);
> }
>
> +ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq)
> +{
> + return dreq->bytes_left;
> +}
> +EXPORT_SYMBOL_GPL(nfs_dreq_bytes_left);
> +
> /*
> * Collects and returns the final error value/byte-count.
> */
> diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
> index 31fdb03..e68d329 100644
> --- a/fs/nfs/internal.h
> +++ b/fs/nfs/internal.h
> @@ -464,6 +464,7 @@ static inline void nfs_inode_dio_wait(struct inode *inode)
> {
> inode_dio_wait(inode);
> }
> +extern ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq);
>
> /* nfs4proc.c */
> extern void __nfs4_read_done_cb(struct nfs_read_data *);
> diff --git a/fs/nfs/nfs4filelayout.c b/fs/nfs/nfs4filelayout.c
> index 53f94d9..f81edd7 100644
> --- a/fs/nfs/nfs4filelayout.c
> +++ b/fs/nfs/nfs4filelayout.c
> @@ -1289,6 +1289,7 @@ filelayout_get_ds_info(struct inode *inode)
> static struct pnfs_layoutdriver_type filelayout_type = {
> .id = LAYOUT_NFSV4_1_FILES,
> .name = "LAYOUT_NFSV4_1_FILES",
> + .flags = PNFS_LAYOUTGET_ALL_FILE,
> .owner = THIS_MODULE,
> .alloc_layout_hdr = filelayout_alloc_layout_hdr,
> .free_layout_hdr = filelayout_free_layout_hdr,
> diff --git a/fs/nfs/objlayout/objio_osd.c b/fs/nfs/objlayout/objio_osd.c
> index ea6d111..e487fb8 100644
> --- a/fs/nfs/objlayout/objio_osd.c
> +++ b/fs/nfs/objlayout/objio_osd.c
> @@ -638,7 +638,8 @@ static struct pnfs_layoutdriver_type objlayout_type = {
> .id = LAYOUT_OSD2_OBJECTS,
> .name = "LAYOUT_OSD2_OBJECTS",
> .flags = PNFS_LAYOUTRET_ON_SETATTR |
> - PNFS_LAYOUTRET_ON_ERROR,
> + PNFS_LAYOUTRET_ON_ERROR |
> + PNFS_LAYOUTGET_ISIZE,
>
> .alloc_layout_hdr = objlayout_alloc_layout_hdr,
> .free_layout_hdr = objlayout_free_layout_hdr,
> diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
> index 2e00fea..d1da23a 100644
> --- a/fs/nfs/pnfs.c
> +++ b/fs/nfs/pnfs.c
> @@ -29,6 +29,7 @@
>
> #include <linux/nfs_fs.h>
> #include <linux/nfs_page.h>
> +#include <linux/pagevec.h>
> #include <linux/module.h>
> #include "internal.h"
> #include "pnfs.h"
> @@ -1172,19 +1173,67 @@ pnfs_generic_pg_init_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *r
> }
> EXPORT_SYMBOL_GPL(pnfs_generic_pg_init_read);
>
> +/*
> + * Return the number of contiguous bytes for a given inode
> + * starting at page frame idx.
> + */
> +static u64 pnfs_num_cont_bytes(struct inode *inode, pgoff_t idx)
> +{
> + struct address_space *mapping = inode->i_mapping;
> + pgoff_t end;
> +
> + /* Optimize common case that writes from 0 to end of file */
> + end = DIV_ROUND_UP(i_size_read(inode), PAGE_CACHE_SIZE);
> + if (end != NFS_I(inode)->npages) {
> + rcu_read_lock();
> + end = radix_tree_next_hole(&mapping->page_tree, idx + 1, ULONG_MAX);
> + rcu_read_unlock();
> + }
> +
> + if (!end)
> + return i_size_read(inode) - (idx << PAGE_CACHE_SHIFT);
> + else
> + return (end - idx) << PAGE_CACHE_SHIFT;
> +}
> +
> void
> pnfs_generic_pg_init_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
> {
> + u64 wb_size;
> + unsigned policy = NFS_SERVER(pgio->pg_inode)->pnfs_curr_ld->flags &
> + PNFS_LAYOUTGET_POLICY_MASK;
> +
> BUG_ON(pgio->pg_lseg != NULL);
>
> if (req->wb_offset != req->wb_pgbase) {
> nfs_pageio_reset_write_mds(pgio);
> return;
> }
> +
> + if (pgio->pg_dreq == NULL) {
> + switch(policy) {
> + case PNFS_LAYOUTGET_ISIZE:
> + wb_size = i_size_read(pgio->pg_inode) - req_offset(req);
> + break;
> + case PNFS_LAYOUTGET_SEARCH_HOLE:
> + wb_size = pnfs_num_cont_bytes(pgio->pg_inode, req->wb_index);
> + break;
> + case PNFS_LAYOUTGET_ALL_FILE:
> + wb_size = NFS4_MAX_UINT64;
> + break;
> + default:
> + WARN_ONCE(1, "invalid layoutget policy %u", policy);
> + wb_size = PAGE_CACHE_SIZE;
> + break;
> + }
> + } else {
> + wb_size = nfs_dreq_bytes_left(pgio->pg_dreq);
> + }
> +
> pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
> req->wb_context,
> req_offset(req),
> - req->wb_bytes,
> + wb_size,
> IOMODE_RW,
> GFP_NOFS);
> /* If no lseg, fall back to write through mds */
> diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h
> index 745aa1b..ce86894 100644
> --- a/fs/nfs/pnfs.h
> +++ b/fs/nfs/pnfs.h
> @@ -71,8 +71,21 @@ enum layoutdriver_policy_flags {
> /* Should the pNFS client commit and return the layout upon a setattr */
> PNFS_LAYOUTRET_ON_SETATTR = 1 << 0,
> PNFS_LAYOUTRET_ON_ERROR = 1 << 1,
> +
> + /* Layoutget(write) length policy:
> + * PNFS_LAYOUTGET_ISIZE, use offset-to-isize
> + * PNFS_LAYOUTGET_SEARCH_HOLE, use offset-to-hole
> + * PNFS_LAYOUTGET_ALL_FILE, use NFS4_MAX_UINT64
> + */
> + PNFS_LAYOUTGET_ISIZE = 1 << 2,
> + PNFS_LAYOUTGET_SEARCH_HOLE = 1 << 3,
> + PNFS_LAYOUTGET_ALL_FILE = 1 << 4,
> };
>
> +#define PNFS_LAYOUTGET_POLICY_MASK (PNFS_LAYOUTGET_ISIZE | \
> + PNFS_LAYOUTGET_SEARCH_HOLE | \
> + PNFS_LAYOUTGET_ALL_FILE)
> +
> struct nfs4_deviceid_node;
>
> /* Per-layout driver specific registration structure */
All 3 looks very good now (fast scan through). However they need heavy
testing. I will only get to them early next week.
How do they perform for you? please report your finding with the EMC
server it is interesting to know.
Thanks for working on this
Boaz
On 08/14/2012 03:42 AM, Myklebust, Trond wrote:
<>
>> void
>> pnfs_generic_pg_init_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
>> {
>> + u64 wb_size;
>> + unsigned policy = NFS_SERVER(pgio->pg_inode)->pnfs_curr_ld->flags &
>> + PNFS_LAYOUTGET_POLICY_MASK;
>> +
>> BUG_ON(pgio->pg_lseg != NULL);
>>
>> if (req->wb_offset != req->wb_pgbase) {
>> nfs_pageio_reset_write_mds(pgio);
>> return;
>> }
>> +
>> + if (pgio->pg_dreq == NULL) {
>> + switch(policy) {
>> + case PNFS_LAYOUTGET_ISIZE:
>> + wb_size = i_size_read(pgio->pg_inode) - req_offset(req);
>> + break;
>> + case PNFS_LAYOUTGET_SEARCH_HOLE:
>> + wb_size = pnfs_num_cont_bytes(pgio->pg_inode, req->wb_index);
>> + break;
>> + case PNFS_LAYOUTGET_ALL_FILE:
>> + wb_size = NFS4_MAX_UINT64;
>> + break;
>> + default:
>> + WARN_ONCE(1, "invalid layoutget policy %u", policy);
>> + wb_size = PAGE_CACHE_SIZE;
>> + break;
>> + }
>> + } else {
>> + wb_size = nfs_dreq_bytes_left(pgio->pg_dreq);
>> + }
>> +
>
> Please just calculate the correct value for wb_size inside
> bl_pg_init_write(), and pass it as an extra parameter to
> pnfs_generic_pg_init_write().
>
> Then add pnfs_pg_init_object_write for objects, that calls the modified
> pnfs_generic_pg_init_write() with the PNFS_LAYOUTGET_ISIZE value.
>
Lets please completely kill pnfs_generic_pg_init_write() just like
files did. It gives us nothing and specialty now it is more compact
code to just inline it, like nfs4filelayout.c did.
But please do this on top of my pending patches for 3.6-rcX. They touch
exactly this code in objects.
> Files don't call this function, so adding the PNFS_LAYOUTGET_ALL_FILE
> isn't needed.
BTW:
filelayout_pg_init_read()
and
pnfs_generic_pg_init_read()
Is char-by-char Identical, except the very good added comment in
filelayout_pg_init_read(). Can be merged.
Thanks
Boaz
For buffer write, use policy based mechanism to determine layoutget size.
Currently files use whole file layout, objects use offset-to-isize, and
blocks search next hole in inode mapping and use offset-to-hole.
For direct write, just use dreq->bytes_left.
Signed-off-by: Peng Tao <[email protected]>
---
fs/nfs/blocklayout/blocklayout.c | 1 +
fs/nfs/direct.c | 7 +++++
fs/nfs/internal.h | 1 +
fs/nfs/nfs4filelayout.c | 1 +
fs/nfs/objlayout/objio_osd.c | 3 +-
fs/nfs/pnfs.c | 51 +++++++++++++++++++++++++++++++++++++-
fs/nfs/pnfs.h | 13 +++++++++
7 files changed, 75 insertions(+), 2 deletions(-)
diff --git a/fs/nfs/blocklayout/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
index 1093968..c4215cf 100644
--- a/fs/nfs/blocklayout/blocklayout.c
+++ b/fs/nfs/blocklayout/blocklayout.c
@@ -1240,6 +1240,7 @@ static const struct nfs_pageio_ops bl_pg_write_ops = {
static struct pnfs_layoutdriver_type blocklayout_type = {
.id = LAYOUT_BLOCK_VOLUME,
.name = "LAYOUT_BLOCK_VOLUME",
+ .flags = PNFS_LAYOUTGET_SEARCH_HOLE,
.read_pagelist = bl_read_pagelist,
.write_pagelist = bl_write_pagelist,
.alloc_layout_hdr = bl_alloc_layout_hdr,
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index c39f775..c1899dd 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -46,6 +46,7 @@
#include <linux/kref.h>
#include <linux/slab.h>
#include <linux/task_io_accounting_ops.h>
+#include <linux/module.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_page.h>
@@ -191,6 +192,12 @@ static void nfs_direct_req_release(struct nfs_direct_req *dreq)
kref_put(&dreq->kref, nfs_direct_req_free);
}
+ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq)
+{
+ return dreq->bytes_left;
+}
+EXPORT_SYMBOL_GPL(nfs_dreq_bytes_left);
+
/*
* Collects and returns the final error value/byte-count.
*/
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 31fdb03..e68d329 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -464,6 +464,7 @@ static inline void nfs_inode_dio_wait(struct inode *inode)
{
inode_dio_wait(inode);
}
+extern ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq);
/* nfs4proc.c */
extern void __nfs4_read_done_cb(struct nfs_read_data *);
diff --git a/fs/nfs/nfs4filelayout.c b/fs/nfs/nfs4filelayout.c
index 53f94d9..f81edd7 100644
--- a/fs/nfs/nfs4filelayout.c
+++ b/fs/nfs/nfs4filelayout.c
@@ -1289,6 +1289,7 @@ filelayout_get_ds_info(struct inode *inode)
static struct pnfs_layoutdriver_type filelayout_type = {
.id = LAYOUT_NFSV4_1_FILES,
.name = "LAYOUT_NFSV4_1_FILES",
+ .flags = PNFS_LAYOUTGET_ALL_FILE,
.owner = THIS_MODULE,
.alloc_layout_hdr = filelayout_alloc_layout_hdr,
.free_layout_hdr = filelayout_free_layout_hdr,
diff --git a/fs/nfs/objlayout/objio_osd.c b/fs/nfs/objlayout/objio_osd.c
index ea6d111..e487fb8 100644
--- a/fs/nfs/objlayout/objio_osd.c
+++ b/fs/nfs/objlayout/objio_osd.c
@@ -638,7 +638,8 @@ static struct pnfs_layoutdriver_type objlayout_type = {
.id = LAYOUT_OSD2_OBJECTS,
.name = "LAYOUT_OSD2_OBJECTS",
.flags = PNFS_LAYOUTRET_ON_SETATTR |
- PNFS_LAYOUTRET_ON_ERROR,
+ PNFS_LAYOUTRET_ON_ERROR |
+ PNFS_LAYOUTGET_ISIZE,
.alloc_layout_hdr = objlayout_alloc_layout_hdr,
.free_layout_hdr = objlayout_free_layout_hdr,
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index 2e00fea..d1da23a 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -29,6 +29,7 @@
#include <linux/nfs_fs.h>
#include <linux/nfs_page.h>
+#include <linux/pagevec.h>
#include <linux/module.h>
#include "internal.h"
#include "pnfs.h"
@@ -1172,19 +1173,67 @@ pnfs_generic_pg_init_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *r
}
EXPORT_SYMBOL_GPL(pnfs_generic_pg_init_read);
+/*
+ * Return the number of contiguous bytes for a given inode
+ * starting at page frame idx.
+ */
+static u64 pnfs_num_cont_bytes(struct inode *inode, pgoff_t idx)
+{
+ struct address_space *mapping = inode->i_mapping;
+ pgoff_t end;
+
+ /* Optimize common case that writes from 0 to end of file */
+ end = DIV_ROUND_UP(i_size_read(inode), PAGE_CACHE_SIZE);
+ if (end != NFS_I(inode)->npages) {
+ rcu_read_lock();
+ end = radix_tree_next_hole(&mapping->page_tree, idx + 1, ULONG_MAX);
+ rcu_read_unlock();
+ }
+
+ if (!end)
+ return i_size_read(inode) - (idx << PAGE_CACHE_SHIFT);
+ else
+ return (end - idx) << PAGE_CACHE_SHIFT;
+}
+
void
pnfs_generic_pg_init_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
{
+ u64 wb_size;
+ unsigned policy = NFS_SERVER(pgio->pg_inode)->pnfs_curr_ld->flags &
+ PNFS_LAYOUTGET_POLICY_MASK;
+
BUG_ON(pgio->pg_lseg != NULL);
if (req->wb_offset != req->wb_pgbase) {
nfs_pageio_reset_write_mds(pgio);
return;
}
+
+ if (pgio->pg_dreq == NULL) {
+ switch(policy) {
+ case PNFS_LAYOUTGET_ISIZE:
+ wb_size = i_size_read(pgio->pg_inode) - req_offset(req);
+ break;
+ case PNFS_LAYOUTGET_SEARCH_HOLE:
+ wb_size = pnfs_num_cont_bytes(pgio->pg_inode, req->wb_index);
+ break;
+ case PNFS_LAYOUTGET_ALL_FILE:
+ wb_size = NFS4_MAX_UINT64;
+ break;
+ default:
+ WARN_ONCE(1, "invalid layoutget policy %u", policy);
+ wb_size = PAGE_CACHE_SIZE;
+ break;
+ }
+ } else {
+ wb_size = nfs_dreq_bytes_left(pgio->pg_dreq);
+ }
+
pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
req->wb_context,
req_offset(req),
- req->wb_bytes,
+ wb_size,
IOMODE_RW,
GFP_NOFS);
/* If no lseg, fall back to write through mds */
diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h
index 745aa1b..ce86894 100644
--- a/fs/nfs/pnfs.h
+++ b/fs/nfs/pnfs.h
@@ -71,8 +71,21 @@ enum layoutdriver_policy_flags {
/* Should the pNFS client commit and return the layout upon a setattr */
PNFS_LAYOUTRET_ON_SETATTR = 1 << 0,
PNFS_LAYOUTRET_ON_ERROR = 1 << 1,
+
+ /* Layoutget(write) length policy:
+ * PNFS_LAYOUTGET_ISIZE, use offset-to-isize
+ * PNFS_LAYOUTGET_SEARCH_HOLE, use offset-to-hole
+ * PNFS_LAYOUTGET_ALL_FILE, use NFS4_MAX_UINT64
+ */
+ PNFS_LAYOUTGET_ISIZE = 1 << 2,
+ PNFS_LAYOUTGET_SEARCH_HOLE = 1 << 3,
+ PNFS_LAYOUTGET_ALL_FILE = 1 << 4,
};
+#define PNFS_LAYOUTGET_POLICY_MASK (PNFS_LAYOUTGET_ISIZE | \
+ PNFS_LAYOUTGET_SEARCH_HOLE | \
+ PNFS_LAYOUTGET_ALL_FILE)
+
struct nfs4_deviceid_node;
/* Per-layout driver specific registration structure */
--
1.7.1.262.g5ef3d