Rev.6を表示中。最新版はこちら。

loopbackとは自分自身に戻る。と言うことで、ループバックマウントは、以下のように、マウント済みファイルシステム下にファイルを作成し、それを擬似的なブロックデバイスとしてマウントすると言う事です。(ある意味、バーチャルなパーティションって感じでしょうか。)

[root@localhost tmp]# dd if=/dev/zero of=disk bs=1M count=1
1+0 レコード入力
1+0 レコード出力
1048576 バイト (1.0 MB) コピーされました、 0.0105052 秒、 99.8 MB/秒

[root@localhost tmp]# mkfs.ext2 disk
mke2fs 1.41.14 (22-Dec-2010)
disk is not a block special device.
Proceed anyway? (y,n) y
 :
Writing inode tables: done
Writing superblocks and filesystem accounting information: done

[root@localhost tmp]# mount ./disk /mnt1

[root@localhost tmp]# ls /mnt1
lost+found

となります。この操作は、一般的にループバックデバイスによるマウントという事ですが、カーネルサイドからは、通常のマウントとなります。

上記での処理の概要でstraceの内容の抜粋です。./diskが通常ファイルなら、/dev/loopデバイスファイルをオープンし、/dev/loopデバイスファイルのコールバック関数のioctl()で、/dev/loopデバイスに./diskをバンドリングします。mountコマンドでは、この処理をmountコマンド内で行っており、システムコールのsys_mountへは、デバイスファイルとして/dev/loopでコールし、通常のmount処理と同じ処理となります。

ループバックも通常マウントも、vfsmountを取得するのですが、/dev/loopの場合、すでにスーパブロックは./diskのファイルシステム下で取得済みであり、従ってスーパブロックの参照カウントをインクリメントするだけで、スーパブロックの読み出しはいたしません。

[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
 :

ループバックデバイスのファイルオペレーションコールバック。ここでは.ioctlが実際のデバイス(ファイル名)をこの/dev/loopにバンドリングさせるためのキモとなる処理です。

static struct block_device_operations lo_fops = {
       .owner =        THIS_MODULE,
       .open =         lo_open,
       .release =      lo_release,
       .ioctl =        lo_ioctl,
};

static int lo_ioctl(struct inode * inode, struct file * file,
       unsigned int cmd, unsigned long arg)
{
       struct loop_device *lo = inode->i_bdev->bd_disk->private_data;
       int err;

       down(&lo->lo_ctl_mutex);
       switch (cmd) {
       case LOOP_SET_FD:
               err = loop_set_fd(lo, file, inode->i_bdev, arg);
               break;
       case LOOP_CLR_FD:
               err = loop_clr_fd(lo, inode->i_bdev);
               break;
       case LOOP_SET_STATUS:
               err = loop_set_status_old(lo, (struct loop_info *) arg);
               break;
       case LOOP_GET_STATUS:
               err = loop_get_status_old(lo, (struct loop_info *) arg);
               break;
       case LOOP_SET_STATUS64:
               err = loop_set_status64(lo, (struct loop_info64 *) arg);
               break;
       case LOOP_GET_STATUS64:
               err = loop_get_status64(lo, (struct loop_info64 *) arg);
               break;
       default:
               err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL;
       }
       up(&lo->lo_ctl_mutex);
       return err;
}

補足

ループバックデバイスのブロックデバイスstruct block_device *bdevのbd_disk->private_dataに、struct loop_deviceが紐づいていて、loop_set_fd()lo_ioctl(システムコールのioctl)は、マウントデバイスをstruct loop_deviceに設定し、ループバックデバイスとマウントデバイスとバインドします。

loop_set_fd()は、loはループバックデバイスのloop_device、bdevはループバックデバイスのブロックデバイス、argはマウントデバイスのファイルIDで、コマンド LOOP_SET_FDでコールされます。

if (lo->lo_state != Lo_unbound)で、/dev/loopがすでにバインドされているかチェックし、while (is_loop_device(f))は、マウントデバイスがループバックデバイスのケースで、マウント先が同じループバックデバイスにマウントしようとしているか、またそうでない場合、すでにそのロープバックデバイスがマウントされているかのチェックをします。

ＯＫなら、マウントデバイスのファイル属性/引数modeが、FMODE_WRITEで無い場合、ループバックデバイスのブロックデバイスにLO_FLAGS_READ_ONLYを設定したりして、struct loop_device *loにこれらの内容を設定しています。

lo->transferのコールバック関数transfer_none()で、この関数が実際のデバイスのやり取りを行い、必要に応じてクリプトできることが可能となっています。(LOOP_SET_STATUS64コマンドでstruct loop_info64を設定)

enum {
       Lo_unbound,
       Lo_bound,
       Lo_rundown,
};

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:
       /* This is safe: open() is still holding a reference. */
       module_put(THIS_MODULE);
       return error;
}

static inline int is_loop_device(struct file *file)
{
       struct inode *i = file->f_mapping->host;

       return i && S_ISBLK(i->i_mode) && MAJOR(i->i_rdev) == LOOP_MAJOR;
}

get_loop_size()でloopデバイスサイズを取得します。lo->lo_sizelimitが0の場合、fileのサイズからlo->lo_offset(開始位置)を引いた値で、lo->lo_sizelimitが0でない場合、それをサイズといたします。

static loff_t get_loop_size(struct loop_device *lo, struct file *file)
{
       return get_size(lo->lo_offset, lo->lo_sizelimit, file);
}

static loff_t get_size(loff_t offset, loff_t sizelimit, struct file *file)
{
       loff_t size, loopsize;

       size = i_size_read(file->f_mapping->host);
       loopsize = size - offset;
       if (loopsize < 0)
               return 0;

       if (sizelimit > 0 && sizelimit < loopsize)
               loopsize = sizelimit;
       return loopsize >> 9;
}

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;
}

ループバックデバイスは通常ファイルのマウント。と言う認識がありますが、マウントするのは通常ファイルだけでなく、ブロックファイルもマウントできます。(すでにマウントしたループデバイスも含む)、しかもオフセットを設定することで、デバイス上に隠し領域みたいなものを有するファイルシステムを実現する事も可能となるようです。

long do_mount(char * dev_name, char * dir_name, char *type_page,
                 unsigned long flags, void *data_page)
{
 :
       if (flags & MS_REMOUNT)
               retval = do_remount(&nd, flags & ~MS_REMOUNT, mnt_flags,
                                   data_page);
       else if (flags & MS_BIND)
               retval = do_loopback(&nd, dev_name, flags & MS_REC);
       else if (flags & MS_MOVE)
               retval = do_move_mount(&nd, dev_name);
       else
               retval = do_add_mount(&nd, type_page, flags, mnt_flags,
                                     dev_name, data_page);
 :
}

/dev/loopでコールされても、do_add_mount()がコールされ、カーネルとしてループバックマウントは、bindオプションのmountになります。