無料Wikiサービス | デモページ
検索

アクセス数
最近のコメント
kprobe - ななし
ksetの実装 - スーパーコピー
カーネルスレッドとは - ノース
カーネルスレッドとは - nbyst
asmlinkageってなに? - ノース
asmlinkageってなに? - よろしく
はじめ - ノース
はじめ - ノース
はじめ - 楽打連動ユーザー
はじめ - 楽打連動ユーザー
Adsense
広告情報が設定されていません。

ループバックマウント


[root@localhost tmp]# strace mount ./disk /mnt1
execve("/bin/mount", ["mount", "./disk", "/mnt1"], [/* 23 vars */]) = 0
 :
open("/tmp/disk", O_RDWR|O_LARGEFILE)   = 3
open("/dev/loop0", O_RDWR|O_LARGEFILE)  = 4
readlink("/tmp", 0xbf8f570b, 4096)      = -1 EINVAL (Invalid argument)
readlink("/tmp/disk", 0xbf8f570b, 4096) = -1 EINVAL (Invalid argument)
 :
ioctl(4, LOOP_SET_FD, 0x3)              = 0
close(3)                                = 0
ioctl(4, LOOP_SET_STATUS64, {offset=0, number=0, flags=LO_FLAGS_AUTOCLEAR, file_name="/tmp/disk", ...}) = 0
 :
mount("/dev/loop0", "/mnt1", "ext2", MS_MGC_VAL, NULL) = 0
 :

ループバックデバイスもlo_fopsをデバイスコールバックとする通常のブロックデバイスとして登録されています。異なるのはlo_fopsには入出力のコールバックが無いと言う事です。

ループバックデバイ下のファイルを参照すると、vfs管理下で参照ブロックのbioが作成され、ループバックデバイスのmake_requestでbioがリストされ、このリストから実デバイスへ入出力され、通常のブロックデバイスとなんら変わりありません。ただし、実デバイスへ入出力は、ブロックデバイスのコールバックでなく、バインドされているファイルの通常の読み書き(ファイルオペレーション)で行われると言う事です。結果的にバインドされているファイルの実デバイスのブロックデバイスコールバックとなりますが。
static const struct block_device_operations lo_fops = {
       .owner =        THIS_MODULE,
       .open =         lo_open,
       .release =      lo_release,
       .ioctl =        lo_ioctl,
#ifdef CONFIG_COMPAT
       .compat_ioctl = lo_compat_ioctl,
#endif
};
mountするとLOOP_SET_FDでloop_set_fd()がコールされます。これがループバックデバイス実態その物です。argはバインドファイルIDとなります。
static int lo_ioctl(struct block_device *bdev, fmode_t mode,
       unsigned int cmd, unsigned long arg)
{
       struct loop_device *lo = bdev->bd_disk->private_data;
       int err;

       mutex_lock_nested(&lo->lo_ctl_mutex, 1);
       switch (cmd) {
       case LOOP_SET_FD:
               err = loop_set_fd(lo, mode, bdev, arg);
               break;
       case LOOP_CHANGE_FD:
               err = loop_change_fd(lo, bdev, arg);
               break;
       case LOOP_CLR_FD:
               err = loop_clr_fd(lo);
               if (!err)
                       goto out_unlocked;
               break;
       case LOOP_SET_STATUS:
               err = -EPERM;
               if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN))
                       err = loop_set_status_old(lo,
                                       (struct loop_info __user *)arg);
               break;
       case LOOP_GET_STATUS:
               err = loop_get_status_old(lo, (struct loop_info __user *) arg);
               break;
       case LOOP_SET_STATUS64:
               err = -EPERM;
               if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN))
                       err = loop_set_status64(lo,
                                       (struct loop_info64 __user *) arg);
               break;
       case LOOP_GET_STATUS64:
               err = loop_get_status64(lo, (struct loop_info64 __user *) arg);
               break;
       case LOOP_SET_CAPACITY:
               err = -EPERM;
               if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN))
                       err = loop_set_capacity(lo, bdev);
               break;
       default:
               err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL;
       }
       mutex_unlock(&lo->lo_ctl_mutex);

