[linux-2.6-block.git] / arch / xtensa / platforms / iss / simdisk.c

/*
 * arch/xtensa/platforms/iss/simdisk.c
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2001-2013 Tensilica Inc.
 *   Authors	Victor Prupis
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/blkdev.h>
#include <linux/bio.h>
#include <linux/proc_fs.h>
#include <asm/uaccess.h>
#include <platform/simcall.h>

#define SIMDISK_MAJOR 240
#define SECTOR_SHIFT 9
#define SIMDISK_MINORS 1
#define MAX_SIMDISK_COUNT 10

struct simdisk {
	const char *filename;
	spinlock_t lock;
	struct request_queue *queue;
	struct gendisk *gd;
	struct proc_dir_entry *procfile;
	int users;
	unsigned long size;
	int fd;
};


static int simdisk_count = CONFIG_BLK_DEV_SIMDISK_COUNT;
module_param(simdisk_count, int, S_IRUGO);
MODULE_PARM_DESC(simdisk_count, "Number of simdisk units.");

static int n_files;
static const char *filename[MAX_SIMDISK_COUNT] = {
#ifdef CONFIG_SIMDISK0_FILENAME
	CONFIG_SIMDISK0_FILENAME,
#ifdef CONFIG_SIMDISK1_FILENAME
	CONFIG_SIMDISK1_FILENAME,
#endif
#endif
};

static int simdisk_param_set_filename(const char *val,
		const struct kernel_param *kp)
{
	if (n_files < ARRAY_SIZE(filename))
		filename[n_files++] = val;
	else
		return -EINVAL;
	return 0;
}

static const struct kernel_param_ops simdisk_param_ops_filename = {
	.set = simdisk_param_set_filename,
};
module_param_cb(filename, &simdisk_param_ops_filename, &n_files, 0);
MODULE_PARM_DESC(filename, "Backing storage filename.");

static int simdisk_major = SIMDISK_MAJOR;

static void simdisk_transfer(struct simdisk *dev, unsigned long sector,
		unsigned long nsect, char *buffer, int write)
{
	unsigned long offset = sector << SECTOR_SHIFT;
	unsigned long nbytes = nsect << SECTOR_SHIFT;

	if (offset > dev->size || dev->size - offset < nbytes) {
		pr_notice("Beyond-end %s (%ld %ld)\n",
				write ? "write" : "read", offset, nbytes);
		return;
	}

	spin_lock(&dev->lock);
	while (nbytes > 0) {
		unsigned long io;

		simc_lseek(dev->fd, offset, SEEK_SET);
		if (write)
			io = simc_write(dev->fd, buffer, nbytes);
		else
			io = simc_read(dev->fd, buffer, nbytes);
		if (io == -1) {
			pr_err("SIMDISK: IO error %d\n", errno);
			break;
		}
		buffer += io;
		offset += io;
		nbytes -= io;
	}
	spin_unlock(&dev->lock);
}

static void simdisk_make_request(struct request_queue *q, struct bio *bio)
{
	struct simdisk *dev = q->queuedata;
	struct bio_vec bvec;
	struct bvec_iter iter;
	sector_t sector = bio->bi_iter.bi_sector;

	bio_for_each_segment(bvec, bio, iter) {
		char *buffer = __bio_kmap_atomic(bio, iter);
		unsigned len = bvec.bv_len >> SECTOR_SHIFT;

		simdisk_transfer(dev, sector, len, buffer,
				bio_data_dir(bio) == WRITE);
		sector += len;
		__bio_kunmap_atomic(buffer);
	}

	bio_endio(bio);
}

static int simdisk_open(struct block_device *bdev, fmode_t mode)
{
	struct simdisk *dev = bdev->bd_disk->private_data;

	spin_lock(&dev->lock);
	if (!dev->users)
		check_disk_change(bdev);
	++dev->users;
	spin_unlock(&dev->lock);
	return 0;
}

static void simdisk_release(struct gendisk *disk, fmode_t mode)
{
	struct simdisk *dev = disk->private_data;
	spin_lock(&dev->lock);
	--dev->users;
	spin_unlock(&dev->lock);
}

static const struct block_device_operations simdisk_ops = {
	.owner		= THIS_MODULE,
	.open		= simdisk_open,
	.release	= simdisk_release,
};

static struct simdisk *sddev;
static struct proc_dir_entry *simdisk_procdir;

static int simdisk_attach(struct simdisk *dev, const char *filename)
{
	int err = 0;

	filename = kstrdup(filename, GFP_KERNEL);
	if (filename == NULL)
		return -ENOMEM;

	spin_lock(&dev->lock);

	if (dev->fd != -1) {
		err = -EBUSY;
		goto out;
	}
	dev->fd = simc_open(filename, O_RDWR, 0);
	if (dev->fd == -1) {
		pr_err("SIMDISK: Can't open %s: %d\n", filename, errno);
		err = -ENODEV;
		goto out;
	}
	dev->size = simc_lseek(dev->fd, 0, SEEK_END);
	set_capacity(dev->gd, dev->size >> SECTOR_SHIFT);
	dev->filename = filename;
	pr_info("SIMDISK: %s=%s\n", dev->gd->disk_name, dev->filename);
out:
	if (err)
		kfree(filename);
	spin_unlock(&dev->lock);

	return err;
}

static int simdisk_detach(struct simdisk *dev)
{
	int err = 0;

	spin_lock(&dev->lock);

	if (dev->users != 0) {
		err = -EBUSY;
	} else if (dev->fd != -1) {
		if (simc_close(dev->fd)) {
			pr_err("SIMDISK: error closing %s: %d\n",
					dev->filename, errno);
			err = -EIO;
		} else {
			pr_info("SIMDISK: %s detached from %s\n",
					dev->gd->disk_name, dev->filename);
			dev->fd = -1;
			kfree(dev->filename);
			dev->filename = NULL;
		}
	}
	spin_unlock(&dev->lock);
	return err;
}

static ssize_t proc_read_simdisk(struct file *file, char __user *buf,
			size_t size, loff_t *ppos)
{
	struct simdisk *dev = PDE_DATA(file_inode(file));
	const char *s = dev->filename;
	if (s) {
		ssize_t n = simple_read_from_buffer(buf, size, ppos,
							s, strlen(s));
		if (n < 0)
			return n;
		buf += n;
		size -= n;
	}
	return simple_read_from_buffer(buf, size, ppos, "\n", 1);
}

static ssize_t proc_write_simdisk(struct file *file, const char __user *buf,
			size_t count, loff_t *ppos)
{
	char *tmp = kmalloc(count + 1, GFP_KERNEL);
	struct simdisk *dev = PDE_DATA(file_inode(file));
	int err;

	if (tmp == NULL)
		return -ENOMEM;
	if (copy_from_user(tmp, buf, count)) {
		err = -EFAULT;
		goto out_free;
	}

	err = simdisk_detach(dev);
	if (err != 0)
		goto out_free;

	if (count > 0 && tmp[count - 1] == '\n')
		tmp[count - 1] = 0;
	else
		tmp[count] = 0;

	if (tmp[0])
		err = simdisk_attach(dev, tmp);

	if (err == 0)
		err = count;
out_free:
	kfree(tmp);
	return err;
}

static const struct file_operations fops = {
	.read = proc_read_simdisk,
	.write = proc_write_simdisk,
	.llseek = default_llseek,
};

static int __init simdisk_setup(struct simdisk *dev, int which,
		struct proc_dir_entry *procdir)
{
	char tmp[2] = { '0' + which, 0 };

	dev->fd = -1;
	dev->filename = NULL;
	spin_lock_init(&dev->lock);
	dev->users = 0;

	dev->queue = blk_alloc_queue(GFP_KERNEL);
	if (dev->queue == NULL) {
		pr_err("blk_alloc_queue failed\n");
		goto out_alloc_queue;
	}

	blk_queue_make_request(dev->queue, simdisk_make_request);
	dev->queue->queuedata = dev;

	dev->gd = alloc_disk(SIMDISK_MINORS);
	if (dev->gd == NULL) {
		pr_err("alloc_disk failed\n");
		goto out_alloc_disk;
	}
	dev->gd->major = simdisk_major;
	dev->gd->first_minor = which;
	dev->gd->fops = &simdisk_ops;
	dev->gd->queue = dev->queue;
	dev->gd->private_data = dev;
	snprintf(dev->gd->disk_name, 32, "simdisk%d", which);
	set_capacity(dev->gd, 0);
	add_disk(dev->gd);

	dev->procfile = proc_create_data(tmp, 0644, procdir, &fops, dev);
	return 0;

out_alloc_disk:
	blk_cleanup_queue(dev->queue);
	dev->queue = NULL;
out_alloc_queue:
	simc_close(dev->fd);
	return -EIO;
}

static int __init simdisk_init(void)
{
	int i;

	if (register_blkdev(simdisk_major, "simdisk") < 0) {
		pr_err("SIMDISK: register_blkdev: %d\n", simdisk_major);
		return -EIO;
	}
	pr_info("SIMDISK: major: %d\n", simdisk_major);

	if (n_files > simdisk_count)
		simdisk_count = n_files;
	if (simdisk_count > MAX_SIMDISK_COUNT)
		simdisk_count = MAX_SIMDISK_COUNT;

	sddev = kmalloc(simdisk_count * sizeof(struct simdisk),
			GFP_KERNEL);
	if (sddev == NULL)
		goto out_unregister;

	simdisk_procdir = proc_mkdir("simdisk", 0);
	if (simdisk_procdir == NULL)
		goto out_free_unregister;

	for (i = 0; i < simdisk_count; ++i) {
		if (simdisk_setup(sddev + i, i, simdisk_procdir) == 0) {
			if (filename[i] != NULL && filename[i][0] != 0 &&
					(n_files == 0 || i < n_files))
				simdisk_attach(sddev + i, filename[i]);
		}
	}

	return 0;

out_free_unregister:
	kfree(sddev);
out_unregister:
	unregister_blkdev(simdisk_major, "simdisk");
	return -ENOMEM;
}
module_init(simdisk_init);

static void simdisk_teardown(struct simdisk *dev, int which,
		struct proc_dir_entry *procdir)
{
	char tmp[2] = { '0' + which, 0 };

	simdisk_detach(dev);
	if (dev->gd)
		del_gendisk(dev->gd);
	if (dev->queue)
		blk_cleanup_queue(dev->queue);
	remove_proc_entry(tmp, procdir);
}

static void __exit simdisk_exit(void)
{
	int i;

	for (i = 0; i < simdisk_count; ++i)
		simdisk_teardown(sddev + i, i, simdisk_procdir);
	remove_proc_entry("simdisk", 0);
	kfree(sddev);
	unregister_blkdev(simdisk_major, "simdisk");
}
module_exit(simdisk_exit);

MODULE_ALIAS_BLOCKDEV_MAJOR(SIMDISK_MAJOR);

MODULE_LICENSE("GPL");
Commit	Line	Data
b6c7e873 VP	1	/*
	2	* arch/xtensa/platforms/iss/simdisk.c
	3	*
	4	* This file is subject to the terms and conditions of the GNU General Public
	5	* License. See the file "COPYING" in the main directory of this archive
	6	* for more details.
	7	*
	8	* Copyright (C) 2001-2013 Tensilica Inc.
	9	* Authors Victor Prupis
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/moduleparam.h>
	14	#include <linux/kernel.h>
	15	#include <linux/init.h>
	16	#include <linux/string.h>
	17	#include <linux/blkdev.h>
	18	#include <linux/bio.h>
	19	#include <linux/proc_fs.h>
	20	#include <asm/uaccess.h>
	21	#include <platform/simcall.h>
	22
	23	#define SIMDISK_MAJOR 240
	24	#define SECTOR_SHIFT 9
	25	#define SIMDISK_MINORS 1
	26	#define MAX_SIMDISK_COUNT 10
	27
	28	struct simdisk {
	29	const char *filename;
	30	spinlock_t lock;
	31	struct request_queue *queue;
	32	struct gendisk *gd;
	33	struct proc_dir_entry *procfile;
	34	int users;
	35	unsigned long size;
	36	int fd;
	37	};
	38
	39
	40	static int simdisk_count = CONFIG_BLK_DEV_SIMDISK_COUNT;
	41	module_param(simdisk_count, int, S_IRUGO);
	42	MODULE_PARM_DESC(simdisk_count, "Number of simdisk units.");
	43
	44	static int n_files;
	45	static const char *filename[MAX_SIMDISK_COUNT] = {
	46	#ifdef CONFIG_SIMDISK0_FILENAME
	47	CONFIG_SIMDISK0_FILENAME,
	48	#ifdef CONFIG_SIMDISK1_FILENAME
	49	CONFIG_SIMDISK1_FILENAME,
	50	#endif
	51	#endif
	52	};
	53
	54	static int simdisk_param_set_filename(const char *val,
	55	const struct kernel_param *kp)
	56	{
	57	if (n_files < ARRAY_SIZE(filename))
	58	filename[n_files++] = val;
	59	else
	60	return -EINVAL;
	61	return 0;
	62	}
	63
	64	static const struct kernel_param_ops simdisk_param_ops_filename = {
65	.set = simdisk_param_set_filename,
66	};
67	module_param_cb(filename, &simdisk_param_ops_filename, &n_files, 0);
68	MODULE_PARM_DESC(filename, "Backing storage filename.");
69
70	static int simdisk_major = SIMDISK_MAJOR;
71
72	static void simdisk_transfer(struct simdisk *dev, unsigned long sector,
73	unsigned long nsect, char *buffer, int write)
74	{
75	unsigned long offset = sector << SECTOR_SHIFT;
76	unsigned long nbytes = nsect << SECTOR_SHIFT;
77
78	if (offset > dev->size \|\| dev->size - offset < nbytes) {
79	pr_notice("Beyond-end %s (%ld %ld)\n",
80	write ? "write" : "read", offset, nbytes);
81	return;
82	}
83
84	spin_lock(&dev->lock);
85	while (nbytes > 0) {
86	unsigned long io;
87
f4b93ba9	88	simc_lseek(dev->fd, offset, SEEK_SET);
b6c7e873 VP	89	if (write)
	90	io = simc_write(dev->fd, buffer, nbytes);
	91	else
	92	io = simc_read(dev->fd, buffer, nbytes);
	93	if (io == -1) {
	94	pr_err("SIMDISK: IO error %d\n", errno);
	95	break;
	96	}
	97	buffer += io;
	98	offset += io;
	99	nbytes -= io;
	100	}
	101	spin_unlock(&dev->lock);
	102	}
	103
4246a0b6	104	static void simdisk_make_request(struct request_queue q, struct bio bio)
b6c7e873	105	{
4246a0b6	106	struct simdisk *dev = q->queuedata;
675675ad JA	107	struct bio_vec bvec;
	108	struct bvec_iter iter;
	109	sector_t sector = bio->bi_iter.bi_sector;
b6c7e873	110
675675ad JA	111	bio_for_each_segment(bvec, bio, iter) {
	112	char *buffer = __bio_kmap_atomic(bio, iter);
	113	unsigned len = bvec.bv_len >> SECTOR_SHIFT;
b6c7e873 VP	114
	115	simdisk_transfer(dev, sector, len, buffer,
	116	bio_data_dir(bio) == WRITE);
	117	sector += len;
675675ad	118	__bio_kunmap_atomic(buffer);
b6c7e873	119	}
b6c7e873	120
4246a0b6	121	bio_endio(bio);
b6c7e873 VP	122	}
b6c7e873 VP	123
b6c7e873 VP	124	static int simdisk_open(struct block_device *bdev, fmode_t mode)
	125	{
	126	struct simdisk *dev = bdev->bd_disk->private_data;
	127
	128	spin_lock(&dev->lock);
	129	if (!dev->users)
	130	check_disk_change(bdev);
	131	++dev->users;
	132	spin_unlock(&dev->lock);
	133	return 0;
	134	}
	135
db2a144b	136	static void simdisk_release(struct gendisk *disk, fmode_t mode)
b6c7e873 VP	137	{
	138	struct simdisk *dev = disk->private_data;
	139	spin_lock(&dev->lock);
	140	--dev->users;
	141	spin_unlock(&dev->lock);
b6c7e873 VP	142	}
	143
	144	static const struct block_device_operations simdisk_ops = {
	145	.owner = THIS_MODULE,
	146	.open = simdisk_open,
	147	.release = simdisk_release,
	148	};
	149
	150	static struct simdisk *sddev;
	151	static struct proc_dir_entry *simdisk_procdir;
	152
	153	static int simdisk_attach(struct simdisk dev, const char filename)
	154	{
	155	int err = 0;
	156
	157	filename = kstrdup(filename, GFP_KERNEL);
	158	if (filename == NULL)
	159	return -ENOMEM;
	160
	161	spin_lock(&dev->lock);
	162
	163	if (dev->fd != -1) {
	164	err = -EBUSY;
	165	goto out;
	166	}
	167	dev->fd = simc_open(filename, O_RDWR, 0);
	168	if (dev->fd == -1) {
	169	pr_err("SIMDISK: Can't open %s: %d\n", filename, errno);
	170	err = -ENODEV;
	171	goto out;
	172	}
f4b93ba9	173	dev->size = simc_lseek(dev->fd, 0, SEEK_END);
b6c7e873 VP	174	set_capacity(dev->gd, dev->size >> SECTOR_SHIFT);
	175	dev->filename = filename;
	176	pr_info("SIMDISK: %s=%s\n", dev->gd->disk_name, dev->filename);
	177	out:
	178	if (err)
	179	kfree(filename);
	180	spin_unlock(&dev->lock);
	181
	182	return err;
	183	}
	184
	185	static int simdisk_detach(struct simdisk *dev)
	186	{
	187	int err = 0;
	188
	189	spin_lock(&dev->lock);
	190
	191	if (dev->users != 0) {
	192	err = -EBUSY;
	193	} else if (dev->fd != -1) {
	194	if (simc_close(dev->fd)) {
	195	pr_err("SIMDISK: error closing %s: %d\n",
	196	dev->filename, errno);
	197	err = -EIO;
	198	} else {
	199	pr_info("SIMDISK: %s detached from %s\n",
	200	dev->gd->disk_name, dev->filename);
	201	dev->fd = -1;
	202	kfree(dev->filename);
	203	dev->filename = NULL;
	204	}
	205	}
	206	spin_unlock(&dev->lock);
	207	return err;
	208	}
	209
a69755b1 AV	210	static ssize_t proc_read_simdisk(struct file file, char __user buf,
a69755b1 AV	211	size_t size, loff_t *ppos)
b6c7e873	212	{
d9dda78b	213	struct simdisk *dev = PDE_DATA(file_inode(file));
0757f615	214	const char *s = dev->filename;
a69755b1 AV	215	if (s) {
	216	ssize_t n = simple_read_from_buffer(buf, size, ppos,
	217	s, strlen(s));
	218	if (n < 0)
	219	return n;
	220	buf += n;
	221	size -= n;
	222	}
	223	return simple_read_from_buffer(buf, size, ppos, "\n", 1);
b6c7e873 VP	224	}
b6c7e873 VP	225
a69755b1	226	static ssize_t proc_write_simdisk(struct file file, const char __user buf,
4fe56e80	227	size_t count, loff_t *ppos)
b6c7e873 VP	228	{
b6c7e873 VP	229	char *tmp = kmalloc(count + 1, GFP_KERNEL);
d9dda78b	230	struct simdisk *dev = PDE_DATA(file_inode(file));
b6c7e873 VP	231	int err;
	232
	233	if (tmp == NULL)
	234	return -ENOMEM;
0757f615	235	if (copy_from_user(tmp, buf, count)) {
b6c7e873 VP	236	err = -EFAULT;
	237	goto out_free;
	238	}
	239
	240	err = simdisk_detach(dev);
	241	if (err != 0)
	242	goto out_free;
	243
	244	if (count > 0 && tmp[count - 1] == '\n')
	245	tmp[count - 1] = 0;
	246	else
	247	tmp[count] = 0;
	248
	249	if (tmp[0])
	250	err = simdisk_attach(dev, tmp);
	251
	252	if (err == 0)
	253	err = count;
	254	out_free:
	255	kfree(tmp);
	256	return err;
	257	}
	258
a69755b1 AV	259	static const struct file_operations fops = {
	260	.read = proc_read_simdisk,
	261	.write = proc_write_simdisk,
	262	.llseek = default_llseek,
	263	};
	264
b6c7e873 VP	265	static int __init simdisk_setup(struct simdisk *dev, int which,
	266	struct proc_dir_entry *procdir)
	267	{
	268	char tmp[2] = { '0' + which, 0 };
	269
	270	dev->fd = -1;
	271	dev->filename = NULL;
	272	spin_lock_init(&dev->lock);
	273	dev->users = 0;
	274
	275	dev->queue = blk_alloc_queue(GFP_KERNEL);
	276	if (dev->queue == NULL) {
	277	pr_err("blk_alloc_queue failed\n");
	278	goto out_alloc_queue;
	279	}
	280
	281	blk_queue_make_request(dev->queue, simdisk_make_request);
	282	dev->queue->queuedata = dev;
	283
	284	dev->gd = alloc_disk(SIMDISK_MINORS);
	285	if (dev->gd == NULL) {
	286	pr_err("alloc_disk failed\n");
	287	goto out_alloc_disk;
	288	}
	289	dev->gd->major = simdisk_major;
	290	dev->gd->first_minor = which;
	291	dev->gd->fops = &simdisk_ops;
	292	dev->gd->queue = dev->queue;
	293	dev->gd->private_data = dev;
	294	snprintf(dev->gd->disk_name, 32, "simdisk%d", which);
	295	set_capacity(dev->gd, 0);
	296	add_disk(dev->gd);
	297
a69755b1	298	dev->procfile = proc_create_data(tmp, 0644, procdir, &fops, dev);
b6c7e873 VP	299	return 0;
	300
	301	out_alloc_disk:
	302	blk_cleanup_queue(dev->queue);
	303	dev->queue = NULL;
	304	out_alloc_queue:
	305	simc_close(dev->fd);
	306	return -EIO;
	307	}
	308
	309	static int __init simdisk_init(void)
	310	{
	311	int i;
	312
	313	if (register_blkdev(simdisk_major, "simdisk") < 0) {
	314	pr_err("SIMDISK: register_blkdev: %d\n", simdisk_major);
	315	return -EIO;
	316	}
	317	pr_info("SIMDISK: major: %d\n", simdisk_major);
	318
	319	if (n_files > simdisk_count)
	320	simdisk_count = n_files;
	321	if (simdisk_count > MAX_SIMDISK_COUNT)
	322	simdisk_count = MAX_SIMDISK_COUNT;
	323
	324	sddev = kmalloc(simdisk_count * sizeof(struct simdisk),
	325	GFP_KERNEL);
	326	if (sddev == NULL)
	327	goto out_unregister;
	328
	329	simdisk_procdir = proc_mkdir("simdisk", 0);
	330	if (simdisk_procdir == NULL)
	331	goto out_free_unregister;
	332
	333	for (i = 0; i < simdisk_count; ++i) {
	334	if (simdisk_setup(sddev + i, i, simdisk_procdir) == 0) {
	335	if (filename[i] != NULL && filename[i][0] != 0 &&
	336	(n_files == 0 \|\| i < n_files))
	337	simdisk_attach(sddev + i, filename[i]);
	338	}
	339	}
	340
	341	return 0;
	342
	343	out_free_unregister:
	344	kfree(sddev);
	345	out_unregister:
	346	unregister_blkdev(simdisk_major, "simdisk");
	347	return -ENOMEM;
	348	}
	349	module_init(simdisk_init);
	350
	351	static void simdisk_teardown(struct simdisk *dev, int which,
	352	struct proc_dir_entry *procdir)
	353	{
	354	char tmp[2] = { '0' + which, 0 };
	355
	356	simdisk_detach(dev);
	357	if (dev->gd)
	358	del_gendisk(dev->gd);
	359	if (dev->queue)
	360	blk_cleanup_queue(dev->queue);
	361	remove_proc_entry(tmp, procdir);
	362	}
363
364	static void __exit simdisk_exit(void)
365	{
366	int i;
367
368	for (i = 0; i < simdisk_count; ++i)
369	simdisk_teardown(sddev + i, i, simdisk_procdir);
370	remove_proc_entry("simdisk", 0);
371	kfree(sddev);
372	unregister_blkdev(simdisk_major, "simdisk");
373	}
374	module_exit(simdisk_exit);
375
376	MODULE_ALIAS_BLOCKDEV_MAJOR(SIMDISK_MAJOR);
377
378	MODULE_LICENSE("GPL");