From 4059c0355c3fb91baa9a1fe6957a2499b0b822cb Mon Sep 17 00:00:00 2001 From: Ben Gras Date: Mon, 17 Jun 2013 01:40:26 +0200 Subject: [PATCH] remove some 64bit functions --- commands/autopart/autopart.c | 12 +-- commands/fsck.mfs/fsck.c | 6 +- commands/part/part.c | 8 +- commands/partition/partition.c | 8 +- commands/vol/vol.c | 4 +- drivers/ahci/ahci.c | 21 ++--- drivers/at_wini/at_wini.c | 30 +++---- drivers/fbd/action.c | 14 ++- drivers/fbd/rule.c | 2 +- drivers/filter/driver.c | 8 +- drivers/filter/main.c | 4 +- drivers/filter/sum.c | 4 +- drivers/floppy/floppy.c | 13 ++- drivers/log/log.c | 4 +- drivers/memory/memory.c | 28 +++--- drivers/random/main.c | 2 +- drivers/vbox/hgcm.c | 2 +- drivers/vbox/vbox.c | 2 +- include/minix/u64.h | 98 -------------------- kernel/arch/earm/arch_clock.c | 8 +- kernel/arch/i386/apic.c | 6 +- kernel/arch/i386/arch_clock.c | 40 ++++----- kernel/arch/i386/arch_watchdog.c | 6 +- kernel/main.c | 2 +- kernel/proc.c | 5 +- kernel/system/do_getinfo.c | 3 +- lib/libblockdriver/driver.c | 2 +- lib/libblockdriver/drvlib.c | 15 ++-- lib/libblockdriver/trace.c | 6 +- lib/libc/sys-minix/sizeup.c | 4 +- lib/libhgfs/time.c | 12 +-- lib/libminixfs/cache.c | 8 +- lib/libsffs/misc.c | 4 +- lib/libsffs/read.c | 2 +- lib/libsffs/write.c | 4 +- lib/libsys/arch/i386/getidle.c | 4 +- lib/libsys/arch/i386/profile.c | 17 ++-- lib/libsys/arch/i386/spin.c | 2 +- lib/libsys/arch/i386/tsc_util.c | 4 +- lib/libsys/sys_hz.c | 2 +- lib/libvboxfs/attr.c | 6 +- servers/ext2/read.c | 10 +-- servers/ext2/super.c | 8 +- servers/iso9660fs/read.c | 12 +-- servers/iso9660fs/super.c | 6 +- servers/mfs/read.c | 8 +- servers/mfs/super.c | 4 +- servers/vfs/device.c | 2 +- servers/vfs/exec.c | 6 +- servers/vfs/filedes.c | 2 +- servers/vfs/open.c | 12 +-- servers/vfs/read.c | 6 +- servers/vfs/request.c | 4 +- servers/vfs/select.c | 4 +- test/blocktest/blocktest.c | 150 +++++++++++++++---------------- test/test53.c | 34 +++---- usr.sbin/mkfs.mfs/mkfs.c | 21 +++-- 57 files changed, 308 insertions(+), 413 deletions(-) diff --git a/commands/autopart/autopart.c b/commands/autopart/autopart.c index 4d6a85cb0..5c001ba46 100644 --- a/commands/autopart/autopart.c +++ b/commands/autopart/autopart.c @@ -525,8 +525,8 @@ void geometry(void) if (ioctl(device, DIOCGETP, &geometry) < 0) err= errno; else { - table[0].lowsec= div64u(geometry.base, SECTOR_SIZE); - table[0].size= div64u(geometry.size, SECTOR_SIZE); + table[0].lowsec= ((u64_t)(geometry.base) / (unsigned)(SECTOR_SIZE)); + table[0].size= ((u64_t)(geometry.size) / (unsigned)(SECTOR_SIZE)); cylinders= geometry.cylinders; heads= geometry.heads; sectors= geometry.sectors; @@ -578,8 +578,8 @@ exit(1); * This makes sense for subpartitioning primary partitions. */ if (precise && ioctl(device, DIOCGETP, &geometry) >= 0) { - table[0].lowsec= div64u(geometry.base, SECTOR_SIZE); - table[0].size= div64u(geometry.size, SECTOR_SIZE); + table[0].lowsec= ((u64_t)(geometry.base) / (unsigned)(SECTOR_SIZE)); + table[0].size= ((u64_t)(geometry.size) / (unsigned)(SECTOR_SIZE)); } else { precise= 0; } @@ -2149,8 +2149,8 @@ sanitycheck_failed(char *dev, struct part_entry *pe) close(fd); - it_lowsec = div64u(part.base, SECTOR_SIZE); - it_secsize = div64u(part.size, SECTOR_SIZE); + it_lowsec = ((u64_t)(part.base) / (unsigned)(SECTOR_SIZE)); + it_secsize = ((u64_t)(part.size) / (unsigned)(SECTOR_SIZE)); if(it_lowsec != pe->lowsec || it_secsize != pe->size) { fprintf(stderr, "\nReturned and set numbers don't match up!\n"); diff --git a/commands/fsck.mfs/fsck.c b/commands/fsck.mfs/fsck.c index ed7698d3d..f51cc4e0b 100644 --- a/commands/fsck.mfs/fsck.c +++ b/commands/fsck.mfs/fsck.c @@ -98,7 +98,7 @@ static struct super_block sb; * btoa64 gives the byte address of a block */ #define ztob(z) ((block_nr) (z) << sb.s_log_zone_size) -#define btoa64(b) (mul64u(b, block_size)) +#define btoa64(b) (((u64_t)(b) * (block_size))) #define SCALE ((int) ztob(1)) /* # blocks in a zone */ #define FIRST ((zone_nr) sb.s_firstdatazone) /* as the name says */ @@ -657,12 +657,12 @@ void chksuper() int inoblock(int inn) { - return div64u(mul64u(inn - 1, INODE_SIZE), block_size) + BLK_ILIST; + return ((u64_t)(((u64_t)(inn - 1) * (INODE_SIZE))) / (unsigned)(block_size)) + BLK_ILIST; } int inooff(int inn) { - return rem64u(mul64u(inn - 1, INODE_SIZE), block_size); + return ((u64_t)(((u64_t)(inn - 1) * (INODE_SIZE))) % (unsigned)(block_size)); } /* Make a listing of the inodes given by `clist'. If `repair' is set, ask diff --git a/commands/part/part.c b/commands/part/part.c index d141d8553..78e2181ef 100644 --- a/commands/part/part.c +++ b/commands/part/part.c @@ -477,8 +477,8 @@ void geometry(void) if (ioctl(device, DIOCGETP, &geometry) < 0) err= errno; else { - table[0].lowsec= div64u(geometry.base, SECTOR_SIZE); - table[0].size= div64u(geometry.size, SECTOR_SIZE); + table[0].lowsec= ((u64_t)(geometry.base) / (unsigned)(SECTOR_SIZE)); + table[0].size= ((u64_t)(geometry.size) / (unsigned)(SECTOR_SIZE)); cylinders= geometry.cylinders; heads= geometry.heads; sectors= geometry.sectors; @@ -546,8 +546,8 @@ void geometry(void) * This makes sense for subpartitioning primary partitions. */ if (precise && ioctl(device, DIOCGETP, &geometry) >= 0) { - table[0].lowsec= div64u(geometry.base, SECTOR_SIZE); - table[0].size= div64u(geometry.size, SECTOR_SIZE); + table[0].lowsec= ((u64_t)(geometry.base) / (unsigned)(SECTOR_SIZE)); + table[0].size= ((u64_t)(geometry.size) / (unsigned)(SECTOR_SIZE)); } else { precise= 0; } diff --git a/commands/partition/partition.c b/commands/partition/partition.c index a2d555b7e..6b408dec0 100644 --- a/commands/partition/partition.c +++ b/commands/partition/partition.c @@ -296,16 +296,16 @@ void geometry(void) /* Use the same fake geometry as part. */ if (fstat(fd, &sb) < 0) fatal(device); - geometry.base= cvul64(0); - geometry.size= cvul64(sb.st_size); + geometry.base= ((u64_t)(0)); + geometry.size= ((u64_t)(sb.st_size)); geometry.sectors= 32; geometry.heads= 64; geometry.cylinders= (sb.st_size-1)/SECTOR_SIZE/ (geometry.sectors*geometry.heads) + 1; } close(fd); - primary.lowsec= div64u(geometry.base, SECTOR_SIZE); - primary.size= div64u(geometry.size, SECTOR_SIZE); + primary.lowsec= ((u64_t)(geometry.base) / (unsigned)(SECTOR_SIZE)); + primary.size= ((u64_t)(geometry.size) / (unsigned)(SECTOR_SIZE)); cylinders= geometry.cylinders; heads= geometry.heads; sectors= geometry.sectors; diff --git a/commands/vol/vol.c b/commands/vol/vol.c index 43264912b..845c08a45 100644 --- a/commands/vol/vol.c +++ b/commands/vol/vol.c @@ -48,7 +48,7 @@ char *buffer = NULL; size_t block_size = 0, mult_max = 0; size_t buffer_size; -long volume_size; +u64_t volume_size; char *str_vol_size; int rflag = 0, wflag = 0, oneflag = 0, variable = 0; @@ -194,7 +194,7 @@ char *argv[]; if (ioctl(fd, DIOCGETP, &part) < 0) { autovolsize = 0; } else { - volume_size = cv64ul(part.size); + volume_size = part.size; } } diff --git a/drivers/ahci/ahci.c b/drivers/ahci/ahci.c index b859e1685..e30b2b895 100644 --- a/drivers/ahci/ahci.c +++ b/drivers/ahci/ahci.c @@ -380,8 +380,7 @@ static int atapi_read_capacity(struct port_state *ps, int cmd) /* Store the number of LBA blocks and sector size. */ buf = ps->tmp_base; - ps->lba_count = add64u(cvu64((buf[0] << 24) | (buf[1] << 16) | - (buf[2] << 8) | buf[3]), 1); + ps->lba_count = ((u64_t)(((u64_t)((buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]))) + (1)); ps->sector_size = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7]; @@ -395,8 +394,7 @@ static int atapi_read_capacity(struct port_state *ps, int cmd) dprintf(V_INFO, ("%s: medium detected (%u byte sectors, %lu MB size)\n", ahci_portname(ps), ps->sector_size, - div64u(mul64(ps->lba_count, cvu64(ps->sector_size)), - 1024*1024))); + ((u64_t)(((u64_t)(ps->lba_count) * (((u64_t)(ps->sector_size))))) / (unsigned)(1024 * 1024)))); return OK; } @@ -1172,11 +1170,11 @@ static ssize_t port_transfer(struct port_state *ps, u64_t pos, u64_t eof, * extend beyond the end of the partition. The caller already * guarantees that the starting position lies within the partition. */ - if (cmp64(add64ul(pos, size), eof) >= 0) + if (cmp64(((u64_t)(pos) + (size)), eof) >= 0) size = (vir_bytes) diff64(eof, pos); - start_lba = div64(pos, cvu64(ps->sector_size)); - lead = rem64u(pos, ps->sector_size); + start_lba = ((u64_t)(pos) / (unsigned)(((u64_t)(ps->sector_size)))); + lead = ((u64_t)(pos) % (unsigned)(ps->sector_size)); count = (lead + size + ps->sector_size - 1) / ps->sector_size; /* Position must be word-aligned for read requests, and sector-aligned @@ -1428,8 +1426,7 @@ static void port_id_check(struct port_state *ps, int success) if (ps->flags & FLAG_HAS_MEDIUM) printf(", %u byte sectors, %lu MB size", - ps->sector_size, div64u(mul64(ps->lba_count, - cvu64(ps->sector_size)), 1024*1024)); + ps->sector_size, ((u64_t)(((u64_t)(ps->lba_count) * (((u64_t)(ps->sector_size))))) / (unsigned)(1024 * 1024))); printf("\n"); } @@ -2522,7 +2519,7 @@ static int ahci_open(dev_t minor, int access) memset(ps->subpart, 0, sizeof(ps->subpart)); ps->part[0].dv_size = - mul64(ps->lba_count, cvu64(ps->sector_size)); + ((u64_t)(ps->lba_count) * (((u64_t)(ps->sector_size)))); partition(&ahci_dtab, ps->device * DEV_PER_DRIVE, P_PRIMARY, !!(ps->flags & FLAG_ATAPI)); @@ -2626,8 +2623,8 @@ static ssize_t ahci_transfer(dev_t minor, int do_write, u64_t position, if (cmp64(position, dv->dv_size) >= 0) return OK; - pos = add64(dv->dv_base, position); - eof = add64(dv->dv_base, dv->dv_size); + pos = ((u64_t)(dv->dv_base) + (position)); + eof = ((u64_t)(dv->dv_base) + (dv->dv_size)); return port_transfer(ps, pos, eof, endpt, (iovec_s_t *) iovec, count, do_write, flags); diff --git a/drivers/at_wini/at_wini.c b/drivers/at_wini/at_wini.c index 5108cf6ad..f4e06ba15 100644 --- a/drivers/at_wini/at_wini.c +++ b/drivers/at_wini/at_wini.c @@ -906,7 +906,7 @@ static int w_identify(void) w_testing = 0; /* Size of the whole drive */ - wn->part[0].dv_size = mul64u(size, SECTOR_SIZE); + wn->part[0].dv_size = ((u64_t)(size) * (SECTOR_SIZE)); /* Reset/calibrate (where necessary) */ if (w_specify() != OK && w_specify() != OK) { @@ -975,7 +975,7 @@ static int w_io_test(void) w_testing = 1; /* Try I/O on the actual drive (not any (sub)partition). */ - r = w_transfer(w_drive * DEV_PER_DRIVE, FALSE /*do_write*/, cvu64(0), + r = w_transfer(w_drive * DEV_PER_DRIVE, FALSE /*do_write*/, ((u64_t)(0)), SELF, &iov, 1, BDEV_NOFLAGS); /* Switch back. */ @@ -1204,7 +1204,7 @@ static ssize_t w_transfer( #endif /* Check disk address. */ - if (rem64u(position, SECTOR_SIZE) != 0) return(EINVAL); + if (((u64_t)(position) % (unsigned)(SECTOR_SIZE)) != 0) return(EINVAL); errors = 0; @@ -1216,9 +1216,9 @@ static ssize_t w_transfer( /* Which block on disk and how close to EOF? */ if (cmp64(position, dv_size) >= 0) return(total); /* At EOF */ - if (cmp64(add64ul(position, nbytes), dv_size) > 0) + if (cmp64(((u64_t)(position) + (nbytes)), dv_size) > 0) nbytes = diff64(dv_size, position); - block = div64u(add64(w_dv->dv_base, position), SECTOR_SIZE); + block = ((u64_t)(((u64_t)(w_dv->dv_base) + (position))) / (unsigned)(SECTOR_SIZE)); do_dma= wn->dma; @@ -1296,7 +1296,7 @@ static ssize_t w_transfer( /* Book the bytes successfully transferred. */ nbytes -= n; - position= add64ul(position, n); + position= ((u64_t)(position) + (n)); total += n; addr_offset += n; if ((iov->iov_size -= n) == 0) { @@ -1368,7 +1368,7 @@ static ssize_t w_transfer( /* Book the bytes successfully transferred. */ nbytes -= SECTOR_SIZE; - position= add64u(position, SECTOR_SIZE); + position= ((u64_t)(position) + (SECTOR_SIZE)); addr_offset += SECTOR_SIZE; total += SECTOR_SIZE; if ((iov->iov_size -= SECTOR_SIZE) == 0) { @@ -1891,7 +1891,7 @@ static void w_geometry(dev_t minor, struct part_geom *entry) wn = w_wn; if (wn->state & ATAPI) { /* Make up some numbers. */ - entry->cylinders = div64u(wn->part[0].dv_size, SECTOR_SIZE) / (64*32); + entry->cylinders = ((u64_t)(wn->part[0].dv_size) / (unsigned)(SECTOR_SIZE)) / (64*32); entry->heads = 64; entry->sectors = 32; } else { /* Return logical geometry. */ @@ -1911,7 +1911,7 @@ static int atapi_open(void) * size of the device to something big. What is really needed is a generic * SCSI layer that does all this stuff for ATAPI and SCSI devices (kjb). (XXX) */ - w_wn->part[0].dv_size = mul64u(800L*1024, 1024); + w_wn->part[0].dv_size = ((u64_t)(800L * 1024) * (1024)); return(OK); } @@ -1985,9 +1985,9 @@ static int atapi_transfer( /* The Minix block size is smaller than the CD block size, so we * may have to read extra before or after the good data. */ - pos = add64(w_dv->dv_base, position); - block = div64u(pos, CD_SECTOR_SIZE); - before = rem64u(pos, CD_SECTOR_SIZE); + pos = ((u64_t)(w_dv->dv_base) + (position)); + block = ((u64_t)(pos) / (unsigned)(CD_SECTOR_SIZE)); + before = ((u64_t)(pos) % (unsigned)(CD_SECTOR_SIZE)); if(before) do_dma = 0; @@ -2005,7 +2005,7 @@ static int atapi_transfer( /* Which block on disk and how close to EOF? */ if (cmp64(position, dv_size) >= 0) return(total); /* At EOF */ - if (cmp64(add64ul(position, nbytes), dv_size) > 0) + if (cmp64(((u64_t)(position) + (nbytes)), dv_size) > 0) nbytes = diff64(dv_size, position); nblocks = (before + nbytes + CD_SECTOR_SIZE - 1) / CD_SECTOR_SIZE; @@ -2060,7 +2060,7 @@ static int atapi_transfer( if (chunk > iov->iov_size) chunk = iov->iov_size; - position= add64ul(position, chunk); + position= ((u64_t)(position) + (chunk)); nbytes -= chunk; total += chunk; if ((iov->iov_size -= chunk) == 0) { @@ -2103,7 +2103,7 @@ static int atapi_transfer( } if (s != OK) panic("Call to sys_insw() failed: %d", s); - position= add64ul(position, chunk); + position= ((u64_t)(position) + (chunk)); nbytes -= chunk; count -= chunk; addr_offset += chunk; diff --git a/drivers/fbd/action.c b/drivers/fbd/action.c index dd7d93c1c..7b11a9d58 100644 --- a/drivers/fbd/action.c +++ b/drivers/fbd/action.c @@ -49,14 +49,14 @@ static size_t get_range(struct fbd_rule *rule, u64_t pos, size_t *size, to_eof = cmp64(rule->start, rule->end) >= 0; if (cmp64(pos, rule->start) > 0) { - if (skip != NULL) *skip = sub64(pos, rule->start); + if (skip != NULL) *skip = ((u64_t)(pos) - (rule->start)); off = 0; } else { - if (skip != NULL) *skip = cvu64(0); + if (skip != NULL) *skip = ((u64_t)(0)); - delta = sub64(rule->start, pos); + delta = ((u64_t)(rule->start) - (pos)); assert(ex64hi(delta) == 0); @@ -66,7 +66,7 @@ static size_t get_range(struct fbd_rule *rule, u64_t pos, size_t *size, if (!to_eof) { assert(cmp64(pos, rule->end) < 0); - delta = sub64(rule->end, pos); + delta = ((u64_t)(rule->end) - (pos)); if (cmp64u(delta, *size) < 0) *size = ex64lo(delta); @@ -186,16 +186,14 @@ static void action_pre_misdir(struct fbd_rule *rule, iovec_t *UNUSED(iov), * here, because we have no idea about the actual disk size, and the * resulting address must of course be valid.. */ - range = div64u(add64u(sub64(rule->params.misdir.end, - rule->params.misdir.start), 1), rule->params.misdir.align); + range = ((u64_t)(((u64_t)(((u64_t)(rule->params.misdir.end) - (rule->params.misdir.start))) + (1))) / (unsigned)(rule->params.misdir.align)); if (range > 0) choice = get_rand(range - 1); else choice = 0; - *pos = add64(rule->params.misdir.start, - mul64u(choice, rule->params.misdir.align)); + *pos = ((u64_t)(rule->params.misdir.start) + (((u64_t)(choice) * (rule->params.misdir.align)))); } /*===========================================================================* diff --git a/drivers/fbd/rule.c b/drivers/fbd/rule.c index 81ebc6620..ff2f31346 100644 --- a/drivers/fbd/rule.c +++ b/drivers/fbd/rule.c @@ -92,7 +92,7 @@ static int rule_match(struct fbd_rule *rule, u64_t pos, size_t size, int flag) */ /* Ranges must overlap (start < pos+size && end > pos). */ - if (cmp64(rule->start, add64u(pos, size)) >= 0 || + if (cmp64(rule->start, ((u64_t)(pos) + (size))) >= 0 || (cmp64u(rule->end, 0) && cmp64(rule->end, pos) <= 0)) return FALSE; diff --git a/drivers/filter/driver.c b/drivers/filter/driver.c index 35464b10e..0fd659123 100644 --- a/drivers/filter/driver.c +++ b/drivers/filter/driver.c @@ -77,8 +77,8 @@ static int driver_open(int which) if(!size_known) { disk_size = part.size; size_known = 1; - sectors = div64u(disk_size, SECTOR_SIZE); - if(cmp64(mul64u(sectors, SECTOR_SIZE), disk_size)) { + sectors = ((u64_t)(disk_size) / (unsigned)(SECTOR_SIZE)); + if(cmp64(((u64_t)(sectors) * (SECTOR_SIZE)), disk_size)) { printf("Filter: partition too large\n"); return RET_REDO; @@ -954,7 +954,7 @@ int read_write(u64_t pos, char *bufa, char *bufb, size_t *sizep, int request) * report the driver for acting strangely! */ if (m1.BDEV_STATUS > (ssize_t) *sizep || - cmp64(add64u(pos, m1.BDEV_STATUS), disk_size) < 0) + cmp64(((u64_t)(pos) + (m1.BDEV_STATUS)), disk_size) < 0) return bad_driver(DRIVER_MAIN, BD_PROTO, EFAULT); /* Return the actual size. */ @@ -976,7 +976,7 @@ int read_write(u64_t pos, char *bufa, char *bufb, size_t *sizep, int request) /* As above */ if (m2.BDEV_STATUS > (ssize_t) *sizep || - cmp64(add64u(pos, m2.BDEV_STATUS), + cmp64(((u64_t)(pos) + (m2.BDEV_STATUS)), disk_size) < 0) return bad_driver(DRIVER_BACKUP, BD_PROTO, EFAULT); diff --git a/drivers/filter/main.c b/drivers/filter/main.c index b825ed31c..f1c488b49 100644 --- a/drivers/filter/main.c +++ b/drivers/filter/main.c @@ -139,7 +139,7 @@ static int do_rdwt(int flag_rw) pos = make64(m_in.BDEV_POS_LO, m_in.BDEV_POS_HI); size = m_in.BDEV_COUNT; - if (rem64u(pos, SECTOR_SIZE) != 0 || size % SECTOR_SIZE != 0) { + if (((u64_t)(pos) % (unsigned)(SECTOR_SIZE)) != 0 || size % SECTOR_SIZE != 0) { printf("Filter: unaligned request from caller!\n"); return EINVAL; @@ -198,7 +198,7 @@ static int do_vrdwt(int flag_rw) for(size = 0, i = 0; i < grants; i++) size += iov_proc[i].iov_size; - if (rem64u(pos, SECTOR_SIZE) != 0 || size % SECTOR_SIZE != 0) { + if (((u64_t)(pos) % (unsigned)(SECTOR_SIZE)) != 0 || size % SECTOR_SIZE != 0) { printf("Filter: unaligned request from caller!\n"); return EINVAL; } diff --git a/drivers/filter/sum.c b/drivers/filter/sum.c index 5fe581c2e..0aeef6bdd 100644 --- a/drivers/filter/sum.c +++ b/drivers/filter/sum.c @@ -8,8 +8,8 @@ #define SEC2SUM_NR(nr) ((nr)/NR_SUM_SEC*(NR_SUM_SEC+1) + NR_SUM_SEC) #define LOG2PHYS(nr) ((nr)/NR_SUM_SEC*(NR_SUM_SEC+1) + (nr)%NR_SUM_SEC) -#define POS2SEC(nr) div64u((nr), SECTOR_SIZE) -#define SEC2POS(nr) mul64u((nr), SECTOR_SIZE) +#define POS2SEC(nr) ((u64_t)((nr)) / (unsigned)(SECTOR_SIZE)) +#define SEC2POS(nr) ((u64_t)((nr)) * (SECTOR_SIZE)) /* Data buffers. */ static char *ext_array, *ext_buffer; /* interspersed buffer */ diff --git a/drivers/floppy/floppy.c b/drivers/floppy/floppy.c index 1150837d2..641ac5ba7 100644 --- a/drivers/floppy/floppy.c +++ b/drivers/floppy/floppy.c @@ -410,8 +410,7 @@ static struct device *f_prepare(dev_t device) if (f_fp->fl_density < NT) { f_dp = &fdensity[f_fp->fl_density]; f_sectors = f_dp->secpt; - f_fp->fl_geom.dv_size = mul64u((long) (NR_HEADS * f_sectors - * f_dp->cyls), SECTOR_SIZE); + f_fp->fl_geom.dv_size = ((u64_t)((long)(NR_HEADS * f_sectors * f_dp->cyls)) * (SECTOR_SIZE)); } /* A partition? */ @@ -461,7 +460,7 @@ static ssize_t f_transfer( iovec_t *iop, *iov_end = iov + nr_req; int s, r, errors, nr; unsigned block, nbytes, count, chunk, sector; - unsigned long dv_size; + u64_t dv_size; vir_bytes user_offset, iov_offset = 0, iop_offset; unsigned long position; signed long uoffsets[MAX_SECTORS], *up; @@ -472,11 +471,11 @@ static ssize_t f_transfer( if (f_prepare(minor) == NULL) return(ENXIO); fp = f_fp; - dv_size = cv64ul(f_dv->dv_size); + dv_size = f_dv->dv_size; if (ex64hi(pos64) != 0) return OK; /* Way beyond EOF */ - position= cv64ul(pos64); + position= pos64; total = 0; /* Record the direction of the last transfer performed. */ @@ -500,7 +499,7 @@ static ssize_t f_transfer( /* Which block on disk and how close to EOF? */ if (position >= dv_size) return(total); /* At EOF */ if (position + nbytes > dv_size) nbytes = dv_size - position; - block = div64u(add64ul(f_dv->dv_base, position), SECTOR_SIZE); + block = ((u64_t)(((u64_t)(f_dv->dv_base) + (position))) / (unsigned)(SECTOR_SIZE)); if ((nbytes & SECTOR_MASK) != 0) return(EINVAL); @@ -1338,7 +1337,7 @@ static int test_read(int density) position = (off_t) f_dp->test << SECTOR_SHIFT; iovec1.iov_addr = (vir_bytes) floppy_buf; iovec1.iov_size = SECTOR_SIZE; - result = f_transfer(device, FALSE /*do_write*/, cvul64(position), SELF, + result = f_transfer(device, FALSE /*do_write*/, position, SELF, &iovec1, 1, BDEV_NOFLAGS); if (result != SECTOR_SIZE) return(EIO); diff --git a/drivers/log/log.c b/drivers/log/log.c index 44f2d55cf..5de3d89df 100644 --- a/drivers/log/log.c +++ b/drivers/log/log.c @@ -101,8 +101,8 @@ static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info)) /* Initialize log devices. */ for(i = 0; i < NR_DEVS; i++) { - log_geom[i].dv_size = cvul64(LOG_SIZE); - log_geom[i].dv_base = cvul64((long)logdevices[i].log_buffer); + log_geom[i].dv_size = ((u64_t)(LOG_SIZE)); + log_geom[i].dv_base = ((u64_t)((long)logdevices[i].log_buffer)); logdevices[i].log_size = logdevices[i].log_read = logdevices[i].log_write = logdevices[i].log_select_alerted = diff --git a/drivers/memory/memory.c b/drivers/memory/memory.c index 4e8df02fe..d42167864 100644 --- a/drivers/memory/memory.c +++ b/drivers/memory/memory.c @@ -167,16 +167,16 @@ static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info)) #endif /* Ramdisk image built into the memory driver */ - m_geom[IMGRD_DEV].dv_base= cvul64(0); - m_geom[IMGRD_DEV].dv_size= cvul64(imgrd_size); + m_geom[IMGRD_DEV].dv_base= ((u64_t)(0)); + m_geom[IMGRD_DEV].dv_size= ((u64_t)(imgrd_size)); m_vaddrs[IMGRD_DEV] = (vir_bytes) imgrd; for(i = 0; i < NR_DEVS; i++) openct[i] = 0; /* Set up memory range for /dev/mem. */ - m_geom[MEM_DEV].dv_base = cvul64(0); - m_geom[MEM_DEV].dv_size = cvul64(0xffffffff); + m_geom[MEM_DEV].dv_base = ((u64_t)(0)); + m_geom[MEM_DEV].dv_size = ((u64_t)(0xffffffff)); m_vaddrs[MEM_DEV] = (vir_bytes) MAP_FAILED; /* we are not mapping this in. */ @@ -231,20 +231,20 @@ static int m_transfer( unsigned count; vir_bytes vir_offset = 0; struct device *dv; - unsigned long dv_size; + u64_t dv_size; int s, r; - off_t position; + u64_t position; cp_grant_id_t grant; vir_bytes dev_vaddr; /* ZERO_DEV and NULL_DEV are infinite in size. */ if (m_device != ZERO_DEV && m_device != NULL_DEV && ex64hi(pos64) != 0) return OK; /* Beyond EOF */ - position= cv64ul(pos64); + position= pos64; /* Get minor device number and check for /dev/null. */ dv = &m_geom[m_device]; - dv_size = cv64ul(dv->dv_size); + dv_size = dv->dv_size; dev_vaddr = m_vaddrs[m_device]; while (nr_req > 0) { @@ -435,21 +435,21 @@ static int m_block_transfer( unsigned count; vir_bytes vir_offset = 0; struct device *dv; - unsigned long dv_size; + u64_t dv_size; int r; - off_t position; + u64_t position; vir_bytes dev_vaddr; cp_grant_id_t grant; ssize_t total = 0; /* Get minor device information. */ if ((dv = m_block_part(minor)) == NULL) return(ENXIO); - dv_size = cv64ul(dv->dv_size); + dv_size = dv->dv_size; dev_vaddr = m_vaddrs[minor]; if (ex64hi(pos64) != 0) return OK; /* Beyond EOF */ - position= cv64ul(pos64); + position= pos64; while (nr_req > 0) { @@ -554,7 +554,7 @@ static int m_block_ioctl(dev_t minor, unsigned int request, endpoint_t endpt, return s; if(is_imgrd) ramdev_size = 0; - if(m_vaddrs[minor] && !cmp64(dv->dv_size, cvul64(ramdev_size))) { + if(m_vaddrs[minor] && !cmp64(dv->dv_size, ((u64_t)(ramdev_size)))) { return(OK); } /* openct is 1 for the ioctl(). */ @@ -602,7 +602,7 @@ static int m_block_ioctl(dev_t minor, unsigned int request, endpoint_t endpt, m_vaddrs[minor] = (vir_bytes) mem; - dv->dv_size = cvul64(ramdev_size); + dv->dv_size = ((u64_t)(ramdev_size)); return(OK); } diff --git a/drivers/random/main.c b/drivers/random/main.c index 18ed36d34..231768204 100644 --- a/drivers/random/main.c +++ b/drivers/random/main.c @@ -202,7 +202,7 @@ static int r_transfer( } /* Book the number of bytes transferred. */ - position= add64u(position, count); + position= ((u64_t)(position) + (count)); if ((iov->iov_size -= count) == 0) { iov++; nr_req--; vir_offset = 0; } } diff --git a/drivers/vbox/hgcm.c b/drivers/vbox/hgcm.c index 2955fe5a3..68d68a912 100644 --- a/drivers/vbox/hgcm.c +++ b/drivers/vbox/hgcm.c @@ -524,7 +524,7 @@ static int store_pages(int conn, int req, vbox_param_t *inp, size_t *offp) assert(!(pvec[j].vp_addr & (PAGE_SIZE - 1))); pagelist->addr[pagelist->count++] = - cvul64(pvec[j].vp_addr); + ((u64_t)(pvec[j].vp_addr)); if (pvec[j].vp_size > PAGE_SIZE) { pvec[j].vp_addr += PAGE_SIZE; diff --git a/drivers/vbox/vbox.c b/drivers/vbox/vbox.c index 8a1a95bbb..6e2bfff96 100644 --- a/drivers/vbox/vbox.c +++ b/drivers/vbox/vbox.c @@ -161,7 +161,7 @@ static void vbox_update_time(void) sizeof(*req)) == VMMDEV_ERR_OK) { time(&otime); /* old time */ - ntime = div64u(req->time, 1000); /* new time */ + ntime = ((u64_t)(req->time) / (unsigned)(1000)); /* new time */ /* Make time go forward, if the difference exceeds the drift * threshold. Never make time go backward. diff --git a/include/minix/u64.h b/include/minix/u64.h index aa0059c15..497ca8cc8 100644 --- a/include/minix/u64.h +++ b/include/minix/u64.h @@ -13,21 +13,6 @@ #define make_zero64(i) ((i) = 0) #define neg64(i) ((i) = -(i)) -static inline u64_t add64(u64_t i, u64_t j) -{ - return i + j; -} - -static inline u64_t add64u(u64_t i, unsigned j) -{ - return i + j; -} - -static inline u64_t add64ul(u64_t i, unsigned long j) -{ - return i + j; -} - static inline int bsr64(u64_t i) { int index; @@ -71,64 +56,6 @@ static inline int cmp64ul(u64_t i, unsigned long j) return 0; } -static inline unsigned cv64u(u64_t i) -{ -/* return ULONG_MAX if really big */ - if (i>>32) - return ULONG_MAX; - - return (unsigned)i; -} - -static inline unsigned long cv64ul(u64_t i) -{ -/* return ULONG_MAX if really big */ - if (i>>32) - return ULONG_MAX; - - return (unsigned long)i; -} - -static inline u64_t cvu64(unsigned i) -{ - return i; -} - -static inline u64_t cvul64(unsigned long i) -{ - return i; -} - -static inline unsigned diff64(u64_t i, u64_t j) -{ - return (unsigned)(i - j); -} - -static inline u64_t div64(u64_t i, u64_t j) -{ - return i / j; -} - -static inline u64_t rem64(u64_t i, u64_t j) -{ - return i % j; -} - -static inline unsigned long div64u(u64_t i, unsigned j) -{ - return (unsigned long)(i / j); -} - -static inline u64_t div64u64(u64_t i, unsigned j) -{ - return i / j; -} - -static inline unsigned rem64u(u64_t i, unsigned j) -{ - return (unsigned)(i % j); -} - static inline unsigned long ex64lo(u64_t i) { return (unsigned long)i; @@ -144,31 +71,6 @@ static inline u64_t make64(unsigned long lo, unsigned long hi) return ((u64_t)hi << 32) | (u64_t)lo; } -static inline u64_t mul64(u64_t i, u64_t j) -{ - return i * j; -} - -static inline u64_t mul64u(unsigned long i, unsigned j) -{ - return (u64_t)i * j; -} - -static inline u64_t sub64(u64_t i, u64_t j) -{ - return i - j; -} - -static inline u64_t sub64u(u64_t i, unsigned j) -{ - return i - j; -} - -static inline u64_t sub64ul(u64_t i, unsigned long j) -{ - return i - j; -} - u64_t rrotate64(u64_t x, unsigned short b); u64_t rshift64(u64_t x, unsigned short b); u64_t xor64(u64_t a, u64_t b); diff --git a/kernel/arch/earm/arch_clock.c b/kernel/arch/earm/arch_clock.c index 0235e1d1a..a40a52811 100644 --- a/kernel/arch/earm/arch_clock.c +++ b/kernel/arch/earm/arch_clock.c @@ -66,13 +66,13 @@ void context_stop(struct proc * p) if(kbill_ipc) { kbill_ipc->p_kipc_cycles = - add64(kbill_ipc->p_kipc_cycles, tsc_delta); + ((u64_t)(kbill_ipc->p_kipc_cycles) + (tsc_delta)); kbill_ipc = NULL; } if(kbill_kcall) { kbill_kcall->p_kcall_cycles = - add64(kbill_kcall->p_kcall_cycles, tsc_delta); + ((u64_t)(kbill_kcall->p_kcall_cycles) + (tsc_delta)); kbill_kcall = NULL; } @@ -125,12 +125,12 @@ int register_local_timer_handler(const irq_handler_t handler) u64_t ms_2_cpu_time(unsigned ms) { - return mul64u(tsc_per_ms[cpuid], ms); + return ((u64_t)(tsc_per_ms[cpuid]) * (ms)); } unsigned cpu_time_2_ms(u64_t cpu_time) { - return div64u(cpu_time, tsc_per_ms[cpuid]); + return ((u64_t)(cpu_time) / (unsigned)(tsc_per_ms[cpuid])); } short cpu_load(void) diff --git a/kernel/arch/i386/apic.c b/kernel/arch/i386/apic.c index 9ec3190c2..653f12fbf 100644 --- a/kernel/arch/i386/apic.c +++ b/kernel/arch/i386/apic.c @@ -515,14 +515,14 @@ static void apic_calibrate_clocks(unsigned cpu) rm_irq_handler(&spurious_irq); lapic_delta = lapic_tctr0 - lapic_tctr1; - tsc_delta = sub64(tsc1, tsc0); + tsc_delta = ((u64_t)(tsc1) - (tsc0)); lapic_bus_freq[cpuid] = system_hz * lapic_delta / (PROBE_TICKS - 1); BOOT_VERBOSE(printf("APIC bus freq %u MHz\n", lapic_bus_freq[cpuid] / 1000000)); - cpu_freq = mul64(div64u64(tsc_delta, PROBE_TICKS - 1), make64(system_hz, 0)); + cpu_freq = ((u64_t)(((u64_t)(tsc_delta) / (unsigned)(PROBE_TICKS - 1))) * (make64(system_hz, 0))); cpu_set_freq(cpuid, cpu_freq); - cpu_info[cpuid].freq = div64u(cpu_freq, 1000000); + cpu_info[cpuid].freq = ((u64_t)(cpu_freq) / (unsigned)(1000000)); BOOT_VERBOSE(cpu_print_freq(cpuid)); } diff --git a/kernel/arch/i386/arch_clock.c b/kernel/arch/i386/arch_clock.c index ee20d2961..ef11416a2 100644 --- a/kernel/arch/i386/arch_clock.c +++ b/kernel/arch/i386/arch_clock.c @@ -119,11 +119,11 @@ static void estimate_cpu_freq(void) /* remove the probe */ rm_irq_handler(&calib_cpu); - tsc_delta = sub64(tsc1, tsc0); + tsc_delta = ((u64_t)(tsc1) - (tsc0)); - cpu_freq = mul64(div64u64(tsc_delta, PROBE_TICKS - 1), make64(system_hz, 0)); + cpu_freq = ((u64_t)(((u64_t)(tsc_delta) / (unsigned)(PROBE_TICKS - 1))) * (make64(system_hz, 0))); cpu_set_freq(cpuid, cpu_freq); - cpu_info[cpuid].freq = div64u(cpu_freq, 1000000); + cpu_info[cpuid].freq = ((u64_t)(cpu_freq) / (unsigned)(1000000)); BOOT_VERBOSE(cpu_print_freq(cpuid)); } @@ -223,9 +223,9 @@ void context_stop(struct proc * p) u64_t tmp; read_tsc_64(&tsc); - tmp = sub64(tsc, *__tsc_ctr_switch); - kernel_ticks[cpu] = add64(kernel_ticks[cpu], tmp); - p->p_cycles = add64(p->p_cycles, tmp); + tmp = ((u64_t)(tsc) - (*__tsc_ctr_switch)); + kernel_ticks[cpu] = ((u64_t)(kernel_ticks[cpu]) + (tmp)); + p->p_cycles = ((u64_t)(p->p_cycles) + (tmp)); must_bkl_unlock = 1; } else { u64_t bkl_tsc; @@ -239,11 +239,11 @@ void context_stop(struct proc * p) read_tsc_64(&tsc); - bkl_ticks[cpu] = add64(bkl_ticks[cpu], sub64(tsc, bkl_tsc)); + bkl_ticks[cpu] = ((u64_t)(bkl_ticks[cpu]) + (((u64_t)(tsc) - (bkl_tsc)))); bkl_tries[cpu]++; bkl_succ[cpu] += !(!(succ == 0)); - p->p_cycles = add64(p->p_cycles, sub64(tsc, *__tsc_ctr_switch)); + p->p_cycles = ((u64_t)(p->p_cycles) + (((u64_t)(tsc) - (*__tsc_ctr_switch)))); #ifdef CONFIG_SMP /* @@ -261,20 +261,20 @@ void context_stop(struct proc * p) } #else read_tsc_64(&tsc); - p->p_cycles = add64(p->p_cycles, sub64(tsc, *__tsc_ctr_switch)); + p->p_cycles = ((u64_t)(p->p_cycles) + (((u64_t)(tsc) - (*__tsc_ctr_switch)))); #endif - tsc_delta = sub64(tsc, *__tsc_ctr_switch); + tsc_delta = ((u64_t)(tsc) - (*__tsc_ctr_switch)); if(kbill_ipc) { kbill_ipc->p_kipc_cycles = - add64(kbill_ipc->p_kipc_cycles, tsc_delta); + ((u64_t)(kbill_ipc->p_kipc_cycles) + (tsc_delta)); kbill_ipc = NULL; } if(kbill_kcall) { kbill_kcall->p_kcall_cycles = - add64(kbill_kcall->p_kcall_cycles, tsc_delta); + ((u64_t)(kbill_kcall->p_kcall_cycles) + (tsc_delta)); kbill_kcall = NULL; } @@ -291,7 +291,7 @@ void context_stop(struct proc * p) if (ex64hi(tsc_delta) < ex64hi(p->p_cpu_time_left) || (ex64hi(tsc_delta) == ex64hi(p->p_cpu_time_left) && ex64lo(tsc_delta) < ex64lo(p->p_cpu_time_left))) - p->p_cpu_time_left = sub64(p->p_cpu_time_left, tsc_delta); + p->p_cpu_time_left = ((u64_t)(p->p_cpu_time_left) - (tsc_delta)); else { make_zero64(p->p_cpu_time_left); } @@ -329,12 +329,12 @@ void context_stop_idle(void) u64_t ms_2_cpu_time(unsigned ms) { - return mul64u(tsc_per_ms[cpuid], ms); + return ((u64_t)(tsc_per_ms[cpuid]) * (ms)); } unsigned cpu_time_2_ms(u64_t cpu_time) { - return div64u(cpu_time, tsc_per_ms[cpuid]); + return ((u64_t)(cpu_time) / (unsigned)(tsc_per_ms[cpuid])); } short cpu_load(void) @@ -358,12 +358,12 @@ short cpu_load(void) /* calculate load since last cpu_load invocation */ if (!is_zero64(*last_tsc)) { - tsc_delta = sub64(current_tsc, *last_tsc); - idle_delta = sub64(*current_idle, *last_idle); + tsc_delta = ((u64_t)(current_tsc) - (*last_tsc)); + idle_delta = ((u64_t)(*current_idle) - (*last_idle)); - busy = sub64(tsc_delta, idle_delta); - busy = mul64(busy, make64(100, 0)); - load = ex64lo(div64(busy, tsc_delta)); + busy = ((u64_t)(tsc_delta) - (idle_delta)); + busy = ((u64_t)(busy) * (make64(100, 0))); + load = ex64lo(((u64_t)(busy) / (unsigned)(tsc_delta))); if (load > 100) load = 100; diff --git a/kernel/arch/i386/arch_watchdog.c b/kernel/arch/i386/arch_watchdog.c index 80647af0d..2f654fa79 100644 --- a/kernel/arch/i386/arch_watchdog.c +++ b/kernel/arch/i386/arch_watchdog.c @@ -33,7 +33,7 @@ static void intel_arch_watchdog_init(const unsigned cpu) */ cpuf = cpu_get_freq(cpu); while (ex64hi(cpuf) || ex64lo(cpuf) > 0x7fffffffU) - cpuf = div64u64(cpuf, 2); + cpuf = ((u64_t)(cpuf) / (unsigned)(2)); cpuf = make64(-ex64lo(cpuf), ex64hi(cpuf)); watchdog->resetval = watchdog->watchdog_resetval = cpuf; @@ -159,7 +159,7 @@ static int intel_arch_watchdog_profile_init(const unsigned freq) /* FIXME works only if all CPUs have the same freq */ cpuf = cpu_get_freq(cpuid); - cpuf = div64u64(cpuf, freq); + cpuf = ((u64_t)(cpuf) / (unsigned)(freq)); /* * if freq is too low and the cpu freq too high we may get in a range of @@ -224,7 +224,7 @@ static int amd_watchdog_profile_init(const unsigned freq) /* FIXME works only if all CPUs have the same freq */ cpuf = cpu_get_freq(cpuid); - cpuf = div64u64(cpuf, freq); + cpuf = ((u64_t)(cpuf) / (unsigned)(freq)); neg64(cpuf); watchdog->profile_resetval = cpuf; diff --git a/kernel/main.c b/kernel/main.c index cf80c954e..91e5d1db4 100644 --- a/kernel/main.c +++ b/kernel/main.c @@ -505,7 +505,7 @@ void cpu_print_freq(unsigned cpu) u64_t freq; freq = cpu_get_freq(cpu); - printf("CPU %d freq %lu MHz\n", cpu, div64u(freq, 1000000)); + printf("CPU %d freq %lu MHz\n", cpu, ((u64_t)(freq) / (unsigned)(1000000))); } int is_fpu(void) diff --git a/kernel/proc.c b/kernel/proc.c index 6dcaf9125..47f5f8633 100644 --- a/kernel/proc.c +++ b/kernel/proc.c @@ -1691,9 +1691,8 @@ void dequeue(struct proc *rp) at a time. */ if (!is_zero64(rp->p_accounting.enter_queue)) { read_tsc_64(&tsc); - tsc_delta = sub64(tsc, rp->p_accounting.enter_queue); - rp->p_accounting.time_in_queue = add64(rp->p_accounting.time_in_queue, - tsc_delta); + tsc_delta = ((u64_t)(tsc) - (rp->p_accounting.enter_queue)); + rp->p_accounting.time_in_queue = ((u64_t)(rp->p_accounting.time_in_queue) + (tsc_delta)); make_zero64(rp->p_accounting.enter_queue); } diff --git a/kernel/system/do_getinfo.c b/kernel/system/do_getinfo.c index 19ab73c14..55b2db620 100644 --- a/kernel/system/do_getinfo.c +++ b/kernel/system/do_getinfo.c @@ -29,8 +29,7 @@ static void update_idle_time(void) idl->p_cycles = make64(0, 0); for (i = 0; i < CONFIG_MAX_CPUS ; i++) { - idl->p_cycles = add64(idl->p_cycles, - get_cpu_var(i, idle_proc).p_cycles); + idl->p_cycles = ((u64_t)(idl->p_cycles) + (get_cpu_var(i, idle_proc).p_cycles)); } } diff --git a/lib/libblockdriver/driver.c b/lib/libblockdriver/driver.c index f45b11552..05fb7cc42 100644 --- a/lib/libblockdriver/driver.c +++ b/lib/libblockdriver/driver.c @@ -290,7 +290,7 @@ static int do_dioctl(struct blockdriver *bdp, dev_t minor, (*bdp->bdr_geometry)(minor, &entry); } else { /* The driver doesn't care -- make up fake geometry. */ - entry.cylinders = div64u(entry.size, SECTOR_SIZE); + entry.cylinders = ((u64_t)(entry.size) / (unsigned)(SECTOR_SIZE)); entry.heads = 64; entry.sectors = 32; } diff --git a/lib/libblockdriver/drvlib.c b/lib/libblockdriver/drvlib.c index 55df9f00d..fee6e4439 100644 --- a/lib/libblockdriver/drvlib.c +++ b/lib/libblockdriver/drvlib.c @@ -73,8 +73,8 @@ u8_t *tmp_buf; /* temporary buffer */ /* Get the geometry of the device to partition */ if ((dv = (*bdp->bdr_part)(device)) == NULL || cmp64u(dv->dv_size, 0) == 0) return; - base = div64u(dv->dv_base, SECTOR_SIZE); - limit = base + div64u(dv->dv_size, SECTOR_SIZE); + base = ((u64_t)(dv->dv_base) / (unsigned)(SECTOR_SIZE)); + limit = base + ((u64_t)(dv->dv_size) / (unsigned)(SECTOR_SIZE)); /* Read the partition table for the device. */ if(!get_part_table(bdp, device, 0L, table, tmp_buf)) { @@ -109,8 +109,8 @@ u8_t *tmp_buf; /* temporary buffer */ if (pe->lowsec < base) pe->lowsec = base; if (part_limit < pe->lowsec) part_limit = pe->lowsec; - dv->dv_base = mul64u(pe->lowsec, SECTOR_SIZE); - dv->dv_size = mul64u(part_limit - pe->lowsec, SECTOR_SIZE); + dv->dv_base = ((u64_t)(pe->lowsec) * (SECTOR_SIZE)); + dv->dv_size = ((u64_t)(part_limit - pe->lowsec) * (SECTOR_SIZE)); if (style == P_PRIMARY) { /* Each Minix primary partition can be subpartitioned. */ @@ -163,9 +163,8 @@ u8_t *tmp_buf; /* temporary buffer */ if (pe->sysind != NO_PART) { if ((dv = (*bdp->bdr_part)(subdev)) == NULL) return; - dv->dv_base = mul64u(extbase + offset + pe->lowsec, - SECTOR_SIZE); - dv->dv_size = mul64u(pe->size, SECTOR_SIZE); + dv->dv_base = ((u64_t)(extbase + offset + pe->lowsec) * (SECTOR_SIZE)); + dv->dv_size = ((u64_t)(pe->size) * (SECTOR_SIZE)); /* Out of devices? */ if (++subdev % NR_PARTITIONS == 0) return; @@ -191,7 +190,7 @@ u8_t *tmp_buf; /* temporary buffer */ u64_t position; int r; - position = mul64u(offset, SECTOR_SIZE); + position = ((u64_t)(offset) * (SECTOR_SIZE)); iovec1.iov_addr = (vir_bytes) tmp_buf; iovec1.iov_size = CD_SECTOR_SIZE; r = (*bdp->bdr_transfer)(device, FALSE /*do_write*/, position, SELF, diff --git a/lib/libblockdriver/trace.c b/lib/libblockdriver/trace.c index bf80cc836..1dfb23864 100644 --- a/lib/libblockdriver/trace.c +++ b/lib/libblockdriver/trace.c @@ -40,7 +40,7 @@ static u32_t trace_gettime(void) read_tsc_64(&tsc); - tsc = sub64(tsc, trace_tsc); + tsc = ((u64_t)(tsc) - (trace_tsc)); return tsc_64_to_micros(tsc); } @@ -195,7 +195,7 @@ void trace_start(thread_id_t id, message *m_ptr) switch (m_ptr->m_type) { case BDEV_OPEN: case BDEV_CLOSE: - pos = cvu64(0); + pos = ((u64_t)(0)); size = m_ptr->BDEV_ACCESS; flags = 0; @@ -212,7 +212,7 @@ void trace_start(thread_id_t id, message *m_ptr) break; case BDEV_IOCTL: - pos = cvu64(0); + pos = ((u64_t)(0)); size = m_ptr->BDEV_REQUEST; flags = 0; diff --git a/lib/libc/sys-minix/sizeup.c b/lib/libc/sys-minix/sizeup.c index abf5323d2..41c0245b1 100644 --- a/lib/libc/sys-minix/sizeup.c +++ b/lib/libc/sys-minix/sizeup.c @@ -41,9 +41,9 @@ u64_t *bytes; perror("sizeup ioctl"); if(fstat(fd, &st) < 0) { perror("fstat"); - entry.size = cvu64(0); + entry.size = ((u64_t)(0)); } else { - entry.size = cvu64(st.st_size); + entry.size = ((u64_t)(st.st_size)); } } close(fd); diff --git a/lib/libhgfs/time.c b/lib/libhgfs/time.c index 1dc806056..30b8193df 100644 --- a/lib/libhgfs/time.c +++ b/lib/libhgfs/time.c @@ -18,7 +18,7 @@ void time_init(void) * the difference between that time and the UNIX epoch, in 100ns units. */ /* FIXME: we currently do not take into account timezones. */ - time_offset = mul64u(116444736, 1000000000); + time_offset = ((u64_t)(116444736) * (1000000000)); } /*===========================================================================* @@ -33,8 +33,8 @@ void time_put(struct timespec *tsp) u64_t hgfstime; if (tsp != NULL) { - hgfstime = add64ul(mul64u(tsp->tv_sec, 10000000), tsp->tv_nsec / 100); - hgfstime = add64(hgfstime, time_offset); + hgfstime = ((u64_t)(((u64_t)(tsp->tv_sec) * (10000000))) + (tsp->tv_nsec / 100)); + hgfstime = ((u64_t)(hgfstime) + (time_offset)); RPC_NEXT32 = ex64lo(hgfstime); RPC_NEXT32 = ex64hi(hgfstime); @@ -60,10 +60,10 @@ void time_get(struct timespec *tsp) time_lo = RPC_NEXT32; time_hi = RPC_NEXT32; - hgfstime = sub64(make64(time_lo, time_hi), time_offset); + hgfstime = ((u64_t)(make64(time_lo, time_hi)) - (time_offset)); - tsp->tv_sec = div64u(hgfstime, 10000000); - tsp->tv_nsec = rem64u(hgfstime, 10000000) * 100; + tsp->tv_sec = ((u64_t)(hgfstime) / (unsigned)(10000000)); + tsp->tv_nsec = ((u64_t)(hgfstime) % (unsigned)(10000000)) * 100; } else RPC_ADVANCE(sizeof(u32_t) * 2); } diff --git a/lib/libminixfs/cache.c b/lib/libminixfs/cache.c index adb482d99..560fb6706 100644 --- a/lib/libminixfs/cache.c +++ b/lib/libminixfs/cache.c @@ -75,8 +75,8 @@ u32_t fs_bufs_heuristic(int minbufs, u32_t btotal, u32_t bfree, vsi.vsi_pagesize / 1024; /* check fs usage. */ - kbytes_used_fs = div64u(mul64u(bused, blocksize), 1024); - kbytes_total_fs = div64u(mul64u(btotal, blocksize), 1024); + kbytes_used_fs = ((u64_t)(((u64_t)(bused) * (blocksize))) / (unsigned)(1024)); + kbytes_total_fs = ((u64_t)(((u64_t)(btotal) * (blocksize))) / (unsigned)(1024)); /* heuristic for a desired cache size based on FS usage; * but never bigger than half of the total filesystem @@ -512,7 +512,7 @@ register struct buf *bp; /* buffer pointer */ ASSERT(fs_block_size > 0); ASSERT(!(fs_block_size % PAGE_SIZE)); - pos = mul64u(bp->lmfs_blocknr, fs_block_size); + pos = ((u64_t)(bp->lmfs_blocknr) * (fs_block_size)); if(fs_block_size > PAGE_SIZE) { #define MAXPAGES 20 vir_bytes vaddr = (vir_bytes) bp->data; @@ -674,7 +674,7 @@ void lmfs_rw_scattered( assert(nblocks > 0); assert(niovecs > 0); - pos = mul64u(bufq[0]->lmfs_blocknr, fs_block_size); + pos = ((u64_t)(bufq[0]->lmfs_blocknr) * (fs_block_size)); if (rw_flag == READING) r = bdev_gather(dev, pos, iovec, niovecs, BDEV_NOFLAGS); else diff --git a/lib/libsffs/misc.c b/lib/libsffs/misc.c index fe48d84cf..31069662d 100644 --- a/lib/libsffs/misc.c +++ b/lib/libsffs/misc.c @@ -62,8 +62,8 @@ int do_statvfs() */ statvfs.f_bsize = BLOCK_SIZE; statvfs.f_frsize = BLOCK_SIZE; - statvfs.f_blocks = div64u(total, BLOCK_SIZE); - statvfs.f_bfree = div64u(free, BLOCK_SIZE); + statvfs.f_blocks = ((u64_t)(total) / (unsigned)(BLOCK_SIZE)); + statvfs.f_bfree = ((u64_t)(free) / (unsigned)(BLOCK_SIZE)); statvfs.f_bavail = statvfs.f_bfree; statvfs.f_files = 0; statvfs.f_ffree = 0; diff --git a/lib/libsffs/read.c b/lib/libsffs/read.c index e34bd28d2..84a447166 100644 --- a/lib/libsffs/read.c +++ b/lib/libsffs/read.c @@ -61,7 +61,7 @@ int do_read() count -= chunk; off += chunk; - pos = add64u(pos, chunk); + pos = ((u64_t)(pos) + (chunk)); } if (r < 0) diff --git a/lib/libsffs/write.c b/lib/libsffs/write.c index bf70038a7..6ebad51e2 100644 --- a/lib/libsffs/write.c +++ b/lib/libsffs/write.c @@ -64,7 +64,7 @@ cp_grant_id_t *grantp; count -= r; off += r; - pos = add64u(pos, r); + pos = ((u64_t)(pos) + (r)); } if (r < 0) @@ -151,7 +151,7 @@ int do_ftrunc() /* Write zeroes to the file. We can't create holes. */ if (cmp64(end, start) <= 0) return EINVAL; - delta = sub64(end, start); + delta = ((u64_t)(end) - (start)); if (ex64hi(delta) != 0) return EINVAL; diff --git a/lib/libsys/arch/i386/getidle.c b/lib/libsys/arch/i386/getidle.c index 8fc225e7c..f7cca8887 100644 --- a/lib/libsys/arch/i386/getidle.c +++ b/lib/libsys/arch/i386/getidle.c @@ -67,8 +67,8 @@ double getidle(void) if ((r = sys_getidletsc(&idle2)) != OK) return -1.0; - idelta = sub64(idle2, idle); - tdelta = sub64(stop, start); + idelta = ((u64_t)(idle2) - (idle)); + tdelta = ((u64_t)(stop) - (start)); if (cmp64(idelta, tdelta) >= 0) return 100.0; diff --git a/lib/libsys/arch/i386/profile.c b/lib/libsys/arch/i386/profile.c index 3acbbc8a7..d171c5678 100644 --- a/lib/libsys/arch/i386/profile.c +++ b/lib/libsys/arch/i386/profile.c @@ -191,13 +191,12 @@ void procexit (char *UNUSED(name)) */ /* Calculate "small" difference. */ - spent = sub64(stop, cprof_stk[cprof_stk_top].start_2); + spent = ((u64_t)(stop) - (cprof_stk[cprof_stk_top].start_2)); cprof_stk[cprof_stk_top].slot->cycles = - add64(cprof_stk[cprof_stk_top].slot->cycles, - sub64(spent, cprof_stk[cprof_stk_top].spent_deeper)); + ((u64_t)(cprof_stk[cprof_stk_top].slot->cycles) + (((u64_t)(spent) - (cprof_stk[cprof_stk_top].spent_deeper)))); /* Clear spent_deeper for call level we're leaving. */ - cprof_stk[cprof_stk_top].spent_deeper = cvu64(0); + cprof_stk[cprof_stk_top].spent_deeper = ((u64_t)(0)); /* Adjust call path string and stack. */ cpath_len = cprof_stk[cprof_stk_top].cpath_len; @@ -217,11 +216,11 @@ void procexit (char *UNUSED(name)) stop = make64(tsc_lo, tsc_hi); /* Calculate "big" difference. */ - spent = sub64(stop, cprof_stk[cprof_stk_top].start_1); + spent = ((u64_t)(stop) - (cprof_stk[cprof_stk_top].start_1)); cprof_stk_top--; /* decrease stack */ if (cprof_stk_top >= 0) /* don't update non-existent level -1 */ cprof_stk[cprof_stk_top].spent_deeper = - add64(cprof_stk[cprof_stk_top].spent_deeper, spent); + ((u64_t)(cprof_stk[cprof_stk_top].spent_deeper) + (spent)); cprof_locked = 0; } @@ -242,9 +241,9 @@ static void cprof_init() for (i=0; is_base_tsc); + tsc_delta = ((u64_t)(cur_tsc) - (s->s_base_tsc)); micro_delta = tsc_64_to_micros(tsc_delta); diff --git a/lib/libsys/arch/i386/tsc_util.c b/lib/libsys/arch/i386/tsc_util.c index 87b2b8c1c..43f46472a 100644 --- a/lib/libsys/arch/i386/tsc_util.c +++ b/lib/libsys/arch/i386/tsc_util.c @@ -63,7 +63,7 @@ micro_delay(u32_t micros) CALIBRATE; /* We have to know when to end the delay. */ - end = add64(now, mul64u(micros, calib_mhz)); + end = ((u64_t)(now) + (((u64_t)(micros) * (calib_mhz)))); /* If we have to wait for at least one HZ tick, use the regular * tickdelay first. Round downwards on purpose, so the average @@ -87,7 +87,7 @@ u32_t tsc_64_to_micros(u64_t tsc) CALIBRATE; - tmp = div64u64(tsc, calib_mhz); + tmp = ((u64_t)(tsc) / (unsigned)(calib_mhz)); if (ex64hi(tmp)) { printf("tsc_64_to_micros: more than 2^32ms\n"); return ~0UL; diff --git a/lib/libsys/sys_hz.c b/lib/libsys/sys_hz.c index 33c9c6aad..dc97f5244 100644 --- a/lib/libsys/sys_hz.c +++ b/lib/libsys/sys_hz.c @@ -31,7 +31,7 @@ micros_to_ticks(u32_t micros) { u32_t ticks; - ticks = div64u(mul64u(micros, sys_hz()), 1000000); + ticks = ((u64_t)(((u64_t)(micros) * (sys_hz()))) / (unsigned)(1000000)); if(ticks < 1) ticks = 1; return ticks; diff --git a/lib/libvboxfs/attr.c b/lib/libvboxfs/attr.c index 6017748a8..c0299c034 100644 --- a/lib/libvboxfs/attr.c +++ b/lib/libvboxfs/attr.c @@ -10,8 +10,8 @@ static void get_time(struct timespec *tsp, u64_t nsecs) { - tsp->tv_sec = div64u(nsecs, 1000000000); - tsp->tv_nsec = rem64u(nsecs, 1000000000); + tsp->tv_sec = ((u64_t)(nsecs) / (unsigned)(1000000000)); + tsp->tv_nsec = ((u64_t)(nsecs) % (unsigned)(1000000000)); } /* @@ -21,7 +21,7 @@ static u64_t set_time(struct timespec *tsp) { - return add64u(mul64u(tsp->tv_sec, 1000000000), tsp->tv_nsec); + return ((u64_t)(((u64_t)(tsp->tv_sec) * (1000000000))) + (tsp->tv_nsec)); } /* diff --git a/servers/ext2/read.c b/servers/ext2/read.c index 64935a1d4..b955e6af4 100644 --- a/servers/ext2/read.c +++ b/servers/ext2/read.c @@ -93,7 +93,7 @@ int fs_readwrite(void) } /* Read or write 'chunk' bytes. */ - r = rw_chunk(rip, cvul64((unsigned long) position), off, chunk, + r = rw_chunk(rip, ((u64_t)((unsigned long)position)), off, chunk, nrbytes, rw_flag, gid, cum_io, block_size, &completed); if (r != OK) break; /* EOF reached */ @@ -174,7 +174,7 @@ int fs_breadwrite(void) cum_io = 0; /* Split the transfer into chunks that don't span two blocks. */ while (nrbytes > 0) { - off = rem64u(position, block_size); /* offset in blk*/ + off = ((u64_t)(position) % (unsigned)(block_size)); /* offset in blk*/ chunk = min(nrbytes, block_size - off); /* Read or write 'chunk' bytes. */ @@ -187,7 +187,7 @@ int fs_breadwrite(void) /* Update counters and pointers. */ nrbytes -= chunk; /* bytes yet to be read */ cum_io += chunk; /* bytes read so far */ - position = add64ul(position, chunk); /* position within the file */ + position = ((u64_t)(position) + (chunk)); /* position within the file */ } fs_m_out.RES_SEEK_POS_LO = ex64lo(position); @@ -239,7 +239,7 @@ int *completed; /* number of bytes copied */ block_spec = (rip->i_mode & I_TYPE) == I_BLOCK_SPECIAL; if (block_spec) { - b = div64u(position, block_size); + b = ((u64_t)(position) / (unsigned)(block_size)); dev = (dev_t) rip->i_block[0]; } else { if (ex64hi(position) != 0) @@ -453,7 +453,7 @@ void read_ahead() assert(rdahedpos >= 0); /* So we can safely cast it to unsigned below */ - bp = rahead(rip, b, cvul64((unsigned long) rdahedpos), block_size); + bp = rahead(rip, b, ((u64_t)((unsigned long)rdahedpos)), block_size); put_block(bp, PARTIAL_DATA_BLOCK); } diff --git a/servers/ext2/super.c b/servers/ext2/super.c index 27c455cde..5fb69c5f5 100644 --- a/servers/ext2/super.c +++ b/servers/ext2/super.c @@ -92,7 +92,7 @@ register struct super_block *sp; /* pointer to a superblock */ panic("can't allocate memory for super_block buffers"); assert(_MIN_BLOCK_SIZE <= sizeof(*ondisk_superblock)); - r = bdev_read(dev, cvu64(super_block_offset), (char*) ondisk_superblock, + r = bdev_read(dev, ((u64_t)(super_block_offset)), (char*) ondisk_superblock, _MIN_BLOCK_SIZE, BDEV_NOFLAGS); if (r != _MIN_BLOCK_SIZE) @@ -177,7 +177,7 @@ register struct super_block *sp; /* pointer to a superblock */ gdt_position = (opt.block_with_super + 1) * 1024; } - r = bdev_read(dev, cvu64(gdt_position), (char*) ondisk_group_descs, + r = bdev_read(dev, ((u64_t)(gdt_position)), (char*) ondisk_group_descs, gd_size, BDEV_NOFLAGS); if (r != (ssize_t) gd_size) { printf("Can not read group descriptors\n"); @@ -230,7 +230,7 @@ struct super_block *sp; /* pointer to a superblock */ super_copy(ondisk_superblock, sp); - r = bdev_write(sp->s_dev, cvu64(super_block_offset), (char *) sp, + r = bdev_write(sp->s_dev, ((u64_t)(super_block_offset)), (char *) sp, SUPER_SIZE_D, BDEV_NOFLAGS); if (r != SUPER_SIZE_D) printf("ext2: Warning, failed to write superblock to the disk!\n"); @@ -248,7 +248,7 @@ struct super_block *sp; /* pointer to a superblock */ copy_group_descriptors(ondisk_group_descs, sp->s_group_desc, sp->s_groups_count); - r = bdev_write(sp->s_dev, cvu64(gdt_position), + r = bdev_write(sp->s_dev, ((u64_t)(gdt_position)), (char*) ondisk_group_descs, gd_size, BDEV_NOFLAGS); if (r != (ssize_t) gd_size) { printf("Can not write group descriptors\n"); diff --git a/servers/iso9660fs/read.c b/servers/iso9660fs/read.c index 2e6073a6c..37ac8ee9e 100644 --- a/servers/iso9660fs/read.c +++ b/servers/iso9660fs/read.c @@ -54,7 +54,7 @@ int fs_read(void) { if (chunk > bytes_left) chunk = (int) bytes_left; /* Read or write 'chunk' bytes. */ - r = read_chunk(dir, cvul64(position), off, chunk, (unsigned) nrbytes, + r = read_chunk(dir, ((u64_t)(position)), off, chunk, (unsigned) nrbytes, gid, cum_io, block_size, &completed, rw); if (r != OK) break; /* EOF reached */ @@ -106,7 +106,7 @@ int fs_bread(void) cum_io = 0; /* Split the transfer into chunks that don't span two blocks. */ while (nrbytes != 0) { - off = rem64u(position, block_size); /* offset in blk*/ + off = ((u64_t)(position) % (unsigned)(block_size)); /* offset in blk*/ chunk = MIN(nrbytes, block_size - off); if (chunk < 0) chunk = block_size - off; @@ -121,7 +121,7 @@ int fs_bread(void) /* Update counters and pointers. */ nrbytes -= chunk; /* bytes yet to be read */ cum_io += chunk; /* bytes read so far */ - position= add64ul(position, chunk); /* position within the file */ + position= ((u64_t)(position) + (chunk)); /* position within the file */ } fs_m_out.RES_SEEK_POS_LO = ex64lo(position); @@ -310,19 +310,19 @@ int rw; /* READING or PEEKING */ if ((ex64lo(position) <= dir->d_file_size) && (ex64lo(position) > dir->data_length_l)) { while ((dir->d_next != NULL) && (ex64lo(position) > dir->data_length_l)) { - position = sub64ul(position, dir->data_length_l); + position = ((u64_t)(position) - (dir->data_length_l)); dir = dir->d_next; } } if (dir->inter_gap_size != 0) { - rel_block = div64u(position, block_size); + rel_block = ((u64_t)(position) / (unsigned)(block_size)); file_unit = rel_block / dir->data_length_l; offset = rel_block % dir->file_unit_size; b = dir->loc_extent_l + (dir->file_unit_size + dir->inter_gap_size) * file_unit + offset; } else { - b = dir->loc_extent_l + div64u(position, block_size); /* Physical position + b = dir->loc_extent_l + ((u64_t)(position) / (unsigned)(block_size)); /* Physical position * to read. */ } diff --git a/servers/iso9660fs/super.c b/servers/iso9660fs/super.c index 6d1381b0c..7fb5de294 100644 --- a/servers/iso9660fs/super.c +++ b/servers/iso9660fs/super.c @@ -91,7 +91,7 @@ int read_vds( static char sbbuf[ISO9660_MIN_BLOCK_SIZE]; int i = 0; - offset = cvul64(ISO9660_SUPER_BLOCK_POSITION); + offset = ((u64_t)(ISO9660_SUPER_BLOCK_POSITION)); while (!vol_ok && i++ 0) { - off = rem64u(position, block_size); /* offset in blk*/ + off = ((u64_t)(position) % (unsigned)(block_size)); /* offset in blk*/ chunk = min(nrbytes, block_size - off); /* Read or write 'chunk' bytes. */ @@ -196,7 +196,7 @@ int fs_breadwrite(void) /* Update counters and pointers. */ nrbytes -= chunk; /* bytes yet to be read */ cum_io += chunk; /* bytes read so far */ - position = add64ul(position, chunk); /* position within the file */ + position = ((u64_t)(position) + (chunk)); /* position within the file */ } fs_m_out.RES_SEEK_POS_LO = ex64lo(position); @@ -248,7 +248,7 @@ int *completed; /* number of bytes copied */ block_spec = (rip->i_mode & I_TYPE) == I_BLOCK_SPECIAL; if (block_spec) { - b = div64u(position, block_size); + b = ((u64_t)(position) / (unsigned)(block_size)); dev = (dev_t) rip->i_zone[0]; } else { if (ex64hi(position) != 0) diff --git a/servers/mfs/super.c b/servers/mfs/super.c index 63084ee8f..2f8101c98 100644 --- a/servers/mfs/super.c +++ b/servers/mfs/super.c @@ -214,10 +214,10 @@ static int rw_super(struct super_block *sp, int writing) if(writing) { memset(sbbuf, 0, _MIN_BLOCK_SIZE); memcpy(sbbuf, sp, ondisk_bytes); - r = bdev_write(sp->s_dev, cvu64(SUPER_BLOCK_BYTES), sbbuf, _MIN_BLOCK_SIZE, + r = bdev_write(sp->s_dev, ((u64_t)(SUPER_BLOCK_BYTES)), sbbuf, _MIN_BLOCK_SIZE, BDEV_NOFLAGS); } else { - r = bdev_read(sp->s_dev, cvu64(SUPER_BLOCK_BYTES), sbbuf, _MIN_BLOCK_SIZE, + r = bdev_read(sp->s_dev, ((u64_t)(SUPER_BLOCK_BYTES)), sbbuf, _MIN_BLOCK_SIZE, BDEV_NOFLAGS); memset(sp, 0, sizeof(*sp)); memcpy(sp, sbbuf, ondisk_bytes); diff --git a/servers/vfs/device.c b/servers/vfs/device.c index b9984e18d..e52db1086 100644 --- a/servers/vfs/device.c +++ b/servers/vfs/device.c @@ -680,7 +680,7 @@ int do_ioctl(message *UNUSED(m_out)) if (S_ISBLK(vp->v_mode)) r = bdev_ioctl(dev, who_e, ioctlrequest, argx); else - r = dev_io(VFS_DEV_IOCTL, dev, who_e, argx, cvu64(0), + r = dev_io(VFS_DEV_IOCTL, dev, who_e, argx, ((u64_t)(0)), ioctlrequest, f->filp_flags, suspend_reopen); } diff --git a/servers/vfs/exec.c b/servers/vfs/exec.c index 9e9b6d096..8a58a77ee 100644 --- a/servers/vfs/exec.c +++ b/servers/vfs/exec.c @@ -567,7 +567,7 @@ char path[PATH_MAX]; /* path to script file */ pos = 0; /* Read from the start of the file */ /* Issue request */ - r = req_readwrite(vp->v_fs_e, vp->v_inode_nr, cvul64(pos), READING, + r = req_readwrite(vp->v_fs_e, vp->v_inode_nr, ((u64_t)(pos)), READING, VFS_PROC_NR, buf, _MAX_BLOCK_SIZE, &new_pos, &cum_io); if (r != OK) return(r); @@ -692,7 +692,7 @@ static int read_seg(struct exec_info *execi, off_t off, off_t seg_addr, size_t s if (off + seg_bytes > LONG_MAX) return(EIO); if ((unsigned long) vp->v_size < off+seg_bytes) return(EIO); - if ((r = req_readwrite(vp->v_fs_e, vp->v_inode_nr, cvul64(off), READING, + if ((r = req_readwrite(vp->v_fs_e, vp->v_inode_nr, ((u64_t)(off)), READING, execi->proc_e, (char*)seg_addr, seg_bytes, &new_pos, &cum_io)) != OK) { printf("VFS: read_seg: req_readwrite failed (data)\n"); @@ -739,7 +739,7 @@ static int map_header(struct vfs_exec_info *execi) execi->args.hdr = hdr; r = req_readwrite(execi->vp->v_fs_e, execi->vp->v_inode_nr, - cvul64(pos), READING, VFS_PROC_NR, hdr, + ((u64_t)(pos)), READING, VFS_PROC_NR, hdr, execi->args.hdr_len, &new_pos, &cum_io); if (r != OK) { printf("VFS: exec: map_header: req_readwrite failed\n"); diff --git a/servers/vfs/filedes.c b/servers/vfs/filedes.c index c0328cdbc..51c057e75 100644 --- a/servers/vfs/filedes.c +++ b/servers/vfs/filedes.c @@ -177,7 +177,7 @@ int get_fd(struct fproc *rfp, int start, mode_t bits, int *k, struct filp **fpt) assert(f->filp_count >= 0); if (f->filp_count == 0 && mutex_trylock(&f->filp_lock) == 0) { f->filp_mode = bits; - f->filp_pos = cvu64(0); + f->filp_pos = ((u64_t)(0)); f->filp_selectors = 0; f->filp_select_ops = 0; f->filp_pipe_select_ops = 0; diff --git a/servers/vfs/open.c b/servers/vfs/open.c index 9e6f2ec67..ceadcaf61 100644 --- a/servers/vfs/open.c +++ b/servers/vfs/open.c @@ -608,16 +608,16 @@ int actual_lseek(message *m_out, int seekfd, int seekwhence, off_t offset) /* The value of 'whence' determines the start position to use. */ switch(seekwhence) { - case SEEK_SET: pos = cvu64(0); break; + case SEEK_SET: pos = ((u64_t)(0)); break; case SEEK_CUR: pos = rfilp->filp_pos; break; - case SEEK_END: pos = cvul64(rfilp->filp_vno->v_size); break; + case SEEK_END: pos = ((u64_t)(rfilp->filp_vno->v_size)); break; default: unlock_filp(rfilp); return(EINVAL); } if (offset >= 0) - newpos = add64ul(pos, offset); + newpos = ((u64_t)(pos) + (offset)); else - newpos = sub64ul(pos, -offset); + newpos = ((u64_t)(pos) - (-offset)); /* Check for overflow. */ if (ex64hi(newpos) != 0) { @@ -675,9 +675,9 @@ int actual_llseek(struct fproc *rfp, message *m_out, int seekfd, int seekwhence, /* The value of 'whence' determines the start position to use. */ switch(seekwhence) { - case SEEK_SET: pos = cvu64(0); break; + case SEEK_SET: pos = ((u64_t)(0)); break; case SEEK_CUR: pos = rfilp->filp_pos; break; - case SEEK_END: pos = cvul64(rfilp->filp_vno->v_size); break; + case SEEK_END: pos = ((u64_t)(rfilp->filp_vno->v_size)); break; default: unlock_filp(rfilp); return(EINVAL); } diff --git a/servers/vfs/read.c b/servers/vfs/read.c index 57bf38615..dfdcb2ff3 100644 --- a/servers/vfs/read.c +++ b/servers/vfs/read.c @@ -181,7 +181,7 @@ int read_write(struct fproc *rfp, int rw_flag, struct filp *f, suspend_reopen); if (r >= 0) { cum_io = r; - position = add64ul(position, r); + position = ((u64_t)(position) + (r)); r = OK; } } else if (S_ISBLK(vp->v_mode)) { /* Block special files. */ @@ -205,7 +205,7 @@ int read_write(struct fproc *rfp, int rw_flag, struct filp *f, } else { /* Regular files */ if (rw_flag == WRITING) { /* Check for O_APPEND flag. */ - if (f->filp_flags & O_APPEND) position = cvul64(vp->v_size); + if (f->filp_flags & O_APPEND) position = ((u64_t)(vp->v_size)); } /* Issue request */ @@ -315,7 +315,7 @@ size_t req_size; oflags = f->filp_flags; vp = f->filp_vno; - position = cvu64(0); /* Not actually used */ + position = ((u64_t)(0)); /* Not actually used */ assert(rw_flag == READING || rw_flag == WRITING); diff --git a/servers/vfs/request.c b/servers/vfs/request.c index d1cd0b02e..71ea86ae2 100644 --- a/servers/vfs/request.c +++ b/servers/vfs/request.c @@ -330,7 +330,7 @@ int req_getdents( cpf_revoke(grant_id); if (r == OK) { - *new_pos = cvul64(m.RES_SEEK_POS_LO); + *new_pos = ((u64_t)(m.RES_SEEK_POS_LO)); r = m.RES_NBYTES; } @@ -808,7 +808,7 @@ unsigned int *cum_iop; if (r == OK) { /* Fill in response structure */ - *new_posp = cvul64(m.RES_SEEK_POS_LO); + *new_posp = ((u64_t)(m.RES_SEEK_POS_LO)); *cum_iop = m.RES_NBYTES; } diff --git a/servers/vfs/select.c b/servers/vfs/select.c index 191b01ffc..53f183bf9 100644 --- a/servers/vfs/select.c +++ b/servers/vfs/select.c @@ -383,7 +383,7 @@ static int select_request_async(struct filp *f, int *ops, int block) f->filp_select_flags &= ~FSF_UPDATE; r = dev_io(VFS_DEV_SELECT, f->filp_vno->v_sdev, rops, NULL, - cvu64(0), 0, 0, FALSE); + ((u64_t)(0)), 0, 0, FALSE); if (r < 0 && r != SUSPEND) return(r); @@ -435,7 +435,7 @@ static int select_request_sync(struct filp *f, int *ops, int block) rops = *ops; if (block) rops |= SEL_NOTIFY; *ops = dev_io(VFS_DEV_SELECT, f->filp_vno->v_sdev, rops, NULL, - cvu64(0), 0, 0, FALSE); + ((u64_t)(0)), 0, 0, FALSE); if (*ops < 0) return(*ops); diff --git a/test/blocktest/blocktest.c b/test/blocktest/blocktest.c index 9804a1c17..24b5dde3f 100644 --- a/test/blocktest/blocktest.c +++ b/test/blocktest/blocktest.c @@ -532,7 +532,7 @@ static void bad_read2(void) buf2_sum = fill_rand(buf2_ptr, buf2_size); buf3_sum = fill_rand(buf3_ptr, buf3_size); - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, buf_size + buf2_size + buf3_size, &res); test_sum(buf_ptr, buf_size, buf_sum, FALSE, &res); @@ -549,7 +549,7 @@ static void bad_read2(void) buf2_sum = fill_rand(buf2_ptr, buf2_size); buf3_sum = fill_rand(buf3_ptr, buf3_size); - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, EINVAL, &res); + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, EINVAL, &res); test_sum(buf_ptr, buf_size, buf_sum, TRUE, &res); test_sum(buf2_ptr, buf2_size, buf2_sum, TRUE, &res); @@ -561,7 +561,7 @@ static void bad_read2(void) memcpy(iov, iovt, sizeof(iovt)); iov[1].iov_size = (vir_bytes) LONG_MAX + 1; - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, EINVAL, &res); + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, EINVAL, &res); test_sum(buf_ptr, buf_size, buf_sum, TRUE, &res); test_sum(buf2_ptr, buf2_size, buf2_sum, TRUE, &res); @@ -574,7 +574,7 @@ static void bad_read2(void) iov[0].iov_size = LONG_MAX / 2 - 1; iov[1].iov_size = LONG_MAX / 2 - 1; - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, EINVAL, &res); + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, EINVAL, &res); test_sum(buf_ptr, buf_size, buf_sum, TRUE, &res); test_sum(buf2_ptr, buf2_size, buf2_sum, TRUE, &res); @@ -587,7 +587,7 @@ static void bad_read2(void) iov[0].iov_size = LONG_MAX - 1; iov[1].iov_size = LONG_MAX - 1; - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, EINVAL, &res); + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, EINVAL, &res); test_sum(buf_ptr, buf_size, buf_sum, TRUE, &res); test_sum(buf2_ptr, buf2_size, buf2_sum, TRUE, &res); @@ -604,7 +604,7 @@ static void bad_read2(void) buf3_sum = fill_rand(buf3_ptr, buf3_size); c1 = buf2_ptr[buf2_size - 1]; - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, BUF_SIZE * 3 - 1, + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, BUF_SIZE * 3 - 1, &res); if (accept_result(&res, RESULT_BADSTATUS, EINVAL)) { @@ -631,7 +631,7 @@ static void bad_read2(void) buf2_sum = fill_rand(buf2_ptr, buf2_size); buf3_sum = fill_rand(buf3_ptr, buf3_size); - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, EINVAL, &res); + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, EINVAL, &res); /* Do not test the first buffer, as it may contain a partial result. */ test_sum(buf2_ptr, buf2_size, buf2_sum, TRUE, &res); @@ -653,7 +653,7 @@ static void bad_read2(void) buf2_sum = fill_rand(buf2_ptr, buf2_size); buf3_sum = fill_rand(buf3_ptr, buf3_size); - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, EINVAL, &res); + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, EINVAL, &res); accept_result(&res, RESULT_BADSTATUS, EPERM); @@ -675,7 +675,7 @@ static void bad_read2(void) buf2_sum = fill_rand(buf2_ptr, buf2_size); buf3_sum = fill_rand(buf3_ptr, buf3_size); - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, EINVAL, &res); + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, EINVAL, &res); accept_result(&res, RESULT_BADSTATUS, EPERM); @@ -702,7 +702,7 @@ static void bad_read2(void) c1 = buf2_ptr[0]; c2 = buf2_ptr[buf2_size - 1]; - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, BUF_SIZE * 3 - 2, + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, BUF_SIZE * 3 - 2, &res); if (accept_result(&res, RESULT_BADSTATUS, EINVAL)) { @@ -730,7 +730,7 @@ static void bad_read2(void) buf2_sum = fill_rand(buf2_ptr, buf2_size); buf3_sum = fill_rand(buf3_ptr, buf3_size); - raw_xfer(driver_minor, cvu64(1), iov, 3, FALSE, EINVAL, &res); + raw_xfer(driver_minor, ((u64_t)(1)), iov, 3, FALSE, EINVAL, &res); test_sum(buf_ptr, buf_size, buf_sum, TRUE, &res); test_sum(buf2_ptr, buf2_size, buf2_sum, TRUE, &res); @@ -745,7 +745,7 @@ static void bad_read2(void) buf2_sum = fill_rand(buf2_ptr, buf2_size); buf3_sum = fill_rand(buf3_ptr, buf3_size); - raw_xfer(driver_minor, cvu64(0), iov, 3, FALSE, + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, FALSE, buf_size + buf2_size + buf3_size, &res); test_sum(buf_ptr, buf_size, buf_sum, FALSE, &res); @@ -801,7 +801,7 @@ static void bad_write(void) buf2_sum = fill_rand(buf2_ptr, buf2_size); buf3_sum = fill_rand(buf3_ptr, buf3_size); - raw_xfer(driver_minor, cvu64(SECTOR_UNALIGN), iov, 3, TRUE, EINVAL, + raw_xfer(driver_minor, ((u64_t)(SECTOR_UNALIGN)), iov, 3, TRUE, EINVAL, &res); test_sum(buf_ptr, buf_size, buf_sum, TRUE, &res); @@ -818,7 +818,7 @@ static void bad_write(void) buf2_sum = fill_rand(buf2_ptr, buf2_size); buf3_sum = fill_rand(buf3_ptr, buf3_size); - raw_xfer(driver_minor, cvu64(0), iov, 3, TRUE, EINVAL, &res); + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, TRUE, EINVAL, &res); test_sum(buf_ptr, buf_size, buf_sum, TRUE, &res); test_sum(buf2_ptr, buf2_size, buf2_sum, TRUE, &res); @@ -838,7 +838,7 @@ static void bad_write(void) buf2_sum = fill_rand(buf2_ptr, buf2_size); buf3_sum = fill_rand(buf3_ptr, buf3_size); - raw_xfer(driver_minor, cvu64(0), iov, 3, TRUE, EINVAL, &res); + raw_xfer(driver_minor, ((u64_t)(0)), iov, 3, TRUE, EINVAL, &res); accept_result(&res, RESULT_BADSTATUS, EPERM); @@ -868,7 +868,7 @@ static void vector_and_large_sub(size_t small_size) result_t res; int i; - base_pos = cvu64(sector_size); + base_pos = ((u64_t)(sector_size)); large_size = small_size * NR_IOREQS; @@ -1185,7 +1185,7 @@ static void read_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) /* Read one sector up to the partition limit. */ fill_rand(buf_ptr, buf_size); - simple_xfer(sub0_minor, cvu64(sub_size - sector_size), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size - sector_size)), buf_ptr, sector_size, FALSE, sector_size, &res); sum = get_sum(buf_ptr, sector_size); @@ -1195,7 +1195,7 @@ static void read_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) /* Read three sectors up to the partition limit. */ fill_rand(buf_ptr, buf_size); - simple_xfer(sub0_minor, cvu64(sub_size - buf_size), buf_ptr, buf_size, + simple_xfer(sub0_minor, ((u64_t)(sub_size - buf_size)), buf_ptr, buf_size, FALSE, buf_size, &res); test_sum(buf_ptr + sector_size * 2, sector_size, sum, TRUE, &res); @@ -1208,7 +1208,7 @@ static void read_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) fill_rand(buf_ptr, buf_size); sum3 = get_sum(buf_ptr + sector_size * 2, sector_size); - simple_xfer(sub0_minor, cvu64(sub_size - sector_size * 2), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size - sector_size * 2)), buf_ptr, buf_size, FALSE, sector_size * 2, &res); test_sum(buf_ptr, sector_size * 2, sum2, TRUE, &res); @@ -1220,7 +1220,7 @@ static void read_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) fill_rand(buf_ptr, buf_size); sum2 = get_sum(buf_ptr + sector_size, sector_size * 2); - simple_xfer(sub0_minor, cvu64(sub_size - sector_size), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size - sector_size)), buf_ptr, buf_size, FALSE, sector_size, &res); test_sum(buf_ptr, sector_size, sum, TRUE, &res); @@ -1232,7 +1232,7 @@ static void read_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) sum = fill_rand(buf_ptr, buf_size); sum2 = get_sum(buf_ptr, sector_size); - simple_xfer(sub0_minor, cvu64(sub_size), buf_ptr, sector_size, FALSE, + simple_xfer(sub0_minor, ((u64_t)(sub_size)), buf_ptr, sector_size, FALSE, 0, &res); test_sum(buf_ptr, sector_size, sum2, TRUE, &res); @@ -1240,7 +1240,7 @@ static void read_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) got_result(&res, "one sector read at partition end"); /* Read three sectors starting at the partition end. */ - simple_xfer(sub0_minor, cvu64(sub_size), buf_ptr, buf_size, FALSE, 0, + simple_xfer(sub0_minor, ((u64_t)(sub_size)), buf_ptr, buf_size, FALSE, 0, &res); test_sum(buf_ptr, buf_size, sum, TRUE, &res); @@ -1248,7 +1248,7 @@ static void read_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) got_result(&res, "multisector read at partition end"); /* Read one sector beyond the partition end. */ - simple_xfer(sub0_minor, cvu64(sub_size + sector_size), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size + sector_size)), buf_ptr, buf_size, FALSE, 0, &res); test_sum(buf_ptr, sector_size, sum2, TRUE, &res); @@ -1307,7 +1307,7 @@ static void write_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) */ sub1_sum = fill_rand(buf_ptr, buf_size); - simple_xfer(sub1_minor, cvu64(0), buf_ptr, buf_size, TRUE, buf_size, + simple_xfer(sub1_minor, ((u64_t)(0)), buf_ptr, buf_size, TRUE, buf_size, &res); got_result(&res, "write to second subpartition"); @@ -1315,7 +1315,7 @@ static void write_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) /* Write one sector, up to the partition limit. */ sum = fill_rand(buf_ptr, sector_size); - simple_xfer(sub0_minor, cvu64(sub_size - sector_size), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size - sector_size)), buf_ptr, sector_size, TRUE, sector_size, &res); got_result(&res, "write up to partition end"); @@ -1323,7 +1323,7 @@ static void write_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) /* Read back to make sure the results have persisted. */ fill_rand(buf_ptr, sector_size * 2); - simple_xfer(sub0_minor, cvu64(sub_size - sector_size * 2), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size - sector_size * 2)), buf_ptr, sector_size * 2, FALSE, sector_size * 2, &res); test_sum(buf_ptr + sector_size, sector_size, sum, TRUE, &res); @@ -1335,7 +1335,7 @@ static void write_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) sum = get_sum(buf_ptr + sector_size, sector_size); sum3 = get_sum(buf_ptr, sector_size); - simple_xfer(sub0_minor, cvu64(sub_size - sector_size * 2), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size - sector_size * 2)), buf_ptr, buf_size, TRUE, sector_size * 2, &res); got_result(&res, "write somewhat across partition end"); @@ -1344,7 +1344,7 @@ static void write_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) fill_rand(buf_ptr, buf_size); sum2 = get_sum(buf_ptr + sector_size, sector_size * 2); - simple_xfer(sub0_minor, cvu64(sub_size - sector_size), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size - sector_size)), buf_ptr, buf_size, FALSE, sector_size, &res); test_sum(buf_ptr, sector_size, sum, TRUE, &res); @@ -1356,7 +1356,7 @@ static void write_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) fill_rand(buf_ptr, buf_size); sum = get_sum(buf_ptr, sector_size); - simple_xfer(sub0_minor, cvu64(sub_size - sector_size), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size - sector_size)), buf_ptr, buf_size, TRUE, sector_size, &res); got_result(&res, "write mostly across partition end"); @@ -1364,7 +1364,7 @@ static void write_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) fill_rand(buf_ptr, buf_size); sum2 = get_sum(buf_ptr + sector_size * 2, sector_size); - simple_xfer(sub0_minor, cvu64(sub_size - sector_size * 2), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size - sector_size * 2)), buf_ptr, buf_size, FALSE, sector_size * 2, &res); test_sum(buf_ptr, sector_size, sum3, TRUE, &res); @@ -1376,13 +1376,13 @@ static void write_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) /* Write one sector at the end of the partition. */ fill_rand(buf_ptr, sector_size); - simple_xfer(sub0_minor, cvu64(sub_size), buf_ptr, sector_size, TRUE, 0, + simple_xfer(sub0_minor, ((u64_t)(sub_size)), buf_ptr, sector_size, TRUE, 0, &res); got_result(&res, "write at partition end"); /* Write one sector beyond the end of the partition. */ - simple_xfer(sub0_minor, cvu64(sub_size + sector_size), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size + sector_size)), buf_ptr, sector_size, TRUE, 0, &res); got_result(&res, "write beyond partition end"); @@ -1392,7 +1392,7 @@ static void write_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) */ fill_rand(buf_ptr, buf_size); - simple_xfer(sub1_minor, cvu64(0), buf_ptr, buf_size, FALSE, buf_size, + simple_xfer(sub1_minor, ((u64_t)(0)), buf_ptr, buf_size, FALSE, buf_size, &res); test_sum(buf_ptr, buf_size, sub1_sum, TRUE, &res); @@ -1410,7 +1410,7 @@ static void write_limits(dev_t sub0_minor, dev_t sub1_minor, size_t sub_size) /* If the last request erroneously succeeded, it would have overwritten * the last sector of the first subpartition. */ - simple_xfer(sub0_minor, cvu64(sub_size - sector_size), buf_ptr, + simple_xfer(sub0_minor, ((u64_t)(sub_size - sector_size)), buf_ptr, sector_size, FALSE, sector_size, &res); test_sum(buf_ptr, sector_size, sum, TRUE, &res); @@ -1443,7 +1443,7 @@ static void vir_limits(dev_t sub0_minor, dev_t sub1_minor, int part_secs) /* Set, and check, the size of the first subpartition. */ subpart = part; - subpart.size = cvu64(sub_size); + subpart.size = ((u64_t)(sub_size)); vir_ioctl(sub0_minor, DIOCSETP, &subpart, OK, &res); @@ -1461,8 +1461,8 @@ static void vir_limits(dev_t sub0_minor, dev_t sub1_minor, int part_secs) /* Set, and check, the base and size of the second subpartition. */ subpart = part; - subpart.base = add64u(subpart.base, sub_size); - subpart.size = cvu64(sub_size); + subpart.base = ((u64_t)(subpart.base) + (sub_size)); + subpart.size = ((u64_t)(sub_size)); vir_ioctl(sub1_minor, DIOCSETP, &subpart, OK, &res); @@ -1520,7 +1520,7 @@ static void real_limits(dev_t sub0_minor, dev_t sub1_minor, int part_secs) memset(buf_ptr, 0, buf_size); /* Write an invalid partition table. */ - simple_xfer(driver_minor, cvu64(0), buf_ptr, buf_size, TRUE, buf_size, + simple_xfer(driver_minor, ((u64_t)(0)), buf_ptr, buf_size, TRUE, buf_size, &res); got_result(&res, "write of invalid partition table"); @@ -1567,7 +1567,7 @@ static void real_limits(dev_t sub0_minor, dev_t sub1_minor, int part_secs) entry = (struct part_entry *) &buf_ptr[PART_TABLE_OFF]; entry[0].sysind = MINIX_PART; - entry[0].lowsec = div64u(part.base, sector_size) + 1; + entry[0].lowsec = ((u64_t)(part.base) / (unsigned)(sector_size)) + 1; entry[0].size = part_secs; entry[1].sysind = MINIX_PART; entry[1].lowsec = entry[0].lowsec + entry[0].size; @@ -1576,7 +1576,7 @@ static void real_limits(dev_t sub0_minor, dev_t sub1_minor, int part_secs) buf_ptr[510] = 0x55; buf_ptr[511] = 0xAA; - simple_xfer(driver_minor, cvu64(0), buf_ptr, buf_size, TRUE, buf_size, + simple_xfer(driver_minor, ((u64_t)(0)), buf_ptr, buf_size, TRUE, buf_size, &res); got_result(&res, "write of valid partition table"); @@ -1594,7 +1594,7 @@ static void real_limits(dev_t sub0_minor, dev_t sub1_minor, int part_secs) vir_ioctl(sub0_minor, DIOCGETP, &subpart, 0, &res); if (res.type == RESULT_OK && (cmp64(subpart.base, - add64u(part.base, sector_size)) || + ((u64_t)(part.base) + (sector_size))) || cmp64u(subpart.size, part_secs * sector_size))) { res.type = RESULT_BADVALUE; @@ -1606,7 +1606,7 @@ static void real_limits(dev_t sub0_minor, dev_t sub1_minor, int part_secs) vir_ioctl(sub1_minor, DIOCGETP, &subpart, 0, &res); if (res.type == RESULT_OK && (cmp64(subpart.base, - add64u(part.base, (1 + part_secs) * sector_size)) || + ((u64_t)(part.base) + ((1 + part_secs) * sector_size))) || cmp64u(subpart.size, part_secs * sector_size))) { res.type = RESULT_BADVALUE; @@ -1678,7 +1678,7 @@ static void unaligned_size_io(u64_t base_pos, u8_t *buf_ptr, size_t buf_size, size_t total_size; int i, nr_req; - base_pos = add64u(base_pos, sector_size); + base_pos = ((u64_t)(base_pos) + (sector_size)); total_size = sector_size * sectors; /* If the limit is two elements per sector, we cannot test three @@ -1859,7 +1859,7 @@ static void unaligned_size(void) */ buf_size = sector_size * 5; - base_pos = cvu64(sector_size * 2); + base_pos = ((u64_t)(sector_size * 2)); if ((buf_ptr = alloc_contig(buf_size, 0, NULL)) == NULL) panic("unable to allocate memory"); @@ -1964,7 +1964,7 @@ static void unaligned_pos1(void) */ buf_size = buf2_size = sector_size * 3; - base_pos = cvu64(sector_size * 3); + base_pos = ((u64_t)(sector_size * 3)); if ((buf_ptr = alloc_contig(buf_size, 0, NULL)) == NULL) panic("unable to allocate memory"); @@ -1997,7 +1997,7 @@ static void unaligned_pos1(void) fill_rand(buf2_ptr, sector_size); sum = get_sum(buf2_ptr + min_read, sector_size - min_read); - simple_xfer(driver_minor, add64u(base_pos, sector_size - min_read), + simple_xfer(driver_minor, ((u64_t)(base_pos) + (sector_size - min_read)), buf2_ptr, min_read, FALSE, min_read, &res); test_sum(buf2_ptr, min_read, get_sum(buf_ptr + sector_size - min_read, @@ -2027,7 +2027,7 @@ static void unaligned_pos1(void) sum = get_sum(buf2_ptr, min_read); sum2 = get_sum(buf2_ptr + min_read * 2, sector_size - min_read * 2); - simple_xfer(driver_minor, add64u(base_pos, min_read), + simple_xfer(driver_minor, ((u64_t)(base_pos) + (min_read)), buf2_ptr + min_read, min_read, FALSE, min_read, &res); test_sum(buf2_ptr + min_read, min_read, get_sum(buf_ptr + min_read, @@ -2046,7 +2046,7 @@ static void unaligned_pos1(void) fill_rand(buf2_ptr, buf2_size); sum = get_sum(buf2_ptr + size, buf2_size - size); - simple_xfer(driver_minor, add64u(base_pos, sector_size - min_read), + simple_xfer(driver_minor, ((u64_t)(base_pos) + (sector_size - min_read)), buf2_ptr, size, FALSE, size, &res); test_sum(buf2_ptr, size, get_sum(buf_ptr + sector_size - min_read, @@ -2072,7 +2072,7 @@ static void unaligned_pos1(void) fill_rand(buf2_ptr, buf2_size); sum = get_sum(buf2_ptr + sector_size, buf2_size - sector_size); - simple_xfer(driver_minor, add64u(base_pos, min_read), buf2_ptr, + simple_xfer(driver_minor, ((u64_t)(base_pos) + (min_read)), buf2_ptr, sector_size, FALSE, sector_size, &res); test_sum(buf2_ptr, sector_size, get_sum(buf_ptr + min_read, @@ -2112,7 +2112,7 @@ static void unaligned_pos2(void) buf_size = buf2_size = max_size + sector_size; - base_pos = cvu64(sector_size * 3); + base_pos = ((u64_t)(sector_size * 3)); if ((buf_ptr = alloc_contig(buf_size, 0, NULL)) == NULL) panic("unable to allocate memory"); @@ -2133,7 +2133,7 @@ static void unaligned_pos2(void) sum2 = fill_rand(buf_ptr + max_size, sector_size); - simple_xfer(driver_minor, add64u(base_pos, max_size), + simple_xfer(driver_minor, ((u64_t)(base_pos) + (max_size)), buf_ptr + max_size, sector_size, TRUE, sector_size, &res); @@ -2150,7 +2150,7 @@ static void unaligned_pos2(void) got_result(&res, "large baseline read"); - simple_xfer(driver_minor, add64u(base_pos, max_size), buf_ptr + + simple_xfer(driver_minor, ((u64_t)(base_pos) + (max_size)), buf_ptr + max_size, sector_size, FALSE, sector_size, &res); if (may_write) @@ -2171,7 +2171,7 @@ static void unaligned_pos2(void) sector_size - min_read); } - vir_xfer(driver_minor, add64u(base_pos, min_read), iov, NR_IOREQS, + vir_xfer(driver_minor, ((u64_t)(base_pos) + (min_read)), iov, NR_IOREQS, FALSE, min_read * NR_IOREQS, &res); for (i = 0; i < NR_IOREQS; i++) { @@ -2193,7 +2193,7 @@ static void unaligned_pos2(void) */ fill_rand(buf2_ptr, buf2_size); - simple_xfer(driver_minor, add64u(base_pos, min_read), buf2_ptr, + simple_xfer(driver_minor, ((u64_t)(base_pos) + (min_read)), buf2_ptr, max_size, FALSE, max_size, &res); test_sum(buf2_ptr, max_size, get_sum(buf_ptr + min_read, max_size), @@ -2218,7 +2218,7 @@ static void unaligned_pos2(void) iov[i].iov_size = max_block; } - vir_xfer(driver_minor, add64u(base_pos, min_read), iov, NR_IOREQS, + vir_xfer(driver_minor, ((u64_t)(base_pos) + (min_read)), iov, NR_IOREQS, FALSE, max_block * NR_IOREQS, &res); test_sum(buf2_ptr, max_block * NR_IOREQS, get_sum(buf_ptr + min_read, @@ -2280,7 +2280,7 @@ static void sweep_area(u64_t base_pos) for (i = 0; i < 6; i++) { fill_rand(buf_ptr, sector_size * 3); - simple_xfer(driver_minor, add64u(base_pos, sector_size * i), + simple_xfer(driver_minor, ((u64_t)(base_pos) + (sector_size * i)), buf_ptr, sector_size * 3, FALSE, sector_size * 3, &res); @@ -2295,7 +2295,7 @@ static void sweep_area(u64_t base_pos) fill_rand(buf_ptr, sector_size * 3); - simple_xfer(driver_minor, add64u(base_pos, sector_size * i), + simple_xfer(driver_minor, ((u64_t)(base_pos) + (sector_size * i)), buf_ptr, sector_size * 3, TRUE, sector_size * 3, &res); for (j = 0; j < 3; j++) @@ -2344,7 +2344,7 @@ static void sweep_and_check(u64_t pos, int check_integ) if (may_write) { sum = fill_rand(buf_ptr, buf_size); - simple_xfer(driver_minor, cvu64(0), buf_ptr, buf_size, + simple_xfer(driver_minor, ((u64_t)(0)), buf_ptr, buf_size, TRUE, buf_size, &res); got_result(&res, "write integrity zone"); @@ -2352,7 +2352,7 @@ static void sweep_and_check(u64_t pos, int check_integ) fill_rand(buf_ptr, buf_size); - simple_xfer(driver_minor, cvu64(0), buf_ptr, buf_size, FALSE, + simple_xfer(driver_minor, ((u64_t)(0)), buf_ptr, buf_size, FALSE, buf_size, &res); if (may_write) @@ -2368,7 +2368,7 @@ static void sweep_and_check(u64_t pos, int check_integ) if (check_integ) { fill_rand(buf_ptr, buf_size); - simple_xfer(driver_minor, cvu64(0), buf_ptr, buf_size, FALSE, + simple_xfer(driver_minor, ((u64_t)(0)), buf_ptr, buf_size, FALSE, buf_size, &res); test_sum(buf_ptr, buf_size, sum, TRUE, &res); @@ -2386,7 +2386,7 @@ static void basic_sweep(void) test_group("basic area sweep", TRUE); - sweep_area(cvu64(sector_size)); + sweep_area(((u64_t)(sector_size))); } static void high_disk_pos(void) @@ -2402,16 +2402,16 @@ static void high_disk_pos(void) u64_t base_pos; base_pos = make64(sector_size * 4, 1L); - base_pos = sub64u(base_pos, rem64u(base_pos, sector_size)); + base_pos = ((u64_t)(base_pos) - (((u64_t)(base_pos) % (unsigned)(sector_size)))); /* The partition end must exceed 32 bits. */ - if (cmp64(add64(part.base, part.size), base_pos) < 0) { + if (cmp64(((u64_t)(part.base) + (part.size)), base_pos) < 0) { test_group("high disk positions", FALSE); return; } - base_pos = sub64u(base_pos, sector_size * 8); + base_pos = ((u64_t)(base_pos) - (sector_size * 8)); /* The partition start must not. */ if (cmp64(base_pos, part.base) < 0) { @@ -2421,7 +2421,7 @@ static void high_disk_pos(void) test_group("high disk positions", TRUE); - base_pos = sub64(base_pos, part.base); + base_pos = ((u64_t)(base_pos) - (part.base)); sweep_and_check(base_pos, !cmp64u(part.base, 0)); } @@ -2444,7 +2444,7 @@ static void high_part_pos(void) } base_pos = make64(sector_size * 4, 1L); - base_pos = sub64u(base_pos, rem64u(base_pos, sector_size)); + base_pos = ((u64_t)(base_pos) - (((u64_t)(base_pos) % (unsigned)(sector_size)))); if (cmp64(part.size, base_pos) < 0) { test_group("high partition positions", FALSE); @@ -2454,7 +2454,7 @@ static void high_part_pos(void) test_group("high partition positions", TRUE); - base_pos = sub64u(base_pos, sector_size * 8); + base_pos = ((u64_t)(base_pos) - (sector_size * 8)); sweep_and_check(base_pos, TRUE); } @@ -2471,16 +2471,16 @@ static void high_lba_pos1(void) */ u64_t base_pos; - base_pos = mul64u(1L << 24, sector_size); + base_pos = ((u64_t)(1L << 24) * (sector_size)); /* The partition end must exceed the 24-bit sector point. */ - if (cmp64(add64(part.base, part.size), base_pos) < 0) { + if (cmp64(((u64_t)(part.base) + (part.size)), base_pos) < 0) { test_group("high LBA positions, part one", FALSE); return; } - base_pos = sub64u(base_pos, sector_size * 8); + base_pos = ((u64_t)(base_pos) - (sector_size * 8)); /* The partition start must not. */ if (cmp64(base_pos, part.base) < 0) { @@ -2491,7 +2491,7 @@ static void high_lba_pos1(void) test_group("high LBA positions, part one", TRUE); - base_pos = sub64(base_pos, part.base); + base_pos = ((u64_t)(base_pos) - (part.base)); sweep_and_check(base_pos, !cmp64u(part.base, 0)); } @@ -2505,16 +2505,16 @@ static void high_lba_pos2(void) */ u64_t base_pos; - base_pos = mul64u(1L << 28, sector_size); + base_pos = ((u64_t)(1L << 28) * (sector_size)); /* The partition end must exceed the 28-bit sector point. */ - if (cmp64(add64(part.base, part.size), base_pos) < 0) { + if (cmp64(((u64_t)(part.base) + (part.size)), base_pos) < 0) { test_group("high LBA positions, part two", FALSE); return; } - base_pos = sub64u(base_pos, sector_size * 8); + base_pos = ((u64_t)(base_pos) - (sector_size * 8)); /* The partition start must not. */ if (cmp64(base_pos, part.base) < 0) { @@ -2525,7 +2525,7 @@ static void high_lba_pos2(void) test_group("high LBA positions, part two", TRUE); - base_pos = sub64(base_pos, part.base); + base_pos = ((u64_t)(base_pos) - (part.base)); sweep_and_check(base_pos, !cmp64u(part.base, 0)); } diff --git a/test/test53.c b/test/test53.c index 6f946a688..be39905c1 100644 --- a/test/test53.c +++ b/test/test53.c @@ -114,7 +114,7 @@ static void testmul(void) { int kdone, kidx; u32_t ilo = ex64lo(i), jlo = ex64lo(j); - u64_t prod = mul64(i, j); + u64_t prod = ((u64_t)(i) * (j)); int prodbits; /* compute maximum index of highest-order bit */ @@ -124,7 +124,7 @@ static void testmul(void) /* compare to 32-bit multiplication if possible */ if (ex64hi(i) == 0 && ex64hi(j) == 0) { - if (cmp64(prod, mul64u(ilo, jlo)) != 0) ERR; + if (prod != (u64_t) ilo * jlo) ERR; /* if there is no overflow we can check against pure 32-bit */ if (prodbits < 32 && cmp64u(prod, ilo * jlo) != 0) ERR; @@ -140,16 +140,16 @@ static void testmul(void) if (prodbits >= 0 && prodbits < 64 && cmp64u(prod, 0) == 0) ERR; /* commutativity */ - if (cmp64(prod, mul64(j, i)) != 0) ERR; + if (prod != (u64_t) j * i) ERR; /* loop though all argument value combinations for third argument */ for (kdone = 0, kidx = 0; k = getargval(kidx, &kdone), !kdone; kidx++) { /* associativity */ - if (cmp64(mul64(mul64(i, j), k), mul64(i, mul64(j, k))) != 0) ERR; + if ((u64_t) (i * j) * k != (u64_t) i * (j * k)) ERR; /* left and right distributivity */ - if (cmp64(mul64(add64(i, j), k), add64(mul64(i, k), mul64(j, k))) != 0) ERR; - if (cmp64(mul64(i, add64(j, k)), add64(mul64(i, j), mul64(i, k))) != 0) ERR; + if (cmp64(((u64_t)(((u64_t)(i) + (j))) * (k)), ((u64_t)(((u64_t)(i) * (k))) + (((u64_t)(j) * (k))))) != 0) ERR; + if (cmp64(((u64_t)(i) * (((u64_t)(j) + (k)))), ((u64_t)(((u64_t)(i) * (j))) + (((u64_t)(i) * (k))))) != 0) ERR; } } @@ -165,11 +165,11 @@ static void testdiv0(void) if (setjmp(jmpbuf_SIGFPE) == 0) { /* divide by zero using various functions */ switch (funcidx) { - case 0: div64(i, j); ERR; break; - case 1: div64u64(i, ex64lo(j)); ERR; break; - case 2: div64u(i, ex64lo(j)); ERR; break; - case 3: rem64(i, j); ERR; break; - case 4: rem64u(i, ex64lo(j)); ERR; break; + case 0: ((u64_t)(i) / (unsigned)(j)); ERR; break; + case 1: ((u64_t)(i) / (unsigned)(ex64lo(j))); ERR; break; + case 2: ((u64_t)(i) / (unsigned)(ex64lo(j))); ERR; break; + case 3: ((u64_t)(i) % (j)); ERR; break; + case 4: ((u64_t)(i) % (unsigned)(ex64lo(j))); ERR; break; default: assert(0); ERR; break; } @@ -206,8 +206,8 @@ static void testdiv(void) } /* perform division, store q in k to make ERR more informative */ - q = div64(i, j); - r = rem64(i, j); + q = ((u64_t)(i) / (unsigned)(j)); + r = ((u64_t)(i) % (j)); k = q; #if TIMED @@ -227,11 +227,11 @@ static void testdiv(void) /* compare to 64/32-bit division if possible */ if (!ex64hi(j)) { - if (cmp64(q, div64u64(i, ex64lo(j))) != 0) ERR; + if (cmp64(q, ((u64_t)(i) / (unsigned)(ex64lo(j)))) != 0) ERR; if (!ex64hi(q)) { - if (cmp64u(q, div64u(i, ex64lo(j))) != 0) ERR; + if (cmp64u(q, ((u64_t)(i) / (unsigned)(ex64lo(j)))) != 0) ERR; } - if (cmp64u(r, rem64u(i, ex64lo(j))) != 0) ERR; + if (cmp64u(r, ((u64_t)(i) % (unsigned)(ex64lo(j)))) != 0) ERR; /* compare to 32-bit division if possible */ if (!ex64hi(i)) { @@ -241,7 +241,7 @@ static void testdiv(void) } /* check results using i = q j + r and r < j */ - if (cmp64(i, add64(mul64(q, j), r)) != 0) ERR; + if (cmp64(i, ((u64_t)(((u64_t)(q) * (j))) + (r))) != 0) ERR; if (cmp64(r, j) >= 0) ERR; } diff --git a/usr.sbin/mkfs.mfs/mkfs.c b/usr.sbin/mkfs.mfs/mkfs.c index 1806b8007..81672a4cd 100644 --- a/usr.sbin/mkfs.mfs/mkfs.c +++ b/usr.sbin/mkfs.mfs/mkfs.c @@ -13,12 +13,15 @@ #if defined(__minix) #include #include -#include #include #elif defined(__linux__) #include #endif +#ifndef __minix +typedef unsigned long long u64_t; +#endif + #include #include #include @@ -371,7 +374,7 @@ main(int argc, char *argv[]) testb = alloc_block(); /* Try writing the last block of partition or diskette. */ - if(lseek64(fd, mul64u(blocks - 1, block_size), SEEK_SET, NULL) < 0) { + if(lseek64(fd, ((u64_t)(blocks - 1) * (block_size)), SEEK_SET, NULL) < 0) { err(1, "couldn't seek to last block to test size (1)"); } testb[0] = 0x3245; @@ -381,7 +384,7 @@ main(int argc, char *argv[]) err(1, "File system is too big for minor device (write1 %d/%u)", w, block_size); sync(); /* flush write, so if error next read fails */ - if(lseek64(fd, mul64u(blocks - 1, block_size), SEEK_SET, NULL) < 0) { + if(lseek64(fd, ((u64_t)(blocks - 1) * (block_size)), SEEK_SET, NULL) < 0) { err(1, "couldn't seek to last block to test size (2)"); } testb[0] = 0; @@ -395,7 +398,7 @@ main(int argc, char *argv[]) testb[0], testb[1], testb[block_size-1]); errx(1, "File system is too big for minor device (read)"); } - lseek64(fd, mul64u(blocks - 1, block_size), SEEK_SET, NULL); + lseek64(fd, ((u64_t)(blocks - 1) * (block_size)), SEEK_SET, NULL); testb[0] = 0; testb[1] = 0; testb[block_size/2-1] = 0; @@ -550,10 +553,10 @@ sizeup(char * device) return 0; } - d = div64u(bytes, block_size); - rem = rem64u(bytes, block_size); + d = ((u64_t)(bytes) / (unsigned)(block_size)); + rem = ((u64_t)(bytes) % (unsigned)(block_size)); - resize = add64u(mul64u(d, block_size), rem); + resize = ((u64_t)(((u64_t)(d) * (block_size))) + (rem)); if(cmp64(resize, bytes) != 0) { /* Assume block_t is unsigned */ d = (block_t)(-1ul); @@ -1570,7 +1573,7 @@ get_block(block_t n, void *buf) memcpy(buf, zero, block_size); return; } - if (lseek64(fd, mul64u(n, block_size), SEEK_SET, NULL) == (off_t)(-1)) + if (lseek64(fd, ((u64_t)(n) * (block_size)), SEEK_SET, NULL) == (off_t)(-1)) pexit("get_block couldn't seek"); k = read(fd, buf, block_size); if (k != block_size) @@ -1597,7 +1600,7 @@ put_block(block_t n, void *buf) (void) read_and_set(n); - if (lseek64(fd, mul64u(n, block_size), SEEK_SET, NULL) == (off_t) -1) + if (lseek64(fd, ((u64_t)(n) * (block_size)), SEEK_SET, NULL) == (off_t) -1) pexit("put_block couldn't seek"); if (write(fd, buf, block_size)!= block_size) pexit("put_block couldn't write block #%u", (unsigned)n);