Blame view

buildroot/buildroot-2016.08.1/package/qemu/qemu.mk 7.45 KB
6b13f685e   김민수   BSP 최초 추가
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
  ################################################################################
  #
  # qemu
  #
  ################################################################################
  
  QEMU_VERSION = 2.6.0
  QEMU_SOURCE = qemu-$(QEMU_VERSION).tar.bz2
  QEMU_SITE = http://wiki.qemu.org/download
  QEMU_LICENSE = GPLv2, LGPLv2.1, MIT, BSD-3c, BSD-2c, Others/BSD-1c
  QEMU_LICENSE_FILES = COPYING COPYING.LIB
  # NOTE: there is no top-level license file for non-(L)GPL licenses;
  #       the non-(L)GPL license texts are specified in the affected
  #       individual source files.
  
  #-------------------------------------------------------------
  # Host-qemu
  
  HOST_QEMU_DEPENDENCIES = host-pkgconf host-python host-zlib host-libglib2 host-pixman
  
  #       BR ARCH         qemu
  #       -------         ----
  #       arm             arm
  #       armeb           armeb
  #       bfin            not supported
  #       i486            i386
  #       i586            i386
  #       i686            i386
  #       x86_64          x86_64
  #       m68k            m68k
  #       microblaze      microblaze
  #       mips            mips
  #       mipsel          mipsel
  #       mips64          mips64
  #       mips64el        mips64el
  #       powerpc         ppc
  #       sh2a            not supported
  #       sh4             sh4
  #       sh4eb           sh4eb
  #       sh4a            sh4
  #       sh4aeb          sh4eb
  #       sh64            not supported
  #       sparc           sparc
  
  HOST_QEMU_ARCH = $(ARCH)
  ifeq ($(HOST_QEMU_ARCH),i486)
  HOST_QEMU_ARCH = i386
  endif
  ifeq ($(HOST_QEMU_ARCH),i586)
  HOST_QEMU_ARCH = i386
  endif
  ifeq ($(HOST_QEMU_ARCH),i686)
  HOST_QEMU_ARCH = i386
  endif
  ifeq ($(HOST_QEMU_ARCH),powerpc)
  HOST_QEMU_ARCH = ppc
  endif
  ifeq ($(HOST_QEMU_ARCH),sh4a)
  HOST_QEMU_ARCH = sh4
  endif
  ifeq ($(HOST_QEMU_ARCH),sh4aeb)
  HOST_QEMU_ARCH = sh4eb
  endif
  
  ifeq ($(BR2_PACKAGE_HOST_QEMU_SYSTEM_MODE),y)
  HOST_QEMU_TARGETS += $(HOST_QEMU_ARCH)-softmmu
  HOST_QEMU_OPTS += --enable-system --enable-fdt
  HOST_QEMU_DEPENDENCIES += host-dtc
  else
  HOST_QEMU_OPTS += --disable-system
  endif
  
  ifeq ($(BR2_PACKAGE_HOST_QEMU_LINUX_USER_MODE),y)
  HOST_QEMU_TARGETS += $(HOST_QEMU_ARCH)-linux-user
  HOST_QEMU_OPTS += --enable-linux-user
  
  HOST_QEMU_HOST_SYSTEM_TYPE = $(shell uname -s)
  ifneq ($(HOST_QEMU_HOST_SYSTEM_TYPE),Linux)
  $(error "qemu-user can only be used on Linux hosts")
  endif
  
  # kernel version as major*256 + minor
  HOST_QEMU_HOST_SYSTEM_VERSION = $(shell uname -r | awk -F. '{ print $$1 * 256 + $$2 }')
  HOST_QEMU_TARGET_SYSTEM_VERSION = $(shell echo $(BR2_TOOLCHAIN_HEADERS_AT_LEAST) | awk -F. '{ print $$1 * 256 + $$2 }')
  HOST_QEMU_COMPARE_VERSION = $(shell test $(HOST_QEMU_HOST_SYSTEM_VERSION) -ge $(HOST_QEMU_TARGET_SYSTEM_VERSION) && echo OK)
  
  #
  # The principle of qemu-user is that it emulates the instructions of
  # the target architecture when running the binary, and then when this
  # binary does a system call, it converts this system call into a
  # system call on the host machine. This mechanism makes an assumption:
  # that the target binary will not do system calls that do not exist on
  # the host. This basically requires that the target binary should be
  # built with kernel headers that are older or the same as the kernel
  # version running on the host machine.
  #
  
  ifeq ($(BR_BUILDING),y)
  ifneq ($(HOST_QEMU_COMPARE_VERSION),OK)
  $(error "Refusing to build qemu-user: target Linux version newer than host's.")
  endif
  endif # BR_BUILDING
  
  else # BR2_PACKAGE_HOST_QEMU_LINUX_USER_MODE
  HOST_QEMU_OPTS += --disable-linux-user
  endif # BR2_PACKAGE_HOST_QEMU_LINUX_USER_MODE
  
  ifeq ($(BR2_PACKAGE_HOST_QEMU_VDE2),y)
  HOST_QEMU_OPTS += --enable-vde
  HOST_QEMU_DEPENDENCIES += host-vde2
  endif
  
  define HOST_QEMU_CONFIGURE_CMDS
  	cd $(@D); $(HOST_CONFIGURE_OPTS) ./configure    \
  		--target-list="$(HOST_QEMU_TARGETS)"    \
  		--prefix="$(HOST_DIR)/usr"              \
  		--interp-prefix=$(STAGING_DIR)          \
  		--cc="$(HOSTCC)"                        \
  		--host-cc="$(HOSTCC)"                   \
  		--python=$(HOST_DIR)/usr/bin/python2    \
  		--extra-cflags="$(HOST_CFLAGS)"         \
  		--extra-ldflags="$(HOST_LDFLAGS)"       \
  		$(HOST_QEMU_OPTS)
  endef
  
  define HOST_QEMU_BUILD_CMDS
  	$(HOST_MAKE_ENV) $(MAKE) -C $(@D)
  endef
  
  define HOST_QEMU_INSTALL_CMDS
  	$(HOST_MAKE_ENV) $(MAKE) -C $(@D) install
  endef
  
  $(eval $(host-generic-package))
  
  # variable used by other packages
  QEMU_USER = $(HOST_DIR)/usr/bin/qemu-$(HOST_QEMU_ARCH)
  
  #-------------------------------------------------------------
  # Target-qemu
  
  QEMU_DEPENDENCIES = host-pkgconf host-python libglib2 zlib pixman
  
  # Need the LIBS variable because librt and libm are
  # not automatically pulled. :-(
  QEMU_LIBS = -lrt -lm
  
  QEMU_OPTS =
  
  QEMU_VARS = \
  	LIBTOOL=$(HOST_DIR)/usr/bin/libtool \
  	PYTHON=$(HOST_DIR)/usr/bin/python2 \
  	PYTHONPATH=$(TARGET_DIR)/usr/lib/python$(PYTHON_VERSION_MAJOR)/site-packages
  
  # If we want to specify only a subset of targets, we must still enable all
  # of them, so that QEMU properly builds its list of default targets, from
  # which it then checks if the specified sub-set is valid. That's what we
  # do in the first part of the if-clause.
  # Otherwise, if we do not want to pass a sub-set of targets, we then need
  # to either enable or disable -user and/or -system emulation appropriately.
  # That's what we do in the else-clause.
  ifneq ($(call qstrip,$(BR2_PACKAGE_QEMU_CUSTOM_TARGETS)),)
  QEMU_OPTS += --enable-system --enable-linux-user
  QEMU_OPTS += --target-list="$(call qstrip,$(BR2_PACKAGE_QEMU_CUSTOM_TARGETS))"
  else
  
  ifeq ($(BR2_PACKAGE_QEMU_SYSTEM),y)
  QEMU_OPTS += --enable-system
  else
  QEMU_OPTS += --disable-system
  endif
  
  ifeq ($(BR2_PACKAGE_QEMU_LINUX_USER),y)
  QEMU_OPTS += --enable-linux-user
  else
  QEMU_OPTS += --disable-linux-user
  endif
  
  endif
  
  ifeq ($(BR2_PACKAGE_QEMU_SDL),y)
  QEMU_OPTS += --enable-sdl
  QEMU_DEPENDENCIES += sdl
  QEMU_VARS += SDL_CONFIG=$(BR2_STAGING_DIR)/usr/bin/sdl-config
  else
  QEMU_OPTS += --disable-sdl
  endif
  
  ifeq ($(BR2_PACKAGE_QEMU_FDT),y)
  QEMU_OPTS += --enable-fdt
  QEMU_DEPENDENCIES += dtc
  else
  QEMU_OPTS += --disable-fdt
  endif
  
  define QEMU_CONFIGURE_CMDS
  	( cd $(@D);                                     \
  		LIBS='$(QEMU_LIBS)'                     \
  		$(TARGET_CONFIGURE_OPTS)                \
  		$(TARGET_CONFIGURE_ARGS)                \
  		$(QEMU_VARS)                            \
  		./configure                             \
  			--prefix=/usr                   \
  			--cross-prefix=$(TARGET_CROSS)  \
  			--with-system-pixman            \
  			--audio-drv-list=               \
  			--enable-kvm                    \
  			--enable-attr                   \
  			--enable-vhost-net              \
  			--disable-bsd-user              \
  			--disable-xen                   \
  			--disable-slirp                 \
  			--disable-vnc                   \
  			--disable-virtfs                \
  			--disable-brlapi                \
  			--disable-curses                \
  			--disable-curl                  \
  			--disable-bluez                 \
  			--disable-uuid                  \
  			--disable-vde                   \
  			--disable-linux-aio             \
  			--disable-cap-ng                \
  			--disable-docs                  \
  			--disable-spice                 \
  			--disable-rbd                   \
  			--disable-libiscsi              \
  			--disable-usb-redir             \
  			--disable-strip                 \
  			--disable-seccomp               \
  			--disable-sparse                \
  			--disable-tools                 \
  			$(QEMU_OPTS)                    \
  	)
  endef
  
  define QEMU_BUILD_CMDS
  	$(TARGET_MAKE_ENV) $(MAKE) -C $(@D)
  endef
  
  define QEMU_INSTALL_TARGET_CMDS
  	$(TARGET_MAKE_ENV) $(MAKE) -C $(@D) $(QEMU_MAKE_ENV) DESTDIR=$(TARGET_DIR) install
  endef
  
  $(eval $(generic-package))