microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

floppy: cleanup: expand macro UDP 

This macro doesn't bring much value and only slightly obfuscates the
code by silently using local variable "drive", let's expand it.

Link: https://lore.kernel.org/r/20200224212352.8640-4-w@1wt.eu
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Denis Efremov <efremov@linux.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
This commit is contained in:
Willy Tarreau 2020-02-24 22:23:45 +01:00 коммит произвёл Jens Axboe
Родитель f9d322bdb1
Коммит 1ce9ae9654
1 изменённых файлов: 77 добавлений и 75 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

152
drivers/block/floppy.c
Просмотреть файл

@ -310,7 +310,6 @@ static bool initialized;
#define DRS (&drive_state[current_drive])
#define DRWE (&write_errors[current_drive])
#define UDP (&drive_params[drive])
#define UDRS (&drive_state[drive])
#define UDRWE (&write_errors[drive])
@ -681,10 +680,10 @@ static void __reschedule_timeout(int drive, const char *message)
delay = 20UL * HZ;
drive = 0;
} else
delay = UDP->timeout;
delay = drive_params[drive].timeout;
mod_delayed_work(floppy_wq, &fd_timeout, delay);
if (UDP->flags & FD_DEBUG)
if (drive_params[drive].flags & FD_DEBUG)
DPRINT("reschedule timeout %s\n", message);
timeout_message = message;
}
@ -738,7 +737,7 @@ static int disk_change(int drive)
{
int fdc = FDC(drive);
if (time_before(jiffies, UDRS->select_date + UDP->select_delay))
if (time_before(jiffies, UDRS->select_date + drive_params[drive].select_delay))
DPRINT("WARNING disk change called early\n");
if (!(fdc_state[fdc].dor & (0x10 << UNIT(drive))) ||
(fdc_state[fdc].dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
@ -747,15 +746,16 @@ static int disk_change(int drive)
(unsigned int)fdc_state[fdc].dor);
}
debug_dcl(UDP->flags,
debug_dcl(drive_params[drive].flags,
"checking disk change line for drive %d\n", drive);
debug_dcl(UDP->flags, "jiffies=%lu\n", jiffies);
debug_dcl(UDP->flags, "disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
debug_dcl(UDP->flags, "flags=%lx\n", UDRS->flags);
debug_dcl(drive_params[drive].flags, "jiffies=%lu\n", jiffies);
debug_dcl(drive_params[drive].flags, "disk change line=%x\n",
fd_inb(FD_DIR) & 0x80);
debug_dcl(drive_params[drive].flags, "flags=%lx\n", UDRS->flags);
if (UDP->flags & FD_BROKEN_DCL)
if (drive_params[drive].flags & FD_BROKEN_DCL)
return test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
if ((fd_inb(FD_DIR) ^ drive_params[drive].flags) & 0x80) {
set_bit(FD_VERIFY_BIT, &UDRS->flags);
/* verify write protection */
@ -764,7 +764,7 @@ static int disk_change(int drive)
/* invalidate its geometry */
if (UDRS->keep_data >= 0) {
if ((UDP->flags & FTD_MSG) &&
if ((drive_params[drive].flags & FTD_MSG) &&
current_type[drive] != NULL)
DPRINT("Disk type is undefined after disk change\n");
current_type[drive] = NULL;
@ -806,7 +806,7 @@ static int set_dor(int fdc, char mask, char data)
unit = olddor & 0x3;
if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
drive = REVDRIVE(fdc, unit);
debug_dcl(UDP->flags,
debug_dcl(drive_params[drive].flags,
"calling disk change from set_dor\n");
disk_change(drive);
}
@ -929,12 +929,12 @@ static void floppy_off(unsigned int drive)
/* make spindle stop in a position which minimizes spinup time
* next time */
if (UDP->rps) {
if (drive_params[drive].rps) {
delta = jiffies - UDRS->first_read_date + HZ -
UDP->spindown_offset;
delta = ((delta * UDP->rps) % HZ) / UDP->rps;
drive_params[drive].spindown_offset;
delta = ((delta * drive_params[drive].rps) % HZ) / drive_params[drive].rps;
motor_off_timer[drive].expires =
jiffies + UDP->spindown - delta;
jiffies + drive_params[drive].spindown - delta;
}
add_timer(motor_off_timer + drive);
}
@ -956,7 +956,7 @@ static void scandrives(void)
saved_drive = current_drive;
for (i = 0; i < N_DRIVE; i++) {
drive = (saved_drive + i + 1) % N_DRIVE;
if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
if (UDRS->fd_ref == 0 || drive_params[drive].select_delay != 0)
continue; /* skip closed drives */
set_fdc(drive);
if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
@ -2999,8 +2999,8 @@ static const char *drive_name(int type, int drive)
if (type)
floppy = floppy_type + type;
else {
if (UDP->native_format)
floppy = floppy_type + UDP->native_format;
if (drive_params[drive].native_format)
floppy = floppy_type + drive_params[drive].native_format;
else
return "(null)";
}
@ -3240,7 +3240,7 @@ static int set_geometry(unsigned int cmd, struct floppy_struct *g,
(int)(g->sect * g->head) <= 0 ||
/* check for zero in F_SECT_PER_TRACK */
(unsigned char)((g->sect << 2) >> FD_SIZECODE(g)) == 0 ||
g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
g->track <= 0 || g->track > drive_params[drive].tracks >> STRETCH(g) ||
/* check if reserved bits are set */
(g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_SECTBASEMASK)) != 0)
return -EINVAL;
@ -3487,10 +3487,10 @@ static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int
outparam = &inparam.g;
break;
case FDMSGON:
UDP->flags |= FTD_MSG;
drive_params[drive].flags |= FTD_MSG;
return 0;
case FDMSGOFF:
UDP->flags &= ~FTD_MSG;
drive_params[drive].flags &= ~FTD_MSG;
return 0;
case FDFMTBEG:
if (lock_fdc(drive))
@ -3514,13 +3514,13 @@ static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int
return -EINTR;
return invalidate_drive(bdev);
case FDSETEMSGTRESH:
UDP->max_errors.reporting = (unsigned short)(param & 0x0f);
drive_params[drive].max_errors.reporting = (unsigned short)(param & 0x0f);
return 0;
case FDGETMAXERRS:
outparam = &UDP->max_errors;
outparam = &drive_params[drive].max_errors;
break;
case FDSETMAXERRS:
UDP->max_errors = inparam.max_errors;
drive_params[drive].max_errors = inparam.max_errors;
break;
case FDGETDRVTYP:
outparam = drive_name(type, drive);
@ -3530,10 +3530,10 @@ static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int
if (!valid_floppy_drive_params(inparam.dp.autodetect,
inparam.dp.native_format))
return -EINVAL;
*UDP = inparam.dp;
drive_params[drive] = inparam.dp;
break;
case FDGETDRVPRM:
outparam = UDP;
outparam = &drive_params[drive];
break;
case FDPOLLDRVSTAT:
if (lock_fdc(drive))
@ -3730,25 +3730,26 @@ static int compat_setdrvprm(int drive,
if (!valid_floppy_drive_params(v.autodetect, v.native_format))
return -EINVAL;
mutex_lock(&floppy_mutex);
UDP->cmos = v.cmos;
UDP->max_dtr = v.max_dtr;
UDP->hlt = v.hlt;
UDP->hut = v.hut;
UDP->srt = v.srt;
UDP->spinup = v.spinup;
UDP->spindown = v.spindown;
UDP->spindown_offset = v.spindown_offset;
UDP->select_delay = v.select_delay;
UDP->rps = v.rps;
UDP->tracks = v.tracks;
UDP->timeout = v.timeout;
UDP->interleave_sect = v.interleave_sect;
UDP->max_errors = v.max_errors;
UDP->flags = v.flags;
UDP->read_track = v.read_track;
memcpy(UDP->autodetect, v.autodetect, sizeof(v.autodetect));
UDP->checkfreq = v.checkfreq;
UDP->native_format = v.native_format;
drive_params[drive].cmos = v.cmos;
drive_params[drive].max_dtr = v.max_dtr;
drive_params[drive].hlt = v.hlt;
drive_params[drive].hut = v.hut;
drive_params[drive].srt = v.srt;
drive_params[drive].spinup = v.spinup;
drive_params[drive].spindown = v.spindown;
drive_params[drive].spindown_offset = v.spindown_offset;
drive_params[drive].select_delay = v.select_delay;
drive_params[drive].rps = v.rps;
drive_params[drive].tracks = v.tracks;
drive_params[drive].timeout = v.timeout;
drive_params[drive].interleave_sect = v.interleave_sect;
drive_params[drive].max_errors = v.max_errors;
drive_params[drive].flags = v.flags;
drive_params[drive].read_track = v.read_track;
memcpy(drive_params[drive].autodetect, v.autodetect,
sizeof(v.autodetect));
drive_params[drive].checkfreq = v.checkfreq;
drive_params[drive].native_format = v.native_format;
mutex_unlock(&floppy_mutex);
return 0;
}
@ -3760,25 +3761,26 @@ static int compat_getdrvprm(int drive,
memset(&v, 0, sizeof(struct compat_floppy_drive_params));
mutex_lock(&floppy_mutex);
v.cmos = UDP->cmos;
v.max_dtr = UDP->max_dtr;
v.hlt = UDP->hlt;
v.hut = UDP->hut;
v.srt = UDP->srt;
v.spinup = UDP->spinup;
v.spindown = UDP->spindown;
v.spindown_offset = UDP->spindown_offset;
v.select_delay = UDP->select_delay;
v.rps = UDP->rps;
v.tracks = UDP->tracks;
v.timeout = UDP->timeout;
v.interleave_sect = UDP->interleave_sect;
v.max_errors = UDP->max_errors;
v.flags = UDP->flags;
v.read_track = UDP->read_track;
memcpy(v.autodetect, UDP->autodetect, sizeof(v.autodetect));
v.checkfreq = UDP->checkfreq;
v.native_format = UDP->native_format;
v.cmos = drive_params[drive].cmos;
v.max_dtr = drive_params[drive].max_dtr;
v.hlt = drive_params[drive].hlt;
v.hut = drive_params[drive].hut;
v.srt = drive_params[drive].srt;
v.spinup = drive_params[drive].spinup;
v.spindown = drive_params[drive].spindown;
v.spindown_offset = drive_params[drive].spindown_offset;
v.select_delay = drive_params[drive].select_delay;
v.rps = drive_params[drive].rps;
v.tracks = drive_params[drive].tracks;
v.timeout = drive_params[drive].timeout;
v.interleave_sect = drive_params[drive].interleave_sect;
v.max_errors = drive_params[drive].max_errors;
v.flags = drive_params[drive].flags;
v.read_track = drive_params[drive].read_track;
memcpy(v.autodetect, drive_params[drive].autodetect,
sizeof(v.autodetect));
v.checkfreq = drive_params[drive].checkfreq;
v.native_format = drive_params[drive].native_format;
mutex_unlock(&floppy_mutex);
if (copy_to_user(arg, &v, sizeof(struct compat_floppy_drive_params)))
@ -3931,16 +3933,16 @@ static void __init config_types(void)
/* read drive info out of physical CMOS */
drive = 0;
if (!UDP->cmos)
UDP->cmos = FLOPPY0_TYPE;
if (!drive_params[drive].cmos)
drive_params[drive].cmos = FLOPPY0_TYPE;
drive = 1;
if (!UDP->cmos)
UDP->cmos = FLOPPY1_TYPE;
if (!drive_params[drive].cmos)
drive_params[drive].cmos = FLOPPY1_TYPE;
/* FIXME: additional physical CMOS drive detection should go here */
for (drive = 0; drive < N_DRIVE; drive++) {
unsigned int type = UDP->cmos;
unsigned int type = drive_params[drive].cmos;
struct floppy_drive_params *params;
const char *name = NULL;
char temparea[32];
@ -3970,7 +3972,7 @@ static void __init config_types(void)
pr_cont("%s fd%d is %s", prepend, drive, name);
}
*UDP = *params;
drive_params[drive] = *params;
}
if (has_drive)
@ -4012,7 +4014,7 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
if (opened_bdev[drive] && opened_bdev[drive] != bdev)
goto out2;
if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
if (!UDRS->fd_ref && (drive_params[drive].flags & FD_BROKEN_DCL)) {
set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
set_bit(FD_VERIFY_BIT, &UDRS->flags);
}
@ -4026,7 +4028,7 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
if (!floppy_track_buffer) {
/* if opening an ED drive, reserve a big buffer,
* else reserve a small one */
if ((UDP->cmos == 6) || (UDP->cmos == 5))
if ((drive_params[drive].cmos == 6) || (drive_params[drive].cmos == 5))
try = 64; /* Only 48 actually useful */
else
try = 32; /* Only 24 actually useful */
@ -4105,7 +4107,7 @@ static unsigned int floppy_check_events(struct gendisk *disk,
test_bit(FD_VERIFY_BIT, &UDRS->flags))
return DISK_EVENT_MEDIA_CHANGE;
if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
if (time_after(jiffies, UDRS->last_checked + drive_params[drive].checkfreq)) {
if (lock_fdc(drive))
return 0;
poll_drive(false, 0);
@ -4471,7 +4473,7 @@ static ssize_t floppy_cmos_show(struct device *dev,
int drive;
drive = p->id;
return sprintf(buf, "%X\n", UDP->cmos);
return sprintf(buf, "%X\n", drive_params[drive].cmos);
}
static DEVICE_ATTR(cmos, 0444, floppy_cmos_show, NULL);