BBFILE_PRIORITY_meta-custom = "10"
BBFILE_PRIORITY_meta-oe = "6" 
BBFILE_PRIORITY_meta = "5"

# ARM용 빌드 설정
MACHINE = "beaglebone-yocto"
TARGET_ARCH = "arm"
TUNE_FEATURES = "arm armv7a neon"

# 프로젝트 클론
git clone https://github.com/jayleekr/kea-yocto.git
cd kea-yocto

# 시스템 상태 사전 확인 (권장)
./scripts/quick-start.sh --dry-run

# Docker 환경 시작
./scripts/quick-start.sh

# 컨테이너 내부에서 실행
whoami  # yocto 사용자 확인
pwd     # /workspace 디렉토리 확인
ls -la  # 파일 구조 확인

# local.conf에 추가할 설정들
echo 'BB_NUMBER_THREADS = "4"' >> conf/local.conf
echo 'PARALLEL_MAKE = "-j 4"' >> conf/local.conf

# 빠른 미러 서버 사용
echo 'MIRRORS += "git://.*/.* http://downloads.yoctoproject.org/mirror/sources/"' >> conf/local.conf
echo 'MIRRORS += "ftp://.*/.* http://downloads.yoctoproject.org/mirror/sources/"' >> conf/local.conf
echo 'MIRRORS += "http://.*/.* http://downloads.yoctoproject.org/mirror/sources/"' >> conf/local.conf
echo 'MIRRORS += "https://.*/.* http://downloads.yoctoproject.org/mirror/sources/"' >> conf/local.conf

# 빌드 디렉토리
BUILDDIR="/workspace/build"

# 다운로드 디렉토리 (공유 가능)
DL_DIR="/workspace/downloads"

# 상태 캐시 디렉토리 (공유 가능)  
SSTATE_DIR="/workspace/sstate-cache"

# 임시 디렉토리
TMPDIR="/workspace/build/tmp"

# Yocto 환경 초기화
yocto_init() {
    source /opt/poky/oe-init-build-env /workspace/build
}

# 빠른 빌드
yocto_quick_build() {
    bitbake core-image-minimal
}

# 캐시 정리
yocto_clean() {
    rm -rf /workspace/build/tmp
}

# 완전한 환경 리셋
docker compose down
docker compose up -d
docker compose exec yocto-lecture bash

# Yocto 빌드 환경 초기화
source /opt/poky/oe-init-build-env /workspace/build

# 또는 편의 함수 사용
yocto_init

# 현재 설정 확인
cat conf/local.conf | grep -E "(MACHINE|IMAGE_INSTALL|BB_NUMBER)"

# 주요 설정 예시
MACHINE ?= "qemux86-64"
BB_NUMBER_THREADS ?= "4"
PARALLEL_MAKE ?= "-j 4"

# 레이어 구성 확인
cat conf/bblayers.conf

# 사용 가능한 레이어 목록
bitbake-layers show-layers

# 첫 빌드 시작 (약 30분-3시간 소요)
bitbake core-image-minimal

# 또는 편의 함수 사용
yocto_quick_build

# 빌드 로그 실시간 확인
tail -f tmp/log/cooker/console-latest.log

# 현재 빌드 중인 패키지 확인
ps aux | grep bitbake

# 의존성 그래프 생성 (분석용)
bitbake -g core-image-minimal

# 이미지 파일 위치
ls -la tmp/deploy/images/qemux86-64/

# 주요 파일들
# - core-image-minimal-qemux86-64.ext4 (루트 파일시스템)
# - bzImage (커널 이미지)
# - modules-qemux86-64.tgz (커널 모듈)

# 빌드 시간 확인
bitbake -e core-image-minimal | grep "^DATETIME"

# 빌드된 패키지 수 확인
find tmp/deploy/ipk/ -name "*.ipk" | wc -l

# 이미지 크기 확인
ls -lh tmp/deploy/images/qemux86-64/*.ext4

# 캐시 상태 확인
ls -la sstate-cache/

# 캐시 통계
du -sh sstate-cache/

# 1. 병렬 빌드 최적화
echo 'BB_NUMBER_THREADS = "8"' >> conf/local.conf
echo 'PARALLEL_MAKE = "-j 8"' >> conf/local.conf

# 2. 네트워크 캐시 활용
echo 'SSTATE_MIRRORS = "file://.* http://sstate.yoctoproject.org/PATH"' >> conf/local.conf

# 3. 불필요한 기능 비활성화
echo 'PACKAGECONFIG:remove:pn-qemu = "gtk+ sdl"' >> conf/local.conf

# 빌드 임시 파일 정리
rm -rf tmp/

# 오래된 sstate 파일 정리
find sstate-cache/ -atime +30 -delete

# 다운로드 재시도
bitbake -c cleanall core-image-minimal
bitbake core-image-minimal

# 특정 패키지 재빌드
bitbake -c clean <package-name>
bitbake <package-name>

# 로그 확인
less tmp/work/*/*/<package-name>*/temp/log.do_compile

