참 놀라운 세상

출처 : http://blog.naver.com/dalmagru?Redirect=Log&logNo=70068719762

wait(), waitpid() : 부모 프로세스가 자식 프로세스가 종료했음을 확인하는 함수.

waitpid() : 인자로 프로세스ID를 받음으로써 특정 자식 프로세스의 종료를 기다릴수 있다.

함수원형

※ 자식 프로세스의 상태를 확인하는 매크로들

※ waitpid()에서 사용하는 pid인자값의 의미

※ waitpid()에서 사용하는 option인자

※ 좀비 프로세스 (zombie process) : 자식 프로세스가 종료되었지만, 부모 프로세스가 아직 그 종료를 확인하지 않는 프로세스

※ 고아 프로세스 : 자식보다 먼저 부모프로세스가 죽었을 경우의 자식 프로세스.

이번엔 AIX... Thread Dump 분석 방법이다.

최근에 발견한 최고의 포스팅.

http://blog.naver.com/bumsukoh/110114573021

안녕하세요. 이번에는 AIX에서 제공하는 Thread 모니터링 관련 툴을 소개하겠습니다.

AIX에서 가장 유용하게 사용할 수 있는 프로세스와 Thread 모니터링 툴로는 ps 명령어입니다.

"왠 ps 명령어 !" 라고 하실 수 있을텐데요.

사실 ps 명령어는 생각보다 굉장히 많은 정보를 제공하고 있습니다. man page를 보시면 더욱 실남나게 느기실텐데요.

그래도 ps 하면 가장 많이 사용하는 명령어가 "ps -ef" 정도겠죠.

AIX에서는 ps 명령어를 통해 Thread 레벨의 정보를 확인할 수 있는 기능을 제공합니다.

Solaris의 prstat이나 HP-UX의 glance처럼 막강하지는 않지만 나름대로 프로세스의 Thread레벨에 대한 정보를 확인하는데는 유용하게 사용하실 수 있습니다.

ps를 통한 Thread 레벨 모니터링 방법은 다음과 같습니다.

# ps -mp [프로세스 IDs] -o THREAD

ps 명령어는 다들 잘 아실테니 옵션부분만 설명하도록 하겠습니다.

- "m" 은 프로세스 뿐만 아니라 Kernel Thread에 대한 리스트를 출력합니다.

"-o" 옵션과 같이 사용하면 다양한 정보를 출력할 수 있습니다.

- "p" 는 프로세스 ID를 설정합니다. ","를 사용하여 여러개의 프로세스 ID를 지정할 수 있습니다.

- "o" 는 Format 지정을 지정합니다. Thread는 "THREAD"로 지정합니다.

다음은 ps -mp 명령어의 출력 결과 예입니다.

위와 같이 프로세스의 전체 정보와 그 밑으로 Thread 별(TID)로 정보가 출력됩니다.

그외 WCHAN, F, TT, BND, COMMA 정보가 있습니다.

자세한 사항은 ps man page나 메뉴얼을 참조하시기 바랍니다.

명령어 결과에서 Thread 상태 항목인 "ST" 부분과 CPU 사용율 항목인 "CP" 부분, 그리고 Thread의 Suspend 횟수 항목인 "SC" 부분을 주의깊게 볼 필요가 있습니다. 그 이유는 성능에 관련된 항목들이기 때문입니다.

위의 항목 중 Thread 상태 항목인 "ST" 부분에는 다음과 같은 상태 코드가 있습니다.

- "O" 는 Nonexistent 상태입니다.

- "R" 은 Running 상태입니다.

- "S" 는 Sleeping 상태입니다.

- "W" 는 Swapped 상태입니다.

- "Z" 는 Canceled 상태입니다.

- "T" 는 Stopped 상태입니다.

Java 프로세스의 경우 대부분이 "R" 또는 "S" 상태입니다.

TID(Thread ID)는 Java Thread dump 분석 시 Java Thread와 매핑하기 위한 key가 됩니다.

이 부분은 차후에 Thread dump 분석 시 설명드리도록 하겠습니다.

그 다음으로는 Solaris와 HP-UX에서 살펴보았던 pstack과 유사한 procstack 명령어입니다.

procstack 은 Solaris와 HP-UX에서 프로세스의 Native Stack을 확인할 수 있듯이 AIX에서 프로세스의 Native Stack을 확인하기 위한 명령어 입니다.

Solaris와 HP-UX에서는 p로 시작하는 프로세스 명령어 대신 AIX에서는 proc로 시작하는 프로세스 명령어가 있습니다. 두 종류가 거의 비슷한 기능을 제공합니다.

