Kernel API 1 - Core(2/2) #

1 Kernel API 1 - Core(2/2)

1.1 인터럽트

1.1.1 HARD IRQ

1.1.1.1 자료 구조

1.1.1.2 request_irq

1.1.1.3 free_irq

1.1.1.4 enable_irq

1.1.1.5 disable_irq

1.1.1.6 local_irq_enable

1.1.1.7 local_irq_save

1.1.1.8 local_irq_disable

1.1.1.9 local_save_flags

1.1.1.10 local_irq_restore

1.1.2 SOFT IRQ

1.1.2.1 softirq

1.1.2.2 tasklet

1.1.3 bottom-half

1.2 동기화

1.2.1 Kernel-synchronization

1.2.2 스핀락 (spinlock)

1.2.2.1 spinlock_t

1.2.2.2 SPIN_LOCK_UNLOCKED

1.2.2.3 spin_lock_init

1.2.2.4 spin_lock/spin_unlock

1.2.2.5 spin_lock_irqsave/spin_unlock_irqrestore

1.2.2.6 spin_lock_irq/spin_unlock_irq

1.2.2.7 spin_lock/unlock_bh

1.2.2.8 spin_trylock

1.2.2.9 spin_trylock_bh

1.2.3 rwlock

1.2.3.1 RW_LOCK_UNLOCKED

1.2.3.2 rwlock_init

1.2.3.3 write_lock/write_unlock

1.2.3.4 read_lock/read_unlock

1.2.3.5 read_trylock

1.2.3.6 read_lock_irq/read_unlock_irq

1.2.3.7 write_lock_irq/write_unlok_irq

1.2.3.8 read_lock_irqsave/read_unlock_irqrestore

1.2.3.9 write_lock_irqsave/write_unlock_irqretore

1.2.4 seqlock

1.2.4.1 SEQLOCK_UNLOCKED

1.2.4.2 seqlock_init

1.2.4.3 write_seqlock/write_sequnlock

1.2.4.4 write_tryseqlock

1.2.4.5 read_seqbegin

1.2.4.6 read_seqretry

1.2.5 세마포어(semaphore)

1.2.5.1 세마포어

1.2.5.1.1 down/down_interruptible

1.2.5.1.2 down_trylock

1.2.5.1.3 up

1.2.5.2 이진 세마포어(MUTEX)

1.2.5.2.1 DECLARE_MUTEX

1.2.5.2.2 DECLARE_MUTEX_LOCKED

1.2.5.2.3 init_MUTEX

1.2.5.2.4 init_MUTEX_LOCKED

1.2.5.2.5 down/down_interruptible

1.2.5.2.6 down_trylock

1.2.5.2.7 up

1.2.5.3 rw_semaphore

1.2.5.3.1 init_rwsem

1.2.5.3.2 down_read (down_write)

1.2.5.3.3 up_read (up_write)

1.2.6 뮤텍스(mutext)

1.2.6.1 mutex_init

1.2.6.2 mutex_is_locked

1.2.6.3 mutex_lock

1.2.6.4 mutex_lock_interruptible

1.2.6.5 mutex_trylock

1.2.6.6 mutex_unlock

1.2.7 completion

1.2.7.1 completion 초기화

1.2.7.2 wait_for_completion

1.2.7.3 complete

1.3 비동기

1.3.1 커널 쓰레드

1.3.2 workqueue

1.3.3 시그널

1.3.3.1 signal_pending

1.4 Block/Non-Block

1.4.1 waitqueue

1.4.1.1 DECLARE_WAIT_QUEUE_HEAD

1.4.1.2 init_waitqueue_head

1.4.1.3 wait_event

1.4.1.4 wait_event_timeout

1.4.1.5 wait_event_interruptible

1.4.1.6 wait_event_interruptible_timeout

1.4.1.7 wake_up

1.4.1.8 wake_up_interruptible

1.4.2 async

1.4.2.1 async_helper

1.4.2.2 kill_fasync

1.4.2.3 poll_wait

1.5 IDR

1.5.1 DEFINE_IDR

1.5.2 idr_init

1.5.3 idr_find

1.5.4 idr_pre_get

1.5.5 idr_get_new

1.5.6 idr_remove

1.6 연결 리스트 (Linked List)

