32b/64b compatibility fixes
authorAndrew Waterman <waterman@s141.Millennium.Berkeley.EDU>
Mon, 23 May 2011 09:18:40 +0000 (02:18 -0700)
committerKevin Klues <klueska@cs.berkeley.edu>
Thu, 3 Nov 2011 00:36:02 +0000 (17:36 -0700)
In a few places, types like int or uint32_t were used when the intent
was to use a type as wide as a machine register or a pointer.
I replaced these mostly with uintptr_t.

18 files changed:
kern/arch/i686/boot/boot [new symlink]
kern/arch/i686/process.c
kern/arch/i686/riscv [new symlink]
kern/arch/sparc/arch.h
kern/arch/sparc/process.c
kern/include/env.h
kern/include/kmalloc.h
kern/include/process.h
kern/include/ros/bcq_struct.h
kern/include/ros/common.h
kern/include/vfs.h
kern/src/blockdev.c
kern/src/ext2fs.c
kern/src/frontend.c
kern/src/monitor.c
kern/src/syscall.c
kern/src/testing.c
kern/src/vfs.c

diff --git a/kern/arch/i686/boot/boot b/kern/arch/i686/boot/boot
new file mode 120000 (symlink)
index 0000000..4ff7493
--- /dev/null
@@ -0,0 +1 @@
+arch/riscv/boot
\ No newline at end of file
index ddae33d..fb80a28 100644 (file)
@@ -9,7 +9,7 @@
 #include <stdio.h>
 
 void proc_init_trapframe(trapframe_t *tf, uint32_t vcoreid,
-                         uint32_t entryp, uint32_t stack_top)
+                         uintptr_t entryp, uintptr_t stack_top)
 {
        memset(tf,0,sizeof(*tf));
 
diff --git a/kern/arch/i686/riscv b/kern/arch/i686/riscv
new file mode 120000 (symlink)
index 0000000..520b30f
--- /dev/null
@@ -0,0 +1 @@
+../arch/riscv
\ No newline at end of file
index c68634b..ff62f35 100644 (file)
@@ -175,7 +175,7 @@ cache_flush(void)
 static __inline void
 reboot(void)
 {
-       extern void appserver_die(int code);
+       extern void appserver_die(uintptr_t code);
        appserver_die(0);
        while(1);
 }
index b70ffda..452957b 100644 (file)
@@ -15,7 +15,7 @@
 
 void
 proc_init_trapframe(trapframe_t *tf, uint32_t vcoreid,
-                    uint32_t entryp, uint32_t stack_top)
+                    uintptr_t entryp, uintptr_t stack_top)
 {
        memset(tf,0,sizeof(*tf));
 
index 9510853..45f2259 100644 (file)
@@ -33,7 +33,7 @@ struct proc {
        uint32_t state;                         // Status of the process
        struct kref p_kref;             /* Refcnt */
        uint32_t env_flags;
-       uint32_t env_entry;
+       uintptr_t env_entry;
 
        /* Cache color map: bitmap of the cache colors currently allocated to this
         * process */
index 3437be4..f3bea8d 100644 (file)
@@ -32,11 +32,11 @@ void  (DFREE(addr) kfree)(void *addr);
 
 struct kmalloc_tag {
        int flags;
+       uint32_t canary;
        union {
                struct kmem_cache *my_cache WHEN(flags == KMALLOC_TAG_CACHE);
                size_t num_pages WHEN(flags == KMALLOC_TAG_PAGES);
        };
-       uint32_t canary;
 };
 
 #endif //ROS_KERN_KMALLOC_H
index ee159c9..cf58486 100644 (file)
@@ -143,7 +143,7 @@ void __tlbshootdown(struct trapframe *tf, uint32_t srcid, void *a0, void *a1,
 
 /* Arch Specific */
 void proc_init_trapframe(trapframe_t *SAFE tf, uint32_t vcoreid,
-                         uint32_t entryp, uint32_t stack_top);
+                         uintptr_t entryp, uintptr_t stack_top);
 void proc_secure_trapframe(struct trapframe *tf);
 void __abandon_core(void);
 
index 20058f0..0eab079 100644 (file)
@@ -9,9 +9,9 @@
 #define ROS_INC_BCQ_STRUCT_H
 
 struct bcq_header {
-       uint32_t prod_idx;              /* next to be produced in */
-       uint32_t cons_pub_idx;  /* last completely consumed */
-       uint32_t cons_pvt_idx;  /* last a consumer has dibs on */
+       uintptr_t prod_idx;             /* next to be produced in */
+       uintptr_t cons_pub_idx; /* last completely consumed */
+       uintptr_t cons_pvt_idx; /* last a consumer has dibs on */
 };
 
 #define DEFINE_BCQ_TYPES(__name, __elem_t, __num_elems)                        \
index 5edde70..3e551cb 100644 (file)
@@ -51,48 +51,48 @@ typedef size_t uintreg_t;
 // Round down to the nearest multiple of n
 #define ROUNDDOWN(a, n)                                                \
 ({                                                             \
-       uint32_t __a = (uint32_t) (a);                          \
+       uintptr_t __a = (uintptr_t) (a);                                \
        (typeof(a)) (__a - __a % (n));                          \
 })
 // Round up to the nearest multiple of n
 #define ROUNDUP(a, n)                                          \
 ({                                                             \
-       uint32_t __n = (uint32_t) (n);                          \
-       (typeof(a)) (ROUNDDOWN((uint32_t) (a) + __n - 1, __n)); \
+       uintptr_t __n = (uintptr_t) (n);                                \
+       (typeof(a)) (ROUNDDOWN((uintptr_t) (a) + __n - 1, __n));        \
 })
 
 // Round down to the nearest multiple of n
 #define PTRROUNDDOWN(a, n)                                             \
 ({                                                             \
        char * __a = (char *) (a);                              \
-       (typeof(a)) (__a - (uint32_t)__a % (n));                                \
+       (typeof(a)) (__a - (uintptr_t)__a % (n));                               \
 })
 // Round pointer up to the nearest multiple of n
 #define PTRROUNDUP(a, n)                                               \
 ({                                                             \
-       uint32_t __n = (uint32_t) (n);                          \
+       uintptr_t __n = (uintptr_t) (n);                                \
        (typeof(a)) (PTRROUNDDOWN((char *) (a) + __n - 1, __n));        \
 })
 
 // Return the integer logarithm of the value provided rounded down
-static inline uint32_t LOG2_DOWN(uint32_t value)
+static inline uintptr_t LOG2_DOWN(uintptr_t value)
 {
-       uint32_t l = 0;
+       uintptr_t l = 0;
        while( (value >> l) > 1 ) ++l;
        return l;
 }
 
 // Return the integer logarithm of the value provided rounded up
-static inline uint32_t LOG2_UP(uint32_t value)
+static inline uintptr_t LOG2_UP(uintptr_t value)
 {
-       uint32_t _v = LOG2_DOWN(value);
+       uintptr_t _v = LOG2_DOWN(value);
        if (value ^ (1 << _v))
                return _v + 1;
        else
                return _v;
 }
 
-static inline uint32_t ROUNDUPPWR2(uint32_t value)
+static inline uintptr_t ROUNDUPPWR2(uintptr_t value)
 {
        return 1 << LOG2_UP(value);
 }
index 3ad068e..4764bb4 100644 (file)
@@ -427,7 +427,7 @@ void dcache_prune(struct super_block *sb, bool negative_only);
 
 /* Inode Functions */
 struct inode *get_inode(struct dentry *dentry);
-void load_inode(struct dentry *dentry, unsigned int ino);
+void load_inode(struct dentry *dentry, unsigned long ino);
 int create_file(struct inode *dir, struct dentry *dentry, int mode);
 int create_dir(struct inode *dir, struct dentry *dentry, int mode);
 int create_symlink(struct inode *dir, struct dentry *dentry,
@@ -435,9 +435,9 @@ int create_symlink(struct inode *dir, struct dentry *dentry,
 int check_perms(struct inode *inode, int access_mode);
 void inode_release(struct kref *kref);
 void stat_inode(struct inode *inode, struct kstat *kstat);
-struct inode *icache_get(struct super_block *sb, unsigned int ino);
+struct inode *icache_get(struct super_block *sb, unsigned long ino);
 void icache_put(struct super_block *sb, struct inode *inode);
-struct inode *icache_remove(struct super_block *sb, unsigned int ino);
+struct inode *icache_remove(struct super_block *sb, unsigned long ino);
 
 /* File-ish functions */
 ssize_t generic_file_read(struct file *file, char *buf, size_t count,
index 77ff867..2ad97cf 100644 (file)
@@ -240,7 +240,7 @@ retry:
        /* Normally, there'd be an ABA problem here, but we never actually remove
         * bhs from the chain until the whole page gets cleaned up, which can't
         * happen while we hold a reference to the page. */
-       if (!atomic_comp_swap((uint32_t*)next_loc, (uint32_t)bh, (uint32_t)new)) {
+       if (!atomic_comp_swap((uintptr_t*)next_loc, (uintptr_t)bh, (uintptr_t)new)) {
                kmem_cache_free(bh_kcache, new);
                goto retry;
        }
index fd49553..78bc842 100644 (file)
@@ -1048,8 +1048,8 @@ static bool create_each_func(struct ext2_dirent *dir_i, void *a1, void *a2,
                              void *a3)
 {
        struct dentry *dentry = (struct dentry*)a1;
-       unsigned int our_rec_len = (unsigned int)a2;
-       unsigned int mode = (unsigned int)a3;
+       uintptr_t our_rec_len = (uintptr_t)a2;
+       uintptr_t mode = (uintptr_t)a3;
        struct ext2_dirent *dir_new;
        unsigned int real_len = ext2_dirent_len(dir_i);
        /* How much room is available after this dir_i before the next one */
@@ -1082,7 +1082,7 @@ int ext2_create(struct inode *dir, struct dentry *dentry, int mode,
        struct ext2_inode *disk_inode;
        struct ext2_i_info *e2ii;
        uint32_t dir_block;
-       unsigned int our_rec_len;
+       uintptr_t our_rec_len;
        /* TODO: figure out the real time!  (Nanwan's birthday, bitches!) */
        time_t now = 1242129600;
        struct ext2_dirent *new_dirent;
@@ -1114,7 +1114,7 @@ int ext2_create(struct inode *dir, struct dentry *dentry, int mode,
        /* Consider caching the start point for future dirent ops.  Or even using
         * the indexed directory.... */
        dir_block = ext2_foreach_dirent(dir, create_each_func, dentry,
-                                       (void*)our_rec_len, (void*)mode);
+                                       (void*)our_rec_len, (void*)(uintptr_t)mode);
        /* If this returned a block number, we didn't find room in any of the
         * existing directory blocks, so we need to make a new one, stick it in the
         * dir inode, and stick our dirent at the beginning.  The reclen is the
index fee839e..a74a4bf 100644 (file)
@@ -195,7 +195,7 @@ void __diediedie(trapframe_t* tf, uint32_t srcid, uint32_t code, uint32_t a1, ui
        while(1);
 }
 
-void appserver_die(int code)
+void appserver_die(uintptr_t code)
 {
        int i;
        for(i = 0; i < num_cpus; i++)
index cd4a1fb..b2ad5d0 100644 (file)
@@ -89,10 +89,10 @@ int mon_kerninfo(int argc, char **argv, trapframe_t *tf)
        extern char (RO SNT _start)[], (RO SNT etext)[], (RO SNT edata)[], (RO SNT end)[];
 
        cprintf("Special kernel symbols:\n");
-       cprintf("  _start %08x (virt)  %08x (phys)\n", _start, (uint32_t)(_start - KERNBASE));
-       cprintf("  etext  %08x (virt)  %08x (phys)\n", etext, (uint32_t)(etext - KERNBASE));
-       cprintf("  edata  %08x (virt)  %08x (phys)\n", edata, (uint32_t)(edata - KERNBASE));
-       cprintf("  end    %08x (virt)  %08x (phys)\n", end, (uint32_t)(end - KERNBASE));
+       cprintf("  _start %016x (virt)  %016x (phys)\n", _start, (uintptr_t)(_start - KERNBASE));
+       cprintf("  etext  %016x (virt)  %016x (phys)\n", etext, (uintptr_t)(etext - KERNBASE));
+       cprintf("  edata  %016x (virt)  %016x (phys)\n", edata, (uintptr_t)(edata - KERNBASE));
+       cprintf("  end    %016x (virt)  %016x (phys)\n", end, (uintptr_t)(end - KERNBASE));
        cprintf("Kernel executable memory footprint: %dKB\n",
                (uint32_t)(end-_start+1023)/1024);
        return 0;
index 4c2025e..64a1e4e 100644 (file)
@@ -45,7 +45,7 @@ extern unsigned char device_mac[6];
 /* Tracing Globals */
 int systrace_flags = 0;
 struct systrace_record *systrace_buffer = 0;
-unsigned int systrace_bufidx = 0;
+uintptr_t systrace_bufidx = 0;
 size_t systrace_bufsize = 0;
 struct proc *systrace_procs[MAX_NUM_TRACED] = {0};
 spinlock_t systrace_lock = SPINLOCK_INITIALIZER;
@@ -117,7 +117,7 @@ static int sys_block(struct proc *p, unsigned int usec)
 static int sys_cache_buster(struct proc *p, uint32_t num_writes,
                              uint32_t num_pages, uint32_t flags)
 { TRUSTEDBLOCK /* zra: this is not really part of the kernel */
-       #define BUSTER_ADDR             0xd0000000  // around 512 MB deep
+       #define BUSTER_ADDR             0xd0000000L  // around 512 MB deep
        #define MAX_WRITES              1048576*8
        #define MAX_PAGES               32
        #define INSERT_ADDR     (UINFO + 2*PGSIZE) // should be free for these tests
@@ -1387,7 +1387,7 @@ intreg_t syscall(struct proc *p, uintreg_t sc_num, uintreg_t a0, uintreg_t a1,
                                       a4, a5, p->pid, coreid, vcoreid);
                        } else {
                                struct systrace_record *trace;
-                               unsigned int idx, new_idx;
+                               uintptr_t idx, new_idx;
                                do {
                                        idx = systrace_bufidx;
                                        new_idx = (idx + 1) % systrace_bufsize;
index 9d01a5e..0825f2f 100644 (file)
@@ -786,7 +786,7 @@ void test_hashtable(void)
        struct test tstruct[10];
 
        struct hashtable *h;
-       int k = 5;
+       uintptr_t k = 5;
        struct test *v = &tstruct[0];
 
        h = create_hashtable(32, __generic_hash, __generic_eq);
index 3dcb178..2ff72da 100644 (file)
@@ -916,7 +916,7 @@ struct inode *get_inode(struct dentry *dentry)
 }
 
 /* Helper: loads/ reads in the inode numbered ino and attaches it to dentry */
-void load_inode(struct dentry *dentry, unsigned int ino)
+void load_inode(struct dentry *dentry, unsigned long ino)
 {
        struct inode *inode;
 
@@ -1075,7 +1075,7 @@ void stat_inode(struct inode *inode, struct kstat *kstat)
 /* Inode Cache management.  In general, search on the ino, get a refcnt'd value
  * back.  Remove does not give you a reference back - it should only be called
  * in inode_release(). */
-struct inode *icache_get(struct super_block *sb, unsigned int ino)
+struct inode *icache_get(struct super_block *sb, unsigned long ino)
 {
        /* This is the same style as in pid2proc, it's the "safely create a strong
         * reference from a weak one, so long as other strong ones exist" pattern */
@@ -1097,7 +1097,7 @@ void icache_put(struct super_block *sb, struct inode *inode)
        spin_unlock(&sb->s_icache_lock);
 }
 
-struct inode *icache_remove(struct super_block *sb, unsigned int ino)
+struct inode *icache_remove(struct super_block *sb, unsigned long ino)
 {
        struct inode *inode;
        /* Presumably these hashtable removals could be easier since callers