/*static*/ status_t VMAddressSpace::Init() { rw_lock_init(&sAddressSpaceTableLock, "address spaces table"); // create the area and address space hash tables { new(&sAddressSpaceTable) AddressSpaceTable; status_t error = sAddressSpaceTable.Init(ASPACE_HASH_TABLE_SIZE); if (error != B_OK) panic("vm_init: error creating aspace hash table\n"); } // create the initial kernel address space if (Create(B_SYSTEM_TEAM, KERNEL_BASE, KERNEL_SIZE, true, &sKernelAddressSpace) != B_OK) { panic("vm_init: error creating kernel address space!\n"); } add_debugger_command("aspaces", &_DumpListCommand, "Dump a list of all address spaces"); add_debugger_command("aspace", &_DumpCommand, "Dump info about a particular address space"); return B_OK; }
static status_t socket_std_ops(int32 op, ...) { switch (op) { case B_MODULE_INIT: { new (&sSocketList) SocketList; mutex_init(&sSocketLock, "socket list"); #if ENABLE_DEBUGGER_COMMANDS add_debugger_command("sockets", dump_sockets, "lists all sockets"); add_debugger_command("socket", dump_socket, "dumps a socket"); #endif return B_OK; } case B_MODULE_UNINIT: ASSERT(sSocketList.IsEmpty()); mutex_destroy(&sSocketLock); #if ENABLE_DEBUGGER_COMMANDS remove_debugger_command("socket", dump_socket); remove_debugger_command("sockets", dump_sockets); #endif return B_OK; default: return B_ERROR; } }
void slab_init_post_area() { MemoryManager::InitPostArea(); add_debugger_command("slabs", dump_slabs, "list all object caches"); add_debugger_command("slab_cache", dump_cache_info, "dump information about a specific object cache"); add_debugger_command("slab_depot", dump_object_depot, "dump contents of an object depot"); add_debugger_command("slab_magazine", dump_depot_magazine, "dump contents of a depot magazine"); }
static status_t tcp_init() { rw_lock_init(&sEndpointManagersLock, "endpoint managers"); status_t status = gStackModule->register_domain_protocols(AF_INET, SOCK_STREAM, 0, "network/protocols/tcp/v1", "network/protocols/ipv4/v1", NULL); if (status < B_OK) return status; status = gStackModule->register_domain_protocols(AF_INET6, SOCK_STREAM, 0, "network/protocols/tcp/v1", "network/protocols/ipv6/v1", NULL); if (status < B_OK) return status; status = gStackModule->register_domain_protocols(AF_INET, SOCK_STREAM, IPPROTO_TCP, "network/protocols/tcp/v1", "network/protocols/ipv4/v1", NULL); if (status < B_OK) return status; status = gStackModule->register_domain_protocols(AF_INET6, SOCK_STREAM, IPPROTO_TCP, "network/protocols/tcp/v1", "network/protocols/ipv6/v1", NULL); if (status < B_OK) return status; status = gStackModule->register_domain_receiving_protocol(AF_INET, IPPROTO_TCP, "network/protocols/tcp/v1"); if (status < B_OK) return status; status = gStackModule->register_domain_receiving_protocol(AF_INET6, IPPROTO_TCP, "network/protocols/tcp/v1"); if (status < B_OK) return status; add_debugger_command("tcp_endpoints", dump_endpoints, "lists all open TCP endpoints"); add_debugger_command("tcp_endpoint", dump_endpoint, "dumps a TCP endpoint internal state"); return B_OK; }
// AddDebuggerCommands void KernelDebug::AddDebuggerCommands() { if (atomic_add(&sCommandsAdded, 1) > 0) return; PRINT(("KernelDebug::AddDebuggerCommands(): adding debugger commands\n")); add_debugger_command("ufs", DebugUFS, "prints general info about " "userland FS"); add_debugger_command("ufs_portpool", DebugPortPool, "ufs_portpool <port pool pointer> - prints info about a " "userland FS port pool"); add_debugger_command("ufs_port", DebugPort, "ufs_port <port pointer> - prints info about a userland FS port"); }
static status_t bcd_std_ops(int32 op, ...) { status_t status; switch (op) { case B_MODULE_INIT: new (&sConnectionList) DoublyLinkedList<HciConnection>; add_debugger_command("btConnections", &DumpHciConnections, "Lists Bluetooth Connections with RemoteDevices & channels"); status = get_module(NET_BUFFER_MODULE_NAME, (module_info **)&gBufferModule); if (status < B_OK) return status; return B_OK; break; case B_MODULE_UNINIT: remove_debugger_command("btConnections", &DumpHciConnections); put_module(NET_BUFFER_MODULE_NAME); return B_OK; break; } return B_ERROR; }
status_t image_init(void) { sImageTable = new(std::nothrow) ImageTable; if (sImageTable == NULL) { panic("image_init(): Failed to allocate image table!"); return B_NO_MEMORY; } status_t error = sImageTable->Init(); if (error != B_OK) { panic("image_init(): Failed to init image table: %s", strerror(error)); return error; } new(&sNotificationService) ImageNotificationService(); sNotificationService.Register(); #ifdef ADD_DEBUGGER_COMMANDS add_debugger_command("team_images", &dump_images_list, "Dump all registered images from the current team"); #endif return B_OK; }
status_t int_init_post_vm(kernel_args *args) { int i; /* initialize the vector list */ for (i = 0; i < NUM_IO_VECTORS; i++) { B_INITIALIZE_SPINLOCK(&sVectors[i].vector_lock); sVectors[i].enable_count = 0; sVectors[i].no_lock_vector = false; #if DEBUG_INTERRUPTS sVectors[i].handled_count = 0; sVectors[i].unhandled_count = 0; sVectors[i].trigger_count = 0; sVectors[i].ignored_count = 0; #endif sVectors[i].handler_list = NULL; } #if DEBUG_INTERRUPTS add_debugger_command("ints", &dump_int_statistics, "list interrupt statistics"); #endif return arch_int_init_post_vm(args); }
status_t ps2_service_init(void) { TRACE("ps2: ps2_service_init\n"); sServiceCmdBuffer = create_packet_buffer(sizeof(ps2_service_cmd) * 50); if (sServiceCmdBuffer == NULL) goto err1; sServiceSem = create_sem(0, "ps2 service"); if (sServiceSem < B_OK) goto err2; sServiceThread = spawn_kernel_thread(ps2_service_thread, "ps2 service", 20, NULL); if (sServiceThread < B_OK) goto err3; sServiceTerminate = false; resume_thread(sServiceThread); #ifdef DEBUG_PUBLISHING add_debugger_command("ps2republish", &ps2_republish, "republish a ps2 device (0-3 mouse, 4 keyb (default))"); #endif TRACE("ps2: ps2_service_init done\n"); return B_OK; err3: delete_sem(sServiceSem); err2: delete_packet_buffer(sServiceCmdBuffer); err1: TRACE("ps2: ps2_service_init failed\n"); return B_ERROR; }
status_t system_info_init(struct kernel_args *args) { add_debugger_command("info", &dump_info, "System info"); return arch_system_info_init(args); }
status_t init_driver() { status_t status = get_module(B_PCI_MODULE_NAME, (module_info**)&gPCIModule); if (status < B_OK) { return ENOSYS; } load_settings(); TRACE_ALWAYS("%s\n", kVersion); pci_info info = {0}; for (long i = 0; B_OK == (*gPCIModule->get_nth_pci_info)(i, &info); i++) { for (size_t idx = 0; idx < _countof(cardInfos); idx++) { if (info.vendor_id == cardInfos[idx].VendorId() && info.device_id == cardInfos[idx].DeviceId()) { TRACE_ALWAYS("Found:%s %#010x\n", cardInfos[idx].Description(), cardInfos[idx].Id()); if (numCards == MAX_DEVICES) { break; } Device* device = new Device(cardInfos[idx], info); if (device == 0) { return ENODEV; } status_t status = device->InitCheck(); if (status < B_OK) { delete device; break; } status = device->SetupDevice(); if (status < B_OK) { delete device; break; } char name[DEVNAME_LEN] = {0}; sprintf(name, "net/%s/%ld", cardInfos[idx].Name(), numCards); gDeviceNames[numCards] = strdup(name); gDevices[numCards++] = device; } } } if (numCards == 0) { put_module(B_PCI_MODULE_NAME); return ENODEV; } add_debugger_command(DRIVER_NAME, SiS19X_DebuggerCommand, "SiS190/191 Ethernet driver info"); return B_OK; }
status_t int_init_post_vm(kernel_args* args) { int i; /* initialize the vector list */ for (i = 0; i < NUM_IO_VECTORS; i++) { B_INITIALIZE_SPINLOCK(&sVectors[i].vector_lock); sVectors[i].enable_count = 0; sVectors[i].no_lock_vector = false; sVectors[i].type = INTERRUPT_TYPE_UNKNOWN; B_INITIALIZE_SPINLOCK(&sVectors[i].load_lock); sVectors[i].last_measure_time = 0; sVectors[i].last_measure_active = 0; sVectors[i].load = 0; #if DEBUG_INTERRUPTS sVectors[i].handled_count = 0; sVectors[i].unhandled_count = 0; sVectors[i].trigger_count = 0; sVectors[i].ignored_count = 0; #endif sVectors[i].handler_list = NULL; sVectorCPUAssignments[i].irq = i; sVectorCPUAssignments[i].count = 1; sVectorCPUAssignments[i].handlers_count = 0; sVectorCPUAssignments[i].load = 0; sVectorCPUAssignments[i].cpu = -1; } #if DEBUG_INTERRUPTS add_debugger_command("ints", &dump_int_statistics, "list interrupt statistics"); #endif add_debugger_command("int_load", &dump_int_load, "list interrupt usage statistics"); return arch_int_init_post_vm(args); }
status_t rtc_init(kernel_args *args) { sRealTimeData = (struct real_time_data*)allocate_commpage_entry( COMMPAGE_ENTRY_REAL_TIME_DATA, sizeof(struct real_time_data)); arch_rtc_init(args, sRealTimeData); rtc_hw_to_system(); add_debugger_command("rtc", &rtc_debug, "Set and test the real-time clock"); return B_OK; }
status_t init_interfaces() { recursive_lock_init(&sLock, "net interfaces"); mutex_init(&sHashLock, "net local addresses"); new (&sInterfaces) InterfaceList; new (&sAddressTable) AddressTable; // static C++ objects are not initialized in the module startup #if ENABLE_DEBUGGER_COMMANDS add_debugger_command("net_interface", &dump_interface, "Dump the given network interface"); add_debugger_command("net_interfaces", &dump_interfaces, "Dump all network interfaces"); add_debugger_command("net_local", &dump_local, "Dump all local interface addresses"); add_debugger_command("net_route", &dump_route, "Dump the given network route"); #endif return B_OK; }
status_t init_domains() { mutex_init(&sDomainLock, "net domains"); new (&sDomains) DomainList; // static C++ objects are not initialized in the module startup #if ENABLE_DEBUGGER_COMMANDS add_debugger_command("net_domains", &dump_domains, "Dump network domains"); #endif return B_OK; }
status_t low_resource_manager_init_post_thread(void) { sLowResourceWaitSem = create_sem(0, "low resource wait"); if (sLowResourceWaitSem < B_OK) return sLowResourceWaitSem; thread_id thread = spawn_kernel_thread(&low_resource_manager, "low resource manager", B_LOW_PRIORITY, NULL); send_signal_etc(thread, SIGCONT, B_DO_NOT_RESCHEDULE); add_debugger_command("low_resource", &dump_handlers, "Dump list of low resource handlers"); return B_OK; }
status_t blue_screen_init(void) { extern console_module_info gFrameBufferConsoleModule; // we can't use get_module() here, since it's too early in the boot process if (!frame_buffer_console_available()) return B_ERROR; sModule = &gFrameBufferConsoleModule; sScreen.paging = true; sScreen.paging_timeout = false; add_debugger_command("paging", set_paging, "Enable or disable paging"); return B_OK; }
static status_t device_open(const char *name, uint32 /*flags*/, void **_cookie) { TRACE((DEVICE_NAME ": open(name = %s)\n", name)); int32 id; // find accessed device { char *thisName; // search for device name for (id = 0; (thisName = gDeviceNames[id]) != NULL; id++) { if (!strcmp(name, thisName)) break; } if (!thisName) return B_BAD_VALUE; } intel_info *info = gDeviceInfo[id]; mutex_lock(&gLock); if (info->open_count == 0) { // this device has been opened for the first time, so // we allocate needed resources and initialize the structure info->init_status = intel_extreme_init(*info); if (info->init_status == B_OK) { #ifdef DEBUG_COMMANDS add_debugger_command("ie_reg", getset_register, "dumps or sets the specified intel_extreme register"); #endif info->open_count++; } } mutex_unlock(&gLock); if (info->init_status == B_OK) *_cookie = info; return info->init_status; }
status_t blue_screen_init(void) { extern console_module_info gFrameBufferConsoleModule; // we can't use get_module() here, since it's too early in the boot process if (!frame_buffer_console_available()) return B_ERROR; sModule = &gFrameBufferConsoleModule; #ifdef _BOOT_MODE sScreen.paging = false; #else sScreen.paging = !get_safemode_boolean( "disable_onscreen_paging", false); sScreen.paging_timeout = false; add_debugger_command("paging", set_paging, "Enable or disable paging"); #endif return B_OK; }
status_t init_driver(void) { /* get a handle for the pci bus */ if (get_module(B_PCI_MODULE_NAME, (module_info **)&pci_bus) != B_OK) return B_ERROR; /* driver private data */ pd = (DeviceData *)calloc(1, sizeof(DeviceData)); if (!pd) { put_module(B_PCI_MODULE_NAME); return B_ERROR; } /* initialize the benaphore */ INIT_BEN(pd->kernel); /* find all of our supported devices */ et6000ProbeDevices(); #if DEBUG > 0 add_debugger_command("et6000dump", et6000dump, "dump ET6000 kernel driver persistant data"); #endif return B_OK; }
// called each time the driver is loaded by the kernel status_t init_driver(void) { CALLED(); int j; if (get_module(BT_CORE_DATA_MODULE_NAME, (module_info**)&btCoreData) != B_OK) { ERROR("%s: cannot get module '%s'\n", __func__, BT_CORE_DATA_MODULE_NAME); return B_ERROR; } // BT devices MODULE INITS if (get_module(btDevices_name, (module_info**)&btDevices) != B_OK) { ERROR("%s: cannot get module '%s'\n", __func__, btDevices_name); goto err_release3; } // HCI MODULE INITS if (get_module(hci_name, (module_info**)&hci) != B_OK) { ERROR("%s: cannot get module '%s'\n", __func__, hci_name); #ifndef BT_SURVIVE_WITHOUT_HCI goto err_release2; #endif } // USB MODULE INITS if (get_module(usb_name, (module_info**)&usb) != B_OK) { ERROR("%s: cannot get module '%s'\n", __func__, usb_name); goto err_release1; } if (get_module(NET_BUFFER_MODULE_NAME, (module_info**)&nb) != B_OK) { ERROR("%s: cannot get module '%s'\n", __func__, NET_BUFFER_MODULE_NAME); #ifndef BT_SURVIVE_WITHOUT_NET_BUFFERS goto err_release; #endif } // GENERAL INITS dev_table_sem = create_sem(1, BLUETOOTH_DEVICE_DEVFS_NAME "dev_table_lock"); if (dev_table_sem < 0) { goto err; } for (j = 0; j < MAX_BT_GENERIC_USB_DEVICES; j++) { bt_usb_devices[j] = NULL; } // Note: After here device_added and publish devices hooks are called usb->register_driver(BLUETOOTH_DEVICE_DEVFS_NAME, supported_devices, 1, NULL); usb->install_notify(BLUETOOTH_DEVICE_DEVFS_NAME, ¬ify_hooks); add_debugger_command("bth2generic", &dump_driver, "Lists H2 Transport device info"); return B_OK; err: // Releasing put_module(NET_BUFFER_MODULE_NAME); err_release: put_module(usb_name); err_release1: put_module(hci_name); #ifndef BT_SURVIVE_WITHOUT_HCI err_release2: #endif put_module(btDevices_name); err_release3: put_module(BT_CORE_DATA_MODULE_NAME); return B_ERROR; }
static int32 bus_std_ops(int32 op, ...) { switch (op) { case B_MODULE_INIT: { TRACE_MODULE("init\n"); if (gUSBStack) return B_OK; #ifdef HAIKU_TARGET_PLATFORM_BEOS // This code is to handle plain R5 (non-BONE) where the same module // gets loaded multiple times (once for each exported module // interface, the USB v2 and v3 API in our case). We don't want to // ever create multiple stacks however, so we "share" the same stack // for both modules by storing it's address in a shared area. void *address = NULL; area_id shared = find_area("shared usb stack"); if (shared >= B_OK && clone_area("usb stack clone", &address, B_ANY_KERNEL_ADDRESS, B_KERNEL_READ_AREA, shared) >= B_OK) { gUSBStack = *((Stack **)address); TRACE_MODULE("found shared stack at %p\n", gUSBStack); return B_OK; } #endif #ifdef TRACE_USB set_dprintf_enabled(true); #ifndef HAIKU_TARGET_PLATFORM_HAIKU load_driver_symbols("usb"); #endif #endif Stack *stack = new(std::nothrow) Stack(); TRACE_MODULE("usb_module: stack created %p\n", stack); if (!stack) return B_NO_MEMORY; if (stack->InitCheck() != B_OK) { delete stack; return ENODEV; } gUSBStack = stack; #ifdef HAIKU_TARGET_PLATFORM_HAIKU add_debugger_command("get_usb_pipe_for_id", &debug_get_pipe_for_id, "Gets the config for a USB pipe"); #elif HAIKU_TARGET_PLATFORM_BEOS // Plain R5 workaround, see comment above. shared = create_area("shared usb stack", &address, B_ANY_KERNEL_ADDRESS, B_PAGE_SIZE, B_NO_LOCK, B_KERNEL_WRITE_AREA); if (shared >= B_OK) *((Stack **)address) = gUSBStack; #endif break; } case B_MODULE_UNINIT: TRACE_MODULE("uninit\n"); delete gUSBStack; gUSBStack = NULL; #ifdef HAIKU_TARGET_PLATFORM_HAIKU remove_debugger_command("get_usb_pipe_for_id", &debug_get_pipe_for_id); #endif break; default: return EINVAL; } return B_OK; }