1.6.1 연결 리스트의 구조

1.6.2 연결 리스트 API

1.6.2.1 연결 리스트 초기화

1.6.2.1.1 LIST_HEAD_INIT

1.6.2.1.2 LIST_HEAD

1.6.2.1.3 INIT_LIST_HEAD

1.6.2.2 연결 리스트 처리

1.6.2.2.1 list_add_tail

1.6.2.2.2 list_del

1.6.2.2.3 list_empty

1.6.2.2.4 list_entry

1.6.2.2.5 list_for_each

1.6.2.2.6 list_for_each_entry

1.7 모듈

1.7.1 모듈 등록/해제 처리

1.7.1.1 module_init/module_exit

1.7.1.2 devexit_p/exit_p

1.7.2 모듈 파라미터

1.7.2.1 moudle_param

1.7.2.2 MODULE_PARAM_DESC

1.7.3 모듈 심볼

1.7.3.1 symbol_get/put

1.7.4 모듈 참조 카운터

1.7.4.1 try_module_get

1.7.4.2 module_put

1.7.5 THIS_MODULE

1.7.6 모듈 동작 메카니즘

1.8 심볼

1.8.1 EXPORT_SYMBOL

1.8.2 EXPORT_SYMBOL_GPL

1.8.3 EXPORT_NO_SYMBOLS

1.9 블록 디바이스 드라이버

1.9.1 alloc_disk

1.9.2 add_disk

1.9.3 del_disk

1.10 네트워크 드라이버

int request_irq(unsigned int irq,
                irqreturn_t (*handler)(int, void *, struct pt_regs *),
                unsigned long irq_flags, const char *devname, void *dev_id);

void free_irq(unsigned int irq, void *dev_id)

void enable_irq(unsigned int irq)

void disable_irq(unsigned int irq)

void local_irq_enable(void)

void local_irq_save(unsigned long flags)

void local_irq_disable(void)

void local_save_flags(unsigned long flags)

unsigned long flags;
local_save_flags(flags);
local_irq_disable();
 ...
local_irq_restore(flags);

void local_irq_restore(unsigned long flags)

spinlock_t xxx_lock = SPIN_LOCK_UNLOCKED;

void spin_lock_init(spinlock_t *lock);

void spin_lock(spinlock_t *lock);

void spin_unlock(spinlock_t *lock);

void spin_lock_irqsave(spinlock_t *lock, unsigned long flags);

void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags);

unsigned long flags;

spin_lock_irqsave(&foo_lock, flags);

// critical jobs

spin_unlock_irqrestore(&foo_lock, flags);

void spin_lock_irq(spinlock_t *lock);

void spin_unlock_irq(spinlock_t *lock);

void spin_lock_bh(spinlock_t *lock);

void spin_unlock_bh(spinlock_t *lock);

int spin_trylock(spinlock_t *lock);

int spin_trylock_bh(spinlock_t *lock);

void init_rwsem(struct rw_semaphore *sem);

inline void down_read(struct rw_sempahore *sem);

inline void down_write(struct rw_semaphore *sem);

inline void up_read(struct rw_semaphore *sem);

inline void up_write(struct rw_semaphore *sem);

mutex_init(struct mutex *lock);

int mutex_is_locked(struct mutex *lock);

struct completion {
  unsigned int done;
  wait_queue_head_t wait;
};

DELCARE_COMPLETION(xxx_completion);

void init_completion(struct completion *x);

static void __init xxx_init(void)
{
  struct completion xxx_com;
  ...

  init_completion(&xxx_com);
  ...
}

void wait_for_completion(struct completion *x);
void wait_for_completion_interruptible(struct completion *x);
void wait_for_completion_timeout(struct completion *x, unsigned long timeout);
void wait_for_completion_interruptible_tiemout(struct completion *x,
                                               unsigned long timeout);

void complete(struct completion *x);
void complete_all(struct completion *x);

pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);

typedef struct siginfo {
  int si_signo;
  int si_errno;
  int si_code;

  union {
    ...
  } _sifields;
} siginfo_t;

#define si_pid   _sifields._kill._pid
...
#define si_int   _sifields._rt._sigval.sival_int
...

kill_proc(cpid, SIGINT, 1);

