Home | History | Annotate | Download | only in unix_file 
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef ART_RUNTIME_BASE_UNIX_FILE_MAPPED_FILE_H_
     18 #define ART_RUNTIME_BASE_UNIX_FILE_MAPPED_FILE_H_
     19 
     20 #include <fcntl.h>
     21 #include <string>
     22 #include "base/unix_file/fd_file.h"
     23 
     24 namespace unix_file {
     25 
     26 // Random access file which handles an mmap(2), munmap(2) pair in C++
     27 // RAII style. When a file is mmapped, the random access file
     28 // interface accesses the mmapped memory directly; otherwise, the
     29 // standard file I/O is used. Whenever a function fails, it returns
     30 // false and errno is set to the corresponding error code.
     31 class MappedFile : public FdFile {
     32  public:
     33   // File modes used in Open().
     34   enum FileMode {
     35     kReadOnlyMode = O_RDONLY | O_LARGEFILE,
     36     kReadWriteMode = O_CREAT | O_RDWR | O_LARGEFILE,
     37   };
     38 
     39   MappedFile() : FdFile(), file_size_(-1), mapped_file_(NULL) {
     40   }
     41   // Creates a MappedFile using the given file descriptor. Takes ownership of
     42   // the file descriptor.
     43   explicit MappedFile(int fd) : FdFile(fd), file_size_(-1), mapped_file_(NULL) {
     44   }
     45 
     46   // Unmaps and closes the file if needed.
     47   virtual ~MappedFile();
     48 
     49   // Maps an opened file to memory in the read-only mode.
     50   bool MapReadOnly();
     51 
     52   // Maps an opened file to memory in the read-write mode. Before the
     53   // file is mapped, it is truncated to 'file_size' bytes.
     54   bool MapReadWrite(int64_t file_size);
     55 
     56   // Unmaps a mapped file so that, e.g., SetLength() may be invoked.
     57   bool Unmap();
     58 
     59   // RandomAccessFile API.
     60   // The functions below require that the file is open, but it doesn't
     61   // have to be mapped.
     62   virtual int Close();
     63   virtual int64_t Read(char* buf, int64_t byte_count, int64_t offset) const;
     64   // SetLength() requires that the file is not mmapped.
     65   virtual int SetLength(int64_t new_length);
     66   virtual int64_t GetLength() const;
     67   virtual int Flush();
     68   // Write() requires that, if the file is mmapped, it is mmapped in
     69   // the read-write mode. Writes past the end of file are discarded.
     70   virtual int64_t Write(const char* buf, int64_t byte_count, int64_t offset);
     71 
     72   // A convenience method equivalent to GetLength().
     73   int64_t size() const;
     74 
     75   // Returns true if the file has been mmapped.
     76   bool IsMapped() const;
     77 
     78   // Returns a pointer to the start of the memory mapping once the
     79   // file is successfully mapped; crashes otherwise.
     80   char* data() const;
     81 
     82  private:
     83   enum MapMode {
     84     kMapReadOnly = 1,
     85     kMapReadWrite = 2,
     86   };
     87 
     88   mutable int64_t file_size_;  // May be updated in GetLength().
     89   void* mapped_file_;
     90   MapMode map_mode_;
     91 
     92   DISALLOW_COPY_AND_ASSIGN(MappedFile);
     93 };
     94 
     95 }  // namespace unix_file
     96 
     97 #endif  // ART_RUNTIME_BASE_UNIX_FILE_MAPPED_FILE_H_
     98