maria-10.0.16 merge

bzr merge -r4588 maria/10.0

8 files changed, 506 insertions, 334 deletions

diff --git a/extra/CMakeLists.txt b/extra/CMakeLists.txt
index f8f71b00743..585b5aef6f6 100644
--- a/extra/CMakeLists.txt
+++ b/extra/CMakeLists.txt
@@ -75,11 +75,29 @@ ENDIF()
 MYSQL_ADD_EXECUTABLE(replace replace.c COMPONENT Server)
 TARGET_LINK_LIBRARIES(replace mysys)
 IF(UNIX)
-  MYSQL_ADD_EXECUTABLE(innochecksum innochecksum.c)
-
   MYSQL_ADD_EXECUTABLE(resolve_stack_dump resolve_stack_dump.c)
   TARGET_LINK_LIBRARIES(resolve_stack_dump mysys)
 
   MYSQL_ADD_EXECUTABLE(mysql_waitpid mysql_waitpid.c COMPONENT Client)
   TARGET_LINK_LIBRARIES(mysql_waitpid mysys)
 ENDIF()
+
+
+  # Add path to the InnoDB headers
+  INCLUDE_DIRECTORIES(
+    ${CMAKE_SOURCE_DIR}/storage/innobase/include
+    ${CMAKE_SOURCE_DIR}/sql)
+
+  # We use the InnoDB code directly in case the code changes.
+  ADD_DEFINITIONS("-DUNIV_INNOCHECKSUM")
+  SET(INNOBASE_SOURCES
+      ../storage/innobase/buf/buf0checksum.cc
+      ../storage/innobase/ut/ut0crc32.cc
+      ../storage/innobase/ut/ut0ut.cc
+      ../storage/innobase/page/page0zip.cc
+      )
+
+  MYSQL_ADD_EXECUTABLE(innochecksum innochecksum.cc ${INNOBASE_SOURCES})
+  TARGET_LINK_LIBRARIES(innochecksum mysys mysys_ssl)
+  ADD_DEPENDENCIES(innochecksum GenError)
+
diff --git a/extra/innochecksum.c b/extra/innochecksum.c
deleted file mode 100644
index ed4dfc48789..00000000000
--- a/extra/innochecksum.c
+++ /dev/null
@@ -1,325 +0,0 @@
-/*
-   Copyright (c) 2005, 2011, Oracle and/or its affiliates
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; version 2 of the License.
-
-   This program 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 General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
-*/
-
-/*
-  InnoDB offline file checksum utility.  85% of the code in this file
-  was taken wholesale fron the InnoDB codebase.
-
-  The final 15% was originally written by Mark Smith of Danga
-  Interactive, Inc. <junior@danga.com>
-
-  Published with a permission.
-*/
-
-#include <my_global.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-/* all of these ripped from InnoDB code from MySQL 4.0.22 */
-#define UT_HASH_RANDOM_MASK     1463735687
-#define UT_HASH_RANDOM_MASK2    1653893711
-#define FIL_PAGE_LSN          16 
-#define FIL_PAGE_FILE_FLUSH_LSN 26
-#define FIL_PAGE_OFFSET     4
-#define FIL_PAGE_DATA       38
-#define FIL_PAGE_END_LSN_OLD_CHKSUM 8
-#define FIL_PAGE_SPACE_OR_CHKSUM 0
-#define UNIV_PAGE_SIZE          (2 * 8192)
-
-/* command line argument to do page checks (that's it) */
-/* another argument to specify page ranges... seek to right spot and go from there */
-
-typedef unsigned long int ulint;
-
-/* innodb function in name; modified slightly to not have the ASM version (lots of #ifs that didn't apply) */
-ulint mach_read_from_4(uchar *b)
-{
-  return( ((ulint)(b[0]) << 24)
-          + ((ulint)(b[1]) << 16)
-          + ((ulint)(b[2]) << 8)
-          + (ulint)(b[3])
-          );
-}
-
-ulint
-ut_fold_ulint_pair(
-/*===============*/
-            /* out: folded value */
-    ulint   n1, /* in: ulint */
-    ulint   n2) /* in: ulint */
-{
-    return(((((n1 ^ n2 ^ UT_HASH_RANDOM_MASK2) << 8) + n1)
-                        ^ UT_HASH_RANDOM_MASK) + n2);
-}
-
-ulint
-ut_fold_binary(
-/*===========*/
-            /* out: folded value */
-    uchar*   str,    /* in: string of bytes */
-    ulint   len)    /* in: length */
-{
-    ulint   i;
-    ulint   fold= 0;
-
-    for (i= 0; i < len; i++)
-    {
-      fold= ut_fold_ulint_pair(fold, (ulint)(*str));
-
-      str++;
-    }
-
-    return(fold);
-}
-
-ulint
-buf_calc_page_new_checksum(
-/*=======================*/
-               /* out: checksum */
-    uchar*    page) /* in: buffer page */
-{
-    ulint checksum;
-
-    /* Since the fields FIL_PAGE_FILE_FLUSH_LSN and ..._ARCH_LOG_NO
-    are written outside the buffer pool to the first pages of data
-    files, we have to skip them in the page checksum calculation.
-    We must also skip the field FIL_PAGE_SPACE_OR_CHKSUM where the
-    checksum is stored, and also the last 8 bytes of page because
-    there we store the old formula checksum. */
-
-    checksum= ut_fold_binary(page + FIL_PAGE_OFFSET,
-                             FIL_PAGE_FILE_FLUSH_LSN - FIL_PAGE_OFFSET)
-            + ut_fold_binary(page + FIL_PAGE_DATA,
-                             UNIV_PAGE_SIZE - FIL_PAGE_DATA
-                             - FIL_PAGE_END_LSN_OLD_CHKSUM);
-    checksum= checksum & 0xFFFFFFFF;
-
-    return(checksum);
-}
-
-ulint
-buf_calc_page_old_checksum(
-/*=======================*/
-               /* out: checksum */
-    uchar*    page) /* in: buffer page */
-{
-    ulint checksum;
-
-    checksum= ut_fold_binary(page, FIL_PAGE_FILE_FLUSH_LSN);
-
-    checksum= checksum & 0xFFFFFFFF;
-
-    return(checksum);
-}
-
-
-int main(int argc, char **argv)
-{
-  FILE *f;                     /* our input file */
-  uchar *p;                     /* storage of pages read */
-  int bytes;                   /* bytes read count */
-  ulint ct;                    /* current page number (0 based) */
-  int now;                     /* current time */
-  int lastt;                   /* last time */
-  ulint oldcsum, oldcsumfield, csum, csumfield, logseq, logseqfield; /* ulints for checksum storage */
-  struct stat st;              /* for stat, if you couldn't guess */
-  unsigned long long int size; /* size of file (has to be 64 bits) */
-  ulint pages;                 /* number of pages in file */
-  ulint start_page= 0, end_page= 0, use_end_page= 0; /* for starting and ending at certain pages */
-  off_t offset= 0;
-  int just_count= 0;          /* if true, just print page count */
-  int verbose= 0;
-  int debug= 0;
-  int c;
-  int fd;
-
-  /* remove arguments */
-  while ((c= getopt(argc, argv, "cvds:e:p:")) != -1)
-  {
-    switch (c)
-    {
-    case 'v':
-      verbose= 1;
-      break;
-    case 'c':
-      just_count= 1;
-      break;
-    case 's':
-      start_page= atoi(optarg);
-      break;
-    case 'e':
-      end_page= atoi(optarg);
-      use_end_page= 1;
-      break;
-    case 'p':
-      start_page= atoi(optarg);
-      end_page= atoi(optarg);
-      use_end_page= 1;
-      break;
-    case 'd':
-      debug= 1;
-      break;
-    case ':':
-      fprintf(stderr, "option -%c requires an argument\n", optopt);
-      return 1;
-      break;
-    case '?':
-      fprintf(stderr, "unrecognized option: -%c\n", optopt);
-      return 1;
-      break;
-    }
-  }
-
-  /* debug implies verbose... */
-  if (debug) verbose= 1;
-
-  /* make sure we have the right arguments */
-  if (optind >= argc)
-  {
-    printf("InnoDB offline file checksum utility.\n");
-    printf("usage: %s [-c] [-s <start page>] [-e <end page>] [-p <page>] [-v] [-d] <filename>\n", argv[0]);
-    printf("\t-c\tprint the count of pages in the file\n");
-    printf("\t-s n\tstart on this page number (0 based)\n");
-    printf("\t-e n\tend at this page number (0 based)\n");
-    printf("\t-p n\tcheck only this page (0 based)\n");
-    printf("\t-v\tverbose (prints progress every 5 seconds)\n");
-    printf("\t-d\tdebug mode (prints checksums for each page)\n");
-    return 1;
-  }
-
-  /* stat the file to get size and page count */
-  if (stat(argv[optind], &st))
-  {
-    perror("error statting file");
-    return 1;
-  }
-  size= st.st_size;
-  pages= size / UNIV_PAGE_SIZE;
-  if (just_count)
-  {
-    printf("%lu\n", pages);
-    return 0;
-  }
-  else if (verbose)
-  {
-    printf("file %s = %llu bytes (%lu pages)...\n", argv[optind], size, pages);
-    printf("checking pages in range %lu to %lu\n", start_page, use_end_page ? end_page : (pages - 1));
-  }
-
-  /* open the file for reading */
-  f= fopen(argv[optind], "r");
-  if (!f)
-  {
-    perror("error opening file");
-    return 1;
-  }
-
-  /* seek to the necessary position */
-  if (start_page)
-  {
-    fd= fileno(f);
-    if (!fd)
-    {
-      perror("unable to obtain file descriptor number");
-      return 1;
-    }
-
-    offset= (off_t)start_page * (off_t)UNIV_PAGE_SIZE;
-
-    if (lseek(fd, offset, SEEK_SET) != offset)
-    {
-      perror("unable to seek to necessary offset");
-      return 1;
-    }
-  }
-
-  /* allocate buffer for reading (so we don't realloc every time) */
-  p= (uchar *)malloc(UNIV_PAGE_SIZE);
-
-  /* main checksumming loop */
-  ct= start_page;
-  lastt= 0;
-  while (!feof(f))
-  {
-    bytes= fread(p, 1, UNIV_PAGE_SIZE, f);
-    if (!bytes && feof(f)) return 0;
-    if (bytes != UNIV_PAGE_SIZE)
-    {
-      fprintf(stderr, "bytes read (%d) doesn't match universal page size (%d)\n", bytes, UNIV_PAGE_SIZE);
-      return 1;
-    }
-
-    /* check the "stored log sequence numbers" */
-    logseq= mach_read_from_4(p + FIL_PAGE_LSN + 4);
-    logseqfield= mach_read_from_4(p + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM + 4);
-    if (debug)
-      printf("page %lu: log sequence number: first = %lu; second = %lu\n", ct, logseq, logseqfield);
-    if (logseq != logseqfield)
-    {
-      fprintf(stderr, "page %lu invalid (fails log sequence number check)\n", ct);
-      return 1;
-    }
-
-    /* check old method of checksumming */
-    oldcsum= buf_calc_page_old_checksum(p);
-    oldcsumfield= mach_read_from_4(p + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM);
-    if (debug)
-      printf("page %lu: old style: calculated = %lu; recorded = %lu\n", ct, oldcsum, oldcsumfield);
-    if (oldcsumfield != mach_read_from_4(p + FIL_PAGE_LSN) && oldcsumfield != oldcsum)
-    {
-      fprintf(stderr, "page %lu invalid (fails old style checksum)\n", ct);
-      return 1;
-    }
-
-    /* now check the new method */
-    csum= buf_calc_page_new_checksum(p);
-    csumfield= mach_read_from_4(p + FIL_PAGE_SPACE_OR_CHKSUM);
-    if (debug)
-      printf("page %lu: new style: calculated = %lu; recorded = %lu\n", ct, csum, csumfield);
-    if (csumfield != 0 && csum != csumfield)
-    {
-      fprintf(stderr, "page %lu invalid (fails new style checksum)\n", ct);
-      return 1;
-    }
-
-    /* end if this was the last page we were supposed to check */
-    if (use_end_page && (ct >= end_page))
-      return 0;
-
-    /* do counter increase and progress printing */
-    ct++;
-    if (verbose)
-    {
-      if (ct % 64 == 0)
-      {
-        now= time(0);
-        if (!lastt) lastt= now;
-        if (now - lastt >= 1)
-        {
-          printf("page %lu okay: %.3f%% done\n", (ct - 1), (float) ct / pages * 100);
-          lastt= now;
-        }
-      }
-    }
-  }
-  return 0;
-}
-
diff --git a/extra/innochecksum.cc b/extra/innochecksum.cc
new file mode 100644
index 00000000000..5a0f7c630d3
--- /dev/null
+++ b/extra/innochecksum.cc
@@ -0,0 +1,470 @@
+/*
+   Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program 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 General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+/*
+  InnoDB offline file checksum utility.  85% of the code in this utility
+  is included from the InnoDB codebase.
+
+  The final 15% was originally written by Mark Smith of Danga
+  Interactive, Inc. <junior@danga.com>
+
+  Published with a permission.
+*/
+
+#include <my_global.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifndef __WIN__
+# include <unistd.h>
+#endif
+#include <my_getopt.h>
+#include <m_string.h>
+#include <welcome_copyright_notice.h> /* ORACLE_WELCOME_COPYRIGHT_NOTICE */
+#include <string.h>
+
+/* Only parts of these files are included from the InnoDB codebase.
+The parts not included are excluded by #ifndef UNIV_INNOCHECKSUM. */
+
+#include "univ.i"                /*  include all of this */
+
+#define FLST_NODE_SIZE (2 * FIL_ADDR_SIZE)
+#define FSEG_PAGE_DATA FIL_PAGE_DATA
+
+#include "ut0ut.h"
+#include "ut0byte.h"
+#include "mach0data.h"
+#include "fsp0types.h"
+#include "rem0rec.h"
+#include "buf0checksum.h"        /* buf_calc_page_*() */
+#include "fil0fil.h"             /* FIL_* */
+#include "page0page.h"           /* PAGE_* */
+#include "page0zip.h"            /* page_zip_*() */
+#include "trx0undo.h"            /* TRX_* */
+#include "fsp0fsp.h"             /* fsp_flags_get_page_size() &
+                                    fsp_flags_get_zip_size() */
+#include "mach0data.h"           /* mach_read_from_4() */
+#include "ut0crc32.h"            /* ut_crc32_init() */
+
+#ifdef UNIV_NONINL
+# include "fsp0fsp.ic"
+# include "mach0data.ic"
+# include "ut0rnd.ic"
+#endif
+
+/* Global variables */
+static my_bool verbose;
+static my_bool debug;
+static my_bool skip_corrupt;
+static my_bool just_count;
+static ulong start_page;
+static ulong end_page;
+static ulong do_page;
+static my_bool use_end_page;
+static my_bool do_one_page;
+ulong srv_page_size;              /* replaces declaration in srv0srv.c */
+static ulong physical_page_size;  /* Page size in bytes on disk. */
+static ulong logical_page_size;   /* Page size when uncompressed. */
+static bool compressed= false;    /* Is tablespace compressed */
+
+/* Get the page size of the filespace from the filespace header. */
+static
+my_bool
+get_page_size(
+/*==========*/
+  FILE*  f,                     /*!< in: file pointer, must be open
+                                         and set to start of file */
+  byte* buf,                    /*!< in: buffer used to read the page */
+  ulong* logical_page_size,     /*!< out: Logical/Uncompressed page size */
+  ulong* physical_page_size)    /*!< out: Physical/Commpressed page size */
+{
+  ulong flags;
+
+  int bytes= fread(buf, 1, UNIV_PAGE_SIZE_MIN, f);
+
+  if (ferror(f))
+  {
+    perror("Error reading file header");
+    return FALSE;
+  }
+
+  if (bytes != UNIV_PAGE_SIZE_MIN)
+  {
+    fprintf(stderr, "Error; Was not able to read the minimum page size ");
+    fprintf(stderr, "of %d bytes.  Bytes read was %d\n", UNIV_PAGE_SIZE_MIN, bytes);
+    return FALSE;
+  }
+
+  rewind(f);
+
+  flags = mach_read_from_4(buf + FIL_PAGE_DATA + FSP_SPACE_FLAGS);
+
+  /* srv_page_size is used by InnoDB code as UNIV_PAGE_SIZE */
+  srv_page_size = *logical_page_size = fsp_flags_get_page_size(flags);
+
+  /* fsp_flags_get_zip_size() will return zero if not compressed. */
+  *physical_page_size = fsp_flags_get_zip_size(flags);
+  if (*physical_page_size == 0)
+  {
+    *physical_page_size= *logical_page_size;
+  }
+  else
+  {
+    compressed= true;
+  }
+  return TRUE;
+}
+
+
+/* command line argument to do page checks (that's it) */
+/* another argument to specify page ranges... seek to right spot and go from there */
+
+static struct my_option innochecksum_options[] =
+{
+  {"help", '?', "Displays this help and exits.",
+    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"info", 'I', "Synonym for --help.",
+    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"version", 'V', "Displays version information and exits.",
+    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"verbose", 'v', "Verbose (prints progress every 5 seconds).",
+    &verbose, &verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"debug", 'd', "Debug mode (prints checksums for each page, implies verbose).",
+    &debug, &debug, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"skip_corrupt", 'u', "Skip corrupt pages.",
+    &skip_corrupt, &skip_corrupt, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"count", 'c', "Print the count of pages in the file.",
+    &just_count, &just_count, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"start_page", 's', "Start on this page number (0 based).",
+    &start_page, &start_page, 0, GET_ULONG, REQUIRED_ARG,
+    0, 0, (longlong) 2L*1024L*1024L*1024L, 0, 1, 0},
+  {"end_page", 'e', "End at this page number (0 based).",
+    &end_page, &end_page, 0, GET_ULONG, REQUIRED_ARG,
+    0, 0, (longlong) 2L*1024L*1024L*1024L, 0, 1, 0},
+  {"page", 'p', "Check only this page (0 based).",
+    &do_page, &do_page, 0, GET_ULONG, REQUIRED_ARG,
+    0, 0, (longlong) 2L*1024L*1024L*1024L, 0, 1, 0},
+  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
+};
+
+static void print_version(void)
+{
+  printf("%s Ver %s, for %s (%s)\n",
+         my_progname, INNODB_VERSION_STR,
+         SYSTEM_TYPE, MACHINE_TYPE);
+}
+
+static void usage(void)
+{
+  print_version();
+  puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000"));
+  printf("InnoDB offline file checksum utility.\n");
+  printf("Usage: %s [-c] [-s <start page>] [-e <end page>] [-p <page>] [-v] [-d] <filename>\n", my_progname);
+  my_print_help(innochecksum_options);
+  my_print_variables(innochecksum_options);
+}
+
+extern "C" my_bool
+innochecksum_get_one_option(
+/*========================*/
+  int optid,
+  const struct my_option *opt __attribute__((unused)),
+  char *argument __attribute__((unused)))
+{
+  switch (optid) {
+  case 'd':
+    verbose=1;	/* debug implies verbose... */
+    break;
+  case 'e':
+    use_end_page= 1;
+    break;
+  case 'p':
+    end_page= start_page= do_page;
+    use_end_page= 1;
+    do_one_page= 1;
+    break;
+  case 'V':
+    print_version();
+    exit(0);
+    break;
+  case 'I':
+  case '?':
+    usage();
+    exit(0);
+    break;
+  }
+  return 0;
+}
+
+static int get_options(
+/*===================*/
+  int *argc,
+  char ***argv)
+{
+  int ho_error;
+
+  if ((ho_error=handle_options(argc, argv, innochecksum_options, innochecksum_get_one_option)))
+    exit(ho_error);
+
+  /* The next arg must be the filename */
+  if (!*argc)
+  {
+    usage();
+    return 1;
+  }
+  return 0;
+} /* get_options */
+
+int main(int argc, char **argv)
+{
+  FILE* f;                       /* our input file */
+  char* filename;                /* our input filename. */
+  unsigned char *big_buf, *buf;
+
+  ulong bytes;                   /* bytes read count */
+  ulint ct;                      /* current page number (0 based) */
+  time_t now;                    /* current time */
+  time_t lastt;                  /* last time */
+  ulint oldcsum, oldcsumfield, csum, csumfield, crc32, logseq, logseqfield;
+                                 /* ulints for checksum storage */
+  struct stat st;                /* for stat, if you couldn't guess */
+  unsigned long long int size;   /* size of file (has to be 64 bits) */
+  ulint pages;                   /* number of pages in file */
+  off_t offset= 0;
+  int fd;
+
+  printf("InnoDB offline file checksum utility.\n");
+
+  ut_crc32_init();
+
+  MY_INIT(argv[0]);
+
+  if (get_options(&argc,&argv))
+    exit(1);
+
+  if (verbose)
+    my_print_variables(innochecksum_options);
+
+  /* The file name is not optional */
+  filename = *argv;
+  if (*filename == '\0')
+  {
+    fprintf(stderr, "Error; File name missing\n");
+    return 1;
+  }
+
+  /* stat the file to get size and page count */
+  if (stat(filename, &st))
+  {
+    fprintf(stderr, "Error; %s cannot be found\n", filename);
+    return 1;
+  }
+  size= st.st_size;
+
+  /* Open the file for reading */
+  f= fopen(filename, "rb");
+  if (f == NULL)
+  {
+    fprintf(stderr, "Error; %s cannot be opened", filename);
+    perror(" ");
+    return 1;
+  }
+
+  big_buf = (unsigned char *)malloc(2 * UNIV_PAGE_SIZE_MAX);
+  if (big_buf == NULL)
+  {
+    fprintf(stderr, "Error; failed to allocate memory\n");
+    perror("");
+    return 1;
+  }
+
+  /* Make sure the page is aligned */
+  buf = (unsigned char*)ut_align_down(big_buf
+                                      + UNIV_PAGE_SIZE_MAX, UNIV_PAGE_SIZE_MAX);
+
+  if (!get_page_size(f, buf, &logical_page_size, &physical_page_size))
+  {
+    free(big_buf);
+    return 1;
+  }
+
+  if (compressed)
+  {
+    printf("Table is compressed\n");
+    printf("Key block size is %lu\n", physical_page_size);
+  }
+  else
+  {
+    printf("Table is uncompressed\n");
+    printf("Page size is %lu\n", physical_page_size);
+  }
+
+  pages= (ulint) (size / physical_page_size);
+
+  if (just_count)
+  {
+    if (verbose)
+      printf("Number of pages: ");
+    printf("%lu\n", pages);
+    free(big_buf);
+    return 0;
+  }
+  else if (verbose)
+  {
+    printf("file %s = %llu bytes (%lu pages)...\n", filename, size, pages);
+    if (do_one_page)
+      printf("InnoChecksum; checking page %lu\n", do_page);
+    else
+      printf("InnoChecksum; checking pages in range %lu to %lu\n", start_page, use_end_page ? end_page : (pages - 1));
+  }
+
+#ifdef UNIV_LINUX
+  if (posix_fadvise(fileno(f), 0, 0, POSIX_FADV_SEQUENTIAL) ||
+      posix_fadvise(fileno(f), 0, 0, POSIX_FADV_NOREUSE))
+  {
+    perror("posix_fadvise failed");
+  }
+#endif
+
+  /* seek to the necessary position */
+  if (start_page)
+  {
+    fd= fileno(f);
+    if (!fd)
+    {
+      perror("Error; Unable to obtain file descriptor number");
+      free(big_buf);
+      return 1;
+    }
+
+    offset= (off_t)start_page * (off_t)physical_page_size;
+
+    if (lseek(fd, offset, SEEK_SET) != offset)
+    {
+      perror("Error; Unable to seek to necessary offset");
+      free(big_buf);
+      return 1;
+    }
+  }
+
+  /* main checksumming loop */
+  ct= start_page;
+  lastt= 0;
+  while (!feof(f))
+  {
+    bytes= fread(buf, 1, physical_page_size, f);
+    if (!bytes && feof(f))
+    {
+      free(big_buf);
+      return 0;
+    }
+
+    if (ferror(f))
+    {
+      fprintf(stderr, "Error reading %lu bytes", physical_page_size);
+      perror(" ");
+      free(big_buf);
+      return 1;
+    }
+
+    if (compressed) {
+      /* compressed pages */
+      if (!page_zip_verify_checksum(buf, physical_page_size)) {
+        fprintf(stderr, "Fail; page %lu invalid (fails compressed page checksum).\n", ct);
+        if (!skip_corrupt)
+        {
+          free(big_buf);
+          return 1;
+        }
+      }
+    } else {
+
+      /* check the "stored log sequence numbers" */
+      logseq= mach_read_from_4(buf + FIL_PAGE_LSN + 4);
+      logseqfield= mach_read_from_4(buf + logical_page_size - FIL_PAGE_END_LSN_OLD_CHKSUM + 4);
+      if (debug)
+        printf("page %lu: log sequence number: first = %lu; second = %lu\n", ct, logseq, logseqfield);
+      if (logseq != logseqfield)
+      {
+        fprintf(stderr, "Fail; page %lu invalid (fails log sequence number check)\n", ct);
+        if (!skip_corrupt)
+        {
+          free(big_buf);
+          return 1;
+        }
+      }
+
+      /* check old method of checksumming */
+      oldcsum= buf_calc_page_old_checksum(buf);
+      oldcsumfield= mach_read_from_4(buf + logical_page_size - FIL_PAGE_END_LSN_OLD_CHKSUM);
+      if (debug)
+        printf("page %lu: old style: calculated = %lu; recorded = %lu\n", ct, oldcsum, oldcsumfield);
+      if (oldcsumfield != mach_read_from_4(buf + FIL_PAGE_LSN) && oldcsumfield != oldcsum)
+      {
+        fprintf(stderr, "Fail;  page %lu invalid (fails old style checksum)\n", ct);
+        if (!skip_corrupt)
+        {
+          free(big_buf);
+          return 1;
+        }
+      }
+
+      /* now check the new method */
+      csum= buf_calc_page_new_checksum(buf);
+      crc32= buf_calc_page_crc32(buf);
+      csumfield= mach_read_from_4(buf + FIL_PAGE_SPACE_OR_CHKSUM);
+      if (debug)
+        printf("page %lu: new style: calculated = %lu; crc32 = %lu; recorded = %lu\n",
+               ct, csum, crc32, csumfield);
+      if (csumfield != 0 && crc32 != csumfield && csum != csumfield)
+      {
+        fprintf(stderr, "Fail; page %lu invalid (fails innodb and crc32 checksum)\n", ct);
+        if (!skip_corrupt)
+        {
+          free(big_buf);
+          return 1;
+        }
+      }
+    }
+    /* end if this was the last page we were supposed to check */
+    if (use_end_page && (ct >= end_page))
+    {
+      free(big_buf);
+      return 0;
+    }
+
+    /* do counter increase and progress printing */
+    ct++;
+    if (verbose)
+    {
+      if (ct % 64 == 0)
+      {
+        now= time(0);
+        if (!lastt) lastt= now;
+        if (now - lastt >= 1)
+        {
+          printf("page %lu okay: %.3f%% done\n", (ct - 1), (float) ct / pages * 100);
+          lastt= now;
+        }
+      }
+    }
+  }
+  free(big_buf);
+  return 0;
+}
diff --git a/extra/replace.c b/extra/replace.c
index c4105e45973..56cf02f2002 100644
--- a/extra/replace.c
+++ b/extra/replace.c
@@ -1,5 +1,5 @@
 /*
-   Copyright (c) 2000, 2011, Oracle and/or its affiliates
+   Copyright (c) 2000, 2014, Oracle and/or its affiliates
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
@@ -1021,7 +1021,7 @@ FILE *in,*out;
   updated=retain=0;
   reset_buffer();
 
-  while ((error=fill_buffer_retaining(fileno(in),retain)) > 0)
+  while ((error=fill_buffer_retaining(my_fileno(in),retain)) > 0)
   {
     end_of_line=buffer ;
     buffer[bufbytes]=0;			/* Sentinel  */
