static void init_tracking(struct kmem_cache *s, void *object) { if (!(s->flags & SLAB_STORE_USER)) return; set_track(s, object, TRACK_FREE, 0UL); set_track(s, object, TRACK_ALLOC, 0UL); }
void hippo_canvas_block_music_set_track_history(HippoCanvasBlockMusic *block_music, GSList *track_history) { if (track_history) { set_track(block_music, track_history->data); set_old_tracks(block_music, track_history->next); } else { set_track(block_music, NULL); set_old_tracks(block_music, NULL); } }
static noinline int alloc_debug_processing(struct kmem_cache *s, struct page *page, void *object, unsigned long addr) { if (!check_slab(s, page)) goto bad; if (!check_valid_pointer(s, page, object)) { object_err(s, page, object, "Freelist Pointer check fails"); goto bad; } if (!check_object(s, page, object, SLUB_RED_INACTIVE)) goto bad; /* Success perform special debug activities for allocs */ if (s->flags & SLAB_STORE_USER) set_track(s, object, TRACK_ALLOC, addr); trace(s, page, object, 1); init_object(s, object, SLUB_RED_ACTIVE); return 1; bad: if (PageSlab(page)) { /* * If this is a slab page then lets do the best we can * to avoid issues in the future. Marking all objects * as used avoids touching the remaining objects. */ slab_fix(s, "Marking all objects used"); page->inuse = page->objects; page->freelist = NULL; } return 0; }
void kasan_kmalloc(struct kmem_cache *cache, const void *object, size_t size, gfp_t flags) { unsigned long redzone_start; unsigned long redzone_end; #ifdef CONFIG_SLAB if (flags & __GFP_RECLAIM) quarantine_reduce(); #endif if (unlikely(object == NULL)) return; redzone_start = round_up((unsigned long)(object + size), KASAN_SHADOW_SCALE_SIZE); redzone_end = round_up((unsigned long)object + cache->object_size, KASAN_SHADOW_SCALE_SIZE); kasan_unpoison_shadow(object, size); kasan_poison_shadow((void *)redzone_start, redzone_end - redzone_start, KASAN_KMALLOC_REDZONE); #ifdef CONFIG_SLAB if (cache->flags & SLAB_KASAN) { struct kasan_alloc_meta *alloc_info = get_alloc_info(cache, object); alloc_info->state = KASAN_STATE_ALLOC; alloc_info->alloc_size = size; set_track(&alloc_info->track, flags); } #endif }
bool kasan_slab_free(struct kmem_cache *cache, void *object) { #ifdef CONFIG_SLAB /* RCU slabs could be legally used after free within the RCU period */ if (unlikely(cache->flags & SLAB_DESTROY_BY_RCU)) return false; if (likely(cache->flags & SLAB_KASAN)) { struct kasan_alloc_meta *alloc_info = get_alloc_info(cache, object); struct kasan_free_meta *free_info = get_free_info(cache, object); switch (alloc_info->state) { case KASAN_STATE_ALLOC: alloc_info->state = KASAN_STATE_QUARANTINE; quarantine_put(free_info, cache); set_track(&free_info->track, GFP_NOWAIT); kasan_poison_slab_free(cache, object); return true; case KASAN_STATE_QUARANTINE: case KASAN_STATE_FREE: pr_err("Double free"); dump_stack(); break; default: break; } } return false; #else kasan_poison_slab_free(cache, object); return false; #endif }
static bool __kasan_slab_free(struct kmem_cache *cache, void *object, unsigned long ip, bool quarantine) { s8 shadow_byte; unsigned long rounded_up_size; if (unlikely(nearest_obj(cache, virt_to_head_page(object), object) != object)) { kasan_report_invalid_free(object, ip); return true; } /* RCU slabs could be legally used after free within the RCU period */ if (unlikely(cache->flags & SLAB_TYPESAFE_BY_RCU)) return false; shadow_byte = READ_ONCE(*(s8 *)kasan_mem_to_shadow(object)); if (shadow_byte < 0 || shadow_byte >= KASAN_SHADOW_SCALE_SIZE) { kasan_report_invalid_free(object, ip); return true; } rounded_up_size = round_up(cache->object_size, KASAN_SHADOW_SCALE_SIZE); kasan_poison_shadow(object, rounded_up_size, KASAN_KMALLOC_FREE); if (!quarantine || unlikely(!(cache->flags & SLAB_KASAN))) return false; set_track(&get_alloc_info(cache, object)->free_track, GFP_NOWAIT); quarantine_put(get_free_info(cache, object), cache); return true; }
int cd_is_audio(int track) { if (!get_audio_info()) return -1; set_track(track); return (cdrom_data.track_type == 64) ? 0 : 1; }
static void hippo_block_music_chat_dispose(GObject *object) { HippoBlockMusicChat *block_music_chat = HIPPO_BLOCK_MUSIC_CHAT(object); set_track(block_music_chat, NULL); G_OBJECT_CLASS(hippo_block_music_chat_parent_class)->dispose(object); }
static unsigned long end_position(int end) { if (end == cdrom_data.high_audio) return cdrom_data.endofdisk; else { set_track(end + 1); return cdrom_data.track_position; } }
static noinline int free_debug_processing(struct kmem_cache *s, struct page *page, void *object, unsigned long addr) { unsigned long flags; int rc = 0; local_irq_save(flags); slab_lock(page); if (!check_slab(s, page)) goto fail; if (!check_valid_pointer(s, page, object)) { slab_err(s, page, "Invalid object pointer 0x%p", object); goto fail; } if (on_freelist(s, page, object)) { object_err(s, page, object, "Object already free"); goto fail; } if (!check_object(s, page, object, SLUB_RED_ACTIVE)) goto out; if (unlikely(s != page->slab)) { if (!PageSlab(page)) { slab_err(s, page, "Attempt to free object(0x%p) " "outside of slab", object); } else if (!page->slab) { printk(KERN_ERR "SLUB <none>: no slab for object 0x%p.\n", object); dump_stack(); } else object_err(s, page, object, "page slab pointer corrupt."); goto fail; } if (s->flags & SLAB_STORE_USER) set_track(s, object, TRACK_FREE, addr); trace(s, page, object, 0); init_object(s, object, SLUB_RED_INACTIVE); rc = 1; out: slab_unlock(page); local_irq_restore(flags); return rc; fail: slab_fix(s, "Object at 0x%p not freed", object); goto out; }
int cd_current_track(void) { unsigned long loc; short i; if (!audio_busy() || !get_audio_info()) return 0; loc = head_position(); for (i = cdrom_data.high_audio; i > cdrom_data.low_audio; i--) { set_track(i); if (loc > cdrom_data.track_position) return i; } return cdrom_data.low_audio; }
static gboolean hippo_block_music_chat_update_from_xml (HippoBlock *block, HippoDataCache *cache, LmMessageNode *node) { HippoBlockMusicChat *block_music_chat = HIPPO_BLOCK_MUSIC_CHAT(block); LmMessageNode *music_node; LmMessageNode *track_node; LmMessageNode *recent_messages_node = NULL; HippoPerson *user; HippoTrack *track; if (!HIPPO_BLOCK_CLASS(hippo_block_music_chat_parent_class)->update_from_xml(block, cache, node)) return FALSE; if (!hippo_xml_split(cache, node, NULL, "musicChat", HIPPO_SPLIT_NODE, &music_node, NULL)) return FALSE; if (!hippo_xml_split(cache, music_node, NULL, "userId", HIPPO_SPLIT_PERSON, &user, "recentMessages", HIPPO_SPLIT_NODE, &recent_messages_node, "track", HIPPO_SPLIT_NODE, &track_node, NULL)) return FALSE; if (!hippo_block_set_recent_messages_from_xml(block, cache, recent_messages_node)) return FALSE; hippo_block_abstract_person_set_user(HIPPO_BLOCK_ABSTRACT_PERSON(block), user); track = hippo_track_new_from_xml(cache, track_node); if (!track) return FALSE; hippo_block_set_chat_id(block, hippo_track_get_play_id(track)); set_track(block_music_chat, track); g_object_unref(track); return TRUE; }
// Loads track if metadata exists, otherwise load the metadata static void load_track_or_metadata(sp_session *session, sp_track *track, const char *uri) { if (track != NULL) { if (s_is_playing) sp_session_player_play(session, false); sp_session_player_unload(session); sp_track_release(track); } track = sp_link_as_track(sp_link_create_from_string(uri)); set_track(track); sp_track_add_ref(track); s_player_position = 0; s_current_uri = uri; // either the track is already cached and can be used or we need to wait for the metadata callback if (sp_track_is_loaded(track)) load_and_play_track(session, track); else s_is_waiting_for_metadata = true; }
bool kasan_slab_free(struct kmem_cache *cache, void *object) { s8 shadow_byte; /* RCU slabs could be legally used after free within the RCU period */ if (unlikely(cache->flags & SLAB_DESTROY_BY_RCU)) return false; shadow_byte = READ_ONCE(*(s8 *)kasan_mem_to_shadow(object)); if (shadow_byte < 0 || shadow_byte >= KASAN_SHADOW_SCALE_SIZE) { kasan_report_double_free(cache, object, shadow_byte); return true; } kasan_poison_slab_free(cache, object); if (unlikely(!(cache->flags & SLAB_KASAN))) return false; set_track(&get_alloc_info(cache, object)->free_track, GFP_NOWAIT); quarantine_put(get_free_info(cache, object), cache); return true; }
void kasan_kmalloc(struct kmem_cache *cache, const void *object, size_t size, gfp_t flags) { unsigned long redzone_start; unsigned long redzone_end; if (gfpflags_allow_blocking(flags)) quarantine_reduce(); if (unlikely(object == NULL)) return; redzone_start = round_up((unsigned long)(object + size), KASAN_SHADOW_SCALE_SIZE); redzone_end = round_up((unsigned long)object + cache->object_size, KASAN_SHADOW_SCALE_SIZE); kasan_unpoison_shadow(object, size); kasan_poison_shadow((void *)redzone_start, redzone_end - redzone_start, KASAN_KMALLOC_REDZONE); if (cache->flags & SLAB_KASAN) set_track(&get_alloc_info(cache, object)->alloc_track, flags); }
int mainwin::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QMainWindow::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: actTrack(); break; case 1: actCalibrate(); break; case 2: actPerspective(); break; case 3: set_track(); break; case 4: set_calibrate(); break; case 5: set_perspective(); break; case 6: about(); break; case 7: updateStats(); break; case 8: end_signal(); break; case 9: play(); break; case 10: finished_play(); break; default: ; } _id -= 11; } return _id; }
static unsigned long start_position(int start) { set_track(start); return cdrom_data.track_position; }