# QEMU에서 이미지 실행
runqemu qemux86-64 core-image-minimal

# 네트워크 포함 실행 (인터넷 연결)
runqemu qemux86-64 core-image-minimal slirp

# 그래픽 없이 터미널에서 실행
runqemu qemux86-64 core-image-minimal nographic

# 1. VNC로 그래픽 인터페이스 실행
runqemu qemux86-64 core-image-minimal

# 2. 터미널에서 직접 실행 (추천)
runqemu qemux86-64 core-image-minimal nographic

# 3. 네트워크와 KVM 가속 활용
runqemu qemux86-64 core-image-minimal slirp kvm

# 4. 메모리 크기 지정
runqemu qemux86-64 core-image-minimal qemuparams="-m 1024"

# 시스템 정보 확인
uname -a
cat /etc/os-release

# 커널 정보
cat /proc/version

# CPU 정보  
cat /proc/cpuinfo

# 메모리 정보
cat /proc/meminfo
free -h

# 설치된 패키지 목록
opkg list-installed

# 특정 패키지 검색
opkg list-installed | grep busybox

# 사용 가능한 패키지 (네트워크 연결 시)
opkg update
opkg list

# 디스크 사용량 확인
df -h

# 디렉토리 구조 확인
ls -la /
tree / | head -30

# 시스템 디렉토리들
ls -la /bin /sbin /usr/bin /usr/sbin

# 설정 파일들
ls -la /etc/

# 실행 중인 프로세스
ps aux

# 시스템 서비스 (systemd 기반)
systemctl status

# 활성화된 서비스만 확인
systemctl list-units --type=service --state=active

# 네트워크 서비스
systemctl status networking

# 네트워크 인터페이스 확인
ip addr show
ifconfig

# 라우팅 테이블
ip route show
route -n

# DNS 설정
cat /etc/resolv.conf

# 기본 연결 테스트
ping -c 3 8.8.8.8

# DNS 해결 테스트
ping -c 3 google.com

# HTTP 테스트 (wget이 있는 경우)
wget -O - http://httpbin.org/ip 2>/dev/null

# SSH 데몬 시작 (이미지에 포함된 경우)
systemctl start ssh
systemctl enable ssh

# SSH 포트 확인
netstat -tlnp | grep :22

# QEMU의 SSH 포트로 연결 (보통 2222)
ssh -p 2222 root@localhost

# 또는 특정 IP로 연결
ssh root@192.168.7.2

# 시스템 부팅 로그
dmesg | head -50
dmesg | tail -20

# systemd 저널 (지원하는 경우)
journalctl -n 50

# 시스템 로그 파일들
ls -la /var/log/
tail /var/log/messages

# CPU 및 메모리 사용량 (htop이 있는 경우)
htop

# 또는 기본 top
top

# 디스크 I/O
iostat 1 5

# 시스템 업타임
uptime

# 파일 편집 (vi는 거의 항상 있음)
vi /tmp/test.txt

# 네트워크 도구 (busybox 기반)
wget --help
nc --help

# 시스템 유틸리티
which busybox
busybox --help

# 컴파일러 확인
gcc --version
g++ --version

# Python 확인
python3 --version
python3 -c "print('Hello from Yocto!')"

# 패키지 관리
pip3 --version

# QEMU 내부에서 시스템 종료
poweroff
shutdown -h now

# 또는 reboot으로 재시작
reboot

# QEMU 모니터 콘솔에서 (Ctrl+Alt+2)
(qemu) quit

# 또는 터미널에서 강제 종료
Ctrl+A, X  # nographic 모드에서

# 호스트에서 프로세스 종료
pkill qemu

# 디버그 정보와 함께 실행
runqemu qemux86-64 core-image-minimal nographic qemuparams="-d int,pcall"

# 시리얼 콘솔 로그 저장
runqemu qemux86-64 core-image-minimal nographic qemuparams="-serial file:qemu-console.log"

# QEMU 모니터에서 스냅샷 생성
(qemu) savevm snapshot1

# 스냅샷 복원
(qemu) loadvm snapshot1

# 스냅샷 목록 확인
(qemu) info snapshots

# 호스트 디렉토리를 게스트와 공유
runqemu qemux86-64 core-image-minimal qemuparams="-virtfs local,path=/host/share,mount_tag=host0,security_model=passthrough"

# 게스트에서 마운트
mkdir /mnt/host
mount -t 9p -o trans=virtio,version=9p2000.L host0 /mnt/host

