Using sparse for typechecking¶

“__bitwise” is a type attribute, so you have to do something like this:

typedef int __bitwise pm_request_t;enum pm_request {        PM_SUSPEND = (__force pm_request_t) 1,        PM_RESUME = (__force pm_request_t) 2};

which makes PM_SUSPEND and PM_RESUME “bitwise” integers (the “__force” isthere because sparse will complain about casting to/from a bitwise type,but in this case we really _do_ want to force the conversion). And becausetheenumvalues are all the same type, now “enumpm_request” will be thattype too.

And with gcc, all the “__bitwise”/”__force stuff” goes away, and it allends up looking just like integers to gcc.

Quite frankly, you don’t need theenumthere. The above all really justboils down to one special “int __bitwise” type.

So the simpler way is to just do:

typedef int __bitwise pm_request_t;#define PM_SUSPEND ((__force pm_request_t) 1)#define PM_RESUME ((__force pm_request_t) 2)

and you now have all the infrastructure needed for strict typechecking.

One small note: the constant integer “0” is special. You can use aconstant zero as a bitwise integer type without sparse ever complaining.This is because “bitwise” (as the name implies) was designed for makingsure that bitwise types don’t get mixed up (little-endian vs big-endianvs cpu-endian vs whatever), and there the constant “0” really _is_special.

Using sparse for lock checking¶

The following macros are undefined for gcc and defined during a sparserun to use the “context” tracking feature of sparse, applied tolocking. These annotations tell sparse when a lock is held, withregard to the annotated function’s entry and exit.

__must_hold - The specified lock is held on function entry and exit.

__acquires - The specified lock is held on function exit, but not entry.

__releases - The specified lock is held on function entry, but not exit.

If the function enters and exits without the lock held, acquiring andreleasing the lock inside the function in a balanced way, noannotation is needed. The three annotations above are for cases wheresparse would otherwise report a context imbalance.

Getting sparse¶

You can get tarballs of the latest released versions from:https://www.kernel.org/pub/software/devel/sparse/dist/

Alternatively, you can get snapshots of the latest development versionof sparse using git to clone:

git://git.kernel.org/pub/scm/devel/sparse/sparse.git

Once you have it, just do:

makemake install

as a regular user, and it will install sparse in your ~/bin directory.

Using sparse¶

Do a kernel make with “make C=1” to run sparse on all the C files that getrecompiled, or use “make C=2” to run sparse on the files whether they need tobe recompiled or not. The latter is a fast way to check the whole tree if youhave already built it.

The optional make variable CF can be used to pass arguments to sparse. Thebuild system passes -Wbitwise to sparse automatically.

Note that sparse defines the __CHECKER__ preprocessor symbol.