out_unlocked:
       return err;
}
ループバックデバイスがバインド済みかどうか、バインドするファイルがループファイルで、それがバインドされている事、またバインドするループバックデバイスでないことをマウントリストに坂下ってチェックします。

OKならファイルのデバイスのブロックサイズをループバックデバイスとし、lo->lo_backing_file = fileとすることで、ループバックデバイスの入出力を、fileのオペレーションコールバックでできるわけです。

lo->transfer = transfer_noneは、ファイル入出力でのメモリ転送コールバックで、デフォルトではtransfer_noneが設定されます。このコールバックの目的は暗号化したファイルシステムを構築することです。

blk_queue_make_request()でloop_make_request()を、vfs管理下のmake_requestコールバックとし、bioがlo->lo_queueにリストされます。

kthread_create()カーネルスレッドとしてloop_thread()が動作し、loop_make_request()でリストされたlo->lo_queueのbioからlo->lo_backing_fileのfileオペレーションコールバックで実デバイスへの入出力します。
static int loop_set_fd(struct loop_device *lo, fmode_t mode,
                      struct block_device *bdev, unsigned int arg)
{
       struct file     *file, *f;
       struct inode    *inode;
       struct address_space *mapping;
       unsigned lo_blocksize;
       int             lo_flags = 0;
       int             error;
       loff_t          size;

       __module_get(THIS_MODULE);

       error = -EBADF;
       file = fget(arg);
       if (!file)
               goto out;

       error = -EBUSY;
       if (lo->lo_state != Lo_unbound)
               goto out_putf;

       f = file;
       while (is_loop_device(f)) {
               struct loop_device *l;

               if (f->f_mapping->host->i_bdev == bdev)
                       goto out_putf;

               l = f->f_mapping->host->i_bdev->bd_disk->private_data;
               if (l->lo_state == Lo_unbound) {
                       error = -EINVAL;
                       goto out_putf;
               }
               f = l->lo_backing_file;
       }

       mapping = file->f_mapping;
       inode = mapping->host;

       error = -EINVAL;
       if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
               goto out_putf;

       if (!(file->f_mode & FMODE_WRITE) || !(mode & FMODE_WRITE) ||
           !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;

       error = -EFBIG;
       size = get_loop_size(lo, file);
       if ((loff_t)(sector_t)size != size)
               goto out_putf;

       error = 0;

       set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0);

       lo->lo_blocksize = lo_blocksize;
       lo->lo_device = bdev;
       lo->lo_flags = lo_flags;
       lo->lo_backing_file = file;
       lo->transfer = transfer_none;
       lo->ioctl = NULL;
       lo->lo_sizelimit = 0;
       lo->old_gfp_mask = mapping_gfp_mask(mapping);
       mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));

       bio_list_init(&lo->lo_bio_list);


       blk_queue_make_request(lo->lo_queue, loop_make_request);
       lo->lo_queue->queuedata = lo;

       if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)
               blk_queue_flush(lo->lo_queue, REQ_FLUSH);

       set_capacity(lo->lo_disk, size);
       bd_set_size(bdev, size << 9);
       loop_sysfs_init(lo);

       kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);

       set_blocksize(bdev, lo_blocksize);

       lo->lo_thread = kthread_create(loop_thread, lo, "loop%d",
                                               lo->lo_number);
       if (IS_ERR(lo->lo_thread)) {
               error = PTR_ERR(lo->lo_thread);
               goto out_clr;
       }
       lo->lo_state = Lo_bound;
       wake_up_process(lo->lo_thread);
       if (part_shift)
               lo->lo_flags |= LO_FLAGS_PARTSCAN;
       if (lo->lo_flags & LO_FLAGS_PARTSCAN)
               ioctl_by_bdev(bdev, BLKRRPART, 0);
       return 0;

out_clr:
       loop_sysfs_exit(lo);
       lo->lo_thread = NULL;
       lo->lo_device = NULL;
       lo->lo_backing_file = NULL;
       lo->lo_flags = 0;
       set_capacity(lo->lo_disk, 0);
       invalidate_bdev(bdev);
       bd_set_size(bdev, 0);
       kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
       mapping_set_gfp_mask(mapping, lo->old_gfp_mask);
       lo->lo_state = Lo_unbound;
