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; }