But a core issue with kernel code is being able both to access data items of known length (for example, filesystem data structures or registers on device boards) and to exploit the capabilities of different processors (32-bit and 64-bit architectures, and possibly 16 bit as well).

Several of the problems encountered by kernel developers while porting x86 code to new architectures have been related to incorrect data typing. Adherence to strict data typing and compiling with the -Wall -Wstrict-prototypes flags can prevent most bugs.

Data types used by kernel data are divided into three main classes: standard C types such as int, explicitly sized types such as u32, and types used for specific kernel objects, such as pid_t. We are going to see when and how each of the three typing classes should be used. The final sections of the chapter talk about some other typical problems you might run into when porting driver code from the x86 to other platforms, and introduce the generalized support for linked lists exported by recent kernel headers.

If you follow the guidelines we provide, your driver should compile and run even on platforms on which you are unable to test it.

morgana% misc-progs/datasize arch   Size:  char  shor   int  long   ptr long-long  u8 u16 u32 u64 i686            1     2     4     4     4     8        1   2   4   8 

The program can be used to show that long integers and pointers feature a different size on 64-bit platforms, as demonstrated by running the program on different Linux computers:

arch   Size:  char  shor   int  long   ptr long-long  u8 u16 u32 u64 i386            1     2     4     4     4     8        1   2   4   8 alpha           1     2     4     8     8     8        1   2   4   8 armv4l          1     2     4     4     4     8        1   2   4   8 ia64            1     2     4     8     8     8        1   2   4   8 m68k            1     2     4     4     4     8        1   2   4   8 mips            1     2     4     4     4     8        1   2   4   8 ppc             1     2     4     4     4     8        1   2   4   8 sparc           1     2     4     4     4     8        1   2   4   8 sparc64         1     2     4     4     4     8        1   2   4   8 

kernel: arch   Size:  char short int long  ptr long-long u8 u16 u32 u64 kernel: sparc64         1    2    4    8    8     8       1   2   4   8 

 u8;   /* unsigned byte (8 bits) */ u16;  /* unsigned word (16 bits) */ u32;  /* unsigned 32-bit value */ u64;  /* unsigned 64-bit value */ 

Even when no interface-specific type is defined, it's always important to use the proper data type in a way consistent with the rest of the kernel. A jiffy count, for instance, is always unsigned long, independent of its actual size, so the unsigned long type should always be used when working with jiffies. In this section we concentrate on use of "_t'' types.

The complete list of _t types appears in <linux/types.h>, but the list is rarely useful. When you need a specific type, you'll find it in the prototype of the functions you need to call or in the data structures you use.

In practice, the data items we're talking about aren't usually meant to be printed, so the issue applies only to debugging messages. Most often, the code needs only to store and compare the interface-specific types, in addition to passing them as arguments to library or kernel functions.

Although _t types are the correct solution for most situations, sometimes the right type doesn't exist. This happens for some old interfaces that haven't yet been cleaned up.

A general rule is to be suspicious of explicit constant values. Usually the code has been parameterized using preprocessor macros. This section lists the most important portability problems. Whenever you encounter other values that have been parameterized, you'll be able to find hints in the header files and in the device drivers distributed with the official kernel.

Time Intervals

Page Size

 int order = (14 - PAGE_SHIFT > 0) ? 14 - PAGE_SHIFT : 0; buf = get_free_pages(GFP_KERNEL, order); 

The solution depends on the knowledge that 16 KB is 1<<14. The quotient of two numbers is the difference of their logarithms (orders), and both 14 and PAGE_SHIFT are orders. The value of order is calculated at compile time, and the implementation shown is a safe way to allocate memory for any power of two, independent of PAGE_SIZE.

Byte Order

 u32 _ _cpu_to_le32 (u32); u32 _ _le32_to_cpu (u32); 

