FAME Operatinf Systems - Modules

Transcription

1 FAME Operatinf Systems - Modules 2012 David Picard Contributions: Arnaud Revel, Mickaël Maillard picard@ensea.fr

2 Introduction Linux is not a monolithic pile of code anymore Possibility to add/remove functionalities (code) dynamically Avoid bloated kernel at runtime No need to compile the kernel each time you want to add or remove functionalities Not even necessary to reboot the OS Modules are used to provide device drivers Or also to provide functionalities that need access to supervisor rights

3 Kernel sources To compile a module, the sources are needed (usually in /usr/src/linux). -- 3rdparty -- Documentation -- arch -- block -- crypto -- drivers -- fs -- include -- init -- ipc -- kernel -- lib -- mm -- net -- scripts -- security -- sound -- usr

4 Compilation Heavy use of Makefile obj-m := mon_mondule_a_moi.o module objs := mon_mondule_a_moi.o KERNEL_SOURCE = /usr/src/linux $(shell uname -r) all : make C $ (KERNEL_SOURCE) M=$(PWD) modules clean : make C $ (KERNEL_SOURCE) M=$(PWD) clean install : make C $ (KERNEL_SOURCE) M=$(PWD) modules install

5 Modules management insmod: load a module directly into the running kernel without dependancy checking (insert) modprobe: load a module with dependancy checking rmmod: unload the module (remove) lsmod: list loaded modules modinfo: print information on module (loaded or not)

6 Simplest example #include <linux/module.h> #include <linux/kernel.h> / Pour KERN INFO / MODULE_DESCRIPTION( Hello World module ); MODULE_AUTHOR( Pierre Ficheux, Open Wide ); MODULE_LICENSE( GPL ); static int init hello_init( void ) { printk(kern_info Hello World\n ); return 0; } static void exit hello_exit(void) { printk(kern_info Goodbye, cruel world!\n ); } module_init(hello_init); module_exit(hello_exit);

7 Module parameters Declaration of parameters using macros: Usage: module_param(var,type, rights) module_param_array(var, type, addr, rights) module_param_string(name_in_modinfo, var, taille, rights) int myint = 3; module_param(myint, int, 0); Loading: modprobe monmodule myint=2

8 procfs procfs (process file system) is a pseudo filesystem (not on real hdd) mounted on /proc useful to access to information on the running kernel No corresponding file on any block device Ex: info on processes ( /proc/[0-9]+/) Debugging,...

9 Adding a procfs entry struct proc_dir_entry* create_proc_entry(const char* name, mode_t mode, struct proc_dir_entry* parent); name: name of the file Mode: permission rights parent: parent entry in procfs (NULL if root) Returns a structure representing the entry in the procfs Support for complex paths ( /proc/some/complex/path )

10 Remove void remove_proc_entry(const char* name, struct proc_dir_entry* parent); name: name of file parent: parent entry in procfs Support for complex paths ( /proc/some/complex/path )

11 Communication struct proc_dir_entry* entry; entry->read_proc = read_func; entry->write_proc = write_func; entry is the structure return by the create() call read_proc() is the function used by a read() call on the file of the procfs (careful: reverse point of view) write_proc is the function used by a write() call on the file of the procfs (careful: reverse point of view)

12 read int read_func(char* page, char** start, off_t off, int count, int* eof, void* data); page: address to fill (destination buffer) off: starting offset count: max number of byte to write eof: 1 if count > than available data start:??? data: up to the module developper

13 Read example char* message = read() call ; static int read_func (char page, char start, off_t off, int count, int eof, void data ) { int len = 0; len += sprintf ( page + len, %s\n, message ) ; return len ; }

14 write int write_func(struct file* file, const char* buffer, unsigned long count, void* data); count: max number of byte to read from the buffer file:??? data: up to module developpers

15 Write example static int write_func (struct file file, const char buffer, unsigned long count, void data ) { int len = count; if(copy_from_user(message, buffer, count)) { return EFAULT; } message[count] = 0; printk(kern_info Modification in message : %s\n, message); } return len;

16 Device entry Device entry: interaction with a device through a file Creation: # mknod /dev/name_of_device_file c major minor major: number defining the class of device hdd, usb, pci... minor: specific instance o the device (model, manufacturer) Different manufacturers Same driver

17 Types 3 block First MFM, RLL and IDE hard disk/cd-rom interface 0 = /dev/hda Master: whole disk (or CD-ROM) 64 = /dev/hdb Slave: whole disk (or CD-ROM) For partitions, add to the whole disk device number: 0 = /dev/hd? Whole disk 1 = /dev/hd?1 First partition 2 = /dev/hd?2 Second partition = /dev/hd?63 63rd partition For Linux/i386, partitions 1-4 are the primary partitions, and 5 and above are logical partitions. Other versions of Linux use partitioning schemes appropriate to their respective architectures. 4 char TTY devices 0 = /dev/tty0 Current virtual console 1 = /dev/tty1 First virtual console = /dev/tty63 63rd virtual console 64 = /dev/ttys0 First UART serial port = /dev/ttys nd UART serial port UART serial ports refer to 8250/16450/16550 series devices.

