Merge commit '85082fd7cbe3173198aac0eb5e85ab1edcc6352c' into test-build

Manual fixup of:

	arch/powerpc/Kconfig

7 files changed, 215 insertions, 94 deletions

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index cd03473f3547..a002a381df92 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -6628,15 +6628,18 @@ static void DAC960_DestroyProcEntries(DAC960_Controller_T *Controller)
  * DAC960_gam_ioctl is the ioctl function for performing RAID operations.
 */
 
-static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
-                            unsigned int Request, unsigned long Argument)
+static long DAC960_gam_ioctl(struct file *file, unsigned int Request,
+                                                unsigned long Argument)
 {
-  int ErrorCode = 0;
+  long ErrorCode = 0;
   if (!capable(CAP_SYS_ADMIN)) return -EACCES;
+
+  lock_kernel();
   switch (Request)
     {
     case DAC960_IOCTL_GET_CONTROLLER_COUNT:
-      return DAC960_ControllerCount;
+      ErrorCode = DAC960_ControllerCount;
+      break;
     case DAC960_IOCTL_GET_CONTROLLER_INFO:
       {
         DAC960_ControllerInfo_T __user *UserSpaceControllerInfo =
@@ -6644,15 +6647,20 @@ static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
         DAC960_ControllerInfo_T ControllerInfo;
         DAC960_Controller_T *Controller;
         int ControllerNumber;
-        if (UserSpaceControllerInfo == NULL) return -EINVAL;
-        ErrorCode = get_user(ControllerNumber,
+        if (UserSpaceControllerInfo == NULL)
+                ErrorCode = -EINVAL;
+        else ErrorCode = get_user(ControllerNumber,
                              &UserSpaceControllerInfo->ControllerNumber);
-        if (ErrorCode != 0) return ErrorCode;
+        if (ErrorCode != 0)
+                break;;
+        ErrorCode = -ENXIO;
         if (ControllerNumber < 0 ||
-            ControllerNumber > DAC960_ControllerCount - 1)
-          return -ENXIO;
+            ControllerNumber > DAC960_ControllerCount - 1) {
+          break;
+        }
         Controller = DAC960_Controllers[ControllerNumber];
-        if (Controller == NULL) return -ENXIO;
+        if (Controller == NULL)
+                break;;
         memset(&ControllerInfo, 0, sizeof(DAC960_ControllerInfo_T));
         ControllerInfo.ControllerNumber = ControllerNumber;
         ControllerInfo.FirmwareType = Controller->FirmwareType;
@@ -6665,8 +6673,9 @@ static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
         ControllerInfo.PCI_Address = Controller->PCI_Address;
         strcpy(ControllerInfo.ModelName, Controller->ModelName);
         strcpy(ControllerInfo.FirmwareVersion, Controller->FirmwareVersion);
-        return (copy_to_user(UserSpaceControllerInfo, &ControllerInfo,
+        ErrorCode = (copy_to_user(UserSpaceControllerInfo, &ControllerInfo,
                              sizeof(DAC960_ControllerInfo_T)) ? -EFAULT : 0);
+        break;
       }
     case DAC960_IOCTL_V1_EXECUTE_COMMAND:
       {
@@ -6684,30 +6693,39 @@ static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
         int ControllerNumber, DataTransferLength;
         unsigned char *DataTransferBuffer = NULL;
         dma_addr_t DataTransferBufferDMA;
-        if (UserSpaceUserCommand == NULL) return -EINVAL;
+        if (UserSpaceUserCommand == NULL) {
+                ErrorCode = -EINVAL;
+                break;
+        }
         if (copy_from_user(&UserCommand, UserSpaceUserCommand,
                                    sizeof(DAC960_V1_UserCommand_T))) {
                 ErrorCode = -EFAULT;
-                goto Failure1a;
+                break;
         }
         ControllerNumber = UserCommand.ControllerNumber;
+        ErrorCode = -ENXIO;
         if (ControllerNumber < 0 ||
             ControllerNumber > DAC960_ControllerCount - 1)
-          return -ENXIO;
+                break;
         Controller = DAC960_Controllers[ControllerNumber];
-        if (Controller == NULL) return -ENXIO;
-        if (Controller->FirmwareType != DAC960_V1_Controller) return -EINVAL;
+        if (Controller == NULL)
+                break;
+        ErrorCode = -EINVAL;
+        if (Controller->FirmwareType != DAC960_V1_Controller)
+                break;
         CommandOpcode = UserCommand.CommandMailbox.Common.CommandOpcode;
         DataTransferLength = UserCommand.DataTransferLength;
-        if (CommandOpcode & 0x80) return -EINVAL;
+        if (CommandOpcode & 0x80)
+                break;
         if (CommandOpcode == DAC960_V1_DCDB)
           {
             if (copy_from_user(&DCDB, UserCommand.DCDB,
                                sizeof(DAC960_V1_DCDB_T))) {
                 ErrorCode = -EFAULT;
-                goto Failure1a;
+                break;
             }
-            if (DCDB.Channel >= DAC960_V1_MaxChannels) return -EINVAL;
+            if (DCDB.Channel >= DAC960_V1_MaxChannels)
+                        break;
             if (!((DataTransferLength == 0 &&
                    DCDB.Direction
                    == DAC960_V1_DCDB_NoDataTransfer) ||
@@ -6717,38 +6735,37 @@ static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
                   (DataTransferLength < 0 &&
                    DCDB.Direction
                    == DAC960_V1_DCDB_DataTransferSystemToDevice)))
-              return -EINVAL;
+                        break;
             if (((DCDB.TransferLengthHigh4 << 16) | DCDB.TransferLength)
                 != abs(DataTransferLength))
-              return -EINVAL;
+                        break;
             DCDB_IOBUF = pci_alloc_consistent(Controller->PCIDevice,
                         sizeof(DAC960_V1_DCDB_T), &DCDB_IOBUFDMA);
-            if (DCDB_IOBUF == NULL)
-                        return -ENOMEM;
+            if (DCDB_IOBUF == NULL) {
+                        ErrorCode = -ENOMEM;
+                        break;
+                }
           }
+        ErrorCode = -ENOMEM;
         if (DataTransferLength > 0)
           {
             DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
                                 DataTransferLength, &DataTransferBufferDMA);
-            if (DataTransferBuffer == NULL) {
-                ErrorCode = -ENOMEM;
-                goto Failure1;
-            }
+            if (DataTransferBuffer == NULL)
+                break;
             memset(DataTransferBuffer, 0, DataTransferLength);
           }
         else if (DataTransferLength < 0)
           {
             DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
                                 -DataTransferLength, &DataTransferBufferDMA);
-            if (DataTransferBuffer == NULL) {
-                ErrorCode = -ENOMEM;
-                goto Failure1;
-            }
+            if (DataTransferBuffer == NULL)
+                break;
             if (copy_from_user(DataTransferBuffer,
                                UserCommand.DataTransferBuffer,
                                -DataTransferLength)) {
                 ErrorCode = -EFAULT;
-                goto Failure1;
+                break;
             }
           }
         if (CommandOpcode == DAC960_V1_DCDB)
@@ -6825,8 +6842,7 @@ static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
         if (DCDB_IOBUF != NULL)
           pci_free_consistent(Controller->PCIDevice, sizeof(DAC960_V1_DCDB_T),
                         DCDB_IOBUF, DCDB_IOBUFDMA);
-      Failure1a:
-        return ErrorCode;
+        break;
       }
     case DAC960_IOCTL_V2_EXECUTE_COMMAND:
       {
@@ -6844,32 +6860,43 @@ static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
         dma_addr_t DataTransferBufferDMA;
         unsigned char *RequestSenseBuffer = NULL;
         dma_addr_t RequestSenseBufferDMA;
-        if (UserSpaceUserCommand == NULL) return -EINVAL;
+
+        ErrorCode = -EINVAL;
+        if (UserSpaceUserCommand == NULL)
+                break;
         if (copy_from_user(&UserCommand, UserSpaceUserCommand,
                            sizeof(DAC960_V2_UserCommand_T))) {
                 ErrorCode = -EFAULT;
-                goto Failure2a;
+                break;
         }
+        ErrorCode = -ENXIO;
         ControllerNumber = UserCommand.ControllerNumber;
         if (ControllerNumber < 0 ||
             ControllerNumber > DAC960_ControllerCount - 1)
-          return -ENXIO;
+                break;
         Controller = DAC960_Controllers[ControllerNumber];
-        if (Controller == NULL) return -ENXIO;
-        if (Controller->FirmwareType != DAC960_V2_Controller) return -EINVAL;
+        if (Controller == NULL)
+                break;
+        if (Controller->FirmwareType != DAC960_V2_Controller){
+                ErrorCode = -EINVAL;
+                break;
+        }
         DataTransferLength = UserCommand.DataTransferLength;
+        ErrorCode = -ENOMEM;
         if (DataTransferLength > 0)
           {
             DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
                                 DataTransferLength, &DataTransferBufferDMA);
-            if (DataTransferBuffer == NULL) return -ENOMEM;
+            if (DataTransferBuffer == NULL)
+                break;
             memset(DataTransferBuffer, 0, DataTransferLength);
           }
         else if (DataTransferLength < 0)
           {
             DataTransferBuffer = pci_alloc_consistent(Controller->PCIDevice,
                                 -DataTransferLength, &DataTransferBufferDMA);
-            if (DataTransferBuffer == NULL) return -ENOMEM;
+            if (DataTransferBuffer == NULL)
+                break;
             if (copy_from_user(DataTransferBuffer,
                                UserCommand.DataTransferBuffer,
                                -DataTransferLength)) {
@@ -6979,8 +7006,7 @@ static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
         if (RequestSenseBuffer != NULL)
           pci_free_consistent(Controller->PCIDevice, RequestSenseLength,
                 RequestSenseBuffer, RequestSenseBufferDMA);
-      Failure2a:
-        return ErrorCode;
+        break;
       }
     case DAC960_IOCTL_V2_GET_HEALTH_STATUS:
       {
@@ -6990,21 +7016,33 @@ static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
         DAC960_V2_HealthStatusBuffer_T HealthStatusBuffer;
         DAC960_Controller_T *Controller;
         int ControllerNumber;
-        if (UserSpaceGetHealthStatus == NULL) return -EINVAL;
+        if (UserSpaceGetHealthStatus == NULL) {
+                ErrorCode = -EINVAL;
+                break;
+        }
         if (copy_from_user(&GetHealthStatus, UserSpaceGetHealthStatus,
-                           sizeof(DAC960_V2_GetHealthStatus_T)))
-                return -EFAULT;
+                           sizeof(DAC960_V2_GetHealthStatus_T))) {
+                ErrorCode = -EFAULT;
+                break;
+        }
+        ErrorCode = -ENXIO;
         ControllerNumber = GetHealthStatus.ControllerNumber;
         if (ControllerNumber < 0 ||
             ControllerNumber > DAC960_ControllerCount - 1)
-          return -ENXIO;
+                    break;
         Controller = DAC960_Controllers[ControllerNumber];
-        if (Controller == NULL) return -ENXIO;
-        if (Controller->FirmwareType != DAC960_V2_Controller) return -EINVAL;
+        if (Controller == NULL)
+                break;
+        if (Controller->FirmwareType != DAC960_V2_Controller) {
+                ErrorCode = -EINVAL;
+                break;
+        }
         if (copy_from_user(&HealthStatusBuffer,
                            GetHealthStatus.HealthStatusBuffer,
-                           sizeof(DAC960_V2_HealthStatusBuffer_T)))
-                return -EFAULT;
+                           sizeof(DAC960_V2_HealthStatusBuffer_T))) {
+                ErrorCode = -EFAULT;
+                break;
+        }
         while (Controller->V2.HealthStatusBuffer->StatusChangeCounter
                == HealthStatusBuffer.StatusChangeCounter &&
                Controller->V2.HealthStatusBuffer->NextEventSequenceNumber
@@ -7012,21 +7050,28 @@ static int DAC960_gam_ioctl(struct inode *inode, struct file *file,
           {
             interruptible_sleep_on_timeout(&Controller->HealthStatusWaitQueue,
                                            DAC960_MonitoringTimerInterval);
-            if (signal_pending(current)) return -EINTR;
+            if (signal_pending(current)) {
+                ErrorCode = -EINTR;
+                break;
+            }
           }
         if (copy_to_user(GetHealthStatus.HealthStatusBuffer,
                          Controller->V2.HealthStatusBuffer,
                          sizeof(DAC960_V2_HealthStatusBuffer_T)))
-                return -EFAULT;
-        return 0;
+                ErrorCode = -EFAULT;
+        else
+                ErrorCode =  0;
       }
+      default:
+        ErrorCode = -ENOTTY;
     }
-  return -EINVAL;
+  unlock_kernel();
+  return ErrorCode;
 }
 
 static const struct file_operations DAC960_gam_fops = {
         .owner          = THIS_MODULE,
-        .ioctl          = DAC960_gam_ioctl
+        .unlocked_ioctl = DAC960_gam_ioctl
 };
 
 static struct miscdevice DAC960_gam_dev = {
diff --git a/drivers/block/aoe/aoechr.c b/drivers/block/aoe/aoechr.c
index e8e60e7a2e70..d1de68a31920 100644
--- a/drivers/block/aoe/aoechr.c
+++ b/drivers/block/aoe/aoechr.c
@@ -7,6 +7,7 @@
 #include <linux/hdreg.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
+#include <linux/smp_lock.h>
 #include "aoe.h"
 
 enum {
@@ -174,12 +175,16 @@ aoechr_open(struct inode *inode, struct file *filp)
 {
         int n, i;
 
+        lock_kernel();
         n = iminor(inode);
         filp->private_data = (void *) (unsigned long) n;
 
         for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
-                if (chardevs[i].minor == n)
+                if (chardevs[i].minor == n) {
+                        unlock_kernel();
                         return 0;
+                }
+        unlock_kernel();
         return -EINVAL;
 }
 
diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index 41f818be2f7e..2f1746295d06 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -1003,7 +1003,7 @@ aoecmd_cfg_rsp(struct sk_buff *skb)
          * Enough people have their dip switches set backwards to
          * warrant a loud message for this special case.
          */
-        aoemajor = be16_to_cpu(get_unaligned(&h->major));
+        aoemajor = get_unaligned_be16(&h->major);
         if (aoemajor == 0xfff) {
                 printk(KERN_ERR "aoe: Warning: shelf address is all ones.  "
                         "Check shelf dip switches.\n");
diff --git a/drivers/block/paride/pg.c b/drivers/block/paride/pg.c
index ab86e23ddc69..9d92636350e5 100644
--- a/drivers/block/paride/pg.c
+++ b/drivers/block/paride/pg.c
@@ -162,6 +162,7 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
 #include <linux/pg.h>
 #include <linux/device.h>
 #include <linux/sched.h>        /* current, TASK_* */
+#include <linux/smp_lock.h>
 #include <linux/jiffies.h>
 
 #include <asm/uaccess.h>
@@ -515,12 +516,18 @@ static int pg_open(struct inode *inode, struct file *file)
 {
         int unit = iminor(inode) & 0x7f;
         struct pg *dev = &devices[unit];
+        int ret = 0;
 
-        if ((unit >= PG_UNITS) || (!dev->present))
-                return -ENODEV;
+        lock_kernel();
+        if ((unit >= PG_UNITS) || (!dev->present)) {
+                ret = -ENODEV;
+                goto out;
+        }
 
-        if (test_and_set_bit(0, &dev->access))
-                return -EBUSY;
+        if (test_and_set_bit(0, &dev->access)) {
+                ret = -EBUSY;
+                goto out;
+        }
 
         if (dev->busy) {
                 pg_reset(dev);
@@ -533,12 +540,15 @@ static int pg_open(struct inode *inode, struct file *file)
         if (dev->bufptr == NULL) {
                 clear_bit(0, &dev->access);
                 printk("%s: buffer allocation failed\n", dev->name);
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto out;
         }
 
         file->private_data = dev;
 
-        return 0;
+out:
+        unlock_kernel();
+        return ret;
 }
 
 static int pg_release(struct inode *inode, struct file *file)
diff --git a/drivers/block/paride/pt.c b/drivers/block/paride/pt.c
index 8b9549ab4a4e..5c74c3574a5a 100644
--- a/drivers/block/paride/pt.c
+++ b/drivers/block/paride/pt.c
@@ -146,6 +146,7 @@ static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
 #include <linux/mtio.h>
 #include <linux/device.h>
 #include <linux/sched.h>        /* current, TASK_*, schedule_timeout() */
+#include <linux/smp_lock.h>
 
 #include <asm/uaccess.h>
 
@@ -189,8 +190,7 @@ module_param_array(drive3, int, NULL, 0);
 #define ATAPI_LOG_SENSE         0x4d
 
 static int pt_open(struct inode *inode, struct file *file);
-static int pt_ioctl(struct inode *inode, struct file *file,
-                    unsigned int cmd, unsigned long arg);
+static long pt_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 static int pt_release(struct inode *inode, struct file *file);
 static ssize_t pt_read(struct file *filp, char __user *buf,
                        size_t count, loff_t * ppos);
@@ -236,7 +236,7 @@ static const struct file_operations pt_fops = {
         .owner = THIS_MODULE,
         .read = pt_read,
         .write = pt_write,
-        .ioctl = pt_ioctl,
+        .unlocked_ioctl = pt_ioctl,
         .open = pt_open,
         .release = pt_release,
 };
@@ -650,8 +650,11 @@ static int pt_open(struct inode *inode, struct file *file)
         struct pt_unit *tape = pt + unit;
         int err;
 
-        if (unit >= PT_UNITS || (!tape->present))
+        lock_kernel();
+        if (unit >= PT_UNITS || (!tape->present)) {
+                unlock_kernel();
                 return -ENODEV;
+        }
 
         err = -EBUSY;
         if (!atomic_dec_and_test(&tape->available))
@@ -678,15 +681,16 @@ static int pt_open(struct inode *inode, struct file *file)
         }
 
         file->private_data = tape;
+        unlock_kernel();
         return 0;
 
 out:
         atomic_inc(&tape->available);
+        unlock_kernel();
         return err;
 }
 
-static int pt_ioctl(struct inode *inode, struct file *file,
-         unsigned int cmd, unsigned long arg)
+static long pt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct pt_unit *tape = file->private_data;
         struct mtop __user *p = (void __user *)arg;
@@ -700,23 +704,26 @@ static int pt_ioctl(struct inode *inode, struct file *file,
                 switch (mtop.mt_op) {
 
                 case MTREW:
+                        lock_kernel();
                         pt_rewind(tape);
+                        unlock_kernel();
                         return 0;
 
                 case MTWEOF:
+                        lock_kernel();
                         pt_write_fm(tape);
+                        unlock_kernel();
                         return 0;
 
                 default:
-                        printk("%s: Unimplemented mt_op %d\n", tape->name,
+                        /* FIXME: rate limit ?? */
+                        printk(KERN_DEBUG "%s: Unimplemented mt_op %d\n", tape->name,
                                mtop.mt_op);
                         return -EINVAL;
                 }
 
         default:
-                printk("%s: Unimplemented ioctl 0x%x\n", tape->name, cmd);
-                return -EINVAL;
-
+                return -ENOTTY;
         }
 }
 
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 3ba1df93e9e3..45bee918c46a 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -49,6 +49,7 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/kthread.h>
+#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/spinlock.h>
 #include <linux/file.h>
@@ -2079,7 +2080,6 @@ static noinline_for_stack int pkt_write_caching(struct pktcdvd_device *pd,
         unsigned char buf[64];
         int ret;
 
-        memset(buf, 0, sizeof(buf));
         init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
         cgc.sense = &sense;
         cgc.buflen = pd->mode_offset + 12;
@@ -2126,7 +2126,6 @@ static noinline_for_stack int pkt_get_max_speed(struct pktcdvd_device *pd,
         unsigned char *cap_buf;
         int ret, offset;
 
-        memset(buf, 0, sizeof(buf));
         cap_buf = &buf[sizeof(struct mode_page_header) + pd->mode_offset];
         init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_UNKNOWN);
         cgc.sense = &sense;
@@ -2633,11 +2632,12 @@ end_io:
 
 
 
-static int pkt_merge_bvec(struct request_queue *q, struct bio *bio, struct bio_vec *bvec)
+static int pkt_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
+                          struct bio_vec *bvec)
 {
         struct pktcdvd_device *pd = q->queuedata;
-        sector_t zone = ZONE(bio->bi_sector, pd);
-        int used = ((bio->bi_sector - zone) << 9) + bio->bi_size;
+        sector_t zone = ZONE(bmd->bi_sector, pd);
+        int used = ((bmd->bi_sector - zone) << 9) + bmd->bi_size;
         int remaining = (pd->settings.size << 9) - used;
         int remaining2;
 
@@ -2645,7 +2645,7 @@ static int pkt_merge_bvec(struct request_queue *q, struct bio *bio, struct bio_v
          * A bio <= PAGE_SIZE must be allowed. If it crosses a packet
          * boundary, pkt_make_request() will split the bio.
          */
-        remaining2 = PAGE_SIZE - bio->bi_size;
+        remaining2 = PAGE_SIZE - bmd->bi_size;
         remaining = max(remaining, remaining2);
 
         BUG_ON(remaining < 0);
@@ -2796,9 +2796,14 @@ out_mem:
         return ret;
 }
 
-static int pkt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long pkt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct pktcdvd_device *pd = inode->i_bdev->bd_disk->private_data;
+        struct inode *inode = file->f_path.dentry->d_inode;
+        struct pktcdvd_device *pd;
+        long ret;
+
+        lock_kernel();
+        pd = inode->i_bdev->bd_disk->private_data;
 
         VPRINTK("pkt_ioctl: cmd %x, dev %d:%d\n", cmd, imajor(inode), iminor(inode));
 
@@ -2811,7 +2816,8 @@ static int pkt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, u
         case CDROM_LAST_WRITTEN:
         case CDROM_SEND_PACKET:
         case SCSI_IOCTL_SEND_COMMAND:
-                return blkdev_ioctl(pd->bdev->bd_inode, file, cmd, arg);
+                ret = blkdev_ioctl(pd->bdev->bd_inode, file, cmd, arg);
+                break;
 
         case CDROMEJECT:
                 /*
@@ -2820,14 +2826,15 @@ static int pkt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, u
                  */
                 if (pd->refcnt == 1)
                         pkt_lock_door(pd, 0);
-                return blkdev_ioctl(pd->bdev->bd_inode, file, cmd, arg);
+                ret = blkdev_ioctl(pd->bdev->bd_inode, file, cmd, arg);
+                break;
 
         default:
                 VPRINTK(DRIVER_NAME": Unknown ioctl for %s (%x)\n", pd->name, cmd);
-                return -ENOTTY;
+                ret = -ENOTTY;
         }
-
-        return 0;
+        unlock_kernel();
+        return ret;
 }
 
 static int pkt_media_changed(struct gendisk *disk)
@@ -2849,7 +2856,7 @@ static struct block_device_operations pktcdvd_ops = {
         .owner =                THIS_MODULE,
         .open =                 pkt_open,
         .release =              pkt_close,
-        .ioctl =                pkt_ioctl,
+        .unlocked_ioctl =       pkt_ioctl,
         .media_changed =        pkt_media_changed,
 };
 
@@ -3014,7 +3021,8 @@ static void pkt_get_status(struct pkt_ctrl_command *ctrl_cmd)
         mutex_unlock(&ctl_mutex);
 }
 