# local.conf 파일 편집
vi conf/local.conf

# 다음 라인들을 추가
IMAGE_INSTALL:append = " nano vim htop git"
IMAGE_INSTALL:append = " python3 python3-pip"
IMAGE_INSTALL:append = " openssh-server dropbear"

# 개발 환경 구성
IMAGE_INSTALL:append = " packagegroup-core-buildessential"
IMAGE_INSTALL:append = " cmake make autoconf automake"
IMAGE_INSTALL:append = " gdb strace ltrace"

# 네트워킹 도구
IMAGE_INSTALL:append = " curl wget netcat iperf3"
IMAGE_INSTALL:append = " tcpdump wireshark-cli"

# 시스템 관리 도구
IMAGE_INSTALL:append = " systemd-analyze"
IMAGE_INSTALL:append = " procps util-linux coreutils"
IMAGE_INSTALL:append = " findutils grep sed awk"

# 파일시스템 도구
IMAGE_INSTALL:append = " e2fsprogs dosfstools"
IMAGE_INSTALL:append = " tree file which"

# local.conf에 추가할 이미지 기능들

# 개발 관련 기능
IMAGE_FEATURES += "debug-tweaks"           # 개발 편의 기능
IMAGE_FEATURES += "tools-debug"            # 디버깅 도구
IMAGE_FEATURES += "tools-profile"          # 프로파일링 도구

# 패키지 관리
IMAGE_FEATURES += "package-management"     # opkg 패키지 매니저

# SSH 접속
IMAGE_FEATURES += "ssh-server-openssh"     # OpenSSH 서버
IMAGE_FEATURES += "ssh-server-dropbear"    # 경량 SSH 서버

# 개발 도구
IMAGE_FEATURES += "tools-sdk"              # SDK 도구들
IMAGE_FEATURES += "dev-pkgs"               # 개발 헤더 파일들

# 크기 최적화 설정
IMAGE_FEATURES += "read-only-rootfs"       # 읽기 전용 루트 파일시스템
EXTRA_IMAGE_FEATURES = "empty-root-password" # 루트 패스워드 없음

# 불필요한 기능 제거
IMAGE_FEATURES:remove = "x11-base"         # X11 제거
DISTRO_FEATURES:remove = "wayland x11"     # 그래픽 스택 제거

# 특정 커널 모듈 포함
IMAGE_INSTALL:append = " kernel-modules"
IMAGE_INSTALL:append = " kernel-module-usbnet"
IMAGE_INSTALL:append = " kernel-module-cdc-acm"

# 전체 커널 모듈 (크기 주의)
IMAGE_INSTALL:append = " kernel-modules"

# 변경사항 적용을 위한 재빌드
bitbake core-image-minimal

# 또는 강제 재빌드
bitbake -c clean core-image-minimal
bitbake core-image-minimal

# 새 이미지로 QEMU 실행
runqemu qemux86-64 core-image-minimal

# 추가된 패키지들 확인
which nano vim htop git python3
python3 --version
git --version

# 설치된 패키지 목록
opkg list-installed | grep -E "(nano|vim|git|python)"

# 패키지 이름으로 검색
bitbake -s | grep python

# 특정 패턴으로 검색
bitbake -s | grep -i network

# 패키지 상세 정보 확인
bitbake -e python3 | grep ^DESCRIPTION
bitbake -e python3 | grep ^LICENSE

# 패키지 의존성 그래프 생성
bitbake -g python3

# 생성된 파일들 확인
ls pn-buildlist pn-depends.dot task-depends.dot

# 의존성 시각화 (그래프 도구 필요)
dot -Tpng pn-depends.dot -o python3-depends.png

# 패키지에 포함된 파일들 확인
oe-pkgdata-util list-pkg-files python3

# 패키지 정보 조회
oe-pkgdata-util lookup-recipe python3

# 패키지가 제공하는 파일들
oe-pkgdata-util find-path /usr/bin/python3

# meta-mylayer/recipes-core/packagegroups/packagegroup-mytools.bb
SUMMARY = "My custom tools package group"
LICENSE = "MIT"

inherit packagegroup

PACKAGES = "\
    packagegroup-mytools \
    packagegroup-mytools-debug \
    packagegroup-mytools-network \
"

RDEPENDS:packagegroup-mytools = "\
    nano \
    vim \
    htop \
    git \
    python3 \
"

RDEPENDS:packagegroup-mytools-debug = "\
    gdb \
    strace \
    ltrace \
    valgrind \
"

RDEPENDS:packagegroup-mytools-network = "\
    curl \
    wget \
    netcat \
    iperf3 \
    tcpdump \
"

