Subversion Repositories HelenOS-historic

Rev

Rev 1200 | Rev 1262 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1200 jermar 1 
/*
2 
 * Copyright (C) 2006 Jakub Jermar
3 
 * All rights reserved.
4 
 *
5 
 * Redistribution and use in source and binary forms, with or without
6 
 * modification, are permitted provided that the following conditions
7 
 * are met:
8 
 *
9 
 * - Redistributions of source code must retain the above copyright
10 
 *   notice, this list of conditions and the following disclaimer.
11 
 * - Redistributions in binary form must reproduce the above copyright
12 
 *   notice, this list of conditions and the following disclaimer in the
13 
 *   documentation and/or other materials provided with the distribution.
14 
 * - The name of the author may not be used to endorse or promote products
15 
 *   derived from this software without specific prior written permission.
16 
 *
17 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
 */
28 
 
1248 jermar 29 
/**
30 
 * @file    bitmap.c
31 
 * @brief   Implementation of bitmap ADT.
32 
 *
33 
 * This file implements bitmap ADT and provides functions for
34 
 * setting and clearing ranges of bits.
35 
 */
36 
 
1200 jermar 37 
#include <adt/bitmap.h>
38 
#include <typedefs.h>
39 
#include <arch/types.h>
40 
#include <align.h>
41 
#include <debug.h>
42 
 
43 
#define ALL_ONES    0xff
44 
#define ALL_ZEROES  0x00
45 
 
46 
/** Initialize bitmap.
47 
 *
48 
 * No portion of the bitmap is set or cleared by this function.
49 
 *
50 
 * @param bitmap Bitmap structure.
51 
 * @param map Address of the memory used to hold the map.
52 
 * @param bits Number of bits stored in bitmap.
53 
 */
54 
void bitmap_initialize(bitmap_t *bitmap, __u8 *map, count_t bits)
55 
{
56 
    bitmap->map = map;
57 
    bitmap->bits = bits;
58 
}
59 
 
60 
/** Set range of bits.
61 
 *
62 
 * @param bitmap Bitmap structure.
63 
 * @param start Starting bit.
64 
 * @param bits Number of bits to set.
65 
 */
66 
void bitmap_set_range(bitmap_t *bitmap, index_t start, count_t bits)
67 
{
68 
    index_t i;
69 
    index_t aligned_start;
70 
    count_t lub;        /* leading unaligned bits */
71 
    count_t tub;        /* trailing unaligned bits */
72 
 
73 
    ASSERT(start + bits <= bitmap->bits);
74 
 
75 
    aligned_start = ALIGN_UP(start, 8);
76 
    lub = aligned_start - start;
77 
    tub = (bits - lub) % 8;
78 
 
79 
    if (lub) {
80 
        /*
81 
         * Make sure to set any leading unaligned bits.
82 
         */
83 
        bitmap->map[start / 8] |= ~((1 << (8 - lub)) - 1);
84 
    }
85 
    for (i = 0; i < (bits - lub) / 8; i++) {
86 
        /*
87 
         * The middle bits can be set byte by byte.
88 
         */
89 
        bitmap->map[aligned_start / 8 + i] = ALL_ONES;
90 
    }
91 
    if (tub) {
92 
        /*
93 
         * Make sure to set any trailing unaligned bits.
94 
         */
95 
        bitmap->map[aligned_start / 8 + i] |= (1 << tub) - 1;
96 
    }
97 
 
98 
}
99 
 
100 
/** Clear range of bits.
101 
 *
102 
 * @param bitmap Bitmap structure.
103 
 * @param start Starting bit.
104 
 * @param bits Number of bits to clear.
105 
 */
106 
void bitmap_clear_range(bitmap_t *bitmap, index_t start, count_t bits)
107 
{
108 
    index_t i;
109 
    index_t aligned_start;
110 
    count_t lub;        /* leading unaligned bits */
111 
    count_t tub;        /* trailing unaligned bits */
112 
 
113 
    ASSERT(start + bits <= bitmap->bits);
114 
 
115 
    aligned_start = ALIGN_UP(start, 8);
116 
    lub = aligned_start - start;
117 
    tub = (bits - lub) % 8;
118 
 
119 
    if (lub) {
120 
        /*
121 
         * Make sure to clear any leading unaligned bits.
122 
         */
123 
        bitmap->map[start / 8] &= (1 << (8 - lub)) - 1;
124 
    }
125 
    for (i = 0; i < (bits - lub) / 8; i++) {
126 
        /*
127 
         * The middle bits can be cleared byte by byte.
128 
         */
129 
        bitmap->map[aligned_start / 8 + i] = ALL_ZEROES;
130 
    }
131 
    if (tub) {
132 
        /*
133 
         * Make sure to clear any trailing unaligned bits.
134 
         */
135 
        bitmap->map[aligned_start / 8 + i] &= ~((1 << tub) - 1);
136 
    }
137 
 
138 
}
139 
 
140 
/** Copy portion of one bitmap into another bitmap.
141 
 *
142 
 * @param dst Destination bitmap.
143 
 * @param src Source bitmap.
144 
 * @param bits Number of bits to copy.
145 
 */
146 
void bitmap_copy(bitmap_t *dst, bitmap_t *src, count_t bits)
147 
{
148 
    index_t i;
149 
 
150 
    ASSERT(bits <= dst->bits);
151 
    ASSERT(bits <= src->bits);
152 
 
153 
    for (i = 0; i < bits / 8; i++)
154 
        dst->map[i] = src->map[i];
155 
 
156 
    if (bits % 8) {
157 
        bitmap_clear_range(dst, i * 8, bits % 8);
158 
        dst->map[i] |= src->map[i] & ((1 << (bits % 8)) - 1);
159 
    }
160 
}