diff --git a/extra/yassl/README b/extra/yassl/README
index b18e2baeea8..30c7af4a702 100644
--- a/extra/yassl/README
+++ b/extra/yassl/README
@@ -12,6 +12,15 @@ before calling SSL_new();
 
 *** end Note ***
 
+yaSSL Release notes, version 2.3.5 (9/29/2014)
+
+    This release of yaSSL fixes an RSA Padding check vulnerability reported by
+    Intel Security Advanced Threat Research team
+
+See normal  build instructions below under 1.0.6.
+See libcurl build instructions below under 1.3.0 and note in 1.5.8.
+
+
 yaSSL Release notes, version 2.3.4 (8/15/2014)
 
     This release of yaSSL adds checking to the input_buffer class itself.
diff --git a/extra/yassl/include/openssl/ssl.h b/extra/yassl/include/openssl/ssl.h
index 835a46eaea8..f819d76adc7 100644
--- a/extra/yassl/include/openssl/ssl.h
+++ b/extra/yassl/include/openssl/ssl.h
@@ -34,7 +34,7 @@
 #include "rsa.h"
 
 
-#define YASSL_VERSION "2.3.4"
+#define YASSL_VERSION "2.3.5"
 
 
 #if defined(__cplusplus)
diff --git a/extra/yassl/src/yassl_imp.cpp b/extra/yassl/src/yassl_imp.cpp
index e2da042457f..25e00d45d2b 100644
--- a/extra/yassl/src/yassl_imp.cpp
+++ b/extra/yassl/src/yassl_imp.cpp
@@ -24,7 +24,7 @@
 #include "handshake.hpp"
 
 #include "asn.hpp"  // provide crypto wrapper??
