debugfs?

  /proc/  밑에 리눅스 커널과 직접 통신이 가능한 file 형태의 인터페이스를 만들어 쓰듯이, debugfs 라는 가상의 메모리 타입 파일 시스템에 디버깅용 인터페이스를 만들어 사용하는 것을 말합니다. 


마운트 방법

$ > mount -t debugfs none /sys/kernel/debug/


 위와 같이 마운트 한후, /sys/kernel/debug/ 디렉토리에 들어가 보면, 리눅스 커널에서 만들어 놓은 디버깅용 인터페이스 파일들을 확인할 수 있습니다. 


example

/ > mount -t debugfs none /sys/kernel/debug


/ > cd /sys/kernel/debug


/sys/kernel/debug > ls

at91_clk        gpio            memblock        wakeup_sources

at91_gpio       hid             mmc0

bdi             ieee80211       usb


/sys/kernel/debug/ > cat at91_gpio

Pin     PIOA            PIOB            PIOC            PIOD


0:      A               A               GPIO:1          A

1:      A               A               GPIO:1          A

2:      GPIO:1          A               GPIO:1          A

3:      GPIO:1          A               GPIO:1          A

4:      GPIO:1          A               GPIO:1          GPIO:1

5:      GPIO:1          A               GPIO:1          GPIO:1

6:      GPIO:1          A               GPIO:1          A

7:      B               A               GPIO:1          A

8:      GPIO:1          GPIO:1          GPIO:1          A

9:      A               A               GPIO:1          A

10:     A               A               GPIO:1          A

11:     A               GPIO:1          GPIO:1          A

12:     A               GPIO:1          GPIO:1          A

13:     A               GPIO:1          GPIO:1          A

14:     GPIO:1          GPIO:1          GPIO:1          GPIO:1

15:     A               GPIO:1          GPIO:1          IRQ:edge-both

16:     A               GPIO:1          GPIO:0          A

17:     A               GPIO:1          GPIO:1          A

18:     A               GPIO:1          GPIO:1          A

19:     A               A               GPIO:1          GPIO:0

20:     A               A               GPIO:0          GPIO:0

21:     GPIO:1          A               GPIO:0          GPIO:1

22:     GPIO:1          A               GPIO:1          A

23:     GPIO:1          A               GPIO:1          A

24:     B               A               GPIO:1          A

25:     B               A               GPIO:1          A

26:     B               A               GPIO:1          A

27:     B               A               GPIO:1          A

28:     B               A               GPIO:0          A

29:     B               A               GPIO:1          A

30:     GPIO:1          A               GPIO:1          A

31:     GPIO:1          A               GPIO:1          A


/sys/kernel/debug/ > cd mmc0


/sys/kernel/debug/mmc0 > ls

clock             ios               pending_events    req

completed_events  mmc0:b368         regs              state


/sys/kernel/debug/mmc0 > cat clock 

50000000



API

 debug fs 를 만드는 api 는 kernel source 검색을 통해 확인 할 수 있습니다. 

대표적인 api 는 아래와 같으며, 이 api 를 시작으로 분석하면 쉽게 익힐 수 있습니다.


fs/debugfs/inode.c

struct dentry *debugfs_create_file(const char *name, mode_t mode, struct dentry *parent, void *data, const struct file_operations *fops);


'development' 카테고리의 다른 글

openwrt  (0) 2015.02.24
[network] nat 설정법  (0) 2015.01.15
[linux] debug fs 사용법  (0) 2015.01.07
[driver] ipTime N150UA-4dBi  (8) 2014.09.16
[program] unused variable 문제  (0) 2013.08.02
[program] 32bit CPU 에서 64bit 변수 사용 문제  (0) 2013.07.25
블로그 이미지

얼굴반반피곤님 김유석0

댓글을 달아 주세요

커널 코드를 살펴보다보면 __read_mostly 라는 매크로를 볼 수 있게 된다. 

