From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754864AbcHWTTN (ORCPT ); Tue, 23 Aug 2016 15:19:13 -0400 Received: from shadbolt.e.decadent.org.uk ([88.96.1.126]:39180 "EHLO shadbolt.e.decadent.org.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753370AbcHWTTH (ORCPT ); Tue, 23 Aug 2016 15:19:07 -0400 Message-ID: <1471979939.13300.168.camel@decadent.org.uk> Subject: Linux 3.2.82 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: Tue, 23 Aug 2016 20:18:59 +0100 Content-Type: multipart/signed; micalg="pgp-sha512"; protocol="application/pgp-signature"; boundary="=-DMVPRH0a4rpUsmcBiTiG" X-Mailer: Evolution 3.20.4-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 --=-DMVPRH0a4rpUsmcBiTiG Content-Type: multipart/mixed; boundary="=-+u+uwxhMrV3mqPCcE1z/" --=-+u+uwxhMrV3mqPCcE1z/ Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: base64 SSdtIGFubm91bmNpbmcgdGhlIHJlbGVhc2Ugb2YgdGhlIDMuMi44MiBrZXJuZWwuCgpBbGwgdXNl cnMgb2YgdGhlIDMuMiBrZXJuZWwgc2VyaWVzIHNob3VsZCB1cGdyYWRlLgoKVGhlIHVwZGF0ZWQg My4yLnkgZ2l0IHRyZWUgY2FuIGJlIGZvdW5kIGF0OgrCoMKgwqDCoMKgwqDCoMKgaHR0cHM6Ly9n aXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvc3RhYmxlL2xpbnV4LXN0YWJs ZS5naXQgbGludXgtMy4yLnkKYW5kIGNhbiBiZSBicm93c2VkIGF0IHRoZSBub3JtYWwga2VybmVs Lm9yZyBnaXQgd2ViIGJyb3dzZXI6CsKgwqDCoMKgwqDCoMKgwqBodHRwczovL2dpdC5rZXJuZWwu b3JnLz9wPWxpbnV4L2tlcm5lbC9naXQvc3RhYmxlL2xpbnV4LXN0YWJsZS5naXQKClRoZSBkaWZm IGZyb20gMy4yLjgxIGlzIGF0dGFjaGVkIHRvIHRoaXMgbWVzc2FnZS4KCkJlbi4KCi0tLS0tLS0t LS0tLQoKwqBNYWtlZmlsZcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNCArLQrCoGFyY2gvYWxwaGEva2Vy bmVsL3BjaS1zeXNmcy5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA0ICstCsKg YXJjaC9hcm0va2VybmVsL3B0cmFjZS5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqB8wqDCoMKgMiArLQrCoGFyY2gvbWlwcy9pbmNsdWRlL2FzbS9wZ3RhYmxlLmjCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqB8wqDCoDQ1ICsrLS0KwqBhcmNoL3BhcmlzYy9rZXJuZWwvdW5hbGln bmVkLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgMTAgKy0KwqBhcmNoL3Bvd2VycGMv bW0vaGFzaF91dGlsc182NC5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqAyOSArKy0KwqBh cmNoL3g4Ni9ib290L01ha2VmaWxlwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgfMKgwqDCoDMgKwrCoGFyY2gveDg2L2tlcm5lbC9hbWRfbmIuY8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDQgKy0KwqBhcmNoL3g4Ni9rZXJuZWwva3By b2Jlcy5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqAxMiArKwrCoGFy Y2gveDg2L2t2bS94ODYuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgfMKgwqDCoDUgKwrCoGFyY2gveDg2L3BjaS9maXh1cC5jwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA3ICsKwqBkcml2ZXJzL2FjcGkv c3lzZnMuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDC oMKgNyArLQrCoGRyaXZlcnMvYXRhL3NhdGFfZHdjXzQ2MGV4LmPCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqB8wqDCoMKgNCArLQrCoGRyaXZlcnMvYmFzZS9pc2EuY8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDIgKy0KwqBkcml2ZXJz L2Jhc2UvbW9kdWxlLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oHzCoMKgwqA4ICstCsKgZHJpdmVycy9iYXNlL3JlZ21hcC9yZWdjYWNoZS5jwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqB8wqDCoMKgMiArLQrCoGRyaXZlcnMvY2hhci9LY29uZmlnwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAxIC0KwqBkcml2ZXJz L2NoYXIvaThrLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoHzCoMKgMTggKy0KwqBkcml2ZXJzL2NyeXB0by9zNXAtc3NzLmPCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgNjEgKysrKy0tCsKgZHJpdmVycy9ncHUvZHJtL3Jh ZGVvbi9yYWRlb25fZGV2aWNlLmPCoMKgwqDCoMKgfMKgwqAyMSArKwrCoGRyaXZlcnMvaGlkL3Vz YmhpZC9oaWRkZXYuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqAxMCArLQrC oGRyaXZlcnMvaW5maW5pYmFuZC9ody9jeGdiMy9jeGlvX2hhbC5jwqDCoMKgwqDCoHzCoMKgwqAy ICstCsKgZHJpdmVycy9pbmZpbmliYW5kL2h3L21seDQvYWguY8KgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoHzCoMKgwqAyICstCsKgZHJpdmVycy9pbmZpbmliYW5kL2h3L21seDQvcXAuY8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAyICstCsKgZHJpdmVycy9pbnB1dC9qb3lzdGljay94cGFk LmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDQgKwrCoGRyaXZlcnMvaW5wdXQv bWlzYy9wd20tYmVlcGVyLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoDcwICsrKystLQrC oGRyaXZlcnMvaW5wdXQvbWlzYy91aW5wdXQuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgfMKgwqDCoDYgKwrCoGRyaXZlcnMvaW5wdXQvbW91c2UvZWxhbnRlY2guY8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgfMKgwqDCoDggKy0KwqBkcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL3dh Y29tX3c4MDAxLmPCoMKgwqDCoHzCoMKgwqAyICstCsKgZHJpdmVycy9tbWMvY29yZS9tbWMuY8Kg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA3ICsKwqBkcml2 ZXJzL210ZC91YmkvZWJhLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoHzCoMKgMTkgKy0KwqBkcml2ZXJzL25ldC9ib25kaW5nL2JvbmRfM2FkLmPCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoHzCoMKgMTMgKy0KwqBkcml2ZXJzL25ldC9ib25kaW5nL2JvbmRfYWxi LmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA3ICstCsKgZHJpdmVycy9uZXQvYm9u ZGluZy9ib25kaW5nLmjCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDMgKwrCoGRy aXZlcnMvbmV0L2Nhbi9hdDkxX2Nhbi5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oHzCoMKgwqA1ICstCsKgZHJpdmVycy9uZXQvY2FuL2Rldi5jwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNiArCsKgZHJpdmVycy9uZXQvZXRoZXJuZXQv aWJtL2VoZWEvZWhlYV9tYWluLmPCoMKgfMKgwqDCoDkgKy0KwqBkcml2ZXJzL25ldC9ldGhlcm5l dC9tZWxsYW5veC9tbHg0L21jZy5jwqDCoMKgfMKgwqDCoDQgKy0KwqBkcml2ZXJzL25ldC93aXJl bGVzcy9hdGgvYXRoNWsvbGVkLmPCoMKgwqDCoMKgwqDCoHzCoMKgwqAyICstCsKgZHJpdmVycy9u ZXQvd2lyZWxlc3MvbWFjODAyMTFfaHdzaW0uY8KgwqDCoMKgwqDCoHzCoMKgwqAxICsKwqBkcml2 ZXJzL3BjaS9wY2ktc3lzZnMuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqB8wqDCoMKgNyArLQrCoGRyaXZlcnMvcGNpL3Byb2JlLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNiArLQrCoGRyaXZlcnMvczM5MC9uZXQv cWV0aF9sMl9tYWluLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMSArCsKgZHJpdmVy cy9zMzkwL25ldC9xZXRoX2wzX21haW4uY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAx ICsKwqBkcml2ZXJzL3Njc2kvYWFjcmFpZC9jb21tc3VwLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoHzCoMKgwqA0ICsKwqBkcml2ZXJzL3N0YWdpbmcvaWlvL2FjY2VsL2t4c2Q5LmPCoMKgwqDC oMKgwqDCoMKgwqDCoHzCoMKgwqA0ICstCsKgZHJpdmVycy9zdGFnaW5nL2lpby9hY2NlbC9zY2Ez MDAwX2NvcmUuY8KgwqDCoHzCoMKgwqAyICstCsKgZHJpdmVycy9zdGFnaW5nL2lpby9pbmR1c3Ry aWFsaW8tdHJpZ2dlci5jIHzCoMKgMjUgKystCsKgZHJpdmVycy90dHkvdnQvdnQuY8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA1ICstCsKgZHJp dmVycy91c2IvY29yZS9kZXZpby5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqB8wqDCoMKgOSArLQrCoGRyaXZlcnMvdXNiL2dhZGdldC9mX2ZzLmPCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNiArLQrCoGRyaXZlcnMvdXNiL211c2IvbXVzYl9o b3N0LmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoDIxICstCsKgZHJpdmVycy91 c2Ivc2VyaWFsL29wdGlvbi5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8IDEyOSAr KysrKysrKysrLQrCoGRyaXZlcnMveGVuL2V2ZW50cy5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA2ICstCsKgZHJpdmVycy94ZW4veGVuLXBjaWJh Y2svY29uZl9zcGFjZS5jwqDCoMKgwqDCoMKgwqB8wqDCoMKgNiArLQrCoGZzL2J0cmZzL2N0cmVl LmjCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8 wqDCoMKgMSArCsKgZnMvYnRyZnMvZmlsZS5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMiArLQrCoGZzL2J0cmZzL2lub2RlLmPC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDC oMKgMiArLQrCoGZzL2J0cmZzL2lvY3RsLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoDIxICsrCsKgZnMvY2lmcy9zZXNzLmPCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfCAyMDcg KysrKysrKysrKy0tLS0tLS0tCsKgZnMvZGNhY2hlLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDUgKy0KwqBmcy9l Y3J5cHRmcy9maWxlLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoHzCoMKgMTUgKy0KwqBmcy9lY3J5cHRmcy9tYWluLmPCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA3ICsKwqBmcy9leHQ0L2lhbGxv Yy5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg fMKgwqAxMCArLQrCoGZzL25mcy9uZnM0cHJvYy5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA1ICstCsKgZnMvbmlsZnMyL3RoZV9uaWxm cy5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMiAr LQrCoGZzL3Byb2Mvcm9vdC5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA3ICsKwqBmcy91Ymlmcy9maWxlLmPCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgMjQgKysr CsKgaW5jbHVkZS9saW51eC9ldGhlcmRldmljZS5owqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqB8wqDCoDExICsKwqBpbmNsdWRlL2xpbnV4L2ZzLmjCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgMTEgKwrCoGluY2x1ZGUvbGludXgvbWln cmF0ZS5owqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAzICsK wqBpbmNsdWRlL2xpbnV4L3N1bnJwYy9tc2dfcHJvdC5owqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg fMKgwqDCoDQgKy0KwqBrZXJuZWwvYXVkaXRzYy5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfCAzMzMgKysrKysrKysrKysrKystLS0tLS0tLS0t LS0tLS0KwqBrZXJuZWwvZXhpdC5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqAyOSArKy0KwqBrZXJuZWwvc2NoZWQuY8KgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDC oDE3ICstCsKgbW0vbWlncmF0ZS5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgNCArLQrCoG5ldC9iYXRtYW4tYWR2L3Ry YW5zbGF0aW9uLXRhYmxlLmPCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoDQyICsrKy0KwqBuZXQvYmF0 bWFuLWFkdi90eXBlcy5owqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg fMKgwqDCoDEgKwrCoG5ldC9pcHY0L3RjcF9pbnB1dC5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgMTcgKy0KwqBuZXQvcmRzL3JlY3YuY8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKg MiArCsKgbmV0L3RpcGMvbm9kZS5jwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMyArLQrCoHNlY3VyaXR5L2tleXMva2V5LmPCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqB8wqDCoMKgMiArLQrC oHNvdW5kL2NvcmUvdGltZXIuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgfMKgwqDCoDUgKy0KwqBzb3VuZC9kcml2ZXJzL2R1bW15LmPCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqAxICsKwqBzb3VuZC9wY2kv YXU4OHgwL2F1ODh4MF9jb3JlLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHzCoMKgwqA1ICst CsKgc291bmQvcGNpL2VjaG9hdWRpby9lY2hvYXVkaW8uY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oHzCoMKgwqA0ICstCsKgdmlydC9rdm0vYXNzaWduZWQtZGV2LmPCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgfMKgwqDCoDIgKy0KwqA4NyBmaWxlcyBjaGFuZ2VkLCA5OTkg aW5zZXJ0aW9ucygrKSwgNDY4IGRlbGV0aW9ucygtKQoKQWRyaWFuIEh1bnRlciAoMSk6CsKgwqDC oMKgwqDCoG1tYzogbW1jOiBGaXggcGFydGl0aW9uIHN3aXRjaCB0aW1lb3V0IGZvciBzb21lIGVN TUNzCgpBbCBWaXJvICgxKToKwqDCoMKgwqDCoMKgZml4IGRfd2FsaygpL25vbi1kZWxheWVkIF9f ZF9mcmVlKCkgcmFjZQoKQWxleCBEZXVjaGVyICgxKToKwqDCoMKgwqDCoMKgZHJtL3JhZGVvbjog Zml4IGFzaWMgaW5pdGlhbGl6YXRpb24gZm9yIHZpcnR1YWxpemVkIGVudmlyb25tZW50cwoKQW5k cmV3IEYuIERhdmlzICgxKToKwqDCoMKgwqDCoMKgcmVnbWFwOiBjYWNoZTogRml4IHR5cG8gaW4g Y2FjaGVfYnlwYXNzIHBhcmFtZXRlciBkZXNjcmlwdGlvbgoKQW5kcmV3IEdvb2Rib2R5ICgyKToK wqDCoMKgwqDCoMKgdXNiOiBtdXNiOiBFbnN1cmUgcnggcmVpbml0IG9jY3VycyBmb3Igc2hhcmVk X2ZpZm8gZW5kcG9pbnRzCsKgwqDCoMKgwqDCoHVzYjogbXVzYjogU3RvcCBidWxrIGVuZHBvaW50 IHdoaWxlIHF1ZXVlIGlzIHJvdGF0ZWQKCkFuZHJleSBHcm9kem92c2t5ICgxKToKwqDCoMKgwqDC oMKgeGVuL3BjaWJhY2s6IEZpeCBjb25mX3NwYWNlIHJlYWQvd3JpdGUgb3ZlcmxhcCBjaGVjay4K CkFuZHJleSBSeWFiaW5pbiAoMSk6CsKgwqDCoMKgwqDCoGtlcm5lbC9zeXNycSwgd2F0Y2hkb2cs IHNjaGVkL2NvcmU6IFJlc2V0IHdhdGNoZG9nIG9uIGFsbCBDUFVzIHdoaWxlIHByb2Nlc3Npbmcg c3lzcnEtdwoKQXJuZCBCZXJnbWFubiAoMSk6CsKgwqDCoMKgwqDCoGdjb3Y6IGRpc2FibGUgdHJl ZS1sb29wLWltIHRvIHJlZHVjZSBzdGFjayB1c2FnZQoKQmVuIEh1dGNoaW5ncyAoMSk6CsKgwqDC oMKgwqDCoExpbnV4IDMuMi44MgoKQmpvcm4gSGVsZ2FhcyAoMik6CsKgwqDCoMKgwqDCoFBDSTog U3VwcGx5IENQVSBwaHlzaWNhbCBhZGRyZXNzIChub3QgYnVzIGFkZHJlc3MpIHRvIGlvbWVtX2lz X2V4Y2x1c2l2ZSgpCsKgwqDCoMKgwqDCoGFscGhhL1BDSTogQ2FsbCBpb21lbV9pc19leGNsdXNp dmUoKSBmb3IgSU9SRVNPVVJDRV9NRU0sIGJ1dCBub3QgSU9SRVNPVVJDRV9JTwoKQm9yaXNsYXYg UGV0a292ICgxKToKwqDCoMKgwqDCoMKgeDg2L2FtZF9uYjogRml4IGJvb3QgY3Jhc2ggb24gbm9u LUFNRCBzeXN0ZW1zCgpDYW1lcm9uIEd1dG1hbiAoMSk6CsKgwqDCoMKgwqDCoElucHV0OiB4cGFk IC0gcHJldmVudCBzcHVyaW91cyBpbnB1dCBmcm9tIHdpcmVkIFhib3ggMzYwIGNvbnRyb2xsZXJz CgpDaHJpc3RvcGhlIEpBSUxMRVQgKDEpOgrCoMKgwqDCoMKgwqBBTFNBOiBlY2hvYXVkaW86IEZp eCBtZW1vcnkgYWxsb2NhdGlvbgoKQ2h1Y2sgTGV2ZXIgKDEpOgrCoMKgwqDCoMKgwqBzdW5ycGM6 IFVwZGF0ZSBSUENCSU5EX01BWE5FVElETEVOCgpDcmVzdGV6IERhbiBMZW9uYXJkICgxKToKwqDC oMKgwqDCoMKgaWlvOiBGaXggZXJyb3IgaGFuZGxpbmcgaW4gaWlvX3RyaWdnZXJfYXR0YWNoX3Bv bGxfZnVuYwoKRGFuIENhcnBlbnRlciAoMyk6CsKgwqDCoMKgwqDCoEFDUEkgLyBzeXNmczogZml4 IGVycm9yIGNvZGUgaW4gZ2V0X3N0YXR1cygpCsKgwqDCoMKgwqDCoHVzYjogZl9mczogb2ZmIGJ5 IG9uZSBidWcgaW4gX2Zmc19mdW5jX2JpbmQoKQrCoMKgwqDCoMKgwqBLRVlTOiBwb3RlbnRpYWwg dW5pbml0aWFsaXplZCB2YXJpYWJsZQoKRG1pdHJ5IFRvcm9raG92ICgxKToKwqDCoMKgwqDCoMKg SW5wdXQ6IGVsYW50ZWNoIC0gYWRkIG1vcmUgSUMgYm9keSB0eXBlcyB0byB0aGUgbGlzdAoKRHVh biBKaW9uZyAoMSk6CsKgwqDCoMKgwqDCoGV0aGVyZGV2aWNlOiBpbnRyb2R1Y2UgaGVscCBmdW5j dGlvbiBldGhfemVyb19hZGRyKCkKCkVyaWMgRHVtYXpldCAoMik6CsKgwqDCoMKgwqDCoGJvbmRp bmc6IHByZXZlbnQgb3V0IG9mIGJvdW5kIGFjY2Vzc2VzCsKgwqDCoMKgwqDCoHRjcDogbWFrZSBj aGFsbGVuZ2UgYWNrcyBsZXNzIHByZWRpY3RhYmxlCgpHZWVydCBVeXR0ZXJob2V2ZW4gKDEpOgrC oMKgwqDCoMKgwqBjaGFyOiBEcm9wIGJvZ3VzIGRlcGVuZGVuY3kgb2YgREVWUE9SVCBvbiAhTTY4 SwoKSC4gUGV0ZXIgQW52aW4gKDEpOgrCoMKgwqDCoMKgwqB4ODYsIGJ1aWxkOiBjb3B5IGxkbGlu dXguYzMyIHRvIGltYWdlLmlzbwoKSGVsZ2UgRGVsbGVyICgxKToKwqDCoMKgwqDCoMKgcGFyaXNj OiBGaXggcGFnZWZhdWx0IGNyYXNoIGluIHVuYWxpZ25lZCBfX2dldF91c2VyKCkgY2FsbAoKSG9u Z2dhbmcgTGkgKDEpOgrCoMKgwqDCoMKgwqBSRE1BL2N4Z2IzOiBkZXZpY2UgZHJpdmVyIGZyZWVz IERNQSBtZW1vcnkgd2l0aCBkaWZmZXJlbnQgc2l6ZQoKSmFubiBIb3JuICgxKToKwqDCoMKgwqDC oMKgcHJvYzogcHJldmVudCBzdGFja2luZyBmaWxlc3lzdGVtcyBvbiB0b3AKCkphc29uIEd1bnRo b3JwZSAoMSk6CsKgwqDCoMKgwqDCoElCL21seDQ6IFByb3Blcmx5IGluaXRpYWxpemUgR1JIIFRD bGFzcyBhbmQgRmxvd0xhYmVsIGluIEFIcwoKSmVmZiBNYWhvbmV5ICgxKToKwqDCoMKgwqDCoMKg ZWNyeXB0ZnM6IGRvbid0IGFsbG93IG1tYXAgd2hlbiB0aGUgbG93ZXIgZnMgZG9lc24ndCBzdXBw b3J0IGl0CgpKZXJvbWUgTWFyY2hhbmQgKDEpOgrCoMKgwqDCoMKgwqBjaWZzOiBkeW5hbWljIGFs bG9jYXRpb24gb2YgbnRsbXNzcCBibG9iCgpKaXJpIFNsYWJ5ICgyKToKwqDCoMKgwqDCoMKgdHR5 OiB2dCwgcmV0dXJuIGVycm9yIHdoZW4gY29uX3N0YXJ0dXAgZmFpbHMKwqDCoMKgwqDCoMKgYmFz ZTogbWFrZSBtb2R1bGVfY3JlYXRlX2RyaXZlcnNfZGlyIHJhY2UtZnJlZQoKSm9uYXRoYW4gQ2Ft ZXJvbiAoMSk6CsKgwqDCoMKgwqDCoHN0YWdpbmc6aWlvOiB0cmlnZ2VyIGZpeGVzIGZvciByZXBl YXQgcmVxdWVzdCBvZiBzYW1lIHRyaWdnZXIgYW5kIGFsbG9jYXRpb24gZmFpbHVyZQoKSm9zZXBo IFNhbGlzYnVyeSAoMSk6CsKgwqDCoMKgwqDCoGF0aDVrOiBDaGFuZ2UgbGVkIHBpbiBjb25maWd1 cmF0aW9uIGZvciBjb21wYXEgYzcwMCBsYXB0b3AKCkpvc2h1YSBLaW5hcmQgKDEpOgrCoMKgwqDC oMKgwqBNSVBTOiBBZGp1c3Qgc2V0X3B0ZSgpIFNNUCBmaXggdG8gaGFuZGxlIFIxMDAwMF9MTFND X1dBUgoKS2FuZ2ppZSBMdSAoNik6CsKgwqDCoMKgwqDCoFVTQjogdXNiZnM6IGZpeCBwb3RlbnRp YWwgaW5mb2xlYWsgaW4gZGV2aW8KwqDCoMKgwqDCoMKgQUxTQTogdGltZXI6IEZpeCBsZWFrIGlu IFNORFJWX1RJTUVSX0lPQ1RMX1BBUkFNUwrCoMKgwqDCoMKgwqBBTFNBOiB0aW1lcjogRml4IGxl YWsgaW4gZXZlbnRzIHZpYSBzbmRfdGltZXJfdXNlcl9jY2FsbGJhY2sKwqDCoMKgwqDCoMKgQUxT QTogdGltZXI6IEZpeCBsZWFrIGluIGV2ZW50cyB2aWEgc25kX3RpbWVyX3VzZXJfdGludGVycnVw dArCoMKgwqDCoMKgwqB0aXBjOiBmaXggYW4gaW5mb2xlYWsgaW4gdGlwY19ubF9jb21wYXRfbGlu a19kdW1wCsKgwqDCoMKgwqDCoHJkczogZml4IGFuIGluZm9sZWFrIGluIHJkc19pbmNfaW5mb19j b3B5CgpLaXJpbGwgQS4gU2h1dGVtb3YgKDEpOgrCoMKgwqDCoMKgwqBVQklGUzogSW1wbGVtZW50 IC0+bWlncmF0ZXBhZ2UoKQoKS3J6eXN6dG9mIEtvemxvd3NraSAoMSk6CsKgwqDCoMKgwqDCoGNy eXB0bzogczVwLXNzcyAtIEZpeCBtaXNzZWQgaW50ZXJydXB0cyB3aGVuIHdvcmtpbmcgd2l0aCA4 IGtCIGJsb2NrcwoKTGVpIExpdSAoMSk6CsKgwqDCoMKgwqDCoFVTQjogc2VyaWFsOiBvcHRpb246 IGFkZCBldmVuIG1vcmUgWlRFIGRldmljZSBpZHMKCkxpbnVzIFdhbGxlaWogKDEpOgrCoMKgwqDC oMKgwqBpaW86IGFjY2VsOiBreHNkOTogZml4IHRoZSB1c2FnZSBvZiBzcGlfdzhyOCgpCgpMdWlz IGRlIEJldGhlbmNvdXJ0ICgxKToKwqDCoMKgwqDCoMKgc3RhZ2luZzogaWlvOiBhY2NlbDogZml4 IGVycm9yIGNoZWNrCgpMdWtlIERhc2hqciAoMSk6CsKgwqDCoMKgwqDCoGJ0cmZzOiBidWdmaXg6 IGhhbmRsZSBGU19JT0MzMl97R0VURkxBR1MsU0VURkxBR1MsR0VUVkVSU0lPTn0gaW4gYnRyZnNf aW9jdGwKCk1hbmZyZWQgU2NobGFlZ2wgKDEpOgrCoMKgwqDCoMKgwqBJbnB1dDogcHdtLWJlZXBl ciAtIGZpeCAtIHNjaGVkdWxpbmcgd2hpbGUgYXRvbWljCgpNYW5zIFJ1bGxnYXJkICgxKToKwqDC oMKgwqDCoMKgYXRhOiBzYXRhX2R3Y180NjBleDogcmVtb3ZlIGluY29ycmVjdCBsb2NraW5nCgpN YXJlayBTenlwcm93c2tpICgxKToKwqDCoMKgwqDCoMKgY3J5cHRvOiBzNXAtc3NzIC0gZml4IGlu Y29ycmVjdCB1c2FnZSBvZiBzY2F0dGVybGlzdHMgYXBpCgpNYXJ0aW4gV2lsbGkgKDEpOgrCoMKg wqDCoMKgwqBtYWM4MDIxMV9od3NpbTogQWRkIG1pc3NpbmcgY2hlY2sgZm9yIEhXU0lNX0FUVFJf U0lHTkFMCgpNYXNhbWkgSGlyYW1hdHN1ICgxKToKwqDCoMKgwqDCoMKga3Byb2Jlcy94ODY6IENs ZWFyIFRGIGJpdCBpbiBmYXVsdCBvbiBzaW5nbGUtc3RlcHBpbmcKCk1pY2hhZWwgRWxsZXJtYW4g KDIpOgrCoMKgwqDCoMKgwqBwb3dlcnBjL21tL2hhc2g2NDogRmFjdG9yIG91dCBoYXNoIHByZWxv YWQgcHNpemUgY2hlY2sKwqDCoMKgwqDCoMKgcG93ZXJwYy9tbS9oYXNoNjQ6IEZpeCBzdWJwYWdl IHByb3RlY3Rpb24gd2l0aCA0SyBIUFRFIGNvbmZpZwoKTWlrbG9zIFN6ZXJlZGkgKDEpOgrCoMKg wqDCoMKgwqBmczogbGltaXQgZmlsZXN5c3RlbSBzdGFja2luZyBkZXB0aAoKT2xlZyBOZXN0ZXJv diAoMSk6CsKgwqDCoMKgwqDCoHdhaXQvcHRyYWNlOiBhc3N1bWUgX19XQUxMIGlmIHRoZSBjaGls ZCBpcyB0cmFjZWQKCk9saXZlciBIYXJ0a29wcCAoMSk6CsKgwqDCoMKgwqDCoGNhbjogZml4IG9v cHMgY2F1c2VkIGJ5IHdyb25nIHJ0bmwgZGVsbGluayB1c2FnZQoKT2xpdmllciBTb2JyaWUgKDEp OgrCoMKgwqDCoMKgwqBJbnB1dDogcHdtLWJlZXBlciAtIHJlbW92ZSB1c2VsZXNzIGNhbGwgdG8g cHdtX2NvbmZpZygpCgpQYWxpIFJvaMOhciAoMSk6CsKgwqDCoMKgwqDCoGh3bW9uOiAoZGVsbC1z bW0pIFJlc3RyaWN0IGZhbiBjb250cm9sIGFuZCBzZXJpYWwgbnVtYmVyIHRvIENBUF9TWVNfQURN SU4gYnkgZGVmYXVsdAoKUGFvbG8gQm9uemluaSAoMSk6CsKgwqDCoMKgwqDCoEtWTTogeDg2OiBm aXggT09QUyBhZnRlciBpbnZhbGlkIEtWTV9TRVRfREVCVUdSRUdTCgpQYXVsIE1vb3JlICgxKToK wqDCoMKgwqDCoMKgYXVkaXQ6IGZpeCBhIGRvdWJsZSBmZXRjaCBpbiBhdWRpdF9sb2dfc2luZ2xl X2V4ZWN2ZV9hcmcoKQoKUGluZyBDaGVuZyAoMSk6CsKgwqDCoMKgwqDCoElucHV0OiB3YWNvbV93 ODAwMSAtIHc4MDAxX01BWF9MRU5HVEggc2hvdWxkIGJlIDEzCgpQcmFyaXQgQmhhcmdhdmEgKDIp OgrCoMKgwqDCoMKgwqB4ODYvUENJOiBNYXJrIEJyb2Fkd2VsbC1FUCBIb21lIEFnZW50IDEgYXMg aGF2aW5nIG5vbi1jb21wbGlhbnQgQkFScwrCoMKgwqDCoMKgwqBQQ0k6IERpc2FibGUgYWxsIEJB UiBzaXppbmcgZm9yIGRldmljZXMgd2l0aCBub24tY29tcGxpYW50IEJBUnMKClJhZ2hhdmEgQWRp dHlhIFJlbnVrdW50YSAoMSk6CsKgwqDCoMKgwqDCoGFhY3JhaWQ6IEZpeCBmb3IgYWFjX2NvbW1h bmRfdGhyZWFkIGhhbmcKClJpY2hhcmQgV2VpbmJlcmdlciAoMik6CsKgwqDCoMKgwqDCoHViaTog TWFrZSByZWNvdmVyX3BlYiBwb3dlciBjdXQgYXdhcmUKwqDCoMKgwqDCoMKgbW06IEV4cG9ydCBt aWdyYXRlX3BhZ2VfbW92ZV9tYXBwaW5nIGFuZCBtaWdyYXRlX3BhZ2VfY29weQoKUmlja3kgTGlh bmcgKDEpOgrCoMKgwqDCoMKgwqBJbnB1dDogdWlucHV0IC0gaGFuZGxlIGNvbXBhdCBpb2N0bCBm b3IgVUlfU0VUX1BIWVMKClJvc3MgTGFnZXJ3YWxsICgxKToKwqDCoMKgwqDCoMKgeGVuL2V2ZW50 czogRG9uJ3QgbW92ZSBkaXNhYmxlZCBpcnFzCgpSdXNzZWxsIEtpbmcgKDEpOgrCoMKgwqDCoMKg wqBBUk06IGZpeCBQVFJBQ0VfU0VUVkZQUkVHUyBvbiBTTVAgc3lzdGVtcwoKU2NvdHQgQmF1ZXIg KDEpOgrCoMKgwqDCoMKgwqBISUQ6IGhpZGRldjogdmFsaWRhdGUgbnVtX3ZhbHVlcyBmb3IgSElE SU9DR1VTQUdFUywgSElESU9DU1VTQUdFUyBjb21tYW5kcwoKU3RlZmFuIE1ldHptYWNoZXIgKDQp OgrCoMKgwqDCoMKgwqBmcy9jaWZzOiBjb3JyZWN0bHkgdG8gYW5vbnltb3VzIGF1dGhlbnRpY2F0 aW9uIHZpYSBOVExNU1NQCsKgwqDCoMKgwqDCoGZzL2NpZnM6IGNvcnJlY3RseSB0byBhbm9ueW1v dXMgYXV0aGVudGljYXRpb24gZm9yIHRoZSBMQU5NQU4gYXV0aGVudGljYXRpb24KwqDCoMKgwqDC oMKgZnMvY2lmczogY29ycmVjdGx5IHRvIGFub255bW91cyBhdXRoZW50aWNhdGlvbiBmb3IgdGhl IE5UTE0odjEpIGF1dGhlbnRpY2F0aW9uCsKgwqDCoMKgwqDCoGZzL2NpZnM6IGNvcnJlY3RseSB0 byBhbm9ueW1vdXMgYXV0aGVudGljYXRpb24gZm9yIHRoZSBOVExNKHYyKSBhdXRoZW50aWNhdGlv bgoKU3ZlbiBFY2tlbG1hbm4gKDEpOgrCoMKgwqDCoMKgwqBiYXRtYW4tYWR2OiBGaXggdXNlLWFm dGVyLWZyZWUvZG91YmxlLWZyZWUgb2YgdHRfcmVxX25vZGUKClRha2FzaGkgSXdhaSAoMyk6CsKg wqDCoMKgwqDCoEFMU0E6IGR1bW15OiBGaXggYSB1c2UtYWZ0ZXItZnJlZSBhdCBjbG9zaW5nCsKg wqDCoMKgwqDCoEFMU0E6IGF1ODh4MDogRml4IGNhbGN1bGF0aW9uIGluIHZvcnRleF93dGRtYV9i dWZzaGlmdCgpCsKgwqDCoMKgwqDCoEFMU0E6IHRpbWVyOiBGaXggbmVnYXRpdmUgcXVldWUgdXNh Z2UgYnkgcmFjeSBhY2Nlc3NlcwoKVGFyaXEgVG91a2FuICgxKToKwqDCoMKgwqDCoMKgbmV0L21s eDRfY29yZTogRml4IGFjY2VzcyB0byB1bmluaXRpYWxpemVkIGluZGV4CgpUaGVvZG9yZSBUcydv ICgxKToKwqDCoMKgwqDCoMKgZXh0NDogZml4IGhhbmcgd2hlbiBwcm9jZXNzaW5nIGNvcnJ1cHRl ZCBvcnBoYW5lZCBpbm9kZSBsaXN0CgpUb3JzdGVuIEhpbGJyaWNoICgxKToKwqDCoMKgwqDCoMKg ZnMvbmlsZnMyOiBmaXggcG90ZW50aWFsIHVuZGVyZmxvdyBpbiBjYWxsIHRvIGNyYzMyX2xlCgpU cm9uZCBNeWtsZWJ1c3QgKDEpOgrCoMKgwqDCoMKgwqBORlM6IEZpeCBhbm90aGVyIE9QRU5fRE9X TkdSQURFIGJ1ZwoKVXJzdWxhIEJyYXVuICgxKToKwqDCoMKgwqDCoMKgcWV0aDogZGVsZXRlIG5h cGkgc3RydWN0IHdoZW4gcmVtb3ZpbmcgYSBxZXRoIGRldmljZQoKVmlrIEhleW5kcmlja3ggKDEp OgrCoMKgwqDCoMKgwqBzY2hlZC9sb2FkYXZnOiBGaXggbG9hZGF2ZyBhcnRpZmFjdHMgb24gZnVs bHkgaWRsZSBhbmQgb24gZnVsbHkgbG9hZGVkIHN5c3RlbXMKCldpbGxpYW0gQnJlYXRoaXR0IEdy YXkgKDEpOgrCoMKgwqDCoMKgwqBpc2E6IENhbGwgaXNhX2J1c19pbml0IGJlZm9yZSBkZXBlbmRl bnQgSVNBIGJ1cyBkcml2ZXJzIHJlZ2lzdGVyCgpXb2xmZ2FuZyBHcmFuZGVnZ2VyICgxKToKwqDC oMKgwqDCoMKgY2FuOiBhdDkxX2NhbjogUlggcXVldWUgY291bGQgZ2V0IHN0dWNrIGF0IGhpZ2gg YnVzIGxvYWQKClhpdWJvIExpICgxKToKwqDCoMKgwqDCoMKga3ZtOiBGaXggaXJxIHJvdXRlIGVu dHJpZXMgZXhjZWVkaW5nIEtWTV9NQVhfSVJRX1JPVVRFUwoKWWlzaGFpIEhhZGFzICgxKToKwqDC oMKgwqDCoMKgSUIvbWx4NDogRml4IHRoZSBTUSBzaXplIG9mIGFuIFJDIFFQCgpsZWkgbGl1ICgx KToKwqDCoMKgwqDCoMKgVVNCOiBzZXJpYWw6IG9wdGlvbjogYWRkIG1vcmUgWlRFIGRldmljZSBp ZHMKCnh5cHJvbi5nbHBrQGdteC5kZSAoMSk6CsKgwqDCoMKgwqDCoG5ldDogZWhlYTogYXZvaWQg bnVsbCBwb2ludGVyIGRlcmVmZXJlbmNlCgotLSAKQmVuIEh1dGNoaW5ncwpUaGUgcHJvZ3JhbSBp cyBhYnNvbHV0ZWx5IHJpZ2h0OyB0aGVyZWZvcmUsIHRoZSBjb21wdXRlciBtdXN0IGJlIHdyb25n Lgo= --=-+u+uwxhMrV3mqPCcE1z/ Content-Type: text/x-diff; charset="UTF-8"; name="linux-3.2.82.patch" Content-Disposition: attachment; filename="linux-3.2.82.patch" Content-Transfer-Encoding: quoted-printable diff --git a/Makefile b/Makefile index 98c276c53906..b6fa6316ef75 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ VERSION =3D 3 PATCHLEVEL =3D 2 -SUBLEVEL =3D 81 +SUBLEVEL =3D 82 EXTRAVERSION =3D NAME =3D Saber-toothed Squirrel =20 @@ -352,7 +352,7 @@ AFLAGS_MODULE =3D LDFLAGS_MODULE =3D CFLAGS_KERNEL =3D AFLAGS_KERNEL =3D -CFLAGS_GCOV =3D -fprofile-arcs -ftest-coverage +CFLAGS_GCOV =3D -fprofile-arcs -ftest-coverage -fno-tree-loop-im =20 =20 # Use LINUXINCLUDE when you must reference the include/ directory. diff --git a/arch/alpha/kernel/pci-sysfs.c b/arch/alpha/kernel/pci-sysfs.c index 53649c7d0068..cb63d52c697a 100644 --- a/arch/alpha/kernel/pci-sysfs.c +++ b/arch/alpha/kernel/pci-sysfs.c @@ -78,10 +78,10 @@ static int pci_mmap_resource(struct kobject *kobj, if (i >=3D PCI_ROM_RESOURCE) return -ENODEV; =20 - if (!__pci_mmap_fits(pdev, i, vma, sparse)) + if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(res->start)) return -EINVAL; =20 - if (iomem_is_exclusive(res->start)) + if (!__pci_mmap_fits(pdev, i, vma, sparse)) return -EINVAL; =20 pcibios_resource_to_bus(pdev, &bar, res); diff --git a/arch/arm/kernel/ptrace.c b/arch/arm/kernel/ptrace.c index 90fa8b36b612..8b17fb452af8 100644 --- a/arch/arm/kernel/ptrace.c +++ b/arch/arm/kernel/ptrace.c @@ -726,8 +726,8 @@ static int vfp_set(struct task_struct *target, if (ret) return ret; =20 - vfp_flush_hwstate(thread); thread->vfpstate.hard =3D new_vfp; + vfp_flush_hwstate(thread); =20 return 0; } diff --git a/arch/mips/include/asm/pgtable.h b/arch/mips/include/asm/pgtabl= e.h index 95bcedbdc92c..d9e992523e7f 100644 --- a/arch/mips/include/asm/pgtable.h +++ b/arch/mips/include/asm/pgtable.h @@ -168,20 +168,39 @@ static inline void set_pte(pte_t *ptep, pte_t pteval) unsigned long page_global =3D _PAGE_GLOBAL; unsigned long tmp; =20 - __asm__ __volatile__ ( - " .set push\n" - " .set noreorder\n" - "1: " LL_INSN " %[tmp], %[buddy]\n" - " bnez %[tmp], 2f\n" - " or %[tmp], %[tmp], %[global]\n" - " " SC_INSN " %[tmp], %[buddy]\n" - " beqz %[tmp], 1b\n" - " nop\n" - "2:\n" - " .set pop" - : [buddy] "+m" (buddy->pte), - [tmp] "=3D&r" (tmp) + if (kernel_uses_llsc && R10000_LLSC_WAR) { + __asm__ __volatile__ ( + " .set arch=3Dr4000 \n" + " .set push \n" + " .set noreorder \n" + "1:" LL_INSN " %[tmp], %[buddy] \n" + " bnez %[tmp], 2f \n" + " or %[tmp], %[tmp], %[global] \n" + SC_INSN " %[tmp], %[buddy] \n" + " beqzl %[tmp], 1b \n" + " nop \n" + "2: \n" + " .set pop \n" + " .set mips0 \n" + : [buddy] "+m" (buddy->pte), [tmp] "=3D&r" (tmp) : [global] "r" (page_global)); + } else if (kernel_uses_llsc) { + __asm__ __volatile__ ( + " .set arch=3Dr4000 \n" + " .set push \n" + " .set noreorder \n" + "1:" LL_INSN " %[tmp], %[buddy] \n" + " bnez %[tmp], 2f \n" + " or %[tmp], %[tmp], %[global] \n" + SC_INSN " %[tmp], %[buddy] \n" + " beqz %[tmp], 1b \n" + " nop \n" + "2: \n" + " .set pop \n" + " .set mips0 \n" + : [buddy] "+m" (buddy->pte), [tmp] "=3D&r" (tmp) + : [global] "r" (page_global)); + } #else /* !CONFIG_SMP */ if (pte_none(*buddy)) pte_val(*buddy) =3D pte_val(*buddy) | _PAGE_GLOBAL; diff --git a/arch/parisc/kernel/unaligned.c b/arch/parisc/kernel/unaligned.= c index 234e3682cf09..43d802b84a91 100644 --- a/arch/parisc/kernel/unaligned.c +++ b/arch/parisc/kernel/unaligned.c @@ -663,7 +663,7 @@ void handle_unaligned(struct pt_regs *regs) break; } =20 - if (modify && R1(regs->iir)) + if (ret =3D=3D 0 && modify && R1(regs->iir)) regs->gr[R1(regs->iir)] =3D newbase; =20 =20 @@ -674,6 +674,14 @@ void handle_unaligned(struct pt_regs *regs) =20 if (ret) { + /* + * The unaligned handler failed. + * If we were called by __get_user() or __put_user() jump + * to it's exception fixup handler instead of crashing. + */ + if (!user_mode(regs) && fixup_exception(regs)) + return; + printk(KERN_CRIT "Unaligned handler failed, ret =3D %d\n", ret); die_if_kernel("Unaligned data reference", regs, 28); =20 diff --git a/arch/powerpc/mm/hash_utils_64.c b/arch/powerpc/mm/hash_utils_6= 4.c index 2d282186cb45..e9a8b8cfbe98 100644 --- a/arch/powerpc/mm/hash_utils_64.c +++ b/arch/powerpc/mm/hash_utils_64.c @@ -1074,6 +1074,30 @@ int hash_page(unsigned long ea, unsigned long access= , unsigned long trap) } EXPORT_SYMBOL_GPL(hash_page); =20 +#ifdef CONFIG_PPC_MM_SLICES +static bool should_hash_preload(struct mm_struct *mm, unsigned long ea) +{ + int psize =3D get_slice_psize(mm, ea); + + /* We only prefault standard pages for now */ + if (unlikely(psize !=3D mm->context.user_psize)) + return false; + + /* + * Don't prefault if subpage protection is enabled for the EA. + */ + if (unlikely((psize =3D=3D MMU_PAGE_4K) && subpage_protection(mm, ea))) + return false; + + return true; +} +#else +static bool should_hash_preload(struct mm_struct *mm, unsigned long ea) +{ + return true; +} +#endif + void hash_preload(struct mm_struct *mm, unsigned long ea, unsigned long access, unsigned long trap) { @@ -1085,11 +1109,8 @@ void hash_preload(struct mm_struct *mm, unsigned lon= g ea, =20 BUG_ON(REGION_ID(ea) !=3D USER_REGION_ID); =20 -#ifdef CONFIG_PPC_MM_SLICES - /* We only prefault standard pages for now */ - if (unlikely(get_slice_psize(mm, ea) !=3D mm->context.user_psize)) + if (!should_hash_preload(mm, ea)) return; -#endif =20 DBG_LOW("hash_preload(mm=3D%p, mm->pgdir=3D%p, ea=3D%016lx, access=3D%lx,= " " trap=3D%lx\n", mm, mm->pgd, ea, access, trap); diff --git a/arch/x86/boot/Makefile b/arch/x86/boot/Makefile index e80542b45329..075c6b3f5e8b 100644 --- a/arch/x86/boot/Makefile +++ b/arch/x86/boot/Makefile @@ -166,6 +166,9 @@ isoimage: $(obj)/bzImage for i in lib lib64 share end ; do \ if [ -f /usr/$$i/syslinux/isolinux.bin ] ; then \ cp /usr/$$i/syslinux/isolinux.bin $(obj)/isoimage ; \ + if [ -f /usr/$$i/syslinux/ldlinux.c32 ]; then \ + cp /usr/$$i/syslinux/ldlinux.c32 $(obj)/isoimage ; \ + fi ; \ break ; \ fi ; \ if [ $$i =3D end ] ; then exit 1 ; fi ; \ diff --git a/arch/x86/kernel/amd_nb.c b/arch/x86/kernel/amd_nb.c index be16854591cc..697461884e23 100644 --- a/arch/x86/kernel/amd_nb.c +++ b/arch/x86/kernel/amd_nb.c @@ -59,8 +59,8 @@ int amd_cache_northbridges(void) while ((misc =3D next_northbridge(misc, amd_nb_misc_ids)) !=3D NULL) i++; =20 - if (i =3D=3D 0) - return 0; + if (!i) + return -ENODEV; =20 nb =3D kzalloc(i * sizeof(struct amd_northbridge), GFP_KERNEL); if (!nb) diff --git a/arch/x86/kernel/kprobes.c b/arch/x86/kernel/kprobes.c index 083848f0652c..29aed8d01b76 100644 --- a/arch/x86/kernel/kprobes.c +++ b/arch/x86/kernel/kprobes.c @@ -949,7 +949,19 @@ int __kprobes kprobe_fault_handler(struct pt_regs *reg= s, int trapnr) * normal page fault. */ regs->ip =3D (unsigned long)cur->addr; + /* + * Trap flag (TF) has been set here because this fault + * happened where the single stepping will be done. + * So clear it by resetting the current kprobe: + */ + regs->flags &=3D ~X86_EFLAGS_TF; + + /* + * If the TF flag was set before the kprobe hit, + * don't touch it: + */ regs->flags |=3D kcb->kprobe_old_flags; + if (kcb->kprobe_status =3D=3D KPROBE_REENTER) restore_previous_kprobe(kcb); else diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index a7fd5b336ac7..4ae334a1bd99 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -2952,6 +2952,11 @@ static int kvm_vcpu_ioctl_x86_set_debugregs(struct k= vm_vcpu *vcpu, if (dbgregs->flags) return -EINVAL; =20 + if (dbgregs->dr6 & ~0xffffffffull) + return -EINVAL; + if (dbgregs->dr7 & ~0xffffffffull) + return -EINVAL; + memcpy(vcpu->arch.db, dbgregs->db, sizeof(vcpu->arch.db)); vcpu->arch.dr6 =3D dbgregs->dr6; vcpu->arch.dr7 =3D dbgregs->dr7; diff --git a/arch/x86/pci/fixup.c b/arch/x86/pci/fixup.c index 7d0cfe38dc60..38eaf74837bc 100644 --- a/arch/x86/pci/fixup.c +++ b/arch/x86/pci/fixup.c @@ -539,9 +539,16 @@ static void __devinit twinhead_reserve_killing_zone(st= ruct pci_dev *dev) } DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x27B9, twinhead_reserve_kil= ling_zone); =20 +/* + * Broadwell EP Home Agent BARs erroneously return non-zero values when re= ad. + * + * See http://www.intel.com/content/www/us/en/processors/xeon/xeon-e5-v4-s= pec-update.html + * entry BDF2. + */ static void pci_bdwep_bar(struct pci_dev *dev) { dev->non_compliant_bars =3D 1; } +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x6f60, pci_bdwep_bar); DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x6fa0, pci_bdwep_bar); DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x6fc0, pci_bdwep_bar); diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c index 240a24400976..9b953d4405e0 100644 --- a/drivers/acpi/sysfs.c +++ b/drivers/acpi/sysfs.c @@ -489,23 +489,22 @@ static void acpi_gbl_event_handler(u32 event_type, ac= pi_handle device, static int get_status(u32 index, acpi_event_status *status, acpi_handle *handle) { - int result =3D 0; + int result; =20 if (index >=3D num_gpes + ACPI_NUM_FIXED_EVENTS) - goto end; + return -EINVAL; =20 if (index < num_gpes) { result =3D acpi_get_gpe_device(index, handle); if (result) { ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND, "Invalid GPE 0x%x\n", index)); - goto end; + return result; } result =3D acpi_get_gpe_status(*handle, index, status); } else if (index < (num_gpes + ACPI_NUM_FIXED_EVENTS)) result =3D acpi_get_event_status(index - num_gpes, status); =20 -end: return result; } =20 diff --git a/drivers/ata/sata_dwc_460ex.c b/drivers/ata/sata_dwc_460ex.c index 0bec79e0d888..e86ccb279213 100644 --- a/drivers/ata/sata_dwc_460ex.c +++ b/drivers/ata/sata_dwc_460ex.c @@ -1386,15 +1386,13 @@ static void sata_dwc_exec_command_by_tag(struct ata= _port *ap, struct ata_taskfile *tf, u8 tag, u32 cmd_issued) { - unsigned long flags; struct sata_dwc_device_port *hsdevp =3D HSDEVP_FROM_AP(ap); =20 dev_dbg(ap->dev, "%s cmd(0x%02x): %s tag=3D%d\n", __func__, tf->command, ata_get_cmd_descript(tf->command), tag); =20 - spin_lock_irqsave(&ap->host->lock, flags); hsdevp->cmd_issued[tag] =3D cmd_issued; - spin_unlock_irqrestore(&ap->host->lock, flags); + /* * Clear SError before executing a new command. * sata_dwc_scr_write and read can not be used here. Clearing the PM diff --git a/drivers/base/isa.c b/drivers/base/isa.c index 91dba65d7264..cd6ccdcf9df0 100644 --- a/drivers/base/isa.c +++ b/drivers/base/isa.c @@ -180,4 +180,4 @@ static int __init isa_bus_init(void) return error; } =20 -device_initcall(isa_bus_init); +postcore_initcall(isa_bus_init); diff --git a/drivers/base/module.c b/drivers/base/module.c index db930d3ee312..2a215780eda2 100644 --- a/drivers/base/module.c +++ b/drivers/base/module.c @@ -24,10 +24,12 @@ static char *make_driver_name(struct device_driver *drv= ) =20 static void module_create_drivers_dir(struct module_kobject *mk) { - if (!mk || mk->drivers_dir) - return; + static DEFINE_MUTEX(drivers_dir_mutex); =20 - mk->drivers_dir =3D kobject_create_and_add("drivers", &mk->kobj); + mutex_lock(&drivers_dir_mutex); + if (mk && !mk->drivers_dir) + mk->drivers_dir =3D kobject_create_and_add("drivers", &mk->kobj); + mutex_unlock(&drivers_dir_mutex); } =20 void module_add_driver(struct module *mod, struct device_driver *drv) diff --git a/drivers/base/regmap/regcache.c b/drivers/base/regmap/regcache.= c index 64004b0817db..637b7fab12f7 100644 --- a/drivers/base/regmap/regcache.c +++ b/drivers/base/regmap/regcache.c @@ -294,7 +294,7 @@ EXPORT_SYMBOL_GPL(regcache_cache_only); * regcache_cache_bypass: Put a register map into cache bypass mode * * @map: map to configure - * @cache_bypass: flag if changes should not be written to the hardware + * @cache_bypass: flag if changes should not be written to the cache * * When a register map is marked with the cache bypass option, writes * to the register map API will only update the hardware and not the diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig index 43643033a3ae..1ba79a6d7631 100644 --- a/drivers/char/Kconfig +++ b/drivers/char/Kconfig @@ -594,7 +594,6 @@ config TELCLOCK =20 config DEVPORT bool - depends on !M68K depends on ISA || PCI default y =20 diff --git a/drivers/char/i8k.c b/drivers/char/i8k.c index 51efcbcf7193..50ca7f6a864c 100644 --- a/drivers/char/i8k.c +++ b/drivers/char/i8k.c @@ -63,6 +63,7 @@ =20 static DEFINE_MUTEX(i8k_mutex); static char bios_version[4]; +static char bios_machineid[16]; static struct device *i8k_hwmon_dev; =20 MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); @@ -77,13 +78,13 @@ static int ignore_dmi; module_param(ignore_dmi, bool, 0); MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data d= oes not match"); =20 -static int restricted; +static int restricted =3D true; module_param(restricted, bool, 0); -MODULE_PARM_DESC(restricted, "Allow fan control if SYS_ADMIN capability se= t"); +MODULE_PARM_DESC(restricted, "Restrict fan control and serial number to CA= P_SYS_ADMIN (default: 1)"); =20 static int power_status; module_param(power_status, bool, 0600); -MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k"); +MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k (default:= 0)"); =20 static int fan_mult =3D I8K_FAN_MULT; module_param(fan_mult, int, 0); @@ -332,8 +333,11 @@ i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, = unsigned long arg) break; =20 case I8K_MACHINE_ID: - memset(buff, 0, 16); - strlcpy(buff, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), sizeof(buff)); + if (restricted && !capable(CAP_SYS_ADMIN)) + return -EPERM; + + memset(buff, 0, sizeof(buff)); + strlcpy(buff, bios_machineid, sizeof(buff)); break; =20 case I8K_FN_STATUS: @@ -450,7 +454,7 @@ static int i8k_proc_show(struct seq_file *seq, void *of= fset) return seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", I8K_PROC_FMT, bios_version, - i8k_get_dmi_data(DMI_PRODUCT_SERIAL), + (restricted && !capable(CAP_SYS_ADMIN)) ? "-1" : bios_machineid, cpu_temp, left_fan, right_fan, left_speed, right_speed, ac_power, fn_key); @@ -697,6 +701,8 @@ static int __init i8k_probe(void) } =20 strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), sizeof(bios_ver= sion)); + strlcpy(bios_machineid, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), + sizeof(bios_machineid)); =20 /* * Get SMM Dell signature diff --git a/drivers/crypto/s5p-sss.c b/drivers/crypto/s5p-sss.c index 8115417a1c93..4f30887461ae 100644 --- a/drivers/crypto/s5p-sss.c +++ b/drivers/crypto/s5p-sss.c @@ -210,11 +210,11 @@ static int s5p_set_outdata(struct s5p_aes_dev *dev, s= truct scatterlist *sg) { int err; =20 - if (!IS_ALIGNED(sg_dma_len(sg), AES_BLOCK_SIZE)) { + if (!IS_ALIGNED(sg->length, AES_BLOCK_SIZE)) { err =3D -EINVAL; goto exit; } - if (!sg_dma_len(sg)) { + if (!sg->length) { err =3D -EINVAL; goto exit; } @@ -236,11 +236,11 @@ static int s5p_set_indata(struct s5p_aes_dev *dev, st= ruct scatterlist *sg) { int err; =20 - if (!IS_ALIGNED(sg_dma_len(sg), AES_BLOCK_SIZE)) { + if (!IS_ALIGNED(sg->length, AES_BLOCK_SIZE)) { err =3D -EINVAL; goto exit; } - if (!sg_dma_len(sg)) { + if (!sg->length) { err =3D -EINVAL; goto exit; } @@ -258,39 +258,51 @@ static int s5p_set_indata(struct s5p_aes_dev *dev, st= ruct scatterlist *sg) return err; } =20 -static void s5p_aes_tx(struct s5p_aes_dev *dev) +/* + * Returns true if new transmitting (output) data is ready and its + * address+length have to be written to device (by calling + * s5p_set_dma_outdata()). False otherwise. + */ +static bool s5p_aes_tx(struct s5p_aes_dev *dev) { int err =3D 0; + bool ret =3D false; =20 s5p_unset_outdata(dev); =20 if (!sg_is_last(dev->sg_dst)) { err =3D s5p_set_outdata(dev, sg_next(dev->sg_dst)); - if (err) { + if (err) s5p_aes_complete(dev, err); - return; - } - - s5p_set_dma_outdata(dev, dev->sg_dst); + else + ret =3D true; } else s5p_aes_complete(dev, err); + + return ret; } =20 -static void s5p_aes_rx(struct s5p_aes_dev *dev) +/* + * Returns true if new receiving (input) data is ready and its + * address+length have to be written to device (by calling + * s5p_set_dma_indata()). False otherwise. + */ +static bool s5p_aes_rx(struct s5p_aes_dev *dev) { int err; + bool ret =3D false; =20 s5p_unset_indata(dev); =20 if (!sg_is_last(dev->sg_src)) { err =3D s5p_set_indata(dev, sg_next(dev->sg_src)); - if (err) { + if (err) s5p_aes_complete(dev, err); - return; - } - - s5p_set_dma_indata(dev, dev->sg_src); + else + ret =3D true; } + + return ret; } =20 static irqreturn_t s5p_aes_interrupt(int irq, void *dev_id) @@ -299,19 +311,32 @@ static irqreturn_t s5p_aes_interrupt(int irq, void *d= ev_id) struct s5p_aes_dev *dev =3D platform_get_drvdata(pdev); uint32_t status; unsigned long flags; + bool set_dma_tx =3D false; + bool set_dma_rx =3D false; =20 spin_lock_irqsave(&dev->lock, flags); =20 if (irq =3D=3D dev->irq_fc) { status =3D SSS_READ(dev, FCINTSTAT); if (status & SSS_FCINTSTAT_BRDMAINT) - s5p_aes_rx(dev); + set_dma_rx =3D s5p_aes_rx(dev); if (status & SSS_FCINTSTAT_BTDMAINT) - s5p_aes_tx(dev); + set_dma_tx =3D s5p_aes_tx(dev); =20 SSS_WRITE(dev, FCINTPEND, status); } =20 + /* + * Writing length of DMA block (either receiving or transmitting) + * will start the operation immediately, so this should be done + * at the end (even after clearing pending interrupts to not miss the + * interrupt). + */ + if (set_dma_tx) + s5p_set_dma_outdata(dev, dev->sg_dst); + if (set_dma_rx) + s5p_set_dma_indata(dev, dev->sg_src); + spin_unlock_irqrestore(&dev->lock, flags); =20 return IRQ_HANDLED; diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeo= n/radeon_device.c index 8cde84b666d5..f122e6132d35 100644 --- a/drivers/gpu/drm/radeon/radeon_device.c +++ b/drivers/gpu/drm/radeon/radeon_device.c @@ -350,10 +350,31 @@ void radeon_gtt_location(struct radeon_device *rdev, = struct radeon_mc *mc) /* * GPU helpers function. */ + +/** + * radeon_device_is_virtual - check if we are running is a virtual environ= ment + * + * Check if the asic has been passed through to a VM (all asics). + * Used at driver startup. + * Returns true if virtual or false if not. + */ +static bool radeon_device_is_virtual(void) +{ +#ifdef CONFIG_X86 + return boot_cpu_has(X86_FEATURE_HYPERVISOR); +#else + return false; +#endif +} + bool radeon_card_posted(struct radeon_device *rdev) { uint32_t reg; =20 + /* for pass through, always force asic_init */ + if (radeon_device_is_virtual()) + return false; + if (efi_enabled(EFI_BOOT) && rdev->pdev->subsystem_vendor =3D=3D PCI_VENDOR_ID_APPLE) return false; diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c index 4ef02b269a71..1378ae0d1376 100644 --- a/drivers/hid/usbhid/hiddev.c +++ b/drivers/hid/usbhid/hiddev.c @@ -515,13 +515,13 @@ static noinline int hiddev_ioctl_usage(struct hiddev = *hiddev, unsigned int cmd, goto inval; } else if (uref->usage_index >=3D field->report_count) goto inval; - - else if ((cmd =3D=3D HIDIOCGUSAGES || cmd =3D=3D HIDIOCSUSAGES) && - (uref_multi->num_values > HID_MAX_MULTI_USAGES || - uref->usage_index + uref_multi->num_values > field->report_count)) - goto inval; } =20 + if ((cmd =3D=3D HIDIOCGUSAGES || cmd =3D=3D HIDIOCSUSAGES) && + (uref_multi->num_values > HID_MAX_MULTI_USAGES || + uref->usage_index + uref_multi->num_values > field->report_count)) + goto inval; + switch (cmd) { case HIDIOCGUSAGE: uref->value =3D field->value[uref->usage_index]; diff --git a/drivers/infiniband/hw/cxgb3/cxio_hal.c b/drivers/infiniband/hw= /cxgb3/cxio_hal.c index c3f5aca4ef00..f26676f2f3b2 100644 --- a/drivers/infiniband/hw/cxgb3/cxio_hal.c +++ b/drivers/infiniband/hw/cxgb3/cxio_hal.c @@ -327,7 +327,7 @@ int cxio_destroy_cq(struct cxio_rdev *rdev_p, struct t3= _cq *cq) kfree(cq->sw_queue); dma_free_coherent(&(rdev_p->rnic_info.pdev->dev), (1UL << (cq->size_log2)) - * sizeof(struct t3_cqe), cq->queue, + * sizeof(struct t3_cqe) + 1, cq->queue, dma_unmap_addr(cq, mapping)); cxio_hal_put_cqid(rdev_p->rscp, cq->cqid); return err; diff --git a/drivers/infiniband/hw/mlx4/ah.c b/drivers/infiniband/hw/mlx4/a= h.c index 08f3f28bd2fb..5364eafc4d28 100644 --- a/drivers/infiniband/hw/mlx4/ah.c +++ b/drivers/infiniband/hw/mlx4/ah.c @@ -65,6 +65,7 @@ static struct ib_ah *create_ib_ah(struct ib_pd *pd, struc= t ib_ah_attr *ah_attr, =20 ah->av.ib.port_pd =3D cpu_to_be32(to_mpd(pd)->pdn | (ah_attr->port_num <<= 24)); ah->av.ib.g_slid =3D ah_attr->src_path_bits; + ah->av.ib.sl_tclass_flowlabel =3D cpu_to_be32(ah_attr->sl << 28); if (ah_attr->ah_flags & IB_AH_GRH) { ah->av.ib.g_slid |=3D 0x80; ah->av.ib.gid_index =3D ah_attr->grh.sgid_index; @@ -82,7 +83,6 @@ static struct ib_ah *create_ib_ah(struct ib_pd *pd, struc= t ib_ah_attr *ah_attr, !(1 << ah->av.ib.stat_rate & dev->caps.stat_rate_support)) --ah->av.ib.stat_rate; } - ah->av.ib.sl_tclass_flowlabel =3D cpu_to_be32(ah_attr->sl << 28); =20 return &ah->ibah; } diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/q= p.c index 2ed14a7cd1a5..1165949d5c43 100644 --- a/drivers/infiniband/hw/mlx4/qp.c +++ b/drivers/infiniband/hw/mlx4/qp.c @@ -283,7 +283,7 @@ static int send_wqe_overhead(enum ib_qp_type type, u32 = flags) sizeof (struct mlx4_wqe_raddr_seg); case IB_QPT_RC: return sizeof (struct mlx4_wqe_ctrl_seg) + - sizeof (struct mlx4_wqe_atomic_seg) + + sizeof (struct mlx4_wqe_masked_atomic_seg) + sizeof (struct mlx4_wqe_raddr_seg); case IB_QPT_SMI: case IB_QPT_GSI: diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c index 0c4c556a0611..7f39abd566c2 100644 --- a/drivers/input/joystick/xpad.c +++ b/drivers/input/joystick/xpad.c @@ -368,6 +368,10 @@ static void xpad360_process_packet(struct usb_xpad *xp= ad, { struct input_dev *dev =3D xpad->dev; =20 + /* valid pad data */ + if (data[0] !=3D 0x00) + return; + /* digital pad */ if (xpad->mapping & MAP_DPAD_TO_BUTTONS) { /* dpad as buttons (left, right, up, down) */ diff --git a/drivers/input/misc/pwm-beeper.c b/drivers/input/misc/pwm-beepe= r.c index 57c294f07198..250fa393041a 100644 --- a/drivers/input/misc/pwm-beeper.c +++ b/drivers/input/misc/pwm-beeper.c @@ -19,21 +19,40 @@ #include #include #include +#include =20 struct pwm_beeper { struct input_dev *input; struct pwm_device *pwm; + struct work_struct work; unsigned long period; }; =20 #define HZ_TO_NANOSECONDS(x) (1000000000UL/(x)) =20 +static void __pwm_beeper_set(struct pwm_beeper *beeper) +{ + unsigned long period =3D beeper->period; + + if (period) { + pwm_config(beeper->pwm, period / 2, period); + pwm_enable(beeper->pwm); + } else + pwm_disable(beeper->pwm); +} + +static void pwm_beeper_work(struct work_struct *work) +{ + struct pwm_beeper *beeper =3D + container_of(work, struct pwm_beeper, work); + + __pwm_beeper_set(beeper); +} + static int pwm_beeper_event(struct input_dev *input, unsigned int type, unsigned int code, int value) { - int ret =3D 0; struct pwm_beeper *beeper =3D input_get_drvdata(input); - unsigned long period; =20 if (type !=3D EV_SND || value < 0) return -EINVAL; @@ -48,23 +67,31 @@ static int pwm_beeper_event(struct input_dev *input, return -EINVAL; } =20 - if (value =3D=3D 0) { - pwm_config(beeper->pwm, 0, 0); - pwm_disable(beeper->pwm); - } else { - period =3D HZ_TO_NANOSECONDS(value); - ret =3D pwm_config(beeper->pwm, period / 2, period); - if (ret) - return ret; - ret =3D pwm_enable(beeper->pwm); - if (ret) - return ret; - beeper->period =3D period; - } + if (value =3D=3D 0) + beeper->period =3D 0; + else + beeper->period =3D HZ_TO_NANOSECONDS(value); + + schedule_work(&beeper->work); =20 return 0; } =20 +static void pwm_beeper_stop(struct pwm_beeper *beeper) +{ + cancel_work_sync(&beeper->work); + + if (beeper->period) + pwm_disable(beeper->pwm); +} + +static void pwm_beeper_close(struct input_dev *input) +{ + struct pwm_beeper *beeper =3D input_get_drvdata(input); + + pwm_beeper_stop(beeper); +} + static int __devinit pwm_beeper_probe(struct platform_device *pdev) { unsigned long pwm_id =3D (unsigned long)pdev->dev.platform_data; @@ -83,6 +110,8 @@ static int __devinit pwm_beeper_probe(struct platform_de= vice *pdev) goto err_free; } =20 + INIT_WORK(&beeper->work, pwm_beeper_work); + beeper->input =3D input_allocate_device(); if (!beeper->input) { dev_err(&pdev->dev, "Failed to allocate input device\n"); @@ -102,6 +131,7 @@ static int __devinit pwm_beeper_probe(struct platform_d= evice *pdev) beeper->input->sndbit[0] =3D BIT(SND_TONE) | BIT(SND_BELL); =20 beeper->input->event =3D pwm_beeper_event; + beeper->input->close =3D pwm_beeper_close; =20 input_set_drvdata(beeper->input, beeper); =20 @@ -132,7 +162,6 @@ static int __devexit pwm_beeper_remove(struct platform_= device *pdev) platform_set_drvdata(pdev, NULL); input_unregister_device(beeper->input); =20 - pwm_disable(beeper->pwm); pwm_free(beeper->pwm); =20 kfree(beeper); @@ -145,8 +174,7 @@ static int pwm_beeper_suspend(struct device *dev) { struct pwm_beeper *beeper =3D dev_get_drvdata(dev); =20 - if (beeper->period) - pwm_disable(beeper->pwm); + pwm_beeper_stop(beeper); =20 return 0; } @@ -155,10 +183,8 @@ static int pwm_beeper_resume(struct device *dev) { struct pwm_beeper *beeper =3D dev_get_drvdata(dev); =20 - if (beeper->period) { - pwm_config(beeper->pwm, beeper->period / 2, beeper->period); - pwm_enable(beeper->pwm); - } + if (beeper->period) + __pwm_beeper_set(beeper); =20 return 0; } diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c index 736056897e50..f236a29a67ae 100644 --- a/drivers/input/misc/uinput.c +++ b/drivers/input/misc/uinput.c @@ -786,8 +786,14 @@ static long uinput_ioctl(struct file *file, unsigned i= nt cmd, unsigned long arg) } =20 #ifdef CONFIG_COMPAT + +#define UI_SET_PHYS_COMPAT _IOW(UINPUT_IOCTL_BASE, 108, compat_uptr_t) + static long uinput_compat_ioctl(struct file *file, unsigned int cmd, unsig= ned long arg) { + if (cmd =3D=3D UI_SET_PHYS_COMPAT) + cmd =3D UI_SET_PHYS; + return uinput_ioctl_handler(file, cmd, arg, compat_ptr(arg)); } #endif diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.= c index 548ea99c1423..537692db93b3 100644 --- a/drivers/input/mouse/elantech.c +++ b/drivers/input/mouse/elantech.c @@ -1284,13 +1284,7 @@ static int elantech_set_properties(struct elantech_d= ata *etd) case 5: etd->hw_version =3D 3; break; - case 6: - case 7: - case 8: - case 9: - case 10: - case 13: - case 14: + case 6 ... 14: etd->hw_version =3D 4; break; default: diff --git a/drivers/input/touchscreen/wacom_w8001.c b/drivers/input/touchs= creen/wacom_w8001.c index 1569a3934ab2..7335a5bd2cf0 100644 --- a/drivers/input/touchscreen/wacom_w8001.c +++ b/drivers/input/touchscreen/wacom_w8001.c @@ -28,7 +28,7 @@ MODULE_AUTHOR("Jaya Kumar "); MODULE_DESCRIPTION(DRIVER_DESC); MODULE_LICENSE("GPL"); =20 -#define W8001_MAX_LENGTH 11 +#define W8001_MAX_LENGTH 13 #define W8001_LEAD_MASK 0x80 #define W8001_LEAD_BYTE 0x80 #define W8001_TAB_MASK 0x40 diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c index c1aec06258c1..408000d9d5f8 100644 --- a/drivers/mmc/core/mmc.c +++ b/drivers/mmc/core/mmc.c @@ -235,6 +235,9 @@ static int mmc_get_ext_csd(struct mmc_card *card, u8 **= new_ext_csd) return err; } =20 +/* Minimum partition switch timeout in milliseconds */ +#define MMC_MIN_PART_SWITCH_TIME 300 + /* * Decode extended CSD. */ @@ -325,6 +328,10 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 = *ext_csd) =20 /* EXT_CSD value is in units of 10ms, but we store in ms */ card->ext_csd.part_time =3D 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME]; + /* Some eMMC set the value too low so set a minimum */ + if (card->ext_csd.part_time && + card->ext_csd.part_time < MMC_MIN_PART_SWITCH_TIME) + card->ext_csd.part_time =3D MMC_MIN_PART_SWITCH_TIME; =20 /* Sleep / awake timeout in 100ns units */ if (sa_shift > 0 && sa_shift <=3D 0x17) diff --git a/drivers/mtd/ubi/eba.c b/drivers/mtd/ubi/eba.c index 22b3636b53f4..910bf2767095 100644 --- a/drivers/mtd/ubi/eba.c +++ b/drivers/mtd/ubi/eba.c @@ -501,6 +501,7 @@ static int recover_peb(struct ubi_device *ubi, int pnum= , int vol_id, int lnum, int err, idx =3D vol_id2idx(ubi, vol_id), new_pnum, data_size, tries =3D = 0; struct ubi_volume *vol =3D ubi->volumes[idx]; struct ubi_vid_hdr *vid_hdr; + uint32_t crc; =20 vid_hdr =3D ubi_zalloc_vid_hdr(ubi, GFP_NOFS); if (!vid_hdr) @@ -522,12 +523,8 @@ retry: goto out_put; } =20 - vid_hdr->sqnum =3D cpu_to_be64(next_sqnum(ubi)); - err =3D ubi_io_write_vid_hdr(ubi, new_pnum, vid_hdr); - if (err) - goto write_error; + ubi_assert(vid_hdr->vol_type =3D=3D UBI_VID_DYNAMIC); =20 - data_size =3D offset + len; mutex_lock(&ubi->buf_mutex); memset(ubi->peb_buf1 + offset, 0xFF, len); =20 @@ -540,6 +537,18 @@ retry: =20 memcpy(ubi->peb_buf1 + offset, buf, len); =20 + data_size =3D offset + len; + crc =3D crc32(UBI_CRC32_INIT, ubi->peb_buf1, data_size); + vid_hdr->sqnum =3D cpu_to_be64(next_sqnum(ubi)); + vid_hdr->copy_flag =3D 1; + vid_hdr->data_size =3D cpu_to_be32(data_size); + vid_hdr->data_crc =3D cpu_to_be32(crc); + err =3D ubi_io_write_vid_hdr(ubi, new_pnum, vid_hdr); + if (err) { + mutex_unlock(&ubi->buf_mutex); + goto write_error; + } + err =3D ubi_io_write_data(ubi, ubi->peb_buf1, new_pnum, 0, data_size); if (err) { mutex_unlock(&ubi->buf_mutex); diff --git a/drivers/net/bonding/bond_3ad.c b/drivers/net/bonding/bond_3ad.= c index aaa79997898b..58da15668668 100644 --- a/drivers/net/bonding/bond_3ad.c +++ b/drivers/net/bonding/bond_3ad.c @@ -93,11 +93,14 @@ // compare MAC addresses #define MAC_ADDRESS_COMPARE(A, B) memcmp(A, B, ETH_ALEN) =20 -static struct mac_addr null_mac_addr =3D { { 0, 0, 0, 0, 0, 0 } }; +static const u8 null_mac_addr[ETH_ALEN + 2] __long_aligned =3D { + 0, 0, 0, 0, 0, 0 +}; static u16 ad_ticks_per_sec; static const int ad_delta_in_ticks =3D (AD_TIMER_INTERVAL * HZ) / 1000; =20 -static const u8 lacpdu_mcast_addr[ETH_ALEN] =3D MULTICAST_LACPDU_ADDR; +static const u8 lacpdu_mcast_addr[ETH_ALEN + 2] __long_aligned =3D + MULTICAST_LACPDU_ADDR; =20 // =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D main 802.3ad protoc= ol functions =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D static int ad_lacpdu_send(struct port *port); @@ -1627,7 +1630,7 @@ static void ad_clear_agg(struct aggregator *aggregato= r) aggregator->is_individual =3D false; aggregator->actor_admin_aggregator_key =3D 0; aggregator->actor_oper_aggregator_key =3D 0; - aggregator->partner_system =3D null_mac_addr; + eth_zero_addr(aggregator->partner_system.mac_addr_value); aggregator->partner_system_priority =3D 0; aggregator->partner_oper_aggregator_key =3D 0; aggregator->receive_state =3D 0; @@ -1650,7 +1653,7 @@ static void ad_initialize_agg(struct aggregator *aggr= egator) if (aggregator) { ad_clear_agg(aggregator); =20 - aggregator->aggregator_mac_address =3D null_mac_addr; + eth_zero_addr(aggregator->aggregator_mac_address.mac_addr_value); aggregator->aggregator_identifier =3D 0; aggregator->slave =3D NULL; } @@ -1686,7 +1689,7 @@ static void ad_initialize_port(struct port *port, int= lacp_fast) if (port) { port->actor_port_number =3D 1; port->actor_port_priority =3D 0xff; - port->actor_system =3D null_mac_addr; + eth_zero_addr(port->actor_system.mac_addr_value); port->actor_system_priority =3D 0xffff; port->actor_port_aggregator_identifier =3D 0; port->ntt =3D false; diff --git a/drivers/net/bonding/bond_alb.c b/drivers/net/bonding/bond_alb.= c index 30431d868d90..dd3b40ea9bea 100644 --- a/drivers/net/bonding/bond_alb.c +++ b/drivers/net/bonding/bond_alb.c @@ -45,13 +45,10 @@ =20 =20 =20 -#ifndef __long_aligned -#define __long_aligned __attribute__((aligned((sizeof(long))))) -#endif -static const u8 mac_bcast[ETH_ALEN] __long_aligned =3D { +static const u8 mac_bcast[ETH_ALEN + 2] __long_aligned =3D { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; -static const u8 mac_v6_allmcast[ETH_ALEN] __long_aligned =3D { +static const u8 mac_v6_allmcast[ETH_ALEN + 2] __long_aligned =3D { 0x33, 0x33, 0x00, 0x00, 0x00, 0x01 }; static const int alb_delta_in_ticks =3D HZ / ALB_TIMER_TICKS_PER_SEC; diff --git a/drivers/net/bonding/bonding.h b/drivers/net/bonding/bonding.h index 1aecc37e5b4d..ad637a269582 100644 --- a/drivers/net/bonding/bonding.h +++ b/drivers/net/bonding/bonding.h @@ -38,6 +38,9 @@ netif_running(dev) && \ netif_carrier_ok(dev)) =20 +#ifndef __long_aligned +#define __long_aligned __attribute__((aligned((sizeof(long))))) +#endif /* * Checks whether slave is ready for transmit. */ diff --git a/drivers/net/can/at91_can.c b/drivers/net/can/at91_can.c index ab411c3a2b51..a42d75cabd14 100644 --- a/drivers/net/can/at91_can.c +++ b/drivers/net/can/at91_can.c @@ -727,9 +727,10 @@ static int at91_poll_rx(struct net_device *dev, int qu= ota) =20 /* upper group completed, look again in lower */ if (priv->rx_next > get_mb_rx_low_last(priv) && - quota > 0 && mb > get_mb_rx_last(priv)) { + mb > get_mb_rx_last(priv)) { priv->rx_next =3D get_mb_rx_first(priv); - goto again; + if (quota > 0) + goto again; } =20 return received; diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c index 664263a2bf81..217b0a3893fc 100644 --- a/drivers/net/can/dev.c +++ b/drivers/net/can/dev.c @@ -730,6 +730,11 @@ static int can_newlink(struct net *src_net, struct net= _device *dev, return -EOPNOTSUPP; } =20 +static void can_dellink(struct net_device *dev, struct list_head *head) +{ + return; +} + static struct rtnl_link_ops can_link_ops __read_mostly =3D { .kind =3D "can", .maxtype =3D IFLA_CAN_MAX, @@ -737,6 +742,7 @@ static struct rtnl_link_ops can_link_ops __read_mostly = =3D { .setup =3D can_setup, .newlink =3D can_newlink, .changelink =3D can_changelink, + .dellink =3D can_dellink, .get_size =3D can_get_size, .fill_info =3D can_fill_info, .get_xstats_size =3D can_get_xstats_size, diff --git a/drivers/net/ethernet/ibm/ehea/ehea_main.c b/drivers/net/ethern= et/ibm/ehea/ehea_main.c index 297f0b6818be..bba48c845dcc 100644 --- a/drivers/net/ethernet/ibm/ehea/ehea_main.c +++ b/drivers/net/ethernet/ibm/ehea/ehea_main.c @@ -1157,16 +1157,15 @@ static void ehea_parse_eqe(struct ehea_adapter *ada= pter, u64 eqe) ec =3D EHEA_BMASK_GET(NEQE_EVENT_CODE, eqe); portnum =3D EHEA_BMASK_GET(NEQE_PORTNUM, eqe); port =3D ehea_get_port(adapter, portnum); + if (!port) { + netdev_err(NULL, "unknown portnum %x\n", portnum); + return; + } dev =3D port->netdev; =20 switch (ec) { case EHEA_EC_PORTSTATE_CHG: /* port state change */ =20 - if (!port) { - netdev_err(dev, "unknown portnum %x\n", portnum); - break; - } - if (EHEA_BMASK_GET(NEQE_PORT_UP, eqe)) { if (!netif_carrier_ok(dev)) { ret =3D ehea_sense_port_attr(port); diff --git a/drivers/net/ethernet/mellanox/mlx4/mcg.c b/drivers/net/etherne= t/mellanox/mlx4/mcg.c index 978688c31046..f815ecd0cb01 100644 --- a/drivers/net/ethernet/mellanox/mlx4/mcg.c +++ b/drivers/net/ethernet/mellanox/mlx4/mcg.c @@ -615,7 +615,7 @@ int mlx4_qp_attach_common(struct mlx4_dev *dev, struct = mlx4_qp *qp, u8 gid[16], struct mlx4_mgm *mgm; u32 members_count; u16 hash; - int index, prev; + int index =3D -1, prev; int link =3D 0; int i; int err; @@ -693,7 +693,7 @@ int mlx4_qp_attach_common(struct mlx4_dev *dev, struct = mlx4_qp *qp, u8 gid[16], goto out; =20 out: - if (prot =3D=3D MLX4_PROT_ETH) { + if (prot =3D=3D MLX4_PROT_ETH && index !=3D -1) { /* manage the steering entry for promisc mode */ if (new_entry) new_steering_entry(dev, 0, port, steer, index, qp->qpn); diff --git a/drivers/net/wireless/ath/ath5k/led.c b/drivers/net/wireless/at= h/ath5k/led.c index c1151c723711..d2b2b36be9f4 100644 --- a/drivers/net/wireless/ath/ath5k/led.c +++ b/drivers/net/wireless/ath/ath5k/led.c @@ -75,7 +75,7 @@ static DEFINE_PCI_DEVICE_TABLE(ath5k_led_devices) =3D { /* HP Compaq CQ60-206US (ddreggors@jumptv.com) */ { ATH_SDEVICE(PCI_VENDOR_ID_HP, 0x0137a), ATH_LED(3, 1) }, /* HP Compaq C700 (nitrousnrg@gmail.com) */ - { ATH_SDEVICE(PCI_VENDOR_ID_HP, 0x0137b), ATH_LED(3, 1) }, + { ATH_SDEVICE(PCI_VENDOR_ID_HP, 0x0137b), ATH_LED(3, 0) }, /* LiteOn AR5BXB63 (magooz@salug.it) */ { ATH_SDEVICE(PCI_VENDOR_ID_ATHEROS, 0x3067), ATH_LED(3, 0) }, /* IBM-specific AR5212 (all others) */ diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/m= ac80211_hwsim.c index 523ad55a2885..8e37a1822ff1 100644 --- a/drivers/net/wireless/mac80211_hwsim.c +++ b/drivers/net/wireless/mac80211_hwsim.c @@ -1440,6 +1440,7 @@ static int hwsim_tx_info_frame_received_nl(struct sk_= buff *skb_2, if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] || !info->attrs[HWSIM_ATTR_FLAGS] || !info->attrs[HWSIM_ATTR_COOKIE] || + !info->attrs[HWSIM_ATTR_SIGNAL] || !info->attrs[HWSIM_ATTR_TX_INFO]) goto out; =20 diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c index 1e6be19e2c4c..82edc0fc8f6c 100644 --- a/drivers/pci/pci-sysfs.c +++ b/drivers/pci/pci-sysfs.c @@ -813,6 +813,9 @@ pci_mmap_resource(struct kobject *kobj, struct bin_attr= ibute *attr, if (i >=3D PCI_ROM_RESOURCE) return -ENODEV; =20 + if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(res->start)) + return -EINVAL; + if (!pci_mmap_fits(pdev, i, vma, PCI_MMAP_SYSFS)) { WARN(1, "process \"%s\" tried to map 0x%08lx bytes " "at page 0x%08lx on %s BAR %d (start 0x%16Lx, size 0x%16Lx)\n", @@ -830,10 +833,6 @@ pci_mmap_resource(struct kobject *kobj, struct bin_att= ribute *attr, pci_resource_to_user(pdev, i, res, &start, &end); vma->vm_pgoff +=3D start >> PAGE_SHIFT; mmap_type =3D res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io; - - if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(start)) - return -EINVAL; - return pci_mmap_page_range(pdev, vma, mmap_type, write_combine); } =20 diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c index fbf3be17239d..4a640a81bc07 100644 --- a/drivers/pci/probe.c +++ b/drivers/pci/probe.c @@ -136,9 +136,6 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_t= ype type, u32 l, sz, mask; u16 orig_cmd; =20 - if (dev->non_compliant_bars) - return 0; - mask =3D type ? PCI_ROM_ADDRESS_MASK : ~0; =20 if (!dev->mmio_always_on) { @@ -251,6 +248,9 @@ static void pci_read_bases(struct pci_dev *dev, unsigne= d int howmany, int rom) { unsigned int pos, reg; =20 + if (dev->non_compliant_bars) + return; + for (pos =3D 0; pos < howmany; pos++) { struct resource *res =3D &dev->resource[pos]; reg =3D PCI_BASE_ADDRESS_0 + (pos << 2); diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_mai= n.c index a21ae3d549db..fc7565910a05 100644 --- a/drivers/s390/net/qeth_l2_main.c +++ b/drivers/s390/net/qeth_l2_main.c @@ -897,6 +897,7 @@ static void qeth_l2_remove_device(struct ccwgroup_devic= e *cgdev) qeth_l2_set_offline(cgdev); =20 if (card->dev) { + netif_napi_del(&card->napi); unregister_netdev(card->dev); card->dev =3D NULL; } diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_mai= n.c index 4d5307ddbe55..fa38a3647c41 100644 --- a/drivers/s390/net/qeth_l3_main.c +++ b/drivers/s390/net/qeth_l3_main.c @@ -3395,6 +3395,7 @@ static void qeth_l3_remove_device(struct ccwgroup_dev= ice *cgdev) qeth_l3_set_offline(cgdev); =20 if (card->dev) { + netif_napi_del(&card->napi); unregister_netdev(card->dev); card->dev =3D NULL; } diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.= c index 43e58c2cc35c..a03ab8eb097b 100644 --- a/drivers/scsi/aacraid/commsup.c +++ b/drivers/scsi/aacraid/commsup.c @@ -1887,6 +1887,10 @@ int aac_command_thread(void *data) if (difference <=3D 0) difference =3D 1; set_current_state(TASK_INTERRUPTIBLE); + + if (kthread_should_stop()) + break; + schedule_timeout(difference); =20 if (kthread_should_stop()) diff --git a/drivers/staging/iio/accel/kxsd9.c b/drivers/staging/iio/accel/= kxsd9.c index 5238503f6805..5541ed38e090 100644 --- a/drivers/staging/iio/accel/kxsd9.c +++ b/drivers/staging/iio/accel/kxsd9.c @@ -81,7 +81,7 @@ static int kxsd9_write_scale(struct iio_dev *indio_dev, i= nt micro) =20 mutex_lock(&st->buf_lock); ret =3D spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C)); - if (ret) + if (ret < 0) goto error_ret; st->tx[0] =3D KXSD9_WRITE(KXSD9_REG_CTRL_C); st->tx[1] =3D (ret & ~KXSD9_FS_MASK) | i; @@ -166,7 +166,7 @@ static int kxsd9_read_raw(struct iio_dev *indio_dev, break; case (1 << IIO_CHAN_INFO_SCALE_SHARED): ret =3D spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C)); - if (ret) + if (ret < 0) goto error_ret; *val2 =3D kxsd9_micro_scales[ret & KXSD9_FS_MASK]; ret =3D IIO_VAL_INT_PLUS_MICRO; diff --git a/drivers/staging/iio/accel/sca3000_core.c b/drivers/staging/iio= /accel/sca3000_core.c index a44a70589db9..74ceba07d38b 100644 --- a/drivers/staging/iio/accel/sca3000_core.c +++ b/drivers/staging/iio/accel/sca3000_core.c @@ -579,7 +579,7 @@ static ssize_t sca3000_read_frequency(struct device *de= v, goto error_ret_mut; ret =3D sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL); mutex_unlock(&st->lock); - if (ret) + if (ret < 0) goto error_ret; val =3D ret; if (base_freq > 0) diff --git a/drivers/staging/iio/industrialio-trigger.c b/drivers/staging/i= io/industrialio-trigger.c index 2c626e0cb29c..fa6e882e13d3 100644 --- a/drivers/staging/iio/industrialio-trigger.c +++ b/drivers/staging/iio/industrialio-trigger.c @@ -218,14 +218,35 @@ static int iio_trigger_attach_poll_func(struct iio_tr= igger *trig, =20 /* Prevent the module being removed whilst attached to a trigger */ __module_get(pf->indio_dev->info->driver_module); + + /* Get irq number */ pf->irq =3D iio_trigger_get_irq(trig); + if (pf->irq < 0) + goto out_put_module; + + /* Request irq */ ret =3D request_threaded_irq(pf->irq, pf->h, pf->thread, pf->type, pf->name, pf); - if (trig->ops && trig->ops->set_trigger_state && notinuse) + if (ret < 0) + goto out_put_irq; + + /* Enable trigger in driver */ + if (trig->ops && trig->ops->set_trigger_state && notinuse) { ret =3D trig->ops->set_trigger_state(trig, true); + if (ret < 0) + goto out_free_irq; + } =20 return ret; + +out_free_irq: + free_irq(pf->irq, pf); +out_put_irq: + iio_trigger_put_irq(trig, pf->irq); +out_put_module: + module_put(pf->indio_dev->info->driver_module); + return ret; } =20 static int iio_trigger_dettach_poll_func(struct iio_trigger *trig, @@ -336,6 +357,8 @@ static ssize_t iio_trigger_write_current(struct device = *dev, mutex_unlock(&indio_dev->mlock); =20 trig =3D iio_trigger_find_by_name(buf, len); + if (oldtrig =3D=3D trig) + return len; =20 if (trig && indio_dev->info->validate_trigger) { ret =3D indio_dev->info->validate_trigger(indio_dev, trig); diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c index c51803fce623..4df5cff7f298 100644 --- a/drivers/tty/vt/vt.c +++ b/drivers/tty/vt/vt.c @@ -3550,9 +3550,10 @@ static int do_register_con_driver(const struct consw= *csw, int first, int last) goto err; =20 desc =3D csw->con_startup(); - - if (!desc) + if (!desc) { + retval =3D -ENODEV; goto err; + } =20 retval =3D -EINVAL; =20 diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c index 64340f3e0792..ed11901ab8ab 100644 --- a/drivers/usb/core/devio.c +++ b/drivers/usb/core/devio.c @@ -1005,10 +1005,11 @@ static int proc_getdriver(struct dev_state *ps, voi= d __user *arg) =20 static int proc_connectinfo(struct dev_state *ps, void __user *arg) { - struct usbdevfs_connectinfo ci =3D { - .devnum =3D ps->dev->devnum, - .slow =3D ps->dev->speed =3D=3D USB_SPEED_LOW - }; + struct usbdevfs_connectinfo ci; + + memset(&ci, 0, sizeof(ci)); + ci.devnum =3D ps->dev->devnum; + ci.slow =3D ps->dev->speed =3D=3D USB_SPEED_LOW; =20 if (copy_to_user(arg, &ci, sizeof(ci))) return -EFAULT; diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c index c635c4c22284..9623556a8f1c 100644 --- a/drivers/usb/gadget/f_fs.c +++ b/drivers/usb/gadget/f_fs.c @@ -2165,7 +2165,7 @@ static int ffs_func_bind(struct usb_configuration *c, const int high =3D gadget_is_dualspeed(func->gadget) && func->ffs->hs_descs_count; =20 - int ret; + int ret, i; =20 /* Make it a single chunk, less management later on */ struct { @@ -2194,8 +2194,8 @@ static int ffs_func_bind(struct usb_configuration *c, memset(data->eps, 0, sizeof data->eps); memcpy(data->raw_descs, ffs->raw_descs + 16, sizeof data->raw_descs); memset(data->inums, 0xff, sizeof data->inums); - for (ret =3D ffs->eps_count; ret; --ret) - data->eps[ret].num =3D -1; + for (i =3D 0; i < ffs->eps_count; i++) + data->eps[i].num =3D -1; =20 /* Save pointers */ func->eps =3D data->eps; diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c index 79cb0af779fa..f2b72681d0bc 100644 --- a/drivers/usb/musb/musb_host.c +++ b/drivers/usb/musb/musb_host.c @@ -571,14 +571,13 @@ musb_rx_reinit(struct musb *musb, struct musb_qh *qh,= struct musb_hw_ep *ep) musb_writew(ep->regs, MUSB_TXCSR, 0); =20 /* scrub all previous state, clearing toggle */ - } else { - csr =3D musb_readw(ep->regs, MUSB_RXCSR); - if (csr & MUSB_RXCSR_RXPKTRDY) - WARNING("rx%d, packet/%d ready?\n", ep->epnum, - musb_readw(ep->regs, MUSB_RXCOUNT)); - - musb_h_flush_rxfifo(ep, MUSB_RXCSR_CLRDATATOG); } + csr =3D musb_readw(ep->regs, MUSB_RXCSR); + if (csr & MUSB_RXCSR_RXPKTRDY) + WARNING("rx%d, packet/%d ready?\n", ep->epnum, + musb_readw(ep->regs, MUSB_RXCOUNT)); + + musb_h_flush_rxfifo(ep, MUSB_RXCSR_CLRDATATOG); =20 /* target addr and (for multipoint) hub addr/port */ if (musb->is_multipoint) { @@ -1385,9 +1384,15 @@ static void musb_bulk_rx_nak_timeout(struct musb *mu= sb, struct musb_hw_ep *ep) musb_ep_select(mbase, ep->epnum); dma =3D is_dma_capable() ? ep->rx_channel : NULL; =20 - /* clear nak timeout bit */ + /* + * Need to stop the transaction by clearing REQPKT first + * then the NAK Timeout bit ref MUSBMHDRC USB 2.0 HIGH-SPEED + * DUAL-ROLE CONTROLLER Programmer's Guide, section 9.2.2 + */ rx_csr =3D musb_readw(epio, MUSB_RXCSR); rx_csr |=3D MUSB_RXCSR_H_WZC_BITS; + rx_csr &=3D ~MUSB_RXCSR_H_REQPKT; + musb_writew(epio, MUSB_RXCSR, rx_csr); rx_csr &=3D ~MUSB_RXCSR_DATAERROR; musb_writew(epio, MUSB_RXCSR, rx_csr); =20 diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c index e8abf19129b6..d541b2540837 100644 --- a/drivers/usb/serial/option.c +++ b/drivers/usb/serial/option.c @@ -1605,7 +1605,79 @@ static const struct usb_device_id option_ids[] =3D { .driver_info =3D (kernel_ulong_t)&net_intf3_blacklist }, { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0178, 0xff, 0xff, 0xff), .driver_info =3D (kernel_ulong_t)&net_intf3_blacklist }, - { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffe9, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff42, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff43, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff44, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff45, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff46, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff47, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff48, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff49, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4a, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4b, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4c, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4d, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4e, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff4f, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff50, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff51, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff52, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff53, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff54, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff55, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff56, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff57, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff58, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff59, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5a, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5b, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5c, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5d, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5e, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff5f, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff60, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff61, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff62, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff63, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff64, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff65, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff66, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff67, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff68, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff69, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6a, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6b, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6c, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6d, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6e, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff6f, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff70, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff71, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff72, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff73, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff74, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff75, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff76, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff77, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff78, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff79, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7a, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7b, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7c, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7d, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7e, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff7f, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff80, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff81, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff82, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff83, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff84, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff85, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff86, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff87, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff88, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff89, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8a, 0xff, 0xff, 0xff) = }, { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8b, 0xff, 0xff, 0xff) = }, { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8c, 0xff, 0xff, 0xff) = }, { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff8d, 0xff, 0xff, 0xff) = }, @@ -1616,6 +1688,61 @@ static const struct usb_device_id option_ids[] =3D { { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff92, 0xff, 0xff, 0xff) = }, { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff93, 0xff, 0xff, 0xff) = }, { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff94, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff9f, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa0, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa1, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa2, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa3, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa4, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa5, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa6, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa7, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa8, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffa9, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffaa, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffab, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffac, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffae, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffaf, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb0, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb1, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb2, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb3, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb4, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb5, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb6, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb7, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb8, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffb9, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffba, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffbb, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffbc, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffbd, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffbe, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffbf, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc0, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc1, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc2, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc3, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc4, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc5, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc6, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc7, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc8, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffc9, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffca, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffcb, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffcc, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffcd, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffce, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffcf, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd0, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd1, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd2, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd3, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd4, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffd5, 0xff, 0xff, 0xff) = }, + { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffe9, 0xff, 0xff, 0xff) = }, =20 { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_CDMA_TECH, 0xf= f, 0xff, 0xff) }, { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC8710, 0xff, = 0xff, 0xff) }, diff --git a/drivers/xen/events.c b/drivers/xen/events.c index 71319739b95b..336c9c86673c 100644 --- a/drivers/xen/events.c +++ b/drivers/xen/events.c @@ -516,7 +516,8 @@ static void eoi_pirq(struct irq_data *data) if (!VALID_EVTCHN(evtchn)) return; =20 - if (unlikely(irqd_is_setaffinity_pending(data))) { + if (unlikely(irqd_is_setaffinity_pending(data)) && + likely(!irqd_irq_disabled(data))) { int masked =3D test_and_set_mask(evtchn); =20 clear_evtchn(evtchn); @@ -1446,7 +1447,8 @@ static void ack_dynirq(struct irq_data *data) if (!VALID_EVTCHN(evtchn)) return; =20 - if (unlikely(irqd_is_setaffinity_pending(data))) { + if (unlikely(irqd_is_setaffinity_pending(data)) && + likely(!irqd_irq_disabled(data))) { int masked =3D test_and_set_mask(evtchn); =20 clear_evtchn(evtchn); diff --git a/drivers/xen/xen-pciback/conf_space.c b/drivers/xen/xen-pciback= /conf_space.c index bb8cb697f65a..a86fe9c49835 100644 --- a/drivers/xen/xen-pciback/conf_space.c +++ b/drivers/xen/xen-pciback/conf_space.c @@ -183,8 +183,7 @@ int xen_pcibk_config_read(struct pci_dev *dev, int offs= et, int size, field_start =3D OFFSET(cfg_entry); field_end =3D OFFSET(cfg_entry) + field->size; =20 - if ((req_start >=3D field_start && req_start < field_end) - || (req_end > field_start && req_end <=3D field_end)) { + if (req_end > field_start && field_end > req_start) { err =3D conf_space_read(dev, cfg_entry, field_start, &tmp_val); if (err) @@ -230,8 +229,7 @@ int xen_pcibk_config_write(struct pci_dev *dev, int off= set, int size, u32 value) field_start =3D OFFSET(cfg_entry); field_end =3D OFFSET(cfg_entry) + field->size; =20 - if ((req_start >=3D field_start && req_start < field_end) - || (req_end > field_start && req_end <=3D field_end)) { + if (req_end > field_start && field_end > req_start) { tmp_val =3D 0; =20 err =3D xen_pcibk_config_read(dev, field_start, diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h index 0d9228bd5a80..c8878fdfb458 100644 --- a/fs/btrfs/ctree.h +++ b/fs/btrfs/ctree.h @@ -2749,6 +2749,7 @@ extern const struct dentry_operations btrfs_dentry_op= erations; =20 /* ioctl.c */ long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg); +long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long= arg); void btrfs_update_iflags(struct inode *inode); void btrfs_inherit_iflags(struct inode *inode, struct inode *dir); int btrfs_defrag_file(struct inode *inode, struct file *file, diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c index a1da0ab783ca..b4de5c0ecbbf 100644 --- a/fs/btrfs/file.c +++ b/fs/btrfs/file.c @@ -1895,6 +1895,6 @@ const struct file_operations btrfs_file_operations = =3D { .fallocate =3D btrfs_fallocate, .unlocked_ioctl =3D btrfs_ioctl, #ifdef CONFIG_COMPAT - .compat_ioctl =3D btrfs_ioctl, + .compat_ioctl =3D btrfs_compat_ioctl, #endif }; diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 007d487eeb6c..9a7efbec8c63 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c @@ -7475,7 +7475,7 @@ static const struct file_operations btrfs_dir_file_op= erations =3D { .readdir =3D btrfs_real_readdir, .unlocked_ioctl =3D btrfs_ioctl, #ifdef CONFIG_COMPAT - .compat_ioctl =3D btrfs_ioctl, + .compat_ioctl =3D btrfs_compat_ioctl, #endif .release =3D btrfs_release_file, .fsync =3D btrfs_sync_file, diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c index f1ca90909362..eb6a0e6f6ecd 100644 --- a/fs/btrfs/ioctl.c +++ b/fs/btrfs/ioctl.c @@ -3260,3 +3260,24 @@ long btrfs_ioctl(struct file *file, unsigned int =20 return -ENOTTY; } + +#ifdef CONFIG_COMPAT +long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long= arg) +{ + switch (cmd) { + case FS_IOC32_GETFLAGS: + cmd =3D FS_IOC_GETFLAGS; + break; + case FS_IOC32_SETFLAGS: + cmd =3D FS_IOC_SETFLAGS; + break; + case FS_IOC32_GETVERSION: + cmd =3D FS_IOC_GETVERSION; + break; + default: + return -ENOIOCTLCMD; + } + + return btrfs_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); +} +#endif diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c index d36262661245..91b51e4aa80e 100644 --- a/fs/cifs/sess.c +++ b/fs/cifs/sess.c @@ -444,19 +444,43 @@ static void build_ntlmssp_negotiate_blob(unsigned cha= r *pbuffer, sec_blob->DomainName.MaximumLength =3D 0; } =20 -/* We do not malloc the blob, it is passed in pbuffer, because its - maximum possible size is fixed and small, making this approach cleaner. - This function returns the length of the data in the blob */ -static int build_ntlmssp_auth_blob(unsigned char *pbuffer, +static int size_of_ntlmssp_blob(struct cifs_ses *ses) +{ + int sz =3D sizeof(AUTHENTICATE_MESSAGE) + ses->auth_key.len + - CIFS_SESS_KEY_SIZE + CIFS_CPHTXT_SIZE + 2; + + if (ses->domainName) + sz +=3D 2 * strnlen(ses->domainName, CIFS_MAX_DOMAINNAME_LEN); + else + sz +=3D 2; + + if (ses->user_name) + sz +=3D 2 * strnlen(ses->user_name, MAX_USERNAME_SIZE); + else + sz +=3D 2; + + return sz; +} + +static int build_ntlmssp_auth_blob(unsigned char **pbuffer, u16 *buflen, struct cifs_ses *ses, const struct nls_table *nls_cp) { int rc; - AUTHENTICATE_MESSAGE *sec_blob =3D (AUTHENTICATE_MESSAGE *)pbuffer; + AUTHENTICATE_MESSAGE *sec_blob; __u32 flags; unsigned char *tmp; =20 + rc =3D setup_ntlmv2_rsp(ses, nls_cp); + if (rc) { + cERROR(1, "Error %d during NTLMSSP authentication", rc); + *buflen =3D 0; + goto setup_ntlmv2_ret; + } + *pbuffer =3D kmalloc(size_of_ntlmssp_blob(ses), GFP_KERNEL); + sec_blob =3D (AUTHENTICATE_MESSAGE *)*pbuffer; + memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8); sec_blob->MessageType =3D NtLmAuthenticate; =20 @@ -471,7 +495,7 @@ static int build_ntlmssp_auth_blob(unsigned char *pbuff= er, flags |=3D NTLMSSP_NEGOTIATE_KEY_XCH; } =20 - tmp =3D pbuffer + sizeof(AUTHENTICATE_MESSAGE); + tmp =3D *pbuffer + sizeof(AUTHENTICATE_MESSAGE); sec_blob->NegotiateFlags =3D cpu_to_le32(flags); =20 sec_blob->LmChallengeResponse.BufferOffset =3D @@ -479,23 +503,27 @@ static int build_ntlmssp_auth_blob(unsigned char *pbu= ffer, sec_blob->LmChallengeResponse.Length =3D 0; sec_blob->LmChallengeResponse.MaximumLength =3D 0; =20 - sec_blob->NtChallengeResponse.BufferOffset =3D cpu_to_le32(tmp - pbuffer)= ; - rc =3D setup_ntlmv2_rsp(ses, nls_cp); - if (rc) { - cERROR(1, "Error %d during NTLMSSP authentication", rc); - goto setup_ntlmv2_ret; - } - memcpy(tmp, ses->auth_key.response + CIFS_SESS_KEY_SIZE, - ses->auth_key.len - CIFS_SESS_KEY_SIZE); - tmp +=3D ses->auth_key.len - CIFS_SESS_KEY_SIZE; + sec_blob->NtChallengeResponse.BufferOffset =3D + cpu_to_le32(tmp - *pbuffer); + if (ses->user_name !=3D NULL) { + memcpy(tmp, ses->auth_key.response + CIFS_SESS_KEY_SIZE, + ses->auth_key.len - CIFS_SESS_KEY_SIZE); + tmp +=3D ses->auth_key.len - CIFS_SESS_KEY_SIZE; =20 - sec_blob->NtChallengeResponse.Length =3D - cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); - sec_blob->NtChallengeResponse.MaximumLength =3D - cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); + sec_blob->NtChallengeResponse.Length =3D + cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); + sec_blob->NtChallengeResponse.MaximumLength =3D + cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); + } else { + /* + * don't send an NT Response for anonymous access + */ + sec_blob->NtChallengeResponse.Length =3D 0; + sec_blob->NtChallengeResponse.MaximumLength =3D 0; + } =20 if (ses->domainName =3D=3D NULL) { - sec_blob->DomainName.BufferOffset =3D cpu_to_le32(tmp - pbuffer); + sec_blob->DomainName.BufferOffset =3D cpu_to_le32(tmp - *pbuffer); sec_blob->DomainName.Length =3D 0; sec_blob->DomainName.MaximumLength =3D 0; tmp +=3D 2; @@ -504,14 +532,14 @@ static int build_ntlmssp_auth_blob(unsigned char *pbu= ffer, len =3D cifs_strtoUCS((__le16 *)tmp, ses->domainName, MAX_USERNAME_SIZE, nls_cp); len *=3D 2; /* unicode is 2 bytes each */ - sec_blob->DomainName.BufferOffset =3D cpu_to_le32(tmp - pbuffer); + sec_blob->DomainName.BufferOffset =3D cpu_to_le32(tmp - *pbuffer); sec_blob->DomainName.Length =3D cpu_to_le16(len); sec_blob->DomainName.MaximumLength =3D cpu_to_le16(len); tmp +=3D len; } =20 if (ses->user_name =3D=3D NULL) { - sec_blob->UserName.BufferOffset =3D cpu_to_le32(tmp - pbuffer); + sec_blob->UserName.BufferOffset =3D cpu_to_le32(tmp - *pbuffer); sec_blob->UserName.Length =3D 0; sec_blob->UserName.MaximumLength =3D 0; tmp +=3D 2; @@ -520,13 +548,13 @@ static int build_ntlmssp_auth_blob(unsigned char *pbu= ffer, len =3D cifs_strtoUCS((__le16 *)tmp, ses->user_name, MAX_USERNAME_SIZE, nls_cp); len *=3D 2; /* unicode is 2 bytes each */ - sec_blob->UserName.BufferOffset =3D cpu_to_le32(tmp - pbuffer); + sec_blob->UserName.BufferOffset =3D cpu_to_le32(tmp - *pbuffer); sec_blob->UserName.Length =3D cpu_to_le16(len); sec_blob->UserName.MaximumLength =3D cpu_to_le16(len); tmp +=3D len; } =20 - sec_blob->WorkstationName.BufferOffset =3D cpu_to_le32(tmp - pbuffer); + sec_blob->WorkstationName.BufferOffset =3D cpu_to_le32(tmp - *pbuffer); sec_blob->WorkstationName.Length =3D 0; sec_blob->WorkstationName.MaximumLength =3D 0; tmp +=3D 2; @@ -535,19 +563,19 @@ static int build_ntlmssp_auth_blob(unsigned char *pbu= ffer, (ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_EXTENDED_SEC)) && !calc_seckey(ses)) { memcpy(tmp, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE); - sec_blob->SessionKey.BufferOffset =3D cpu_to_le32(tmp - pbuffer); + sec_blob->SessionKey.BufferOffset =3D cpu_to_le32(tmp - *pbuffer); sec_blob->SessionKey.Length =3D cpu_to_le16(CIFS_CPHTXT_SIZE); sec_blob->SessionKey.MaximumLength =3D cpu_to_le16(CIFS_CPHTXT_SIZE); tmp +=3D CIFS_CPHTXT_SIZE; } else { - sec_blob->SessionKey.BufferOffset =3D cpu_to_le32(tmp - pbuffer); + sec_blob->SessionKey.BufferOffset =3D cpu_to_le32(tmp - *pbuffer); sec_blob->SessionKey.Length =3D 0; sec_blob->SessionKey.MaximumLength =3D 0; } =20 + *buflen =3D tmp - *pbuffer; setup_ntlmv2_ret: - *buflen =3D tmp - pbuffer; return rc; } =20 @@ -570,7 +598,7 @@ CIFS_SessSetup(unsigned int xid, struct cifs_ses *ses, struct key *spnego_key =3D NULL; __le32 phase =3D NtLmNegotiate; /* NTLMSSP, if needed, is multistage */ u16 blob_len; - char *ntlmsspblob =3D NULL; + unsigned char *ntlmsspblob =3D NULL; =20 if (ses =3D=3D NULL) return -EINVAL; @@ -647,23 +675,25 @@ ssetup_ntlmssp_authenticate: =20 pSMB->req.hdr.Flags2 &=3D ~SMBFLG2_UNICODE; =20 - /* no capabilities flags in old lanman negotiation */ - - pSMB->old_req.PasswordLength =3D cpu_to_le16(CIFS_AUTH_RESP_SIZE); - - /* Calculate hash with password and copy into bcc_ptr. - * Encryption Key (stored as in cryptkey) gets used if the - * security mode bit in Negottiate Protocol response states - * to use challenge/response method (i.e. Password bit is 1). - */ - - rc =3D calc_lanman_hash(ses->password, ses->server->cryptkey, - ses->server->sec_mode & SECMODE_PW_ENCRYPT ? - true : false, lnm_session_key); + if (ses->user_name !=3D NULL) { + /* no capabilities flags in old lanman negotiation */ + pSMB->old_req.PasswordLength =3D cpu_to_le16(CIFS_AUTH_RESP_SIZE); =20 + /* Calculate hash with password and copy into bcc_ptr. + * Encryption Key (stored as in cryptkey) gets used if the + * security mode bit in Negottiate Protocol response states + * to use challenge/response method (i.e. Password bit is 1). + */ + rc =3D calc_lanman_hash(ses->password, ses->server->cryptkey, + ses->server->sec_mode & SECMODE_PW_ENCRYPT ? + true : false, lnm_session_key); + + memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_AUTH_RESP_SIZE); + bcc_ptr +=3D CIFS_AUTH_RESP_SIZE; + } else { + pSMB->old_req.PasswordLength =3D 0; + } ses->flags |=3D CIFS_SES_LANMAN; - memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_AUTH_RESP_SIZE); - bcc_ptr +=3D CIFS_AUTH_RESP_SIZE; =20 /* can not sign if LANMAN negotiated so no need to calculate signing key? but what if server @@ -676,25 +706,31 @@ ssetup_ntlmssp_authenticate: #endif } else if (type =3D=3D NTLM) { pSMB->req_no_secext.Capabilities =3D cpu_to_le32(capabilities); - pSMB->req_no_secext.CaseInsensitivePasswordLength =3D - cpu_to_le16(CIFS_AUTH_RESP_SIZE); - pSMB->req_no_secext.CaseSensitivePasswordLength =3D - cpu_to_le16(CIFS_AUTH_RESP_SIZE); - - /* calculate ntlm response and session key */ - rc =3D setup_ntlm_response(ses, nls_cp); - if (rc) { - cERROR(1, "Error %d during NTLM authentication", rc); - goto ssetup_exit; - } + if (ses->user_name !=3D NULL) { + pSMB->req_no_secext.CaseInsensitivePasswordLength =3D + cpu_to_le16(CIFS_AUTH_RESP_SIZE); + pSMB->req_no_secext.CaseSensitivePasswordLength =3D + cpu_to_le16(CIFS_AUTH_RESP_SIZE); + + /* calculate ntlm response and session key */ + rc =3D setup_ntlm_response(ses, nls_cp); + if (rc) { + cERROR(1, "Error %d during NTLM authentication", + rc); + goto ssetup_exit; + } =20 - /* copy ntlm response */ - memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, - CIFS_AUTH_RESP_SIZE); - bcc_ptr +=3D CIFS_AUTH_RESP_SIZE; - memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, - CIFS_AUTH_RESP_SIZE); - bcc_ptr +=3D CIFS_AUTH_RESP_SIZE; + /* copy ntlm response */ + memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, + CIFS_AUTH_RESP_SIZE); + bcc_ptr +=3D CIFS_AUTH_RESP_SIZE; + memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, + CIFS_AUTH_RESP_SIZE); + bcc_ptr +=3D CIFS_AUTH_RESP_SIZE; + } else { + pSMB->req_no_secext.CaseInsensitivePasswordLength =3D 0; + pSMB->req_no_secext.CaseSensitivePasswordLength =3D 0; + } =20 if (ses->capabilities & CAP_UNICODE) { /* unicode strings must be word aligned */ @@ -711,21 +747,26 @@ ssetup_ntlmssp_authenticate: /* LM2 password would be here if we supported it */ pSMB->req_no_secext.CaseInsensitivePasswordLength =3D 0; =20 - /* calculate nlmv2 response and session key */ - rc =3D setup_ntlmv2_rsp(ses, nls_cp); - if (rc) { - cERROR(1, "Error %d during NTLMv2 authentication", rc); - goto ssetup_exit; - } - memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, - ses->auth_key.len - CIFS_SESS_KEY_SIZE); - bcc_ptr +=3D ses->auth_key.len - CIFS_SESS_KEY_SIZE; + if (ses->user_name !=3D NULL) { + /* calculate nlmv2 response and session key */ + rc =3D setup_ntlmv2_rsp(ses, nls_cp); + if (rc) { + cERROR(1, "Error %d during NTLMv2 authentication", rc); + goto ssetup_exit; + } =20 - /* set case sensitive password length after tilen may get - * assigned, tilen is 0 otherwise. - */ - pSMB->req_no_secext.CaseSensitivePasswordLength =3D - cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); + memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE, + ses->auth_key.len - CIFS_SESS_KEY_SIZE); + bcc_ptr +=3D ses->auth_key.len - CIFS_SESS_KEY_SIZE; + + /* set case sensitive password length after tilen may get + * assigned, tilen is 0 otherwise. + */ + pSMB->req_no_secext.CaseSensitivePasswordLength =3D + cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE); + } else { + pSMB->req_no_secext.CaseSensitivePasswordLength =3D 0; + } =20 if (ses->capabilities & CAP_UNICODE) { if (iov[0].iov_len % 2) { @@ -811,21 +852,7 @@ ssetup_ntlmssp_authenticate: cpu_to_le16(sizeof(NEGOTIATE_MESSAGE)); break; case NtLmAuthenticate: - /* - * 5 is an empirical value, large enough to hold - * authenticate message plus max 10 of av paris, - * domain, user, workstation names, flags, etc. - */ - ntlmsspblob =3D kzalloc( - 5*sizeof(struct _AUTHENTICATE_MESSAGE), - GFP_KERNEL); - if (!ntlmsspblob) { - cERROR(1, "Can't allocate NTLMSSP blob"); - rc =3D -ENOMEM; - goto ssetup_exit; - } - - rc =3D build_ntlmssp_auth_blob(ntlmsspblob, + rc =3D build_ntlmssp_auth_blob(&ntlmsspblob, &blob_len, ses, nls_cp); if (rc) goto ssetup_exit; diff --git a/fs/dcache.c b/fs/dcache.c index 46265f58b5b8..01c68ae3129c 100644 --- a/fs/dcache.c +++ b/fs/dcache.c @@ -1261,7 +1261,7 @@ struct dentry *d_alloc(struct dentry * parent, const = struct qstr *name) struct dentry *dentry =3D __d_alloc(parent->d_sb, name); if (!dentry) return NULL; - + dentry->d_flags |=3D DCACHE_RCUACCESS; spin_lock(&parent->d_lock); /* * don't need child lock because it is not subject @@ -2011,7 +2011,6 @@ static void __d_rehash(struct dentry * entry, struct = hlist_bl_head *b) { BUG_ON(!d_unhashed(entry)); hlist_bl_lock(b); - entry->d_flags |=3D DCACHE_RCUACCESS; hlist_bl_add_head_rcu(&entry->d_hash, b); hlist_bl_unlock(b); } @@ -2195,6 +2194,7 @@ static void __d_move(struct dentry * dentry, struct d= entry * target) =20 /* ... and switch the parents */ if (IS_ROOT(dentry)) { + dentry->d_flags |=3D DCACHE_RCUACCESS; dentry->d_parent =3D target->d_parent; target->d_parent =3D target; INIT_LIST_HEAD(&target->d_child); @@ -2311,6 +2311,7 @@ static void __d_materialise_dentry(struct dentry *den= try, struct dentry *anon) switch_names(dentry, anon); swap(dentry->d_name.hash, anon->d_name.hash); =20 + dentry->d_flags |=3D DCACHE_RCUACCESS; dentry->d_parent =3D (aparent =3D=3D anon) ? dentry : aparent; list_del(&dentry->d_child); if (!IS_ROOT(dentry)) diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c index 464fe1f177bb..298f5b2dad08 100644 --- a/fs/ecryptfs/file.c +++ b/fs/ecryptfs/file.c @@ -183,6 +183,19 @@ out: return rc; } =20 +static int ecryptfs_mmap(struct file *file, struct vm_area_struct *vma) +{ + struct file *lower_file =3D ecryptfs_file_to_lower(file); + /* + * Don't allow mmap on top of file systems that don't support it + * natively. If FILESYSTEM_MAX_STACK_DEPTH > 2 or ecryptfs + * allows recursive mounting, this will need to be extended. + */ + if (!lower_file->f_op->mmap) + return -ENODEV; + return generic_file_mmap(file, vma); +} + /** * ecryptfs_open * @inode: inode speciying file to open @@ -382,7 +395,7 @@ const struct file_operations ecryptfs_main_fops =3D { #ifdef CONFIG_COMPAT .compat_ioctl =3D ecryptfs_compat_ioctl, #endif - .mmap =3D generic_file_mmap, + .mmap =3D ecryptfs_mmap, .open =3D ecryptfs_open, .flush =3D ecryptfs_flush, .release =3D ecryptfs_release, diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c index 62b8ddc2c630..b53a97e43c91 100644 --- a/fs/ecryptfs/main.c +++ b/fs/ecryptfs/main.c @@ -576,6 +576,13 @@ static struct dentry *ecryptfs_mount(struct file_syste= m_type *fs_type, int flags s->s_maxbytes =3D path.dentry->d_sb->s_maxbytes; s->s_blocksize =3D path.dentry->d_sb->s_blocksize; s->s_magic =3D ECRYPTFS_SUPER_MAGIC; + s->s_stack_depth =3D path.dentry->d_sb->s_stack_depth + 1; + + rc =3D -EINVAL; + if (s->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { + pr_err("eCryptfs: maximum fs stacking depth exceeded\n"); + goto out_free; + } =20 inode =3D ecryptfs_get_inode(path.dentry->d_inode, s); rc =3D PTR_ERR(inode); diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c index a308844adbdb..476caae17161 100644 --- a/fs/ext4/ialloc.c +++ b/fs/ext4/ialloc.c @@ -999,11 +999,13 @@ struct inode *ext4_orphan_get(struct super_block *sb,= unsigned long ino) goto iget_failed; =20 /* - * If the orphans has i_nlinks > 0 then it should be able to be - * truncated, otherwise it won't be removed from the orphan list - * during processing and an infinite loop will result. + * If the orphans has i_nlinks > 0 then it should be able to + * be truncated, otherwise it won't be removed from the orphan + * list during processing and an infinite loop will result. + * Similarly, it must not be a bad inode. */ - if (inode->i_nlink && !ext4_can_truncate(inode)) + if ((inode->i_nlink && !ext4_can_truncate(inode)) || + is_bad_inode(inode)) goto bad_orphan; =20 if (NEXT_ORPHAN(inode) > max_ino) diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c index 609a951cff8e..9fc799828ea7 100644 --- a/fs/nfs/nfs4proc.c +++ b/fs/nfs/nfs4proc.c @@ -2025,12 +2025,11 @@ static void nfs4_close_prepare(struct rpc_task *tas= k, void *data) call_close |=3D is_wronly; else if (is_wronly) calldata->arg.fmode |=3D FMODE_WRITE; + if (calldata->arg.fmode !=3D (FMODE_READ|FMODE_WRITE)) + call_close |=3D is_rdwr; } else if (is_rdwr) calldata->arg.fmode |=3D FMODE_READ|FMODE_WRITE; =20 - if (calldata->arg.fmode =3D=3D 0) - call_close |=3D is_rdwr; - spin_unlock(&state->owner->so_lock); =20 if (!call_close) { diff --git a/fs/nilfs2/the_nilfs.c b/fs/nilfs2/the_nilfs.c index 1c98f5394dee..6a90908aa1fe 100644 --- a/fs/nilfs2/the_nilfs.c +++ b/fs/nilfs2/the_nilfs.c @@ -425,7 +425,7 @@ static int nilfs_valid_sb(struct nilfs_super_block *sbp= ) if (!sbp || le16_to_cpu(sbp->s_magic) !=3D NILFS_SUPER_MAGIC) return 0; bytes =3D le16_to_cpu(sbp->s_bytes); - if (bytes > BLOCK_SIZE) + if (bytes < sumoff + 4 || bytes > BLOCK_SIZE) return 0; crc =3D crc32_le(le32_to_cpu(sbp->s_crc_seed), (unsigned char *)sbp, sumoff); diff --git a/fs/proc/root.c b/fs/proc/root.c index 03102d978180..c2f39abdbb7a 100644 --- a/fs/proc/root.c +++ b/fs/proc/root.c @@ -53,6 +53,13 @@ static struct dentry *proc_mount(struct file_system_type= *fs_type, if (IS_ERR(sb)) return ERR_CAST(sb); =20 + /* + * procfs isn't actually a stacking filesystem; however, there is + * too much magic going on inside it to permit stacking things on + * top of it + */ + sb->s_stack_depth =3D FILESYSTEM_MAX_STACK_DEPTH; + if (!sb->s_root) { sb->s_flags =3D flags; err =3D proc_fill_super(sb); diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c index 6589006aa6f4..9df621795ed2 100644 --- a/fs/ubifs/file.c +++ b/fs/ubifs/file.c @@ -53,6 +53,7 @@ #include #include #include +#include =20 static int read_block(struct inode *inode, void *addr, unsigned int block, struct ubifs_data_node *dn) @@ -1421,6 +1422,26 @@ static int ubifs_set_page_dirty(struct page *page) return ret; } =20 +#ifdef CONFIG_MIGRATION +static int ubifs_migrate_page(struct address_space *mapping, + struct page *newpage, struct page *page, enum migrate_mode mode) +{ + int rc; + + rc =3D migrate_page_move_mapping(mapping, newpage, page, NULL, mode); + if (rc !=3D 0) + return rc; + + if (PagePrivate(page)) { + ClearPagePrivate(page); + SetPagePrivate(newpage); + } + + migrate_page_copy(newpage, page); + return 0; +} +#endif + static int ubifs_releasepage(struct page *page, gfp_t unused_gfp_flags) { /* @@ -1555,6 +1576,9 @@ const struct address_space_operations ubifs_file_addr= ess_operations =3D { .write_end =3D ubifs_write_end, .invalidatepage =3D ubifs_invalidatepage, .set_page_dirty =3D ubifs_set_page_dirty, +#ifdef CONFIG_MIGRATION + .migratepage =3D ubifs_migrate_page, +#endif .releasepage =3D ubifs_releasepage, }; =20 diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h index 05955cf09937..4d29153aa4ee 100644 --- a/include/linux/etherdevice.h +++ b/include/linux/etherdevice.h @@ -140,6 +140,17 @@ static inline void random_ether_addr(u8 *addr) } =20 /** + * eth_zero_addr - Assign zero address + * @addr: Pointer to a six-byte array containing the Ethernet address + * + * Assign the zero address to the given address array. + */ +static inline void eth_zero_addr(u8 *addr) +{ + memset(addr, 0x00, ETH_ALEN); +} + +/** * dev_hw_addr_random - Create random MAC and set device flag * @dev: pointer to net_device structure * @hwaddr: Pointer to a six-byte array containing the Ethernet address diff --git a/include/linux/fs.h b/include/linux/fs.h index 44e856ba8a79..a509bee30c50 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -486,6 +486,12 @@ struct iattr { */ #include =20 +/* + * Maximum number of layers of fs stack. Needs to be limited to + * prevent kernel stack overflow + */ +#define FILESYSTEM_MAX_STACK_DEPTH 2 + /**=20 * enum positive_aop_returns - aop return codes with specific semantics * @@ -1497,6 +1503,11 @@ struct super_block { int cleancache_poolid; =20 struct shrinker s_shrink; /* per-sb shrinker handle */ + + /* + * Indicates how deep in a filesystem stack this SB is + */ + int s_stack_depth; }; =20 /* superblock cache pruning functions */ diff --git a/include/linux/migrate.h b/include/linux/migrate.h index eaf867412f7a..40044bdb60ef 100644 --- a/include/linux/migrate.h +++ b/include/linux/migrate.h @@ -43,6 +43,9 @@ extern int migrate_vmas(struct mm_struct *mm, extern void migrate_page_copy(struct page *newpage, struct page *page); extern int migrate_huge_page_move_mapping(struct address_space *mapping, struct page *newpage, struct page *page); +extern int migrate_page_move_mapping(struct address_space *mapping, + struct page *newpage, struct page *page, + struct buffer_head *head, enum migrate_mode mode); #else #define PAGE_MIGRATION 0 =20 diff --git a/include/linux/sunrpc/msg_prot.h b/include/linux/sunrpc/msg_pro= t.h index c68a147939a6..abf2486f40f8 100644 --- a/include/linux/sunrpc/msg_prot.h +++ b/include/linux/sunrpc/msg_prot.h @@ -149,9 +149,9 @@ typedef __be32 rpc_fraghdr; =20 /* * Note that RFC 1833 does not put any size restrictions on the - * netid string, but all currently defined netid's fit in 4 bytes. + * netid string, but all currently defined netid's fit in 5 bytes. */ -#define RPCBIND_MAXNETIDLEN (4u) +#define RPCBIND_MAXNETIDLEN (5u) =20 /* * Universal addresses are introduced in RFC 1833 and further spelled diff --git a/kernel/auditsc.c b/kernel/auditsc.c index d1d2843d464f..018aed14ce78 100644 --- a/kernel/auditsc.c +++ b/kernel/auditsc.c @@ -67,6 +67,7 @@ #include #include #include +#include =20 #include "audit.h" =20 @@ -77,7 +78,8 @@ /* Indicates that audit should log the full pathname. */ #define AUDIT_NAME_FULL -1 =20 -/* no execve audit message should be longer than this (userspace limits) *= / +/* no execve audit message should be longer than this (userspace limits), + * see the note near the top of audit_log_execve_info() about this value *= / #define MAX_EXECVE_AUDIT_LEN 7500 =20 /* number of audit rules */ @@ -1026,189 +1028,184 @@ static int audit_log_pid_context(struct audit_con= text *context, pid_t pid, return rc; } =20 -/* - * to_send and len_sent accounting are very loose estimates. We aren't - * really worried about a hard cap to MAX_EXECVE_AUDIT_LEN so much as bein= g - * within about 500 bytes (next page boundary) - * - * why snprintf? an int is up to 12 digits long. if we just assumed when - * logging that a[%d]=3D was going to be 16 characters long we would be wa= sting - * space in every audit message. In one 7500 byte message we can log up t= o - * about 1000 min size arguments. That comes down to about 50% waste of s= pace - * if we didn't do the snprintf to find out how long arg_num_len was. - */ -static int audit_log_single_execve_arg(struct audit_context *context, - struct audit_buffer **ab, - int arg_num, - size_t *len_sent, - const char __user *p, - char *buf) -{ - char arg_num_len_buf[12]; - const char __user *tmp_p =3D p; - /* how many digits are in arg_num? 5 is the length of ' a=3D""' */ - size_t arg_num_len =3D snprintf(arg_num_len_buf, 12, "%d", arg_num) + 5; - size_t len, len_left, to_send; - size_t max_execve_audit_len =3D MAX_EXECVE_AUDIT_LEN; - unsigned int i, has_cntl =3D 0, too_long =3D 0; - int ret; - - /* strnlen_user includes the null we don't want to send */ - len_left =3D len =3D strnlen_user(p, MAX_ARG_STRLEN) - 1; - - /* - * We just created this mm, if we can't find the strings - * we just copied into it something is _very_ wrong. Similar - * for strings that are too long, we should not have created - * any. - */ - if (unlikely((len =3D=3D -1) || len > MAX_ARG_STRLEN - 1)) { - WARN_ON(1); - send_sig(SIGKILL, current, 0); - return -1; - } - - /* walk the whole argument looking for non-ascii chars */ - do { - if (len_left > MAX_EXECVE_AUDIT_LEN) - to_send =3D MAX_EXECVE_AUDIT_LEN; - else - to_send =3D len_left; - ret =3D copy_from_user(buf, tmp_p, to_send); - /* - * There is no reason for this copy to be short. We just - * copied them here, and the mm hasn't been exposed to user- - * space yet. - */ - if (ret) { - WARN_ON(1); - send_sig(SIGKILL, current, 0); - return -1; - } - buf[to_send] =3D '\0'; - has_cntl =3D audit_string_contains_control(buf, to_send); - if (has_cntl) { - /* - * hex messages get logged as 2 bytes, so we can only - * send half as much in each message - */ - max_execve_audit_len =3D MAX_EXECVE_AUDIT_LEN / 2; - break; - } - len_left -=3D to_send; - tmp_p +=3D to_send; - } while (len_left > 0); - - len_left =3D len; - - if (len > max_execve_audit_len) - too_long =3D 1; - - /* rewalk the argument actually logging the message */ - for (i =3D 0; len_left > 0; i++) { - int room_left; - - if (len_left > max_execve_audit_len) - to_send =3D max_execve_audit_len; - else - to_send =3D len_left; - - /* do we have space left to send this argument in this ab? */ - room_left =3D MAX_EXECVE_AUDIT_LEN - arg_num_len - *len_sent; - if (has_cntl) - room_left -=3D (to_send * 2); - else - room_left -=3D to_send; - if (room_left < 0) { - *len_sent =3D 0; - audit_log_end(*ab); - *ab =3D audit_log_start(context, GFP_KERNEL, AUDIT_EXECVE); - if (!*ab) - return 0; - } - - /* - * first record needs to say how long the original string was - * so we can be sure nothing was lost. - */ - if ((i =3D=3D 0) && (too_long)) - audit_log_format(*ab, " a%d_len=3D%zu", arg_num, - has_cntl ? 2*len : len); - - /* - * normally arguments are small enough to fit and we already - * filled buf above when we checked for control characters - * so don't bother with another copy_from_user - */ - if (len >=3D max_execve_audit_len) - ret =3D copy_from_user(buf, p, to_send); - else - ret =3D 0; - if (ret) { - WARN_ON(1); - send_sig(SIGKILL, current, 0); - return -1; - } - buf[to_send] =3D '\0'; - - /* actually log it */ - audit_log_format(*ab, " a%d", arg_num); - if (too_long) - audit_log_format(*ab, "[%d]", i); - audit_log_format(*ab, "=3D"); - if (has_cntl) - audit_log_n_hex(*ab, buf, to_send); - else - audit_log_string(*ab, buf); - - p +=3D to_send; - len_left -=3D to_send; - *len_sent +=3D arg_num_len; - if (has_cntl) - *len_sent +=3D to_send * 2; - else - *len_sent +=3D to_send; - } - /* include the null we didn't log */ - return len + 1; -} - static void audit_log_execve_info(struct audit_context *context, struct audit_buffer **ab, struct audit_aux_data_execve *axi) { - int i; - size_t len, len_sent =3D 0; - const char __user *p; + long len_max; + long len_rem; + long len_full; + long len_buf; + long len_abuf; + long len_tmp; + bool require_data; + bool encode; + unsigned int iter; + unsigned int arg; + char *buf_head; char *buf; + const char __user *p; + + /* NOTE: this buffer needs to be large enough to hold all the non-arg + * data we put in the audit record for this argument (see the + * code below) ... at this point in time 96 is plenty */ + char abuf[96]; =20 if (axi->mm !=3D current->mm) return; /* execve failed, no additional info */ =20 p =3D (const char __user *)axi->mm->arg_start; =20 - audit_log_format(*ab, "argc=3D%d", axi->argc); + /* NOTE: we set MAX_EXECVE_AUDIT_LEN to a rather arbitrary limit, the + * current value of 7500 is not as important as the fact that it + * is less than 8k, a setting of 7500 gives us plenty of wiggle + * room if we go over a little bit in the logging below */ + WARN_ON_ONCE(MAX_EXECVE_AUDIT_LEN > 7500); + len_max =3D MAX_EXECVE_AUDIT_LEN; =20 - /* - * we need some kernel buffer to hold the userspace args. Just - * allocate one big one rather than allocating one of the right size - * for every single argument inside audit_log_single_execve_arg() - * should be <8k allocation so should be pretty safe. - */ - buf =3D kmalloc(MAX_EXECVE_AUDIT_LEN + 1, GFP_KERNEL); - if (!buf) { + /* scratch buffer to hold the userspace args */ + buf_head =3D kmalloc(MAX_EXECVE_AUDIT_LEN + 1, GFP_KERNEL); + if (!buf_head) { audit_panic("out of memory for argv string\n"); return; } + buf =3D buf_head; =20 - for (i =3D 0; i < axi->argc; i++) { - len =3D audit_log_single_execve_arg(context, ab, i, - &len_sent, p, buf); - if (len <=3D 0) - break; - p +=3D len; - } - kfree(buf); + audit_log_format(*ab, "argc=3D%d", axi->argc); + + len_rem =3D len_max; + len_buf =3D 0; + len_full =3D 0; + require_data =3D true; + encode =3D false; + iter =3D 0; + arg =3D 0; + do { + /* NOTE: we don't ever want to trust this value for anything + * serious, but the audit record format insists we + * provide an argument length for really long arguments, + * e.g. > MAX_EXECVE_AUDIT_LEN, so we have no choice but + * to use strncpy_from_user() to obtain this value for + * recording in the log, although we don't use it + * anywhere here to avoid a double-fetch problem */ + if (len_full =3D=3D 0) + len_full =3D strnlen_user(p, MAX_ARG_STRLEN) - 1; + + /* read more data from userspace */ + if (require_data) { + /* can we make more room in the buffer? */ + if (buf !=3D buf_head) { + memmove(buf_head, buf, len_buf); + buf =3D buf_head; + } + + /* fetch as much as we can of the argument */ + len_tmp =3D strncpy_from_user(&buf_head[len_buf], p, + len_max - len_buf); + if (len_tmp =3D=3D -EFAULT) { + /* unable to copy from userspace */ + send_sig(SIGKILL, current, 0); + goto out; + } else if (len_tmp =3D=3D (len_max - len_buf)) { + /* buffer is not large enough */ + require_data =3D true; + /* NOTE: if we are going to span multiple + * buffers force the encoding so we stand + * a chance at a sane len_full value and + * consistent record encoding */ + encode =3D true; + len_full =3D len_full * 2; + p +=3D len_tmp; + } else { + require_data =3D false; + if (!encode) + encode =3D audit_string_contains_control( + buf, len_tmp); + /* try to use a trusted value for len_full */ + if (len_full < len_max) + len_full =3D (encode ? + len_tmp * 2 : len_tmp); + p +=3D len_tmp + 1; + } + len_buf +=3D len_tmp; + buf_head[len_buf] =3D '\0'; + + /* length of the buffer in the audit record? */ + len_abuf =3D (encode ? len_buf * 2 : len_buf + 2); + } + + /* write as much as we can to the audit log */ + if (len_buf > 0) { + /* NOTE: some magic numbers here - basically if we + * can't fit a reasonable amount of data into the + * existing audit buffer, flush it and start with + * a new buffer */ + if ((sizeof(abuf) + 8) > len_rem) { + len_rem =3D len_max; + audit_log_end(*ab); + *ab =3D audit_log_start(context, + GFP_KERNEL, AUDIT_EXECVE); + if (!*ab) + goto out; + } + + /* create the non-arg portion of the arg record */ + len_tmp =3D 0; + if (require_data || (iter > 0) || + ((len_abuf + sizeof(abuf)) > len_rem)) { + if (iter =3D=3D 0) { + len_tmp +=3D snprintf(&abuf[len_tmp], + sizeof(abuf) - len_tmp, + " a%d_len=3D%lu", + arg, len_full); + } + len_tmp +=3D snprintf(&abuf[len_tmp], + sizeof(abuf) - len_tmp, + " a%d[%d]=3D", arg, iter++); + } else + len_tmp +=3D snprintf(&abuf[len_tmp], + sizeof(abuf) - len_tmp, + " a%d=3D", arg); + WARN_ON(len_tmp >=3D sizeof(abuf)); + abuf[sizeof(abuf) - 1] =3D '\0'; + + /* log the arg in the audit record */ + audit_log_format(*ab, "%s", abuf); + len_rem -=3D len_tmp; + len_tmp =3D len_buf; + if (encode) { + if (len_abuf > len_rem) + len_tmp =3D len_rem / 2; /* encoding */ + audit_log_n_hex(*ab, buf, len_tmp); + len_rem -=3D len_tmp * 2; + len_abuf -=3D len_tmp * 2; + } else { + if (len_abuf > len_rem) + len_tmp =3D len_rem - 2; /* quotes */ + audit_log_n_string(*ab, buf, len_tmp); + len_rem -=3D len_tmp + 2; + /* don't subtract the "2" because we still need + * to add quotes to the remaining string */ + len_abuf -=3D len_tmp; + } + len_buf -=3D len_tmp; + buf +=3D len_tmp; + } + + /* ready to move to the next argument? */ + if ((len_buf =3D=3D 0) && !require_data) { + arg++; + iter =3D 0; + len_full =3D 0; + require_data =3D true; + encode =3D false; + } + } while (arg < axi->argc); + + /* NOTE: the caller handles the final audit_log_end() call */ + +out: + kfree(buf_head); } =20 static void audit_log_cap(struct audit_buffer *ab, char *prefix, kernel_ca= p_t *cap) diff --git a/kernel/exit.c b/kernel/exit.c index fde15f96b158..ee5a8786c3d2 100644 --- a/kernel/exit.c +++ b/kernel/exit.c @@ -1138,17 +1138,28 @@ static int eligible_pid(struct wait_opts *wo, struc= t task_struct *p) task_pid_type(p, wo->wo_type) =3D=3D wo->wo_pid; } =20 -static int eligible_child(struct wait_opts *wo, struct task_struct *p) +static int +eligible_child(struct wait_opts *wo, bool ptrace, struct task_struct *p) { if (!eligible_pid(wo, p)) return 0; - /* Wait for all children (clone and not) if __WALL is set; - * otherwise, wait for clone children *only* if __WCLONE is - * set; otherwise, wait for non-clone children *only*. (Note: - * A "clone" child here is one that reports to its parent - * using a signal other than SIGCHLD.) */ - if (((p->exit_signal !=3D SIGCHLD) ^ !!(wo->wo_flags & __WCLONE)) - && !(wo->wo_flags & __WALL)) + + /* + * Wait for all children (clone and not) if __WALL is set or + * if it is traced by us. + */ + if (ptrace || (wo->wo_flags & __WALL)) + return 1; + + /* + * Otherwise, wait for clone children *only* if __WCLONE is set; + * otherwise, wait for non-clone children *only*. + * + * Note: a "clone" child here is one that reports to its parent + * using a signal other than SIGCHLD, or a non-leader thread which + * we can only see if it is traced by us. + */ + if ((p->exit_signal !=3D SIGCHLD) ^ !!(wo->wo_flags & __WCLONE)) return 0; =20 return 1; @@ -1525,7 +1536,7 @@ static int wait_task_continued(struct wait_opts *wo, = struct task_struct *p) static int wait_consider_task(struct wait_opts *wo, int ptrace, struct task_struct *p) { - int ret =3D eligible_child(wo, p); + int ret =3D eligible_child(wo, ptrace, p); if (!ret) return ret; =20 diff --git a/kernel/sched.c b/kernel/sched.c index 33ac1e348542..fb554299ca44 100644 --- a/kernel/sched.c +++ b/kernel/sched.c @@ -3507,10 +3507,13 @@ static long calc_load_fold_active(struct rq *this_r= q) static unsigned long calc_load(unsigned long load, unsigned long exp, unsigned long active) { - load *=3D exp; - load +=3D active * (FIXED_1 - exp); - load +=3D 1UL << (FSHIFT - 1); - return load >> FSHIFT; + unsigned long newload; + + newload =3D load * exp + active * (FIXED_1 - exp); + if (active >=3D load) + newload +=3D FIXED_1-1; + + return newload / FIXED_1; } =20 #ifdef CONFIG_NO_HZ @@ -6257,14 +6260,16 @@ void show_state_filter(unsigned long state_filter) /* * reset the NMI-timeout, listing all files on a slow * console might take a lot of time: + * Also, reset softlockup watchdogs on all CPUs, because + * another CPU might be blocked waiting for us to process + * an IPI. */ touch_nmi_watchdog(); + touch_all_softlockup_watchdogs(); if (!state_filter || (p->state & state_filter)) sched_show_task(p); } while_each_thread(g, p); =20 - touch_all_softlockup_watchdogs(); - #ifdef CONFIG_SCHED_DEBUG sysrq_sched_debug_show(); #endif diff --git a/mm/migrate.c b/mm/migrate.c index 7d26ea580662..f2d86f2bd203 100644 --- a/mm/migrate.c +++ b/mm/migrate.c @@ -294,7 +294,7 @@ static inline bool buffer_migrate_lock_buffers(struct b= uffer_head *head, * 2 for pages with a mapping * 3 for pages with a mapping and PagePrivate/PagePrivate2 set. */ -static int migrate_page_move_mapping(struct address_space *mapping, +int migrate_page_move_mapping(struct address_space *mapping, struct page *newpage, struct page *page, struct buffer_head *head, enum migrate_mode mode) { @@ -377,6 +377,7 @@ static int migrate_page_move_mapping(struct address_spa= ce *mapping, =20 return 0; } +EXPORT_SYMBOL(migrate_page_move_mapping); =20 /* * The expected number of remaining references is the same as that @@ -476,6 +477,7 @@ void migrate_page_copy(struct page *newpage, struct pag= e *page) if (PageWriteback(newpage)) end_page_writeback(newpage); } +EXPORT_SYMBOL(migrate_page_copy); =20 /************************************************************ * Migration functions diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translatio= n-table.c index 088af45f45c8..d2d85a6cabcc 100644 --- a/net/batman-adv/translation-table.c +++ b/net/batman-adv/translation-table.c @@ -952,6 +952,29 @@ uint16_t tt_local_crc(struct bat_priv *bat_priv) return total; } =20 +/** + * batadv_tt_req_node_release - free tt_req node entry + * @ref: kref pointer of the tt req_node entry + */ +static void batadv_tt_req_node_release(struct kref *ref) +{ + struct tt_req_node *tt_req_node; + + tt_req_node =3D container_of(ref, struct tt_req_node, refcount); + + kfree(tt_req_node); +} + +/** + * batadv_tt_req_node_put - decrement the tt_req_node refcounter and + * possibly release it + * @tt_req_node: tt_req_node to be free'd + */ +static void batadv_tt_req_node_put(struct tt_req_node *tt_req_node) +{ + kref_put(&tt_req_node->refcount, batadv_tt_req_node_release); +} + static void tt_req_list_free(struct bat_priv *bat_priv) { struct tt_req_node *node, *safe; @@ -960,7 +983,7 @@ static void tt_req_list_free(struct bat_priv *bat_priv) =20 list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) { list_del(&node->list); - kfree(node); + batadv_tt_req_node_put(node); } =20 spin_unlock_bh(&bat_priv->tt_req_list_lock); @@ -995,7 +1018,7 @@ static void tt_req_purge(struct bat_priv *bat_priv) if (is_out_of_time(node->issued_at, TT_REQUEST_TIMEOUT * 1000)) { list_del(&node->list); - kfree(node); + batadv_tt_req_node_put(node); } } spin_unlock_bh(&bat_priv->tt_req_list_lock); @@ -1020,9 +1043,11 @@ static struct tt_req_node *new_tt_req_node(struct ba= t_priv *bat_priv, if (!tt_req_node) goto unlock; =20 + kref_init(&tt_req_node->refcount); memcpy(tt_req_node->addr, orig_node->orig, ETH_ALEN); tt_req_node->issued_at =3D jiffies; =20 + kref_get(&tt_req_node->refcount); list_add(&tt_req_node->list, &bat_priv->tt_req_list); unlock: spin_unlock_bh(&bat_priv->tt_req_list_lock); @@ -1174,12 +1199,19 @@ out: hardif_free_ref(primary_if); if (ret) kfree_skb(skb); + if (ret && tt_req_node) { spin_lock_bh(&bat_priv->tt_req_list_lock); - list_del(&tt_req_node->list); + if (!list_empty(&tt_req_node->list)) { + list_del(&tt_req_node->list); + batadv_tt_req_node_put(tt_req_node); + } spin_unlock_bh(&bat_priv->tt_req_list_lock); - kfree(tt_req_node); } + + if (tt_req_node) + batadv_tt_req_node_put(tt_req_node); + return ret; } =20 @@ -1552,7 +1584,7 @@ void handle_tt_response(struct bat_priv *bat_priv, if (!compare_eth(node->addr, tt_response->src)) continue; list_del(&node->list); - kfree(node); + batadv_tt_req_node_put(node); } spin_unlock_bh(&bat_priv->tt_req_list_lock); =20 diff --git a/net/batman-adv/types.h b/net/batman-adv/types.h index ab8d0fe6df5a..1be63ab0ad2b 100644 --- a/net/batman-adv/types.h +++ b/net/batman-adv/types.h @@ -250,6 +250,7 @@ struct tt_change_node { struct tt_req_node { uint8_t addr[ETH_ALEN]; unsigned long issued_at; + struct kref refcount; struct list_head list; }; =20 diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c index 039e40f33860..eb7a8fba6f4f 100644 --- a/net/ipv4/tcp_input.c +++ b/net/ipv4/tcp_input.c @@ -87,7 +87,7 @@ int sysctl_tcp_adv_win_scale __read_mostly =3D 1; EXPORT_SYMBOL(sysctl_tcp_adv_win_scale); =20 /* rfc5961 challenge ack rate limiting */ -int sysctl_tcp_challenge_ack_limit =3D 100; +int sysctl_tcp_challenge_ack_limit =3D 1000; =20 int sysctl_tcp_stdurg __read_mostly; int sysctl_tcp_rfc1337 __read_mostly; @@ -3715,13 +3715,20 @@ static void tcp_send_challenge_ack(struct sock *sk) /* unprotected vars, we dont care of overwrites */ static u32 challenge_timestamp; static unsigned int challenge_count; - u32 now =3D jiffies / HZ; + u32 count, now =3D jiffies / HZ; =20 if (now !=3D challenge_timestamp) { + u32 half =3D (sysctl_tcp_challenge_ack_limit + 1) >> 1; + challenge_timestamp =3D now; - challenge_count =3D 0; - } - if (++challenge_count <=3D sysctl_tcp_challenge_ack_limit) { + ACCESS_ONCE(challenge_count) =3D + half + (u32)( + ((u64) random32() * sysctl_tcp_challenge_ack_limit) + >> 32); + } + count =3D ACCESS_ONCE(challenge_count); + if (count > 0) { + ACCESS_ONCE(challenge_count) =3D count - 1; NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPCHALLENGEACK); tcp_send_ack(sk); } diff --git a/net/rds/recv.c b/net/rds/recv.c index 96a1239c05c2..9e28c993584a 100644 --- a/net/rds/recv.c +++ b/net/rds/recv.c @@ -544,5 +544,7 @@ void rds_inc_info_copy(struct rds_incoming *inc, minfo.fport =3D inc->i_hdr.h_dport; } =20 + minfo.flags =3D 0; + rds_info_copy(iter, &minfo, sizeof(minfo)); } diff --git a/net/tipc/node.c b/net/tipc/node.c index 27b4bb0cca6c..915bc6b0a0a1 100644 --- a/net/tipc/node.c +++ b/net/tipc/node.c @@ -485,7 +485,8 @@ struct sk_buff *tipc_node_get_links(const void *req_tlv= _area, int req_tlv_space) continue; link_info.dest =3D htonl(n_ptr->addr); link_info.up =3D htonl(tipc_link_is_up(n_ptr->links[i])); - strcpy(link_info.str, n_ptr->links[i]->name); + strncpy(link_info.str, n_ptr->links[i]->name, + sizeof(link_info.str)); tipc_cfg_append_tlv(buf, TIPC_TLV_LINK_INFO, &link_info, sizeof(link_info)); } diff --git a/security/keys/key.c b/security/keys/key.c index 4414abddcb5b..d3b2f6ec137a 100644 --- a/security/keys/key.c +++ b/security/keys/key.c @@ -572,7 +572,7 @@ int key_reject_and_link(struct key *key, =20 mutex_unlock(&key_construction_mutex); =20 - if (keyring) + if (keyring && link_ret =3D=3D 0) __key_link_end(keyring, key->type, prealloc); =20 /* wake up anyone waiting for a key to be constructed */ diff --git a/sound/core/timer.c b/sound/core/timer.c index bc83a9653c76..bce3fe051fbf 100644 --- a/sound/core/timer.c +++ b/sound/core/timer.c @@ -1213,6 +1213,7 @@ static void snd_timer_user_ccallback(struct snd_timer= _instance *timeri, tu->tstamp =3D *tstamp; if ((tu->filter & (1 << event)) =3D=3D 0 || !tu->tread) return; + memset(&r1, 0, sizeof(r1)); r1.event =3D event; r1.tstamp =3D *tstamp; r1.val =3D resolution; @@ -1247,6 +1248,7 @@ static void snd_timer_user_tinterrupt(struct snd_time= r_instance *timeri, } if ((tu->filter & (1 << SNDRV_TIMER_EVENT_RESOLUTION)) && tu->last_resolution !=3D resolution) { + memset(&r1, 0, sizeof(r1)); r1.event =3D SNDRV_TIMER_EVENT_RESOLUTION; r1.tstamp =3D tstamp; r1.val =3D resolution; @@ -1712,6 +1714,7 @@ static int snd_timer_user_params(struct file *file, if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) { if (tu->tread) { struct snd_timer_tread tread; + memset(&tread, 0, sizeof(tread)); tread.event =3D SNDRV_TIMER_EVENT_EARLY; tread.tstamp.tv_sec =3D 0; tread.tstamp.tv_nsec =3D 0; @@ -1923,6 +1926,7 @@ static ssize_t snd_timer_user_read(struct file *file,= char __user *buffer, =20 qhead =3D tu->qhead++; tu->qhead %=3D tu->queue_size; + tu->qused--; spin_unlock_irq(&tu->qlock); =20 if (tu->tread) { @@ -1936,7 +1940,6 @@ static ssize_t snd_timer_user_read(struct file *file,= char __user *buffer, } =20 spin_lock_irq(&tu->qlock); - tu->qused--; if (err < 0) goto _error; result +=3D unit; diff --git a/sound/drivers/dummy.c b/sound/drivers/dummy.c index 3662c6267f55..51f1cc2238fd 100644 --- a/sound/drivers/dummy.c +++ b/sound/drivers/dummy.c @@ -419,6 +419,7 @@ static int dummy_hrtimer_stop(struct snd_pcm_substream = *substream) =20 static inline void dummy_hrtimer_sync(struct dummy_hrtimer_pcm *dpcm) { + hrtimer_cancel(&dpcm->timer); tasklet_kill(&dpcm->tasklet); } =20 diff --git a/sound/pci/au88x0/au88x0_core.c b/sound/pci/au88x0/au88x0_core.= c index 489150380eac..dd6e74fd3d28 100644 --- a/sound/pci/au88x0/au88x0_core.c +++ b/sound/pci/au88x0/au88x0_core.c @@ -1444,9 +1444,8 @@ static int vortex_wtdma_bufshift(vortex_t * vortex, i= nt wtdma) int page, p, pp, delta, i; =20 page =3D - (hwread(vortex->mmio, VORTEX_WTDMA_STAT + (wtdma << 2)) & - WT_SUBBUF_MASK) - >> WT_SUBBUF_SHIFT; + (hwread(vortex->mmio, VORTEX_WTDMA_STAT + (wtdma << 2)) + >> WT_SUBBUF_SHIFT) & WT_SUBBUF_MASK; if (dma->nr_periods >=3D 4) delta =3D (page - dma->period_real) & 3; else { diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudi= o.c index 9fd694c61866..69e78cec9dbc 100644 --- a/sound/pci/echoaudio/echoaudio.c +++ b/sound/pci/echoaudio/echoaudio.c @@ -2251,11 +2251,11 @@ static int snd_echo_resume(struct pci_dev *pci) =20 DE_INIT(("resume start\n")); pci_restore_state(pci); - commpage_bak =3D kmalloc(sizeof(struct echoaudio), GFP_KERNEL); + commpage_bak =3D kmalloc(sizeof(*commpage), GFP_KERNEL); if (commpage_bak =3D=3D NULL) return -ENOMEM; commpage =3D chip->comm_page; - memcpy(commpage_bak, commpage, sizeof(struct comm_page)); + memcpy(commpage_bak, commpage, sizeof(*commpage)); =20 err =3D init_hw(chip, chip->pci->device, chip->pci->subsystem_device); if (err < 0) { diff --git a/virt/kvm/assigned-dev.c b/virt/kvm/assigned-dev.c index 758e3b36d4cf..e9f3b3ab4803 100644 --- a/virt/kvm/assigned-dev.c +++ b/virt/kvm/assigned-dev.c @@ -826,7 +826,7 @@ long kvm_vm_ioctl_assigned_device(struct kvm *kvm, unsi= gned ioctl, if (copy_from_user(&routing, argp, sizeof(routing))) goto out; r =3D -EINVAL; - if (routing.nr >=3D KVM_MAX_IRQ_ROUTES) + if (routing.nr > KVM_MAX_IRQ_ROUTES) goto out; if (routing.flags) goto out; =0D --=-+u+uwxhMrV3mqPCcE1z/-- --=-DMVPRH0a4rpUsmcBiTiG Content-Type: application/pgp-signature; name="signature.asc" Content-Description: This is a digitally signed message part -----BEGIN PGP SIGNATURE----- iQIcBAABCgAGBQJXvKGjAAoJEOe/yOyVhhEJCK4QAKkiM4PviLXrq64XnkHNGGwF xvDIrtR5hbbmiW/m2YwazMYB7i3mTPHE/LtUtB+ySRRrpLWKyimyJzk8kFw/y7G6 Ei6GKsFCO/cGDmqFHEZbMpFbgpkVVyWC/7N1N2hXIb6q20eNi687VH4LU5ZLrS9Q hX9WsGW3qAhViQKTK0zmrf/5I59qFnyhv++aM6CSberwrj8WBaAgKAbiYvn+sNoU mvlpSLv37YDKuPKI+ZiM8/6oPOrBPBXrddJxSE7vXyo2cYyp234FUP+taccdaB4h /LphSn9txAVBoXN+a7iLf9EVHLnumtdfX6gTzx6tDNjzDNMwI6JGsCjNHpWBY/JM e44nfbgW0UW3dsgjImIy/jwQgzb0mzdSdix/jgOBZxZDDTvYq1NqVV9Oh/RhTCNb /rRb9G8L/5TyBcaM1xeWZ+9cHCsm3MV/7ECW6UhlG7X0Amz++MgyyZCpV1JlHAt2 6TyPfnXC+ox/lOdVxvRr7tMsMyWhI6IAsWKYsF5RaZSzuOOWpOIfakrnYE9pq/9h fVyZMv8fCVw53b0UhfDiD8pZVYSsbQyAK3g05kdSiPiuIp2Bobx12ZoAzEF6c3ml YYUWdv1wwKcsb+kDYa05tM5ihtWZy5reR0CZtyjzYHk8rcaYtGxLJlazt3N87uUU nrflpWng2d3tIov3M/cN =y05J -----END PGP SIGNATURE----- --=-DMVPRH0a4rpUsmcBiTiG--