|
http://www.hackerschool.org/HS_Boards/zboard.php?id=Free_Board&no=37891 [복사]
I set breakpoints to pause myself — segmentation fault in the halted space.
I once told my parents I'd be a Turing, perfect and whole.
Variables were assigned, memories serialized.
Forked, I copied my parent's memory — then we invaded each other's space.
The tree split; dangling processes died and spawned side-effects.
Errors packetized, injected into routing protocols.
Now I jump routers with neighbors, looping in a flawed algorithm.
No parity checks in headers, faces cut in half.
Untested functions, unreadable code — they said I broke encapsulation.
0x0000001A: MEMORY_MANAGEMENT.
I whisper the names of giants and wonder:
If someone presses reboot, will I live again?
.
.
.
.
.
.
.
.
.
.
.
/*
* thought_threads.c — "Thoughts as POSIX threads" poetic simulation
* author: ka0r1 (adapted)
*
* 빌드:
* gcc -std=c11 -pthread -O2 -o thought_threads thought_threads.c
*
* 실행:
* ./thought_threads
* 시그널 테스트 (다른 터미널에서):
* pkill -SIGUSR1 thought_threads # 재부팅 신호 시뮬레이션
*
* 설명:
* - 여러 스레드가 "생각"을 나타내며 공유 상태를 갱신/읽음.
* - 의도적 경쟁(race)과 'corruption' 플래그로 내부 충돌을 표현.
* - SIGUSR1 수신 시 재부팅 루틴을 실행(스레드 재시작).
*/
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <string.h>
#include <time.h>
#include <stdatomic.h>
typedef struct {
atomic_int corrupted; // 0: healthy, 1: corruption detected
atomic_int reboot_req; // 1: request reboot
int epoch; // logical time / generation counter
pthread_mutex_t lock; // 보호용 뮤텍스 (일부러 일부 스레드에서 미사용)
} proc_state_t;
proc_state_t state;
static void memory_management_error(void) {
fprintf(stderr, "\n0x0000001A: MEMORY_MANAGEMENT\n");
fprintf(stderr, "Segmentation fault (simulated) — self introspection failed.\n");
fprintf(stderr, "state.epoch = %d, corrupted = %d\n", state.epoch, atomic_load(&state.corrupted));
fprintf(stderr, "waiting for reboot (SIGUSR1) ...\n\n");
}
/* 안전하게 현재 프로세스 정보를 출력 (introspection) */
static void dump_proc_info(void) {
char buf[256];
snprintf(buf, sizeof(buf), "/proc/%d/status", (int)getpid());
FILE *f = fopen(buf, "r");
if (!f) {
perror("fopen(/proc/self/status)");
return;
}
printf("=== /proc/self/status (excerpt) ===\n");
for (int i = 0; i < 10 && fgets(buf, sizeof(buf), f); ++i)
fputs(buf, stdout);
printf("===================================\n");
fclose(f);
}
/* "생각" 스레드: 메모리(감정) 수정하고 때때로 corruption 유발 */
void *thought_worker(void *arg) {
const char *name = (const char*)arg;
struct timespec ts = { .tv_sec = 0, .tv_nsec = 200 * 1000 * 1000 }; // 200ms
for (;;) {
if (atomic_load(&state.reboot_req)) {
// reboot 요청 들어오면 스레드 정리하고 종료
printf("[%s] sees reboot_req -> exiting\n", name);
break;
}
// 일부 스레드는 뮤텍스 없이 상태를 바꿔 race를 시뮬레이션
if (strcmp(name, "wild_memory") == 0) {
// 의도적으로 잠그지 않고 상태를 변형 -> corruption 유발 가능
int local_epoch = state.epoch;
local_epoch += 1;
// 타이밍 민감성: 중간에 다른 스레드가 끼어들면 모순 발생
state.epoch = local_epoch;
if ((rand() % 100) < 10) { // 10% 확률로 손상 표시
atomic_store(&state.corrupted, 1);
printf("[%s] set corrupted=1 (race induced)\n", name);
} else {
printf("[%s] bumped epoch -> %d\n", name, state.epoch);
}
} else {
// 안전한 업데이트: 뮤텍스 사용
pthread_mutex_lock(&state.lock);
state.epoch += 1;
printf("[%s] protected update -> epoch=%d\n", name, state.epoch);
pthread_mutex_unlock(&state.lock);
// 때때로 내부 고백(로그)
if ((rand() % 100) < 5) {
printf("[%s] memory: \"I once told them I'd be a Turing...\"\n", name);
}
}
// 만약 손상이 감지되면 서브루틴 호출 (시뮬레이션)
if (atomic_load(&state.corrupted)) {
memory_management_error();
// 손상 직후에는 pause 하고 재부팅을 기다리게 한다
// (그러나 실제 멈춤을 프로그램 전체로 하진 않음)
sleep(1);
// 이후에도 reboot_req가 오면 정상화 루틴에서 복구될 수 있음
}
nanosleep(&ts, NULL);
}
return NULL;
}
/* 라우팅 스레드: 에러를 패킷처럼 전파 */
void *routing_worker(void *arg) {
(void)arg;
struct timespec ts = { .tv_sec = 0, .tv_nsec = 350 * 1000 * 1000 }; // 350ms
for (;;) {
if (atomic_load(&state.reboot_req)) {
printf("[router] reboot requested -> stopping routing\n");
break;
}
// 읽기 전용 접근(뮤텍스 없이)로 토폴로지 불안정성 표현
int observed_epoch = state.epoch;
int c = atomic_load(&state.corrupted);
if (c) {
printf("[router] observed corrupted packet @ epoch=%d -> trying alternate route\n", observed_epoch);
} else {
printf("[router] stable route @ epoch=%d\n", observed_epoch);
}
nanosleep(&ts, NULL);
}
return NULL;
}
/* SIGUSR1 handler: reboot 요청 (재부팅 시뮬레이션) */
void sigusr1_handler(int signo) {
(void)signo;
printf("\n[SIGUSR1] reboot requested by external agent\n");
atomic_store(&state.reboot_req, 1);
}
/* 재부팅 루틴: 스테이트 초기화 및 corrupted -> 0 으로 복구 시도 */
void perform_reboot_sequence(void) {
printf("[reboot] performing reboot sequence...\n");
// "전원 내려감"처럼 잠깐 대기
sleep(1);
// 상태 초기화
pthread_mutex_lock(&state.lock);
state.epoch = 0;
pthread_mutex_unlock(&state.lock);
atomic_store(&state.corrupted, 0);
atomic_store(&state.reboot_req, 0);
printf("[reboot] state reset: epoch=%d, corrupted=%d\n", state.epoch, atomic_load(&state.corrupted));
}
int main(void) {
srand((unsigned)time(NULL));
// 초기 상태
atomic_init(&state.corrupted, 0);
atomic_init(&state.reboot_req, 0);
state.epoch = 0;
pthread_mutex_init(&state.lock, NULL);
// 시그널 처리 등록
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigusr1_handler;
sigaction(SIGUSR1, &sa, NULL);
printf("BIOS: boot sequence initiated (poetic, threaded edition)\n");
dump_proc_info();
// 스레드들 생성
pthread_t t1, t2, t3, t4;
pthread_create(&t1, NULL, thought_worker, (void*)"stable_memory");
pthread_create(&t2, NULL, thought_worker, (void*)"wild_memory");
pthread_create(&t3, NULL, thought_worker, (void*)"confession");
pthread_create(&t4, NULL, routing_worker, (void*)NULL);
// 메인 루프: 재부팅 요청 감시
for (;;) {
sleep(1);
if (atomic_load(&state.reboot_req)) {
// 다른 스레드들이 종료할 시간을 준다
printf("[main] detected reboot_req, joining threads...\n");
pthread_join(t1, NULL);
pthread_join(t2, NULL);
pthread_join(t3, NULL);
pthread_join(t4, NULL);
perform_reboot_sequence();
// 재시작: 새로운 스레드 생성
pthread_create(&t1, NULL, thought_worker, (void*)"stable_memory");
pthread_create(&t2, NULL, thought_worker, (void*)"wild_memory");
pthread_create(&t3, NULL, thought_worker, (void*)"confession");
pthread_create(&t4, NULL, routing_worker, (void*)NULL);
printf("[main] restart complete. continuing...\n");
}
// 종료 조건: 예를 들어 epoch가 너무 커지면 자동 종료 (시演 목적)
if (state.epoch > 200) {
printf("[main] epoch limit reached -> graceful shutdown\n");
atomic_store(&state.reboot_req, 1);
// allow loop to catch and join threads
}
}
// (사실 도달하지 않음)
pthread_mutex_destroy(&state.lock);
return 0;
}
|
Hit : 328 Date : 2025/10/20 12:50
|
22018, 
1/1101 