자주 읽지만, 쓰는 것은 드문 데이터들이 있을 수 있다. 이런 데이터들을 캐쉬에 올려 놓으면 read 할때 유리하게 된다. 

__read_mostly 라는 매크로를 붙여주면 그 데이터는 캐쉬에 올라가게 된다. 


SMP 환경에서 이런 특성(자주 읽지만, 쓰는 것은 드문)의 데이터들은 캐쉬에 올려놓고 사용하는 것이 유리하다고 하니 필요에 따라서 이 매크로를 사용하도록 하자. 



'development' 카테고리의 다른 글

[u-boot] RPC : sendmsg returned error 101  (0) 2013.07.19
[Kernel] Kbuild system  (0) 2013.07.12
[kernel] __read_mostly?????  (0) 2013.05.08
[etc] Reglar expressions  (0) 2012.09.19
[kernel] initrd/initramfs 편집하기.  (0) 2012.05.29
[u-boot] u-boot 사용법  (0) 2012.03.08
블로그 이미지

얼굴반반피곤님 김유석0

댓글을 달아 주세요

[kernel] 스핀락

development 2012. 1. 4. 16:17
Table of content
  1. spin lock?
  2. example of spin_lock 












1. spin lock?
  프로세스 한개만 계속 수행되는 경우라면 critical section 에 대해서 신경쓸 필요가 없다.
  하지만, 현실은 여러 프로세스가 함께 동작하는 상황이므로 LOCK 에 대한 고민을 할 수 밖에 없다. 
 
  spin lock 은 커널에서 사용하는 LOCK 기법중의 하나이며 대표적인 기법이다.

  spin lock 의 API 들은 아래와 같다.

    spin_lock_init();
    spin_lock();
    spin_unlock();
    spin_locK_irqsave():
    spin_lock_irq();
    spin_lock_bh();
    spin_unlock_irqrestore();
    spin_unlock_irq();
    spin_unlock_bh();
    spin_trylock();
    spin_trylock_bh();

  spin lock() 이 커널의 LOCK 기법중 하나인 것을 감안하면 api 의 숫자가 많은 것에 놀랄수도 있다. 그만큼 LOCK 기법은 어렵고 신경써야 할 점이 많다는 것이라고 이해하면 된다. 


2. example of spin_lock
  spin lock 을 사용하려면
  
 
첫번째, spin lock 변수를 선언해야 하고
 
두번째, spin lock 변수를 초기화 해야 하며
    : static 과 dynamic 방식으로 구분된다. 
 
세번째, lock 을 얻어야 하며
    : spin_lock();
 
네번째, lock 을 풀어주어야 한다.
    : spin_unlock(); 

  아래는 spin lock 을 사용하는 가장 간단한 예제이다.

#include <asm/init.h>
#include <asm/kernel.h>
#include <asm/module.h>
#include <asm/version.h>
#include <asm/delay.h>
#include <asm/spinlock.h>
#include <asm/kthread.h>

spinlock_t g_this_lock;
struct task_struct *g_th_id1;
struct task_struct *g_th_id1;

