1Chinese translated version of Documentation/CodingStyle 2 3If you have any comment or update to the content, please post to LKML directly. 4However, if you have problem communicating in English you can also ask the 5Chinese maintainer for help. Contact the Chinese maintainer, if this 6translation is outdated or there is problem with translation. 7 8Chinese maintainer: Zhang Le <r0bertz@gentoo.org> 9--------------------------------------------------------------------- 10Documentation/CodingStyle��������������� 11 12������������������������������������������������������������LKML������������������������������������������������������ 13������������������������������������������������������������������������������������������������������������������������ 14 15��������������������� ������ Zhang Le <r0bertz@gentoo.org> 16��������������������� ������ Zhang Le <r0bertz@gentoo.org> 17��������������������� ������ Wang Cong <xiyou.wangcong@gmail.com> 18 wheelz <kernel.zeng@gmail.com> 19 ��������� Xudong Guan <xudong.guan@gmail.com> 20 Li Zefan <lizf@cn.fujitsu.com> 21 Wang Chen <wangchen@cn.fujitsu.com> 22��������������� 23--------------------------------------------------------------------- 24 25 Linux������������������ 26 27���������������������������������������linux������������������������������������������������������������������������ 28������������������������������������������������������������������������������������������������������������������������ 29������������������������������������������������������������������������������������������������������������������������ 30��������� 31 32���������������������������������GNU��������������������������������������������������������������������������������� 33������������������ 34 35������������������������������������ 36 37 38 ������������������ 39 40������������8������������������������������8���������������������������������������������������4���������2������������ 41���������������������������������������������������������3��� 42 43������������������������������������������������������������������������������������������������������������������������ 44������������20��������������������������������������������������������������������������������� 45 46���������������������������8������������������������������������������������������������80��������������������������� 47������������������������������������������������������������������������3��������������������������������������������� 48��������������������������������������������������������� 49 50���������������8������������������������������������������������������������������������������������������������������ 51������������������������������������������������ 52 53���switch������������������������������������������������������switch������������������������case��������������������� 54���������������������������������������case��������������������� 55 56 switch (suffix) { 57 case 'G': 58 case 'g': 59 mem <<= 30; 60 break; 61 case 'M': 62 case 'm': 63 mem <<= 20; 64 break; 65 case 'K': 66 case 'k': 67 mem <<= 10; 68 /* fall through */ 69 default: 70 break; 71 } 72 73 74��������������������������������������������������������������������������� 75 76 if (condition) do_this; 77 do_something_everytime; 78 79������������������������������������������������������������������������������������������������������������������������ 80��������� 81 82������������������������Kconfig������������������������������������������������������������������������������������ 83 84��������������������������������������������������������� 85 86 87 ������������������������������������������ 88 89������������������������������������������������������������������������������������������������������ 90 91������������������������������80������������������������������������������������ 92 93������80��������������������������������������������������������������������������������������������������������������� 94������������������������������������������������������������������������������������������������������������������������ 95������������������������������������80��������������������������������������������������������������������� 96 97void fun(int a, int b, int c) 98{ 99 if (condition) 100 printk(KERN_WARNING "Warning this is a long printk with " 101 "3 parameters a: %u b: %u " 102 "c: %u \n", a, b, c); 103 else 104 next_statement; 105} 106 107 ��������������������������������������� 108 109C��������������������������������������������������������������������������������������������������������������������� 110���������������������������������������������������������������������Kernighan���Ritchie������������������������ 111������������������������������������������������������������������������������ 112 113 if (x is true) { 114 we do y 115 } 116 117������������������������������������������if���switch���for���while���do��������������� 118 119 switch (action) { 120 case KOBJ_ADD: 121 return "add"; 122 case KOBJ_REMOVE: 123 return "remove"; 124 case KOBJ_CHANGE: 125 return "change"; 126 default: 127 return NULL; 128 } 129 130������������������������������������������������������������������������������������������������������������ 131 132 int function(int x) 133 { 134 body of function 135 } 136 137������������������������������������������������������������������������������������������������������������������������������ 138a���K&R���_���������_������������b���K&R���������������������������������������������������������������C��������� 139��������������������������������� 140 141���������������������������������������������������������������������������������������������������������do������������ 142���while���������if���������������else������������������ 143 144 do { 145 body of do-loop 146 } while (condition); 147 148��� 149 150 if (x == y) { 151 .. 152 } else if (x > y) { 153 ... 154 } else { 155 .... 156 } 157 158���������K&R��� 159 160������������������������������������������������������������������������������������������������������������������������ 161������������������������������������������������������������������������������25��������������������������������������� 162������������������������������ 163 164��������������������������������������������������������������������������� 165 166if (condition) 167 action(); 168 169������������������������������������������������������������������������������������������������������������������������ 170��������� 171 172if (condition) { 173 do_this(); 174 do_that(); 175} else { 176 otherwise(); 177} 178 179 3.1��������� 180 181Linux��������������������������������������������������������������������������������������������������������������� 182���������������������������������������������sizeof���typeof���alignof���__attribute__������������������ 183������������������������������������������������Linux������������������������������������������������C��������������� 184���������������������������������������struct fileinfo info���������������������sizeof info��������� 185 186������������������������������������������������ 187 if, switch, case, for, do, while 188���������������sizeof���typeof���alignof������__attribute__������������������������������������������ 189 s = sizeof(struct file); 190 191������������������������������������������������������������������������ 192 193 s = sizeof( struct file ); 194 195���������������������������������������������������������������*��������������������������������������������������������� 196��������������������������������������������� 197 198 char *linux_banner; 199 unsigned long long memparse(char *ptr, char **retptr); 200 char *match_strdup(substring_t *s); 201 202��������������������������������������������������������������������������������������������������� 203 204 = + - < > * / % | & ^ <= >= == != ? : 205 206������������������������������������������ 207 & * + - ~ ! sizeof typeof alignof __attribute__ defined 208 209������������������������������������������������������ 210 ++ -- 211 212������������������������������������������������������ 213 ++ -- 214 215���.���������->������������������������������������������������ 216 217��������������������������������������������������������������������������������������������������������������������� 218��������������������������������������������������������������������������������������������������������������������� 219��������������������������������������������������������������������������������������������������������������������� 220��������� 221 222���git��������������������������������������������������������������������������������������������������������������� 223������������������������������������������������������������������������������������������������������������������������ 224 225 226 ������������������ 227 228C������������������������������������������������������������Modula-2���Pascal������������������C��������������� 229���������ThisVariableIsATemporaryCounter������������������������C���������������������������������tmp��� 230������������������������������������������������������������������������ 231 232������������������������������������������������������������������������������������������������������������������������ 233������������������������������foo������������������������������������ 234 235������������������������������������������������������������������������������������������������������������������������ 236������������������������������������������������������������������������������������count_active_users()��������� 237���������������������������������������cntuser()������ 238 239��������������������������������������������������������������������������������������������������������������������������� 240������������������������������������������������������������������������������������������������������������������������ 241 242������������������������������������������������������������������������������������������������������������������������ 243������������������������i���������������loop_counter������������������������������������������������������������������ 244���������tmp��������������������������������������������������� 245 246������������������������������������������������������������������������������������������������������������������������ 247��������������������������������� 248 249 250 ������������Typedef 251 252���������������������vps_t��������������������� 253 254���������������������������typedef��������������������������������������������� 255 256 vps_t a; 257 258��������������������������� 259 260������������������������ 261 262 struct virtual_container *a; 263 264���������������a������������������ 265 266���������������typedef��������������������������������������������������������������������������������������� 267 268 (a) ���������������������������������������������������������typedef��������������������������������������������� 269 270 ������������pte_t��������������������������������������������������������������������������� 271 272 ���������������������������������������������������������������������������pte_t��������������������������������� 273 ��������������������������������������������� 274 275 (b) ������������������������������������������������������������������������������int������������long��������������� 276 277 u8/u16/u32������������������������typedef������������������������������(d)������������������ 278 279 ���������������������������������������������������������������������������unsigned long������������������������ 280 281 typedef unsigned long myflags_t; 282 283 ���������������������������������������������������������������������������������������unsigned int��������� 284 ���������������������������unsigned long���������������������������������������������typedef��� 285 286 (c) ������������sparse��������������������������������������������������������������� 287 288 (d) ���������C99������������������������������������������������������ 289 290 ������������������������������������������������������������uint32_t������������������������������������������ 291 ������������������������������ 292 293 ���������Linux������������������������������������u8/u16/u32/u64������������������������������������������ 294 ������������������������������������������������������������������������������������������ 295 296 ������������������������������������������������������������������������������������������������������������������ 297 298 (e) ��������������������������������������������� 299 300 ���������������������������������������������������������������C99���������������������������������������u32��� 301 ���������������������������������������������������������������������������__u32��������������������� 302 303������������������������������������������������������������������������typedef������������������������������������ 304������������������������������ 305 306������������������������������������������������������������������������������������������������������������������������ 307���������������typedef��� 308 309 310 ������������������ 311 312������������������������������������������������������������������������������������������������������������������������ 313���ISO/ANSI���������������80x24������������������������������������������������ 314 315������������������������������������������������������������������������������������������������������������������������ 316���������������������������������������������������case������������������������������������������case��������������� 317������������������������������������������������������������������ 318 319������������������������������������������������������������������������������������������������������������������������ 320������������������������������������������������������������������������������������������������������������������������ 321������������������������������������������������������������������������������������������������������������������������ 322��������������������������������������������������������������� 323 324���������������������������������������������������������������������������������5���10������������������������������ 325������������������������������������������������������������������������������������������������������������������������ 326���7������������������������������������������������������������������������������������������������������������������2 327������������������������������ 328 329���������������������������������������������������������������������������������������������EXPORT*��������������� 330������������������������������������������ 331 332int system_is_up(void) 333{ 334 return system_state == SYSTEM_RUNNING; 335} 336EXPORT_SYMBOL(system_is_up); 337 338���������������������������������������������������������������������C������������������������������������Linux������ 339������������������������������������������������������������������������������������������������ 340 341 342 ��������������������������������������� 343 344���������������������������������������������goto��������������������������������������������������������������������� 345������������������������ 346 347������������������������������������������������������������������������������������������goto������������������������ 348������ 349 350������������ 351 352- ������������������������������������ 353- ������������������ 354- ��������������������������������������������������������������������������������� 355- ������������������������������������������������������;) 356 357int fun(int a) 358{ 359 int result = 0; 360 char *buffer = kmalloc(SIZE); 361 362 if (buffer == NULL) 363 return -ENOMEM; 364 365 if (condition1) { 366 while (loop1) { 367 ... 368 } 369 result = 1; 370 goto out; 371 } 372 ... 373out: 374 kfree(buffer); 375 return result; 376} 377 378 ������������������ 379 380������������������������������������������������������������������������������������������������������������������������ 381������������������������������������������������������������������������������������������������������ 382 383������������������������������������������������������������������������������������������������������������������������ 384������������������������������������������������������������������������������������������������������������������������ 385������������������������������������������������������������������������������������������������������������������������ 386������������������������������������������������������������������������������������������������������������������������ 387��������������������� 388 389���������������API���������������������kernel-doc��������������� 390Documentation/kernel-doc-nano-HOWTO.txt���scripts/kernel-doc������������������������ 391 392Linux������������������C89���/* ... */������������������������C99���������// ...������������ 393 394������������������������������������������ 395 396 /* 397 * This is the preferred style for multi-line 398 * comments in the Linux kernel source code. 399 * Please use it consistently. 400 * 401 * Description: A column of asterisks on the left side, 402 * with beginning and ending almost-blank lines. 403 */ 404 405������������������������������������������������������������������������������������������������������������������������ 406������������������������������������������������������������������������������������������������������������������������ 407��������������������������������������� 408 409 410 ��������������������������������������� 411 412���������������������������������������������������������������������Unix���������������������������GNU emacs������ 413���������������������C������������������������������������������������������������������������������������������������ 414������������������������������������������������������������������������������������������GNU emacs������������������ 415���������������������������������������������������Infinite Monkey Theorem��� 416 417���������������������GNU emacs������������������������������������������������������������������������������������ 418���������������������������������.emacs������������ 419 420(defun linux-c-mode () 421 "C mode with adjusted defaults for use with the Linux kernel." 422 (interactive) 423 (c-mode) 424 (c-set-style "K&R") 425 (setq tab-width 8) 426 (setq indent-tabs-mode t) 427 (setq c-basic-offset 8)) 428 429������������������M-x linux-c-mode���������������hack��������������������������������������������� 430-*- linux-c -*-������������������������������������������������������������������������������������������������ 431/usr/src/linux������������������������������������linux-c-mode��������������������������������� 432 433(setq auto-mode-alist (cons '("/usr/src/linux.*/.*\\.[ch]$" . linux-c-mode) 434 auto-mode-alist)) 435 436���������.emacs������������ 437 438������������������������emacs������������������������������������������������������������������������������������������ 439indent������ 440 441���������GNU indent���������GNU emacs������������������������������������������������������������������������ 442���������������������������������������������GNU indent������������������K&R���������������GNU������������������ 443���������������������������������������������������������������������������������indent���������������-kr -i8��� 444������������K&R���8���������������������������������������scripts/Lindent������������������������������������������ 445������������������ 446 447���indent��������������������������������������������������������������������������������������������������������������� 448������������indent������������������������������������ 449 450 451 ������������Kconfig������������ 452 453������������������������������Kconfig*������������������������������������������C��������������������������������� 454������config������������������������������������������������������������������������2��������������������� 455 456config AUDIT 457 bool "Auditing support" 458 depends on NET 459 help 460 Enable auditing infrastructure that can be used with another 461 kernel subsystem, such as SELinux (which requires this for 462 logging of avc messages output). Does not do system-call 463 auditing without CONFIG_AUDITSYSCALL. 464 465������������������������������������������������������������������������������������������������������������������������ 466��������� 467 468config ADFS_FS_RW 469 bool "ADFS write support (DANGEROUS)" 470 depends on ADFS_FS 471 ... 472 473���������������������������������������������Documentation/kbuild/kconfig-language.txt��� 474 475 476 ��������������������������� 477 478������������������������������������������������������������������������������������������������������������������������ 479������������������������������������������������������������������������������������������������������������������������ 480��������������������������������������������������� 481 482��������������������������������������������������������������������������������������������������������������������������� 483������������������������������������������������������������������������������������������������������������������������ 484������������������������ 485 486������������������������������������������������������������������������������������������������������������������������ 487��������������������������������������������������������������� 488 489������������������������������2������������������������������������������������������������������������������������������ 490��������������������������������������������������������������������������� 491 492������������������������������������������������������������������struct mm_struct������mm_users���mm_count��� 493���������������������struct super_block������s_count���s_active��������������� 494 495������������������������������������������������������������������������������������������������������������������������ 496������������������������bug��� 497 498 499 ������������������������������RTL 500 501��������������������������������������������������������������������� 502 503#define CONSTANT 0x12345 504 505������������������������������������������������������ 506 507������������������������������������������������������������������������������������������ 508 509������������������������������������������������������������������������ 510 511������������������������������������������������do-while��������������� 512 513#define macrofun(a, b, c) \ 514 do { \ 515 if (a == 5) \ 516 do_this(b, c); \ 517 } while (0) 518 519��������������������������������������� 520 5211) ��������������������������� 522 523#define FOO(x) \ 524 do { \ 525 if (blah(x) < 0) \ 526 return -EBUGGERED; \ 527 } while(0) 528 529��������������������������������������������������������������������������������������������������������������������������� 530��������������������� 531 5322) ��������������������������������������������������� 533 534#define FOO(val) bar(index, val) 535 536������������������������������������������������������������������������������������������������������������������������ 537��������������������������������� 538 5393) ��������������������������������� FOO(x) = y������������������FOO������������������������������������������ 540��������������������� 541 5424) ������������������������������������������������������������������������������������������������������������������ 543������������������������������ 544 545#define CONSTANT 0x4000 546#define CONSTEXP (CONSTANT | 3) 547 548cpp���������������������������������Gcc internals������������������������RTL������������register 549transfer language������������������������������������������������ 550 551 552 ��������������������������������� 553 554������������������������������������������������������������������������������������������������������������������������ 555������������������������������dont������������������do not������������don't��������������������������������������������� 556��������� 557 558������������������������������������������������������������������������ 559 560���������������������������(%d)��������������������������������������������� 561 562<linux/device.h>��������������������������������������������������������������������������������������������� 563���������������������������������������������������������������������������dev_err(), dev_warn(), 564dev_info()������������������������������������������������������������������<linux/kernel.h>��������� 565pr_debug()���pr_info()��� 566 567��������������������������������������������������������������������������������������������������������������������� 568���������������������������������DEBUG��������������������������������������������������������������������������� 569���������������������������������������������������������������������������������dev_dbg()������pr_debug()��� 570������������������������������������������������������Kconfig���������������-DDEBUG������������������������������ 571���������VERBOSE_DEBUG���������dev_vdbg()������������������������DEBUG������������������������ 572 573 574 ��������������������������� 575 576������������������������������������������������������������kmalloc()���kzalloc()���kcalloc()��� 577vmalloc()������������API��������������������������������������������� 578 579��������������������������������������������������� 580 581 p = kmalloc(sizeof(*p), ...); 582 583������������������������������sizeof��������������������������������������������������������������������������������� 584���bug���������������������������������������������������������������������������������������sizeof������������������ 585 586������������������void������������������������������C������������������������void��������������������������������� 587������������������������������ 588 589 590 ��������������������������� 591 592������������������������������������������gcc������������������������������������������������������������������������ 593������������������������������������������������������������������������������������������������������������������������ 594���������inline������������������������������������������������������������������������������������������������������ 595������������������������������������������������������������������������������������������������������������������������ 596���pagecache���������������������������������������������pagecache��������������������������������������������� 597������5���������5������������������CPU������������������������������ 598 599���������������������������������������������3������������������������������������������������������������������������ 600������������������������������������������������������������������������������������������������������������������������ 601���������������������������������������������������������������������inline������������kmalloc()��������������� 602��������������������������� 603 604���������������������static���������������������������������������inline������������������������������������������ 605���������������������������������������������������������������������������������������������������������inline gcc 606���������������������������������������������������������������������inline���������������������������������inline 607��������������������������������������� 608 609 610 ��������������������������������������� 611 612������������������������������������������������������������������������������������������������������������������������ 613������������������������������������������������������-Exxx������������0������������������������������������������������ 6140���������������0��������������� 615 616���������������������������������������������������bug������������������C��������������������������������������������� 617���������������������������������������������������������������������C������������������������������������������bug������ 618������������������������ 619 620 ������������������������������������������������������������������������������������������������������������ 621 ������������������������������������������������������������������������������������ 622 623������������add work���������������������������add_work()������������������������0���������������������-EBUSY��� 624���������������������PCI device present���������������������������pci_dev_present()��������������������� 625������������������������������������1���������������������������������0��� 626 627������������������������EXPORT��������������������������������������������������������������������������������������� 628������static������������������������������������������������������������ 629 630������������������������������������������������������������������������������������������������������������������������ 631������������������������������������������������������������������������������������������������������������������������ 632NULL������ERR_PTR������������������������ 633 634 635 ������������������������������������������ 636 637���������include/linux/kernel.h������������������������������������������������������������������������������ 638������������������������������������������������������������������������������ 639 640 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) 641 642������������������������������������������������������������������ 643 644 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f)) 645 646���������������������������������������min()���max()��������������������������������������������������������������� 647������������������������������������������������������������������������������������������������������������������������ 648��������������������� 649 650 651 ��������������������������������������������������������������� 652 653������������������������������������������������������������������������������������������������������������emacs 654��������������������������������������� 655 656-*- mode: c -*- 657 658������������������ 659 660/* 661Local Variables: 662compile-command: "gcc -DMAGIC_DEBUG_FLAG foo.c" 663End: 664*/ 665 666Vim������������������������������ 667 668/* vim:set sw=8 noet */ 669 670��������������������������������������������������������������������������������������������������������������������� 671��������������������������������������������������������������������������������������������������������������������� 672��������������������������������������������������������������������� 673 674 675 676 ������ I��������� 677 678The C Programming Language, ���������, ������Brian W. Kernighan���Denni 679M. Ritchie. Prentice Hall, Inc., 1988. ISBN 0-13-110362-8 (������), 6800-13-110370-9 (������). URL: http://cm.bell-labs.com/cm/cs/cbook/ 681 682The Practice of Programming ������Brian W. Kernighan���Rob Pike. Addison-Wesley, 683Inc., 1999. ISBN 0-201-61586-X. URL: http://cm.bell-labs.com/cm/cs/tpop/ 684 685cpp���gcc���gcc internals���indent���GNU���������������K&R��������������������������������������������� 686http://www.gnu.org/manual/������ 687 688WG14���C������������������������������������URL: http://www.open-std.org/JTC1/SC22/WG14/ 689 690Kernel CodingStyle���������greg@kroah.com���������OLS 2002��� 691http://www.kroah.com/linux/talks/ols_2002_kernel_codingstyle_talk/html/ 692 693-- 694���������������2007���7���13������ 695