Removing __kernel_old_uid_t, git_t, dev_t

on the base our discussion some month ago you recommend me to remove old kernel types.
I did some tests and I found that first step must be to remove all references in linux kernel code because of compilation error. Just perform grep to include linux folder.

I think we should create this patch first and then I can remove them from MB posix_types.h.

Do you agree with me?

include/asm-generic/types.h new file +0 -0

new file mode 100644
index 0000000..5841716

include/asm-generic/types.h line 9

Quoted 6 lines · Arnd Bergmann

include/asm-generic/types.h new file +6 -0

+/*
+ * int-ll64 is used on all 32 bit architectures and on x86-64,
+ * so use it as a reasonable default.
+ */
+#include <asm-generic/int-ll64.h>
+

Most 64-bit archs have been migrated to ll64 by now. Alpha, ia64, and mips64 are the remaining exceptions.

Quoted 6 lines

include/asm-generic/types.h new file +6 -0

+/*
+ * DMA addresses may be larger than pointers, but not smaller.
+ * Do not define the dma64_addr_t type, which never really
+ * worked.
+ */
+#if defined(CONFIG_64BIT) || defined(CONFIG_PHYS_64BIT)

include/asm-generic/types.h line 50

Quoted 4 lines

include/asm-generic/types.h new file +4 -0

+typedef u64 dma_addr_t;
+#else
+typedef u32 dma_addr_t;
+#endif /* 64 bit DMA pointer */

Is there any specific reason why dma_addr_t is in <asm/types.h>, while phys_addr_t is in
<linux/types.h>?

Furthermore, CONFIG_PHYS_64BIT is used on PPC only. Probably it should be replaced by CONFIG_PHYS_ADDR_T_64BIT, which is always set if CONFIG_64BIT, so the #ifdef above becomes even simpler?

dma_addr_t is a big mess that was traditionally defined per architecture, in lots of wrong ways, including the misconception of dma64_addr_t. Sparc64 still uses a 32 bit dma_addr_t, possibly because it always uses an IOMMU (?). It can save some space in scatterlists, but might come back to bite us if someone tries to build a sparc64 system with actual 64-bit DMA.

There is no reason to use anything larger than a 32-bit DMA address type on sparc64, and using 32-bit saves lots of space in many data structures so I am unlikely to ever change this. :-)

I've spent more time on my asm-generic patches and believe I now have an unistd.h implementation that can be used by the new architectures (score and microblaze) so they don't have to go through the error-prone process of coming up with their own lists.

It would be good if more people could in particular look over the system call lists. I have left the syscalls that I think should be dropped in #ifdef __ARCH_WANT_SYSCALL_{DEPRECATED,NO_AT,NO_FLAGS,OFF_T} so that it becomes easy to reenable them temporarily while porting the libc, and to easily see which ones get left out.

I have also changed checksyscalls.sh to stop complaining when the old syscalls are not present.

Signed-off-by Arnd Bergmann <[email protected]>

---
 include/asm-generic/posix_types.h |  162 ++++++ include/asm-generic/types.h       |   63 ++ include/asm-generic/unistd.h      |  829 +++++++++++++++++++++++++++++ kernel/Makefile                   |    1 + kernel/syscall_table.c            |   12 + scripts/checksyscalls.sh          |   93 +++-

 6 files changed, 1157 insertions(+), 3 deletions(-)

include/asm-generic/posix_types.h new file +162 -0

