seven_zip_ruby 1.0.0

data/ext/p7zip/C/Aes.h

@@ -0,0 +1,38 @@
+/* Aes.h -- AES encryption / decryption
+2009-11-23 : Igor Pavlov : Public domain */
+
+#ifndef __AES_H
+#define __AES_H
+
+#include "Types.h"
+
+EXTERN_C_BEGIN
+
+#define AES_BLOCK_SIZE 16
+
+/* Call AesGenTables one time before other AES functions */
+void AesGenTables(void);
+
+/* UInt32 pointers must be 16-byte aligned */
+
+/* 16-byte (4 * 32-bit words) blocks: 1 (IV) + 1 (keyMode) + 15 (AES-256 roundKeys) */
+#define AES_NUM_IVMRK_WORDS ((1 + 1 + 15) * 4)
+
+/* aes - 16-byte aligned pointer to keyMode+roundKeys sequence */
+/* keySize = 16 or 24 or 32 (bytes) */
+typedef void (MY_FAST_CALL *AES_SET_KEY_FUNC)(UInt32 *aes, const Byte *key, unsigned keySize);
+void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *aes, const Byte *key, unsigned keySize);
+void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *aes, const Byte *key, unsigned keySize);
+
+/* ivAes - 16-byte aligned pointer to iv+keyMode+roundKeys sequence: UInt32[AES_NUM_IVMRK_WORDS] */
+void AesCbc_Init(UInt32 *ivAes, const Byte *iv); /* iv size is AES_BLOCK_SIZE */
+/* data - 16-byte aligned pointer to data */
+/* numBlocks - the number of 16-byte blocks in data array */
+typedef void (MY_FAST_CALL *AES_CODE_FUNC)(UInt32 *ivAes, Byte *data, size_t numBlocks);
+extern AES_CODE_FUNC g_AesCbc_Encode;
+extern AES_CODE_FUNC g_AesCbc_Decode;
+extern AES_CODE_FUNC g_AesCtr_Code;
+
+EXTERN_C_END
+
+#endif

data/ext/p7zip/C/Alloc.back3