out_putf:
       fput(file);
out:
       module_put(THIS_MODULE);
       return error;
}
loop_make_request()でリストされたlo->lo_bio_listからbioを取得し、loop_handle_bio()からdo_bio_filebacked()で入出力します。
static int loop_thread(void *data)
{
       struct loop_device *lo = data;
       struct bio *bio;

       set_user_nice(current, -20);

       while (!kthread_should_stop() || !bio_list_empty(&lo->lo_bio_list)) {

               wait_event_interruptible(lo->lo_event,
                               !bio_list_empty(&lo->lo_bio_list) ||
                               kthread_should_stop());

               if (bio_list_empty(&lo->lo_bio_list))
                       continue;
               spin_lock_irq(&lo->lo_lock);
               bio = loop_get_bio(lo);
               spin_unlock_irq(&lo->lo_lock);

               BUG_ON(!bio);
               loop_handle_bio(lo, bio);
       }

       return 0;
}

static inline void loop_handle_bio(struct loop_device *lo, struct bio *bio)
{
       if (unlikely(!bio->bi_bdev)) {
               do_loop_switch(lo, bio->bi_private);
               bio_put(bio);
       } else {
               int ret = do_bio_filebacked(lo, bio);
               bio_endio(bio, ret);
       }
}
bioからバインドされているファイル位置を取得します。bio->bi_sector << 9はブロックサイズが512で、lo->lo_offsetはデフォルトでは0で、パーティションで分割されていたりすると、パーティションに応じてlo_offsetが設定されたり、先頭領域をあえて使用しないために設定することも可能です。

バインドファイル参照位置が決まると、書込みならlo_send()、読込みならlo_receive()がコールされます。

if (bio->bi_rw & REQ_DISCARD)は、破棄するbio領域をfallocate()で実領域として維持し、再使用することでファイルの断片化を防止します。(たぶん)
static int do_bio_filebacked(struct loop_device *lo, struct bio *bio)
{
       loff_t pos;
       int ret;

       pos = ((loff_t) bio->bi_sector << 9) + lo->lo_offset;

       if (bio_rw(bio) == WRITE) {
               struct file *file = lo->lo_backing_file;

               if (bio->bi_rw & REQ_FLUSH) {
                       ret = vfs_fsync(file, 0);
                       if (unlikely(ret && ret != -EINVAL)) {
                               ret = -EIO;
                               goto out;
                       }
               }

               if (bio->bi_rw & REQ_DISCARD) {
                       struct file *file = lo->lo_backing_file;
                       int mode = FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE;

                       if ((!file->f_op->fallocate) ||
                           lo->lo_encrypt_key_size) {
                               ret = -EOPNOTSUPP;
                               goto out;
                       }
                       ret = file->f_op->fallocate(file, mode, pos,
                                                   bio->bi_size);
                       if (unlikely(ret && ret != -EINVAL &&
                                    ret != -EOPNOTSUPP))
                               ret = -EIO;
                       goto out;
               }

               ret = lo_send(lo, bio, pos);

               if ((bio->bi_rw & REQ_FUA) && !ret) {
                       ret = vfs_fsync(file, 0);
                       if (unlikely(ret && ret != -EINVAL))
                               ret = -EIO;
               }
       } else
               ret = lo_receive(lo, bio, lo->lo_blocksize, pos);

out:
       return ret;
}
crypt(暗号)ならdo_lo_send_write、そうでないならdo_lo_send_direct_writeがコールされます。do_lo_send_write()は実pageを引数とします。cryptするための中間バッファとなります。do_lo_send_direct_write()はその必要がないため、page=NULLです。
static int lo_send(struct loop_device *lo, struct bio *bio, loff_t pos)
{
       int (*do_lo_send)(struct loop_device *, struct bio_vec *, loff_t,
                       struct page *page);
       struct bio_vec *bvec;
       struct page *page = NULL;
       int i, ret = 0;

       if (lo->transfer != transfer_none) {
               page = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
               if (unlikely(!page))
                       goto fail;
               kmap(page);
               do_lo_send = do_lo_send_write;
       } else {
               do_lo_send = do_lo_send_direct_write;
       }

       bio_for_each_segment(bvec, bio, i) {
               ret = do_lo_send(lo, bvec, pos, page);
               if (ret < 0)
                       break;
               pos += bvec->bv_len;
       }
       if (page) {
               kunmap(page);
               __free_page(page);
       }
out:
       return ret;
fail:
       printk(KERN_ERR "loop: Failed to allocate temporary page for write.\n");
       ret = -ENOMEM;
       goto out;
}
cryptするケースです。lo_do_transfer()で書き込むpageのbvec->bv_pageをcryptしてpageに転送し、そのpageを__do_lo_send_write()で書き込みます。
static int do_lo_send_write(struct loop_device *lo, struct bio_vec *bvec,
               loff_t pos, struct page *page)
{
       int ret = lo_do_transfer(lo, WRITE, page, 0, bvec->bv_page,
                       bvec->bv_offset, bvec->bv_len, pos >> 9);
       if (likely(!ret))
               return __do_lo_send_write(lo->lo_backing_file,
                               page_address(page), bvec->bv_len,
                               pos);
       printk(KERN_ERR "loop: Transfer error at byte offset %llu, "
                       "length %i.\n", (unsigned long long)pos, bvec->bv_len);
       if (ret > 0)
               ret = -EIO;
       return ret;
}
 
