Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  *

  * This code 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

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  *

  */

 #ifndef SHARE_VM_MEMORY_FILEMAP_HPP

 #define SHARE_VM_MEMORY_FILEMAP_HPP

 #include "memory/metaspaceShared.hpp"

 // Layout of the file:

 //  header: dump of archive instance plus versioning info, datestamp, etc.

 //   [magic # = 0xF00BABA2]

 //  ... padding to align on page-boundary

 //  read-write space from CompactingPermGenGen

 //  read-only space from CompactingPermGenGen

 //  misc data (block offset table, string table, symbols, dictionary, etc.)

 //  tag(666)

 static const int JVM_SHARED_JARS_MAX = 128;

 static const int JVM_SPACENAME_MAX = 128;

 static const int JVM_IDENT_MAX = 256;

 static const int JVM_ARCH_MAX = 12;

 class Metaspace;

 class FileMapInfo : public CHeapObj<mtInternal> {

 private:

   enum {

     _invalid_version = -1,

     _current_version = 1

   };

   bool  _file_open;

   int   _fd;

   long  _file_offset;

   // FileMapHeader describes the shared space data in the file to be

   // mapped.  This structure gets written to a file.  It is not a class, so

   // that the compilers don't add any compiler-private data to it.

   struct FileMapHeader {

     int    _magic;                    // identify file type.

     int    _version;                  // (from enum, above.)

     size_t _alignment;                // how shared archive should be aligned

     int    _obj_alignment;            // value of ObjectAlignmentInBytes

     struct space_info {

       int    _file_offset;   // sizeof(this) rounded to vm page size

       char*  _base;          // copy-on-write base address

       size_t _capacity;      // for validity checking

       size_t _used;          // for setting space top on read

       bool   _read_only;     // read only space?

       bool   _allow_exec;    // executable code in space?

     } _space[MetaspaceShared::n_regions];

     // The following fields are all sanity checks for whether this archive

     // will function correctly with this JVM and the bootclasspath it's

     // invoked with.

     char  _arch[JVM_ARCH_MAX];            // architecture

     char  _jvm_ident[JVM_IDENT_MAX];      // identifier for jvm

     int   _num_jars;              // Number of jars in bootclasspath

     // Per jar file data:  timestamp, size.

     struct {

       time_t _timestamp;          // jar timestamp.

       long   _filesize;           // jar file size.

     } _jar[JVM_SHARED_JARS_MAX];

   } _header;

   const char* _full_path;

   static FileMapInfo* _current_info;

   bool  init_from_file(int fd);

   void  align_file_position();

 public:

   FileMapInfo() {

     _file_offset = 0;

     _file_open = false;

     _header._version = _invalid_version;

   }

   static int current_version()        { return _current_version; }

   void   populate_header(size_t alignment);

   bool   validate();

   void   invalidate();

   int    version()                    { return _header._version; }

   size_t alignment()                  { return _header._alignment; }

   size_t space_capacity(int i)        { return _header._space[i]._capacity; }

   char*  region_base(int i)           { return _header._space[i]._base; }

   struct FileMapHeader* header()      { return &_header; }

   static void set_current_info(FileMapInfo* info) {

     CDS_ONLY(_current_info = info;)

   }

   static FileMapInfo* current_info() {

     CDS_ONLY(return _current_info;)

     NOT_CDS(return NULL;)

   }

   static void assert_mark(bool check);

   // File manipulation.

   bool  initialize() NOT_CDS_RETURN_(false);

   bool  open_for_read();

   void  open_for_write();

   void  write_header();

   void  write_space(int i, Metaspace* space, bool read_only);

   void  write_region(int region, char* base, size_t size,

                      size_t capacity, bool read_only, bool allow_exec);

   void  write_bytes(const void* buffer, int count);

   void  write_bytes_aligned(const void* buffer, int count);

   char* map_region(int i);

   void  unmap_region(int i);

   void  close();

   bool  is_open() { return _file_open; }

   ReservedSpace reserve_shared_memory();

   // JVM/TI RedefineClasses() support:

   // Remap the shared readonly space to shared readwrite, private.

   bool  remap_shared_readonly_as_readwrite();

   // Errors.

   static void fail_stop(const char *msg, ...);

   void fail_continue(const char *msg, ...);

   // Return true if given address is in the mapped shared space.

   bool is_in_shared_space(const void* p) NOT_CDS_RETURN_(false);

 };

 #endif // SHARE_VM_MEMORY_FILEMAP_HPP