@@ -0,0 +1,238 @@
+/* Alloc.c -- Memory allocation functions
+2008-09-24
+Igor Pavlov
+Public domain */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#ifdef _7ZIP_LARGE_PAGES
+
+#ifdef __linux__
+
+#ifndef _7ZIP_ST
+#include <pthread.h>
+#endif
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+#ifndef SHM_HUGETLB
+#warning SHM_HUGETLB undefined ?
+#define SHM_HUGETLB 04000
+#endif
+
+/* Only ia64 requires this */
+#ifdef __ia64__
+#define ADDR (void *)(0x8000000000000000UL)
+#define SHMAT_FLAGS (SHM_RND)
+#else
+#define ADDR (void *)(0x0UL)
+#define SHMAT_FLAGS (0)
+#endif
+
+
+#endif /*  __linux__ */
+
+#endif /* _7ZIP_LARGE_PAGES */
+
+#include "Alloc.h"
+
+/* #define _SZ_ALLOC_DEBUG */
+
+/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
+#ifdef _SZ_ALLOC_DEBUG
+#include <stdio.h>
+int g_allocCount = 0;
+int g_allocCountMid = 0;
+int g_allocCountBig = 0;
+#endif
+
+void *MyAlloc(size_t size)
+{
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  {
+    void *p = malloc(size);
+    fprintf(stderr, "\nAlloc %10d bytes, count = %10d,  addr = %8X", size, g_allocCount++, (unsigned)p);
+    return p;
+  }
+  #else
+  return malloc(size);
+  #endif
+}
+
+void MyFree(void *address)
+{
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+    fprintf(stderr, "\nFree; count = %10d,  addr = %8X", --g_allocCount, (unsigned)address);
+  #endif
+  free(address);
+}
+
+#ifdef __linux__
+#define _7ZIP_MAX_HUGE_ALLOCS 64
+static void *g_HugePageAddr[_7ZIP_MAX_HUGE_ALLOCS] = { NULL };
+static void *g_HugePageShmid[_7ZIP_MAX_HUGE_ALLOCS];
+static size_t g_HugePageLen[_7ZIP_MAX_HUGE_ALLOCS];
+#endif
+
+static void *VirtualAlloc(void *address, size_t size, int AllocLargePages)
+{
+  #ifdef _7ZIP_LARGE_PAGES
+  if (AllocLargePages)
+  {
+    #ifdef __linux__
+    /* huge pages support for Linux; added by Joachim Henke */
+    #ifndef _7ZIP_ST
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    #endif
+    int i;
+
+    address = NULL;
+    #ifndef _7ZIP_ST
+    pthread_mutex_lock(&mutex);
+    #endif
+    for (i = 0; i < _7ZIP_MAX_HUGE_ALLOCS; ++i)
+    {
+      if (g_HugePageAddr[i] == NULL)
+      {
+        char *shmaddr;
+        int shmid = shmget(2, size, SHM_HUGETLB | IPC_CREAT | SHM_R | SHM_W);
+        if (shmid < 0)
+        {
+          fprintf(stderr,"Warning shmget : %s\n",strerror(errno));
+          address = NULL;
+          break;
+        }
+        shmaddr = shmat(shmid, ADDR, SHMAT_FLAGS);
+        if (shmaddr == (char *)-1)
+        {
+          fprintf(stderr,"Warning shmat : %s\n",strerror(errno));
+          shmctl(shmid, IPC_RMID, NULL);
+          address = NULL;
+          break;
+        }
+        
+        g_HugePageShmid[i] = shmid;
+        g_HugePageLen[i] = size;
+        g_HugePageAddr[i] = address;
+printf("HUGE[%d]=%ld %p\n",i,(long)size,address);
+        break;
+      }
+    }
+    #ifndef _7ZIP_ST
+    pthread_mutex_unlock(&mutex);
+    #endif
+    return address;
+    #endif
+  }
+  #endif
+  return malloc(size);
+}
+
+static int VirtualFree(void *address)
+{
+  #ifdef _7ZIP_LARGE_PAGES
+  #ifdef __linux__
+  int i;
+
+  for (i = 0; i < _7ZIP_MAX_HUGE_ALLOCS; ++i)
+  {
+    if (g_HugePageAddr[i] == address)
+    {
+      shmdt(g_HugePageAddr[i]);
+      shmctl(g_HugePageLen[i], IPC_RMID, NULL);
+      g_HugePageAddr[i] = NULL;
+      return 1;
+    }
+  }
+  #endif
+  #endif
+  free(address);
+  return 1;
+}
+
+void *MidAlloc(size_t size)
+{
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc_Mid %10d bytes;  count = %10d", size, g_allocCountMid++);
+  #endif
+  return VirtualAlloc(0, size, 0);
+}
+
+void MidFree(void *address)
+{
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+    fprintf(stderr, "\nFree_Mid; count = %10d", --g_allocCountMid);
+  #endif
+  if (address == 0)
+    return;
+  VirtualFree(address);
+}
+
+#ifdef _7ZIP_LARGE_PAGES
+size_t g_LargePageSize = 0;
+#endif
+
+void SetLargePageSize()
+{
+printf("SetLargePageSize : <>\n");
+  #ifdef _7ZIP_LARGE_PAGES
+  size_t size = 0;
+
+#if defined(__linux__)
+  size = sysconf(_SC_PAGESIZE);
+printf("SetLargePageSize : size=%ld\n",(long)size);
+  if (size == -1) size = 0;
+#endif
+
+  if (size == 0 || (size & (size - 1)) != 0)
+    return;
+  g_LargePageSize = size;
+printf("SetLargePageSize : %ld\n",(long)g_LargePageSize);
+  #endif
+}
+
+
+void *BigAlloc(size_t size)
+{
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc_Big %10d bytes;  count = %10d", size, g_allocCountBig++);
+  #endif
+  
+  #ifdef _7ZIP_LARGE_PAGES
+  if (g_LargePageSize != 0 && g_LargePageSize <= (1 << 30) && size >= (1 << 18))
+  {
+    void *res = VirtualAlloc(0, (size + g_LargePageSize - 1) & (~(g_LargePageSize - 1)),1);
+printf("BigAlloc : %ld %ld => %p\n",(long)g_LargePageSize,(long)size,res);
+    if (res != 0)
+      return res;
+  }
+  #endif
+  return VirtualAlloc(0, size, 0);
+}
+
+void BigFree(void *address)
+{
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+    fprintf(stderr, "\nFree_Big; count = %10d", --g_allocCountBig);
+  #endif
+  
+  if (address == 0)
+    return;
+  VirtualFree(address);
+}

