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