-static int pkt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long pkt_ctl_ioctl(struct file *file, unsigned int cmd,
+                                                unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         struct pkt_ctrl_command ctrl_cmd;
@@ -3031,16 +3039,22 @@ static int pkt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cm
         case PKT_CTRL_CMD_SETUP:
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
+                lock_kernel();
                 ret = pkt_setup_dev(new_decode_dev(ctrl_cmd.dev), &pkt_dev);
                 ctrl_cmd.pkt_dev = new_encode_dev(pkt_dev);
+                unlock_kernel();
                 break;
         case PKT_CTRL_CMD_TEARDOWN:
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
+                lock_kernel();
                 ret = pkt_remove_dev(new_decode_dev(ctrl_cmd.pkt_dev));
+                unlock_kernel();
                 break;
         case PKT_CTRL_CMD_STATUS:
+                lock_kernel();
                 pkt_get_status(&ctrl_cmd);
+                unlock_kernel();
                 break;
         default:
                 return -ENOTTY;
@@ -3053,7 +3067,7 @@ static int pkt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cm
 
 
 static const struct file_operations pkt_ctl_fops = {
-        .ioctl   = pkt_ctl_ioctl,
+        .unlocked_ioctl  = pkt_ctl_ioctl,
         .owner   = THIS_MODULE,
 };
 
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index f2fff5799ddf..9ae05c584234 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -38,6 +38,7 @@
 #include <linux/interrupt.h>
 #include <linux/blkdev.h>
 #include <linux/hdreg.h>
+#include <linux/cdrom.h>
 #include <linux/module.h>
 
 #include <xen/xenbus.h>
@@ -153,6 +154,40 @@ static int blkif_getgeo(struct block_device *bd, struct hd_geometry *hg)
         return 0;
 }
 