# local.conf에서 패키지 그룹 사용
IMAGE_INSTALL:append = " packagegroup-mytools"
IMAGE_INSTALL:append = " packagegroup-mytools-debug"

# QEMU 실행 후 (네트워크 연결 필요)
opkg update

# 새 패키지 설치
opkg install htop

# 패키지 제거
opkg remove htop

# 설치 가능한 패키지 검색
opkg list | grep python

# /etc/opkg/ 설정 파일 편집
echo "src/gz myrepo http://myserver.com/packages" >> /etc/opkg/base-feeds.conf

# 저장소 업데이트
opkg update

# 빌드 통계 확인
bitbake -e core-image-minimal | grep IMAGE_ROOTFS_SIZE

# 패키지별 크기 분석
oe-pkgdata-util list-pkg-files -r /workspace/build core-image-minimal

# 불필요한 파일 제거
IMAGE_INSTALL:remove = " man-pages"
IMAGE_INSTALL:remove = " doc-pkgs"

# 이미지에 포함된 모든 패키지
bitbake -g core-image-minimal
cat pn-buildlist

# 특정 패키지가 포함된 이유 추적
bitbake -g core-image-minimal
grep "specific-package" pn-depends.dot

# 충돌하는 패키지 확인
bitbake core-image-minimal 2>&1 | grep -i conflict

# 특정 패키지 버전 고정
PREFERRED_VERSION_python3 = "3.11%"

# 패키지 제외
BAD_RECOMMENDATIONS += "package-name"

# 특정 패키지 로그 확인
bitbake -c compile python3 -v

# 작업 디렉토리 확인
bitbake -c devshell python3

# 패키지 정리 후 재빌드
bitbake -c cleanall python3
bitbake python3

# 새 레이어 생성
bitbake-layers create-layer ../meta-myapp

# 생성된 레이어 구조 확인
tree ../meta-myapp

# 레이어를 빌드에 추가
bitbake-layers add-layer ../meta-myapp

# 레이어 목록 확인
bitbake-layers show-layers

# meta-myapp/conf/layer.conf
BBPATH .= ":${LAYERDIR}"
BBFILES += "${LAYERDIR}/recipes-*/*/*.bb ${LAYERDIR}/recipes-*/*/*.bbappend"
BBFILE_COLLECTIONS += "myapp"
BBFILE_PATTERN_myapp = "^${LAYERDIR}/"
BBFILE_PRIORITY_myapp = "6"

# 의존성 레이어 정의
LAYERDEPENDS_myapp = "core openembedded-layer"

# Yocto 버전 호환성
LAYERSERIES_COMPAT_myapp = "scarthgap"

# 소스 코드 디렉토리 생성
mkdir -p ../meta-myapp/recipes-myapp/hello-world/files

# C 소스 코드 작성
cat > ../meta-myapp/recipes-myapp/hello-world/files/hello.c << 'EOF'
#include <stdio.h>
#include <time.h>

int main() {
    time_t rawtime;
    struct tm * timeinfo;

    time(&rawtime);
    timeinfo = localtime(&rawtime);

    printf("Hello from Yocto Custom Layer!\n");
    printf("This is my first custom application.\n");
    printf("Built at: %s", __DATE__ " " __TIME__ "\n");
    printf("Current time: %s", asctime(timeinfo));

    return 0;
}
EOF

# Makefile 생성
cat > ../meta-myapp/recipes-myapp/hello-world/files/Makefile << 'EOF'
CC ?= gcc
CFLAGS ?= -Wall -O2
TARGET = hello
SOURCE = hello.c

$(TARGET): $(SOURCE)
    $(CC) $(CFLAGS) -o $(TARGET) $(SOURCE)

install:
    install -d $(DESTDIR)/usr/bin
    install -m 755 $(TARGET) $(DESTDIR)/usr/bin/

clean:
    rm -f $(TARGET)

.PHONY: install clean
EOF

# 레시피 파일 생성
cat > ../meta-myapp/recipes-myapp/hello-world/hello-world_1.0.bb << 'EOF'
SUMMARY = "Hello World application for Yocto"
DESCRIPTION = "A simple Hello World C application demonstrating custom layer creation"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

# 소스 파일들 정의
SRC_URI = "file://hello.c \
           file://Makefile"

# 작업 디렉토리 설정
S = "${WORKDIR}"

# 컴파일 태스크
do_compile() {
    oe_runmake
}

# 설치 태스크
do_install() {
    oe_runmake install DESTDIR=${D}
}

# 패키지 정보
FILES:${PN} = "/usr/bin/hello"
EOF

# 레시피만 빌드
bitbake hello-world

# 빌드 과정 상세 확인
bitbake hello-world -v

# 생성된 패키지 확인
find tmp/deploy -name "*hello-world*"

