shell bypass 403
UnknownSec Shell
:
/
usr
/
src
/
snapapi26-0.8.58
/ [
drwxr-xr-x
]
upload
mass deface
mass delete
console
info server
name :
snumbd26.c
/* snumbd26.c Copyright (C) Acronis, 2004 Written by Vladimir Simonov $Id: snumbd26.c 1262030 2018-01-11 12:33:11Z marina $ */ #include "kernel_config.h" #ifdef HAVE_LINUX_CONFIG #include <linux/config.h> #elif defined(HAVE_LINUX_AUTOCONF) #include <linux/autoconf.h> #elif defined(HAVE_GENERATED_AUTOCONF) #include <generated/autoconf.h> #else #warning "neither linux/config.h nor linux/autoconf.h or generated/autoconf.h found" #endif #ifdef HAVE_SCHED_SIGNAL_H #include <linux/sched/signal.h> #endif #include <linux/module.h> #include <linux/sched.h> #include <linux/kernel.h> #include <linux/errno.h> #include <linux/string.h> #include <linux/file.h> #include <linux/fs.h> #include <linux/init.h> #include <linux/kthread.h> #include <linux/version.h> #if LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0) #include <asm/system.h> #endif #include <asm/uaccess.h> #include <asm/bitops.h> #include <linux/mm.h> #include <linux/highmem.h> #include <linux/slab.h> #include <linux/smp.h> #include <linux/bio.h> #include <linux/blkdev.h> #include <linux/buffer_head.h> #include <linux/interrupt.h> /* for in_interrupt */ #include <linux/poll.h> #include <linux/notifier.h> #include <linux/reboot.h> #ifdef HAVE_IOCTL32_CONVERSIONS #include <linux/ioctl32.h> #endif #include "snumbd.h" #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) #define sn_request_queue request_queue_t #else #define sn_request_queue struct request_queue #endif #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) #define sn_bio_endio(x) bio_endio(x, sn_bio_bi_size(x), 0) #define sn_bio_io_error(x) bio_io_error(x, sn_bio_bi_size(x)) #else #ifdef HAVE_BIO_ENDIO_2ARGS #define sn_bio_endio(x) bio_endio(x, 0) #else #define sn_bio_endio(x) bio_endio(x) #endif /* HAVE_BIO_ENDIO_2ARGS */ #define sn_bio_io_error(x) bio_io_error(x) #endif /* LINUX_VERSION_CODE */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7) #define USE_KERNEL_THREAD #endif #ifdef HAVE_KMAP_ATOMIC_2ARGS #define sn_kmap_atomic(a) kmap_atomic(a, KM_USER0) #define sn_kunmap_atomic(a) kunmap_atomic(a, KM_USER0) #else /* 1 argument */ #define sn_kmap_atomic(a) kmap_atomic(a) #define sn_kunmap_atomic(a) kunmap_atomic(a) #endif #ifdef HAVE_ASM_HAVE_SET_MB #define sn_set_mb set_mb #else #define sn_set_mb smp_store_mb #endif #ifndef HAVE_REQ_WRITE #define REQ_WRITE (1 << BIO_RW) #endif #ifndef HAVE_PAGE_CACHE_RELEASE #define page_cache_release(page) put_page(page) #endif #define MAX_MINOR 255 #define SN_MMAP_PAGES 256 #define SN_MMAP_SIZE (SN_MMAP_PAGES << PAGE_SHIFT) #define DEBUG 0 #define DEBUG_API (1 << 1) #define DEBUG_ALLOC (1 << 2) #define DEBUG_BIO (1 << 3) #define DEBUG_INTERNALS (1 << 4) #define DEBUG_LEVEL (DEBUG_API) #if DEBUG #ifdef inline #undef inline #endif #define inline #define sa_debug(level, fmt, arg...) \ do { \ static const char *func = __FUNCTION__; \ if (((level) & DEBUG_LEVEL) && snumbd_printk_rate_limit())\ printk(KERN_DEBUG "%s(%s,%d): " fmt, func, \ current->comm, current->pid, ##arg); \ } while (0) #else #define sa_debug(fmt,arg...) do { } while (0) #endif #define sa_kdebug(fmt, arg...) \ do { \ static const char *func= __FUNCTION__; \ if (snumbd_printk_rate_limit()) \ printk(KERN_DEBUG "%s(%s,%d): " fmt, func,\ current->comm, current->pid, ##arg); \ } while (0) #define sa_info(fmt, arg...) \ do { \ static const char *func = __FUNCTION__; \ if (snumbd_printk_rate_limit()) \ printk(KERN_INFO "%s(%s,%d): " fmt, func,\ current->comm, current->pid, ##arg); \ } while (0) #define sa_warn(fmt, arg...) \ do { \ static const char *func = __FUNCTION__; \ if (snumbd_printk_rate_limit()) \ printk(KERN_WARNING "%s(%s,%d): " fmt, func,\ current->comm, current->pid, ##arg); \ } while (0) #define sa_error(fmt, arg...) \ do { \ static const char *func = __FUNCTION__; \ if (snumbd_printk_rate_limit()) \ printk(KERN_ERR "%s(%s,%d): " fmt, func,\ current->comm, current->pid, ##arg); \ } while (0) #define sa_BUG(fmt, arg...) \ do { \ static const char *func = __FUNCTION__; \ printk(KERN_CRIT "%s(%s,%d): " fmt, func, \ current->comm, current->pid, ##arg); \ BUG(); \ } while (0) #define sn_is_power_of_2(x) ((x) != 0 && (((x) & ((x) - 1)) == 0)) #if defined(__x86_64) && defined (HAVE_IOCTL32_H) && defined(CONFIG_COMPAT) && !defined(HAVE_COMPAT_IOCTL) #define HAVE_IOCTL32_CONVERSION #endif #ifdef HAVE_FOPS_RELEASE_VOID #define FILE_OPS_RELEASE_RETURN_VALUE void #define FILE_OPS_RELEASE_RETURN_STATUS #else #define FILE_OPS_RELEASE_RETURN_VALUE int #define FILE_OPS_RELEASE_RETURN_STATUS 0 #endif static int snumbd_init_ok; static int snumbdctl_major; static int snumbd_major; static LIST_HEAD(sessions_list); static LIST_HEAD(notinited_list); static int sessions_count; /* sessions_list & noninit_sessions_list protection */ #ifdef HAVE_SPIN_LOCK_UNLOCKED static spinlock_t sessions_lock = SPIN_LOCK_UNLOCKED; #else static DEFINE_SPINLOCK(sessions_lock); #endif /* protects 'session->s_disk->private_data' */ #ifdef HAVE_SPIN_LOCK_UNLOCKED static spinlock_t disk_lock = SPIN_LOCK_UNLOCKED; #else static DEFINE_SPINLOCK(disk_lock); #endif #ifdef __GFP_HIGHIO #define GFP_SNAPHIGH (__GFP_IO | __GFP_HIGHIO | __GFP_FS | __GFP_HIGHMEM) #else #define GFP_SNAPHIGH (__GFP_IO | __GFP_FS | __GFP_HIGHMEM) #endif #define TIMER_INTERVAL (900*HZ) #ifndef HAVE_FMODE_T typedef unsigned int fmode_t; #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0) #define HAVE_BIO_BVEC_ITER 1 #endif #ifdef HAVE_BIO_BVEC_ITER #define bio_for_each_segment4(bv, bvp, b, i) \ bio_for_each_segment((bv), (b), (i)) typedef struct bvec_iter bvec_iterator_t; #else #define bio_for_each_segment4(bv, bvp, b, i) \ bio_for_each_segment((bvp), (b), (i)) typedef int bvec_iterator_t; #endif #ifdef HAVE_VM_FAULT_2ARGS #define snumbdctl_vm_fault(a, b) snumbdctl_vm_fault(a, b) #else #define snumbdctl_vm_fault(a, b) snumbdctl_vm_fault(b) #endif #ifdef HAVE_VMFAULT_T #define VMFAULT_RETURN_VALUE vm_fault_t #else #define VMFAULT_RETURN_VALUE int #endif static inline sector_t sn_bio_bi_sector(struct bio *bio) { #ifdef HAVE_BVEC_ITER return bio->bi_iter.bi_sector; #else return bio->bi_sector; #endif } static inline unsigned int sn_bio_bi_size(struct bio *bio) { #ifdef HAVE_BVEC_ITER return bio->bi_iter.bi_size; #else return bio->bi_size; #endif } static dev_t sn_bio_dev(struct bio *bio) { #ifndef HAVE_BIO_SET_DEV return bio->bi_bdev->bd_dev; #else return bio_dev(bio); #endif } struct session_struct { struct list_head s_list; /* under sessions_lock */ dev_t s_kdev; unsigned long long s_scount; /* sectors count */ unsigned int s_sector_size; /* sector size */ volatile unsigned int s_state; atomic_t s_users; int s_ro; /* read-only mode */ unsigned int s_hpid; struct gendisk * s_disk; spinlock_t s_misc_lock; /* protects from here to */ /* s_vma */ unsigned int s_ioctlcnt; /* state data */ unsigned int s_ioctlcnt_prev; struct vm_area_struct * s_vma; struct page * s_mpages[SN_MMAP_PAGES];/* mmapped pages */ struct semaphore s_sem; /* session_struct access serialization */ unsigned int s_gpages; /* got pages */ unsigned int s_ppages; /* put pages */ unsigned int s_reads; /* total reads count */ pid_t s_apgrp[2]; /* allowed pgrps */ wait_queue_head_t s_req_put_wq; /* kernel waits for space to put request */ wait_queue_head_t s_req_get_wq; /* userspace waits for request to handle */ #define MT_REQ_MAX 4 struct bio * s_bio[MT_REQ_MAX]; pid_t s_tag[MT_REQ_MAX]; unsigned int s_bio_offset[MT_REQ_MAX];/* offset in mmapped pages */ unsigned s_bio_count; unsigned s_tag_count; unsigned long long s_total_secs_write; unsigned long long s_total_secs_read; }; static void unregister_device(struct session_struct * s); inline static int is_session_usable(struct session_struct *s) { return SNUM_INITED == s->s_state; } static void shutdown_session(struct session_struct *s) { unsigned i; down(&s->s_sem); sn_set_mb(s->s_state, SNUM_SESSION_ERR); /* fail all requests*/ for (i = 0; i < MT_REQ_MAX; ++i) { struct bio *bio = s->s_bio[i]; if (bio) { s->s_bio[i] = NULL; s->s_tag[i] = 0; s->s_bio_offset[i] = 0; sn_bio_io_error(bio); } } s->s_bio_count = 0; s->s_tag_count = 0; wake_up_all(&s->s_req_put_wq); wake_up_all(&s->s_req_get_wq); up(&s->s_sem); } static void get_session(struct session_struct *s) { atomic_inc(&s->s_users); } static void put_session(struct session_struct *s) { if (atomic_dec_and_test(&s->s_users)) { unregister_device(s); spin_lock(&sessions_lock); list_del_init(&s->s_list); s->s_kdev = 0; sessions_count--; spin_unlock(&sessions_lock); kfree(s); } } #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) #include <linux/nsproxy.h> static pid_t sn_current_pgrp(void) { if (!current->nsproxy) return 1; #ifdef HAVE_PID_NS_CHILDREN return task_pgrp_nr_ns(current, current->nsproxy->pid_ns_for_children); #else return task_pgrp_nr_ns(current, current->nsproxy->pid_ns); #endif } #else static pid_t sn_current_pgrp(void) { return process_group(current); } #endif #ifndef HAVE_STRUCT_QUEUE_LIMITS #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31) static void sn_set_queue_block_size(struct request_queue *q, unsigned short size) { blk_queue_logical_block_size(q, size); blk_queue_physical_block_size(q, size); blk_queue_io_min(q, size); } #else static void sn_set_queue_block_size(struct request_queue *q, unsigned short size) { blk_queue_hardsect_size(q, size); } #endif //LINUX_VERSION_CODE #endif // HAVE_STRUCT_QUEUE_LIMITS static int sn_op_is_write(struct bio *bio) { #ifndef HAVE_OP_IS_WRITE return bio->bi_rw & REQ_WRITE; #else return op_is_write(bio_op(bio)); #endif } #ifdef HAVE_OP_IS_WRITE #define BIO_RW_RETURN_VALUE unsigned int #else #define BIO_RW_RETURN_VALUE unsigned long #endif #if (DEBUG != 0) static BIO_RW_RETURN_VALUE get_bio_req_flags(struct bio *bio) { #ifdef HAVE_BIO_OPF return bio->bi_opf; #else return bio->bi_rw; #endif } #endif static int snumbd_printk_rate_limit(void) { static unsigned long count, last; if (jiffies - last > HZ) count = 0; if (count >= 32) return 0; last = jiffies; count++; return 1; } static inline int get_free_minor(void) { dev_t dev; int minor; struct list_head *tmp; minor = 0; repeate: minor++; dev = MKDEV(snumbd_major, minor); list_for_each(tmp, &sessions_list) { struct session_struct *s; s = list_entry(tmp, struct session_struct, s_list); if (s->s_kdev == dev) goto repeate; } return minor; } static int snumbd_ioctl_blk(struct block_device *bdev, fmode_t mode, unsigned cmd, unsigned long arg) { #if DEBUG struct session_struct *s = bdev->bd_disk->private_data; if (s) sa_debug(DEBUG_API, "s=%p dev=%x\n", s, s->s_kdev); #endif return -ENOTTY; } static int snumbd_is_parent_task(unsigned int pid) { #ifdef CONFIG_PREEMPT_RCU return 0; #else int ret = 0; struct task_struct* task; rcu_read_lock(); task = current; while (task && (task != &init_task)) { if (task->pid == pid) { ret = 1; break; } task = rcu_dereference(task->parent); } rcu_read_unlock(); return ret; #endif } static int #ifdef HAVE_BLK_MODE_T snumbd_open_blk(struct gendisk *disk, blk_mode_t mode) #else snumbd_open_blk(struct block_device *bdev, fmode_t mode) #endif { int users; int state; pid_t pgrp; struct session_struct *s; loff_t old_size; loff_t new_size; spin_lock(&disk_lock); #ifdef HAVE_BLK_MODE_T s = disk->private_data; #else s = bdev->bd_disk->private_data; #endif if (!s) { spin_unlock(&disk_lock); return -ENODEV; } users = atomic_read(&s->s_users); spin_unlock(&disk_lock); state = s->s_state; if (state != SNUM_INITED) { sa_info("session (%p, %x) is in wrong state %d\n", s, s->s_kdev, state); return -EACCES; } if (users == 0) { sa_info("dying session detected...(%p, %x)\n", s, s->s_kdev); return -ENODEV; } pgrp = sn_current_pgrp(); /* Allow to open device only programs in device creator's group. This eliminates problems with device access(reference) from udev, multipathd, automount and others. */ if ((pgrp != s->s_apgrp[0]) && (pgrp != s->s_apgrp[1]) && (!snumbd_is_parent_task(s->s_hpid))) { sa_info("Disable access (%d,%d,%d)...\n", pgrp, s->s_apgrp[0], s->s_apgrp[1]); return -EACCES; } get_session(s); /* Note: On first open bdev has zero size */ #ifdef HAVE_BLK_MODE_T struct block_device *bdev = disk->part0; #endif #ifdef HAVE_SET_BLOCKSIZE_REQUIRE_FILE_PTR old_size = bdev_nr_sectors(bdev) << SECTOR_SHIFT; #else old_size = i_size_read(bdev->bd_inode); #endif new_size = s->s_scount * s->s_sector_size; sa_debug(DEBUG_API, "s=%p dev=%x users=%d. osize=%llu, nsize=%llu\n", s, s->s_kdev, atomic_read(&s->s_users), (unsigned long long)old_size, (unsigned long long)new_size); if (old_size != new_size) { #ifdef HAVE_SET_CAPACITY #ifdef HAVE_BLK_MODE_T set_capacity(disk, new_size); #else set_capacity(bdev->bd_disk, new_size); #endif #elif defined(HAVE_BD_SET_NR_SECTORS) bd_set_nr_sectors(bdev, new_size >> SECTOR_SHIFT); #else bd_set_size(bdev, new_size); #endif #ifndef HAVE_SET_BLOCKSIZE_REQUIRE_FILE_PTR set_blocksize(bdev, s->s_sector_size); #endif #ifndef HAVE_BLK_MODE_T #ifdef HAVE_SET_DEVICE_RO set_device_ro(bdev, (s->s_ro != 0)); #else bdev->bd_read_only = (s->s_ro != 0); #endif #else set_disk_ro(disk, (s->s_ro != 0)); #endif // BLK_MODE_T } /* Note: 'put_session()' will be done in 'snumbd_release_blk()' */ return 0; } static FILE_OPS_RELEASE_RETURN_VALUE #ifdef HAVE_FOPS_RELEASE_ONE_ARG snumbd_release_blk(struct gendisk *disk) #else snumbd_release_blk(struct gendisk *disk, fmode_t mode) #endif { struct session_struct *s; spin_lock(&disk_lock); s = disk->private_data; if (!s) { spin_unlock(&disk_lock); return FILE_OPS_RELEASE_RETURN_STATUS; } spin_unlock(&disk_lock); sa_info("dev=%x, IO (sectors) write=%llu read=%llu\n", s->s_kdev, s->s_total_secs_write, s->s_total_secs_read); if (s->s_total_secs_write > 1024 * 1024 && s->s_total_secs_write > (s->s_total_secs_read >> 2)) sa_warn("Ineffective usage - too many write operations."); /* Note: respective 'get_session()' has been done in 'snumbd_open_blk()' */ put_session(s); return FILE_OPS_RELEASE_RETURN_STATUS; } #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28) static int snumbd_open(struct inode *inode, struct file *file) { struct block_device *bdev; bdev = inode->i_bdev; return snumbd_open_blk(bdev, 1); } static FILE_OPS_RELEASE_RETURN_VALUE snumbd_release(struct inode *inode, struct file *file) { struct gendisk *disk; disk = inode->i_bdev->bd_disk; return snumbd_release_blk(disk, 1); } static int snumbd_ioctl(struct inode *inode, struct file *file, unsigned cmd, unsigned long arg) { struct block_device *bdev; bdev = inode->i_bdev; return snumbd_ioctl_blk(bdev, 1, cmd, arg); } #else #define snumbd_open snumbd_open_blk #define snumbd_ioctl snumbd_ioctl_blk #define snumbd_release snumbd_release_blk #endif #if defined (HAVE_BDOPS_SUBMIT_BIO_BLK_QC_T) || defined(HAVE_BDOPS_SUBMIT_BIO_VOID) #define HAVE_BDOPS_SUBMIT_BIO 1 #endif #ifdef HAVE_BDOPS_SUBMIT_BIO #ifdef HAVE_BDOPS_SUBMIT_BIO_VOID #define MAKE_REQUEST_RETURN_VALUE void #define MAKE_REQUEST_EXIT_STATUS #else #define MAKE_REQUEST_RETURN_VALUE blk_qc_t #define MAKE_REQUEST_EXIT_STATUS 0 #endif typedef MAKE_REQUEST_RETURN_VALUE (make_request_fn) (struct bio *bio); #else #ifdef HAVE_MAKE_REQUEST_INT #define MAKE_REQUEST_EXIT_STATUS 0 #define MAKE_REQUEST_RETURN_VALUE int #elif defined(HAVE_MAKE_REQUEST_BLK_QC_T) #define MAKE_REQUEST_EXIT_STATUS 0 #define MAKE_REQUEST_RETURN_VALUE blk_qc_t #else #define MAKE_REQUEST_EXIT_STATUS #define MAKE_REQUEST_RETURN_VALUE void #endif #endif #ifndef HAVE_BDOPS_SUBMIT_BIO static MAKE_REQUEST_RETURN_VALUE snumbd_make_request(sn_request_queue *q, struct bio *bio); #else static MAKE_REQUEST_RETURN_VALUE snumbd_make_request(struct bio *bio); #endif static struct block_device_operations snumbd_bdops = { .owner = THIS_MODULE, .open = snumbd_open, .ioctl = snumbd_ioctl, .release = snumbd_release, #ifdef HAVE_BDOPS_SUBMIT_BIO .submit_bio = snumbd_make_request, #endif }; /* to avoid error on add_disk */ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-result" static int register_device(struct session_struct * s) { sn_request_queue *queue; int ret; ret = -ENOMEM; #ifdef HAVE_STRUCT_QUEUE_LIMITS struct queue_limits lim = { .logical_block_size = s->s_sector_size, .physical_block_size = s->s_sector_size, .io_min = s->s_sector_size, }; #endif sa_debug(DEBUG_API, "s=%p\n", s); #ifndef HAVE_BLK_ALLOC_DISK #ifdef HAVE_BLK_ALLOC_QUEUE_ONE_ARG queue = blk_alloc_queue(GFP_KERNEL); #elif defined (HAVE_BLK_ALLOC_QUEUE_RH) queue = blk_alloc_queue_rh(snumbd_make_request, NUMA_NO_NODE); #else queue = blk_alloc_queue(snumbd_make_request, NUMA_NO_NODE); #endif if (!queue) { sa_info("%s\n", "Alloc queue failed"); return ret; } s->s_disk = alloc_disk(1); if (!s->s_disk) { sa_info("%s\n", "Alloc disk failed"); blk_cleanup_queue(queue); goto out; } s->s_disk->queue = queue; #else #if defined (HAVE_STRUCT_QUEUE_LIMITS) && defined (HAVE_BLK_ALLOC_DISK_2ARG) s->s_disk = blk_alloc_disk(&lim, NUMA_NO_NODE); #elif defined HAVE_BLK_ALLOC_DISK_2ARG s->s_disk = blk_alloc_disk(NULL, NUMA_NO_NODE); #else s->s_disk = blk_alloc_disk(NUMA_NO_NODE); #endif if (!s->s_disk) { sa_info("%s\n", "Alloc disk failed"); goto out; } s->s_disk->minors = 1; queue = s->s_disk->queue; #endif s->s_disk->major = MAJOR(s->s_kdev); s->s_disk->first_minor = MINOR(s->s_kdev); sprintf(s->s_disk->disk_name, SNUMBD_NAME"%dd", MINOR(s->s_kdev)); s->s_disk->private_data = s; s->s_disk->fops = &snumbd_bdops; sa_debug(DEBUG_INTERNALS, "s=%p(%d) users=%d\n", s, s->s_state, atomic_read(&s->s_users)); set_capacity(s->s_disk, s->s_scount * (s->s_sector_size / 512)); #ifdef HAVE_BLK_QUEUE_MAKE_REQUEST /* Note: 'blk_queue_make_request()' resets queue's settings */ blk_queue_make_request(queue, snumbd_make_request); #endif #ifndef HAVE_STRUCT_QUEUE_LIMITS sn_set_queue_block_size(queue, s->s_sector_size); #endif add_disk(s->s_disk); return 0; out: return ret; } #pragma GCC diagnostic pop static void unregister_device(struct session_struct * s) { sa_debug(DEBUG_API, "s=%p dev=%x\n", s, s->s_kdev); if (s->s_disk) { #ifndef HAVE_BLK_CLEANUP_DISK #ifdef HAVE_BLK_CLEANUP_QUEUE sn_request_queue *queue; #endif #endif sa_debug(DEBUG_INTERNALS, "s=%p(%d) users=%d\n", s, s->s_state, atomic_read(&s->s_users)); spin_lock(&disk_lock); s->s_disk->private_data = 0; spin_unlock(&disk_lock); del_gendisk(s->s_disk); #ifdef HAVE_BLK_CLEANUP_DISK blk_cleanup_disk(s->s_disk); #else #ifdef HAVE_BLK_CLEANUP_QUEUE queue = s->s_disk->queue; if (queue) blk_cleanup_queue(queue); #endif put_disk(s->s_disk); #endif s->s_disk = NULL; } } #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26) #define SN_NOPAGE_SIGBUS NOPAGE_SIGBUS #else #define SN_NOPAGE_SIGBUS VM_FAULT_ERROR #endif #if 0 static void session_stat(struct sn_state *sn) { sa_info("dev=%x:%x, state=%d, blksize=%d, mmapsize=%d\n", sn->major, sn->minor, sn->state, sn->blksize, sn->mmapsize); sa_info("psize=%u, pstrt=%u, mshft=%d, ioctls=%u\n", sn->partsize, sn->partstrt, sn->minorshft, sn->ioctlcnt); sa_info("bhpgs=%d, bhcnt=%d, abhs=%u, fbhs=%u, dbhs=%u\n", sn->bhpages, sn->bhcount, sn->abhs, sn->fbhs, sn->dbhs); sa_info("gpgs=%u, ppgs=%u, emmax=%d, emmin=%d, emcur=%d, cached=%d\n", sn->gpages, sn->ppages, sn->emmax, sn->emmin, sn->emcur, sn->cachepages); sa_info("rblocks=%u, cblocks=%u, rcblocks=%u, rwcolls=%u\n", sn->rblocks, sn->cblocks, sn->rcblocks, sn->rwcolls); } #endif static void fill_state(struct session_struct *s, struct snumbd_state *out) { memset(out, 0, sizeof(*out)); out->version = (SNUMBD_VMAJOR << 16) + (SNUMBD_VMINOR << 8) + SNUMBD_VSUBMINOR; out->major = MAJOR(s->s_kdev); out->minor = MINOR(s->s_kdev); out->state = s->s_state; out->hpid = s->s_hpid; out->scount = s->s_scount; out->mmapsize = SN_MMAP_SIZE; out->ioctlcnt = s->s_ioctlcnt; out->users = atomic_read(&s->s_users); } static void close_session(struct session_struct *s) { int i; shutdown_session(s); down(&s->s_sem); sa_debug(DEBUG_API, "s=%p, state=%d, users=%d\n", s, s->s_state, atomic_read(&s->s_users)); for (i = 0; i < SN_MMAP_PAGES; i++) { if (s->s_mpages[i]) { sa_debug(DEBUG_ALLOC, "s=%p, page_release=%p(%d)\n", s, s->s_mpages[i], page_count(s->s_mpages[i])); s->s_ppages++; page_cache_release(s->s_mpages[i]); s->s_mpages[i] = NULL; } } up(&s->s_sem); put_session(s); } #if (DEBUG != 0) && (DEBUG_LEVEL & DEBUG_BIO) static void print_bio(struct bio *bio, char *pref) { sa_warn("%s bio=%p, dev=%x, sector=%llu, bi_flags=%x" " bi_rw=%x bi_size=%d bi_vcnt=%d bi_io_vec=%p" " bi_max_vecs=%d\n", pref, bio, bio->bi_bdev ? bio->bi_bdev->bd_dev : -1, (unsigned long long)sn_bio_bi_sector(bio), bio->bi_flags, get_bio_req_flags(bio), sn_bio_bi_size(bio), bio->bi_vcnt, bio->bi_io_vec, bio->bi_max_vecs); } #define dump_bio(x, y) print_bio(x, y) #else #define dump_bio(x, y) #endif #ifndef HAVE_BDOPS_SUBMIT_BIO static MAKE_REQUEST_RETURN_VALUE snumbd_make_request(sn_request_queue *q, struct bio *bio) { #else static MAKE_REQUEST_RETURN_VALUE snumbd_make_request(struct bio *bio) { #endif struct session_struct *s; dev_t dev; int write; unsigned i; dev = sn_bio_dev(bio); spin_lock(&disk_lock); #ifdef HAVE_BIO_BI_BDEV s = (struct session_struct *)(bio->bi_bdev->bd_disk->private_data); #else s = (struct session_struct *)(bio->bi_disk->private_data); #endif if (!s) { spin_unlock(&disk_lock); sa_warn("Can't find session, bio=%p dev=%x.\n", bio, dev); sn_bio_io_error(bio); return MAKE_REQUEST_EXIT_STATUS; } get_session(s); spin_unlock(&disk_lock); write = sn_op_is_write(bio); sa_debug(DEBUG_INTERNALS, "s=%p kdev=%x, bio_size=%u, cmd=%s, state=%d, sector=%llu" " users=%d, offset=%u.\n", s, s->s_kdev, sn_bio_bi_size(bio), write == WRITE_DATA ? "WRITE_DATA": "READ_DATA", s->s_state, (unsigned long long) sn_bio_bi_sector(bio), atomic_read(&s->s_users), s->s_bio_offset[i]); retry: if (!is_session_usable(s)) { sa_warn("Session is in unusable state=%u, bio=%p dev=%x.\n", s->s_state, bio, dev); put_session(s); sn_bio_io_error(bio); return MAKE_REQUEST_EXIT_STATUS; } down(&s->s_sem); if (s->s_bio_count >= MT_REQ_MAX) { up(&s->s_sem); wait_event(s->s_req_put_wq, !is_session_usable(s) || s->s_bio_count < MT_REQ_MAX); goto retry; } for (i = 0; i < MT_REQ_MAX; ++i) { if (!s->s_bio[i]) break; } s->s_bio[i] = bio; s->s_bio_offset[i] = 0; ++s->s_bio_count; if (write) s->s_total_secs_write += sn_bio_bi_size(bio) / s->s_sector_size; else s->s_total_secs_read += sn_bio_bi_size(bio) / s->s_sector_size; wake_up(&s->s_req_get_wq); up(&s->s_sem); put_session(s); return MAKE_REQUEST_EXIT_STATUS; } static int session_init(struct session_struct * s, unsigned long long size, int ro, unsigned int sector_size) { int ret; int minor; int i; sa_debug(DEBUG_API, "len=%llu.\n", size); ret = -EINVAL; down(&s->s_sem); if (s->s_state != SNUM_NOTINITED) goto out; if (!sn_is_power_of_2(sector_size) || sector_size < 512 || sector_size > PAGE_SIZE) { sa_warn("Block size is invalid: size=%d", sector_size); goto out; } s->s_scount = size; s->s_sector_size = sector_size; s->s_ro = ro; s->s_hpid = current->pid; s->s_apgrp[0] = sn_current_pgrp(); s->s_apgrp[1] = sn_current_pgrp(); ret = -ENOMEM; for (i = 0; i < SN_MMAP_PAGES; i++) { s->s_mpages[i] = alloc_page(GFP_KERNEL); if (!s->s_mpages[i]) goto out_free; } spin_lock(&sessions_lock); minor = get_free_minor(); ret = -ENODEV; if (minor > MAX_MINOR) { spin_unlock(&sessions_lock); goto out_free; } list_del_init(&s->s_list); s->s_kdev = MKDEV(snumbd_major, minor); list_add_tail(&s->s_list, &sessions_list); spin_unlock(&sessions_lock); ret = register_device(s); if (ret) { spin_lock(&sessions_lock); list_del_init(&s->s_list); s->s_kdev = 0; list_add(&s->s_list, ¬inited_list); spin_unlock(&sessions_lock); goto out_free; } sa_kdebug("OK. kdev=%x:%x, len=%llu sect=%u s=%p pgrp=(%d).\n", MAJOR(s->s_kdev), MINOR(s->s_kdev), s->s_scount, s->s_sector_size, s, s->s_apgrp[0]); sn_set_mb(s->s_state, SNUM_INITED); goto out; out_free: for (i = 0; i < SN_MMAP_PAGES; i++) { if (s->s_mpages[i]) { page_cache_release(s->s_mpages[i]); s->s_mpages[i] = NULL; } } out: up(&s->s_sem); return ret; } static void noinline sn_data_to_user(struct session_struct *s, struct bio *bio, unsigned off) { unsigned len; struct bio_vec bv, *bvp = &bv; bvec_iterator_t iter; unsigned skip_pages = SN_MMAP_PAGES * off; unsigned skip_bytes = skip_pages * PAGE_SIZE; len = 0; bio_for_each_segment4(bv, bvp, bio, iter) { char *kaddr; int i, count, rest, m_off, bv_copied; if (len >= skip_bytes + SN_MMAP_SIZE) { break; } if (len + bvp->bv_len <= skip_bytes) { len += bvp->bv_len; continue; } bv_copied = (len < skip_bytes) ? skip_bytes - len : 0; len += bv_copied; i = (len >> PAGE_SHIFT) - skip_pages; m_off = len % PAGE_SIZE; rest = PAGE_SIZE - m_off; count = (rest < bvp->bv_len - bv_copied) ? rest : bvp->bv_len - bv_copied; kaddr = sn_kmap_atomic(bvp->bv_page); memcpy(page_address(s->s_mpages[i]) + m_off, kaddr + bvp->bv_offset + bv_copied, count); len += count; if (i + 1 < SN_MMAP_PAGES && count < bvp->bv_len - bv_copied) { /* place rest on the next page */ rest = bvp->bv_len - bv_copied - count; memcpy(page_address(s->s_mpages[i + 1]), kaddr + bvp->bv_offset + bv_copied + count, rest); len += rest; } sn_kunmap_atomic(kaddr); } } static void noinline sn_data_from_user(struct session_struct *s, struct bio *bio, unsigned off) { unsigned len; struct bio_vec bv, *bvp = &bv; bvec_iterator_t iter; unsigned skip_pages = SN_MMAP_PAGES * off; unsigned skip_bytes = skip_pages * PAGE_SIZE; len = 0; bio_for_each_segment4(bv, bvp, bio, iter) { char *kaddr; int i, count, rest, m_off, bv_filled; if (len >= skip_bytes + SN_MMAP_SIZE) { break; } if (len + bvp->bv_len <= skip_bytes) { len += bvp->bv_len; continue; } bv_filled = (len < skip_bytes) ? skip_bytes - len : 0; len += bv_filled; i = (len >> PAGE_SHIFT) - skip_pages; m_off = len % PAGE_SIZE; rest = PAGE_SIZE - m_off; count = (rest < bvp->bv_len - bv_filled) ? rest : bvp->bv_len - bv_filled; kaddr = sn_kmap_atomic(bvp->bv_page); memcpy(kaddr + bvp->bv_offset + bv_filled, page_address(s->s_mpages[i]) + m_off, count); len += count; if (i + 1 < SN_MMAP_PAGES && count < bvp->bv_len - bv_filled) { /* get rest from the next page */ rest = bvp->bv_len - bv_filled - count; memcpy(kaddr + bvp->bv_offset + bv_filled + count, page_address(s->s_mpages[i + 1]), rest); len += rest; } sn_kunmap_atomic(kaddr); } } static int session_req(struct session_struct *s, unsigned int size, void *req) { int ret; struct snumbd_req kreq; struct bio *bio; int i; int write; unsigned sect_per_mmap; unsigned rest_len; retry: down(&s->s_sem); if (!is_session_usable(s)) { up(&s->s_sem); return -EIO; } if (s->s_tag_count >= s->s_bio_count) { up(&s->s_sem); ret = wait_event_interruptible(s->s_req_get_wq, !is_session_usable(s) || s->s_tag_count < s->s_bio_count); if (ret) { goto out; } goto retry; } for (i = 0; i < MT_REQ_MAX; ++i) { if (!s->s_tag[i] && s->s_bio[i]) break; } s->s_tag[i] = current->pid; ++s->s_tag_count; bio = s->s_bio[i]; write = sn_op_is_write(bio); sect_per_mmap = SN_MMAP_SIZE / 512; rest_len = sn_bio_bi_size(bio) - s->s_bio_offset[i] * SN_MMAP_SIZE; kreq.cmd = (write) ? WRITE_DATA : READ_DATA; kreq.sno = sn_bio_bi_sector(bio) + s->s_bio_offset[i] * sect_per_mmap; kreq.offset = 0; kreq.len = (rest_len > SN_MMAP_SIZE) ? SN_MMAP_SIZE : rest_len; sa_debug(DEBUG_INTERNALS, "s=%p kdev=%x, bio_size=%u, cmd=%s, state=%d, " "users=%d, offset=%u.\n", s, s->s_kdev, sn_bio_bi_size(bio), kreq.cmd == WRITE_DATA ? "WRITE_DATA": "READ_DATA", s->s_state, atomic_read(&s->s_users), s->s_bio_offset[i]); if (write) { sn_data_to_user(s, bio, s->s_bio_offset[i]); } if (size > sizeof(kreq)) size = sizeof(kreq); ret = copy_to_user(req, &kreq, size); if (ret) ret = -EACCES; up(&s->s_sem); out: return ret; } static int session_dataready(struct session_struct *s, unsigned int size, const void *req) { int ret; struct snumbd_req kreq; struct bio *bio; pid_t tag; int i; int write; if (size > sizeof(kreq)) size = sizeof(kreq); ret = copy_from_user(&kreq, req, size); if (ret) { ret = -EACCES; shutdown_session(s); goto out; } sa_debug(DEBUG_INTERNALS, "s=%p kdev=%x, size=%u, cmd=%d, state=%d, " "users=%d.\n", s, s->s_kdev, size, kreq.cmd, s->s_state, atomic_read(&s->s_users)); if (kreq.cmd & ERROR_FLAG) { ret = -ENOSPC; shutdown_session(s); goto out; } ret = -EIO; down(&s->s_sem); if (!is_session_usable(s)) { goto unlock; } tag = current->pid; for (i = 0; i < MT_REQ_MAX; ++i) { if (s->s_tag[i] == tag) { break; } } if (i >= MT_REQ_MAX) { goto unlock; } bio = s->s_bio[i]; write = sn_op_is_write(bio); if (!write) { sn_data_from_user(s, bio, s->s_bio_offset[i]); } if (sn_bio_bi_size(bio) < SN_MMAP_SIZE * (s->s_bio_offset[i] + 1)) { sa_debug(DEBUG_INTERNALS, "ENDIO: s=%p kdev=%x, bio_size=%u, cmd=%s, state=%d, " "users=%d, offset=%u.\n", s, s->s_kdev, sn_bio_bi_size(bio), kreq.cmd == WRITE_DATA ? "WRITE_DATA": "READ_DATA", s->s_state, atomic_read(&s->s_users), s->s_bio_offset[i]); s->s_bio[i] = NULL; s->s_tag[i] = 0; s->s_bio_offset[i] = 0; --s->s_tag_count; --s->s_bio_count; sn_bio_endio(bio); } else { s->s_tag[i] = 0; --s->s_tag_count; s->s_bio_offset[i]++; sa_debug(DEBUG_INTERNALS, "CONTIO: s=%p kdev=%x, bio_size=%u, cmd=%s, state=%d, " "users=%d, offset=%u.\n", s, s->s_kdev, sn_bio_bi_size(bio), kreq.cmd == WRITE_DATA ? "WRITE_DATA": "READ_DATA", s->s_state, atomic_read(&s->s_users), s->s_bio_offset[i]); } wake_up(&s->s_req_get_wq); wake_up(&s->s_req_put_wq); ret = 0; unlock: up(&s->s_sem); out: return ret; } static int session_state(struct session_struct *s, int size, void *state) { struct snumbd_state st; int ret; fill_state(s, &st); spin_lock(&sessions_lock); st.sessions = sessions_count; spin_unlock(&sessions_lock); if (size > sizeof(st)) size = sizeof(st); ret = copy_to_user(state, &st, size); if (ret) ret = -EACCES; return ret; } static int session_states(struct session_struct *s, int size, void *state) { struct snumbd_state st; struct snumbd_state *out; struct list_head *tmp; int len; int ret; sa_debug(DEBUG_API, "s=%p, size=%d, state=%p\n", s, size, state); out = state; len = 0; ret = -ENOSPC; spin_lock(&sessions_lock); list_for_each(tmp, &sessions_list) { struct session_struct *ss; ss = list_entry(tmp, struct session_struct, s_list); fill_state(ss, &st); st.sessions = sessions_count; if (size - len < sizeof(st)) goto err_unlock; sa_debug(DEBUG_INTERNALS, "out=%p, len=%d\n", out, len); ret = copy_to_user(out, &st, sizeof(st)); if (ret) { ret = -EACCES; goto err_unlock; } len += sizeof(st); out++; } list_for_each(tmp, ¬inited_list) { struct session_struct *s; s = list_entry(tmp, struct session_struct, s_list); fill_state(s, &st); st.sessions = sessions_count; if (size - len < sizeof(st)) goto err_unlock; sa_debug(DEBUG_INTERNALS, "out=%p, len=%d\n", out, len); ret = copy_to_user(out, &st, sizeof(st)); if (ret) { ret = -EACCES; goto err_unlock; } len += sizeof(st); out++; } ret = 0; err_unlock: spin_unlock(&sessions_lock); return ret; } static int session_allowed_pgrp(struct session_struct *s, pid_t pgrp) { if (pgrp <= 0) return -EINVAL; s->s_apgrp[1] = s->s_apgrp[0]; s->s_apgrp[0] = pgrp; return 0; } static long snumbdctl3_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int err; struct session_struct * ss; if (!snumbd_init_ok) return -EPERM; ss = file->private_data; if (!ss) return -EINVAL; err = -EFAULT; spin_lock(&ss->s_misc_lock); ss->s_ioctlcnt++; spin_unlock(&ss->s_misc_lock); switch(cmd) { case SNUMBDCTL_INIT: { struct snumbdctl_init s; if (copy_from_user(&s, (void *)arg, sizeof(s))) break; err = session_init(ss, s.scount, s.dev_ro, 512); } break; case SNUMBDCTL_INIT_V2: { struct snumbdctl_init_v2 s; if (copy_from_user(&s, (void *)arg, sizeof(s))) break; err = session_init(ss, s.scount, s.dev_ro, s.sector_size); } break; case SNUMBDCTL_REQ: { struct snumbdctl_req s; if (copy_from_user(&s, (void *)arg, sizeof(s))) break; err = session_req(ss, s.size, s.req); } break; case SNUMBDCTL_DATAREADY: { struct snumbdctl_dataready s; if (copy_from_user(&s, (void *)arg, sizeof(s))) break; err = session_dataready(ss, s.size, s.req); } break; case SNUMBDCTL_STATE: { struct snumbdctl_state s; if (copy_from_user(&s, (void *)arg, sizeof(s))) break; err = session_state(ss, s.size, s.state); } break; case SNUMBDCTL_STATES: { struct snumbdctl_state s; if (copy_from_user(&s, (void *)arg, sizeof(s))) break; err = session_states(ss, s.size, s.state); } break; case SNUMBDCTL_PGRP: { struct snumbdctl_pgrp s; if (copy_from_user(&s, (void *)arg, sizeof(s))) break; err = session_allowed_pgrp(ss, s.allowed_pgrp); } break; default: err = -ENOTTY; break; } sa_debug(DEBUG_API, "err=%d\n", -err); return err; } #ifndef HAVE_UNLOCKED_IOCTL_IN_FS_H static int snumbdctl4_ioctl(struct inode *ino, struct file *file, unsigned int cmd, unsigned long arg) { return snumbdctl3_ioctl(file, cmd, arg); } #endif /* 2.6.37 */ #ifdef HAVE_IOCTL32_CONVERSION static int snumbdctl_compat_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg, struct file *filep) { return snumbdctl3_ioctl(filep, cmd, arg); } #endif #ifdef HAVE_COMPAT_IOCTL static long snumbdctl_compat_ioctl(struct file *filep, unsigned int cmd, unsigned long arg) { return snumbdctl3_ioctl(filep, cmd, arg); } #endif static int snumbdctl_open(struct inode *ino, struct file *file) { struct session_struct * s; sa_debug(DEBUG_API,"%s\n","enter"); if (!snumbd_init_ok) return -EPERM; s = kmalloc(sizeof(*s), GFP_KERNEL); if (!s) return -ENOMEM; memset(s, 0, sizeof(*s)); INIT_LIST_HEAD(&s->s_list); sema_init(&s->s_sem, 1); spin_lock_init(&s->s_misc_lock); atomic_set(&s->s_users, 1); init_waitqueue_head(&s->s_req_put_wq); init_waitqueue_head(&s->s_req_get_wq); spin_lock(&sessions_lock); list_add(&s->s_list, ¬inited_list); sessions_count++; spin_unlock(&sessions_lock); file->private_data = s; sa_kdebug("%s\n", "OK"); return 0; } static int snumbdctl_release(struct inode *ino, struct file *file) { struct session_struct * s; s = file->private_data; if (!s) return -EINVAL; file->private_data = NULL; sa_debug(DEBUG_API,"%s\n","enter"); sa_kdebug("OK. kdev=%x:%x\n", MAJOR(s->s_kdev), MINOR(s->s_kdev)); close_session(s); return 0; } static struct page * snumbdctl_vm_nopage(struct vm_area_struct * vma, unsigned long address, int *unused) { unsigned int i; struct session_struct *s; if (!vma->vm_file) { sa_warn("vma does not have a file attached.%s", "\n"); return (struct page *)SN_NOPAGE_SIGBUS; } s = vma->vm_file->private_data; if (address - vma->vm_start >= SN_MMAP_SIZE) { sa_warn("Incorrect address.%s", "\n"); return (struct page *)SN_NOPAGE_SIGBUS; } i = (address - vma->vm_start) >> PAGE_SHIFT; get_page(s->s_mpages[i]); sa_debug(DEBUG_ALLOC, "s=%p, nopage=%p(%d)\n", s, s->s_mpages[i], page_count(s->s_mpages[i])); s->s_gpages++; return s->s_mpages[i]; } #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26) static VMFAULT_RETURN_VALUE snumbdctl_vm_fault(struct vm_area_struct * vma, struct vm_fault *vmf) { #ifdef HAVE_VMFAULT_VIRTUAL_ADDRESS unsigned long address = (unsigned long) vmf->virtual_address; #else unsigned long address = (unsigned long) vmf->address; #endif #ifdef HAVE_VM_FAULT_2ARGS vmf->page = snumbdctl_vm_nopage(vma, address, 0); #else vmf->page = snumbdctl_vm_nopage(vmf->vma, address, 0); #endif if (vmf->page == (struct page *)SN_NOPAGE_SIGBUS) return VM_FAULT_ERROR; return 0; } #endif static void snumbdctl_vm_close(struct vm_area_struct * vma) { unsigned int i; struct session_struct *s; if (!vma->vm_file) { sa_warn("vma does not have a file attached.%s", "\n"); return; } s = vma->vm_file->private_data; for (i = 0; i < SN_MMAP_PAGES; i++) { if (s->s_mpages[i]) { sa_debug(DEBUG_ALLOC, "s=%p, put page=%p(%d)\n", s, s->s_mpages[i], page_count(s->s_mpages[i])); /* page was put by upper level */ s->s_ppages++; } } s->s_vma = NULL; } static struct vm_operations_struct snumbdctl_vm_ops = { #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26) nopage: snumbdctl_vm_nopage, #else fault: snumbdctl_vm_fault, #endif close: snumbdctl_vm_close, }; static int snumbdctl_mmap(struct file * file, struct vm_area_struct * vma) { struct session_struct *s; int ret; unsigned long pg_off; s = file->private_data; sa_debug(DEBUG_API,"s=%p, vma=%p,%lx-%lx %lx %lx\n", s, vma, vma->vm_start, vma->vm_end, vma->vm_flags, vma->vm_pgoff); if (!s) return -EBADF; if (!(vma->vm_flags & VM_SHARED)) return -EINVAL; ret = -EINVAL; down(&s->s_sem); pg_off = (SN_MMAP_SIZE * (MINOR(s->s_kdev) - 1)) >> PAGE_SHIFT; if (s->s_vma || s->s_state < SNUM_INITED || vma->vm_pgoff != pg_off) goto out_up; ret = -ENOMEM; if (vma->vm_end - vma->vm_start != SN_MMAP_SIZE) goto out_up; ret = 0; s->s_vma = vma; vma->vm_ops = &snumbdctl_vm_ops; out_up: up(&s->s_sem); return ret; } static ssize_t snumbdctl_read(struct file * filp, char * buf, size_t count, loff_t *ppos) { struct session_struct *s; ssize_t ret; if (count != sizeof(struct snumbd_req)) return -EINVAL; s = filp->private_data; if (!s) return -EBADF; sa_debug(DEBUG_INTERNALS,"s=%p, buf=%p, count=%zu, ppos=%lld, state=%d\n", s, buf, count, *ppos, s->s_state); ret = session_req(s, count, buf); if (!ret) ret = count; return ret; } static ssize_t snumbdctl_write(struct file *filp, const char *buf, size_t count, loff_t *ppos) { struct session_struct *s; ssize_t ret; s = filp->private_data; if (!s) return -EBADF; sa_debug(DEBUG_INTERNALS,"s=%p, buf=%p, count=%zu, ppos=%lld, state=%d\n", s, buf, count, *ppos, s->s_state); ret = session_dataready(s, count, buf); if (!ret) ret = count; return ret; } static unsigned int snumbdctl_poll(struct file *filp, poll_table *wait) { struct session_struct *s; unsigned int mask; s = filp->private_data; sa_debug(DEBUG_INTERNALS, "s=%p\n", s); if (!s || IS_ERROR_STATE(s->s_state)) return POLLERR; poll_wait(filp, &s->s_req_get_wq, wait); down(&s->s_sem); mask = 0; if (!is_session_usable(s)) { mask |= POLLERR; } sa_debug(DEBUG_INTERNALS, "RET s=%p s_tag_count=%u s_bio_count=%u\n", s, s->s_tag_count, s->s_bio_count); if (s->s_tag_count < s->s_bio_count) { mask |= POLLIN | POLLRDNORM; } up(&s->s_sem); return mask; } static struct file_operations snumbdctl_fops = { owner: THIS_MODULE, #ifdef HAVE_UNLOCKED_IOCTL_IN_FS_H unlocked_ioctl: snumbdctl3_ioctl, #else ioctl: snumbdctl4_ioctl, #endif open: snumbdctl_open, read: snumbdctl_read, write: snumbdctl_write, poll: snumbdctl_poll, mmap: snumbdctl_mmap, release: snumbdctl_release, #ifdef HAVE_COMPAT_IOCTL compat_ioctl: snumbdctl_compat_ioctl, #endif }; static int __init snumbd_init(void) { int ret; ret = register_chrdev(0, SNUMBDCTL_NAME, &snumbdctl_fops); if (ret < 0) goto out_notify; snumbdctl_major = ret; ret = register_blkdev(0, SNUMBD_NAME); if (ret < 0) goto out_unreg_chr; snumbd_major = ret; #ifdef HAVE_IOCTL32_CONVERSION register_ioctl32_conversion(SNUMBDCTL_INIT, snumbdctl_compat_ioctl); register_ioctl32_conversion(SNUMBDCTL_INIT_V2, snumbdctl_compat_ioctl); register_ioctl32_conversion(SNUMBDCTL_STOP, snumbdctl_compat_ioctl); register_ioctl32_conversion(SNUMBDCTL_REQ, snumbdctl_compat_ioctl); register_ioctl32_conversion(SNUMBDCTL_DATAREADY, snumbdctl_compat_ioctl); register_ioctl32_conversion(SNUMBDCTL_STATE, snumbdctl_compat_ioctl); register_ioctl32_conversion(SNUMBDCTL_STATES, snumbdctl_compat_ioctl); #endif snumbd_init_ok = 1; ret = 0; out_info: sa_info("Snumbd(v.%d.%d.%d) init %s. Ctl major %d, blk major %d.\n", SNUMBD_VMAJOR, SNUMBD_VMINOR, SNUMBD_VSUBMINOR, snumbd_init_ok ? "OK" : "failed", snumbdctl_major, snumbd_major); return ret; out_unreg_chr: unregister_chrdev(snumbdctl_major, SNUMBDCTL_NAME); out_notify: goto out_info; } static void __exit snumbd_exit(void) { unregister_chrdev(snumbdctl_major, SNUMBDCTL_NAME); unregister_blkdev(snumbd_major, SNUMBD_NAME); #ifdef HAVE_IOCTL32_CONVERSION unregister_ioctl32_conversion(SNUMBDCTL_INIT); unregister_ioctl32_conversion(SNUMBDCTL_INIT_V2); unregister_ioctl32_conversion(SNUMBDCTL_STOP); unregister_ioctl32_conversion(SNUMBDCTL_REQ); unregister_ioctl32_conversion(SNUMBDCTL_DATAREADY); unregister_ioctl32_conversion(SNUMBDCTL_STATE); unregister_ioctl32_conversion(SNUMBDCTL_STATES); #endif sa_info("Snumbd unloading...%s", "\n"); } module_init(snumbd_init); module_exit(snumbd_exit); MODULE_AUTHOR("Acronis"); MODULE_DESCRIPTION("Acronis User Mode Block Device"); MODULE_LICENSE("GPL"); MODULE_VERSION(SNUMBD_COMMON_MOD_VERSION); MODULE_INFO(supported, "external");
© 2026 UnknownSec