*
*/
+#include <linux/config.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/sched.h>
#include <linux/blkdev.h>
#include <linux/blkpg.h>
#include <linux/init.h>
+#include <linux/devfs_fs_kernel.h>
#include <linux/smp_lock.h>
#include <linux/swap.h>
#include <linux/slab.h>
#include <linux/completion.h>
#include <linux/highmem.h>
#include <linux/gfp.h>
+#include <linux/vs_base.h>
#include <linux/vs_context.h>
#include <asm/uaccess.h>
{
struct file *file = lo->lo_backing_file; /* kudos to NFsckingS */
struct address_space *mapping = file->f_mapping;
- const struct address_space_operations *aops = mapping->a_ops;
+ struct address_space_operations *aops = mapping->a_ops;
pgoff_t index;
unsigned offset, bv_offs;
int len, ret;
mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask);
lo->lo_backing_file = file;
- lo->lo_blocksize = S_ISBLK(mapping->host->i_mode) ?
- mapping->host->i_bdev->bd_block_size : PAGE_SIZE;
+ lo->lo_blocksize = mapping->host->i_blksize;
lo->old_gfp_mask = mapping_gfp_mask(mapping);
mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
complete(&p->wait);
struct file *file, *f;
struct inode *inode;
struct address_space *mapping;
- struct vx_info_save vxis;
unsigned lo_blocksize;
int lo_flags = 0;
int error;
error = -EINVAL;
if (S_ISREG(inode->i_mode) || S_ISBLK(inode->i_mode)) {
- const struct address_space_operations *aops = mapping->a_ops;
+ struct address_space_operations *aops = mapping->a_ops;
/*
* If we can't read - sorry. If we only can't write - well,
* it's going to be read-only.
if (!(lo_flags & LO_FLAGS_USE_AOPS) && !file->f_op->write)
lo_flags |= LO_FLAGS_READ_ONLY;
- lo_blocksize = S_ISBLK(inode->i_mode) ?
- inode->i_bdev->bd_block_size : PAGE_SIZE;
-
+ lo_blocksize = inode->i_blksize;
error = 0;
} else {
goto out_putf;
lo->lo_device = bdev;
lo->lo_flags = lo_flags;
lo->lo_backing_file = file;
- lo->transfer = transfer_none;
+ lo->transfer = NULL;
lo->ioctl = NULL;
lo->lo_sizelimit = 0;
lo->old_gfp_mask = mapping_gfp_mask(mapping);
set_blocksize(bdev, lo_blocksize);
- __enter_vx_admin(&vxis);
- error = kernel_thread(loop_thread, lo, CLONE_KERNEL);
- __leave_vx_admin(&vxis);
- if (error < 0)
- goto out_putf;
+ kernel_thread(loop_thread, lo, CLONE_KERNEL);
wait_for_completion(&lo->lo_done);
return 0;
struct loop_device *lo = inode->i_bdev->bd_disk->private_data;
int err;
- mutex_lock(&lo->lo_ctl_mutex);
+ down(&lo->lo_ctl_mutex);
switch (cmd) {
case LOOP_SET_FD:
err = loop_set_fd(lo, file, inode->i_bdev, arg);
default:
err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL;
}
- mutex_unlock(&lo->lo_ctl_mutex);
+ up(&lo->lo_ctl_mutex);
return err;
}
{
struct loop_device *lo = inode->i_bdev->bd_disk->private_data;
- mutex_lock(&lo->lo_ctl_mutex);
+ down(&lo->lo_ctl_mutex);
lo->lo_refcnt++;
- mutex_unlock(&lo->lo_ctl_mutex);
+ up(&lo->lo_ctl_mutex);
return 0;
}
{
struct loop_device *lo = inode->i_bdev->bd_disk->private_data;
- mutex_lock(&lo->lo_ctl_mutex);
+ down(&lo->lo_ctl_mutex);
--lo->lo_refcnt;
- mutex_unlock(&lo->lo_ctl_mutex);
+ up(&lo->lo_ctl_mutex);
return 0;
}
xfer_funcs[n] = NULL;
for (lo = &loop_dev[0]; lo < &loop_dev[max_loop]; lo++) {
- mutex_lock(&lo->lo_ctl_mutex);
+ down(&lo->lo_ctl_mutex);
if (lo->lo_encryption == xfer)
loop_release_xfer(lo);
- mutex_unlock(&lo->lo_ctl_mutex);
+ up(&lo->lo_ctl_mutex);
}
return 0;
goto out_mem3;
}
+ devfs_mk_dir("loop");
+
for (i = 0; i < max_loop; i++) {
struct loop_device *lo = &loop_dev[i];
struct gendisk *disk = disks[i];
lo->lo_queue = blk_alloc_queue(GFP_KERNEL);
if (!lo->lo_queue)
goto out_mem4;
- mutex_init(&lo->lo_ctl_mutex);
+ init_MUTEX(&lo->lo_ctl_mutex);
init_completion(&lo->lo_done);
init_completion(&lo->lo_bh_done);
lo->lo_number = i;
disk->first_minor = i;
disk->fops = &lo_fops;
sprintf(disk->disk_name, "loop%d", i);
+ sprintf(disk->devfs_name, "loop/%d", i);
disk->private_data = lo;
disk->queue = lo->lo_queue;
}
out_mem4:
while (i--)
- blk_cleanup_queue(loop_dev[i].lo_queue);
+ blk_put_queue(loop_dev[i].lo_queue);
+ devfs_remove("loop");
i = max_loop;
out_mem3:
while (i--)
for (i = 0; i < max_loop; i++) {
del_gendisk(disks[i]);
- blk_cleanup_queue(loop_dev[i].lo_queue);
+ blk_put_queue(loop_dev[i].lo_queue);
put_disk(disks[i]);
}
+ devfs_remove("loop");
if (unregister_blkdev(LOOP_MAJOR, "loop"))
printk(KERN_WARNING "loop: cannot unregister blkdev\n");