18 Drivers: implement related ops struct file_operations { struct module *owner; loff_t (*llseek) (struct file *, loff_t, int); ssize_t (*read) (struct file *, char user *, size_t, loff_t *); ssize_t (*write) (struct file *, const char user *, size_t, loff_t *); ssize_t (*aio_read) (struct kiocb *, const struct iovec *, ulong, loff_t); ssize_t (*aio_write) (struct kiocb *, const struct iovec *, ulong, loff_t); int (*readdir) (struct file *, void *, filldir_t); uint (*poll) (struct file *, struct poll_table_struct *); int (*ioctl) (struct inode *, struct file *, uint, ulong); long (*unlocked_ioctl) (struct file *, uint, ulong); long (*compat_ioctl) (struct file *, uint, ulong); int (*mmap) (struct file *, struct vm_area_struct *); int (*open) (struct inode *, struct file *); int (*flush) (struct file *, fl_owner_t id); int (*release) (struct inode *, struct file *); int (*fsync) (struct file *, struct dentry *, int datasync); int (*aio_fsync) (struct kiocb *, int datasync); int (*fasync) (int, struct file *, int); int (*lock) (struct file *, int, struct file_lock *); ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *); ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int); ulong (*get_unmapped_area)(struct file *, ulong, ulong, ulong, ulong); int (*check_flags)(int); int (*dir_notify)(struct file *filp, ulong arg); int (*flock) (struct file *, int, struct file_lock *); ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, uint); ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, uint); };

19 Operations? No need to redefine all operations Open: initialize some device related resources Release: free these resources read/write: exchange data with user space static struct file_operations mon_driver_fops = {.owner =.read =.write =.open = THIS_MODULE, my_driver_read, my_driver_write, my_driver_open,.release = my_driver_release, };

20 #include <linux/kernel.h> /* printk() */ #include <linux/module.h> /* modules */ #include <linux/fs.h> /* file_operations */ MODULE_DESCRIPTION("mydriver1"); MODULE_AUTHOR("Stelian Pop/Pierre Ficheux, Open Wide"); MODULE_LICENSE("GPL"); /* Arguments */ static int major = 0; /* Major number */ module_param(major, int, 0644); MODULE_PARM_DESC(major, "Static major number (none = dynamic)"); /* File operations */ static ssize_t mydriver1_read(struct file *file, char *buf, size_t count, loff_t *ppos) { printk(kern_info "mydriver1: read()\n"); return count; } static ssize_t mydriver1_write(struct file *file, const char *buf, size_t count, loff_t *ppos) { printk(kern_info "mydriver1: write()\n"); return count; } static int mydriver1_open(struct inode *inode, struct file *file) { printk(kern_info "mydriver1: open()\n"); return 0; } static int mydriver1_release(struct inode *inode, struct file *file) { printk(kern_info "mydriver1: release()\n"); return 0; }

21 static struct file_operations mydriver1_fops = {.owner = THIS_MODULE,.read = mydriver1_read,.write = mydriver1_write,.open = mydriver1_open,.release = mydriver1_release, }; /* Init and Exit */ static int init mydriver1_init(void) { int ret; ret = register_chrdev(major, "mydriver1", &mydriver1_fops); if (ret < 0) { printk(kern_warning "mydriver1: unable to get a major\n"); return ret; } if (major == 0) major = ret; /* dynamic value */ printk(kern_info "mydriver1: successfully loaded with major %d\n", major); return 0; } static void exit mydriver1_exit(void) { if (unregister_chrdev(major, "mydriver1") < 0) { printk(kern_warning "mydriver1: error while unregistering\n"); return; } printk(kern_info "mydriver1: successfully unloaded\n"); } /* Module entry points */ module_init(mydriver1_init); module_exit(mydriver1_exit);

22 I/O Ports Each device has a range of addresses on some I/O bus Theses addresses are called I/O ports The kernel has special routines to read or write to these addresses Some addresses can be reserved such that the module has exclusive access to them

23 How to int inb(int read_addr) Read on byte from the I/O port read_addr void outb(int write_addr, char value) Write one byte to the I/O port write_addr One routine per type of data (b for byte, w for 16bits, l for 32bits)

24 Example (from LDD3) ÉCOLE NATIONALE SUPÉRIEURE DE L'ÉLECTRONIQUE ET DE SES APPLICATIONS