These two macros convert a value from whatever the CPU uses to an unsigned, little-endian, 32-bit quantity and back. They work whether your CPU is big-endian or little-endian, and, for that matter, whether it is a 32-bit processor or not. They return their argument unchanged in cases where there is no work to be done. Use of these macros makes it easy to write portable code without having to use a lot of conditional compilation constructs.

There are dozens of similar routines; you can see the full list in <linux/byteorder/big_endian.h> and <linux/byteorder/little_endian.h>. After a while, the pattern is not hard to follow. _ _be64_to_cpu converts an unsigned, big-endian, 64-bit value to the internal CPU representation. _ _le16_to_cpus, instead, handles signed, little-endian, 16-bit quantities. When dealing with pointers, you can also use functions like _ _cpu_to_le32p, which take a pointer to the value to be converted rather than the value itself. See the include file for the rest.

Not all Linux versions defined all the macros that deal with byte ordering. In particular, the linux/byteorderdirectory appeared in version 2.1.72 to make order in the various <asm/byteorder.h> files and remove duplicate definitions. If you use our sysdep.h, you'll be able to use all of the macros available in Linux 2.4 when compiling code for 2.0 or 2.2.

Data Alignment

 #include <asm/unaligned.h> get_unaligned(ptr); put_unaligned(val, ptr); 

These macros are typeless and work for every data item, whether it's one, two, four, or eight bytes long. They are defined with any kernel version.

arch  Align:  char  short  int  long   ptr long-long  u8 u16 u32 u64 i386            1     2     4     4     4     4        1   2   4   4 i686            1     2     4     4     4     4        1   2   4   4 alpha           1     2     4     8     8     8        1   2   4   8 armv4l          1     2     4     4     4     4        1   2   4   4 ia64            1     2     4     8     8     8        1   2   4   8 mips            1     2     4     4     4     8        1   2   4   8 ppc             1     2     4     4     4     8        1   2   4   8 sparc           1     2     4     4     4     8        1   2   4   8 sparc64         1     2     4     4     4     8        1   2   4   8  kernel: arch  Align: char short int long  ptr long-long u8 u16 u32 u64 kernel: sparc64        1    2    4    8    8     8       1   2   4   8 

It's interesting to note that not all platforms align 64-bit values on 64-bit boundaries, so you'll need filler fields to enforce alignment and ensure portability.

 struct list_head {     struct list_head *next, *prev; }; 

Linked lists used in real code are almost invariably made up of some type of structure, each one describing one entry in the list. To use the Linux list facility in your code, you need only embed a list_head inside the structures that make up the list. If your driver maintains a list of things to do, say, its declaration would look something like this:

 struct todo_struct {     struct list_head list;     int priority; /* driver specific */     /* ... add other driver-specific fields */ }; 

 struct list_head todo_list;  INIT_LIST_HEAD(&todo_list); 

Alternatively, lists can be initialized at compile time as follows:

 LIST_HEAD(todo_list); 

Several functions are defined in <linux/list.h> that work with lists:

 list_entry(struct list_head *ptr, type_of_struct, field_name); 

where ptr is a pointer to the struct list_head being used, type_of_struct is the type of the structure containing the ptr, and field_name is the name of the list field within the structure. In our todo_struct structure from before, the list field is called simply list. Thus, we would turn a list entry into its containing structure with a line like this:

 struct todo_struct *todo_ptr =     list_entry(listptr, struct todo_struct, list); 

The list_entry macro takes a little getting used to, but is not that hard to use.

 void todo_add_entry(struct todo_struct *new) {     struct list_head *ptr;     struct todo_struct *entry;      for (ptr = todo_list.next; ptr != &todo_list; ptr = ptr->next) {         entry = list_entry(ptr, struct todo_struct, list);         if (entry->priority < new->priority) {             list_add_tail(&new->list, ptr);             return;         }     }     list_add_tail(&new->list, &todo_struct) } 

The <linux/list.h> file also defines a macro list_for_each that expands to the for loop used in this code. As you may suspect, you must be careful when modifying the list while traversing it.

Figure 10-1 shows how the simple struct list_head is used to maintain a list of data structures.