VirtualBox

Ticket #15581: patch-floppy-4.6.5.diff

File patch-floppy-4.6.5.diff, 5.1 KB (added by dinosaur0, 8 years ago)

Patch to the Linux kernel to restore proper floppy compatibility with Vbox 5.0

  • drivers/block/floppy.c

    diff -durN linux-4.6.5/drivers/block/floppy.c linux-4.6.5-patched/drivers/block/floppy.c
    old new  
    866866}
    867867
    868868/* locks the driver */
    869 static int lock_fdc(int drive)
     869static int lock_fdc(int drive, bool interruptible)
    870870{
    871871        if (WARN(atomic_read(&usage_count) == 0,
    872872                 "Trying to lock fdc while usage count=0\n"))
     
    21732173{
    21742174        int ret;
    21752175
    2176         if (lock_fdc(drive))
     2176        if (lock_fdc(drive, true))
    21772177                return -EINTR;
    21782178
    21792179        set_floppy(drive);
     
    29602960{
    29612961        int ret;
    29622962
    2963         if (lock_fdc(drive))
     2963        if (lock_fdc(drive, interruptible))
    29642964                return -EINTR;
    29652965
    29662966        if (arg == FD_RESET_ALWAYS)
     
    32433243                if (!capable(CAP_SYS_ADMIN))
    32443244                        return -EPERM;
    32453245                mutex_lock(&open_lock);
    3246                 if (lock_fdc(drive)) {
     3246                if (lock_fdc(drive, true)) {
    32473247                        mutex_unlock(&open_lock);
    32483248                        return -EINTR;
    32493249                }
     
    32633263        } else {
    32643264                int oldStretch;
    32653265
    3266                 if (lock_fdc(drive))
     3266                if (lock_fdc(drive, true))
    32673267                        return -EINTR;
    32683268                if (cmd != FDDEFPRM) {
    32693269                        /* notice a disk change immediately, else
     
    33493349        if (type)
    33503350                *g = &floppy_type[type];
    33513351        else {
    3352                 if (lock_fdc(drive))
     3352                if (lock_fdc(drive, false))
    33533353                        return -EINTR;
    33543354                if (poll_drive(false, 0) == -EINTR)
    33553355                        return -EINTR;
     
    34333433                if (UDRS->fd_ref != 1)
    34343434                        /* somebody else has this drive open */
    34353435                        return -EBUSY;
    3436                 if (lock_fdc(drive))
     3436                if (lock_fdc(drive, true))
    34373437                        return -EINTR;
    34383438
    34393439                /* do the actual eject. Fails on
     
    34453445                process_fd_request();
    34463446                return ret;
    34473447        case FDCLRPRM:
    3448                 if (lock_fdc(drive))
     3448                if (lock_fdc(drive, true))
    34493449                        return -EINTR;
    34503450                current_type[drive] = NULL;
    34513451                floppy_sizes[drive] = MAX_DISK_SIZE << 1;
     
    34673467                UDP->flags &= ~FTD_MSG;
    34683468                return 0;
    34693469        case FDFMTBEG:
    3470                 if (lock_fdc(drive))
     3470                if (lock_fdc(drive, true))
    34713471                        return -EINTR;
    34723472                if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
    34733473                        return -EINTR;
     
    34843484                return do_format(drive, &inparam.f);
    34853485        case FDFMTEND:
    34863486        case FDFLUSH:
    3487                 if (lock_fdc(drive))
     3487                if (lock_fdc(drive, true))
    34883488                        return -EINTR;
    34893489                return invalidate_drive(bdev);
    34903490        case FDSETEMSGTRESH:
     
    35073507                outparam = UDP;
    35083508                break;
    35093509        case FDPOLLDRVSTAT:
    3510                 if (lock_fdc(drive))
     3510                if (lock_fdc(drive, true))
    35113511                        return -EINTR;
    35123512                if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
    35133513                        return -EINTR;
     
    35303530        case FDRAWCMD:
    35313531                if (type)
    35323532                        return -EINVAL;
    3533                 if (lock_fdc(drive))
     3533                if (lock_fdc(drive, true))
    35343534                        return -EINTR;
    35353535                set_floppy(drive);
    35363536                i = raw_cmd_ioctl(cmd, (void __user *)param);
     
    35393539                process_fd_request();
    35403540                return i;
    35413541        case FDTWADDLE:
    3542                 if (lock_fdc(drive))
     3542                if (lock_fdc(drive, true))
    35433543                        return -EINTR;
    35443544                twaddle();
    35453545                process_fd_request();
     
    35853585                unsigned int type = UDP->cmos;
    35863586                struct floppy_drive_params *params;
    35873587                const char *name = NULL;
    3588                 char temparea[32];
     3588                static char temparea[32];
    35893589
    35903590                if (type < ARRAY_SIZE(default_drive_params)) {
    35913591                        params = &default_drive_params[type].params;
     
    35963596                                allowed_drive_mask &= ~(1 << drive);
    35973597                } else {
    35983598                        params = &default_drive_params[0].params;
    3599                         snprintf(temparea, sizeof(temparea),
    3600                                  "unknown type %d (usb?)", type);
     3599                        sprintf(temparea, "unknown type %d (usb?)", type);
    36013600                        name = temparea;
    36023601                }
    36033602                if (name) {
     
    36633662
    36643663        opened_bdev[drive] = bdev;
    36653664
    3666         if (!(mode & (FMODE_READ|FMODE_WRITE))) {
    3667                 res = -EINVAL;
    3668                 goto out;
    3669         }
    3670 
    36713665        res = -ENXIO;
    36723666
    36733667        if (!floppy_track_buffer) {
     
    37113705        if (UFDCS->rawcmd == 1)
    37123706                UFDCS->rawcmd = 2;
    37133707
    3714         UDRS->last_checked = 0;
    3715         clear_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);
    3716         check_disk_change(bdev);
    3717         if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags))
    3718                 goto out;
    3719         if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags))
    3720                 goto out;
    3721 
    3722         res = -EROFS;
    3723 
    3724         if ((mode & FMODE_WRITE) &&
    3725                         !test_bit(FD_DISK_WRITABLE_BIT, &UDRS->flags))
    3726                 goto out;
    3727 
     3708        if (!(mode & FMODE_NDELAY)) {
     3709                if (mode & (FMODE_READ|FMODE_WRITE)) {
     3710                        UDRS->last_checked = 0;
     3711                        clear_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);
     3712                        check_disk_change(bdev);
     3713                        if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags))
     3714                                goto out;
     3715                        if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags))
     3716                                goto out;
     3717                }
     3718                res = -EROFS;
     3719                if ((mode & FMODE_WRITE) &&
     3720                    !test_bit(FD_DISK_WRITABLE_BIT, &UDRS->flags))
     3721                        goto out;
     3722        }
    37283723        mutex_unlock(&open_lock);
    37293724        mutex_unlock(&floppy_mutex);
    37303725        return 0;
     
    37523747                return DISK_EVENT_MEDIA_CHANGE;
    37533748
    37543749        if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
    3755                 if (lock_fdc(drive))
    3756                         return -EINTR;
     3750                lock_fdc(drive, false);
    37573751                poll_drive(false, 0);
    37583752                process_fd_request();
    37593753        }
     
    38523846                         "VFS: revalidate called on non-open device.\n"))
    38533847                        return -EFAULT;
    38543848
    3855                 res = lock_fdc(drive);
    3856                 if (res)
    3857                         return res;
     3849                lock_fdc(drive, false);
    38583850                cf = (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
    38593851                      test_bit(FD_VERIFY_BIT, &UDRS->flags));
    38603852                if (!(cf || test_bit(drive, &fake_change) || drive_no_geom(drive))) {

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette