字符驱动分析

1.使用字符设备驱动程序

1) 编译/安装驱动

2)创建设备文件

3)访问设备

1) 在linux系统中，驱动程序通常采用内核模块的程序结构进行编码。

因此，编译/安装一个驱动程序，其实质就是编译/安装一个内核模块。

驱动名 memdev.c
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>

int dev1_registers[5];
int dev2_registers[5];

struct cdev cdev;
dev_t devno;

/*文件打开函数*/
int mem_open(struct inode *inode, struct file *filp)
{

/*获取次设备号*/
int num = MINOR(inode->i_rdev);

if (num==0)
filp->private_data = dev1_registers;
else if(num == 1)
filp->private_data = dev2_registers;
else
return -ENODEV;  //无效的次设备号

return 0;
}

/*文件释放函数*/
int mem_release(struct inode *inode, struct file *filp)
{
return 0;
}

/*读函数*/
static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
unsigned long p =  *ppos;
unsigned int count = size;
int ret = 0;
int *register_addr = filp->private_data; /*获取设备的寄存器基地址*/

/*判断读位置是否有效*/
if (p >= 5*sizeof(int))
return 0;
if (count > 5*sizeof(int) - p)
count = 5*sizeof(int) - p;

/*读数据到用户空间*/
if (copy_to_user(buf, register_addr+p, count))
{
ret = -EFAULT;
}
else
{
*ppos += count;
ret = count;
}

return ret;
}

/*写函数*/
static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
unsigned long p =  *ppos;
unsigned int count = size;
int ret = 0;
int *register_addr = filp->private_data; /*获取设备的寄存器地址*/

/*分析和获取有效的写长度*/
if (p >= 5*sizeof(int))
return 0;
if (count > 5*sizeof(int) - p)
count = 5*sizeof(int) - p;

/*从用户空间写入数据*/
if (copy_from_user(register_addr + p, buf, count))
ret = -EFAULT;
else
{
*ppos += count;
ret = count;
}

return ret;
}

/* seek文件定位函数 */
static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
{
loff_t newpos;

switch(whence) {
case SEEK_SET:
newpos = offset;
break;

case SEEK_CUR:
newpos = filp->f_pos + offset;
break;

case SEEK_END:
newpos = 5*sizeof(int)-1 + offset;
break;

default:
return -EINVAL;
}
if ((newpos<0) || (newpos>5*sizeof(int)))
return -EINVAL;

filp->f_pos = newpos;
return newpos;

}

/*文件操作结构体*/
static const struct file_operations mem_fops =
{
.llseek = mem_llseek,
.read = mem_read,
.write = mem_write,
.open = mem_open,
.release = mem_release,
};

/*设备驱动模块加载函数*/
static int memdev_init(void)
{
/*初始化cdev结构*/
cdev_init(&cdev, &mem_fops);

/* 注册字符设备 */
alloc_chrdev_region(&devno, 0, 2, "memdev");
cdev_add(&cdev, devno, 2);
}

/*模块卸载函数*/
static void memdev_exit(void)
{
cdev_del(&cdev);   /*注销设备*/
unregister_chrdev_region(devno, 2); /*释放设备号*/
}

MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(memdev_exit);

Makefile文件：
obj-m := memdev.o
KDIR := /home/S5-driver/lesson7/TQ210/linux
all:
make -C $(KDIR) M=$(PWD) modules CROSS_COMPILE=arm-linux- ARCH=arm
clean:
rm -f *.ko *.o *.mod.o *.mod.c *.symvers *.bak *.order

insmod memdev.ko

应用程序： mem_write.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
int fd = 0;
int src = 2013;

/*打开设备文件*/
fd = open("/dev/memdev0",O_RDWR);

/*写入数据*/
write(fd, &src, sizeof(int));

/*关闭设备*/
close(fd);

return 0;

}
arm-linux-readelf -d  mem_write.c  检查动态链接库
一般采用静态编译
arm-linux-gcc -static mem_write.c -o mem_write

应用程序： mem_read.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
int fd = 0;
int dst = 0;

/*打开设备文件*/
fd = open("/dev/memdev0",O_RDWR);

/*写入数据*/
read(fd, &dst, sizeof(int));

printf("dst is %d\n",dst);

/*关闭设备*/
close(fd);

return 0;

}

创建字符设备文件

1. 使用mknod命令 mknod /dev/文件名 c 主设备号 次设备号

2. 使用函数在驱动程序中创建。后面会提到。

2.字符设备文件

应用程序{文件名} ---> 字符设备文件 --->(主设备号) ----> 设备驱动程序