static int
 thr_spin_lock_1(void *arg)
{
  int i = 0;
 
  printk(KERN_ALERT "@ %s() : called\n", __FUNCTION__);

  spin_lock(&g_this_lock);

  
printk(KERN_ALERT "@ %s() : get locked\n", __FUNCTION__);

  for(i=0;i<30;i++){
    
printk(KERN_ALERT "@ %s() : loop\n", __FUNCTION__);
    ssleep(1); 

  } 
 

  spin_unlock(&g_this_lock); 

  printk(KERN_ALERT "@ %s() : unlocked\n", __FUNCTION__);
 
 
return 0; 



static int
 thr_spin_lock_2(void *arg)

  printk(KERN_ALERT "@ %s() : called\n", __FUNCTION__);

  spin_lock(&g_this_lock);

  
printk(KERN_ALERT "@ %s() : get locked\n", __FUNCTION__);

  ssleep(10);

  spin_unlock(&g_this_lock); 


  
printk(KERN_ALERT "@ %s() : unlocked\n", __FUNCTION__);
  
  
return 0; 


static void __init only_spin_lock_init(void)
{
  spin_lock_init(&_ghis_lock);

  g_th_id1 = kthread_run(thr_spin_lock_1, NULL, "LOCK1");
  g_th_id2 = kthread_run(thr_spin_lock_2, NULL, "LOCK2");

  return 0; 



 위 예제는 문제를 내포하고 있는 코드입니다. spin_lock 이 걸려 있는 상태에서 rmmod 로 모듈을 제거하게 되면 "device is busy" 가 발생하게 됩니다. 
 

'development' 카테고리의 다른 글

[program] 2차원 배열 동적 할당  (0) 2012.02.10
[kernel] Top Half? Bottom Half? context?  (5) 2012.01.13
[kernel] 스핀락  (1) 2012.01.04
[program] Makefile  (0) 2012.01.04
[kernel] 커널 쓰레드  (0) 2012.01.04
[kernel] 시간지연  (1) 2012.01.02
블로그 이미지

얼굴반반피곤님 김유석0

댓글을 달아 주세요


Table of Content
  1. kernel_thread VS kthread
  
2. kernel_thread 
     A. 소개
     B. daemonize()
     
  3
. kthread 
  
4. kthread 예제 

1. kernel_thread VS kthread
  linux kernel 에서 쓰레드를 구현하는 기법엔 크게 두가지가 있습니다.
  첫번째는 kernel_thread() 를 사용하는 것이고
  두번째는 kthread_xxxx() 를 사용하는 것입니다.

  kernel_thread() 는 가장 기본적인 쓰레드 구현 방법인데 실제 커널 코드상에서는 사용 빈도가 극히 드뭅니다. 
  kernel_thread() 를 직접 사용하면 이것저것 해 줘야 할 것들이 많아지는데  
kthread_xxxx() 계열을 사용하면 코드가 상당히 간단해 집니다.  

kthread_create()
kthread_run()
kthread_bind()
kthread_sop()
kthread_should_stop()
kthread_data() 

 자세한 내용은 커널 소스 트리와 linux/kthread.h 를 참조해 주십시요. 

2. kernel_thread
A. 소개 

  kernel_thread 는 잘 사용안하는 방법으로 생각됩니다. 커널 코드를 살펴보아도 5~6 군데에서만 사용하고 있습니다. 
  쓰레드 종료와 SMP 에 대해서는 크게 신경쓰고 있지 않는 것으로 보입니다.
  샘플 코드는 아래와 같습니다. 
  
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/completion.h>
#include <linux/delay.h>
#include <linux/kthread.h>

int flag=0;
struct task_struct *th_id;

static int kernel_thread_thr_wait(void *arg)
{
  int i = 0;
  char *text = (char *)arg;
  while(flag)
  {
    printk(KERN_ALERT "KERNEL_THREAD. %d [ %s ]\n", i, text);
    ++i;
    udelay(1000);
  }
  printk(KERN_ALERT "KERNEL_THREAD. Stoped\n");
 
return 0;


static void DONE(void)
{
  flag = 0;
}  


static int __init kernel_thread_init(void)
{
  flag = 1;
  th_id = (struct task_struct *)kernel_thread(kernel_thread_thr_wait, "TEST", CLONE_KERNEL);
  if(IS_ERR(th_id)){
    printk(KERN_ALERT "Fail to create the thread\n");
    return -1;
  }
  udelay(5000);
  DONE();
  로 udelay(5000);
 
return 0;


static void kernel_thread_release(void)
{
  printk(KERN_ALERT "Exit %s()\n", __FUNCTION__);


module_init(kernel_thread_init);
module_exit(kernel_thread_release);
MODULE_LICENSE("Dual BSD/GPL"); 

B. daemonize()
  kernel_thread() 로 생성된 쓰레드는 부모 쓰레드가 자식 쓰레드보다 먼저 죽게되면 자식 쓰레드는 좀비 쓰레드가 됩니다. 
  이런 일을 방지하기 위해서 daemonize() 를 호출하여 부모 쓰레드를 kthreadd 라는 커널 쓰레드로 바꿔주어서 자식 쓰레드가 죽을 때까지 기다릴 수 있게 만들어 줍니다. 

  사용방법은 커널 소스트리를 살펴봐 주세요. 

3. kthread
  대다수의 커널 쓰레드 들은 kthread 를 사용하여 구현되어 있습니다. (커널 소스 트리 검색)

  쓰레드 생성 api
   
kthread_create();
    kthread_run();


  쓰레드 정지 api
    kthread_stop();
    kthread_should_stop();


  그외 api
    kthread_bind();
    kthread_data();
    kthreadadd();
    kthread_worker();
    init_kthread_worker();
    init_kthread_work();
    kthread_worker_fn();
    queue_kthread_work();
    flush_kthread_work();
    flush_kthread_worker();

  많은 API 가 있지만 주로 사용하는 API 는 아래와 같습니다. 
    kthread_create();        : 쓰레드 생성
    kthread_run();            : 쓰레드 생성 + 잘생성되었는지 검사
    kthread_stop();           : 쓰레드 종료하라고 명령 내림
    kthread_should_stop(); : 쓰레드 종료 명령이 내려졌는지 검사함. 
    kthread_bind()            : 쓰레드가 사용할 cpu 지정.

4. kthread 예제
  kthread 에 대한 간단한 예제는 아래와 같습니다. 

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/completion.h>
#include <linux/delay.h>
#include <linux/kthread.h>

struct task_struct
 *g_th_id=NULL;

static int kthread_example_thr_fun(void *arg)
{
  printk(KERN_ALERT "@ %s() : called\n", __FUNCTION__);
  while(!kthread_should_stop())
  {
    printk(KERN_ALERT "@ %s() : loop\n", __FUNCTION__);
    ssleep(1); 

  }
  printk(KERN_ALERT "@ %s() : kthread_should_stop() called. Bye.\n", __FUNCTION__);
  return 0;


static int __init kthread_example_init(void)
{
  printk(KERN_ALERT "@ %s() : called\n", __FUNCTION__);
 
  if(g_th_id == NULL){ 

     g_th_id = (struct task_struct *)kthread_run(kthread_example_thr_fun, NULL, "kthread_example");
  }
 
return 0;


static void __exit kthread_example_release(void)
{
  if(g_th_id){
     kthread_stop(g_th_id);
     g_th_id = NULL;
  }
  printk(KERN_ALERT "@ %s() : Bye.\n", __FUNCTION__);

 

module_init(kthread_example_init);
module_exit(kthread_example_release);
MODULE_LICENSE("Dual BSD/GPL"); 

  위 코드를 살펴보면 g_th_id 을 자동관리해 주지 않는다는 것을 알 수 있습니다.
  항상 g_th_id 에 대한 관리를 확실히 해 주는 것이 중요할 것으로 예상됩니다.
 


 


  


'development' 카테고리의 다른 글

[kernel] 스핀락  (1) 2012.01.04
[program] Makefile  (0) 2012.01.04
[kernel] 커널 쓰레드  (0) 2012.01.04
[kernel] 시간지연  (1) 2012.01.02
[kernel] 커널 메모리 모델  (0) 2011.12.29
[etc] 빌드 시스템  (0) 2011.12.23
블로그 이미지

얼굴반반피곤님 김유석0

댓글을 달아 주세요

Table of Content
  1. Intro
  2. 쉬운 API
  3. 어려운  API
  4. 어려운 API 와 쉬운 API?
  5. CPU 소모성 API
  6. CPU 소모가 없는 API
  7. msleep()
  8. msleep_interruptible()
  9. ssleep()
  10. schedule_timeout_interrupt()
  11. schedule_timeout_uninterrupt() 
  12. schedule_timeout() 
  13. ndelay(), udelay(), mdelay()  


1. Intro
 커널에서 시간 지연 함수는 여러가지가 있습니다. 
 굳이 분류를 하자면 쉬운 API, 어려운 API, CPU 소모성 API, CPU 소모가 없는 API 정도로 나눌 수 있습니다. 

2. 쉬운 API
 쉬운 API는 크게 보면 아래와 같습니다. 
  #include <linux/delay.h>
  #include <linux/timer.h>

  msleep()
  ssleep()

 이 API들은 함수명대로 micro  second, milli second, 1 second 을 뜻합니다. 
 그냥 사용하시면 됩니다. 

3. 어려운 API
 어려운 API 는 크게 보면 아래와 같습니다. 

 
  #include <linux/delay.h>
   #include <linux/timer.h>
   
   msleep_interruptible()
   schedule_timeout_interruptible();
   schedule_timerout_uninterruptible();
   schedule_timeout();

 이것도 그냥 사용하면 됩니다.

4. 어려운 API 와 쉬운 API ?
  어려운 API 와 쉬운 API 의 차이점은 무엇일까요? 

  가장 기본이 되는 지연 함수는 schedule_timeout() 입니다. 
  관계를 살펴보면

      ssleep()
    -----------------------------------------
      msleep()

    -----------------------------------------
      schedule_timeout_interruptible(), schedule_timeout_uninterruptible
 
    -----------------------------------------
      schedule_timeout()

 입니다. 위에 그림만으로는 잘 설명이 안될 수도 있는데, 커널 소스를 살펴보면 관계를 확실히 확인 할 수 있습니다. 

  ssleep() 는 msleep() 를 호출합니다. 
  msleep() 는 schedule_timeout_uninterrupt() 를 호출합니다. 
  schedule_timeout_uninterrupt() 는 schedule_timeout() 을 호출합니다. 

 결국 최종으로 호출되는 것은 schedule_timeout() 인데 시간 지연이라는게 인터럽트를 허용할 수도, 아닐수도 있고 또한 사용상의 편의상 ssleep() 나 msleep() 같은 front-end 를 만들어 쓴다고 생각하면 됩니다. 

8. CPU 소모성 API
 지정한 지연시간까지 loop 를 돌면서 cpu 시간을 소모하는 형태의 API 입니다. 
 
 ndelay();
 udelay();
 mdelay();

 위와 같이 delay 라는 이름이 붙은 API 들이 CPU 소모성 API 이며 아래와 같이 구현할 경우에도 CPU 소모성 API 입니다. 
 
 while(time_before(jiffies, j1))
 {
   cpu_relax();
 }

9. CPU 소모가 없는 API
 CPU 점유가 없이 시간 지연을 구현하려면 현재 자기자신한테 할당된 프로세스 시간을 반납하고 대기하는 방식을 사용하면 됩니다. 

 schedule_timeout_interruptible()
 schedule_timeout_uninterruptible()

 등이 그런 계통입니다. 

7. msleep()
  header :
asm/delay.h
  void msleep(unsigned int msecs);
  unsigned long msleep_interruptible(unsigned int msecs);

 => 밀리세컨드 동안 지연해 줍니다. 지연시간동안에는 인터럽트를 받을 수 없습니다. 

example
 #include <asm/delay.h>

static void example_msleep(void)
{
  msleep(1000);


 
8. msleep_interruptible()
  header : 
asm/delay.h
  unsigned long msleep_interruptible(unsigned int msecs);

 => 밀리세컨드 동안 지연해 줍니다. 지연시간동안에는 인터럽트를 받을 수 있습니다. 

example)
 #include <asm/delay.h>

static void example_msleep(void)
{
  msleep_interruptible(1000);


 
9. ssleep()
  
  header : asm/delay.h
    void ssleep(unsigned int seconds);

 => 초단위로 지연해 줍니다. 지연시간동안에는 인터럽트를 받을 수 없습니다. 

example)
 #include <linux/sched.h>

static void example_ssleep(void)
{
  ssleep(2);



10. schedule_timeout_interruptible()

  
  header : linux/sched.h
    void schedule_timeout_interruptible(unsigned long timeout);

 => timeout 시간만큼 지연해 줍니다.  

example)
 #include <linux/sched.h>

static void example_ssleep(void)
{
  schedule_timeout_interruptible(1 * HZ); /* 1 초간 지연 */


11. schedule_timeout_uninterruptible()

  
  header : linux/sched.h
    void schedule_timeout_uninterruptible(unsigned long timeout);

 => timeout 시간만큼 지연해 줍니다. 지연시간도중에는 인터럽트를 받을 수 없습니다. 
  
  
example)
 #include <linux/sched.h>

static void example_ssleep(void)
{
  schedule_timeout_uninterruptible(1 * HZ); /* 1 초간 지연 */


 
12. schedule_timeout()

  
  header : linux/sched.h
    void schedule_timeout(unsigned long timeout);

 => timeout 시간만큼 지연해 줍니다. 가장 기본이 되는 함수입니다. 그렇기 때문에 직접 호출하여 사용하지는 않습니다. 

example)
 #include <linux/sched.h>

static void __sched schedule_timeout_interruptible(void long timeout)
{
  __set_current_state(TASK_INTERRUPTIBLE);
 
return schedule_timeout(timeout); 


13. ndelay, udelay, mdelay
   header : linux/delay.h
   #define ndelay(n);
   #define udelay(n); 
   #define mdelay(n);

  busy wait 방식이어서 cpu 로드가 많은 편입니다. 하지만 간단하게 쓸 수 있는 장점이 있습니다.

example)
#include <linux/delay.h>

void delay_test(void long timeout)
{
  ndelay(1000);
  udelay(1000);
  mdelay(1000); 
 


 

 
   

 

'development' 카테고리의 다른 글

[program] Makefile  (0) 2012.01.04
[kernel] 커널 쓰레드  (0) 2012.01.04
[kernel] 시간지연  (1) 2012.01.02
[kernel] 커널 메모리 모델  (0) 2011.12.29
[etc] 빌드 시스템  (0) 2011.12.23
[kernel] Thread 와 Kill  (0) 2011.11.26
블로그 이미지

얼굴반반피곤님 김유석0

댓글을 달아 주세요

  • application사용 2019.04.02 15:05  댓글주소  수정/삭제  댓글쓰기

    udelay함수를 application에서 사용하려고 하는데요. include해서 사용하니까 에러가 나던데요.
    사용 방법이 따로 있나요?

 리눅스 커널도 하나의 프로세스이므로 총 4GByte 의 Virtual memory 를 사용하게 됩니다.

 4GByte 의 메모리는 아래와 같이 크게 두 개로 나뉘게 되며 하위 3GByte 는 user space(application) 용이며 상위 1GByte 는 kernel space 로 구분합니다. 



 위와 같이 커널 영역은 Virtual memory 4GByte 영역중에서 하위 1GByte 영역에 위치하게 됩니다.(0xc0000000 ~ 0xffffffff)

 커널 영역의 상위 8Byte 는 아래와 같이 물리 메모리와 1:1 매핑되게 됩니다.


 커널 영역의 하위 128MByte 는 아래와 같이 특수 목적을 위해 커널에서 Reserved 하여 사용하게 됩니다.(물리 메모리와는 상관 없습니다.)


 그러므로 Virtual memory 중에서 커널 영역에서 사용할 수 있는 공간은 1GByte - 128MByte = 896MByte 입니다.  


 위에 설명한 모든 내용은 PAE(Physical Address Extension) 를 사용하지 않는 32Bit CPU 일 경우에 관한 내용입니다.
 64Bit CPU 를 사용하거나 PAE 를 사용하는 경우에는 메모리 매핑하는 방법이 약간 달라집니다.

리눅스메모리모델.pptx




'development' 카테고리의 다른 글

[kernel] 커널 쓰레드  (0) 2012.01.04
[kernel] 시간지연  (1) 2012.01.02
[kernel] 커널 메모리 모델  (0) 2011.12.29
[etc] 빌드 시스템  (0) 2011.12.23
[kernel] Thread 와 Kill  (0) 2011.11.26
[GCC] -S 옵션?  (0) 2011.11.18
블로그 이미지

얼굴반반피곤님 김유석0

댓글을 달아 주세요

커널에서 개발을 하다 보면 버퍼의 내용을 출력하여 확인하고 싶을 때가 있다. 

이 때는 print_hex_dump() 를 사용하면 된다.

void print_hex_dump(const char *level,
                           const char *prefix_str,
                           int prefix_type,
                           int rowsize,
                           int groupsize,
                           const void *buf,
                           size_t len,
                           bool ascii);


예를 들어 buf 가 아래와 같다면

  buf = "123456789abcdefghijklmnop";

  print_hex_dump(KERN_ALERT, "", DUMP_PREFIX_OFFSET, 16, 1, buf, strlen(buf), 0);

위와 같이 호출하면 아래와 같은 출력을 볼 수 있다.
 
   [70339.966181] 00000000: 31 32 33 34 35 36 37 38 39 61 62 63 64 65 66 67
   [70339.966480] 00000010: 68 69 6a 6b 6c 6d 6e 6f 70

아래와 같이 호출하면  

  buf = "123456789abcdefghijklmnop";

  print_hex_dump(KERN_ALERT, "", DUMP_PREFIX_OFFSET, 16, 1, buf, strlen(buf), 1);

  [70468.050260] 00000000: 31 32 33 34 35 36 37 38 39 61 62 63 64 65 66 67  123456789abcdefg
  [70468.050819] 00000010: 68 69 6a 6b 6c 6d 6e 6f 70                                    hijklmnop
 

아래와 같이 호출하면
   buf = "123456789abcdefghijklmnop";

  print_hex_dump(KERN_ALERT, "김무겸바보", DUMP_PREFIX_OFFSET, 16, 1, buf, strlen(buf), 1);

  [70553.053132] 김무겸바보00000000: 31 32 33 34 35 36 37 38 39 61 62 63 64 65 66 67  123456789abcdefg
  [70553.054274] 김무겸바보00000010: 68 69 6a 6b 6c 6d 6e 6f 70                                    hijklmnop
 

유용한 API 임.
 
블로그 이미지

얼굴반반피곤님 김유석0

댓글을 달아 주세요

completion(완료)는 kernel 동기화 기법중 하나입니다. 

API 는 아래와 같습니다.

#include <linux/completion.h>

DECLEAR_COMPLETION(struct completion comp);
init_completion(struct completion *comp);
void wailt_for_completion(struct completion *comp);
void complete(struct completion *comp);
void complete_all(struct completion *comp);

1. wait 을 걸때

#include <linux/module.h> 
#include <linux/completion.h>
#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/time.h>

struct completion comp;

static int wait(void)
{
  init_completion(&comp);
  wait_for_completion(&comp);


1. wait 을 풀때

#include <linux/module.h> 
#include <linux/completion.h>
#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/time.h>

struct completion comp;

static int un_wait(void)
{
  complete(&comp);



풀 동작하는 샘플 코드는 아래와 같이 첨부 파일을 참조 바랍니다.

completion.c

Makefile

 
블로그 이미지

얼굴반반피곤님 김유석0

댓글을 달아 주세요

리눅스 커널의 이해(Understanding Linux Kenel 3rd Edition) 의 전자북 버전입니다. 

 
무료배포버전이니 편하게 사용하십시요.  
블로그 이미지

얼굴반반피곤님 김유석0

댓글을 달아 주세요

 scatterlist 관련한 코드의 예시를 살펴보기 위해 커널 소스를 뒤져 보았는데 생각외로 광범위하게 사용되고 있어서 조금 놀랐다. 

 scatterlist 에 대해 알아보기 시작한 것이 crypto 쪽 작업 때문이었는데 crypto 뿐 아니라 filesystem, video driver, frame buffer 등등 분야를 가리지 않고 광범위하게 사용되고 있음을 확인 할 수 있었다. 

 그도 그럴것이 scatterlist 라는 것이 DMA 를 위한 것이니 DMA 를 사용하는 것에서는 모두 사용이 되고 있는 것이 당연할 것이다.

 무엇보다 scatterlist 의 가장 간단한 example 를 찾기 위해 구글을 뒤졌는데 아래와 같은 소스가 보기 쉽다는 답변을 확인 하였다.

 security/seclvl.c
 linux/fs/ecryptfs/ : eCryptfs file system 
 linux/drivers/staging/rtl8187se/ieee80211 : 802.11 wireless stack 

이중에서 가장 쉬운 코드가  security/seclvl.c 라는 설명이 있었는데 아쉽게도 kernel-2.6.18 이후론 없어진 것 같다. 
그래도 참조용으로 코드를 아래 정리해 보았다.
 

static int
plaintext_to_sha1(unsigned char *hash, const char *plaintext, unsigned int len)
{
  struct crypto_tfm *tfm;
  struct scatterlist sg;
  if (len > PAGE_SIZE) {
    seclvl_printk(0, KERN_ERR, "Plaintext password too large (%d "
            "characters).  Largest possible is %lu "
            "bytes.\n", len, PAGE_SIZE);
    return -EINVAL;
  }
  tfm = crypto_alloc_tfm("sha1", CRYPTO_TFM_REQ_MAY_SLEEP);
  if (tfm == NULL) {
    seclvl_printk(0, KERN_ERR,
            "Failed to load transform for SHA1\n");
    return -EINVAL;
  }
  sg_init_one(&sg, (u8 *)plaintext, len);
  crypto_digest_init(tfm);
  crypto_digest_update(tfm, &sg, 1);
  crypto_digest_final(tfm, hash);
  crypto_free_tfm(tfm);
  return 0; 
} 



아래 코드도 참조용으로 유용한 것으로 생각된다. (출처 : http://stackoverflow.com/questions/3869028/how-to-use-cryptoapi-in-the-linux-kernel-2-6)

struct crypto_hash *tfm = crypto_alloc_hash("sha1", 0, CRYPTO_ALG_ASYNC);
if (tfm == NULL)
    fail;
char *output_buf = kmalloc(crypto_hash_digestsize(tfm), GFP_KERNEL);
if (output_buf == NULL)
    fail;
struct scatterlist sg[2];
struct hash_desc desc = {.tfm = tfm};
ret = crypto_hash_init(&desc);
if (ret != 0)
    fail;
sg_init_table(sg, ARRAY_SIZE(sg));
sg_set_buf(&sg[0], "Hello", 5);
sg_set_buf(&sg[1], " World", 6);
ret = crypto_hash_digest(&desc, sg, 11, output_buf);
if (ret != 0)
    fail;

 
  참고로 scatterlist example 은 아니지만 암호화 테스트용 샘플 코드로써 암호화 API 를 사용하는 법을 쉽게 볼 수 있는 코드도 있다. 

  crypto/tcrypt.c


 
블로그 이미지

얼굴반반피곤님 김유석0

댓글을 달아 주세요