root/drivers/block/loop.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. transfer_none
  2. transfer_xor
  3. transfer_des
  4. figure_loop_size
  5. do_lo_request
  6. loop_set_fd
  7. loop_clr_fd
  8. loop_set_status
  9. loop_get_status
  10. lo_ioctl
  11. lo_open
  12. lo_release
  13. loop_init
  14. cleanup_module

   1 /*
   2  *  linux/drivers/block/loop.c
   3  *
   4  *  Written by Theodore Ts'o, 3/29/93
   5  * 
   6  * Copyright 1993 by Theodore Ts'o.  Redistribution of this file is
   7  * permitted under the GNU Public License.
   8  *
   9  * DES encryption plus some minor changes by Werner Almesberger, 30-MAY-1993
  10  *
  11  * Modularized and updated for 1.1.16 kernel - Mitch Dsouza 28th May 1994
  12  *
  13  * Adapted for 1.3.59 kernel - Andries Brouwer, 1 Feb 1996
  14  */
  15 
  16 #include <linux/module.h>
  17 
  18 #include <linux/fs.h>
  19 #include <linux/stat.h>
  20 #include <linux/errno.h>
  21 #include <linux/major.h>
  22 
  23 #ifdef DES_AVAILABLE
  24 #include "des.h"
  25 #endif
  26 #include <linux/loop.h>         /* must follow des.h */
  27 
  28 #define MAJOR_NR LOOP_MAJOR
  29 
  30 #define DEVICE_NAME "loop"
  31 #define DEVICE_REQUEST do_lo_request
  32 #define DEVICE_NR(device) (MINOR(device))
  33 #define DEVICE_ON(device)
  34 #define DEVICE_OFF(device)
  35 #define DEVICE_NO_RANDOM
  36 #define TIMEOUT_VALUE (6 * HZ)
  37 #include <linux/blk.h>
  38 
  39 #define MAX_LOOP 8
  40 static struct loop_device loop_dev[MAX_LOOP];
  41 static int loop_sizes[MAX_LOOP];
  42 
  43 /*
  44  * Transfer functions
  45  */
  46 static int transfer_none(struct loop_device *lo, int cmd, char *raw_buf,
     /* [previous][next][first][last][top][bottom][index][help] */
  47                   char *loop_buf, int size)
  48 {
  49         if (cmd == READ)
  50                 memcpy(loop_buf, raw_buf, size);
  51         else
  52                 memcpy(raw_buf, loop_buf, size);
  53         return 0;
  54 }
  55 
  56 static int transfer_xor(struct loop_device *lo, int cmd, char *raw_buf,
     /* [previous][next][first][last][top][bottom][index][help] */
  57                  char *loop_buf, int size)
  58 {
  59         char    *in, *out, *key;
  60         int     i, keysize;
  61 
  62         if (cmd == READ) {
  63                 in = raw_buf;
  64                 out = loop_buf;
  65         } else {
  66                 in = loop_buf;
  67                 out = raw_buf;
  68         }
  69         key = lo->lo_encrypt_key;
  70         keysize = lo->lo_encrypt_key_size;
  71         for (i=0; i < size; i++)
  72                 *out++ = *in++ ^ key[(i & 511) % keysize];
  73         return 0;
  74 }
  75 
  76 #ifdef DES_AVAILABLE
  77 static int transfer_des(struct loop_device *lo, int cmd, char *raw_buf,
     /* [previous][next][first][last][top][bottom][index][help] */
  78                   char *loop_buf, int size)
  79 {
  80         unsigned long tmp[2];
  81         unsigned long x0,x1,p0,p1;
  82 
  83         if (size & 7)
  84                 return -EINVAL;
  85         x0 = lo->lo_des_init[0];
  86         x1 = lo->lo_des_init[1];
  87         while (size) {
  88                 if (cmd == READ) {
  89                         tmp[0] = (p0 = ((unsigned long *) raw_buf)[0])^x0;
  90                         tmp[1] = (p1 = ((unsigned long *) raw_buf)[1])^x1;
  91                         des_ecb_encrypt((des_cblock *) tmp,(des_cblock *)
  92                             loop_buf,lo->lo_des_key,DES_ENCRYPT);
  93                         x0 = p0^((unsigned long *) loop_buf)[0];
  94                         x1 = p1^((unsigned long *) loop_buf)[1];
  95                 }
  96                 else {
  97                         p0 = ((unsigned long *) loop_buf)[0];
  98                         p1 = ((unsigned long *) loop_buf)[1];
  99                         des_ecb_encrypt((des_cblock *) loop_buf,(des_cblock *)
 100                             raw_buf,lo->lo_des_key,DES_DECRYPT);
 101                         ((unsigned long *) raw_buf)[0] ^= x0;
 102                         ((unsigned long *) raw_buf)[1] ^= x1;
 103                         x0 = p0^((unsigned long *) raw_buf)[0];
 104                         x1 = p1^((unsigned long *) raw_buf)[1];
 105                 }
 106                 size -= 8;
 107                 raw_buf += 8;
 108                 loop_buf += 8;
 109         }
 110         return 0;
 111 }
 112 #endif
 113 
 114 static transfer_proc_t xfer_funcs[MAX_LOOP] = {
 115         transfer_none,          /* LO_CRYPT_NONE */
 116         transfer_xor,           /* LO_CRYPT_XOR */
 117 #ifdef DES_AVAILABLE
 118         transfer_des,           /* LO_CRYPT_DES */
 119 #else
 120         NULL,                   /* LO_CRYPT_DES */
 121 #endif
 122         0                       /* LO_CRYPT_IDEA */
 123 };
 124 
 125 
 126 #define MAX_DISK_SIZE 1024*1024*1024
 127 
 128 
 129 static void figure_loop_size(struct loop_device *lo)
     /* [previous][next][first][last][top][bottom][index][help] */
 130 {
 131         int     size;
 132 
 133         if (S_ISREG(lo->lo_inode->i_mode))
 134                 size = (lo->lo_inode->i_size - lo->lo_offset) / 1024;
 135         else {
 136                 if (blk_size[MAJOR(lo->lo_device)])
 137                         size = ((blk_size[MAJOR(lo->lo_device)]
 138                                  [MINOR(lo->lo_device)]) -
 139                                 (lo->lo_offset/1024));
 140                 else
 141                         size = MAX_DISK_SIZE;
 142         }
 143         loop_sizes[lo->lo_number] = size;
 144 }
 145 
 146 static void do_lo_request(void)
     /* [previous][next][first][last][top][bottom][index][help] */
 147 {
 148         int     real_block, block, offset, len, blksize, size;
 149         char    *dest_addr;
 150         struct loop_device *lo;
 151         struct buffer_head *bh;
 152 
 153 repeat:
 154         INIT_REQUEST;
 155         if (MINOR(CURRENT->rq_dev) >= MAX_LOOP)
 156                 goto error_out;
 157         lo = &loop_dev[MINOR(CURRENT->rq_dev)];
 158         if (!lo->lo_inode || !lo->transfer)
 159                 goto error_out;
 160 
 161         blksize = BLOCK_SIZE;
 162         if (blksize_size[MAJOR(lo->lo_device)]) {
 163             blksize = blksize_size[MAJOR(lo->lo_device)][MINOR(lo->lo_device)];
 164             if (!blksize)
 165               blksize = BLOCK_SIZE;
 166         }
 167 
 168         dest_addr = CURRENT->buffer;
 169         
 170         if (blksize < 512) {
 171                 block = CURRENT->sector * (512/blksize);
 172                 offset = 0;
 173         } else {
 174                 block = CURRENT->sector / (blksize >> 9);
 175                 offset = CURRENT->sector % (blksize >> 9);
 176         }
 177         block += lo->lo_offset / blksize;
 178         offset += lo->lo_offset % blksize;
 179         if (offset > blksize) {
 180                 block++;
 181                 offset -= blksize;
 182         }
 183         len = CURRENT->current_nr_sectors << 9;
 184         if ((CURRENT->cmd != WRITE) && (CURRENT->cmd != READ)) {
 185                 printk("unknown loop device command (%d)?!?", CURRENT->cmd);
 186                 goto error_out;
 187         }
 188         while (len > 0) {
 189                 real_block = block;
 190                 if (lo->lo_flags & LO_FLAGS_DO_BMAP) {
 191                         real_block = bmap(lo->lo_inode, block);
 192                         if (!real_block) {
 193                                 printk("loop: block %d not present\n", block);
 194                                 goto error_out;
 195                         }
 196                 }
 197                 bh = getblk(lo->lo_device, real_block, blksize);
 198                 if (!bh) {
 199                         printk("loop: device %s: getblk(-, %d, %d) returned NULL",
 200                                kdevname(lo->lo_device),
 201                                block, blksize);
 202                         goto error_out;
 203                 }
 204                 if (!buffer_uptodate(bh) && ((CURRENT->cmd == READ) ||
 205                                         (offset || (len < blksize)))) {
 206                         ll_rw_block(READ, 1, &bh);
 207                         wait_on_buffer(bh);
 208                         if (!buffer_uptodate(bh)) {
 209                                 brelse(bh);
 210                                 goto error_out;
 211                         }
 212                 }
 213                 size = blksize - offset;
 214                 if (size > len)
 215                         size = len;
 216                            
 217                 if ((lo->transfer)(lo, CURRENT->cmd, bh->b_data + offset,
 218                                    dest_addr, size)) {
 219                         printk("loop: transfer error block %d\n", block);
 220                         brelse(bh);
 221                         goto error_out;
 222                 }
 223                 if (CURRENT->cmd == WRITE)
 224                         mark_buffer_dirty(bh, 1);
 225                 brelse(bh);
 226                 dest_addr += size;
 227                 len -= size;
 228                 offset = 0;
 229                 block++;
 230         }
 231         end_request(1);
 232         goto repeat;
 233 error_out:
 234         end_request(0);
 235         goto repeat;
 236 }
 237 
 238 static int loop_set_fd(struct loop_device *lo, unsigned int arg)
     /* [previous][next][first][last][top][bottom][index][help] */
 239 {
 240         struct file     *file;
 241         struct inode    *inode;
 242         
 243         if (arg >= NR_OPEN || !(file = current->files->fd[arg]))
 244                 return -EBADF;
 245         if (lo->lo_inode)
 246                 return -EBUSY;
 247         inode = file->f_inode;
 248         if (!inode) {
 249                 printk("loop_set_fd: NULL inode?!?\n");
 250                 return -EINVAL;
 251         }
 252         if (S_ISBLK(inode->i_mode)) {
 253                 int error = blkdev_open(inode, file);
 254                 if (error)
 255                         return error;
 256                 lo->lo_device = inode->i_rdev;
 257                 lo->lo_flags = 0;
 258         } else if (S_ISREG(inode->i_mode)) {
 259                 lo->lo_device = inode->i_dev;
 260                 lo->lo_flags = LO_FLAGS_DO_BMAP;
 261         } else
 262                 return -EINVAL;
 263 
 264         invalidate_inode_pages (inode);
 265         lo->lo_inode = inode;
 266         lo->lo_inode->i_count++;
 267         lo->transfer = NULL;
 268         figure_loop_size(lo);
 269         MOD_INC_USE_COUNT;
 270         return 0;
 271 }
 272 
 273 static int loop_clr_fd(struct loop_device *lo, kdev_t dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 274 {
 275         if (!lo->lo_inode)
 276                 return -ENXIO;
 277         if (lo->lo_refcnt > 1)
 278                 return -EBUSY;
 279         if (S_ISBLK(lo->lo_inode->i_mode))
 280                 blkdev_release (lo->lo_inode);
 281         iput(lo->lo_inode);
 282         lo->lo_device = 0;
 283         lo->lo_inode = NULL;
 284         lo->lo_encrypt_type = 0;
 285         lo->lo_offset = 0;
 286         lo->lo_encrypt_key_size = 0;
 287         memset(lo->lo_encrypt_key, 0, LO_KEY_SIZE);
 288         memset(lo->lo_name, 0, LO_NAME_SIZE);
 289         loop_sizes[lo->lo_number] = 0;
 290         invalidate_buffers(dev);
 291         MOD_DEC_USE_COUNT;
 292         return 0;
 293 }
 294 
 295 static int loop_set_status(struct loop_device *lo, struct loop_info *arg)
     /* [previous][next][first][last][top][bottom][index][help] */
 296 {
 297         struct loop_info info;
 298 
 299         if (!lo->lo_inode)
 300                 return -ENXIO;
 301         if (!arg)
 302                 return -EINVAL;
 303         memcpy_fromfs(&info, arg, sizeof(info));
 304         if ((unsigned int) info.lo_encrypt_key_size > LO_KEY_SIZE)
 305                 return -EINVAL;
 306         switch (info.lo_encrypt_type) {
 307         case LO_CRYPT_NONE:
 308                 break;
 309         case LO_CRYPT_XOR:
 310                 if (info.lo_encrypt_key_size < 0)
 311                         return -EINVAL;
 312                 break;
 313 #ifdef DES_AVAILABLE
 314         case LO_CRYPT_DES:
 315                 if (info.lo_encrypt_key_size != 8)
 316                         return -EINVAL;
 317                 des_set_key((des_cblock *) lo->lo_encrypt_key,
 318                    lo->lo_des_key);
 319                 memcpy(lo->lo_des_init,info.lo_init,8);
 320                 break;
 321 #endif
 322         default:
 323                 return -EINVAL;
 324         }
 325         lo->lo_offset = info.lo_offset;
 326         strncpy(lo->lo_name, info.lo_name, LO_NAME_SIZE);
 327         lo->lo_encrypt_type = info.lo_encrypt_type;
 328         lo->transfer = xfer_funcs[lo->lo_encrypt_type];
 329         lo->lo_encrypt_key_size = info.lo_encrypt_key_size;
 330         if (info.lo_encrypt_key_size)
 331                 memcpy(lo->lo_encrypt_key, info.lo_encrypt_key,
 332                        info.lo_encrypt_key_size);
 333         figure_loop_size(lo);
 334         return 0;
 335 }
 336 
 337 static int loop_get_status(struct loop_device *lo, struct loop_info *arg)
     /* [previous][next][first][last][top][bottom][index][help] */
 338 {
 339         struct loop_info        info;
 340         
 341         if (!lo->lo_inode)
 342                 return -ENXIO;
 343         if (!arg)
 344                 return -EINVAL;
 345         memset(&info, 0, sizeof(info));
 346         info.lo_number = lo->lo_number;
 347         info.lo_device = kdev_t_to_nr(lo->lo_inode->i_dev);
 348         info.lo_inode = lo->lo_inode->i_ino;
 349         info.lo_rdevice = kdev_t_to_nr(lo->lo_device);
 350         info.lo_offset = lo->lo_offset;
 351         info.lo_flags = lo->lo_flags;
 352         strncpy(info.lo_name, lo->lo_name, LO_NAME_SIZE);
 353         info.lo_encrypt_type = lo->lo_encrypt_type;
 354         if (lo->lo_encrypt_key_size && suser()) {
 355                 info.lo_encrypt_key_size = lo->lo_encrypt_key_size;
 356                 memcpy(info.lo_encrypt_key, lo->lo_encrypt_key,
 357                        lo->lo_encrypt_key_size);
 358         }
 359         memcpy_tofs(arg, &info, sizeof(info));
 360         return 0;
 361 }
 362 
 363 static int lo_ioctl(struct inode * inode, struct file * file,
     /* [previous][next][first][last][top][bottom][index][help] */
 364         unsigned int cmd, unsigned long arg)
 365 {
 366         struct loop_device *lo;
 367         int dev, err;
 368 
 369         if (!inode)
 370                 return -EINVAL;
 371         if (MAJOR(inode->i_rdev) != MAJOR_NR) {
 372                 printk("lo_ioctl: pseudo-major != %d\n", MAJOR_NR);
 373                 return -ENODEV;
 374         }
 375         dev = MINOR(inode->i_rdev);
 376         if (dev >= MAX_LOOP)
 377                 return -ENODEV;
 378         lo = &loop_dev[dev];
 379         switch (cmd) {
 380         case LOOP_SET_FD:
 381                 return loop_set_fd(lo, arg);
 382         case LOOP_CLR_FD:
 383                 return loop_clr_fd(lo, inode->i_rdev);
 384         case LOOP_SET_STATUS:
 385                 return loop_set_status(lo, (struct loop_info *) arg);
 386         case LOOP_GET_STATUS:
 387                 return loop_get_status(lo, (struct loop_info *) arg);
 388         case BLKGETSIZE:   /* Return device size */
 389                 if (!lo->lo_inode)
 390                         return -ENXIO;
 391                 if (!arg)  return -EINVAL;
 392                 err = verify_area(VERIFY_WRITE, (long *) arg, sizeof(long));
 393                 if (err)
 394                         return err;
 395                 put_fs_long(loop_sizes[lo->lo_number] << 1, (long *) arg);
 396                 return 0;
 397                 default:
 398                         return -EINVAL;
 399         }
 400         return 0;
 401 }
 402 
 403 static int lo_open(struct inode *inode, struct file *file)
     /* [previous][next][first][last][top][bottom][index][help] */
 404 {
 405         struct loop_device *lo;
 406         int     dev;
 407 
 408         if (!inode)
 409                 return -EINVAL;
 410         if (MAJOR(inode->i_rdev) != MAJOR_NR) {
 411                 printk("lo_open: pseudo-major != %d\n", MAJOR_NR);
 412                 return -ENODEV;
 413         }
 414         dev = MINOR(inode->i_rdev);
 415         if (dev >= MAX_LOOP)
 416                 return -ENODEV;
 417         lo = &loop_dev[dev];
 418         lo->lo_refcnt++;
 419         MOD_INC_USE_COUNT;
 420         return 0;
 421 }
 422 
 423 static void lo_release(struct inode *inode, struct file *file)
     /* [previous][next][first][last][top][bottom][index][help] */
 424 {
 425         struct loop_device *lo;
 426         int     dev;
 427 
 428         if (!inode)
 429                 return;
 430         if (MAJOR(inode->i_rdev) != MAJOR_NR) {
 431                 printk("lo_release: pseudo-major != %d\n", MAJOR_NR);
 432                 return;
 433         }
 434         dev = MINOR(inode->i_rdev);
 435         if (dev >= MAX_LOOP)
 436                 return;
 437         fsync_dev(inode->i_rdev);
 438         lo = &loop_dev[dev];
 439         if (lo->lo_refcnt <= 0)
 440                 printk("lo_release: refcount(%d) <= 0\n", lo->lo_refcnt);
 441         else  {
 442                 lo->lo_refcnt--;
 443                 MOD_DEC_USE_COUNT;
 444         }
 445 
 446         return;
 447 }
 448 
 449 static struct file_operations lo_fops = {
 450         NULL,                   /* lseek - default */
 451         block_read,             /* read - general block-dev read */
 452         block_write,            /* write - general block-dev write */
 453         NULL,                   /* readdir - bad */
 454         NULL,                   /* select */
 455         lo_ioctl,               /* ioctl */
 456         NULL,                   /* mmap */
 457         lo_open,                /* open */
 458         lo_release              /* release */
 459 };
 460 
 461 /*
 462  * And now the modules code and kernel interface.
 463  */
 464 #ifdef MODULE
 465 #define loop_init init_module
 466 #endif
 467 
 468 int
 469 loop_init( void ) {
     /* [previous][next][first][last][top][bottom][index][help] */
 470         int     i;
 471 
 472         if (register_blkdev(MAJOR_NR, "loop", &lo_fops)) {
 473                 printk("Unable to get major number %d for loop device\n",
 474                        MAJOR_NR);
 475                 return -EIO;
 476         }
 477 #ifndef MODULE
 478         printk("loop: registered device at major %d\n", MAJOR_NR);
 479 #endif
 480 
 481         blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
 482         for (i=0; i < MAX_LOOP; i++) {
 483                 memset(&loop_dev[i], 0, sizeof(struct loop_device));
 484                 loop_dev[i].lo_number = i;
 485         }
 486         memset(&loop_sizes, 0, sizeof(loop_sizes));
 487         blk_size[MAJOR_NR] = loop_sizes;
 488 
 489         return 0;
 490 }
 491 
 492 #ifdef MODULE
 493 void
 494 cleanup_module( void ) {
     /* [previous][next][first][last][top][bottom][index][help] */
 495   if (unregister_blkdev(MAJOR_NR, "loop") != 0)
 496     printk("loop: cleanup_module failed\n");
 497 }
 498 #endif

/* [previous][next][first][last][top][bottom][index][help] */