通过字符设备文件，应用程序可以使用相应的字符设备驱动程序来控制字符设备。创建字符设备

文件的方法一般有两种：

1.使用mknod命令

mknod /dev/文件名 c 主设备号 次设备号

cat /proc/devices

第一列 第二列

数字(主设备号) 设备名字

2.字符驱动编程模型：

字符驱动编程模型：1.设备描述结构cdev

2.字符设备驱动模型

3.范例驱动分析

1.设备描述结构cdev

1.1 结构定义

1.2 设备号

1.3 设备操作集

1.驱动模型

在Linux系统中，设备的类型非常繁多，如：字符设备，块设备，网络接口设备，USB设备，PCI设备

平台设备，混杂设备....,设备类型不同，也意味着其对应的驱动程序模型不同，这样就导致了我们需要去

掌握众多的驱动程序模型。那么能不能从这些众多的驱动模型中提炼出一些具有共性的规则，则是

我们能不能学好Linux驱动的关键。

驱动初始化：

2.1.1 分配设备描述结构

2.1.2 初始化设备描述结构

2.1.3 注册设备描述结构

2.1.4 硬件初始化

2.1.1 设备描述结构

在任何一种驱动模型中，设备都会用内核中的一种结构来描述。我们的字符设备在内核中使用struct cdev

来描述。

struct cdev{

struct kobject kobj;

struct module *owner;

const struct file_operations* ops; //设备操作集

struct list_head list;

dev_t dev; //设备号

unsigned int count; //设备数

};

1.1 设备号

查看/dev目录下 设备号

字符设备文件 ----->>>>> 字符设备驱动

主设备号： 字符设备文件与字符驱动程序如何建立起对应关系？

主设备号。

串口1

串口驱动程序

串口2

驱动程序什么来区分串口1和串口2： 次设备号。

设备号 --- 操作

Linux内核中使用dev_t类型来定义设备号，dev_t这种类型其实质为32位的unsigned int,

其中高12位为设备号，低20位为次设备号。

问1：如果知道主设备号，次设备号，怎么组合成dev_t类型

dev_t dev = MKDEV(主设备号，次设备号)

问2：如何从dev_t 中分解出主设备号？

主设备号 = MAJOR(dev_t dev)

问3： 如何从dev_t中分解出次设备号

次设备号 = MINOR(dev_t dev)

1.2设备号 -- 分配

如何为设备分配一个主设备号？

静态申请：开发者自己选择一个数字作为主设备号，然后通过函数register_chrdev_region

向内核申请使用。缺点：如果申请使用的设备号已经被内核中的其他驱动使用了，则申请失败。

动态分配：使用alloc_chrdev_region由内核分配一个可用的主设备号。

优点：因为内核知道哪些号已经被使用了，所以不会导致分配到已经被使用的号。

1.1设备号 -- 注销

不论使用何种方法分配设备号，都应该在驱动退出时，使用unregister_chrdev_region函数释放这些设备号。

应用程序

read

如何响应？

write 字符设备文件 -----------> 字符设备驱动 分析file_operations 定义。

open

/*
* NOTE:
* all file operations except setlease can be called without
* the big kernel lock held in all filesystems.
*/
struct file_operations {
struct module *owner;

loff_t (*llseek) (struct file *, loff_t, int);
重定位读写指针，响应lseek系统调用

ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
从设备读取数据，响应read系统调用

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
向设备写入数据，响应write系统调用

ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);

int (*open) (struct inode *, struct file *);
打开设备，响应open系统调用

int (*flush) (struct file *, fl_owner_t id);

int (*release) (struct inode *, struct file *);
关闭设备，响应close系统调用

