From: Davi Arnaut Date: July 6 2010 12:47am Subject: bzr commit into mysql-trunk-bugfixing branch (davi:3086) Bug#22320 Bug#52261 List-Archive: http://lists.mysql.com/commits/112922 X-Bug: 22320,52261 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============4634514191234535408==" --===============4634514191234535408== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline # At a local mysql-trunk-bugfixing repository of davi 3086 Davi Arnaut 2010-07-05 Bug#22320: my_atomic-t unit test fails Bug#52261: 64 bit atomic operations do not work on Solaris i386 gcc in debug compilation One of the various problems was that the source operand to CMPXCHG8b was marked as a input/output operand, causing GCC to use the EBX register as the destination register for the CMPXCHG8b instruction. This could lead to crashes as the EBX register is also implicitly used by the instruction, causing the value to be potentially garbaged and a protection fault once the value is used to access a position in memory. Another problem was the lack of proper clobbers for the atomic operations and, also, a discrepancy between the implementations for the Compare and Set operation. The specific problems are described and fixed by Kristian Nielsen patches: Patch: 1 Fix bugs in my_atomic_cas*(val,cmp,new) that *cmp is accessed after CAS succeds. In the gcc builtin implementation, problem was that *cmp was read again after atomic CAS to check if old *val == *cmp; this fails if CAS is successful and another thread modifies *cmp in-between. In the x86-gcc implementation, problem was that *cmp was set also in the case of successful CAS; this means there is a window where it can clobber a value written by another thread after successful CAS. Patch 2: Add a GCC asm "memory" clobber to primitives that imply a memory barrier. This signifies to GCC that any potentially aliased memory must be flushed before the operation, and re-read after the operation, so that read or modification in other threads of such memory values will work as intended. In effect, it makes these primitives work as memory barriers for the compiler as well as the CPU. This is better and more correct than adding "volatile" to variables. @ include/atomic/gcc_builtins.h Do not read from *cmp after the operation as it might be already gone if the operation was successful. @ include/atomic/nolock.h Prefer system provided atomics over the broken x86 asm. @ include/atomic/x86-gcc.h Do not mark source operands as input/output operands. Add proper memory clobbers. @ include/my_atomic.h Add notes about my_atomic_add and my_atomic_cas behaviors. @ unittest/mysys/my_atomic-t.c Remove work around, if it fails, there is either a problem with the atomic operations code or the specific compiler version should be black-listed. modified: include/atomic/gcc_builtins.h include/atomic/nolock.h include/atomic/x86-gcc.h include/my_atomic.h unittest/mysys/my_atomic-t.c === modified file 'include/atomic/gcc_builtins.h' --- a/include/atomic/gcc_builtins.h 2009-11-27 17:11:05 +0000 +++ b/include/atomic/gcc_builtins.h 2010-07-06 00:47:46 +0000 @@ -22,8 +22,9 @@ v= __sync_lock_test_and_set(a, v); #define make_atomic_cas_body(S) \ int ## S sav; \ - sav= __sync_val_compare_and_swap(a, *cmp, set); \ - if (!(ret= (sav == *cmp))) *cmp= sav; + int ## S cmp_val= *cmp; \ + sav= __sync_val_compare_and_swap(a, cmp_val, set);\ + if (!(ret= (sav == cmp_val))) *cmp= sav #ifdef MY_ATOMIC_MODE_DUMMY #define make_atomic_load_body(S) ret= *a === modified file 'include/atomic/nolock.h' --- a/include/atomic/nolock.h 2009-12-23 08:27:41 +0000 +++ b/include/atomic/nolock.h 2010-07-06 00:47:46 +0000 @@ -29,21 +29,22 @@ We choose implementation as follows: ------------------------------------ On Windows using Visual C++ the native implementation should be - preferrable. When using gcc we prefer the native x86 implementation, - we prefer the Solaris implementation before the gcc because of - stability preference, we choose gcc implementation if nothing else - works on gcc. If neither Visual C++ or gcc we still choose the - Solaris implementation on Solaris (mainly for SunStudio compiles. + preferrable. When using gcc we prefer the Solaris implementation + before the gcc because of stability preference, we choose gcc + builtins if available, otherwise we choose the somewhat broken + native x86 implementation. If neither Visual C++ or gcc we still + choose the Solaris implementation on Solaris (mainly for SunStudio + compilers). */ # if defined(_MSV_VER) # include "generic-msvc.h" # elif __GNUC__ -# if defined(__i386__) || defined(__x86_64__) -# include "x86-gcc.h" -# elif defined(HAVE_SOLARIS_ATOMIC) +# if defined(HAVE_SOLARIS_ATOMIC) # include "solaris.h" # elif defined(HAVE_GCC_ATOMIC_BUILTINS) # include "gcc_builtins.h" +# elif defined(__i386__) || defined(__x86_64__) +# include "x86-gcc.h" # endif # elif defined(HAVE_SOLARIS_ATOMIC) # include "solaris.h" === modified file 'include/atomic/x86-gcc.h' --- a/include/atomic/x86-gcc.h 2010-02-19 14:20:29 +0000 +++ b/include/atomic/x86-gcc.h 2010-07-06 00:47:46 +0000 @@ -53,18 +53,29 @@ #endif #define make_atomic_add_body32 \ - asm volatile (LOCK_prefix "; xadd %0, %1;" : "+r" (v) , "+m" (*a)) + asm volatile (LOCK_prefix "; xadd %0, %1;" \ + : "+r" (v), "=m" (*a) \ + : "m" (*a) \ + : "memory") #define make_atomic_cas_body32 \ + __typeof__(*cmp) sav; \ asm volatile (LOCK_prefix "; cmpxchg %3, %0; setz %2;" \ - : "+m" (*a), "+a" (*cmp), "=q" (ret): "r" (set)) + : "=m" (*a), "=a" (sav), "=q" (ret) \ + : "r" (set), "m" (*a), "a" (*cmp) \ + : "memory"); \ + if (!ret) \ + *cmp= sav #ifdef __x86_64__ #define make_atomic_add_body64 make_atomic_add_body32 #define make_atomic_cas_body64 make_atomic_cas_body32 -#define make_atomic_fas_body(S) \ - asm volatile ("xchg %0, %1;" : "+r" (v) , "+m" (*a)) +#define make_atomic_fas_body(S) \ + asm volatile ("xchg %0, %1;" \ + : "+r" (v), "=m" (*a) \ + : "m" (*a) \ + : "memory") /* Actually 32-bit reads/writes are always atomic on x86 @@ -73,9 +84,14 @@ #define make_atomic_load_body(S) \ ret=0; \ asm volatile (LOCK_prefix "; cmpxchg %2, %0" \ - : "+m" (*a), "+a" (ret): "r" (ret)) + : "=m" (*a), "+a" (ret) \ + : "r" (ret) \ + : "memory") #define make_atomic_store_body(S) \ - asm volatile ("; xchg %0, %1;" : "+m" (*a), "+r" (v)) + asm volatile ("; xchg %0, %1;" \ + : "=m" (*a), "+r" (v) \ + : "m" (*a) \ + : "memory") #else /* @@ -104,12 +120,14 @@ platforms the much simpler make_atomic_cas_body32 will work fine. */ -#define make_atomic_cas_body64 \ - int32 ebx=(set & 0xFFFFFFFF), ecx=(set >> 32); \ - asm volatile ("push %%ebx; movl %3, %%ebx;" \ - LOCK_prefix "; cmpxchg8b %0; setz %2; pop %%ebx"\ - : "+m" (*a), "+A" (*cmp), "=c" (ret) \ - :"m" (ebx), "c" (ecx)) +#define make_atomic_cas_body64 \ + int32 ebx=(set & 0xFFFFFFFF), ecx=(set >> 32); \ + asm volatile ("xchgl %2, %%ebx;" \ + LOCK_prefix "; cmpxchg8b %1;" \ + "xchgl %2, %%ebx" \ + : "=A" (ret) "=m" (*a), "+A" (*cmp) \ + : "DS" (ebx), "c" (ecx), "m" (*a) \ + : "memory", "esp") #endif /* === modified file 'include/my_atomic.h' --- a/include/my_atomic.h 2010-02-23 15:49:21 +0000 +++ b/include/my_atomic.h 2010-07-06 00:47:46 +0000 @@ -20,6 +20,7 @@ This header defines five atomic operations: my_atomic_add#(&var, what) + 'Fetch and Add' add 'what' to *var, and return the old value of *var my_atomic_fas#(&var, what) @@ -27,9 +28,10 @@ store 'what' in *var, and return the old value of *var my_atomic_cas#(&var, &old, new) - 'Compare And Swap' + An odd variation of 'Compare And Set/Swap' if *var is equal to *old, then store 'new' in *var, and return TRUE otherwise store *var in *old, and return FALSE + Usually, &old should not be accessed if the operation is successful. my_atomic_load#(&var) return *var === modified file 'unittest/mysys/my_atomic-t.c' --- a/unittest/mysys/my_atomic-t.c 2009-11-27 17:11:05 +0000 +++ b/unittest/mysys/my_atomic-t.c 2010-07-06 00:47:46 +0000 @@ -15,13 +15,6 @@ #include "thr_template.c" -/* at least gcc 3.4.5 and 3.4.6 (but not 3.2.3) on RHEL */ -#if __GNUC__ == 3 && __GNUC_MINOR__ == 4 -#define GCC_BUG_WORKAROUND volatile -#else -#define GCC_BUG_WORKAROUND -#endif - volatile uint32 b32; volatile int32 c32; my_atomic_rwlock_t rwl; @@ -29,8 +22,8 @@ my_atomic_rwlock_t rwl; /* add and sub a random number in a loop. Must get 0 at the end */ pthread_handler_t test_atomic_add(void *arg) { - int m= (*(int *)arg)/2; - GCC_BUG_WORKAROUND int32 x; + int m= (*(int *)arg)/2; + int32 x; for (x= ((int)(intptr)(&m)); m ; m--) { x= (x*m+0x87654321) & INT_MAX32; @@ -52,8 +45,8 @@ volatile int64 a64; /* add and sub a random number in a loop. Must get 0 at the end */ pthread_handler_t test_atomic_add64(void *arg) { - int m= (*(int *)arg)/2; - GCC_BUG_WORKAROUND int64 x; + int m= (*(int *)arg)/2; + int64 x; for (x= ((int64)(intptr)(&m)); m ; m--) { x= (x*m+0xfdecba987654321LL) & INT_MAX64; @@ -128,8 +121,8 @@ pthread_handler_t test_atomic_fas(void * */ pthread_handler_t test_atomic_cas(void *arg) { - int m= (*(int *)arg)/2, ok= 0; - GCC_BUG_WORKAROUND int32 x, y; + int m= (*(int *)arg)/2, ok= 0; + int32 x, y; for (x= ((int)(intptr)(&m)); m ; m--) { my_atomic_rwlock_wrlock(&rwl); --===============4634514191234535408== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/davi.arnaut@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: davi.arnaut@stripped # target_branch: file:///home/davi/bzr/bugs/22320-trunk/ # testament_sha1: 83fa9ccb125703368aaf56cd9aefc08d85dc51e5 # timestamp: 2010-07-05 21:47:52 -0300 # base_revision_id: alik@ibmvm-20100702062300-3cceo4fdbu3b0qkr # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWY8PFYYABzz/gFS/Yod7//// f+/fxL////RgD2u19O0Gu7t8971WQe7AOWuGm0Cijbs3vVu3Lm2VUUeW0d1QEkgkxUn+QJM9T0iT 1P0yZIz1RlNP1T1NGjTGoeU8RM1Hmin6anqgaBATTERqYp5Seo9qnsqDIA2o0yAAAAGgaNDhoaMm jRo00MjIYQBkAMg00AADIGQBIiEEARpT9TT0o9B6Imn6p6Ro0BiAA0AANABtSITEA00ZDRMk2FGR tT01BoAAAAAAASRAgCAACAJ6Imp5MppiBoGjQNBpkaA0ui6GzMcH2YmX9s9seXhbf4jF58WhpntD DIEH81py7Oo1fT/NDuzPTAx3kAzPvGQJtaA9lfFg4R7CTUUMFaedcbMC6th6Zdb777+bRgB+JP9S I9tiCWA9GOWHgTZkwZtkJYxjfog+2zM+eaXr1U07Fvrp7O3Z5dP1aMiQhFsPUmwJgQ795ARChxtk IdhBUSH7y7p2xwqwodFAOmscDDRpkcoj/4Y7iucNCqX6VlQnY5bXCLIos7UmjPVHKjchgxtptA2l vt5OLzJHA35cND9B0Gb3uOTALsH2rri9mDpgebAtUODh2oX30KFBy54Ueh0MTMCMUjZBPCaqqPfA 424d1Nm+LuHXuUOA6u/p5eXL0XjlRbNM3E5tV21dzlIM9rV2Ev9tVKrrpLI1jOfBda/4qJgcViPR qB2qMc59FAoU79EmwD/LlE/PjGNze/IYI838q00j4u5ffbCjY45jyP4P6cYLmZo8hqPLN+5XG4rv V9gYnGMWEr7Gyxg58Ddvu0e5iAFV1lXSSDXdy41JAYUKceEXK4clRtxDHBrkbpnqoWMGZpmZgHmP nkz4yriQbVpAHaytIRpO1H91LD062BcB6V8Kvkq2OJmd8mqbKM+YQ8tDnfE7DbwhvznndKSbJpkK mKor3VPynldThZGtPGkcJDRnSbQDd2jiokdn7Q3kNep1L/rmcOw6xPV/GBtmIbrXEjq2K7+p+CLn BZZjum3t1Zs128GOPpVvrihtu7Ji/PIjahvABzcyCxhQAZhgTTGIY58j8K6q8CSAX0DOnJHuNCP9 pGaCsnlTC6GKRgfwWME2bzTGJzGbI96Y8sbJX2SBKm3SX2aqTNbhumMivDgTYmHDGFt2CQV0SZlX W+Y+bVsTT1nXY9+JUNM/BBi06NYloGOggUcxLrQViw45RkuQd3w2WYE/ZgXfKqE22ZXJitJSUmc1 qcvW02ucXjxxbQ5x0aq2EtGVNJRAKRNDu6YTg7l65opeqZXROqKyxiz634MBJsBtJZ2Uu4Ky3VfW vVxqEmYCUgToBhebJAyeyhuVhyNNVIHAkJVycAqYgrxKQVFSEBMQsMsKvfVzCyz4GkvGXy+KWx1R Cta1ithndrAgnOywkMgPjzXHb/C80ac4kU4lrFQCtwlN7zLQRQWUTgb7TyT8ZmZgebxC7iKL3Vdf S4BZhugxRRIw5UC+FeNdkhfrqNKbzeajtgaEZOJEy6EayJWb4pKgYamdVwujsgwyqa8+l9OdCCb4 KNtRtg8Yq19/vgpSwWCWYkb9dCjM1LYwnaTK6+SjGQ2t8Ko1zkbSEd0symBoKriwmTMGGtOBfI9Y dqcS+5fGtvxrpfnVmGDamM5KAZhyKcFCJHwTQOFe33SrFslWRiqky46iZkoU1jYqsyMdnW7WF6RV jRtGQrWytlCrrTrV4mzLKr+MTFinl1i5GYe+HXZTJElJLJVU40u1lulUO8ZLPHFMFbBZN+UvYlQJ l65SsEqr9RQrnjunxqfHojcJ1WZz5M3Pu8VFd6vV/YspjleOgv81EGWxxukPCJ1d99RWCeRc2ovi QIGjYYEd3OcIbCNdBpjDmY2mKsrscjIe6otouMUA4UqxEKdhEszlpSiur7Y+OZCnV8WFxqvxKimU irXg8HMhzexhNZiZxys0ERxl3RWcoE1VnW9Y4sNjTTGx1oQEE5IsLTMGwxJW2PAtEvCZiUuCwuzK KsriTqqIsjl6tOjnvmllsN6vNsi1S0Lmu9YaV5rbpo12HCJbNG0jsg/GdpMbaaBmCxnzjrYdPHth 4nlIX4C23ANw18f1ERmIUGAlqwCMa0R9WohWGhM97ODQ68RIZYRCh4ZhAVGrQIDGwa+c7rdwhTzD E7xKor4fKIOMdUroQWVtUJXZ3VI3NQHkjZW0K6Q5dRVJFaUqIi6kSKjpR3gWuZv5jCp1d9v0dvtY tVTS3/ELyXo+TjyuheS5K1mbxR2wUAcQ2BeYiONH6v756VbMuN8BLku9/4I489VjU/izmscHjZkm M6kdMu60LiXKaCQnjztXPnYeUauleSWe8Wl77pt/SEigOuem04gQqN9+qV044u87SuXh4nG1XEWX wdkkcp9W5CB+hA5uDu7tOnT36VvHWz9GnwtS6c948Va92Hi/nlhuSjdPo96ZcicA4+koB4nmojfc iEJ/4XeWRHv3HwLCMyDd4/H+yRq8pfKAXwu21vFw6OocSnznPnLV29usGxApS+J7apILnOc+R98W ZeQVAGx1Yl0/CZModrKtif2B41GiDNEKlvIqpz78u6sB2bWw5rb7D+23TGoA/osi4hqPpEq6bi18 WobQ03HKzXpoLWsWh+I0CjMLjuweE7JIG2zJ7A0iXzJkPfUpAHEUf0HeJZPy/UvZxXkXblI7e0c6 H1PoxPrDoOLZ9adcwYf1HkvCO1QTwKxNUt4/itHlQ3KLqaKdUQithyl0QkzjMMmPb6JCZRQRZgZM yghrCoOBzXuXGnM1rYWnAm5cyGDZlzpoYOeaFvLh0enBbU6Lzmci8jhqqdIvPAlN8cX9SHXgqEsH Y5ohIKkF/sA+1gijFIOrVAPQZmMcy0jMrz+fz0UOShMwUaikEuJJpLmXSMR1BdaHIWVw7jut4HB0 by1LduOwsDJeliUkVpD0Mh0O4TI1UV5L9TMcGzQ1RYDX4mGH9yKplf1CrN1mClu8E/tVyLdj4W9k nJdPR3D48AhAUXcdj7wxRE6JMrLGpxJQe4kMLsLUCILh2vqp9KXOTITsepnTIbsOk5OcOw6zgSje xt9dXZ1vrPI9ShKVxwRUjGxHmz4ZlaZxFwFshQ0uWfCqvn97dd50OUzuLbZ5bK+WSzLbZ2TOTHWp W86BPV6zb6oR9Odu46jKohnwQ48ZbrrhGaeprmd2E5qcu5rsg3EL5OMEK564O1osKUTjuKUtS54z ZLYmyCXZjpHO3hEq2jb263oVlfpHdfM5wkUXyR125rJ1HJyvkCMimCR9i8OZBAifpkSADatYVMkO 8xSl0s5MNiSWuWsJ6DAOoOEMfqNfhxFhTkXpaXCbRvG+ri3YivDPC8a4nMjsRc40MihEUmWW4gq3 Qgq+NZkc6KdKvO0PobOwtywpWmGIer/HJyxDVMdOICe6SSp/KS5LjKXjMEUtwqNOwSTnC7E5tBQR sZU5pxC/mwb6UrD7pAVtGTsijszcY8gVxQm7KajJOSGYBbK5M4DQgrrFqyp5scvaeXwHRhmEhoy4 x01gFz/dQqLbg91rh8IsoxfftmEHT1YhkQ2AQutPNVdCUmgzoKOWh/9r7INVAYFPQjBG7fYxqigo Ey5EwDeemeaQRMwmZMkwbssU1YebM6ZOoYyA19qp9uuoN1XWX7zhW8y3EnKF0mkFDZOFaDeQaHy5 RhkE9RmRvExeGTBeMPEX256JjWQlCkiTre1BqSU5eQZ6iPaYRkFrAXGlQHTkU/ENxvAnBeMnG087 bkEL3uTYRESbaStAaRMlO+cIDorHpqKPfkqtwZURVddXSraapXIKBvXZhZrYPlbWPHliAa9T4hpg 6I6UwId3YMxQcLCcTXBPV9iuDWUYUX7LMCIHp64MilJTErEFjJRVQmCoCHyqZxV3FR124e9uSeC9 i7c0Wcy59MjiJmfZpDTPHBFYIpLctolw12EA+k66hEvMiz2gErvO/JZA1kaC+QIpAQSc+xk9fzQF brWPS0JBq0yWexGOB3qowBoMJZGBpDaG0muCni7yudd4tZ8JwmWVi2tZFToXcC0TIydfcR6yIqr1 eoSOn4gtRH/3cidyQZa0hP9g0cZeMQuZdD2yHBc6yK4C5tkaltkYPKBpgUBld7LdEwowDM3BQ9ve oLQGEhwvI5LmnoLtvUYVzzSUUU5jh5tAEMlTg684IZJmQ4omXEAwIh3iWhOBr0WLrZeQwi5jUqhj srzZV68kVm6y2p7KnEtnUuRAeBNSUaBsdoUNtttsO6frThviBkgHFkFNh1zgopzXiR4eXZKDN6L6 fPzRMpbYhYexf1Y6p0FNUtd2q64lhFH0cMwQNqdfAQSUxduw9FsQk19RAdOyaicJqAB0hq78ausb nOA7q5s9zjMxA4qgk4IYM4a+lWIykZCCBZsojNZ8cAwfIg0Otoi9QW0bwYoVYCWV5sih0lNyQ3iU yOaII6m1IpVNOstgFs0YGZkVC96+bEtZlk70eTaIiIiIiIiKHhEuRbVcJa2Kr1VYTOq8DaQq+N4L q7AAIaQI5h+ewqZ4oZawLKludNzMhpAkY4FCa05oxpVKl1Cb7ygYKl9ElVVQ+AjgoJFWzK41OW0n PNIY1E6YypwI0aMUSkBsZJcEDcsKTiY81ERsMIYpWvGEoaG0QU7C1T7SypZnORgiNJWScTOV228J Z2ORysD6YzgGSWdpFeEamXi0/oGAdexbkbk2fJaANHTu0YBOSpNWOP1PBiScBYHrSXDcQmobHM48 1ChZWQtFenGOyPUiSINwAzLoqw8fWqT2LdsoC4jZ71SBhubtW+5RU1MVzW7TYOJbLJac2qtQaTRF AULhqpIFKpdr1WvsprUxzFjQXwWcj0lNrMmcrbPZp8FMUEKShc4oOcQSl6YFlJiwxbHuLOPQoFWG ZZb9pQZx2/MUoykRISEBIU1bxMf2f/i7kinChIR4eKww --===============4634514191234535408==--