static inline int
lo_do_transfer(struct loop_device *lo, int cmd,
              struct page *rpage, unsigned roffs,
              struct page *lpage, unsigned loffs,
              int size, sector_t rblock)
{
       if (unlikely(!lo->transfer))
               return 0;

       return lo->transfer(lo, cmd, rpage, roffs, lpage, loffs, size, rblock);
}
cryptしないケースです。引数のpageはNULLです。lo_do_transfer()で転送することなく、直接bvec->bv_pageを__do_lo_send_write()で書き込みます。
static int do_lo_send_direct_write(struct loop_device *lo,
               struct bio_vec *bvec, loff_t pos, struct page *page)
{
       ssize_t bw = __do_lo_send_write(lo->lo_backing_file,
                       kmap(bvec->bv_page) + bvec->bv_offset,
                       bvec->bv_len, pos);
       kunmap(bvec->bv_page);
       cond_resched();
       return bw;
}
cryptしないtransferで、読込み時は、カーネル3では結果的に直接bioのpageとやり取りするため、使用されることはありません。たぶん以前のバージョンでは、do_lo_send_direct_writeでなく、do_lo_send_writeの実装での残骸ではと思います。
static int transfer_none(struct loop_device *lo, int cmd,
                        struct page *raw_page, unsigned raw_off,
                        struct page *loop_page, unsigned loop_off,
                        int size, sector_t real_block)
{
       char *raw_buf = kmap_atomic(raw_page, KM_USER0) + raw_off;
       char *loop_buf = kmap_atomic(loop_page, KM_USER1) + loop_off;

       if (cmd == READ)
               memcpy(loop_buf, raw_buf, size);
       else
               memcpy(raw_buf, loop_buf, size);

       kunmap_atomic(loop_buf, KM_USER1);
       kunmap_atomic(raw_buf, KM_USER0);
       cond_resched();
       return 0;
}
__do_lo_send_write()がブロックデバイスでのコールバック関数となりますが、バインドされているファイルのファイルオペレーションコールバックによるオフセット位置への書き込みとなります。
static int __do_lo_send_write(struct file *file,
               u8 *buf, const int len, loff_t pos)
{
       ssize_t bw;
       mm_segment_t old_fs = get_fs();

       set_fs(get_ds());
       bw = file->f_op->write(file, buf, len, &pos);
       set_fs(old_fs);
       if (likely(bw == len))
               return 0;
       printk(KERN_ERR "loop: Write error at byte offset %llu, length %i.\n",
                       (unsigned long long)pos, len);
       if (bw >= 0)
               bw = -EIO;
       return bw;
}

crypt(暗号)