-
+#include <my_attribute.h>
 
 
 namespace yaSSL {
@@ -947,7 +947,7 @@ void Alert::Process(input_buffer& input, SSL& ssl)
 
         if (ssl.getSecurity().get_parms().cipher_type_ == block) {
             int    ivExtra = 0;
-            opaque fill;
+            opaque fill __attribute__((unused));
 
             if (ssl.isTLSv1_1())
                 ivExtra = ssl.getCrypto().get_cipher().get_blockSize();
@@ -2395,7 +2395,7 @@ void Finished::Process(input_buffer& input, SSL& ssl)
         if (ssl.isTLSv1_1())
             ivExtra = ssl.getCrypto().get_cipher().get_blockSize();
 
-    opaque fill;
+    opaque fill __attribute__((unused));
     int    padSz = ssl.getSecurity().get_parms().encrypt_size_ - ivExtra -
                      HANDSHAKE_HEADER - finishedSz - digestSz;
     for (int i = 0; i < padSz; i++) 
diff --git a/extra/yassl/taocrypt/src/rsa.cpp b/extra/yassl/taocrypt/src/rsa.cpp
index 69c59402e48..79a8a8f1c4f 100644
--- a/extra/yassl/taocrypt/src/rsa.cpp
+++ b/extra/yassl/taocrypt/src/rsa.cpp
@@ -177,7 +177,7 @@ word32 RSA_BlockType1::UnPad(const byte* pkcsBlock, word32 pkcsBlockLen,
 
     // skip past the padding until we find the separator
     unsigned i=1;
-    while (i<pkcsBlockLen && pkcsBlock[i++]) { // null body
+    while (i<pkcsBlockLen && pkcsBlock[i++] == 0xFF) { // null body
         }
     if (!(i==pkcsBlockLen || pkcsBlock[i-1]==0))
         return 0;