자세한 사항은 다음 포스트를 참고하시면 됩니다. (http://blog.naver.com/bumsukoh/110098535739)

명령어 사용법은 다음과 같습니다.

# procstack [프로세스 ID]

출력 결과는 다음과 같습니다.

위와 같이 JVM을 구현한 Native Stack 입니다. Java 1.6(64bit) 버전의 Jeus 서버에 대한 Thread Native Stack 입니다.

각 Thread 별로 tid와 pthread id 에 대한 내용이 출력되며, 여기서의 tid는 위에서 "ps -mp"의 TID와 동일한 값을 나타냅니다.

"ps -mp"의 모니터링 결과 CPU 점유가 높은 Thread에 대해 procstack으로 Native Stack 확인이 가능하게 됩니다. 물론 Java 프로세스의 경우 procstack으로 Java Stack 확인이 불가능하지만 그런데로 도움은 됩니다. 그 이후에 필요하다면 Thread dump(javacore 파일)을 생성하여 Java Stack을 확인할 수 있습니다.

위의 Native Stack은 모두 Java의 SocketInputStream의 socketread() 부분에서 대기중(상태"SLEEP")이며, 최종 Native Stack은 poll() 함수인 것을 알 수 있습니다.

poll()함수는 Thread를 즉시 "SLEEP"시키고 해당 STREAM(파일 FD)에서 Data input event가 감지되면 Thread를 wake-up시켜 데이터를 처리할 수 있도록하는 기능을 하는 함수입니다.

즉, Java의 socket read는 내부적으로 poll() 함수로 구현되었다는것을 알 수 있는 부분입니다.

그 외에 프로세스에 대한 degugging을 위한 dbx나 프로파일 툴인 tprof등을 사용할 수 있습니다.

프로파일 툴인 tprof는 java 기반(java stack 제공)의 프로파일을 할 수 있어 전문적인 프로파일링 툴이 없을 경우 유용하게 사용할 수 있습니다. (tprof 참고 : http://blog.naver.com/bumsukoh/110104594318)

이것으로 AIX에서 유용하게 사용할 수 있는 Thread 관련 명령어에 대해 알아 보았습니다.

다음 포스트에서는 본격적으로 Thread dump에 대한 내용을 설명드리도록 하겠습니다.

어제 엄청난 호우로 많은 지역이 피해를 입은 것 같습니다. 저도 어제 비와 천둥소리로 잠을 설칠 정도 였습니다. 모두들 호우에 피해를 입지 않도록 각별히 신경 쓰셔야 할 것같습니다.

그럼 이만.. 다음에 뵙겠습니다.

너무 좋은 글들... 최근 dump 분석 때문에 골머리 썩고 있었는데 완전 딱 맞는 자료를 발견했다...

http://blog.naver.com/bumsukoh/110114008655

이번 포스트에서는 Thread dump를 분석하기 전에 Thread들에 대한 정보를 확인하기 위한 유용한 OS 툴들에 대한 내용을 다루어 보겠습니다.

각 OS별로 프로세스 및 Thread 레벨로 상태를 확인하기 위한 명령어들을 제공합니다. 멀티 Thread 기반으로 운영체제들이 변해가면서 제공하는 기능들이 생겨나게 되었습니다.

여기서 설명드리는 OS 툴들은 모두 프로세스에 대한 Native Stack 정보를 출력하는 것입니다.

물론 java stack을 볼 수 없지만 문제가 발생한 Thread에 대한 Native Stack 및 Thread ID를 확인할 수 있습니다. 일부 Java Thread dump에서는 Native Thread ID를 통해 해당 Thread를 찾기도 합니다.

첫번째로 Solaris에서 제공하는 명령어에 대해 알아 보겠습니다.

Solaris에서 가장 유용하게 사용할 수 있는 프로세스와 Thread 모니터링 툴로는 prstat 이 있습니다.

prstat은 생각보다 굉장히 강력한 기능을 가지고 있습니다. 프로세스와 Thread의 CPU 자원 사용율 및 메모리 사용율을 알 수 있지만, CPU 사용율에 대한 microstat 정보를 확인 할 수 있어 굉장히 유용합니다.

저의 경우 이 prstat의 microstat정보를 유용하게 활용하여 시스템의 CPU 자원 사용의 문제점을 확인하고 디버깅한 경험이 있습니다.

prstat 명령어 사용법은 다음과 같습니다.

# prstat -L -m -p [프로세스 ID] [refresh interval]

옵션은 다음과 같습니다.

- "-L" 은 Thread 레벨의 정보를 출력합니다.

- "-m" 은 microstat 정보를 출력합니다.

- "-p" 은 모니터링할 프로세스 ID입니다.

- "refresh interval" 은 모니터링 정보 갱신 주기입니다.

다음은 prstat 출력 결과 예입니다.

==============================================================================================

PID USERNAME USR SYS TRP TFL DFL LCK SLP LAT VCX ICX SCL SIG PROCESS/LWPID

----------------------------------------------------------------------------------------
24565 mspbpp 0.8 0.1 0.0 0.0 0.0 0.0 99 0.2 198 1 198 0 java/14
24565 mspbpp 0.8 0.1 0.0 0.0 0.0 0.0 99 0.2 198 1 198 0 java/19
24565 mspbpp 0.4 0.1 0.0 0.0 0.0 0.0 99 0.2 198 0 198 0 java/15
24565 mspbpp 0.4 0.1 0.0 0.0 0.0 0.0 99 0.2 198 0 198 0 java/21
24565 mspbpp 0.4 0.1 0.0 0.0 0.0 0.0 99 0.2 198 0 198 0 java/24
24565 mspbpp 0.1 0.0 0.0 0.0 0.0 100 0.0 0.0 2 0 3 0 java/2
24565 mspbpp 0.0 0.0 0.0 0.0 0.0 0.0 100 0.0 39 0 39 0 java/8
24565 mspbpp 0.0 0.0 0.0 0.0 0.0 0.0 100 0.0 2 0 4 0 java/9
24565 mspbpp 0.0 0.0 0.0 0.0 0.0 0.0 100 0.0 0 0 0 0 java/13
24565 mspbpp 0.0 0.0 0.0 0.0 0.0 0.0 100 0.0 0 0 0 0 java/12
24565 mspbpp 0.0 0.0 0.0 0.0 0.0 0.0 100 0.0 0 0 0 0 java/11
24565 mspbpp 0.0 0.0 0.0 0.0 0.0 0.0 100 0.0 0 0 0 0 java/10
24565 mspbpp 0.0 0.0 0.0 0.0 0.0 100 0.0 0.0 0 0 0 0 java/7
24565 mspbpp 0.0 0.0 0.0 0.0 0.0 100 0.0 0.0 0 0 0 0 java/6
24565 mspbpp 0.0 0.0 0.0 0.0 0.0 100 0.0 0.0 0 0 0 0 java/5
Total: 1 processes, 26 lwps, load averages: 0.15, 0.15, 0.14

==============================================================================================

위와 같이 프로세스의 Thread별(LWPID)로 CPU 사용에 대한 상세 정보가 출력됩니다.

다음은 prstat의 수행 결과 항목입니다. (여기서는 CPU에 대한 항목 만 설명합니다.)

이외 TRP, TFL, DFL, VCX, ICX, SCL, SIG 정보가 있습니다.

위의 결과 내용을 추출하여 분석한 결과 그래프(예시)를 살펴 보도록 하겠습니다.

이 그래프는 동일한 어플리케이션에 대해 사용자 수를 높이며 CPU 자원에 대한 사용 추이입니다.

눈여겨 볼 부분은 사용자가 많아 질 수록 SLP와 LCK 부분이 낮아 지며 LAT 부분이 높아 지는 것을 알 수 있습니다. 즉 사용자 량이 많아 처리량이 많아 질수록 초기에 LCK인 user locks (Java에서 object block이겠죠)과 SLP인 sleep (이 sleep도 대기상태입니다)이 높았다가 점점 낮아 집니다. 이는 Thread들이 일을 쉬지않고 열심히 더 하고 있다는 말이겠죠. 그러다 보니 LAT (CPU 할당 대기)가 점점 높아 지게 되는 것입니다.

여기에서 해당 시스템의 총 사용가능한 사용자에 대한 수치를 알 수 있습니다. 사실 이 작업을 할때는 패키지 제품에서 CPU 과부하가 있다는 것을 보여주기 위해 한것입니다. 결론적으로는 패키지의 CPU 과부하 버그를 조치한 경우입니다.

이렇게 prstat은 유용하게 사용할 수 있는 Solaris의 툴입니다.

그 다음으로는 pstack 명령어입니다.

pstack 명령어는 Solaris에서 프로세스의 Native Stack을 확인 할 수 있는 명령어입니다.(HP-UX에서도 사용합니다.)

이 pstack은 Native Stack (C 코드)만 확인 할 수 있습니다. java stack 에 대한 내용을 확인이 불가능하죠. 아예 나오지 않습니다. (Java 버전 1.5 이상에서는 pstack하고 유사한 jstack이라는 명령어가 제공됩니다. java stack을 Thread dump 없이 볼 수 있답니다.)

이러한 pstack은 JVM 내부의 흐름을 파악하기 위한 방법으로 유용하며, JVM의 Bug 같은 경우를 확인할 때 사용되기도 합니다.(사용되는 빈도는 극히 드물지만요..)

명령어 사용법은 다음과 같습니다.

# pstack [프로세스 ID]

출력 결과는 다음과 같습니다.

=============================================================================================

----------------- lwp# 25 / thread# 25 --------------------
ff2cc7f4 lwp_cond_wait (189b848, 189b830, 0, 0)
feb54b78 __1cCosNPlatformEventEpark6M_v_ (189b830, 45754, fed35879, 7c400, 189b800, fee069ec) + 108
fe5df09c __1cNObjectMonitorGEnterI6MpnGThread__v_ (323df0, 230c00, 323e00, fedb2000, 323e00, 1) + 1cc
fe53879c __1cNObjectMonitorFenter6MpnGThread__v_ (323df0, 230c00, 230c00, 2, 18a4678, 230e78) + 358
fec03c60 __1cSObjectSynchronizerKfast_enter6FnGHandle_pnJBasicLock_bpnGThread__v_ (ddbff834, ddbff908, 1, 230c00, 34800, d6a244) + a4
febad568 __1cNSharedRuntimebAcomplete_monitor_locking_C6FpnHoopDesc_pnJBasicLock_pnKJavaThread__v_ (ec450a70, ddbff908, 230c00, fede68e1, 6, fedb2000) + dc
fc055754 * weblogic/socket/SocketMuxer.readReadySocketOnce(Lweblogic/socket/MuxableSocket;Lweblogic/socket/SocketInfo;)Z+337 (line 1954)
fc63b53c * *weblogic/socket/DevPollSocketMuxer.processSockets()V [compiled] +12 (line 184)
fc005868 * weblogic/socket/SocketReaderRequest.run()V+3 (line 58)
fc005868 * weblogic/socket/SocketReaderRequest.execute(Lweblogic/kernel/ExecuteThread;)V+1 (line 84)
fc005d88 * weblogic/kernel/ExecuteThread.execute(Lweblogic/kernel/ExecuteRequest;)V+19 (line 288)
fc005868 * weblogic/kernel/ExecuteThread.run()V+32 (line 224)
fc00021c * StubRoutines (1)
fe561bdc __1cJJavaCallsLcall_helper6FpnJJavaValue_pnMmethodHandle_pnRJavaCallArguments_pnGThread__v_ (fc0001c0, 230c00, 1, d6a230, e11c6fd8, ddbffe78) + 208
fe90aebc __1cJJavaCallsMcall_virtual6FpnJJavaValue_nLKlassHandle_nMsymbolHandle_4pnRJavaCallArguments_pnGThread__v_ (ddbffe70, d6a234, fee07100, d6a240, ddbffda0, 230c00) + ec
fe5f0adc __1cJJavaCallsMcall_virtual6FpnJJavaValue_nGHandle_nLKlassHandle_nMsymbolHandle_5pnGThread__v_ (d6a234, ddbffe6c, ddbffe68, ddbffe64, ddbffe60, fee07100) + 6c
fe603350 __1cMthread_entry6FpnKJavaThread_pnGThread__v_ (dfc33688, 230c00, 54c00, fee07434, fee07100, fee06dd4) + 110
fec2318c __1cKJavaThreadRthread_main_inner6M_v_ (230c00, 16, fedee064, 19, fedb2000, 0) + 48
feb4ccbc java_start (230c00, 234e, fedb2000, fed33c51, 18a4678, fee02a2c) + 22c
ff2c8a20 _lwp_start (0, 0, 0, 0, 0, 0)

=============================================================================================

위와 같이 JVM을 구현한 Native Stack 입니다. Java 1.6 버전상의 Weblogic 10g에 대한 Thread Native Stack입니다.

lwp# 25 / thread# 25 는 Thread의 ID입니다. lwp는 Light Weight Process라 하여 경량의 프로세스라 하여 Thread에 대한 통칭입니다.

이 Thread ID는 이후에 설명드릴 Thread dump에서 thread와 매핑할 수 있는 key가 됩니다.

위의 Thread Stack에서는 Weblogic Executor Thread에서 사용자 요청을 받기 위해 대기중인 것을 알 수있습니다. 그래서 stack의 최종 frame은 "lwp_cond_wait (189b848, 189b830, 0, 0)" 입니다.

그 외에 프로세스 debug를 위한 dbx 나 Solaris의 막강 프로파일 툴인 Dtrace등을 활용할 수 있으나, 굉장히 advanced한 내용으로 많은 지식을 필요로 합니다.

대부분은 위의 내용정도만 아셔도 트러블슈팅하는데 많은 도움이 됩니다.

다음 포스트에서는 "OS 툴을 잘 활용하라 !" HP-UX 에 대해 설명드리도록 하겠습니다.

장마가 끝나니 날씨가 장난이 아니네요. 다시 장마시즌이 점점 그리워지는건 왜일까요 ^^

몸 건강들 하시고 다음 포스트에서 뵙겠습니다.

그럼 이만

살펴보다가 너무 좋은 자료가 있어서 퍼왔다..

출처 : http://blog.naver.com/bumsukoh/110114572973

이전 포스트에 이어 프로세스 Thread 정보를 확인하기 위한 OS 명령어 활용법 그 두번째로 HP-UX에서 제공하는 명령어에 대해 알아 보도록 하겠습니다.

HP-UX에서는 glance로 프로세스에 대한 모든 것을 볼 수 있습니다.

glance 툴은 굉장히 많은 유용한 정보를 제공합니다. 우선 시스템에 대한 전반적인 상태 정보, 프로세스 정보, 네트웍, DISK, 메모리등등.. HP-UX 시스템에 대한 거의 모든 것을 모니터링 할 수 있는 툴이라 할 수 있습니다.

glance에서 java 프로세스와 관련하여 보아야할 주요항목이 프로세스와 프로세스의 Thread, 프로세스 메모리 정보들입니다.

Solaris prstat의 microstat 정보만큼은 아니지만 THREAD에 대한 각종 CPU 사용 정보(System, User, Cswitch, Interrupt, Nice, Nnice, Normal등)를 제공합니다.

이러한 glance는 text 모드와 gui 모드, 그리고 advisor 모드를 제공합니다.

터미널에서 바로 사용할 수 있는 text 모드가 가장 많이 사용됩니다. gui 모드는 X-Window 환경에서 사용하며 여러가지 정보를 각각의 창에서 볼 수 있다는 장점이 있습니다. advisor 모드는 필요한 정보를 특정 시간동안 일정한 간격으로 정보를 남길수 있습니다. advisor 모드는 "HP-UX Glance advisor를 통한 CPU 자원 모니터링 방법" (http://blog.naver.com/bumsukoh/110107086979) 포스트를 참조하시면 될 것 같습니다.

glance 명령어 사용법은 다음과 같습니다.

# glance -j [갱신간격(초)]

저는 개인적으로 "-j" 옵션을 선호합니다. 갱신 간격이 기본이 5초여서 신속한 정보를 보기가 힘든점이 있어 저는 "glance -j 1" 를 통해 1초 마다 갱신하도록 하여 모니터링합니다.

그럼 glance의 프로세스 정보와 Thread 정보를 확인하는 방법에 대해 설명하겠습니다.

=========================================================================================

다음은 glance를 수행 시 첫화면입니다.

상단에 전체적인 시스템 사용율 정보(CPU, Memory, Disk, Network등)가 나옵니다.

그리고 그 아래에 각 프로세스들에 대한 리스트와 간략한 CPU. Memory, Block 정보들이 나오게됩니다(다른 프로세스명과 User ID는 일부러 삭제했습니다.). 여기서는 java 프로세스(pid 9852)에 대한 모니터링을 설명하도록 하겠습니다.

자 그럼 해당 프로세스에 대한 상세 모니터링을 위해 "S" key를 누르고 프로세스 ID를 입력합니다.

그러면 위와 같이 해당 프로세스에 대한 상세정보가 출력됩니다.

보시면 아시겠지만 프로세스에 대한 다양한 정보들이 쭉 출력됩니다. 이러한 정보 중에서 다양한 CPU사용율정보(User, System, Interrupt 등), Memory 사용율 정보(RSS/VSS, Fault 등), Wait Reason 등의 정보를 눈여겨 보시면 좋을것 같습니다. 우선은 수치가 높은 부분은 확인을 해 볼 필요가 있겠죠.

그럼 여기서 각 Thread에 대한 정보를 확인 하기 위해 "G" key를 누릅니다.

위와 같이 각 Thread에 대한 리스트와 함께 CPU, I/O, Priority, Block 정보를 볼 수가 있습니다.

CPU의 경우 현재 사용율과 누적 사용율을 보실 수가 있습니다. 아무래도 누적 사용율이 높으면 일을 많이 하는 Thread라고 판단할 수 있습니다. 그럼 해당 Thread가 무엇인지 확인할 필요가 있습니다. 이렇때 Thread dump를 통해 TID와 매핑하여 확인할 수 있습니다.

위의 그림에서는 6949836 TID가 현재 CPU 사용을 많이 하고 있으며, CPU Time 누적치도 높게 보여집니다. 참고로 CPU Util과 CPU Time의 의미는 다음과 같습니다.

- CPU Util은 해당 모니터링 시간(glance interval이 3초라면 3초동안)동안 해당 Thread가 사용한 전체 CPU 용량(100 * CORE수의 %)에 대한 비율입니다.

- CPU Time은 해당 Thread가 실제로 CPU를 점유한 시간입니다. 보통 CPU의 Scheduling 시간(보통 1 tick이라함)이 10ms이므로 Thread가 한번에 점유할 수 있는 최대 시간은 10ms라고 볼 수 있습니다. 우선순위가 높은 Thread의 경우 CPU 점유 시간이 높을 수 밖에 없겠죠.

더욱 상세한 Thread 정보를 보기 위해서는 "I" key를 누르고 TID를 입력합니다.

위와 같이 해당 TID의 Thread에 대한 상세 정보가 출력됩니다. 프로세스의 상세정보 부분과 거의 유사한 정보들이 출력됩니다.

이렇게 glance를 통해 프로세스에 대한 전반적인 모니터링 방법에 대해 알아 보았습니다.

많은 분들이 glance 라는 툴은 잘아시는데 사용법, 특히 화면 key에 대한 부분을 잘 모르시더라고요.

저도 이러한 key를 모두 알고 있지는 않습니다. 대신 key help 화면을 위한 key는 꼭 기억하고 있습니다.^^ 화면에서 "h" key를 누르게 되면 다음과

같은 help 화면을 보실 수 있습니다.

help key만 알고있으며 필요시 key를 확인하며 사용해도 아무 지장이 없습니다.

추가적으로 프로세스에 대한 Memory 정보와 Open File정보, System call 정보에 대한 화면을 보여드리도록 하겠습니다.

- Memory 정보

프로세스에 할당된 메모리 block들에 대한 메모리 Type, 참조계수, RSS, VSS, 할당 File명등에 대한 정보를 확인하실 수 있으며, 아래에는 프로세스에 대한 유형별(Text, Data, Stack, Shared, Other) 전체적인 사용량이 출력됩니다.

- Open File 정보

프로세스가 Open한 FD(File Descriptor)에 대한 정보가 출력됩니다. 실제 File의 경로와 파일명이 잘 출력되지 않지만 Volumne과 inode정보가 있어 파일을 찾는(find -inum 명령 사용)데는 문제가 없습니다.

- System call 정보

프로세스가 수행시킨 System call 함수에 대한 항목과 그에 대한 정보들입니다.

위에서는 횟수로는 gettimeofday() 함수가 가장 많이 호출되었으며, Elapsed Time은 ksleep() 함수인것을 알 수 있습니다.

해당 프로세스가 시간과 관련된 내용을 많이 처리하는 프로세스인 것을 알 수 있으며, 이 부분이 염려할 수준은 아닌것으로 보여집니다. ksleep()은 프로세스가 SLEEP으로 빠지게 되면 호출되는 함수로 CPU JOB만 수행하는 프로세스는 아니며, I/O등의 BLOCK(임의적일수도 있음)으로 인해 SLEEP으로 빠지는 경우가 있는 것으로 보여집니다.

=========================================================================================

위와 같이 glance를 사용하면 프로세스에 대해 OS가 제공하는 거의 모든 정보를 모니터링 가능합니다.

참고로 glance는 HP-UX의 kernel trace 정보를 활용하여 보여줌으로 굉장히 막강한 기능을 제공합니다.

kernel trace를 위해 caliper나 ktrace등으로 별도로 하지 않아도 어느 정도의 정보는 제공하게 되며 이러한 정보는 시스템을 튜닝 및 trace하는데 상당한 도움이 되는 것이 사실입니다.

Solaris(DTrace)나 AIX(trace, curt등) 을 사용해 보셨다면 glance가 제공하는 실시간적인 상태 정보는 거의 환상이라고 할 수 있겠죠.

그 다음으로는 pstack 명령어입니다.

이 부분은 Solaris의 pstack과 동일하기 때문에 별도로 설명은 드리지 않겠습니다.

Solaris의 ptack 부분 (http://blog.naver.com/bumsukoh/110114008655)을 참고하시면 되겠습니다.

단, pstack은 HP Itanium 에서 사용가능한 명령어입니다.

그외 pfiles, pmap등과 같은 프로세스 관련된 유용한 명령어들이 있습니다만, 여기서는 Java 프로세스와 Thread에 대한 내용에 초점이 두었기에 다루지 않도록 하겠습니다.

(다음 기회에 HP-UX의 프로세스 관련 명령어를 통한 모니터링 방법에 대해 설명드리겠습니다.)

다음은 gdb인데요. 굳이 gdb까지 사용하여 뭔가 트러블슈팅하는 경우는 그렇게 많지 않을 것 같은데요.

알고 있으면 상당히 유용한건 사실입니다. (써먹을 기회가 별로 없어서 그렇지만요 ㅠ.ㅠ!)

자, 그럼 gdb를 어디에 써먹을 것인가? gdb는 Unix 프로세스를 debugging하기 위한 툴입니다.

이 툴은 보통 C 언어의 프로그램을 디버깅하는데 사용됩니다.(물론 C++, Fortran, Ada등도 가능합니다.)

Java 기반의 시스템과 프로그램이 많아지면서 HP-UX에서는 gdb에서 Java에 대한 분석도 가능하도록 하기 위한 기능을 제공하게 됩니다.

Java Unwind LIbrary라고 하는것인데.. 자세한 사항은 "HP-0UX 에서 gdb를 이용해 Java 프로세스 core 분석하기 !!" (http://blog.naver.com/bumsukoh/110112408842) 포스트를 참고하시면 될 것 같습니다.

그 외에 프로세스 프로파일링을 위한 막강 프로파일 툴인 caliper 등을 활용할 수 있으나, 굳이 Java기반에서는 이러한 프로파일링 툴까지 쓸 필요는 없을것 같고, 대신 Java를 위한 프로파일링 툴은 알아둘 필요가 있습니다. 이 부분은 이번 연재의 뒷부분에서 다루도록 하겠습니다.

다음 포스트에서는 "OS 툴을 잘 활용하라 !" AIX 에 대해 설명드리도록 하겠습니다.

그럼 건강하시고 다음 포스트에서 뵙도록 하겠습니다.

Language C - Libxml

libxml2을 설치하면 libxml 폴더에 각종 헤더 파일이 들어있다.

현재 내가 사용하는 header 파일은 아래 두개인데..

물론 더 많이 사용하는 법이 있겠지만 기본적으로 사용하는 법을 알아보자..

libxml/xmlmemory.h

libxml/parser.h

노드 타입은 아래와 같다

참고 할 것.

XML_ELEMENT_NODE= 1,
XML_ATTRIBUTE_NODE= 2,
XML_TEXT_NODE= 3,
XML_CDATA_SECTION_NODE= 4,
XML_ENTITY_REF_NODE= 5,
XML_ENTITY_NODE= 6,
XML_PI_NODE= 7,
XML_COMMENT_NODE= 8,
XML_DOCUMENT_NODE= 9,
XML_DOCUMENT_TYPE_NODE= 10,
XML_DOCUMENT_FRAG_NODE= 11,
XML_NOTATION_NODE= 12,
XML_HTML_DOCUMENT_NODE= 13,
XML_DTD_NODE= 14,
XML_ELEMENT_DECL= 15,
XML_ATTRIBUTE_DECL= 16,
XML_ENTITY_DECL= 17,
XML_NAMESPACE_DECL= 18,
XML_XINCLUDE_START= 19,
XML_XINCLUDE_END= 20

참고 : http://blog.naver.com/kdepirate?Redirect=Log&logNo=50033294493

--------------------------------------------------------------------------------

xmlDocPtr doc; // (1)
xmlNodePtr cur; // (2)
doc = xmlParseFile(docname); // (3)
if(doc == NULL) { // (4)
    fprintf(stderr, "Document not parsed successfully.\n");
    return;
}
cur = xmlDocGetRootElement(doc); // (5)
if(cur == NULL) { // (6)
    fprintf(stderr, "empty document\n");
    xmlFreeDoc(doc);
    return;
}
if(xmlStrcmp(cur->name, (const xmlChar *)"story")) { // (7)
    fprintf(stderr, "document of the wrong type, root node != story");
    xmlFreeDoc(doc);
    return;
}

cur = cur->xmlChildrenNode; // (1)
while(cur != NULL) { // (2)
    if((!xmlStrcmp(cur->name, (const xmlChar *)"storyinfo"))) {
        parseStory(doc, cur);
    }
    cur = cur->next;
}

void parseStory(xmlDocPtr doc, xmlNodePtr cur) {
    xmlChar *key;
    cur = cur->xmlChildrenNode; // (1)
    while(cur != NULL) { // (2)
        if((!xmlStrcmp(cur->name, (const xmlChar *)"keyword"))) {
            key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); // (3)
            printf("keyword: %s\n", key);
            xmlFree(key);
        }
        cur = cur->next;
    }
    return;
}

xmlXPathObjectPtr getnodeset (xmlDocPtr doc, xmlChar *xpath) {
    xmlXPathContextPtr context; // (1)
    xmlXPathObjectPtr result;
    context = xmlXPathNewContext(doc); // (2)
    result = xmlXPathEvalExpression(xpath, context); // (3)
    if(xmlXPathNodeSetIsEmpty(result->nodesetval)) { // (4)
        printf("No result\n");
        return NULL;
    }
    xmlXPathFreeContext(context);
    return result;
}

for(i = 0; i < nodeset->nodeNr; i++) { // (1)
    keyword = xmlNodeListGetString(doc, nodeset->nodeTab[i]->xmlChildrenNode, 1); // (2)
    printf("keyword: %s\n", keyword);
    xmlFree(keyword);
}

void parseStory(mxlDocPtr doc, xmlNodePtr cur, char *keyword) {
    xmlNewTextChild(cur, NULL, "keyword", keyword); // (1)
    return;
}

xmlSaveFormatFile(docname, doc, 1);

xmlAttrPtr newattr;

xmlNodePtr newnode;

newnode = xmlNewTextChild(cur, NULL, "reference", NULL); // (1)
newattr = xmlNewProp(newnode, "uri", uri); // (2)

void getReference(xmlDocPtr doc, xmlNodePtr cur) {
    xmlChar *uri;
    cur = cur->xmlChildrenNode;
    while(cur != NULL) {
        if((!xmlStrcmp(cur->name, (const xmlChar *)"reference"))) {
            uri = xmlGetProp(cur, "uri"); // (1)
            printf("uri: %s\n", uri);
            xmlFree(uri);
        }
        cur = cur->next;
    }
    return;
}

xmlCharEncodingHandlerPtr handler; // (1)
size = (int)strlen(in) + 1; // (2)
out_size = size * 2 - 1;
out = malloc((size_t)out_size);
...
handler = xmlFindCharEncodingHandler(encoding); // (3)
...
handler->input(out, &out_size, in, &temp); // (4)
...
xmlSaveFormatFileEnc("-", doc, encoding, 1); // (5)

<?xml version="1.0"?>
<story>
    <storyinfo>
        <author>John Fleck</author>
        <datewritten>June 2, 2002</datewritten>
        <keyword>example keyword</keyword>
    </storyinfo>
    <body>
        <headline>This is the headline</headline>
        <para>This is the body text.</para>
    </body>
</story>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>

void parseStory(xmlDocPtr doc, xmlNodePtr cur) {
    xmlChar *key;
    cur = cur->xmlChildrenNode;
    while(cur != NULL) {
        if((!xmlStrcmp(cur->name, (const xmlChar *)"keyword"))) {
            key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
            printf("keyword: %s\n", key);
            xmlFree(key);
        }
        cur = cur->next;
    }
    return;
}

static void parseDoc(char *docname) {
    xmlDocPtr doc;
    xmlNodePtr cur;
    doc = xmlParseFile(docname);
    if(doc == NULL) {
        fprintf(stderr, "Document not parsed successfully.\n");
        return;
    }
    cur = xmlDocGetRootElement(doc);
    if(cur == NULL) {
        fprintf(stderr, "empty document\n");
        xmlFreeDoc(doc);
        return;
    }
    if(xmlStrcmp(cur->name, (const xmlChar *)"story")) {
        fprintf(stderr, "document of the wrong type, root node != story\n");
        xmlFreeDoc(doc);
        return;
    }
    cur = cur->xmlChildrenNode;
    while(cur != NULL) {
        if((!xmlStrcmp(cur->name, (const xmlChar *)"storyinfo"))) {
            parseStory(doc, cur);
        }
        cur = cur->next;
    }
    xmlFreeDoc(doc);
    return;
}

int main(int argc, char **argv) {
    char *docname;
    if(argc <= 1) {
        printf("Usage: %s docname\n", argv[0]);
        return(0);
    }
    docname = argv[1];
    parseDoc(docname);
    return(1);
}

#include <libxml/parser.h>
#include <libxml/xpath.h>

xmlDocPtr getdoc (char *docname) {
    xmlDocPtr doc;
    doc = xmlParseFile(docname);
    if (doc == NULL ) {
         fprintf(stderr,"Document not parsed successfully. \n");
        return NULL;
    }
    return doc;
}

xmlXPathObjectPtr getnodeset (xmlDocPtr doc, xmlChar *xpath) {
    xmlXPathContextPtr context;
    xmlXPathObjectPtr result;
    context = xmlXPathNewContext(doc);
    result = xmlXPathEvalExpression(xpath, context);
    if(xmlXPathNodeSetIsEmpty(result->nodesetval)) {
        printf("No result\n");
        return NULL;
    }
    xmlXPathFreeContext(context);
    return result;
}

int main(int argc, char **argv) {
    char *docname;
    xmlDocPtr doc;
    xmlChar *xpath = (xmlChar *)"//keyword";
    xmlNodeSetPtr nodeset;
    xmlXPathObjectPtr result;
    int i;
    xmlChar *keyword;
    if (argc <= 1) {
        printf("Usage: %s docname\n", argv[0]);
        return(0);
    }
    docname = argv[1];
    doc = getdoc(docname);
    result = getnodeset (doc, xpath);
    if (result) {
        nodeset = result->nodesetval;
        for (i=0; i < nodeset->nodeNr; i++) {
            keyword = xmlNodeListGetString(doc, nodeset->nodeTab[i]->xmlChildrenNode, 1);
            printf("keyword: %s\n", keyword);
            xmlFree(keyword);
        }
        xmlXPathFreeObject (result);
    }
    xmlFreeDoc(doc);
    xmlCleanupParser();
    return (1);
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>

void parseStory (xmlDocPtr doc, xmlNodePtr cur, char *keyword) {
    xmlNewTextChild (cur, NULL, "keyword", keyword);
    return;
}

xmlDocPtr parseDoc(char *docname, char *keyword) {
    xmlDocPtr doc;
    xmlNodePtr cur;
    doc = xmlParseFile(docname);
    if (doc == NULL ) {
        fprintf(stderr,"Document not parsed successfully. \n");
        return (NULL);
    }
    cur = xmlDocGetRootElement(doc);
    if (cur == NULL) {
        fprintf(stderr,"empty document\n");
        xmlFreeDoc(doc);
        return (NULL);
    }
    if (xmlStrcmp(cur->name, (const xmlChar *) "story")) {
        fprintf(stderr,"document of the wrong type, root node != story");
        xmlFreeDoc(doc);
        return (NULL);
    }
    cur = cur->xmlChildrenNode;
    while (cur != NULL) {
        if ((!xmlStrcmp(cur->name, (const xmlChar *)"storyinfo"))) {
            parseStory (doc, cur, keyword);
        }
        cur = cur->next;
    }
    return(doc);
}

int main(int argc, char **argv) {
    char *docname;
    char *keyword;
    xmlDocPtr doc;
    if (argc <= 2) {
        printf("Usage: %s docname, keyword\n", argv[0]);
        return(0);
    }
    docname = argv[1];
    keyword = argv[2];
    doc = parseDoc (docname, keyword);
    if (doc != NULL) {
        xmlSaveFormatFile (docname, doc, 0);
        xmlFreeDoc(doc);
    }
    return (1);
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>

xmlDocPtr parseDoc(char *docname, char *uri) {
    xmlDocPtr doc;
    xmlNodePtr cur;
    xmlNodePtr newnode;
    xmlAttrPtr newattr;
    doc = xmlParseFile(docname);
    if (doc == NULL ) {
        fprintf(stderr,"Document not parsed successfully. \n");
        return (NULL);
    }
    cur = xmlDocGetRootElement(doc);
    if (cur == NULL) {
        fprintf(stderr,"empty document\n");
        xmlFreeDoc(doc);
        return (NULL);
    }
    if (xmlStrcmp(cur->name, (const xmlChar *) "story")) {
        fprintf(stderr,"document of the wrong type, root node != story");
        xmlFreeDoc(doc);
        return (NULL);
    }
    newnode = xmlNewTextChild (cur, NULL, "reference", NULL);
    newattr = xmlNewProp (newnode, "uri", uri);
    return(doc);
}

int main(int argc, char **argv) {
    char *docname;
    char *uri;
    xmlDocPtr doc;
    if (argc <= 2) {
        printf("Usage: %s docname, uri\n", argv[0]);
        return(0);
    }
    docname = argv[1];
    uri = argv[2];
    doc = parseDoc (docname, uri);
    if (doc != NULL) {
        xmlSaveFormatFile (docname, doc, 1);
        xmlFreeDoc(doc);
    }
    return (1);
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>

xmlDocPtr parseDoc(char *docname, char *uri) {
    xmlDocPtr doc;
    xmlNodePtr cur;
    xmlNodePtr newnode;
    xmlAttrPtr newattr;
    doc = xmlParseFile(docname);
    if (doc == NULL ) {
        fprintf(stderr,"Document not parsed successfully. \n");
        return (NULL);
    }
    cur = xmlDocGetRootElement(doc);
    if (cur == NULL) {
        fprintf(stderr,"empty document\n");
        xmlFreeDoc(doc);
        return (NULL);
    }
    if (xmlStrcmp(cur->name, (const xmlChar *) "story")) {
        fprintf(stderr,"document of the wrong type, root node != story");
        xmlFreeDoc(doc);
        return (NULL);
    }
    newnode = xmlNewTextChild (cur, NULL, "reference", NULL);
    newattr = xmlNewProp (newnode, "uri", uri);
    return(doc);
}

int main(int argc, char **argv) {
    char *docname;
    char *uri;
    xmlDocPtr doc;
    if (argc <= 2) {
        printf("Usage: %s docname, uri\n", argv[0]);
        return(0);
    }
    docname = argv[1];
    uri = argv[2];
    doc = parseDoc (docname, uri);
    if (doc != NULL) {
        xmlSaveFormatFile (docname, doc, 1);
        xmlFreeDoc(doc);
    }
    return (1);
}

#include <string.h>
#include <libxml/parser.h>

unsigned char* convert (unsigned char *in, char *encoding) {
    unsigned char *out;
    int ret,size,out_size,temp;
    xmlCharEncodingHandlerPtr handler;
    size = (int)strlen(in)+1;
    out_size = size*2-1;
    out = malloc((size_t)out_size);
    if (out) {
        handler = xmlFindCharEncodingHandler(encoding);
        if (!handler) {
            free(out);
            out = NULL;
        }
    }
    if (out){
        temp=size-1;
        ret = handler->input(out, &out_size, in, &temp);
        if (ret || temp-size+1) {
            if (ret) {
                printf("conversion wasn't successful.\n");
            }
            else {
                printf("conversion wasn't successful. converted\n");
            }
            free(out);
            out = NULL;
        }
        else {
            out = realloc(out,out_size+1);
            out[out_size]=0; /*null terminating out*/
        }
    }
    else {
        printf("no mem\n");
    }
    return (out);
}

int main(int argc, char **argv) {
    unsigned char *content, *out;
    xmlDocPtr doc;
    xmlNodePtr rootnode;
    char *encoding = "ISO-8859-1";
    if (argc <= 1) {
        printf("Usage: %s content\n", argv[0]);
        return(0);
    }
    content = argv[1];
    out = convert(content, encoding);
    doc = xmlNewDoc ("1.0");
    rootnode = xmlNewDocNode(doc, NULL, (const xmlChar*)"root", out);
    xmlDocSetRootElement(doc, rootnode);
    xmlSaveFormatFileEnc("-", doc, encoding, 1);
    return (1);
}

어떤 분이 써놓은 신 문서이다.

정리가 제법 잘 되어 있어서 퍼왔다.

원문 출처

http://optimizer.snu.ac.kr/yanne/

GDB 사용하기

1.   GDB

GDB같은 디버거의 목적은 다른 프로그램 수행 중에 그 프로그램 ‘내부에서’ 무슨 일이 일어나고 있는지 보여주거나 프로그램이 잘못 실행되었을 때 무슨 일이 일어나고 있는지 보여주는 것이다. GDB는C, C++, Modula-2로 짠 프로그램을 디버그 할 수 있다.

쉘에서 gdb로 GDB를 시작하면 quit로 종료명령을 주기전까지는 터미널로부터 명령라인을 읽어 들인다. help명령을 사용하여 gdb내부에서 도움말을 볼 수 있다.

디버깅을 하기 위해서는 –g옵션을 주고 컴파일/링크 해야 한다. 만약 링크가 libg.a를 찾을 수 없다고 하면서 실패하게 되면, /usr/lib/ligb.a를 갖고 있지 않기 때문이다. 그 파일은 특별한 라이브러리로서 디버깅 가능 C라이브러리이다. libc 패키지에 포함되어 있거나 또는 libc 소스 코드를 받아서 컴파일 하면 생긴다. /usr/lib/libc.a를 /usr/lib/libg.a로 링크 시켜도 된다.

l  코어파일 분석하기

코어파일은 충돌할 당시 프로세스의 메모리 이미지를 덤프한 것이다. 코어파일을 gdb와 함께 사용하여 프로그램의 상태를 조사하고 실패 원인을 규명할 수 있다. 어떤 예기치 않은 일이 발생하여 비정상적인 종료가 발생할 때 운영체계는 디스크에 코어 파일을 남긴다.메모리에 관한 문제는 Checker 패키지를 사용하여 예방할 수 있다. 하지만 메모리 fault를 일으키는 경우에는 충돌하면서 파일을 덤프한다. 코어파일은 일반적으로 프로세스를 실행시킨 현재 작업 디렉토리에 생성되지만 프로그램 내에서 작업 디렉토리를 바꾸는 경우도 있다.

보통 리눅스는 부팅시에 코어 파일을 만들지 않도록 세팅되어 있다. 코어 파일 생성을 가능케 하려고 한다면 그것을 다시 가능케 하는 셀의 내장 명령을 사용한다.

만약C쉘 호환 쉘(tcsh)을 쓰고 있다면 다음과 같이 명령을 내린다.

%  limit core unlimited

만약 본쉘류( sh , bash , zsh , pdksh )를 사용하고 있다면,

$  ulimit –c unlimited

와 같은 명령을 내린다.

코어파일을 함께 사용하기 위해선 다음과 같이 한다.

% gdb program core

ulimte -a 를 하면 현재 설정값을 볼 수 있다.

l  실행 중인 프로그램 디버깅하기

gdb는 이미 실행중인 프로그램도 디버깅할 수 있게 해준다. 프로세스 실행을 가로채고 조사한 뒤 다시 원래 상태로 실행하도록 할 수 있다. attach명령을 사용하여 실행중인 프로세서에 gdb를 붙인다. attach 명령을 사용하기 위해서는 프로세스에 해당하는 실행 프로그램에 허가권을 가지고 있어야 한다. 예를 들어 프로세스 ID 254번으로 실행 중인 pgmseq 프로그램이 있다면 다음과 같이 한다.

% gdb pgmseq

% attach 254

다음과 같이 해도 된다.

% gdb pgmseq 254

일단 gdb가 실행 중인 프로세스에 부착되면 프로그램을 일시 중지 시키고 gdb명령을 사용할 수 있도록 제어권을 가져온다. break를 사용하여 중지점을 사용할 수 있고 중지점에 이를 때까지 실행하도록 continue 명령을 사용할 수 있다.

detach명령을 사용하여 gdb를 실행 중인 프로세스에서 떼어 낸다. 필요에 따라 다른 프로세스에 대하여 attach명령을 사용할 수 있다.

2.   gdb시작하기

% gdb                       - gdb를 먼저 실행 후file이라는 명령으로 program을 부른다.

% gdb  program         - 일반적인 방법이다.

% gdb  program  core - 코어파일을 사용할 때 동시에 인자로 준다.

% gdb  program  1234 - 실행중인 프로세스를 디버그 하려면 프로세스 ID를 두 번째 인자로 주면 된다. 이 명령은 gdb를 (‘1234’ 란 이름의 파일이 없다면) 프로세스 1234에 접속시킨다.(gdb는 core파일을 먼저 찾는다.)

실행절차

%  gcc  –g  test.c  –o  test

%  gdb  test

이 명령을 실행하면 다음과 같은 메시지가 나타난다.

3.   많이 사용하는 GDB명령어

4.   gdb 해보기

예제1

% vi test.c

% gcc –g test.c –o test

% test

실행이 되지 않으면 mv test a.out으로 하여a.out을 실행시킨다. 실행을 시키면 원하는 답이 아니다. 그러면 gdb를 해보자.

% gdb a.out

(gdb) list        // list는 소스 내용을 10줄씩 보여준다.

1         #include <stdio.h>

2

3         main()

4         {

5         int i;

6         double j;

7         /*다음은i/2+i의 값을 출력하는 문이다.

8         i가1이면 j는1.5가 되어야 하지만 실제는 그렇지 않다.*/

9         ( i=0; i<5 ; i++){

j=i/2+i;

(gdb) b 9  // break 9 : for 문에 이상이 있다고 판단하여 line 9에 breakpoint를 잡는다.

Breakpoint 1 at 0x80483d6: file test.c, line 9.

(gdb) r               // run : breakpoint까지 실행된다.

Starting program: /home/pllab/chowing/gdb/a.out

Breakpoint 1, main () at test.c:9

9  for( i=0; i<5 ; i++){

(gdb) s                           // step : 한줄 실행시킨다.

j=i/2+i;

(gdb) s

11  printf(“j is %f \n”,j);

(gdb) p j         // print j : j의 값을 본다.

$2 = 0

(gdb) n

j is 0.000000

for( i=0; i<5 ; i++){

(gdb) display i

(gdb) display j

(gdb) n

11  printf(“j is %f \n”,j);

2: j = 1

1: i = 1

// 10 line에서 실행 후 i=1일 때, j=1이므로 10 line에서 잘못된 것을 알 수 있다.

// 10 line을 j = (double) i/2 + i; 로 고친다.

(gdb) quit

예제2

% vi hab.c

// 이 프로그램은 이상은 없다. 스택을 보기 위한 것이다.

// 여러 곳에서 호출되는 함수 안에서 충돌이 일어날 경우를 생각해 보자. 이 때는 함수가 어디로부터 호출되었는지 그리고 어떤 상황에서 충돌이 일어났는지 파악하고자 할 것이다.

backtrace (bt) 명령을 이용하면 충돌이 일어난 시점에서 프로그램의 현재 호출 스택(call stack) 상태를 볼 수 있다. 호출 스택은 현재 함수까지 이르는 호출 목록이다. 함수를 호출할 때마다 보관된 레지스터 값, 함수 전달 인수, 지역 변수 등의 자료를 스택에 push한다. 이렇게 해서 각 함수들은 스택상에 일정 공간을 차지한다. 특정함수에 대하여 스택에서 사용되고 있는 메로리 부분을 스택프레임(frame)이라 부르며 호출 스택은 이러한 스택 프레임을 순서대로 정렬한 목록이다.

% gdb hab

(gdb) b 10      Breakpoint 2 at 0x8048428: file hab.c, line 10.

(gdb) r

Starting program: /home/pllab/chowing/gdb/hab

정수a, b를 입력하시오3 4

breakpoint 2, main () at hab.c:10

10       dab = hab(a,b);

(gdb) bt         // 현재 스택에 main이 있다.

#0  main () at hab.c:10

(gdb) s

hab (x=3, y=4) at hab.c:15

15          return (x + y);

(gdb) bt         // 지금은 스택에 hab이 있다.

#0  hab (x=3, y=4) at hab.c:15

#1  0x8048435 in main () at hab.c:10

(gdb) frame 0 // hab의 상태를 점검하기 위해서 스택 프레임0번으로 이동

#0  hab (x=3, y=4) at hab.c:15

15          return (x + y);

(gdb) up           // hab이 어떻게 호출되었는가를 보기 위하여 상위 스택프레임으로 이동

#1  0x8048435 in main () at hab.c:10

dab = hab(a,b);

(gdb) finish

(gdb) info program     // 프로그램의 실행 상태를 보여 준다.

Using the running image of child Pid 12909.

Program stopped at 0x804843d.

It stopped after being stepped.

(gdb) info locals          // 현재 함수 내에서 모든 지역 변수 이름과 값을 출력한다.

a = 3

b = 4

dab = 7

(gdb) info variables   // 소스파일 순서대로 프로그램 내에 알려져 있는 모든 변수를 출력한다.

(gdb) info address a   // 어떤 변수가 어디에 저장되어 있는지에 대하여 알려 준다.

Symbol “a” is a local variable at frame offset -4.

// a가 스택프레임 꼭대기로부터4바이트 아래에 놓여 있다는 뜻이다.

(gdb) info frame         // 현재 프레임 정보를 보여 준다.

Stack level 0, frame at 0xbffff848:

eip = 0x804843d in main (hab.c:11); saved eip 0x400301eb

source language c.

Arglist at 0xbffff848, args:

Locals at 0xbffff848, Previous frame’s sp is 0x0

Saved registers:

ebp at 0xbffff848, eip at 0xbffff84c

예제3

% vi core.c

% coredebug

Segmentation fault

// core 파일 생성

% gdb coredebug

(gdb) b 7

Breakpoint 1, main () at core.c:7

7           strcpy(bug,”debug”);

(gdb) p bug

$1 = 0x0         // gdb 에서0x0는 null이다. 즉 번지가 없다.

(gdb) s

Program received signal SIGSEGV, Segmentation fault.

0x40075434 in ?? ()    

// strcpy에서 segmentation fault가 발생한 것을 알 수 있다.

// bug에 번지를 할당하면 된다.

% gdb corebug core  // core파일을 이용하면 bug정보가 나온다.

GNU gdb 4.18

Copyright 1998 Free Software Foundation, Inc.

GDB is free software, covered by the GNU General Public License, and you are

welcome to change it and/or distribute copies of it under certain conditions.

Type “show copying” to see the conditions.

There is absolutely no warranty for GDB.  Type “show warranty” for details.

This GDB was configured as “i386-redhat-linux”...

warning: core file may not match specified executable file.

Core was generated by ‘a.out’.

Program terminated with signal 11, 세그멘테이션 오류.

Reading symbols from /lib/libc.so.6...done.

Reading symbols from /lib/ld-linux.so.2...done.

#0  strcpy (dest=0x0, src=0x8048490 “debug”) at ../sysdeps/generic/strcpy.c:38

../sysdeps/generic/strcpy.c: 그런 파일이나 디렉토리가 없음.

gdb는 signal 11 번과 함께 코어 파일이 생성되었음을 알려 준다. 여기서는 허가받지 않은 메모리 공간에 읽기, 쓰기를 시도했기 때문에 커널이 프로세스에게 signal 11을 보냈다.

이 시그널로 인해 프로세스는 종료하면서 코어 파일을 덤프한다.

l  기타 기능

gdb는 매우 많은 기능을 가진 프로그램이다.

Breakpoint

중지점을 조건적으로 설정할 수 있다. 즉 어떤 동작이 참일 때만 작동하도록 할 수 있다.  Ex) break 184 if (stace == 0)

info break를 사용하면 모든 중지점과 감시점 목록을 보여 주고 그 상태도 보여 준다.

disable를 사용하여 작동불능으로 할 수 있고 enable를 사용하여 가능하게 할 수도 있다.

인스트럭션 레벨 디버깅

gdb를 통해 인스트럭션 레벨의 디버깅을 할 수 있으므로 프로그램의 매우 깊은 내부까지 조사할 수 있다.

(gdb) disass play      //play함수에 대한 디스어셈블리.

(gdb) display/ i $pc   //현재의 인스트럭션을 보여준다. $pc는 gdb내부 변수로서 현재 인스트럭션의 위치를 가리키는 프로그램 카운터이다.

참고

GDB에 대한 매뉴얼은

http://kkucc.konkuk.ac.kr/~kipal/html/gdb-man.html에서 볼 수 있다.

(복사본)

http://pl.changwon.ac.kr/~chowing/gdb_man.html

dbx와 core 파일을 분석할때는 다음과 같이 하자.

우선 첫째로 현재 해당 core파일을 생성한 바이너리 부터 확인해보자.

file 다음 core 파일을 입력하면 현재 core 파일의 [비트], [생성한 바이너리명] 을 알 수 있다.

$> file core

core_: AIX core file 64-bit, server

그 다음 core 파일과 dbx를 실행 시켜보자.

실행 방법은 dbx [바이너리경로] [코어파일경로]

dbx가 실행 된 뒤 where 을 치면 차세한 오류 내역을 확인할 수 있다.

$> dbx server core

(dbx) where

.

.

warning: "/lib/libi18n.a(shr_64.o)" has changed since core creation
warning: "/lib/libiconv.a(shr4_64.o)" has changed since core creation
warning: "/usr/mqm/lib64/libmqmcs.a(shr.o)" has changed since core creation
warning: "/usr/mqm/lib64/libmqz.a(libmqz.o)" has changed since core creation
warning: "/lib/libC.a(shr2_64.o)" has changed since core creation
warning: "/lib/libnsl.a(shr_64.o)" has changed since core creation
warning: "/lib/libC.a(ansi_64.o)" has changed since core creation
warning: "/lib/libc.a(shr_64.o)" has changed since core creation

IOT/Abort trap in pthread_kill at 0x900000000aa37d0
0x900000000aa37d0 (pthread_kill+0xb0) e8410028          ld   r2,0x28(r1)
(dbx) q

뭐.. 이런식으로 확인한다.

dbx로 Running Process를 분석할때는 아래와 같다

$> dbx -d<depth> -a <pid>

ex) dbx -d 300 -a 12345

dbx에서 thread 정보를 확인하고자 할때는

(dbx) thread

(dbx) thread info <thread no.>

특정 프로세서의 thread 상황은

(dbx) ps -p <pid> -mo THREAD

file 와 [디렉토리 경로]

list [start] , [end]

또는 바로 수정하려면 edit를 사용하면 된다.

dbx에서 사용가능한 명령어들은 다음과 같다.

 addcmd       alias        assign       attribute    barrier      call       
 case         catch        clear        cleari       condition    corefile   
 coremap      cont         delcmd       delete       detach       disable    
 display(/)   down         dump         edit         enable       fd         
 file         frame        func         goto         gotoi        handler    
 help         ignore       kthread      list         listi        malloc     
 map          move         multproc     mutex        spinlock     next       
 nexti        onceblock    plugin       pluginload   pluginunload print      
 proc         prompt       pthread      quit         registers    rerun      
 resource     return       run          rwlock       screen       search(/?) 
 set          sh           skip         source       status       step       
 stepi        stop         stophwp      stopi        thread       tls        
 tnext        tnexti       trace        tracehwp     tracei       tskip      
 tstep        tstepi       tstop        tstophwp     tstopi       ttrace     
 ttracehwp    ttracei      unalias      unset        up           use        
 whatis       where        whereis      which    

gdb에서는 break <linenumber> 이지만 dbx에서는 stop <linenumber> 인듯하다.

디버깅을 하기 위해서는 –g옵션을 주고 컴파일/링크 해야 한다. 만약 링크가 libg.a를 찾을 수 없다고 하면서 실패하게 되면, /usr/lib/ligb.a를 갖고 있지 않기 때문이다. 그 파일은 특별한 라이브러리로서 디버깅 가능 C라이브러리이다. libc 패키지에 포함되어 있거나 또는 libc 소스 코드를 받아서 컴파일 하면 생긴다. /usr/lib/libc.a를 /usr/lib/libg.a로 링크 시켜도 된다.

또한 AIX에서 ulimit로 코어파일을 생성하도록 설정해줘야 한다.

-c 옵션으로 생성하는 코어파일의 block 크기를 지정할 수 있다. block 크기는 시스템에 따라 다르다

코어 파일 생성을 가능케 하려고 한다면 그것을 다시 가능케 하는 셀의 내장 명령을 사용한다.

만약C쉘 호환 쉘(tcsh)을 쓰고 있다면 다음과 같이 명령을 내린다.

%  limit core unlimited

만약 본쉘류( sh , bash , zsh , pdksh )를 사용하고 있다면,

$  ulimit –c unlimited

와 같은 명령을 내린다.

코어파일을 함께 사용하기 위해선 다음과 같이 한다. (gdb의 경우)

% gdb program core

자세한 메뉴얼은 아래에 써 놓습니다.

출처 : http://alladdin.tistory.com/21

----------------------------------------------

dbx 명령

목적

디버그할 환경을 제공하고 프로그램을 실행합니다.

구문

dbx [ -a ProcessID ] [ -c CommandFile ] [ -d NestingDepth ] [ -I Directory ] [ -E DebugEnvironment ] [ -p oldpath=newpath:...| pathfile ] [ -k ] [ -u ] [ -F ] [ -r ] [ -x ] [ ObjectFile [ CoreFile ] ]

설명

dbx 명령은 C, C++, Pascal 및 FORTRAN 프로그램에 대한 디버그를 제공하여, 사용자가 다음과 같은 작업을 수행할 수 있도록 합니다.

• 오브젝트 및 코어 파일 검사.
• 프로그램 실행을 위한 제어 환경 제공.
• 선택한 문장에 중단점을 설정하거나 한 번에 한 행씩 프로그램 실행.
• 변수를 사용하여 디버그한 후 올바른 형식으로 표시.

ObjectFile 매개변수는 컴파일러가 만들어 내는 오브젝트(실행 가능) 파일입니다. dbx 명령에 필요한 정보를 만들기 위해 프로그램 컴파일 시 -g(기호 테이블 작성) 플래그를 사용합니다.

주: 오브젝트 파일을 컴파일할 경우 cc 명령의 -g 플래그를 사용해야 합니다. -g 플래그를 사용하지 않거나 strip 명령으로 xcoff 파일에서 기호 참조가 제거된 경우, dbx 명령의 사용 범위는 제한됩니다.

-c 플래그를 지정하지 않으면 dbx 명령은 사용자의 $HOME 디렉토리의 .dbxinit 파일을 검사합니다. 그런 다음, 사용자의 현재 디렉토리에서 .dbxinit 파일을 검사합니다. .dbxinit 파일이 현재 디렉토리에 존재하면, 이 파일이 사용자의 $HOME 디렉토리에 있는 .dbxinit 파일을 대체합니다. .dbxinit 파일이 사용자의 $HOME 디렉토리 또는 현재 디렉토리에 존재하면, 디버그 세션이 시작될 때 이 파일의 부속 명령이 실행됩니다. 편집기를 사용하여 .dbxinit 파일을 작성하십시오.

ObjectFile을 지정하지 않으면, dbx는 디버그할 오브젝트 파일 이름을 요청합니다. 디폴트는 a.out입니다. 코어 파일이 현재 디렉토리에 존재하거나 CoreFile 매개변수가 지정되어 있으면, dbx는 프로그램에 이상이 있는 위치를 보고합니다. 코어 이미지에 보유된 변수, 레지스터 및 메모리는 ObjectFile의 실행이 시작될 때까지 검사됩니다. 그 시점에 dbx 디버그 프로그램은 명령을 위한 프롬프트를 리턴합니다.

표현식 처리

dbx 프로그램은 광범위한 표현식을 사용합니다. dbx 디버그 프로그램에 C 및 Pascal 구문의 공통적인 기능의 일부와, 여러 가지 FORTRAN 확장자를 가진 표현식을 지정할 수 있습니다.

디버그 프로그램에서 자주 사용되는 연산자는 다음과 같습니다.

디버그 프로그램에서 사용되는 연산자 유형은 다음과 같습니다.

논리적 표현식과 비교 표현식이 stop 및 trace의 조건으로 허용됩니다.

표현식 유형이 검사됩니다. 사용자는 표현식의 이름을 변경하거나 캐스팅 연산자를 사용하여 표현식 유형을 대체합니다. 이름 바꾸기의 세 가지 양식은 Typename(Expression), Expression |Typename, (Typename) Expression입니다. 다음 예제에서 변수 x는 값이 97인 정수입니다.

(dbx) print x
97
(dbx) print char (x), x ₩ char, (char) x, x
'a' 'a' 'a' 97

명령행 편집

dbx 명령은 Korn 쉘에서 제공하는 것과 유사한 명령행 편집 기능을 제공합니다. vi 모드는 vi와 같은 편집 기능을 제공하는 반면, emacs 모드는 emacs와 유사한 제어를 제공합니다.

이 기능은 dbx 부속 명령인 set -o 또는 set edit를 사용하여 설정될 수 있습니다. vi 방식의 명령행 편집 기능을 사용하기 위해서는, 부속 명령 set edit vi 또는 set -o vi를 입력하십시오.

EDITOR 환경 변수를 사용하여 편집 모드를 설정할 수도 있습니다.

dbx 명령은 입력된 명령을 .dbxhistory 파일에 저장합니다. DBXHISTFILE 환경 변수가 설정되지 않은 경우, 기록을 위해 사용되는 파일은 $HOME/.dbxhistory입니다.

디폴트로, dbx는 최근에 입력된 128개의 명령 텍스트를 저장합니다. DBXHISTSIZE 환경 변수는 이 한계를 늘리는데 사용될 수 있습니다.

플래그

예제

1. 다음 예제는 프로세스와 동시에 dbx 디버그 프로그램을 시작하는 방법에 대해 설명합니다. 예제는 samp.c라는 프로그램을 사용합니다. 이 C 프로그램은 먼저 기호 테이블 참조사항이 들어 있는 오브젝트 파일을 작성하기 위해 -g 플래그를 사용하여 컴파일됩니다. 이런 경우, samp 프로그램은 다음 사항을 표시합니다.

   $ cc -g samp.c -o samp

   samp 프로그램이 실행 중일 때 운영 시스템은 버스 오류를 알리고 다음과 같이 사용자의 현재 작업 디렉토리에 코어 이미지를 작성합니다.

   $ samp
   Bus Error - core dumped

   오류가 발생한 위치를 찾아내려면 다음을 입력하십시오.

   $ dbx samp

   시스템이 다음과 같은 메시지를 리턴합니다.

   dbx version 3.1
   Type 'help' for help.
   reading symbolic information . . . [
   using memory image in core]
     25   x[i] = 0;
   (dbx) quit

2. 이 예제는 프로세스에 dbx를 연결하는 방법에 대해 설명합니다. 이 예제는 looper.c 프로그램을 사용합니다.

   main()
   {
   int i,x[10];
          
         for (i = 0; i < 10;);
   }

   i가 증가하지 않으므로 프로그램이 종료되지 않습니다. 기호 디버깅 기능을 확보하려면 looper.c를 -g 플래그를 사용하여 컴파일하십시오.

   $ cc -g looper.c -o looper

   명령행에서 looper를 실행하고 다음 단계를 실행하여 프로그램을 실행하는 중에 프로그램에 dbx를 연결합니다.

   1. dbx를 looper에 연결하려면 프로세스 ID를 확인해야 합니다. 백그라운드 프로세스로서 looper를 실행하지 않았으면, 다른 Xwindow를 열어 두어야 합니다. 이 Xwindow 창에서, 다음을 입력하십시오.

      ps -u UserID

      여기서 UserID는 로그인 ID를 말합니다. 사용자에게 속하는 사용 중인 모든 프로세스는 다음과 같이 표시됩니다.

      PID     TTY      TIME    COMMAND
      68      console   0:04    sh
      467     lft3     10:48    looper

      이 예제에서 looper와 관련된 프로세스 ID는 467입니다.

   2. dbx를 looper에 연결하려면 다음을 입력하십시오.

      $ dbx -a 467

      시스템이 다음과 같은 메시지를 리턴합니다.

      Waiting to attach to process 467 . . .
      Successfully attached to /tmp/looper.
      dbx is initializing
      Type 'help' for help.
      reading symbolic information . . .
       
      attached in main at line 5
      5     for (i = 0; i < 10;);
      (dbx)

      프로세스가 처음에 dbx에 의해 시작된 것처럼 지금 프로세스를 조회하고 디버그할 수 있습니다.

3. 실행 파일인 objefile의 소스 파일을 검색하기 위한 디렉토리 리스트에 디렉토리를 추가하려면, 다음을 입력하십시오.

   $dbx -I /home/user/src -I /home/group/src 
   objfile

   dbx를 시작하면 use 부속 명령을 이 기능에 사용할 수 있습니다. -I 플래그가 리스트에 디렉토리를 추가하는 것과는 달리 use 명령은 디렉토리 리스트를 재설정합니다.

4. -r 플래그를 사용하려면 다음을 입력하십시오.

   $ dbx -r samp 

   시스템이 다음과 같은 메시지를 리턴합니다.

   Entering debug program . . .
   dbx version 3.1
   Type 'help' for help.
   reading symbolic information . . .
   bus error in main at line 25
     25   x[i] = 0;
   (dbx) quit

   -r 플래그는 사용자가 코어 이미지를 가지고 있지 않더라도 메모리에서 사용자의 프로세스 상태를 검사할 수 있도록 합니다.

5. 디버그 프로그램에 대한 환경 변수를 지정하려면, 다음을 입력하십시오.

   dbx -E LIBPATH=/home/user/lib -E LANG=Ja_JP objfile

dbx 부속 명령

주: 부속 명령은 dbx 디버그 프로그램이 실행 중일 때만 사용할 수 있습니다.

/ 부속 명령

/ [ RegularExpression [ / ] ]

/ 부속 명령은 현재 소스 파일에서 앞쪽으로 RegularExpression 매개변수에서 지정한 패턴을 검색합니다. 인수 없이 / 부속 명령을 입력하면 dbx는 이전 정규식을 파일의 앞쪽으로 검색합니다. 검색은 파일의 끝을 만나면 다시 처음부터 검색하기 시작합니다.

예제

1. 현재 소스 파일에서 12라는 숫자에 대해 앞쪽으로 검색하려면 다음을 입력하십시오.

   / 12

2. 이전 검색을 반복하려면, 다음을 입력하십시오.

   /

? (search) 부속 명령 및 regcmp 서브루틴을 참조하십시오.

? 부속 명령

? [ RegularExpression [ ? ] ]

? 부속 명령은 RegularExpression 매개변수에서 지정한 패턴에 대해 현재 소스 파일의 역방향으로 검색합니다. 인수 없이 ? 부속 명령을 입력하면 dbx 명령은 이전 정규식을 뒷쪽(역방향)으로 검색합니다. 검색은 파일의 끝을 만나면 다시 처음부터 검색하기 시작합니다.

예제

1. 현재 소스 파일에서 문자 z에 대해 뒤쪽으로 검색하려면, 다음을 입력하십시오.

   ?z

2. 이전 검색을 반복하려면, 다음을 입력하십시오.

   ?

/(search) 부속 명령 및 regcmp 서브루틴을 참조하십시오.

alias 부속 명령

alias [ Name [ [ (Arglist) ] String | Subcommand ] ]

alias 부속 명령은 dbx 부속 명령에 대한 별명을 작성합니다. Name 매개변수는 작성되고 있는 별명입니다. String 매개변수는 일련의 dbx 부속 명령으로서 이 부속 명령을 실행한 다음 Name으로 참조할 수 있습니다. 매개변수 없이 alias 부속 명령을 사용하면 현재의 모든 별명이 표시됩니다.

예제

1. rerun의 rr을 대체하려면 다음을 입력하십시오.

   alias rr rerun

2. printandstep을 명령행에 입력할 때마다 두 개의 부속 명령 print n과 step을 실행하려면 다음을 입력하십시오.

   alias printandstep "print n; step"

3. alias 부속 명령을 제한된 매크로 기능으로 사용할 수도 있습니다. 예를 들면 다음과 같습니다.

   (dbx) alias px(n) "set $hexints; print n; unset $hexints"
   (dbx) alias a(x,y) "print symname[x]->symvalue._n_n.name.Id[y]"
   (dbx) px(126)
   0x7e

   이 예제에서 별명 px는 디버깅 환경에 영구적으로 영향을 미치지 않고 16진수로 값을 인쇄합니다.

assign 부속 명령

assign 변수=표현식

assign 부속 명령은 Expression 매개변수가 지정한 값을 Variable 매개변수가 지정한 변수에 지정합니다.

예제

1. 5 값을 x 변수에 지정하려면 다음을 입력하십시오.

   assign x = 5

2. 변수 y를 변수 x에 지정하려면 다음을 입력하십시오.

   assign x =  y

3. 문자 값 'z'를 변수 z에 지정하려면 다음을 입력하십시오.

   assign  z  =  'z'

4. 부울식 값 false를 논리적 형식 변수 B에 지정하려면 다음을 입력하십시오.

   assign  B  =  false

5. "Hello World" 문자열을 문자 포인터에 지정하려면 다음을 입력하십시오. Y, enter:

   assign  Y  =  "Hello  World"

6. 유형 검사 기능을 사용하지 않으려면, 다음과 같이 입력하여 dbx 디버그 프로그램 변수 $unsafeassign을 설정하십시오.

   set $unsafeassign

Displaying and Modifying Variables를 참조하십시오.

attribute 부속 명령

attribute [ AttributeNumber ... ]

Attribute 부속 명령은 사용자 스레드, mutex 또는 AttributeNumber 매개변수에 의해 정의된 조건 속성 오브젝트에 대한 정보를 표시합니다. 매개변수를 지정하지 않으면, 모든 속성 오브젝트가 나열됩니다.

나열된 각 속성 오브젝트에 다음과 같은 정보가 표시됩니다.

주:

1. dbx 디버그 프로그램의 print 부속 명령은 기호로 된 속성 이름을 인식하며, 해당 오브젝트의 상태를 표시하는 데 사용할 수 있습니다.
2. 사용 가능한 속성은 POSIX 옵션 구현에 따라 달라집니다.

예제

1. 모든 속성에 관한 정보를 나열하려면, 다음을 입력하십시오.

   attribute

   출력은 다음과 유사합니다.

   attr   obj_addr   type  state  stack   scope    prio 
   sched p-shar
   $a1   0x200035c8  mutex valid                                  no 
   $a2   0x20003628  cond  valid                                  no
   $a3   0x200037c8  thr   valid  57344    sys      126 other
   $a4   0x200050f8  thr   valid  57344    pro      126 other
     

2. 속성 1과 3에 관한 정보를 나열하려면 다음을 입력하십시오.

   attribute 1 3
    

   출력은 다음과 유사합니다.

   attr   obj_addr   type  state  stack   scope    prio 
   sched p-shar
   $a1   0x200035c8  mutex valid                                  no 
   $a3   0x200037c8  thr   valid  57344    sys      126 other
     

dbx 명령의 condition 부속 명령, mutex 부속 명령, print 부속 명령 및 thread 부속 명령을 참조하십시오.

AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그의 Creating Threads, Mutexes 사용 및 Using Condition Variables를 참조하십시오.

call 부속 명령

call Procedure ( [ 매개변수] )

call 부속 명령은 Procedure 매개변수에 지정된 프로시저를 실행합니다. 리턴 코드는 인쇄되지 않습니다. 매개변수를 지정하면 매개변수는 실행 중인 프로시저로 전달됩니다.

예제

dbx를 실행하는 중에 명령을 호출하려면 다음을 입력하십시오.

(dbx) call printf("hello")
hello

printf가 성공적으로 리턴합니다.

case 부속 명령

case [ default | mixed | lower | upper ]

case 부속 명령은 dbx 디버그 프로그램이 기호를 해석하는 방법을 변경합니다. 기호의 디폴트 처리 방법은 현재 언어에 따라 다릅니다. 현재 언어가 C, C++이거나 정의되지 않았으면, 기호는 대문자로 변환되지 않습니다. 현재 언어가 FORTRAN 또는 Pascal이면, 기호는 소문자로 변환됩니다. 기호가 현재 언어와 일치하지 않는 방법으로 해석되어야 하는 경우, 이 부속 명령을 사용하십시오.

매개변수 없이 case 부속 명령을 입력하면 현재 문자 모드가 표시됩니다.

플래그

예제

1. 현재 문자 모드를 표시하려면 다음을 입력하십시오.

   case

2. 실제로 나타나는 대로 기호를 해석하도록 dbx를 지시하려면 다음을 입력하십시오.

   case mixed

3. 기호를 대문자로 해석하도록 dbx를 지시하려면 다음을 입력하십시오.

   case upper

변수를 소문자와 대문자로 변환을 참조하십시오.

catch 부속 명령

catch [ SignalNumber | SignalName ]

catch 부속 명령은 신호가 응용프로그램으로 전송되기 전에 지정된 신호 트랩을 시작합니다. 이 부속 명령은 디버그되고 있는 응용프로그램이 인터럽트와 같은 신호를 처리할 때 유용합니다. 트랩될 신호는 각각 SignalNumber 또는 SignalName 매개변수를 사용하여 번호 또는 이름으로 지정할 수 있습니다. 신호 이름은 대소문자를 구별하지 않으며 SIG 접두어는 선택적입니다. SignalNumber 또는 SignalName 매개변수를 지정하지 않으면 기본적으로 SIGHUP, SIGCLD, SIGALARM 및 SIGKILL 신호를 제외한 모든 신호가 트랩됩니다. 아무 인수도 지정하지 않으면, 찾으려고 하는 현재 신호 리스트가 표시됩니다.

예제

1. dbx에서 트랩할 현재 신호 리스트를 표시하려면 다음을 입력하십시오.

   catch

2. 신호 SIGALARM을 트랩하려면 다음을 입력하십시오.

   catch SIGALARM

ignore 부속 명령과 Handling Signals를 참조하십시오.

clear 부속 명령

clear SourceLine

clear 부속 명령은 주어진 소스 행에서 모든 정지(stop)를 제거합니다. SourceLine 매개변수는 두 가지 형식으로 지정될 수 있습니다.

• 정수로 지정
• :(콜론)과 정수 앞에 오는 파일 이름 문자열로 지정

예제

19 행에서 중단점 설정을 제거하려면 다음을 입력하십시오.

clear 19

cleari 부속 명령 및 delete 부속 명령. AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Setting and Deleting Breakpoints를 참조하십시오.

cleari 부속 명령

cleariAddress

cleari 부속 명령은 Address 매개변수에서 지정한 주소의 모든 중단점을 지웁니다.

예제

1. 주소 0x100001b4에서 중단점 설정을 제거하려면 다음을 입력하십시오.

   cleari 0x100001b4

2. main() 프로시저 주소에서 중단점 설정을 제거하려면 다음을 입력하십시오.

   cleari &main

clear 부속 명령, delete 부속 명령, AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Setting and Deleting Breakpoints를 참조하십시오.

condition 부속 명령

condition [ wait | nowait | ConditionNumber ... ]

condition 부속 명령은 하나 이상의 조건 변수에 대한 정보를 표시합니다. 하나 이상의 ConditionNumber 매개변수가 주어지면, condition 부속 명령은 지정된 조건 변수에 대한 정보를 표시합니다. 플래그나 매개변수를 지정하지 않으면, condition 부속 명령은 모든 조건 변수를 나열합니다.

각 조건에 대해 나열되는 정보는 다음과 같습니다.

주: dbx 디버그 프로그램의 print 부속 명령은 기호로 된 조건 변수 이름을 인식하며, 해당 오브젝트의 상태를 표시하는 데 사용될 수 있습니다.

플래그

예제

1. 모든 조건 변수에 관한 정보를 표시하려면 다음을 입력하십시오.

   condition

2. 대기 중인 스레드가 있는 모든 조건 변수에 관한 정보를 표시하려면 다음을 입력하십시오.
   condition wait
   
3. 조건 변수 3에 관한 정보를 표시하려면 다음을 입력하십시오.

   condition 3

   출력은 다음과 유사합니다.

   cv      obj_addr     num_wait  waiters
    $c3     0x20003290         0

attribute 부속 명령, mutex 부속 명령, print 부속 명령 및 thread 부속 명령을 참조하십시오.

또한, AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그의 Using Condition Variables를 참조하십시오.

cont 부속 명령

cont [ SignalNumber | SignalName ]

cont 부속 명령은 프로그램이 종료되거나 다른 중단점에 도달할 때까지 현재 정지점에 있는 응용프로그램을 계속해서 실행합니다. 신호를 지정하면, 프로그램은 SignalNumber 매개변수에 지정된 숫자나 SignalName 매개변수에 지정된 이름에 의해 그 신호를 받은 것으로 간주하고 실행을 계속합니다. 신호 이름은 대소문자를 구분하지 않으며 SIG 접두어는 선택적입니다. 신호가 지정되지 않으면, 프로그램은 중단되지 않았던 것처럼 실행을 계속합니다.

예제

1. 현재 정지점에서 프로그램 실행을 계속하려면 다음을 입력하십시오.

   cont

2. SIGQUIT 신호를 받은 것처럼 프로그램 실행을 계속하려면 다음을 입력하십시오.

   cont SIGQUIT

dbx 명령의 detach 부속 명령, dbx 명령의 goto 부속 명령, dbx 명령의 next 부속 명령, dbx 명령의 skip 부속 명령, dbx 명령의 step 부속 명령을 참조하십시오.

corefile 부속 명령

corefile 부속 명령은 실행 파일 이름, 코어 파일 형식 버전 정보, 사용 가능한 데이터를 표시하는 플래그, 고장을 야기한 신호, 코어를 덤프한 프로세스의 실행 모드를 비롯하여, 코어 파일의 헤더에 있는 정보를 표시합니다.

delete 부속 명령

delete { Number ... | all }

delete 부속 명령은 응용프로그램에 설명되어 있는 추적 및 정지를 해제합니다. 해제될 추적 및 정지는 Number 매개변수에 의해 지정될 수 있으며, 모든 추적 및 정지는 all 플래그를 사용하여 해제될 수 있습니다. dbx 프로그램별로 추적 및 정지에 연관된 숫자를 표시하려면 status 부속 명령을 사용하십시오.

플래그

예제

1. 응용프로그램에서 모든 추적 및 정지를 해제하려면, 다음을 입력하십시오.

   delete all

2. 이벤트 번호 4에 대한 추적 및 정지를 해제하려면, 다음을 입력하십시오.

   delete 4

clear 부속 명령, cleari 부속 명령, status 부속 명령 및 AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Setting and Deleting Breakpoints를 참조하십시오.

detach 부속 명령

detach [ SignalNumber | SignalName ]

detach 부속 명령은 응용프로그램의 실행을 계속하고 디버그 프로그램을 종료합니다. 신호는 다음의 두 가지 방법 가운데 한가지로 지정될 수 있습니다.

• SignalName 매개변수를 사용한 이름
• SignalNumber 매개변수를 사용한 숫자

  신호 이름은 대소문자를 구분하지 않으며 SIG 접두어는 선택적입니다.

  신호를 지정하면, 프로그램은 그 신호를 받은 것으로 간주하고 실행을 계속합니다. 신호를 지정하지 않으면, 프로그램은 정지가 발생하지 않았던 것처럼 실행을 계속합니다.

예제

1. 응용프로그램의 실행을 계속하고 dbx를 종료하려면 다음을 입력하십시오.

   detach

2. 응용프로그램에서 SIGREQUEST 신호를 받더라도 dbx를 종료하고 응용프로그램 실행을 계속하려면 다음을 입력하십시오.

   detach SIGREQUEST

Using the dbx Debug Program을 참조하십시오.

disable 부속 명령

disable { Number ... all }

disable 부속 명령은 디버그 이벤트와 연관된 추적 및 정지를 사용 불가능하게 합니다. 사용 불가능하게 할 추적 및 정지는 Number 매개변수를 통해 지정할 수 있으며, 모든 추적 및 정지는 all 플래그를 사용하여 사용 불가능하게 할 수 있습니다. dbx 디버그 프로그램에 의해 추적 및 정지에 연관된 이벤트 숫자를 표시하려면 status 부속 명령을 사용하십시오.

플래그

예제

1. 응용프로그램에서 모든 추적 및 정지를 사용 불가능하게 하려면 다음을 입력하십시오.

   disable all

2. 이벤트 번호 4에 대한 추적 및 정지를 사용 불가능하게 하려면 다음을 입력하십시오.

   disable 4

자세한 정보는 enable 부속 명령, delete 부속 명령, status 부속 명령을 참조하십시오.

또한, AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Setting and Deleting Breakpoints를 참조하십시오.

display memory 부속 명령

{ Address,Address/ | Address/ [ Count ] } [ Mode ] [ >File ]

display memory 부속 명령에는 명령을 초기화하는 키워드가 없으며 다음과 같은 요인으로 제어되는 메모리의 일부분을 표시합니다.

표시되는 메모리 범위는 다음 중의 하나를 지정하면 제어됩니다.

• 두 개의 Address 매개변수

  또는

• 시작점을 나타내는 하나의 Address 매개변수와, 그 Address로부터 표시되는 행의 갯수를 결정하는 Count.

앞에 &(앰퍼샌드)를 가진 이름으로 기호 주소를 지정하십시오. 주소는 다른 주소 및 연산자 +(더하기 부호), -(빼기 부호), *로 이루어진 표현식이 될 수 있습니다. 괄호 안에 들어 있는 표현식은 주소로 해석합니다.

• 메모리를 표시하는 형식은 Mode 매개변수가 제어합니다. Mode 매개변수의 디폴드는 현재 모드입니다. Mode의 초기값은 X입니다.

플래그

예제

1. 주소 0x3fffe460에서 16진수 문자열에 있는 메모리 내용 중 긴 단어 하나를 표시하려면 다음을 입력하십시오.

   0x3fffe460 / X

2. 변수 y에서 시작하는 메모리 2바이트의 내용을 문자로 나타내려면 다음을 입력하십시오.

   &y / 2c

3. FORTRAN 문자열 a_string에서 6-8번째 요소를 표시하려면 다음을 입력하십시오.

   &a_string + 5, &a_string + 7/c

AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Examining Memory Addresses를 참조하십시오.

down 부속 명령

down [ Count ]

down 부속 명령은 현재의 함수를 Count 레벨 번호 아래로 이동시킵니다. 현재 함수는 이름을 분석하는 데 사용됩니다. Count 매개변수에 대한 디폴트는 1입니다.

예제

1. 스택을 한 레벨 아래로 이동하려면 다음을 입력하십시오.

   아래로

2. 스택을 세 레벨 아래로 이동하려면 다음을 입력하십시오.

   down 3

up 부속 명령, where 부속 명령 및 AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Displaying a Stack Trace를 참조하십시오.

dump 부속 명령

dump [ Procedure ] [ >File ]

dump 부속 명령은 지정된 프로시저 내의 모든 변수 이름과 값을 표시합니다. Procedure 매개변수는 .(마침표)이며, 모든 사용 중에 있는 변수가 표시됩니다. Procedure 매개변수를 지정하지 않으면, 현재 프로시저가 사용됩니다. >File 플래그를 사용하면 출력은 지정된 파일로 방향 재지정됩니다.

플래그

예제

1. 현재 프로시저에 있는 변수 이름과 값을 표시하려면 다음을 입력하십시오.

   dump

2. add_count 프로시저에 있는 변수 이름과 값을 표시하려면 다음을 입력하십시오.

   dump add_count

3. 현재 프로시저에 있는 변수 이름과 값을 var.list 파일로 방향 재지정하려면 다음을 입력하십시오.

   dump > var.list

Displaying and Modifying Variables AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서를 참조하십시오.

edit 부속 명령

edit [ Procedure | File ]

edit 부속 명령은 지정된 파일에서 편집기를 실행시킵니다. 파일은 File 매개변수 또는 Procedure 매개변수를 지정하여 지정할 수 있으며, 여기서 편집기는 해당 프로시저가 포함되어 있는 파일에서 호출됩니다. 파일을 지정하지 않으면, 현재 소스 파일에서 편집기가 실행됩니다. 디폴트는 vi 편집기입니다. EDITOR 환경 변수를 원하는 편집기의 이름으로 재설정하여 디폴트를 변경할 수 있습니다.

예제

1. 현재 소스 파일에서 편집기를 시작하려면 다음을 입력하십시오.

   edit

2. main.c 파일에서 편집기를 시작하려면 다음을 입력하십시오.

   edit main.c

3. do_count() 프로시저가 포함된 파일에서 편집기를 시작하려면 다음을 입력하십시오.

   edit do_count

list 부속 명령, vi 또는 vedit 명령을 참조하십시오. AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Changing the Current File or Procedure 및 Displaying the Current File을 참조하십시오.

enable 부속 명령

enable { Number ... all }

enable 부속 명령은 디버그 이벤트와 연관된 추적 및 정지를 사용 가능하게 합니다. 사용 가능하게 할 추적 및 정지는 Number 매개변수를 통해 지정할 수 있으며, 모든 추적 및 정지는 all 플래그를 사용하여 사용 가능하게 할 수 있습니다. dbx 디버그 프로그램에 의해 추적 및 정지에 연관된 이벤트 숫자를 표시하려면 status 부속 명령을 사용하십시오.

플래그

예제

1. 응용프로그램에서 모든 추적 및 정지를 사용 가능하게 하려면 다음을 입력하십시오.

   enable all

2. 이벤트 번호 4에 대한 추적 및 정지를 사용 가능하게 하려면 다음을 입력하십시오.

   enable 4

자세한 정보는 disable 부속 명령, delete 부속 명령, status 부속 명령을 참조하십시오.

또한, AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Setting and Deleting Breakpoints를 참조하십시오.

fd 부속 명령

fd [ raw ] [ start [ end ] ]

fd 부속 명령은 파일 설명자 정보를 표시합니다. raw 옵션을 사용하면 출력이 원시 16진 형식으로 표시됩니다. 다른 선택적 인수에는 start와 end 색인이 포함됩니다. 색인을 지정하지 않으면, 사용 가능한 모든 파일 설명자에 대한 정보가 표시됩니다. 하나의 색인을 사용하면 단일 파일 설명자가 표시되고 두 개를 사용하면 포함 범위가 표시됩니다.

예제

1. 16진으로 된 모든 파일 설명자에 대한 정보를 보려면 다음을 입력하십시오.

   fd raw

2. 3 - 5 범위의 파일 설명자에 대한 정보를 보려면 다음을 입력하십시오.

   fd 3 5

file 부속 명령

file [ File ]

file 부속 명령은 현재 소스 파일을 File 매개변수에서 지정한 파일로 변경합니다. 그 파일에 쓰지는 않습니다. File 매개변수에 파일에 대한 전체 경로 이름을 지정할 수 있습니다. File 매개변수에 경로가 지정되어 있지 않으면, dbx 프로그램은 사용 경로를 검색하여 파일을 찾으려고 합니다. File 매개변수를 지정하지 않으면, file 부속 명령은 현재 소스 파일의 이름을 표시합니다. 경로를 알 수 있는 경우, file 부속 명령은 파일의 전체 또는 상대 경로도 표시합니다.

예제

1. 현재 소스 파일을 main.c 파일로 변경하려면 다음을 입력하십시오.

   file main.c

2. 현재 소스 파일 이름을 표시하려면, 다음을 입력하십시오.

   file

func 부속 명령을 참조하십시오. AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Changing the Current File or Procedure 및 Displaying the Current File을 참조하십시오.

func 부속 명령

func [ Procedure ]

func 부속 명령은 현재 함수를 Procedure 매개변수에서 지정한 프로시저나 함수로 변경합니다. Procedure 매개변수를 지정하지 않으면, 디폴트 현재 함수가 표시됩니다. 현재 기능을 내재적으로 변경하면 현재 소스 파일은 새로운 함수가 포함된 파일로 변경됩니다. 이름 해석에 사용된 현재 유효범위도 변경됩니다.

예제

1. 현재 함수를 do_count 프로시저로 변경하려면 다음을 입력하십시오.

   func do_count

2. 현재 함수 이름을 표시하려면, 다음을 입력하십시오.

   func

file 부속 명령을 참조하십시오. AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Changing the Current File or Procedure를 참조하십시오.

goto 부속 명령

gotoSourceLine

goto 부속 명령은 지정된 소스 행이 다음에 실행되도록 합니다. 일반적으로, 소스 행은 현재 소스 행과 동일한 함수 내에 들어 있어야 합니다. 이 제한사항을 대체하려면 set 부속 명령에 $unsafegoto 플래그를 사용하십시오.

예제

다음 행이 행 6에서 실행되도록 변경하려면 다음을 입력하십시오.

goto 6

cont 부속 명령, gotoi 부속 명령 및 set 부속 명령을 참조하십시오.

gotoi 부속 명령

gotoi Address

gotoi 부속 명령은 프로그램 계수기 주소를 Address 매개변수에서 지정한 주소로 변경합니다.

예제

주소를 0x100002b4로 변경하려면 다음을 입력하십시오.

gotoi 0x100002b4

goto 부속 명령을 참조하십시오.

handler 부속 명령

handler { atfork | cancel_cleanup [ all | pthread id ] }

handler 부속 명령은 각각 pthread_atfork 및 pthread_cleanup_push를 사용하여 등록된 atfork 또는 취소 정리 처리기에 대한 정보를 표시합니다. atfork 옵션을 사용하면 pre, parent 및 child atfork 처리기로 등록된 루틴의 이름이 표시됩니다(비posix 준수 atfork 처리기의 경우 각각의 인수도 같이 표시됩니다). 특정 pthread를 지정하는 선택적 pthread id 매개변수나 모든 pthread를 지정하는 all 매개변수와 함께 cancel_cleanup 옵션을 사용하면 등록된 모든 취소 정리 처리기가 표시됩니다. 어느 매개변수도 지정하지 않으면, 현재 pthread의 취소 정리 처리기가 표시됩니다(있는 경우).

예제

1. 등록된 모든 atfork 처리기에 대한 정보를 보려면 다음을 입력하십시오.

   handler atfork

2. 현재 pthread에 대해 등록된 취소 정리 처리기에 대한 정보를 보려면 다음을 입력하십시오.

   handler cancel_cleanup

3. $t2라고 하는 pthread 오브젝트에 대해 등록된 취소 정리 처리기에 대한 정보를 보려면 다음을 입력하십시오.

   handler cancel_cleanup 2

help 부속 명령

help [ Subcommand | Topic ]

help 부속 명령은 지정한 매개변수에 따라 dbx 부속 명령 또는 주제에 대한 도움말 정보를 표시합니다. help 부속 명령을 Subcommand 매개변수와 함께 입력하면 구문 명령과 지정된 부속 명령에 대한 설명이 표시됩니다. help 부속 명령을 Topic 매개변수와 함께 입력하면 지정된 주제에 대한 설명이 표시됩니다. 다음 주제가 사용 가능합니다.

예제

1. 사용 가능한 dbx 부속 명령과 주제를 모두 나열하려면 다음을 입력하십시오.

   도움말

2. dbx 부속 명령 리스트 설명을 표시하려면 다음을 입력하십시오.

   help list

3. dbx 항목 set_variables의 설명을 표시하려면 다음을 입력하십시오.

   help set_variables

ignore 부속 명령

ignore [ SignalNumber | SignalName ]

ignore 부속 명령은 신호가 응용프로그램으로 전송되기 전에 지정된 신호의 트랩을 정지합니다. 이 부속 명령은 디버그되고 있는 응용프로그램이 인터럽트와 같은 신호를 처리할 때 유용합니다.

다음 사항이 트랩되는 신호를 지정합니다.

• SignalNumber 매개변수를 사용한 숫자
• SignalName 매개변수를 사용한 이름

신호 이름은 대소문자를 구분하지 않습니다. SIG 접두어는 생략 가능합니다.

SignalNumber 또는 SignalName 매개변수 중 아무것도 지정하지 않으면, 디폴트로 SIGHUP, SIGCLD, SIGALRM 및 SIGKILL 신호를 제외한 모든 신호가 트랩됩니다. dbx 디버그 프로그램은 디버거 외부의 프로세스에서 생긴 SIGTRAP 신호를 무시할 수 없습니다. 아무 인수도 지정하지 않으면, 현재 무시된 신호의 리스트가 표시됩니다.

예제

dbx가 응용프로그램으로 송신된 제한시간 초과 신호를 무시하도록 하려면 다음을 입력하십시오.

ignore alrm

catch 부속 명령을 참조하십시오. AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Handling Signals를 참조하십시오.

kthread 부속 명령

kthread [ raw ] [ info | ru ] [ tid ]

kthread 부속 명령은 커널 스레드에 대한 정보를 표시합니다. raw 옵션을 사용하면 사용자가 읽기 쉬운 형식으로 표시 가능한지 여부에 관계없이 모든 출력이 16진으로 표시됩니다. 인수를 사용하지 않으면 모든 커널 스레드에 대한 요약 정보가 표시됩니다. 숫자 스레드 ID를 제공하면 dbx는 단일 스레드에 대한 정보를 표시합니다. info 옵션은 사용자 스레드 구조를 통해 스레드에 대한 자세한 출력을 생성합니다. ru 옵션을 사용하면 ti_ru 데이터 멤버를 표시합니다. 여기에는 사용 정보가 포함됩니다.

사용자 스레드에 대한 자세한 정보는 thread 부속 명령을 참조하십시오.

예제

1. 현재 실행 중인 스레드에 대한 정보를 찾으려면, 먼저 명령행에 다음과 같이 입력하여 모든 스레드에 대한 정보를 확보해야 합니다.

   kthread

   dbx가 프로세스를 정지하기 바로 전에 실행 중이었던(또는 실행 가능했던) 스레드에 별표가 표시됩니다. 출력을 기초로 올바른 스레드 ID를 선택하고 다음을 입력하십시오.

   kthread info tid

2. 모든 스레드에 대한 자원 정보를 16진으로 보려면 다음을 입력하십시오.

   kthread raw ru

list 부속 명령

list [ Procedure | SourceLine-Expression [ ,SourceLine-Expression ] ]

list 부속 명령은 소스 파일 중 지정된 행을 표시합니다. 표시된 행 수는 두 가지 중 한 가지 방식으로 지정됩니다.

• Procedure 매개변수를 사용하여 프로시저를 지정.

이 경우, list 부속 명령은 지정된 프로시저가 시작되기 전에 창의 크기만큼 여러 행을 보여줍니다.

• SourceLine-Expression 매개변수를 사용하여 시작 및 종료 소스 행 번호를 지정.

SourceLine-Expression 매개변수는 +(더하기 부호)나 -(빼기 부호), 그리고 정수로 되어 있는 유효 행 번호로 구성되어야 합니다. 또한, $(달러 기호)인 SourceLine을 사용하여 현재 행 번호를 표시하고, @인 SourceLine을 사용하여 나열되는 다음 행 번호를 표시할 수도 있습니다.

그러면 지정된 첫 번째 행 번호에서부터 지정된 두 번째 행 번호에 이르기까지 모든 행이 표시됩니다.

두 번째 소스 행이 생략된 경우, 첫 번째 행만 출력됩니다.

list 부속 명령이 매개변수 없이 사용되면, 현재 소스 행에서부터 $listwindow에 지정된 행 만큼이 인쇄됩니다.

디폴트로 나열되는 행 번호를 변경하려면 특별한 디버그 프로그램 변수인 $listwindow를 사용자가 원하는 행 번호로 설정하십시오. 처음에는 $listwindow는 10으로 설정됩니다.

예제

1. 현재 파일에서 행 1에서 10까지 나열하려면 다음을 입력하십시오.

   list 1,10

2. main 프로시저 주위의 10 행이나 $listwindow 행을 나열하려면 다음을 입력하십시오.

   list main

3. 현재 행 주위의 11행을 나열하려면, 다음을 입력하십시오.

   list $-5,$+5

4. SourceLineExpression 표현식에 더하기와 빼기가 포함된 간단한 정수식을 사용할 수 있습니다. 예를 들면 다음과 같습니다.

   (dbx) list $
   4 {
   
   (dbx) list 5
   5 char i = '4';
   
   (dbx) list sub
   23 char *sub(s,a,k)
   24 int a;
   25 enum status k;  .  .  .  
   
   (dbx) move 
   25
   (dbx) list @ -2
   23 char *sub(s,a,k)

edit 부속 명령, listi 부속 명령 및 move 부속 명령을 참조하십시오. AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Displaying the Current File을 참조하십시오.

listi 부속 명령

listi [ Procedure | at SourceLine | Address [ , Address ] ]

listi 부속 명령은 소스 파일에 있는 명령어 세트를 표시합니다. 표시된 명령은 다음과 같이 지정됩니다.

• Procedure 매개변수를 제공하면 listi 부속 명령은 리스트 창이 채워질 때까지 지정한 프로시저의 시작으로부터 명령을 나열합니다.
• at SourceLine 플래그를 사용하면 listi 부속 명령은 지정한 소스 행에서 시작하는 명령을 표시하고 리스트 창이 채워질 때까지 계속합니다. SourceLine 변수는 정수 또는 뒤에 콜론(:)과 정수가 붙는 파일 이름 문자열로 지정할 수 있습니다.
• Address 매개변수를 사용하여 시작 및 종료 주소를 지정하면 두 주소를 포함하여 그 사이의 모든 명령이 표시됩니다.

listi 부속 명령을 플래그나 매개변수 없이 사용하면, 다음 $listwindow 명령이 표시됩니다. 현재 리스트 창의 크기를 변경하려면, set $listwindow=Value 부속 명령을 사용하십시오.

디어셈블리 모드

dbx 프로그램은 POWER 제품군 또는 POWER PC 구조의 명령을 디어셈블할 수 있습니다. 디폴트 모드에서는 dbx 프로그램이 실행 중인 구조에 대한 명령을 표시합니다.

dbx 명령에 대한 set 부속 명령의 $instructionset 변수와 $mnemonics 변수를 사용하면 기본 디어셈블리 모드를 겹쳐쓸 수 있습니다. 자세한 정보는 dbx 명령의 set 부속 명령을 참조하십시오.

플래그

예제

1. 다음 10이나, $listwindow, 명령을 나열하려면 다음을 입력하십시오.

   listi

2. 소스 행 10에 있는 기계 명령어를 나열하려면 다음을 입력하십시오.

   listi at 10

3. 파일 sample.c에 있는 소스 행 5에서 시작하는 기계 명령어를 나열하려면 다음을 입력하십시오.

   listi at "sample.c":5

4. 주소 0x10000400와 0x10000420 사이에 있는 명령을 나열하려면 다음을 입력하십시오.

   listi 0x10000400, 0x10000420

list 부속 명령과 set 부속 명령을 참조하십시오. 또한, AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서의 Debugging at the Machine Level with dbx를 참조하십시오.

malloc 부속 명령

malloc [ > File ]

옵션이 없는 malloc 부속 명령은 프로세스가 시작한 이후의 malloc 사용 통계 요약과 사용 가능하게 된 옵션 및 할당 정책 리스트를 인쇄합니다.

malloc [ allocation [ { address | size | heap | pid | tid | time } { "<" | "==" | ">" "!=" ] } Value ] ] [ > File ]

malloc 부속 명령에 대한 allocation 옵션은 프로세스가 현재 보유하는 모든 할당을 분류된 리스트로 표시합니다. 선택적 attribute RELOP value 인수를 사용하면 활성 할당 선택 범위가 좁혀집니다.

malloc [ freespace [ { address | size | heap } { "<" | "==" | ">" | "!=" ] } Value ] ] [ > File ]

malloc 부속 명령에 대한 freespace 옵션은 프로세스 힙에서 사용 가능한 모든 여유 공간을 분류된 리스트로 표시합니다. 선택적 attribute RELOP value 인수를 사용하면 여유 공간 노드 선택 범위가 좁혀집니다.

플래그

자세한 정보는 AIX 5L 버전 5.3 일반 프로그래밍 개념: 프로그램 작성 및 디버그에서 malloc 서브시스템을 사용한 시스템 메모리 할당을 참조하십시오.

map 부속 명령

map { [Format] [ entry ModuleNumber [ , ModuleNumber ] | Address | SymbolName ] [ > File ] }

map 부속 명령은 응용프로그램의 로드 부분에 대한 특징을 표시합니다. 이 정보에는 로드된 각 모듈의 모듈 이름, 멤버 이름, 텍스트 기점, 텍스트 끝, 텍스트 길이, 데이터 기점, 데이터 끝, 데이터 길이 및 파일 설명자가 포함될 수 있습니다. 표시할 항목은 다음 방식으로 지정할 수 있습니다.

• ModuleNumber 매개변수를 사용하여 단일 항목 지정
• 쉼표로 구분되는 두 개의 ModuleNumber 매개변수를 사용하여 항목 범위 지정
• Address 매개변수를 사용하여 로드된 모듈로 해석될 주소 지정
• SymbolName 매개변수를 사용하여 로드된 모듈로 해석될 기호 이름 지정

위의 스펙을 전혀 사용하지 않고 호출한 경우, map 부속 명령은 응용프로그램의 모든 로드 부분에 대한 정보를 표시합니다.

Format 인수는 로드된 모듈 설명에 대한 출력 모드를 지정합니다. 다음 리스트에 가능한 Format 인수 값이 있습니다.