From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754992AbcDAMLb (ORCPT ); Fri, 1 Apr 2016 08:11:31 -0400 Received: from shadbolt.e.decadent.org.uk ([88.96.1.126]:57595 "EHLO shadbolt.e.decadent.org.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752492AbcDAMLZ (ORCPT ); Fri, 1 Apr 2016 08:11:25 -0400 Message-ID: <1459512674.2704.47.camel@decadent.org.uk> Subject: Linux 3.2.79 From: Ben Hutchings To: linux-kernel@vger.kernel.org, Andrew Morton , torvalds@linux-foundation.org, Jiri Slaby , stable@vger.kernel.org Cc: lwn@lwn.net Date: Fri, 01 Apr 2016 13:11:14 +0100 Content-Type: multipart/signed; micalg="pgp-sha512"; protocol="application/pgp-signature"; boundary="=-O/83a+7HBPd55CEASXEG" X-Mailer: Evolution 3.18.5.1-1 Mime-Version: 1.0 X-SA-Exim-Connect-IP: 2a02:8011:400e:2:6f00:88c8:c921:d332 X-SA-Exim-Mail-From: ben@decadent.org.uk X-SA-Exim-Scanned: No (on shadbolt.decadent.org.uk); SAEximRunCond expanded to false Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --=-O/83a+7HBPd55CEASXEG Content-Type: multipart/mixed; boundary="=-b3ALMroV8hGLP01sOjLw" --=-b3ALMroV8hGLP01sOjLw Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: base64 SSdtIGFubm91bmNpbmcgdGhlIHJlbGVhc2Ugb2YgdGhlIDMuMi43OSBrZXJuZWwuCgpBbGwgdXNl cnMgb2YgdGhlIDMuMiBrZXJuZWwgc2VyaWVzIHNob3VsZCB1cGdyYWRlLgoKVGhlIHVwZGF0ZWQg My4yLnkgZ2l0IHRyZWUgY2FuIGJlIGZvdW5kIGF0OgrCoMKgwqDCoMKgwqDCoMKgaHR0cHM6Ly9n aXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvc3RhYmxlL2xpbnV4LXN0YWJs ZS5naXQgbGludXgtMy4yLnkKYW5kIGNhbiBiZSBicm93c2VkIGF0IHRoZSBub3JtYWwga2VybmVs Lm9yZyBnaXQgd2ViIGJyb3dzZXI6CsKgwqDCoMKgwqDCoMKgwqBodHRwczovL2dpdC5rZXJuZWwu b3JnLz9wPWxpbnV4L2tlcm5lbC9naXQvc3RhYmxlL2xpbnV4LXN0YWJsZS5naXQKClRoZSBkaWZm IGZyb20gMy4yLjc4IGlzIGF0dGFjaGVkIHRvIHRoaXMgbWVzc2FnZS4KCkJlbi4KCi0tLS0tLS0t LS0tLQoKwqBNYWtlZmlsZcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDIgKy0KwqBhcmNoL21pcHMv a2VybmVsL3RyYXBzLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8 wqDCoDEzICsrLQrCoGFyY2gvczM5MC9pbmNsdWRlL2FzbS9tbXVfY29udGV4dC5owqDCoMKgwqDC oMKgwqDCoMKgwqB8wqDCoDIwICsrLS0KwqBhcmNoL3MzOTAvaW5jbHVkZS9hc20vcGdhbGxvYy5o wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAzIC0KwqBhcmNoL3g4Ni9rZXJuZWwv YWNwaS9zbGVlcC5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA3ICsr CsKgYXJjaC94ODYvbGliL2NvcHlfdXNlcl9ub2NhY2hlXzY0LlPCoMKgwqDCoMKgwqDCoMKgwqDC oHwgMTUyICsrKysrKysrKysrKysrKysrKy0tLS0tLS0tLQrCoGNyeXB0by9hYmxrY2lwaGVyLmPC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDC oDEgKwrCoGNyeXB0by9hbGdpZl9za2NpcGhlci5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNSArLQrCoGNyeXB0by9ibGtjaXBoZXIuY8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAxICsK wqBkcml2ZXJzL2F0YS9haGNpLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNiArKwrCoGRyaXZlcnMvYXRhL2xpYmF0YS1zY3NpLmPC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqAxMSArLQrCoGRyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2kyYy5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDC oMKgMiArLQrCoGRyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2RldmljZS5jwqDCoMKgwqDC oMKgwqB8wqDCoMKgMSAtCsKgZHJpdmVycy9oaWQvdXNiaGlkL2hpZC1jb3JlLmPCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA0ICstCsKgZHJpdmVycy9pbmZpbmliYW5kL2Nv cmUvc2FfcXVlcnkuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMiArLQrCoGRyaXZlcnMv aW5wdXQvdGFibGV0L2FpcHRlay5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDC oMKgOSArKwrCoGRyaXZlcnMvaW9tbXUvZG1hci5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMiArLQrCoGRyaXZlcnMvaW9tbXUvaW50cl9y ZW1hcHBpbmcuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAyICstCsKgZHJp dmVycy9tdGQvdWJpL3VwZC5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgfMKgwqDCoDIgKy0KwqBkcml2ZXJzL25ldC9jYW4vdXNiL2Vtc191c2IuY8KgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqAxNCArKy0KwqBkcml2ZXJzL25ldC9ldGhl cm5ldC9tZWxsYW5veC9tbHg0L2VuX3BvcnQuYyB8wqDCoMKgNCArLQrCoGRyaXZlcnMvcGNpL3hl bi1wY2lmcm9udC5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoDEw ICstCsKgZHJpdmVycy9zMzkwL2Jsb2NrL2Rhc2RfYWxpYXMuY8KgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqB8wqDCoDIzICsrLS0KwqBkcml2ZXJzL3Njc2kvaXByLmPCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoDEwICstCsKgZHJpdmVy cy91c2IvZHdjMy9jb3JlLmjCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoHzCoMKgwqAxIC0KwqBkcml2ZXJzL3VzYi9kd2MzL2VwMC5jwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA1IC0KwqBkcml2ZXJzL3VzYi9kd2Mz L2dhZGdldC5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgNzAg KysrKysrKystLS0tCsKgZHJpdmVycy91c2Ivc2VyaWFsL2NwMjEweC5jwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDMgKwrCoGRyaXZlcnMvdXNiL3NlcmlhbC9vcHRp b24uY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgMTEgKysKwqBkcml2 ZXJzL3hlbi94ZW4tcGNpYmFjay9wY2liYWNrX29wcy5jwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA5 ICstCsKgZnMvY2lmcy9jaWZzZW5jcnlwdC5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDIgKy0KwqBmcy9leHQ0L2lub2RlLmPCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoDMy ICsrKysrLQrCoGZzL2hwZnMvbmFtZWkuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgMzEgKy0tLS0tCsKgZnMvamZmczIvUkVB RE1FLkxvY2tpbmfCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzC oMKgwqA1ICstCsKgZnMvamZmczIvYnVpbGQuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoDc1ICsrKysrKysrKy0tLS0KwqBmcy9q ZmZzMi9maWxlLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqB8wqDCoDM5ICsrKystLS0KwqBmcy9qZmZzMi9nYy5jwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKg MTcgKy0tCsKgZnMvamZmczIvbm9kZWxpc3QuaMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNiArLQrCoGluY2x1ZGUvbGludXgvYXRhLmjC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDC oDQgKy0KwqBpbmNsdWRlL2xpbnV4L2NvbXBpbGVyLmjCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMiArLQrCoGluY2x1ZGUvbGludXgvbGliYXRhLmjCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDIgKy0KwqBp bmNsdWRlL2xpbnV4L25mc19mcy5owqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoHzCoMKgwqA0ICstCsKgaW5jbHVkZS9saW51eC9wb2lzb24uaMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNCArLQrCoGluY2x1ZGUv bGludXgvc2tidWZmLmjCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgfMKgwqAyNCArKysrKwrCoGluY2x1ZGUvbGludXgvdHJhY2Vwb2ludC5owqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNSArCsKgaW5jbHVkZS9uZXQvaXdfaGFu ZGxlci5owqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDYg KysKwqBrZXJuZWwvcmVzb3VyY2UuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDUgKy0KwqBtbS9tZW1vcnkuY8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg fMKgwqAxNCArKy0KwqBuZXQvaXB2NC9pZ21wLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMyArLQrCoG5ldC9pcHY2L21j YXN0LmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgfMKgwqDCoDMgKy0KwqBuZXQvbWFjODAyMTEvYWdnLXJ4LmPCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMiArLQrCoG5ldC9tYWM4MDIx MS9yYzgwMjExX21pbnN0cmVsX2h0LmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDIgKy0K wqBuZXQvc3VucnBjL2NhY2hlLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMiArLQrCoG5ldC91bml4L2FmX3VuaXguY8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgMjMgKyst LQrCoG5ldC93aXJlbGVzcy9jb3JlLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDQgKwrCoG5ldC93aXJlbGVzcy93ZXh0LWNvcmUuY8Kg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgNTIgKysrKysrKy0t CsKgc291bmQvY29yZS9zZXEvb3NzL3NlcV9vc3MuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqB8wqDCoMKgMiAtCsKgc291bmQvY29yZS9zZXEvb3NzL3NlcV9vc3NfZGV2aWNlLmjC oMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAxIC0KwqBzb3VuZC9jb3JlL3NlcS9vc3Mvc2VxX29z c19pbml0LmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoDE3IC0tLQrCoHNvdW5kL2NvcmUv c2VxL3NlcV9tZW1vcnkuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKg MTMgKystCsKgc291bmQvY29yZS9zZXEvc2VxX3BvcnRzLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoHzCoMKgMTMgKystCsKgc291bmQvY29yZS90aW1lcl9jb21wYXQuY8Kg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNSArLQrCoHNvdW5k L3BjaS9ybWU5NjUyL2hkc3AuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoHzCoMKgwqA0ICstCsKgc291bmQvcGNpL3JtZTk2NTIvaGRzcG0uY8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNiArLQrCoHNvdW5kL3NvYy9jb2RlY3Mv d204OTU4LWRzcDIuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA4ICstCsKg c291bmQvc29jL2NvZGVjcy93bTg5OTQuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqB8wqDCoMKgNCArLQrCoHZpcnQva3ZtL2FzeW5jX3BmLmPCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDIgKy0KwqA2NyBmaWxl cyBjaGFuZ2VkLCA1NTQgaW5zZXJ0aW9ucygrKSwgMjk0IGRlbGV0aW9ucygtKQoKQWxleGFuZHJh IFlhdGVzICgxKToKwqDCoMKgwqDCoMKgQWRkaW5nIEludGVsIExld2lzYnVyZyBkZXZpY2UgSURz IGZvciBTQVRBCgpBbWlyIFZhZGFpICgxKToKwqDCoMKgwqDCoMKgbmV0L21seDRfZW46IENvdW50 IEhXIGJ1ZmZlciBvdmVycnVuIG9ubHkgb25jZQoKQW5kcmVhIEFyY2FuZ2VsaSAoMSk6CsKgwqDC oMKgwqDCoG1tOiB0aHA6IGZpeCBTTVAgcmFjZSBjb25kaXRpb24gYmV0d2VlbiBUSFAgcGFnZSBm YXVsdCBhbmQgTUFEVl9ET05UTkVFRAoKQW5kcmV5IFNrdm9ydHNvdiAoMSk6CsKgwqDCoMKgwqDC oFVTQjogb3B0aW9uOiBhZGQgc3VwcG9ydCBmb3IgU0lNNzEwMEUKCkFudG9uIFByb3RvcG9wb3Yg KDEpOgrCoMKgwqDCoMKgwqBjaWZzOiBmaXggZXJyb25lb3VzIHJldHVybiB2YWx1ZQoKQXJuZCBC ZXJnbWFubiAoMik6CsKgwqDCoMKgwqDCoGxpYmF0YTogZml4IEhESU9fR0VUXzMyQklUIGlvY3Rs CsKgwqDCoMKgwqDCoHRyYWNpbmc6IEZpeCBmcmVhayBsaW5rIGVycm9yIGNhdXNlZCBieSBicmFu Y2ggdHJhY2VyCgpCZW4gSHV0Y2hpbmdzICgzKToKwqDCoMKgwqDCoMKgUmV2ZXJ0ICJjcnlwdG86 IGFsZ2lmX3NrY2lwaGVyIC0gRG8gbm90IGRlcmVmZXJlbmNlIGN0eCB3aXRob3V0IHNvY2tldCBs b2NrIgrCoMKgwqDCoMKgwqBjcnlwdG86IHtibGssZ2l2fWNpcGhlcjogU2V0IGhhc19zZXRrZXkK wqDCoMKgwqDCoMKgTGludXggMy4yLjc5CgpCZW5qYW1pbiBQb2lyaWVyICgxKToKwqDCoMKgwqDC oMKgbWxkLCBpZ21wOiBGaXggcmVzZXJ2ZWQgdGFpbHJvb20gY2FsY3VsYXRpb24KCkJqw7hybiBN b3JrICgxKToKwqDCoMKgwqDCoMKgVVNCOiBvcHRpb246IGFkZCAiNEcgTFRFIHVzYi1tb2RlbSBV OTAxIgoKQ1EgVGFuZyAoMSk6CsKgwqDCoMKgwqDCoGlvbW11L3Z0LWQ6IEZpeCA2NC1iaXQgYWNj ZXNzZXMgdG8gMzItYml0IERNQVJfR1NUU19SRUcKCkNocmlzIEJhaW5icmlkZ2UgKDEpOgrCoMKg wqDCoMKgwqBtYWM4MDIxMTogZml4IHVzZSBvZiB1bmluaXRpYWxpc2VkIHZhbHVlcyBpbiBSWCBh Z2dyZWdhdGlvbgoKQ2hyaXN0aWFuIEJvcm50cmFlZ2VyICgxKToKwqDCoMKgwqDCoMKgS1ZNOiBh c3luY19wZjogZG8gbm90IHdhcm4gb24gcGFnZSBhbGxvY2F0aW9uIGZhaWx1cmVzCgpDaHJpc3Rv cGggSGVsbHdpZyAoMSk6CsKgwqDCoMKgwqDCoG5mczogZml4IG5mc19zaXplX3RvX2xvZmZfdAoK RGF2aWQgV29vZGhvdXNlICgyKToKwqDCoMKgwqDCoMKgamZmczI6IEZpeCBwYWdlIGxvY2sgLyBm LT5zZW0gZGVhZGxvY2sKwqDCoMKgwqDCoMKgRml4IGRpcmVjdG9yeSBoYXJkbGlua3MgZnJvbSBk ZWxldGVkIGRpcmVjdG9yaWVzCgpGZWxpeCBGaWV0a2F1ICgxKToKwqDCoMKgwqDCoMKgbWFjODAy MTE6IG1pbnN0cmVsX2h0OiBzZXQgZGVmYXVsdCB0eCBhZ2dyZWdhdGlvbiB0aW1lb3V0IHRvIDAK CkdhYnJpZWwgS3Jpc21hbiBCZXJ0YXppICgxKToKwqDCoMKgwqDCoMKgaXByOiBGaXggcmVncmVz c2lvbiB3aGVuIGxvYWRpbmcgZmlybXdhcmUKCkdlcmhhcmQgVXR0ZW50aGFsZXIgKDEpOgrCoMKg wqDCoMKgwqBjYW46IGVtc191c2I6IEZpeCBwb3NzaWJsZSB0eCBvdmVyZmxvdwoKSC4gUGV0ZXIg QW52aW4gKDEpOgrCoMKgwqDCoMKgwqB4ODYsIGV4dGFibGU6IFJlbW92ZSBvcGVuLWNvZGVkIGV4 Y2VwdGlvbiB0YWJsZSBlbnRyaWVzIGluIGFyY2gveDg2L2xpYi9jb3B5X3VzZXJfbm9jYWNoZV82 NC5TCgpIYXJ2ZXkgSHVudCAoMSk6CsKgwqDCoMKgwqDCoGxpYmF0YTogQWxpZ24gYXRhX2Rldmlj ZSdzIGlkIG9uIGEgY2FjaGVsaW5lCgpJbnN1IFl1biAoMSk6CsKgwqDCoMKgwqDCoGlwcjogRml4 IG91dC1vZi1ib3VuZHMgbnVsbCBvdmVyd3JpdGUKCklvYW4tQWRyaWFuIFJhdGl1ICgxKToKwqDC oMKgwqDCoMKgSElEOiB1c2JoaWQ6IGZpeCByZWN1cnNpdmUgZGVhZGxvY2sKCkphbiBLYXJhICgx KToKwqDCoMKgwqDCoMKgZXh0NDogZml4IGJoLT5iX3N0YXRlIGNvcnJ1cHRpb24KCkpvaGFubmVz IEJlcmcgKDIpOgrCoMKgwqDCoMKgwqB3ZXh0OiBmaXggbWVzc2FnZSBkZWxheS9vcmRlcmluZwrC oMKgwqDCoMKgwqBjZmc4MDIxMS93ZXh0OiBmaXggbWVzc2FnZSBvcmRlcmluZwoKSm9obiBZb3Vu ICgxKToKwqDCoMKgwqDCoMKgdXNiOiBkd2MzOiBGaXggYXNzaWdubWVudCBvZiBFUCB0cmFuc2Zl ciByZXNvdXJjZXMKCktlbiBMaW4gKDEpOgrCoMKgwqDCoMKgwqBVU0I6IGNwMjEweDogYWRkIElE cyBmb3IgR0UgQjY1MFYzIGFuZCBCODUwVjMgYm9hcmRzCgpLb25yYWQgUnplc3p1dGVrIFdpbGsg KDMpOgrCoMKgwqDCoMKgwqB4ZW4vcGNpYmFjazogQ2hlY2sgUEYgaW5zdGVhZCBvZiBWRiBmb3Ig UENJX0NPTU1BTkRfTUVNT1JZCsKgwqDCoMKgwqDCoHhlbi9wY2liYWNrOiBTYXZlIHRoZSBudW1i ZXIgb2YgTVNJLVggZW50cmllcyB0byBiZSBjb3BpZWQgbGF0ZXIuCsKgwqDCoMKgwqDCoHhlbi9w Y2lmcm9udDogRml4IG15c3RlcmlvdXMgY3Jhc2hlcyB3aGVuIE5VTUEgbG9jYWxpdHkgaW5mb3Jt YXRpb24gd2FzIGV4dHJhY3RlZC4KCkxpbnVzIFRvcnZhbGRzICgxKToKwqDCoMKgwqDCoMKgUmV2 ZXJ0ICJkcm0vcmFkZW9uOiBjYWxsIGhwZF9pcnFfZXZlbnQgb24gcmVzdW1lIgoKTWFjaWVqIFcu IFJvenlja2kgKDEpOgrCoMKgwqDCoMKgwqBNSVBTOiB0cmFwczogRml4IFNJR0ZQRSBpbmZvcm1h dGlvbiBsZWFrIGZyb20gYGRvX292JyBhbmQgYGRvX3RyYXBfb3JfYnAnCgpNYXJ0aW4gU2Nod2lk ZWZza3kgKDEpOgrCoMKgwqDCoMKgwqBzMzkwL21tOiBmb3VyIHBhZ2UgdGFibGUgbGV2ZWxzIHZz LiBmb3JrCgpNaWt1bGFzIFBhdG9ja2EgKDEpOgrCoMKgwqDCoMKgwqBocGZzOiBkb24ndCB0cnVu Y2F0ZSB0aGUgZmlsZSB3aGVuIGRlbGV0ZSBmYWlscwoKT3IgR2VybGl0eiAoMSk6CsKgwqDCoMKg wqDCoElCL2NvcmU6IFVzZSBHUkggd2hlbiB0aGUgcGF0aCBob3AtbGltaXQgPiAwCgpSYWluZXIg V2Vpa3VzYXQgKDIpOgrCoMKgwqDCoMKgwqBhZl91bml4OiBEb24ndCBzZXQgZXJyIGluIHVuaXhf c3RyZWFtX3JlYWRfZ2VuZXJpYyB1bmxlc3MgdGhlcmUgd2FzIGFuIGVycm9yCsKgwqDCoMKgwqDC oGFmX3VuaXg6IEd1YXJkIGFnYWluc3Qgb3RoZXIgPT0gc2sgaW4gdW5peF9kZ3JhbV9zZW5kbXNn CgpSYXNtdXMgVmlsbGVtb2VzICgxKToKwqDCoMKgwqDCoMKgZHJtL2k5MTU6IGZpeCBlcnJvciBw YXRoIGluIGludGVsX3NldHVwX2dtYnVzKCkKClJpY2hhcmQgV2VpbmJlcmdlciAoMSk6CsKgwqDC oMKgwqDCoHViaTogRml4IG91dCBvZiBib3VuZHMgd3JpdGUgaW4gdm9sdW1lIHVwZGF0ZSBjb2Rl CgpTaW1vbiBHdWlub3QgKDEpOgrCoMKgwqDCoMKgwqBrZXJuZWwvcmVzb3VyY2UuYzogZml4IG11 eGVkIHJlc291cmNlIGhhbmRsaW5nIGluIF9fcmVxdWVzdF9yZWdpb24oKQoKU3RlZmFuIEhhYmVy bGFuZCAoMik6CsKgwqDCoMKgwqDCoHMzOTAvZGFzZDogcHJldmVudCBpbmNvcnJlY3QgbGVuZ3Ro IGVycm9yIHVuZGVyIHovVk0gYWZ0ZXIgUEFWIGNoYW5nZXMKwqDCoMKgwqDCoMKgczM5MC9kYXNk OiBmaXggcmVmY291bnQgZm9yIFBBViByZWFzc2lnbm1lbnQKClN0ZWZhbiBIYWpub2N6aSAoMSk6 CsKgwqDCoMKgwqDCoHN1bnJwYy9jYWNoZTogZml4IG9mZi1ieS1vbmUgaW4gcXdvcmRfZ2V0KCkK ClN0ZXZlbiBSb3N0ZWR0IChSZWQgSGF0KSAoMSk6CsKgwqDCoMKgwqDCoHRyYWNlcG9pbnRzOiBE byBub3QgdHJhY2Ugd2hlbiBjcHUgaXMgb2ZmbGluZQoKVGFrYXNoaSBJd2FpICg4KToKwqDCoMKg wqDCoMKgQUxTQTogc2VxOiBGaXggbGVhayBvZiBwb29sIGJ1ZmZlciBhdCBjb25jdXJyZW50IHdy aXRlcwrCoMKgwqDCoMKgwqBBTFNBOiBzZXE6IEZpeCBkb3VibGUgcG9ydCBsaXN0IGRlbGV0aW9u CsKgwqDCoMKgwqDCoEFMU0E6IHRpbWVyOiBGaXggYnJva2VuIGNvbXBhdCB0aW1lciB1c2VyIHN0 YXR1cyBpb2N0bArCoMKgwqDCoMKgwqBBTFNBOiBoZHNwbTogRml4IHdyb25nIGJvb2xlYW4gY3Rs IHZhbHVlIGFjY2Vzc2VzCsKgwqDCoMKgwqDCoEFMU0E6IGhkc3A6IEZpeCB3cm9uZyBib29sZWFu IGN0bCB2YWx1ZSBhY2Nlc3NlcwrCoMKgwqDCoMKgwqBBU29DOiB3bTg5NTg6IEZpeCBlbnVtIGN0 bCBhY2Nlc3NlcyBpbiBhIHdyb25nIHR5cGUKwqDCoMKgwqDCoMKgQVNvQzogd204OTk0OiBGaXgg ZW51bSBjdGwgYWNjZXNzZXMgaW4gYSB3cm9uZyB0eXBlCsKgwqDCoMKgwqDCoEFMU0E6IHNlcTog b3NzOiBEb24ndCBkcmFpbiBhdCBjbG9zaW5nIGEgY2xpZW50CgpUaG9tYXMgQmV0a2VyICgxKToK wqDCoMKgwqDCoMKgUmV2ZXJ0ICJqZmZzMjogRml4IGxvY2sgYWNxdWlzaXRpb24gb3JkZXIgYnVn IGluIGpmZnMyX3dyaXRlX2JlZ2luIgoKVG9kZCBFIEJyYW5kdCAoMSk6CsKgwqDCoMKgwqDCoFBN IC8gc2xlZXAgLyB4ODY6IEZpeCBjcmFzaCBvbiBncmFwaCB0cmFjZSB0aHJvdWdoIHg4NiBzdXNw ZW5kCgpUb3NoaSBLYW5pICgyKToKwqDCoMKgwqDCoMKgeDg2L3VhY2Nlc3MvNjQ6IE1ha2UgdGhl IF9fY29weV91c2VyX25vY2FjaGUoKSBhc3NlbWJseSBjb2RlIG1vcmUgcmVhZGFibGUKwqDCoMKg wqDCoMKgeDg2L3VhY2Nlc3MvNjQ6IEhhbmRsZSB0aGUgY2FjaGluZyBvZiA0LWJ5dGUgbm9jYWNo ZSBjb3BpZXMgcHJvcGVybHkgaW4gX19jb3B5X3VzZXJfbm9jYWNoZSgpCgpWYXNpbHkgS3VsaWtv diAoMSk6CsKgwqDCoMKgwqDCoGluY2x1ZGUvbGludXgvcG9pc29uLmg6IGZpeCBMSVNUX1BPSVNP TnsxLDJ9IG9mZnNldAoKVml0dG9yaW8gQWxmaWVyaSAoMSk6CsKgwqDCoMKgwqDCoFVTQjogY3Ay MTB4OiBBZGQgSUQgZm9yIFBhcnJvdCBOTUVBIEdQUyBGbGlnaHQgUmVjb3JkZXIKClZsYWRpcyBE cm9ub3YgKDEpOgrCoMKgwqDCoMKgwqBJbnB1dDogYWlwdGVrIC0gZml4IGNyYXNoIG9uIGRldGVj dGluZyBkZXZpY2Ugd2l0aG91dCBlbmRwb2ludHMKClllZ29yIFllZnJlbW92ICgxKToKwqDCoMKg wqDCoMKgVVNCOiBzZXJpYWw6IG9wdGlvbjogYWRkIHN1cHBvcnQgZm9yIFF1ZWN0ZWwgVUMyMAoK LS0gCkJlbiBIdXRjaGluZ3MKNzMuNDYlIG9mIGFsbCBzdGF0aXN0aWNzIGFyZSBtYWRlIHVwLm== --=-b3ALMroV8hGLP01sOjLw Content-Type: text/x-diff; charset="UTF-8"; name="linux-3.2.79.patch" Content-Disposition: attachment; filename="linux-3.2.79.patch" Content-Transfer-Encoding: quoted-printable diff --git a/Makefile b/Makefile index e43b86ec72bf..cfadb8fc7781 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ VERSION =3D 3 PATCHLEVEL =3D 2 -SUBLEVEL =3D 78 +SUBLEVEL =3D 79 EXTRAVERSION =3D NAME =3D Saber-toothed Squirrel =20 diff --git a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c index 5c8a49d55054..e0ee75d4c96f 100644 --- a/arch/mips/kernel/traps.c +++ b/arch/mips/kernel/traps.c @@ -656,14 +656,14 @@ static int simulate_sync(struct pt_regs *regs, unsign= ed int opcode) =20 asmlinkage void do_ov(struct pt_regs *regs) { - siginfo_t info; + siginfo_t info =3D { + .si_signo =3D SIGFPE, + .si_code =3D FPE_INTOVF, + .si_addr =3D (void __user *)regs->cp0_epc, + }; =20 die_if_kernel("Integer overflow", regs); =20 - info.si_code =3D FPE_INTOVF; - info.si_signo =3D SIGFPE; - info.si_errno =3D 0; - info.si_addr =3D (void __user *) regs->cp0_epc; force_sig_info(SIGFPE, &info, current); } =20 @@ -758,7 +758,7 @@ asmlinkage void do_fpe(struct pt_regs *regs, unsigned l= ong fcr31) static void do_trap_or_bp(struct pt_regs *regs, unsigned int code, const char *str) { - siginfo_t info; + siginfo_t info =3D { 0 }; char b[40]; =20 #ifdef CONFIG_KGDB_LOW_LEVEL_TRAP @@ -785,7 +785,6 @@ static void do_trap_or_bp(struct pt_regs *regs, unsigne= d int code, else info.si_code =3D FPE_INTOVF; info.si_signo =3D SIGFPE; - info.si_errno =3D 0; info.si_addr =3D (void __user *) regs->cp0_epc; force_sig_info(SIGFPE, &info, current); break; diff --git a/arch/s390/include/asm/mmu_context.h b/arch/s390/include/asm/mm= u_context.h index 20f0e01a098e..803ed142d091 100644 --- a/arch/s390/include/asm/mmu_context.h +++ b/arch/s390/include/asm/mmu_context.h @@ -16,12 +16,11 @@ static inline int init_new_context(struct task_struct *tsk, struct mm_struct *mm) { + spin_lock_init(&mm->context.list_lock); + INIT_LIST_HEAD(&mm->context.pgtable_list); + INIT_LIST_HEAD(&mm->context.gmap_list); atomic_set(&mm->context.attach_count, 0); mm->context.flush_mm =3D 0; - mm->context.asce_bits =3D _ASCE_TABLE_LENGTH | _ASCE_USER_BITS; -#ifdef CONFIG_64BIT - mm->context.asce_bits |=3D _ASCE_TYPE_REGION3; -#endif if (current->mm && current->mm->context.alloc_pgste) { /* * alloc_pgste indicates, that any NEW context will be created @@ -40,7 +39,14 @@ static inline int init_new_context(struct task_struct *t= sk, mm->context.has_pgste =3D 0; mm->context.alloc_pgste =3D 0; } - mm->context.asce_limit =3D STACK_TOP_MAX; + if (mm->context.asce_limit =3D=3D 0) { + /* context created by exec, set asce limit to 4TB */ + mm->context.asce_bits =3D _ASCE_TABLE_LENGTH | _ASCE_USER_BITS; +#ifdef CONFIG_64BIT + mm->context.asce_bits |=3D _ASCE_TYPE_REGION3; +#endif + mm->context.asce_limit =3D STACK_TOP_MAX; + } crst_table_init((unsigned long *) mm->pgd, pgd_entry_type(mm)); return 0; } @@ -94,10 +100,6 @@ static inline void activate_mm(struct mm_struct *prev, static inline void arch_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm) { -#ifdef CONFIG_64BIT - if (oldmm->context.asce_limit < mm->context.asce_limit) - crst_table_downgrade(mm, oldmm->context.asce_limit); -#endif } =20 static inline void arch_exit_mmap(struct mm_struct *mm) diff --git a/arch/s390/include/asm/pgalloc.h b/arch/s390/include/asm/pgallo= c.h index 78e3041919de..272c0694ddb7 100644 --- a/arch/s390/include/asm/pgalloc.h +++ b/arch/s390/include/asm/pgalloc.h @@ -110,9 +110,6 @@ static inline void pud_populate(struct mm_struct *mm, p= ud_t *pud, pmd_t *pmd) =20 static inline pgd_t *pgd_alloc(struct mm_struct *mm) { - spin_lock_init(&mm->context.list_lock); - INIT_LIST_HEAD(&mm->context.pgtable_list); - INIT_LIST_HEAD(&mm->context.gmap_list); return (pgd_t *) crst_table_alloc(mm); } #define pgd_free(mm, pgd) crst_table_free(mm, (unsigned long *) pgd) diff --git a/arch/x86/kernel/acpi/sleep.c b/arch/x86/kernel/acpi/sleep.c index 103b6ab368d3..0d56eaa629ff 100644 --- a/arch/x86/kernel/acpi/sleep.c +++ b/arch/x86/kernel/acpi/sleep.c @@ -15,6 +15,7 @@ #include #include =20 +#include #include "realmode/wakeup.h" #include "sleep.h" =20 @@ -102,7 +103,13 @@ int acpi_suspend_lowlevel(void) saved_magic =3D 0x123456789abcdef0L; #endif /* CONFIG_64BIT */ =20 + /* + * Pause/unpause graph tracing around do_suspend_lowlevel as it has + * inconsistent call/return info after it jumps to the wakeup vector. + */ + pause_graph_tracing(); do_suspend_lowlevel(); + unpause_graph_tracing(); return 0; } =20 diff --git a/arch/x86/lib/copy_user_nocache_64.S b/arch/x86/lib/copy_user_n= ocache_64.S index cb0c112386fb..2aac3b236edf 100644 --- a/arch/x86/lib/copy_user_nocache_64.S +++ b/arch/x86/lib/copy_user_nocache_64.S @@ -14,6 +14,7 @@ #include #include #include +#include =20 .macro ALIGN_DESTINATION #ifdef FIX_ALIGNMENT @@ -36,27 +37,38 @@ jmp copy_user_handle_tail .previous =20 - .section __ex_table,"a" - .align 8 - .quad 100b,103b - .quad 101b,103b - .previous + _ASM_EXTABLE(100b,103b) + _ASM_EXTABLE(101b,103b) #endif .endm =20 /* * copy_user_nocache - Uncached memory copy with exception handling - * This will force destination/source out of cache for more performance. + * This will force destination out of cache for more performance. + * + * Note: Cached memory copy is used when destination or size is not + * naturally aligned. That is: + * - Require 8-byte alignment when size is 8 bytes or larger. + * - Require 4-byte alignment when size is 4 bytes. */ ENTRY(__copy_user_nocache) CFI_STARTPROC + + /* If size is less than 8 bytes, go to 4-byte copy */ cmpl $8,%edx - jb 20f /* less then 8 bytes, go to byte copy loop */ + jb .L_4b_nocache_copy_entry + + /* If destination is not 8-byte aligned, "cache" copy to align it */ ALIGN_DESTINATION + + /* Set 4x8-byte copy count and remainder */ movl %edx,%ecx andl $63,%edx shrl $6,%ecx - jz 17f + jz .L_8b_nocache_copy_entry /* jump if count is 0 */ + + /* Perform 4x8-byte nocache loop-copy */ +.L_4x8b_nocache_copy_loop: 1: movq (%rsi),%r8 2: movq 1*8(%rsi),%r9 3: movq 2*8(%rsi),%r10 @@ -76,62 +88,106 @@ ENTRY(__copy_user_nocache) leaq 64(%rsi),%rsi leaq 64(%rdi),%rdi decl %ecx - jnz 1b -17: movl %edx,%ecx + jnz .L_4x8b_nocache_copy_loop + + /* Set 8-byte copy count and remainder */ +.L_8b_nocache_copy_entry: + movl %edx,%ecx andl $7,%edx shrl $3,%ecx - jz 20f -18: movq (%rsi),%r8 -19: movnti %r8,(%rdi) + jz .L_4b_nocache_copy_entry /* jump if count is 0 */ + + /* Perform 8-byte nocache loop-copy */ +.L_8b_nocache_copy_loop: +20: movq (%rsi),%r8 +21: movnti %r8,(%rdi) leaq 8(%rsi),%rsi leaq 8(%rdi),%rdi decl %ecx - jnz 18b -20: andl %edx,%edx - jz 23f + jnz .L_8b_nocache_copy_loop + + /* If no byte left, we're done */ +.L_4b_nocache_copy_entry: + andl %edx,%edx + jz .L_finish_copy + + /* If destination is not 4-byte aligned, go to byte copy: */ + movl %edi,%ecx + andl $3,%ecx + jnz .L_1b_cache_copy_entry + + /* Set 4-byte copy count (1 or 0) and remainder */ + movl %edx,%ecx + andl $3,%edx + shrl $2,%ecx + jz .L_1b_cache_copy_entry /* jump if count is 0 */ + + /* Perform 4-byte nocache copy: */ +30: movl (%rsi),%r8d +31: movnti %r8d,(%rdi) + leaq 4(%rsi),%rsi + leaq 4(%rdi),%rdi + + /* If no bytes left, we're done: */ + andl %edx,%edx + jz .L_finish_copy + + /* Perform byte "cache" loop-copy for the remainder */ +.L_1b_cache_copy_entry: movl %edx,%ecx -21: movb (%rsi),%al -22: movb %al,(%rdi) +.L_1b_cache_copy_loop: +40: movb (%rsi),%al +41: movb %al,(%rdi) incq %rsi incq %rdi decl %ecx - jnz 21b -23: xorl %eax,%eax + jnz .L_1b_cache_copy_loop + + /* Finished copying; fence the prior stores */ +.L_finish_copy: + xorl %eax,%eax sfence ret =20 .section .fixup,"ax" -30: shll $6,%ecx +.L_fixup_4x8b_copy: + shll $6,%ecx addl %ecx,%edx - jmp 60f -40: lea (%rdx,%rcx,8),%rdx - jmp 60f -50: movl %ecx,%edx -60: sfence + jmp .L_fixup_handle_tail +.L_fixup_8b_copy: + lea (%rdx,%rcx,8),%rdx + jmp .L_fixup_handle_tail +.L_fixup_4b_copy: + lea (%rdx,%rcx,4),%rdx + jmp .L_fixup_handle_tail +.L_fixup_1b_copy: + movl %ecx,%edx +.L_fixup_handle_tail: + sfence jmp copy_user_handle_tail .previous =20 - .section __ex_table,"a" - .quad 1b,30b - .quad 2b,30b - .quad 3b,30b - .quad 4b,30b - .quad 5b,30b - .quad 6b,30b - .quad 7b,30b - .quad 8b,30b - .quad 9b,30b - .quad 10b,30b - .quad 11b,30b - .quad 12b,30b - .quad 13b,30b - .quad 14b,30b - .quad 15b,30b - .quad 16b,30b - .quad 18b,40b - .quad 19b,40b - .quad 21b,50b - .quad 22b,50b - .previous + _ASM_EXTABLE(1b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(2b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(3b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(4b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(5b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(6b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(7b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(8b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(9b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(10b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(11b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(12b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(13b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(14b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(15b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(16b,.L_fixup_4x8b_copy) + _ASM_EXTABLE(20b,.L_fixup_8b_copy) + _ASM_EXTABLE(21b,.L_fixup_8b_copy) + _ASM_EXTABLE(30b,.L_fixup_4b_copy) + _ASM_EXTABLE(31b,.L_fixup_4b_copy) + _ASM_EXTABLE(40b,.L_fixup_1b_copy) + _ASM_EXTABLE(41b,.L_fixup_1b_copy) CFI_ENDPROC ENDPROC(__copy_user_nocache) diff --git a/crypto/ablkcipher.c b/crypto/ablkcipher.c index 6600a2a15b6b..3ad43ad6586e 100644 --- a/crypto/ablkcipher.c +++ b/crypto/ablkcipher.c @@ -461,6 +461,7 @@ static int crypto_init_givcipher_ops(struct crypto_tfm = *tfm, u32 type, crt->givdecrypt =3D alg->givdecrypt ?: no_givdecrypt; crt->base =3D __crypto_ablkcipher_cast(tfm); crt->ivsize =3D alg->ivsize; + crt->has_setkey =3D alg->max_keysize; =20 return 0; } diff --git a/crypto/algif_skcipher.c b/crypto/algif_skcipher.c index da5d4ed238e2..45fa6bd9187b 100644 --- a/crypto/algif_skcipher.c +++ b/crypto/algif_skcipher.c @@ -249,11 +249,8 @@ static int skcipher_sendmsg(struct kiocb *unused, stru= ct socket *sock, { struct sock *sk =3D sock->sk; struct alg_sock *ask =3D alg_sk(sk); - struct sock *psk =3D ask->parent; - struct alg_sock *pask =3D alg_sk(psk); struct skcipher_ctx *ctx =3D ask->private; - struct ablkcipher_tfm *skc =3D pask->private; - struct crypto_ablkcipher *tfm =3D skc->base; + struct crypto_ablkcipher *tfm =3D crypto_ablkcipher_reqtfm(&ctx->req); unsigned ivsize =3D crypto_ablkcipher_ivsize(tfm); struct skcipher_sg_list *sgl; struct af_alg_control con =3D {}; diff --git a/crypto/blkcipher.c b/crypto/blkcipher.c index 3041504370b1..7b69d7a902a9 100644 --- a/crypto/blkcipher.c +++ b/crypto/blkcipher.c @@ -458,6 +458,7 @@ static int crypto_init_blkcipher_ops_async(struct crypt= o_tfm *tfm) } crt->base =3D __crypto_ablkcipher_cast(tfm); crt->ivsize =3D alg->ivsize; + crt->has_setkey =3D alg->max_keysize; =20 return 0; } diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c index f2fd6a7392fc..baeee8324138 100644 --- a/drivers/ata/ahci.c +++ b/drivers/ata/ahci.c @@ -377,15 +377,21 @@ static const struct pci_device_id ahci_pci_tbl[] =3D = { { PCI_VDEVICE(INTEL, 0xa107), board_ahci }, /* Sunrise Point-H RAID */ { PCI_VDEVICE(INTEL, 0xa10f), board_ahci }, /* Sunrise Point-H RAID */ { PCI_VDEVICE(INTEL, 0x2822), board_ahci }, /* Lewisburg RAID*/ + { PCI_VDEVICE(INTEL, 0x2823), board_ahci }, /* Lewisburg AHCI*/ { PCI_VDEVICE(INTEL, 0x2826), board_ahci }, /* Lewisburg RAID*/ + { PCI_VDEVICE(INTEL, 0x2827), board_ahci }, /* Lewisburg RAID*/ { PCI_VDEVICE(INTEL, 0xa182), board_ahci }, /* Lewisburg AHCI*/ { PCI_VDEVICE(INTEL, 0xa184), board_ahci }, /* Lewisburg RAID*/ { PCI_VDEVICE(INTEL, 0xa186), board_ahci }, /* Lewisburg RAID*/ { PCI_VDEVICE(INTEL, 0xa18e), board_ahci }, /* Lewisburg RAID*/ + { PCI_VDEVICE(INTEL, 0xa1d2), board_ahci }, /* Lewisburg RAID*/ + { PCI_VDEVICE(INTEL, 0xa1d6), board_ahci }, /* Lewisburg RAID*/ { PCI_VDEVICE(INTEL, 0xa202), board_ahci }, /* Lewisburg AHCI*/ { PCI_VDEVICE(INTEL, 0xa204), board_ahci }, /* Lewisburg RAID*/ { PCI_VDEVICE(INTEL, 0xa206), board_ahci }, /* Lewisburg RAID*/ { PCI_VDEVICE(INTEL, 0xa20e), board_ahci }, /* Lewisburg RAID*/ + { PCI_VDEVICE(INTEL, 0xa252), board_ahci }, /* Lewisburg RAID*/ + { PCI_VDEVICE(INTEL, 0xa256), board_ahci }, /* Lewisburg RAID*/ =20 /* JMicron 360/1/3/5/6, match class to avoid IDE function */ { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c index 0ac7a5e6991b..eeadf8f9903f 100644 --- a/drivers/ata/libata-scsi.c +++ b/drivers/ata/libata-scsi.c @@ -672,19 +672,18 @@ static int ata_ioc32(struct ata_port *ap) int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *scsidev, int cmd, void __user *arg) { - int val =3D -EINVAL, rc =3D -EINVAL; + unsigned long val; + int rc =3D -EINVAL; unsigned long flags; =20 switch (cmd) { - case ATA_IOC_GET_IO32: + case HDIO_GET_32BIT: spin_lock_irqsave(ap->lock, flags); val =3D ata_ioc32(ap); spin_unlock_irqrestore(ap->lock, flags); - if (copy_to_user(arg, &val, 1)) - return -EFAULT; - return 0; + return put_user(val, (unsigned long __user *)arg); =20 - case ATA_IOC_SET_IO32: + case HDIO_SET_32BIT: val =3D (unsigned long) arg; rc =3D 0; spin_lock_irqsave(ap->lock, flags); diff --git a/drivers/gpu/drm/i915/intel_i2c.c b/drivers/gpu/drm/i915/intel_= i2c.c index d30ccccb9d73..e035eaf88454 100644 --- a/drivers/gpu/drm/i915/intel_i2c.c +++ b/drivers/gpu/drm/i915/intel_i2c.c @@ -410,7 +410,7 @@ int intel_setup_gmbus(struct drm_device *dev) return 0; =20 err: - while (--i) { + while (i--) { struct intel_gmbus *bus =3D &dev_priv->gmbus[i]; i2c_del_adapter(&bus->adapter); } diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeo= n/radeon_device.c index e51f09f7a175..8cde84b666d5 100644 --- a/drivers/gpu/drm/radeon/radeon_device.c +++ b/drivers/gpu/drm/radeon/radeon_device.c @@ -960,7 +960,6 @@ int radeon_resume_kms(struct drm_device *dev) } =20 drm_kms_helper_poll_enable(dev); - drm_helper_hpd_irq_event(dev); return 0; } =20 diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c index b403fcef0b86..831e20dd77a5 100644 --- a/drivers/hid/usbhid/hid-core.c +++ b/drivers/hid/usbhid/hid-core.c @@ -448,8 +448,6 @@ static void hid_ctrl(struct urb *urb) struct usbhid_device *usbhid =3D hid->driver_data; int unplug =3D 0, status =3D urb->status; =20 - spin_lock(&usbhid->lock); - switch (status) { case 0: /* success */ if (usbhid->ctrl[usbhid->ctrltail].dir =3D=3D USB_DIR_IN) @@ -469,6 +467,8 @@ static void hid_ctrl(struct urb *urb) hid_warn(urb->dev, "ctrl urb status %d received\n", status); } =20 + spin_lock(&usbhid->lock); + if (unplug) usbhid->ctrltail =3D usbhid->ctrlhead; else diff --git a/drivers/infiniband/core/sa_query.c b/drivers/infiniband/core/s= a_query.c index fbbfa24cf572..f41f1519bbf7 100644 --- a/drivers/infiniband/core/sa_query.c +++ b/drivers/infiniband/core/sa_query.c @@ -508,7 +508,7 @@ int ib_init_ah_from_path(struct ib_device *device, u8 p= ort_num, =20 force_grh =3D rdma_port_get_link_layer(device, port_num) =3D=3D IB_LINK_L= AYER_ETHERNET; =20 - if (rec->hop_limit > 1 || force_grh) { + if (rec->hop_limit > 0 || force_grh) { ah_attr->ah_flags =3D IB_AH_GRH; ah_attr->grh.dgid =3D rec->dgid; =20 diff --git a/drivers/input/tablet/aiptek.c b/drivers/input/tablet/aiptek.c index 6d89fd1842c3..56570187000c 100644 --- a/drivers/input/tablet/aiptek.c +++ b/drivers/input/tablet/aiptek.c @@ -1810,6 +1810,14 @@ aiptek_probe(struct usb_interface *intf, const struc= t usb_device_id *id) input_set_abs_params(inputdev, ABS_TILT_Y, AIPTEK_TILT_MIN, AIPTEK_TILT_M= AX, 0, 0); input_set_abs_params(inputdev, ABS_WHEEL, AIPTEK_WHEEL_MIN, AIPTEK_WHEEL_= MAX - 1, 0, 0); =20 + /* Verify that a device really has an endpoint */ + if (intf->altsetting[0].desc.bNumEndpoints < 1) { + dev_err(&intf->dev, + "interface has %d endpoints, but must have minimum 1\n", + intf->altsetting[0].desc.bNumEndpoints); + err =3D -EINVAL; + goto fail3; + } endpoint =3D &intf->altsetting[0].endpoint[0].desc; =20 /* Go set up our URB, which is called when the tablet receives @@ -1852,6 +1860,7 @@ aiptek_probe(struct usb_interface *intf, const struct= usb_device_id *id) if (i =3D=3D ARRAY_SIZE(speeds)) { dev_info(&intf->dev, "Aiptek tried all speeds, no sane response\n"); + err =3D -EINVAL; goto fail2; } =20 diff --git a/drivers/iommu/dmar.c b/drivers/iommu/dmar.c index cf065df9bb18..fce4e2dcd59e 100644 --- a/drivers/iommu/dmar.c +++ b/drivers/iommu/dmar.c @@ -923,7 +923,7 @@ void dmar_disable_qi(struct intel_iommu *iommu) =20 raw_spin_lock_irqsave(&iommu->register_lock, flags); =20 - sts =3D dmar_readq(iommu->reg + DMAR_GSTS_REG); + sts =3D readl(iommu->reg + DMAR_GSTS_REG); if (!(sts & DMA_GSTS_QIES)) goto end; =20 diff --git a/drivers/iommu/intr_remapping.c b/drivers/iommu/intr_remapping.= c index 73ca321f330a..cc2c7b465d4e 100644 --- a/drivers/iommu/intr_remapping.c +++ b/drivers/iommu/intr_remapping.c @@ -496,7 +496,7 @@ static void iommu_disable_intr_remapping(struct intel_i= ommu *iommu) =20 raw_spin_lock_irqsave(&iommu->register_lock, flags); =20 - sts =3D dmar_readq(iommu->reg + DMAR_GSTS_REG); + sts =3D readl(iommu->reg + DMAR_GSTS_REG); if (!(sts & DMA_GSTS_IRES)) goto end; =20 diff --git a/drivers/mtd/ubi/upd.c b/drivers/mtd/ubi/upd.c index 068a2466d060..d1802b054bfe 100644 --- a/drivers/mtd/ubi/upd.c +++ b/drivers/mtd/ubi/upd.c @@ -197,7 +197,7 @@ int ubi_start_leb_change(struct ubi_device *ubi, struct= ubi_volume *vol, vol->ch_lnum =3D req->lnum; vol->ch_dtype =3D req->dtype; =20 - vol->upd_buf =3D vmalloc(req->bytes); + vol->upd_buf =3D vmalloc(ALIGN((int)req->bytes, ubi->min_io_size)); if (!vol->upd_buf) return -ENOMEM; =20 diff --git a/drivers/net/can/usb/ems_usb.c b/drivers/net/can/usb/ems_usb.c index a72c7bfb4090..3b8c4da11f3e 100644 --- a/drivers/net/can/usb/ems_usb.c +++ b/drivers/net/can/usb/ems_usb.c @@ -118,6 +118,9 @@ MODULE_LICENSE("GPL v2"); */ #define EMS_USB_ARM7_CLOCK 8000000 =20 +#define CPC_TX_QUEUE_TRIGGER_LOW 25 +#define CPC_TX_QUEUE_TRIGGER_HIGH 35 + /* * CAN-Message representation in a CPC_MSG. Message object type is * CPC_MSG_TYPE_CAN_FRAME or CPC_MSG_TYPE_RTR_FRAME or @@ -280,6 +283,11 @@ static void ems_usb_read_interrupt_callback(struct urb= *urb) switch (urb->status) { case 0: dev->free_slots =3D dev->intr_in_buffer[1]; + if(dev->free_slots > CPC_TX_QUEUE_TRIGGER_HIGH){ + if (netif_queue_stopped(netdev)){ + netif_wake_queue(netdev); + } + } break; =20 case -ECONNRESET: /* unlink */ @@ -535,8 +543,6 @@ static void ems_usb_write_bulk_callback(struct urb *urb= ) /* Release context */ context->echo_index =3D MAX_TX_URBS; =20 - if (netif_queue_stopped(netdev)) - netif_wake_queue(netdev); } =20 /* @@ -596,7 +602,7 @@ static int ems_usb_start(struct ems_usb *dev) int err, i; =20 dev->intr_in_buffer[0] =3D 0; - dev->free_slots =3D 15; /* initial size */ + dev->free_slots =3D 50; /* initial size */ =20 for (i =3D 0; i < MAX_RX_URBS; i++) { struct urb *urb =3D NULL; @@ -858,7 +864,7 @@ static netdev_tx_t ems_usb_start_xmit(struct sk_buff *s= kb, struct net_device *ne =20 /* Slow down tx path */ if (atomic_read(&dev->active_tx_urbs) >=3D MAX_TX_URBS || - dev->free_slots < 5) { + dev->free_slots < CPC_TX_QUEUE_TRIGGER_LOW) { netif_stop_queue(netdev); } } diff --git a/drivers/net/ethernet/mellanox/mlx4/en_port.c b/drivers/net/eth= ernet/mellanox/mlx4/en_port.c index 03c84cd78cde..0158799839ca 100644 --- a/drivers/net/ethernet/mellanox/mlx4/en_port.c +++ b/drivers/net/ethernet/mellanox/mlx4/en_port.c @@ -248,11 +248,11 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, = u8 port, u8 reset) be64_to_cpu(mlx4_en_stats->MCAST_novlan); stats->collisions =3D 0; stats->rx_length_errors =3D be32_to_cpu(mlx4_en_stats->RdropLength); - stats->rx_over_errors =3D be32_to_cpu(mlx4_en_stats->RdropOvflw); + stats->rx_over_errors =3D 0; stats->rx_crc_errors =3D be32_to_cpu(mlx4_en_stats->RCRC); stats->rx_frame_errors =3D 0; stats->rx_fifo_errors =3D be32_to_cpu(mlx4_en_stats->RdropOvflw); - stats->rx_missed_errors =3D be32_to_cpu(mlx4_en_stats->RdropOvflw); + stats->rx_missed_errors =3D 0; stats->tx_aborted_errors =3D 0; stats->tx_carrier_errors =3D 0; stats->tx_fifo_errors =3D 0; diff --git a/drivers/pci/xen-pcifront.c b/drivers/pci/xen-pcifront.c index 90832a955991..10d4ca2b4197 100644 --- a/drivers/pci/xen-pcifront.c +++ b/drivers/pci/xen-pcifront.c @@ -50,7 +50,7 @@ struct pcifront_device { }; =20 struct pcifront_sd { - int domain; + struct pci_sysdata sd; struct pcifront_device *pdev; }; =20 @@ -64,7 +64,9 @@ static inline void pcifront_init_sd(struct pcifront_sd *s= d, unsigned int domain, unsigned int bus, struct pcifront_device *pdev) { - sd->domain =3D domain; + /* Because we do not expose that information via XenBus. */ + sd->sd.node =3D first_online_node; + sd->sd.domain =3D domain; sd->pdev =3D pdev; } =20 @@ -461,8 +463,8 @@ static int __devinit pcifront_scan_root(struct pcifront= _device *pdev, dev_info(&pdev->xdev->dev, "Creating PCI Frontend Bus %04x:%02x\n", domain, bus); =20 - bus_entry =3D kmalloc(sizeof(*bus_entry), GFP_KERNEL); - sd =3D kmalloc(sizeof(*sd), GFP_KERNEL); + bus_entry =3D kzalloc(sizeof(*bus_entry), GFP_KERNEL); + sd =3D kzalloc(sizeof(*sd), GFP_KERNEL); if (!bus_entry || !sd) { err =3D -ENOMEM; goto err_out; diff --git a/drivers/s390/block/dasd_alias.c b/drivers/s390/block/dasd_alia= s.c index c388eda1e2b1..88a012e93bb6 100644 --- a/drivers/s390/block/dasd_alias.c +++ b/drivers/s390/block/dasd_alias.c @@ -326,8 +326,10 @@ void dasd_alias_disconnect_device_from_lcu(struct dasd= _device *device) spin_unlock_irqrestore(&lcu->lock, flags); cancel_work_sync(&lcu->suc_data.worker); spin_lock_irqsave(&lcu->lock, flags); - if (device =3D=3D lcu->suc_data.device) + if (device =3D=3D lcu->suc_data.device) { + dasd_put_device(device); lcu->suc_data.device =3D NULL; + } } was_pending =3D 0; if (device =3D=3D lcu->ruac_data.device) { @@ -335,8 +337,10 @@ void dasd_alias_disconnect_device_from_lcu(struct dasd= _device *device) was_pending =3D 1; cancel_delayed_work_sync(&lcu->ruac_data.dwork); spin_lock_irqsave(&lcu->lock, flags); - if (device =3D=3D lcu->ruac_data.device) + if (device =3D=3D lcu->ruac_data.device) { + dasd_put_device(device); lcu->ruac_data.device =3D NULL; + } } private->lcu =3D NULL; spin_unlock_irqrestore(&lcu->lock, flags); @@ -586,8 +590,10 @@ static void lcu_update_work(struct work_struct *work) if (rc || (lcu->flags & NEED_UAC_UPDATE)) { DBF_DEV_EVENT(DBF_WARNING, device, "could not update" " alias data in lcu (rc =3D %d), retry later", rc); - schedule_delayed_work(&lcu->ruac_data.dwork, 30*HZ); + if (!schedule_delayed_work(&lcu->ruac_data.dwork, 30*HZ)) + dasd_put_device(device); } else { + dasd_put_device(device); lcu->ruac_data.device =3D NULL; lcu->flags &=3D ~UPDATE_PENDING; } @@ -630,8 +636,10 @@ static int _schedule_lcu_update(struct alias_lcu *lcu, */ if (!usedev) return -EINVAL; + dasd_get_device(usedev); lcu->ruac_data.device =3D usedev; - schedule_delayed_work(&lcu->ruac_data.dwork, 0); + if (!schedule_delayed_work(&lcu->ruac_data.dwork, 0)) + dasd_put_device(usedev); return 0; } =20 @@ -749,7 +757,7 @@ static int reset_summary_unit_check(struct alias_lcu *l= cu, ASCEBC((char *) &cqr->magic, 4); ccw =3D cqr->cpaddr; ccw->cmd_code =3D DASD_ECKD_CCW_RSCK; - ccw->flags =3D 0 ; + ccw->flags =3D CCW_FLAG_SLI; ccw->count =3D 16; ccw->cda =3D (__u32)(addr_t) cqr->data; ((char *)cqr->data)[0] =3D reason; @@ -953,6 +961,7 @@ static void summary_unit_check_handling_work(struct wor= k_struct *work) /* 3. read new alias configuration */ _schedule_lcu_update(lcu, device); lcu->suc_data.device =3D NULL; + dasd_put_device(device); spin_unlock_irqrestore(&lcu->lock, flags); } =20 @@ -1012,6 +1021,8 @@ void dasd_alias_handle_summary_unit_check(struct dasd= _device *device, } lcu->suc_data.reason =3D reason; lcu->suc_data.device =3D device; + dasd_get_device(device); spin_unlock(&lcu->lock); - schedule_work(&lcu->suc_data.worker); + if (!schedule_work(&lcu->suc_data.worker)) + dasd_put_device(device); }; diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c index fd860d952b28..17f93ee0ff46 100644 --- a/drivers/scsi/ipr.c +++ b/drivers/scsi/ipr.c @@ -3736,13 +3736,17 @@ static ssize_t ipr_store_update_fw(struct device *d= ev, struct ipr_sglist *sglist; char fname[100]; char *src; - int len, result, dnld_size; + char *endline; + int result, dnld_size; =20 if (!capable(CAP_SYS_ADMIN)) return -EACCES; =20 - len =3D snprintf(fname, 99, "%s", buf); - fname[len-1] =3D '\0'; + snprintf(fname, sizeof(fname), "%s", buf); + + endline =3D strchr(fname, '\n'); + if (endline) + *endline =3D '\0'; =20 if(request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) { dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname); diff --git a/drivers/usb/dwc3/core.h b/drivers/usb/dwc3/core.h index ae2b763650d8..b05e4a584953 100644 --- a/drivers/usb/dwc3/core.h +++ b/drivers/usb/dwc3/core.h @@ -610,7 +610,6 @@ struct dwc3 { unsigned ep0_status_pending:1; unsigned ep0_bounced:1; unsigned ep0_expect_in:1; - unsigned start_config_issued:1; =20 enum dwc3_ep0_next ep0_next_event; enum dwc3_ep0_state ep0state; diff --git a/drivers/usb/dwc3/ep0.c b/drivers/usb/dwc3/ep0.c index 24864d4d2b14..529186bcf7c8 100644 --- a/drivers/usb/dwc3/ep0.c +++ b/drivers/usb/dwc3/ep0.c @@ -449,7 +449,6 @@ static int dwc3_ep0_set_config(struct dwc3 *dwc, struct= usb_ctrlrequest *ctrl) u32 cfg; int ret; =20 - dwc->start_config_issued =3D false; cfg =3D le16_to_cpu(ctrl->wValue); =20 switch (dwc->dev_state) { @@ -498,10 +497,6 @@ static int dwc3_ep0_std_request(struct dwc3 *dwc, stru= ct usb_ctrlrequest *ctrl) dev_vdbg(dwc->dev, "USB_REQ_SET_CONFIGURATION\n"); ret =3D dwc3_ep0_set_config(dwc, ctrl); break; - case USB_REQ_SET_INTERFACE: - dev_vdbg(dwc->dev ,"USB_REQ_SET_INTERFACE"); - dwc->start_config_issued =3D false; - /* Fall through */ default: dev_vdbg(dwc->dev, "Forwarding to gadget driver\n"); ret =3D dwc3_ep0_delegate_req(dwc, ctrl); diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c index b4623f1ac16f..392222ba28b7 100644 --- a/drivers/usb/dwc3/gadget.c +++ b/drivers/usb/dwc3/gadget.c @@ -229,24 +229,66 @@ static void dwc3_free_trb_pool(struct dwc3_ep *dep) dep->trb_pool_dma =3D 0; } =20 +static int dwc3_gadget_set_xfer_resource(struct dwc3 *dwc, struct dwc3_ep = *dep); + +/** + * dwc3_gadget_start_config - Configure EP resources + * @dwc: pointer to our controller context structure + * @dep: endpoint that is being enabled + * + * The assignment of transfer resources cannot perfectly follow the + * data book due to the fact that the controller driver does not have + * all knowledge of the configuration in advance. It is given this + * information piecemeal by the composite gadget framework after every + * SET_CONFIGURATION and SET_INTERFACE. Trying to follow the databook + * programming model in this scenario can cause errors. For two + * reasons: + * + * 1) The databook says to do DEPSTARTCFG for every SET_CONFIGURATION + * and SET_INTERFACE (8.1.5). This is incorrect in the scenario of + * multiple interfaces. + * + * 2) The databook does not mention doing more DEPXFERCFG for new + * endpoint on alt setting (8.1.6). + * + * The following simplified method is used instead: + * + * All hardware endpoints can be assigned a transfer resource and this + * setting will stay persistent until either a core reset or + * hibernation. So whenever we do a DEPSTARTCFG(0) we can go ahead and + * do DEPXFERCFG for every hardware endpoint as well. We are + * guaranteed that there are as many transfer resources as endpoints. + * + * This function is called for each endpoint when it is being enabled + * but is triggered only when called for EP0-out, which always happens + * first, and which should only happen in one of the above conditions. + */ static int dwc3_gadget_start_config(struct dwc3 *dwc, struct dwc3_ep *dep) { struct dwc3_gadget_ep_cmd_params params; u32 cmd; + int i; + int ret; + + if (dep->number) + return 0; =20 memset(¶ms, 0x00, sizeof(params)); + cmd =3D DWC3_DEPCMD_DEPSTARTCFG; =20 - if (dep->number !=3D 1) { - cmd =3D DWC3_DEPCMD_DEPSTARTCFG; - /* XferRscIdx =3D=3D 0 for ep0 and 2 for the remaining */ - if (dep->number > 1) { - if (dwc->start_config_issued) - return 0; - dwc->start_config_issued =3D true; - cmd |=3D DWC3_DEPCMD_PARAM(2); - } + ret =3D dwc3_send_gadget_ep_cmd(dwc, 0, cmd, ¶ms); + if (ret) + return ret; =20 - return dwc3_send_gadget_ep_cmd(dwc, 0, cmd, ¶ms); + for (i =3D 0; i < DWC3_ENDPOINTS_NUM; i++) { + struct dwc3_ep *dep =3D dwc->eps[i]; + + if (!dep) + continue; + + ret =3D dwc3_gadget_set_xfer_resource(dwc, dep); + if (ret) + return ret; } =20 return 0; @@ -340,10 +382,6 @@ static int __dwc3_gadget_ep_enable(struct dwc3_ep *dep= , struct dwc3_trb_hw *trb_link_hw; struct dwc3_trb trb_link; =20 - ret =3D dwc3_gadget_set_xfer_resource(dwc, dep); - if (ret) - return ret; - dep->desc =3D desc; dep->type =3D usb_endpoint_type(desc); dep->flags |=3D DWC3_EP_ENABLED; @@ -1185,8 +1223,6 @@ static int dwc3_gadget_start(struct usb_gadget *g, reg |=3D DWC3_DCFG_SUPERSPEED; dwc3_writel(dwc->regs, DWC3_DCFG, reg); =20 - dwc->start_config_issued =3D false; - /* Start with SuperSpeed Default */ dwc3_gadget_ep0_desc.wMaxPacketSize =3D cpu_to_le16(512); =20 @@ -1640,7 +1676,6 @@ static void dwc3_gadget_disconnect_interrupt(struct d= wc3 *dwc) =20 dwc3_stop_active_transfers(dwc); dwc3_disconnect_gadget(dwc); - dwc->start_config_issued =3D false; =20 dwc->gadget.speed =3D USB_SPEED_UNKNOWN; } @@ -1692,7 +1727,6 @@ static void dwc3_gadget_reset_interrupt(struct dwc3 *= dwc) =20 dwc3_stop_active_transfers(dwc); dwc3_clear_stall_all_ep(dwc); - dwc->start_config_issued =3D false; =20 /* Reset device address to zero */ reg =3D dwc3_readl(dwc->regs, DWC3_DCFG); diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c index a30b188f914a..9b43535cd182 100644 --- a/drivers/usb/serial/cp210x.c +++ b/drivers/usb/serial/cp210x.c @@ -168,6 +168,9 @@ static const struct usb_device_id id_table[] =3D { { USB_DEVICE(0x1843, 0x0200) }, /* Vaisala USB Instrument Cable */ { USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */ { USB_DEVICE(0x18EF, 0xE025) }, /* ELV Marble Sound Board 1 */ + { USB_DEVICE(0x1901, 0x0190) }, /* GE B850 CP2105 Recorder interface */ + { USB_DEVICE(0x1901, 0x0193) }, /* GE B650 CP2104 PMC interface */ + { USB_DEVICE(0x19CF, 0x3000) }, /* Parrot NMEA GPS Flight Recorder */ { USB_DEVICE(0x1ADB, 0x0001) }, /* Schweitzer Engineering C662 Cable */ { USB_DEVICE(0x1B1C, 0x1C00) }, /* Corsair USB Dongle */ { USB_DEVICE(0x1BA4, 0x0002) }, /* Silicon Labs 358x factory default */ diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c index 0aa025f1d5fd..e8abf19129b6 100644 --- a/drivers/usb/serial/option.c +++ b/drivers/usb/serial/option.c @@ -316,6 +316,7 @@ static void option_instat_callback(struct urb *urb); #define TOSHIBA_PRODUCT_G450 0x0d45 =20 #define ALINK_VENDOR_ID 0x1e0e +#define SIMCOM_PRODUCT_SIM7100E 0x9001 /* Yes, ALINK_VENDOR_ID */ #define ALINK_PRODUCT_PH300 0x9100 #define ALINK_PRODUCT_3GU 0x9200 =20 @@ -613,6 +614,10 @@ static const struct option_blacklist_info zte_1255_bla= cklist =3D { .reserved =3D BIT(3) | BIT(4), }; =20 +static const struct option_blacklist_info simcom_sim7100e_blacklist =3D { + .reserved =3D BIT(5) | BIT(6), +}; + static const struct option_blacklist_info telit_le910_blacklist =3D { .sendsetup =3D BIT(0), .reserved =3D BIT(1) | BIT(2), @@ -1128,9 +1133,13 @@ static const struct usb_device_id option_ids[] =3D { { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC650) }, { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC680) }, { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6000)}, /* ZTE AC8700 */ + { USB_DEVICE_AND_INTERFACE_INFO(QUALCOMM_VENDOR_ID, 0x6001, 0xff, 0xff, 0= xff), /* 4G LTE usb-modem U901 */ + .driver_info =3D (kernel_ulong_t)&net_intf3_blacklist }, { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */ { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x0023)}, /* ONYX 3G device */ { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x9000)}, /* SIMCom SIM5218 */ + { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x9003), /* Quectel UC20 */ + .driver_info =3D (kernel_ulong_t)&net_intf4_blacklist }, { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6001) }, { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_CMU_300) }, { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6003), @@ -1644,6 +1653,8 @@ static const struct usb_device_id option_ids[] =3D { { USB_DEVICE(ALINK_VENDOR_ID, 0x9000) }, { USB_DEVICE(ALINK_VENDOR_ID, ALINK_PRODUCT_PH300) }, { USB_DEVICE_AND_INTERFACE_INFO(ALINK_VENDOR_ID, ALINK_PRODUCT_3GU, 0xff,= 0xff, 0xff) }, + { USB_DEVICE(ALINK_VENDOR_ID, SIMCOM_PRODUCT_SIM7100E), + .driver_info =3D (kernel_ulong_t)&simcom_sim7100e_blacklist }, { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X060S_X200), .driver_info =3D (kernel_ulong_t)&alcatel_x200_blacklist }, diff --git a/drivers/xen/xen-pciback/pciback_ops.c b/drivers/xen/xen-pcibac= k/pciback_ops.c index 31c8580ceecc..ceed177914a2 100644 --- a/drivers/xen/xen-pciback/pciback_ops.c +++ b/drivers/xen/xen-pciback/pciback_ops.c @@ -225,8 +225,9 @@ int xen_pcibk_enable_msix(struct xen_pcibk_device *pdev= , /* * PCI_COMMAND_MEMORY must be enabled, otherwise we may not be able * to access the BARs where the MSI-X entries reside. + * But VF devices are unique in which the PF needs to be checked. */ - pci_read_config_word(dev, PCI_COMMAND, &cmd); + pci_read_config_word(pci_physfn(dev), PCI_COMMAND, &cmd); if (dev->msi_enabled || !(cmd & PCI_COMMAND_MEMORY)) return -ENXIO; =20 @@ -330,6 +331,9 @@ void xen_pcibk_do_op(struct work_struct *data) struct xen_pcibk_dev_data *dev_data =3D NULL; struct xen_pci_op *op =3D &pdev->op; int test_intx =3D 0; +#ifdef CONFIG_PCI_MSI + unsigned int nr =3D 0; +#endif =20 *op =3D pdev->sh_info->op; barrier(); @@ -358,6 +362,7 @@ void xen_pcibk_do_op(struct work_struct *data) op->err =3D xen_pcibk_disable_msi(pdev, dev, op); break; case XEN_PCI_OP_enable_msix: + nr =3D op->value; op->err =3D xen_pcibk_enable_msix(pdev, dev, op); break; case XEN_PCI_OP_disable_msix: @@ -380,7 +385,7 @@ void xen_pcibk_do_op(struct work_struct *data) if (op->cmd =3D=3D XEN_PCI_OP_enable_msix && op->err =3D=3D 0) { unsigned int i; =20 - for (i =3D 0; i < op->value; i++) + for (i =3D 0; i < nr; i++) pdev->sh_info->op.msix_entries[i].vector =3D op->msix_entries[i].vector; } diff --git a/fs/cifs/cifsencrypt.c b/fs/cifs/cifsencrypt.c index af9538650566..12cce595f026 100644 --- a/fs/cifs/cifsencrypt.c +++ b/fs/cifs/cifsencrypt.c @@ -616,7 +616,7 @@ setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls= _table *nls_cp) =20 ses->auth_key.response =3D kmalloc(baselen + tilen, GFP_KERNEL); if (!ses->auth_key.response) { - rc =3D ENOMEM; + rc =3D -ENOMEM; ses->auth_key.len =3D 0; cERROR(1, "%s: Can't allocate auth blob", __func__); goto setup_ntlmv2_rsp_ret; diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c index 06107662ac53..0de8c6ddf580 100644 --- a/fs/ext4/inode.c +++ b/fs/ext4/inode.c @@ -595,6 +595,34 @@ int ext4_map_blocks(handle_t *handle, struct inode *in= ode, return retval; } =20 +/* + * Update EXT4_MAP_FLAGS in bh->b_state. For buffer heads attached to page= s + * we have to be careful as someone else may be manipulating b_state as we= ll. + */ +static void ext4_update_bh_state(struct buffer_head *bh, unsigned long fla= gs) +{ + unsigned long old_state; + unsigned long new_state; + + flags &=3D EXT4_MAP_FLAGS; + + /* Dummy buffer_head? Set non-atomically. */ + if (!bh->b_page) { + bh->b_state =3D (bh->b_state & ~EXT4_MAP_FLAGS) | flags; + return; + } + /* + * Someone else may be modifying b_state. Be careful! This is ugly but + * once we get rid of using bh as a container for mapping information + * to pass to / from get_block functions, this can go away. + */ + do { + old_state =3D ACCESS_ONCE(bh->b_state); + new_state =3D (old_state & ~EXT4_MAP_FLAGS) | flags; + } while (unlikely( + cmpxchg(&bh->b_state, old_state, new_state) !=3D old_state)); +} + /* Maximum number of blocks we map for direct IO at once. */ #define DIO_MAX_BLOCKS 4096 =20 @@ -625,7 +653,7 @@ static int _ext4_get_block(struct inode *inode, sector_= t iblock, ret =3D ext4_map_blocks(handle, inode, &map, flags); if (ret > 0) { map_bh(bh, inode->i_sb, map.m_pblk); - bh->b_state =3D (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags; + ext4_update_bh_state(bh, map.m_flags); bh->b_size =3D inode->i_sb->s_blocksize * map.m_len; ret =3D 0; } @@ -1787,7 +1815,7 @@ static int ext4_da_get_block_prep(struct inode *inode= , sector_t iblock, return ret; =20 map_bh(bh, inode->i_sb, map.m_pblk); - bh->b_state =3D (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags; + ext4_update_bh_state(bh, map.m_flags); =20 if (buffer_unwritten(bh)) { /* A delayed write to unwritten bh should be marked diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c index ea91fcb0ef9b..902d94829b5c 100644 --- a/fs/hpfs/namei.c +++ b/fs/hpfs/namei.c @@ -362,12 +362,11 @@ static int hpfs_unlink(struct inode *dir, struct dent= ry *dentry) struct inode *inode =3D dentry->d_inode; dnode_secno dno; int r; - int rep =3D 0; int err; =20 hpfs_lock(dir->i_sb); hpfs_adjust_length(name, &len); -again: + err =3D -ENOENT; de =3D map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh); if (!de) @@ -387,33 +386,9 @@ again: hpfs_error(dir->i_sb, "there was error when removing dirent"); err =3D -EFSERROR; break; - case 2: /* no space for deleting, try to truncate file */ - + case 2: /* no space for deleting */ err =3D -ENOSPC; - if (rep++) - break; - - dentry_unhash(dentry); - if (!d_unhashed(dentry)) { - hpfs_unlock(dir->i_sb); - return -ENOSPC; - } - if (generic_permission(inode, MAY_WRITE) || - !S_ISREG(inode->i_mode) || - get_write_access(inode)) { - d_rehash(dentry); - } else { - struct iattr newattrs; - /*printk("HPFS: truncating file before delete.\n");*/ - newattrs.ia_size =3D 0; - newattrs.ia_valid =3D ATTR_SIZE | ATTR_CTIME; - err =3D notify_change(dentry, &newattrs); - put_write_access(inode); - if (!err) - goto again; - } - hpfs_unlock(dir->i_sb); - return -ENOSPC; + break; default: drop_nlink(inode); err =3D 0; diff --git a/fs/jffs2/README.Locking b/fs/jffs2/README.Locking index 3ea36554107f..8918ac905a3b 100644 --- a/fs/jffs2/README.Locking +++ b/fs/jffs2/README.Locking @@ -2,10 +2,6 @@ JFFS2 LOCKING DOCUMENTATION --------------------------- =20 -At least theoretically, JFFS2 does not require the Big Kernel Lock -(BKL), which was always helpfully obtained for it by Linux 2.4 VFS -code. It has its own locking, as described below. - This document attempts to describe the existing locking rules for JFFS2. It is not expected to remain perfectly up to date, but ought to be fairly close. @@ -69,6 +65,7 @@ Ordering constraints: any f->sem held. 2. Never attempt to lock two file mutexes in one thread. No ordering rules have been made for doing so. + 3. Never lock a page cache page with f->sem held. =20 =20 erase_completion_lock spinlock diff --git a/fs/jffs2/build.c b/fs/jffs2/build.c index 3005ec4520ad..99f0eaa7ab82 100644 --- a/fs/jffs2/build.c +++ b/fs/jffs2/build.c @@ -47,7 +47,8 @@ next_inode(int *i, struct jffs2_inode_cache *ic, struct j= ffs2_sb_info *c) =20 =20 static void jffs2_build_inode_pass1(struct jffs2_sb_info *c, - struct jffs2_inode_cache *ic) + struct jffs2_inode_cache *ic, + int *dir_hardlinks) { struct jffs2_full_dirent *fd; =20 @@ -66,19 +67,21 @@ static void jffs2_build_inode_pass1(struct jffs2_sb_inf= o *c, dbg_fsbuild("child \"%s\" (ino #%u) of dir ino #%u doesn't exist!\n", fd->name, fd->ino, ic->ino); jffs2_mark_node_obsolete(c, fd->raw); + /* Clear the ic/raw union so it doesn't cause problems later. */ + fd->ic =3D NULL; continue; } =20 + /* From this point, fd->raw is no longer used so we can set fd->ic */ + fd->ic =3D child_ic; + child_ic->pino_nlink++; + /* If we appear (at this stage) to have hard-linked directories, + * set a flag to trigger a scan later */ if (fd->type =3D=3D DT_DIR) { - if (child_ic->pino_nlink) { - JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u appears to be a= hard link\n", - fd->name, fd->ino, ic->ino); - /* TODO: What do we do about it? */ - } else { - child_ic->pino_nlink =3D ic->ino; - } - } else - child_ic->pino_nlink++; + child_ic->flags |=3D INO_FLAGS_IS_DIR; + if (child_ic->pino_nlink > 1) + *dir_hardlinks =3D 1; + } =20 dbg_fsbuild("increased nlink for child \"%s\" (ino #%u)\n", fd->name, fd= ->ino); /* Can't free scan_dents so far. We might need them in pass 2 */ @@ -92,8 +95,7 @@ static void jffs2_build_inode_pass1(struct jffs2_sb_info = *c, */ static int jffs2_build_filesystem(struct jffs2_sb_info *c) { - int ret; - int i; + int ret, i, dir_hardlinks =3D 0; struct jffs2_inode_cache *ic; struct jffs2_full_dirent *fd; struct jffs2_full_dirent *dead_fds =3D NULL; @@ -117,7 +119,7 @@ static int jffs2_build_filesystem(struct jffs2_sb_info = *c) /* Now scan the directory tree, increasing nlink according to every diren= t found. */ for_each_inode(i, c, ic) { if (ic->scan_dents) { - jffs2_build_inode_pass1(c, ic); + jffs2_build_inode_pass1(c, ic, &dir_hardlinks); cond_resched(); } } @@ -153,6 +155,20 @@ static int jffs2_build_filesystem(struct jffs2_sb_info= *c) } =20 dbg_fsbuild("pass 2a complete\n"); + + if (dir_hardlinks) { + /* If we detected directory hardlinks earlier, *hopefully* + * they are gone now because some of the links were from + * dead directories which still had some old dirents lying + * around and not yet garbage-collected, but which have + * been discarded above. So clear the pino_nlink field + * in each directory, so that the final scan below can + * print appropriate warnings. */ + for_each_inode(i, c, ic) { + if (ic->flags & INO_FLAGS_IS_DIR) + ic->pino_nlink =3D 0; + } + } dbg_fsbuild("freeing temporary data structures\n"); =20 /* Finally, we can scan again and free the dirent structs */ @@ -160,6 +176,33 @@ static int jffs2_build_filesystem(struct jffs2_sb_info= *c) while(ic->scan_dents) { fd =3D ic->scan_dents; ic->scan_dents =3D fd->next; + /* We do use the pino_nlink field to count nlink of + * directories during fs build, so set it to the + * parent ino# now. Now that there's hopefully only + * one. */ + if (fd->type =3D=3D DT_DIR) { + if (!fd->ic) { + /* We'll have complained about it and marked the coresponding + raw node obsolete already. Just skip it. */ + continue; + } + + /* We *have* to have set this in jffs2_build_inode_pass1() */ + BUG_ON(!(fd->ic->flags & INO_FLAGS_IS_DIR)); + + /* We clear ic->pino_nlink =E2=88=80 directories' ic *only* if dir_har= dlinks + * is set. Otherwise, we know this should never trigger anyway, so + * we don't do the check. And ic->pino_nlink still contains the nlink + * value (which is 1). */ + if (dir_hardlinks && fd->ic->pino_nlink) { + JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u is also hard l= inked from dir ino #%u\n", + fd->name, fd->ino, ic->ino, fd->ic->pino_nlink); + /* Should we unlink it from its previous parent? */ + } + + /* For directories, ic->pino_nlink holds that parent inode # */ + fd->ic->pino_nlink =3D ic->ino; + } jffs2_free_full_dirent(fd); } ic->scan_dents =3D NULL; @@ -238,11 +281,7 @@ static void jffs2_build_remove_unlinked_inode(struct j= ffs2_sb_info *c, =20 /* Reduce nlink of the child. If it's now zero, stick it on the dead_fds list to be cleaned up later. Else just free the fd */ - - if (fd->type =3D=3D DT_DIR) - child_ic->pino_nlink =3D 0; - else - child_ic->pino_nlink--; + child_ic->pino_nlink--; =20 if (!child_ic->pino_nlink) { dbg_fsbuild("inode #%u (\"%s\") now has no links; adding to dead_fds l= ist.\n", diff --git a/fs/jffs2/file.c b/fs/jffs2/file.c index 0095a70a3426..4964a5bd2d26 100644 --- a/fs/jffs2/file.c +++ b/fs/jffs2/file.c @@ -135,39 +135,33 @@ static int jffs2_write_begin(struct file *filp, struc= t address_space *mapping, struct page *pg; struct inode *inode =3D mapping->host; struct jffs2_inode_info *f =3D JFFS2_INODE_INFO(inode); - struct jffs2_sb_info *c =3D JFFS2_SB_INFO(inode->i_sb); - struct jffs2_raw_inode ri; - uint32_t alloc_len =3D 0; pgoff_t index =3D pos >> PAGE_CACHE_SHIFT; uint32_t pageofs =3D index << PAGE_CACHE_SHIFT; int ret =3D 0; =20 - D1(printk(KERN_DEBUG "%s()\n", __func__)); - - if (pageofs > inode->i_size) { - ret =3D jffs2_reserve_space(c, sizeof(ri), &alloc_len, - ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); - if (ret) - return ret; - } - - mutex_lock(&f->sem); pg =3D grab_cache_page_write_begin(mapping, index, flags); - if (!pg) { - if (alloc_len) - jffs2_complete_reservation(c); - mutex_unlock(&f->sem); + if (!pg) return -ENOMEM; - } *pagep =3D pg; =20 - if (alloc_len) { + D1(printk(KERN_DEBUG "%s()\n", __func__)); + + if (pageofs > inode->i_size) { /* Make new hole frag from old EOF to new page */ + struct jffs2_sb_info *c =3D JFFS2_SB_INFO(inode->i_sb); + struct jffs2_raw_inode ri; struct jffs2_full_dnode *fn; + uint32_t alloc_len; =20 D1(printk(KERN_DEBUG "Writing new hole frag 0x%x-0x%x between current EO= F and new page\n", (unsigned int)inode->i_size, pageofs)); =20 + ret =3D jffs2_reserve_space(c, sizeof(ri), &alloc_len, + ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); + if (ret) + goto out_page; + + mutex_lock(&f->sem); memset(&ri, 0, sizeof(ri)); =20 ri.magic =3D cpu_to_je16(JFFS2_MAGIC_BITMASK); @@ -194,6 +188,7 @@ static int jffs2_write_begin(struct file *filp, struct = address_space *mapping, if (IS_ERR(fn)) { ret =3D PTR_ERR(fn); jffs2_complete_reservation(c); + mutex_unlock(&f->sem); goto out_page; } ret =3D jffs2_add_full_dnode_to_inode(c, f, fn); @@ -207,10 +202,12 @@ static int jffs2_write_begin(struct file *filp, struc= t address_space *mapping, jffs2_mark_node_obsolete(c, fn->raw); jffs2_free_full_dnode(fn); jffs2_complete_reservation(c); + mutex_unlock(&f->sem); goto out_page; } jffs2_complete_reservation(c); inode->i_size =3D pageofs; + mutex_unlock(&f->sem); } =20 /* @@ -219,18 +216,18 @@ static int jffs2_write_begin(struct file *filp, struc= t address_space *mapping, * case of a short-copy. */ if (!PageUptodate(pg)) { + mutex_lock(&f->sem); ret =3D jffs2_do_readpage_nolock(inode, pg); + mutex_unlock(&f->sem); if (ret) goto out_page; } - mutex_unlock(&f->sem); D1(printk(KERN_DEBUG "end write_begin(). pg->flags %lx\n", pg->flags)); return ret; =20 out_page: unlock_page(pg); page_cache_release(pg); - mutex_unlock(&f->sem); return ret; } =20 diff --git a/fs/jffs2/gc.c b/fs/jffs2/gc.c index 4bbd5211bb32..42b7fca0889e 100644 --- a/fs/jffs2/gc.c +++ b/fs/jffs2/gc.c @@ -1246,14 +1246,17 @@ static int jffs2_garbage_collect_dnode(struct jffs2= _sb_info *c, struct jffs2_era BUG_ON(start > orig_start); } =20 - /* First, use readpage() to read the appropriate page into the page cache= */ - /* Q: What happens if we actually try to GC the _same_ page for which com= mit_write() - * triggered garbage collection in the first place? - * A: I _think_ it's OK. read_cache_page shouldn't deadlock, we'll write = out the - * page OK. We'll actually write it out again in commit_write, which i= s a little - * suboptimal, but at least we're correct. - */ + /* The rules state that we must obtain the page lock *before* f->sem, so + * drop f->sem temporarily. Since we also hold c->alloc_sem, nothing's + * actually going to *change* so we're safe; we only allow reading. + * + * It is important to note that jffs2_write_begin() will ensure that its + * page is marked Uptodate before allocating space. That means that if we + * end up here trying to GC the *same* page that jffs2_write_begin() is + * trying to write out, read_cache_page() will not deadlock. */ + mutex_unlock(&f->sem); pg_ptr =3D jffs2_gc_fetch_page(c, f, start, &pg); + mutex_lock(&f->sem); =20 if (IS_ERR(pg_ptr)) { printk(KERN_WARNING "read_cache_page() returned error: %ld\n", PTR_ERR(p= g_ptr)); diff --git a/fs/jffs2/nodelist.h b/fs/jffs2/nodelist.h index fa35ff79ab35..0637271f3770 100644 --- a/fs/jffs2/nodelist.h +++ b/fs/jffs2/nodelist.h @@ -194,6 +194,7 @@ struct jffs2_inode_cache { #define INO_STATE_CLEARING 6 /* In clear_inode() */ =20 #define INO_FLAGS_XATTR_CHECKED 0x01 /* has no duplicate xattr_ref */ +#define INO_FLAGS_IS_DIR 0x02 /* is a directory */ =20 #define RAWNODE_CLASS_INODE_CACHE 0 #define RAWNODE_CLASS_XATTR_DATUM 1 @@ -249,7 +250,10 @@ struct jffs2_readinode_info =20 struct jffs2_full_dirent { - struct jffs2_raw_node_ref *raw; + union { + struct jffs2_raw_node_ref *raw; + struct jffs2_inode_cache *ic; /* Just during part of build */ + }; struct jffs2_full_dirent *next; uint32_t version; uint32_t ino; /* =3D=3D zero for unlink */ diff --git a/include/linux/ata.h b/include/linux/ata.h index 5856c9e02192..abdf0d7d1bc4 100644 --- a/include/linux/ata.h +++ b/include/linux/ata.h @@ -464,8 +464,8 @@ enum ata_tf_protocols { }; =20 enum ata_ioctls { - ATA_IOC_GET_IO32 =3D 0x309, - ATA_IOC_SET_IO32 =3D 0x324, + ATA_IOC_GET_IO32 =3D 0x309, /* HDIO_GET_32BIT */ + ATA_IOC_SET_IO32 =3D 0x324, /* HDIO_SET_32BIT */ }; =20 /* core structures */ diff --git a/include/linux/compiler.h b/include/linux/compiler.h index 65c8b78fc9af..01b6d065d609 100644 --- a/include/linux/compiler.h +++ b/include/linux/compiler.h @@ -125,7 +125,7 @@ void ftrace_likely_update(struct ftrace_branch_data *f,= int val, int expect); */ #define if(cond, ...) __trace_if( (cond , ## __VA_ARGS__) ) #define __trace_if(cond) \ - if (__builtin_constant_p((cond)) ? !!(cond) : \ + if (__builtin_constant_p(!!(cond)) ? !!(cond) : \ ({ \ int ______r; \ static struct ftrace_branch_data \ diff --git a/include/linux/libata.h b/include/linux/libata.h index 000434ef6fff..10f56437ae4d 100644 --- a/include/linux/libata.h +++ b/include/linux/libata.h @@ -662,7 +662,7 @@ struct ata_device { union { u16 id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */ u32 gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */ - }; + } ____cacheline_aligned; =20 /* error history */ int spdn_cnt; diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h index 33c52a22d598..018164cb32f5 100644 --- a/include/linux/nfs_fs.h +++ b/include/linux/nfs_fs.h @@ -588,9 +588,7 @@ static inline void nfs3_forget_cached_acls(struct inode= *inode) =20 static inline loff_t nfs_size_to_loff_t(__u64 size) { - if (size > (__u64) OFFSET_MAX - 1) - return OFFSET_MAX - 1; - return (loff_t) size; + return min_t(u64, size, OFFSET_MAX); } =20 static inline ino_t diff --git a/include/linux/poison.h b/include/linux/poison.h index 79159de0e341..eae9c383e7cc 100644 --- a/include/linux/poison.h +++ b/include/linux/poison.h @@ -19,8 +19,8 @@ * under normal circumstances, used to verify that nobody uses * non-initialized list entries. */ -#define LIST_POISON1 ((void *) 0x00100100 + POISON_POINTER_DELTA) -#define LIST_POISON2 ((void *) 0x00200200 + POISON_POINTER_DELTA) +#define LIST_POISON1 ((void *) 0x100 + POISON_POINTER_DELTA) +#define LIST_POISON2 ((void *) 0x200 + POISON_POINTER_DELTA) =20 /********** include/linux/timer.h **********/ /* diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h index d9c4a603c25e..04eda28c9203 100644 --- a/include/linux/skbuff.h +++ b/include/linux/skbuff.h @@ -1377,6 +1377,30 @@ static inline void skb_reserve(struct sk_buff *skb, = int len) skb->tail +=3D len; } =20 +/** + * skb_tailroom_reserve - adjust reserved_tailroom + * @skb: buffer to alter + * @mtu: maximum amount of headlen permitted + * @needed_tailroom: minimum amount of reserved_tailroom + * + * Set reserved_tailroom so that headlen can be as large as possible but + * not larger than mtu and tailroom cannot be smaller than + * needed_tailroom. + * The required headroom should already have been reserved before using + * this function. + */ +static inline void skb_tailroom_reserve(struct sk_buff *skb, unsigned int = mtu, + unsigned int needed_tailroom) +{ + SKB_LINEAR_ASSERT(skb); + if (mtu < skb_tailroom(skb) - needed_tailroom) + /* use at most mtu */ + skb->reserved_tailroom =3D skb_tailroom(skb) - mtu; + else + /* use up to all available space */ + skb->reserved_tailroom =3D needed_tailroom; +} + static inline void skb_reset_mac_len(struct sk_buff *skb) { skb->mac_len =3D skb->network_header - skb->mac_header; diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h index f3680aa895bc..41d17562fa32 100644 --- a/include/linux/tracepoint.h +++ b/include/linux/tracepoint.h @@ -14,8 +14,10 @@ * See the file COPYING for more details. */ =20 +#include #include #include +#include #include #include =20 @@ -126,6 +128,9 @@ static inline void tracepoint_synchronize_unregister(vo= id) void *it_func; \ void *__data; \ \ + if (!cpu_online(raw_smp_processor_id())) \ + return; \ + \ if (!(cond)) \ return; \ rcu_read_lock_sched_notrace(); \ diff --git a/include/net/iw_handler.h b/include/net/iw_handler.h index 5d5a6a4732ef..1b5984a46fe9 100644 --- a/include/net/iw_handler.h +++ b/include/net/iw_handler.h @@ -442,6 +442,12 @@ extern void wireless_send_event(struct net_device * de= v, unsigned int cmd, union iwreq_data * wrqu, const char * extra); +#ifdef CONFIG_WEXT_CORE +/* flush all previous wext events - if work is done from netdev notifiers = */ +void wireless_nlevent_flush(void); +#else +static inline void wireless_nlevent_flush(void) {} +#endif =20 /* We may need a function to send a stream of events to user space. * More on that later... */ diff --git a/kernel/resource.c b/kernel/resource.c index 08aa28e23abb..240e26ee4a23 100644 --- a/kernel/resource.c +++ b/kernel/resource.c @@ -886,9 +886,10 @@ struct resource * __request_region(struct resource *pa= rent, if (!conflict) break; if (conflict !=3D parent) { - parent =3D conflict; - if (!(conflict->flags & IORESOURCE_BUSY)) + if (!(conflict->flags & IORESOURCE_BUSY)) { + parent =3D conflict; continue; + } } if (conflict->flags & flags & IORESOURCE_MUXED) { add_wait_queue(&muxed_resource_wait, &wait); diff --git a/mm/memory.c b/mm/memory.c index 7762b1d59a29..675b211296fd 100644 --- a/mm/memory.c +++ b/mm/memory.c @@ -3583,8 +3583,18 @@ retry: */ if (unlikely(pmd_none(*pmd)) && __pte_alloc(mm, vma, pmd, address)) return VM_FAULT_OOM; - /* if an huge pmd materialized from under us just retry later */ - if (unlikely(pmd_trans_huge(*pmd))) + /* + * If a huge pmd materialized under us just retry later. Use + * pmd_trans_unstable() instead of pmd_trans_huge() to ensure the pmd + * didn't become pmd_trans_huge under us and then back to pmd_none, as + * a result of MADV_DONTNEED running immediately after a huge pmd fault + * in a different thread of this mm, in turn leading to a misleading + * pmd_trans_huge() retval. All we have to ensure is that it is a + * regular pmd that we can walk with pte_offset_map() and we can do that + * through an atomic read in C, which is what pmd_trans_unstable() + * provides. + */ + if (unlikely(pmd_trans_unstable(pmd))) return 0; /* * A regular pmd is established and it can't morph into a huge pmd diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c index d9c1d589f131..24f69a0cebfa 100644 --- a/net/ipv4/igmp.c +++ b/net/ipv4/igmp.c @@ -327,9 +327,8 @@ static struct sk_buff *igmpv3_newpack(struct net_device= *dev, unsigned int mtu) skb_dst_set(skb, &rt->dst); skb->dev =3D dev; =20 - skb->reserved_tailroom =3D skb_end_offset(skb) - - min(mtu, skb_end_offset(skb)); skb_reserve(skb, hlen); + skb_tailroom_reserve(skb, mtu, tlen); =20 skb_reset_network_header(skb); pip =3D ip_hdr(skb); diff --git a/net/ipv6/mcast.c b/net/ipv6/mcast.c index 9129a7c8fe36..be5466e3b54f 100644 --- a/net/ipv6/mcast.c +++ b/net/ipv6/mcast.c @@ -1359,9 +1359,8 @@ static struct sk_buff *mld_newpack(struct inet6_dev *= idev, unsigned int mtu) if (!skb) return NULL; =20 - skb->reserved_tailroom =3D skb_end_offset(skb) - - min(mtu, skb_end_offset(skb)); skb_reserve(skb, hlen); + skb_tailroom_reserve(skb, mtu, tlen); =20 if (__ipv6_get_lladdr(idev, &addr_buf, IFA_F_TENTATIVE)) { /* : diff --git a/net/mac80211/agg-rx.c b/net/mac80211/agg-rx.c index 6174785fe9f3..635fa804fc3b 100644 --- a/net/mac80211/agg-rx.c +++ b/net/mac80211/agg-rx.c @@ -280,7 +280,7 @@ void ieee80211_process_addba_request(struct ieee80211_l= ocal *local, } =20 /* prepare A-MPDU MLME for Rx aggregation */ - tid_agg_rx =3D kmalloc(sizeof(struct tid_ampdu_rx), GFP_KERNEL); + tid_agg_rx =3D kzalloc(sizeof(*tid_agg_rx), GFP_KERNEL); if (!tid_agg_rx) goto end; =20 diff --git a/net/mac80211/rc80211_minstrel_ht.c b/net/mac80211/rc80211_mins= trel_ht.c index cdb28535716b..2fe20c981a6e 100644 --- a/net/mac80211/rc80211_minstrel_ht.c +++ b/net/mac80211/rc80211_minstrel_ht.c @@ -376,7 +376,7 @@ minstrel_aggr_check(struct minstrel_priv *mp, struct ie= ee80211_sta *pubsta, stru if (skb_get_queue_mapping(skb) =3D=3D IEEE80211_AC_VO) return; =20 - ieee80211_start_tx_ba_session(pubsta, tid, 5000); + ieee80211_start_tx_ba_session(pubsta, tid, 0); } =20 static void diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c index 7de935a22353..51b23bc01542 100644 --- a/net/sunrpc/cache.c +++ b/net/sunrpc/cache.c @@ -1211,7 +1211,7 @@ int qword_get(char **bpp, char *dest, int bufsize) if (bp[0] =3D=3D '\\' && bp[1] =3D=3D 'x') { /* HEX STRING */ bp +=3D 2; - while (len < bufsize) { + while (len < bufsize - 1) { int h, l; =20 h =3D hex_to_bin(bp[0]); diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c index 390e079913f4..8d0b803bb7ca 100644 --- a/net/unix/af_unix.c +++ b/net/unix/af_unix.c @@ -1694,7 +1694,12 @@ restart_locked: goto out_unlock; } =20 - if (unlikely(unix_peer(other) !=3D sk && unix_recvq_full(other))) { + /* other =3D=3D sk && unix_peer(other) !=3D sk if + * - unix_peer(sk) =3D=3D NULL, destination address bound to sk + * - unix_peer(sk) =3D=3D sk by time of get but disconnected before lock + */ + if (other !=3D sk && + unlikely(unix_peer(other) !=3D sk && unix_recvq_full(other))) { if (timeo) { timeo =3D unix_wait_for_peer(other, timeo); =20 @@ -2059,13 +2064,15 @@ static int unix_stream_recvmsg(struct kiocb *iocb, = struct socket *sock, int err =3D 0; long timeo; =20 - err =3D -EINVAL; - if (sk->sk_state !=3D TCP_ESTABLISHED) + if (unlikely(sk->sk_state !=3D TCP_ESTABLISHED)) { + err =3D -EINVAL; goto out; + } =20 - err =3D -EOPNOTSUPP; - if (flags&MSG_OOB) + if (unlikely(flags & MSG_OOB)) { + err =3D -EOPNOTSUPP; goto out; + } =20 target =3D sock_rcvlowat(sk, flags&MSG_WAITALL, size); timeo =3D sock_rcvtimeo(sk, noblock); @@ -2107,9 +2114,11 @@ static int unix_stream_recvmsg(struct kiocb *iocb, s= truct socket *sock, goto unlock; =20 unix_state_unlock(sk); - err =3D -EAGAIN; - if (!timeo) + if (!timeo) { + err =3D -EAGAIN; break; + } + mutex_unlock(&u->readlock); =20 timeo =3D unix_stream_data_wait(sk, timeo); diff --git a/net/wireless/core.c b/net/wireless/core.c index ea93f4bf4d39..4043f71792cd 100644 --- a/net/wireless/core.c +++ b/net/wireless/core.c @@ -985,8 +985,12 @@ static int cfg80211_netdev_notifier_call(struct notifi= er_block * nb, if (ret) return notifier_from_errno(ret); break; + default: + return NOTIFY_DONE; } =20 + wireless_nlevent_flush(); + return NOTIFY_DONE; } =20 diff --git a/net/wireless/wext-core.c b/net/wireless/wext-core.c index 0af7f54e4f61..2894190a697c 100644 --- a/net/wireless/wext-core.c +++ b/net/wireless/wext-core.c @@ -342,6 +342,40 @@ static const int compat_event_type_size[] =3D { =20 /* IW event code */ =20 +void wireless_nlevent_flush(void) +{ + struct sk_buff *skb; + struct net *net; + + ASSERT_RTNL(); + + for_each_net(net) { + while ((skb =3D skb_dequeue(&net->wext_nlevents))) + rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, + GFP_KERNEL); + } +} +EXPORT_SYMBOL_GPL(wireless_nlevent_flush); + +static int wext_netdev_notifier_call(struct notifier_block *nb, + unsigned long state, void *ptr) +{ + /* + * When a netdev changes state in any way, flush all pending messages + * to avoid them going out in a strange order, e.g. RTM_NEWLINK after + * RTM_DELLINK, or with IFF_UP after without IFF_UP during dev_close() + * or similar - all of which could otherwise happen due to delays from + * schedule_work(). + */ + wireless_nlevent_flush(); + + return NOTIFY_OK; +} + +static struct notifier_block wext_netdev_notifier =3D { + .notifier_call =3D wext_netdev_notifier_call, +}; + static int __net_init wext_pernet_init(struct net *net) { skb_queue_head_init(&net->wext_nlevents); @@ -360,7 +394,12 @@ static struct pernet_operations wext_pernet_ops =3D { =20 static int __init wireless_nlevent_init(void) { - return register_pernet_subsys(&wext_pernet_ops); + int err =3D register_pernet_subsys(&wext_pernet_ops); + + if (err) + return err; + + return register_netdevice_notifier(&wext_netdev_notifier); } =20 subsys_initcall(wireless_nlevent_init); @@ -368,17 +407,8 @@ subsys_initcall(wireless_nlevent_init); /* Process events generated by the wireless layer or the driver. */ static void wireless_nlevent_process(struct work_struct *work) { - struct sk_buff *skb; - struct net *net; - rtnl_lock(); - - for_each_net(net) { - while ((skb =3D skb_dequeue(&net->wext_nlevents))) - rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, - GFP_KERNEL); - } - + wireless_nlevent_flush(); rtnl_unlock(); } =20 diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c index 8d4d5e853efe..ab774954c985 100644 --- a/sound/core/seq/oss/seq_oss.c +++ b/sound/core/seq/oss/seq_oss.c @@ -150,8 +150,6 @@ odev_release(struct inode *inode, struct file *file) if ((dp =3D file->private_data) =3D=3D NULL) return 0; =20 - snd_seq_oss_drain_write(dp); - mutex_lock(®ister_mutex); snd_seq_oss_release(dp); mutex_unlock(®ister_mutex); diff --git a/sound/core/seq/oss/seq_oss_device.h b/sound/core/seq/oss/seq_o= ss_device.h index c0154a959d55..2464112b08ad 100644 --- a/sound/core/seq/oss/seq_oss_device.h +++ b/sound/core/seq/oss/seq_oss_device.h @@ -131,7 +131,6 @@ int snd_seq_oss_write(struct seq_oss_devinfo *dp, const= char __user *buf, int co unsigned int snd_seq_oss_poll(struct seq_oss_devinfo *dp, struct file *fil= e, poll_table * wait); =20 void snd_seq_oss_reset(struct seq_oss_devinfo *dp); -void snd_seq_oss_drain_write(struct seq_oss_devinfo *dp); =20 /* */ void snd_seq_oss_process_queue(struct seq_oss_devinfo *dp, abstime_t time)= ; diff --git a/sound/core/seq/oss/seq_oss_init.c b/sound/core/seq/oss/seq_oss= _init.c index 966d0dc5385b..ed1b02c36f4f 100644 --- a/sound/core/seq/oss/seq_oss_init.c +++ b/sound/core/seq/oss/seq_oss_init.c @@ -447,23 +447,6 @@ snd_seq_oss_release(struct seq_oss_devinfo *dp) =20 =20 /* - * Wait until the queue is empty (if we don't have nonblock) - */ -void -snd_seq_oss_drain_write(struct seq_oss_devinfo *dp) -{ - if (! dp->timer->running) - return; - if (is_write_mode(dp->file_mode) && !is_nonblock_mode(dp->file_mode) && - dp->writeq) { - debug_printk(("syncing..\n")); - while (snd_seq_oss_writeq_sync(dp->writeq)) - ; - } -} - - -/* * reset sequencer devices */ void diff --git a/sound/core/seq/seq_memory.c b/sound/core/seq/seq_memory.c index f478f770bf52..e0e683cd3926 100644 --- a/sound/core/seq/seq_memory.c +++ b/sound/core/seq/seq_memory.c @@ -383,17 +383,22 @@ int snd_seq_pool_init(struct snd_seq_pool *pool) =20 if (snd_BUG_ON(!pool)) return -EINVAL; - if (pool->ptr) /* should be atomic? */ - return 0; =20 - pool->ptr =3D vmalloc(sizeof(struct snd_seq_event_cell) * pool->size); - if (pool->ptr =3D=3D NULL) { + cellptr =3D vmalloc(sizeof(struct snd_seq_event_cell) * pool->size); + if (!cellptr) { snd_printd("seq: malloc for sequencer events failed\n"); return -ENOMEM; } =20 /* add new cells to the free cell list */ spin_lock_irqsave(&pool->lock, flags); + if (pool->ptr) { + spin_unlock_irqrestore(&pool->lock, flags); + vfree(cellptr); + return 0; + } + + pool->ptr =3D cellptr; pool->free =3D NULL; =20 for (cell =3D 0; cell < pool->size; cell++) { diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c index 67c91d226552..ee0522a8f730 100644 --- a/sound/core/seq/seq_ports.c +++ b/sound/core/seq/seq_ports.c @@ -540,19 +540,22 @@ static void delete_and_unsubscribe_port(struct snd_se= q_client *client, bool is_src, bool ack) { struct snd_seq_port_subs_info *grp; + struct list_head *list; + bool empty; =20 grp =3D is_src ? &port->c_src : &port->c_dest; + list =3D is_src ? &subs->src_list : &subs->dest_list; down_write(&grp->list_mutex); write_lock_irq(&grp->list_lock); - if (is_src) - list_del(&subs->src_list); - else - list_del(&subs->dest_list); + empty =3D list_empty(list); + if (!empty) + list_del_init(list); grp->exclusive =3D 0; write_unlock_irq(&grp->list_lock); up_write(&grp->list_mutex); =20 - unsubscribe_port(client, port, grp, &subs->info, ack); + if (!empty) + unsubscribe_port(client, port, grp, &subs->info, ack); } =20 /* connect two ports */ diff --git a/sound/core/timer_compat.c b/sound/core/timer_compat.c index e05802ae6e1b..8e7eddf35c6a 100644 --- a/sound/core/timer_compat.c +++ b/sound/core/timer_compat.c @@ -70,13 +70,14 @@ static int snd_timer_user_status_compat(struct file *fi= le, struct snd_timer_status32 __user *_status) { struct snd_timer_user *tu; - struct snd_timer_status status; + struct snd_timer_status32 status; =09 tu =3D file->private_data; if (snd_BUG_ON(!tu->timeri)) return -ENXIO; memset(&status, 0, sizeof(status)); - status.tstamp =3D tu->tstamp; + status.tstamp.tv_sec =3D tu->tstamp.tv_sec; + status.tstamp.tv_nsec =3D tu->tstamp.tv_nsec; status.resolution =3D snd_timer_resolution(tu->timeri); status.lost =3D tu->timeri->lost; status.overrun =3D tu->overrun; diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c index f2a3758dac52..70ad12845a82 100644 --- a/sound/pci/rme9652/hdsp.c +++ b/sound/pci/rme9652/hdsp.c @@ -3163,7 +3163,7 @@ static int snd_hdsp_get_dds_offset(struct snd_kcontro= l *kcontrol, struct snd_ctl { struct hdsp *hdsp =3D snd_kcontrol_chip(kcontrol); =20 - ucontrol->value.enumerated.item[0] =3D hdsp_dds_offset(hdsp); + ucontrol->value.integer.value[0] =3D hdsp_dds_offset(hdsp); return 0; } =20 @@ -3175,7 +3175,7 @@ static int snd_hdsp_put_dds_offset(struct snd_kcontro= l *kcontrol, struct snd_ctl =20 if (!snd_hdsp_use_is_exclusive(hdsp)) return -EBUSY; - val =3D ucontrol->value.enumerated.item[0]; + val =3D ucontrol->value.integer.value[0]; spin_lock_irq(&hdsp->lock); if (val !=3D hdsp_dds_offset(hdsp)) change =3D (hdsp_set_dds_offset(hdsp, val) =3D=3D 0) ? 1 : 0; diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c index 71a3d52741bb..45192ced80ab 100644 --- a/sound/pci/rme9652/hdspm.c +++ b/sound/pci/rme9652/hdspm.c @@ -4386,7 +4386,7 @@ static int snd_hdspm_get_tco_word_term(struct snd_kco= ntrol *kcontrol, { struct hdspm *hdspm =3D snd_kcontrol_chip(kcontrol); =20 - ucontrol->value.enumerated.item[0] =3D hdspm->tco->term; + ucontrol->value.integer.value[0] =3D hdspm->tco->term; =20 return 0; } @@ -4397,8 +4397,8 @@ static int snd_hdspm_put_tco_word_term(struct snd_kco= ntrol *kcontrol, { struct hdspm *hdspm =3D snd_kcontrol_chip(kcontrol); =20 - if (hdspm->tco->term !=3D ucontrol->value.enumerated.item[0]) { - hdspm->tco->term =3D ucontrol->value.enumerated.item[0]; + if (hdspm->tco->term !=3D ucontrol->value.integer.value[0]) { + hdspm->tco->term =3D ucontrol->value.integer.value[0]; =20 hdspm_tco_write(hdspm); =20 diff --git a/sound/soc/codecs/wm8958-dsp2.c b/sound/soc/codecs/wm8958-dsp2.= c index 5a14d5c0e0e1..bb1982075200 100644 --- a/sound/soc/codecs/wm8958-dsp2.c +++ b/sound/soc/codecs/wm8958-dsp2.c @@ -458,7 +458,7 @@ static int wm8958_put_mbc_enum(struct snd_kcontrol *kco= ntrol, struct snd_soc_codec *codec =3D snd_kcontrol_chip(kcontrol); struct wm8994_priv *wm8994 =3D snd_soc_codec_get_drvdata(codec); struct wm8994_pdata *pdata =3D wm8994->pdata; - int value =3D ucontrol->value.integer.value[0]; + int value =3D ucontrol->value.enumerated.item[0]; int reg; =20 /* Don't allow on the fly reconfiguration */ @@ -548,7 +548,7 @@ static int wm8958_put_vss_enum(struct snd_kcontrol *kco= ntrol, struct snd_soc_codec *codec =3D snd_kcontrol_chip(kcontrol); struct wm8994_priv *wm8994 =3D snd_soc_codec_get_drvdata(codec); struct wm8994_pdata *pdata =3D wm8994->pdata; - int value =3D ucontrol->value.integer.value[0]; + int value =3D ucontrol->value.enumerated.item[0]; int reg; =20 /* Don't allow on the fly reconfiguration */ @@ -581,7 +581,7 @@ static int wm8958_put_vss_hpf_enum(struct snd_kcontrol = *kcontrol, struct snd_soc_codec *codec =3D snd_kcontrol_chip(kcontrol); struct wm8994_priv *wm8994 =3D snd_soc_codec_get_drvdata(codec); struct wm8994_pdata *pdata =3D wm8994->pdata; - int value =3D ucontrol->value.integer.value[0]; + int value =3D ucontrol->value.enumerated.item[0]; int reg; =20 /* Don't allow on the fly reconfiguration */ @@ -748,7 +748,7 @@ static int wm8958_put_enh_eq_enum(struct snd_kcontrol *= kcontrol, struct snd_soc_codec *codec =3D snd_kcontrol_chip(kcontrol); struct wm8994_priv *wm8994 =3D snd_soc_codec_get_drvdata(codec); struct wm8994_pdata *pdata =3D wm8994->pdata; - int value =3D ucontrol->value.integer.value[0]; + int value =3D ucontrol->value.enumerated.item[0]; int reg; =20 /* Don't allow on the fly reconfiguration */ diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c index 9a5679807454..a0088c97912e 100644 --- a/sound/soc/codecs/wm8994.c +++ b/sound/soc/codecs/wm8994.c @@ -386,7 +386,7 @@ static int wm8994_put_drc_enum(struct snd_kcontrol *kco= ntrol, struct wm8994_priv *wm8994 =3D snd_soc_codec_get_drvdata(codec); struct wm8994_pdata *pdata =3D wm8994->pdata; int drc =3D wm8994_get_drc(kcontrol->id.name); - int value =3D ucontrol->value.integer.value[0]; + int value =3D ucontrol->value.enumerated.item[0]; =20 if (drc < 0) return drc; @@ -489,7 +489,7 @@ static int wm8994_put_retune_mobile_enum(struct snd_kco= ntrol *kcontrol, struct wm8994_priv *wm8994 =3D snd_soc_codec_get_drvdata(codec); struct wm8994_pdata *pdata =3D wm8994->pdata; int block =3D wm8994_get_retune_mobile_block(kcontrol->id.name); - int value =3D ucontrol->value.integer.value[0]; + int value =3D ucontrol->value.enumerated.item[0]; =20 if (block < 0) return block; diff --git a/virt/kvm/async_pf.c b/virt/kvm/async_pf.c index bdd2c0d690d6..541f03082b96 100644 --- a/virt/kvm/async_pf.c +++ b/virt/kvm/async_pf.c @@ -159,7 +159,7 @@ int kvm_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva= , gfn_t gfn, * do alloc nowait since if we are going to sleep anyway we * may as well sleep faulting in page */ - work =3D kmem_cache_zalloc(async_pf_cache, GFP_NOWAIT); + work =3D kmem_cache_zalloc(async_pf_cache, GFP_NOWAIT | __GFP_NOWARN); if (!work) return 0; =20 =0D --=-b3ALMroV8hGLP01sOjLw-- --=-O/83a+7HBPd55CEASXEG Content-Type: application/pgp-signature; name="signature.asc" Content-Description: This is a digitally signed message part -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 iQIcBAABCgAGBQJW/mVjAAoJEOe/yOyVhhEJhz4P/je19PiOLAUpxgAuspxIE3+2 uCWaiwUu1PVhZmLHuIT6G88Wp0QceqrWL3uhY2akD/KOWDUaZkfbTOQh0+J6GZiS bqMGFxzGhIuij7cIbHKvhb9oXQP2YqA4+nadpv4ijp8EDh4pUANq4dEHBV4+MITL Owq5y+iGdb3/oKFcRRIHFnm/joBy1ZmQ7NHh4eAiR9hWKFQSQOCKA0aRX92/yOWz 4II2Clj9lAmTJSv24xCn0FgPzm7ZqLOUydbwqXwdI6/5LSBwYXrSH5vuc/lCNtjY 8eq5dKduPNEnZY+iTzbcjfHF7dQS1thZiL1HdYdlvg+6q/rWY5hsRs0WzXuY38el OJ8pZFx7Rk7IzhFkgGPv4ezoI6kZYrQ/HmLmSMk2GFbc7jimByS6R1OlCAd8rEcn 7RxHGSlCVkIaf2+tT0TnG+vWLXnXCnfIzzXOb6j0z8pgXPRO7wGsM6R8zwQtWRPN VUgTKvZaiOK4QbkpzqDB3Q4KCRq/1buTfwgnCGuTjocSyafgH7O9gVWmWAjiIgek Rpep/LX515aex5773tZAmCPFN6oTNIVplPimKPjsj4VtWd6mdSCOJEjbkUehxxo0 +9g3EhYGxhda2z6N4wI8FA2GzKeXk9oWXHX0W2oD5RgOml2lUWcO2cOMNtd6/pAP ZxupcmoLdzNtsfN1NsoA =xNdY -----END PGP SIGNATURE----- --=-O/83a+7HBPd55CEASXEG--