From patchwork Wed Dec 3 16:37:27 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella X-Patchwork-Id: 125848 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from vm01.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 97A504315720 for ; Wed, 3 Dec 2025 16:38:29 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 97A504315720 Authentication-Results: sourceware.org; dkim=pass (2048-bit key, unprotected) header.d=linaro.org header.i=@linaro.org header.a=rsa-sha256 header.s=google header.b=yZ35ZN7K X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-dy1-f176.google.com (mail-dy1-f176.google.com [74.125.82.176]) by sourceware.org (Postfix) with ESMTPS id 063B348EFFAE for ; Wed, 3 Dec 2025 16:37:54 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 063B348EFFAE Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=linaro.org ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 063B348EFFAE Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=74.125.82.176 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1764779874; cv=none; b=lBcs6Fu239IiRR8506qx3Fm1NMLHiAYiuKiKRhHh/chSZVQqrTDpplXiAlXMlBOfk4sb4T0/mnV+0qGwGpjptDpMTckfpVEGcGAvrTMNqghST2RoEqO18ybYUIdiTtzkGHrzK9Ib+yE/lTuz/RUzLnjBCnM/A3oruW29tWPHDzU= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1764779874; c=relaxed/simple; bh=gpkNZXJFkI0v5gbZ2PRVZepi+7v7eymJLrKnu5aS14U=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=KwDt6XZ54d3Ul6uV/PYyWX+4PajsL6JOQUR0bKrKggo3o0omLn3+wY9ejYEk61S9DtM5daa16ugqNVS7/g48DPz/xDnwFx3LHVfO07gdxSa2AmEjEEfRyorpSzspsr+DAGohE/alSlxx6YhrnSUeNO6ccoBjJLqvTmKQkkBbt98= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 063B348EFFAE Received: by mail-dy1-f176.google.com with SMTP id 5a478bee46e88-2a45877bd5eso1588292eec.0 for ; Wed, 03 Dec 2025 08:37:53 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1764779872; x=1765384672; darn=sourceware.org; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:from:to:cc:subject:date:message-id:reply-to; bh=OIBmKuA9zAGzzFM3BMSTw/4Gwg1cMjaw4f4gOCTgGxs=; b=yZ35ZN7K3Ed5ryJBCeERsgZT/VxjXqIPVOqzn7c73ahfVpfv6YOrx7UAqqLKGQT3hj y/s2qg0a28h5h3CPjbCqN0HYmJTZYYPgTx3HFN7owyLZ3RdVIYJUSU08+uGCO66+0aV8 Ze+ziCTNoR0fMt5KcqLMCGAWedVqEQiOhYeHtc+RYGLPQUg4SjUAW++iEMIV0zzfj0ZH 8SaKnZVcvwDOdilzSFQEkCRdp61kjja13Hqt1s9jZC0o4UW1I1StrJYnZOHYM1kxHRxx LvcCp8G3pYwP2ch48qNZyjwMdXST6Dk2RZPrSFytlvAnWEDANzBtQI0ae+0wvzO0gE3L 6JeQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1764779872; x=1765384672; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=OIBmKuA9zAGzzFM3BMSTw/4Gwg1cMjaw4f4gOCTgGxs=; b=AfYYTqg5fR0eBMhfJZ09hRK64fG/CN/sdO/xy3In+Ba9wet/KxSnmXL6bTLvvFE4W1 iqNHnkgir3HPwqckP2Quvhq5fi+JSPQavKm17u5OxqxlFS+as4pv9HRe+EIKPb3I0l3o mFzdm1Z/zUrgEfe0tzlyPMLV2hSZejbflJl/M8xmMDg9DzoOd4y/ybxZosF2/f41d9xR 2gBduvJhSuEodlldPkvasi16+SB7m41XpK7n6HLtrspWmmP1hEeCRjBlsnXPU/RmJLVw JA0OKaXO7UafPzBDZgXpzCtH+ygYY9OVaVVoYQHY/GHlb7GopTuQPtr6GkiX0MM/0BZR Pkwg== X-Gm-Message-State: AOJu0YwJoL6xd4Zwy98dufkldWQvtpWsaWqodIbBH/EgRBA+TyiPC68A aNFmJgUWjJbpDxMHI5TgNb/L8t9jQ+YySBt2ZeBmDdfojR4v8SL4SoK2cDo4nCRGFvUGNtbH7np puCB1 X-Gm-Gg: ASbGncsbXMfkUIBx+mU6XIDLG6HDbGyCyt1cIxcpg24SOz22bbUuJWLe+c4aSGVqc+K pxdenT3IXUyc/SmqzFqSeiHz9jRt3mYCIIkluGQgwvrnENnssu1bZiAzOtX4bID3sV9Tr8G+EuV 42VT+UJdnIToNaKOtQ4ZRSaAHiP3rEd3lay4SFqcDE6R3fsC9DwsVrBaaGPFp5bCHC+7FYZTSlC KbDny9TlmdOKdfi6kYXKkar1nAY2SUJNbWywSCfzvQSOZXEQ/DOwMEinl4yHCnSYwPlSkcTzIuh BkqjKRAa2ohlG+ln6R4nLoosJZXYJWZvvJJTyqfmbfGpRKB7CUHzcoaQSdwK4V5AbseqZvSTo07 BhyqaVsU1lcV/nsZ2sRcipprGKWOJzWhrhTRfh0AkZRctRDdOdPFdAJpF2eESA5raO17h1GFSmK CBlVuZsfQ5K1V8dbof4OILDNBWXWVsrXAQvGWzBER+Vxs3u2XRVzKQS7UPkydIWWPqffA= X-Google-Smtp-Source: AGHT+IHKdYauokY0pWbG+43d1FGpvxBlgA2aRORnh35y9umiTvgVz2A52q4UIZITxOLkIJjqWTBxXQ== X-Received: by 2002:a05:693c:2181:b0:2a4:646c:e096 with SMTP id 5a478bee46e88-2aba316e26fmr30929eec.0.1764779872129; Wed, 03 Dec 2025 08:37:52 -0800 (PST) Received: from ubuntu-vm.. (200-100-151-160.dial-up.telesp.net.br. [200.100.151.160]) by smtp.gmail.com with ESMTPSA id 5a478bee46e88-2a9653ca11esm65454178eec.0.2025.12.03.08.37.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 03 Dec 2025 08:37:51 -0800 (PST) From: Adhemerval Zanella To: libc-alpha@sourceware.org Cc: Adhemerval Zanella Netto Subject: [PATCH v2] posix: Fix getconf symbolic constants defined in limits.h (BZ# 29147) Date: Wed, 3 Dec 2025 13:37:27 -0300 Message-ID: <20251203163735.2805829-1-adhemerval.zanella@linaro.org> X-Mailer: git-send-email 2.43.0 MIME-Version: 1.0 X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, RCVD_IN_VALIDITY_RPBL_BLOCKED, RCVD_IN_VALIDITY_SAFE_BLOCKED, SPF_HELO_NONE, SPF_PASS, TXREP, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libc-alpha-bounces~patchwork=sourceware.org@sourceware.org From: Adhemerval Zanella Netto POSIX-1.2018 defines that getconf utility shall print symbolic constant listed under the heading Maximum value and Minimum Values [1], however current behaviour is to print the values using pathconf or sysconf, which represents the specific implementation values instead of the system agnostics ones. Another issue is for such the symbolic constants, getconf handles them as a path_var which requires an additional pathname (which does not make sense for constants values). The patch fixes it adding a new internal type, LIMITS_H, which only prints the constant symbolic without requiring an additional path. Only the values define in glibc provided limits.h plust the GNU extensions are handled. Checked on x86_64-linux-gnu. [1] https://pubs.opengroup.org/onlinepubs/9699919799/utilities/getconf.html) --- posix/Makefile | 15 ++++++- posix/getconf.c | 86 +++++++++++++++++++++++++++++-------- posix/tst-getconf-limits.py | 72 +++++++++++++++++++++++++++++++ 3 files changed, 155 insertions(+), 18 deletions(-) create mode 100755 posix/tst-getconf-limits.py diff --git a/posix/Makefile b/posix/Makefile index f6421e5379..490e89f7b8 100644 --- a/posix/Makefile +++ b/posix/Makefile @@ -476,7 +476,10 @@ endif # XXX Please note that for now we ignore the result of this test. tests-special += $(objpfx)annexc.out ifeq ($(run-built-tests),yes) -tests-special += $(objpfx)tst-getconf.out +tests-special += \ + $(objpfx)tst-getconf.out \ + $(objpfx)tst-getconf-limits.out \ + # tests-special ifeq (yes,$(build-shared)) ifneq ($(PERL),no) tests-special += \ @@ -729,6 +732,16 @@ $(objpfx)tst-getconf.out: tst-getconf.sh $(objpfx)getconf $(SHELL) $< $(common-objpfx) '$(built-program-cmd)'; \ $(evaluate-test) +$(objpfx)tst-getconf-limits.out: tst-getconf-limits.py $(objpfx)getconf + PYTHONPATH=../scripts \ + $(PYTHON) tst-getconf-limits.py \ + --cc="$(CC) $(patsubst -DMODULE_NAME=%, \ + -DMODULE_NAME=testsuite, \ + $(CPPFLAGS)) -D_ISOMAC" \ + '$(built-program-cmd)' \ + < /dev/null > $@ 2>&1; $(evaluate-test) + + $(objpfx)bug-ga2-mem.out: $(objpfx)bug-ga2.out { test -r $(objpfx)bug-ga2.mtrace \ || ( echo "bug-ga2.mtrace does not exist"; exit 77; ) \ diff --git a/posix/getconf.c b/posix/getconf.c index 4ba9c0dee8..9bee1badf3 100644 --- a/posix/getconf.c +++ b/posix/getconf.c @@ -49,24 +49,18 @@ struct conf { const char *name; - const int call_name; - const enum { SYSCONF, CONFSTR, PATHCONF } call; + const long int call_name; + const enum { SYSCONF, CONFSTR, PATHCONF, LIMITS_H } call; }; static const struct conf vars[] = { { "LINK_MAX", _PC_LINK_MAX, PATHCONF }, - { "_POSIX_LINK_MAX", _PC_LINK_MAX, PATHCONF }, { "MAX_CANON", _PC_MAX_CANON, PATHCONF }, - { "_POSIX_MAX_CANON", _PC_MAX_CANON, PATHCONF }, { "MAX_INPUT", _PC_MAX_INPUT, PATHCONF }, - { "_POSIX_MAX_INPUT", _PC_MAX_INPUT, PATHCONF }, { "NAME_MAX", _PC_NAME_MAX, PATHCONF }, - { "_POSIX_NAME_MAX", _PC_NAME_MAX, PATHCONF }, { "PATH_MAX", _PC_PATH_MAX, PATHCONF }, - { "_POSIX_PATH_MAX", _PC_PATH_MAX, PATHCONF }, { "PIPE_BUF", _PC_PIPE_BUF, PATHCONF }, - { "_POSIX_PIPE_BUF", _PC_PIPE_BUF, PATHCONF }, { "SOCK_MAXBUF", _PC_SOCK_MAXBUF, PATHCONF }, { "_POSIX_ASYNC_IO", _PC_ASYNC_IO, PATHCONF }, { "_POSIX_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED, PATHCONF }, @@ -125,9 +119,7 @@ static const struct conf vars[] = { "_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN, SYSCONF }, { "NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN, SYSCONF }, { "_PHYS_PAGES", _SC_PHYS_PAGES, SYSCONF }, - { "_POSIX_ARG_MAX", _SC_ARG_MAX, SYSCONF }, { "_POSIX_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO, SYSCONF }, - { "_POSIX_CHILD_MAX", _SC_CHILD_MAX, SYSCONF }, { "_POSIX_FSYNC", _SC_FSYNC, SYSCONF }, { "_POSIX_JOB_CONTROL", _SC_JOB_CONTROL, SYSCONF }, { "_POSIX_MAPPED_FILES", _SC_MAPPED_FILES, SYSCONF }, @@ -135,8 +127,6 @@ static const struct conf vars[] = { "_POSIX_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE, SYSCONF }, { "_POSIX_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION, SYSCONF }, { "_POSIX_MESSAGE_PASSING", _SC_MESSAGE_PASSING, SYSCONF }, - { "_POSIX_NGROUPS_MAX", _SC_NGROUPS_MAX, SYSCONF }, - { "_POSIX_OPEN_MAX", _SC_OPEN_MAX, SYSCONF }, { "_POSIX_PII", _SC_PII, SYSCONF }, { "_POSIX_PII_INTERNET", _SC_PII_INTERNET, SYSCONF }, { "_POSIX_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM, SYSCONF }, @@ -155,8 +145,6 @@ static const struct conf vars[] = { "_POSIX_SELECT", _SC_SELECT, SYSCONF }, { "_POSIX_SEMAPHORES", _SC_SEMAPHORES, SYSCONF }, { "_POSIX_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS, SYSCONF }, - { "_POSIX_SSIZE_MAX", _SC_SSIZE_MAX, SYSCONF }, - { "_POSIX_STREAM_MAX", _SC_STREAM_MAX, SYSCONF }, { "_POSIX_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO, SYSCONF }, { "_POSIX_THREADS", _SC_THREADS, SYSCONF }, { "_POSIX_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR, SYSCONF }, @@ -172,7 +160,6 @@ static const struct conf vars[] = { "_POSIX_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS, SYSCONF }, { "_POSIX_TIMERS", _SC_TIMERS, SYSCONF }, { "TIMER_MAX", _SC_TIMER_MAX, SYSCONF }, - { "_POSIX_TZNAME_MAX", _SC_TZNAME_MAX, SYSCONF }, { "_POSIX_VERSION", _SC_VERSION, SYSCONF }, { "_T_IOV_MAX", _SC_T_IOV_MAX, SYSCONF }, { "_XOPEN_CRYPT", _SC_XOPEN_CRYPT, SYSCONF }, @@ -209,7 +196,6 @@ static const struct conf vars[] = { "POSIX2_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX, SYSCONF }, { "POSIX2_FORT_DEV", _SC_2_FORT_DEV, SYSCONF }, { "POSIX2_FORT_RUN", _SC_2_FORT_RUN, SYSCONF }, - { "_POSIX2_LINE_MAX", _SC_LINE_MAX, SYSCONF }, { "POSIX2_LINE_MAX", _SC_LINE_MAX, SYSCONF }, { "POSIX2_LOCALEDEF", _SC_2_LOCALEDEF, SYSCONF }, { "POSIX2_RE_DUP_MAX", _SC_RE_DUP_MAX, SYSCONF }, @@ -405,6 +391,63 @@ static const struct conf vars[] = { "_POSIX_IPV6", _SC_IPV6, SYSCONF }, { "_POSIX_RAW_SOCKETS", _SC_RAW_SOCKETS, SYSCONF }, + /* limits.h symbolic constants. */ +#define DEF_LIMIT_H(name) { #name, name, LIMITS_H } + /* Maximum Values. */ + DEF_LIMIT_H (_POSIX_CLOCKRES_MIN), + + /* Minimum Values. */ + DEF_LIMIT_H (_POSIX_AIO_LISTIO_MAX), + DEF_LIMIT_H (_POSIX_AIO_MAX), + DEF_LIMIT_H (_POSIX_ARG_MAX), + DEF_LIMIT_H (_POSIX_CHILD_MAX), + DEF_LIMIT_H (_POSIX_DELAYTIMER_MAX), + DEF_LIMIT_H (_POSIX_HOST_NAME_MAX), + DEF_LIMIT_H (_POSIX_LINK_MAX), + DEF_LIMIT_H (_POSIX_LOGIN_NAME_MAX), + DEF_LIMIT_H (_POSIX_MAX_CANON), + DEF_LIMIT_H (_POSIX_MAX_INPUT), + DEF_LIMIT_H (_POSIX_MQ_OPEN_MAX), + DEF_LIMIT_H (_POSIX_MQ_PRIO_MAX), + DEF_LIMIT_H (_POSIX_NAME_MAX), + DEF_LIMIT_H (_POSIX_NGROUPS_MAX), + DEF_LIMIT_H (_POSIX_OPEN_MAX), + DEF_LIMIT_H (_POSIX_PATH_MAX), + DEF_LIMIT_H (_POSIX_PIPE_BUF), + DEF_LIMIT_H (_POSIX_RE_DUP_MAX), + DEF_LIMIT_H (_POSIX_RTSIG_MAX), + DEF_LIMIT_H (_POSIX_SEM_NSEMS_MAX), + DEF_LIMIT_H (_POSIX_SEM_VALUE_MAX), + DEF_LIMIT_H (_POSIX_SIGQUEUE_MAX), + DEF_LIMIT_H (_POSIX_SSIZE_MAX), + DEF_LIMIT_H (_POSIX_STREAM_MAX), + DEF_LIMIT_H (_POSIX_SYMLINK_MAX), + DEF_LIMIT_H (_POSIX_SYMLOOP_MAX), + DEF_LIMIT_H (_POSIX_THREAD_DESTRUCTOR_ITERATIONS), + DEF_LIMIT_H (_POSIX_THREAD_KEYS_MAX), + DEF_LIMIT_H (_POSIX_THREAD_THREADS_MAX), + DEF_LIMIT_H (_POSIX_TIMER_MAX), + DEF_LIMIT_H (_POSIX_TTY_NAME_MAX), + DEF_LIMIT_H (_POSIX_TZNAME_MAX), + + DEF_LIMIT_H (_POSIX2_BC_BASE_MAX), + DEF_LIMIT_H (_POSIX2_BC_DIM_MAX), + DEF_LIMIT_H (_POSIX2_BC_SCALE_MAX), + DEF_LIMIT_H (_POSIX2_BC_STRING_MAX), + DEF_LIMIT_H (_POSIX2_CHARCLASS_NAME_MAX), + DEF_LIMIT_H (_POSIX2_COLL_WEIGHTS_MAX), + DEF_LIMIT_H (_POSIX2_EXPR_NEST_MAX), + DEF_LIMIT_H (_POSIX2_LINE_MAX), + DEF_LIMIT_H (_POSIX2_RE_DUP_MAX), + + DEF_LIMIT_H (_XOPEN_IOV_MAX), + + /* GNU extensions. */ + DEF_LIMIT_H (_POSIX_FD_SETSIZE), + DEF_LIMIT_H (_POSIX_HIWAT), + DEF_LIMIT_H (_POSIX_QLIMIT), + DEF_LIMIT_H (_POSIX_UIO_MAXIOV), + { NULL, 0, SYSCONF } }; @@ -432,7 +475,7 @@ print_all (const char *path) long int value; char *cvalue; for (c = vars; c->name != NULL; ++c) { - printf("%-35s", c->name); + printf("%-36s", c->name); switch (c->call) { case PATHCONF: value = pathconf (path, c->call_name); @@ -463,6 +506,9 @@ print_all (const char *path) printf ("%.*s\n", (int) clen, cvalue); free (cvalue); break; + case LIMITS_H: + printf ("%ld\n", c->call_name); + break; } } exit (0); @@ -703,6 +749,12 @@ environment SPEC.\n\n")); printf ("%.*s\n", (int) clen, cvalue); exit (0); + + case LIMITS_H: + if (argc - ai > 1) + usage (); + printf ("%ld\n", c->call_name); + exit (0); } } diff --git a/posix/tst-getconf-limits.py b/posix/tst-getconf-limits.py new file mode 100755 index 0000000000..e0db1619e1 --- /dev/null +++ b/posix/tst-getconf-limits.py @@ -0,0 +1,72 @@ +#!/usr/bin/python3 +# +# Test if getconf returns the symbolic constants defined in limits.h. +# Copyright (C) 2025 Free Software Foundation, Inc. +# This file is part of the GNU C Library. +# +# The GNU C Library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# The GNU C Library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with the GNU C Library; if not, see +# . + +import argparse +import glibcextract +import re +import subprocess +import sys + + +def parse_getconf(cmd): + getconf_out = subprocess.run(cmd + ['-a'], stdout=subprocess.PIPE, + check=True, universal_newlines=True).stdout + getconf_set = {} + for line in getconf_out.splitlines(): + fields = line.split() + if len(fields) == 2: + getconf_set[fields[0]] = fields[1] + return getconf_set + + +def main(): + """The main entry point.""" + parser = argparse.ArgumentParser( + description='Test if getconf returns the symbolic constants defined ' + 'in limits.h.') + parser.add_argument('--cc', metavar='CC', + help='C compiler (including options) to use') + parser.add_argument('cmd', + help='How to run getconf') + args = parser.parse_args() + + ctes = glibcextract.compute_macro_consts( + source_text='#include \n', + cc=args.cc, + macro_re='_POSIX.*', + exclude_re='_POSIX_C_SOURCE|_POSIX_SOURCE') + + getconf_ctes = parse_getconf (args.cmd.split()) + + ret = 0 + for cte,value in ctes.items(): + if cte in getconf_ctes: + if getconf_ctes[cte] != value: + print('Symbol {} is defined as {} on limits.h but getconf shows {}' + .format(cte, value, getconf_ctes[cte])) + ret = 1; + else: + print('Symbol {} not presented in getconf'.format(cte)) + ret = 1; + sys.exit(ret) + + +if __name__ == '__main__': + main()