You've already forked linux-apfs
mirror of
https://github.com/linux-apfs/linux-apfs.git
synced 2026-05-01 15:00:59 -07:00
Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
This commit is contained in:
Linus Torvalds
Executable
+2
@@ -0,0 +1,2 @@
|
||||
#!/bin/sh
|
||||
indent -kr -i8 -ts8 -sob -l80 -ss -ncs "$@"
|
||||
@@ -0,0 +1,22 @@
|
||||
###
|
||||
# scripts contains sources for various helper programs used throughout
|
||||
# the kernel for the build process.
|
||||
# ---------------------------------------------------------------------------
|
||||
# kallsyms: Find all symbols in vmlinux
|
||||
# pnmttologo: Convert pnm files to logo files
|
||||
# conmakehash: Create chartable
|
||||
# conmakehash: Create arrays for initializing the kernel console tables
|
||||
|
||||
hostprogs-$(CONFIG_KALLSYMS) += kallsyms
|
||||
hostprogs-$(CONFIG_LOGO) += pnmtologo
|
||||
hostprogs-$(CONFIG_VT) += conmakehash
|
||||
hostprogs-$(CONFIG_PROM_CONSOLE) += conmakehash
|
||||
hostprogs-$(CONFIG_IKCONFIG) += bin2c
|
||||
|
||||
always := $(hostprogs-y)
|
||||
|
||||
subdir-$(CONFIG_MODVERSIONS) += genksyms
|
||||
subdir-$(CONFIG_MODULES) += mod
|
||||
|
||||
# Let clean descend into subdirs
|
||||
subdir- += basic lxdialog kconfig package
|
||||
@@ -0,0 +1,330 @@
|
||||
# ==========================================================================
|
||||
# Building
|
||||
# ==========================================================================
|
||||
|
||||
src := $(obj)
|
||||
|
||||
.PHONY: __build
|
||||
__build:
|
||||
|
||||
# Read .config if it exist, otherwise ignore
|
||||
-include .config
|
||||
|
||||
include $(if $(wildcard $(obj)/Kbuild), $(obj)/Kbuild, $(obj)/Makefile)
|
||||
|
||||
include scripts/Makefile.lib
|
||||
|
||||
ifdef host-progs
|
||||
ifneq ($(hostprogs-y),$(host-progs))
|
||||
$(warning kbuild: $(obj)/Makefile - Usage of host-progs is deprecated. Please replace with hostprogs-y!)
|
||||
hostprogs-y += $(host-progs)
|
||||
endif
|
||||
endif
|
||||
|
||||
# Do not include host rules unles needed
|
||||
ifneq ($(hostprogs-y)$(hostprogs-m),)
|
||||
include scripts/Makefile.host
|
||||
endif
|
||||
|
||||
ifneq ($(KBUILD_SRC),)
|
||||
# Create output directory if not already present
|
||||
_dummy := $(shell [ -d $(obj) ] || mkdir -p $(obj))
|
||||
|
||||
# Create directories for object files if directory does not exist
|
||||
# Needed when obj-y := dir/file.o syntax is used
|
||||
_dummy := $(foreach d,$(obj-dirs), $(shell [ -d $(d) ] || mkdir -p $(d)))
|
||||
endif
|
||||
|
||||
|
||||
ifdef EXTRA_TARGETS
|
||||
$(warning kbuild: $(obj)/Makefile - Usage of EXTRA_TARGETS is obsolete in 2.6. Please fix!)
|
||||
endif
|
||||
|
||||
ifdef build-targets
|
||||
$(warning kbuild: $(obj)/Makefile - Usage of build-targets is obsolete in 2.6. Please fix!)
|
||||
endif
|
||||
|
||||
ifdef export-objs
|
||||
$(warning kbuild: $(obj)/Makefile - Usage of export-objs is obsolete in 2.6. Please fix!)
|
||||
endif
|
||||
|
||||
ifdef O_TARGET
|
||||
$(warning kbuild: $(obj)/Makefile - Usage of O_TARGET := $(O_TARGET) is obsolete in 2.6. Please fix!)
|
||||
endif
|
||||
|
||||
ifdef L_TARGET
|
||||
$(error kbuild: $(obj)/Makefile - Use of L_TARGET is replaced by lib-y in 2.6. Please fix!)
|
||||
endif
|
||||
|
||||
ifdef list-multi
|
||||
$(warning kbuild: $(obj)/Makefile - list-multi := $(list-multi) is obsolete in 2.6. Please fix!)
|
||||
endif
|
||||
|
||||
ifndef obj
|
||||
$(warning kbuild: Makefile.build is included improperly)
|
||||
endif
|
||||
|
||||
# ===========================================================================
|
||||
|
||||
ifneq ($(strip $(lib-y) $(lib-m) $(lib-n) $(lib-)),)
|
||||
lib-target := $(obj)/lib.a
|
||||
endif
|
||||
|
||||
ifneq ($(strip $(obj-y) $(obj-m) $(obj-n) $(obj-) $(lib-target)),)
|
||||
builtin-target := $(obj)/built-in.o
|
||||
endif
|
||||
|
||||
# We keep a list of all modules in $(MODVERDIR)
|
||||
|
||||
__build: $(if $(KBUILD_BUILTIN),$(builtin-target) $(lib-target) $(extra-y)) \
|
||||
$(if $(KBUILD_MODULES),$(obj-m)) \
|
||||
$(subdir-ym) $(always)
|
||||
@:
|
||||
|
||||
# Linus' kernel sanity checking tool
|
||||
ifneq ($(KBUILD_CHECKSRC),0)
|
||||
ifeq ($(KBUILD_CHECKSRC),2)
|
||||
quiet_cmd_force_checksrc = CHECK $<
|
||||
cmd_force_checksrc = $(CHECK) $(CHECKFLAGS) $(c_flags) $< ;
|
||||
else
|
||||
quiet_cmd_checksrc = CHECK $<
|
||||
cmd_checksrc = $(CHECK) $(CHECKFLAGS) $(c_flags) $< ;
|
||||
endif
|
||||
endif
|
||||
|
||||
|
||||
# Compile C sources (.c)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
# Default is built-in, unless we know otherwise
|
||||
modkern_cflags := $(CFLAGS_KERNEL)
|
||||
quiet_modtag := $(empty) $(empty)
|
||||
|
||||
$(real-objs-m) : modkern_cflags := $(CFLAGS_MODULE)
|
||||
$(real-objs-m:.o=.i) : modkern_cflags := $(CFLAGS_MODULE)
|
||||
$(real-objs-m:.o=.s) : modkern_cflags := $(CFLAGS_MODULE)
|
||||
$(real-objs-m:.o=.lst): modkern_cflags := $(CFLAGS_MODULE)
|
||||
|
||||
$(real-objs-m) : quiet_modtag := [M]
|
||||
$(real-objs-m:.o=.i) : quiet_modtag := [M]
|
||||
$(real-objs-m:.o=.s) : quiet_modtag := [M]
|
||||
$(real-objs-m:.o=.lst): quiet_modtag := [M]
|
||||
|
||||
$(obj-m) : quiet_modtag := [M]
|
||||
|
||||
# Default for not multi-part modules
|
||||
modname = $(*F)
|
||||
|
||||
$(multi-objs-m) : modname = $(modname-multi)
|
||||
$(multi-objs-m:.o=.i) : modname = $(modname-multi)
|
||||
$(multi-objs-m:.o=.s) : modname = $(modname-multi)
|
||||
$(multi-objs-m:.o=.lst) : modname = $(modname-multi)
|
||||
$(multi-objs-y) : modname = $(modname-multi)
|
||||
$(multi-objs-y:.o=.i) : modname = $(modname-multi)
|
||||
$(multi-objs-y:.o=.s) : modname = $(modname-multi)
|
||||
$(multi-objs-y:.o=.lst) : modname = $(modname-multi)
|
||||
|
||||
quiet_cmd_cc_s_c = CC $(quiet_modtag) $@
|
||||
cmd_cc_s_c = $(CC) $(c_flags) -S -o $@ $<
|
||||
|
||||
%.s: %.c FORCE
|
||||
$(call if_changed_dep,cc_s_c)
|
||||
|
||||
quiet_cmd_cc_i_c = CPP $(quiet_modtag) $@
|
||||
cmd_cc_i_c = $(CPP) $(c_flags) -o $@ $<
|
||||
|
||||
%.i: %.c FORCE
|
||||
$(call if_changed_dep,cc_i_c)
|
||||
|
||||
# C (.c) files
|
||||
# The C file is compiled and updated dependency information is generated.
|
||||
# (See cmd_cc_o_c + relevant part of rule_cc_o_c)
|
||||
|
||||
quiet_cmd_cc_o_c = CC $(quiet_modtag) $@
|
||||
|
||||
ifndef CONFIG_MODVERSIONS
|
||||
cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<
|
||||
|
||||
else
|
||||
# When module versioning is enabled the following steps are executed:
|
||||
# o compile a .tmp_<file>.o from <file>.c
|
||||
# o if .tmp_<file>.o doesn't contain a __ksymtab version, i.e. does
|
||||
# not export symbols, we just rename .tmp_<file>.o to <file>.o and
|
||||
# are done.
|
||||
# o otherwise, we calculate symbol versions using the good old
|
||||
# genksyms on the preprocessed source and postprocess them in a way
|
||||
# that they are usable as a linker script
|
||||
# o generate <file>.o from .tmp_<file>.o using the linker to
|
||||
# replace the unresolved symbols __crc_exported_symbol with
|
||||
# the actual value of the checksum generated by genksyms
|
||||
|
||||
cmd_cc_o_c = $(CC) $(c_flags) -c -o $(@D)/.tmp_$(@F) $<
|
||||
cmd_modversions = \
|
||||
if $(OBJDUMP) -h $(@D)/.tmp_$(@F) | grep -q __ksymtab; then \
|
||||
$(CPP) -D__GENKSYMS__ $(c_flags) $< \
|
||||
| $(GENKSYMS) \
|
||||
> $(@D)/.tmp_$(@F:.o=.ver); \
|
||||
\
|
||||
$(LD) $(LDFLAGS) -r -o $@ $(@D)/.tmp_$(@F) \
|
||||
-T $(@D)/.tmp_$(@F:.o=.ver); \
|
||||
rm -f $(@D)/.tmp_$(@F) $(@D)/.tmp_$(@F:.o=.ver); \
|
||||
else \
|
||||
mv $(@D)/.tmp_$(@F) $@; \
|
||||
fi;
|
||||
endif
|
||||
|
||||
define rule_cc_o_c
|
||||
$(if $($(quiet)cmd_checksrc),echo ' $($(quiet)cmd_checksrc)';) \
|
||||
$(cmd_checksrc) \
|
||||
$(if $($(quiet)cmd_cc_o_c),echo ' $($(quiet)cmd_cc_o_c)';) \
|
||||
$(cmd_cc_o_c); \
|
||||
$(cmd_modversions) \
|
||||
scripts/basic/fixdep $(depfile) $@ '$(cmd_cc_o_c)' > $(@D)/.$(@F).tmp; \
|
||||
rm -f $(depfile); \
|
||||
mv -f $(@D)/.$(@F).tmp $(@D)/.$(@F).cmd
|
||||
endef
|
||||
|
||||
# Built-in and composite module parts
|
||||
|
||||
%.o: %.c FORCE
|
||||
$(call cmd,force_checksrc)
|
||||
$(call if_changed_rule,cc_o_c)
|
||||
|
||||
# Single-part modules are special since we need to mark them in $(MODVERDIR)
|
||||
|
||||
$(single-used-m): %.o: %.c FORCE
|
||||
$(call cmd,force_checksrc)
|
||||
$(call if_changed_rule,cc_o_c)
|
||||
@{ echo $(@:.o=.ko); echo $@; } > $(MODVERDIR)/$(@F:.o=.mod)
|
||||
|
||||
quiet_cmd_cc_lst_c = MKLST $@
|
||||
cmd_cc_lst_c = $(CC) $(c_flags) -g -c -o $*.o $< && \
|
||||
$(CONFIG_SHELL) $(srctree)/scripts/makelst $*.o \
|
||||
System.map $(OBJDUMP) > $@
|
||||
|
||||
%.lst: %.c FORCE
|
||||
$(call if_changed_dep,cc_lst_c)
|
||||
|
||||
# Compile assembler sources (.S)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
modkern_aflags := $(AFLAGS_KERNEL)
|
||||
|
||||
$(real-objs-m) : modkern_aflags := $(AFLAGS_MODULE)
|
||||
$(real-objs-m:.o=.s): modkern_aflags := $(AFLAGS_MODULE)
|
||||
|
||||
quiet_cmd_as_s_S = CPP $(quiet_modtag) $@
|
||||
cmd_as_s_S = $(CPP) $(a_flags) -o $@ $<
|
||||
|
||||
%.s: %.S FORCE
|
||||
$(call if_changed_dep,as_s_S)
|
||||
|
||||
quiet_cmd_as_o_S = AS $(quiet_modtag) $@
|
||||
cmd_as_o_S = $(CC) $(a_flags) -c -o $@ $<
|
||||
|
||||
%.o: %.S FORCE
|
||||
$(call if_changed_dep,as_o_S)
|
||||
|
||||
targets += $(real-objs-y) $(real-objs-m) $(lib-y)
|
||||
targets += $(extra-y) $(MAKECMDGOALS) $(always)
|
||||
|
||||
# Linker scripts preprocessor (.lds.S -> .lds)
|
||||
# ---------------------------------------------------------------------------
|
||||
quiet_cmd_cpp_lds_S = LDS $@
|
||||
cmd_cpp_lds_S = $(CPP) $(cpp_flags) -D__ASSEMBLY__ -o $@ $<
|
||||
|
||||
%.lds: %.lds.S FORCE
|
||||
$(call if_changed_dep,cpp_lds_S)
|
||||
|
||||
# Build the compiled-in targets
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
# To build objects in subdirs, we need to descend into the directories
|
||||
$(sort $(subdir-obj-y)): $(subdir-ym) ;
|
||||
|
||||
#
|
||||
# Rule to compile a set of .o files into one .o file
|
||||
#
|
||||
ifdef builtin-target
|
||||
quiet_cmd_link_o_target = LD $@
|
||||
# If the list of objects to link is empty, just create an empty built-in.o
|
||||
cmd_link_o_target = $(if $(strip $(obj-y)),\
|
||||
$(LD) $(ld_flags) -r -o $@ $(filter $(obj-y), $^),\
|
||||
rm -f $@; $(AR) rcs $@)
|
||||
|
||||
$(builtin-target): $(obj-y) FORCE
|
||||
$(call if_changed,link_o_target)
|
||||
|
||||
targets += $(builtin-target)
|
||||
endif # builtin-target
|
||||
|
||||
#
|
||||
# Rule to compile a set of .o files into one .a file
|
||||
#
|
||||
ifdef lib-target
|
||||
quiet_cmd_link_l_target = AR $@
|
||||
cmd_link_l_target = rm -f $@; $(AR) $(EXTRA_ARFLAGS) rcs $@ $(lib-y)
|
||||
|
||||
$(lib-target): $(lib-y) FORCE
|
||||
$(call if_changed,link_l_target)
|
||||
|
||||
targets += $(lib-target)
|
||||
endif
|
||||
|
||||
#
|
||||
# Rule to link composite objects
|
||||
#
|
||||
# Composite objects are specified in kbuild makefile as follows:
|
||||
# <composite-object>-objs := <list of .o files>
|
||||
# or
|
||||
# <composite-object>-y := <list of .o files>
|
||||
link_multi_deps = \
|
||||
$(filter $(addprefix $(obj)/, \
|
||||
$($(subst $(obj)/,,$(@:.o=-objs))) \
|
||||
$($(subst $(obj)/,,$(@:.o=-y)))), $^)
|
||||
|
||||
quiet_cmd_link_multi-y = LD $@
|
||||
cmd_link_multi-y = $(LD) $(ld_flags) -r -o $@ $(link_multi_deps)
|
||||
|
||||
quiet_cmd_link_multi-m = LD [M] $@
|
||||
cmd_link_multi-m = $(LD) $(ld_flags) $(LDFLAGS_MODULE) -o $@ $(link_multi_deps)
|
||||
|
||||
# We would rather have a list of rules like
|
||||
# foo.o: $(foo-objs)
|
||||
# but that's not so easy, so we rather make all composite objects depend
|
||||
# on the set of all their parts
|
||||
$(multi-used-y) : %.o: $(multi-objs-y) FORCE
|
||||
$(call if_changed,link_multi-y)
|
||||
|
||||
$(multi-used-m) : %.o: $(multi-objs-m) FORCE
|
||||
$(call if_changed,link_multi-m)
|
||||
@{ echo $(@:.o=.ko); echo $(link_multi_deps); } > $(MODVERDIR)/$(@F:.o=.mod)
|
||||
|
||||
targets += $(multi-used-y) $(multi-used-m)
|
||||
|
||||
|
||||
# Descending
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
.PHONY: $(subdir-ym)
|
||||
$(subdir-ym):
|
||||
$(Q)$(MAKE) $(build)=$@
|
||||
|
||||
# Add FORCE to the prequisites of a target to force it to be always rebuilt.
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
.PHONY: FORCE
|
||||
|
||||
FORCE:
|
||||
|
||||
# Read all saved command lines and dependencies for the $(targets) we
|
||||
# may be building above, using $(if_changed{,_dep}). As an
|
||||
# optimization, we don't need to read them if the target does not
|
||||
# exist, we will rebuild anyway in that case.
|
||||
|
||||
targets := $(wildcard $(sort $(targets)))
|
||||
cmd_files := $(wildcard $(foreach f,$(targets),$(dir $(f)).$(notdir $(f)).cmd))
|
||||
|
||||
ifneq ($(cmd_files),)
|
||||
include $(cmd_files)
|
||||
endif
|
||||
@@ -0,0 +1,94 @@
|
||||
# ==========================================================================
|
||||
# Cleaning up
|
||||
# ==========================================================================
|
||||
|
||||
src := $(obj)
|
||||
|
||||
.PHONY: __clean
|
||||
__clean:
|
||||
|
||||
include $(if $(wildcard $(obj)/Kbuild), $(obj)/Kbuild, $(obj)/Makefile)
|
||||
|
||||
# Figure out what we need to build from the various variables
|
||||
# ==========================================================================
|
||||
|
||||
__subdir-y := $(patsubst %/,%,$(filter %/, $(obj-y)))
|
||||
subdir-y += $(__subdir-y)
|
||||
__subdir-m := $(patsubst %/,%,$(filter %/, $(obj-m)))
|
||||
subdir-m += $(__subdir-m)
|
||||
__subdir-n := $(patsubst %/,%,$(filter %/, $(obj-n)))
|
||||
subdir-n += $(__subdir-n)
|
||||
__subdir- := $(patsubst %/,%,$(filter %/, $(obj-)))
|
||||
subdir- += $(__subdir-)
|
||||
|
||||
# Subdirectories we need to descend into
|
||||
|
||||
subdir-ym := $(sort $(subdir-y) $(subdir-m))
|
||||
subdir-ymn := $(sort $(subdir-ym) $(subdir-n) $(subdir-))
|
||||
|
||||
# Add subdir path
|
||||
|
||||
subdir-ymn := $(addprefix $(obj)/,$(subdir-ymn))
|
||||
|
||||
# build a list of files to remove, usually releative to the current
|
||||
# directory
|
||||
|
||||
__clean-files := $(extra-y) $(EXTRA_TARGETS) $(always) \
|
||||
$(targets) $(clean-files) \
|
||||
$(host-progs) \
|
||||
$(hostprogs-y) $(hostprogs-m) $(hostprogs-)
|
||||
|
||||
# as clean-files is given relative to the current directory, this adds
|
||||
# a $(obj) prefix, except for absolute paths
|
||||
|
||||
__clean-files := $(wildcard \
|
||||
$(addprefix $(obj)/, $(filter-out /%, $(__clean-files))) \
|
||||
$(filter /%, $(__clean-files)))
|
||||
|
||||
# as clean-dirs is given relative to the current directory, this adds
|
||||
# a $(obj) prefix, except for absolute paths
|
||||
|
||||
__clean-dirs := $(wildcard \
|
||||
$(addprefix $(obj)/, $(filter-out /%, $(clean-dirs))) \
|
||||
$(filter /%, $(clean-dirs)))
|
||||
|
||||
# ==========================================================================
|
||||
|
||||
quiet_cmd_clean = CLEAN $(obj)
|
||||
cmd_clean = rm -f $(__clean-files)
|
||||
quiet_cmd_cleandir = CLEAN $(__clean-dirs)
|
||||
cmd_cleandir = rm -rf $(__clean-dirs)
|
||||
|
||||
|
||||
__clean: $(subdir-ymn)
|
||||
ifneq ($(strip $(__clean-files)),)
|
||||
+$(call cmd,clean)
|
||||
endif
|
||||
ifneq ($(strip $(__clean-dirs)),)
|
||||
+$(call cmd,cleandir)
|
||||
endif
|
||||
ifneq ($(strip $(clean-rule)),)
|
||||
+$(clean-rule)
|
||||
endif
|
||||
@:
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# Generic stuff
|
||||
# ===========================================================================
|
||||
|
||||
# Descending
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
.PHONY: $(subdir-ymn)
|
||||
$(subdir-ymn):
|
||||
$(Q)$(MAKE) $(clean)=$@
|
||||
|
||||
# If quiet is set, only print short version of command
|
||||
|
||||
cmd = @$(if $($(quiet)cmd_$(1)),echo ' $($(quiet)cmd_$(1))' &&) $(cmd_$(1))
|
||||
|
||||
# Shorthand for $(Q)$(MAKE) scripts/Makefile.clean obj=dir
|
||||
# Usage:
|
||||
# $(Q)$(MAKE) $(clean)=dir
|
||||
clean := -f $(if $(KBUILD_SRC),$(srctree)/)scripts/Makefile.clean obj
|
||||
@@ -0,0 +1,155 @@
|
||||
# ==========================================================================
|
||||
# Building binaries on the host system
|
||||
# Binaries are used during the compilation of the kernel, for example
|
||||
# to preprocess a data file.
|
||||
#
|
||||
# Both C and C++ is supported, but preferred language is C for such utilities.
|
||||
#
|
||||
# Samle syntax (see Documentation/kbuild/makefile.txt for reference)
|
||||
# hostprogs-y := bin2hex
|
||||
# Will compile bin2hex.c and create an executable named bin2hex
|
||||
#
|
||||
# hostprogs-y := lxdialog
|
||||
# lxdialog-objs := checklist.o lxdialog.o
|
||||
# Will compile lxdialog.c and checklist.c, and then link the executable
|
||||
# lxdialog, based on checklist.o and lxdialog.o
|
||||
#
|
||||
# hostprogs-y := qconf
|
||||
# qconf-cxxobjs := qconf.o
|
||||
# qconf-objs := menu.o
|
||||
# Will compile qconf as a C++ program, and menu as a C program.
|
||||
# They are linked as C++ code to the executable qconf
|
||||
|
||||
# hostprogs-y := conf
|
||||
# conf-objs := conf.o libkconfig.so
|
||||
# libkconfig-objs := expr.o type.o
|
||||
# Will create a shared library named libkconfig.so that consist of
|
||||
# expr.o and type.o (they are both compiled as C code and the object file
|
||||
# are made as position independent code).
|
||||
# conf.c is compiled as a c program, and conf.o is linked together with
|
||||
# libkconfig.so as the executable conf.
|
||||
# Note: Shared libraries consisting of C++ files are not supported
|
||||
|
||||
__hostprogs := $(sort $(hostprogs-y)$(hostprogs-m))
|
||||
|
||||
# hostprogs-y := tools/build may have been specified. Retreive directory
|
||||
obj-dirs += $(foreach f,$(__hostprogs), $(if $(dir $(f)),$(dir $(f))))
|
||||
obj-dirs := $(strip $(sort $(filter-out ./,$(obj-dirs))))
|
||||
|
||||
|
||||
# C code
|
||||
# Executables compiled from a single .c file
|
||||
host-csingle := $(foreach m,$(__hostprogs),$(if $($(m)-objs),,$(m)))
|
||||
|
||||
# C executables linked based on several .o files
|
||||
host-cmulti := $(foreach m,$(__hostprogs),\
|
||||
$(if $($(m)-cxxobjs),,$(if $($(m)-objs),$(m))))
|
||||
|
||||
# Object (.o) files compiled from .c files
|
||||
host-cobjs := $(sort $(foreach m,$(__hostprogs),$($(m)-objs)))
|
||||
|
||||
# C++ code
|
||||
# C++ executables compiled from at least on .cc file
|
||||
# and zero or more .c files
|
||||
host-cxxmulti := $(foreach m,$(__hostprogs),$(if $($(m)-cxxobjs),$(m)))
|
||||
|
||||
# C++ Object (.o) files compiled from .cc files
|
||||
host-cxxobjs := $(sort $(foreach m,$(host-cxxmulti),$($(m)-cxxobjs)))
|
||||
|
||||
# Shared libaries (only .c supported)
|
||||
# Shared libraries (.so) - all .so files referenced in "xxx-objs"
|
||||
host-cshlib := $(sort $(filter %.so, $(host-cobjs)))
|
||||
# Remove .so files from "xxx-objs"
|
||||
host-cobjs := $(filter-out %.so,$(host-cobjs))
|
||||
|
||||
#Object (.o) files used by the shared libaries
|
||||
host-cshobjs := $(sort $(foreach m,$(host-cshlib),$($(m:.so=-objs))))
|
||||
|
||||
__hostprogs := $(addprefix $(obj)/,$(__hostprogs))
|
||||
host-csingle := $(addprefix $(obj)/,$(host-csingle))
|
||||
host-cmulti := $(addprefix $(obj)/,$(host-cmulti))
|
||||
host-cobjs := $(addprefix $(obj)/,$(host-cobjs))
|
||||
host-cxxmulti := $(addprefix $(obj)/,$(host-cxxmulti))
|
||||
host-cxxobjs := $(addprefix $(obj)/,$(host-cxxobjs))
|
||||
host-cshlib := $(addprefix $(obj)/,$(host-cshlib))
|
||||
host-cshobjs := $(addprefix $(obj)/,$(host-cshobjs))
|
||||
obj-dirs := $(addprefix $(obj)/,$(obj-dirs))
|
||||
|
||||
#####
|
||||
# Handle options to gcc. Support building with separate output directory
|
||||
|
||||
_hostc_flags = $(HOSTCFLAGS) $(HOST_EXTRACFLAGS) $(HOSTCFLAGS_$(*F).o)
|
||||
_hostcxx_flags = $(HOSTCXXFLAGS) $(HOST_EXTRACXXFLAGS) $(HOSTCXXFLAGS_$(*F).o)
|
||||
|
||||
ifeq ($(KBUILD_SRC),)
|
||||
__hostc_flags = $(_hostc_flags)
|
||||
__hostcxx_flags = $(_hostcxx_flags)
|
||||
else
|
||||
__hostc_flags = -I$(obj) $(call flags,_hostc_flags)
|
||||
__hostcxx_flags = -I$(obj) $(call flags,_hostcxx_flags)
|
||||
endif
|
||||
|
||||
hostc_flags = -Wp,-MD,$(depfile) $(__hostc_flags)
|
||||
hostcxx_flags = -Wp,-MD,$(depfile) $(__hostcxx_flags)
|
||||
|
||||
#####
|
||||
# Compile programs on the host
|
||||
|
||||
# Create executable from a single .c file
|
||||
# host-csingle -> Executable
|
||||
quiet_cmd_host-csingle = HOSTCC $@
|
||||
cmd_host-csingle = $(HOSTCC) $(hostc_flags) $(HOST_LOADLIBES) -o $@ $<
|
||||
$(host-csingle): %: %.c FORCE
|
||||
$(call if_changed_dep,host-csingle)
|
||||
|
||||
# Link an executable based on list of .o files, all plain c
|
||||
# host-cmulti -> executable
|
||||
quiet_cmd_host-cmulti = HOSTLD $@
|
||||
cmd_host-cmulti = $(HOSTCC) $(HOSTLDFLAGS) -o $@ \
|
||||
$(addprefix $(obj)/,$($(@F)-objs)) \
|
||||
$(HOST_LOADLIBES) $(HOSTLOADLIBES_$(@F))
|
||||
$(host-cmulti): %: $(host-cobjs) $(host-cshlib) FORCE
|
||||
$(call if_changed,host-cmulti)
|
||||
|
||||
# Create .o file from a single .c file
|
||||
# host-cobjs -> .o
|
||||
quiet_cmd_host-cobjs = HOSTCC $@
|
||||
cmd_host-cobjs = $(HOSTCC) $(hostc_flags) -c -o $@ $<
|
||||
$(host-cobjs): %.o: %.c FORCE
|
||||
$(call if_changed_dep,host-cobjs)
|
||||
|
||||
# Link an executable based on list of .o files, a mixture of .c and .cc
|
||||
# host-cxxmulti -> executable
|
||||
quiet_cmd_host-cxxmulti = HOSTLD $@
|
||||
cmd_host-cxxmulti = $(HOSTCXX) $(HOSTLDFLAGS) -o $@ \
|
||||
$(foreach o,objs cxxobjs,\
|
||||
$(addprefix $(obj)/,$($(@F)-$(o)))) \
|
||||
$(HOST_LOADLIBES) $(HOSTLOADLIBES_$(@F))
|
||||
$(host-cxxmulti): %: $(host-cobjs) $(host-cxxobjs) $(host-cshlib) FORCE
|
||||
$(call if_changed,host-cxxmulti)
|
||||
|
||||
# Create .o file from a single .cc (C++) file
|
||||
quiet_cmd_host-cxxobjs = HOSTCXX $@
|
||||
cmd_host-cxxobjs = $(HOSTCXX) $(hostcxx_flags) -c -o $@ $<
|
||||
$(host-cxxobjs): %.o: %.cc FORCE
|
||||
$(call if_changed_dep,host-cxxobjs)
|
||||
|
||||
# Compile .c file, create position independent .o file
|
||||
# host-cshobjs -> .o
|
||||
quiet_cmd_host-cshobjs = HOSTCC -fPIC $@
|
||||
cmd_host-cshobjs = $(HOSTCC) $(hostc_flags) -fPIC -c -o $@ $<
|
||||
$(host-cshobjs): %.o: %.c FORCE
|
||||
$(call if_changed_dep,host-cshobjs)
|
||||
|
||||
# Link a shared library, based on position independent .o files
|
||||
# *.o -> .so shared library (host-cshlib)
|
||||
quiet_cmd_host-cshlib = HOSTLLD -shared $@
|
||||
cmd_host-cshlib = $(HOSTCC) $(HOSTLDFLAGS) -shared -o $@ \
|
||||
$(addprefix $(obj)/,$($(@F:.so=-objs))) \
|
||||
$(HOST_LOADLIBES) $(HOSTLOADLIBES_$(@F))
|
||||
$(host-cshlib): %: $(host-cshobjs) FORCE
|
||||
$(call if_changed,host-cshlib)
|
||||
|
||||
targets += $(host-csingle) $(host-cmulti) $(host-cobjs)\
|
||||
$(host-cxxmulti) $(host-cxxobjs) $(host-cshlib) $(host-cshobjs)
|
||||
|
||||
@@ -0,0 +1,267 @@
|
||||
# ===========================================================================
|
||||
# kbuild: Generic definitions
|
||||
# ===========================================================================
|
||||
|
||||
# Standard vars
|
||||
|
||||
comma := ,
|
||||
empty :=
|
||||
space := $(empty) $(empty)
|
||||
|
||||
# Backward compatibility - to be removed...
|
||||
extra-y += $(EXTRA_TARGETS)
|
||||
# Figure out what we need to build from the various variables
|
||||
# ===========================================================================
|
||||
|
||||
# When an object is listed to be built compiled-in and modular,
|
||||
# only build the compiled-in version
|
||||
|
||||
obj-m := $(filter-out $(obj-y),$(obj-m))
|
||||
|
||||
# Libraries are always collected in one lib file.
|
||||
# Filter out objects already built-in
|
||||
|
||||
lib-y := $(filter-out $(obj-y), $(sort $(lib-y) $(lib-m)))
|
||||
|
||||
|
||||
# Handle objects in subdirs
|
||||
# ---------------------------------------------------------------------------
|
||||
# o if we encounter foo/ in $(obj-y), replace it by foo/built-in.o
|
||||
# and add the directory to the list of dirs to descend into: $(subdir-y)
|
||||
# o if we encounter foo/ in $(obj-m), remove it from $(obj-m)
|
||||
# and add the directory to the list of dirs to descend into: $(subdir-m)
|
||||
|
||||
__subdir-y := $(patsubst %/,%,$(filter %/, $(obj-y)))
|
||||
subdir-y += $(__subdir-y)
|
||||
__subdir-m := $(patsubst %/,%,$(filter %/, $(obj-m)))
|
||||
subdir-m += $(__subdir-m)
|
||||
obj-y := $(patsubst %/, %/built-in.o, $(obj-y))
|
||||
obj-m := $(filter-out %/, $(obj-m))
|
||||
|
||||
# Subdirectories we need to descend into
|
||||
|
||||
subdir-ym := $(sort $(subdir-y) $(subdir-m))
|
||||
|
||||
# if $(foo-objs) exists, foo.o is a composite object
|
||||
multi-used-y := $(sort $(foreach m,$(obj-y), $(if $(strip $($(m:.o=-objs)) $($(m:.o=-y))), $(m))))
|
||||
multi-used-m := $(sort $(foreach m,$(obj-m), $(if $(strip $($(m:.o=-objs)) $($(m:.o=-y))), $(m))))
|
||||
multi-used := $(multi-used-y) $(multi-used-m)
|
||||
single-used-m := $(sort $(filter-out $(multi-used-m),$(obj-m)))
|
||||
|
||||
# Build list of the parts of our composite objects, our composite
|
||||
# objects depend on those (obviously)
|
||||
multi-objs-y := $(foreach m, $(multi-used-y), $($(m:.o=-objs)) $($(m:.o=-y)))
|
||||
multi-objs-m := $(foreach m, $(multi-used-m), $($(m:.o=-objs)) $($(m:.o=-y)))
|
||||
multi-objs := $(multi-objs-y) $(multi-objs-m)
|
||||
|
||||
# $(subdir-obj-y) is the list of objects in $(obj-y) which do not live
|
||||
# in the local directory
|
||||
subdir-obj-y := $(foreach o,$(obj-y),$(if $(filter-out $(o),$(notdir $(o))),$(o)))
|
||||
|
||||
# $(obj-dirs) is a list of directories that contain object files
|
||||
obj-dirs := $(dir $(multi-objs) $(subdir-obj-y))
|
||||
|
||||
# Replace multi-part objects by their individual parts, look at local dir only
|
||||
real-objs-y := $(foreach m, $(filter-out $(subdir-obj-y), $(obj-y)), $(if $(strip $($(m:.o=-objs)) $($(m:.o=-y))),$($(m:.o=-objs)) $($(m:.o=-y)),$(m))) $(extra-y)
|
||||
real-objs-m := $(foreach m, $(obj-m), $(if $(strip $($(m:.o=-objs)) $($(m:.o=-y))),$($(m:.o=-objs)) $($(m:.o=-y)),$(m)))
|
||||
|
||||
# Add subdir path
|
||||
|
||||
extra-y := $(addprefix $(obj)/,$(extra-y))
|
||||
always := $(addprefix $(obj)/,$(always))
|
||||
targets := $(addprefix $(obj)/,$(targets))
|
||||
obj-y := $(addprefix $(obj)/,$(obj-y))
|
||||
obj-m := $(addprefix $(obj)/,$(obj-m))
|
||||
lib-y := $(addprefix $(obj)/,$(lib-y))
|
||||
subdir-obj-y := $(addprefix $(obj)/,$(subdir-obj-y))
|
||||
real-objs-y := $(addprefix $(obj)/,$(real-objs-y))
|
||||
real-objs-m := $(addprefix $(obj)/,$(real-objs-m))
|
||||
single-used-m := $(addprefix $(obj)/,$(single-used-m))
|
||||
multi-used-y := $(addprefix $(obj)/,$(multi-used-y))
|
||||
multi-used-m := $(addprefix $(obj)/,$(multi-used-m))
|
||||
multi-objs-y := $(addprefix $(obj)/,$(multi-objs-y))
|
||||
multi-objs-m := $(addprefix $(obj)/,$(multi-objs-m))
|
||||
subdir-ym := $(addprefix $(obj)/,$(subdir-ym))
|
||||
obj-dirs := $(addprefix $(obj)/,$(obj-dirs))
|
||||
|
||||
# The temporary file to save gcc -MD generated dependencies must not
|
||||
# contain a comma
|
||||
depfile = $(subst $(comma),_,$(@D)/.$(@F).d)
|
||||
|
||||
# These flags are needed for modversions and compiling, so we define them here
|
||||
# already
|
||||
# $(modname_flags) #defines KBUILD_MODNAME as the name of the module it will
|
||||
# end up in (or would, if it gets compiled in)
|
||||
# Note: It's possible that one object gets potentially linked into more
|
||||
# than one module. In that case KBUILD_MODNAME will be set to foo_bar,
|
||||
# where foo and bar are the name of the modules.
|
||||
basename_flags = -DKBUILD_BASENAME=$(subst $(comma),_,$(subst -,_,$(*F)))
|
||||
modname_flags = $(if $(filter 1,$(words $(modname))),-DKBUILD_MODNAME=$(subst $(comma),_,$(subst -,_,$(modname))))
|
||||
|
||||
_c_flags = $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$(*F).o)
|
||||
_a_flags = $(AFLAGS) $(EXTRA_AFLAGS) $(AFLAGS_$(*F).o)
|
||||
_cpp_flags = $(CPPFLAGS) $(EXTRA_CPPFLAGS) $(CPPFLAGS_$(@F))
|
||||
|
||||
# If building the kernel in a separate objtree expand all occurrences
|
||||
# of -Idir to -I$(srctree)/dir except for absolute paths (starting with '/').
|
||||
|
||||
ifeq ($(KBUILD_SRC),)
|
||||
__c_flags = $(_c_flags)
|
||||
__a_flags = $(_a_flags)
|
||||
__cpp_flags = $(_cpp_flags)
|
||||
else
|
||||
|
||||
# Prefix -I with $(srctree) if it is not an absolute path
|
||||
addtree = $(if $(filter-out -I/%,$(1)),$(patsubst -I%,-I$(srctree)/%,$(1))) $(1)
|
||||
# Find all -I options and call addtree
|
||||
flags = $(foreach o,$($(1)),$(if $(filter -I%,$(o)),$(call addtree,$(o)),$(o)))
|
||||
|
||||
# -I$(obj) locates generated .h files
|
||||
# $(call addtree,-I$(obj)) locates .h files in srctree, from generated .c files
|
||||
# and locates generated .h files
|
||||
# FIXME: Replace both with specific CFLAGS* statements in the makefiles
|
||||
__c_flags = $(call addtree,-I$(obj)) $(call flags,_c_flags)
|
||||
__a_flags = $(call flags,_a_flags)
|
||||
__cpp_flags = $(call flags,_cpp_flags)
|
||||
endif
|
||||
|
||||
c_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(CPPFLAGS) \
|
||||
$(__c_flags) $(modkern_cflags) \
|
||||
$(basename_flags) $(modname_flags)
|
||||
|
||||
a_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(CPPFLAGS) \
|
||||
$(__a_flags) $(modkern_aflags)
|
||||
|
||||
cpp_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(__cpp_flags)
|
||||
|
||||
ld_flags = $(LDFLAGS) $(EXTRA_LDFLAGS)
|
||||
|
||||
# Finds the multi-part object the current object will be linked into
|
||||
modname-multi = $(sort $(foreach m,$(multi-used),\
|
||||
$(if $(filter $(subst $(obj)/,,$*.o), $($(m:.o=-objs)) $($(m:.o=-y))),$(m:.o=))))
|
||||
|
||||
# Shipped files
|
||||
# ===========================================================================
|
||||
|
||||
quiet_cmd_shipped = SHIPPED $@
|
||||
cmd_shipped = cat $< > $@
|
||||
|
||||
$(obj)/%:: $(src)/%_shipped
|
||||
$(call cmd,shipped)
|
||||
|
||||
# Commands useful for building a boot image
|
||||
# ===========================================================================
|
||||
#
|
||||
# Use as following:
|
||||
#
|
||||
# target: source(s) FORCE
|
||||
# $(if_changed,ld/objcopy/gzip)
|
||||
#
|
||||
# and add target to EXTRA_TARGETS so that we know we have to
|
||||
# read in the saved command line
|
||||
|
||||
# Linking
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
quiet_cmd_ld = LD $@
|
||||
cmd_ld = $(LD) $(LDFLAGS) $(EXTRA_LDFLAGS) $(LDFLAGS_$(@F)) \
|
||||
$(filter-out FORCE,$^) -o $@
|
||||
|
||||
# Objcopy
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
quiet_cmd_objcopy = OBJCOPY $@
|
||||
cmd_objcopy = $(OBJCOPY) $(OBJCOPYFLAGS) $(OBJCOPYFLAGS_$(@F)) $< $@
|
||||
|
||||
# Gzip
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
quiet_cmd_gzip = GZIP $@
|
||||
cmd_gzip = gzip -f -9 < $< > $@
|
||||
|
||||
# ===========================================================================
|
||||
# Generic stuff
|
||||
# ===========================================================================
|
||||
|
||||
ifneq ($(KBUILD_NOCMDDEP),1)
|
||||
# Check if both arguments has same arguments. Result in empty string if equal
|
||||
# User may override this check using make KBUILD_NOCMDDEP=1
|
||||
arg-check = $(strip $(filter-out $(1), $(2)) $(filter-out $(2), $(1)) )
|
||||
|
||||
endif
|
||||
|
||||
# echo command. Short version is $(quiet) equals quiet, otherwise full command
|
||||
echo-cmd = $(if $($(quiet)cmd_$(1)), \
|
||||
echo ' $(subst ','\'',$($(quiet)cmd_$(1)))';)
|
||||
|
||||
# function to only execute the passed command if necessary
|
||||
# >'< substitution is for echo to work, >$< substitution to preserve $ when reloading .cmd file
|
||||
# note: when using inline perl scripts [perl -e '...$$t=1;...'] in $(cmd_xxx) double $$ your perl vars
|
||||
#
|
||||
if_changed = $(if $(strip $? $(call arg-check, $(cmd_$(1)), $(cmd_$@)) ), \
|
||||
@set -e; \
|
||||
$(echo-cmd) \
|
||||
$(cmd_$(1)); \
|
||||
echo 'cmd_$@ := $(subst $$,$$$$,$(subst ','\'',$(cmd_$(1))))' > $(@D)/.$(@F).cmd)
|
||||
|
||||
|
||||
# execute the command and also postprocess generated .d dependencies
|
||||
# file
|
||||
|
||||
if_changed_dep = $(if $(strip $? $(filter-out FORCE $(wildcard $^),$^)\
|
||||
$(call arg-check, $(cmd_$(1)), $(cmd_$@)) ), \
|
||||
@set -e; \
|
||||
$(echo-cmd) \
|
||||
$(cmd_$(1)); \
|
||||
scripts/basic/fixdep $(depfile) $@ '$(subst $$,$$$$,$(subst ','\'',$(cmd_$(1))))' > $(@D)/.$(@F).tmp; \
|
||||
rm -f $(depfile); \
|
||||
mv -f $(@D)/.$(@F).tmp $(@D)/.$(@F).cmd)
|
||||
|
||||
# Usage: $(call if_changed_rule,foo)
|
||||
# will check if $(cmd_foo) changed, or any of the prequisites changed,
|
||||
# and if so will execute $(rule_foo)
|
||||
|
||||
if_changed_rule = $(if $(strip $? $(call arg-check, $(cmd_$(1)), $(cmd_$@)) ),\
|
||||
@set -e; \
|
||||
$(rule_$(1)))
|
||||
|
||||
# If quiet is set, only print short version of command
|
||||
|
||||
cmd = @$(if $($(quiet)cmd_$(1)),echo ' $(subst ','\'',$($(quiet)cmd_$(1)))' &&) $(cmd_$(1))
|
||||
|
||||
# $(call descend,<dir>,<target>)
|
||||
# Recursively call a sub-make in <dir> with target <target>
|
||||
# Usage is deprecated, because make do not see this as an invocation of make.
|
||||
descend =$(Q)$(MAKE) -f $(if $(KBUILD_SRC),$(srctree)/)scripts/Makefile.build obj=$(1) $(2)
|
||||
|
||||
# Shorthand for $(Q)$(MAKE) -f scripts/Makefile.build obj=
|
||||
# Usage:
|
||||
# $(Q)$(MAKE) $(build)=dir
|
||||
build := -f $(if $(KBUILD_SRC),$(srctree)/)scripts/Makefile.build obj
|
||||
|
||||
# filechk is used to check if the content of a generated file is updated.
|
||||
# Sample usage:
|
||||
# define filechk_sample
|
||||
# echo $KERNELRELEASE
|
||||
# endef
|
||||
# version.h : Makefile
|
||||
# $(call filechk,sample)
|
||||
# The rule defined shall write to stdout the content of the new file.
|
||||
# The existing file will be compared with the new one.
|
||||
# - If no file exist it is created
|
||||
# - If the content differ the new file is used
|
||||
# - If they are equal no change, and no timestamp update
|
||||
|
||||
define filechk
|
||||
$(Q)set -e; \
|
||||
echo ' CHK $@'; \
|
||||
mkdir -p $(dir $@); \
|
||||
$(filechk_$(1)) $(2) > $@.tmp; \
|
||||
if [ -r $@ ] && cmp -s $@ $@.tmp; then \
|
||||
rm -f $@.tmp; \
|
||||
else \
|
||||
echo ' UPD $@'; \
|
||||
mv -f $@.tmp $@; \
|
||||
fi
|
||||
endef
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
# ==========================================================================
|
||||
# Installing modules
|
||||
# ==========================================================================
|
||||
|
||||
.PHONY: __modinst
|
||||
__modinst:
|
||||
|
||||
include scripts/Makefile.lib
|
||||
|
||||
#
|
||||
|
||||
__modules := $(sort $(shell grep -h '\.ko' /dev/null $(wildcard $(MODVERDIR)/*.mod)))
|
||||
modules := $(patsubst %.o,%.ko,$(wildcard $(__modules:.ko=.o)))
|
||||
|
||||
.PHONY: $(modules)
|
||||
__modinst: $(modules)
|
||||
@:
|
||||
|
||||
quiet_cmd_modules_install = INSTALL $@
|
||||
cmd_modules_install = mkdir -p $(2); cp $@ $(2)
|
||||
|
||||
# Modules built outside the kernel source tree go into extra by default
|
||||
INSTALL_MOD_DIR ?= extra
|
||||
ext-mod-dir = $(INSTALL_MOD_DIR)$(subst $(KBUILD_EXTMOD),,$(@D))
|
||||
|
||||
modinst_dir = $(if $(KBUILD_EXTMOD),$(ext-mod-dir),kernel/$(@D))
|
||||
|
||||
$(modules):
|
||||
$(call cmd,modules_install,$(MODLIB)/$(modinst_dir))
|
||||
@@ -0,0 +1,110 @@
|
||||
# ===========================================================================
|
||||
# Module versions
|
||||
# ===========================================================================
|
||||
#
|
||||
# Stage one of module building created the following:
|
||||
# a) The individual .o files used for the module
|
||||
# b) A <module>.o file wich is the .o files above linked together
|
||||
# c) A <module>.mod file in $(MODVERDIR)/, listing the name of the
|
||||
# the preliminary <module>.o file, plus all .o files
|
||||
|
||||
# Stage 2 is handled by this file and does the following
|
||||
# 1) Find all modules from the files listed in $(MODVERDIR)/
|
||||
# 2) modpost is then used to
|
||||
# 3) create one <module>.mod.c file pr. module
|
||||
# 4) create one Module.symvers file with CRC for all exported symbols
|
||||
# 5) compile all <module>.mod.c files
|
||||
# 6) final link of the module to a <module.ko> file
|
||||
|
||||
# Step 3 is used to place certain information in the module's ELF
|
||||
# section, including information such as:
|
||||
# Version magic (see include/vermagic.h for full details)
|
||||
# - Kernel release
|
||||
# - SMP is CONFIG_SMP
|
||||
# - PREEMPT is CONFIG_PREEMPT
|
||||
# - GCC Version
|
||||
# Module info
|
||||
# - Module version (MODULE_VERSION)
|
||||
# - Module alias'es (MODULE_ALIAS)
|
||||
# - Module license (MODULE_LICENSE)
|
||||
# - See include/linux/module.h for more details
|
||||
|
||||
# Step 4 is solely used to allow module versioning in external modules,
|
||||
# where the CRC of each module is retreived from the Module.symers file.
|
||||
|
||||
.PHONY: _modpost
|
||||
_modpost: __modpost
|
||||
|
||||
include .config
|
||||
include scripts/Makefile.lib
|
||||
|
||||
symverfile := $(objtree)/Module.symvers
|
||||
|
||||
# Step 1), find all modules listed in $(MODVERDIR)/
|
||||
__modules := $(sort $(shell grep -h '\.ko' /dev/null $(wildcard $(MODVERDIR)/*.mod)))
|
||||
modules := $(patsubst %.o,%.ko, $(wildcard $(__modules:.ko=.o)))
|
||||
|
||||
_modpost: $(modules)
|
||||
|
||||
|
||||
# Step 2), invoke modpost
|
||||
# Includes step 3,4
|
||||
quiet_cmd_modpost = MODPOST
|
||||
cmd_modpost = scripts/mod/modpost \
|
||||
$(if $(CONFIG_MODVERSIONS),-m) \
|
||||
$(if $(CONFIG_MODULE_SRCVERSION_ALL),-a,) \
|
||||
$(if $(KBUILD_EXTMOD),-i,-o) $(symverfile) \
|
||||
$(filter-out FORCE,$^)
|
||||
|
||||
.PHONY: __modpost
|
||||
__modpost: $(wildcard vmlinux) $(modules:.ko=.o) FORCE
|
||||
$(call cmd,modpost)
|
||||
|
||||
# Declare generated files as targets for modpost
|
||||
$(symverfile): __modpost ;
|
||||
$(modules:.ko=.mod.c): __modpost ;
|
||||
|
||||
|
||||
# Step 5), compile all *.mod.c files
|
||||
|
||||
# modname is set to make c_flags define KBUILD_MODNAME
|
||||
modname = $(*F)
|
||||
|
||||
quiet_cmd_cc_o_c = CC $@
|
||||
cmd_cc_o_c = $(CC) $(c_flags) $(CFLAGS_MODULE) \
|
||||
-c -o $@ $<
|
||||
|
||||
$(modules:.ko=.mod.o): %.mod.o: %.mod.c FORCE
|
||||
$(call if_changed_dep,cc_o_c)
|
||||
|
||||
targets += $(modules:.ko=.mod.o)
|
||||
|
||||
# Step 6), final link of the modules
|
||||
quiet_cmd_ld_ko_o = LD [M] $@
|
||||
cmd_ld_ko_o = $(LD) $(LDFLAGS) $(LDFLAGS_MODULE) -o $@ \
|
||||
$(filter-out FORCE,$^)
|
||||
|
||||
$(modules): %.ko :%.o %.mod.o FORCE
|
||||
$(call if_changed,ld_ko_o)
|
||||
|
||||
targets += $(modules)
|
||||
|
||||
|
||||
# Add FORCE to the prequisites of a target to force it to be always rebuilt.
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
.PHONY: FORCE
|
||||
|
||||
FORCE:
|
||||
|
||||
# Read all saved command lines and dependencies for the $(targets) we
|
||||
# may be building above, using $(if_changed{,_dep}). As an
|
||||
# optimization, we don't need to read them if the target does not
|
||||
# exist, we will rebuild anyway in that case.
|
||||
|
||||
targets := $(wildcard $(sort $(targets)))
|
||||
cmd_files := $(wildcard $(foreach f,$(targets),$(dir $(f)).$(notdir $(f)).cmd))
|
||||
|
||||
ifneq ($(cmd_files),)
|
||||
include $(cmd_files)
|
||||
endif
|
||||
@@ -0,0 +1,18 @@
|
||||
###
|
||||
# Makefile.basic list the most basic programs used during the build process.
|
||||
# The programs listed herein is what is needed to do the basic stuff,
|
||||
# such as splitting .config and fix dependency file.
|
||||
# This initial step is needed to avoid files to be recompiled
|
||||
# when kernel configuration changes (which is what happens when
|
||||
# .config is included by main Makefile.
|
||||
# ---------------------------------------------------------------------------
|
||||
# fixdep: Used to generate dependency information during build process
|
||||
# split-include: Divide all config symbols up in a number of files in
|
||||
# include/config/...
|
||||
# docproc: Used in Documentation/docbook
|
||||
|
||||
hostprogs-y := fixdep split-include docproc
|
||||
always := $(hostprogs-y)
|
||||
|
||||
# fixdep is needed to compile other host programs
|
||||
$(addprefix $(obj)/,$(filter-out fixdep,$(always))): $(obj)/fixdep
|
||||
@@ -0,0 +1,398 @@
|
||||
/*
|
||||
* docproc is a simple preprocessor for the template files
|
||||
* used as placeholders for the kernel internal documentation.
|
||||
* docproc is used for documentation-frontend and
|
||||
* dependency-generator.
|
||||
* The two usages have in common that they require
|
||||
* some knowledge of the .tmpl syntax, therefore they
|
||||
* are kept together.
|
||||
*
|
||||
* documentation-frontend
|
||||
* Scans the template file and call kernel-doc for
|
||||
* all occurrences of ![EIF]file
|
||||
* Beforehand each referenced file are scanned for
|
||||
* any exported sympols "EXPORT_SYMBOL()" statements.
|
||||
* This is used to create proper -function and
|
||||
* -nofunction arguments in calls to kernel-doc.
|
||||
* Usage: docproc doc file.tmpl
|
||||
*
|
||||
* dependency-generator:
|
||||
* Scans the template file and list all files
|
||||
* referenced in a format recognized by make.
|
||||
* Usage: docproc depend file.tmpl
|
||||
* Writes dependency information to stdout
|
||||
* in the following format:
|
||||
* file.tmpl src.c src2.c
|
||||
* The filenames are obtained from the following constructs:
|
||||
* !Efilename
|
||||
* !Ifilename
|
||||
* !Dfilename
|
||||
* !Ffilename
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <unistd.h>
|
||||
#include <limits.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
|
||||
/* exitstatus is used to keep track of any failing calls to kernel-doc,
|
||||
* but execution continues. */
|
||||
int exitstatus = 0;
|
||||
|
||||
typedef void DFL(char *);
|
||||
DFL *defaultline;
|
||||
|
||||
typedef void FILEONLY(char * file);
|
||||
FILEONLY *internalfunctions;
|
||||
FILEONLY *externalfunctions;
|
||||
FILEONLY *symbolsonly;
|
||||
|
||||
typedef void FILELINE(char * file, signed char * line);
|
||||
FILELINE * singlefunctions;
|
||||
FILELINE * entity_system;
|
||||
|
||||
#define MAXLINESZ 2048
|
||||
#define MAXFILES 250
|
||||
#define KERNELDOCPATH "scripts/"
|
||||
#define KERNELDOC "kernel-doc"
|
||||
#define DOCBOOK "-docbook"
|
||||
#define FUNCTION "-function"
|
||||
#define NOFUNCTION "-nofunction"
|
||||
|
||||
void usage (void)
|
||||
{
|
||||
fprintf(stderr, "Usage: docproc {doc|depend} file\n");
|
||||
fprintf(stderr, "Input is read from file.tmpl. Output is sent to stdout\n");
|
||||
fprintf(stderr, "doc: frontend when generating kernel documentation\n");
|
||||
fprintf(stderr, "depend: generate list of files referenced within file\n");
|
||||
}
|
||||
|
||||
/*
|
||||
* Execute kernel-doc with parameters givin in svec
|
||||
*/
|
||||
void exec_kernel_doc(char **svec)
|
||||
{
|
||||
pid_t pid;
|
||||
int ret;
|
||||
char real_filename[PATH_MAX + 1];
|
||||
/* Make sure output generated so far are flushed */
|
||||
fflush(stdout);
|
||||
switch(pid=fork()) {
|
||||
case -1:
|
||||
perror("fork");
|
||||
exit(1);
|
||||
case 0:
|
||||
memset(real_filename, 0, sizeof(real_filename));
|
||||
strncat(real_filename, getenv("SRCTREE"), PATH_MAX);
|
||||
strncat(real_filename, KERNELDOCPATH KERNELDOC,
|
||||
PATH_MAX - strlen(real_filename));
|
||||
execvp(real_filename, svec);
|
||||
fprintf(stderr, "exec ");
|
||||
perror(real_filename);
|
||||
exit(1);
|
||||
default:
|
||||
waitpid(pid, &ret ,0);
|
||||
}
|
||||
if (WIFEXITED(ret))
|
||||
exitstatus |= WEXITSTATUS(ret);
|
||||
else
|
||||
exitstatus = 0xff;
|
||||
}
|
||||
|
||||
/* Types used to create list of all exported symbols in a number of files */
|
||||
struct symbols
|
||||
{
|
||||
char *name;
|
||||
};
|
||||
|
||||
struct symfile
|
||||
{
|
||||
char *filename;
|
||||
struct symbols *symbollist;
|
||||
int symbolcnt;
|
||||
};
|
||||
|
||||
struct symfile symfilelist[MAXFILES];
|
||||
int symfilecnt = 0;
|
||||
|
||||
void add_new_symbol(struct symfile *sym, char * symname)
|
||||
{
|
||||
sym->symbollist =
|
||||
realloc(sym->symbollist, (sym->symbolcnt + 1) * sizeof(char *));
|
||||
sym->symbollist[sym->symbolcnt++].name = strdup(symname);
|
||||
}
|
||||
|
||||
/* Add a filename to the list */
|
||||
struct symfile * add_new_file(char * filename)
|
||||
{
|
||||
symfilelist[symfilecnt++].filename = strdup(filename);
|
||||
return &symfilelist[symfilecnt - 1];
|
||||
}
|
||||
/* Check if file already are present in the list */
|
||||
struct symfile * filename_exist(char * filename)
|
||||
{
|
||||
int i;
|
||||
for (i=0; i < symfilecnt; i++)
|
||||
if (strcmp(symfilelist[i].filename, filename) == 0)
|
||||
return &symfilelist[i];
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* List all files referenced within the template file.
|
||||
* Files are separated by tabs.
|
||||
*/
|
||||
void adddep(char * file) { printf("\t%s", file); }
|
||||
void adddep2(char * file, signed char * line) { line = line; adddep(file); }
|
||||
void noaction(char * line) { line = line; }
|
||||
void noaction2(char * file, signed char * line) { file = file; line = line; }
|
||||
|
||||
/* Echo the line without further action */
|
||||
void printline(char * line) { printf("%s", line); }
|
||||
|
||||
/*
|
||||
* Find all symbols exported with EXPORT_SYMBOL and EXPORT_SYMBOL_GPL
|
||||
* in filename.
|
||||
* All symbols located are stored in symfilelist.
|
||||
*/
|
||||
void find_export_symbols(char * filename)
|
||||
{
|
||||
FILE * fp;
|
||||
struct symfile *sym;
|
||||
char line[MAXLINESZ];
|
||||
if (filename_exist(filename) == NULL) {
|
||||
char real_filename[PATH_MAX + 1];
|
||||
memset(real_filename, 0, sizeof(real_filename));
|
||||
strncat(real_filename, getenv("SRCTREE"), PATH_MAX);
|
||||
strncat(real_filename, filename,
|
||||
PATH_MAX - strlen(real_filename));
|
||||
sym = add_new_file(filename);
|
||||
fp = fopen(real_filename, "r");
|
||||
if (fp == NULL)
|
||||
{
|
||||
fprintf(stderr, "docproc: ");
|
||||
perror(real_filename);
|
||||
}
|
||||
while(fgets(line, MAXLINESZ, fp)) {
|
||||
signed char *p;
|
||||
signed char *e;
|
||||
if (((p = strstr(line, "EXPORT_SYMBOL_GPL")) != 0) ||
|
||||
((p = strstr(line, "EXPORT_SYMBOL")) != 0)) {
|
||||
/* Skip EXPORT_SYMBOL{_GPL} */
|
||||
while (isalnum(*p) || *p == '_')
|
||||
p++;
|
||||
/* Remove paranteses and additional ws */
|
||||
while (isspace(*p))
|
||||
p++;
|
||||
if (*p != '(')
|
||||
continue; /* Syntax error? */
|
||||
else
|
||||
p++;
|
||||
while (isspace(*p))
|
||||
p++;
|
||||
e = p;
|
||||
while (isalnum(*e) || *e == '_')
|
||||
e++;
|
||||
*e = '\0';
|
||||
add_new_symbol(sym, p);
|
||||
}
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Document all external or internal functions in a file.
|
||||
* Call kernel-doc with following parameters:
|
||||
* kernel-doc -docbook -nofunction function_name1 filename
|
||||
* function names are obtained from all the the src files
|
||||
* by find_export_symbols.
|
||||
* intfunc uses -nofunction
|
||||
* extfunc uses -function
|
||||
*/
|
||||
void docfunctions(char * filename, char * type)
|
||||
{
|
||||
int i,j;
|
||||
int symcnt = 0;
|
||||
int idx = 0;
|
||||
char **vec;
|
||||
|
||||
for (i=0; i <= symfilecnt; i++)
|
||||
symcnt += symfilelist[i].symbolcnt;
|
||||
vec = malloc((2 + 2 * symcnt + 2) * sizeof(char*));
|
||||
if (vec == NULL) {
|
||||
perror("docproc: ");
|
||||
exit(1);
|
||||
}
|
||||
vec[idx++] = KERNELDOC;
|
||||
vec[idx++] = DOCBOOK;
|
||||
for (i=0; i < symfilecnt; i++) {
|
||||
struct symfile * sym = &symfilelist[i];
|
||||
for (j=0; j < sym->symbolcnt; j++) {
|
||||
vec[idx++] = type;
|
||||
vec[idx++] = sym->symbollist[j].name;
|
||||
}
|
||||
}
|
||||
vec[idx++] = filename;
|
||||
vec[idx] = NULL;
|
||||
printf("<!-- %s -->\n", filename);
|
||||
exec_kernel_doc(vec);
|
||||
fflush(stdout);
|
||||
free(vec);
|
||||
}
|
||||
void intfunc(char * filename) { docfunctions(filename, NOFUNCTION); }
|
||||
void extfunc(char * filename) { docfunctions(filename, FUNCTION); }
|
||||
|
||||
/*
|
||||
* Document spåecific function(s) in a file.
|
||||
* Call kernel-doc with the following parameters:
|
||||
* kernel-doc -docbook -function function1 [-function function2]
|
||||
*/
|
||||
void singfunc(char * filename, signed char * line)
|
||||
{
|
||||
char *vec[200]; /* Enough for specific functions */
|
||||
int i, idx = 0;
|
||||
int startofsym = 1;
|
||||
vec[idx++] = KERNELDOC;
|
||||
vec[idx++] = DOCBOOK;
|
||||
|
||||
/* Split line up in individual parameters preceeded by FUNCTION */
|
||||
for (i=0; line[i]; i++) {
|
||||
if (isspace(line[i])) {
|
||||
line[i] = '\0';
|
||||
startofsym = 1;
|
||||
continue;
|
||||
}
|
||||
if (startofsym) {
|
||||
startofsym = 0;
|
||||
vec[idx++] = FUNCTION;
|
||||
vec[idx++] = &line[i];
|
||||
}
|
||||
}
|
||||
vec[idx++] = filename;
|
||||
vec[idx] = NULL;
|
||||
exec_kernel_doc(vec);
|
||||
}
|
||||
|
||||
/*
|
||||
* Parse file, calling action specific functions for:
|
||||
* 1) Lines containing !E
|
||||
* 2) Lines containing !I
|
||||
* 3) Lines containing !D
|
||||
* 4) Lines containing !F
|
||||
* 5) Default lines - lines not matching the above
|
||||
*/
|
||||
void parse_file(FILE *infile)
|
||||
{
|
||||
char line[MAXLINESZ];
|
||||
signed char * s;
|
||||
while(fgets(line, MAXLINESZ, infile)) {
|
||||
if (line[0] == '!') {
|
||||
s = line + 2;
|
||||
switch (line[1]) {
|
||||
case 'E':
|
||||
while (*s && !isspace(*s)) s++;
|
||||
*s = '\0';
|
||||
externalfunctions(line+2);
|
||||
break;
|
||||
case 'I':
|
||||
while (*s && !isspace(*s)) s++;
|
||||
*s = '\0';
|
||||
internalfunctions(line+2);
|
||||
break;
|
||||
case 'D':
|
||||
while (*s && !isspace(*s)) s++;
|
||||
*s = '\0';
|
||||
symbolsonly(line+2);
|
||||
break;
|
||||
case 'F':
|
||||
/* filename */
|
||||
while (*s && !isspace(*s)) s++;
|
||||
*s++ = '\0';
|
||||
/* function names */
|
||||
while (isspace(*s))
|
||||
s++;
|
||||
singlefunctions(line +2, s);
|
||||
break;
|
||||
default:
|
||||
defaultline(line);
|
||||
}
|
||||
}
|
||||
else {
|
||||
defaultline(line);
|
||||
}
|
||||
}
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
FILE * infile;
|
||||
if (argc != 3) {
|
||||
usage();
|
||||
exit(1);
|
||||
}
|
||||
/* Open file, exit on error */
|
||||
infile = fopen(argv[2], "r");
|
||||
if (infile == NULL) {
|
||||
fprintf(stderr, "docproc: ");
|
||||
perror(argv[2]);
|
||||
exit(2);
|
||||
}
|
||||
|
||||
if (strcmp("doc", argv[1]) == 0)
|
||||
{
|
||||
/* Need to do this in two passes.
|
||||
* First pass is used to collect all symbols exported
|
||||
* in the various files.
|
||||
* Second pass generate the documentation.
|
||||
* This is required because function are declared
|
||||
* and exported in different files :-((
|
||||
*/
|
||||
/* Collect symbols */
|
||||
defaultline = noaction;
|
||||
internalfunctions = find_export_symbols;
|
||||
externalfunctions = find_export_symbols;
|
||||
symbolsonly = find_export_symbols;
|
||||
singlefunctions = noaction2;
|
||||
parse_file(infile);
|
||||
|
||||
/* Rewind to start from beginning of file again */
|
||||
fseek(infile, 0, SEEK_SET);
|
||||
defaultline = printline;
|
||||
internalfunctions = intfunc;
|
||||
externalfunctions = extfunc;
|
||||
symbolsonly = printline;
|
||||
singlefunctions = singfunc;
|
||||
|
||||
parse_file(infile);
|
||||
}
|
||||
else if (strcmp("depend", argv[1]) == 0)
|
||||
{
|
||||
/* Create first part of dependency chain
|
||||
* file.tmpl */
|
||||
printf("%s\t", argv[2]);
|
||||
defaultline = noaction;
|
||||
internalfunctions = adddep;
|
||||
externalfunctions = adddep;
|
||||
symbolsonly = adddep;
|
||||
singlefunctions = adddep2;
|
||||
parse_file(infile);
|
||||
printf("\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "Unknown option: %s\n", argv[1]);
|
||||
exit(1);
|
||||
}
|
||||
fclose(infile);
|
||||
fflush(stdout);
|
||||
return exitstatus;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,390 @@
|
||||
/*
|
||||
* "Optimize" a list of dependencies as spit out by gcc -MD
|
||||
* for the kernel build
|
||||
* ===========================================================================
|
||||
*
|
||||
* Author Kai Germaschewski
|
||||
* Copyright 2002 by Kai Germaschewski <kai.germaschewski@gmx.de>
|
||||
*
|
||||
* This software may be used and distributed according to the terms
|
||||
* of the GNU General Public License, incorporated herein by reference.
|
||||
*
|
||||
*
|
||||
* Introduction:
|
||||
*
|
||||
* gcc produces a very nice and correct list of dependencies which
|
||||
* tells make when to remake a file.
|
||||
*
|
||||
* To use this list as-is however has the drawback that virtually
|
||||
* every file in the kernel includes <linux/config.h> which then again
|
||||
* includes <linux/autoconf.h>
|
||||
*
|
||||
* If the user re-runs make *config, linux/autoconf.h will be
|
||||
* regenerated. make notices that and will rebuild every file which
|
||||
* includes autoconf.h, i.e. basically all files. This is extremely
|
||||
* annoying if the user just changed CONFIG_HIS_DRIVER from n to m.
|
||||
*
|
||||
* So we play the same trick that "mkdep" played before. We replace
|
||||
* the dependency on linux/autoconf.h by a dependency on every config
|
||||
* option which is mentioned in any of the listed prequisites.
|
||||
*
|
||||
* To be exact, split-include populates a tree in include/config/,
|
||||
* e.g. include/config/his/driver.h, which contains the #define/#undef
|
||||
* for the CONFIG_HIS_DRIVER option.
|
||||
*
|
||||
* So if the user changes his CONFIG_HIS_DRIVER option, only the objects
|
||||
* which depend on "include/linux/config/his/driver.h" will be rebuilt,
|
||||
* so most likely only his driver ;-)
|
||||
*
|
||||
* The idea above dates, by the way, back to Michael E Chastain, AFAIK.
|
||||
*
|
||||
* So to get dependencies right, there are two issues:
|
||||
* o if any of the files the compiler read changed, we need to rebuild
|
||||
* o if the command line given to the compile the file changed, we
|
||||
* better rebuild as well.
|
||||
*
|
||||
* The former is handled by using the -MD output, the later by saving
|
||||
* the command line used to compile the old object and comparing it
|
||||
* to the one we would now use.
|
||||
*
|
||||
* Again, also this idea is pretty old and has been discussed on
|
||||
* kbuild-devel a long time ago. I don't have a sensibly working
|
||||
* internet connection right now, so I rather don't mention names
|
||||
* without double checking.
|
||||
*
|
||||
* This code here has been based partially based on mkdep.c, which
|
||||
* says the following about its history:
|
||||
*
|
||||
* Copyright abandoned, Michael Chastain, <mailto:mec@shout.net>.
|
||||
* This is a C version of syncdep.pl by Werner Almesberger.
|
||||
*
|
||||
*
|
||||
* It is invoked as
|
||||
*
|
||||
* fixdep <depfile> <target> <cmdline>
|
||||
*
|
||||
* and will read the dependency file <depfile>
|
||||
*
|
||||
* The transformed dependency snipped is written to stdout.
|
||||
*
|
||||
* It first generates a line
|
||||
*
|
||||
* cmd_<target> = <cmdline>
|
||||
*
|
||||
* and then basically copies the .<target>.d file to stdout, in the
|
||||
* process filtering out the dependency on linux/autoconf.h and adding
|
||||
* dependencies on include/config/my/option.h for every
|
||||
* CONFIG_MY_OPTION encountered in any of the prequisites.
|
||||
*
|
||||
* It will also filter out all the dependencies on *.ver. We need
|
||||
* to make sure that the generated version checksum are globally up
|
||||
* to date before even starting the recursive build, so it's too late
|
||||
* at this point anyway.
|
||||
*
|
||||
* The algorithm to grep for "CONFIG_..." is bit unusual, but should
|
||||
* be fast ;-) We don't even try to really parse the header files, but
|
||||
* merely grep, i.e. if CONFIG_FOO is mentioned in a comment, it will
|
||||
* be picked up as well. It's not a problem with respect to
|
||||
* correctness, since that can only give too many dependencies, thus
|
||||
* we cannot miss a rebuild. Since people tend to not mention totally
|
||||
* unrelated CONFIG_ options all over the place, it's not an
|
||||
* efficiency problem either.
|
||||
*
|
||||
* (Note: it'd be easy to port over the complete mkdep state machine,
|
||||
* but I don't think the added complexity is worth it)
|
||||
*/
|
||||
/*
|
||||
* Note 2: if somebody writes HELLO_CONFIG_BOOM in a file, it will depend onto
|
||||
* CONFIG_BOOM. This could seem a bug (not too hard to fix), but please do not
|
||||
* fix it! Some UserModeLinux files (look at arch/um/) call CONFIG_BOOM as
|
||||
* UML_CONFIG_BOOM, to avoid conflicts with /usr/include/linux/autoconf.h,
|
||||
* through arch/um/include/uml-config.h; this fixdep "bug" makes sure that
|
||||
* those files will have correct dependencies.
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/mman.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <limits.h>
|
||||
#include <ctype.h>
|
||||
#include <arpa/inet.h>
|
||||
|
||||
#define INT_CONF ntohl(0x434f4e46)
|
||||
#define INT_ONFI ntohl(0x4f4e4649)
|
||||
#define INT_NFIG ntohl(0x4e464947)
|
||||
#define INT_FIG_ ntohl(0x4649475f)
|
||||
|
||||
char *target;
|
||||
char *depfile;
|
||||
char *cmdline;
|
||||
|
||||
void usage(void)
|
||||
|
||||
{
|
||||
fprintf(stderr, "Usage: fixdep <depfile> <target> <cmdline>\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
void print_cmdline(void)
|
||||
{
|
||||
printf("cmd_%s := %s\n\n", target, cmdline);
|
||||
}
|
||||
|
||||
char * str_config = NULL;
|
||||
int size_config = 0;
|
||||
int len_config = 0;
|
||||
|
||||
/*
|
||||
* Grow the configuration string to a desired length.
|
||||
* Usually the first growth is plenty.
|
||||
*/
|
||||
void grow_config(int len)
|
||||
{
|
||||
while (len_config + len > size_config) {
|
||||
if (size_config == 0)
|
||||
size_config = 2048;
|
||||
str_config = realloc(str_config, size_config *= 2);
|
||||
if (str_config == NULL)
|
||||
{ perror("fixdep:malloc"); exit(1); }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Lookup a value in the configuration string.
|
||||
*/
|
||||
int is_defined_config(const char * name, int len)
|
||||
{
|
||||
const char * pconfig;
|
||||
const char * plast = str_config + len_config - len;
|
||||
for ( pconfig = str_config + 1; pconfig < plast; pconfig++ ) {
|
||||
if (pconfig[ -1] == '\n'
|
||||
&& pconfig[len] == '\n'
|
||||
&& !memcmp(pconfig, name, len))
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Add a new value to the configuration string.
|
||||
*/
|
||||
void define_config(const char * name, int len)
|
||||
{
|
||||
grow_config(len + 1);
|
||||
|
||||
memcpy(str_config+len_config, name, len);
|
||||
len_config += len;
|
||||
str_config[len_config++] = '\n';
|
||||
}
|
||||
|
||||
/*
|
||||
* Clear the set of configuration strings.
|
||||
*/
|
||||
void clear_config(void)
|
||||
{
|
||||
len_config = 0;
|
||||
define_config("", 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Record the use of a CONFIG_* word.
|
||||
*/
|
||||
void use_config(char *m, int slen)
|
||||
{
|
||||
char s[PATH_MAX];
|
||||
char *p;
|
||||
|
||||
if (is_defined_config(m, slen))
|
||||
return;
|
||||
|
||||
define_config(m, slen);
|
||||
|
||||
memcpy(s, m, slen); s[slen] = 0;
|
||||
|
||||
for (p = s; p < s + slen; p++) {
|
||||
if (*p == '_')
|
||||
*p = '/';
|
||||
else
|
||||
*p = tolower((unsigned char)*p);
|
||||
}
|
||||
printf(" $(wildcard include/config/%s.h) \\\n", s);
|
||||
}
|
||||
|
||||
void parse_config_file(signed char *map, size_t len)
|
||||
{
|
||||
int *end = (int *) (map + len);
|
||||
/* start at +1, so that p can never be < map */
|
||||
int *m = (int *) map + 1;
|
||||
signed char *p, *q;
|
||||
|
||||
for (; m < end; m++) {
|
||||
if (*m == INT_CONF) { p = (signed char *) m ; goto conf; }
|
||||
if (*m == INT_ONFI) { p = (signed char *) m-1; goto conf; }
|
||||
if (*m == INT_NFIG) { p = (signed char *) m-2; goto conf; }
|
||||
if (*m == INT_FIG_) { p = (signed char *) m-3; goto conf; }
|
||||
continue;
|
||||
conf:
|
||||
if (p > map + len - 7)
|
||||
continue;
|
||||
if (memcmp(p, "CONFIG_", 7))
|
||||
continue;
|
||||
for (q = p + 7; q < map + len; q++) {
|
||||
if (!(isalnum(*q) || *q == '_'))
|
||||
goto found;
|
||||
}
|
||||
continue;
|
||||
|
||||
found:
|
||||
use_config(p+7, q-p-7);
|
||||
}
|
||||
}
|
||||
|
||||
/* test is s ends in sub */
|
||||
int strrcmp(char *s, char *sub)
|
||||
{
|
||||
int slen = strlen(s);
|
||||
int sublen = strlen(sub);
|
||||
|
||||
if (sublen > slen)
|
||||
return 1;
|
||||
|
||||
return memcmp(s + slen - sublen, sub, sublen);
|
||||
}
|
||||
|
||||
void do_config_file(char *filename)
|
||||
{
|
||||
struct stat st;
|
||||
int fd;
|
||||
void *map;
|
||||
|
||||
fd = open(filename, O_RDONLY);
|
||||
if (fd < 0) {
|
||||
fprintf(stderr, "fixdep: ");
|
||||
perror(filename);
|
||||
exit(2);
|
||||
}
|
||||
fstat(fd, &st);
|
||||
if (st.st_size == 0) {
|
||||
close(fd);
|
||||
return;
|
||||
}
|
||||
map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
|
||||
if ((long) map == -1) {
|
||||
perror("fixdep: mmap");
|
||||
close(fd);
|
||||
return;
|
||||
}
|
||||
|
||||
parse_config_file(map, st.st_size);
|
||||
|
||||
munmap(map, st.st_size);
|
||||
|
||||
close(fd);
|
||||
}
|
||||
|
||||
void parse_dep_file(void *map, size_t len)
|
||||
{
|
||||
signed char *m = map;
|
||||
signed char *end = m + len;
|
||||
signed char *p;
|
||||
char s[PATH_MAX];
|
||||
|
||||
p = strchr(m, ':');
|
||||
if (!p) {
|
||||
fprintf(stderr, "fixdep: parse error\n");
|
||||
exit(1);
|
||||
}
|
||||
memcpy(s, m, p-m); s[p-m] = 0;
|
||||
printf("deps_%s := \\\n", target);
|
||||
m = p+1;
|
||||
|
||||
clear_config();
|
||||
|
||||
while (m < end) {
|
||||
while (m < end && (*m == ' ' || *m == '\\' || *m == '\n'))
|
||||
m++;
|
||||
p = m;
|
||||
while (p < end && *p != ' ') p++;
|
||||
if (p == end) {
|
||||
do p--; while (!isalnum(*p));
|
||||
p++;
|
||||
}
|
||||
memcpy(s, m, p-m); s[p-m] = 0;
|
||||
if (strrcmp(s, "include/linux/autoconf.h") &&
|
||||
strrcmp(s, "arch/um/include/uml-config.h") &&
|
||||
strrcmp(s, ".ver")) {
|
||||
printf(" %s \\\n", s);
|
||||
do_config_file(s);
|
||||
}
|
||||
m = p + 1;
|
||||
}
|
||||
printf("\n%s: $(deps_%s)\n\n", target, target);
|
||||
printf("$(deps_%s):\n", target);
|
||||
}
|
||||
|
||||
void print_deps(void)
|
||||
{
|
||||
struct stat st;
|
||||
int fd;
|
||||
void *map;
|
||||
|
||||
fd = open(depfile, O_RDONLY);
|
||||
if (fd < 0) {
|
||||
fprintf(stderr, "fixdep: ");
|
||||
perror(depfile);
|
||||
exit(2);
|
||||
}
|
||||
fstat(fd, &st);
|
||||
if (st.st_size == 0) {
|
||||
fprintf(stderr,"fixdep: %s is empty\n",depfile);
|
||||
close(fd);
|
||||
return;
|
||||
}
|
||||
map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
|
||||
if ((long) map == -1) {
|
||||
perror("fixdep: mmap");
|
||||
close(fd);
|
||||
return;
|
||||
}
|
||||
|
||||
parse_dep_file(map, st.st_size);
|
||||
|
||||
munmap(map, st.st_size);
|
||||
|
||||
close(fd);
|
||||
}
|
||||
|
||||
void traps(void)
|
||||
{
|
||||
static char test[] __attribute__((aligned(sizeof(int)))) = "CONF";
|
||||
|
||||
if (*(int *)test != INT_CONF) {
|
||||
fprintf(stderr, "fixdep: sizeof(int) != 4 or wrong endianess? %#x\n",
|
||||
*(int *)test);
|
||||
exit(2);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
traps();
|
||||
|
||||
if (argc != 4)
|
||||
usage();
|
||||
|
||||
depfile = argv[1];
|
||||
target = argv[2];
|
||||
cmdline = argv[3];
|
||||
|
||||
print_cmdline();
|
||||
print_deps();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,226 @@
|
||||
/*
|
||||
* split-include.c
|
||||
*
|
||||
* Copyright abandoned, Michael Chastain, <mailto:mec@shout.net>.
|
||||
* This is a C version of syncdep.pl by Werner Almesberger.
|
||||
*
|
||||
* This program takes autoconf.h as input and outputs a directory full
|
||||
* of one-line include files, merging onto the old values.
|
||||
*
|
||||
* Think of the configuration options as key-value pairs. Then there
|
||||
* are five cases:
|
||||
*
|
||||
* key old value new value action
|
||||
*
|
||||
* KEY-1 VALUE-1 VALUE-1 leave file alone
|
||||
* KEY-2 VALUE-2A VALUE-2B write VALUE-2B into file
|
||||
* KEY-3 - VALUE-3 write VALUE-3 into file
|
||||
* KEY-4 VALUE-4 - write an empty file
|
||||
* KEY-5 (empty) - leave old empty file alone
|
||||
*/
|
||||
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define ERROR_EXIT(strExit) \
|
||||
{ \
|
||||
const int errnoSave = errno; \
|
||||
fprintf(stderr, "%s: ", str_my_name); \
|
||||
errno = errnoSave; \
|
||||
perror((strExit)); \
|
||||
exit(1); \
|
||||
}
|
||||
|
||||
|
||||
|
||||
int main(int argc, const char * argv [])
|
||||
{
|
||||
const char * str_my_name;
|
||||
const char * str_file_autoconf;
|
||||
const char * str_dir_config;
|
||||
|
||||
FILE * fp_config;
|
||||
FILE * fp_target;
|
||||
FILE * fp_find;
|
||||
|
||||
int buffer_size;
|
||||
|
||||
char * line;
|
||||
char * old_line;
|
||||
char * list_target;
|
||||
char * ptarget;
|
||||
|
||||
struct stat stat_buf;
|
||||
|
||||
/* Check arg count. */
|
||||
if (argc != 3)
|
||||
{
|
||||
fprintf(stderr, "%s: wrong number of arguments.\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
str_my_name = argv[0];
|
||||
str_file_autoconf = argv[1];
|
||||
str_dir_config = argv[2];
|
||||
|
||||
/* Find a buffer size. */
|
||||
if (stat(str_file_autoconf, &stat_buf) != 0)
|
||||
ERROR_EXIT(str_file_autoconf);
|
||||
buffer_size = 2 * stat_buf.st_size + 4096;
|
||||
|
||||
/* Allocate buffers. */
|
||||
if ( (line = malloc(buffer_size)) == NULL
|
||||
|| (old_line = malloc(buffer_size)) == NULL
|
||||
|| (list_target = malloc(buffer_size)) == NULL )
|
||||
ERROR_EXIT(str_file_autoconf);
|
||||
|
||||
/* Open autoconfig file. */
|
||||
if ((fp_config = fopen(str_file_autoconf, "r")) == NULL)
|
||||
ERROR_EXIT(str_file_autoconf);
|
||||
|
||||
/* Make output directory if needed. */
|
||||
if (stat(str_dir_config, &stat_buf) != 0)
|
||||
{
|
||||
if (mkdir(str_dir_config, 0755) != 0)
|
||||
ERROR_EXIT(str_dir_config);
|
||||
}
|
||||
|
||||
/* Change to output directory. */
|
||||
if (chdir(str_dir_config) != 0)
|
||||
ERROR_EXIT(str_dir_config);
|
||||
|
||||
/* Put initial separator into target list. */
|
||||
ptarget = list_target;
|
||||
*ptarget++ = '\n';
|
||||
|
||||
/* Read config lines. */
|
||||
while (fgets(line, buffer_size, fp_config))
|
||||
{
|
||||
const signed char * str_config;
|
||||
int is_same;
|
||||
int itarget;
|
||||
|
||||
if (line[0] != '#')
|
||||
continue;
|
||||
if ((str_config = strstr(line, "CONFIG_")) == NULL)
|
||||
continue;
|
||||
|
||||
/* Make the output file name. */
|
||||
str_config += sizeof("CONFIG_") - 1;
|
||||
for (itarget = 0; !isspace(str_config[itarget]); itarget++)
|
||||
{
|
||||
int c = (unsigned char) str_config[itarget];
|
||||
if (isupper(c)) c = tolower(c);
|
||||
if (c == '_') c = '/';
|
||||
ptarget[itarget] = c;
|
||||
}
|
||||
ptarget[itarget++] = '.';
|
||||
ptarget[itarget++] = 'h';
|
||||
ptarget[itarget++] = '\0';
|
||||
|
||||
/* Check for existing file. */
|
||||
is_same = 0;
|
||||
if ((fp_target = fopen(ptarget, "r")) != NULL)
|
||||
{
|
||||
fgets(old_line, buffer_size, fp_target);
|
||||
if (fclose(fp_target) != 0)
|
||||
ERROR_EXIT(ptarget);
|
||||
if (!strcmp(line, old_line))
|
||||
is_same = 1;
|
||||
}
|
||||
|
||||
if (!is_same)
|
||||
{
|
||||
/* Auto-create directories. */
|
||||
int islash;
|
||||
for (islash = 0; islash < itarget; islash++)
|
||||
{
|
||||
if (ptarget[islash] == '/')
|
||||
{
|
||||
ptarget[islash] = '\0';
|
||||
if (stat(ptarget, &stat_buf) != 0
|
||||
&& mkdir(ptarget, 0755) != 0)
|
||||
ERROR_EXIT( ptarget );
|
||||
ptarget[islash] = '/';
|
||||
}
|
||||
}
|
||||
|
||||
/* Write the file. */
|
||||
if ((fp_target = fopen(ptarget, "w" )) == NULL)
|
||||
ERROR_EXIT(ptarget);
|
||||
fputs(line, fp_target);
|
||||
if (ferror(fp_target) || fclose(fp_target) != 0)
|
||||
ERROR_EXIT(ptarget);
|
||||
}
|
||||
|
||||
/* Update target list */
|
||||
ptarget += itarget;
|
||||
*(ptarget-1) = '\n';
|
||||
}
|
||||
|
||||
/*
|
||||
* Close autoconfig file.
|
||||
* Terminate the target list.
|
||||
*/
|
||||
if (fclose(fp_config) != 0)
|
||||
ERROR_EXIT(str_file_autoconf);
|
||||
*ptarget = '\0';
|
||||
|
||||
/*
|
||||
* Fix up existing files which have no new value.
|
||||
* This is Case 4 and Case 5.
|
||||
*
|
||||
* I re-read the tree and filter it against list_target.
|
||||
* This is crude. But it avoids data copies. Also, list_target
|
||||
* is compact and contiguous, so it easily fits into cache.
|
||||
*
|
||||
* Notice that list_target contains strings separated by \n,
|
||||
* with a \n before the first string and after the last.
|
||||
* fgets gives the incoming names a terminating \n.
|
||||
* So by having an initial \n, strstr will find exact matches.
|
||||
*/
|
||||
|
||||
fp_find = popen("find * -type f -name \"*.h\" -print", "r");
|
||||
if (fp_find == 0)
|
||||
ERROR_EXIT( "find" );
|
||||
|
||||
line[0] = '\n';
|
||||
while (fgets(line+1, buffer_size, fp_find))
|
||||
{
|
||||
if (strstr(list_target, line) == NULL)
|
||||
{
|
||||
/*
|
||||
* This is an old file with no CONFIG_* flag in autoconf.h.
|
||||
*/
|
||||
|
||||
/* First strip the \n. */
|
||||
line[strlen(line)-1] = '\0';
|
||||
|
||||
/* Grab size. */
|
||||
if (stat(line+1, &stat_buf) != 0)
|
||||
ERROR_EXIT(line);
|
||||
|
||||
/* If file is not empty, make it empty and give it a fresh date. */
|
||||
if (stat_buf.st_size != 0)
|
||||
{
|
||||
if ((fp_target = fopen(line+1, "w")) == NULL)
|
||||
ERROR_EXIT(line);
|
||||
if (fclose(fp_target) != 0)
|
||||
ERROR_EXIT(line);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (pclose(fp_find) != 0)
|
||||
ERROR_EXIT("find");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
/*
|
||||
* Unloved program to convert a binary on stdin to a C include on stdout
|
||||
*
|
||||
* Jan 1999 Matt Mackall <mpm@selenic.com>
|
||||
*
|
||||
* This software may be used and distributed according to the terms
|
||||
* of the GNU General Public License, incorporated herein by reference.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int ch, total=0;
|
||||
|
||||
if (argc > 1)
|
||||
printf("const char %s[] %s=\n",
|
||||
argv[1], argc > 2 ? argv[2] : "");
|
||||
|
||||
do {
|
||||
printf("\t\"");
|
||||
while ((ch = getchar()) != EOF)
|
||||
{
|
||||
total++;
|
||||
printf("\\x%02x",ch);
|
||||
if (total % 16 == 0)
|
||||
break;
|
||||
}
|
||||
printf("\"\n");
|
||||
} while (ch != EOF);
|
||||
|
||||
if (argc > 1)
|
||||
printf("\t;\n\nconst int %s_size = %d;\n", argv[1], total);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,163 @@
|
||||
/***************************************************************************
|
||||
* binoffset.c
|
||||
* (C) 2002 Randy Dunlap <rddunlap@osdl.org>
|
||||
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
# binoffset.c:
|
||||
# - searches a (binary) file for a specified (binary) pattern
|
||||
# - returns the offset of the located pattern or ~0 if not found
|
||||
# - exits with exit status 0 normally or non-0 if pattern is not found
|
||||
# or any other error occurs.
|
||||
|
||||
****************************************************************/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/mman.h>
|
||||
|
||||
#define VERSION "0.1"
|
||||
#define BUF_SIZE (16 * 1024)
|
||||
#define PAT_SIZE 100
|
||||
|
||||
char *progname;
|
||||
char *inputname;
|
||||
int inputfd;
|
||||
unsigned int bix; /* buf index */
|
||||
unsigned char patterns [PAT_SIZE] = {0}; /* byte-sized pattern array */
|
||||
int pat_len; /* actual number of pattern bytes */
|
||||
unsigned char *madr; /* mmap address */
|
||||
size_t filesize;
|
||||
int num_matches = 0;
|
||||
off_t firstloc = 0;
|
||||
|
||||
void usage (void)
|
||||
{
|
||||
fprintf (stderr, "%s ver. %s\n", progname, VERSION);
|
||||
fprintf (stderr, "usage: %s filename pattern_bytes\n",
|
||||
progname);
|
||||
fprintf (stderr, " [prints location of pattern_bytes in file]\n");
|
||||
exit (1);
|
||||
}
|
||||
|
||||
void get_pattern (int pat_count, char *pats [])
|
||||
{
|
||||
int ix, err, tmp;
|
||||
|
||||
#ifdef DEBUG
|
||||
fprintf (stderr,"get_pattern: count = %d\n", pat_count);
|
||||
for (ix = 0; ix < pat_count; ix++)
|
||||
fprintf (stderr, " pat # %d: [%s]\n", ix, pats[ix]);
|
||||
#endif
|
||||
|
||||
for (ix = 0; ix < pat_count; ix++) {
|
||||
tmp = 0;
|
||||
err = sscanf (pats[ix], "%5i", &tmp);
|
||||
if (err != 1 || tmp > 0xff) {
|
||||
fprintf (stderr, "pattern or value error in pattern # %d [%s]\n",
|
||||
ix, pats[ix]);
|
||||
usage ();
|
||||
}
|
||||
patterns [ix] = tmp;
|
||||
}
|
||||
pat_len = pat_count;
|
||||
}
|
||||
|
||||
void search_pattern (void)
|
||||
{
|
||||
for (bix = 0; bix < filesize; bix++) {
|
||||
if (madr[bix] == patterns[0]) {
|
||||
if (memcmp (&madr[bix], patterns, pat_len) == 0) {
|
||||
if (num_matches == 0)
|
||||
firstloc = bix;
|
||||
num_matches++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef NOTDEF
|
||||
size_t get_filesize (int fd)
|
||||
{
|
||||
off_t end_off = lseek (fd, 0, SEEK_END);
|
||||
lseek (fd, 0, SEEK_SET);
|
||||
return (size_t) end_off;
|
||||
}
|
||||
#endif
|
||||
|
||||
size_t get_filesize (int fd)
|
||||
{
|
||||
int err;
|
||||
struct stat stat;
|
||||
|
||||
err = fstat (fd, &stat);
|
||||
fprintf (stderr, "filesize: %ld\n", err < 0 ? (long)err : stat.st_size);
|
||||
if (err < 0)
|
||||
return err;
|
||||
return (size_t) stat.st_size;
|
||||
}
|
||||
|
||||
int main (int argc, char *argv [])
|
||||
{
|
||||
progname = argv[0];
|
||||
|
||||
if (argc < 3)
|
||||
usage ();
|
||||
|
||||
get_pattern (argc - 2, argv + 2);
|
||||
|
||||
inputname = argv[1];
|
||||
|
||||
inputfd = open (inputname, O_RDONLY);
|
||||
if (inputfd == -1) {
|
||||
fprintf (stderr, "%s: cannot open '%s'\n",
|
||||
progname, inputname);
|
||||
exit (3);
|
||||
}
|
||||
|
||||
filesize = get_filesize (inputfd);
|
||||
|
||||
madr = mmap (0, filesize, PROT_READ, MAP_PRIVATE, inputfd, 0);
|
||||
if (madr == MAP_FAILED) {
|
||||
fprintf (stderr, "mmap error = %d\n", errno);
|
||||
close (inputfd);
|
||||
exit (4);
|
||||
}
|
||||
|
||||
search_pattern ();
|
||||
|
||||
if (munmap (madr, filesize))
|
||||
fprintf (stderr, "munmap error = %d\n", errno);
|
||||
|
||||
if (close (inputfd))
|
||||
fprintf (stderr, "%s: error %d closing '%s'\n",
|
||||
progname, errno, inputname);
|
||||
|
||||
fprintf (stderr, "number of pattern matches = %d\n", num_matches);
|
||||
if (num_matches == 0)
|
||||
firstloc = ~0;
|
||||
printf ("%ld\n", firstloc);
|
||||
fprintf (stderr, "%ld\n", firstloc);
|
||||
|
||||
exit (num_matches ? 0 : 2);
|
||||
}
|
||||
|
||||
/* end binoffset.c */
|
||||
Executable
+65
@@ -0,0 +1,65 @@
|
||||
#! /usr/bin/perl
|
||||
#
|
||||
# checkconfig: find uses of CONFIG_* names without matching definitions.
|
||||
# Copyright abandoned, 1998, Michael Elizabeth Chastain <mailto:mec@shout.net>.
|
||||
|
||||
use integer;
|
||||
|
||||
$| = 1;
|
||||
|
||||
foreach $file (@ARGV)
|
||||
{
|
||||
# Open this file.
|
||||
open(FILE, $file) || die "Can't open $file: $!\n";
|
||||
|
||||
# Initialize variables.
|
||||
my $fInComment = 0;
|
||||
my $fInString = 0;
|
||||
my $fUseConfig = 0;
|
||||
my $iLinuxConfig = 0;
|
||||
my %configList = ();
|
||||
|
||||
LINE: while ( <FILE> )
|
||||
{
|
||||
# Strip comments.
|
||||
$fInComment && (s+^.*?\*/+ +o ? ($fInComment = 0) : next);
|
||||
m+/\*+o && (s+/\*.*?\*/+ +go, (s+/\*.*$+ +o && ($fInComment = 1)));
|
||||
|
||||
# Pick up definitions.
|
||||
if ( m/^\s*#/o )
|
||||
{
|
||||
$iLinuxConfig = $. if m/^\s*#\s*include\s*"linux\/config\.h"/o;
|
||||
$configList{uc $1} = 1 if m/^\s*#\s*include\s*"config\/(\S*)\.h"/o;
|
||||
}
|
||||
|
||||
# Strip strings.
|
||||
$fInString && (s+^.*?"+ +o ? ($fInString = 0) : next);
|
||||
m+"+o && (s+".*?"+ +go, (s+".*$+ +o && ($fInString = 1)));
|
||||
|
||||
# Pick up definitions.
|
||||
if ( m/^\s*#/o )
|
||||
{
|
||||
$iLinuxConfig = $. if m/^\s*#\s*include\s*<linux\/config\.h>/o;
|
||||
$configList{uc $1} = 1 if m/^\s*#\s*include\s*<config\/(\S*)\.h>/o;
|
||||
$configList{$1} = 1 if m/^\s*#\s*define\s+CONFIG_(\w*)/o;
|
||||
$configList{$1} = 1 if m/^\s*#\s*undef\s+CONFIG_(\w*)/o;
|
||||
}
|
||||
|
||||
# Look for usages.
|
||||
next unless m/CONFIG_/o;
|
||||
WORD: while ( m/\bCONFIG_(\w+)/og )
|
||||
{
|
||||
$fUseConfig = 1;
|
||||
last LINE if $iLinuxConfig;
|
||||
next WORD if exists $configList{$1};
|
||||
print "$file: $.: need CONFIG_$1.\n";
|
||||
$configList{$1} = 0;
|
||||
}
|
||||
}
|
||||
|
||||
# Report superfluous includes.
|
||||
if ( $iLinuxConfig && ! $fUseConfig )
|
||||
{ print "$file: $iLinuxConfig: linux/config.h not needed.\n"; }
|
||||
|
||||
close(FILE);
|
||||
}
|
||||
Executable
+24
@@ -0,0 +1,24 @@
|
||||
#!/usr/bin/perl
|
||||
#
|
||||
# checkincludes: Find files included more than once in (other) files.
|
||||
# Copyright abandoned, 2000, Niels Kristian Bech Jensen <nkbj@image.dk>.
|
||||
|
||||
foreach $file (@ARGV) {
|
||||
open(FILE, $file) or die "Cannot open $file: $!.\n";
|
||||
|
||||
my %includedfiles = ();
|
||||
|
||||
while (<FILE>) {
|
||||
if (m/^\s*#\s*include\s*[<"](\S*)[>"]/o) {
|
||||
++$includedfiles{$1};
|
||||
}
|
||||
}
|
||||
|
||||
foreach $filename (keys %includedfiles) {
|
||||
if ($includedfiles{$filename} > 1) {
|
||||
print "$file: $filename is included more than once.\n";
|
||||
}
|
||||
}
|
||||
|
||||
close(FILE);
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
#!/usr/bin/perl
|
||||
|
||||
# Check the stack usage of functions
|
||||
#
|
||||
# Copyright Joern Engel <joern@wh.fh-wedel.de>
|
||||
# Inspired by Linus Torvalds
|
||||
# Original idea maybe from Keith Owens
|
||||
# s390 port and big speedup by Arnd Bergmann <arnd@bergmann-dalldorf.de>
|
||||
# Mips port by Juan Quintela <quintela@mandrakesoft.com>
|
||||
# IA64 port via Andreas Dilger
|
||||
# Arm port by Holger Schurig
|
||||
# sh64 port by Paul Mundt
|
||||
# Random bits by Matt Mackall <mpm@selenic.com>
|
||||
# M68k port by Geert Uytterhoeven and Andreas Schwab
|
||||
#
|
||||
# Usage:
|
||||
# objdump -d vmlinux | stackcheck.pl [arch]
|
||||
#
|
||||
# TODO : Port to all architectures (one regex per arch)
|
||||
|
||||
# check for arch
|
||||
#
|
||||
# $re is used for two matches:
|
||||
# $& (whole re) matches the complete objdump line with the stack growth
|
||||
# $1 (first bracket) matches the size of the stack growth
|
||||
#
|
||||
# use anything else and feel the pain ;)
|
||||
my (@stack, $re, $x, $xs);
|
||||
{
|
||||
my $arch = shift;
|
||||
if ($arch eq "") {
|
||||
$arch = `uname -m`;
|
||||
}
|
||||
|
||||
$x = "[0-9a-f]"; # hex character
|
||||
$xs = "[0-9a-f ]"; # hex character or space
|
||||
if ($arch eq 'arm') {
|
||||
#c0008ffc: e24dd064 sub sp, sp, #100 ; 0x64
|
||||
$re = qr/.*sub.*sp, sp, #(([0-9]{2}|[3-9])[0-9]{2})/o;
|
||||
} elsif ($arch =~ /^i[3456]86$/) {
|
||||
#c0105234: 81 ec ac 05 00 00 sub $0x5ac,%esp
|
||||
$re = qr/^.*[as][du][db] \$(0x$x{1,8}),\%esp$/o;
|
||||
} elsif ($arch eq 'x86_64') {
|
||||
# 2f60: 48 81 ec e8 05 00 00 sub $0x5e8,%rsp
|
||||
$re = qr/^.*[as][du][db] \$(0x$x{1,8}),\%rsp$/o;
|
||||
} elsif ($arch eq 'ia64') {
|
||||
#e0000000044011fc: 01 0f fc 8c adds r12=-384,r12
|
||||
$re = qr/.*adds.*r12=-(([0-9]{2}|[3-9])[0-9]{2}),r12/o;
|
||||
} elsif ($arch eq 'm68k') {
|
||||
# 2b6c: 4e56 fb70 linkw %fp,#-1168
|
||||
# 1df770: defc ffe4 addaw #-28,%sp
|
||||
$re = qr/.*(?:linkw %fp,|addaw )#-([0-9]{1,4})(?:,%sp)?$/o;
|
||||
} elsif ($arch eq 'mips64') {
|
||||
#8800402c: 67bdfff0 daddiu sp,sp,-16
|
||||
$re = qr/.*daddiu.*sp,sp,-(([0-9]{2}|[3-9])[0-9]{2})/o;
|
||||
} elsif ($arch eq 'mips') {
|
||||
#88003254: 27bdffe0 addiu sp,sp,-32
|
||||
$re = qr/.*addiu.*sp,sp,-(([0-9]{2}|[3-9])[0-9]{2})/o;
|
||||
} elsif ($arch eq 'ppc') {
|
||||
#c00029f4: 94 21 ff 30 stwu r1,-208(r1)
|
||||
$re = qr/.*stwu.*r1,-($x{1,8})\(r1\)/o;
|
||||
} elsif ($arch eq 'ppc64') {
|
||||
#XXX
|
||||
$re = qr/.*stdu.*r1,-($x{1,8})\(r1\)/o;
|
||||
} elsif ($arch =~ /^s390x?$/) {
|
||||
# 11160: a7 fb ff 60 aghi %r15,-160
|
||||
$re = qr/.*ag?hi.*\%r15,-(([0-9]{2}|[3-9])[0-9]{2})/o;
|
||||
} elsif ($arch =~ /^sh64$/) {
|
||||
#XXX: we only check for the immediate case presently,
|
||||
# though we will want to check for the movi/sub
|
||||
# pair for larger users. -- PFM.
|
||||
#a00048e0: d4fc40f0 addi.l r15,-240,r15
|
||||
$re = qr/.*addi\.l.*r15,-(([0-9]{2}|[3-9])[0-9]{2}),r15/o;
|
||||
} else {
|
||||
print("wrong or unknown architecture\n");
|
||||
exit
|
||||
}
|
||||
}
|
||||
|
||||
sub bysize($) {
|
||||
my ($asize, $bsize);
|
||||
($asize = $a) =~ s/.*: *(.*)$/$1/;
|
||||
($bsize = $b) =~ s/.*: *(.*)$/$1/;
|
||||
$bsize <=> $asize
|
||||
}
|
||||
|
||||
#
|
||||
# main()
|
||||
#
|
||||
my $funcre = qr/^$x* <(.*)>:$/;
|
||||
my $func;
|
||||
while (my $line = <STDIN>) {
|
||||
if ($line =~ m/$funcre/) {
|
||||
$func = $1;
|
||||
}
|
||||
if ($line =~ m/$re/) {
|
||||
my $size = $1;
|
||||
$size = hex($size) if ($size =~ /^0x/);
|
||||
|
||||
if ($size > 0xf0000000) {
|
||||
$size = - $size;
|
||||
$size += 0x80000000;
|
||||
$size += 0x80000000;
|
||||
}
|
||||
next if ($size > 0x10000000);
|
||||
|
||||
next if $line !~ m/^($xs*)/;
|
||||
my $addr = $1;
|
||||
$addr =~ s/ /0/g;
|
||||
$addr = "0x$addr";
|
||||
|
||||
my $intro = "$addr $func:";
|
||||
my $padlen = 56 - length($intro);
|
||||
while ($padlen > 0) {
|
||||
$intro .= ' ';
|
||||
$padlen -= 8;
|
||||
}
|
||||
next if ($size < 100);
|
||||
push @stack, "$intro$size\n";
|
||||
}
|
||||
}
|
||||
|
||||
print sort bysize @stack;
|
||||
Executable
+72
@@ -0,0 +1,72 @@
|
||||
#! /usr/bin/perl
|
||||
#
|
||||
# checkversion find uses of LINUX_VERSION_CODE, KERNEL_VERSION, or
|
||||
# UTS_RELEASE without including <linux/version.h>, or cases of
|
||||
# including <linux/version.h> that don't need it.
|
||||
# Copyright (C) 2003, Randy Dunlap <rddunlap@osdl.org>
|
||||
|
||||
$| = 1;
|
||||
|
||||
my $debugging = 0;
|
||||
|
||||
foreach $file (@ARGV)
|
||||
{
|
||||
# Open this file.
|
||||
open(FILE, $file) || die "Can't open $file: $!\n";
|
||||
|
||||
# Initialize variables.
|
||||
my $fInComment = 0;
|
||||
my $fInString = 0;
|
||||
my $fUseVersion = 0;
|
||||
my $iLinuxVersion = 0;
|
||||
|
||||
LINE: while ( <FILE> )
|
||||
{
|
||||
# Strip comments.
|
||||
$fInComment && (s+^.*?\*/+ +o ? ($fInComment = 0) : next);
|
||||
m+/\*+o && (s+/\*.*?\*/+ +go, (s+/\*.*$+ +o && ($fInComment = 1)));
|
||||
|
||||
# Pick up definitions.
|
||||
if ( m/^\s*#/o ) {
|
||||
$iLinuxVersion = $. if m/^\s*#\s*include\s*"linux\/version\.h"/o;
|
||||
}
|
||||
|
||||
# Strip strings.
|
||||
$fInString && (s+^.*?"+ +o ? ($fInString = 0) : next);
|
||||
m+"+o && (s+".*?"+ +go, (s+".*$+ +o && ($fInString = 1)));
|
||||
|
||||
# Pick up definitions.
|
||||
if ( m/^\s*#/o ) {
|
||||
$iLinuxVersion = $. if m/^\s*#\s*include\s*<linux\/version\.h>/o;
|
||||
}
|
||||
|
||||
# Look for uses: LINUX_VERSION_CODE, KERNEL_VERSION, UTS_RELEASE
|
||||
if (($_ =~ /LINUX_VERSION_CODE/) || ($_ =~ /\WKERNEL_VERSION/) ||
|
||||
($_ =~ /UTS_RELEASE/)) {
|
||||
$fUseVersion = 1;
|
||||
last LINE if $iLinuxVersion;
|
||||
}
|
||||
}
|
||||
|
||||
# Report used version IDs without include?
|
||||
if ($fUseVersion && ! $iLinuxVersion) {
|
||||
print "$file: $.: need linux/version.h\n";
|
||||
}
|
||||
|
||||
# Report superfluous includes.
|
||||
if ($iLinuxVersion && ! $fUseVersion) {
|
||||
print "$file: $iLinuxVersion linux/version.h not needed.\n";
|
||||
}
|
||||
|
||||
# debug: report OK results:
|
||||
if ($debugging) {
|
||||
if ($iLinuxVersion && $fUseVersion) {
|
||||
print "$file: version use is OK ($iLinuxVersion)\n";
|
||||
}
|
||||
if (! $iLinuxVersion && ! $fUseVersion) {
|
||||
print "$file: version use is OK (none)\n";
|
||||
}
|
||||
}
|
||||
|
||||
close(FILE);
|
||||
}
|
||||
@@ -0,0 +1,293 @@
|
||||
/*
|
||||
* conmakehash.c
|
||||
*
|
||||
* Create arrays for initializing the kernel folded tables (using a hash
|
||||
* table turned out to be to limiting...) Unfortunately we can't simply
|
||||
* preinitialize the tables at compile time since kfree() cannot accept
|
||||
* memory not allocated by kmalloc(), and doing our own memory management
|
||||
* just for this seems like massive overkill.
|
||||
*
|
||||
* Copyright (C) 1995-1997 H. Peter Anvin
|
||||
*
|
||||
* This program is a part of the Linux kernel, and may be freely
|
||||
* copied under the terms of the GNU General Public License (GPL),
|
||||
* version 2, or at your option any later version.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sysexits.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#define MAX_FONTLEN 256
|
||||
|
||||
typedef unsigned short unicode;
|
||||
|
||||
void usage(char *argv0)
|
||||
{
|
||||
fprintf(stderr, "Usage: \n"
|
||||
" %s chartable [hashsize] [hashstep] [maxhashlevel]\n", argv0);
|
||||
exit(EX_USAGE);
|
||||
}
|
||||
|
||||
int getunicode(char **p0)
|
||||
{
|
||||
unsigned char *p = *p0;
|
||||
|
||||
while (*p == ' ' || *p == '\t')
|
||||
p++;
|
||||
if (*p != 'U' || p[1] != '+' ||
|
||||
!isxdigit(p[2]) || !isxdigit(p[3]) || !isxdigit(p[4]) ||
|
||||
!isxdigit(p[5]) || isxdigit(p[6]))
|
||||
return -1;
|
||||
*p0 = p+6;
|
||||
return strtol(p+2,0,16);
|
||||
}
|
||||
|
||||
unicode unitable[MAX_FONTLEN][255];
|
||||
/* Massive overkill, but who cares? */
|
||||
int unicount[MAX_FONTLEN];
|
||||
|
||||
void addpair(int fp, int un)
|
||||
{
|
||||
int i;
|
||||
|
||||
if ( un <= 0xfffe )
|
||||
{
|
||||
/* Check it isn't a duplicate */
|
||||
|
||||
for ( i = 0 ; i < unicount[fp] ; i++ )
|
||||
if ( unitable[fp][i] == un )
|
||||
return;
|
||||
|
||||
/* Add to list */
|
||||
|
||||
if ( unicount[fp] > 254 )
|
||||
{
|
||||
fprintf(stderr, "ERROR: Only 255 unicodes/glyph permitted!\n");
|
||||
exit(EX_DATAERR);
|
||||
}
|
||||
|
||||
unitable[fp][unicount[fp]] = un;
|
||||
unicount[fp]++;
|
||||
}
|
||||
|
||||
/* otherwise: ignore */
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
FILE *ctbl;
|
||||
char *tblname;
|
||||
char buffer[65536];
|
||||
int fontlen;
|
||||
int i, nuni, nent;
|
||||
int fp0, fp1, un0, un1;
|
||||
char *p, *p1;
|
||||
|
||||
if ( argc < 2 || argc > 5 )
|
||||
usage(argv[0]);
|
||||
|
||||
if ( !strcmp(argv[1],"-") )
|
||||
{
|
||||
ctbl = stdin;
|
||||
tblname = "stdin";
|
||||
}
|
||||
else
|
||||
{
|
||||
ctbl = fopen(tblname = argv[1], "r");
|
||||
if ( !ctbl )
|
||||
{
|
||||
perror(tblname);
|
||||
exit(EX_NOINPUT);
|
||||
}
|
||||
}
|
||||
|
||||
/* For now we assume the default font is always 256 characters. */
|
||||
fontlen = 256;
|
||||
|
||||
/* Initialize table */
|
||||
|
||||
for ( i = 0 ; i < fontlen ; i++ )
|
||||
unicount[i] = 0;
|
||||
|
||||
/* Now we come to the tricky part. Parse the input table. */
|
||||
|
||||
while ( fgets(buffer, sizeof(buffer), ctbl) != NULL )
|
||||
{
|
||||
if ( (p = strchr(buffer, '\n')) != NULL )
|
||||
*p = '\0';
|
||||
else
|
||||
fprintf(stderr, "%s: Warning: line too long\n", tblname);
|
||||
|
||||
p = buffer;
|
||||
|
||||
/*
|
||||
* Syntax accepted:
|
||||
* <fontpos> <unicode> <unicode> ...
|
||||
* <range> idem
|
||||
* <range> <unicode range>
|
||||
*
|
||||
* where <range> ::= <fontpos>-<fontpos>
|
||||
* and <unicode> ::= U+<h><h><h><h>
|
||||
* and <h> ::= <hexadecimal digit>
|
||||
*/
|
||||
|
||||
while (*p == ' ' || *p == '\t')
|
||||
p++;
|
||||
if (!*p || *p == '#')
|
||||
continue; /* skip comment or blank line */
|
||||
|
||||
fp0 = strtol(p, &p1, 0);
|
||||
if (p1 == p)
|
||||
{
|
||||
fprintf(stderr, "Bad input line: %s\n", buffer);
|
||||
exit(EX_DATAERR);
|
||||
}
|
||||
p = p1;
|
||||
|
||||
while (*p == ' ' || *p == '\t')
|
||||
p++;
|
||||
if (*p == '-')
|
||||
{
|
||||
p++;
|
||||
fp1 = strtol(p, &p1, 0);
|
||||
if (p1 == p)
|
||||
{
|
||||
fprintf(stderr, "Bad input line: %s\n", buffer);
|
||||
exit(EX_DATAERR);
|
||||
}
|
||||
p = p1;
|
||||
}
|
||||
else
|
||||
fp1 = 0;
|
||||
|
||||
if ( fp0 < 0 || fp0 >= fontlen )
|
||||
{
|
||||
fprintf(stderr,
|
||||
"%s: Glyph number (0x%x) larger than font length\n",
|
||||
tblname, fp0);
|
||||
exit(EX_DATAERR);
|
||||
}
|
||||
if ( fp1 && (fp1 < fp0 || fp1 >= fontlen) )
|
||||
{
|
||||
fprintf(stderr,
|
||||
"%s: Bad end of range (0x%x)\n",
|
||||
tblname, fp1);
|
||||
exit(EX_DATAERR);
|
||||
}
|
||||
|
||||
if (fp1)
|
||||
{
|
||||
/* we have a range; expect the word "idem" or a Unicode range of the
|
||||
same length */
|
||||
while (*p == ' ' || *p == '\t')
|
||||
p++;
|
||||
if (!strncmp(p, "idem", 4))
|
||||
{
|
||||
for (i=fp0; i<=fp1; i++)
|
||||
addpair(i,i);
|
||||
p += 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
un0 = getunicode(&p);
|
||||
while (*p == ' ' || *p == '\t')
|
||||
p++;
|
||||
if (*p != '-')
|
||||
{
|
||||
fprintf(stderr,
|
||||
"%s: Corresponding to a range of font positions, there should be a Unicode range\n",
|
||||
tblname);
|
||||
exit(EX_DATAERR);
|
||||
}
|
||||
p++;
|
||||
un1 = getunicode(&p);
|
||||
if (un0 < 0 || un1 < 0)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"%s: Bad Unicode range corresponding to font position range 0x%x-0x%x\n",
|
||||
tblname, fp0, fp1);
|
||||
exit(EX_DATAERR);
|
||||
}
|
||||
if (un1 - un0 != fp1 - fp0)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"%s: Unicode range U+%x-U+%x not of the same length as font position range 0x%x-0x%x\n",
|
||||
tblname, un0, un1, fp0, fp1);
|
||||
exit(EX_DATAERR);
|
||||
}
|
||||
for(i=fp0; i<=fp1; i++)
|
||||
addpair(i,un0-fp0+i);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* no range; expect a list of unicode values for a single font position */
|
||||
|
||||
while ( (un0 = getunicode(&p)) >= 0 )
|
||||
addpair(fp0, un0);
|
||||
}
|
||||
while (*p == ' ' || *p == '\t')
|
||||
p++;
|
||||
if (*p && *p != '#')
|
||||
fprintf(stderr, "%s: trailing junk (%s) ignored\n", tblname, p);
|
||||
}
|
||||
|
||||
/* Okay, we hit EOF, now output hash table */
|
||||
|
||||
fclose(ctbl);
|
||||
|
||||
|
||||
/* Compute total size of Unicode list */
|
||||
nuni = 0;
|
||||
for ( i = 0 ; i < fontlen ; i++ )
|
||||
nuni += unicount[i];
|
||||
|
||||
printf("\
|
||||
/*\n\
|
||||
* Do not edit this file; it was automatically generated by\n\
|
||||
*\n\
|
||||
* conmakehash %s > [this file]\n\
|
||||
*\n\
|
||||
*/\n\
|
||||
\n\
|
||||
#include <linux/types.h>\n\
|
||||
\n\
|
||||
u8 dfont_unicount[%d] = \n\
|
||||
{\n\t", argv[1], fontlen);
|
||||
|
||||
for ( i = 0 ; i < fontlen ; i++ )
|
||||
{
|
||||
printf("%3d", unicount[i]);
|
||||
if ( i == fontlen-1 )
|
||||
printf("\n};\n");
|
||||
else if ( i % 8 == 7 )
|
||||
printf(",\n\t");
|
||||
else
|
||||
printf(", ");
|
||||
}
|
||||
|
||||
printf("\nu16 dfont_unitable[%d] = \n{\n\t", nuni);
|
||||
|
||||
fp0 = 0;
|
||||
nent = 0;
|
||||
for ( i = 0 ; i < nuni ; i++ )
|
||||
{
|
||||
while ( nent >= unicount[fp0] )
|
||||
{
|
||||
fp0++;
|
||||
nent = 0;
|
||||
}
|
||||
printf("0x%04x", unitable[fp0][nent++]);
|
||||
if ( i == nuni-1 )
|
||||
printf("\n};\n");
|
||||
else if ( i % 8 == 7 )
|
||||
printf(",\n\t");
|
||||
else
|
||||
printf(", ");
|
||||
}
|
||||
|
||||
exit(EX_OK);
|
||||
}
|
||||
Executable
+77
@@ -0,0 +1,77 @@
|
||||
#!/bin/sh
|
||||
# extracts .config info from a [b]zImage file
|
||||
# uses: binoffset (new), dd, zcat, strings, grep
|
||||
# $arg1 is [b]zImage filename
|
||||
|
||||
binoffset="./scripts/binoffset"
|
||||
|
||||
IKCFG_ST="0x49 0x4b 0x43 0x46 0x47 0x5f 0x53 0x54"
|
||||
IKCFG_ED="0x49 0x4b 0x43 0x46 0x47 0x5f 0x45 0x44"
|
||||
function dump_config {
|
||||
typeset file="$1"
|
||||
|
||||
start=`$binoffset $file $IKCFG_ST 2>/dev/null`
|
||||
[ "$?" != "0" ] && start="-1"
|
||||
if [ "$start" -eq "-1" ]; then
|
||||
return
|
||||
fi
|
||||
end=`$binoffset $file $IKCFG_ED 2>/dev/null`
|
||||
|
||||
let start="$start + 8"
|
||||
let size="$end - $start"
|
||||
|
||||
head --bytes="$end" "$file" | tail --bytes="$size" | zcat
|
||||
|
||||
clean_up
|
||||
exit 0
|
||||
}
|
||||
|
||||
|
||||
usage()
|
||||
{
|
||||
echo " usage: extract-ikconfig [b]zImage_filename"
|
||||
}
|
||||
|
||||
clean_up()
|
||||
{
|
||||
if [ "$TMPFILE" != "" ]; then
|
||||
rm -f $TMPFILE
|
||||
fi
|
||||
}
|
||||
|
||||
if [ $# -lt 1 ]
|
||||
then
|
||||
usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
TMPFILE="/tmp/ikconfig-$$"
|
||||
image="$1"
|
||||
|
||||
# vmlinux: Attempt to dump the configuration from the file directly
|
||||
dump_config "$image"
|
||||
|
||||
GZHDR1="0x1f 0x8b 0x08 0x00"
|
||||
GZHDR2="0x1f 0x8b 0x08 0x08"
|
||||
|
||||
# vmlinux.gz: Check for a compressed images
|
||||
off=`$binoffset "$image" $GZHDR1 2>/dev/null`
|
||||
[ "$?" != "0" ] && off="-1"
|
||||
if [ "$off" -eq "-1" ]; then
|
||||
off=`$binoffset "$image" $GZHDR2 2>/dev/null`
|
||||
[ "$?" != "0" ] && off="-1"
|
||||
fi
|
||||
if [ "$off" -eq "0" ]; then
|
||||
zcat <"$image" >"$TMPFILE"
|
||||
dump_config "$TMPFILE"
|
||||
elif [ "$off" -ne "-1" ]; then
|
||||
(dd ibs="$off" skip=1 count=0 && dd bs=512k) <"$image" 2>/dev/null | \
|
||||
zcat >"$TMPFILE"
|
||||
dump_config "$TMPFILE"
|
||||
fi
|
||||
|
||||
echo "ERROR: Unable to extract kernel configuration information."
|
||||
echo " This kernel image may not have the config info."
|
||||
|
||||
clean_up
|
||||
exit 1
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user