+int blkif_ioctl(struct inode *inode, struct file *filep,
+                unsigned command, unsigned long argument)
+{
+        struct blkfront_info *info =
+                inode->i_bdev->bd_disk->private_data;
+        int i;
+
+        dev_dbg(&info->xbdev->dev, "command: 0x%x, argument: 0x%lx\n",
+                command, (long)argument);
+
+        switch (command) {
+        case CDROMMULTISESSION:
+                dev_dbg(&info->xbdev->dev, "FIXME: support multisession CDs later\n");
+                for (i = 0; i < sizeof(struct cdrom_multisession); i++)
+                        if (put_user(0, (char __user *)(argument + i)))
+                                return -EFAULT;
+                return 0;
+
+        case CDROM_GET_CAPABILITY: {
+                struct gendisk *gd = info->gd;
+                if (gd->flags & GENHD_FL_CD)
+                        return 0;
+                return -EINVAL;
+        }
+
+        default:
+                /*printk(KERN_ALERT "ioctl %08x not supported by Xen blkdev\n",
+                  command);*/
+                return -EINVAL; /* same return as native Linux */
+        }
+
+        return 0;
+}
+
 /*
  * blkif_queue_request
  *
@@ -324,6 +359,9 @@ static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size)
         /* Make sure buffer addresses are sector-aligned. */
         blk_queue_dma_alignment(rq, 511);
 
