1dbddf429SAlex Dewar // SPDX-License-Identifier: GPL-2.0
21da177e4SLinus Torvalds /*
3a41421edSAnton Ivanov * Copyright (C) 2018 Cambridge Greys Ltd
4f88f0bdfSAnton Ivanov * Copyright (C) 2015-2016 Anton Ivanov (aivanov@brocade.com)
51da177e4SLinus Torvalds * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
61da177e4SLinus Torvalds */
71da177e4SLinus Torvalds
81da177e4SLinus Torvalds /* 2001-09-28...2002-04-17
91da177e4SLinus Torvalds * Partition stuff by James_McMechan@hotmail.com
101da177e4SLinus Torvalds * old style ubd by setting UBD_SHIFT to 0
111da177e4SLinus Torvalds * 2002-09-27...2002-10-18 massive tinkering for 2.5
121da177e4SLinus Torvalds * partitions have changed in 2.5
131da177e4SLinus Torvalds * 2003-01-29 more tinkering for 2.5.59-1
141da177e4SLinus Torvalds * This should now address the sysfs problems and has
151da177e4SLinus Torvalds * the symlink for devfs to allow for booting with
161da177e4SLinus Torvalds * the common /dev/ubd/discX/... names rather than
171da177e4SLinus Torvalds * only /dev/ubdN/discN this version also has lots of
181da177e4SLinus Torvalds * clean ups preparing for ubd-many.
191da177e4SLinus Torvalds * James McMechan
201da177e4SLinus Torvalds */
211da177e4SLinus Torvalds
221da177e4SLinus Torvalds #define UBD_SHIFT 4
231da177e4SLinus Torvalds
248ea3c06aSAl Viro #include <linux/module.h>
258ea3c06aSAl Viro #include <linux/init.h>
268ea3c06aSAl Viro #include <linux/blkdev.h>
274e6da0feSRichard Weinberger #include <linux/blk-mq.h>
288ea3c06aSAl Viro #include <linux/ata.h>
298ea3c06aSAl Viro #include <linux/hdreg.h>
30b81e0c23SChristoph Hellwig #include <linux/major.h>
318ea3c06aSAl Viro #include <linux/cdrom.h>
328ea3c06aSAl Viro #include <linux/proc_fs.h>
338ea3c06aSAl Viro #include <linux/seq_file.h>
348ea3c06aSAl Viro #include <linux/ctype.h>
358ea3c06aSAl Viro #include <linux/slab.h>
368ea3c06aSAl Viro #include <linux/vmalloc.h>
378ea3c06aSAl Viro #include <linux/platform_device.h>
388ea3c06aSAl Viro #include <linux/scatterlist.h>
398ea3c06aSAl Viro #include <asm/tlbflush.h>
4037185b33SAl Viro #include <kern_util.h>
411da177e4SLinus Torvalds #include "mconsole_kern.h"
4237185b33SAl Viro #include <init.h>
4337185b33SAl Viro #include <irq_kern.h>
448ea3c06aSAl Viro #include "ubd.h"
4537185b33SAl Viro #include <os.h>
461da177e4SLinus Torvalds #include "cow.h"
471da177e4SLinus Torvalds
48a43c8316SAnton Ivanov /* Max request size is determined by sector mask - 32K */
49a43c8316SAnton Ivanov #define UBD_MAX_REQUEST (8 * sizeof(long))
501da177e4SLinus Torvalds
51fc6b6a87SGabriel Krisman Bertazi struct io_desc {
52fc6b6a87SGabriel Krisman Bertazi char *buffer;
53fc6b6a87SGabriel Krisman Bertazi unsigned long length;
54fc6b6a87SGabriel Krisman Bertazi unsigned long sector_mask;
55fc6b6a87SGabriel Krisman Bertazi unsigned long long cow_offset;
56fc6b6a87SGabriel Krisman Bertazi unsigned long bitmap_words[2];
57fc6b6a87SGabriel Krisman Bertazi };
58fc6b6a87SGabriel Krisman Bertazi
591da177e4SLinus Torvalds struct io_thread_req {
6062f96cb0SJeff Dike struct request *req;
611da177e4SLinus Torvalds int fds[2];
621da177e4SLinus Torvalds unsigned long offsets[2];
631da177e4SLinus Torvalds unsigned long long offset;
641da177e4SLinus Torvalds int sectorsize;
651da177e4SLinus Torvalds int error;
66fc6b6a87SGabriel Krisman Bertazi
67fc6b6a87SGabriel Krisman Bertazi int desc_cnt;
68fc6b6a87SGabriel Krisman Bertazi /* io_desc has to be the last element of the struct */
69fc6b6a87SGabriel Krisman Bertazi struct io_desc io_desc[];
701da177e4SLinus Torvalds };
711da177e4SLinus Torvalds
72f88f0bdfSAnton Ivanov
73f88f0bdfSAnton Ivanov static struct io_thread_req * (*irq_req_buffer)[];
74f88f0bdfSAnton Ivanov static struct io_thread_req *irq_remainder;
75f88f0bdfSAnton Ivanov static int irq_remainder_size;
76f88f0bdfSAnton Ivanov
77f88f0bdfSAnton Ivanov static struct io_thread_req * (*io_req_buffer)[];
78f88f0bdfSAnton Ivanov static struct io_thread_req *io_remainder;
79f88f0bdfSAnton Ivanov static int io_remainder_size;
80f88f0bdfSAnton Ivanov
81f88f0bdfSAnton Ivanov
82f88f0bdfSAnton Ivanov
ubd_test_bit(__u64 bit,unsigned char * data)8391acb21fSJeff Dike static inline int ubd_test_bit(__u64 bit, unsigned char *data)
841da177e4SLinus Torvalds {
851da177e4SLinus Torvalds __u64 n;
861da177e4SLinus Torvalds int bits, off;
871da177e4SLinus Torvalds
8891acb21fSJeff Dike bits = sizeof(data[0]) * 8;
891da177e4SLinus Torvalds n = bit / bits;
901da177e4SLinus Torvalds off = bit % bits;
91dc764e50SJeff Dike return (data[n] & (1 << off)) != 0;
921da177e4SLinus Torvalds }
931da177e4SLinus Torvalds
ubd_set_bit(__u64 bit,unsigned char * data)9491acb21fSJeff Dike static inline void ubd_set_bit(__u64 bit, unsigned char *data)
951da177e4SLinus Torvalds {
961da177e4SLinus Torvalds __u64 n;
971da177e4SLinus Torvalds int bits, off;
981da177e4SLinus Torvalds
9991acb21fSJeff Dike bits = sizeof(data[0]) * 8;
1001da177e4SLinus Torvalds n = bit / bits;
1011da177e4SLinus Torvalds off = bit % bits;
10291acb21fSJeff Dike data[n] |= (1 << off);
1031da177e4SLinus Torvalds }
1041da177e4SLinus Torvalds /*End stuff from ubd_user.h*/
1051da177e4SLinus Torvalds
1061da177e4SLinus Torvalds #define DRIVER_NAME "uml-blkdev"
1071da177e4SLinus Torvalds
108d7fb2c38SPaolo 'Blaisorblade' Giarrusso static DEFINE_MUTEX(ubd_lock);
1099a181c58SArnd Bergmann static DEFINE_MUTEX(ubd_mutex); /* replaces BKL, might not be needed */
1101da177e4SLinus Torvalds
111*05bdb996SChristoph Hellwig static int ubd_open(struct gendisk *disk, blk_mode_t mode);
112ae220766SChristoph Hellwig static void ubd_release(struct gendisk *disk);
113*05bdb996SChristoph Hellwig static int ubd_ioctl(struct block_device *bdev, blk_mode_t mode,
1141da177e4SLinus Torvalds unsigned int cmd, unsigned long arg);
115a885c8c4SChristoph Hellwig static int ubd_getgeo(struct block_device *bdev, struct hd_geometry *geo);
1161da177e4SLinus Torvalds
11797d88ac8SPaolo 'Blaisorblade' Giarrusso #define MAX_DEV (16)
1181da177e4SLinus Torvalds
11983d5cde4SAlexey Dobriyan static const struct block_device_operations ubd_blops = {
1201da177e4SLinus Torvalds .owner = THIS_MODULE,
121a625c998SAl Viro .open = ubd_open,
122a625c998SAl Viro .release = ubd_release,
123a625c998SAl Viro .ioctl = ubd_ioctl,
124ab0cf1e4SArnd Bergmann .compat_ioctl = blkdev_compat_ptr_ioctl,
125a885c8c4SChristoph Hellwig .getgeo = ubd_getgeo,
1261da177e4SLinus Torvalds };
1271da177e4SLinus Torvalds
1281da177e4SLinus Torvalds /* Protected by ubd_lock */
1291da177e4SLinus Torvalds static struct gendisk *ubd_gendisk[MAX_DEV];
1301da177e4SLinus Torvalds
1311da177e4SLinus Torvalds #ifdef CONFIG_BLK_DEV_UBD_SYNC
1321da177e4SLinus Torvalds #define OPEN_FLAGS ((struct openflags) { .r = 1, .w = 1, .s = 1, .c = 0, \
1331da177e4SLinus Torvalds .cl = 1 })
1341da177e4SLinus Torvalds #else
1351da177e4SLinus Torvalds #define OPEN_FLAGS ((struct openflags) { .r = 1, .w = 1, .s = 0, .c = 0, \
1361da177e4SLinus Torvalds .cl = 1 })
1371da177e4SLinus Torvalds #endif
1381da177e4SLinus Torvalds static struct openflags global_openflags = OPEN_FLAGS;
1391da177e4SLinus Torvalds
1401da177e4SLinus Torvalds struct cow {
1412a9d32f6SPaolo 'Blaisorblade' Giarrusso /* backing file name */
1421da177e4SLinus Torvalds char *file;
1432a9d32f6SPaolo 'Blaisorblade' Giarrusso /* backing file fd */
1441da177e4SLinus Torvalds int fd;
1451da177e4SLinus Torvalds unsigned long *bitmap;
1461da177e4SLinus Torvalds unsigned long bitmap_len;
1471da177e4SLinus Torvalds int bitmap_offset;
1481da177e4SLinus Torvalds int data_offset;
1491da177e4SLinus Torvalds };
1501da177e4SLinus Torvalds
151a0044bdfSJeff Dike #define MAX_SG 64
152a0044bdfSJeff Dike
1531da177e4SLinus Torvalds struct ubd {
1542a9d32f6SPaolo 'Blaisorblade' Giarrusso /* name (and fd, below) of the file opened for writing, either the
1552a9d32f6SPaolo 'Blaisorblade' Giarrusso * backing or the cow file. */
1561da177e4SLinus Torvalds char *file;
157ef3ba87cSChristopher Obbard char *serial;
1581da177e4SLinus Torvalds int count;
1591da177e4SLinus Torvalds int fd;
1601da177e4SLinus Torvalds __u64 size;
1611da177e4SLinus Torvalds struct openflags boot_openflags;
1621da177e4SLinus Torvalds struct openflags openflags;
16384e945e3SPaolo 'Blaisorblade' Giarrusso unsigned shared:1;
16484e945e3SPaolo 'Blaisorblade' Giarrusso unsigned no_cow:1;
16550109b5aSAnton Ivanov unsigned no_trim:1;
1661da177e4SLinus Torvalds struct cow cow;
1671da177e4SLinus Torvalds struct platform_device pdev;
16862f96cb0SJeff Dike struct request_queue *queue;
1694e6da0feSRichard Weinberger struct blk_mq_tag_set tag_set;
17062f96cb0SJeff Dike spinlock_t lock;
1714e6da0feSRichard Weinberger };
1724e6da0feSRichard Weinberger
1731da177e4SLinus Torvalds #define DEFAULT_COW { \
1741da177e4SLinus Torvalds .file = NULL, \
1751da177e4SLinus Torvalds .fd = -1, \
1761da177e4SLinus Torvalds .bitmap = NULL, \
1771da177e4SLinus Torvalds .bitmap_offset = 0, \
1781da177e4SLinus Torvalds .data_offset = 0, \
1791da177e4SLinus Torvalds }
1801da177e4SLinus Torvalds
1811da177e4SLinus Torvalds #define DEFAULT_UBD { \
1821da177e4SLinus Torvalds .file = NULL, \
183ef3ba87cSChristopher Obbard .serial = NULL, \
1841da177e4SLinus Torvalds .count = 0, \
1851da177e4SLinus Torvalds .fd = -1, \
1861da177e4SLinus Torvalds .size = -1, \
1871da177e4SLinus Torvalds .boot_openflags = OPEN_FLAGS, \
1881da177e4SLinus Torvalds .openflags = OPEN_FLAGS, \
1891da177e4SLinus Torvalds .no_cow = 0, \
19050109b5aSAnton Ivanov .no_trim = 0, \
1916c29256cSJeff Dike .shared = 0, \
1921da177e4SLinus Torvalds .cow = DEFAULT_COW, \
19322e65004SThomas Gleixner .lock = __SPIN_LOCK_UNLOCKED(ubd_devs.lock), \
1941da177e4SLinus Torvalds }
1951da177e4SLinus Torvalds
196b8831a1dSJeff Dike /* Protected by ubd_lock */
1975dc62b1bSWANG Cong static struct ubd ubd_devs[MAX_DEV] = { [0 ... MAX_DEV - 1] = DEFAULT_UBD };
1981da177e4SLinus Torvalds
1994e6da0feSRichard Weinberger static blk_status_t ubd_queue_rq(struct blk_mq_hw_ctx *hctx,
2004e6da0feSRichard Weinberger const struct blk_mq_queue_data *bd);
2014e6da0feSRichard Weinberger
fake_ide_setup(char * str)2021da177e4SLinus Torvalds static int fake_ide_setup(char *str)
2031da177e4SLinus Torvalds {
2047eb90f7eSChristoph Hellwig pr_warn("The fake_ide option has been removed\n");
205dc764e50SJeff Dike return 1;
2061da177e4SLinus Torvalds }
2071da177e4SLinus Torvalds __setup("fake_ide", fake_ide_setup);
2081da177e4SLinus Torvalds
2091da177e4SLinus Torvalds __uml_help(fake_ide_setup,
2101da177e4SLinus Torvalds "fake_ide\n"
2117eb90f7eSChristoph Hellwig " Obsolete stub.\n\n"
2121da177e4SLinus Torvalds );
2131da177e4SLinus Torvalds
parse_unit(char ** ptr)2141da177e4SLinus Torvalds static int parse_unit(char **ptr)
2151da177e4SLinus Torvalds {
2161da177e4SLinus Torvalds char *str = *ptr, *end;
2171da177e4SLinus Torvalds int n = -1;
2181da177e4SLinus Torvalds
2191da177e4SLinus Torvalds if(isdigit(*str)) {
2201da177e4SLinus Torvalds n = simple_strtoul(str, &end, 0);
2211da177e4SLinus Torvalds if(end == str)
222dc764e50SJeff Dike return -1;
2231da177e4SLinus Torvalds *ptr = end;
2241da177e4SLinus Torvalds }
22597d88ac8SPaolo 'Blaisorblade' Giarrusso else if (('a' <= *str) && (*str <= 'z')) {
2261da177e4SLinus Torvalds n = *str - 'a';
2271da177e4SLinus Torvalds str++;
2281da177e4SLinus Torvalds *ptr = str;
2291da177e4SLinus Torvalds }
230dc764e50SJeff Dike return n;
2311da177e4SLinus Torvalds }
2321da177e4SLinus Torvalds
233d8d7c28eSPaolo 'Blaisorblade' Giarrusso /* If *index_out == -1 at exit, the passed option was a general one;
234d8d7c28eSPaolo 'Blaisorblade' Giarrusso * otherwise, the str pointer is used (and owned) inside ubd_devs array, so it
235d8d7c28eSPaolo 'Blaisorblade' Giarrusso * should not be freed on exit.
236d8d7c28eSPaolo 'Blaisorblade' Giarrusso */
ubd_setup_common(char * str,int * index_out,char ** error_out)237f28169d2SJeff Dike static int ubd_setup_common(char *str, int *index_out, char **error_out)
2381da177e4SLinus Torvalds {
2397d314e34SPaolo 'Blaisorblade' Giarrusso struct ubd *ubd_dev;
2401da177e4SLinus Torvalds struct openflags flags = global_openflags;
241ef3ba87cSChristopher Obbard char *file, *backing_file, *serial;
242b8831a1dSJeff Dike int n, err = 0, i;
2431da177e4SLinus Torvalds
2441da177e4SLinus Torvalds if(index_out) *index_out = -1;
2451da177e4SLinus Torvalds n = *str;
2461da177e4SLinus Torvalds if(n == '='){
2471da177e4SLinus Torvalds str++;
2481da177e4SLinus Torvalds if(!strcmp(str, "sync")){
2491da177e4SLinus Torvalds global_openflags = of_sync(global_openflags);
2509ca55299SDaniel Walter return err;
2511da177e4SLinus Torvalds }
2521da177e4SLinus Torvalds
2537eb90f7eSChristoph Hellwig pr_warn("fake major not supported any more\n");
2547eb90f7eSChristoph Hellwig return 0;
2551da177e4SLinus Torvalds }
2561da177e4SLinus Torvalds
2571da177e4SLinus Torvalds n = parse_unit(&str);
2581da177e4SLinus Torvalds if(n < 0){
259f28169d2SJeff Dike *error_out = "Couldn't parse device number";
260f28169d2SJeff Dike return -EINVAL;
2611da177e4SLinus Torvalds }
2621da177e4SLinus Torvalds if(n >= MAX_DEV){
263f28169d2SJeff Dike *error_out = "Device number out of range";
264f28169d2SJeff Dike return 1;
2651da177e4SLinus Torvalds }
2661da177e4SLinus Torvalds
267f28169d2SJeff Dike err = -EBUSY;
268d7fb2c38SPaolo 'Blaisorblade' Giarrusso mutex_lock(&ubd_lock);
2691da177e4SLinus Torvalds
2707d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev = &ubd_devs[n];
2717d314e34SPaolo 'Blaisorblade' Giarrusso if(ubd_dev->file != NULL){
272f28169d2SJeff Dike *error_out = "Device is already configured";
2731da177e4SLinus Torvalds goto out;
2741da177e4SLinus Torvalds }
2751da177e4SLinus Torvalds
2761da177e4SLinus Torvalds if (index_out)
2771da177e4SLinus Torvalds *index_out = n;
2781da177e4SLinus Torvalds
279f28169d2SJeff Dike err = -EINVAL;
28050109b5aSAnton Ivanov for (i = 0; i < sizeof("rscdt="); i++) {
2811da177e4SLinus Torvalds switch (*str) {
2821da177e4SLinus Torvalds case 'r':
2831da177e4SLinus Torvalds flags.w = 0;
2841da177e4SLinus Torvalds break;
2851da177e4SLinus Torvalds case 's':
2861da177e4SLinus Torvalds flags.s = 1;
2871da177e4SLinus Torvalds break;
2881da177e4SLinus Torvalds case 'd':
2897d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->no_cow = 1;
2901da177e4SLinus Torvalds break;
2916c29256cSJeff Dike case 'c':
2927d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->shared = 1;
2936c29256cSJeff Dike break;
29450109b5aSAnton Ivanov case 't':
29550109b5aSAnton Ivanov ubd_dev->no_trim = 1;
29650109b5aSAnton Ivanov break;
2971da177e4SLinus Torvalds case '=':
2981da177e4SLinus Torvalds str++;
2991da177e4SLinus Torvalds goto break_loop;
3001da177e4SLinus Torvalds default:
301f28169d2SJeff Dike *error_out = "Expected '=' or flag letter "
30250109b5aSAnton Ivanov "(r, s, c, t or d)";
3031da177e4SLinus Torvalds goto out;
3041da177e4SLinus Torvalds }
3051da177e4SLinus Torvalds str++;
3061da177e4SLinus Torvalds }
3071da177e4SLinus Torvalds
3081da177e4SLinus Torvalds if (*str == '=')
309f28169d2SJeff Dike *error_out = "Too many flags specified";
3101da177e4SLinus Torvalds else
311f28169d2SJeff Dike *error_out = "Missing '='";
3121da177e4SLinus Torvalds goto out;
3131da177e4SLinus Torvalds
3141da177e4SLinus Torvalds break_loop:
315ef3ba87cSChristopher Obbard file = strsep(&str, ",:");
316ef3ba87cSChristopher Obbard if (*file == '\0')
317ef3ba87cSChristopher Obbard file = NULL;
3181da177e4SLinus Torvalds
319ef3ba87cSChristopher Obbard backing_file = strsep(&str, ",:");
32094c41b3aSHajime Tazaki if (backing_file && *backing_file == '\0')
321ef3ba87cSChristopher Obbard backing_file = NULL;
3221da177e4SLinus Torvalds
323ef3ba87cSChristopher Obbard serial = strsep(&str, ",:");
32494c41b3aSHajime Tazaki if (serial && *serial == '\0')
325ef3ba87cSChristopher Obbard serial = NULL;
326ef3ba87cSChristopher Obbard
327ef3ba87cSChristopher Obbard if (backing_file && ubd_dev->no_cow) {
328f28169d2SJeff Dike *error_out = "Can't specify both 'd' and a cow file";
329f28169d2SJeff Dike goto out;
330f28169d2SJeff Dike }
331ef3ba87cSChristopher Obbard
332f28169d2SJeff Dike err = 0;
333ef3ba87cSChristopher Obbard ubd_dev->file = file;
3347d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->cow.file = backing_file;
335ef3ba87cSChristopher Obbard ubd_dev->serial = serial;
3367d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->boot_openflags = flags;
3371da177e4SLinus Torvalds out:
338d7fb2c38SPaolo 'Blaisorblade' Giarrusso mutex_unlock(&ubd_lock);
339f28169d2SJeff Dike return err;
3401da177e4SLinus Torvalds }
3411da177e4SLinus Torvalds
ubd_setup(char * str)3421da177e4SLinus Torvalds static int ubd_setup(char *str)
3431da177e4SLinus Torvalds {
344f28169d2SJeff Dike char *error;
345f28169d2SJeff Dike int err;
346f28169d2SJeff Dike
347f28169d2SJeff Dike err = ubd_setup_common(str, NULL, &error);
348f28169d2SJeff Dike if(err)
349f28169d2SJeff Dike printk(KERN_ERR "Failed to initialize device with \"%s\" : "
350f28169d2SJeff Dike "%s\n", str, error);
351f28169d2SJeff Dike return 1;
3521da177e4SLinus Torvalds }
3531da177e4SLinus Torvalds
3541da177e4SLinus Torvalds __setup("ubd", ubd_setup);
3551da177e4SLinus Torvalds __uml_help(ubd_setup,
356ef3ba87cSChristopher Obbard "ubd<n><flags>=<filename>[(:|,)<filename2>][(:|,)<serial>]\n"
3571da177e4SLinus Torvalds " This is used to associate a device with a file in the underlying\n"
3581da177e4SLinus Torvalds " filesystem. When specifying two filenames, the first one is the\n"
3591da177e4SLinus Torvalds " COW name and the second is the backing file name. As separator you can\n"
3601da177e4SLinus Torvalds " use either a ':' or a ',': the first one allows writing things like;\n"
3611da177e4SLinus Torvalds " ubd0=~/Uml/root_cow:~/Uml/root_backing_file\n"
3621da177e4SLinus Torvalds " while with a ',' the shell would not expand the 2nd '~'.\n"
363f28169d2SJeff Dike " When using only one filename, UML will detect whether to treat it like\n"
3641da177e4SLinus Torvalds " a COW file or a backing file. To override this detection, add the 'd'\n"
3651da177e4SLinus Torvalds " flag:\n"
3661da177e4SLinus Torvalds " ubd0d=BackingFile\n"
3671da177e4SLinus Torvalds " Usually, there is a filesystem in the file, but \n"
3681da177e4SLinus Torvalds " that's not required. Swap devices containing swap files can be\n"
3691da177e4SLinus Torvalds " specified like this. Also, a file which doesn't contain a\n"
3701da177e4SLinus Torvalds " filesystem can have its contents read in the virtual \n"
3711da177e4SLinus Torvalds " machine by running 'dd' on the device. <n> must be in the range\n"
3721da177e4SLinus Torvalds " 0 to 7. Appending an 'r' to the number will cause that device\n"
3731da177e4SLinus Torvalds " to be mounted read-only. For example ubd1r=./ext_fs. Appending\n"
37420ede453SJeff Dike " an 's' will cause data to be written to disk on the host immediately.\n"
37520ede453SJeff Dike " 'c' will cause the device to be treated as being shared between multiple\n"
37620ede453SJeff Dike " UMLs and file locking will be turned off - this is appropriate for a\n"
37720ede453SJeff Dike " cluster filesystem and inappropriate at almost all other times.\n\n"
37850109b5aSAnton Ivanov " 't' will disable trim/discard support on the device (enabled by default).\n\n"
379ef3ba87cSChristopher Obbard " An optional device serial number can be exposed using the serial parameter\n"
380ef3ba87cSChristopher Obbard " on the cmdline which is exposed as a sysfs entry. This is particularly\n"
381ef3ba87cSChristopher Obbard " useful when a unique number should be given to the device. Note when\n"
382ef3ba87cSChristopher Obbard " specifying a label, the filename2 must be also presented. It can be\n"
383ef3ba87cSChristopher Obbard " an empty string, in which case the backing file is not used:\n"
384ef3ba87cSChristopher Obbard " ubd0=File,,Serial\n"
3851da177e4SLinus Torvalds );
3861da177e4SLinus Torvalds
udb_setup(char * str)3878299ca5cSJeff Dike static int udb_setup(char *str)
3881da177e4SLinus Torvalds {
3891da177e4SLinus Torvalds printk("udb%s specified on command line is almost certainly a ubd -> "
3901da177e4SLinus Torvalds "udb TYPO\n", str);
391dc764e50SJeff Dike return 1;
3921da177e4SLinus Torvalds }
3931da177e4SLinus Torvalds
3941da177e4SLinus Torvalds __setup("udb", udb_setup);
3951da177e4SLinus Torvalds __uml_help(udb_setup,
3961da177e4SLinus Torvalds "udb\n"
3970894e27eSJeff Dike " This option is here solely to catch ubd -> udb typos, which can be\n"
3980894e27eSJeff Dike " to impossible to catch visually unless you specifically look for\n"
3990894e27eSJeff Dike " them. The only result of any option starting with 'udb' is an error\n"
4001da177e4SLinus Torvalds " in the boot output.\n\n"
4011da177e4SLinus Torvalds );
4021da177e4SLinus Torvalds
40391acb21fSJeff Dike /* Only changed by ubd_init, which is an initcall. */
4045dc62b1bSWANG Cong static int thread_fd = -1;
40509ace81cSJeff Dike
406f88f0bdfSAnton Ivanov /* Function to read several request pointers at a time
407f88f0bdfSAnton Ivanov * handling fractional reads if (and as) needed
408f88f0bdfSAnton Ivanov */
409f88f0bdfSAnton Ivanov
bulk_req_safe_read(int fd,struct io_thread_req * (* request_buffer)[],struct io_thread_req ** remainder,int * remainder_size,int max_recs)410f88f0bdfSAnton Ivanov static int bulk_req_safe_read(
411f88f0bdfSAnton Ivanov int fd,
412f88f0bdfSAnton Ivanov struct io_thread_req * (*request_buffer)[],
413f88f0bdfSAnton Ivanov struct io_thread_req **remainder,
414f88f0bdfSAnton Ivanov int *remainder_size,
415f88f0bdfSAnton Ivanov int max_recs
416f88f0bdfSAnton Ivanov )
417f88f0bdfSAnton Ivanov {
418f88f0bdfSAnton Ivanov int n = 0;
419f88f0bdfSAnton Ivanov int res = 0;
420f88f0bdfSAnton Ivanov
421f88f0bdfSAnton Ivanov if (*remainder_size > 0) {
422f88f0bdfSAnton Ivanov memmove(
423f88f0bdfSAnton Ivanov (char *) request_buffer,
424f88f0bdfSAnton Ivanov (char *) remainder, *remainder_size
425f88f0bdfSAnton Ivanov );
426f88f0bdfSAnton Ivanov n = *remainder_size;
427f88f0bdfSAnton Ivanov }
428f88f0bdfSAnton Ivanov
429f88f0bdfSAnton Ivanov res = os_read_file(
430f88f0bdfSAnton Ivanov fd,
431f88f0bdfSAnton Ivanov ((char *) request_buffer) + *remainder_size,
432f88f0bdfSAnton Ivanov sizeof(struct io_thread_req *)*max_recs
433f88f0bdfSAnton Ivanov - *remainder_size
434f88f0bdfSAnton Ivanov );
435f88f0bdfSAnton Ivanov if (res > 0) {
436f88f0bdfSAnton Ivanov n += res;
437f88f0bdfSAnton Ivanov if ((n % sizeof(struct io_thread_req *)) > 0) {
438f88f0bdfSAnton Ivanov /*
439f88f0bdfSAnton Ivanov * Read somehow returned not a multiple of dword
440f88f0bdfSAnton Ivanov * theoretically possible, but never observed in the
441f88f0bdfSAnton Ivanov * wild, so read routine must be able to handle it
442f88f0bdfSAnton Ivanov */
443f88f0bdfSAnton Ivanov *remainder_size = n % sizeof(struct io_thread_req *);
444f88f0bdfSAnton Ivanov WARN(*remainder_size > 0, "UBD IPC read returned a partial result");
445f88f0bdfSAnton Ivanov memmove(
446f88f0bdfSAnton Ivanov remainder,
447f88f0bdfSAnton Ivanov ((char *) request_buffer) +
448f88f0bdfSAnton Ivanov (n/sizeof(struct io_thread_req *))*sizeof(struct io_thread_req *),
449f88f0bdfSAnton Ivanov *remainder_size
450f88f0bdfSAnton Ivanov );
451f88f0bdfSAnton Ivanov n = n - *remainder_size;
452f88f0bdfSAnton Ivanov }
453f88f0bdfSAnton Ivanov } else {
454f88f0bdfSAnton Ivanov n = res;
455f88f0bdfSAnton Ivanov }
456f88f0bdfSAnton Ivanov return n;
457f88f0bdfSAnton Ivanov }
458f88f0bdfSAnton Ivanov
45962f96cb0SJeff Dike /* Called without dev->lock held, and only in interrupt context. */
ubd_handler(void)46091acb21fSJeff Dike static void ubd_handler(void)
46191acb21fSJeff Dike {
46291acb21fSJeff Dike int n;
463f88f0bdfSAnton Ivanov int count;
46409ace81cSJeff Dike
465a0044bdfSJeff Dike while(1){
466f88f0bdfSAnton Ivanov n = bulk_req_safe_read(
467f88f0bdfSAnton Ivanov thread_fd,
468f88f0bdfSAnton Ivanov irq_req_buffer,
469f88f0bdfSAnton Ivanov &irq_remainder,
470f88f0bdfSAnton Ivanov &irq_remainder_size,
471f88f0bdfSAnton Ivanov UBD_REQ_BUFFER_SIZE
472f88f0bdfSAnton Ivanov );
473f88f0bdfSAnton Ivanov if (n < 0) {
474a0044bdfSJeff Dike if(n == -EAGAIN)
475a0044bdfSJeff Dike break;
476a0044bdfSJeff Dike printk(KERN_ERR "spurious interrupt in ubd_handler, "
477a0044bdfSJeff Dike "err = %d\n", -n);
47891acb21fSJeff Dike return;
47991acb21fSJeff Dike }
480f88f0bdfSAnton Ivanov for (count = 0; count < n/sizeof(struct io_thread_req *); count++) {
4814e6da0feSRichard Weinberger struct io_thread_req *io_req = (*irq_req_buffer)[count];
482a0044bdfSJeff Dike
48350109b5aSAnton Ivanov if ((io_req->error == BLK_STS_NOTSUPP) && (req_op(io_req->req) == REQ_OP_DISCARD)) {
48450109b5aSAnton Ivanov blk_queue_max_discard_sectors(io_req->req->q, 0);
48550109b5aSAnton Ivanov blk_queue_max_write_zeroes_sectors(io_req->req->q, 0);
48650109b5aSAnton Ivanov }
48750109b5aSAnton Ivanov blk_mq_end_request(io_req->req, io_req->error);
4884e6da0feSRichard Weinberger kfree(io_req);
489a0044bdfSJeff Dike }
49091acb21fSJeff Dike }
4914e6da0feSRichard Weinberger }
4924e6da0feSRichard Weinberger
ubd_intr(int irq,void * dev)4937bea96fdSAl Viro static irqreturn_t ubd_intr(int irq, void *dev)
4941da177e4SLinus Torvalds {
49591acb21fSJeff Dike ubd_handler();
496dc764e50SJeff Dike return IRQ_HANDLED;
4971da177e4SLinus Torvalds }
4981da177e4SLinus Torvalds
49991acb21fSJeff Dike /* Only changed by ubd_init, which is an initcall. */
50091acb21fSJeff Dike static int io_pid = -1;
50191acb21fSJeff Dike
kill_io_thread(void)5025dc62b1bSWANG Cong static void kill_io_thread(void)
50391acb21fSJeff Dike {
50491acb21fSJeff Dike if(io_pid != -1)
50591acb21fSJeff Dike os_kill_process(io_pid, 1);
50691acb21fSJeff Dike }
50791acb21fSJeff Dike
50891acb21fSJeff Dike __uml_exitcall(kill_io_thread);
50991acb21fSJeff Dike
ubd_file_size(struct ubd * ubd_dev,__u64 * size_out)510d8d7c28eSPaolo 'Blaisorblade' Giarrusso static inline int ubd_file_size(struct ubd *ubd_dev, __u64 *size_out)
5111da177e4SLinus Torvalds {
5121da177e4SLinus Torvalds char *file;
51385356398SRichard Weinberger int fd;
51485356398SRichard Weinberger int err;
5151da177e4SLinus Torvalds
51685356398SRichard Weinberger __u32 version;
51785356398SRichard Weinberger __u32 align;
51885356398SRichard Weinberger char *backing_file;
519853bc0abSArnd Bergmann time64_t mtime;
52085356398SRichard Weinberger unsigned long long size;
52185356398SRichard Weinberger int sector_size;
52285356398SRichard Weinberger int bitmap_offset;
52385356398SRichard Weinberger
52485356398SRichard Weinberger if (ubd_dev->file && ubd_dev->cow.file) {
52585356398SRichard Weinberger file = ubd_dev->cow.file;
52685356398SRichard Weinberger
52785356398SRichard Weinberger goto out;
52885356398SRichard Weinberger }
52985356398SRichard Weinberger
530d4afcba9SMartin Pärtel fd = os_open_file(ubd_dev->file, of_read(OPENFLAGS()), 0);
53185356398SRichard Weinberger if (fd < 0)
53285356398SRichard Weinberger return fd;
53385356398SRichard Weinberger
53485356398SRichard Weinberger err = read_cow_header(file_reader, &fd, &version, &backing_file, \
53585356398SRichard Weinberger &mtime, &size, §or_size, &align, &bitmap_offset);
53685356398SRichard Weinberger os_close_file(fd);
53785356398SRichard Weinberger
53885356398SRichard Weinberger if(err == -EINVAL)
53985356398SRichard Weinberger file = ubd_dev->file;
54085356398SRichard Weinberger else
54185356398SRichard Weinberger file = backing_file;
54285356398SRichard Weinberger
54385356398SRichard Weinberger out:
544dc764e50SJeff Dike return os_file_size(file, size_out);
5451da177e4SLinus Torvalds }
5461da177e4SLinus Torvalds
read_cow_bitmap(int fd,void * buf,int offset,int len)5475dc62b1bSWANG Cong static int read_cow_bitmap(int fd, void *buf, int offset, int len)
5485dc62b1bSWANG Cong {
5495dc62b1bSWANG Cong int err;
5505dc62b1bSWANG Cong
5518c6157b6SAnton Ivanov err = os_pread_file(fd, buf, len, offset);
5525dc62b1bSWANG Cong if (err < 0)
5535dc62b1bSWANG Cong return err;
5545dc62b1bSWANG Cong
5555dc62b1bSWANG Cong return 0;
5565dc62b1bSWANG Cong }
5575dc62b1bSWANG Cong
backing_file_mismatch(char * file,__u64 size,time64_t mtime)558853bc0abSArnd Bergmann static int backing_file_mismatch(char *file, __u64 size, time64_t mtime)
5595dc62b1bSWANG Cong {
560853bc0abSArnd Bergmann time64_t modtime;
5615dc62b1bSWANG Cong unsigned long long actual;
5625dc62b1bSWANG Cong int err;
5635dc62b1bSWANG Cong
5645dc62b1bSWANG Cong err = os_file_modtime(file, &modtime);
5655dc62b1bSWANG Cong if (err < 0) {
5665dc62b1bSWANG Cong printk(KERN_ERR "Failed to get modification time of backing "
5675dc62b1bSWANG Cong "file \"%s\", err = %d\n", file, -err);
5685dc62b1bSWANG Cong return err;
5695dc62b1bSWANG Cong }
5705dc62b1bSWANG Cong
5715dc62b1bSWANG Cong err = os_file_size(file, &actual);
5725dc62b1bSWANG Cong if (err < 0) {
5735dc62b1bSWANG Cong printk(KERN_ERR "Failed to get size of backing file \"%s\", "
5745dc62b1bSWANG Cong "err = %d\n", file, -err);
5755dc62b1bSWANG Cong return err;
5765dc62b1bSWANG Cong }
5775dc62b1bSWANG Cong
5785dc62b1bSWANG Cong if (actual != size) {
5795dc62b1bSWANG Cong /*__u64 can be a long on AMD64 and with %lu GCC complains; so
5805dc62b1bSWANG Cong * the typecast.*/
5815dc62b1bSWANG Cong printk(KERN_ERR "Size mismatch (%llu vs %llu) of COW header "
5825dc62b1bSWANG Cong "vs backing file\n", (unsigned long long) size, actual);
5835dc62b1bSWANG Cong return -EINVAL;
5845dc62b1bSWANG Cong }
5855dc62b1bSWANG Cong if (modtime != mtime) {
586853bc0abSArnd Bergmann printk(KERN_ERR "mtime mismatch (%lld vs %lld) of COW header vs "
5875dc62b1bSWANG Cong "backing file\n", mtime, modtime);
5885dc62b1bSWANG Cong return -EINVAL;
5895dc62b1bSWANG Cong }
5905dc62b1bSWANG Cong return 0;
5915dc62b1bSWANG Cong }
5925dc62b1bSWANG Cong
path_requires_switch(char * from_cmdline,char * from_cow,char * cow)5935dc62b1bSWANG Cong static int path_requires_switch(char *from_cmdline, char *from_cow, char *cow)
5945dc62b1bSWANG Cong {
5955dc62b1bSWANG Cong struct uml_stat buf1, buf2;
5965dc62b1bSWANG Cong int err;
5975dc62b1bSWANG Cong
5985dc62b1bSWANG Cong if (from_cmdline == NULL)
5995dc62b1bSWANG Cong return 0;
6005dc62b1bSWANG Cong if (!strcmp(from_cmdline, from_cow))
6015dc62b1bSWANG Cong return 0;
6025dc62b1bSWANG Cong
6035dc62b1bSWANG Cong err = os_stat_file(from_cmdline, &buf1);
6045dc62b1bSWANG Cong if (err < 0) {
6055dc62b1bSWANG Cong printk(KERN_ERR "Couldn't stat '%s', err = %d\n", from_cmdline,
6065dc62b1bSWANG Cong -err);
6075dc62b1bSWANG Cong return 0;
6085dc62b1bSWANG Cong }
6095dc62b1bSWANG Cong err = os_stat_file(from_cow, &buf2);
6105dc62b1bSWANG Cong if (err < 0) {
6115dc62b1bSWANG Cong printk(KERN_ERR "Couldn't stat '%s', err = %d\n", from_cow,
6125dc62b1bSWANG Cong -err);
6135dc62b1bSWANG Cong return 1;
6145dc62b1bSWANG Cong }
6155dc62b1bSWANG Cong if ((buf1.ust_dev == buf2.ust_dev) && (buf1.ust_ino == buf2.ust_ino))
6165dc62b1bSWANG Cong return 0;
6175dc62b1bSWANG Cong
6185dc62b1bSWANG Cong printk(KERN_ERR "Backing file mismatch - \"%s\" requested, "
6195dc62b1bSWANG Cong "\"%s\" specified in COW header of \"%s\"\n",
6205dc62b1bSWANG Cong from_cmdline, from_cow, cow);
6215dc62b1bSWANG Cong return 1;
6225dc62b1bSWANG Cong }
6235dc62b1bSWANG Cong
open_ubd_file(char * file,struct openflags * openflags,int shared,char ** backing_file_out,int * bitmap_offset_out,unsigned long * bitmap_len_out,int * data_offset_out,int * create_cow_out)6245dc62b1bSWANG Cong static int open_ubd_file(char *file, struct openflags *openflags, int shared,
6255dc62b1bSWANG Cong char **backing_file_out, int *bitmap_offset_out,
6265dc62b1bSWANG Cong unsigned long *bitmap_len_out, int *data_offset_out,
6275dc62b1bSWANG Cong int *create_cow_out)
6285dc62b1bSWANG Cong {
629853bc0abSArnd Bergmann time64_t mtime;
6305dc62b1bSWANG Cong unsigned long long size;
6315dc62b1bSWANG Cong __u32 version, align;
6325dc62b1bSWANG Cong char *backing_file;
6335dc62b1bSWANG Cong int fd, err, sectorsize, asked_switch, mode = 0644;
6345dc62b1bSWANG Cong
6355dc62b1bSWANG Cong fd = os_open_file(file, *openflags, mode);
6365dc62b1bSWANG Cong if (fd < 0) {
6375dc62b1bSWANG Cong if ((fd == -ENOENT) && (create_cow_out != NULL))
6385dc62b1bSWANG Cong *create_cow_out = 1;
6395dc62b1bSWANG Cong if (!openflags->w ||
6405dc62b1bSWANG Cong ((fd != -EROFS) && (fd != -EACCES)))
6415dc62b1bSWANG Cong return fd;
6425dc62b1bSWANG Cong openflags->w = 0;
6435dc62b1bSWANG Cong fd = os_open_file(file, *openflags, mode);
6445dc62b1bSWANG Cong if (fd < 0)
6455dc62b1bSWANG Cong return fd;
6465dc62b1bSWANG Cong }
6475dc62b1bSWANG Cong
6485dc62b1bSWANG Cong if (shared)
6495dc62b1bSWANG Cong printk(KERN_INFO "Not locking \"%s\" on the host\n", file);
6505dc62b1bSWANG Cong else {
6515dc62b1bSWANG Cong err = os_lock_file(fd, openflags->w);
6525dc62b1bSWANG Cong if (err < 0) {
6535dc62b1bSWANG Cong printk(KERN_ERR "Failed to lock '%s', err = %d\n",
6545dc62b1bSWANG Cong file, -err);
6555dc62b1bSWANG Cong goto out_close;
6565dc62b1bSWANG Cong }
6575dc62b1bSWANG Cong }
6585dc62b1bSWANG Cong
6595dc62b1bSWANG Cong /* Successful return case! */
6605dc62b1bSWANG Cong if (backing_file_out == NULL)
6615dc62b1bSWANG Cong return fd;
6625dc62b1bSWANG Cong
6635dc62b1bSWANG Cong err = read_cow_header(file_reader, &fd, &version, &backing_file, &mtime,
6645dc62b1bSWANG Cong &size, §orsize, &align, bitmap_offset_out);
6655dc62b1bSWANG Cong if (err && (*backing_file_out != NULL)) {
6665dc62b1bSWANG Cong printk(KERN_ERR "Failed to read COW header from COW file "
6675dc62b1bSWANG Cong "\"%s\", errno = %d\n", file, -err);
6685dc62b1bSWANG Cong goto out_close;
6695dc62b1bSWANG Cong }
6705dc62b1bSWANG Cong if (err)
6715dc62b1bSWANG Cong return fd;
6725dc62b1bSWANG Cong
6735dc62b1bSWANG Cong asked_switch = path_requires_switch(*backing_file_out, backing_file,
6745dc62b1bSWANG Cong file);
6755dc62b1bSWANG Cong
6765dc62b1bSWANG Cong /* Allow switching only if no mismatch. */
6775dc62b1bSWANG Cong if (asked_switch && !backing_file_mismatch(*backing_file_out, size,
6785dc62b1bSWANG Cong mtime)) {
6795dc62b1bSWANG Cong printk(KERN_ERR "Switching backing file to '%s'\n",
6805dc62b1bSWANG Cong *backing_file_out);
6815dc62b1bSWANG Cong err = write_cow_header(file, fd, *backing_file_out,
6825dc62b1bSWANG Cong sectorsize, align, &size);
6835dc62b1bSWANG Cong if (err) {
6845dc62b1bSWANG Cong printk(KERN_ERR "Switch failed, errno = %d\n", -err);
6855dc62b1bSWANG Cong goto out_close;
6865dc62b1bSWANG Cong }
6875dc62b1bSWANG Cong } else {
6885dc62b1bSWANG Cong *backing_file_out = backing_file;
6895dc62b1bSWANG Cong err = backing_file_mismatch(*backing_file_out, size, mtime);
6905dc62b1bSWANG Cong if (err)
6915dc62b1bSWANG Cong goto out_close;
6925dc62b1bSWANG Cong }
6935dc62b1bSWANG Cong
6945dc62b1bSWANG Cong cow_sizes(version, size, sectorsize, align, *bitmap_offset_out,
6955dc62b1bSWANG Cong bitmap_len_out, data_offset_out);
6965dc62b1bSWANG Cong
6975dc62b1bSWANG Cong return fd;
6985dc62b1bSWANG Cong out_close:
6995dc62b1bSWANG Cong os_close_file(fd);
7005dc62b1bSWANG Cong return err;
7015dc62b1bSWANG Cong }
7025dc62b1bSWANG Cong
create_cow_file(char * cow_file,char * backing_file,struct openflags flags,int sectorsize,int alignment,int * bitmap_offset_out,unsigned long * bitmap_len_out,int * data_offset_out)7035dc62b1bSWANG Cong static int create_cow_file(char *cow_file, char *backing_file,
7045dc62b1bSWANG Cong struct openflags flags,
7055dc62b1bSWANG Cong int sectorsize, int alignment, int *bitmap_offset_out,
7065dc62b1bSWANG Cong unsigned long *bitmap_len_out, int *data_offset_out)
7075dc62b1bSWANG Cong {
7085dc62b1bSWANG Cong int err, fd;
7095dc62b1bSWANG Cong
7105dc62b1bSWANG Cong flags.c = 1;
7115dc62b1bSWANG Cong fd = open_ubd_file(cow_file, &flags, 0, NULL, NULL, NULL, NULL, NULL);
7125dc62b1bSWANG Cong if (fd < 0) {
7135dc62b1bSWANG Cong err = fd;
7145dc62b1bSWANG Cong printk(KERN_ERR "Open of COW file '%s' failed, errno = %d\n",
7155dc62b1bSWANG Cong cow_file, -err);
7165dc62b1bSWANG Cong goto out;
7175dc62b1bSWANG Cong }
7185dc62b1bSWANG Cong
7195dc62b1bSWANG Cong err = init_cow_file(fd, cow_file, backing_file, sectorsize, alignment,
7205dc62b1bSWANG Cong bitmap_offset_out, bitmap_len_out,
7215dc62b1bSWANG Cong data_offset_out);
7225dc62b1bSWANG Cong if (!err)
7235dc62b1bSWANG Cong return fd;
7245dc62b1bSWANG Cong os_close_file(fd);
7255dc62b1bSWANG Cong out:
7265dc62b1bSWANG Cong return err;
7275dc62b1bSWANG Cong }
7285dc62b1bSWANG Cong
ubd_close_dev(struct ubd * ubd_dev)7295f75a4f8SPaolo 'Blaisorblade' Giarrusso static void ubd_close_dev(struct ubd *ubd_dev)
7301da177e4SLinus Torvalds {
7317d314e34SPaolo 'Blaisorblade' Giarrusso os_close_file(ubd_dev->fd);
7327d314e34SPaolo 'Blaisorblade' Giarrusso if(ubd_dev->cow.file == NULL)
7331da177e4SLinus Torvalds return;
7341da177e4SLinus Torvalds
7357d314e34SPaolo 'Blaisorblade' Giarrusso os_close_file(ubd_dev->cow.fd);
7367d314e34SPaolo 'Blaisorblade' Giarrusso vfree(ubd_dev->cow.bitmap);
7377d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->cow.bitmap = NULL;
7381da177e4SLinus Torvalds }
7391da177e4SLinus Torvalds
ubd_open_dev(struct ubd * ubd_dev)7407d314e34SPaolo 'Blaisorblade' Giarrusso static int ubd_open_dev(struct ubd *ubd_dev)
7411da177e4SLinus Torvalds {
7421da177e4SLinus Torvalds struct openflags flags;
7431da177e4SLinus Torvalds char **back_ptr;
7441da177e4SLinus Torvalds int err, create_cow, *create_ptr;
7450bf16bffSPaolo 'Blaisorblade' Giarrusso int fd;
7461da177e4SLinus Torvalds
7477d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->openflags = ubd_dev->boot_openflags;
7481da177e4SLinus Torvalds create_cow = 0;
7497d314e34SPaolo 'Blaisorblade' Giarrusso create_ptr = (ubd_dev->cow.file != NULL) ? &create_cow : NULL;
7507d314e34SPaolo 'Blaisorblade' Giarrusso back_ptr = ubd_dev->no_cow ? NULL : &ubd_dev->cow.file;
7510bf16bffSPaolo 'Blaisorblade' Giarrusso
7520bf16bffSPaolo 'Blaisorblade' Giarrusso fd = open_ubd_file(ubd_dev->file, &ubd_dev->openflags, ubd_dev->shared,
7537d314e34SPaolo 'Blaisorblade' Giarrusso back_ptr, &ubd_dev->cow.bitmap_offset,
7547d314e34SPaolo 'Blaisorblade' Giarrusso &ubd_dev->cow.bitmap_len, &ubd_dev->cow.data_offset,
7556c29256cSJeff Dike create_ptr);
7561da177e4SLinus Torvalds
7570bf16bffSPaolo 'Blaisorblade' Giarrusso if((fd == -ENOENT) && create_cow){
7580bf16bffSPaolo 'Blaisorblade' Giarrusso fd = create_cow_file(ubd_dev->file, ubd_dev->cow.file,
759a43c8316SAnton Ivanov ubd_dev->openflags, SECTOR_SIZE, PAGE_SIZE,
7607d314e34SPaolo 'Blaisorblade' Giarrusso &ubd_dev->cow.bitmap_offset,
7617d314e34SPaolo 'Blaisorblade' Giarrusso &ubd_dev->cow.bitmap_len,
7627d314e34SPaolo 'Blaisorblade' Giarrusso &ubd_dev->cow.data_offset);
7630bf16bffSPaolo 'Blaisorblade' Giarrusso if(fd >= 0){
7641da177e4SLinus Torvalds printk(KERN_INFO "Creating \"%s\" as COW file for "
7657d314e34SPaolo 'Blaisorblade' Giarrusso "\"%s\"\n", ubd_dev->file, ubd_dev->cow.file);
7661da177e4SLinus Torvalds }
7671da177e4SLinus Torvalds }
7681da177e4SLinus Torvalds
7690bf16bffSPaolo 'Blaisorblade' Giarrusso if(fd < 0){
7707d314e34SPaolo 'Blaisorblade' Giarrusso printk("Failed to open '%s', errno = %d\n", ubd_dev->file,
7710bf16bffSPaolo 'Blaisorblade' Giarrusso -fd);
7720bf16bffSPaolo 'Blaisorblade' Giarrusso return fd;
7731da177e4SLinus Torvalds }
7740bf16bffSPaolo 'Blaisorblade' Giarrusso ubd_dev->fd = fd;
7751da177e4SLinus Torvalds
7767d314e34SPaolo 'Blaisorblade' Giarrusso if(ubd_dev->cow.file != NULL){
777086fa5ffSMartin K. Petersen blk_queue_max_hw_sectors(ubd_dev->queue, 8 * sizeof(long));
778f4768ffdSJeff Dike
7791da177e4SLinus Torvalds err = -ENOMEM;
780da2486baSJesper Juhl ubd_dev->cow.bitmap = vmalloc(ubd_dev->cow.bitmap_len);
7817d314e34SPaolo 'Blaisorblade' Giarrusso if(ubd_dev->cow.bitmap == NULL){
7821da177e4SLinus Torvalds printk(KERN_ERR "Failed to vmalloc COW bitmap\n");
7831da177e4SLinus Torvalds goto error;
7841da177e4SLinus Torvalds }
7851da177e4SLinus Torvalds flush_tlb_kernel_vm();
7861da177e4SLinus Torvalds
7877d314e34SPaolo 'Blaisorblade' Giarrusso err = read_cow_bitmap(ubd_dev->fd, ubd_dev->cow.bitmap,
7887d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->cow.bitmap_offset,
7897d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->cow.bitmap_len);
7901da177e4SLinus Torvalds if(err < 0)
7911da177e4SLinus Torvalds goto error;
7921da177e4SLinus Torvalds
7937d314e34SPaolo 'Blaisorblade' Giarrusso flags = ubd_dev->openflags;
7941da177e4SLinus Torvalds flags.w = 0;
7957d314e34SPaolo 'Blaisorblade' Giarrusso err = open_ubd_file(ubd_dev->cow.file, &flags, ubd_dev->shared, NULL,
7966c29256cSJeff Dike NULL, NULL, NULL, NULL);
7971da177e4SLinus Torvalds if(err < 0) goto error;
7987d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->cow.fd = err;
7991da177e4SLinus Torvalds }
80050109b5aSAnton Ivanov if (ubd_dev->no_trim == 0) {
80150109b5aSAnton Ivanov ubd_dev->queue->limits.discard_granularity = SECTOR_SIZE;
80250109b5aSAnton Ivanov blk_queue_max_discard_sectors(ubd_dev->queue, UBD_MAX_REQUEST);
80350109b5aSAnton Ivanov blk_queue_max_write_zeroes_sectors(ubd_dev->queue, UBD_MAX_REQUEST);
80450109b5aSAnton Ivanov }
805a43c8316SAnton Ivanov blk_queue_flag_set(QUEUE_FLAG_NONROT, ubd_dev->queue);
806dc764e50SJeff Dike return 0;
8071da177e4SLinus Torvalds error:
8087d314e34SPaolo 'Blaisorblade' Giarrusso os_close_file(ubd_dev->fd);
809dc764e50SJeff Dike return err;
8101da177e4SLinus Torvalds }
8111da177e4SLinus Torvalds
ubd_device_release(struct device * dev)8122e3f5251SJeff Dike static void ubd_device_release(struct device *dev)
8132e3f5251SJeff Dike {
8148691b97bSGreg Kroah-Hartman struct ubd *ubd_dev = dev_get_drvdata(dev);
8152e3f5251SJeff Dike
8164e6da0feSRichard Weinberger blk_mq_free_tag_set(&ubd_dev->tag_set);
8172e3f5251SJeff Dike *ubd_dev = ((struct ubd) DEFAULT_UBD);
8182e3f5251SJeff Dike }
8192e3f5251SJeff Dike
serial_show(struct device * dev,struct device_attribute * attr,char * buf)820ef3ba87cSChristopher Obbard static ssize_t serial_show(struct device *dev,
821ef3ba87cSChristopher Obbard struct device_attribute *attr, char *buf)
822ef3ba87cSChristopher Obbard {
823ef3ba87cSChristopher Obbard struct gendisk *disk = dev_to_disk(dev);
824ef3ba87cSChristopher Obbard struct ubd *ubd_dev = disk->private_data;
825ef3ba87cSChristopher Obbard
826ef3ba87cSChristopher Obbard if (!ubd_dev)
827ef3ba87cSChristopher Obbard return 0;
828ef3ba87cSChristopher Obbard
829ef3ba87cSChristopher Obbard return sprintf(buf, "%s", ubd_dev->serial);
830ef3ba87cSChristopher Obbard }
831ef3ba87cSChristopher Obbard
832ef3ba87cSChristopher Obbard static DEVICE_ATTR_RO(serial);
833ef3ba87cSChristopher Obbard
834ef3ba87cSChristopher Obbard static struct attribute *ubd_attrs[] = {
835ef3ba87cSChristopher Obbard &dev_attr_serial.attr,
836ef3ba87cSChristopher Obbard NULL,
837ef3ba87cSChristopher Obbard };
838ef3ba87cSChristopher Obbard
ubd_attrs_are_visible(struct kobject * kobj,struct attribute * a,int n)839ef3ba87cSChristopher Obbard static umode_t ubd_attrs_are_visible(struct kobject *kobj,
840ef3ba87cSChristopher Obbard struct attribute *a, int n)
841ef3ba87cSChristopher Obbard {
842ef3ba87cSChristopher Obbard return a->mode;
843ef3ba87cSChristopher Obbard }
844ef3ba87cSChristopher Obbard
845ef3ba87cSChristopher Obbard static const struct attribute_group ubd_attr_group = {
846ef3ba87cSChristopher Obbard .attrs = ubd_attrs,
847ef3ba87cSChristopher Obbard .is_visible = ubd_attrs_are_visible,
848ef3ba87cSChristopher Obbard };
849ef3ba87cSChristopher Obbard
850ef3ba87cSChristopher Obbard static const struct attribute_group *ubd_attr_groups[] = {
851ef3ba87cSChristopher Obbard &ubd_attr_group,
852ef3ba87cSChristopher Obbard NULL,
853ef3ba87cSChristopher Obbard };
854ef3ba87cSChristopher Obbard
ubd_disk_register(int major,u64 size,int unit,struct gendisk * disk)85566638f16SLuis Chamberlain static int ubd_disk_register(int major, u64 size, int unit,
85635efb594SChristoph Hellwig struct gendisk *disk)
8571da177e4SLinus Torvalds {
8581da177e4SLinus Torvalds disk->major = major;
8591da177e4SLinus Torvalds disk->first_minor = unit << UBD_SHIFT;
86035efb594SChristoph Hellwig disk->minors = 1 << UBD_SHIFT;
8611da177e4SLinus Torvalds disk->fops = &ubd_blops;
8621da177e4SLinus Torvalds set_capacity(disk, size / 512);
8631da177e4SLinus Torvalds sprintf(disk->disk_name, "ubd%c", 'a' + unit);
8641da177e4SLinus Torvalds
8657d314e34SPaolo 'Blaisorblade' Giarrusso ubd_devs[unit].pdev.id = unit;
8667d314e34SPaolo 'Blaisorblade' Giarrusso ubd_devs[unit].pdev.name = DRIVER_NAME;
8672e3f5251SJeff Dike ubd_devs[unit].pdev.dev.release = ubd_device_release;
8688691b97bSGreg Kroah-Hartman dev_set_drvdata(&ubd_devs[unit].pdev.dev, &ubd_devs[unit]);
8697d314e34SPaolo 'Blaisorblade' Giarrusso platform_device_register(&ubd_devs[unit].pdev);
8701da177e4SLinus Torvalds
8717d314e34SPaolo 'Blaisorblade' Giarrusso disk->private_data = &ubd_devs[unit];
87262f96cb0SJeff Dike disk->queue = ubd_devs[unit].queue;
87366638f16SLuis Chamberlain return device_add_disk(&ubd_devs[unit].pdev.dev, disk, ubd_attr_groups);
8741da177e4SLinus Torvalds }
8751da177e4SLinus Torvalds
876a43c8316SAnton Ivanov #define ROUND_BLOCK(n) ((n + (SECTOR_SIZE - 1)) & (-SECTOR_SIZE))
8771da177e4SLinus Torvalds
8784e6da0feSRichard Weinberger static const struct blk_mq_ops ubd_mq_ops = {
8794e6da0feSRichard Weinberger .queue_rq = ubd_queue_rq,
8804e6da0feSRichard Weinberger };
8814e6da0feSRichard Weinberger
ubd_add(int n,char ** error_out)882f28169d2SJeff Dike static int ubd_add(int n, char **error_out)
8831da177e4SLinus Torvalds {
8847d314e34SPaolo 'Blaisorblade' Giarrusso struct ubd *ubd_dev = &ubd_devs[n];
88535efb594SChristoph Hellwig struct gendisk *disk;
886f28169d2SJeff Dike int err = 0;
8871da177e4SLinus Torvalds
8887d314e34SPaolo 'Blaisorblade' Giarrusso if(ubd_dev->file == NULL)
889ec7cf783SJeff Dike goto out;
8901da177e4SLinus Torvalds
8917d314e34SPaolo 'Blaisorblade' Giarrusso err = ubd_file_size(ubd_dev, &ubd_dev->size);
892f28169d2SJeff Dike if(err < 0){
893f28169d2SJeff Dike *error_out = "Couldn't determine size of device's file";
89480c13749SJeff Dike goto out;
895f28169d2SJeff Dike }
8961da177e4SLinus Torvalds
8977d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->size = ROUND_BLOCK(ubd_dev->size);
8981da177e4SLinus Torvalds
8994e6da0feSRichard Weinberger ubd_dev->tag_set.ops = &ubd_mq_ops;
9004e6da0feSRichard Weinberger ubd_dev->tag_set.queue_depth = 64;
9014e6da0feSRichard Weinberger ubd_dev->tag_set.numa_node = NUMA_NO_NODE;
9024e6da0feSRichard Weinberger ubd_dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
9034e6da0feSRichard Weinberger ubd_dev->tag_set.driver_data = ubd_dev;
9044e6da0feSRichard Weinberger ubd_dev->tag_set.nr_hw_queues = 1;
905a0044bdfSJeff Dike
9064e6da0feSRichard Weinberger err = blk_mq_alloc_tag_set(&ubd_dev->tag_set);
9074e6da0feSRichard Weinberger if (err)
90880c13749SJeff Dike goto out;
9094e6da0feSRichard Weinberger
91035efb594SChristoph Hellwig disk = blk_mq_alloc_disk(&ubd_dev->tag_set, ubd_dev);
91135efb594SChristoph Hellwig if (IS_ERR(disk)) {
91235efb594SChristoph Hellwig err = PTR_ERR(disk);
913aea05eb5SAnton Ivanov goto out_cleanup_tags;
91462f96cb0SJeff Dike }
91535efb594SChristoph Hellwig ubd_dev->queue = disk->queue;
9164e6da0feSRichard Weinberger
917f935a8ceSJens Axboe blk_queue_write_cache(ubd_dev->queue, true, false);
9188a78362cSMartin K. Petersen blk_queue_max_segments(ubd_dev->queue, MAX_SG);
919fc6b6a87SGabriel Krisman Bertazi blk_queue_segment_boundary(ubd_dev->queue, PAGE_SIZE - 1);
92066638f16SLuis Chamberlain err = ubd_disk_register(UBD_MAJOR, ubd_dev->size, n, disk);
92166638f16SLuis Chamberlain if (err)
92266638f16SLuis Chamberlain goto out_cleanup_disk;
92366638f16SLuis Chamberlain
92435efb594SChristoph Hellwig ubd_gendisk[n] = disk;
92535efb594SChristoph Hellwig return 0;
92662f96cb0SJeff Dike
92766638f16SLuis Chamberlain out_cleanup_disk:
9288b9ab626SChristoph Hellwig put_disk(disk);
9294e6da0feSRichard Weinberger out_cleanup_tags:
9304e6da0feSRichard Weinberger blk_mq_free_tag_set(&ubd_dev->tag_set);
93135efb594SChristoph Hellwig out:
93235efb594SChristoph Hellwig return err;
9331da177e4SLinus Torvalds }
9341da177e4SLinus Torvalds
ubd_config(char * str,char ** error_out)935f28169d2SJeff Dike static int ubd_config(char *str, char **error_out)
9361da177e4SLinus Torvalds {
937e7f6552fSPaolo 'Blaisorblade' Giarrusso int n, ret;
9381da177e4SLinus Torvalds
939f28169d2SJeff Dike /* This string is possibly broken up and stored, so it's only
940f28169d2SJeff Dike * freed if ubd_setup_common fails, or if only general options
941f28169d2SJeff Dike * were set.
942f28169d2SJeff Dike */
943970d6e3aSJeff Dike str = kstrdup(str, GFP_KERNEL);
9441da177e4SLinus Torvalds if (str == NULL) {
945f28169d2SJeff Dike *error_out = "Failed to allocate memory";
946f28169d2SJeff Dike return -ENOMEM;
9471da177e4SLinus Torvalds }
948f28169d2SJeff Dike
949f28169d2SJeff Dike ret = ubd_setup_common(str, &n, error_out);
950f28169d2SJeff Dike if (ret)
951e7f6552fSPaolo 'Blaisorblade' Giarrusso goto err_free;
952f28169d2SJeff Dike
953e7f6552fSPaolo 'Blaisorblade' Giarrusso if (n == -1) {
954e7f6552fSPaolo 'Blaisorblade' Giarrusso ret = 0;
955d8d7c28eSPaolo 'Blaisorblade' Giarrusso goto err_free;
956e7f6552fSPaolo 'Blaisorblade' Giarrusso }
9571da177e4SLinus Torvalds
958d7fb2c38SPaolo 'Blaisorblade' Giarrusso mutex_lock(&ubd_lock);
959f28169d2SJeff Dike ret = ubd_add(n, error_out);
960e7f6552fSPaolo 'Blaisorblade' Giarrusso if (ret)
9617d314e34SPaolo 'Blaisorblade' Giarrusso ubd_devs[n].file = NULL;
962d7fb2c38SPaolo 'Blaisorblade' Giarrusso mutex_unlock(&ubd_lock);
9631da177e4SLinus Torvalds
964e7f6552fSPaolo 'Blaisorblade' Giarrusso out:
965e7f6552fSPaolo 'Blaisorblade' Giarrusso return ret;
966e7f6552fSPaolo 'Blaisorblade' Giarrusso
967e7f6552fSPaolo 'Blaisorblade' Giarrusso err_free:
968e7f6552fSPaolo 'Blaisorblade' Giarrusso kfree(str);
969e7f6552fSPaolo 'Blaisorblade' Giarrusso goto out;
9701da177e4SLinus Torvalds }
9711da177e4SLinus Torvalds
ubd_get_config(char * name,char * str,int size,char ** error_out)9721da177e4SLinus Torvalds static int ubd_get_config(char *name, char *str, int size, char **error_out)
9731da177e4SLinus Torvalds {
9747d314e34SPaolo 'Blaisorblade' Giarrusso struct ubd *ubd_dev;
9751da177e4SLinus Torvalds int n, len = 0;
9761da177e4SLinus Torvalds
9771da177e4SLinus Torvalds n = parse_unit(&name);
9781da177e4SLinus Torvalds if((n >= MAX_DEV) || (n < 0)){
9791da177e4SLinus Torvalds *error_out = "ubd_get_config : device number out of range";
980dc764e50SJeff Dike return -1;
9811da177e4SLinus Torvalds }
9821da177e4SLinus Torvalds
9837d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev = &ubd_devs[n];
984d7fb2c38SPaolo 'Blaisorblade' Giarrusso mutex_lock(&ubd_lock);
9851da177e4SLinus Torvalds
9867d314e34SPaolo 'Blaisorblade' Giarrusso if(ubd_dev->file == NULL){
9871da177e4SLinus Torvalds CONFIG_CHUNK(str, size, len, "", 1);
9881da177e4SLinus Torvalds goto out;
9891da177e4SLinus Torvalds }
9901da177e4SLinus Torvalds
9917d314e34SPaolo 'Blaisorblade' Giarrusso CONFIG_CHUNK(str, size, len, ubd_dev->file, 0);
9921da177e4SLinus Torvalds
9937d314e34SPaolo 'Blaisorblade' Giarrusso if(ubd_dev->cow.file != NULL){
9941da177e4SLinus Torvalds CONFIG_CHUNK(str, size, len, ",", 0);
9957d314e34SPaolo 'Blaisorblade' Giarrusso CONFIG_CHUNK(str, size, len, ubd_dev->cow.file, 1);
9961da177e4SLinus Torvalds }
9971da177e4SLinus Torvalds else CONFIG_CHUNK(str, size, len, "", 1);
9981da177e4SLinus Torvalds
9991da177e4SLinus Torvalds out:
1000d7fb2c38SPaolo 'Blaisorblade' Giarrusso mutex_unlock(&ubd_lock);
1001dc764e50SJeff Dike return len;
10021da177e4SLinus Torvalds }
10031da177e4SLinus Torvalds
ubd_id(char ** str,int * start_out,int * end_out)100429d56cfeSJeff Dike static int ubd_id(char **str, int *start_out, int *end_out)
100529d56cfeSJeff Dike {
100629d56cfeSJeff Dike int n;
100729d56cfeSJeff Dike
100829d56cfeSJeff Dike n = parse_unit(str);
100929d56cfeSJeff Dike *start_out = 0;
101029d56cfeSJeff Dike *end_out = MAX_DEV - 1;
101129d56cfeSJeff Dike return n;
101229d56cfeSJeff Dike }
101329d56cfeSJeff Dike
ubd_remove(int n,char ** error_out)1014f28169d2SJeff Dike static int ubd_remove(int n, char **error_out)
10151da177e4SLinus Torvalds {
10162e3f5251SJeff Dike struct gendisk *disk = ubd_gendisk[n];
10177d314e34SPaolo 'Blaisorblade' Giarrusso struct ubd *ubd_dev;
101829d56cfeSJeff Dike int err = -ENODEV;
10191da177e4SLinus Torvalds
1020d7fb2c38SPaolo 'Blaisorblade' Giarrusso mutex_lock(&ubd_lock);
10211da177e4SLinus Torvalds
10227d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev = &ubd_devs[n];
102329d56cfeSJeff Dike
10247d314e34SPaolo 'Blaisorblade' Giarrusso if(ubd_dev->file == NULL)
102529d56cfeSJeff Dike goto out;
102629d56cfeSJeff Dike
102729d56cfeSJeff Dike /* you cannot remove a open disk */
102829d56cfeSJeff Dike err = -EBUSY;
10297d314e34SPaolo 'Blaisorblade' Giarrusso if(ubd_dev->count > 0)
103029d56cfeSJeff Dike goto out;
103129d56cfeSJeff Dike
10321da177e4SLinus Torvalds ubd_gendisk[n] = NULL;
1033b47d2debSJeff Dike if(disk != NULL){
1034b47d2debSJeff Dike del_gendisk(disk);
10358b9ab626SChristoph Hellwig put_disk(disk);
10361da177e4SLinus Torvalds }
10371da177e4SLinus Torvalds
10381da177e4SLinus Torvalds err = 0;
10392e3f5251SJeff Dike platform_device_unregister(&ubd_dev->pdev);
10401da177e4SLinus Torvalds out:
1041d7fb2c38SPaolo 'Blaisorblade' Giarrusso mutex_unlock(&ubd_lock);
104229d56cfeSJeff Dike return err;
10431da177e4SLinus Torvalds }
10441da177e4SLinus Torvalds
1045f28169d2SJeff Dike /* All these are called by mconsole in process context and without
1046b8831a1dSJeff Dike * ubd-specific locks. The structure itself is const except for .list.
1047f28169d2SJeff Dike */
10481da177e4SLinus Torvalds static struct mc_device ubd_mc = {
104984f48d4fSJeff Dike .list = LIST_HEAD_INIT(ubd_mc.list),
10501da177e4SLinus Torvalds .name = "ubd",
10511da177e4SLinus Torvalds .config = ubd_config,
10521da177e4SLinus Torvalds .get_config = ubd_get_config,
105329d56cfeSJeff Dike .id = ubd_id,
10541da177e4SLinus Torvalds .remove = ubd_remove,
10551da177e4SLinus Torvalds };
10561da177e4SLinus Torvalds
ubd_mc_init(void)1057d8d7c28eSPaolo 'Blaisorblade' Giarrusso static int __init ubd_mc_init(void)
10581da177e4SLinus Torvalds {
10591da177e4SLinus Torvalds mconsole_register_dev(&ubd_mc);
10601da177e4SLinus Torvalds return 0;
10611da177e4SLinus Torvalds }
10621da177e4SLinus Torvalds
10631da177e4SLinus Torvalds __initcall(ubd_mc_init);
10641da177e4SLinus Torvalds
ubd0_init(void)1065d8d7c28eSPaolo 'Blaisorblade' Giarrusso static int __init ubd0_init(void)
1066d8d7c28eSPaolo 'Blaisorblade' Giarrusso {
1067d8d7c28eSPaolo 'Blaisorblade' Giarrusso struct ubd *ubd_dev = &ubd_devs[0];
1068d8d7c28eSPaolo 'Blaisorblade' Giarrusso
1069b8831a1dSJeff Dike mutex_lock(&ubd_lock);
1070d8d7c28eSPaolo 'Blaisorblade' Giarrusso if(ubd_dev->file == NULL)
1071d8d7c28eSPaolo 'Blaisorblade' Giarrusso ubd_dev->file = "root_fs";
1072b8831a1dSJeff Dike mutex_unlock(&ubd_lock);
1073b8831a1dSJeff Dike
1074dc764e50SJeff Dike return 0;
1075d8d7c28eSPaolo 'Blaisorblade' Giarrusso }
1076d8d7c28eSPaolo 'Blaisorblade' Giarrusso
1077d8d7c28eSPaolo 'Blaisorblade' Giarrusso __initcall(ubd0_init);
1078d8d7c28eSPaolo 'Blaisorblade' Giarrusso
1079b8831a1dSJeff Dike /* Used in ubd_init, which is an initcall */
10803ae5eaecSRussell King static struct platform_driver ubd_driver = {
10813ae5eaecSRussell King .driver = {
10821da177e4SLinus Torvalds .name = DRIVER_NAME,
10833ae5eaecSRussell King },
10841da177e4SLinus Torvalds };
10851da177e4SLinus Torvalds
ubd_init(void)1086d8d7c28eSPaolo 'Blaisorblade' Giarrusso static int __init ubd_init(void)
10871da177e4SLinus Torvalds {
1088f28169d2SJeff Dike char *error;
1089f28169d2SJeff Dike int i, err;
10901da177e4SLinus Torvalds
1091792dd4fcSChristoph Hellwig if (register_blkdev(UBD_MAJOR, "ubd"))
10921da177e4SLinus Torvalds return -1;
10931da177e4SLinus Torvalds
10946da2ec56SKees Cook irq_req_buffer = kmalloc_array(UBD_REQ_BUFFER_SIZE,
10956da2ec56SKees Cook sizeof(struct io_thread_req *),
1096f88f0bdfSAnton Ivanov GFP_KERNEL
1097f88f0bdfSAnton Ivanov );
1098f88f0bdfSAnton Ivanov irq_remainder = 0;
1099f88f0bdfSAnton Ivanov
1100f88f0bdfSAnton Ivanov if (irq_req_buffer == NULL) {
1101f88f0bdfSAnton Ivanov printk(KERN_ERR "Failed to initialize ubd buffering\n");
1102f88f0bdfSAnton Ivanov return -1;
1103f88f0bdfSAnton Ivanov }
11046da2ec56SKees Cook io_req_buffer = kmalloc_array(UBD_REQ_BUFFER_SIZE,
11056da2ec56SKees Cook sizeof(struct io_thread_req *),
1106f88f0bdfSAnton Ivanov GFP_KERNEL
1107f88f0bdfSAnton Ivanov );
1108f88f0bdfSAnton Ivanov
1109f88f0bdfSAnton Ivanov io_remainder = 0;
1110f88f0bdfSAnton Ivanov
1111f88f0bdfSAnton Ivanov if (io_req_buffer == NULL) {
1112f88f0bdfSAnton Ivanov printk(KERN_ERR "Failed to initialize ubd buffering\n");
1113f88f0bdfSAnton Ivanov return -1;
1114f88f0bdfSAnton Ivanov }
11153ae5eaecSRussell King platform_driver_register(&ubd_driver);
1116b8831a1dSJeff Dike mutex_lock(&ubd_lock);
1117f28169d2SJeff Dike for (i = 0; i < MAX_DEV; i++){
1118f28169d2SJeff Dike err = ubd_add(i, &error);
1119f28169d2SJeff Dike if(err)
1120f28169d2SJeff Dike printk(KERN_ERR "Failed to initialize ubd device %d :"
1121f28169d2SJeff Dike "%s\n", i, error);
1122f28169d2SJeff Dike }
1123b8831a1dSJeff Dike mutex_unlock(&ubd_lock);
11241da177e4SLinus Torvalds return 0;
11251da177e4SLinus Torvalds }
11261da177e4SLinus Torvalds
11271da177e4SLinus Torvalds late_initcall(ubd_init);
11281da177e4SLinus Torvalds
ubd_driver_init(void)1129d8d7c28eSPaolo 'Blaisorblade' Giarrusso static int __init ubd_driver_init(void){
113091acb21fSJeff Dike unsigned long stack;
113191acb21fSJeff Dike int err;
113291acb21fSJeff Dike
113391acb21fSJeff Dike /* Set by CONFIG_BLK_DEV_UBD_SYNC or ubd=sync.*/
113491acb21fSJeff Dike if(global_openflags.s){
113591acb21fSJeff Dike printk(KERN_INFO "ubd: Synchronous mode\n");
113691acb21fSJeff Dike /* Letting ubd=sync be like using ubd#s= instead of ubd#= is
113791acb21fSJeff Dike * enough. So use anyway the io thread. */
113891acb21fSJeff Dike }
11392fcb4090SJohannes Berg stack = alloc_stack(0, 0);
1140558f9b2fSYiFei Zhu io_pid = start_io_thread(stack + PAGE_SIZE, &thread_fd);
114191acb21fSJeff Dike if(io_pid < 0){
114291acb21fSJeff Dike printk(KERN_ERR
114391acb21fSJeff Dike "ubd : Failed to start I/O thread (errno = %d) - "
114491acb21fSJeff Dike "falling back to synchronous I/O\n", -io_pid);
114591acb21fSJeff Dike io_pid = -1;
1146dc764e50SJeff Dike return 0;
114791acb21fSJeff Dike }
114891acb21fSJeff Dike err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr,
1149c0b79a90SYong Zhang 0, "ubd", ubd_devs);
115036d46a59SJohannes Berg if(err < 0)
115191acb21fSJeff Dike printk(KERN_ERR "um_request_irq failed - errno = %d\n", -err);
1152f4c57a78SJeff Dike return 0;
115391acb21fSJeff Dike }
115491acb21fSJeff Dike
115591acb21fSJeff Dike device_initcall(ubd_driver_init);
115691acb21fSJeff Dike
ubd_open(struct gendisk * disk,blk_mode_t mode)1157*05bdb996SChristoph Hellwig static int ubd_open(struct gendisk *disk, blk_mode_t mode)
11581da177e4SLinus Torvalds {
11597d314e34SPaolo 'Blaisorblade' Giarrusso struct ubd *ubd_dev = disk->private_data;
11601da177e4SLinus Torvalds int err = 0;
11611da177e4SLinus Torvalds
11629a181c58SArnd Bergmann mutex_lock(&ubd_mutex);
11637d314e34SPaolo 'Blaisorblade' Giarrusso if(ubd_dev->count == 0){
11647d314e34SPaolo 'Blaisorblade' Giarrusso err = ubd_open_dev(ubd_dev);
11651da177e4SLinus Torvalds if(err){
11661da177e4SLinus Torvalds printk(KERN_ERR "%s: Can't open \"%s\": errno = %d\n",
11677d314e34SPaolo 'Blaisorblade' Giarrusso disk->disk_name, ubd_dev->file, -err);
11681da177e4SLinus Torvalds goto out;
11691da177e4SLinus Torvalds }
11701da177e4SLinus Torvalds }
11717d314e34SPaolo 'Blaisorblade' Giarrusso ubd_dev->count++;
11727d314e34SPaolo 'Blaisorblade' Giarrusso set_disk_ro(disk, !ubd_dev->openflags.w);
11731da177e4SLinus Torvalds out:
11749a181c58SArnd Bergmann mutex_unlock(&ubd_mutex);
1175dc764e50SJeff Dike return err;
11761da177e4SLinus Torvalds }
11771da177e4SLinus Torvalds
ubd_release(struct gendisk * disk)1178ae220766SChristoph Hellwig static void ubd_release(struct gendisk *disk)
11791da177e4SLinus Torvalds {
11807d314e34SPaolo 'Blaisorblade' Giarrusso struct ubd *ubd_dev = disk->private_data;
11811da177e4SLinus Torvalds
11829a181c58SArnd Bergmann mutex_lock(&ubd_mutex);
11837d314e34SPaolo 'Blaisorblade' Giarrusso if(--ubd_dev->count == 0)
11845f75a4f8SPaolo 'Blaisorblade' Giarrusso ubd_close_dev(ubd_dev);
11859a181c58SArnd Bergmann mutex_unlock(&ubd_mutex);
11861da177e4SLinus Torvalds }
11871da177e4SLinus Torvalds
cowify_bitmap(__u64 io_offset,int length,unsigned long * cow_mask,__u64 * cow_offset,unsigned long * bitmap,__u64 bitmap_offset,unsigned long * bitmap_words,__u64 bitmap_len)118891acb21fSJeff Dike static void cowify_bitmap(__u64 io_offset, int length, unsigned long *cow_mask,
118991acb21fSJeff Dike __u64 *cow_offset, unsigned long *bitmap,
119091acb21fSJeff Dike __u64 bitmap_offset, unsigned long *bitmap_words,
119191acb21fSJeff Dike __u64 bitmap_len)
11921da177e4SLinus Torvalds {
1193a43c8316SAnton Ivanov __u64 sector = io_offset >> SECTOR_SHIFT;
119491acb21fSJeff Dike int i, update_bitmap = 0;
11951da177e4SLinus Torvalds
1196a43c8316SAnton Ivanov for (i = 0; i < length >> SECTOR_SHIFT; i++) {
119791acb21fSJeff Dike if(cow_mask != NULL)
119891acb21fSJeff Dike ubd_set_bit(i, (unsigned char *) cow_mask);
119991acb21fSJeff Dike if(ubd_test_bit(sector + i, (unsigned char *) bitmap))
120009ace81cSJeff Dike continue;
12011da177e4SLinus Torvalds
120291acb21fSJeff Dike update_bitmap = 1;
120391acb21fSJeff Dike ubd_set_bit(sector + i, (unsigned char *) bitmap);
12041da177e4SLinus Torvalds }
120591acb21fSJeff Dike
120691acb21fSJeff Dike if(!update_bitmap)
120791acb21fSJeff Dike return;
120891acb21fSJeff Dike
120991acb21fSJeff Dike *cow_offset = sector / (sizeof(unsigned long) * 8);
121091acb21fSJeff Dike
121191acb21fSJeff Dike /* This takes care of the case where we're exactly at the end of the
121291acb21fSJeff Dike * device, and *cow_offset + 1 is off the end. So, just back it up
121391acb21fSJeff Dike * by one word. Thanks to Lynn Kerby for the fix and James McMechan
121491acb21fSJeff Dike * for the original diagnosis.
121591acb21fSJeff Dike */
12166d074242SJiri Olsa if (*cow_offset == (DIV_ROUND_UP(bitmap_len,
12176d074242SJiri Olsa sizeof(unsigned long)) - 1))
121891acb21fSJeff Dike (*cow_offset)--;
121991acb21fSJeff Dike
122091acb21fSJeff Dike bitmap_words[0] = bitmap[*cow_offset];
122191acb21fSJeff Dike bitmap_words[1] = bitmap[*cow_offset + 1];
122291acb21fSJeff Dike
122391acb21fSJeff Dike *cow_offset *= sizeof(unsigned long);
122491acb21fSJeff Dike *cow_offset += bitmap_offset;
122591acb21fSJeff Dike }
122691acb21fSJeff Dike
cowify_req(struct io_thread_req * req,struct io_desc * segment,unsigned long offset,unsigned long * bitmap,__u64 bitmap_offset,__u64 bitmap_len)1227fc6b6a87SGabriel Krisman Bertazi static void cowify_req(struct io_thread_req *req, struct io_desc *segment,
1228fc6b6a87SGabriel Krisman Bertazi unsigned long offset, unsigned long *bitmap,
122991acb21fSJeff Dike __u64 bitmap_offset, __u64 bitmap_len)
123091acb21fSJeff Dike {
1231fc6b6a87SGabriel Krisman Bertazi __u64 sector = offset >> SECTOR_SHIFT;
123291acb21fSJeff Dike int i;
123391acb21fSJeff Dike
1234fc6b6a87SGabriel Krisman Bertazi if (segment->length > (sizeof(segment->sector_mask) * 8) << SECTOR_SHIFT)
123591acb21fSJeff Dike panic("Operation too long");
123691acb21fSJeff Dike
1237a43c8316SAnton Ivanov if (req_op(req->req) == REQ_OP_READ) {
1238fc6b6a87SGabriel Krisman Bertazi for (i = 0; i < segment->length >> SECTOR_SHIFT; i++) {
123991acb21fSJeff Dike if(ubd_test_bit(sector + i, (unsigned char *) bitmap))
124091acb21fSJeff Dike ubd_set_bit(i, (unsigned char *)
1241fc6b6a87SGabriel Krisman Bertazi &segment->sector_mask);
124291acb21fSJeff Dike }
1243fc6b6a87SGabriel Krisman Bertazi } else {
1244fc6b6a87SGabriel Krisman Bertazi cowify_bitmap(offset, segment->length, &segment->sector_mask,
1245fc6b6a87SGabriel Krisman Bertazi &segment->cow_offset, bitmap, bitmap_offset,
1246fc6b6a87SGabriel Krisman Bertazi segment->bitmap_words, bitmap_len);
124791acb21fSJeff Dike }
12481da177e4SLinus Torvalds }
12491da177e4SLinus Torvalds
ubd_map_req(struct ubd * dev,struct io_thread_req * io_req,struct request * req)1250fc6b6a87SGabriel Krisman Bertazi static void ubd_map_req(struct ubd *dev, struct io_thread_req *io_req,
1251fc6b6a87SGabriel Krisman Bertazi struct request *req)
12521da177e4SLinus Torvalds {
1253fc6b6a87SGabriel Krisman Bertazi struct bio_vec bvec;
1254fc6b6a87SGabriel Krisman Bertazi struct req_iterator iter;
1255fc6b6a87SGabriel Krisman Bertazi int i = 0;
1256fc6b6a87SGabriel Krisman Bertazi unsigned long byte_offset = io_req->offset;
12577ee1de6eSBart Van Assche enum req_op op = req_op(req);
1258ecb0a83eSChristoph Hellwig
1259fc6b6a87SGabriel Krisman Bertazi if (op == REQ_OP_WRITE_ZEROES || op == REQ_OP_DISCARD) {
1260fc6b6a87SGabriel Krisman Bertazi io_req->io_desc[0].buffer = NULL;
1261fc6b6a87SGabriel Krisman Bertazi io_req->io_desc[0].length = blk_rq_bytes(req);
1262fc6b6a87SGabriel Krisman Bertazi } else {
1263fc6b6a87SGabriel Krisman Bertazi rq_for_each_segment(bvec, req, iter) {
1264fc6b6a87SGabriel Krisman Bertazi BUG_ON(i >= io_req->desc_cnt);
1265fc6b6a87SGabriel Krisman Bertazi
126625d84545SChristoph Hellwig io_req->io_desc[i].buffer = bvec_virt(&bvec);
1267fc6b6a87SGabriel Krisman Bertazi io_req->io_desc[i].length = bvec.bv_len;
1268fc6b6a87SGabriel Krisman Bertazi i++;
1269fc6b6a87SGabriel Krisman Bertazi }
1270fc6b6a87SGabriel Krisman Bertazi }
1271fc6b6a87SGabriel Krisman Bertazi
1272fc6b6a87SGabriel Krisman Bertazi if (dev->cow.file) {
1273fc6b6a87SGabriel Krisman Bertazi for (i = 0; i < io_req->desc_cnt; i++) {
1274fc6b6a87SGabriel Krisman Bertazi cowify_req(io_req, &io_req->io_desc[i], byte_offset,
1275fc6b6a87SGabriel Krisman Bertazi dev->cow.bitmap, dev->cow.bitmap_offset,
1276fc6b6a87SGabriel Krisman Bertazi dev->cow.bitmap_len);
1277fc6b6a87SGabriel Krisman Bertazi byte_offset += io_req->io_desc[i].length;
1278fc6b6a87SGabriel Krisman Bertazi }
1279fc6b6a87SGabriel Krisman Bertazi
1280fc6b6a87SGabriel Krisman Bertazi }
1281fc6b6a87SGabriel Krisman Bertazi }
1282fc6b6a87SGabriel Krisman Bertazi
ubd_alloc_req(struct ubd * dev,struct request * req,int desc_cnt)1283fc6b6a87SGabriel Krisman Bertazi static struct io_thread_req *ubd_alloc_req(struct ubd *dev, struct request *req,
1284fc6b6a87SGabriel Krisman Bertazi int desc_cnt)
1285fc6b6a87SGabriel Krisman Bertazi {
1286fc6b6a87SGabriel Krisman Bertazi struct io_thread_req *io_req;
1287fc6b6a87SGabriel Krisman Bertazi int i;
1288fc6b6a87SGabriel Krisman Bertazi
1289fc6b6a87SGabriel Krisman Bertazi io_req = kmalloc(sizeof(*io_req) +
1290fc6b6a87SGabriel Krisman Bertazi (desc_cnt * sizeof(struct io_desc)),
1291fc6b6a87SGabriel Krisman Bertazi GFP_ATOMIC);
1292ecb0a83eSChristoph Hellwig if (!io_req)
1293fc6b6a87SGabriel Krisman Bertazi return NULL;
129491acb21fSJeff Dike
129562f96cb0SJeff Dike io_req->req = req;
1296ecb0a83eSChristoph Hellwig if (dev->cow.file)
1297ecb0a83eSChristoph Hellwig io_req->fds[0] = dev->cow.fd;
1298ecb0a83eSChristoph Hellwig else
1299ecb0a83eSChristoph Hellwig io_req->fds[0] = dev->fd;
13000033dfd9SAnton Ivanov io_req->error = 0;
130153766defSAnton Ivanov io_req->sectorsize = SECTOR_SIZE;
1302ecb0a83eSChristoph Hellwig io_req->fds[1] = dev->fd;
1303fc6b6a87SGabriel Krisman Bertazi io_req->offset = (u64) blk_rq_pos(req) << SECTOR_SHIFT;
13041da177e4SLinus Torvalds io_req->offsets[0] = 0;
1305ecb0a83eSChristoph Hellwig io_req->offsets[1] = dev->cow.data_offset;
13061da177e4SLinus Torvalds
1307fc6b6a87SGabriel Krisman Bertazi for (i = 0 ; i < desc_cnt; i++) {
1308fc6b6a87SGabriel Krisman Bertazi io_req->io_desc[i].sector_mask = 0;
1309fc6b6a87SGabriel Krisman Bertazi io_req->io_desc[i].cow_offset = -1;
1310fc6b6a87SGabriel Krisman Bertazi }
1311fc6b6a87SGabriel Krisman Bertazi
1312fc6b6a87SGabriel Krisman Bertazi return io_req;
1313fc6b6a87SGabriel Krisman Bertazi }
1314fc6b6a87SGabriel Krisman Bertazi
ubd_submit_request(struct ubd * dev,struct request * req)1315fc6b6a87SGabriel Krisman Bertazi static int ubd_submit_request(struct ubd *dev, struct request *req)
1316fc6b6a87SGabriel Krisman Bertazi {
1317fc6b6a87SGabriel Krisman Bertazi int segs = 0;
1318fc6b6a87SGabriel Krisman Bertazi struct io_thread_req *io_req;
1319fc6b6a87SGabriel Krisman Bertazi int ret;
13207ee1de6eSBart Van Assche enum req_op op = req_op(req);
1321fc6b6a87SGabriel Krisman Bertazi
1322fc6b6a87SGabriel Krisman Bertazi if (op == REQ_OP_FLUSH)
1323fc6b6a87SGabriel Krisman Bertazi segs = 0;
1324fc6b6a87SGabriel Krisman Bertazi else if (op == REQ_OP_WRITE_ZEROES || op == REQ_OP_DISCARD)
1325fc6b6a87SGabriel Krisman Bertazi segs = 1;
1326fc6b6a87SGabriel Krisman Bertazi else
1327fc6b6a87SGabriel Krisman Bertazi segs = blk_rq_nr_phys_segments(req);
1328fc6b6a87SGabriel Krisman Bertazi
1329fc6b6a87SGabriel Krisman Bertazi io_req = ubd_alloc_req(dev, req, segs);
1330fc6b6a87SGabriel Krisman Bertazi if (!io_req)
1331fc6b6a87SGabriel Krisman Bertazi return -ENOMEM;
1332fc6b6a87SGabriel Krisman Bertazi
1333fc6b6a87SGabriel Krisman Bertazi io_req->desc_cnt = segs;
1334fc6b6a87SGabriel Krisman Bertazi if (segs)
1335fc6b6a87SGabriel Krisman Bertazi ubd_map_req(dev, io_req, req);
13361da177e4SLinus Torvalds
1337ecb0a83eSChristoph Hellwig ret = os_write_file(thread_fd, &io_req, sizeof(io_req));
1338ecb0a83eSChristoph Hellwig if (ret != sizeof(io_req)) {
1339ecb0a83eSChristoph Hellwig if (ret != -EAGAIN)
1340ecb0a83eSChristoph Hellwig pr_err("write to io thread failed: %d\n", -ret);
1341bc1d72e7SRichard Weinberger kfree(io_req);
1342bc1d72e7SRichard Weinberger }
1343ecb0a83eSChristoph Hellwig return ret;
1344bc1d72e7SRichard Weinberger }
1345bc1d72e7SRichard Weinberger
ubd_queue_rq(struct blk_mq_hw_ctx * hctx,const struct blk_mq_queue_data * bd)13464e6da0feSRichard Weinberger static blk_status_t ubd_queue_rq(struct blk_mq_hw_ctx *hctx,
13474e6da0feSRichard Weinberger const struct blk_mq_queue_data *bd)
13481da177e4SLinus Torvalds {
13496961cd4dSJens Axboe struct ubd *ubd_dev = hctx->queue->queuedata;
13504e6da0feSRichard Weinberger struct request *req = bd->rq;
135153766defSAnton Ivanov int ret = 0, res = BLK_STS_OK;
13521da177e4SLinus Torvalds
13534e6da0feSRichard Weinberger blk_mq_start_request(req);
1354a0044bdfSJeff Dike
13556961cd4dSJens Axboe spin_lock_irq(&ubd_dev->lock);
13566961cd4dSJens Axboe
135753766defSAnton Ivanov switch (req_op(req)) {
135853766defSAnton Ivanov case REQ_OP_FLUSH:
135953766defSAnton Ivanov case REQ_OP_READ:
136053766defSAnton Ivanov case REQ_OP_WRITE:
136150109b5aSAnton Ivanov case REQ_OP_DISCARD:
136250109b5aSAnton Ivanov case REQ_OP_WRITE_ZEROES:
1363fc6b6a87SGabriel Krisman Bertazi ret = ubd_submit_request(ubd_dev, req);
136450109b5aSAnton Ivanov break;
136553766defSAnton Ivanov default:
136653766defSAnton Ivanov WARN_ON_ONCE(1);
136753766defSAnton Ivanov res = BLK_STS_NOTSUPP;
136853766defSAnton Ivanov }
1369ecb0a83eSChristoph Hellwig
13706961cd4dSJens Axboe spin_unlock_irq(&ubd_dev->lock);
13716961cd4dSJens Axboe
1372d848074bSAnton Ivanov if (ret < 0) {
1373d848074bSAnton Ivanov if (ret == -ENOMEM)
1374d848074bSAnton Ivanov res = BLK_STS_RESOURCE;
1375d848074bSAnton Ivanov else
1376d848074bSAnton Ivanov res = BLK_STS_DEV_RESOURCE;
1377d848074bSAnton Ivanov }
13786961cd4dSJens Axboe
137953766defSAnton Ivanov return res;
138091acb21fSJeff Dike }
13814e6da0feSRichard Weinberger
ubd_getgeo(struct block_device * bdev,struct hd_geometry * geo)1382a885c8c4SChristoph Hellwig static int ubd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1383a885c8c4SChristoph Hellwig {
13847d314e34SPaolo 'Blaisorblade' Giarrusso struct ubd *ubd_dev = bdev->bd_disk->private_data;
1385a885c8c4SChristoph Hellwig
1386a885c8c4SChristoph Hellwig geo->heads = 128;
1387a885c8c4SChristoph Hellwig geo->sectors = 32;
13887d314e34SPaolo 'Blaisorblade' Giarrusso geo->cylinders = ubd_dev->size / (128 * 32 * 512);
1389a885c8c4SChristoph Hellwig return 0;
1390a885c8c4SChristoph Hellwig }
1391a885c8c4SChristoph Hellwig
ubd_ioctl(struct block_device * bdev,blk_mode_t mode,unsigned int cmd,unsigned long arg)1392*05bdb996SChristoph Hellwig static int ubd_ioctl(struct block_device *bdev, blk_mode_t mode,
13931da177e4SLinus Torvalds unsigned int cmd, unsigned long arg)
13941da177e4SLinus Torvalds {
1395a625c998SAl Viro struct ubd *ubd_dev = bdev->bd_disk->private_data;
139673855e13SBartlomiej Zolnierkiewicz u16 ubd_id[ATA_ID_WORDS];
13971da177e4SLinus Torvalds
13981da177e4SLinus Torvalds switch (cmd) {
13991da177e4SLinus Torvalds struct cdrom_volctrl volume;
14001da177e4SLinus Torvalds case HDIO_GET_IDENTITY:
140173855e13SBartlomiej Zolnierkiewicz memset(&ubd_id, 0, ATA_ID_WORDS * 2);
140273855e13SBartlomiej Zolnierkiewicz ubd_id[ATA_ID_CYLS] = ubd_dev->size / (128 * 32 * 512);
140373855e13SBartlomiej Zolnierkiewicz ubd_id[ATA_ID_HEADS] = 128;
140473855e13SBartlomiej Zolnierkiewicz ubd_id[ATA_ID_SECTORS] = 32;
14051da177e4SLinus Torvalds if(copy_to_user((char __user *) arg, (char *) &ubd_id,
14061da177e4SLinus Torvalds sizeof(ubd_id)))
1407dc764e50SJeff Dike return -EFAULT;
1408dc764e50SJeff Dike return 0;
14091da177e4SLinus Torvalds
14101da177e4SLinus Torvalds case CDROMVOLREAD:
14111da177e4SLinus Torvalds if(copy_from_user(&volume, (char __user *) arg, sizeof(volume)))
1412dc764e50SJeff Dike return -EFAULT;
14131da177e4SLinus Torvalds volume.channel0 = 255;
14141da177e4SLinus Torvalds volume.channel1 = 255;
14151da177e4SLinus Torvalds volume.channel2 = 255;
14161da177e4SLinus Torvalds volume.channel3 = 255;
14171da177e4SLinus Torvalds if(copy_to_user((char __user *) arg, &volume, sizeof(volume)))
1418dc764e50SJeff Dike return -EFAULT;
1419dc764e50SJeff Dike return 0;
14201da177e4SLinus Torvalds }
1421dc764e50SJeff Dike return -EINVAL;
14221da177e4SLinus Torvalds }
14231da177e4SLinus Torvalds
map_error(int error_code)1424a43c8316SAnton Ivanov static int map_error(int error_code)
1425a43c8316SAnton Ivanov {
1426a43c8316SAnton Ivanov switch (error_code) {
1427a43c8316SAnton Ivanov case 0:
1428a43c8316SAnton Ivanov return BLK_STS_OK;
1429a43c8316SAnton Ivanov case ENOSYS:
1430a43c8316SAnton Ivanov case EOPNOTSUPP:
1431a43c8316SAnton Ivanov return BLK_STS_NOTSUPP;
1432a43c8316SAnton Ivanov case ENOSPC:
1433a43c8316SAnton Ivanov return BLK_STS_NOSPC;
1434a43c8316SAnton Ivanov }
1435a43c8316SAnton Ivanov return BLK_STS_IOERR;
1436a43c8316SAnton Ivanov }
1437a43c8316SAnton Ivanov
1438a41421edSAnton Ivanov /*
1439a41421edSAnton Ivanov * Everything from here onwards *IS NOT PART OF THE KERNEL*
1440a41421edSAnton Ivanov *
1441a41421edSAnton Ivanov * The following functions are part of UML hypervisor code.
1442a41421edSAnton Ivanov * All functions from here onwards are executed as a helper
1443a41421edSAnton Ivanov * thread and are not allowed to execute any kernel functions.
1444a41421edSAnton Ivanov *
1445a41421edSAnton Ivanov * Any communication must occur strictly via shared memory and IPC.
1446a41421edSAnton Ivanov *
1447a41421edSAnton Ivanov * Do not add printks, locks, kernel memory operations, etc - it
1448a41421edSAnton Ivanov * will result in unpredictable behaviour and/or crashes.
1449a41421edSAnton Ivanov */
1450a41421edSAnton Ivanov
update_bitmap(struct io_thread_req * req,struct io_desc * segment)1451fc6b6a87SGabriel Krisman Bertazi static int update_bitmap(struct io_thread_req *req, struct io_desc *segment)
14521da177e4SLinus Torvalds {
145391acb21fSJeff Dike int n;
145491acb21fSJeff Dike
1455fc6b6a87SGabriel Krisman Bertazi if (segment->cow_offset == -1)
1456a43c8316SAnton Ivanov return map_error(0);
145791acb21fSJeff Dike
1458fc6b6a87SGabriel Krisman Bertazi n = os_pwrite_file(req->fds[1], &segment->bitmap_words,
1459fc6b6a87SGabriel Krisman Bertazi sizeof(segment->bitmap_words), segment->cow_offset);
1460fc6b6a87SGabriel Krisman Bertazi if (n != sizeof(segment->bitmap_words))
1461a43c8316SAnton Ivanov return map_error(-n);
146291acb21fSJeff Dike
1463a43c8316SAnton Ivanov return map_error(0);
146491acb21fSJeff Dike }
146591acb21fSJeff Dike
do_io(struct io_thread_req * req,struct io_desc * desc)1466fc6b6a87SGabriel Krisman Bertazi static void do_io(struct io_thread_req *req, struct io_desc *desc)
146791acb21fSJeff Dike {
146850109b5aSAnton Ivanov char *buf = NULL;
146991acb21fSJeff Dike unsigned long len;
147091acb21fSJeff Dike int n, nsectors, start, end, bit;
14711da177e4SLinus Torvalds __u64 off;
14721da177e4SLinus Torvalds
147350109b5aSAnton Ivanov /* FLUSH is really a special case, we cannot "case" it with others */
147450109b5aSAnton Ivanov
1475a43c8316SAnton Ivanov if (req_op(req->req) == REQ_OP_FLUSH) {
1476805f11a0SRichard Weinberger /* fds[0] is always either the rw image or our cow file */
1477a41421edSAnton Ivanov req->error = map_error(-os_sync_file(req->fds[0]));
1478805f11a0SRichard Weinberger return;
1479805f11a0SRichard Weinberger }
1480805f11a0SRichard Weinberger
1481fc6b6a87SGabriel Krisman Bertazi nsectors = desc->length / req->sectorsize;
14821da177e4SLinus Torvalds start = 0;
14831da177e4SLinus Torvalds do {
1484fc6b6a87SGabriel Krisman Bertazi bit = ubd_test_bit(start, (unsigned char *) &desc->sector_mask);
14851da177e4SLinus Torvalds end = start;
14861da177e4SLinus Torvalds while((end < nsectors) &&
1487fc6b6a87SGabriel Krisman Bertazi (ubd_test_bit(end, (unsigned char *) &desc->sector_mask) == bit))
14881da177e4SLinus Torvalds end++;
14891da177e4SLinus Torvalds
149091acb21fSJeff Dike off = req->offset + req->offsets[bit] +
14911da177e4SLinus Torvalds start * req->sectorsize;
14921da177e4SLinus Torvalds len = (end - start) * req->sectorsize;
1493fc6b6a87SGabriel Krisman Bertazi if (desc->buffer != NULL)
1494fc6b6a87SGabriel Krisman Bertazi buf = &desc->buffer[start * req->sectorsize];
14951da177e4SLinus Torvalds
149650109b5aSAnton Ivanov switch (req_op(req->req)) {
149750109b5aSAnton Ivanov case REQ_OP_READ:
149891acb21fSJeff Dike n = 0;
149991acb21fSJeff Dike do {
150091acb21fSJeff Dike buf = &buf[n];
150191acb21fSJeff Dike len -= n;
15028c6157b6SAnton Ivanov n = os_pread_file(req->fds[bit], buf, len, off);
150391acb21fSJeff Dike if (n < 0) {
1504a43c8316SAnton Ivanov req->error = map_error(-n);
15051da177e4SLinus Torvalds return;
15061da177e4SLinus Torvalds }
150791acb21fSJeff Dike } while((n < len) && (n != 0));
150891acb21fSJeff Dike if (n < len) memset(&buf[n], 0, len - n);
150950109b5aSAnton Ivanov break;
151050109b5aSAnton Ivanov case REQ_OP_WRITE:
15118c6157b6SAnton Ivanov n = os_pwrite_file(req->fds[bit], buf, len, off);
151291acb21fSJeff Dike if(n != len){
1513a43c8316SAnton Ivanov req->error = map_error(-n);
151491acb21fSJeff Dike return;
151591acb21fSJeff Dike }
151650109b5aSAnton Ivanov break;
151750109b5aSAnton Ivanov case REQ_OP_DISCARD:
151850109b5aSAnton Ivanov n = os_falloc_punch(req->fds[bit], off, len);
151950109b5aSAnton Ivanov if (n) {
152050109b5aSAnton Ivanov req->error = map_error(-n);
152150109b5aSAnton Ivanov return;
152250109b5aSAnton Ivanov }
152350109b5aSAnton Ivanov break;
1524d2a0a616SFrédéric Danis case REQ_OP_WRITE_ZEROES:
1525d2a0a616SFrédéric Danis n = os_falloc_zeroes(req->fds[bit], off, len);
1526d2a0a616SFrédéric Danis if (n) {
1527d2a0a616SFrédéric Danis req->error = map_error(-n);
1528d2a0a616SFrédéric Danis return;
1529d2a0a616SFrédéric Danis }
1530d2a0a616SFrédéric Danis break;
153150109b5aSAnton Ivanov default:
153250109b5aSAnton Ivanov WARN_ON_ONCE(1);
153350109b5aSAnton Ivanov req->error = BLK_STS_NOTSUPP;
153450109b5aSAnton Ivanov return;
153591acb21fSJeff Dike }
15361da177e4SLinus Torvalds
15371da177e4SLinus Torvalds start = end;
15381da177e4SLinus Torvalds } while(start < nsectors);
153991acb21fSJeff Dike
1540fc6b6a87SGabriel Krisman Bertazi req->offset += len;
1541fc6b6a87SGabriel Krisman Bertazi req->error = update_bitmap(req, desc);
15421da177e4SLinus Torvalds }
154391acb21fSJeff Dike
154491acb21fSJeff Dike /* Changed in start_io_thread, which is serialized by being called only
154591acb21fSJeff Dike * from ubd_init, which is an initcall.
154691acb21fSJeff Dike */
154791acb21fSJeff Dike int kernel_fd = -1;
154891acb21fSJeff Dike
1549d8d7c28eSPaolo 'Blaisorblade' Giarrusso /* Only changed by the io thread. XXX: currently unused. */
15504dc5a328SXin Gao static int io_count;
155191acb21fSJeff Dike
io_thread(void * arg)155291acb21fSJeff Dike int io_thread(void *arg)
155391acb21fSJeff Dike {
1554f88f0bdfSAnton Ivanov int n, count, written, res;
155591acb21fSJeff Dike
155691d44ff8SRichard Weinberger os_fix_helper_signals();
155791d44ff8SRichard Weinberger
155891acb21fSJeff Dike while(1){
1559f88f0bdfSAnton Ivanov n = bulk_req_safe_read(
1560f88f0bdfSAnton Ivanov kernel_fd,
1561f88f0bdfSAnton Ivanov io_req_buffer,
1562f88f0bdfSAnton Ivanov &io_remainder,
1563f88f0bdfSAnton Ivanov &io_remainder_size,
1564f88f0bdfSAnton Ivanov UBD_REQ_BUFFER_SIZE
1565f88f0bdfSAnton Ivanov );
1566e355b2f5SGabriel Krisman Bertazi if (n <= 0) {
1567e355b2f5SGabriel Krisman Bertazi if (n == -EAGAIN)
1568f88f0bdfSAnton Ivanov ubd_read_poll(-1);
1569e355b2f5SGabriel Krisman Bertazi
1570f88f0bdfSAnton Ivanov continue;
1571f88f0bdfSAnton Ivanov }
1572f88f0bdfSAnton Ivanov
1573f88f0bdfSAnton Ivanov for (count = 0; count < n/sizeof(struct io_thread_req *); count++) {
1574fc6b6a87SGabriel Krisman Bertazi struct io_thread_req *req = (*io_req_buffer)[count];
1575fc6b6a87SGabriel Krisman Bertazi int i;
1576fc6b6a87SGabriel Krisman Bertazi
1577f88f0bdfSAnton Ivanov io_count++;
1578fc6b6a87SGabriel Krisman Bertazi for (i = 0; !req->error && i < req->desc_cnt; i++)
1579fc6b6a87SGabriel Krisman Bertazi do_io(req, &(req->io_desc[i]));
1580fc6b6a87SGabriel Krisman Bertazi
1581f88f0bdfSAnton Ivanov }
1582f88f0bdfSAnton Ivanov
1583f88f0bdfSAnton Ivanov written = 0;
1584f88f0bdfSAnton Ivanov
1585f88f0bdfSAnton Ivanov do {
15866e682d53SGabriel Krisman Bertazi res = os_write_file(kernel_fd,
15876e682d53SGabriel Krisman Bertazi ((char *) io_req_buffer) + written,
15886e682d53SGabriel Krisman Bertazi n - written);
1589ff6a1798SAnton Ivanov if (res >= 0) {
1590f88f0bdfSAnton Ivanov written += res;
159191acb21fSJeff Dike }
1592f88f0bdfSAnton Ivanov if (written < n) {
1593f88f0bdfSAnton Ivanov ubd_write_poll(-1);
1594f88f0bdfSAnton Ivanov }
1595f88f0bdfSAnton Ivanov } while (written < n);
159691acb21fSJeff Dike }
159791acb21fSJeff Dike
15981b57e9c2SJeff Dike return 0;
15991b57e9c2SJeff Dike }
1600