int (*fsync) (struct file *, 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 (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
long (*fallocate)(struct file *file, int mode, loff_t offset,
loff_t len);
};

1.2操作函数集

struct file_operations是一个函数指针的集合，定义能在设备上进行的操作。结构上的函数指针指向

驱动中的函数，这些函数实现一个针对设备的操作，对于不支持的操作则设置函数指针为NULL,例如：

struct file_operations dev_fops = {

.llseek = NULL,

.read = dev_read,

.write = dev_write,

.ioctl = dev_ioctl,

.open = dev_open,

.release = dev_release,

};

2.1 描述结构 - 分配

cdev变量的定义可以采用静态和动态两种方法：

静态分配

struct cdev mdev;

动态分配

struct cdev *pdev = cdev_alloc();

2.2描述结构 -- 初始化

struct cdev 的初始化使用cdev_init函数来完成。

cdev_init(struct cdev* cdev , const struct file_operations *fops);

参数：

cdev： 待初始化的cdev结构。

fops: 设备对应的操作函数集。

2.3 描述函数结构 -- 注册

字符设备的注册使用cdev_add函数来完成。

cdev_add(struct cdev* p , dev_t dev, unsigned count);

参数：

p:待添加到内核的字符设备结构

dev：设备号

count: 该类设备的设备个数。

2.4 硬件初始化

根据相应硬件的芯片手册，完成初始化。

2.2 struct file

在linux系统中，每一个打开的文件，在内核中都会关联一个struct file,它由内核在打开文件时创建，在文件关闭后释放。

重要成员：

loff_t f_pos; 文件读写指针

struct file_operations *f_op; 该文件所对应的操作

2.3 struct inode

每一个存在文件系统里面的文件都会关联一个inode结构，该结构主要用来记录文件物理上的信息。因此，它和代表打开文件

的file结构是不同的。一个文件没有被打开时不会关联file结构，但是却会关联一个inode结构。

重要成员：

dev_t i_rdev; 设备号

3.2 设备操作 - open

open设备方法是驱动程序用来为以后的操作完成初始化准备工作的。在大部分驱动程序中，open完成如下工作：

标明次设备号

启动设备

3.2 设备操作 - release

release 方法的作用正好与open相反。这个设备方法有时也称为close，它应该：

关闭设备。

2.2 设备操作 - read

read设备方法通常完成2件事情：

从设备中读取数据(属于硬件访问类操作)

将读取到的数据返回给应用程序。

ssize_t (*read)(struct file* filp, char __user* buff, size_t count,loff_t *offp)

参数分析：

filp: 与字符设备文件关联的file结构指针，由内核创建。

buff: 从设备读取到的数据，需要保存到的位置，由read系统调用提供该参数。

count： 请求传输的数据量，由read系统调用提供该参数。

offp: 文件的读写位置，由内核从file结构中取出后，传递进来。

buff参数是来源于用户空间的指针，这类指针都不能被内核代码直接引用，必须使用专门的函数。

int copy_from_user(void* to,const void __user *from,int n);

int copy_to_user(void __user *to,const void* from,int n);

2.3 设备操作 -- write

write设备方法通常完成2件事情

从应用程序提供的地址中取出数据

将数据写入设备(属于硬件访问类操作)

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

2.5：驱动注销

当我们从内核中卸载驱动程序的时候，需要使用cdev_del函数来完成字符设备的注销。

编码思维导图：

设备驱动模型： 驱动初始化 ---> 2.11 分配cdev ---> 静态分配和动态分配

2.12 初始化cdev ----> cdev_init

2.13 注销cdev -----> cdev_add

2.14 硬件初始化

实现设备操作：

2.2.2 open

2.2.3 read ----> copy_to_user

2.2.4 write ----> copy_from_user

2.2.5 lseek

2.2.6 close

驱动注销： cdev_del

unregister_chrdev_region

struct inode {
/* RCU path lookup touches following: */
umode_t			i_mode;
uid_t			i_uid;
gid_t			i_gid;
const struct inode_operations	*i_op;
struct super_block	*i_sb;

spinlock_t		i_lock;	/* i_blocks, i_bytes, maybe i_size */
unsigned int		i_flags;
struct mutex		i_mutex;

unsigned long		i_state;
unsigned long		dirtied_when;	/* jiffies of first dirtying */

struct hlist_node	i_hash;
struct list_head	i_wb_list;	/* backing dev IO list */
struct list_head	i_lru;		/* inode LRU list */
struct list_head	i_sb_list;
union {
struct list_head	i_dentry;
struct rcu_head		i_rcu;
};
unsigned long		i_ino;
atomic_t		i_count;
unsigned int		i_nlink;
dev_t			i_rdev;
unsigned int		i_blkbits;
u64			i_version;
loff_t			i_size;
#ifdef __NEED_I_SIZE_ORDERED
seqcount_t		i_size_seqcount;
#endif
struct timespec		i_atime;
struct timespec		i_mtime;
struct timespec		i_ctime;
blkcnt_t		i_blocks;
unsigned short          i_bytes;
struct rw_semaphore	i_alloc_sem;
const struct file_operations	*i_fop;	/* former ->i_op->default_file_ops */
struct file_lock	*i_flock;
struct address_space	*i_mapping;
struct address_space	i_data;
#ifdef CONFIG_QUOTA
struct dquot		*i_dquot[MAXQUOTAS];
#endif
struct list_head	i_devices;
union {
struct pipe_inode_info	*i_pipe;
struct block_device	*i_bdev;
struct cdev             *i_cdev;
};

__u32			i_generation;

#ifdef CONFIG_FSNOTIFY
__u32			i_fsnotify_mask; /* all events this inode cares about */
struct hlist_head	i_fsnotify_marks;
#endif

#ifdef CONFIG_IMA
atomic_t		i_readcount; /* struct files open RO */
#endif
atomic_t		i_writecount;
#ifdef CONFIG_SECURITY
void			*i_security;
#endif
#ifdef CONFIG_FS_POSIX_ACL
struct posix_acl	*i_acl;
struct posix_acl	*i_default_acl;
#endif
void			*i_private; /* fs or device private pointer */
};

struct file {
/*
* fu_list becomes invalid after file_free is called and queued via
* fu_rcuhead for RCU freeing
*/
union {
struct list_head	fu_list;
struct rcu_head 	fu_rcuhead;
} f_u;
struct path		f_path;
#define f_dentry	f_path.dentry
#define f_vfsmnt	f_path.mnt
const struct file_operations	*f_op;
spinlock_t		f_lock;  /* f_ep_links, f_flags, no IRQ */
#ifdef CONFIG_SMP
int			f_sb_list_cpu;
#endif
atomic_long_t		f_count;
unsigned int 		f_flags;
fmode_t			f_mode;
loff_t			f_pos;
struct fown_struct	f_owner;
const struct cred	*f_cred;
struct file_ra_state	f_ra;

u64			f_version;
#ifdef CONFIG_SECURITY
void			*f_security;
#endif
/* needed for tty driver, and maybe others */
void			*private_data;

#ifdef CONFIG_EPOLL
/* Used by fs/eventpoll.c to link all the hooks to this file */
struct list_head	f_ep_links;
#endif /* #ifdef CONFIG_EPOLL */
struct address_space	*f_mapping;
#ifdef CONFIG_DEBUG_WRITECOUNT
unsigned long f_mnt_write_state;
#endif
};

驱动程序和应用程序的桥梁到底怎么建立的？

例如：应用程序： mem_read.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
int fd = 0;
int dst = 0;

/*打开设备文件*/
fd = open("/dev/memdev0",O_RDWR);

/*写入数据*/
read(fd, &dst, sizeof(int));

printf("dst is %d\n",dst);

/*关闭设备*/
close(fd);

return 0;
}