+        /* Make sure we don't use bounce buffers. */
+        blk_queue_bounce_limit(rq, BLK_BOUNCE_ANY);
+
         gd->queue = rq;
 
         return 0;
@@ -546,7 +584,7 @@ static int setup_blkring(struct xenbus_device *dev,
 
         info->ring_ref = GRANT_INVALID_REF;
 
-        sring = (struct blkif_sring *)__get_free_page(GFP_KERNEL);
+        sring = (struct blkif_sring *)__get_free_page(GFP_NOIO | __GFP_HIGH);
         if (!sring) {
                 xenbus_dev_fatal(dev, -ENOMEM, "allocating shared ring");
                 return -ENOMEM;
@@ -703,7 +741,8 @@ static int blkif_recover(struct blkfront_info *info)
         int j;
 
         /* Stage 1: Make a safe copy of the shadow state. */
-        copy = kmalloc(sizeof(info->shadow), GFP_KERNEL);
+        copy = kmalloc(sizeof(info->shadow),
+                       GFP_NOIO | __GFP_REPEAT | __GFP_HIGH);
         if (!copy)
                 return -ENOMEM;
         memcpy(copy, info->shadow, sizeof(info->shadow));
@@ -959,7 +998,7 @@ static int blkif_release(struct inode *inode, struct file *filep)
                 struct xenbus_device *dev = info->xbdev;
                 enum xenbus_state state = xenbus_read_driver_state(dev->otherend);
 
-                if (state == XenbusStateClosing)
+                if (state == XenbusStateClosing && info->is_ready)
                         blkfront_closing(dev);
         }
         return 0;
@@ -971,6 +1010,7 @@ static struct block_device_operations xlvbd_block_fops =
         .open = blkif_open,
         .release = blkif_release,
         .getgeo = blkif_getgeo,
+        .ioctl = blkif_ioctl,
 };
 
 
@@ -1006,7 +1046,7 @@ static int __init xlblk_init(void)
 module_init(xlblk_init);
 
 
-static void xlblk_exit(void)
+static void __exit xlblk_exit(void)
 {
         return xenbus_unregister_driver(&blkfront);
 }