From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Skidmore, Donald C" Subject: RE: [PATCH v5 3/3] ixgbe: Add new ndo to trust VF Date: Wed, 20 May 2015 18:14:15 +0000 Message-ID: References: <7F861DC0615E0C47A872E6F3C5FCDDBD05EB28F4@BPXM14GP.gisp.nec.co.jp> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: Or Gerlitz , David Miller , Linux Netdev List , "nhorman@redhat.com" , "sassmann@redhat.com" , "jogreene@redhat.com" , "Choi, Sy Jong" , Edward Cree , Rony Efraim To: Hiroshi Shimamoto , "Kirsher, Jeffrey T" , "intel-wired-lan@lists.osuosl.org" Return-path: Received: from mga14.intel.com ([192.55.52.115]:36577 "EHLO mga14.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754519AbbETSOR (ORCPT ); Wed, 20 May 2015 14:14:17 -0400 In-Reply-To: <7F861DC0615E0C47A872E6F3C5FCDDBD05EB28F4@BPXM14GP.gisp.nec.co.jp> Content-Language: en-US Sender: netdev-owner@vger.kernel.org List-ID: PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiBGcm9tOiBIaXJvc2hpIFNoaW1hbW90byBb bWFpbHRvOmgtc2hpbWFtb3RvQGN0LmpwLm5lYy5jb21dDQo+IFNlbnQ6IFR1ZXNkYXksIE1heSAx OSwgMjAxNSA1OjA2IFBNDQo+IFRvOiBLaXJzaGVyLCBKZWZmcmV5IFQ7IGludGVsLXdpcmVkLWxh bkBsaXN0cy5vc3Vvc2wub3JnDQo+IENjOiBTa2lkbW9yZSwgRG9uYWxkIEM7IE9yIEdlcmxpdHo7 IERhdmlkIE1pbGxlcjsgTGludXggTmV0ZGV2IExpc3Q7DQo+IG5ob3JtYW5AcmVkaGF0LmNvbTsg c2Fzc21hbm5AcmVkaGF0LmNvbTsgam9ncmVlbmVAcmVkaGF0LmNvbTsNCj4gQ2hvaSwgU3kgSm9u ZzsgRWR3YXJkIENyZWU7IFJvbnkgRWZyYWltDQo+IFN1YmplY3Q6IFtQQVRDSCB2NSAzLzNdIGl4 Z2JlOiBBZGQgbmV3IG5kbyB0byB0cnVzdCBWRg0KPiANCj4gRnJvbTogSGlyb3NoaSBTaGltYW1v dG8gPGgtc2hpbWFtb3RvQGN0LmpwLm5lYy5jb20+DQo+IA0KPiBJbXBsZW1lbnQgdGhlIG5ldyBu ZXRkZXYgb3AgdG8gdHJ1c3QgVkYgaW4gaXhnYmUgYW5kIG1ha2UgVkYgbXVsdGljYXN0DQo+IHBy b21pc2N1b3VzIG1vZGUgZW5hYmxlZCBvbmx5IGluIHRydXN0ZWQgVkYuDQo+IA0KPiBUaGUgYWRt aW5pc3RyYXRvciBjYW4gbWFrZSBWRiB0cnVzdGVkIGJ5IGlwIGNvbW1hbmQgd2hpY2ggc3VwcG9y dHMgdHJ1c3QNCj4gbWVzc2FnZS4NCj4gICMgaXAgbGluayBzZXQgZGV2IGV0aDAgdmYgMSB0cnVz dCBvbg0KPiANCj4gQWZ0ZXIgbWFraW5nIFZGIHVudHJ1c3RlZCwgaXhnYmUgZGlzYWJsZXMgVkYg bXVsdGljYXN0IHByb21pc2N1b3VzIGZlYXR1cmUNCj4gcmVxdWVzdGVkIGZyb20gVkYuDQo+ICAj IGlwIGxpbmsgc2V0IGRldiBldGgwIHZmIDEgdHJ1c3Qgb2ZmDQo+IA0KPiBPbmx5IHRydXN0ZWQg VkYgY2FuIGVuYWJsZSBWRiBtdWx0aWNhc3QgcHJvbWlzY3VvdXMgbW9kZSBhbmQgaGFuZGxlIG92 ZXINCj4gMzAgSVB2NiBhZGRyZXNzZXMgb24gVk0sIGJlY2F1c2UgVkYgbXVsdGljYXN0IHByb21p c2N1b3VzIG1vZGUgbWF5IGh1cnQNCj4gcGVyZm9ybWFuY2UuDQo+IA0KPiBTaWduZWQtb2ZmLWJ5 OiBIaXJvc2hpIFNoaW1hbW90byA8aC1zaGltYW1vdG9AY3QuanAubmVjLmNvbT4NCj4gUmV2aWV3 ZWQtYnk6IEhheWF0byBNb21tYSA8aC1tb21tYUBjZS5qcC5uZWMuY29tPg0KPiBDQzogQ2hvaSwg U3kgSm9uZyA8c3kuam9uZy5jaG9pQGludGVsLmNvbT4NCj4gLS0tDQo+ICBkcml2ZXJzL25ldC9l dGhlcm5ldC9pbnRlbC9peGdiZS9peGdiZS5oICAgICAgIHwgIDEgKw0KPiAgZHJpdmVycy9uZXQv ZXRoZXJuZXQvaW50ZWwvaXhnYmUvaXhnYmVfbWFpbi5jICB8ICA1ICsrKysNCj4gZHJpdmVycy9u ZXQvZXRoZXJuZXQvaW50ZWwvaXhnYmUvaXhnYmVfc3Jpb3YuYyB8IDM4DQo+ICsrKysrKysrKysr KysrKysrKysrKysrLS0tDQo+IGRyaXZlcnMvbmV0L2V0aGVybmV0L2ludGVsL2l4Z2JlL2l4Z2Jl X3NyaW92LmggfCAgMiArKw0KPiAgNCBmaWxlcyBjaGFuZ2VkLCA0MiBpbnNlcnRpb25zKCspLCA0 IGRlbGV0aW9ucygtKQ0KPiANCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2lu dGVsL2l4Z2JlL2l4Z2JlLmgNCj4gYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9pbnRlbC9peGdiZS9p eGdiZS5oDQo+IGluZGV4IDA4ZTY1YjYuLjUxODFhNGQgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMv bmV0L2V0aGVybmV0L2ludGVsL2l4Z2JlL2l4Z2JlLmgNCj4gKysrIGIvZHJpdmVycy9uZXQvZXRo ZXJuZXQvaW50ZWwvaXhnYmUvaXhnYmUuaA0KPiBAQCAtMTUzLDYgKzE1Myw3IEBAIHN0cnVjdCB2 Zl9kYXRhX3N0b3JhZ2Ugew0KPiAgCXUxNiB2bGFuX2NvdW50Ow0KPiAgCXU4IHNwb29mY2hrX2Vu YWJsZWQ7DQo+ICAJYm9vbCByc3NfcXVlcnlfZW5hYmxlZDsNCj4gKwl1OCB0cnVzdGVkOw0KPiAg CXVuc2lnbmVkIGludCB2Zl9hcGk7DQo+ICB9Ow0KPiANCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv bmV0L2V0aGVybmV0L2ludGVsL2l4Z2JlL2l4Z2JlX21haW4uYw0KPiBiL2RyaXZlcnMvbmV0L2V0 aGVybmV0L2ludGVsL2l4Z2JlL2l4Z2JlX21haW4uYw0KPiBpbmRleCBiMWVhNzA3Li4yNjNjYjQw IDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9pbnRlbC9peGdiZS9peGdiZV9t YWluLmMNCj4gKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvaW50ZWwvaXhnYmUvaXhnYmVfbWFp bi5jDQo+IEBAIC0zNjc5LDYgKzM2NzksMTAgQEAgc3RhdGljIHZvaWQgaXhnYmVfY29uZmlndXJl X3ZpcnR1YWxpemF0aW9uKHN0cnVjdA0KPiBpeGdiZV9hZGFwdGVyICphZGFwdGVyKQ0KPiAgCQkv KiBFbmFibGUvRGlzYWJsZSBSU1MgcXVlcnkgZmVhdHVyZSAgKi8NCj4gIAkJaXhnYmVfbmRvX3Nl dF92Zl9yc3NfcXVlcnlfZW4oYWRhcHRlci0+bmV0ZGV2LCBpLA0KPiAgCQkJCQkgIGFkYXB0ZXIt DQo+ID52ZmluZm9baV0ucnNzX3F1ZXJ5X2VuYWJsZWQpOw0KPiArDQo+ICsJCS8qIFJlY29uZmln dXJlIGZlYXR1cmVzIGluIHRydXN0ZWQgKi8NCj4gKwkJaXhnYmVfbmRvX3NldF92Zl90cnVzdChh ZGFwdGVyLT5uZXRkZXYsIGksDQo+ICsJCQkJICAgICAgIGFkYXB0ZXItPnZmaW5mb1tpXS50cnVz dGVkKTsNCj4gIAl9DQo+ICB9DQo+IA0KPiBAQCAtODE4Miw2ICs4MTg2LDcgQEAgc3RhdGljIGNv bnN0IHN0cnVjdCBuZXRfZGV2aWNlX29wcw0KPiBpeGdiZV9uZXRkZXZfb3BzID0gew0KPiAgCS5u ZG9fc2V0X3ZmX3JhdGUJPSBpeGdiZV9uZG9fc2V0X3ZmX2J3LA0KPiAgCS5uZG9fc2V0X3ZmX3Nw b29mY2hrCT0gaXhnYmVfbmRvX3NldF92Zl9zcG9vZmNoaywNCj4gIAkubmRvX3NldF92Zl9yc3Nf cXVlcnlfZW4gPSBpeGdiZV9uZG9fc2V0X3ZmX3Jzc19xdWVyeV9lbiwNCj4gKwkubmRvX3NldF92 Zl90cnVzdAk9IGl4Z2JlX25kb19zZXRfdmZfdHJ1c3QsDQo+ICAJLm5kb19nZXRfdmZfY29uZmln CT0gaXhnYmVfbmRvX2dldF92Zl9jb25maWcsDQo+ICAJLm5kb19nZXRfc3RhdHM2NAk9IGl4Z2Jl X2dldF9zdGF0czY0LA0KPiAgI2lmZGVmIENPTkZJR19JWEdCRV9EQ0INCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvbmV0L2V0aGVybmV0L2ludGVsL2l4Z2JlL2l4Z2JlX3NyaW92LmMNCj4gYi9kcml2 ZXJzL25ldC9ldGhlcm5ldC9pbnRlbC9peGdiZS9peGdiZV9zcmlvdi5jDQo+IGluZGV4IDYxNWY2 NTEuLjZjNjAyYmMgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L2ludGVsL2l4 Z2JlL2l4Z2JlX3NyaW92LmMNCj4gKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvaW50ZWwvaXhn YmUvaXhnYmVfc3Jpb3YuYw0KPiBAQCAtMTE3LDggKzExNywxMSBAQCBzdGF0aWMgaW50IF9faXhn YmVfZW5hYmxlX3NyaW92KHN0cnVjdCBpeGdiZV9hZGFwdGVyDQo+ICphZGFwdGVyKQ0KPiAgCQkJ ICovDQo+ICAJCQlhZGFwdGVyLT52ZmluZm9baV0ucnNzX3F1ZXJ5X2VuYWJsZWQgPSAwOw0KPiAN Cj4gLQkJCS8qIFR1cm4gbXVsdGljYXN0IHByb21pc2N1b3VzIG1vZGUgb2ZmIGZvciBhbGwgVkZz ICovDQo+ICsJCQkvKiBEaXNhbGxvdyBWRiBtdWx0aWNhc3QgcHJvbWlzY3VvdXMgY2FwYWJpbGl0 eQ0KPiArCQkJICogYW5kIHR1cm4gaXQgb2ZmIGZvciBhbGwgVkZzDQo+ICsJCQkgKi8NCj4gIAkJ CWFkYXB0ZXItPnZmaW5mb1tpXS5tY19wcm9taXNjID0gZmFsc2U7DQo+ICsJCQlhZGFwdGVyLT52 ZmluZm9baV0udHJ1c3RlZCA9IGZhbHNlOw0KPiAgCQl9DQo+IA0KPiAgCQlyZXR1cm4gMDsNCj4g QEAgLTMyOSw5ICszMzIsMTQgQEAgc3RhdGljIGludCBpeGdiZV9lbmFibGVfdmZfbWNfcHJvbWlz YyhzdHJ1Y3QNCj4gaXhnYmVfYWRhcHRlciAqYWRhcHRlciwgdTMyIHZmKQ0KPiAgCWh3ID0gJmFk YXB0ZXItPmh3Ow0KPiAgCXZtb2xyID0gSVhHQkVfUkVBRF9SRUcoaHcsIElYR0JFX1ZNT0xSKHZm KSk7DQo+IA0KPiAtCWVfaW5mbyhkcnYsICJWRiAldTogZW5hYmxpbmcgbXVsdGljYXN0IHByb21p c2N1b3VzXG4iLCB2Zik7DQo+IC0NCj4gLQl2bW9sciB8PSBJWEdCRV9WTU9MUl9NUEU7DQo+ICsJ aWYgKGFkYXB0ZXItPnZmaW5mb1t2Zl0udHJ1c3RlZCkgew0KPiArCQllX2luZm8oZHJ2LCAiVkYg JXU6IGVuYWJsaW5nIG11bHRpY2FzdCBwcm9taXNjdW91c1xuIiwgdmYpOw0KPiArCQl2bW9sciB8 PSBJWEdCRV9WTU9MUl9NUEU7DQo+ICsJfSBlbHNlIHsNCj4gKwkJZV9pbmZvKGRydiwgIlZGICV1 OiBkaXNhYmxpbmcgbXVsdGljYXN0IHByb21pc2N1b3VzICINCj4gKwkJICAgICAgICJvbiB1bnRy dXN0ZWQgVkYuXG4iLCB2Zik7DQo+ICsJCXZtb2xyICY9IH5JWEdCRV9WTU9MUl9NUEU7DQo+ICsJ fQ0KPiANCj4gIAlJWEdCRV9XUklURV9SRUcoaHcsIElYR0JFX1ZNT0xSKHZmKSwgdm1vbHIpOw0K PiANCj4gQEAgLTE0OTIsNiArMTUwMCwyNyBAQCBpbnQgaXhnYmVfbmRvX3NldF92Zl9yc3NfcXVl cnlfZW4oc3RydWN0DQo+IG5ldF9kZXZpY2UgKm5ldGRldiwgaW50IHZmLA0KPiAgCXJldHVybiAw Ow0KPiAgfQ0KPiANCj4gK2ludCBpeGdiZV9uZG9fc2V0X3ZmX3RydXN0KHN0cnVjdCBuZXRfZGV2 aWNlICpuZXRkZXYsIGludCB2ZiwgYm9vbA0KPiArc2V0dGluZykgew0KPiArCXN0cnVjdCBpeGdi ZV9hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsNCj4gKw0KPiArCWlmICh2 ZiA+PSBhZGFwdGVyLT5udW1fdmZzKQ0KPiArCQlyZXR1cm4gLUVJTlZBTDsNCj4gKw0KPiArCS8q IG5vdGhpbmcgdG8gZG8gKi8NCj4gKwlpZiAoYWRhcHRlci0+dmZpbmZvW3ZmXS50cnVzdGVkID09 IHNldHRpbmcpDQo+ICsJCXJldHVybiAwOw0KPiArDQo+ICsJYWRhcHRlci0+dmZpbmZvW3ZmXS50 cnVzdGVkID0gc2V0dGluZzsNCj4gKw0KPiArCS8qIFJlY29uZmlndXJlIGZlYXR1cmVzIHdoaWNo IGFyZSBvbmx5IGFsbG93ZWQgZm9yIHRydXN0ZWQgVkYgKi8NCj4gKwkvKiBWRiBtdWx0aWNhc3Qg cHJvbWlzY3VvdXMgbW9kZSAqLw0KPiArCWlmIChhZGFwdGVyLT52ZmluZm9bdmZdLm1jX3Byb21p c2MpDQo+ICsJCWl4Z2JlX2VuYWJsZV92Zl9tY19wcm9taXNjKGFkYXB0ZXIsIHZmKTsNCj4gKw0K PiArCXJldHVybiAwOw0KPiArfQ0KPiArDQo+ICBpbnQgaXhnYmVfbmRvX2dldF92Zl9jb25maWco c3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwNCj4gIAkJCSAgICBpbnQgdmYsIHN0cnVjdCBpZmxh X3ZmX2luZm8gKml2aSkgIHsgQEAgLTE1MDYsNSArMTUzNSw2DQo+IEBAIGludCBpeGdiZV9uZG9f Z2V0X3ZmX2NvbmZpZyhzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LA0KPiAgCWl2aS0+cW9zID0g YWRhcHRlci0+dmZpbmZvW3ZmXS5wZl9xb3M7DQo+ICAJaXZpLT5zcG9vZmNoayA9IGFkYXB0ZXIt PnZmaW5mb1t2Zl0uc3Bvb2ZjaGtfZW5hYmxlZDsNCj4gIAlpdmktPnJzc19xdWVyeV9lbiA9IGFk YXB0ZXItPnZmaW5mb1t2Zl0ucnNzX3F1ZXJ5X2VuYWJsZWQ7DQo+ICsJaXZpLT50cnVzdGVkID0g YWRhcHRlci0+dmZpbmZvW3ZmXS50cnVzdGVkOw0KPiAgCXJldHVybiAwOw0KPiAgfQ0KPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvaW50ZWwvaXhnYmUvaXhnYmVfc3Jpb3YuaA0K PiBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L2ludGVsL2l4Z2JlL2l4Z2JlX3NyaW92LmgNCj4gaW5k ZXggMmMxOTdlNi4uZDg1ZTZmYyAxMDA2NDQNCj4gLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQv aW50ZWwvaXhnYmUvaXhnYmVfc3Jpb3YuaA0KPiArKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9p bnRlbC9peGdiZS9peGdiZV9zcmlvdi5oDQo+IEBAIC00OSw2ICs0OSw4IEBAIGludCBpeGdiZV9u ZG9fc2V0X3ZmX2J3KHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYsDQo+IGludCB2ZiwgaW50IG1p bl90eF9yYXRlLCAgaW50IGl4Z2JlX25kb19zZXRfdmZfc3Bvb2ZjaGsoc3RydWN0IG5ldF9kZXZp Y2UNCj4gKm5ldGRldiwgaW50IHZmLCBib29sIHNldHRpbmcpOyAgaW50IGl4Z2JlX25kb19zZXRf dmZfcnNzX3F1ZXJ5X2VuKHN0cnVjdA0KPiBuZXRfZGV2aWNlICpuZXRkZXYsIGludCB2ZiwNCj4g IAkJCQkgIGJvb2wgc2V0dGluZyk7DQo+ICtpbnQgaXhnYmVfbmRvX3NldF92Zl90cnVzdChzdHJ1 Y3QgbmV0X2RldmljZSAqbmV0ZGV2LA0KPiArCQkJICAgIGludCB2ZiwgYm9vbCBzZXR0aW5nKTsN Cj4gIGludCBpeGdiZV9uZG9fZ2V0X3ZmX2NvbmZpZyhzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2 LA0KPiAgCQkJICAgIGludCB2Ziwgc3RydWN0IGlmbGFfdmZfaW5mbyAqaXZpKTsgIHZvaWQNCj4g aXhnYmVfY2hlY2tfdmZfcmF0ZV9saW1pdChzdHJ1Y3QgaXhnYmVfYWRhcHRlciAqYWRhcHRlcik7 DQo+IC0tDQo+IDEuOC4zLjENCg0KSGV5IEhpcm9zaGksDQoNCkluIGdlbmVyYWwgSSBsaWtlIHlv dXIgcGF0Y2ggc2V0LiAgIFRoZXJlIGlzIGEgbGl0dGxlIGNvbXBsZXhpdHkgSeKAmW0gbm90IHN1 cmUgSSB1bmRlcnN0YW5kLiAgSSdtIGFzc3VtaW5nIHRoYXQ6DQoNCiBhZGFwdGVyLT52ZmluZm9b dmZdLnRydXN0ZWQgLSBDbGVhcmx5IHN0b3JlcyBpZiB0aGUgUEYgdHJ1c3RzIGEgZ2l2ZW4gVkYg KGkuZS4gYWxsb3dzIGl0IHRvIGdvIGludG8gInJpc2t5IiBjb25maWd1cmF0aW9ucykNCg0KV2hh dCBJJ20gYSBiaXQgdW5jbGVhciBhYm91dCBpczoNCg0KYWRhcHRlci0+dmZpbmZvW3ZmXS5tY19w cm9taXNjIC0gVGhpcyBzZWVtcyB0byByZWNvcmQgdGhhdCB0aGUgVkYgYXQgb25lIHRpbWUgYXMg cmVxdWVzdGVkIG92ZXIgMzAgTUMuDQoNCkkgZG9uJ3QgdW5kZXJzdGFuZCB0aGUgcmVhc29uIGZv ciB0aGlzIGJpdC4gIFdvdWxkbid0IGl0IGJlIHNpbXBsZXIgYW5kIG1vcmUgc3RyYWlnaHRmb3J3 YXJkIHRvIHNpbXBseSB1c2UgdGhlIHRydXN0ZWQgYml0PyAgIEkgZ3Vlc3Mgc3BlY2lmaWNhbGx5 IEkgZG9uJ3QgdW5kZXJzdGFuZCB3aHkgd2Ugd291bGQgY2FsbCBpeGdiZV9lbmFibGVfdmZfbWNf cHJvbWlzYygpIGluIGl4Z2JlX25kb19zZXRfdmZfdHJ1c3QoKSBpZiBtY19wcm9taXNjIGlzIHNl dC4gIFdvdWxkbid0IGp1c3Qgc2V0dGluZyB0aGUgdHJ1c3RlZCBiaXQgYWxsb3cgdGhlIG5leHQg SVhHQkVfVkZfU0VUX01DX1BST01JU0MgbWFpbGJveCBtZXNzYWdlIHRvIChwb3NzaWJseSkgdHVy biBvbiBNQyBQcm9taXNjIG1vZGU/DQoNClRoYW5rcywNCi1Eb24gU2tpZG1vcmUgPGRvbmFsZC5j LnNraWRtb3JlQGludGVsLmNvbT4NCg0KDQo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: Skidmore, Donald C Date: Wed, 20 May 2015 18:14:15 +0000 Subject: [Intel-wired-lan] [PATCH v5 3/3] ixgbe: Add new ndo to trust VF In-Reply-To: <7F861DC0615E0C47A872E6F3C5FCDDBD05EB28F4@BPXM14GP.gisp.nec.co.jp> References: <7F861DC0615E0C47A872E6F3C5FCDDBD05EB28F4@BPXM14GP.gisp.nec.co.jp> Message-ID: MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: intel-wired-lan@osuosl.org List-ID: > -----Original Message----- > From: Hiroshi Shimamoto [mailto:h-shimamoto at ct.jp.nec.com] > Sent: Tuesday, May 19, 2015 5:06 PM > To: Kirsher, Jeffrey T; intel-wired-lan at lists.osuosl.org > Cc: Skidmore, Donald C; Or Gerlitz; David Miller; Linux Netdev List; > nhorman at redhat.com; sassmann at redhat.com; jogreene at redhat.com; > Choi, Sy Jong; Edward Cree; Rony Efraim > Subject: [PATCH v5 3/3] ixgbe: Add new ndo to trust VF > > From: Hiroshi Shimamoto > > Implement the new netdev op to trust VF in ixgbe and make VF multicast > promiscuous mode enabled only in trusted VF. > > The administrator can make VF trusted by ip command which supports trust > message. > # ip link set dev eth0 vf 1 trust on > > After making VF untrusted, ixgbe disables VF multicast promiscuous feature > requested from VF. > # ip link set dev eth0 vf 1 trust off > > Only trusted VF can enable VF multicast promiscuous mode and handle over > 30 IPv6 addresses on VM, because VF multicast promiscuous mode may hurt > performance. > > Signed-off-by: Hiroshi Shimamoto > Reviewed-by: Hayato Momma > CC: Choi, Sy Jong > --- > drivers/net/ethernet/intel/ixgbe/ixgbe.h | 1 + > drivers/net/ethernet/intel/ixgbe/ixgbe_main.c | 5 ++++ > drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c | 38 > +++++++++++++++++++++++--- > drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.h | 2 ++ > 4 files changed, 42 insertions(+), 4 deletions(-) > > diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe.h > b/drivers/net/ethernet/intel/ixgbe/ixgbe.h > index 08e65b6..5181a4d 100644 > --- a/drivers/net/ethernet/intel/ixgbe/ixgbe.h > +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe.h > @@ -153,6 +153,7 @@ struct vf_data_storage { > u16 vlan_count; > u8 spoofchk_enabled; > bool rss_query_enabled; > + u8 trusted; > unsigned int vf_api; > }; > > diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c > b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c > index b1ea707..263cb40 100644 > --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c > +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c > @@ -3679,6 +3679,10 @@ static void ixgbe_configure_virtualization(struct > ixgbe_adapter *adapter) > /* Enable/Disable RSS query feature */ > ixgbe_ndo_set_vf_rss_query_en(adapter->netdev, i, > adapter- > >vfinfo[i].rss_query_enabled); > + > + /* Reconfigure features in trusted */ > + ixgbe_ndo_set_vf_trust(adapter->netdev, i, > + adapter->vfinfo[i].trusted); > } > } > > @@ -8182,6 +8186,7 @@ static const struct net_device_ops > ixgbe_netdev_ops = { > .ndo_set_vf_rate = ixgbe_ndo_set_vf_bw, > .ndo_set_vf_spoofchk = ixgbe_ndo_set_vf_spoofchk, > .ndo_set_vf_rss_query_en = ixgbe_ndo_set_vf_rss_query_en, > + .ndo_set_vf_trust = ixgbe_ndo_set_vf_trust, > .ndo_get_vf_config = ixgbe_ndo_get_vf_config, > .ndo_get_stats64 = ixgbe_get_stats64, > #ifdef CONFIG_IXGBE_DCB > diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c > b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c > index 615f651..6c602bc 100644 > --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c > +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c > @@ -117,8 +117,11 @@ static int __ixgbe_enable_sriov(struct ixgbe_adapter > *adapter) > */ > adapter->vfinfo[i].rss_query_enabled = 0; > > - /* Turn multicast promiscuous mode off for all VFs */ > + /* Disallow VF multicast promiscuous capability > + * and turn it off for all VFs > + */ > adapter->vfinfo[i].mc_promisc = false; > + adapter->vfinfo[i].trusted = false; > } > > return 0; > @@ -329,9 +332,14 @@ static int ixgbe_enable_vf_mc_promisc(struct > ixgbe_adapter *adapter, u32 vf) > hw = &adapter->hw; > vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf)); > > - e_info(drv, "VF %u: enabling multicast promiscuous\n", vf); > - > - vmolr |= IXGBE_VMOLR_MPE; > + if (adapter->vfinfo[vf].trusted) { > + e_info(drv, "VF %u: enabling multicast promiscuous\n", vf); > + vmolr |= IXGBE_VMOLR_MPE; > + } else { > + e_info(drv, "VF %u: disabling multicast promiscuous " > + "on untrusted VF.\n", vf); > + vmolr &= ~IXGBE_VMOLR_MPE; > + } > > IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf), vmolr); > > @@ -1492,6 +1500,27 @@ int ixgbe_ndo_set_vf_rss_query_en(struct > net_device *netdev, int vf, > return 0; > } > > +int ixgbe_ndo_set_vf_trust(struct net_device *netdev, int vf, bool > +setting) { > + struct ixgbe_adapter *adapter = netdev_priv(netdev); > + > + if (vf >= adapter->num_vfs) > + return -EINVAL; > + > + /* nothing to do */ > + if (adapter->vfinfo[vf].trusted == setting) > + return 0; > + > + adapter->vfinfo[vf].trusted = setting; > + > + /* Reconfigure features which are only allowed for trusted VF */ > + /* VF multicast promiscuous mode */ > + if (adapter->vfinfo[vf].mc_promisc) > + ixgbe_enable_vf_mc_promisc(adapter, vf); > + > + return 0; > +} > + > int ixgbe_ndo_get_vf_config(struct net_device *netdev, > int vf, struct ifla_vf_info *ivi) { @@ -1506,5 +1535,6 > @@ int ixgbe_ndo_get_vf_config(struct net_device *netdev, > ivi->qos = adapter->vfinfo[vf].pf_qos; > ivi->spoofchk = adapter->vfinfo[vf].spoofchk_enabled; > ivi->rss_query_en = adapter->vfinfo[vf].rss_query_enabled; > + ivi->trusted = adapter->vfinfo[vf].trusted; > return 0; > } > diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.h > b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.h > index 2c197e6..d85e6fc 100644 > --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.h > +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.h > @@ -49,6 +49,8 @@ int ixgbe_ndo_set_vf_bw(struct net_device *netdev, > int vf, int min_tx_rate, int ixgbe_ndo_set_vf_spoofchk(struct net_device > *netdev, int vf, bool setting); int ixgbe_ndo_set_vf_rss_query_en(struct > net_device *netdev, int vf, > bool setting); > +int ixgbe_ndo_set_vf_trust(struct net_device *netdev, > + int vf, bool setting); > int ixgbe_ndo_get_vf_config(struct net_device *netdev, > int vf, struct ifla_vf_info *ivi); void > ixgbe_check_vf_rate_limit(struct ixgbe_adapter *adapter); > -- > 1.8.3.1 Hey Hiroshi, In general I like your patch set. There is a little complexity I?m not sure I understand. I'm assuming that: adapter->vfinfo[vf].trusted - Clearly stores if the PF trusts a given VF (i.e. allows it to go into "risky" configurations) What I'm a bit unclear about is: adapter->vfinfo[vf].mc_promisc - This seems to record that the VF at one time as requested over 30 MC. I don't understand the reason for this bit. Wouldn't it be simpler and more straightforward to simply use the trusted bit? I guess specifically I don't understand why we would call ixgbe_enable_vf_mc_promisc() in ixgbe_ndo_set_vf_trust() if mc_promisc is set. Wouldn't just setting the trusted bit allow the next IXGBE_VF_SET_MC_PROMISC mailbox message to (possibly) turn on MC Promisc mode? Thanks, -Don Skidmore