summaryrefslogtreecommitdiffstats
path: root/src/include/kernel/basesegment.H
blob: 72869d535d112b417b17e71d013994fff2e4713e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
//  IBM_PROLOG_BEGIN_TAG
//  This is an automatically generated prolog.
//
//  $Source: src/include/kernel/basesegment.H $
//
//  IBM CONFIDENTIAL
//
//  COPYRIGHT International Business Machines Corp. 2011
//
//  p1
//
//  Object Code Only (OCO) source materials
//  Licensed Internal Code Source Materials
//  IBM HostBoot Licensed Internal Code
//
//  The source code for this program is not published or other-
//  wise divested of its trade secrets, irrespective of what has
//  been deposited with the U.S. Copyright Office.
//
//  Origin: 30
//
//  IBM_PROLOG_END
/** @file basesegment.H
 *  @brief Defines the base segment (0TB) class.
 */
#ifndef __KERNEL_BASESEGMENT_H
#define __KERNEL_BASESEGMENT_H

#include <kernel/segment.H>

// Forward declaration.
class MessageQueue;
class Block;

/** @class BaseSegment
 *  @brief Class to manage the base segment at 0 TB.
 *
 *  Contains a chain of blocks associated with the first segment.
 */
class BaseSegment : public Segment
{
    protected:
        /**
         * @brief Constructor.
         * Initialize attributes and set base addresss of segment to 0 TB.
         */
        BaseSegment() : Segment(0x0), iv_block(NULL), iv_physMemSize(0) {};
        /**
         * @brief Destructor
         * Delete any blocks owned by this segment.
         */
        ~BaseSegment();

    public:
        /**
         * @brief Initialize the segment by allocating initial blocks and
         *        adding to the segment manager.
         */
        static void init();

        /**
         * @brief Implementation of the pure-virtual function from Segment.
         *
         * Calls block chain to deal with page fault.
         */
        virtual bool handlePageFault(task_t* i_task, uint64_t i_addr);

        /**
         * @brief Implementation of the pure-virtual function from Segment.
         *        Update LRU statistics on the block that owns the address         *
         *
         * @param[in] i_vaddr - Virtual Address of page
         * @param[in] i_stats - Usage statistics
         */
        virtual void updateRefCount( uint64_t i_vaddr,
				     PageTableManager::UsageStats_t i_stats );

        /**
         * @brief Allocates a block of virtual memory of the given size
         * @param i_mq[in] - Message queue to be associated with the block
         * @param i_va[in] - Base virtual address of the block to be allocated
         * @param i_size[in] - Requested virtual memory size of the block
         * @return int - 0 for successful block allocation, non-zero otherwise
         */
        static int mmAllocBlock(MessageQueue* i_mq,void* i_va,
                                uint64_t i_size);

        /**
         * @brief Locate the physical address of the given virtual address
         * @param[in] i_vaddr virtual address
         * @return the physical address bound to the virtual address, or
         *         -EFAULT if i_vaddr not found. @see errno.h
         */
         virtual uint64_t findPhysicalAddress(uint64_t i_vaddr) const;

    private:
        /**
         * @brief Internal implementation of init function.
         */
        void _init();

        /** Block-chain associated with this Segment. */
        Block* iv_block;

        /** Physical memory byte size */
        uint64_t iv_physMemSize;

        /**
         * @brief Allocates a block of virtual memory of the given size
         * @param i_mq[in] - Message queue to be associated with the block
         * @param i_va[in] - Base virtual address of the block to be allocated
         * @param i_size[in] - Requested virtual memory size of the block
         * @return int - 0 for successful block allocation, non-zero otherwise
         */
        int _mmAllocBlock(MessageQueue* i_mq,void* i_va,uint64_t i_size);

};

#endif
OpenPOWER on IntegriCloud