From 8ea438ae93f8fc03d1096dd61a940791db4f0ee0 Mon Sep 17 00:00:00 2001 From: Ben Gras Date: Wed, 7 Feb 2007 16:22:19 +0000 Subject: [PATCH] Retired DEV_{READ,WRITE,GATHER,SCATTER,IOCTL} (safe versions *_S are to be used and drivers should never receieve these 'unsafe' variants any more). --- drivers/at_wini/at_wini.c | 25 ++++++++++++------------- drivers/bios_wini/bios_wini.c | 11 +++++------ drivers/floppy/floppy.c | 18 +++++++++--------- drivers/libdriver/driver.c | 20 ++++++++++++++++---- drivers/libdriver/drvlib.c | 2 +- drivers/log/log.c | 4 ++-- drivers/memory/memory.c | 12 ++++++------ drivers/printer/printer.c | 1 - drivers/random/main.c | 6 +++--- drivers/sb16/sb16_dsp.c | 12 ++++++++---- drivers/sb16/sb16_mixer.c | 2 ++ drivers/tty/console.c | 2 -- drivers/tty/keyboard.c | 6 ------ drivers/tty/pty.c | 4 ---- drivers/tty/tty.c | 6 +----- include/minix/com.h | 5 ----- servers/inet/sr.c | 14 ++++++++++++++ servers/mfs/cache.c | 4 ++-- servers/mfs/const.h | 7 +++++++ servers/mfs/device.c | 15 ++++++++------- servers/mfs/super.c | 2 +- servers/vfs/const.h | 8 ++++++++ servers/vfs/device.c | 24 ++++++++++++++++-------- servers/vfs/read.c | 6 +++--- servers/vfs/select.c | 4 ++-- 25 files changed, 126 insertions(+), 94 deletions(-) diff --git a/drivers/at_wini/at_wini.c b/drivers/at_wini/at_wini.c index f88805d1a..7b68446d4 100644 --- a/drivers/at_wini/at_wini.c +++ b/drivers/at_wini/at_wini.c @@ -1051,7 +1051,7 @@ PRIVATE int w_io_test(void) if (w_prepare(w_drive * DEV_PER_DRIVE) == NIL_DEV) panic(w_name(), "Couldn't switch devices", NO_NUM); - r = w_transfer(SELF, DEV_GATHER, cvu64(0), &iov, 1, 0); + r = w_transfer(SELF, DEV_GATHER_S, cvu64(0), &iov, 1, 0); /* Switch back. */ if (w_prepare(save_dev) == NIL_DEV) @@ -1142,21 +1142,21 @@ PRIVATE int do_transfer(struct wini *wn, unsigned int precomp, cmd.count = count; if (do_dma) { - cmd.command = opcode == DEV_SCATTER ? CMD_WRITE_DMA : + cmd.command = opcode == DEV_SCATTER_S ? CMD_WRITE_DMA : CMD_READ_DMA; } else - cmd.command = opcode == DEV_SCATTER ? CMD_WRITE : CMD_READ; + cmd.command = opcode == DEV_SCATTER_S ? CMD_WRITE : CMD_READ; if (do_lba48) { if (do_dma) { - cmd.command = ((opcode == DEV_SCATTER) ? + cmd.command = ((opcode == DEV_SCATTER_S) ? CMD_WRITE_DMA_EXT : CMD_READ_DMA_EXT); } else { - cmd.command = ((opcode == DEV_SCATTER) ? + cmd.command = ((opcode == DEV_SCATTER_S) ? CMD_WRITE_EXT : CMD_READ_EXT); } cmd.count_prev= (count >> 8); @@ -1193,7 +1193,7 @@ PRIVATE int do_transfer(struct wini *wn, unsigned int precomp, *===========================================================================*/ PRIVATE int w_transfer(proc_nr, opcode, position, iov, nr_req, safe) int proc_nr; /* process doing the request */ -int opcode; /* DEV_GATHER or DEV_SCATTER */ +int opcode; /* DEV_GATHER_S or DEV_SCATTER_S */ u64_t position; /* offset on device to read or write */ iovec_t *iov; /* pointer to read or write request vector */ unsigned nr_req; /* length of request vector */ @@ -1232,7 +1232,7 @@ int safe; /* iov contains addresses (0) or grants? */ block = div64u(add64(w_dv->dv_base, position), SECTOR_SIZE); do_dma= wn->dma; - do_write= (opcode == DEV_SCATTER); + do_write= (opcode == DEV_SCATTER_S); if (nbytes >= wn->max_count) { /* The drive can't do more then max_count at once. */ @@ -1254,7 +1254,7 @@ int safe; /* iov contains addresses (0) or grants? */ r = do_transfer(wn, wn->precomp, (nbytes >> SECTOR_SHIFT), block, opcode, do_dma); - if (opcode == DEV_SCATTER) { + if (opcode == DEV_SCATTER_S) { /* The specs call for a 400 ns wait after issuing the command. * Reading the alternate status register is the suggested * way to implement this wait. @@ -1355,7 +1355,7 @@ int safe; /* iov contains addresses (0) or grants? */ * interrupt (write). */ - if (opcode == DEV_GATHER) { + if (opcode == DEV_GATHER_S) { /* First an interrupt, then data. */ if ((r = at_intr_wait()) != OK) { /* An error, send data to the bit bucket. */ @@ -1380,7 +1380,7 @@ int safe; /* iov contains addresses (0) or grants? */ if (!w_waitfor(STATUS_DRQ, STATUS_DRQ)) { r = ERR; break; } /* Copy bytes to or from the device's buffer. */ - if (opcode == DEV_GATHER) { + if (opcode == DEV_GATHER_S) { if(safe) { s=sys_safe_insw(wn->base_cmd + REG_DATA, proc_nr, (void *) (iov->iov_addr), addr_offset, @@ -2123,7 +2123,7 @@ void sense_request(void) *===========================================================================*/ PRIVATE int atapi_transfer(proc_nr, opcode, position, iov, nr_req, safe) int proc_nr; /* process doing the request */ -int opcode; /* DEV_GATHER or DEV_SCATTER */ +int opcode; /* DEV_GATHER_S or DEV_SCATTER_S */ u64_t position; /* offset on device to read or write */ iovec_t *iov; /* pointer to read or write request vector */ unsigned nr_req; /* length of request vector */ @@ -2344,9 +2344,8 @@ int safe; { int r, timeout, prev; - if (m->m_type != DEV_IOCTL && m->m_type != DEV_IOCTL_S ) { + if (m->m_type != DEV_IOCTL_S ) return EINVAL; - } if (m->REQUEST == DIOCTIMEOUT) { if(safe) { diff --git a/drivers/bios_wini/bios_wini.c b/drivers/bios_wini/bios_wini.c index f6f4565d2..87d6fd2fd 100644 --- a/drivers/bios_wini/bios_wini.c +++ b/drivers/bios_wini/bios_wini.c @@ -260,7 +260,7 @@ int safe; /* use safecopies? */ /* Degrade to per-sector mode if there were errors. */ if (errors > 0) nbytes = SECTOR_SIZE; - if (opcode == DEV_SCATTER) { + if (opcode == DEV_SCATTER_S) { /* Copy from user space to the DMA buffer. */ count = 0; for (iop = iov; count < nbytes; iop++) { @@ -294,7 +294,7 @@ int safe; /* use safecopies? */ /* Set up an extended read or write BIOS call. */ reg86.u.b.intno = 0x13; - reg86.u.w.ax = opcode == DEV_SCATTER ? 0x4300 : 0x4200; + reg86.u.w.ax = opcode == DEV_SCATTER_S ? 0x4300 : 0x4200; reg86.u.b.dl = wn->drive_id; reg86.u.w.si = (bios_buf_phys + i13e_rw_off) % HCLICK_SIZE; reg86.u.w.ds = (bios_buf_phys + i13e_rw_off) / HCLICK_SIZE; @@ -305,7 +305,7 @@ int safe; /* use safecopies? */ unsigned head = (block % secspcyl) / wn->sectors; reg86.u.b.intno = 0x13; - reg86.u.b.ah = opcode == DEV_SCATTER ? 0x03 : 0x02; + reg86.u.b.ah = opcode == DEV_SCATTER_S ? 0x03 : 0x02; reg86.u.b.al = nbytes >> SECTOR_SHIFT; reg86.u.w.bx = bios_buf_phys % HCLICK_SIZE; reg86.u.w.es = bios_buf_phys / HCLICK_SIZE; @@ -325,7 +325,7 @@ int safe; /* use safecopies? */ continue; } - if (opcode == DEV_GATHER) { + if (opcode == DEV_GATHER_S) { /* Copy from the DMA buffer to user space. */ count = 0; for (iop = iov; count < nbytes; iop++) { @@ -553,9 +553,8 @@ int safe; { int r, timeout, prev; - if (m->m_type != DEV_IOCTL && m->m_type != DEV_IOCTL_S ) { + if (m->m_type != DEV_IOCTL_S ) return EINVAL; - } if (m->REQUEST == DIOCOPENCT) { int count; diff --git a/drivers/floppy/floppy.c b/drivers/floppy/floppy.c index bc4cacd17..eefbb4361 100644 --- a/drivers/floppy/floppy.c +++ b/drivers/floppy/floppy.c @@ -435,7 +435,7 @@ PRIVATE void f_cleanup() *===========================================================================*/ PRIVATE int f_transfer(proc_nr, opcode, pos64, iov, nr_req, safe) int proc_nr; /* process doing the request */ -int opcode; /* DEV_GATHER or DEV_SCATTER */ +int opcode; /* DEV_GATHER_S or DEV_SCATTER_S */ u64_t pos64; /* offset on device to read or write */ iovec_t *iov; /* pointer to read or write request vector */ unsigned nr_req; /* length of request vector */ @@ -482,7 +482,7 @@ int safe; /* Using a formatting device? */ if (f_device & FORMAT_DEV_BIT) { - if (opcode != DEV_SCATTER) return(EIO); + if (opcode != DEV_SCATTER_S) return(EIO); if (iov->iov_size < SECTOR_SIZE + sizeof(fmt_param)) return(EINVAL); @@ -592,7 +592,7 @@ int safe; } } - if (r == OK && opcode == DEV_SCATTER) { + if (r == OK && opcode == DEV_SCATTER_S) { /* Copy the user bytes to the DMA buffer. */ if(safe) { s=sys_safecopyfrom(proc_nr, *ug, *up, @@ -619,7 +619,7 @@ int safe; r = fdc_transfer(opcode); } - if (r == OK && opcode == DEV_GATHER) { + if (r == OK && opcode == DEV_GATHER_S) { /* Copy the DMA buffer to user space. */ if(safe) { s=sys_safecopyto(proc_nr, *ug, *up, @@ -678,7 +678,7 @@ int safe; * dma_setup * *===========================================================================*/ PRIVATE int dma_setup(opcode) -int opcode; /* DEV_GATHER or DEV_SCATTER */ +int opcode; /* DEV_GATHER_S or DEV_SCATTER_S */ { /* The IBM PC can perform DMA operations by using the DMA chip. To use it, * the DMA (Direct Memory Access) chip is loaded with the 20-bit memory address @@ -706,7 +706,7 @@ int opcode; /* DEV_GATHER or DEV_SCATTER */ */ pv_set(byte_out[0], DMA_INIT, DMA_RESET_VAL); /* reset the dma controller */ pv_set(byte_out[1], DMA_FLIPFLOP, 0); /* write anything to reset it */ - pv_set(byte_out[2], DMA_MODE, opcode == DEV_SCATTER ? DMA_WRITE : DMA_READ); + pv_set(byte_out[2], DMA_MODE, opcode == DEV_SCATTER_S ? DMA_WRITE : DMA_READ); pv_set(byte_out[3], DMA_ADDR, (unsigned) tmp_phys >> 0); pv_set(byte_out[4], DMA_ADDR, (unsigned) tmp_phys >> 8); pv_set(byte_out[5], DMA_TOP, (unsigned) (tmp_phys >> 16)); @@ -857,7 +857,7 @@ PRIVATE int seek() * fdc_transfer * *===========================================================================*/ PRIVATE int fdc_transfer(opcode) -int opcode; /* DEV_GATHER or DEV_SCATTER */ +int opcode; /* DEV_GATHER_S or DEV_SCATTER_S */ { /* The drive is now on the proper cylinder. Read, write or format 1 block. */ @@ -880,7 +880,7 @@ int opcode; /* DEV_GATHER or DEV_SCATTER */ cmd[5] = fmt_param.fill_byte_for_format; if (fdc_command(cmd, 6) != OK) return(ERR_TRANSFER); } else { - cmd[0] = opcode == DEV_SCATTER ? FDC_WRITE : FDC_READ; + cmd[0] = opcode == DEV_SCATTER_S ? FDC_WRITE : FDC_READ; cmd[1] = (fp->fl_head << 2) | f_drive; cmd[2] = fp->fl_cylinder; cmd[3] = fp->fl_head; @@ -1312,7 +1312,7 @@ int density; position = (off_t) f_dp->test << SECTOR_SHIFT; iovec1.iov_addr = (vir_bytes) tmp_buf; iovec1.iov_size = SECTOR_SIZE; - result = f_transfer(SELF, DEV_GATHER, cvul64(position), &iovec1, 1, 0); + result = f_transfer(SELF, DEV_GATHER_S, cvul64(position), &iovec1, 1, 0); if (iovec1.iov_size != 0) return(EIO); diff --git a/drivers/libdriver/driver.c b/drivers/libdriver/driver.c index 4f7302331..6f28bb2b9 100644 --- a/drivers/libdriver/driver.c +++ b/drivers/libdriver/driver.c @@ -37,6 +37,7 @@ * driver_task: called by the device dependent task entry */ + #include "../drivers.h" #include #include @@ -113,16 +114,22 @@ struct driver *dp; /* Device dependent entry points. */ switch(mess.m_type) { case DEV_OPEN: r = (*dp->dr_open)(dp, &mess); break; case DEV_CLOSE: r = (*dp->dr_close)(dp, &mess); break; +#ifdef DEV_IOCTL case DEV_IOCTL: r = (*dp->dr_ioctl)(dp, &mess, 0); break; +#endif case DEV_IOCTL_S: r = (*dp->dr_ioctl)(dp, &mess, 1); break; case CANCEL: r = (*dp->dr_cancel)(dp, &mess);break; case DEV_SELECT: r = (*dp->dr_select)(dp, &mess);break; +#ifdef DEV_READ case DEV_READ: case DEV_WRITE: r = do_rdwt(dp, &mess, 0); break; +#endif case DEV_READ_S: case DEV_WRITE_S: r = do_rdwt(dp, &mess, 1); break; +#ifdef DEV_GATHER case DEV_GATHER: case DEV_SCATTER: r = do_vrdwt(dp, &mess, 0); break; +#endif case DEV_GATHER_S: case DEV_SCATTER_S: r = do_vrdwt(dp, &mess, 1); break; @@ -212,8 +219,12 @@ int safe; /* use safecopies? */ if ((*dp->dr_prepare)(mp->DEVICE) == NIL_DEV) return(ENXIO); /* Create a one element scatter/gather vector for the buffer. */ - if(mp->m_type == DEV_READ || mp->m_type == DEV_READ_S) opcode = DEV_GATHER; - else opcode = DEV_SCATTER; + if( +#ifdef DEV_READ + mp->m_type == DEV_READ || +#endif + mp->m_type == DEV_READ_S) opcode = DEV_GATHER_S; + else opcode = DEV_SCATTER_S; iovec1.iov_addr = (vir_bytes) mp->ADDRESS; iovec1.iov_size = mp->COUNT; @@ -272,8 +283,6 @@ int safe; /* use safecopies? */ /* Transfer bytes from/to the device. */ opcode = mp->m_type; - if(opcode == DEV_GATHER_S) opcode = DEV_GATHER; - if(opcode == DEV_SCATTER_S) opcode = DEV_SCATTER; position= make64(mp->POSITION, mp->HIGHPOS); r = (*dp->dr_transfer)(mp->IO_ENDPT, opcode, position, iov, nr_req, safe); @@ -319,7 +328,10 @@ message *mp; switch (mp->m_type) { case DEV_OPEN: return(ENODEV); case DEV_CLOSE: return(OK); + case DEV_IOCTL_S: +#ifdef DEV_IOCTL case DEV_IOCTL: return(ENOTTY); +#endif default: printf("nop: ignoring code %d\n", mp->m_type); return(EIO); } } diff --git a/drivers/libdriver/drvlib.c b/drivers/libdriver/drvlib.c index 1e1bc8ab7..57d7dfe65 100644 --- a/drivers/libdriver/drvlib.c +++ b/drivers/libdriver/drvlib.c @@ -164,7 +164,7 @@ struct part_entry *table; /* four entries */ iovec1.iov_addr = (vir_bytes) partbuf; iovec1.iov_size = CD_SECTOR_SIZE; if ((*dp->dr_prepare)(device) != NIL_DEV) { - (void) (*dp->dr_transfer)(SELF, DEV_GATHER, position, &iovec1, 1, 0); + (void) (*dp->dr_transfer)(SELF, DEV_GATHER_S, position, &iovec1, 1, 0); } if (iovec1.iov_size != 0) { return 0; diff --git a/drivers/log/log.c b/drivers/log/log.c index 043fa55ad..aa00e61bd 100644 --- a/drivers/log/log.c +++ b/drivers/log/log.c @@ -226,7 +226,7 @@ subread(struct logdevice *log, int count, int proc_nr, *===========================================================================*/ PRIVATE int log_transfer(proc_nr, opcode, position, iov, nr_req, safe) int proc_nr; /* process doing the request */ -int opcode; /* DEV_GATHER or DEV_SCATTER */ +int opcode; /* DEV_GATHER_S or DEV_SCATTER_S */ u64_t position; /* offset on device to read or write */ iovec_t *iov; /* pointer to read or write request vector */ unsigned nr_req; /* length of request vector */ @@ -258,7 +258,7 @@ int safe; /* safe copies? */ switch (log_device) { case MINOR_KLOG: - if (opcode == DEV_GATHER) { + if (opcode == DEV_GATHER_S) { if (log->log_proc_nr || count < 1) { /* There's already someone hanging to read, or * no real I/O requested. diff --git a/drivers/memory/memory.c b/drivers/memory/memory.c index 969754261..1bd9ff9da 100644 --- a/drivers/memory/memory.c +++ b/drivers/memory/memory.c @@ -121,7 +121,7 @@ int device; *===========================================================================*/ PRIVATE int m_transfer(proc_nr, opcode, pos64, iov, nr_req, safe) int proc_nr; /* process doing the request */ -int opcode; /* DEV_GATHER or DEV_SCATTER */ +int opcode; /* DEV_GATHER_S or DEV_SCATTER_S */ u64_t pos64; /* offset on device to read or write */ iovec_t *iov; /* pointer to read or write request vector */ unsigned nr_req; /* length of request vector */ @@ -158,7 +158,7 @@ int safe; /* safe copies */ /* No copying; ignore request. */ case NULL_DEV: - if (opcode == DEV_GATHER) return(OK); /* always at EOF */ + if (opcode == DEV_GATHER_S) return(OK); /* always at EOF */ break; /* Virtual copying. For RAM disk, kernel memory and boot device. */ @@ -169,7 +169,7 @@ int safe; /* safe copies */ if (position + count > dv_size) count = dv_size - position; seg = m_seg[m_device]; - if (opcode == DEV_GATHER) { /* copy actual data */ + if (opcode == DEV_GATHER_S) { /* copy actual data */ if(safe) { r=sys_safecopyto(proc_nr, user_vir, vir_offset, position, count, seg); @@ -201,7 +201,7 @@ int safe; /* safe copies */ panic("MEM","sys_umap failed in m_transfer",r); } - if (opcode == DEV_GATHER) { /* copy data */ + if (opcode == DEV_GATHER_S) { /* copy data */ sys_physcopy(NONE, PHYS_SEG, mem_phys, NONE, PHYS_SEG, user_phys + vir_offset, count); } else { @@ -212,7 +212,7 @@ int safe; /* safe copies */ /* Null byte stream generator. */ case ZERO_DEV: - if (opcode == DEV_GATHER) { + if (opcode == DEV_GATHER_S) { size_t suboffset = 0; left = count; while (left > 0) { @@ -237,7 +237,7 @@ int safe; /* safe copies */ if (position >= dv_size) return(OK); /* check for EOF */ if (position + count > dv_size) count = dv_size - position; - if (opcode == DEV_GATHER) { /* copy actual data */ + if (opcode == DEV_GATHER_S) { /* copy actual data */ if(safe) { s=sys_safecopyto(proc_nr, user_vir, vir_offset, (vir_bytes)&imgrd[position], count, D); diff --git a/drivers/printer/printer.c b/drivers/printer/printer.c index 9b5826789..61ab831fb 100644 --- a/drivers/printer/printer.c +++ b/drivers/printer/printer.c @@ -140,7 +140,6 @@ PUBLIC void main(void) case DEV_CLOSE: reply(TASK_REPLY, pr_mess.m_source, pr_mess.IO_ENDPT, OK); break; - case DEV_WRITE: do_write(&pr_mess, 0); break; case DEV_WRITE_S: do_write(&pr_mess, 1); break; case DEV_STATUS: do_status(&pr_mess); break; case CANCEL: do_cancel(&pr_mess); break; diff --git a/drivers/random/main.c b/drivers/random/main.c index 78f571310..a032205f5 100644 --- a/drivers/random/main.c +++ b/drivers/random/main.c @@ -122,12 +122,12 @@ int safe; /* safe copies? */ /* Random number generator. Character instead of block device. */ case RANDOM_DEV: - if (opcode == DEV_GATHER && !random_isseeded()) + if (opcode == DEV_GATHER_S && !random_isseeded()) return(EAGAIN); left = count; while (left > 0) { chunk = (left > RANDOM_BUF_SIZE) ? RANDOM_BUF_SIZE : left; - if (opcode == DEV_GATHER) { + if (opcode == DEV_GATHER_S) { random_getbytes(random_buf, chunk); if(safe) { r= sys_safecopyto(proc_nr, user_vir, vir_offset, @@ -143,7 +143,7 @@ int safe; /* safe copies? */ sys_vircopy(SELF, D, (vir_bytes) random_buf, proc_nr, D, user_vir + vir_offset, chunk); } - } else if (opcode == DEV_SCATTER) { + } else if (opcode == DEV_SCATTER_S) { if(safe) { r= sys_safecopyfrom(proc_nr, user_vir, vir_offset, (vir_bytes) random_buf, chunk, D); diff --git a/drivers/sb16/sb16_dsp.c b/drivers/sb16/sb16_dsp.c index f30f775b8..605a8efdd 100644 --- a/drivers/sb16/sb16_dsp.c +++ b/drivers/sb16/sb16_dsp.c @@ -101,10 +101,14 @@ PUBLIC void main() switch(mess.m_type) { case DEV_OPEN: r = dsp_open(); break; case DEV_CLOSE: r = dsp_close(); break; +#ifdef DEV_IOCTL case DEV_IOCTL: r = dsp_ioctl(&mess); break; +#endif +#ifdef DEV_READ case DEV_READ: r = EINVAL; break; /* Not yet implemented */ case DEV_WRITE: dsp_write(&mess); continue; /* don't reply */ +#endif case DEV_STATUS: dsp_status(&mess); continue; /* don't reply */ case HARD_INT: dsp_hardware_msg(); continue; /* don't reply */ @@ -226,7 +230,7 @@ message *m_ptr; if(DmaBusy < 0) { /* Dma tranfer not yet started */ - DmaMode = DEV_WRITE; /* Dma mode is writing */ + DmaMode = DEV_WRITE_S; /* Dma mode is writing */ sys_datacopy(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->ADDRESS, SELF, (vir_bytes)DmaPtr, (phys_bytes)DspFragmentSize); dsp_dma_setup(DmaPhys, DspFragmentSize * DMA_NR_OF_BUFFERS); dsp_setup(); @@ -578,7 +582,7 @@ int count; pv_set(pvb[1], DMA8_CLEAR, 0x00); /* Clear flip flop */ /* set DMA mode */ - pv_set(pvb[2], DMA8_MODE, (DmaMode == DEV_WRITE ? DMA8_AUTO_PLAY : DMA8_AUTO_REC)); + pv_set(pvb[2], DMA8_MODE, (DmaMode == DEV_WRITE_S ? DMA8_AUTO_PLAY : DMA8_AUTO_REC)); pv_set(pvb[3], DMA8_ADDR, address >> 0); /* Low_byte of address */ pv_set(pvb[4], DMA8_ADDR, address >> 8); /* High byte of address */ @@ -596,7 +600,7 @@ int count; pv_set(pvb[1], DMA16_CLEAR, 0x00); /* Clear flip flop */ /* Set dma mode */ - pv_set(pvb[2], DMA16_MODE, (DmaMode == DEV_WRITE ? DMA16_AUTO_PLAY : DMA16_AUTO_REC)); + pv_set(pvb[2], DMA16_MODE, (DmaMode == DEV_WRITE_S ? DMA16_AUTO_PLAY : DMA16_AUTO_REC)); pv_set(pvb[3], DMA16_ADDR, (address >> 1) & 0xFF); /* Low_byte of address */ pv_set(pvb[4], DMA16_ADDR, (address >> 9) & 0xFF); /* High byte of address */ @@ -619,7 +623,7 @@ PRIVATE void dsp_setup() dsp_set_speed(DspSpeed); /* Put the speaker on */ - if(DmaMode == DEV_WRITE) { + if(DmaMode == DEV_WRITE_S) { dsp_command (DSP_CMD_SPKON); /* put speaker on */ /* Program DSP with dma mode */ diff --git a/drivers/sb16/sb16_mixer.c b/drivers/sb16/sb16_mixer.c index d595671f1..6e4a9f141 100644 --- a/drivers/sb16/sb16_mixer.c +++ b/drivers/sb16/sb16_mixer.c @@ -71,7 +71,9 @@ message mess; switch(mess.m_type) { case DEV_OPEN: err = mixer_open(&mess); break; case DEV_CLOSE: err = mixer_close(&mess); break; +#ifdef DEV_IOCTL case DEV_IOCTL: err = mixer_ioctl(&mess); break; +#endif default: err = EINVAL; break; } diff --git a/drivers/tty/console.c b/drivers/tty/console.c index 453e0a46c..4fd10c30b 100644 --- a/drivers/tty/console.c +++ b/drivers/tty/console.c @@ -810,8 +810,6 @@ PUBLIC void do_video(message *m) break; case DEV_IOCTL_S: safe=1; - /* Fallthrough. */ - case DEV_IOCTL: if (m->TTY_REQUEST == MIOCMAP || m->TTY_REQUEST == MIOCUNMAP) { int r, do_map; diff --git a/drivers/tty/keyboard.c b/drivers/tty/keyboard.c index ce402f656..6ab1ad0a2 100644 --- a/drivers/tty/keyboard.c +++ b/drivers/tty/keyboard.c @@ -214,8 +214,6 @@ message *m; break; case DEV_READ_S: safecopy = 1; - /* Fallthrough. */ - case DEV_READ: if (kbdp->req_size) { /* We handle only request at a time */ @@ -263,8 +261,6 @@ message *m; case DEV_WRITE_S: safecopy = 1; - /* Fallthrough. */ - case DEV_WRITE: if (kbdp != &kbdaux) { printf("write to keyboard not implemented\n"); @@ -316,8 +312,6 @@ message *m; break; case DEV_IOCTL_S: safecopy=1; - /* Fallthrough. */ - case DEV_IOCTL: if (kbdp == &kbd && m->TTY_REQUEST == KIOCSLEDS) { kio_leds_t leds; diff --git a/drivers/tty/pty.c b/drivers/tty/pty.c index 76b38dce2..b90fe6e80 100644 --- a/drivers/tty/pty.c +++ b/drivers/tty/pty.c @@ -95,8 +95,6 @@ message *m_ptr; switch (m_ptr->m_type) { case DEV_READ_S: safe=1; - /* fallthrough */ - case DEV_READ: /* Check, store information on the reader, do I/O. */ if (pp->state & TTY_CLOSED) { r = 0; @@ -146,8 +144,6 @@ message *m_ptr; case DEV_WRITE_S: safe=1; - /* fallthrough */ - case DEV_WRITE: /* Check, store information on the writer, do I/O. */ if (pp->state & TTY_CLOSED) { r = EIO; diff --git a/drivers/tty/tty.c b/drivers/tty/tty.c index e10db0353..07532c4b1 100644 --- a/drivers/tty/tty.c +++ b/drivers/tty/tty.c @@ -259,8 +259,7 @@ PUBLIC void main(void) tp = tty_addr(line - TTYPX_MINOR + NR_CONS + NR_RS_LINES); } else if ((line - PTYPX_MINOR) < NR_PTYS) { tp = tty_addr(line - PTYPX_MINOR + NR_CONS + NR_RS_LINES); - if (tty_mess.m_type != DEV_IOCTL && - tty_mess.m_type != DEV_IOCTL_S) { + if (tty_mess.m_type != DEV_IOCTL_S) { do_pty(tp, &tty_mess); continue; } @@ -282,11 +281,8 @@ PUBLIC void main(void) /* Execute the requested device driver function. */ switch (tty_mess.m_type) { - case DEV_READ: do_read(tp, &tty_mess, 0); break; case DEV_READ_S: do_read(tp, &tty_mess, 1); break; - case DEV_WRITE: do_write(tp, &tty_mess, 0); break; case DEV_WRITE_S: do_write(tp, &tty_mess, 1); break; - case DEV_IOCTL: do_ioctl(tp, &tty_mess, 0); break; case DEV_IOCTL_S: do_ioctl(tp, &tty_mess, 1); break; case DEV_OPEN: do_open(tp, &tty_mess); break; case DEV_CLOSE: do_close(tp, &tty_mess); break; diff --git a/include/minix/com.h b/include/minix/com.h index 819248e7b..dd34f3534 100755 --- a/include/minix/com.h +++ b/include/minix/com.h @@ -145,13 +145,8 @@ #define DEV_RS_BASE 0x500 /* base for device response types */ #define CANCEL (DEV_RQ_BASE + 0) /* force a task to cancel */ -#define DEV_READ (DEV_RQ_BASE + 3) /* read from minor device */ -#define DEV_WRITE (DEV_RQ_BASE + 4) /* write to minor device */ -#define DEV_IOCTL (DEV_RQ_BASE + 5) /* I/O control code */ #define DEV_OPEN (DEV_RQ_BASE + 6) /* open a minor device */ #define DEV_CLOSE (DEV_RQ_BASE + 7) /* close a minor device */ -#define DEV_SCATTER (DEV_RQ_BASE + 8) /* write from a vector */ -#define DEV_GATHER (DEV_RQ_BASE + 9) /* read into a vector */ #define TTY_SETPGRP (DEV_RQ_BASE + 10) /* set process group */ #define TTY_EXIT (DEV_RQ_BASE + 11) /* process group leader exited */ #define DEV_SELECT (DEV_RQ_BASE + 12) /* request select() attention */ diff --git a/servers/inet/sr.c b/servers/inet/sr.c index 1f6771997..25e4282af 100644 --- a/servers/inet/sr.c +++ b/servers/inet/sr.c @@ -175,6 +175,7 @@ mq_t *m; send_reply= 1; free_mess= 1; break; +#ifdef DEV_READ case DEV_READ: case DEV_WRITE: case DEV_IOCTL3: @@ -183,6 +184,7 @@ mq_t *m; send_reply= (result == SUSPEND); free_mess= 0; break; +#endif case DEV_READ_S: case DEV_WRITE_S: case DEV_IOCTL_S: @@ -329,6 +331,7 @@ mq_t *m; switch(m->mq_mess.m_type) { +#ifdef DEV_READ case DEV_READ: q_head_ptr= &sr_fd->srf_read_q; q_tail_ptr= &sr_fd->srf_read_q_tail; @@ -350,6 +353,7 @@ mq_t *m; susp_flag= SFF_IOCTL_SUSP; first_flag= SFF_IOCTL_FIRST; break; +#endif default: ip_panic(("illegal case entry")); } @@ -372,6 +376,7 @@ mq_t *m; switch(m->mq_mess.m_type) { +#ifdef DEV_READ case DEV_READ: r= (*sr_fd->srf_read)(sr_fd->srf_fd, m->mq_mess.NDEV_COUNT); @@ -395,6 +400,7 @@ mq_t *m; } r= (*sr_fd->srf_ioctl)(sr_fd->srf_fd, request); break; +#endif default: ip_panic(("illegal case entry")); } @@ -933,8 +939,12 @@ assert (loc_fd->srf_flags & ip_flag); } else { +#ifdef DEV_READ assert(m_type == DEV_READ || m_type == DEV_WRITE || m_type == DEV_IOCTL); +#else + ip_panic(("sr_get_userdata: m_type not *_S\n")); +#endif safe_copy= 0; } @@ -1018,8 +1028,12 @@ int for_ioctl; } else { +#ifdef DEV_READ assert(m_type == DEV_READ || m_type == DEV_WRITE || m_type == DEV_IOCTL); +#else + ip_panic(("sr_put_userdata: m_type not *_S\n")); +#endif safe_copy= 0; } diff --git a/servers/mfs/cache.c b/servers/mfs/cache.c index 5f5b85e1e..352295387 100644 --- a/servers/mfs/cache.c +++ b/servers/mfs/cache.c @@ -268,7 +268,7 @@ int rw_flag; /* READING or WRITING */ if ( (dev = bp->b_dev) != NO_DEV) { pos = mul64u(bp->b_blocknr, block_size); - op = (rw_flag == READING ? DEV_READ : DEV_WRITE); + op = (rw_flag == READING ? MFS_DEV_READ : MFS_DEV_WRITE); r = block_dev_io(op, dev, SELF_E, bp->b_data, pos, block_size, 0); if (r != block_size) { if (r >= 0) r = END_OF_FILE; @@ -373,7 +373,7 @@ int rw_flag; /* READING or WRITING */ iop->iov_addr = (vir_bytes) bp->b_data; iop->iov_size = block_size; } - r = block_dev_io(rw_flag == WRITING ? DEV_SCATTER : DEV_GATHER, + r = block_dev_io(rw_flag == WRITING ? MFS_DEV_SCATTER : MFS_DEV_GATHER, dev, SELF_E, iovec, mul64u(bufq[0]->b_blocknr, block_size), j, 0); diff --git a/servers/mfs/const.h b/servers/mfs/const.h index 9f5027523..d8616ddcc 100644 --- a/servers/mfs/const.h +++ b/servers/mfs/const.h @@ -109,3 +109,10 @@ #define MFS_MIN(a,b) mfs_min_f(__FILE__,__LINE__,(a), (b)) #define MFS_NUL(str,l,m) mfs_nul_f(__FILE__,__LINE__,(str), (l), (m)) + +/* Args to dev_bio/dev_io */ +#define MFS_DEV_READ 10001 +#define MFS_DEV_WRITE 10002 +#define MFS_DEV_SCATTER 10003 +#define MFS_DEV_GATHER 10004 + diff --git a/servers/mfs/device.c b/servers/mfs/device.c index 5d6acd83e..7072bbf45 100644 --- a/servers/mfs/device.c +++ b/servers/mfs/device.c @@ -90,10 +90,10 @@ vir_bytes bytes; *gid = GRANT_INVALID; switch(*op) { - case DEV_READ: - case DEV_WRITE: + case MFS_DEV_READ: + case MFS_DEV_WRITE: /* Change to safe op. */ - *op = *op == DEV_READ ? DEV_READ_S : DEV_WRITE_S; + *op = *op == MFS_DEV_READ ? DEV_READ_S : DEV_WRITE_S; if((*gid=cpf_grant_direct(driver, (vir_bytes) *buf, bytes, *op == DEV_READ_S ? CPF_WRITE : @@ -103,10 +103,11 @@ vir_bytes bytes; } break; - case DEV_GATHER: - case DEV_SCATTER: + case MFS_DEV_GATHER: + case MFS_DEV_SCATTER: /* Change to safe op. */ - *op = *op == DEV_GATHER ? DEV_GATHER_S : DEV_SCATTER_S; + *op = *op == MFS_DEV_GATHER ? + DEV_GATHER_S : DEV_SCATTER_S; /* Grant access to my new i/o vector. */ if((*gid = cpf_grant_direct(driver, @@ -174,7 +175,7 @@ int gids_size; * block_dev_io * *===========================================================================*/ PUBLIC int block_dev_io(op, dev, proc_e, buf, pos, bytes, flags) -int op; /* DEV_READ, DEV_WRITE, DEV_IOCTL, etc. */ +int op; /* MFS_DEV_READ, MFS_DEV_WRITE, etc. */ dev_t dev; /* major-minor device number */ int proc_e; /* in whose address space is buf? */ void *buf; /* virtual address of the buffer */ diff --git a/servers/mfs/super.c b/servers/mfs/super.c index 23272ef3a..f90b37085 100644 --- a/servers/mfs/super.c +++ b/servers/mfs/super.c @@ -224,7 +224,7 @@ register struct super_block *sp; /* pointer to a superblock */ if (dev == NO_DEV) panic(__FILE__,"request for super_block of NO_DEV", NO_NUM); - r = block_dev_io(DEV_READ, dev, SELF_E, + r = block_dev_io(MFS_DEV_READ, dev, SELF_E, sbbuf, cvu64(SUPER_BLOCK_BYTES), _MIN_BLOCK_SIZE, 0); if (r != _MIN_BLOCK_SIZE) { printf("MFSread_super r != _MIN_BLOCK_SIZE\n"); diff --git a/servers/vfs/const.h b/servers/vfs/const.h index 479c8eae2..4894e234b 100644 --- a/servers/vfs/const.h +++ b/servers/vfs/const.h @@ -108,3 +108,11 @@ #define V2_INODE_SIZE usizeof (d2_inode) /* bytes in V2 dsk ino */ #define V2_INDIRECTS(b) ((b)/V2_ZONE_NUM_SIZE) /* # zones/indir block */ #define V2_INODES_PER_BLOCK(b) ((b)/V2_INODE_SIZE)/* # V2 dsk inodes/blk */ + +/* Args to dev_bio/dev_io */ +#define VFS_DEV_READ 2001 +#define VFS_DEV_WRITE 2002 +#define VFS_DEV_SCATTER 2003 +#define VFS_DEV_GATHER 2004 +#define VFS_DEV_IOCTL 2005 +#define VFS_DEV_SELECT 2006 diff --git a/servers/vfs/device.c b/servers/vfs/device.c index 13c207b16..95593ed6b 100644 --- a/servers/vfs/device.c +++ b/servers/vfs/device.c @@ -195,10 +195,10 @@ off_t *pos; *gid = GRANT_INVALID; switch(*op) { - case DEV_READ: - case DEV_WRITE: + case VFS_DEV_READ: + case VFS_DEV_WRITE: /* Change to safe op. */ - *op = *op == DEV_READ ? DEV_READ_S : DEV_WRITE_S; + *op = *op == VFS_DEV_READ ? DEV_READ_S : DEV_WRITE_S; if((*gid=cpf_grant_magic(driver, *io_ept, (vir_bytes) *buf, bytes, @@ -208,10 +208,11 @@ off_t *pos; } break; - case DEV_GATHER: - case DEV_SCATTER: + case VFS_DEV_GATHER: + case VFS_DEV_SCATTER: /* Change to safe op. */ - *op = *op == DEV_GATHER ? DEV_GATHER_S : DEV_SCATTER_S; + *op = *op == VFS_DEV_GATHER ? + DEV_GATHER_S : DEV_SCATTER_S; /* Grant access to my new i/o vector. */ if((*gid = cpf_grant_direct(driver, @@ -240,7 +241,7 @@ off_t *pos; /* Set user's vector to the new one. */ *buf = new_iovec; break; - case DEV_IOCTL: + case VFS_DEV_IOCTL: *pos = *io_ept; /* Old endpoint in POSITION field. */ *op = DEV_IOCTL_S; if(_MINIX_IOCTL_IOR(m_in.REQUEST)) access |= CPF_WRITE; @@ -260,6 +261,13 @@ off_t *pos; "cpf_grant_magic failed (ioctl)\n", NO_NUM); } + break; + case VFS_DEV_SELECT: + *op = DEV_SELECT; + break; + default: + panic(__FILE__,"safe_io_conversion: unknown operation", + *op); } /* If we have converted to a safe operation, I/O @@ -654,7 +662,7 @@ PUBLIC int do_ioctl() && (vp->v_mode & I_TYPE) != I_BLOCK_SPECIAL) return(ENOTTY); dev = (dev_t) vp->v_sdev; - return (dev_io(DEV_IOCTL, dev, who_e, m_in.ADDRESS, cvu64(0), + return (dev_io(VFS_DEV_IOCTL, dev, who_e, m_in.ADDRESS, cvu64(0), m_in.REQUEST, f->filp_flags)); } diff --git a/servers/vfs/read.c b/servers/vfs/read.c index 54ef44cba..47e68155f 100644 --- a/servers/vfs/read.c +++ b/servers/vfs/read.c @@ -108,7 +108,7 @@ int rw_flag; /* READING or WRITING */ cum_io = 0; } - op = (rw_flag == READING ? DEV_READ : DEV_WRITE); + op = (rw_flag == READING ? VFS_DEV_READ : VFS_DEV_WRITE); mode_word = vp->v_mode & I_TYPE; regular = mode_word == I_REGULAR || mode_word == I_NAMED_PIPE; @@ -279,8 +279,8 @@ int rw_flag; /* READING or WRITING */ while (bleft) { /* First read the whole block */ - r = dev_bio(DEV_READ, dev, FS_PROC_NR, buf, b * _MIN_BLOCK_SIZE, - _MIN_BLOCK_SIZE); + r = dev_bio(VFS_DEV_READ, dev, FS_PROC_NR, buf, + b * _MIN_BLOCK_SIZE, _MIN_BLOCK_SIZE); if (r != _MIN_BLOCK_SIZE) break; diff --git a/servers/vfs/select.c b/servers/vfs/select.c index efb03949d..05fd10c79 100644 --- a/servers/vfs/select.c +++ b/servers/vfs/select.c @@ -104,8 +104,8 @@ PRIVATE int select_request_general(struct filp *f, int *ops, int block) { int rops = *ops; if (block) rops |= SEL_NOTIFY; - *ops = dev_io(DEV_SELECT, f->filp_vno->v_sdev, rops, NULL, cvu64(0), - 0, 0); + *ops = dev_io(VFS_DEV_SELECT, f->filp_vno->v_sdev, rops, NULL, + cvu64(0), 0, 0); if (*ops < 0) return SEL_ERR; return SEL_OK; -- 2.11.4.GIT