LOOP_SET_STATUS/LOOP_SET_STATUS64でlo_ioctl()をコールすることで、info->lo_encrypt_typeのxfer_funcs[type]がlo->transferに設定されます。
static int
loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
{
       int err;
       struct loop_func_table *xfer;
       uid_t uid = current_uid();

       if (lo->lo_encrypt_key_size &&
           lo->lo_key_owner != uid &&
           !capable(CAP_SYS_ADMIN))
               return -EPERM;
       if (lo->lo_state != Lo_bound)
               return -ENXIO;
       if ((unsigned int) info->lo_encrypt_key_size > LO_KEY_SIZE)
               return -EINVAL;

       err = loop_release_xfer(lo);
       if (err)
               return err;

       if (info->lo_encrypt_type) {
               unsigned int type = info->lo_encrypt_type;

               if (type >= MAX_LO_CRYPT)
                       return -EINVAL;
               xfer = xfer_funcs[type];
               if (xfer == NULL)
                       return -EINVAL;
       } else
               xfer = NULL;

       err = loop_init_xfer(lo, xfer, info);
       if (err)
               return err;

       if (lo->lo_offset != info->lo_offset ||
           lo->lo_sizelimit != info->lo_sizelimit) {
               if (figure_loop_size(lo, info->lo_offset, info->lo_sizelimit))
                       return -EFBIG;
       }
       loop_config_discard(lo);

       memcpy(lo->lo_file_name, info->lo_file_name, LO_NAME_SIZE);
       memcpy(lo->lo_crypt_name, info->lo_crypt_name, LO_NAME_SIZE);
       lo->lo_file_name[LO_NAME_SIZE-1] = 0;
       lo->lo_crypt_name[LO_NAME_SIZE-1] = 0;

       if (!xfer)
               xfer = &none_funcs;
       lo->transfer = xfer->transfer;
       lo->ioctl = xfer->ioctl;

       if ((lo->lo_flags & LO_FLAGS_AUTOCLEAR) !=
            (info->lo_flags & LO_FLAGS_AUTOCLEAR))
               lo->lo_flags ^= LO_FLAGS_AUTOCLEAR;

       if ((info->lo_flags & LO_FLAGS_PARTSCAN) &&
            !(lo->lo_flags & LO_FLAGS_PARTSCAN)) {
               lo->lo_flags |= LO_FLAGS_PARTSCAN;
               lo->lo_disk->flags &= ~GENHD_FL_NO_PART_SCAN;
               ioctl_by_bdev(lo->lo_device, BLKRRPART, 0);
       }

       lo->lo_encrypt_key_size = info->lo_encrypt_key_size;
       lo->lo_init[0] = info->lo_init[0];
       lo->lo_init[1] = info->lo_init[1];
       if (info->lo_encrypt_key_size) {
               memcpy(lo->lo_encrypt_key, info->lo_encrypt_key,
                      info->lo_encrypt_key_size);
               lo->lo_key_owner = uid;
       }       

       return 0;
}
loop transferコールバックは、lkm毎にloop_register_transfer()をコールすることで、xfer_funcs[n] に登録されます。公開しない独自の暗号loop transferコールバックのlkmを実装すれば、よりセキュリティの高いファイルシステムを構築できます。
static struct loop_func_table cryptoloop_funcs = {
       .number = LO_CRYPT_CRYPTOAPI,
       .init = cryptoloop_init,
       .ioctl = cryptoloop_ioctl,
       .transfer = cryptoloop_transfer,
       .release = cryptoloop_release,
       .owner = THIS_MODULE
};

static int __init
init_cryptoloop(void)
{
       int rc = loop_register_transfer(&cryptoloop_funcs);

       if (rc)
               printk(KERN_ERR "cryptoloop: loop_register_transfer failed\n");
       return rc;
}

int loop_register_transfer(struct loop_func_table *funcs)
{
       unsigned int n = funcs->number;

       if (n >= MAX_LO_CRYPT || xfer_funcs[n])
               return -EINVAL;
       xfer_funcs[n] = funcs;
       return 0;
}

補足

ループバックデバイスは一般的な使い方としてファイルをバインドしますが、ブロックデバイススペシャルファイルはraw読書きで、デバイスが1つの仮想的なファイルとなるイメージです。従ってブロックデバイススペシャルファイル自身をループバックデバイスにバインドすることも可能で、そうする事で暗号化したブロックデバイスでの運用が可能となります。


最終更新 2014/12/12 22:05:33 - north
(2013/06/13 19:34:52 作成)