[devel] re APT patch with impossible error on "Can't allocate an item of size zero"

* [devel] re APT patch with impossible error on "Can't allocate an item of size zero"
@ 2020-02-13  2:08 Ivan Zakharyaschev
  2020-02-13  2:43 ` Ivan Zakharyaschev
  2020-02-13 12:59 ` Aleksei Nikiforov
  0 siblings, 2 replies; 11+ messages in thread
From: Ivan Zakharyaschev @ 2020-02-13  2:08 UTC (permalink / raw)
  To: darktemplar, devel

[-- Attachment #1: Type: text/plain, Size: 8198 bytes --]

В ветке sisyphus_one_more_time в
git://git.altlinux.org/people/darktemplar/packages/apt.git в коммите

commit f53c1af17e2997ff6d2e23139bc61f5d5c82a547
Author: Aleksei Nikiforov <darktemplar@altlinux.org>
Date:   Tue Jun 11 14:53:47 2019 +0300

    dynamic memory management: apt-pkg/pkgcachegen.{cc,h} changes
    
    make the used MMap moveable (and therefore dynamic resizeable) by
    applying (some) mad pointer magic
    
    Ported from Apt from Debian
    
    Closes: https://bugzilla.altlinux.org/37373
    
    Change-Id: I4583e13077e7504ec8f59df4bcf3bc825eaf6202

есть такой hunk касательно DynamicMMap::RawAllocate():

diff --git a/apt/apt-pkg/contrib/mmap.cc b/apt/apt-pkg/contrib/mmap.cc
index d7a5c3a68..36dc11524 100644
--- a/apt/apt-pkg/contrib/mmap.cc
+++ b/apt/apt-pkg/contrib/mmap.cc
@@ -226,6 +245,12 @@ unsigned long DynamicMMap::RawAllocate(unsigned long Size,unsigned long Aln)
    size in the file. */
 unsigned long DynamicMMap::Allocate(unsigned long ItemSize)
 {   
+   if (ItemSize == 0)
+   {
+      _error->Error("Can't allocate an item of size zero");
+      return 0;
+   }
+
    // Look for a matching pool entry
    Pool *I;
    Pool *Empty = 0;

(Весь контекст изменений в этой функции в конце письма.)

Во-первых, почему бы это изменение не оформить отдельным коммитом, ведь
оно касается проверки правильности аргументов функции и не связано
тесно с тем, есть ли у нас динамическое изменение размера DynamicMMap
с помощью realloc/mremap? (Кстати, summary в коммите можно было бы
сделать более информативным, чем просто "changes".)

Во-вторых, я подумал, что это такой класс ошибок, который не возникает
в run-time из-за плохих данных или отказа ОС (например, выделить
память или прочитать файл) -- т.е. не что-то заранее непредсказуемое
для программиста и поэтому требующее специальной обработки в run-time.

Если програмист написал всё так, как он хотел, то он не передаст
неправильный аргумент (0) в функцию. (Да и понятно, что в реальном
коде APT это не ожидается: там обычно этот аргумент заполняется
константой sizeof(...).)

Я бы предложил такие требования (имеющие характер спецификации того,
что программист задумал реализовать) оформлять просто с помощью
assert.

Так будет легче понимать код: сразу ясно, что выполнение этого условия
(важного для корректности кода в теле функции) просто гарантируется
тем, как весь наш код написан и вообще-то может быть обосновано ещё до
run-time (просто глядя на исходный код, на том же этапе работы, что и
запускаем компилятор).

Для справки: единственный вызов Allocate() в коде, который находится с
помощью

git grep -nH -Ee '(^|[^[:alpha:]])Allocate\('

это:

std::experimental::optional<map_ptrloc> pkgCacheGenerator::AllocateInMap(unsigned long size) {/*{{{*/
   void *oldMap = Map.Data();
   const auto index = Map.Allocate(size);
   if (index)
      ReMap(oldMap, Map.Data());
   return index;
}

поищем, как используется AllocateInMap():

git --no-pager grep -nH -Ee '(^|[^[:alpha:]])AllocateInMap\('
apt/apt-pkg/pkgcachegen.cc:167:std::experimental::optional<map_ptrloc> pkgCacheGenerator::AllocateInMap(unsigned long size) {/*{{{*/
apt/apt-pkg/pkgcachegen.cc:449:   const auto Package = AllocateInMap(sizeof(pkgCache::Package));
apt/apt-pkg/pkgcachegen.cc:502:   const auto VerFile = AllocateInMap(sizeof(pkgCache::VerFile));
apt/apt-pkg/pkgcachegen.cc:533:   const auto Version = AllocateInMap(sizeof(pkgCache::Version));
apt/apt-pkg/pkgcachegen.cc:561:   const auto Dependency = Owner->AllocateInMap(sizeof(pkgCache::Dependency));
apt/apt-pkg/pkgcachegen.cc:639:   const auto Provides = Owner->AllocateInMap(sizeof(pkgCache::Provides));
apt/apt-pkg/pkgcachegen.cc:686:   const auto idxFile = AllocateInMap(sizeof(*CurrentFile));
apt/apt-pkg/pkgcachegen.cc:744:   const auto Item = AllocateInMap(sizeof(pkgCache::StringItem));
apt/apt-pkg/pkgcachegen.h:45:   std::experimental::optional<map_ptrloc> AllocateInMap(unsigned long size);

-- как я и подозревал, константа времени компиляции sizeof(...).

Я за assert в обсуждаемом месте.

Примеры использования assert в коде APT:

git --no-pager grep -nH -Ee '(^|[^_[:alpha:]])assert\('
apt/apt-pkg/acquire-item.cc:309:	 assert(Repository == NULL || Repository->IsAuthenticated() == false);
apt/apt-pkg/acquire-item.cc:390:   assert(Master == false || Repository != NULL);
apt/apt-pkg/luaiface.cc:125:   assert(lua_istable(L, -1));
apt/apt-pkg/luaiface.cc:198:   assert(lua_istable(L, -1));
apt/apt-pkg/luaiface.cc:220:	 assert(lua_gettop(L) == 0);
apt/apt-pkg/pkgcache.cc:421:	 assert(Size < sizeof(Res)/sizeof(*Res));
apt/apt-pkg/pkgcache.cc:450:	 assert(Size < sizeof(Res)/sizeof(*Res));
apt/apt-pkg/rpm/rpmhandler.cc:106:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmhandler.cc:112:   assert(rc != 0);
apt/apt-pkg/rpm/rpmhandler.cc:124:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmhandler.cc:141:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmhandler.cc:149:      assert(i != NULL);
apt/apt-pkg/rpm/rpmhandler.cc:162:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmhandler.cc:207:   assert(Offset == 0);
apt/apt-pkg/rpm/rpmrecords.cc:92:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmrecords.cc:114:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmrecords.cc:128:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmrecords.cc:146:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmrecords.cc:211:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmrecords.cc:329:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmrecords.cc:369:   assert(type == RPM_STRING_ARRAY_TYPE || count == 0);
apt/apt-pkg/rpm/rpmrecords.cc:406:   assert(type == RPM_STRING_ARRAY_TYPE || count == 0);
apt/apt-pkg/rpm/rpmrecords.cc:423:   assert(type == RPM_STRING_ARRAY_TYPE || count == 0);
apt/apt-pkg/rpm/rpmrecords.cc:440:   assert(type == RPM_STRING_ARRAY_TYPE || count == 0);
apt/apt-pkg/rpm/rpmsrcrecords.cc:71:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmsrcrecords.cc:89:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmsrcrecords.cc:136:   assert(HeaderP != NULL);
apt/apt-pkg/rpm/rpmsrcrecords.cc:378:   assert(type == RPM_STRING_ARRAY_TYPE || count == 0);
apt/apt-pkg/rpm/rpmsrcrecords.cc:415:   assert(type == RPM_STRING_ARRAY_TYPE || count == 0);
apt/buildlib/ltmain.sh:4808:  assert(path != NULL);
apt/buildlib/ltmain.sh:4833:  assert(str != NULL);
apt/buildlib/ltmain.sh:4834:  assert(pat != NULL);
apt/lua/lapi.c:38:#define api_check(L, o)		/*{ assert(o); }*/
apt/lua/ltests.c:358:  assert(lua_gettop(L) == level+1);  /* +1 for result */
apt/lua/ltests.c:365:  assert(lua_gettop(L) == level+1);
apt/lua/ltests.c:372:  assert(lua_gettop(L) == level);
apt/tools/cached_md5.cc:45:      assert(p1);
apt/tools/cached_md5.cc:50:      assert(p2);
apt/tools/genpkglist.cc:206:   assert(l1.bnc == l1.dic);
apt/tools/genpkglist.cc:237:   assert(l2.bnc == l2.dic);


* * *

Весь контекст изменений в DynamicMMap::RawAllocate():

diff --git a/apt/apt-pkg/contrib/mmap.cc b/apt/apt-pkg/contrib/mmap.cc
index d7a5c3a68..36dc11524 100644
--- a/apt/apt-pkg/contrib/mmap.cc
+++ b/apt/apt-pkg/contrib/mmap.cc
@@ -226,6 +245,12 @@ unsigned long DynamicMMap::RawAllocate(unsigned long Size,unsigned long Aln)
    size in the file. */
 unsigned long DynamicMMap::Allocate(unsigned long ItemSize)
 {   
+   if (ItemSize == 0)
+   {
+      _error->Error("Can't allocate an item of size zero");
+      return 0;
+   }
+
    // Look for a matching pool entry
    Pool *I;
    Pool *Empty = 0;
@@ -252,15 +277,26 @@ unsigned long DynamicMMap::Allocate(unsigned long ItemSize)
       I->Count = 0;
    }
    
+   unsigned long Result = 0;
    // Out of space, allocate some more
    if (I->Count == 0)
    {
-      I->Count = 20*1024/ItemSize;
-      I->Start = RawAllocate(I->Count*ItemSize,ItemSize);
-   }   
+      const unsigned long size = 20*1024;
+      I->Count = size/ItemSize;
+      Pool* oldPools = Pools;
+      Result = RawAllocate(I->Count*ItemSize,ItemSize);
+      if (Result == 0)
+         return 0;
+
+      if (Pools != oldPools)
+         I = RebasePointer(I, oldPools, Pools);
+
+      I->Start = Result;
+   }
+   else
+      Result = I->Start;
 
    I->Count--;
-   unsigned long Result = I->Start;
    I->Start += ItemSize;  
    return Result/ItemSize;
 }

-- 
Best regards,
Ivan

^ permalink raw reply	[flat|nested] 11+ messages in thread