struct siginfo info;

info.si_signo = SIGUSR2;
info.si_errno = 0;
info.si_code = SI_QUEUE;
info.si_int = flags;

if (send_sig_info(SIGUSR2, &info, p))
  send_sig_info(SIGINT, (struct siginfo *)1, p);

inline int signal_pending(struct task_struct *p)

wait_event(wait_queue_head wq, condition);

signed long wait_event_timeout(wait_queue_head_t wq, condition,
                               signed long timeout);

int wait_event_interruptbile(wait_queue_head_t wq, condition);

signed int wait_event_interruptible_timeout(wait_queue_head_t wq, condition,
                                            signed long timeout);

wake_up(wait_queue_head_t *wq);

wake_up_interruptible(wait_queue_head_t *wq);

DEFINE_IDR(name)

void idr_init(struct idr *idp);

void *idr_find(struct idr *idp, int id);

int idr_pre_get(struct idr *idp, gfp_t gfp_mask);

int err;

if (!idr_pre_get(&mmc_host_idr, GFP_KERNEL))
  return -ENOMEM;

spin_lock(&mmc_host_lock);
err = idr_get_new(&mmc_host_idr, host, &host->index);
spin_unlock(&mmc_host_lock);

int idr_get_new(struct idr, *idp, void *ptr, int *id);

int err;

if (!idr_pre_get(&mmc_host_idr, GFP_KERNEL))
  return -ENOMEM;

spin_lock(&mmc_host_lock);
err = idr_get_new(&mmc_host_idr, host, &host->index);
spin_unlock(&mmc_host_lock);

void idr_remove(struct idr *idp, int id);

spin_lock(&mmc_host_lock);
idr_remove(&mmc_hsot_idr, host->index);
spin_unlock(&mmc_host_lock);

LIST_HEAD_INIT(name);

LIST_HEAD(name);

INIT_LIST_HEAD(struct list_head *ptr);

void list_add(struct list_head *new, struct list_head *head);

void list_del(struct list_head *entry);

int list_empty(const struct list_head *head);

list_entry(ptr, type, member);

struct list_head *p;
loff_t l = *pos;
...
list_for_each(p, &block_subsys.kset.list)
  if (!l--)
    return list_entry(p, struct gendisk, kobj.entry);
...

list_for_each(pos, head);

list_for_each_entry(pos, head, member)

list_for_each_entry(dev, &bus->devices, bus_list) {
  if (!list_entry(&dev->global_list))
    continue;
  pci_bus_add_device(dev);
}

static int __init xxx_init(void)
{
  ...
}

static void __exit xxx_exit(void)
{
  ...
}

module_init(xxx_init);
module_exit(xxx_exit);

module_param(name, type, perm)

MODULE_PARAM_DESC(name, const char * desc)

static int nrpacks = USX2Y_NRPACKS;

module_param(nrpacks, int , 0444);
MODULE_PRAM_DESC(nrpacks, "Number of packets per URB.");

void *symbol_get(const char *symbol);
void symbol_put(void char *symbol);

/* get the symbol */
int (*del_bus)(struct i2c_adapter *) = symbol_get(i2c_bit_del_bus);

/* put the symbol */
symbol_put(i2c_bit_del_bus);

int try_module_get(struct module *module)

void module_put(struct module *module)

enum module_state
{
   MODULE_STATE_LIVE,
   MODULE_STATE_COMING,
   MODULE_STATE_GOING,
};

EXPORT_SYMBOL(foobar);

EXPORT_NO_SYMBOLS;

struct gendisk {
        int major;                      /* major number of driver */
        int first_minor;
        int minors;                     /* maximum number of minors, =1 for
                                         * disks that can't be partitioned. */
        char disk_name[32];             /* name of major driver */
        struct hd_struct **part;        /* [indexed by minor] */
        struct block_device_operations *fops;
        struct request_queue *queue;
        void *private_data;
        sector_t capacity;

        int flags;
        char devfs_name[64];            /* devfs crap */
        int number;                     /* more of the same */
        struct device *driverfs_dev;
        struct kobject kobj;
        ...
};

struct gendisk *alloc_disk(int minors);

void add_disk(struct gendisk *disk);

void del_gendisk(struct gendisk *disk);