Bitmap *copy_bitmap(const Bitmap *src)
{
Bitmap *dst = alloc_bitmap(src->w, src->h);
dst->left = src->left;
dst->top = src->top;
memcpy(dst->buffer, src->buffer, src->stride * src->h);
return dst;
}
int policy_init(mcd_t *paging)
{
int i;
int rc;
/* Allocate bitmap for pages not to page out */
rc = alloc_bitmap(&bitmap, paging->bitmap_size);
if ( rc != 0 )
goto out;
/* Allocate bitmap to track unusable pages */
rc = alloc_bitmap(&unconsumed, paging->bitmap_size);
if ( rc != 0 )
goto out;
/* record bitmap_size */
bitmap_size = paging->bitmap_size;
max_pages = paging->domain_info->max_pages;
/* Initialise MRU list of paged in pages */
if ( paging->policy_mru_size > 0 )
mru_size = paging->policy_mru_size;
else
mru_size = DEFAULT_MRU_SIZE;
mru = malloc(sizeof(*mru) * mru_size);
if ( mru == NULL )
{
rc = -ENOMEM;
goto out;
}
for ( i = 0; i < mru_size; i++ )
mru[i] = INVALID_MFN;
/* Don't page out page 0 */
set_bit(0, bitmap);
out:
return rc;
}
struct ippool *
ippool_new(char *address, char *netmask)
{
struct ippool *ippool;
ippool = malloc(sizeof(struct ippool));
if (ipcalc(ippool, address, netmask) != 0) {
return NULL;
}
alloc_bitmap(ippool->hosts, &(ippool->pool));
return ippool;
}
Bitmap *outline_to_bitmap(ASS_Library *library, FT_Library ftlib,
FT_Outline *outline, int bord)
{
Bitmap *bm;
int w, h;
int error;
FT_BBox bbox;
FT_Bitmap bitmap;
FT_Outline_Get_CBox(outline, &bbox);
// move glyph to origin (0, 0)
bbox.xMin &= ~63;
bbox.yMin &= ~63;
FT_Outline_Translate(outline, -bbox.xMin, -bbox.yMin);
// bitmap size
bbox.xMax = (bbox.xMax + 63) & ~63;
bbox.yMax = (bbox.yMax + 63) & ~63;
w = (bbox.xMax - bbox.xMin) >> 6;
h = (bbox.yMax - bbox.yMin) >> 6;
// pen offset
bbox.xMin >>= 6;
bbox.yMax >>= 6;
if (w * h > 8000000) {
ass_msg(library, MSGL_WARN, "Glyph bounding box too large: %dx%dpx",
w, h);
return NULL;
}
// allocate and set up bitmap
bm = alloc_bitmap(w + 2 * bord, h + 2 * bord);
bm->left = bbox.xMin - bord;
bm->top = -bbox.yMax - bord;
bitmap.width = w;
bitmap.rows = h;
bitmap.pitch = bm->stride;
bitmap.buffer = bm->buffer + bord + bm->stride * bord;
bitmap.num_grays = 256;
bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
// render into target bitmap
if ((error = FT_Outline_Get_Bitmap(ftlib, outline, &bitmap))) {
ass_msg(library, MSGL_WARN, "Failed to rasterize glyph: %d\n", error);
ass_free_bitmap(bm);
return NULL;
}
return bm;
}
static Bitmap *glyph_to_bitmap_internal(ASS_Library *library,
FT_Glyph glyph, int bord)
{
FT_BitmapGlyph bg;
FT_Bitmap *bit;
Bitmap *bm;
int w, h;
unsigned char *src;
unsigned char *dst;
int i;
int error;
if (check_glyph_area(library, glyph))
return 0;
error = FT_Glyph_To_Bitmap(&glyph, FT_RENDER_MODE_NORMAL, 0, 0);
if (error) {
ass_msg(library, MSGL_WARN, "FT_Glyph_To_Bitmap error %d",
error);
return 0;
}
bg = (FT_BitmapGlyph) glyph;
bit = &(bg->bitmap);
if (bit->pixel_mode != FT_PIXEL_MODE_GRAY) {
ass_msg(library, MSGL_WARN, "Unsupported pixel mode: %d",
(int) (bit->pixel_mode));
FT_Done_Glyph(glyph);
return 0;
}
w = bit->width;
h = bit->rows;
bm = alloc_bitmap(w + 2 * bord, h + 2 * bord);
memset(bm->buffer, 0, bm->w * bm->h);
bm->left = bg->left - bord;
bm->top = -bg->top - bord;
src = bit->buffer;
dst = bm->buffer + bord + bm->w * bord;
for (i = 0; i < h; ++i) {
memcpy(dst, src, w);
src += bit->pitch;
dst += bm->w;
}
FT_Done_Glyph(glyph);
return bm;
}
static int get_swap_writer(struct swap_map_handle *handle)
{
handle->cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
if (!handle->cur)
return -ENOMEM;
handle->bitmap = alloc_bitmap(count_swap_pages(root_swap, 0));
if (!handle->bitmap) {
release_swap_writer(handle);
return -ENOMEM;
}
handle->cur_swap = alloc_swap_page(root_swap, handle->bitmap);
if (!handle->cur_swap) {
release_swap_writer(handle);
return -ENOSPC;
}
handle->k = 0;
return 0;
}
/*===========================================================================*
* fs_inodewalker *
*===========================================================================*/
int fs_inodewalker()
{
/* Get the list of blocks in use by the system from the inode bitmap */
printf("Inode Walker\n");
printf("Getting super node from device %llu ...\n", fs_dev);
type = IMAP;
sb = get_super(fs_dev);
read_super(sb);
lsuper();
init_global();
imap_disk = alloc_bitmap(N_IMAP);
printf("Loading inode bitmap from disk ...\n");
get_bitmap(imap_disk, IMAP);
printf(" done.\n");
sleep(3);
int *list_inodes = get_list_used(imap_disk, IMAP);
free_bitmap(imap_disk);
return 0;
}
/*===========================================================================*
* fs_zonewalker *
*===========================================================================*/
int fs_zonewalker()
{
/* Get the list of blocks used by the system from the zone bitmap */
printf("Zone Walkder\n");
printf("Getting super node from device %llu ...\n", fs_dev);
type = ZMAP;
sb = get_super(fs_dev);
read_super(sb);
lsuper();
sleep(3);
init_global();
zmap_disk = alloc_bitmap(N_ZMAP);
printf("Loading zone bitmap from disk ...\n");
get_bitmap(zmap_disk, ZMAP);
printf(" done.\n\n");
sleep(3);
//print_bitmap(zmap_disk);
int* list = get_list_used(zmap_disk, ZMAP);
free_bitmap(zmap_disk);
return 0;
}
int convert_free_space_to_extents(struct btrfs_trans_handle *trans,
struct btrfs_fs_info *fs_info,
struct btrfs_block_group_cache *block_group,
struct btrfs_path *path)
{
struct btrfs_root *root = fs_info->free_space_root;
struct btrfs_free_space_info *info;
struct btrfs_key key, found_key;
struct extent_buffer *leaf;
unsigned long *bitmap;
u64 start, end;
/* Initialize to silence GCC. */
u64 extent_start = 0;
u64 offset;
u32 bitmap_size, flags, expected_extent_count;
int prev_bit = 0, bit, bitnr;
u32 extent_count = 0;
int done = 0, nr;
int ret;
bitmap_size = free_space_bitmap_size(block_group->key.offset,
block_group->sectorsize);
bitmap = alloc_bitmap(bitmap_size);
if (!bitmap) {
ret = -ENOMEM;
goto out;
}
start = block_group->key.objectid;
end = block_group->key.objectid + block_group->key.offset;
key.objectid = end - 1;
key.type = (u8)-1;
key.offset = (u64)-1;
while (!done) {
ret = btrfs_search_prev_slot(trans, root, &key, path, -1, 1);
if (ret)
goto out;
leaf = path->nodes[0];
nr = 0;
path->slots[0]++;
while (path->slots[0] > 0) {
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0] - 1);
if (found_key.type == BTRFS_FREE_SPACE_INFO_KEY) {
ASSERT(found_key.objectid == block_group->key.objectid);
ASSERT(found_key.offset == block_group->key.offset);
done = 1;
break;
} else if (found_key.type == BTRFS_FREE_SPACE_BITMAP_KEY) {
unsigned long ptr;
char *bitmap_cursor;
u32 bitmap_pos, data_size;
ASSERT(found_key.objectid >= start);
ASSERT(found_key.objectid < end);
ASSERT(found_key.objectid + found_key.offset <= end);
bitmap_pos = div_u64(found_key.objectid - start,
block_group->sectorsize *
BITS_PER_BYTE);
bitmap_cursor = ((char *)bitmap) + bitmap_pos;
data_size = free_space_bitmap_size(found_key.offset,
block_group->sectorsize);
ptr = btrfs_item_ptr_offset(leaf, path->slots[0] - 1);
read_extent_buffer(leaf, bitmap_cursor, ptr,
data_size);
nr++;
path->slots[0]--;
} else {
ASSERT(0);
}
}
ret = btrfs_del_items(trans, root, path, path->slots[0], nr);
if (ret)
goto out;
btrfs_release_path(path);
}
info = search_free_space_info(trans, fs_info, block_group, path, 1);
if (IS_ERR(info)) {
ret = PTR_ERR(info);
goto out;
}
leaf = path->nodes[0];
flags = btrfs_free_space_flags(leaf, info);
flags &= ~BTRFS_FREE_SPACE_USING_BITMAPS;
btrfs_set_free_space_flags(leaf, info, flags);
expected_extent_count = btrfs_free_space_extent_count(leaf, info);
btrfs_mark_buffer_dirty(leaf);
btrfs_release_path(path);
offset = start;
bitnr = 0;
while (offset < end) {
bit = !!test_bit(bitnr, bitmap);
if (prev_bit == 0 && bit == 1) {
extent_start = offset;
} else if (prev_bit == 1 && bit == 0) {
key.objectid = extent_start;
key.type = BTRFS_FREE_SPACE_EXTENT_KEY;
key.offset = offset - extent_start;
ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
if (ret)
goto out;
btrfs_release_path(path);
extent_count++;
}
prev_bit = bit;
offset += block_group->sectorsize;
bitnr++;
}
if (prev_bit == 1) {
key.objectid = extent_start;
key.type = BTRFS_FREE_SPACE_EXTENT_KEY;
key.offset = end - extent_start;
ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
if (ret)
goto out;
btrfs_release_path(path);
extent_count++;
}
if (extent_count != expected_extent_count) {
btrfs_err(fs_info, "incorrect extent count for %llu; counted %u, expected %u",
block_group->key.objectid, extent_count,
expected_extent_count);
ASSERT(0);
ret = -EIO;
goto out;
}
ret = 0;
out:
kvfree(bitmap);
if (ret)
btrfs_abort_transaction(trans, ret);
return ret;
}
int convert_free_space_to_bitmaps(struct btrfs_trans_handle *trans,
struct btrfs_fs_info *fs_info,
struct btrfs_block_group_cache *block_group,
struct btrfs_path *path)
{
struct btrfs_root *root = fs_info->free_space_root;
struct btrfs_free_space_info *info;
struct btrfs_key key, found_key;
struct extent_buffer *leaf;
unsigned long *bitmap;
char *bitmap_cursor;
u64 start, end;
u64 bitmap_range, i;
u32 bitmap_size, flags, expected_extent_count;
u32 extent_count = 0;
int done = 0, nr;
int ret;
bitmap_size = free_space_bitmap_size(block_group->key.offset,
block_group->sectorsize);
bitmap = alloc_bitmap(bitmap_size);
if (!bitmap) {
ret = -ENOMEM;
goto out;
}
start = block_group->key.objectid;
end = block_group->key.objectid + block_group->key.offset;
key.objectid = end - 1;
key.type = (u8)-1;
key.offset = (u64)-1;
while (!done) {
ret = btrfs_search_prev_slot(trans, root, &key, path, -1, 1);
if (ret)
goto out;
leaf = path->nodes[0];
nr = 0;
path->slots[0]++;
while (path->slots[0] > 0) {
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0] - 1);
if (found_key.type == BTRFS_FREE_SPACE_INFO_KEY) {
ASSERT(found_key.objectid == block_group->key.objectid);
ASSERT(found_key.offset == block_group->key.offset);
done = 1;
break;
} else if (found_key.type == BTRFS_FREE_SPACE_EXTENT_KEY) {
u64 first, last;
ASSERT(found_key.objectid >= start);
ASSERT(found_key.objectid < end);
ASSERT(found_key.objectid + found_key.offset <= end);
first = div_u64(found_key.objectid - start,
block_group->sectorsize);
last = div_u64(found_key.objectid + found_key.offset - start,
block_group->sectorsize);
bitmap_set(bitmap, first, last - first);
extent_count++;
nr++;
path->slots[0]--;
} else {
ASSERT(0);
}
}
ret = btrfs_del_items(trans, root, path, path->slots[0], nr);
if (ret)
goto out;
btrfs_release_path(path);
}
info = search_free_space_info(trans, fs_info, block_group, path, 1);
if (IS_ERR(info)) {
ret = PTR_ERR(info);
goto out;
}
leaf = path->nodes[0];
flags = btrfs_free_space_flags(leaf, info);
flags |= BTRFS_FREE_SPACE_USING_BITMAPS;
btrfs_set_free_space_flags(leaf, info, flags);
expected_extent_count = btrfs_free_space_extent_count(leaf, info);
btrfs_mark_buffer_dirty(leaf);
btrfs_release_path(path);
if (extent_count != expected_extent_count) {
btrfs_err(fs_info, "incorrect extent count for %llu; counted %u, expected %u",
block_group->key.objectid, extent_count,
expected_extent_count);
ASSERT(0);
ret = -EIO;
goto out;
}
bitmap_cursor = (char *)bitmap;
bitmap_range = block_group->sectorsize * BTRFS_FREE_SPACE_BITMAP_BITS;
i = start;
while (i < end) {
unsigned long ptr;
u64 extent_size;
u32 data_size;
extent_size = min(end - i, bitmap_range);
data_size = free_space_bitmap_size(extent_size,
block_group->sectorsize);
key.objectid = i;
key.type = BTRFS_FREE_SPACE_BITMAP_KEY;
key.offset = extent_size;
ret = btrfs_insert_empty_item(trans, root, path, &key,
data_size);
if (ret)
goto out;
leaf = path->nodes[0];
ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
write_extent_buffer(leaf, bitmap_cursor, ptr,
data_size);
btrfs_mark_buffer_dirty(leaf);
btrfs_release_path(path);
i += extent_size;
bitmap_cursor += data_size;
}
ret = 0;
out:
kvfree(bitmap);
if (ret)
btrfs_abort_transaction(trans, ret);
return ret;
}
static void
read_GF_char(struct font *fontp,
wide_ubyte ch)
{
struct glyph *g;
ubyte cmnd;
int min_m, max_m, min_n, max_n;
bmUnitT *cp, *basep, *maxp;
int bytes_wide;
Boolean paint_switch;
#define White False
#define Black True
Boolean new_row;
int count;
int word_weight;
g = &fontp->glyph[ch];
GF_file = fontp->file;
if (globals.debug & DBG_PK)
printf("Loading gf char %d", ch);
for (;;) {
switch (cmnd = get_byte(GF_file)) {
case XXX1:
case XXX2:
case XXX3:
case XXX4:
fseek(GF_file, (long)get_bytes(GF_file, (int)(cmnd - XXX1 + 1)), SEEK_CUR);
continue;
case YYY:
(void)get_bytes(GF_file, 4);
continue;
case BOC:
(void)get_bytes(GF_file, 4); /* skip character code */
(void)get_bytes(GF_file, 4); /* skip pointer to prev char */
min_m = get_lbytes(GF_file, 4);
max_m = get_lbytes(GF_file, 4);
g->x = -min_m;
min_n = get_lbytes(GF_file, 4);
g->y = max_n = get_lbytes(GF_file, 4);
g->bitmap.w = max_m - min_m + 1;
g->bitmap.h = max_n - min_n + 1;
break;
case BOC1:
(void)get_byte(GF_file); /* skip character code */
g->bitmap.w = get_byte(GF_file); /* max_m - min_m */
g->x = g->bitmap.w - get_byte(GF_file); /* ditto - max_m */
++g->bitmap.w;
g->bitmap.h = get_byte(GF_file) + 1;
g->y = get_byte(GF_file);
break;
default:
XDVI_FATAL((stderr, "Bad BOC code: %d", cmnd));
}
break;
}
paint_switch = White;
if (globals.debug & DBG_PK)
printf(", size=%dx%d, dvi_adv=%ld\n", g->bitmap.w, g->bitmap.h,
g->dvi_adv);
alloc_bitmap(&g->bitmap);
cp = basep = (bmUnitT *) g->bitmap.bits;
/*
* Read character data into *basep
*/
bytes_wide = ROUNDUP((int)g->bitmap.w, BMBITS) * BMBYTES;
maxp = ADD(basep, g->bitmap.h * bytes_wide);
memset(g->bitmap.bits, 0, g->bitmap.h * bytes_wide);
new_row = False;
word_weight = BMBITS;
for (;;) {
count = -1;
cmnd = get_byte(GF_file);
if (cmnd < 64)
count = cmnd;
else if (cmnd >= NEW_ROW_0 && cmnd <= NEW_ROW_MAX) {
count = cmnd - NEW_ROW_0;
paint_switch = White; /* it'll be complemented later */
new_row = True;
}
else
switch (cmnd) {
case PAINT1:
case PAINT2:
case PAINT3:
count = get_bytes(GF_file, (int)(cmnd - PAINT1 + 1));
break;
case EOC:
if (cp >= ADD(basep, bytes_wide))
too_many_bits(ch);
return;
case SKIP1:
case SKIP2:
case SKIP3:
basep += get_bytes(GF_file, (int)(cmnd - SKIP0)) * bytes_wide / sizeof(bmUnitT);
/* *((char **)&basep) += get_bytes(GF_file, WIDENINT cmnd - SKIP0) * bytes_wide; */
case SKIP0:
new_row = True;
paint_switch = White;
break;
case XXX1:
case XXX2:
case XXX3:
case XXX4:
fseek(GF_file, (long)get_bytes(GF_file, (int)(cmnd - XXX1 + 1)), SEEK_CUR);
break;
case YYY:
(void)get_bytes(GF_file, 4);
break;
case NO_OP:
break;
default:
XDVI_FATAL((stderr, "Bad command in GF file: %d", cmnd));
} /* end switch */
if (new_row) {
basep += bytes_wide / sizeof(bmUnitT);
/* *((char **)&basep) += bytes_wide; */
if (basep >= maxp || cp >= basep)
too_many_bits(ch);
cp = basep;
word_weight = BMBITS;
new_row = False;
}
if (count >= 0) {
while (count)
if (count <= word_weight) {
#ifndef WORDS_BIGENDIAN
if (paint_switch)
*cp |= bit_masks[count] << (BMBITS - word_weight);
#endif
word_weight -= count;
#ifdef WORDS_BIGENDIAN
if (paint_switch)
*cp |= bit_masks[count] << word_weight;
#endif
break;
}
else {
if (paint_switch)
#ifndef WORDS_BIGENDIAN
*cp |= bit_masks[word_weight] << (BMBITS - word_weight);
#else
*cp |= bit_masks[word_weight];
#endif
cp++;
count -= word_weight;
word_weight = BMBITS;
}
paint_switch = 1 - paint_switch;
}
} /* end for */
}
static void
read_PK_char(struct font *fontp, wide_ubyte ch)
{
int i, j;
int n;
int row_bit_pos;
Boolean paint_switch;
BMUNIT *cp;
struct glyph *g;
FILE *fp = fontp->file;
long fpwidth;
BMUNIT word = 0;
int word_weight, bytes_wide;
int rows_left, h_bit, count;
g = &fontp->glyph[ch];
PK_flag_byte = g->x2;
PK_dyn_f = PK_flag_byte >> 4;
paint_switch = ((PK_flag_byte & 8) != 0);
PK_flag_byte &= 0x7;
if (PK_flag_byte == 7)
n = 4;
else if (PK_flag_byte > 3)
n = 2;
else
n = 1;
if (debug & DBG_PK)
Printf("loading pk char %d, char type %d ", ch, n);
/*
* now read rest of character preamble
*/
if (n != 4)
fpwidth = num(fp, 3);
else {
fpwidth = sfour(fp);
(void)four(fp); /* horizontal escapement */
}
(void)num(fp, n); /* vertical escapement */
{
unsigned long w, h;
w = num(fp, n);
h = num(fp, n);
if (w > 0x7fff || h > 0x7fff)
oops("Character %d too large in file %s", ch, fontp->fontname);
g->bitmap.w = w;
g->bitmap.h = h;
}
g->x = snum(fp, n);
g->y = snum(fp, n);
g->dvi_adv = fontp->dimconv * fpwidth;
if (debug & DBG_PK) {
if (g->bitmap.w != 0)
Printf(", size=%dx%d, dvi_adv=%ld", g->bitmap.w, g->bitmap.h,
g->dvi_adv);
Putchar('\n');
}
alloc_bitmap(&g->bitmap);
cp = (BMUNIT *) g->bitmap.bits;
/*
* read character data into *cp
*/
bytes_wide = ROUNDUP((int)g->bitmap.w, BMBITS) * BMBYTES;
PK_bitpos = -1;
if (PK_dyn_f == 14) { /* get raster by bits */
bzero(g->bitmap.bits, (int)g->bitmap.h * bytes_wide);
for (i = 0; i < (int)g->bitmap.h; i++) { /* get all rows */
cp = ADD(g->bitmap.bits, i * bytes_wide);
#ifndef WORDS_BIGENDIAN
row_bit_pos = -1;
#else
row_bit_pos = BMBITS;
#endif
for (j = 0; j < (int)g->bitmap.w; j++) { /* get one row */
if (--PK_bitpos < 0) {
word = one(fp);
PK_bitpos = 7;
}
#ifndef WORDS_BIGENDIAN
if (++row_bit_pos >= BMBITS) {
cp++;
row_bit_pos = 0;
}
#else
if (--row_bit_pos < 0) {
cp++;
row_bit_pos = BMBITS - 1;
}
#endif
if (word & (1 << PK_bitpos))
*cp |= 1 << row_bit_pos;
}
}
}
else { /* get packed raster */
rows_left = g->bitmap.h;
h_bit = g->bitmap.w;
PK_repeat_count = 0;
word_weight = BMBITS;
word = 0;
while (rows_left > 0) {
count = PK_packed_num(fp);
while (count > 0) {
if (count < word_weight && count < h_bit) {
#ifndef WORDS_BIGENDIAN
if (paint_switch)
word |= bit_masks[count] << (BMBITS - word_weight);
#endif
h_bit -= count;
word_weight -= count;
#ifdef WORDS_BIGENDIAN
if (paint_switch)
word |= bit_masks[count] << word_weight;
#endif
count = 0;
}
else if (count >= h_bit && h_bit <= word_weight) {
if (paint_switch)
word |= bit_masks[h_bit] <<
#ifndef WORDS_BIGENDIAN
(BMBITS - word_weight);
#else
(word_weight - h_bit);
#endif
*cp++ = word;
/* "output" row(s) */
for (i = PK_repeat_count * bytes_wide / BMBYTES; i > 0; --i) {
*cp = *SUB(cp, bytes_wide);
++cp;
}
rows_left -= PK_repeat_count + 1;
PK_repeat_count = 0;
word = 0;
word_weight = BMBITS;
count -= h_bit;
h_bit = g->bitmap.w;
}
else {
if (paint_switch)
#ifndef WORDS_BIGENDIAN
word |= bit_masks[word_weight] <<
(BMBITS - word_weight);
#else
word |= bit_masks[word_weight];
#endif
*cp++ = word;
word = 0;
count -= word_weight;
h_bit -= word_weight;
word_weight = BMBITS;
}
}
paint_switch = 1 - paint_switch;
}
if (cp != ((BMUNIT *) (g->bitmap.bits + bytes_wide * g->bitmap.h)))
oops("Wrong number of bits stored: char. %d, font %s", ch,
fontp->fontname);
if (rows_left != 0 || h_bit != g->bitmap.w)
oops("Bad pk file (%s), too many bits", fontp->fontname);
}
}
Bitmap *outline_to_bitmap(ASS_Renderer *render_priv,
ASS_Outline *outline, int bord)
{
ASS_Rasterizer *rst = &render_priv->rasterizer;
if (!rasterizer_set_outline(rst, outline)) {
ass_msg(render_priv->library, MSGL_WARN, "Failed to process glyph outline!\n");
return NULL;
}
if (bord < 0 || bord > INT_MAX / 2)
return NULL;
if (rst->x_min >= rst->x_max || rst->y_min >= rst->y_max) {
Bitmap *bm = alloc_bitmap(2 * bord, 2 * bord);
if (!bm)
return NULL;
bm->left = bm->top = -bord;
return bm;
}
if (rst->x_max > INT_MAX - 63 || rst->y_max > INT_MAX - 63)
return NULL;
int x_min = rst->x_min >> 6;
int y_min = rst->y_min >> 6;
int x_max = (rst->x_max + 63) >> 6;
int y_max = (rst->y_max + 63) >> 6;
int w = x_max - x_min;
int h = y_max - y_min;
int mask = (1 << rst->tile_order) - 1;
if (w < 0 || h < 0 || w > 8000000 / FFMAX(h, 1) ||
w > INT_MAX - (2 * bord + mask) || h > INT_MAX - (2 * bord + mask)) {
ass_msg(render_priv->library, MSGL_WARN, "Glyph bounding box too large: %dx%dpx",
w, h);
return NULL;
}
int tile_w = (w + 2 * bord + mask) & ~mask;
int tile_h = (h + 2 * bord + mask) & ~mask;
Bitmap *bm = alloc_bitmap(tile_w, tile_h);
if (!bm)
return NULL;
bm->left = x_min - bord;
bm->top = y_min - bord;
int offs = bord & ~mask;
if (!rasterizer_fill(rst,
bm->buffer + offs * (bm->stride + 1),
x_min - bord + offs,
y_min - bord + offs,
((w + bord + mask) & ~mask) - offs,
((h + bord + mask) & ~mask) - offs,
bm->stride)) {
ass_msg(render_priv->library, MSGL_WARN, "Failed to rasterize glyph!\n");
ass_free_bitmap(bm);
return NULL;
}
return bm;
}
static int snapshot_ioctl(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg)
{
int error = 0;
struct snapshot_data *data;
loff_t offset, avail;
if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)
return -ENOTTY;
if (_IOC_NR(cmd) > SNAPSHOT_IOC_MAXNR)
return -ENOTTY;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
data = filp->private_data;
switch (cmd) {
case SNAPSHOT_FREEZE:
if (data->frozen)
break;
down(&pm_sem);
disable_nonboot_cpus();
if (freeze_processes()) {
thaw_processes();
enable_nonboot_cpus();
error = -EBUSY;
}
up(&pm_sem);
if (!error)
data->frozen = 1;
break;
case SNAPSHOT_UNFREEZE:
if (!data->frozen)
break;
down(&pm_sem);
thaw_processes();
enable_nonboot_cpus();
up(&pm_sem);
data->frozen = 0;
break;
case SNAPSHOT_ATOMIC_SNAPSHOT:
if (data->mode != O_RDONLY || !data->frozen || data->ready) {
error = -EPERM;
break;
}
down(&pm_sem);
/* Free memory before shutting down devices. */
error = swsusp_shrink_memory();
if (!error) {
error = device_suspend(PMSG_FREEZE);
if (!error) {
in_suspend = 1;
error = swsusp_suspend();
device_resume();
}
}
up(&pm_sem);
if (!error)
error = put_user(in_suspend, (unsigned int __user *)arg);
if (!error)
data->ready = 1;
break;
case SNAPSHOT_ATOMIC_RESTORE:
if (data->mode != O_WRONLY || !data->frozen ||
!snapshot_image_loaded(&data->handle)) {
error = -EPERM;
break;
}
down(&pm_sem);
pm_prepare_console();
error = device_suspend(PMSG_FREEZE);
if (!error) {
error = swsusp_resume();
device_resume();
}
pm_restore_console();
up(&pm_sem);
break;
case SNAPSHOT_FREE:
swsusp_free();
memset(&data->handle, 0, sizeof(struct snapshot_handle));
data->ready = 0;
break;
case SNAPSHOT_SET_IMAGE_SIZE:
image_size = arg;
break;
case SNAPSHOT_AVAIL_SWAP:
avail = count_swap_pages(data->swap, 1);
avail <<= PAGE_SHIFT;
error = put_user(avail, (loff_t __user *)arg);
break;
case SNAPSHOT_GET_SWAP_PAGE:
if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
error = -ENODEV;
break;
}
if (!data->bitmap) {
data->bitmap = alloc_bitmap(count_swap_pages(data->swap, 0));
if (!data->bitmap) {
error = -ENOMEM;
break;
}
}
offset = alloc_swap_page(data->swap, data->bitmap);
if (offset) {
offset <<= PAGE_SHIFT;
error = put_user(offset, (loff_t __user *)arg);
} else {
error = -ENOSPC;
}
break;
case SNAPSHOT_FREE_SWAP_PAGES:
if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
error = -ENODEV;
break;
}
free_all_swap_pages(data->swap, data->bitmap);
free_bitmap(data->bitmap);
data->bitmap = NULL;
break;
case SNAPSHOT_SET_SWAP_FILE:
if (!data->bitmap) {
/*
* User space encodes device types as two-byte values,
* so we need to recode them
*/
if (old_decode_dev(arg)) {
data->swap = swap_type_of(old_decode_dev(arg));
if (data->swap < 0)
error = -ENODEV;
} else {
data->swap = -1;
error = -EINVAL;
}
} else {
error = -EPERM;
}
break;
case SNAPSHOT_S2RAM:
if (!data->frozen) {
error = -EPERM;
break;
}
if (down_trylock(&pm_sem)) {
error = -EBUSY;
break;
}
if (pm_ops->prepare) {
error = pm_ops->prepare(PM_SUSPEND_MEM);
if (error)
goto OutS3;
}
/* Put devices to sleep */
error = device_suspend(PMSG_SUSPEND);
if (error) {
printk(KERN_ERR "Failed to suspend some devices.\n");
} else {
/* Enter S3, system is already frozen */
suspend_enter(PM_SUSPEND_MEM);
/* Wake up devices */
device_resume();
}
if (pm_ops->finish)
pm_ops->finish(PM_SUSPEND_MEM);
OutS3:
up(&pm_sem);
break;
default:
error = -ENOTTY;
}
return error;
}
static int minit(void)
{
int err = 0;
init_hash_parameters();
if (0 > (err = init_some_parameters()))
goto out;
if (0 > (err = alloc_percpu_file()))
goto err_alloc_file;
if (0 > (err = alloc_slab()))
goto err_alloc_slab;
if (0 > (err = alloc_bitmap()))
goto err_bitmap;
if (0 > (err = initial_hash_table_cache()))
goto err_hash_table_cache;
printk(KERN_INFO "Start %s.", THIS_MODULE->name);
if (0 > (err = nf_register_hook(&nf_out_ops))) {
printk(KERN_ERR "Failed to register nf_out %s.\n", THIS_MODULE->name);
goto err_nf_reg_out;
}
if (0 > (err = nf_register_hook(&nf_in_ops))) {
printk(KERN_ERR "Failed to register nf_in %s.\n", THIS_MODULE->name);
goto err_nf_reg_in;
}
if (tcp_alloc_sha1sig_pool() == NULL) {
printk(KERN_ERR "Failed to alloc sha1 pool %s.\n", THIS_MODULE->name);
goto err_sha1siq_pool;
}
err = register_jprobe(&jps_netif_receive_skb);
if (err < 0) {
printk(KERN_ERR "Failed to register jprobe netif_receive_skb %s.\n", THIS_MODULE->name);
goto out;
}
kprobe_in_reged = 1;
goto out;
err_sha1siq_pool:
tcp_free_sha1sig_pool();
err_nf_reg_in:
nf_unregister_hook(&nf_in_ops);
err_nf_reg_out:
nf_unregister_hook(&nf_out_ops);
err_hash_table_cache:
release_hash_table_cache();
err_bitmap:
free_bitmap();
err_alloc_slab:
free_slab();
err_alloc_file:
free_percpu_file();
out:
return err;
}
static Bitmap *outline_to_bitmap_ft(ASS_Renderer *render_priv,
FT_Outline *outline, int bord)
{
Bitmap *bm;
int w, h;
int error;
FT_BBox bbox;
FT_Bitmap bitmap;
FT_Outline_Get_CBox(outline, &bbox);
if (bbox.xMin >= bbox.xMax || bbox.yMin >= bbox.yMax) {
bm = alloc_bitmap(2 * bord, 2 * bord);
if (!bm)
return NULL;
bm->left = bm->top = -bord;
return bm;
}
// move glyph to origin (0, 0)
bbox.xMin &= ~63;
bbox.yMin &= ~63;
FT_Outline_Translate(outline, -bbox.xMin, -bbox.yMin);
if (bbox.xMax > INT_MAX - 63 || bbox.yMax > INT_MAX - 63)
return NULL;
// bitmap size
bbox.xMax = (bbox.xMax + 63) & ~63;
bbox.yMax = (bbox.yMax + 63) & ~63;
w = (bbox.xMax - bbox.xMin) >> 6;
h = (bbox.yMax - bbox.yMin) >> 6;
// pen offset
bbox.xMin >>= 6;
bbox.yMax >>= 6;
if (w < 0 || h < 0 || w > 8000000 / FFMAX(h, 1) ||
w > INT_MAX - 2 * bord || h > INT_MAX - 2 * bord) {
ass_msg(render_priv->library, MSGL_WARN, "Glyph bounding box too large: %dx%dpx",
w, h);
return NULL;
}
// allocate and set up bitmap
bm = alloc_bitmap(w + 2 * bord, h + 2 * bord);
if (!bm)
return NULL;
bm->left = bbox.xMin - bord;
bm->top = -bbox.yMax - bord;
bitmap.width = w;
bitmap.rows = h;
bitmap.pitch = bm->stride;
bitmap.buffer = bm->buffer + bord + bm->stride * bord;
bitmap.num_grays = 256;
bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
// render into target bitmap
if ((error = FT_Outline_Get_Bitmap(render_priv->ftlibrary, outline, &bitmap))) {
ass_msg(render_priv->library, MSGL_WARN, "Failed to rasterize glyph: %d\n", error);
ass_free_bitmap(bm);
return NULL;
}
return bm;
}
static void
pk_unpack_fn P1C(ubyte, ch)
{
int i, j;
ubyte n;
int row_bit_pos;
boolean paint_switch;
BMUNIT *cp;
long fpwidth;
BMUNIT word;
int word_weight, bytes_wide;
int rows_left, h_bit, count;
register struct glyph *g = ¤t_font->glyph[ch];
/* We randomly chose `x2' to store this above. */
PK_flag_byte = g->x2;
PK_dyn_f = PK_flag_byte >> 4;
paint_switch = !!(PK_flag_byte & 8);
PK_flag_byte &= 0x7;
if (PK_flag_byte == 7)
n = 4;
else if (PK_flag_byte > 3)
n = 2;
else
n = 1;
if (debug & DBG_PK)
Printf ("loading pk char %d, char type %d ", ch, n);
/* Set the static variable for other routines to get the data from. */
data_string = g->packed_data;
/* Now read rest of character preamble. */
if (n != 4)
fpwidth = data_snum (3);
else
{
fpwidth = data_sfour ();
(void) data_four (); /* horizontal escapement */
}
(void) data_num (n); /* vertical escapement */
{
unsigned long w, h;
w = data_num (n);
h = data_num (n);
if (w > 0x7fff || h > 0x7fff)
oops ("Too large character in file %s", current_font->fontname);
g->bitmap.w = w;
g->bitmap.h = h;
}
g->x = data_snum (n);
g->y = data_snum (n);
g->dvi_adv = ((double) current_font->scale * fpwidth) / (1 << 20);
if (debug & DBG_PK)
{
if (g->bitmap.w != 0)
Printf (", size=%dx%d, dvi_adv=%d", g->bitmap.w, g->bitmap.h,
g->dvi_adv);
Putchar ('\n');
}
alloc_bitmap (&g->bitmap);
cp = (BMUNIT *) g->bitmap.bits;
/* read character data into *cp. */
bytes_wide = ROUNDUP (g->bitmap.w, BITS_PER_BMUNIT) * BYTES_PER_BMUNIT;
PK_bitpos = -1;
if (PK_dyn_f == 14) /* get raster by bits */
{
bzero (g->bitmap.bits, g->bitmap.h * bytes_wide);
for (i = 0; i < g->bitmap.h; i++) /* get all rows */
{
cp = ADD (g->bitmap.bits, i * bytes_wide);
#ifndef MSBITFIRST
row_bit_pos = -1;
#else
row_bit_pos = BITS_PER_BMUNIT;
#endif
for (j = 0; j < g->bitmap.w; j++) /* get one row */
{
if (--PK_bitpos < 0)
{
word = data_one ();
PK_bitpos = 7;
}
#ifndef MSBITFIRST
if (++row_bit_pos >= BITS_PER_BMUNIT)
#else
if (--row_bit_pos < 0)
#endif
{
cp++;
#ifndef MSBITFIRST
row_bit_pos = 0;
#else
row_bit_pos = BITS_PER_BMUNIT - 1;
#endif
}
if (word & (1 << PK_bitpos))
*cp |= 1 << row_bit_pos;
}
}
}
else
{
/* get packed raster */
rows_left = g->bitmap.h;
h_bit = g->bitmap.w;
PK_repeat_count = 0;
word_weight = BITS_PER_BMUNIT;
word = 0;
while (rows_left > 0)
{
count = PK_packed_num ();
while (count > 0)
{
if (count < word_weight && count < h_bit)
{
#ifndef MSBITFIRST
if (paint_switch)
word |= bit_masks[count] <<
(BITS_PER_BMUNIT - word_weight);
#endif
h_bit -= count;
word_weight -= count;
#ifdef MSBITFIRST
if (paint_switch)
word |= bit_masks[count] << word_weight;
#endif
count = 0;
}
else if (count >= h_bit && h_bit <= word_weight)
{
if (paint_switch)
word |= bit_masks[h_bit] <<
#ifndef MSBITFIRST
(BITS_PER_BMUNIT - word_weight);
#else
(word_weight - h_bit);
#endif
*cp++ = word;
/* "output" row(s) */
for (i = PK_repeat_count * bytes_wide /
BYTES_PER_BMUNIT; i > 0; --i)
{
*cp = *SUB (cp, bytes_wide);
++cp;
}
rows_left -= PK_repeat_count + 1;
PK_repeat_count = 0;
word = 0;
word_weight = BITS_PER_BMUNIT;
count -= h_bit;
h_bit = g->bitmap.w;
}
else
{
if (paint_switch)
#ifndef MSBITFIRST
word |= bit_masks[word_weight] <<
(BITS_PER_BMUNIT - word_weight);
#else
word |= bit_masks[word_weight];
#endif
*cp++ = word;
word = 0;
count -= word_weight;
h_bit -= word_weight;
word_weight = BITS_PER_BMUNIT;
}
}
paint_switch = 1 - paint_switch;
}
if (cp != ((BMUNIT *) (g->bitmap.bits + bytes_wide * g->bitmap.h)))
oops ("Wrong number of bits stored: char. %d, font %s", ch,
current_font->fontname);
if (rows_left != 0 || h_bit != g->bitmap.w)
oops ("Bad pk file (%s), too many bits", current_font->fontname);
}
/* Now that we've read the packed data, we can release the memory. */
free (g->packed_data);
g->packed_data = NULL;
}
static int snapshot_ioctl(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg)
{
int error = 0;
struct snapshot_data *data;
loff_t avail;
sector_t offset;
if (_IOC_TYPE(cmd) != SNAPSHOT_IOC_MAGIC)
return -ENOTTY;
if (_IOC_NR(cmd) > SNAPSHOT_IOC_MAXNR)
return -ENOTTY;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
data = filp->private_data;
switch (cmd) {
case SNAPSHOT_FREEZE:
if (data->frozen)
break;
mutex_lock(&pm_mutex);
if (freeze_processes()) {
thaw_processes();
error = -EBUSY;
}
mutex_unlock(&pm_mutex);
if (!error)
data->frozen = 1;
break;
case SNAPSHOT_UNFREEZE:
if (!data->frozen)
break;
mutex_lock(&pm_mutex);
thaw_processes();
mutex_unlock(&pm_mutex);
data->frozen = 0;
break;
case SNAPSHOT_ATOMIC_SNAPSHOT:
if (data->mode != O_RDONLY || !data->frozen || data->ready) {
error = -EPERM;
break;
}
error = snapshot_suspend(data->platform_suspend);
if (!error)
error = put_user(in_suspend, (unsigned int __user *)arg);
if (!error)
data->ready = 1;
break;
case SNAPSHOT_ATOMIC_RESTORE:
snapshot_write_finalize(&data->handle);
if (data->mode != O_WRONLY || !data->frozen ||
!snapshot_image_loaded(&data->handle)) {
error = -EPERM;
break;
}
error = snapshot_restore(data->platform_suspend);
break;
case SNAPSHOT_FREE:
swsusp_free();
memset(&data->handle, 0, sizeof(struct snapshot_handle));
data->ready = 0;
break;
case SNAPSHOT_SET_IMAGE_SIZE:
image_size = arg;
break;
case SNAPSHOT_AVAIL_SWAP:
avail = count_swap_pages(data->swap, 1);
avail <<= PAGE_SHIFT;
error = put_user(avail, (loff_t __user *)arg);
break;
case SNAPSHOT_GET_SWAP_PAGE:
if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
error = -ENODEV;
break;
}
if (!data->bitmap) {
data->bitmap = alloc_bitmap(count_swap_pages(data->swap, 0));
if (!data->bitmap) {
error = -ENOMEM;
break;
}
}
offset = alloc_swapdev_block(data->swap, data->bitmap);
if (offset) {
offset <<= PAGE_SHIFT;
error = put_user(offset, (sector_t __user *)arg);
} else {
error = -ENOSPC;
}
break;
case SNAPSHOT_FREE_SWAP_PAGES:
if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
error = -ENODEV;
break;
}
free_all_swap_pages(data->swap, data->bitmap);
free_bitmap(data->bitmap);
data->bitmap = NULL;
break;
case SNAPSHOT_SET_SWAP_FILE:
if (!data->bitmap) {
/*
* User space encodes device types as two-byte values,
* so we need to recode them
*/
if (old_decode_dev(arg)) {
data->swap = swap_type_of(old_decode_dev(arg),
0, NULL);
if (data->swap < 0)
error = -ENODEV;
} else {
data->swap = -1;
error = -EINVAL;
}
} else {
error = -EPERM;
}
break;
case SNAPSHOT_S2RAM:
if (!pm_ops) {
error = -ENOSYS;
break;
}
if (!data->frozen) {
error = -EPERM;
break;
}
if (!mutex_trylock(&pm_mutex)) {
error = -EBUSY;
break;
}
if (pm_ops->prepare) {
error = pm_ops->prepare(PM_SUSPEND_MEM);
if (error)
goto OutS3;
}
/* Put devices to sleep */
suspend_console();
error = device_suspend(PMSG_SUSPEND);
if (error) {
printk(KERN_ERR "Failed to suspend some devices.\n");
} else {
/* Enter S3, system is already frozen */
suspend_enter(PM_SUSPEND_MEM);
/* Wake up devices */
device_resume();
}
resume_console();
if (pm_ops->finish)
pm_ops->finish(PM_SUSPEND_MEM);
OutS3:
mutex_unlock(&pm_mutex);
break;
case SNAPSHOT_PMOPS:
error = -EINVAL;
switch (arg) {
case PMOPS_PREPARE:
if (pm_ops && pm_ops->enter) {
data->platform_suspend = 1;
error = 0;
} else {
error = -ENOSYS;
}
break;
case PMOPS_ENTER:
if (data->platform_suspend) {
disable_nonboot_cpus();
kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
error = pm_ops->enter(PM_SUSPEND_DISK);
enable_nonboot_cpus();
}
break;
case PMOPS_FINISH:
if (data->platform_suspend)
error = 0;
break;
default:
printk(KERN_ERR "SNAPSHOT_PMOPS: invalid argument %ld\n", arg);
}
break;
case SNAPSHOT_SET_SWAP_AREA:
if (data->bitmap) {
error = -EPERM;
} else {
struct resume_swap_area swap_area;
dev_t swdev;
error = copy_from_user(&swap_area, (void __user *)arg,
sizeof(struct resume_swap_area));
if (error) {
error = -EFAULT;
break;
}
/*
* User space encodes device types as two-byte values,
* so we need to recode them
*/
swdev = old_decode_dev(swap_area.dev);
if (swdev) {
offset = swap_area.offset;
data->swap = swap_type_of(swdev, offset, NULL);
if (data->swap < 0)
error = -ENODEV;
} else {
data->swap = -1;
error = -EINVAL;
}
}
break;
default:
error = -ENOTTY;
}
return error;
}