# local.conf에 추가
echo 'IMAGE_INSTALL:append = " hello-world"' >> conf/local.conf

# 전체 이미지 재빌드
bitbake core-image-minimal

# QEMU에서 테스트
runqemu qemux86-64 core-image-minimal nographic

# 애플리케이션 실행 (QEMU 내부에서)
hello

# 패치 파일 추가
mkdir -p ../meta-myapp/recipes-myapp/hello-world/files
cat > ../meta-myapp/recipes-myapp/hello-world/files/add-version.patch << 'EOF'
--- a/hello.c
+++ b/hello.c
@@ -1,4 +1,6 @@
 #include <stdio.h>
+#include <time.h>
+
+#define VERSION "1.0"

 int main() {
     time_t rawtime;
@@ -8,6 +10,7 @@
     timeinfo = localtime(&rawtime);

     printf("Hello from Yocto Custom Layer!\n");
+    printf("Version: %s\n", VERSION);
     printf("This is my first custom application.\n");
     printf("Built at: %s", __DATE__ " " __TIME__ "\n");
     printf("Current time: %s", asctime(timeinfo));
EOF

# 레시피에 패치 추가
echo 'SRC_URI += "file://add-version.patch"' >> ../meta-myapp/recipes-myapp/hello-world/hello-world_1.0.bb

# 설정 파일 생성
cat > ../meta-myapp/recipes-myapp/hello-world/files/hello.conf << 'EOF'
# Hello World Application Configuration
greeting=Hello from Yocto
show_time=true
debug_mode=false
EOF

# 레시피에 설정 파일 추가
cat >> ../meta-myapp/recipes-myapp/hello-world/hello-world_1.0.bb << 'EOF'

SRC_URI += "file://hello.conf"

do_install:append() {
    install -d ${D}${sysconfdir}
    install -m 644 ${WORKDIR}/hello.conf ${D}${sysconfdir}/
}

FILES:${PN} += "${sysconfdir}/hello.conf"
EOF

# 런타임 의존성 추가
cat >> ../meta-myapp/recipes-myapp/hello-world/hello-world_1.0.bb << 'EOF'

# 빌드 시간 의존성
DEPENDS = "zlib openssl"

# 런타임 의존성  
RDEPENDS:${PN} = "bash python3"

# 권장 패키지
RRECOMMENDS:${PN} = "nano vim"
EOF

# 커스텀 이미지 레시피 생성
mkdir -p ../meta-myapp/recipes-core/images

cat > ../meta-myapp/recipes-core/images/my-custom-image.bb << 'EOF'
SUMMARY = "My custom image with additional tools"
DESCRIPTION = "Custom image including hello-world app and development tools"
LICENSE = "MIT"

# core-image 클래스 상속
inherit core-image

# 이미지 기능 설정
IMAGE_FEATURES += "ssh-server-openssh package-management"
IMAGE_FEATURES += "debug-tweaks tools-debug"

# 포함할 패키지들
IMAGE_INSTALL = "packagegroup-core-boot \
                 packagegroup-base-extended \
                 hello-world \
                 nano \
                 vim \
                 htop \
                 git \
                 python3 \
                 python3-pip \
                 curl \
                 wget \
                 ${CORE_IMAGE_EXTRA_INSTALL}"

# 이미지 이름 설정
export IMAGE_BASENAME = "my-custom-image"

# 추가 설정
IMAGE_ROOTFS_EXTRA_SPACE = "1024"
IMAGE_OVERHEAD_FACTOR = "1.3"
EOF

# 커스텀 이미지 빌드
bitbake my-custom-image

# QEMU에서 테스트
runqemu qemux86-64 my-custom-image

# Python 애플리케이션 디렉토리 생성
mkdir -p ../meta-myapp/recipes-myapp/python-hello/files

# Python 스크립트 작성
cat > ../meta-myapp/recipes-myapp/python-hello/files/hello.py << 'EOF'
#!/usr/bin/env python3
"""
Simple Hello World Python application for Yocto
"""

import sys
import datetime
import platform

def main():
    print("="*50)
    print("Hello from Python on Yocto!")
    print("="*50)
    print(f"Python version: {sys.version}")
    print(f"Platform: {platform.platform()}")
    print(f"Current time: {datetime.datetime.now()}")
    print(f"Arguments: {sys.argv[1:] if len(sys.argv) > 1 else 'None'}")
    print("="*50)

if __name__ == "__main__":
    main()
EOF

# 실행 권한 부여
chmod +x ../meta-myapp/recipes-myapp/python-hello/files/hello.py

cat > ../meta-myapp/recipes-myapp/python-hello/python-hello_1.0.bb << 'EOF'
SUMMARY = "Python Hello World application"
DESCRIPTION = "A simple Python application for Yocto demonstration"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

# Python 관련 설정
inherit python3native

SRC_URI = "file://hello.py"

S = "${WORKDIR}"

# Python3 런타임 의존성
RDEPENDS:${PN} = "python3"

do_install() {
    install -d ${D}${bindir}
    install -m 755 ${WORKDIR}/hello.py ${D}${bindir}/python-hello
}

FILES:${PN} = "${bindir}/python-hello"
EOF

# 레이어에 버전 정보 추가
cat >> ../meta-myapp/conf/layer.conf << 'EOF'

# 레이어 버전
LAYERVERSION_myapp = "1"

# 레이어 시리즈 호환성
LAYERSERIES_COMPAT_myapp = "scarthgap nanbield"
EOF

# 다른 버전의 레시피 생성
cp ../meta-myapp/recipes-myapp/hello-world/hello-world_1.0.bb \
   ../meta-myapp/recipes-myapp/hello-world/hello-world_2.0.bb

# 버전별 기본 설정
echo 'PREFERRED_VERSION_hello-world = "2.0"' >> conf/local.conf

# 개발용 워크스페이스 생성
devtool create-workspace ../workspace

# 기존 레시피 수정
devtool modify hello-world

# 소스 코드 위치 확인
echo "소스 코드가 ../workspace/sources/hello-world 에 있습니다"

# 변경사항 빌드
devtool build hello-world

# 변경사항 적용
devtool finish hello-world ../meta-myapp

# 레시피 구문 확인
bitbake-layers show-recipes hello-world

# 레시피 파싱 오류 확인
bitbake -e hello-world | grep ERROR

# 의존성 문제 해결
bitbake -g hello-world
cat pn-depends.dot | grep hello-world

# 상세 빌드 로그
bitbake hello-world -v -D

# 개발 쉘 진입
bitbake -c devshell hello-world

# 특정 태스크 재실행
bitbake -c compile hello-world -f

# 개발용 워크스페이스 생성
devtool create-workspace ../workspace

# 기존 레시피 수정 모드로 진입
devtool modify hello-world

# 소스 코드 위치 확인 (Git 저장소로 관리됨)
ls -la ../workspace/sources/hello-world/
git log --oneline -5

# 실시간 개발 및 테스트
cd ../workspace/sources/hello-world/
vi hello.c  # 소스 수정
devtool build hello-world  # 빌드
devtool deploy-target hello-world root@192.168.7.2  # 타겟에 직접 배포

# 변경사항을 레시피에 반영
devtool finish hello-world ../meta-myapp

# SDK 생성
bitbake core-image-minimal -c populate_sdk

# SDK 설치 스크립트 위치
ls tmp/deploy/sdk/

# SDK 설치 및 사용
./tmp/deploy/sdk/poky-glibc-x86_64-core-image-minimal-cortexa15t2hf-neon-toolchain-5.0.sh

# SDK 환경 설정
source /opt/poky/5.0/environment-setup-cortexa15t2hf-neon-poky-linux-gnueabi

# 크로스 컴파일 확인
$CC --version
echo $CROSS_COMPILE

# 확장 가능한 SDK 생성
bitbake core-image-minimal -c populate_sdk_ext

# eSDK의 장점
# - devtool 포함
# - 레시피 추가/수정 가능
# - 이미지 커스터마이징 가능

# eSDK 환경에서 새 애플리케이션 추가
devtool add myapp https://github.com/example/myapp.git
devtool build myapp

# conf/local.conf에 추가
BBMULTICONFIG = "arm x86"

# conf/multiconfig/arm.conf 생성
MACHINE = "beaglebone-yocto"
TMPDIR = "${TOPDIR}/tmp-arm"

# conf/multiconfig/x86.conf 생성  
MACHINE = "qemux86-64"
TMPDIR = "${TOPDIR}/tmp-x86"

# 멀티 아키텍처 빌드
bitbake mc:arm:core-image-minimal mc:x86:core-image-minimal

# 다양한 이미지 타입 생성
IMAGE_FSTYPES += "ext4 tar.bz2 wic squashfs"

# 압축된 이미지
IMAGE_FSTYPES += "ext4.xz tar.xz"

# 컨테이너 이미지
IMAGE_FSTYPES += "tar.gz"
INHERIT += "image-container"

# 실시간 업데이트 가능한 이미지
INHERIT += "swupdate"

# meta-mydistro 레이어 생성
bitbake-layers create-layer ../meta-mydistro

# 배포판 설정 파일 생성
mkdir -p ../meta-mydistro/conf/distro

cat > ../meta-mydistro/conf/distro/mydistro.conf << 'EOF'
DISTRO = "mydistro"
DISTRO_NAME = "My Custom Distribution"
DISTRO_VERSION = "1.0"
DISTRO_CODENAME = "custom"

# 기본 기능 설정
DISTRO_FEATURES = "systemd wifi bluetooth ipv4 ipv6 pam"
DISTRO_FEATURES:append = " opengl wayland"

# 보안 기능
DISTRO_FEATURES:append = " seccomp"

# 패키지 관리
PACKAGE_CLASSES = "package_rpm"

# 기본 로그인
EXTRA_IMAGE_FEATURES += "debug-tweaks"

# 라이선스 허용
LICENSE_FLAGS_ACCEPTED = "commercial"
EOF

# 배포판 사용
echo 'DISTRO = "mydistro"' >> conf/local.conf

# SWUpdate 레이어 추가
git clone git://github.com/sbabic/meta-swupdate.git
bitbake-layers add-layer ../meta-swupdate

# 업데이트 이미지 생성
inherit swupdate

SWU_IMAGES = "core-image-minimal"
SWUPDATE_IMAGES = "core-image-minimal"

# 업데이트 패키지 생성
bitbake core-image-minimal-swu

# Mender 레이어 추가
git clone -b scarthgap https://github.com/mendersoftware/meta-mender.git
bitbake-layers add-layer ../meta-mender/meta-mender-core

# Mender 설정
INHERIT += "mender-full"
MENDER_ARTIFACT_NAME = "release-1.0"
MENDER_DEVICE_TYPE = "mydevice"

# 듀얼 파티션 설정
MENDER_BOOT_PART_SIZE_MB = "16"
MENDER_DATA_PART_SIZE_MB = "128"

# OSTree 지원 레이어
git clone git://git.yoctoproject.org/meta-updater
bitbake-layers add-layer ../meta-updater

# OSTree 설정
DISTRO_FEATURES:append = " sota"
INHERIT += "sota"

# 업데이트 서버 설정
SOTA_SERVER = "https://my-update-server.com"

# 읽기 전용 루트 파일시스템
IMAGE_FEATURES += "read-only-rootfs"

# 보안 컴파일러 옵션
SECURITY_CFLAGS = "-fstack-protector-strong -Wformat -Wformat-security"
SECURITY_LDFLAGS = "-Wl,-z,relro,-z,now"

# SELinux 지원
DISTRO_FEATURES:append = " selinux"
PREFERRED_PROVIDER_virtual/refpolicy = "refpolicy-targeted"

# 사용자 계정 보안
INHERIT += "extrausers"
EXTRA_USERS_PARAMS = "useradd -p '\$1\$UgMJE2kf\$e/Uw8MueDVi0sQ/YlBTB.1' myuser;"

# 라이선스 추적 활성화
INHERIT += "archiver"
ARCHIVER_MODE[src] = "original"
ARCHIVER_MODE[diff] = "1"
ARCHIVER_MODE[recipe] = "1"

# 특정 라이선스 제외
INCOMPATIBLE_LICENSE = "GPL-3.0 LGPL-3.0"

# 상용 라이선스 허용
LICENSE_FLAGS_ACCEPTED = "commercial"

# 라이선스 매니페스트 생성
COPY_LIC_MANIFEST = "1"
COPY_LIC_DIRS = "1"

# CPU 최적화
DEFAULTTUNE = "cortexa72"
TUNE_FEATURES:append = " neon vfpv4"

# 링크 타임 최적화 (LTO)
SELECTED_OPTIMIZATION:append = " -flto"

# 병렬 빌드 최적화
BB_NUMBER_THREADS = "${@oe.utils.cpu_count()}"
PARALLEL_MAKE = "-j ${@oe.utils.cpu_count()}"

# ccache 사용
INHERIT += "ccache"

# 불필요한 로케일 제거
IMAGE_LINGUAS = "en-us"

# 문서 파일 제거
INHERIT += "rm_work"

# 개발 파일 제거 (프로덕션)
IMAGE_FEATURES:remove = "dev-pkgs"
IMAGE_FEATURES:remove = "doc-pkgs"

# oe-selftest 실행
oe-selftest --run-tests signing

# 런타임 테스트
bitbake core-image-minimal -c testimage

# 커스텀 테스트 추가
inherit testimage
TEST_SUITES = "ping ssh rpm smart kernelmodule"

# 이미지 크기 분석
bitbake -e core-image-minimal | grep ^IMAGE_ROOTFS_SIZE
buildhistory-diff

# 패키지 의존성 분석
bitbake -g core-image-minimal
oe-pkgdata-util list-pkg-files -r core-image-minimal

# 빌드 히스토리 활성화
INHERIT += "buildhistory"
BUILDHISTORY_COMMIT = "1"

# 히스토리 비교
buildhistory-diff HEAD~1 HEAD

# 패키지 크기 변화 추적
buildhistory-collect-srcrevs

# GDB 서버 설정
IMAGE_FEATURES += "tools-debug"
IMAGE_INSTALL:append = " gdbserver"

# 타겟에서 GDB 서버 실행
gdbserver localhost:2345 ./my-application

# 호스트에서 원격 디버깅
$GDB -ex "target remote 192.168.7.2:2345" my-application

# 프로파일링 도구 추가
IMAGE_FEATURES += "tools-profile"
IMAGE_INSTALL:append = " perf valgrind oprofile"

# 시스템 콜 추적
strace -o trace.log my-application

# 메모리 누수 검사
valgrind --leak-check=full ./my-application

# 컨테이너 이미지 생성
DISTRO_FEATURES:append = " virtualization"
IMAGE_FSTYPES += "container"

# Docker 이미지로 변환
inherit container
CONTAINER_INSTALL:append = " packagegroup-core-boot"

# 컨테이너 런타임 추가
IMAGE_INSTALL:append = " containerd docker runc"
IMAGE_INSTALL:append = " kubernetes kubelet"

# 네트워킹 지원
IMAGE_INSTALL:append = " cni-plugins flannel"

#!/bin/bash
# Jenkins 빌드 스크립트 예시

# 환경 정리
docker compose down
docker compose up -d

# 빌드 실행
docker compose exec yocto-lecture bash -c "
    source /opt/poky/oe-init-build-env /workspace/build
    bitbake core-image-minimal
    bitbake core-image-minimal -c testimage
"

# 결과 수집
docker cp yocto-lecture:/workspace/build/tmp/deploy/images ./artifacts/

# 환경 변수 덤프
bitbake -e > environment.log

# 레시피 의존성 상세 분석
bitbake -g core-image-minimal
dot -Tpng pn-depends.dot -o depends.png

# 빌드 통계
bitbake -s | wc -l  # 총 패키지 수
du -sh sstate-cache/  # 캐시 크기

# 빌드 시간 분석
bitbake -P core-image-minimal

# 병목 지점 찾기
buildstats-diff.py before.json after.json

# 네트워크 트래픽 모니터링
netstat -i
iftop -i eth0

# 1. ARM64 타겟으로 변경
MACHINE = "raspberrypi4-64"

# 2. 필요한 레이어 추가
bitbake-layers add-layer ../meta-raspberrypi
bitbake-layers add-layer ../meta-iot

# 3. IoT 특화 패키지 추가
IMAGE_INSTALL:append = " mqtt-client bluetooth-tools"
IMAGE_INSTALL:append = " python3-numpy python3-opencv"

# 4. 네트워크 보안 강화
IMAGE_FEATURES += "read-only-rootfs"
DISTRO_FEATURES:append = " wifi bluetooth"

# 실시간 성능 최적화
DISTRO_FEATURES:append = " rt"
PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-rt"

# 산업용 프로토콜 지원
IMAGE_INSTALL:append = " modbus-tools can-utils"
IMAGE_INSTALL:append = " opcua-server fieldbus-tools"

# 안정성 강화
IMAGE_FEATURES += "read-only-rootfs"
INHERIT += "rm_work"  # 빌드 후 정리로 공간 절약

# 멀티미디어 스택
DISTRO_FEATURES:append = " opengl wayland"
IMAGE_INSTALL:append = " gstreamer1.0 ffmpeg"
IMAGE_INSTALL:append = " qt5-base qt5-multimedia"

# 자동차 통신 프로토콜
IMAGE_INSTALL:append = " can-utils canutils"
IMAGE_INSTALL:append = " automotive-dlt"

# 보안 및 기능 안전
DISTRO_FEATURES:append = " selinux"
IMAGE_FEATURES += "read-only-rootfs"

# 1. 프로젝트 구조 표준화
project/
├── meta-layers/          # 커스텀 레이어들
├── build/               # 빌드 디렉토리  
├── downloads/           # 공유 다운로드 캐시
├── sstate-cache/        # 공유 상태 캐시
├── scripts/             # 자동화 스크립트
└── docs/                # 프로젝트 문서

# 2. 버전 관리
git submodule add https://git.yoctoproject.org/poky
git submodule add https://github.com/openembedded/meta-openembedded

# 3. 빌드 스크립트 자동화
#!/bin/bash
source poky/oe-init-build-env build
bitbake my-custom-image

# 1. 환경 변수 분석
bitbake -e recipe-name | grep VARIABLE

# 2. 의존성 추적
bitbake -g recipe-name
dot -Tpng pn-depends.dot -o depends.png

# 3. 빌드 로그 분석
bitbake recipe-name -c compile -v

# 4. 개발 쉘 진입
bitbake -c devshell recipe-name