new file mode 100644
index 0000000..4772f74
@@ -0,0 +1,162 @@
+#ifndef __ASM_GENERIC_POSIX_TYPES_H
+#define __ASM_GENERIC_POSIX_TYPES_H
+
+#include <asm/types.h>
+
+/*
+ * This file is generally used by user-level software, so you need to
+ * be a little careful about namespace pollution etc.
+ *
+ * First the types that are often defined in different ways across
+ * architectures, so that you can override them.
+ */
+
+#ifndef __kernel_ino_t
+typedef unsigned long  __kernel_ino_t;
+#endif
+
+#ifndef __kernel_mode_t
+typedef unsigned int   __kernel_mode_t;
+#endif
+
+#ifndef __kernel_nlink_t
+typedef unsigned long  __kernel_nlink_t;
+#endif
+
+#ifndef __kernel_pid_t
+typedef int            __kernel_pid_t;
+#endif
+
+#ifndef __kernel_ipc_pid_t
+typedef int            __kernel_ipc_pid_t;
+#endif
+
+#ifndef __kernel_uid_t
+typedef unsigned int   __kernel_uid_t;
+typedef unsigned int   __kernel_gid_t;
+#endif
+
+#ifndef __kernel_suseconds_t
+typedef long           __kernel_suseconds_t;
+#endif
+
+#ifndef __kernel_daddr_t
+typedef int            __kernel_daddr_t;
+#endif
+
+#ifndef __kernel_uid32_t
+typedef __kernel_uid_t __kernel_uid32_t;
+typedef __kernel_gid_t __kernel_gid32_t;
+#endif
+
+#ifndef __kernel_old_uid_t
+typedef __kernel_uid_t __kernel_old_uid_t;
+typedef __kernel_gid_t __kernel_old_gid_t;
+#endif
+
+#ifndef __kernel_old_dev_t
+typedef unsigned int   __kernel_old_dev_t;
+#endif
+
+#ifndef __kernel_size_t
+#if __BITS_PER_LONG != 64
+typedef unsigned int   __kernel_size_t;
+typedef int            __kernel_ssize_t;
+typedef int            __kernel_ptrdiff_t;
+#else
+typedef unsigned long  __kernel_size_t;
+typedef long           __kernel_ssize_t;
+typedef long           __kernel_ptrdiff_t;
+#endif
+#endif
+
+/*
+ * anything below here should be completely generic
+ */
+typedef long           __kernel_off_t;
+typedef long long      __kernel_loff_t;
+typedef long           __kernel_time_t;
+typedef long           __kernel_clock_t;
+typedef int            __kernel_timer_t;
+typedef int            __kernel_clockid_t;
+typedef char *         __kernel_caddr_t;
+typedef unsigned short __kernel_uid16_t;
+typedef unsigned short __kernel_gid16_t;
+
+typedef struct {
+       int     val[2];
+} __kernel_fsid_t;
+
+#ifdef __KERNEL__
+
+#undef __FD_SET
+static inline void __FD_SET(unsigned long __fd, __kernel_fd_set *__fdsetp)
+{
+       unsigned long __tmp = __fd / __NFDBITS;
+       unsigned long __rem = __fd % __NFDBITS;
+       __fdsetp->fds_bits[__tmp] |= (1UL<<__rem);
+}
+
+#undef __FD_CLR
+static inline void __FD_CLR(unsigned long __fd, __kernel_fd_set *__fdsetp)
+{
+       unsigned long __tmp = __fd / __NFDBITS;
+       unsigned long __rem = __fd % __NFDBITS;
+       __fdsetp->fds_bits[__tmp] &= ~(1UL<<__rem);
+}
+
+#undef __FD_ISSET
+static inline int __FD_ISSET(unsigned long __fd, const __kernel_fd_set *__p)
+{
+       unsigned long __tmp = __fd / __NFDBITS;
+       unsigned long __rem = __fd % __NFDBITS;
+       return (__p->fds_bits[__tmp] & (1UL<<__rem)) != 0;
+}
+
+/*
+ * This will unroll the loop for the normal constant case (8 ints,
+ * for a 256-bit fd_set)
+ */
+#undef __FD_ZERO
+static inline void __FD_ZERO(__kernel_fd_set *__p)
+{
+       unsigned long *__tmp = __p->fds_bits;
+       int __i;
+
+       if (__builtin_constant_p(__FDSET_LONGS)) {
+               switch (__FDSET_LONGS) {
+               case 16:
+                       __tmp[ 0] = 0; __tmp[ 1] = 0;
+                       __tmp[ 2] = 0; __tmp[ 3] = 0;
+                       __tmp[ 4] = 0; __tmp[ 5] = 0;
+                       __tmp[ 6] = 0; __tmp[ 7] = 0;
+                       __tmp[ 8] = 0; __tmp[ 9] = 0;
+                       __tmp[10] = 0; __tmp[11] = 0;
+                       __tmp[12] = 0; __tmp[13] = 0;
+                       __tmp[14] = 0; __tmp[15] = 0;
+                       return;
+
+               case 8:
+                       __tmp[ 0] = 0; __tmp[ 1] = 0;
+                       __tmp[ 2] = 0; __tmp[ 3] = 0;
+                       __tmp[ 4] = 0; __tmp[ 5] = 0;
+                       __tmp[ 6] = 0; __tmp[ 7] = 0;
+                       return;
+
+               case 4:
+                       __tmp[ 0] = 0; __tmp[ 1] = 0;
+                       __tmp[ 2] = 0; __tmp[ 3] = 0;
+                       return;
+               }
+       }
+       __i = __FDSET_LONGS;
+       while (__i) {
+               __i--;
+               *__tmp = 0;
+               __tmp++;
+       }
+}
+
+#endif /* __KERNEL__ */
+
+#endif /* __ASM_GENERIC_POSIX_TYPES_H */

