☰
×
◈ Introductions
◈ Linux Kernel Compilation
◈ Linux Kernel Debugging
◈ Linux Kernel APIs - I
◈ Linux Kernel APIS - II
◈ Linux Kernel APIS - III
◈ KGDB Setup
◈ QEMU Setup
◈ Linux System Calls Table
◈ Useful Linux Commands
Home
About
Consulting
Training
Tutorials
Interview Questions
Contact
Tutorials
Linux Kernel APIs
Home
Linux Kernel APIs
◈ Introductions
◈ Linux Kernel Compilation
◈ Linux Kernel Debugging
◈ Linux Kernel APIs - I
◈ Linux Kernel APIS - II
◈ Linux Kernel APIS - III
◈ KGDB Setup
◈ QEMU Setup
◈ Linux System Calls Table
◈ Useful Linux Commands
Tutorials - Linux Kernel Function
Kernel APIs - II
« Prev
Next »
Linux Kernel APIs
☛ I/O Port Access from User Space
☛ I/O Memory Allocation
☛ Linux Kernel Semaphores & Spinlocks
☛ The linux ioctl() mechanism
☛ Process Sleeping / Waitqueues
6. I/O Port Access from User Space: #include
int ioperm(unsigned long from, unsigned long num, int turn_on); e.g: ioperm(0x378,3,0x644); Upto 1k ports int iopl(int level); e.g: iopl(3); /* 0 least privilege, 3 most privileged */ /* from 1 to 64k ports */ 7. I/O Memory Allocation: #include
struct resource *request_mem_region(unsigned long start, unsigned long len, char *name); void release_mem_region(unsigned long start, unsigned long len); #include
void *ioremap(unsigned long physical_address, unsigned long size); void iounmap(void *address); unsigned int ioread8(void *addr); unsigned int ioread16(void *addr); unsigned int ioread32(void *addr); void iowrite8(u8 value, void *addr); void iowrite16(u16 value, void *addr); void iowrite32(u32 value, void *addr); void memset_io(void *addr, u8 value, unsigned int count); void memcpy_fromio(void *dest, void *src, unsigned int count); void memcpy_toio(void *dest, void *src, unsigned int count); Important methods inside struct file_operations : int (*open) (struct inode *, struct file *); int (*release) (struct inode *, struct file *); ssize_t (*read) (struct file *, char __user *, size_t, loff_t *); ssize_t (*write)(struct file *,const char __user *,size_t,loff_t *); struct module *owner; int (*ioctl)(struct inode *,struct file *,unsigned int, unsigned long); int (*mmap) (struct file *, struct vm_area_struct *); struct file { ... struct file_operations *f_op; atomic_t f_count; unsigned int f_flags; mode_t f_mode; loff_t f_pos; struct fown_struct f_owner; unsigned int f_uid, f_gid; ... void *private_data; ... }; struct inode { ... dev_t i_rdev; /* unsigned int iminor(struct inode *inode); ... }; 8. Linux Kernel Semaphores & Spinlocks : #include
struct semaphore sem; void sema_init(struct semaphore *sem, int val); void down(struct semaphore *sem); int down_interruptible(struct semaphore *sem); int down_trylock(struct semaphore *sem); void up(struct semaphore *sem); Reader-Writer Semaphores : #include
struct rw_semaphore rwsem; void init_rwsem(struct rw_semaphore *sem); void down_read(struct rw_semaphore *sem); int down_read_trylock(struct rw_semaphore *sem); void up_read(struct rw_semaphore *sem); void down_write(struct rw_semaphore *sem); int down_write_trylock(struct rw_semaphore *sem); void up_write(struct rw_semaphore *sem); void downgrade_write(struct rw_semaphore *sem); Spinlocks: #include
spinlock_t 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); /* This disables interrupts on the local processor only */ void spin_lock_irq(spinlock_t *lock); void spin_lock_bh(spinlock_t *lock); /* This disables software interrupts, but enables hw ints */ void spin_unlock_irqrestore(spinlock_t *lock,unsigned long flags); void spin_unlock_irq(spinlock_t *lock); void spin_unlock_bh(spinlock_t *lock); int spin_trylock(spinlock_t *lock); int spin_trylock_bh(spinlock_t *lock); /* Returns nonzero on success, 0 otherwise */ Reader/Writer Spinlocks: #include
rwlock_t lock = RW_LOCK_UNLOCKED; /* Static initialization */ rwlock_t lock; rwlock_init(&lock) /* Dynamic Initialization */ void read_lock(rwlock_t *lock); void read_lock_irqsave(rwlock_t *lock, unsigned long flags); void read_lock_irq(rwlock_t *lock); void read_lock_bh(rwlock_t *lock); void read_unlock(rwlock_t *lock); void read_unlock_irqrestore(rwlock_t *lock, unsigneed long flags); void read_unlock_irq(rwlock_t *lock); void read_unlock_bh(rwlock_t *lock); void write_lock(rwlock_t *lock); void write_lock_irqsave(rwlock_t *lock, unsigned long flags); void write_lock_irq(rwlock_t *lock); write_lock_bh(rwlock_t *lock); int write_trylock(rwlock_t *lock); void write_unlock(rwlock_t *lock); void write_unlock_irqrestore(rwlock-T *lock, unsigned long flags); void write_unlock_irq(rwlock_t *lock); void write_unlock_bh(rwlock_t *lock); 9. The linux ioctl() mechanism : In userspace: #include
int ioctl(int fd, int cmd, ...); In driver: int (*ioctl)(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg); #include
Encoding macros: _IO(type,number); _IOR(type,nr,datatype); _IOW(type,nr,datatype); _IOWR(type,nr,datatype); Decoding macros: _IOC_DIR(nr); _IOC_TYPE(nr); _IOC_NR(nr); _IOC_SIZE(nr); 10. Process Sleeping / Waitqueues : #include
DECLARE_WAIT_QUEUE_HEAD(name); wait_queue_head_t queue; init_waitqueue_head(&queue); wait_event(queue,condition); wait_event_interruptible(queue,condition); wait_event_timeout(queue,condition,timeout); wait_event_interruptible_timeout(queue,condition,timeout); void wake_up(wait_queue_head_t *queue); void wake_up_interruptible(wait_queue_head_t *queue);
« Prev
Next »
Helpful Links
Interview Questions
Corporate Training
Recommended Books
Linux Consulting
Apply for Job Assistance
If you have any queries please email us at
info@motionzen.com