1/*
 2 * loop.h
 3 *
 4 * Written by Theodore Ts'o, 3/29/93.
 5 *
 6 * Copyright 1993 by Theodore Ts'o.  Redistribution of this file is
 7 * permitted under the GNU General Public License.
 8 */
 9#ifndef _LINUX_LOOP_H
10#define _LINUX_LOOP_H
11
12#include <linux/bio.h>
13#include <linux/blkdev.h>
 
14#include <linux/spinlock.h>
15#include <linux/mutex.h>
 
16#include <uapi/linux/loop.h>
17
18/* Possible states of device */
19enum {
20	Lo_unbound,
21	Lo_bound,
22	Lo_rundown,
23};
24
25struct loop_func_table;
26
27struct loop_device {
28	int		lo_number;
29	int		lo_refcnt;
30	loff_t		lo_offset;
31	loff_t		lo_sizelimit;
32	int		lo_flags;
33	int		(*transfer)(struct loop_device *, int cmd,
34				    struct page *raw_page, unsigned raw_off,
35				    struct page *loop_page, unsigned loop_off,
36				    int size, sector_t real_block);
37	char		lo_file_name[LO_NAME_SIZE];
38	char		lo_crypt_name[LO_NAME_SIZE];
39	char		lo_encrypt_key[LO_KEY_SIZE];
40	int		lo_encrypt_key_size;
41	struct loop_func_table *lo_encryption;
42	__u32           lo_init[2];
43	kuid_t		lo_key_owner;	/* Who set the key */
44	int		(*ioctl)(struct loop_device *, int cmd, 
45				 unsigned long arg); 
46
47	struct file *	lo_backing_file;
48	struct block_device *lo_device;
49	unsigned	lo_blocksize;
50	void		*key_data; 
51
52	gfp_t		old_gfp_mask;
53
54	spinlock_t		lo_lock;
55	struct bio_list		lo_bio_list;
56	unsigned int		lo_bio_count;
57	int			lo_state;
58	struct mutex		lo_ctl_mutex;
59	struct task_struct	*lo_thread;
60	wait_queue_head_t	lo_event;
61	/* wait queue for incoming requests */
62	wait_queue_head_t	lo_req_wait;
63
64	struct request_queue	*lo_queue;
 
65	struct gendisk		*lo_disk;
 
 
 
 
 
 
 
 
 
 
66};
67
68/* Support for loadable transfer modules */
69struct loop_func_table {
70	int number;	/* filter type */ 
71	int (*transfer)(struct loop_device *lo, int cmd,
72			struct page *raw_page, unsigned raw_off,
73			struct page *loop_page, unsigned loop_off,
74			int size, sector_t real_block);
75	int (*init)(struct loop_device *, const struct loop_info64 *); 
76	/* release is called from loop_unregister_transfer or clr_fd */
77	int (*release)(struct loop_device *); 
78	int (*ioctl)(struct loop_device *, int cmd, unsigned long arg);
79	struct module *owner;
80}; 
81
82int loop_register_transfer(struct loop_func_table *funcs);
83int loop_unregister_transfer(int number); 
84
85#endif

 1/*
 2 * loop.h
 3 *
 4 * Written by Theodore Ts'o, 3/29/93.
 5 *
 6 * Copyright 1993 by Theodore Ts'o.  Redistribution of this file is
 7 * permitted under the GNU General Public License.
 8 */
 9#ifndef _LINUX_LOOP_H
10#define _LINUX_LOOP_H
11
12#include <linux/bio.h>
13#include <linux/blkdev.h>
14#include <linux/blk-mq.h>
15#include <linux/spinlock.h>
16#include <linux/mutex.h>
17#include <linux/kthread.h>
18#include <uapi/linux/loop.h>
19
20/* Possible states of device */
21enum {
22	Lo_unbound,
23	Lo_bound,
24	Lo_rundown,
25};
26
27struct loop_func_table;
28
29struct loop_device {
30	int		lo_number;
31	atomic_t	lo_refcnt;
32	loff_t		lo_offset;
33	loff_t		lo_sizelimit;
34	int		lo_flags;
35	int		(*transfer)(struct loop_device *, int cmd,
36				    struct page *raw_page, unsigned raw_off,
37				    struct page *loop_page, unsigned loop_off,
38				    int size, sector_t real_block);
39	char		lo_file_name[LO_NAME_SIZE];
40	char		lo_crypt_name[LO_NAME_SIZE];
41	char		lo_encrypt_key[LO_KEY_SIZE];
42	int		lo_encrypt_key_size;
43	struct loop_func_table *lo_encryption;
44	__u32           lo_init[2];
45	kuid_t		lo_key_owner;	/* Who set the key */
46	int		(*ioctl)(struct loop_device *, int cmd, 
47				 unsigned long arg); 
48
49	struct file *	lo_backing_file;
50	struct block_device *lo_device;
 
51	void		*key_data; 
52
53	gfp_t		old_gfp_mask;
54
55	spinlock_t		lo_lock;
 
 
56	int			lo_state;
57	struct mutex		lo_ctl_mutex;
58	struct kthread_worker	worker;
59	struct task_struct	*worker_task;
60	bool			use_dio;
 
61
62	struct request_queue	*lo_queue;
63	struct blk_mq_tag_set	tag_set;
64	struct gendisk		*lo_disk;
65};
66
67struct loop_cmd {
68	struct kthread_work work;
69	bool use_aio; /* use AIO interface to handle I/O */
70	atomic_t ref; /* only for aio */
71	long ret;
72	struct kiocb iocb;
73	struct bio_vec *bvec;
74	struct cgroup_subsys_state *css;
75};
76
77/* Support for loadable transfer modules */
78struct loop_func_table {
79	int number;	/* filter type */ 
80	int (*transfer)(struct loop_device *lo, int cmd,
81			struct page *raw_page, unsigned raw_off,
82			struct page *loop_page, unsigned loop_off,
83			int size, sector_t real_block);
84	int (*init)(struct loop_device *, const struct loop_info64 *); 
85	/* release is called from loop_unregister_transfer or clr_fd */
86	int (*release)(struct loop_device *); 
87	int (*ioctl)(struct loop_device *, int cmd, unsigned long arg);
88	struct module *owner;
89}; 
90
91int loop_register_transfer(struct loop_func_table *funcs);
92int loop_unregister_transfer(int number); 
93
94#endif