home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / debian / ruleset / misc / patches.mk < prev    next >
Encoding:
Text File  |  2005-11-02  |  12.2 KB  |  229 lines
  1. ######################### -*- Mode: Makefile-Gmake -*- ########################
  2. ## patches.mk --- 
  3. ## Author           : Manoj Srivastava ( srivasta@glaurung.internal.golden-gryphon.com ) 
  4. ## Created On       : Mon Oct 31 18:09:46 2005
  5. ## Created On Node  : glaurung.internal.golden-gryphon.com
  6. ## Last Modified By : Manoj Srivastava
  7. ## Last Modified On : Mon Oct 31 18:09:46 2005
  8. ## Last Machine Used: glaurung.internal.golden-gryphon.com
  9. ## Update Count     : 0
  10. ## Status           : Unknown, Use with caution!
  11. ## HISTORY          : 
  12. ## Description      : deals with setting up variables, looking at
  13. ##                    directories, and creating a list of valid third party
  14. ##                    patches available for the kernel being built.
  15. ## 
  16. ## arch-tag: 0cdf8272-2183-49dd-abb7-e64ef8f0b482
  17. ## 
  18. ## 
  19. ## This program is free software; you can redistribute it and/or modify
  20. ## it under the terms of the GNU General Public License as published by
  21. ## the Free Software Foundation; either version 2 of the License, or
  22. ## (at your option) any later version.
  23. ##
  24. ## This program is distributed in the hope that it will be useful,
  25. ## but WITHOUT ANY WARRANTY; without even the implied warranty of
  26. ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27. ## GNU General Public License for more details.
  28. ##
  29. ## You should have received a copy of the GNU General Public License
  30. ## along with this program; if not, write to the Free Software
  31. ## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  32. ##
  33. ###############################################################################
  34.  
  35. ifeq ($(strip $(VERSIONED_PATCH_DIR)),)
  36. VERSIONED_PATCH_DIR         = $(shell if [ -d \
  37. /usr/src/kernel-patches/$(architecture)/$(VERSION).$(PATCHLEVEL).$(SUBLEVEL) \
  38.                    ]; then echo \
  39. /usr/src/kernel-patches/$(architecture)/$(VERSION).$(PATCHLEVEL).$(SUBLEVEL); \
  40.                 fi)
  41. endif
  42.  
  43. ifeq ($(strip $(VERSIONED_ALL_PATCH_DIR)),)
  44. VERSIONED_ALL_PATCH_DIR         = $(shell if [ -d \
  45. /usr/src/kernel-patches/all/$(VERSION).$(PATCHLEVEL).$(SUBLEVEL) \
  46.                    ]; then echo \
  47. /usr/src/kernel-patches/all/$(VERSION).$(PATCHLEVEL).$(SUBLEVEL); \
  48.                 fi)
  49. endif
  50.  
  51. ifeq ($(strip $(PATCH_DIR)),)
  52. PATCH_DIR  = $(shell if [ -d /usr/src/kernel-patches/$(architecture)/ ];\
  53.                         then echo /usr/src/kernel-patches/$(architecture); \
  54.                  fi)
  55. endif
  56.  
  57. ifeq ($(strip $(ALL_PATCH_DIR)),)
  58. ALL_PATCH_DIR  = $(shell if [ -d /usr/src/kernel-patches/all/ ]; \
  59.                             then echo /usr/src/kernel-patches/all ;\
  60.              fi)
  61. endif
  62.  
  63. VERSIONED_ALL_PATCH_APPLY   = $(VERSIONED_ALL_PATCH_DIR)/apply
  64. VERSIONED_ALL_PATCH_UNPATCH = $(VERSIONED_ALL_PATCH_DIR)/unpatch
  65.  
  66. VERSIONED_DIR_PATCH_APPLY   = $(VERSIONED_PATCH_DIR)/apply
  67. VERSIONED_DIR_PATCH_UNPATCH = $(VERSIONED_PATCH_DIR)/unpatch
  68.  
  69. ALL_PATCH_APPLY   = $(ALL_PATCH_DIR)/apply
  70. ALL_PATCH_UNPATCH = $(ALL_PATCH_DIR)/unpatch
  71.  
  72. DIR_PATCH_APPLY   = $(PATCH_DIR)/apply
  73. DIR_PATCH_UNPATCH = $(PATCH_DIR)/unpatch
  74.  
  75. ifeq ($(strip $(patch_the_kernel)),YES)
  76.  
  77. # Well then. Let us see if we want to select the patches we apply.
  78. ifneq ($(strip $(KPKG_SELECTED_PATCHES)),)
  79. canonical_patches=$(subst $(comma),$(space),$(KPKG_SELECTED_PATCHES))
  80.  
  81. ifneq ($(strip $(canonical_patches)),)
  82. # test to see if the patches exist
  83. temp_valid_patches = $(shell for name in $(canonical_patches); do                \
  84.                             if [ -x "$(VERSIONED_DIR_PATCH_APPLY)/$$name"   ] &&   \
  85.                                [ -x "$(VERSIONED_DIR_PATCH_UNPATCH)/$$name" ];     \
  86.                                then echo "$(VERSIONED_DIR_PATCH_APPLY)/$$name";    \
  87.                             elif [ -x "$(VERSIONED_ALL_PATCH_APPLY)/$$name"   ] && \
  88.                                  [ -x "$(VERSIONED_ALL_PATCH_UNPATCH)/$$name" ];   \
  89.                                then echo "$(VERSIONED_ALL_PATCH_APPLY)/$$name";    \
  90.                             elif [ -x "$(DIR_PATCH_APPLY)/$$name"   ] &&           \
  91.                                  [ -x "$(DIR_PATCH_UNPATCH)/$$name" ]; then        \
  92.                                echo "$(DIR_PATCH_APPLY)/$$name";                   \
  93.                             elif [ -x "$(ALL_PATCH_APPLY)/$$name"   ] &&           \
  94.                                  [ -x "$(ALL_PATCH_UNPATCH)/$$name" ]; then        \
  95.                                echo "$(ALL_PATCH_APPLY)/$$name";                   \
  96.                             else                                                 \
  97.                                echo "$$name.error";                                \
  98.                             fi;                                                  \
  99.                         done)
  100.  
  101. temp_patch_not_found = $(filter %.error, $(temp_valid_patches))
  102. patch_not_found = $(subst .error,,$(temp_patch_not_found))
  103. ifneq ($(strip $(patch_not_found)),)
  104. $(error Could not find patch for $(patch_not_found))
  105. endif
  106.  
  107. valid_patches = $(filter-out %.error, $(temp_valid_patches))
  108.  
  109. ifeq ($(strip $(valid_patches)),)
  110. $(error Could not find patch scripts for $(canonical_patches))
  111. endif
  112.  
  113.  
  114.  
  115. canonical_unpatches = $(shell new="";                                         \
  116.                               for name in $(canonical_patches); do            \
  117.                                   new="$$name $$new";                         \
  118.                               done;                                           \
  119.                               echo $$new;)
  120.  
  121. temp_valid_unpatches = $(shell for name in $(canonical_unpatches); do            \
  122.                             if [ -x "$(VERSIONED_DIR_PATCH_APPLY)/$$name"   ] &&   \
  123.                                [ -x "$(VERSIONED_DIR_PATCH_UNPATCH)/$$name" ];     \
  124.                               then echo "$(VERSIONED_DIR_PATCH_UNPATCH)/$$name";   \
  125.                             elif [ -x "$(VERSIONED_ALL_PATCH_APPLY)/$$name"   ] && \
  126.                                  [ -x "$(VERSIONED_ALL_PATCH_UNPATCH)/$$name" ];   \
  127.                               then echo "$(VERSIONED_ALL_PATCH_UNPATCH)/$$name";   \
  128.                             elif [ -x "$(DIR_PATCH_APPLY)/$$name"   ] &&           \
  129.                                  [ -x "$(DIR_PATCH_UNPATCH)/$$name" ]; then        \
  130.                                echo "$(DIR_PATCH_UNPATCH)/$$name";                 \
  131.                             elif [ -x "$(ALL_PATCH_APPLY)/$$name"   ] &&           \
  132.                                  [ -x "$(ALL_PATCH_UNPATCH)/$$name" ]; then        \
  133.                                echo "$(ALL_PATCH_UNPATCH)/$$name";                 \
  134.                             else                                                 \
  135.                                echo $$name.error;                                \
  136.                             fi;                                                  \
  137.                         done)
  138. temp_unpatch_not_found = $(filter %.error, $(temp_valid_unpatches))
  139. unpatch_not_found = $(subst .error,,$(temp_unpatch_not_found))
  140. ifneq ($(strip $(unpatch_not_found)),)
  141. $(error Could not find unpatch for $(unpatch_not_found))
  142. endif
  143.  
  144. valid_unpatches = $(filter-out %.error, $(temp_valid_unpatches))
  145.  
  146. ifeq ($(strip $(valid_unpatches)),)
  147. $(error Could not find un-patch scripts for $(canonical_unpatches))
  148. endif
  149.  
  150.  
  151. endif
  152. else
  153. # OK. We want to patch the kernel, but there are no patches specified.
  154. valid_patches = $(shell if [ -n "$(VERSIONED_PATCH_DIR)" ] &&                 \
  155.                            [ -n "$(VERSIONED_DIR_PATCH_APPLY)" ] &&           \
  156.                            [ -d "$(VERSIONED_DIR_PATCH_APPLY)" ]; then        \
  157.                                run-parts --test $(VERSIONED_DIR_PATCH_APPLY); \
  158.                         fi;                                                   \
  159.                         if [ -n "$(VERSIONED_ALL_PATCH_DIR)" ] &&             \
  160.                            [ -n "$(VERSIONED_ALL_PATCH_APPLY)" ] &&           \
  161.                            [ -d "$(VERSIONED_ALL_PATCH_APPLY)" ]; then        \
  162.                                run-parts --test $(VERSIONED_ALL_PATCH_APPLY); \
  163.                         fi;                                                   \
  164.                         if [ -n "$(PATCH_DIR)" ] &&                           \
  165.                            [ -n "$(DIR_PATCH_APPLY)" ] &&                     \
  166.                            [ -d "$(DIR_PATCH_APPLY)" ]; then                  \
  167.                               run-parts --test $(DIR_PATCH_APPLY);            \
  168.                         fi;                                                   \
  169.                         if [ -n "$(ALL_PATCH_DIR)" ] &&                       \
  170.                            [ -n "$(ALL_PATCH_APPLY)" ] &&                     \
  171.                            [ -d "$(ALL_PATCH_APPLY)"  ]; then                 \
  172.                               run-parts --test $(ALL_PATCH_APPLY);            \
  173.                         fi)
  174. valid_unpatches = $(shell ( if [ -n "$(VERSIONED_PATCH_DIR)"       ]  &&          \
  175.                                [ -n "$(VERSIONED_DIR_PATCH_UNPATCH)" ] &&         \
  176.                                [ -d "$(VERSIONED_DIR_PATCH_UNPATCH)" ]; then      \
  177.                                  run-parts --test $(VERSIONED_DIR_PATCH_UNPATCH); \
  178.                             fi;                                                   \
  179.                             if [ -n "$(VERSIONED_ALL_PATCH_DIR)"    ]  &&         \
  180.                                [ -n "$(VERSIONED_ALL_PATCH_UNPATCH)" ] &&         \
  181.                                [ -d "$(VERSIONED_ALL_PATCH_UNPATCH)"  ]; then     \
  182.                                  run-parts --test $(VERSIONED_ALL_PATCH_UNPATCH); \
  183.                             fi;                                                   \
  184.                             if [ -n "$(PATCH_DIR)"       ]  &&                    \
  185.                                [ -n "$(DIR_PATCH_UNPATCH)" ] &&                   \
  186.                                [ -d "$(DIR_PATCH_UNPATCH)" ]; then                \
  187.                                  run-parts --test $(DIR_PATCH_UNPATCH);           \
  188.                             fi;                                                   \
  189.                             if [ -n "$(ALL_PATCH_DIR)"    ]  &&                   \
  190.                                [ -n "$(ALL_PATCH_UNPATCH)" ] &&                   \
  191.                                [ -d "$(ALL_PATCH_UNPATCH)"  ]; then               \
  192.                                 run-parts --test $(ALL_PATCH_UNPATCH);            \
  193.                             fi) | tac)
  194. endif
  195. endif
  196.  
  197. old_applied_patches=$(shell if [ -f applied_patches ]; then                   \
  198.                                cat applied_patches;                           \
  199.                             else                                              \
  200.                                echo '';                                       \
  201.                             fi )
  202.  
  203. ifeq ($(strip $(valid_unpatches)),)
  204. ifneq ($(strip $(old_applied_patches)),)
  205. old_unpatches=$(shell new="";                                          \
  206.                       for name in $(notdir $(old_applied_patches)); do \
  207.                           new="$$name $$new";                          \
  208.                       done;                                            \
  209.                       echo $$new;)
  210. temp_old_unpatches = $(shell for name in $(old_unpatches); do         \
  211.                             if [ -x "$(VERSIONED_DIR_PATCH_UNPATCH)/$$name" ];  \
  212.                               then echo "$(VERSIONED_DIR_PATCH_UNPATCH)/$$name";\
  213.                             elif [ -x "$(VERSIONED_ALL_PATCH_UNPATCH)/$$name" ];\
  214.                               then echo "$(VERSIONED_ALL_PATCH_UNPATCH)/$$name";\
  215.                             elif [ -x "$(DIR_PATCH_UNPATCH)/$$name" ]; then     \
  216.                                echo "$(DIR_PATCH_UNPATCH)/$$name";              \
  217.                             elif [ -x "$(ALL_PATCH_UNPATCH)/$$name" ]; then     \
  218.                                echo "$(ALL_PATCH_UNPATCH)/$$name";              \
  219.                             else                                              \
  220.                                echo "$$name.error";                             \
  221.                             fi;                                               \
  222.                         done)
  223. temp_old_unpatch_not_found = $(filter %.error, $(temp_old_unpatches))
  224. old_unpatch_not_found = $(subst .error,,$(temp_unpatch_not_found))
  225. valid_unpatches = $(filter-out %.error, $(temp_old_unpatches))
  226. endif
  227. endif
  228.  
  229.