include/asm-generic/types.h new file +12 -0

new file mode 100644
index 0000000..147b553
@@ -0,0 +1,63 @@
+#ifndef _ASM_GENERIC_TYPES_H
+#define _ASM_GENERIC_TYPES_H
+
+/*
+ * int-ll64 is used practically everywhere now,
+ * so use it as a reasonable default.
+ */
+#include <asm-generic/int-ll64.h>
+
+#ifndef __ASSEMBLY__
+
+typedef unsigned short umode_t;

include/asm-generic/types.h new file +31 -0

+
+/*
+ * These aren't exported outside the kernel to avoid name space clashes
+ */
+#ifdef __KERNEL__
+
+#ifdef CONFIG_64BIT
+#define BITS_PER_LONG 64
+#else
+#define BITS_PER_LONG 32
+#endif /* CONFIG_64BIT */
+
+#if BITS_PER_LONG != __BITS_PER_LONG
+#error cannot determine word size
+#endif
+
+#ifndef __ASSEMBLY__
+
+/*
+ * DMA addresses may be very different from physical addresses
+ * and pointers. i386 and powerpc may have 64 bit DMA on 32 bit
+ * systems, while sparc64 uses 32 bit DMA addresses for 64 bit
+ * physical addresses.
+ * This default defines dma_addr_t to have the same size as
+ * phys_addr_t, which is the most common way.
+ * Do not define the dma64_addr_t type, which never really
+ * worked.
+ */
+#ifndef dma_addr_t
+#ifdef CONFIG_PHYS_ADDR_T_64BIT
+typedef u64 dma_addr_t;

include/asm-generic/types.h line 22

Quoted 6 lines

+ * There seems to be no way of detecting this automatically from user
+ * space, so 64 bit architectures should override this in their types.h.
+ */

include/asm-generic/types.h new file +3 -0

+#ifndef __BITS_PER_LONG
+#define __BITS_PER_LONG 32
+#endif

Why is this define required? It doesn't seem to be in any existing headers.

Unfortunately, there is no generic way to detect the word size yet, but every architecture uses its own preprocessor macro (__x86_64__, __s390x__, __ppc64__). We also can't use CONFIG_64BIT in an user-exported interface header file, because the use space can also be compiled for 32 bits when the kernel uses 64 bits.

Actually, gcc does have the _LP64 and __SIZEOF_POINTER__ macros (as well as __CHAR_BIT__), although I don't know how far back it does have that.
If it has been with us for long enough it might be possible to
switch over to using panarch macros.

Quoted 4 lines

Actually, gcc does have the _LP64 and __SIZEOF_POINTER__ macros (as well as __CHAR_BIT__), although I don't know how far back it does have that. If it has been with us for long enough it might be possible to switch over to using panarch macros.

Worst case the oldest compilers had <limits.h> and "#if ULONG_MAX == 0xffffffffUL", though I wouldn't like myself to be using a setup where <limits.h> got pulled in.