From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alexey Brodkin Subject: Re: [PATCH] ARC: Improve cmpxchng syscall implementation Date: Wed, 4 Apr 2018 08:56:13 +0000 Message-ID: <1522832172.4851.7.camel@synopsys.com> References: <20180319110002.27419-1-abrodkin@synopsys.com> <5bc39838-b1c5-ef65-f97d-8777ed33bda0@synopsys.com> <1521633274.9805.30.camel@synopsys.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1521633274.9805.30.camel@synopsys.com> Content-Language: en-US Content-ID: Sender: linux-kernel-owner@vger.kernel.org To: "peterz@infradead.org" , Vineet Gupta Cc: "wbx@uclibc-ng.org" , "linux-kernel@vger.kernel.org" , "linux-arch@vger.kernel.org" , "jcmvbkbc@gmail.com" , "linux-snps-arc@lists.infradead.org" List-Id: linux-arch.vger.kernel.org SGkgVmluZWV0LCBQZXRlciwNCg0KT24gV2VkLCAyMDE4LTAzLTIxIGF0IDE0OjU0ICswMzAwLCBB bGV4ZXkgQnJvZGtpbiB3cm90ZToNCj4gSGkgVmluZWV0LA0KPiANCj4gT24gTW9uLCAyMDE4LTAz LTE5IGF0IDExOjI5IC0wNzAwLCBWaW5lZXQgR3VwdGEgd3JvdGU6DQo+ID4gT24gMDMvMTkvMjAx OCAwNDowMCBBTSwgQWxleGV5IEJyb2RraW4gd3JvdGU6DQo+ID4gPiBhcmNfdXNyX2NtcHhjaGcg c3lzY2FsbCBpcyBzdXBwb3NlZCB0byBiZSB1c2VkIG9uIHBsYXRmb3Jtcw0KPiA+ID4gdGhhdCBs YWNrIHN1cHBvcnQgb2YgTG9hZC1Mb2NrZWQvU3RvcmUtQ29uZGl0aW9uYWwgaW5zdHJ1Y3Rpb25z DQo+ID4gPiBpbiBoYXJkd2FyZS4gQW5kIGluIHRoYXQgY2FzZSB3ZSBtaW1pYyBtaXNzaW5nIGhh cmR3YXJlIGZlYXR1cmVzDQo+ID4gPiB3aXRoIGhlbHAgb2Yga2VybmVsJ3Mgc3ljYWxsIHRoYXQg ImF0b21pY2FsbHkiIGNoZWNrcyBjdXJyZW50DQo+ID4gPiB2YWx1ZSBpbiBtZW1vcnkgYW5kIHRo ZW4gaWYgaXQgbWF0Y2hlcyBjYWxsZXIgZXhwZWN0YXRpb24gbmV3DQo+ID4gPiB2YWx1ZSBpcyB3 cml0dGVuIHRvIHRoYXQgc2FtZSBsb2NhdGlvbi4NCj4gPiA+IA0KPiA+IA0KPiA+IC4uLg0KPiA+ IC4uLg0KPiA+IA0KPiA+ID4gDQo+ID4gPiAyLiBXaGF0J3Mgd29yc2UgaWYgd2UncmUgZGVhbGlu ZyB3aXRoIGRhdGEgZnJvbSBub3QgeWV0IGFsbG9jYXRlZA0KPiA+ID4gICAgIHBhZ2UgKHRoaW5r IG9mIHByZS1jb3B5LW9uLXdyaXRlIHN0YXRlKSB3ZSdsbCBzdWNjZXNzZnVsbHkNCj4gPiA+ICAg ICByZWFkIGRhdGEgYnV0IG9uIHdyaXRlIHdlJ2xsIHNpbGVudGx5IHJldHVybiB0byB1c2VyLXNw YWNlDQo+ID4gPiAgICAgd2l0aCBjb3JyZWN0IHJlc3VsdCANCj4gPiANCj4gPiBUaGlzIGlzIHRl Y2huaWNhbGx5IGluY29ycmVjdCwgZXZlbiBmb3IgcmVhZGluZywgeW91IG5lZWQgYSBwYWdlLCB3 aGljaCBjb3VsZCBiZSANCj4gPiBjb21tb24gemVybyBwYWdlIGluIGNlcnRhaW4gY2FzZXMuDQo+ IA0KPiBPayBJJ2xsIHJld29yZCBpdCBsaWtlLg0KPiANCj4gPiANCj4gPiAod2hpY2ggd2UgcmVh bGx5IHJlYWQganVzdCBiZWZvcmUpLiBUaGF0IGxlYWRzDQo+ID4gPiAgICAgdG8gdmVyeSBzdHJh bmdlIHByb2JsZW1zIGluIHVzZXItc3BhY2UgYXBwIGZ1cnRoZXIgZG93biB0aGUgbGluZQ0KPiA+ ID4gICAgIGJlY2F1c2UgbmV3IHZhbHVlIHdhcyBuZXZlciB3cml0dGVuIHRvIHRoZSBkZXN0aW5h dGlvbi4NCj4gPiA+IA0KPiA+ID4gMy4gUmVnYXJkbGVzcyBvZiB3aGF0IHdlbnQgd3Jvbmcgd2Un bGwgcmV0dXJuIGZyb20gc3lzY2FsbA0KPiA+ID4gICAgIGFuZCB1c2VyLXNwYWNlIGFwcGxpY2F0 aW9uIHdpbGwgY29udGludWUgdG8gZXhlY3V0ZS4NCj4gPiA+ICAgICBFdmVuIGlmIHVzZXIncyBw b2ludGVyIHdhcyBjb21wbGV0ZWx5IGJvZ3VzLg0KPiA+IA0KPiA+IEFnYWluIHdlIGFyZSBleGFn Z2VyYXRpbmcgKGZyb20gdGVjaG5pY2FsIGNvcnJlY3RuZXNzIFBPVikgLSBpZiB1c2VyIHBvaW50 ZXIgd2FzIA0KPiA+IGJvZ3MsIHRoZSByZWFkIHdvdWxkIG5vdCBoYXZlIHdvcmtlZCBpbiBmaXJz dCBwbGFjZSBldGMuIFNvIGxldHMgdG9uZSBkb3duIHRoZSANCj4gPiByaGV0b3JpYy4NCj4gDQo+ IE9rIGhlcmUgSSBtYXkgcmVwaHJhc2UgaXQgbGlrZSB0aGF0Og0KPiAtLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tPjgtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQ0KPiAzLiBSZWdh cmRsZXNzIG9mIHdoYXQgd2VudCB3cm9uZyB3ZSdsbCByZXR1cm4gZnJvbSBzeXNjYWxsDQo+ICAg IGFuZCB1c2VyLXNwYWNlIGFwcGxpY2F0aW9uIHdpbGwgY29udGludWUgdG8gZXhlY3V0ZS4NCj4g LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLT44LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0NCj4gDQo+ID4gDQo+ID4gPiAgICAgSW4gY2FzZSBvZiBoYXJkd2FyZSBMTC9TQyB0aGF0 IGFwcCB3b3VsZCBoYXZlIGJlZW4ga2lsbGVkDQo+ID4gPiAgICAgYnkgdGhlIGtlcm5lbC4NCj4g PiA+IA0KPiA+ID4gV2l0aCB0aGF0IGNoYW5nZSB3ZSBhdHRlbXB0IHRvIGltcm92ZSBvbiBhbGwg MyBpdGVtcyBhYm92ZToNCj4gPiA+IA0KPiA+ID4gMS4gV2Ugc3RpbGwgZGlzYWJsZSBwcmVlbXB0 aW9uIGFyb3VuZCByZWFkLWFuZC13cml0ZSBvZg0KPiA+ID4gICAgIHVzZXIncyBkYXRhIGJ1dCBp ZiB3ZSBoYXBwZW4gdG8gZmFpbCB3aXRoIGVpdGhlciBvZiB0aGVtDQo+ID4gPiAgICAgd2UncmUg ZW5hYmxpbmcgcHJlZW1wdGlvbiBhbmQgdHJ5IHRvIGZvcmNlIHBhZ2UgZmF1bHQgc28NCj4gPiA+ ICAgICB0aGF0IHdlIGhhdmUgYSBjb3JyZWN0IG1hcHBpbmcgaW4gdGhlIFRMQi4gVGhlbiByZS10 cnkNCj4gPiA+ICAgICBhZ2FpbiBpbiAiYXRvbWljIiBjb250ZXh0Lg0KPiA+ID4gDQo+ID4gPiAy LiBJZiByZWFsIHBhZ2UgZmF1bHQgZmFpbHMgb3IgZXZlbiBhY2Nlc3Nfb2soKSByZXR1cm5zIGZh bHNlDQo+ID4gPiAgICAgd2Ugc2VuZCBTSUdTRUdWIHRvIHRoZSB1c2VyLXNwYWNlIHByb2Nlc3Mg c28gaWYgc29tZXRoaW5nIGdvZXMNCj4gPiA+ICAgICBzZXJpb3VzbHkgd3Jvbmcgd2UnbGwga25v dyBhYm91dCBpdCBtdWNoIGVhcmxpZXIuDQo+ID4gPiANCj4gPiANCj4gPiANCj4gPiA+ICAgDQo+ ID4gPiAgIAkvKg0KPiA+ID4gICAJICogVGhpcyBpcyBvbmx5IGZvciBvbGQgY29yZXMgbGFja2lu ZyBMTE9DSy9TQ09ORCwgd2hpY2ggYnkgZGVmaW50aW9uDQo+ID4gPiBAQCAtNjAsMjMgKzYyLDQ4 IEBAIFNZU0NBTExfREVGSU5FMyhhcmNfdXNyX2NtcHhjaGcsIGludCAqLCB1YWRkciwgaW50LCBl eHBlY3RlZCwgaW50LCBuZXcpDQo+ID4gPiAgIAkvKiBaIGluZGljYXRlcyB0byB1c2Vyc3BhY2Ug aWYgb3BlcmF0aW9uIHN1Y2NlZGVkICovDQo+ID4gPiAgIAlyZWdzLT5zdGF0dXMzMiAmPSB+U1RB VFVTX1pfTUFTSzsNCj4gPiA+ICAgDQo+ID4gPiAtCWlmICghYWNjZXNzX29rKFZFUklGWV9XUklU RSwgdWFkZHIsIHNpemVvZihpbnQpKSkNCj4gPiA+IC0JCXJldHVybiAtRUZBVUxUOw0KPiA+ID4g KwlyZXQgPSBhY2Nlc3Nfb2soVkVSSUZZX1dSSVRFLCB1YWRkciwgc2l6ZW9mKCp1YWRkcikpOw0K PiA+ID4gKwlpZiAoIXJldCkNCj4gPiA+ICsJCWdvdG8gZmFpbDsNCj4gPiA+ICAgDQo+ID4gPiAr YWdhaW46DQo+ID4gPiAgIAlwcmVlbXB0X2Rpc2FibGUoKTsNCj4gPiA+ICAgDQo+ID4gPiAtCWlm IChfX2dldF91c2VyKHV2YWwsIHVhZGRyKSkNCj4gPiA+IC0JCWdvdG8gZG9uZTsNCj4gPiA+IC0N Cj4gPiA+IC0JaWYgKHV2YWwgPT0gZXhwZWN0ZWQpIHsNCj4gPiA+IC0JCWlmICghX19wdXRfdXNl cihuZXcsIHVhZGRyKSkNCj4gPiA+ICsJcmV0ID0gX19nZXRfdXNlcih2YWwsIHVhZGRyKTsNCj4g PiA+ICsJaWYgKHJldCA9PSAtRUZBVUxUKSB7DQo+ID4gDQo+ID4gDQo+ID4gTGV0cyBzZWUgaWYg dGhpcyB3YXJyYW50cyBhZGRpbmcgY29tcGxleGl0eSAhIFRoaXMgaW1wbGllcyB0aGF0IFRMQiBl bnRyeSB3aXRoIA0KPiA+IFJlYWQgcGVybWlzc2lvbnMgZGlkbid0IGV4aXN0IGZvciByZWFkaW5n IHRoZSB2YXIgYW5kIHBhZ2UgZmF1bHQgaGFuZGxlciBjb3VsZCBub3QgDQo+ID4gd2lyZSB1cCBl dmVuIGEgemVybyBwYWdlIGR1ZSB0byBwcmVlbXB0X2Rpc2FibGUsIG1lYW5pbmcgaXQgd2FzIHNv bWV0aGluZyBub3QgDQo+ID4gdG91Y2hlZCBieSB1c2Vyc3BhY2UgYWxyZWFkeSAtIHNvcnQgb2Yg dW5pbml0aWFsaXplZCB2YXJpYWJsZSBpbiB1c2VyIGNvZGUuDQo+IA0KPiBPayBJIGNvbXBsZXRl bHkgbWlzc2VkIHRoZSBmYWN0IHRoYXQgZmFzdCBwYXRoIFRMQiBtaXNzIGhhbmRsZXIgaXMgYmVp bmcNCj4gZXhlY3V0ZWQgZXZlbiBpZiB3ZSBoYXZlIHByZWVtcHRpb24gZGlzYWJsZWQuIFNvIGdp dmVuIHRoZSBtYXBwaW5nIGV4aXN0DQo+IHdlIGRvIG5vdCBuZWVkIHRvIHJldHJ5IHdpdGggZW5h YmxlZCBwcmVlbXB0aW9uLg0KPiANCj4gU3RpbGwgbWF5YmUgSSdtIGEgYml0IHBhcmFub2lkIGhl cmUgYnV0IElNSE8gaXQncyBnb29kIHRvIGJlIHJlYWR5IGZvciBhIGNvcm5lci1jYXNlDQo+IHdo ZW4gdGhlIHBvaW50ZXIgaXMgY29tcGxldGVseSBib2d1cyBhbmQgdGhlcmUncyBubyBtYXBwaW5n IGZvciBoaW0uDQo+IEkgdW5kZXJzdGFuZCB0aGF0IHRvZGF5IHdlIG9ubHkgZXhwZWN0IHRoaXMg c3lzY2FsbCB0byBiZSB1c2VkIGZyb20gbGliYydzDQo+IGludGVybmFscyBidXQgYXMgbG9uZyBh cyBzeXNjYWxsIGV4aXN0cyBub2JvZHkgc3RvcHMgYW55Ym9keSBmcm9tIHVzaW5nIGl0DQo+IGRp cmVjdGx5IHdpdGhvdXQgbGliYy4gU28gbWF5YmUgaW5zdGVhZCBvZiBkb2luZyBnZXRfdXNlcl9w YWdlc19mYXN0KCkganVzdA0KPiBzZW5kIGEgU0lHU0VHViB0byB0aGUgcHJvY2Vzcz8gQXQgbGVh c3QgdXNlciB3aWxsIHJlYWxpemUgdGhlcmUncyBzb21lIHByb2JsZW0NCj4gYXQgZWFybGllciBz dGFnZS4NCj4gDQo+ID4gT3RoZXJ3aXNlIGl0IGlzIGV4dHJlbWVseSB1bmxpa2VseSB0byBzdGFy dCB3aXRoIGEgVExCIGVudHJ5IHdpdGggUmVhZCANCj4gPiBwZXJtaXNzaW9ucywgZm9sbG93ZWQg Ynkgc3lzY2FsbCBUcmFwIG9ubHkgdG8gZmluZCB0aGUgZW50cnkgbWlzc2luZywgdW5sZXNzIGEg DQo+ID4gZ2xvYmFsIFRMQiBmbHVzaCBjYW1lIGZyb20gb3RoZXIgY29yZXMsIHJpZ2h0IGluIHRo ZSBtaWRkbGUuIEJ1dCB0aGlzIHN5c2NhbGwgaXMgDQo+ID4gbm90IGd1YXJhbnRlZWQgdG8gd29y ayB3aXRoIFNNUCBhbnl3YXlzLCBzbyBsZXRzIGlnbm9yZSBhbnkgU01QIG1pc2RvaW5ncyBoZXJl Lg0KPiANCj4gV2VsbCBidXQgdGhhdCdzIGV4YWN0bHkgdGhlIHNpdHVhdGlvbiBJIHdhcyBkZWJ1 Z2dpbmc6IHdlIHN0YXJ0IGZyb20gZGF0YSBmcm9tIHJlYWQtb25seQ0KPiBwYWdlIGFuZCBvbiBh dHRlbXB0IHRvIHdyaXRlIGJhY2sgbW9kaWZpZWQgdmFsdWUgQ09XIG1hY2hpbmVyeSBnZXRzIGlu dm9sdmVkLg0KPiANCj4gVGhhdCB3YXMgb24gVVAgcGxhdGZvcm0uDQo+IA0KPiA+IE5vdyBpbiBj YXNlIGl0IHdhcyAqYW4qIHVuaW5pdGlhbGl6ZWQgdmFyLCBkbyB3ZSBoYXZlIHRvIGd1YXJhbnRl ZSBhbnkgd2VsbCANCj4gPiBkZWZpbmVkIHNlbWFudGljcyBmb3IgdGhlIGtlcm5lbCBlbXVsYXRp b24gb2YgY21weGNoZyA/IElNTyBpdCBzaG91bGQgYmUgZmluZSB0byANCj4gPiByZXR1cm4gMCBv ciAtRUZBVUxUIGV0Yy4gSW5mYWN0IC1FRkFVTFQgaXMgYmV0dGVyIGFzIGl0IHdpbGwgZm9yY2Ug YSByZXRyeSBsb29wIG9uIA0KPiA+IHVzZXIgc2lkZSwgZ2l2ZW4gdGhlIHR5cGljYWwgY21weGNo ZyB1c2FnZSBwYXR0ZXJuLg0KPiANCj4gVGhlIHByb2JsZW0gaXMgbGliYyBvbmx5IGV4cGVjdHMg dG8gZ2V0IGEgdmFsdWUgcmVhZCBmcm9tIG1lbW9yeS4NCj4gQW5kIGluIHRoZW9yeSBleHBlY3Rl ZCB2YWx1ZSBtaWdodCBiZSAtMTQgd2hpY2ggaXMgYmFzaWNhbGx5IC1FRkFVTFQuDQo+IEknbSBu b3QgdGFsa2luZyBhYm91dCAwIGF0IGFsbCBiZWNhdXNlIGluIHNvbWUgY2FzZXMgdGhhdCdzIGV4 YWN0bHkgd2hhdA0KPiB1c2VyLXNwYWNlIGV4cGVjdHMuDQo+IA0KPiBTbyBpZiB3ZSByZWFkIHVu ZXhwZWN0ZWQgdmFsdWUgdGhlbiB3ZSdsbCBqdXN0IHJldHVybiBpdCB3aXRob3V0IGV2ZW4gYXR0 ZW1wdGluZw0KPiB0byB3cml0ZS4NCj4gDQo+IElmIHdlIHJlYWQgZXhwZWN0ZWQgZGF0YSBidXQg ZmFpbCB0byB3cml0ZSB0aGVuIHdlJ2xsIHNlbmQgYSBTSUdTRUdWIGFuZA0KPiByZXR1cm4gd2hh dGV2ZXIuLi4gbGV0IGl0IGJlIC1FRkFVTFQgLSBhbnl3YXlzIHRoZSBhcHAgd2lsbCBiZSBraWxs ZWQgb24gZXhpdCBmcm9tDQo+IHRoaXMgc3lzY2FsbC4NCg0KQW55IGNvbW1lbnRzIG9uIG15IGNv bW1lbnRzIGFib3ZlPw0KDQotQWxleGV5 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alexey.Brodkin@synopsys.com (Alexey Brodkin) Date: Wed, 4 Apr 2018 08:56:13 +0000 Subject: [PATCH] ARC: Improve cmpxchng syscall implementation In-Reply-To: <1521633274.9805.30.camel@synopsys.com> References: <20180319110002.27419-1-abrodkin@synopsys.com> <5bc39838-b1c5-ef65-f97d-8777ed33bda0@synopsys.com> <1521633274.9805.30.camel@synopsys.com> List-ID: Message-ID: <1522832172.4851.7.camel@synopsys.com> To: linux-snps-arc@lists.infradead.org Hi Vineet, Peter, On Wed, 2018-03-21@14:54 +0300, Alexey Brodkin wrote: > Hi Vineet, > > On Mon, 2018-03-19@11:29 -0700, Vineet Gupta wrote: > > On 03/19/2018 04:00 AM, Alexey Brodkin wrote: > > > arc_usr_cmpxchg syscall is supposed to be used on platforms > > > that lack support of Load-Locked/Store-Conditional instructions > > > in hardware. And in that case we mimic missing hardware features > > > with help of kernel's sycall that "atomically" checks current > > > value in memory and then if it matches caller expectation new > > > value is written to that same location. > > > > > > > ... > > ... > > > > > > > > 2. What's worse if we're dealing with data from not yet allocated > > > page (think of pre-copy-on-write state) we'll successfully > > > read data but on write we'll silently return to user-space > > > with correct result > > > > This is technically incorrect, even for reading, you need a page, which could be > > common zero page in certain cases. > > Ok I'll reword it like. > > > > > (which we really read just before). That leads > > > to very strange problems in user-space app further down the line > > > because new value was never written to the destination. > > > > > > 3. Regardless of what went wrong we'll return from syscall > > > and user-space application will continue to execute. > > > Even if user's pointer was completely bogus. > > > > Again we are exaggerating (from technical correctness POV) - if user pointer was > > bogs, the read would not have worked in first place etc. So lets tone down the > > rhetoric. > > Ok here I may rephrase it like that: > ------------------------------->8----------------------------- > 3. Regardless of what went wrong we'll return from syscall > and user-space application will continue to execute. > ------------------------------->8----------------------------- > > > > > > In case of hardware LL/SC that app would have been killed > > > by the kernel. > > > > > > With that change we attempt to imrove on all 3 items above: > > > > > > 1. We still disable preemption around read-and-write of > > > user's data but if we happen to fail with either of them > > > we're enabling preemption and try to force page fault so > > > that we have a correct mapping in the TLB. Then re-try > > > again in "atomic" context. > > > > > > 2. If real page fault fails or even access_ok() returns false > > > we send SIGSEGV to the user-space process so if something goes > > > seriously wrong we'll know about it much earlier. > > > > > > > > > > > > > /* > > > * This is only for old cores lacking LLOCK/SCOND, which by defintion > > > @@ -60,23 +62,48 @@ SYSCALL_DEFINE3(arc_usr_cmpxchg, int *, uaddr, int, expected, int, new) > > > /* Z indicates to userspace if operation succeded */ > > > regs->status32 &= ~STATUS_Z_MASK; > > > > > > - if (!access_ok(VERIFY_WRITE, uaddr, sizeof(int))) > > > - return -EFAULT; > > > + ret = access_ok(VERIFY_WRITE, uaddr, sizeof(*uaddr)); > > > + if (!ret) > > > + goto fail; > > > > > > +again: > > > preempt_disable(); > > > > > > - if (__get_user(uval, uaddr)) > > > - goto done; > > > - > > > - if (uval == expected) { > > > - if (!__put_user(new, uaddr)) > > > + ret = __get_user(val, uaddr); > > > + if (ret == -EFAULT) { > > > > > > Lets see if this warrants adding complexity ! This implies that TLB entry with > > Read permissions didn't exist for reading the var and page fault handler could not > > wire up even a zero page due to preempt_disable, meaning it was something not > > touched by userspace already - sort of uninitialized variable in user code. > > Ok I completely missed the fact that fast path TLB miss handler is being > executed even if we have preemption disabled. So given the mapping exist > we do not need to retry with enabled preemption. > > Still maybe I'm a bit paranoid here but IMHO it's good to be ready for a corner-case > when the pointer is completely bogus and there's no mapping for him. > I understand that today we only expect this syscall to be used from libc's > internals but as long as syscall exists nobody stops anybody from using it > directly without libc. So maybe instead of doing get_user_pages_fast() just > send a SIGSEGV to the process? At least user will realize there's some problem > at earlier stage. > > > Otherwise it is extremely unlikely to start with a TLB entry with Read > > permissions, followed by syscall Trap only to find the entry missing, unless a > > global TLB flush came from other cores, right in the middle. But this syscall is > > not guaranteed to work with SMP anyways, so lets ignore any SMP misdoings here. > > Well but that's exactly the situation I was debugging: we start from data from read-only > page and on attempt to write back modified value COW machinery gets involved. > > That was on UP platform. > > > Now in case it was *an* uninitialized var, do we have to guarantee any well > > defined semantics for the kernel emulation of cmpxchg ? IMO it should be fine to > > return 0 or -EFAULT etc. Infact -EFAULT is better as it will force a retry loop on > > user side, given the typical cmpxchg usage pattern. > > The problem is libc only expects to get a value read from memory. > And in theory expected value might be -14 which is basically -EFAULT. > I'm not talking about 0 at all because in some cases that's exactly what > user-space expects. > > So if we read unexpected value then we'll just return it without even attempting > to write. > > If we read expected data but fail to write then we'll send a SIGSEGV and > return whatever... let it be -EFAULT - anyways the app will be killed on exit from > this syscall. Any comments on my comments above? -Alexey