25 Example /* default is the first printer port on PC's */ static unsigned long base = 0x378; /* Version-specific methods for the fops structure. */ ssize_t short_write(struct file *filp, const char user *buf, size_t count, loff_t *f_pos) { int retval = count; unsigned char *kbuf = kmalloc(count, GFP_KERNEL), *ptr; if (!kbuf) return -ENOMEM; if (copy_from_user(kbuf, buf, count)) return -EFAULT; ptr = kbuf; } while (count--) { outb(*(ptr++), base); wmb(); } return retval; struct file_operations short_fops = {.owner = THIS_MODULE,.write = short_write, };

26 I/O memory Modern devices have addressable memory zones. Control registers (similar to I/O ports) Data storage (video texture, network packets,...) The kernel offers to map these zone into the main memory This mapping is called I/O memory

27 Usage Mapping: struct resource *request_mem_region(unsigned long start, unsigned long len, char *name); Unmapping : Test: void release_mem_region(unsigned long start, unsigned long len); int check_mem_region(unsigned long start, unsigned long len); Remapping : void *ioremap(unsigned long phys_addr, unsigned long size); The returned pointer points towards the devices memory Can not use this pointer as any other pointer (because of instruction reordering)!

28 Communication with I/O memory Read: Write: Loop: 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 ioread8_rep(void *addr, void *buf, unsigned long count);...

29 Interrupts int request_irq(unsigned int irq, void (*gest)(int, void *, struct pt_regs *), unsigned long drap_interrupt, const char *devname, void *dev_id) Associate an interrupt number (irq) with a handler function gest who handles the interruption for device devname identified by dev_id The handler returns: IRQ_HANDLED if handled correctly IRQ_NONE Deregister the handler with void free_irq(unsigned int irq, void *dev_id)

30 Timer void fastcall init_timer(struct timer_list * timer): creation of a programmable timer timer_list structure with field function called each time the time quantum is reached and data defines the parameters to transmit to the function int mod_timer(struct timer_list * timer, unsigned long expires): activate timer at the specified time in number of tick starting from kernel boot If you want to activate launch the function in 100 ticks, expires is jiffies+100 For periodical timers, need to reactivate at each use (like for signals)

31 Example #include <linux/timer.h> #define INTERVALLE 100 static struct timer_list timer; static void mytimer(unsigned long data) {... /* periodical timer */ mod_timer(&timer,jiffies+100);... } static int init module_init(void) {... init_timer(&timer); timer.function = mytimer; timer.data = 0; mod_timer(&timer, jiffies + INTERVALLE); }

32 Mutex Critical resources inside the kernel: up to the modules to limit access DECLARE_MUTEX(sem) Declare a mutex mutex_lock(&sem) Acquire the mutex mutex_unlock(&sem) Free the mutex

33 Management of longer interrupts Sometimes the processing of an interrupt can be heavy The kernel has to stay the least possible in an interrupt (because it blocks the system) Two step procedure: Step top-half: rapidly returns from interrupt but adds the processing to a tasklet list (low latency) or a workqueue Step bottom-half: asynchronous management of the processing by the tasklet or the workqueue

34 Tasklets Tasklets are called only in interrupts Creating a tasklet is demanding the kernel to execute an atomic task later (asynchronous) When it is possible (low load) Never beyond one tick

35 Tasklets DECLARE_TASKLET(name, func, data) Declares tasklet with name name, associated with function func with parameters data tasklet_schedule(&name) Ask the kernel to schedule the tasklet tasklet_hi_schedule(&name) Scheduling with high priority (for audio buffer for example) DECLARE_TASKLET_DISABLED(), tasklet_disable(), tasklet_disable_nosync() Deactivate a tasklet tasklet_enable() Reactivate a tasklet tasklet_kill() Delete a tasklet

36 Example #include <linux/interrupt.h> void tasklet_function(unsigned long); char tasklet_data[64]; DECLARE_TASKLET(test_tasklet, tasklet_function, (unsigned long) &tasklet_data); void tasklet_function(unsigned long data) { struct timeval now; do_gettimeofday(&now); printk("%s at %ld,%ld\n", (char *) data, now.tv_sec, now.tv_usec); } int init_module(void) { sprintf(tasklet_data,"%s\n", "Linux tasklet called in init_module"); tasklet_schedule(&test_tasklet); }

37 Workqueue Inside a kernel process context More flexible, can be preempted and resumed Asynchronous execution Creation: create_workqueue(name) Create the queu and return a pointer struct workqueue_struct Destruction: void destroy_workqueue(struct workqueue_struct *queue) Free the file

38 How to DECLARE_WORK(name,function,data) Declare a work int queue_work(struct workqueue_struct *wq, struct work_struct *work) Put the work in the file int queue_delayed_work(struct workqueue_struct *wq, struct work_struct *work, unsigned long delay) Add work to file, but no execution before delay ticks int cancel_delayed_work(struct work_struct *work) Remove work from queue void flush_workqueue(struct workqueue_struct *queue) Clear the queue