1Chinese translated version of Documentation/volatile-considered-harmful.txt 2 3If you have any comment or update to the content, please contact the 4original document maintainer directly. However, if you have a problem 5communicating in English you can also ask the Chinese maintainer for 6help. Contact the Chinese maintainer if this translation is outdated 7or if there is a problem with the translation. 8 9Maintainer: Jonathan Corbet <corbet@lwn.net> 10Chinese maintainer: Bryan Wu <bryan.wu@analog.com> 11--------------------------------------------------------------------- 12Documentation/volatile-considered-harmful.txt ��������������� 13 14������������������������������������������������������������������������������������������������������ 15������������������������������������������������������������������������������������������������������ 16������������������������������������������������ 17 18��������������������� Jonathan Corbet <corbet@lwn.net> 19��������������������� ������ Bryan Wu <bryan.wu@analog.com> 20��������������������� ������ Bryan Wu <bryan.wu@analog.com> 21��������������������� ��������� Eugene Teo <eugeneteo@kernel.sg> 22 ������ Dave Young <hidave.darkstar@gmail.com> 23��������������� 24--------------------------------------------------------------------- 25 26���������������������������volatile��������� 27------------------------------ 28 29C���������������������volatile������������������������������������������������������������������������������������ 30���������������������������������������������C���������������������volatile��������������������������������������� 31���������volatile���������������������������������������������������������������������������������volatile��� 32��������������������������������������������������������� 33 34������volatile��������������������������������������������������������������������������������������������������� 35��������������������������������������������������������������������������������������������������������������������� 36��������������������������������������������������������������������������������������������������������������������� 37��������� 38 39���volatile���������������������������������������������������������������������������������������, ���������,��� 40��������������������������������������������������������������������������������������������������������������������� 41���������������volatile���������������������������volatile��������������������������������������������������� 42���bug���������������������������������������volatile��������������������������������������� 43 44������������������������������������������ 45 46 spin_lock(&the_lock); 47 do_something_on(&shared_data); 48 do_something_else_with(&shared_data); 49 spin_unlock(&the_lock); 50 51������������������������������������������������������the_lock������������������������������������shared_data��� 52������������������������������������������������������������������������������������������������������������������������ ��� 53��������������������������������� ������ ��������������������������������������������������������������������������������� 54������������shared_data���������������������������������spin_lock()������������������������������������������ 55��������������������������������������������������������������������������������������������� 56 57������shared_data������������volatile��������������������������������������������������������������������������� 58���������������������������������������������������������shared_data������������������������������������ 59shared_data������volatile��������������������������������������������������������������������������� 60volatile ������ ������������������������������ 61 62volatile������������������������������������������������I/O��������������������������������������������������������� 63���������������������������������������������������������������������������������������������������������I/O��������������� 64���������������������������������������������������������I/O������������������������������������������������������������ 65���������������������������������������������������������������������������������������������������volatile��������� 66��������������� 67 68���������������������������������volatile��������������������������������������������������������������������������� 69��������������������������� 70 71 while (my_variable != what_i_want) 72 cpu_relax(); 73 74cpu_relax()���������������CPU��������������������������������������������������������������������������������������� 75���������������������������volatile������������������������������������������������������������������������������ 76 77���������������������������������������volatile������������������������ 78 79 - ���������������������������������������������������I/0������������������������������������������������������������ 80 volatile������������������������������������������������������������������������������������������������������ 81 ��������������������������������������������� 82 83 - ���������������������������������������������������������������������������������������������������GCC������������ 84 ���������������������������������volatile������������������������������������������ 85 86 - Jiffies���������������������������������������������������������������������������������������������jiffies 87 ������������������������������������������������������jiffies������������������volatile������������������ 88 ���������jiffies������������������������volatile���Jiffies���������������������������������������" 89 ���Linus������������������������������������������������������������������ 90 91 - ������������I/0������������������������������������������,������������,��������������������������������������� 92 ������������������������������volatile������������������������������������������������������������������������ 93 ��������������������������������������������������������������������������������� 94 95���������������������������������������������volatile���������������������������������������volatile��������� 96bug���������������������������������������������������������������������volatile������������������������������������ 97������������������������������������ 98 99������������������volatile��������������� ��� ��������������������������������������������������������� 100 101������ 102---- 103 104[1] http://lwn.net/Articles/233481/ 105[2] http://lwn.net/Articles/233482/ 106 107������ 108---- 109 110���������Randy Dunlap������������������������ 111���Jonathan Corbet������ 112������Satyam Sharma���Johannes Stezenbach���Jesper Juhl���Heikki Orsila��� 113H. Peter Anvin���Philipp Hahn���Stefan Richter��������������������������� 114