data/ext/p7zip/C/Alloc.c

@@ -0,0 +1,280 @@
+/* Alloc.c -- Memory allocation functions
+2008-09-24
+Igor Pavlov
+Public domain */
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef _7ZIP_LARGE_PAGES
+#ifdef __linux__
+#ifndef _7ZIP_ST
+#include <pthread.h>
+#endif
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <mntent.h>
+#endif
+#endif
+
+#include "Alloc.h"
+
+/* #define _SZ_ALLOC_DEBUG */
+
+/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
+#ifdef _SZ_ALLOC_DEBUG
+#include <stdio.h>
+int g_allocCount = 0;
+int g_allocCountMid = 0;
+int g_allocCountBig = 0;
+#endif
+
+void *MyAlloc(size_t size)
+{
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  {
+    void *p = malloc(size);
+    fprintf(stderr, "\nAlloc %10d bytes, count = %10d,  addr = %8X", size, g_allocCount++, (unsigned)p);
+    return p;
+  }
+  #else
+  return malloc(size);
+  #endif
+}
+
+void MyFree(void *address)
+{
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+    fprintf(stderr, "\nFree; count = %10d,  addr = %8X", --g_allocCount, (unsigned)address);
+  #endif
+  free(address);
+}
+
+#ifndef _WIN32
+
+#ifdef _7ZIP_LARGE_PAGES
+
+#ifdef __linux__
+#define _7ZIP_MAX_HUGE_ALLOCS 64
+static void *g_HugePageAddr[_7ZIP_MAX_HUGE_ALLOCS] = { NULL };
+static size_t g_HugePageLen[_7ZIP_MAX_HUGE_ALLOCS];
+static char *g_HugetlbPath;
+#endif
+
+#endif
+
+static void *VirtualAlloc(size_t size, int memLargePages)
+{
+  #ifdef _7ZIP_LARGE_PAGES
+  if (memLargePages)
+  {
+    #ifdef __linux__
+    /* huge pages support for Linux; added by Joachim Henke */
+    #ifndef _7ZIP_ST
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    #endif
+    int i;
+
+    void * address = NULL;
+    #ifndef _7ZIP_ST
+    pthread_mutex_lock(&mutex);
+    #endif
+    for (i = 0; i < _7ZIP_MAX_HUGE_ALLOCS; ++i)
+    {
+      if (g_HugePageAddr[i] == NULL)
+      {
+        int fd, pathlen = strlen(g_HugetlbPath);
+        char tempname[pathlen+12];
+
+        memcpy(tempname, g_HugetlbPath, pathlen);
+        memcpy(tempname + pathlen, "/7z-XXXXXX", 11);
+        fd = mkstemp(tempname);
+        unlink(tempname);
+        if (fd < 0)
+        {
+          fprintf(stderr,"cant't open %s (%s)\n",tempname,strerror(errno));
+          break;
+        }
+        address = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        close(fd);
+        if (address == MAP_FAILED)
+        {
+          address = NULL;
+          break;
+        }
+        g_HugePageLen[i] = size;
+        g_HugePageAddr[i] = address;
+// fprintf(stderr,"HUGE[%d]=%ld %p\n",i,(long)size,address);
+        break;
+      }
+    }
+    #ifndef _7ZIP_ST
+    pthread_mutex_unlock(&mutex);
+    #endif
+    return address;
+    #endif
+  }
+  #endif
+  return malloc(size);
+}
+
+static int VirtualFree(void *address)
+{
+  #ifdef _7ZIP_LARGE_PAGES
+  #ifdef __linux__
+  int i;
+
+  for (i = 0; i < _7ZIP_MAX_HUGE_ALLOCS; ++i)
+  {
+    if (g_HugePageAddr[i] == address)
+    {
+      munmap(address, g_HugePageLen[i]);
+      g_HugePageAddr[i] = NULL;
+      return 1;
+    }
+  }
+  #endif
+  #endif
+  free(address);
+  return 1;
+}
+
+#endif
+
+void *MidAlloc(size_t size)
+{
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc_Mid %10d bytes;  count = %10d", size, g_allocCountMid++);
+  #endif
+  return VirtualAlloc(size, 0);
+}
+
+void MidFree(void *address)
+{
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+    fprintf(stderr, "\nFree_Mid; count = %10d", --g_allocCountMid);
+  #endif
+  if (address == 0)
+    return;
+  VirtualFree(address);
+}
+
+#ifdef _7ZIP_LARGE_PAGES
+size_t g_LargePageSize = 0;
+#ifdef _WIN32
+typedef SIZE_T (WINAPI *GetLargePageMinimumP)();
+#elif defined(__linux__)
+size_t largePageMinimum()
+{
+  size_t size;
+
+  g_HugetlbPath = getenv("HUGETLB_PATH");
+
+  if (g_HugetlbPath == NULL)
+  {
+    // not defined => try to find out the directory
+    static char dir_hugetlbfs[1024];
+    const char * filename = "/etc/mtab"; // mounted filesystems
+    FILE *fp;
+    struct mntent * info;
+
+    dir_hugetlbfs[0]=0;
+
+    fp = setmntent(filename,"r");
+    if (fp)
+    {
+      info = getmntent(fp);
+      while(info)
+      {
+/*
+        printf("%s:\n",info->mnt_fsname);
+        printf("  dir='%s'\n",info->mnt_dir);
+        printf("  type='%s'\n",info->mnt_type);
+*/
+
+        if (strcmp(info->mnt_type,"hugetlbfs") == 0)
+        {
+          strcpy(dir_hugetlbfs,info->mnt_dir);
+          break;
+        }
+
+        info = getmntent(fp);
+      }
+      endmntent(fp);
+    }
+
+    if (dir_hugetlbfs[0])
+    {
+      g_HugetlbPath = dir_hugetlbfs;
+      // fprintf(stderr," Found hugetlbfs = '%s'\n",g_HugetlbPath);
+    }
+  }
+  if (g_HugetlbPath == NULL || (size = pathconf(g_HugetlbPath, _PC_REC_MIN_XFER_SIZE)) <= getpagesize())
+    return 0;
+  return size;
+}
+#else
+#define largePageMinimum() 0
+#endif
+#endif
+
+void SetLargePageSize()
+{
+  #ifdef _7ZIP_LARGE_PAGES
+  size_t size;
+  #ifdef _WIN32
+  GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)
+        GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");
+  if (largePageMinimum == 0)
+    return;
+  #endif
+  size = largePageMinimum();
+  if (size == 0 || (size & (size - 1)) != 0)
+    return;
+  g_LargePageSize = size;
+  // fprintf(stderr,"SetLargePageSize : %ld\n",(long)g_LargePageSize);
+  #endif
+}
+
+
+void *BigAlloc(size_t size)
+{
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc_Big %10d bytes;  count = %10d", size, g_allocCountBig++);
+  #endif
+  
+  #ifdef _7ZIP_LARGE_PAGES
+  if (g_LargePageSize != 0 && g_LargePageSize <= (1 << 30) && size >= (1 << 18))
+  {
+    void *res = VirtualAlloc( (size + g_LargePageSize - 1) & (~(g_LargePageSize - 1)), 1);
+    if (res != 0)
+      return res;
+  }
+  #endif
+  return VirtualAlloc(size, 0);
+}
+
+void BigFree(void *address)
+{
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+    fprintf(stderr, "\nFree_Big; count = %10d", --g_allocCountBig);
+  #endif
+  
+  if (address == 0)
+    return;
+  VirtualFree(address);
+}