首先：我们静态编译 arm-linux-gcc  -static  -g  read_mem.c  -o  read_mem

接着反汇编：arm-linux-objdump -D -S read_mem > tmp

read_mem:     file format elf32-littlearm

Disassembly of section .note.ABI-tag:

000080f4 <.note.ABI-tag>:
80f4:	00000004 	.word	0x00000004
80f8:	00000010 	.word	0x00000010
80fc:	00000001 	.word	0x00000001
8100:	00554e47 	.word	0x00554e47
8104:	00000000 	.word	0x00000000
8108:	00000002 	.word	0x00000002
810c:	00000006 	.word	0x00000006
8110:	0000000e 	.word	0x0000000e
Disassembly of section .init:

00008228 <main>:
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
8228:	e92d4800 	push	{fp, lr}
822c:	e28db004 	add	fp, sp, #4	; 0x4
8230:	e24dd008 	sub	sp, sp, #8	; 0x8
int fd = 0;
8234:	e3a03000 	mov	r3, #0	; 0x0
8238:	e50b3008 	str	r3, [fp, #-8]
int dst = 0;
823c:	e3a03000 	mov	r3, #0	; 0x0
8240:	e50b300c 	str	r3, [fp, #-12]

/*打开设备文件*/
fd = open("/dev/memdev0",O_RDWR);
8244:	e59f004c 	ldr	r0, [pc, #76]	; 8298 <main+0x70>
8248:	e3a01002 	mov	r1, #2	; 0x2
824c:	eb0028a3 	bl	124e0 <__libc_open>
8250:	e1a03000 	mov	r3, r0
8254:	e50b3008 	str	r3, [fp, #-8]

/*写入数据*/
read(fd, &dst, sizeof(int));
8258:	e24b300c 	sub	r3, fp, #12	; 0xc
825c:	e51b0008 	ldr	r0, [fp, #-8]
8260:	e1a01003 	mov	r1, r3
8264:	e3a02004 	mov	r2, #4 ; 0x4
8268:       eb0028c0        bl      12570<libc_read>

参数个数小于4    采用通用寄存器。 r0,r1,r2,r3

00012600 <__libc_read>:
12600:	e51fc028 	ldr	ip, [pc, #-40]	; 125e0 <__libc_close+0x70>
12604:	e79fc00c 	ldr	ip, [pc, ip]
12608:	e33c0000 	teq	ip, #0	; 0x0
1260c:	1a000006 	bne	1262c <__libc_read+0x2c>
12610:	e1a0c007 	mov	ip, r7
12614:	e3a07003 	mov	r7, #3	; 0x3
12618:	ef000000 	svc	0x00000000
1261c:	e1a0700c 	mov	r7, ip

在应用程序中r7 = 3   svc是系统调用指令   ----> 用户空间进入内核空间。

1.入口： 在arch\arm\kernel\entry-common.S  中的vector_swi
2.取NO.
3.查表（依据是NO.）

ENTRY(vector_swi)
sub	sp, sp, #S_FRAME_SIZE
stmia	sp, {r0 - r12}			@ Calling r0 - r12
ARM(	add	r8, sp, #S_PC		)
ARM(	stmdb	r8, {sp, lr}^		)	@ Calling sp, lr
THUMB(	mov	r8, sp			)
THUMB(	store_user_sp_lr r8, r10, S_SP	)	@ calling sp, lr
mrs	r8, spsr			@ called from non-FIQ mode, so ok.
str	lr, [sp, #S_PC]			@ Save calling PC
str	r8, [sp, #S_PSR]		@ Save CPSR
str	r0, [sp, #S_OLD_R0]		@ Save OLD_R0
zero_fp

/*
* Get the system call number.
*/
/*
* If the swi argument is zero, this is an EABI call and we do nothing.
*
* If this is an old ABI call, get the syscall number into scno and
* get the old ABI syscall table address.
*/
bics	r10, r10, #0xff000000
eorne	scno, r10, #__NR_OABI_SYSCALL_BASE
ldrne	tbl, =sys_oabi_call_table

/*
* If the swi argument is zero, this is an EABI call and we do nothing.
*
* If this is an old ABI call, get the syscall number into scno and
* get the old ABI syscall table address.
*/
bics	r10, r10, #0xff000000
eorne	scno, r10, #__NR_OABI_SYSCALL_BASE
ldrne	tbl, =sys_oabi_call_table

ENTRY(sys_call_table)
#include "calls.S"
#undef ABI
#undef OBSOLETE

/*============================================================================
* Special system call wrappers
*/
@ r0 = syscall number
@ r8 = syscall table
sys_syscall:

*  linux/arch/arm/kernel/calls.S
*
*  Copyright (C) 1995-2005 Russell King
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
*  This file is included thrice in entry-common.S
*/
/* 0 */		CALL(sys_restart_syscall)
CALL(sys_exit)
CALL(sys_fork_wrapper)
CALL(sys_read)
CALL(sys_write)
/* 5 */		CALL(sys_open)
CALL(sys_close)
CALL(sys_ni_syscall)		/* was sys_waitpid */
CALL(sys_creat)
CALL(sys_link)
/* 10 */	CALL(sys_unlink)
CALL(sys_execve_wrapper)
CALL(sys_chdir)
CALL(OBSOLETE(sys_time))	/* used by libc4 */
CALL(sys_mknod)
/* 15 */	CALL(sys_chmod)
CALL(sys_lchown16)
CALL(sys_ni_syscall)		/* was sys_break */
CALL(sys_ni_syscall)		/* was sys_stat */
CALL(sys_lseek)
/* 20 */	CALL(sys_getpid)
CALL(sys_mount)
CALL(OBSOLETE(sys_oldumount))	/* used by libc4 */

找到 sys_read 函数。

asmlinkage long sys_read(unsigned int fd, char __user *buf, size_t count);

SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
{
struct file *file;
ssize_t ret = -EBADF;
int fput_needed;

file = fget_light(fd, &fput_needed);
if (file) {
loff_t pos = file_pos_read(file);
ret = vfs_read(file, buf, count, &pos);
file_pos_write(file, pos);
fput_light(file, fput_needed);
}

return ret;
}

在read_write.c中

ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
ssize_t ret;

if (!(file->f_mode & FMODE_READ))
return -EBADF;
if (!file->f_op || (!file->f_op->read && !file->f_op->aio_read))
return -EINVAL;
if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
return -EFAULT;

ret = rw_verify_area(READ, file, pos, count);
if (ret >= 0) {
count = ret;
if (file->f_op->read)
ret = file->f_op->read(file, buf, count, pos);
else
ret = do_sync_read(file, buf, count, pos);
if (ret > 0) {
fsnotify_access(file);
add_rchar(current, ret);
}
inc_syscr(current);
}

return ret;
}