Return to check_glibc_kernelversion.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / tests / cris

Annotation of qemu/tests/cris/check_glibc_kernelversion.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Check the lz insn.
        !             3:  */
        !             4: 
        !             5: #include <stdio.h>
        !             6: #include <stdlib.h>
        !             7: #include <stdint.h>
        !             8: #include "sys.h"
        !             9: 
        !            10: #define __LINUX_KERNEL_VERSION 131584
        !            11: 
        !            12: #define DL_SYSDEP_OSCHECK(FATAL) \
        !            13:   do {                                                                        \
        !            14:     /* Test whether the kernel is new enough.  This test is only              \
        !            15:        performed if the library is not compiled to run on all                 \
        !            16:        kernels.  */                                                           \
        !            17:     if (__LINUX_KERNEL_VERSION > 0)                                           \
        !            18:       {                                                                       \
        !            19:         char bufmem[64];                                                      \
        !            20:         char *buf = bufmem;                                                   \
        !            21:         unsigned int version;                                                 \
        !            22:         int parts;                                                            \
        !            23:         char *cp;                                                             \
        !            24:         struct utsname uts;                                                   \
        !            25:                                                                               \
        !            26:         /* Try the uname syscall */                                           \
        !            27:         if (__uname (&uts))                                                   \
        !            28:           {                                                                   \
        !            29:             /* This was not successful.  Now try reading the /proc            \
        !            30:                filesystem.  */                                                \
        !            31:             ssize_t reslen;                                                   \
        !            32:             int fd = __open ("/proc/sys/kernel/osrelease", O_RDONLY);         \
        !            33:             if (fd == -1                                                      \
        !            34:                 || (reslen = __read (fd, bufmem, sizeof (bufmem))) <= 0)      \
        !            35:               /* This also didn't work.  We give up since we cannot           \
        !            36:                  make sure the library can actually work.  */                 \
        !            37:               FATAL ("FATAL: cannot determine library version\n");            \
        !            38:             __close (fd);                                                     \
        !            39:             buf[MIN (reslen, (ssize_t) sizeof (bufmem) - 1)] = '\0';          \
        !            40:           }                                                                   \
        !            41:         else                                                                  \
        !            42:           buf = uts.release;                                                  \
        !            43:                                                                               \
        !            44:         /* Now convert it into a number.  The string consists of at most      \
        !            45:            three parts.  */                                                   \
        !            46:         version = 0;                                                          \
        !            47:         parts = 0;                                                            \
        !            48:         cp = buf;                                                             \
        !            49:         while ((*cp >= '0') && (*cp <= '9'))                                  \
        !            50:           {                                                                   \
        !            51:             unsigned int here = *cp++ - '0';                                  \
        !            52:                                                                               \
        !            53:             while ((*cp >= '0') && (*cp <= '9'))                              \
        !            54:               {                                                               \
        !            55:                 here *= 10;                                                   \
        !            56:                 here += *cp++ - '0';                                          \
        !            57:               }                                                               \
        !            58:                                                                               \
        !            59:             ++parts;                                                          \
        !            60:             version <<= 8;                                                    \
        !            61:             version |= here;                                                  \
        !            62:                                                                               \
        !            63:             if (*cp++ != '.')                                                 \
        !            64:               /* Another part following?  */                                  \
        !            65:               break;                                                          \
        !            66:           }                                                                   \
        !            67:                                                                               \
        !            68:         if (parts < 3)                                                        \
        !            69:           version <<= 8 * (3 - parts);                                        \
        !            70:                                                                               \
        !            71:         /* Now we can test with the required version.  */                     \
        !            72:         if (version < __LINUX_KERNEL_VERSION)                                 \
        !            73:           /* Not sufficent.  */                                               \
        !            74:           FATAL ("FATAL: kernel too old\n");                                  \
        !            75:                                                                               \
        !            76:         _dl_osversion = version;                                              \
        !            77:       }                                                                       \
        !            78:   } while (0)
        !            79: 
        !            80: int main(void)
        !            81: {
        !            82:         char bufmem[64] = "2.6.22";
        !            83:         char *buf = bufmem;
        !            84:         unsigned int version;
        !            85:         int parts;
        !            86:         char *cp;
        !            87: 
        !            88:         version = 0;
        !            89:         parts = 0;
        !            90:         cp = buf;
        !            91:         while ((*cp >= '0') && (*cp <= '9'))
        !            92:           {
        !            93:             unsigned int here = *cp++ - '0';
        !            94: 
        !            95:             while ((*cp >= '0') && (*cp <= '9'))
        !            96:               {
        !            97:                 here *= 10;
        !            98:                 here += *cp++ - '0';
        !            99:               }
        !           100: 
        !           101:             ++parts;
        !           102:             version <<= 8;
        !           103:             version |= here;
        !           104: 
        !           105:             if (*cp++ != '.')
        !           106:               /* Another part following?  */
        !           107:               break;
        !           108:           }
        !           109: 
        !           110:         if (parts < 3)
        !           111:           version <<= 8 * (3 - parts);
        !           112:        if (version < __LINUX_KERNEL_VERSION)
        !           113:                err();
        !           114:        pass();
        !           115:        exit(0);
        !           116: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.