headers/cpp/defalloc.h

76

pointer address(reference x) { return (pointer)&x; }

headers/cpp/stl_alloc.h

753

pointer address(reference __x) const { return &__x; }

headers/cpp/stl_alloc.h

754

const_pointer address(const_reference __x) const { return &__x; }

headers/cpp/stl_alloc.h

831

pointer address(reference __x) const { return &__x; }

headers/cpp/stl_alloc.h

832

const_pointer address(const_reference __x) const { return &__x; }

headers/libs/libfdt/fdt.h

32

fdt64_t address;

headers/libs/libfdt/libfdt.h

1542

int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size);

headers/libs/libfdt/libfdt.h

454

int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size);

headers/os/add-ons/network_settings/NetworkSettings.h

182

BNetworkInterfaceAddressSettings& address);

headers/os/add-ons/network_settings/NetworkSettings.h

267

BNetworkServiceAddressSettings& address);

headers/os/bluetooth/RemoteDevice.h

54

RemoteDevice(const BString& address);

headers/os/bluetooth/RemoteDevice.h

55

RemoteDevice(const bdaddr_t address, uint8 record[3]);

headers/os/drivers/ACPI.h

165

acpi_physical_address address, uint32 bitWidth, int *value,

headers/os/drivers/ACPI.h

214

acpi_gpe_handler address);

headers/os/drivers/ISA.h

20

uint32 address; // memory address in little endian

headers/os/drivers/KernelExport.h

110

phys_addr_t address; /* address in physical memory */

headers/os/drivers/KernelExport.h

190

extern status_t unlock_memory_etc(team_id team, void *address,

headers/os/drivers/KernelExport.h

193

extern status_t get_memory_map_etc(team_id team, const void *address,

headers/os/kernel/OS.h

106

extern area_id area_for(void *address);

headers/os/kernel/OS.h

68

void *address;

headers/os/kernel/debugger.h

230

void *address; // address from which to read

headers/os/kernel/debugger.h

246

void *address; // address to which to write

headers/os/kernel/debugger.h

261

const void *address; // address within area to clone

headers/os/kernel/debugger.h

266

const void *address; // corresponding address in clone

headers/os/kernel/debugger.h

315

void *address; // breakpoint address

headers/os/kernel/debugger.h

326

void *address; // breakpoint address

headers/os/kernel/debugger.h

333

void *address; // watchpoint address

headers/os/kernel/debugger.h

348

void *address; // watchpoint address

headers/os/kernel/debugger.h

62

extern status_t set_debugger_breakpoint(void *address);

headers/os/kernel/debugger.h

63

extern status_t clear_debugger_breakpoint(void *address);

headers/os/kernel/debugger.h

64

extern status_t set_debugger_watchpoint(void *address, uint32 type,

headers/os/kernel/debugger.h

66

extern status_t clear_debugger_watchpoint(void *address);

headers/os/kernel/image.h

87

void clear_caches(void *address, size_t length, uint32 flags);

headers/os/net/DatagramSocket.h

32

virtual ssize_t SendTo(const BNetworkAddress& address,

headers/os/net/NetworkAddress.h

115

status_t ResolveTo(const BNetworkAddress& address);

headers/os/net/NetworkAddress.h

147

status_t _ParseLinkAddress(const char* address);

headers/os/net/NetworkAddress.h

22

BNetworkAddress(const char* address,

headers/os/net/NetworkAddress.h

24

BNetworkAddress(const char* address,

headers/os/net/NetworkAddress.h

26

BNetworkAddress(int family, const char* address,

headers/os/net/NetworkAddress.h

28

BNetworkAddress(int family, const char* address,

headers/os/net/NetworkAddress.h

30

BNetworkAddress(const sockaddr& address);

headers/os/net/NetworkAddress.h

32

const sockaddr_storage& address);

headers/os/net/NetworkAddress.h

33

BNetworkAddress(const sockaddr_in& address);

headers/os/net/NetworkAddress.h

34

BNetworkAddress(const sockaddr_in6& address);

headers/os/net/NetworkAddress.h

35

BNetworkAddress(const sockaddr_dl& address);

headers/os/net/NetworkAddress.h

36

BNetworkAddress(in_addr_t address,

headers/os/net/NetworkAddress.h

38

BNetworkAddress(const in6_addr& address,

headers/os/net/NetworkAddress.h

47

status_t SetTo(const char* address, uint16 port = 0,

headers/os/net/NetworkAddress.h

49

status_t SetTo(const char* address, const char* service,

headers/os/net/NetworkAddress.h

51

status_t SetTo(int family, const char* address,

headers/os/net/NetworkAddress.h

53

status_t SetTo(int family, const char* address,

headers/os/net/NetworkAddress.h

55

void SetTo(const sockaddr& address);

headers/os/net/NetworkAddress.h

56

void SetTo(const sockaddr& address, size_t length);

headers/os/net/NetworkAddress.h

57

void SetTo(const sockaddr_storage& address);

headers/os/net/NetworkAddress.h

58

void SetTo(const sockaddr_in& address);

headers/os/net/NetworkAddress.h

59

void SetTo(const sockaddr_in6& address);

headers/os/net/NetworkAddress.h

60

void SetTo(const sockaddr_dl& address);

headers/os/net/NetworkAddress.h

61

void SetTo(in_addr_t address, uint16 port = 0);

headers/os/net/NetworkAddress.h

62

void SetTo(const in6_addr& address, uint16 port = 0);

headers/os/net/NetworkAddress.h

73

status_t SetAddress(in_addr_t address);

headers/os/net/NetworkAddress.h

74

status_t SetAddress(const in6_addr& address);

headers/os/net/NetworkAddress.h

78

void SetToLinkLevel(const uint8* address, size_t length);

headers/os/net/NetworkAddressResolver.h

30

BNetworkAddressResolver(const char* address,

headers/os/net/NetworkAddressResolver.h

32

BNetworkAddressResolver(const char* address,

headers/os/net/NetworkAddressResolver.h

35

const char* address, uint16 port = 0,

headers/os/net/NetworkAddressResolver.h

38

const char* address, const char* service,

headers/os/net/NetworkAddressResolver.h

46

status_t SetTo(const char* address, uint16 port = 0,

headers/os/net/NetworkAddressResolver.h

48

status_t SetTo(const char* address, const char* service,

headers/os/net/NetworkAddressResolver.h

50

status_t SetTo(int family, const char* address,

headers/os/net/NetworkAddressResolver.h

52

status_t SetTo(int family, const char* address,

headers/os/net/NetworkAddressResolver.h

56

BNetworkAddress& address) const;

headers/os/net/NetworkAddressResolver.h

58

BNetworkAddress& address) const;

headers/os/net/NetworkAddressResolver.h

64

const char* address, const char* service,

headers/os/net/NetworkAddressResolver.h

67

const char* address, uint16 port = 0,

headers/os/net/NetworkAddressResolver.h

70

const char* address, const char* service,

headers/os/net/NetworkAddressResolver.h

73

const char* address, uint16 port = 0,

headers/os/net/NetworkAddressResolver.h

82

CacheEntry(int family, const char* address, const char* service,

headers/os/net/NetworkAddressResolver.h

86

fAddress(address),

headers/os/net/NetworkAddressResolver.h

93

bool Matches(int family, BString address, BString service, uint32 flags)

headers/os/net/NetworkAddressResolver.h

95

return family == fFamily && flags == fFlags && address == fAddress

headers/os/net/NetworkDevice.h

105

status_t GetHardwareAddress(BNetworkAddress& address);

headers/os/net/NetworkDevice.h

119

status_t GetNetwork(const BNetworkAddress& address,

headers/os/net/NetworkDevice.h

126

status_t JoinNetwork(const BNetworkAddress& address,

headers/os/net/NetworkDevice.h

131

status_t LeaveNetwork(const BNetworkAddress& address);

headers/os/net/NetworkDevice.h

136

BNetworkAddress& address);

headers/os/net/NetworkDevice.h

59

BNetworkAddress address;

headers/os/net/NetworkInterface.h

102

status_t GetHardwareAddress(BNetworkAddress& address);

headers/os/net/NetworkInterface.h

28

void SetAddress(const BNetworkAddress& address);

headers/os/net/NetworkInterface.h

88

BNetworkInterfaceAddress& address);

headers/os/net/NetworkInterface.h

89

int32 FindAddress(const BNetworkAddress& address);

headers/os/net/NetworkInterface.h

93

const BNetworkInterfaceAddress& address);

headers/os/net/NetworkInterface.h

94

status_t AddAddress(const BNetworkAddress& address);

headers/os/net/NetworkInterface.h

96

const BNetworkInterfaceAddress& address);

headers/os/net/NetworkInterface.h

98

const BNetworkInterfaceAddress& address);

headers/os/net/NetworkInterface.h

99

status_t RemoveAddress(const BNetworkAddress& address);

headers/os/net/NetworkRoute.h

70

void _FreeAndUnsetAddress(sockaddr*& address);

headers/posix/arpa/inet.h

20

int inet_aton(const char* addressString, struct in_addr* address);

headers/posix/arpa/inet.h

21

in_addr_t inet_lnaof(struct in_addr address);

headers/posix/arpa/inet.h

28

in_addr_t inet_netof(struct in_addr address);

headers/posix/arpa/inet.h

30

char* inet_ntoa(struct in_addr address);

headers/posix/malloc_debug.h

30

status_t heap_debug_get_allocation_info(void *address, size_t *size,

headers/posix/netdb.h

146

struct hostent* gethostbyaddr(const void *address, socklen_t length, int type);

headers/posix/sys/mman.h

55

void* mmap(void* address, size_t length, int protection, int flags,

headers/posix/sys/mman.h

57

int munmap(void* address, size_t length);

headers/posix/sys/mman.h

59

int mprotect(void* address, size_t length, int protection);

headers/posix/sys/mman.h

60

int msync(void* address, size_t length, int flags);

headers/posix/sys/mman.h

62

int madvise(void* address, size_t length, int advice);

headers/posix/sys/mman.h

63

int posix_madvise(void* address, size_t length, int advice);

headers/posix/sys/mman.h

65

int mlock(const void* address, size_t length);

headers/posix/sys/mman.h

66

int munlock(const void* address, size_t length);

headers/posix/sys/socket.h

171

int accept(int socket, struct sockaddr *address, socklen_t *_addressLength);

headers/posix/sys/socket.h

172

int accept4(int socket, struct sockaddr *address, socklen_t *_addressLength, int flags);

headers/posix/sys/socket.h

173

int bind(int socket, const struct sockaddr *address,

headers/posix/sys/socket.h

175

int connect(int socket, const struct sockaddr *address,

headers/posix/sys/socket.h

177

int getpeername(int socket, struct sockaddr *address,

headers/posix/sys/socket.h

179

int getsockname(int socket, struct sockaddr *address,

headers/posix/sys/socket.h

186

struct sockaddr *address, socklen_t *_addressLength);

headers/posix/sys/socket.h

191

const struct sockaddr *address, socklen_t addressLength);

headers/private/bluetooth/ConnectionIncoming.h

33

ConnectionIncoming(bdaddr_t address);

headers/private/bluetooth/ConnectionView.h

28

BString device, BString address);

headers/private/bluetooth/PincodeWindow.h

33

PincodeWindow(bdaddr_t address, hci_id hid);

headers/private/bluetooth/PincodeWindow.h

37

void SetBDaddr(BString address);

headers/private/debug/DebugContext.h

31

ssize_t ReadMemoryPartial(const void* address,

headers/private/debug/DebugContext.h

33

ssize_t ReadMemory(const void* address,

headers/private/debug/DebugContext.h

35

ssize_t ReadString(const void* address,

headers/private/debug/DebugContext.h

38

status_t SetBreakpoint(void* address);

headers/private/debug/DebugContext.h

39

status_t ClearBreakpoint(void* address);

headers/private/debug/DebugContext.h

41

status_t SetWatchpoint(void* address, uint32 type,

headers/private/debug/DebugContext.h

43

status_t ClearWatchpoint(void* address);

headers/private/debug/debug_support.h

31

ssize_t debug_read_memory_partial(debug_context *context, const void *address,

headers/private/debug/debug_support.h

33

ssize_t debug_read_memory(debug_context *context, const void *address,

headers/private/debug/debug_support.h

37

ssize_t debug_write_memory_partial(debug_context *context, const void *address,

headers/private/debug/debug_support.h

39

ssize_t debug_write_memory(debug_context *context, const void *address,

headers/private/debug/debug_support.h

77

const void *address, void **baseAddress, char *symbolName,

headers/private/debugger/arch/Architecture.h

100

virtual status_t ReadValueFromMemory(target_addr_t address,

headers/private/debugger/arch/Architecture.h

104

target_addr_t address, uint32 valueType,

headers/private/debugger/arch/Architecture.h

111

target_addr_t address,

headers/private/debugger/arch/Architecture.h

113

virtual status_t GetInstructionInfo(target_addr_t address,

headers/private/debugger/arch/CpuState.h

31

target_addr_t address) = 0;

headers/private/debugger/controllers/TeamDebugger.h

104

virtual void ClearBreakpointRequested(target_addr_t address);

headers/private/debugger/controllers/TeamDebugger.h

122

virtual void SetWatchpointRequested(target_addr_t address,

headers/private/debugger/controllers/TeamDebugger.h

126

virtual void ClearWatchpointRequested(target_addr_t address);

headers/private/debugger/controllers/TeamDebugger.h

130

virtual void InspectRequested(target_addr_t address,

headers/private/debugger/controllers/TeamDebugger.h

132

virtual void MemoryWriteRequested(target_addr_t address,

headers/private/debugger/controllers/TeamDebugger.h

205

void _HandleSetUserBreakpoint(target_addr_t address,

headers/private/debugger/controllers/TeamDebugger.h

210

target_addr_t address);

headers/private/debugger/controllers/TeamDebugger.h

214

void _HandleSetWatchpoint(target_addr_t address,

headers/private/debugger/controllers/TeamDebugger.h

218

void _HandleClearWatchpoint( target_addr_t address);

headers/private/debugger/controllers/TeamDebugger.h

222

target_addr_t address,

headers/private/debugger/controllers/TeamDebugger.h

225

target_addr_t address, void* data,

headers/private/debugger/controllers/TeamDebugger.h

92

uint32 action, target_addr_t address);

headers/private/debugger/controllers/TeamDebugger.h

94

virtual void SetBreakpointRequested(target_addr_t address,

headers/private/debugger/controllers/ThreadHandler.h

105

target_addr_t address);

headers/private/debugger/controllers/ThreadHandler.h

50

status_t SetBreakpointAndRun(target_addr_t address);

headers/private/debugger/controllers/ThreadHandler.h

72

target_addr_t address);

headers/private/debugger/controllers/ThreadHandler.h

92

target_addr_t address);

headers/private/debugger/debug_info/ImageDebugInfo.h

53

AddressSectionType GetAddressSectionType(target_addr_t address)

headers/private/debugger/debug_info/ImageDebugInfo.h

58

FunctionInstance* FunctionAtAddress(target_addr_t address) const;

headers/private/debugger/debug_info/ImageDebugInfo.h

75

const target_addr_t* address,

headers/private/debugger/debug_info/SpecificImageDebugInfo.h

59

virtual AddressSectionType GetAddressSectionType(target_addr_t address)

headers/private/debugger/debug_info/SpecificImageDebugInfo.h

76

target_addr_t address,

headers/private/debugger/debug_info/SpecificImageDebugInfo.h

88

virtual ssize_t ReadCode(target_addr_t address, void* buffer,

headers/private/debugger/model/AreaInfo.h

19

const BString& name, target_addr_t address,

headers/private/debugger/model/AreaInfo.h

24

const BString& name, target_addr_t address,

headers/private/debugger/model/Breakpoint.h

22

Breakpoint(Image* image, target_addr_t address);

headers/private/debugger/model/Breakpoint.h

53

const target_addr_t* address,

headers/private/debugger/model/DisassembledCode.h

35

Statement* StatementAtAddress(target_addr_t address) const;

headers/private/debugger/model/DisassembledCode.h

48

target_addr_t address, target_size_t size);

headers/private/debugger/model/DisassembledCode.h

62

const target_addr_t* address,

headers/private/debugger/model/Image.h

44

bool ContainsAddress(target_addr_t address) const;

headers/private/debugger/model/ReturnValueInfo.h

20

ReturnValueInfo(target_addr_t address,

headers/private/debugger/model/ReturnValueInfo.h

24

void SetTo(target_addr_t address, CpuState* state);

headers/private/debugger/model/StackFrame.h

63

void SetReturnAddress(target_addr_t address);

headers/private/debugger/model/Statement.h

26

virtual bool ContainsAddress(target_addr_t address)

headers/private/debugger/model/Statement.h

55

virtual bool ContainsAddress(target_addr_t address) const;

headers/private/debugger/model/SymbolInfo.h

16

SymbolInfo(target_addr_t address,

headers/private/debugger/model/SymbolInfo.h

21

void SetTo(target_addr_t address, target_size_t size,

headers/private/debugger/model/Team.h

143

Image* ImageByAddress(target_addr_t address) const;

headers/private/debugger/model/Team.h

179

target_addr_t address) const;

headers/private/debugger/model/Team.h

203

target_addr_t address) const;

headers/private/debugger/model/Team.h

211

status_t GetStatementAtAddress(target_addr_t address,

headers/private/debugger/model/Team.h

275

void NotifyMemoryChanged(target_addr_t address,

headers/private/debugger/model/Team.h

461

target_addr_t address, target_size_t size);

headers/private/debugger/model/TeamMemory.h

26

virtual ssize_t ReadMemory(target_addr_t address, void* buffer,

headers/private/debugger/model/TeamMemory.h

28

virtual status_t ReadMemoryString(target_addr_t address,

headers/private/debugger/model/TeamMemory.h

30

virtual ssize_t WriteMemory(target_addr_t address,

headers/private/debugger/model/TeamMemoryBlock.h

42

bool Contains(target_addr_t address) const;

headers/private/debugger/model/UserBreakpoint.h

59

target_addr_t address);

headers/private/debugger/model/Watchpoint.h

17

Watchpoint(target_addr_t address, uint32 type,

headers/private/debugger/model/Watchpoint.h

35

bool Contains(target_addr_t address) const;

headers/private/debugger/model/Watchpoint.h

40

const target_addr_t* address,

headers/private/debugger/types/TargetAddressRange.h

54

bool Contains(target_addr_t address) const

headers/private/debugger/types/TargetAddressRange.h

56

return address >= Start() && address < End();

headers/private/debugger/types/TargetAddressRangeList.h

34

bool Contains(target_addr_t address) const;

headers/private/debugger/types/ValueLocation.h

100

void SetToMemory(target_addr_t address)

headers/private/debugger/types/ValueLocation.h

103

this->address = address;

headers/private/debugger/types/ValueLocation.h

30

target_addr_t address; // memory address

headers/private/debugger/user_interface/UserInterface.h

124

target_addr_t address = 0) = 0;

headers/private/debugger/user_interface/UserInterface.h

126

virtual void SetBreakpointRequested(target_addr_t address,

headers/private/debugger/user_interface/UserInterface.h

137

target_addr_t address) = 0;

headers/private/debugger/user_interface/UserInterface.h

156

virtual void SetWatchpointRequested(target_addr_t address,

headers/private/debugger/user_interface/UserInterface.h

163

target_addr_t address) = 0;

headers/private/debugger/user_interface/UserInterface.h

168

target_addr_t address,

headers/private/debugger/user_interface/UserInterface.h

171

target_addr_t address,

headers/private/debugger/user_interface/util/UiUtils.h

66

target_addr_t address, int32 itemSize,

headers/private/drivers/ata_adapter.h

29

uint32 address; // physical address of block (must be even)

headers/private/drivers/poke.h

67

void* address;

headers/private/graphics/common/dp.h

37

uint32 address;

headers/private/graphics/radeon/radeon_interface.h

630

uint address; // address

headers/private/graphics/radeon/radeon_interface.h

639

uint address; // address

headers/private/graphics/radeon/radeon_interface.h

648

uint address; // address

headers/private/graphics/radeon/radeon_interface.h

658

uint address; // address

headers/private/kernel/acpi.h

250

uint64 address;

headers/private/kernel/acpi.h

261

uint64 address;

headers/private/kernel/acpi.h

343

uint32 address;

headers/private/kernel/acpi.h

407

acpi_address16_attribute address;

headers/private/kernel/acpi.h

418

acpi_address32_attribute address;

headers/private/kernel/acpi.h

429

acpi_address64_attribute address;

headers/private/kernel/acpi.h

451

acpi_resource_address address;

headers/private/kernel/arch/cpu.h

37

void arch_cpu_sync_icache(void *address, size_t length);

headers/private/kernel/arch/generic/msi.h

16

uint32 count, uint32& startVector, uint64& address, uint32& data) = 0;

headers/private/kernel/arch/generic/msi.h

27

uint64 *address, uint32 *data);

headers/private/kernel/arch/m68k/arch_cpu.h

448

extern bool m68k_is_hw_register_readable(addr_t address);

headers/private/kernel/arch/m68k/arch_cpu.h

449

extern bool m68k_is_hw_register_writable(addr_t address, uint16 value);

headers/private/kernel/arch/m68k/arch_cpu.h

481

void (*flush_dcache)(addr_t address, size_t len);

headers/private/kernel/arch/m68k/arch_cpu.h

482

void (*flush_icache)(addr_t address, size_t len);

headers/private/kernel/arch/m68k/arch_mmu.h

117

uint32 address : 24;

headers/private/kernel/arch/m68k/arch_mmu.h

70

uint32 address : 28;

headers/private/kernel/arch/m68k/arch_mmu.h

86

uint32 address : 28;

headers/private/kernel/arch/m68k/arch_mmu.h

97

uint32 address : 24;

headers/private/kernel/arch/m68k/stage2_priv.h

12

void s2_change_framebuffer_addr(unsigned int address);

headers/private/kernel/arch/m68k/stage2_priv.h

29

void syncicache(void *address, int len);

headers/private/kernel/arch/ppc/arch_mmu.h

58

void SetVirtualAddress(void *address)

headers/private/kernel/arch/ppc/arch_mmu.h

60

page_index = uint32(address) >> 17;

headers/private/kernel/arch/ppc/arch_mmu.h

63

void SetPhysicalAddress(void *address)

headers/private/kernel/arch/ppc/arch_mmu.h

65

physical_block_number = uint32(address) >> 17;

headers/private/kernel/arch/ppc/arch_mmu_amcc440.h

65

void SetVirtualAddress(void *address)

headers/private/kernel/arch/ppc/arch_mmu_amcc440.h

67

page_index = uint32(address) >> 17;

headers/private/kernel/arch/ppc/arch_mmu_amcc440.h

70

void SetPhysicalAddress(void *address)

headers/private/kernel/arch/ppc/arch_mmu_amcc440.h

72

physical_block_number = uint32(address) >> 17;

headers/private/kernel/arch/ppc/stage2_priv.h

12

void s2_change_framebuffer_addr(unsigned int address);

headers/private/kernel/arch/ppc/stage2_priv.h

29

void syncicache(void *address, int len);

headers/private/kernel/arch/user_debugger.h

40

status_t arch_set_breakpoint(void *address);

headers/private/kernel/arch/user_debugger.h

41

status_t arch_clear_breakpoint(void *address);

headers/private/kernel/arch/user_debugger.h

42

status_t arch_set_watchpoint(void *address, uint32 type, int32 length);

headers/private/kernel/arch/user_debugger.h

43

status_t arch_clear_watchpoint(void *address);

headers/private/kernel/arch/user_debugger.h

47

status_t arch_set_kernel_breakpoint(void *address);

headers/private/kernel/arch/user_debugger.h

48

status_t arch_clear_kernel_breakpoint(void *address);

headers/private/kernel/arch/user_debugger.h

49

status_t arch_set_kernel_watchpoint(void *address, uint32 type, int32 length);

headers/private/kernel/arch/user_debugger.h

50

status_t arch_clear_kernel_watchpoint(void *address);

headers/private/kernel/arch/x86/arch_hpet.h

103

uint64 address;

headers/private/kernel/arch/x86/arch_user_debugger.h

96

void *address; // NULL, if deactivated

headers/private/kernel/boot/net/IP.h

62

ip_addr_t ip_parse_address(const char* address);

headers/private/kernel/boot/net/NetDefs.h

39

mac_addr_t(uint8 *address)

headers/private/kernel/boot/net/NetDefs.h

41

memcpy(this->address, address, ETH_ALEN);

headers/private/kernel/boot/net/NetDefs.h

46

memcpy(address, other.address, sizeof(address));

headers/private/kernel/boot/net/NetDefs.h

51

return ((uint64)address[0] << 40)

headers/private/kernel/boot/net/NetDefs.h

52

| ((uint64)address[1] << 32)

headers/private/kernel/boot/net/NetDefs.h

53

| ((uint64)address[2] << 24)

headers/private/kernel/boot/net/NetDefs.h

54

| ((uint64)address[3] << 16)

headers/private/kernel/boot/net/NetDefs.h

55

| ((uint64)address[4] << 8)

headers/private/kernel/boot/net/NetDefs.h

56

| (uint64)address[5];

headers/private/kernel/boot/net/NetDefs.h

61

return address[index];

headers/private/kernel/boot/net/NetDefs.h

66

memcpy(address, other.address, sizeof(address));

headers/private/kernel/boot/net/NetDefs.h

72

return memcmp(address, other.address, sizeof(address)) == 0;

headers/private/kernel/boot/net/NetDefs.h

80

uint8 address[ETH_ALEN];

headers/private/kernel/boot/net/TCP.h

132

TCPSocket* _FindSocket(ip_addr_t address, uint16 port);

headers/private/kernel/boot/net/TCP.h

70

status_t Connect(ip_addr_t address, uint16 port);

headers/private/kernel/boot/net/UDP.h

102

UDPSocket *_FindSocket(ip_addr_t address, uint16 port);

headers/private/kernel/boot/net/UDP.h

54

status_t Bind(ip_addr_t address, uint16 port);

headers/private/kernel/boot/net/UDP.h

93

status_t BindSocket(UDPSocket *socket, ip_addr_t address, uint16 port);

headers/private/kernel/boot/net/iSCSITarget.h

35

status_t Open(ip_addr_t address, uint16 port);

headers/private/kernel/boot/net/iSCSITarget.h

61

status_t Init(ip_addr_t address, uint16 port, char** targetAlias = NULL);

headers/private/kernel/boot/net/iSCSITarget.h

82

status_t Init(ip_addr_t address, uint16 port, const char* targetName);

headers/private/kernel/boot/net/iSCSITarget.h

92

static bool DiscoverTargets(ip_addr_t address, uint16 port,

headers/private/kernel/boot/net/iSCSITarget.h

94

static bool _AddDevice(ip_addr_t address, uint16 port,

headers/private/kernel/boot/platform.h

30

extern status_t platform_free_region(void *address, size_t size);

headers/private/kernel/boot/platform.h

31

extern status_t platform_bootloader_address_to_kernel_address(void *address, addr_t *_result);

headers/private/kernel/boot/platform.h

32

extern status_t platform_kernel_address_to_bootloader_address(addr_t address, void **_result);

headers/private/kernel/boot/platform/openfirmware/platform_arch.h

20

extern void *arch_mmu_allocate(void *address, size_t size, uint8 protection,

headers/private/kernel/boot/platform/openfirmware/platform_arch.h

22

extern status_t arch_mmu_free(void *address, size_t size);

headers/private/kernel/boot/platform/routerboard_mipsel/platform_arch.h

21

extern void *arch_mmu_allocate(void *address, size_t size, uint8 protection,

headers/private/kernel/boot/platform/routerboard_mipsel/platform_arch.h

23

extern status_t arch_mmu_free(void *address, size_t size);

headers/private/kernel/boot/platform/u-boot/platform_arch.h

20

extern void *arch_mmu_allocate(void *address, size_t size, uint8 protection,

headers/private/kernel/boot/platform/u-boot/platform_arch.h

22

extern status_t arch_mmu_free(void *address, size_t size);

headers/private/kernel/boot/stage2.h

30

extern void kernel_args_free(void *address);

headers/private/kernel/commpage.h

23

area_id clone_commpage_area(team_id team, void** address);

headers/private/kernel/commpage_compat.h

27

area_id clone_commpage_compat_area(team_id team, void** address);

headers/private/kernel/cpu.h

130

void _user_clear_caches(void *address, size_t length, uint32 flags);

headers/private/kernel/debug.h

183

extern bool debug_is_kernel_memory_accessible(addr_t address, size_t size,

headers/private/kernel/debug_heap.h

23

void debug_free(void* address);

headers/private/kernel/debug_paranoia.h

42

status_t set_paranoia_check(const void* object, const void* address,

headers/private/kernel/debug_paranoia.h

44

status_t remove_paranoia_check(const void* object, const void* address,

headers/private/kernel/debug_paranoia.h

72

#define ADD_PARANOIA_CHECK(level, object, address, size) \

headers/private/kernel/debug_paranoia.h

74

set_paranoia_check((object), (address), (size), \

headers/private/kernel/debug_paranoia.h

76

#define UPDATE_PARANOIA_CHECK(level, object, address, size) \

headers/private/kernel/debug_paranoia.h

78

set_paranoia_check((object), (address), (size), \

headers/private/kernel/debug_paranoia.h

80

#define SET_PARANOIA_CHECK(level, object, address, size) \

headers/private/kernel/debug_paranoia.h

82

set_paranoia_check((object), (address), (size), \

headers/private/kernel/debug_paranoia.h

84

#define REMOVE_PARANOIA_CHECK(level, object, address, size) \

headers/private/kernel/debug_paranoia.h

86

remove_paranoia_check((object), (address), (size)))

headers/private/kernel/elf.h

21

addr_t address;

headers/private/kernel/elf.h

42

status_t elf_debug_lookup_symbol_address(addr_t address, addr_t *_baseAddress,

headers/private/kernel/elf.h

45

status_t elf_debug_lookup_user_symbol_address(Team* team, addr_t address,

headers/private/kernel/elf.h

51

status_t elf_get_image_info_for_address(addr_t address, image_info* info);

headers/private/kernel/elf.h

55

addr_t address, size_t size, int32 type);

headers/private/kernel/heap.h

29

void* realloc_etc(void* address, size_t newSize, uint32 flags);

headers/private/kernel/heap.h

30

void free_etc(void* address, uint32 flags);

headers/private/kernel/kernel.h

50

addr_t address = (addr_t)addr;

headers/private/kernel/kernel.h

53

if ((address + size) < address)

headers/private/kernel/kernel.h

57

return IS_USER_ADDRESS(address) && IS_USER_ADDRESS(address + size - 1);

headers/private/kernel/ksignal.h

122

void SetAddress(void* address)

headers/private/kernel/ksignal.h

123

{ fAddress = address; }

headers/private/kernel/ksignal.h

210

void signal_get_user_stack(addr_t address, stack_t* stack);

headers/private/kernel/user_debugger.h

292

status_t _user_set_debugger_breakpoint(void *address, uint32 type,

headers/private/kernel/user_debugger.h

294

status_t _user_clear_debugger_breakpoint(void *address, bool watchpoint);

headers/private/kernel/util/KMessage.h

223

bool alignSize, void** address,

headers/private/kernel/vfs.h

262

status_t _user_bind(int socket, const struct sockaddr *address,

headers/private/kernel/vfs.h

265

status_t _user_connect(int socket, const struct sockaddr *address,

headers/private/kernel/vfs.h

268

int _user_accept(int socket, struct sockaddr *address,

headers/private/kernel/vfs.h

272

struct sockaddr *address, socklen_t *_addressLength);

headers/private/kernel/vfs.h

276

const struct sockaddr *address, socklen_t addressLength);

headers/private/kernel/vfs.h

282

status_t _user_getpeername(int socket, struct sockaddr *address,

headers/private/kernel/vfs.h

284

status_t _user_getsockname(int socket, struct sockaddr *address,

headers/private/kernel/vm/VMAddressSpace.h

110

virtual status_t UnreserveAddressRange(addr_t address,

headers/private/kernel/vm/VMAddressSpace.h

214

AreaRangeIterator(VMAddressSpace* addressSpace, addr_t address, addr_t size)

headers/private/kernel/vm/VMAddressSpace.h

218

fAddress(address),

headers/private/kernel/vm/VMAddressSpace.h

219

fEndAddress(address + size - 1)

headers/private/kernel/vm/VMAddressSpace.h

264

VMAddressSpace::GetAreaRangeIterator(addr_t address, addr_t size)

headers/private/kernel/vm/VMAddressSpace.h

266

return AreaRangeIterator(this, address, size);

headers/private/kernel/vm/VMAddressSpace.h

71

inline AreaRangeIterator GetAreaRangeIterator(addr_t address,

headers/private/kernel/vm/VMAddressSpace.h

81

virtual VMArea* LookupArea(addr_t address) const = 0;

headers/private/kernel/vm/VMAddressSpace.h

82

virtual VMArea* FindClosestArea(addr_t address, bool less) const

headers/private/kernel/vm/VMArea.h

136

bool ContainsAddress(addr_t address) const

headers/private/kernel/vm/VMArea.h

137

{ return address >= fBase

headers/private/kernel/vm/VMArea.h

138

&& address <= fBase + (fSize - 1); }

headers/private/kernel/vm/VMTranslationMap.h

139

virtual status_t MemsetPhysical(phys_addr_t address, int value,

headers/private/kernel/vm/VMTranslationMap.h

153

VMTranslationMap::ProtectPage(VMArea* area, addr_t address, uint32 attributes)

headers/private/kernel/vm/VMTranslationMap.h

155

return Protect(address, address + B_PAGE_SIZE - 1, attributes,

headers/private/kernel/vm/VMTranslationMap.h

44

virtual status_t UnmapPage(VMArea* area, addr_t address,

headers/private/kernel/vm/VMTranslationMap.h

64

status_t ProtectPage(VMArea* area, addr_t address,

headers/private/kernel/vm/VMTranslationMap.h

73

VMArea* area, addr_t address,

headers/private/kernel/vm/vm.h

102

area_id vm_map_file(team_id aid, const char *name, void **address,

headers/private/kernel/vm/vm.h

107

area_id vm_create_null_area(team_id team, const char *name, void **address,

headers/private/kernel/vm/vm.h

111

area_id vm_clone_area(team_id team, const char *name, void **address,

headers/private/kernel/vm/vm.h

127

status_t vm_wire_page(team_id team, addr_t address, bool writable,

headers/private/kernel/vm/vm.h

148

status_t vm_memset_physical(phys_addr_t address, int value, phys_size_t length);

headers/private/kernel/vm/vm.h

159

area_id _user_create_area(const char *name, void **address, uint32 addressSpec,

headers/private/kernel/vm/vm.h

166

status_t _user_unmap_memory(void *address, size_t size);

headers/private/kernel/vm/vm.h

167

status_t _user_set_memory_protection(void* address, size_t size,

headers/private/kernel/vm/vm.h

169

status_t _user_sync_memory(void *address, size_t size, uint32 flags);

headers/private/kernel/vm/vm.h

170

status_t _user_memory_advice(void* address, size_t size, uint32 advice);

headers/private/kernel/vm/vm.h

171

status_t _user_get_memory_properties(team_id teamID, const void *address,

headers/private/kernel/vm/vm.h

174

status_t _user_mlock(const void* address, size_t size);

headers/private/kernel/vm/vm.h

175

status_t _user_munlock(const void* address, size_t size);

headers/private/kernel/vm/vm.h

177

area_id _user_area_for(void *address);

headers/private/kernel/vm/vm.h

189

status_t _user_unreserve_address_range(addr_t address, addr_t size);

headers/private/kernel/vm/vm.h

87

status_t vm_block_address_range(const char* name, void* address, addr_t size);

headers/private/kernel/vm/vm.h

88

status_t vm_unreserve_address_range(team_id team, void *address, addr_t size);

headers/private/kernel/vm/vm.h

96

area_id vm_map_physical_memory(team_id team, const char *name, void **address,

headers/private/kernel/vm/vm_priv.h

30

status_t vm_page_fault(addr_t address, addr_t faultAddress, bool isWrite,

headers/private/kernel/vm/vm_types.h

42

void* address;

headers/private/libroot/memory_private.h

15

status_t get_memory_properties(team_id teamID, const void* address,

headers/private/libroot/user_group.h

101

return address = (Type*)(baseAddress + (addr_t)address);

headers/private/libroot/user_group.h

99

relocate_pointer(addr_t baseAddress, Type*& address)

headers/private/mail/mail_util.h

95

void extract_address(BString &address);

headers/private/mail/mail_util.h

98

void extract_address_name(BString &address);

headers/private/media/ServerInterface.h

220

void* address;

headers/private/net/AddressUtilities.h

145

const sockaddr* address)

headers/private/net/AddressUtilities.h

148

fAddress(address)

headers/private/net/AddressUtilities.h

153

const sockaddr_storage* address)

headers/private/net/AddressUtilities.h

156

fAddress((sockaddr*)address)

headers/private/net/AddressUtilities.h

160

ConstSocketAddress(const ConstSocketAddress& address)

headers/private/net/AddressUtilities.h

162

fModule(address.fModule),

headers/private/net/AddressUtilities.h

163

fAddress(address.fAddress)

headers/private/net/AddressUtilities.h

167

ConstSocketAddress(const SocketAddress& address)

headers/private/net/AddressUtilities.h

169

fModule(address.Module()),

headers/private/net/AddressUtilities.h

170

fAddress(*address)

headers/private/net/AddressUtilities.h

174

void SetAddressTo(const sockaddr* address)

headers/private/net/AddressUtilities.h

176

fAddress = address;

headers/private/net/AddressUtilities.h

189

bool EqualTo(const sockaddr* address, bool checkPort = false) const

headers/private/net/AddressUtilities.h

192

return fModule->equal_addresses_and_ports(fAddress, address);

headers/private/net/AddressUtilities.h

194

return fModule->equal_addresses(fAddress, address);

headers/private/net/AddressUtilities.h

20

SocketAddress(net_address_module_info* module, sockaddr* address)

headers/private/net/AddressUtilities.h

202

bool MatchMasked(const sockaddr* address, const sockaddr* mask) const

headers/private/net/AddressUtilities.h

204

return fModule->equal_masked_addresses(fAddress, address, mask);

headers/private/net/AddressUtilities.h

23

fAddress(address)

headers/private/net/AddressUtilities.h

27

SocketAddress(net_address_module_info* module, sockaddr_storage* address)

headers/private/net/AddressUtilities.h

30

fAddress((sockaddr*)address)

headers/private/net/AddressUtilities.h

34

SocketAddress(const SocketAddress& address)

headers/private/net/AddressUtilities.h

36

fModule(address.fModule),

headers/private/net/AddressUtilities.h

37

fAddress(address.fAddress)

headers/private/net/AddressUtilities.h

41

void SetAddressTo(sockaddr* address)

headers/private/net/AddressUtilities.h

43

fAddress = address;

headers/private/net/AddressUtilities.h

56

bool EqualTo(const sockaddr* address, bool checkPort = false) const

headers/private/net/AddressUtilities.h

59

return fModule->equal_addresses_and_ports(fAddress, address);

headers/private/net/AddressUtilities.h

61

return fModule->equal_addresses(fAddress, address);

headers/private/net/AddressUtilities.h

74

bool MatchMasked(const sockaddr* address, const sockaddr* mask) const

headers/private/net/AddressUtilities.h

76

return fModule->equal_masked_addresses(fAddress, address, mask);

headers/private/net/NetUtilities.h

103

AddressString(net_domain* domain, const sockaddr* address,

headers/private/net/NetUtilities.h

108

domain->address_module->print_address(address, &fBuffer, printPort);

headers/private/net/NetUtilities.h

111

AddressString(net_domain* domain, const sockaddr& address,

headers/private/net/NetUtilities.h

116

domain->address_module->print_address(&address, &fBuffer, printPort);

headers/private/net/NetUtilities.h

120

const sockaddr* address, bool printPort = false)

headers/private/net/NetUtilities.h

124

address_module->print_address(address, &fBuffer, printPort);

headers/private/net/ProtocolUtilities.h

57

&fSocket->address); }

headers/private/net/ProtocolUtilities.h

61

&fSocket->address); }

headers/private/net/SocketMessenger.h

18

const BNetworkAddress& address,

headers/private/net/SocketMessenger.h

25

status_t SetTo(const BNetworkAddress& address,

headers/private/net/arp_control.h

33

in_addr_t address;

headers/private/net/net_datalink.h

101

net_domain* domain, const struct sockaddr* address);

headers/private/net/net_datalink.h

107

const struct sockaddr* address);

headers/private/net/net_datalink.h

130

status_t (*mask_address)(const struct sockaddr* address,

headers/private/net/net_datalink.h

141

bool (*is_empty_address)(const struct sockaddr* address,

headers/private/net/net_datalink.h

143

bool (*is_same_family)(const struct sockaddr* address);

headers/private/net/net_datalink.h

147

bool (*check_mask)(const struct sockaddr* address);

headers/private/net/net_datalink.h

149

status_t (*print_address)(const struct sockaddr* address,

headers/private/net/net_datalink.h

151

status_t (*print_address_buffer)(const struct sockaddr* address,

headers/private/net/net_datalink.h

154

uint16 (*get_port)(const struct sockaddr* address);

headers/private/net/net_datalink.h

155

status_t (*set_port)(struct sockaddr* address, uint16 port);

headers/private/net/net_datalink.h

157

status_t (*set_to)(struct sockaddr* address,

headers/private/net/net_datalink.h

159

status_t (*set_to_empty_address)(struct sockaddr* address);

headers/private/net/net_datalink.h

162

const struct sockaddr* address,

headers/private/net/net_datalink.h

165

status_t (*update_to)(struct sockaddr* address,

headers/private/net/net_datalink.h

168

uint32 (*hash_address)(const struct sockaddr* address,

headers/private/net/net_datalink.h

174

const struct sockaddr* address);

headers/private/net/net_datalink.h

66

struct sockaddr address;

headers/private/net/net_datalink.h

80

const struct sockaddr* address,

headers/private/net/net_datalink.h

84

bool unconfigured, const struct sockaddr* address,

headers/private/net/net_datalink.h

89

const struct sockaddr* address);

headers/private/net/net_datalink.h

93

const struct sockaddr* address);

headers/private/net/net_datalink.h

96

void (*put_interface_address)(net_interface_address* address);

headers/private/net/net_datalink.h

99

net_domain* domain, const struct sockaddr* address);

headers/private/net/net_datalink_protocol.h

32

net_interface_address* address, int32 option,

headers/private/net/net_datalink_protocol.h

40

const struct sockaddr* address);

headers/private/net/net_datalink_protocol.h

42

const struct sockaddr* address);

headers/private/net/net_device.h

35

struct net_hardware_address address;

headers/private/net/net_device.h

61

const struct sockaddr* address);

headers/private/net/net_device.h

63

const struct sockaddr* address);

headers/private/net/net_protocol.h

103

size_t (*get_mtu)(net_protocol* self, const struct sockaddr* address);

headers/private/net/net_protocol.h

122

const struct sockaddr* address, socklen_t addressLength,

headers/private/net/net_protocol.h

79

status_t (*connect)(net_protocol* self, const struct sockaddr* address);

headers/private/net/net_protocol.h

88

status_t (*bind)(net_protocol* self, const struct sockaddr* address);

headers/private/net/net_protocol.h

89

status_t (*unbind)(net_protocol* self, struct sockaddr* address);

headers/private/net/net_socket.h

100

int (*getpeername)(net_socket* socket, struct sockaddr* address,

headers/private/net/net_socket.h

102

int (*getsockname)(net_socket* socket, struct sockaddr* address,

headers/private/net/net_socket.h

30

struct sockaddr_storage address;

headers/private/net/net_socket.h

94

int (*accept)(net_socket* socket, struct sockaddr* address,

headers/private/net/net_socket.h

96

int (*bind)(net_socket* socket, const struct sockaddr* address,

headers/private/net/net_socket.h

98

int (*connect)(net_socket* socket, const struct sockaddr* address,

headers/private/net/net_stack_interface.h

31

status_t (*bind)(net_socket* socket, const struct sockaddr* address,

headers/private/net/net_stack_interface.h

34

status_t (*connect)(net_socket* socket, const struct sockaddr* address,

headers/private/net/net_stack_interface.h

37

status_t (*accept)(net_socket* socket, struct sockaddr* address,

headers/private/net/net_stack_interface.h

42

int flags, struct sockaddr* address,

headers/private/net/net_stack_interface.h

49

int flags, const struct sockaddr* address,

headers/private/net/net_stack_interface.h

59

status_t (*getpeername)(net_socket* socket, struct sockaddr* address,

headers/private/net/net_stack_interface.h

61

status_t (*getsockname)(net_socket* socket, struct sockaddr* address,

headers/private/net/net_stat.h

24

struct sockaddr_storage address;

headers/private/runtime_loader/runtime_loader.h

41

status_t (*get_nearest_symbol_at_address)(void* address,

headers/private/shared/BytePointer.h

15

char* address;

headers/private/shared/BytePointer.h

17

BytePointer(void* base) { address = (char*)base; }

headers/private/shared/BytePointer.h

19

T* operator&() { return reinterpret_cast<T*>(address); }

headers/private/shared/BytePointer.h

20

T* operator->() { return reinterpret_cast<T*>(address); }

headers/private/shared/BytePointer.h

21

void operator+=(size_t offset) { address += offset; }

headers/private/shared/BytePointer.h

22

char* operator+(size_t offset) const { return address + offset; }

headers/private/system/syscalls.h

362

extern status_t _kern_bind(int socket, const struct sockaddr *address,

headers/private/system/syscalls.h

365

extern status_t _kern_connect(int socket, const struct sockaddr *address,

headers/private/system/syscalls.h

368

extern int _kern_accept(int socket, struct sockaddr *address,

headers/private/system/syscalls.h

373

int flags, struct sockaddr *address,

headers/private/system/syscalls.h

380

int flags, const struct sockaddr *address,

headers/private/system/syscalls.h

388

extern status_t _kern_getpeername(int socket, struct sockaddr *address,

headers/private/system/syscalls.h

390

extern status_t _kern_getsockname(int socket, struct sockaddr *address,

headers/private/system/syscalls.h

434

extern area_id _kern_create_area(const char *name, void **address,

headers/private/system/syscalls.h

438

extern area_id _kern_area_for(void *address);

headers/private/system/syscalls.h

453

extern status_t _kern_unreserve_address_range(addr_t address, addr_t size);

headers/private/system/syscalls.h

455

extern area_id _kern_map_file(const char *name, void **address,

headers/private/system/syscalls.h

459

extern status_t _kern_unmap_memory(void *address, size_t size);

headers/private/system/syscalls.h

460

extern status_t _kern_set_memory_protection(void *address, size_t size,

headers/private/system/syscalls.h

462

extern status_t _kern_sync_memory(void *address, size_t size, int flags);

headers/private/system/syscalls.h

463

extern status_t _kern_memory_advice(void *address, size_t size,

headers/private/system/syscalls.h

467

const void *address, uint32* _protected, uint32* _lock);

headers/private/system/syscalls.h

469

extern status_t _kern_mlock(const void* address, size_t size);

headers/private/system/syscalls.h

470

extern status_t _kern_munlock(const void* address, size_t size);

headers/private/system/syscalls.h

510

extern status_t _kern_set_debugger_breakpoint(void *address, uint32 type,

headers/private/system/syscalls.h

512

extern status_t _kern_clear_debugger_breakpoint(void *address,

headers/private/system/syscalls.h

569

extern void _kern_clear_caches(void *address, size_t length,

headers/private/userlandfs/private/AreaSupport.h

10

status_t get_area_for_address(void* address, int32 size, area_id* area,

headers/private/userlandfs/private/Request.h

28

void SetRelocatedAddress(void* address)

headers/private/userlandfs/private/Request.h

29

{ fRelocated = address; }

headers/private/userlandfs/private/Request.h

52

Address *address;

headers/private/userlandfs/private/RequestAllocator.h

38

status_t AllocateAddress(Address& address, int32 size,

headers/private/userlandfs/private/RequestAllocator.h

41

status_t AllocateData(Address& address, const void* data,

headers/private/userlandfs/private/RequestAllocator.h

44

status_t AllocateString(Address& address,

headers/tools/elfsymbolpatcher/ElfSymbolPatcher.h

70

void SetOriginalAddress(void* address,

src/add-ons/accelerants/3dfx/3dfx_mode.cpp

368

int address = (mode.v_display_start * mode.virtual_width

src/add-ons/accelerants/3dfx/3dfx_mode.cpp

371

address &= ~0x07;

src/add-ons/accelerants/3dfx/3dfx_mode.cpp

372

address += si.frameBufferOffset;

src/add-ons/accelerants/3dfx/3dfx_mode.cpp

375

OUTREG32(VIDEO_DESKTOP_START_ADDR, address);

src/add-ons/accelerants/ati/mach64_mode.cpp

379

int address = (mode.v_display_start * mode.virtual_width

src/add-ons/accelerants/ati/mach64_mode.cpp

382

address &= ~0x07;

src/add-ons/accelerants/ati/mach64_mode.cpp

383

address += si.frameBufferOffset;

src/add-ons/accelerants/ati/mach64_mode.cpp

385

OUTREGM(CRTC_OFF_PITCH, address, 0xfffff);

src/add-ons/accelerants/ati/rage128_mode.cpp

414

int address = (mode.v_display_start * mode.virtual_width

src/add-ons/accelerants/ati/rage128_mode.cpp

417

address &= ~0x07;

src/add-ons/accelerants/ati/rage128_mode.cpp

418

address += si.frameBufferOffset;

src/add-ons/accelerants/ati/rage128_mode.cpp

420

OUTREG(R128_CRTC_OFFSET, address);

src/add-ons/accelerants/framebuffer/accelerant.cpp

119

gInfo->frame_buffer = info.address;

src/add-ons/accelerants/intel_810/i810_mode.cpp

257

uint32 address = ((mode.v_display_start * mode.virtual_width

src/add-ons/accelerants/intel_810/i810_mode.cpp

260

WriteCrtcReg(START_ADDR_LO, address & 0xff);

src/add-ons/accelerants/intel_810/i810_mode.cpp

261

WriteCrtcReg(START_ADDR_HI, (address >> 8) & 0xff);

src/add-ons/accelerants/intel_810/i810_mode.cpp

262

WriteCrtcReg(EXT_START_ADDR_HI, (address >> 22) & 0xff);

src/add-ons/accelerants/intel_810/i810_mode.cpp

264

((address >> 16) & 0x3f) | EXT_START_ADDR_ENABLE);

src/add-ons/accelerants/intel_extreme/Ports.cpp

46

wait_for_set(addr_t address, uint32 mask, uint32 timeout)

src/add-ons/accelerants/intel_extreme/Ports.cpp

52

if ((read32(address) & mask) != 0)

src/add-ons/accelerants/intel_extreme/Ports.cpp

60

wait_for_clear(addr_t address, uint32 mask, uint32 timeout)

src/add-ons/accelerants/intel_extreme/Ports.cpp

624

message.address = slaveAddress;

src/add-ons/accelerants/intel_extreme/Ports.cpp

66

if ((read32(address) & mask) == 0)

src/add-ons/accelerants/intel_extreme/Ports.cpp

673

message.address = slaveAddress;

src/add-ons/accelerants/intel_extreme/Ports.cpp

74

wait_for_clear_status(addr_t address, uint32 mask, uint32 timeout)

src/add-ons/accelerants/intel_extreme/Ports.cpp

769

transmitBuffer[0] = (message->request << 4) | ((message->address >> 16) & 0xf);

src/add-ons/accelerants/intel_extreme/Ports.cpp

770

transmitBuffer[1] = (message->address >> 8) & 0xff;

src/add-ons/accelerants/intel_extreme/Ports.cpp

771

transmitBuffer[2] = message->address & 0xff;

src/add-ons/accelerants/intel_extreme/Ports.cpp

81

status = read32(address);

src/add-ons/accelerants/matrox/engine/mga_i2c.c

279

int i2c_maven_read(unsigned char address)

src/add-ons/accelerants/matrox/engine/mga_i2c.c

287

error+=i2c_sendbyte(address);

src/add-ons/accelerants/matrox/engine/mga_i2c.c

295

void i2c_maven_write(unsigned char address, unsigned char data)

src/add-ons/accelerants/matrox/engine/mga_i2c.c

302

error+=i2c_sendbyte(address);

src/add-ons/accelerants/matrox/engine/mga_proto.h

24

int i2c_maven_read(unsigned char address);

src/add-ons/accelerants/matrox/engine/mga_proto.h

25

void i2c_maven_write(unsigned char address, unsigned char data);

src/add-ons/accelerants/radeon/driver_wrapper.c

58

status_t Radeon_VIPRead( accelerator_info *ai, uint channel, uint address, uint32 *data )

src/add-ons/accelerants/radeon/driver_wrapper.c

65

vr.address = address;

src/add-ons/accelerants/radeon/driver_wrapper.c

77

status_t Radeon_VIPWrite( accelerator_info *ai, uint8 channel, uint address, uint32 data )

src/add-ons/accelerants/radeon/driver_wrapper.c

83

vw.address = address;

src/add-ons/accelerants/radeon/internal_tv_out.c

110

for( ; mapping->address != 0 && mapping->offset != 0; ++mapping ) {

src/add-ons/accelerants/radeon/internal_tv_out.c

115

mapping->address, *(uint32 *)((char *)(values) + mapping->offset) );

src/add-ons/accelerants/radeon/internal_tv_out.c

235

for( ; mapping->address != 0 && mapping->offset != 0; ++mapping ) {

src/add-ons/accelerants/radeon/internal_tv_out.c

237

INREG( regs, mapping->address );

src/add-ons/accelerants/radeon/internal_tv_out.c

24

uint16 address; // register address

src/add-ons/accelerants/radeon/internal_tv_out.c

251

for( ; mapping->address != 0 && mapping->offset != 0; ++mapping ) {

src/add-ons/accelerants/radeon/internal_tv_out.c

253

Radeon_INPLL( ai->regs, ai->si->asic, mapping->address );

src/add-ons/accelerants/radeon/internal_tv_out.c

95

for( ; mapping->address != 0 && mapping->offset != 0; ++mapping ) {

src/add-ons/accelerants/radeon/internal_tv_out.c

99

OUTREG( regs, mapping->address, *(uint32 *)((char *)(values) + mapping->offset) );

src/add-ons/accelerants/radeon/radeon_accelerant.h

121

status_t Radeon_VIPRead( accelerator_info *ai, uint channel, uint address, uint32 *data );

src/add-ons/accelerants/radeon/radeon_accelerant.h

122

status_t Radeon_VIPWrite( accelerator_info *ai, uint8 channel, uint address, uint32 data );

src/add-ons/accelerants/radeon/theatre_out.c

109

for( ; mapping->address != 0 || mapping->offset != 0; ++mapping ) {

src/add-ons/accelerants/radeon/theatre_out.c

110

Radeon_VIPWrite( ai, ai->si->theatre_channel, mapping->address,

src/add-ons/accelerants/radeon/theatre_out.c

223

for( ; mapping->address != 0 || mapping->offset != 0; ++mapping ) {

src/add-ons/accelerants/radeon/theatre_out.c

224

Radeon_VIPRead( ai, ai->si->theatre_channel, mapping->address,

src/add-ons/accelerants/radeon/theatre_out.c

23

uint16 address; // register address

src/add-ons/accelerants/radeon_hd/connector.cpp

721

uint8* address = (uint8*)pathObject->asDispPath;

src/add-ons/accelerants/radeon_hd/connector.cpp

723

address += pathSize;

src/add-ons/accelerants/radeon_hd/connector.cpp

724

path = (ATOM_DISPLAY_OBJECT_PATH*)address;

src/add-ons/accelerants/radeon_hd/displayport.cpp

131

auxMessage[0] = message->address & 0xff;

src/add-ons/accelerants/radeon_hd/displayport.cpp

132

auxMessage[1] = (message->address >> 8) & 0xff;

src/add-ons/accelerants/radeon_hd/displayport.cpp

133

auxMessage[2] = (message->request << 4) | ((message->address >> 16) & 0xf);

src/add-ons/accelerants/radeon_hd/displayport.cpp

191

dpcd_reg_write(uint32 connectorIndex, uint32 address, uint8 value)

src/add-ons/accelerants/radeon_hd/displayport.cpp

198

message.address = address;

src/add-ons/accelerants/radeon_hd/displayport.cpp

212

dpcd_reg_read(uint32 connectorIndex, uint32 address)

src/add-ons/accelerants/radeon_hd/displayport.cpp

221

message.address = address;

src/add-ons/accelerants/radeon_hd/displayport.cpp

237

dp_aux_get_i2c_byte(uint32 connectorIndex, uint32 address, uint8* data,

src/add-ons/accelerants/radeon_hd/displayport.cpp

244

message.address = address;

src/add-ons/accelerants/radeon_hd/displayport.cpp

287

dp_aux_set_i2c_byte(uint32 connectorIndex, uint32 address, uint8* data,

src/add-ons/accelerants/radeon_hd/displayport.cpp

293

message.address = address;

src/add-ons/accelerants/radeon_hd/displayport.cpp

489

message.address = DP_LANE_STATUS_0_1;

src/add-ons/accelerants/radeon_hd/displayport.cpp

568

message.address = DP_TRAINING_LANE0_SET;

src/add-ons/accelerants/radeon_hd/displayport.h

26

uint8 dpcd_reg_read(uint32 connectorIndex, uint32 address);

src/add-ons/accelerants/radeon_hd/displayport.h

27

void dpcd_reg_write(uint32 connectorIndex, uint32 address, uint8 value);

src/add-ons/accelerants/radeon_hd/displayport.h

32

status_t dp_aux_set_i2c_byte(uint32 connectorIndex, uint32 address,

src/add-ons/accelerants/radeon_hd/displayport.h

34

status_t dp_aux_get_i2c_byte(uint32 connectorIndex, uint32 address,

src/add-ons/accelerants/s3/savage_mode.cpp

804

int address = (mode.v_display_start * mode.virtual_width)

src/add-ons/accelerants/s3/savage_mode.cpp

806

address &= ~0x1F;

src/add-ons/accelerants/s3/savage_mode.cpp

807

address += si.frameBufferOffset;

src/add-ons/accelerants/s3/savage_mode.cpp

811

WriteReg32(PRI_STREAM_FBUF_ADDR0, address & 0xFFFFFFFC);

src/add-ons/accelerants/s3/savage_mode.cpp

812

WriteReg32(PRI_STREAM_FBUF_ADDR1, address & 0xFFFFFFFC);

src/add-ons/accelerants/s3/savage_mode.cpp

816

WriteReg32(PRI_STREAM_FBUF_ADDR1, address & 0xFFFFFFF8);

src/add-ons/accelerants/s3/savage_mode.cpp

820

WriteReg32(PRI_STREAM_FBUF_ADDR0, (address & 0xFFFFFFF8));

src/add-ons/accelerants/s3/savage_mode.cpp

821

WriteReg32(PRI_STREAM2_FBUF_ADDR0, (address & 0xFFFFFFF8));

src/add-ons/accelerants/s3/savage_mode.cpp

824

WriteReg32(PRI_STREAM_FBUF_ADDR0, address | 0xFFFFFFFC);

src/add-ons/accelerants/s3/savage_mode.cpp

825

WriteReg32(PRI_STREAM_FBUF_ADDR1, address | 0x80000000);

src/add-ons/accelerants/skeleton/engine/i2c.c

290

int i2c_maven_read(unsigned char address)

src/add-ons/accelerants/skeleton/engine/i2c.c

298

error+=i2c_sendbyte(address);

src/add-ons/accelerants/skeleton/engine/i2c.c

306

void i2c_maven_write(unsigned char address, unsigned char data)

src/add-ons/accelerants/skeleton/engine/i2c.c

313

error+=i2c_sendbyte(address);

src/add-ons/accelerants/skeleton/engine/proto.h

29

int i2c_maven_read(unsigned char address);

src/add-ons/accelerants/skeleton/engine/proto.h

30

void i2c_maven_write(unsigned char address, unsigned char data);

src/add-ons/accelerants/vesa/mode.cpp

299

gInfo->frame_buffer = info.address;

src/add-ons/accelerants/via/engine/i2c.c

290

int i2c_maven_read(unsigned char address)

src/add-ons/accelerants/via/engine/i2c.c

298

error+=i2c_sendbyte(address);

src/add-ons/accelerants/via/engine/i2c.c

306

void i2c_maven_write(unsigned char address, unsigned char data)

src/add-ons/accelerants/via/engine/i2c.c

313

error+=i2c_sendbyte(address);

src/add-ons/accelerants/via/engine/proto.h

29

int i2c_maven_read(unsigned char address);

src/add-ons/accelerants/via/engine/proto.h

30

void i2c_maven_write(unsigned char address, unsigned char data);

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1003

AcpiOsReadPort(ACPI_IO_ADDRESS address, UINT32 *value, UINT32 width)

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1006

DEBUG_FUNCTION_F("addr: 0x%08lx; width: %" B_PRIu32, (addr_t)address, (uint32)width);

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1009

*value = gPCIManager->read_io_8(address);

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1013

*value = gPCIManager->read_io_16(address);

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1017

*value = gPCIManager->read_io_32(address);

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1045

AcpiOsWritePort(ACPI_IO_ADDRESS address, UINT32 value, UINT32 width)

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1049

(addr_t)address, (uint32)value, (uint32)width);

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1052

gPCIManager->write_io_8(address, value);

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1056

gPCIManager->write_io_16(address,value);

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1060

gPCIManager->write_io_32(address,value);

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1088

AcpiOsReadMemory(ACPI_PHYSICAL_ADDRESS address, UINT64 *value, UINT32 width)

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1091

if (vm_memcpy_from_physical(value, (phys_addr_t)address, width / 8, false)

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1116

AcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS address, UINT64 value, UINT32 width)

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1119

if (vm_memcpy_to_physical((phys_addr_t)address, &value, width / 8, false)

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1157

((char *)pointer) + length <= info.address + info.ram_size;

src/add-ons/kernel/bus_managers/acpi/ACPICAHaiku.cpp

1190

((char *)pointer) + length <= info.address + info.ram_size;

src/add-ons/kernel/bus_managers/acpi/ACPIPrivate.h

197

acpi_gpe_handler address);

src/add-ons/kernel/bus_managers/acpi/ACPIPrivate.h

83

acpi_gpe_handler address);

src/add-ons/kernel/bus_managers/acpi/BusManager.cpp

394

acpi_gpe_handler address)

src/add-ons/kernel/bus_managers/acpi/BusManager.cpp

396

return AcpiRemoveGpeHandler(handle, gpeNumber, (ACPI_GPE_HANDLER)address)

src/add-ons/kernel/bus_managers/acpi/BusManager.cpp

769

if (wakeVector.address >= 0x100000000LL) {

src/add-ons/kernel/bus_managers/acpi/BusManager.cpp

774

acpiStatus = AcpiSetFirmwareWakingVector(wakeVector.address,

src/add-ons/kernel/bus_managers/acpi/BusManager.cpp

775

wakeVector.address);

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

57

bus_space_read_1(int address)

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

59

return gPCIManager->read_io_8(address);

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

64

bus_space_write_1(int address, uint8 value)

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

641

EcSpaceHandler(uint32 function, acpi_physical_address address, uint32 width,

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

651

if (address + width / 8 > 256)

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

66

gPCIManager->write_io_8(address, value);

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

681

ACPI_PHYSICAL_ADDRESS ecAddr = address;

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

698

} while (ecAddr < address + width / 8);

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

829

EcRead(struct acpi_ec_cookie* sc, uint8 address, uint8* readData)

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

831

TRACE("read from %#x\n", address);

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

840

EC_SET_DATA(sc, address);

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

858

EcWrite(struct acpi_ec_cookie* sc, uint8 address, uint8 writeData)

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp

865

EC_SET_DATA(sc, address);

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.h

216

acpi_physical_address address,

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.h

222

static acpi_status EcRead(struct acpi_ec_cookie *sc, uint8 address,

src/add-ons/kernel/bus_managers/acpi/EmbeddedController.h

224

static acpi_status EcWrite(struct acpi_ec_cookie *sc, uint8 address,

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

1068

*_physicalBase = entry.address;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

113

uint8 address; /* location of AGP interface in PCI capabilities */

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

288

uint8 address = get_pci_config(info, PCI_capabilities_ptr, 1);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

291

uint8 id = get_pci_config(info, address, 1);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

292

uint8 next = get_pci_config(info, address + 1, 1) & ~0x3;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

297

*_address = address;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

305

address = next;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

325

if (is_agp_device(info, &device.address)) {

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

336

AGP_ID(device.address), 4);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

338

AGP_STATUS(device.address), 4);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

340

AGP_COMMAND(device.address), 4);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

354

set_pci_config(deviceInfo.info, AGP_COMMAND(deviceInfo.address), 4, command);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

356

AGP_COMMAND(deviceInfo.address), 4);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

400

base = (addr_t)info.address;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

52

#define AGP_ID(address) (address)

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

53

#define AGP_STATUS(address) (address + 4)

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

54

#define AGP_COMMAND(address) (address + 8)

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

590

void *address;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

591

memory->area = create_area("GART memory", &address, B_ANY_KERNEL_ADDRESS,

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

635

Aperture::BindMemory(aperture_memory *memory, addr_t address, size_t size)

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

655

address += offset;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

667

status = get_memory_map((void *)(address + offset), B_PAGE_SIZE,

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

674

physicalAddress = entry.address;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

862

sDeviceInfos[index].info, AGP_STATUS(sDeviceInfos[index].address), 4);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

864

sDeviceInfos[index].info, AGP_COMMAND(sDeviceInfos[index].address), 4);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

909

AGP_STATUS(deviceInfo.address), 4);

src/add-ons/kernel/bus_managers/ata/ATAChannel.cpp

980

entry->address + offset, currentLength, transferred);

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

309

uint32 address = ((uint32)command->high_lba << 16)

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

313

return ExecuteReadWrite(request, address, command->length != 0

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

321

uint32 address = B_BENDIAN_TO_HOST_INT32(command->lba);

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

326

return ExecuteReadWrite(request, address, sectorCount);

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

338

uint32 address = B_BENDIAN_TO_HOST_INT32(command->lba);

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

343

return ExecuteReadWrite(request, address, sectorCount);

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

355

uint64 address = B_BENDIAN_TO_HOST_INT64(command->lba);

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

360

return ExecuteReadWrite(request, address, sectorCount);

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

642

ATADevice::ExecuteReadWrite(ATARequest *request, uint64 address,

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

650

if (_FillTaskFile(request, address) != B_OK) {

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

710

ATADevice::_FillTaskFile(ATARequest *request, uint64 address)

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

728

&& (address + sectorCount > 0xfffffff || sectorCount > 0x100)) {

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

744

fTaskFile.lba48.lba_0_7 = address & 0xff;

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

745

fTaskFile.lba48.lba_8_15 = (address >> 8) & 0xff;

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

746

fTaskFile.lba48.lba_16_23 = (address >> 16) & 0xff;

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

747

fTaskFile.lba48.lba_24_31 = (address >> 24) & 0xff;

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

748

fTaskFile.lba48.lba_32_39 = (address >> 32) & 0xff;

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

749

fTaskFile.lba48.lba_40_47 = (address >> 40) & 0xff;

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

768

fTaskFile.lba.lba_0_7 = address & 0xff;

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

769

fTaskFile.lba.lba_8_15 = (address >> 8) & 0xff;

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

770

fTaskFile.lba.lba_16_23 = (address >> 16) & 0xff;

src/add-ons/kernel/bus_managers/ata/ATADevice.cpp

771

fTaskFile.lba.lba_24_27 = (address >> 24) & 0xf;

src/add-ons/kernel/bus_managers/ata/ATAHelper.cpp

53

vm_memcpy_from_physical(buffer, sgList->address + offset, bytes,

src/add-ons/kernel/bus_managers/ata/ATAHelper.cpp

56

vm_memcpy_to_physical(sgList->address + offset, buffer, bytes,

src/add-ons/kernel/bus_managers/ata/ATAPrivate.h

209

uint64 address, uint32 sectorCount);

src/add-ons/kernel/bus_managers/ata/ATAPrivate.h

225

uint64 address);

src/add-ons/kernel/bus_managers/firewire/util.c

67

*phy = (void*)(addr_t)pe.address;

src/add-ons/kernel/bus_managers/firewire/util.c

69

pe.address);

src/add-ons/kernel/bus_managers/hyperv/VMBus.cpp

1197

length, buffer, entry.address);

src/add-ons/kernel/bus_managers/hyperv/VMBus.cpp

1200

*_physAddr = entry.address;

src/add-ons/kernel/bus_managers/hyperv/VMBusRequest.cpp

54

fHcPostMessagePhys = entry.address;

src/add-ons/kernel/bus_managers/pci/pci.cpp

2114

addr_t address;

src/add-ons/kernel/bus_managers/pci/pci.cpp

2124

(void**)&address);

src/add-ons/kernel/bus_managers/pci/pci.cpp

2128

info->table_address = address + info->table_offset;

src/add-ons/kernel/bus_managers/pci/pci.cpp

2141

(void**)&address);

src/add-ons/kernel/bus_managers/pci/pci.cpp

2150

info->pba_address = address + info->pba_offset;

src/add-ons/kernel/bus_managers/pci/pci.cpp

2215

PCI::_HtMSIMap(PCIDev *device, uint64 address)

src/add-ons/kernel/bus_managers/pci/pci.cpp

2222

if ((address != 0) != enabled) {

src/add-ons/kernel/bus_managers/pci/pci.cpp

2226

if ((address >> 20) != (info->address_value >> 20))

src/add-ons/kernel/bus_managers/pci/pci.cpp

345

int address;

src/add-ons/kernel/bus_managers/pci/pci.cpp

352

address = strtoul(argv[1], NULL, 0);

src/add-ons/kernel/bus_managers/pci/pci.cpp

380

kprintf("[0x%" B_PRIx32 "] ", address + i * itemSize);

src/add-ons/kernel/bus_managers/pci/pci.cpp

392

kprintf(" %02" B_PRIx8, pci_read_io_8(address + i * itemSize));

src/add-ons/kernel/bus_managers/pci/pci.cpp

395

kprintf(" %04" B_PRIx16, pci_read_io_16(address + i * itemSize));

src/add-ons/kernel/bus_managers/pci/pci.cpp

398

kprintf(" %08" B_PRIx32, pci_read_io_32(address + i * itemSize));

src/add-ons/kernel/bus_managers/pci/pci.cpp

413

int address;

src/add-ons/kernel/bus_managers/pci/pci.cpp

421

address = strtoul(argv[1], NULL, 0);

src/add-ons/kernel/bus_managers/pci/pci.cpp

442

pci_write_io_8(address + i * itemSize, value);

src/add-ons/kernel/bus_managers/pci/pci.cpp

445

pci_write_io_16(address + i * itemSize, value);

src/add-ons/kernel/bus_managers/pci/pci.cpp

448

pci_write_io_32(address + i * itemSize, value);

src/add-ons/kernel/bus_managers/pci/pci.h

183

uint32 &address, uint32 *size = NULL,

src/add-ons/kernel/bus_managers/pci/pci.h

198

void _HtMSIMap(PCIDev *device, uint64 address);

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

110

uchar *buffer_data = buffer->address;

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

126

vm_memcpy_from_physical(buffer_data, sg_list->address, bytes,

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

129

vm_memcpy_to_physical(sg_list->address, buffer_data, bytes, false);

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

204

(void**)&buffer->address);

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

216

(void **)&buffer->address, B_ANY_KERNEL_ADDRESS, size,

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

253

buffer->address,

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

324

sg_list->address, sg_list->size);

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

409

request->data = buffer->address;

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

63

max_len = (dma_boundary + 1) - (sg_list->address & dma_boundary);

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

67

sg_list->address + max_len);

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

72

if ((sg_list->address & alignment) != 0) {

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

74

sg_list->address);

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

78

if (((sg_list->address + sg_list->size) & alignment) != 0) {

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

80

sg_list->address + sg_list->size);

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

84

if ((sg_list->address + sg_list->size) > high_address) {

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

86

sg_list->address + sg_list->size);

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

100

device->buffer_sg_list[0].address = physicalAddress;

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

496

B_PRIuSIZE ", to_buffer = %d", buffer, sg_list->address + offset,

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

500

vm_memcpy_from_physical(buffer, sg_list->address + offset, bytes,

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

503

vm_memcpy_to_physical(sg_list->address + offset, buffer, bytes,

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

71

void* address;

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

78

0, 0, &virtualRestrictions, &physicalRestrictions, &address);

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

88

get_memory_map(address, B_PAGE_SIZE, map, 1);

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

91

phys_addr_t physicalAddress = map[0].address;

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

94

physicalAddress, address);

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

96

device->buffer = (char*)address;

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

99

device->buffer_sg_list = (physical_entry*)((char*)address + buffer_size);

src/add-ons/kernel/bus_managers/scsi/scatter_gather.cpp

62

(temp_sg[cur_idx].address & dma_boundary);

src/add-ons/kernel/bus_managers/scsi/scatter_gather.cpp

68

B_PRIu32, temp_sg[cur_idx].address, temp_sg[cur_idx].size,

src/add-ons/kernel/bus_managers/scsi/scatter_gather.cpp

80

temp_sg[cur_idx + 1].address

src/add-ons/kernel/bus_managers/scsi/scatter_gather.cpp

81

= temp_sg[cur_idx + 1].address + max_len;

src/add-ons/kernel/bus_managers/scsi/scsi_internal.h

123

uchar *address; // address of DMA buffer

src/add-ons/kernel/bus_managers/scsi/virtual_memory.cpp

93

&& map[cur_idx].address

src/add-ons/kernel/bus_managers/scsi/virtual_memory.cpp

94

== map[cur_idx - 1].address + map[cur_idx - 1].size) {

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

101

address--;

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

102

if (address < 0)

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

108

if (!fDeviceMap[address]) {

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

109

TRACE_ERROR("freeing address %d which was not allocated\n", address);

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

112

fDeviceMap[address] = false;

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

80

int8 address = fDeviceIndex;

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

82

if (fDeviceMap[address] == false) {

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

83

fDeviceIndex = (address + 1) % 127;

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

84

fDeviceMap[address] = true;

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

86

return address + 1;

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

89

address = (address + 1) % 127;

src/add-ons/kernel/bus_managers/usb/BusManager.cpp

99

BusManager::FreeAddress(int8 address)

src/add-ons/kernel/bus_managers/usb/PhysicalMemoryAllocator.cpp

92

fPhysicalBase = physicalEntry.address;

src/add-ons/kernel/bus_managers/usb/Pipe.cpp

62

Pipe::SetHubInfo(int8 address, uint8 port)

src/add-ons/kernel/bus_managers/usb/Pipe.cpp

64

fHubAddress = address;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

339

*physicalAddress = (phys_addr_t)physicalEntry.address;

src/add-ons/kernel/bus_managers/usb/Stack.cpp

342

B_PRIxPHYSADDR "\n", area, size, logAddress, physicalEntry.address);

src/add-ons/kernel/bus_managers/usb/Transfer.cpp

108

fVector[i].base = (generic_addr_t)vector[i].address;

src/add-ons/kernel/bus_managers/usb/Transfer.cpp

197

vector[i].base = vector[i].base - (addr_t)areaInfo.address;

src/add-ons/kernel/bus_managers/usb/usb_private.h

218

void FreeAddress(int8 address);

src/add-ons/kernel/bus_managers/usb/usb_private.h

349

void SetHubInfo(int8 address, uint8 port);

src/add-ons/kernel/bus_managers/virtio/VirtioQueue.cpp

379

desc[index].addr = vector[i].address;

src/add-ons/kernel/bus_managers/virtio/VirtioQueue.cpp

44

*phy = pe.address;

src/add-ons/kernel/bus_managers/virtio/VirtioQueue.cpp

46

areaid, size, virtadr, pe.address);

src/add-ons/kernel/busses/agp_gart/intel_gart.cpp

43

#define write32(address, data) \

src/add-ons/kernel/busses/agp_gart/intel_gart.cpp

44

(*((volatile uint32*)(address)) = (data))

src/add-ons/kernel/busses/agp_gart/intel_gart.cpp

45

#define read32(address) \

src/add-ons/kernel/busses/agp_gart/intel_gart.cpp

46

(*((volatile uint32*)(address)))

src/add-ons/kernel/busses/agp_gart/intel_gart.cpp

797

info.scratch_page = entry.address;

src/add-ons/kernel/busses/ata/silicon_image_3112/silicon_image_3112.c

465

channel->prdt_phys = entry.address;

src/add-ons/kernel/busses/ata/silicon_image_3112/silicon_image_3112.c

689

prd->address = B_HOST_TO_LENDIAN_INT32((uint32)pci->ram_address(device,

src/add-ons/kernel/busses/ata/silicon_image_3112/silicon_image_3112.c

690

sg_list->address));

src/add-ons/kernel/busses/ata/silicon_image_3112/silicon_image_3112.c

696

FLOW("%" B_PRIx32", %" B_PRId16", %" B_PRId8"\n", prd->address, prd->count, prd->EOT);

src/add-ons/kernel/busses/i2c/ocores/ocores_i2c.cpp

71

uint8 val = OcoresI2cRegsAddress7{.read = isRead, .address = (uint8)adr}.val;

src/add-ons/kernel/busses/i2c/ocores/ocores_i2c.h

106

status_t WriteAddress(i2c_addr address, bool isRead);

src/add-ons/kernel/busses/i2c/ocores/ocores_i2c.h

28

uint8 address: 7;

src/add-ons/kernel/busses/i2c/pch/pch_i2c.h

36

#define write32(address, data) \

src/add-ons/kernel/busses/i2c/pch/pch_i2c.h

37

(*((volatile uint32*)(address)) = (data))

src/add-ons/kernel/busses/i2c/pch/pch_i2c.h

38

#define read32(address) \

src/add-ons/kernel/busses/i2c/pch/pch_i2c.h

39

(*((volatile uint32*)(address)))

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

309

uint64 address = (uint64)(PciAddress {

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

315

status_t res = AtuMap(1, kPciAtuOutbound, atuType, fConfigPhysBase, address, fConfigSize);

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

332

addr_t address = ConfigAddress(bus, device, function, offset);

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

333

if (address == 0)

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

337

case 1: value = ReadReg8(address); break;

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

338

case 2: value = ReadReg16(address); break;

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

339

case 4: value = *(vuint32*)address; break;

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

354

addr_t address = ConfigAddress(bus, device, function, offset);

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

355

if (address == 0)

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

359

case 1: WriteReg8(address, value); break;

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

360

case 2: WriteReg16(address, value); break;

src/add-ons/kernel/busses/pci/designware/DWPCIController.cpp

361

case 4: *(vuint32*)address = value; break;

src/add-ons/kernel/busses/pci/designware/DWPCIController.h

168

status_t AllocateVectors(uint32 count, uint32& startVector, uint64& address,

src/add-ons/kernel/busses/pci/designware/MsiInterruptCtrlDW.cpp

27

fMsiPhysAddr = pe.address;

src/add-ons/kernel/busses/pci/designware/MsiInterruptCtrlDW.cpp

56

MsiInterruptCtrlDW::AllocateVectors(uint32 count, uint32& startVector, uint64& address,

src/add-ons/kernel/busses/pci/designware/MsiInterruptCtrlDW.cpp

68

address = fMsiPhysAddr;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

115

PciAddressEcam address {

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

121

if ((ROUNDDOWN(address.val, 4) + 4) > fRegsLen)

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

124

return (addr_t)fRegs + address.val;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

135

addr_t address = ConfigAddress(bus, device, function, offset);

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

136

if (address == 0)

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

140

case 1: value = *(vuint8*)address; break;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

141

case 2: value = *(vuint16*)address; break;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

142

case 4: value = *(vuint32*)address; break;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

155

addr_t address = ConfigAddress(bus, device, function, offset);

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

156

if (address == 0)

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

160

case 1: *(vuint8*)address = value; break;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

161

case 2: *(vuint16*)address = value; break;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIController.cpp

162

case 4: *(vuint32*)address = value; break;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

136

const auto& address = res->data.address16;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

137

if (!DecodeAddress(address, range))

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

142

const auto& address = res->data.address32;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

143

if (!DecodeAddress(address, range))

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

149

const auto& address = res->data.address64;

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

150

if (!DecodeAddress(address, range))

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

160

switch (res->data.address.resource_type) {

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

163

if (res->data.address.info.mem.caching == 3 /*ACPI_PREFETCHABLE_MEMORY*/)

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

56

alloc->address, alloc->pci_segment, alloc->start_bus_number, alloc->end_bus_number);

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

68

alloc->address, fRegsLen, B_ANY_KERNEL_ADDRESS,

src/add-ons/kernel/busses/pci/ecam/ECAMPCIControllerACPI.cpp

93

const auto& acpiRange = resource.address;

src/add-ons/kernel/busses/random/ccp/ccp.h

34

#define read32(address) \

src/add-ons/kernel/busses/random/ccp/ccp.h

35

(*((volatile uint32*)(address)))

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

1117

s->sram_phys = (uint32) entries[0].address;

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

256

sp->syncmsg.address = LE(PPHADDR(sp->_syncmsg));

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

259

sp->widemsg.address = LE(PPHADDR(sp->_widemsg));

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

262

sp->sendmsg.address = LE(PPHADDR(sp->_sendmsg));

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

264

sp->recvmsg.address = LE(PPHADDR(sp->_recvmsg));

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

267

sp->status.address = LE(PPHADDR(sp->_status));

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

270

sp->extdmsg.address = LE(PPHADDR(sp->_extdmsg));

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

273

sp->command.address = LE(PPHADDR(sp->_command));

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

317

t[sgcount].address = LE((uint32) pe[sgcount].address);

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

328

t[i].address = LE((uint32) pe[i].address);

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

334

t[sgcount].address = LE(ARG_END);

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

572

t->address = HE(t->count);

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

580

s->active->inbound ? " in" : "out", dbc, n, t->address, t->count);

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

584

t->address += t->count - dbc;

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

588

t->address, t->count);

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

594

t->address = LE(t->address);

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

614

t->address += t->count - dbc;

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

618

t->address -= bytesleft;

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

622

t->address, t->count);

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

628

t->address = LE(t->address);

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

865

prep_io((SymPriv *) ccb->cam_sim_priv, (uint32) pe[0].address);

src/add-ons/kernel/busses/scsi/53c8xx/53c8xx.c

871

targ->priv_phys = (uint32 ) pe[0].address;

src/add-ons/kernel/busses/scsi/53c8xx/symbios.h

47

uint32 address;

src/add-ons/kernel/busses/scsi/ahci/ahci_port.cpp

502

phys_addr_t address = sgTable->address;

src/add-ons/kernel/busses/scsi/ahci/ahci_port.cpp

503

T_PORT(AHCIPortPrdTable(fController, fIndex, address, size));

src/add-ons/kernel/busses/scsi/ahci/ahci_port.cpp

505

address, size);

src/add-ons/kernel/busses/scsi/ahci/ahci_port.cpp

506

if (address & 1) {

src/add-ons/kernel/busses/scsi/ahci/ahci_port.cpp

518

*prdCount, address, bytes);

src/add-ons/kernel/busses/scsi/ahci/ahci_port.cpp

520

prdTable->dba = LO32(address);

src/add-ons/kernel/busses/scsi/ahci/ahci_port.cpp

521

prdTable->dbau = HI32(address);

src/add-ons/kernel/busses/scsi/ahci/ahci_port.cpp

526

address = address + bytes;

src/add-ons/kernel/busses/scsi/ahci/ahci_tracing.h

38

AHCIPortPrdTable(AHCIController* controller, int index, void* address,

src/add-ons/kernel/busses/scsi/ahci/ahci_tracing.h

41

, fAddress(address)

src/add-ons/kernel/busses/scsi/ahci/util.cpp

106

sgTable[i].address, size);

src/add-ons/kernel/busses/scsi/ahci/util.cpp

108

vm_memcpy_to_physical(sgTable[i].address, data, size, false);

src/add-ons/kernel/busses/scsi/ahci/util.cpp

51

*phy = pe.address;

src/add-ons/kernel/busses/scsi/ahci/util.cpp

53

areaid, size, virtadr, pe.address);

src/add-ons/kernel/busses/scsi/buslogic/buslogic.c

424

priv_phys = (uint32) entries[0].address;

src/add-ons/kernel/busses/scsi/buslogic/buslogic.c

474

j, (uint32) scratch[j].address, scratch[j].size);

src/add-ons/kernel/busses/scsi/buslogic/buslogic.c

508

i, (uint32) scratch[i].address, scratch[i].size);

src/add-ons/kernel/busses/scsi/buslogic/buslogic.c

533

bl_ccb->data = toLE((uint32) scratch[0].address);

src/add-ons/kernel/busses/scsi/buslogic/buslogic.c

844

bl->phys_to_virt = ((uint) a) - ((uint) entries[0].address);

src/add-ons/kernel/busses/scsi/buslogic/buslogic.c

845

bl->virt_to_phys = (((uint) entries[0].address - (uint) a));

src/add-ons/kernel/busses/scsi/buslogic/buslogic.c

846

bl->phys_mailboxes = (uint) entries[0].address;

src/add-ons/kernel/busses/scsi/hyperv/HyperVSCSIRequest.cpp

125

vm_memcpy_from_physical(bounceBufferPtr, fCCB->sg_list[i].address,

src/add-ons/kernel/busses/scsi/hyperv/HyperVSCSIRequest.cpp

132

entry.address = fBounceBufferPhys;

src/add-ons/kernel/busses/scsi/hyperv/HyperVSCSIRequest.cpp

159

vm_memcpy_to_physical(fCCB->sg_list[i].address, bounceBufferPtr,

src/add-ons/kernel/busses/scsi/hyperv/HyperVSCSIRequest.cpp

212

fGPARange->offset = sgList[0].address & HV_PAGE_MASK;

src/add-ons/kernel/busses/scsi/hyperv/HyperVSCSIRequest.cpp

215

phys_addr_t address = sgList[i].address;

src/add-ons/kernel/busses/scsi/hyperv/HyperVSCSIRequest.cpp

217

uint32 pageCount = HV_BYTES_TO_SPAN_PAGES(address, length);

src/add-ons/kernel/busses/scsi/hyperv/HyperVSCSIRequest.cpp

225

uint64 pageNumber = address >> HV_PAGE_SHIFT;

src/add-ons/kernel/busses/scsi/hyperv/HyperVSCSIRequest.cpp

36

fBounceBufferPhys = entry.address;

src/add-ons/kernel/busses/scsi/hyperv/HyperVSCSIRequest.cpp

89

phys_addr_t offset = fCCB->sg_list[i].address & HV_PAGE_MASK;

src/add-ons/kernel/busses/scsi/usb/datafab/datafab.c

392

uint8 address[3]; /* part of address */

src/add-ons/kernel/busses/scsi/usb/datafab/datafab.c

564

.address = {0},

src/add-ons/kernel/busses/scsi/virtio/VirtioSCSIHelper.cpp

54

vm_memcpy_from_physical(buffer, sgList->address + offset, bytes,

src/add-ons/kernel/busses/scsi/virtio/VirtioSCSIHelper.cpp

57

vm_memcpy_to_physical(sgList->address + offset, buffer, bytes,

src/add-ons/kernel/busses/scsi/virtio/VirtioSCSIRequest.cpp

195

entries[outCount].address = entries[0].address

src/add-ons/kernel/busses/usb/xhci.cpp

1017

phys_addr_t address;

src/add-ons/kernel/busses/usb/xhci.cpp

1020

address = td->buffer_addrs[i];

src/add-ons/kernel/busses/usb/xhci.cpp

1023

address = transferVec->base + transferVecOffset;

src/add-ons/kernel/busses/usb/xhci.cpp

1045

td->trbs[i].address = address;

src/add-ons/kernel/busses/usb/xhci.cpp

1737

device->address = SLOT_3_DEVICE_ADDRESS_GET(_ReadContext(

src/add-ons/kernel/busses/usb/xhci.cpp

1740

TRACE("device: address 0x%x state 0x%08" B_PRIx32 "\n", device->address,

src/add-ons/kernel/busses/usb/xhci.cpp

1753

pipe.InitCommon(device->address + 1, 0, speed, Pipe::Default, maxPacketSize, 0,

src/add-ons/kernel/busses/usb/xhci.cpp

1835

deviceDescriptor, device->address + 1, speed, false, device);

src/add-ons/kernel/busses/usb/xhci.cpp

1839

deviceDescriptor, device->address + 1, speed, false, device);

src/add-ons/kernel/busses/usb/xhci.cpp

1982

device->address, SLOT_3_SLOT_STATE_GET(_ReadContext(

src/add-ons/kernel/busses/usb/xhci.cpp

2083

descriptor->trbs[descriptor->trb_used].address = addr;

src/add-ons/kernel/busses/usb/xhci.cpp

2096

descriptor->trbs[i].address =

src/add-ons/kernel/busses/usb/xhci.cpp

2097

B_HOST_TO_LENDIAN_INT64(descriptor->trbs[i].address);

src/add-ons/kernel/busses/usb/xhci.cpp

2106

endpoint->trbs[link].address =

src/add-ons/kernel/busses/usb/xhci.cpp

2125

endpoint->trbs[eventdata].address =

src/add-ons/kernel/busses/usb/xhci.cpp

2134

endpoint->trbs[next].address = 0;

src/add-ons/kernel/busses/usb/xhci.cpp

2146

endpoint->trbs[link].address,

src/add-ons/kernel/busses/usb/xhci.cpp

2622

", 0x%08" B_PRIx32 ")\n", i, TRB_3_TYPE_GET(trb->flags), trb->address,

src/add-ons/kernel/busses/usb/xhci.cpp

2625

fCmdRing[i].address = trb->address;

src/add-ons/kernel/busses/usb/xhci.cpp

2658

if (fCmdAddr == trb->address) {

src/add-ons/kernel/busses/usb/xhci.cpp

2731

phys_addr_t source = B_LENDIAN_TO_HOST_INT64(trb->address);

src/add-ons/kernel/busses/usb/xhci.cpp

2739

source = B_LENDIAN_TO_HOST_INT64(endpoint->trbs[offset].address);

src/add-ons/kernel/busses/usb/xhci.cpp

2838

trbs[i].address, trbs[i].status, trbs[i].flags);

src/add-ons/kernel/busses/usb/xhci.cpp

2902

trb.address = 0;

src/add-ons/kernel/busses/usb/xhci.cpp

2915

trb.address = 0;

src/add-ons/kernel/busses/usb/xhci.cpp

2933

trb.address = 0;

src/add-ons/kernel/busses/usb/xhci.cpp

2946

trb.address = inputContext;

src/add-ons/kernel/busses/usb/xhci.cpp

2962

trb.address = inputContext;

src/add-ons/kernel/busses/usb/xhci.cpp

2978

trb.address = inputContext;

src/add-ons/kernel/busses/usb/xhci.cpp

3002

trb.address = 0;

src/add-ons/kernel/busses/usb/xhci.cpp

3030

trb.address = 0;

src/add-ons/kernel/busses/usb/xhci.cpp

3046

trb.address = dequeue | ENDPOINT_2_DCS_BIT;

src/add-ons/kernel/busses/usb/xhci.cpp

3062

trb.address = 0;

src/add-ons/kernel/busses/usb/xhci.cpp

3115

B_PRIx32 ")\n", i, event, fEventRing[i].address,

src/add-ons/kernel/busses/usb/xhci.cpp

791

fCmdRing[XHCI_MAX_COMMANDS - 1].address = dmaAddress;

src/add-ons/kernel/busses/usb/xhci.cpp

893

memcpy(&descriptor->trbs[index].address, requestData,

src/add-ons/kernel/busses/usb/xhci.cpp

907

descriptor->trbs[index].address = descriptor->buffer_addrs[0];

src/add-ons/kernel/busses/usb/xhci.cpp

925

descriptor->trbs[index].address = 0;

src/add-ons/kernel/busses/usb/xhci.h

73

uint8 address;

src/add-ons/kernel/busses/usb/xhci_hardware.h

327

uint64 address;

src/add-ons/kernel/busses/virtio/virtio_mmio/VirtioDevice.cpp

112

uint32_t pfn = pe.address / B_PAGE_SIZE;

src/add-ons/kernel/busses/virtio/virtio_mmio/VirtioDevice.cpp

178

fDescs[desc].addr = vector[i].address;

src/add-ons/kernel/busses/virtio/virtio_mmio/VirtioDevice.cpp

94

phys_addr_t descsPhys = (addr_t)fDescs - (addr_t)queueMem + pe.address;

src/add-ons/kernel/busses/virtio/virtio_mmio/VirtioDevice.cpp

95

phys_addr_t availPhys = (addr_t)fAvail - (addr_t)queueMem + pe.address;

src/add-ons/kernel/busses/virtio/virtio_mmio/VirtioDevice.cpp

96

phys_addr_t usedPhys = (addr_t)fUsed - (addr_t)queueMem + pe.address;

src/add-ons/kernel/busses/virtio/virtio_mmio/virtio_mmio.cpp

143

range.base = res->data.fixed_memory32.address;

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

126

addr_t address = baseAddress + offset;

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

127

if (address == where)

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

141

kprintf("%#16llx: %16.16s\t%s\n", static_cast<unsigned long long>(address), hexString,

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

144

kprintf("%#16llx: failed-to-format\n", static_cast<unsigned long long>(address));

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

146

if (address == where)

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

28

ZyanU64 address;

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

30

context->runtime_address, &address));

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

36

if (IS_KERNEL_ADDRESS(address)) {

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

37

error = elf_debug_lookup_symbol_address(address, &baseAddress,

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

41

debug_get_debugged_thread()->team, address, &baseAddress,

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

49

int64_t offset = address - baseAddress;

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

86

addr_t address = baseAddress;

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

90

while (address < where

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

91

&& debug_memcpy(B_CURRENT_TEAM, &buffer, (const void*)address, sizeof(buffer)) == B_OK

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

94

address += instruction.length;

src/add-ons/kernel/debugger/disasm/x86/disasm_arch.cpp

98

if (address == where) {

src/add-ons/kernel/drivers/audio/ac97/geode/gcscaudioreg.h

134

uint32 address;

src/add-ons/kernel/drivers/audio/ac97/geode/geode_controller.cpp

324

phys_addr_t bufferPhysicalAddress = pe.address;

src/add-ons/kernel/drivers/audio/ac97/geode/geode_controller.cpp

358

stream->physical_buffer_descriptors = pe.address;

src/add-ons/kernel/drivers/audio/ac97/geode/geode_controller.cpp

365

bufferDescriptors->address = stream->physical_buffers[index];

src/add-ons/kernel/drivers/audio/ac97/geode/geode_controller.cpp

369

bufferDescriptors->address = stream->physical_buffer_descriptors;

src/add-ons/kernel/drivers/audio/ac97/sis7018/Stream.cpp

87

fBuffersPhysAddress = PhysEntry.address;

src/add-ons/kernel/drivers/audio/cmedia/cm.c

130

io_base = area.address;

src/add-ons/kernel/drivers/audio/cmedia/cm.c

339

addr = ainfo.address;

src/add-ons/kernel/drivers/audio/cmedia/cm.c

348

if ((where.address & ~(phys_addr_t)0xffffff) != 0) {

src/add-ons/kernel/drivers/audio/cmedia/cm.c

357

where.address, ainfo.address);

src/add-ons/kernel/drivers/audio/cmedia/cm.c

380

ddprintf(("cmedia_pci: physical %p\n", where.address));

src/add-ons/kernel/drivers/audio/cmedia/cm.c

381

if ((where.address & ~(phys_addr_t)0xffffff) != 0) {

src/add-ons/kernel/drivers/audio/cmedia/cm.c

386

if (((where.address + low_size) & ~(phys_addr_t)0xffffff) != 0) {

src/add-ons/kernel/drivers/audio/cmedia/cm.c

405

card->low_phys = where.address;

src/add-ons/kernel/drivers/audio/generic/util.c

102

*phy = pe.address;

src/add-ons/kernel/drivers/audio/generic/util.c

104

pe.address));

src/add-ons/kernel/drivers/audio/hda/hda_controller.cpp

604

pe.address, B_UNCACHED_MEMORY);

src/add-ons/kernel/drivers/audio/hda/hda_controller.cpp

608

controller->Write32(HDAC_CORB_BASE_LOWER, (uint32)pe.address);

src/add-ons/kernel/drivers/audio/hda/hda_controller.cpp

611

(uint32)((uint64)pe.address >> 32));

src/add-ons/kernel/drivers/audio/hda/hda_controller.cpp

614

controller->Write32(HDAC_RIRB_BASE_LOWER, (uint32)pe.address + rirbOffset);

src/add-ons/kernel/drivers/audio/hda/hda_controller.cpp

617

(uint32)(((uint64)pe.address + rirbOffset) >> 32));

src/add-ons/kernel/drivers/audio/hda/hda_controller.cpp

622

(uint32)pe.address + posOffset);

src/add-ons/kernel/drivers/audio/hda/hda_controller.cpp

625

(uint32)(((uint64)pe.address + posOffset) >> 32));

src/add-ons/kernel/drivers/audio/hda/hda_controller.cpp

907

phys_addr_t bufferPhysicalAddress = pe.address;

src/add-ons/kernel/drivers/audio/hda/hda_controller.cpp

947

stream->physical_buffer_descriptors = pe.address;

src/add-ons/kernel/drivers/audio/ice1712/multi.cpp

56

(uint32)(card->phys_pb.address));

src/add-ons/kernel/drivers/audio/ice1712/multi.cpp

66

(uint32)(card->phys_rec.address));

src/add-ons/kernel/drivers/audio/ice1712/util.cpp

74

*log, phy->address);

src/add-ons/kernel/drivers/audio/sb16/hardware.h

218

char *address;

src/add-ons/kernel/drivers/audio/usb/Stream.cpp

250

uint8 address = fAlternates[fActiveAlternate]->Endpoint()->fEndpointAddress;

src/add-ons/kernel/drivers/audio/usb/Stream.cpp

255

if (address == interface->endpoint[i].descr->endpoint_address) {

src/add-ons/kernel/drivers/audio/usb/Stream.cpp

258

fIsInput ? "Input" : "Output", address, fStreamEndpoint);

src/add-ons/kernel/drivers/audio/usb/Stream.cpp

264

fIsInput ? "Input" : "Output", address);

src/add-ons/kernel/drivers/audio/usb/Stream.cpp

447

uint8 address = fAlternates[fActiveAlternate]->Endpoint()->fEndpointAddress;

src/add-ons/kernel/drivers/audio/usb/Stream.cpp

452

address, sizeof(freq), &freq, &actualLength);

src/add-ons/kernel/drivers/audio/usb/Stream.cpp

456

address, actualLength, strerror(status));

src/add-ons/kernel/drivers/disk/nvme/compat/libnvme_haiku.cpp

53

void* address;

src/add-ons/kernel/drivers/disk/nvme/compat/libnvme_haiku.cpp

56

0, 0, &virtualRestrictions, &physicalRestrictions, &address);

src/add-ons/kernel/drivers/disk/nvme/compat/libnvme_haiku.cpp

61

*paddr = nvme_mem_vtophys(address);

src/add-ons/kernel/drivers/disk/nvme/compat/libnvme_haiku.cpp

62

return address;

src/add-ons/kernel/drivers/disk/nvme/compat/libnvme_haiku.cpp

91

return entry.address;

src/add-ons/kernel/drivers/disk/nvme/libnvme/nvme.h

514

uint64_t *address, uint32_t *length);

src/add-ons/kernel/drivers/disk/nvme/libnvme/nvme_qpair.c

631

sgl->address = phys_addr;

src/add-ons/kernel/drivers/disk/nvme/libnvme/nvme_qpair.c

648

req->cmd.dptr.sgl1.address = tr->u.sgl[0].address;

src/add-ons/kernel/drivers/disk/nvme/libnvme/nvme_qpair.c

653

req->cmd.dptr.sgl1.address = tr->prp_sgl_bus_addr;

src/add-ons/kernel/drivers/disk/nvme/libnvme/nvme_spec.h

407

uint64_t address;

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

596

ior_next_sge(nvme_io_request* request, uint64_t* address, uint32_t* length)

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

602

*address = request->iovecs[index].address + request->iovec_offset;

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

606

request->iovec_i, request->iovec_offset, *address, *length);

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

800

if ((nvme_request.iovecs[i].address % B_PAGE_SIZE) != 0)

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

812

if (!bounceAll && (((entry->address + entry->size) % B_PAGE_SIZE) != 0

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

813

|| (entry->address & 0x3) != 0 || (entry->size % block_size) != 0))

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

817

if (!bounceAll && ((entry->address % B_PAGE_SIZE) != 0

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

824

if (!bounceAll && ((entry->address & 0x3) != 0 || (entry->size % block_size) != 0))

src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp

133

entries[numEntries].address = page->physical_page_number * B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp

183

vm_page_free(NULL, vm_lookup_page(entries[i].address / B_PAGE_SIZE));

src/add-ons/kernel/drivers/disk/virtual/virtio_block/virtio_block.cpp

209

entries[0].address = info->bufferPhysAddr;

src/add-ons/kernel/drivers/disk/virtual/virtio_block/virtio_block.cpp

211

entries[operation->VecCount() + 1].address = entries[0].address

src/add-ons/kernel/drivers/disk/virtual/virtio_block/virtio_block.cpp

584

info->bufferPhysAddr = entry.address;

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

159

i2c_start_address(i2c_bus *bus, int address, int read /* 1 = read, 0 = write */)

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

168

addr = (address << 1) | (read & 1);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

258

i2c_read_unlocked(i2c_bus *bus, int address, void *data, int size)

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

266

status = i2c_start_address(bus, address, 1 /* 1 = read, 0 = write */);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

302

i2c_write_unlocked(i2c_bus *bus, int address, const void *data, int size)

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

311

status = i2c_start_address(bus, address, 0 /* 1 = read, 0 = write */);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

345

i2c_read(i2c_bus *bus, int address, void *data, int size)

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

349

res = i2c_read_unlocked(bus, address, data, size);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

356

i2c_write(i2c_bus *bus, int address, const void *data, int size)

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

360

res = i2c_write_unlocked(bus, address, data, size);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

367

i2c_xfer(i2c_bus *bus, int address,

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

376

res = i2c_write_unlocked(bus, address, write_data, write_size);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

384

res = i2c_read_unlocked(bus, address, read_data, read_size);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

39

static status_t i2c_read_unlocked(i2c_bus *bus, int address, void *data, int size);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.c

40

static status_t i2c_write_unlocked(i2c_bus *bus, int address, const void *data, int size);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.h

48

status_t i2c_read(i2c_bus *bus, int address, void *data, int size);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.h

49

status_t i2c_write(i2c_bus *bus, int address, const void *data, int size);

src/add-ons/kernel/drivers/dvb/cx23882/i2c_core.h

51

status_t i2c_xfer(i2c_bus *bus, int address,

src/add-ons/kernel/drivers/dvb/cx23882/util.c

102

*phy = pe.address;

src/add-ons/kernel/drivers/dvb/cx23882/util.c

104

B_PRIxPHYSADDR "\n", areaid, size, virtadr, pe.address);

src/add-ons/kernel/drivers/graphics/ati/driver.cpp

249

#define ADDRESS_SEGMENT(address) ((addr_t)(address) >> 4)

src/add-ons/kernel/drivers/graphics/ati/driver.cpp

250

#define ADDRESS_OFFSET(address) ((addr_t)(address) & 0xf)

src/add-ons/kernel/drivers/graphics/intel_810/driver.cpp

148

#define ADDRESS_SEGMENT(address) ((addr_t)(address) >> 4)

src/add-ons/kernel/drivers/graphics/intel_810/driver.cpp

149

#define ADDRESS_OFFSET(address) ((addr_t)(address) & 0xf)

src/add-ons/kernel/drivers/graphics/intel_810/driver.cpp

322

OUTREG32(PAGE_TABLE_CONTROL, entry.address | PAGE_TABLE_ENABLED);

src/add-ons/kernel/drivers/graphics/intel_810/driver.cpp

350

si.videoMemPCI = entry.address;

src/add-ons/kernel/drivers/graphics/intel_810/driver.cpp

353

entry.address | PTE_VALID);

src/add-ons/kernel/drivers/graphics/intel_extreme/bios.cpp

240

uint16_t ReadWord(off_t address)

src/add-ons/kernel/drivers/graphics/intel_extreme/bios.cpp

242

return memory[address] | memory[address + 1] << 8;

src/add-ons/kernel/drivers/graphics/nvidia/driver.c

959

= (void*)(uintptr_t)((map[0].address + net_buf_size - 1) & ~(net_buf_size - 1));

src/add-ons/kernel/drivers/graphics/radeon/DMA.c

114

cur_desc->dest_address = address;

src/add-ons/kernel/drivers/graphics/radeon/DMA.c

119

address += cur_size;

src/add-ons/kernel/drivers/graphics/radeon/DMA.c

85

phys_addr_t address = map[i].address;

src/add-ons/kernel/drivers/graphics/radeon/DMA.c

92

if (address + contig_size > (phys_addr_t)1 << 32) {

src/add-ons/kernel/drivers/graphics/radeon/DMA.c

94

"size: %#" B_PRIxSIZE, address, size);

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

163

gart->GATT.phys = PTB_map[0].address;

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

191

phys_addr_t addr = map[i].address;

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

99

(void **)((map[0].address + size - 1) & ~(size - 1));

src/add-ons/kernel/drivers/graphics/radeon/driver.c

403

result = Radeon_VIPRead( di, vr->channel, vr->address, &vr->data,

src/add-ons/kernel/drivers/graphics/radeon/driver.c

413

result = Radeon_VIPWrite( di, vw->channel, vw->address, vw->data,

src/add-ons/kernel/drivers/graphics/radeon/driver.c

423

result = Radeon_VIPFifoRead( di, vr->channel, vr->address, vr->count, vr->data,

src/add-ons/kernel/drivers/graphics/radeon/driver.c

433

result = Radeon_VIPFifoWrite( di, vw->channel, vw->address, vw->count, vw->data,

src/add-ons/kernel/drivers/graphics/radeon/radeon_driver.h

229

bool Radeon_VIPRead( device_info *di, uint channel, uint address, uint32 *data, bool lock );

src/add-ons/kernel/drivers/graphics/radeon/radeon_driver.h

230

bool Radeon_VIPWrite( device_info *di, uint8 channel, uint address, uint32 data, bool lock );

src/add-ons/kernel/drivers/graphics/radeon/radeon_driver.h

231

bool Radeon_VIPFifoRead(device_info *di, uint8 channel, uint32 address, uint32 count, uint8 *buffer, bool lock);

src/add-ons/kernel/drivers/graphics/radeon/radeon_driver.h

232

bool Radeon_VIPFifoWrite(device_info *di, uint8 channel, uint32 address, uint32 count, uint8 *buffer, bool lock);

src/add-ons/kernel/drivers/graphics/radeon/vip.c

110

address, count );

src/add-ons/kernel/drivers/graphics/radeon/vip.c

114

OUTREG( regs, RADEON_VIPH_REG_ADDR, (channel << 14) | address | 0x3000);

src/add-ons/kernel/drivers/graphics/radeon/vip.c

172

bool Radeon_VIPFifoRead(device_info *di, uint8 channel, uint32 address, uint32 count, uint8 *buffer, bool lock)

src/add-ons/kernel/drivers/graphics/radeon/vip.c

179

res = do_VIPFifoRead( di, channel, address, count, buffer );

src/add-ons/kernel/drivers/graphics/radeon/vip.c

191

static bool do_VIPWrite( device_info *di, uint8 channel, uint address, uint32 data )

src/add-ons/kernel/drivers/graphics/radeon/vip.c

196

OUTREG( regs, RADEON_VIPH_REG_ADDR, (channel << 14) | (address & ~0x2000) );

src/add-ons/kernel/drivers/graphics/radeon/vip.c

210

bool Radeon_VIPWrite(device_info *di, uint8 channel, uint address, uint32 data, bool lock )

src/add-ons/kernel/drivers/graphics/radeon/vip.c

219

res = do_VIPWrite( di, channel, address, data );

src/add-ons/kernel/drivers/graphics/radeon/vip.c

228

static bool do_VIPFifoWrite(device_info *di, uint8 channel, uint32 address,

src/add-ons/kernel/drivers/graphics/radeon/vip.c

237

address, count );

src/add-ons/kernel/drivers/graphics/radeon/vip.c

241

((channel << 14) | address | 0x1000) & ~0x2000 );

src/add-ons/kernel/drivers/graphics/radeon/vip.c

249

(unsigned int)address);

src/add-ons/kernel/drivers/graphics/radeon/vip.c

274

bool Radeon_VIPFifoWrite(device_info *di, uint8 channel, uint32 address, uint32 count, uint8 *buffer, bool lock)

src/add-ons/kernel/drivers/graphics/radeon/vip.c

284

res = do_VIPFifoWrite( di, channel, address, count, buffer );

src/add-ons/kernel/drivers/graphics/radeon/vip.c

30

device_info *di, uint channel, uint address, uint32 *data )

src/add-ons/kernel/drivers/graphics/radeon/vip.c

36

OUTREG( regs, RADEON_VIPH_REG_ADDR, (channel << 14) | address | 0x2000 );

src/add-ons/kernel/drivers/graphics/radeon/vip.c

80

device_info *di, uint channel, uint address, uint32 *data, bool lock )

src/add-ons/kernel/drivers/graphics/radeon/vip.c

87

res = do_VIPRead( di, channel, address, data );

src/add-ons/kernel/drivers/graphics/radeon/vip.c

97

static bool do_VIPFifoRead(device_info *di, uint8 channel, uint32 address, uint32 count, uint8 *buffer)

src/add-ons/kernel/drivers/graphics/radeon_hd/driver.h

25

#define read8(address) (*((volatile uint8*)(address)))

src/add-ons/kernel/drivers/graphics/radeon_hd/driver.h

26

#define read16(address) (*((volatile uint16*)(address)))

src/add-ons/kernel/drivers/graphics/radeon_hd/driver.h

27

#define read32(address) (*((volatile uint32*)(address)))

src/add-ons/kernel/drivers/graphics/radeon_hd/driver.h

28

#define write8(address, data) (*((volatile uint8*)(address)) = (data))

src/add-ons/kernel/drivers/graphics/radeon_hd/driver.h

29

#define write16(address, data) (*((volatile uint16*)(address)) = (data))

src/add-ons/kernel/drivers/graphics/radeon_hd/driver.h

30

#define write32(address, data) (*((volatile uint32*)(address)) = (data))

src/add-ons/kernel/drivers/graphics/s3/driver.cpp

495

#define ADDRESS_SEGMENT(address) ((addr_t)(address) >> 4)

src/add-ons/kernel/drivers/graphics/s3/driver.cpp

496

#define ADDRESS_OFFSET(address) ((addr_t)(address) & 0xf)

src/add-ons/kernel/drivers/graphics/virtio/virtio_gpu.cpp

280

entries[i].address, entries[i].size);

src/add-ons/kernel/drivers/graphics/virtio/virtio_gpu.cpp

281

backing.entries[i].addr = entries[i].address;

src/add-ons/kernel/drivers/graphics/virtio/virtio_gpu.cpp

511

info->commandPhysAddr = entry.address;

src/add-ons/kernel/drivers/input/virtio_input/virtio_input.cpp

182

dev->physAdr = pe.address;

src/add-ons/kernel/drivers/input/virtio_input/virtio_input.cpp

204

pe.address = dev->physAdr + (uint8*)pkt - (uint8*)dev->packets;

src/add-ons/kernel/drivers/misc/poke.cpp

289

result = get_memory_map(ioctl.address, ioctl.size, &table, 1);

src/add-ons/kernel/drivers/misc/poke.cpp

290

ioctl.physical_address = table.address;

src/add-ons/kernel/drivers/misc/poke.cpp

310

(void**)&ioctl.address, ioctl.flags, ioctl.size, ioctl.protection,

src/add-ons/kernel/drivers/network/ether/intel22x/dev/igc/igc_i225.c

720

u32 address)

src/add-ons/kernel/drivers/network/ether/intel22x/dev/igc/igc_i225.c

744

flswctl = address | opcode;

src/add-ons/kernel/drivers/network/ether/intel22x/dev/igc/igc_i225.h

21

u32 address);

src/add-ons/kernel/drivers/network/ether/intel22x/dev/igc/igc_phy.c

1011

static s32 __igc_access_xmdio_reg(struct igc_hw *hw, u16 address,

src/add-ons/kernel/drivers/network/ether/intel22x/dev/igc/igc_phy.c

1022

ret_val = hw->phy.ops.write_reg(hw, IGC_MMDAAD, address);

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_82575.c

2553

static s32 __e1000_access_emi_reg(struct e1000_hw *hw, u16 address,

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_82575.c

2560

ret_val = hw->phy.ops.write_reg(hw, E1000_EMIADD, address);

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_i210.c

232

static s32 e1000_read_invm_word_i210(struct e1000_hw *hw, u8 address, u16 *data)

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_i210.c

253

if (word_address == address) {

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_i210.c

256

address, *data);

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_i210.c

263

DEBUGOUT1("Requested word 0x%02x not found in OTP\n", address);

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_ich8lan.c

855

static s32 __e1000_access_emi_reg_locked(struct e1000_hw *hw, u16 address,

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_ich8lan.c

862

ret_val = hw->phy.ops.write_reg_locked(hw, I82579_EMI_ADDR, address);

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_phy.c

4121

s32 e1000_read_phy_reg_mphy(struct e1000_hw *hw, u32 address, u32 *data)

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_phy.c

4153

(address & E1000_MPHY_ADDRESS_MASK);

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_phy.c

4182

s32 e1000_write_phy_reg_mphy(struct e1000_hw *hw, u32 address, u32 data,

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_phy.c

4218

(address & E1000_MPHY_ADDRESS_MASK);

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_phy.c

4275

static s32 __e1000_access_xmdio_reg(struct e1000_hw *hw, u16 address,

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_phy.c

4286

ret_val = hw->phy.ops.write_reg(hw, E1000_MMDAAD, address);

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_phy.h

119

s32 e1000_read_phy_reg_mphy(struct e1000_hw *hw, u32 address, u32 *data);

src/add-ons/kernel/drivers/network/ether/ipro1000/dev/e1000/e1000_phy.h

120

s32 e1000_write_phy_reg_mphy(struct e1000_hw *hw, u32 address, u32 data,

src/add-ons/kernel/drivers/network/ether/usb_davicom/DavicomDevice.cpp

464

ether_address address;

src/add-ons/kernel/drivers/network/ether/usb_davicom/DavicomDevice.cpp

465

status_t result = _ReadMACAddress(&address);

src/add-ons/kernel/drivers/network/ether/usb_davicom/DavicomDevice.cpp

472

address.ebyte[0], address.ebyte[1], address.ebyte[2],

src/add-ons/kernel/drivers/network/ether/usb_davicom/DavicomDevice.cpp

473

address.ebyte[3], address.ebyte[4], address.ebyte[5]);

src/add-ons/kernel/drivers/network/ether/usb_davicom/DavicomDevice.cpp

478

if (memcmp(&address, &fMACAddress, sizeof(address)) != 0) {

src/add-ons/kernel/drivers/network/ether/usb_davicom/DavicomDevice.cpp

487

fMACAddress = address;

src/add-ons/kernel/drivers/network/ether/usb_davicom/DavicomDevice.cpp

613

DavicomDevice::_ReadMACAddress(ether_address_t *address)

src/add-ons/kernel/drivers/network/ether/usb_davicom/DavicomDevice.cpp

616

sizeof(ether_address), (uint8*)address);

src/add-ons/kernel/drivers/network/ether/usb_davicom/DavicomDevice.h

142

status_t _ReadMACAddress(ether_address_t *address);

src/add-ons/kernel/drivers/network/ether/wb840/device.h

16

# define write8(address,value) (*gPci->write_io_8)((address),(value))

src/add-ons/kernel/drivers/network/ether/wb840/device.h

17

# define write16(address,value) (*gPci->write_io_16)((address),(value))

src/add-ons/kernel/drivers/network/ether/wb840/device.h

18

# define write32(address,value) (*gPci->write_io_32)((address),(value))

src/add-ons/kernel/drivers/network/ether/wb840/device.h

19

# define read8(address) ((*gPci->read_io_8)(address))

src/add-ons/kernel/drivers/network/ether/wb840/device.h

20

# define read16(address) ((*gPci->read_io_16)(address))

src/add-ons/kernel/drivers/network/ether/wb840/device.h

21

# define read32(address) ((*gPci->read_io_32)(address))

src/add-ons/kernel/drivers/network/ether/wb840/device.h

23

# define read8(address) (*((volatile uint8*)(address)))

src/add-ons/kernel/drivers/network/ether/wb840/device.h

24

# define read16(address) (*((volatile uint16*)(address)))

src/add-ons/kernel/drivers/network/ether/wb840/device.h

25

# define read32(address) (*((volatile uint32*)(address)))

src/add-ons/kernel/drivers/network/ether/wb840/device.h

26

# define write8(address,data) (*((volatile uint8 *)(address)) = data)

src/add-ons/kernel/drivers/network/ether/wb840/device.h

27

# define write16(address,data) (*((volatile uint16 *)(address)) = (data))

src/add-ons/kernel/drivers/network/ether/wb840/device.h

28

# define write32(address,data) (*((volatile uint32 *)(address)) = (data))

src/add-ons/kernel/drivers/network/ether/wb840/wb840.c

100

device->phy = device->currentPHY->address;

src/add-ons/kernel/drivers/network/ether/wb840/wb840.c

131

mii->address = phy;

src/add-ons/kernel/drivers/network/ether/wb840/wb840.c

64

return table.address;

src/add-ons/kernel/drivers/network/ether/wb840/wb840.h

389

uint16 address;

src/add-ons/kernel/drivers/power/amd_thermal/amd_thermal.cpp

62

ksmn_read_reg(amd_thermal_device_info* device, uint32 address)

src/add-ons/kernel/drivers/power/amd_thermal/amd_thermal.cpp

64

device->pci->write_pci_config(device->pci_cookie, AMD_SMN_17H_ADDR, 4, address);

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

46

#define write8(address, data) \

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

47

(*((volatile uint8*)(address)) = (data))

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

48

#define read8(address) \

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

49

(*((volatile uint8*)(address)))

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

50

#define write16(address, data) \

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

51

(*((volatile uint16*)(address)) = (data))

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

52

#define read16(address) \

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

53

(*((volatile uint16*)(address)))

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

54

#define write32(address, data) \

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

55

(*((volatile uint32*)(address)) = (data))

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

56

#define read32(address) \

src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp

57

(*((volatile uint32*)(address)))

src/add-ons/kernel/drivers/timer/hpet.cpp

373

hpetTable->hpet_address.address,

src/add-ons/kernel/drivers/timer/hpet.h

113

uint64 address;

src/add-ons/kernel/drivers/timer/msi.h

30

uint64 *address, uint16 *data);

src/add-ons/kernel/drivers/wmi/WMIACPI.cpp

24

acpi_physical_address address, uint32 bitWidth, int *value,

src/add-ons/kernel/file_systems/bfs/Debug.cpp

290

addr_t address = parse_expression(argv[argc - 1]);

src/add-ons/kernel/file_systems/bfs/Debug.cpp

293

node = (bfs_inode*)address;

src/add-ons/kernel/file_systems/bfs/Debug.cpp

295

Inode* inode = (Inode*)address;

src/add-ons/kernel/file_systems/bfs/Journal.cpp

147

add_to_iovec(iovec* vecs, int32& index, int32 max, const void* address,

src/add-ons/kernel/file_systems/bfs/Journal.cpp

151

+ vecs[index - 1].iov_len == (addr_t)address) {

src/add-ons/kernel/file_systems/bfs/Journal.cpp

161

vecs[index].iov_base = const_cast<void*>(address);

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

435

uint64 address;

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

437

status = fTree->SystemVolume()->GetNewBlock(address, block);

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

452

fNodes[level]->SetLogicalAddress(address);

src/add-ons/kernel/file_systems/btrfs/BTree.cpp

464

parentNode->Index(parentSlot)->SetLogicalAddress(address);

src/add-ons/kernel/file_systems/btrfs/BTree.h

152

void SetLogicalAddress(uint64 address)

src/add-ons/kernel/file_systems/btrfs/BTree.h

153

{ fNode->header.SetLogicalAddress(address); }

src/add-ons/kernel/file_systems/btrfs/btrfs.h

138

void SetLogicalAddress(uint64 address)

src/add-ons/kernel/file_systems/btrfs/btrfs.h

139

{ logical_address = B_HOST_TO_LENDIAN_INT64(address); }

src/add-ons/kernel/file_systems/netfs/client/ExtendedServerInfo.cpp

36

ExtendedServerInfo::ExtendedServerInfo(const NetAddress& address)

src/add-ons/kernel/file_systems/netfs/client/ExtendedServerInfo.cpp

39

fAddress(address),

src/add-ons/kernel/file_systems/netfs/client/ExtendedServerInfo.h

31

ExtendedServerInfo(const NetAddress& address);

src/add-ons/kernel/file_systems/netfs/client/RootVolume.cpp

305

RootVolume::_GetServerVolume(const NetAddress& address)

src/add-ons/kernel/file_systems/netfs/client/RootVolume.cpp

319

if (volume && volume->GetServerAddress().GetIP() == address.GetIP()) {

src/add-ons/kernel/file_systems/netfs/client/RootVolume.h

44

ServerVolume* _GetServerVolume(const NetAddress& address);

src/add-ons/kernel/file_systems/netfs/client/ServerManager.cpp

213

ServerManager::GetServerInfo(const NetAddress& address)

src/add-ons/kernel/file_systems/netfs/client/ServerManager.cpp

216

ExtendedServerInfo* serverInfo = fServerInfos->Get(address);

src/add-ons/kernel/file_systems/netfs/client/ServerManager.cpp

228

ServerManager::AddServer(const NetAddress& address)

src/add-ons/kernel/file_systems/netfs/client/ServerManager.cpp

232

ExtendedServerInfo* oldInfo = fServerInfos->Get(address);

src/add-ons/kernel/file_systems/netfs/client/ServerManager.cpp

238

= new(std::nothrow) ExtendedServerInfo(address);

src/add-ons/kernel/file_systems/netfs/client/ServerManager.cpp

243

status_t error = fServerInfos->Put(address, serverInfo);

src/add-ons/kernel/file_systems/netfs/client/ServerManager.cpp

260

ServerManager::RemoveServer(const NetAddress& address)

src/add-ons/kernel/file_systems/netfs/client/ServerManager.cpp

264

ExtendedServerInfo* serverInfo = fServerInfos->Get(address);

src/add-ons/kernel/file_systems/netfs/client/ServerManager.h

25

ExtendedServerInfo* GetServerInfo(const NetAddress& address);

src/add-ons/kernel/file_systems/netfs/client/ServerManager.h

26

status_t AddServer(const NetAddress& address);

src/add-ons/kernel/file_systems/netfs/client/ServerManager.h

27

void RemoveServer(const NetAddress& address);

src/add-ons/kernel/file_systems/netfs/headers/shared/InsecureChannel.h

20

status_t GetPeerAddress(NetAddress *address) const;

src/add-ons/kernel/file_systems/netfs/headers/shared/NetAddress.h

22

NetAddress(const sockaddr_in& address);

src/add-ons/kernel/file_systems/netfs/headers/shared/NetAddress.h

23

NetAddress(const NetAddress& address);

src/add-ons/kernel/file_systems/netfs/headers/shared/NetAddress.h

25

void SetIP(int32 address);

src/add-ons/kernel/file_systems/netfs/headers/shared/NetAddress.h

31

void SetAddress(const sockaddr_in& address);

src/add-ons/kernel/file_systems/netfs/headers/shared/NetAddress.h

41

NetAddress& operator=(const NetAddress& address);

src/add-ons/kernel/file_systems/netfs/headers/shared/NetAddress.h

42

bool operator==(const NetAddress& address) const;

src/add-ons/kernel/file_systems/netfs/headers/shared/NetAddress.h

43

bool operator!=(const NetAddress& address) const;

src/add-ons/kernel/file_systems/netfs/headers/shared/NetAddress.h

58

NetAddress* address);

src/add-ons/kernel/file_systems/netfs/headers/shared/Request.h

19

const void* address;

src/add-ons/kernel/file_systems/netfs/headers/shared/Request.h

22

Data() : address(NULL), size(0) {}

src/add-ons/kernel/file_systems/netfs/headers/shared/Request.h

24

void SetTo(const void* address, int32 size)

src/add-ons/kernel/file_systems/netfs/headers/shared/Request.h

26

this->address = (size > 0 ? address : NULL);

src/add-ons/kernel/file_systems/netfs/headers/shared/Request.h

32

return address;

src/add-ons/kernel/file_systems/netfs/headers/shared/Request.h

55

return (const char*)address;

src/add-ons/kernel/file_systems/netfs/shared/InsecureChannel.cpp

137

InsecureChannel::GetPeerAddress(NetAddress *address) const

src/add-ons/kernel/file_systems/netfs/shared/InsecureChannel.cpp

139

if (!address)

src/add-ons/kernel/file_systems/netfs/shared/InsecureChannel.cpp

149

address->SetAddress(addr);

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

167

NetAddress::operator=(const NetAddress& address)

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

169

fAddress = address.fAddress;

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

175

NetAddress::operator==(const NetAddress& address) const

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

177

return (fAddress.sin_addr.s_addr == address.fAddress.sin_addr.s_addr

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

178

&& fAddress.sin_port == address.fAddress.sin_port);

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

183

NetAddress::operator!=(const NetAddress& address) const

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

185

return !(*this == address);

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

205

status_t GetHostAddress(const char* hostName, NetAddress* address)

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

217

*address = addr;

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

274

NetAddressResolver::GetHostAddress(const char* hostName, NetAddress* address)

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

278

if (!hostName || !address)

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

280

return fResolver->GetHostAddress(hostName, address);

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

33

NetAddress::NetAddress(const sockaddr_in& address)

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

35

fAddress = address;

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

39

NetAddress::NetAddress(const NetAddress& address)

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

41

fAddress = address.fAddress;

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

46

NetAddress::SetIP(int32 address)

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

48

fAddress.sin_addr.s_addr = B_HOST_TO_BENDIAN_INT32(address);

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

74

NetAddress::SetAddress(const sockaddr_in& address)

src/add-ons/kernel/file_systems/netfs/shared/NetAddress.cpp

76

fAddress = address;

src/add-ons/kernel/file_systems/netfs/shared/RequestFlattener.cpp

180

WriteData(data.address, data.size);

src/add-ons/kernel/file_systems/netfs/shared/RequestFlattener.cpp

187

WriteData(data.address, data.size);

src/add-ons/kernel/file_systems/netfs/shared/RequestUnflattener.cpp

180

data.address = buffer;

src/add-ons/kernel/file_systems/netfs/shared/RequestUnflattener.cpp

201

data.address = buffer;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

289

AddressResolver::GetNextAddress(PeerAddress* address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

291

ASSERT(address != NULL);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

297

*address = fAddress;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

302

address->fProtocol = fForcedProtocol;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

306

memcpy(&address->fAddress, fCurrent->ai_addr, sizeof(sockaddr_in));

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

307

reinterpret_cast<sockaddr_in*>(&address->fAddress)->sin_port

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

310

memcpy(&address->fAddress, fCurrent->ai_addr, sizeof(sockaddr_in6));

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

311

reinterpret_cast<sockaddr_in6*>(&address->fAddress)->sin6_port

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

326

Connection::Connection(const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

328

ConnectionBase(address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

333

ConnectionListener::ConnectionListener(const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

335

ConnectionBase(address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

340

ConnectionBase::ConnectionBase(const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

344

fPeerAddress(address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

350

ConnectionStream::ConnectionStream(const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

352

Connection(address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

357

ConnectionPacket::ConnectionPacket(const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

359

Connection(address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

374

ConnectionBase::GetLocalAddress(PeerAddress* address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

376

ASSERT(address != NULL);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

378

address->fProtocol = fPeerAddress.fProtocol;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

380

socklen_t addressSize = sizeof(address->fAddress);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

381

return getsockname(fSocket, (struct sockaddr*)&address->fAddress,

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

39

PeerAddress::operator==(const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

41

return memcmp(&fAddress, &address.fAddress, sizeof(fAddress)) == 0

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

42

&& fProtocol == address.fProtocol;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

47

PeerAddress::operator<(const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

49

int compare = memcmp(&fAddress, &address.fAddress, sizeof(fAddress));

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

50

return compare < 0 || (compare == 0 && fProtocol < address.fProtocol);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

55

PeerAddress::operator=(const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

57

fAddress = address.fAddress;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

577

Connection::CreateObject(const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

579

switch (address.fProtocol) {

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

58

fProtocol = address.fProtocol;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

581

return new(std::nothrow) ConnectionStream(address);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

583

return new(std::nothrow) ConnectionPacket(address);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

591

Connection::Connect(Connection **_connection, const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

595

Connection* conn = CreateObject(address);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

620

const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

625

Connection* conn = CreateObject(address);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

663

PeerAddress address(fPeerAddress.Family());

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

673

address.SetPort(port);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

674

result = bind(fSocket, (sockaddr*)&address.fAddress,

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

675

address.AddressSize());

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

726

PeerAddress address(networkFamily);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

727

address.SetPort(port);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

728

address.fProtocol = IPPROTO_TCP;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

730

status_t result = bind(sock, (sockaddr*)&address.fAddress,

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

731

address.AddressSize());

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

742

*listener = new(std::nothrow) ConnectionListener(address);

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

794

PeerAddress address;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

795

address.fProtocol = IPPROTO_TCP;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

796

address.fAddress = addr;

src/add-ons/kernel/file_systems/nfs4/Connection.cpp

798

status_t result = Connection::SetTo(connection, sock, address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

101

const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

103

const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

111

static Connection* CreateObject(const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

113

Connection(const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

120

ConnectionStream(const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

128

ConnectionPacket(const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

142

ConnectionListener(const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

22

bool operator==(const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

23

bool operator<(const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

25

PeerAddress& operator=(const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

61

status_t GetNextAddress(PeerAddress* address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

83

ConnectionBase(const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/Connection.h

86

status_t GetLocalAddress(PeerAddress* address);

src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.h

88

PeerAddress address;

src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.h

92

memset((void*)&address, 0, sizeof(address));

src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.h

93

fListener->GetLocalAddress(&address);

src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.h

94

return address;

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

103

ASSERT(address != NULL);

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

353

PeerAddress address;

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

356

while ((result = resolver->GetNextAddress(&address)) == B_OK) {

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

357

result = _Acquire(_server, address, createPrivateData);

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

367

ServerManager::_Acquire(Server** _server, const PeerAddress& address,

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

376

ServerNode* node = _Find(address);

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

388

node->fID = address;

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

391

result = Connection::Connect(&conn, address);

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

443

ServerManager::_Find(const PeerAddress& address)

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

447

if (node->fID == address)

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

449

if (node->fID < address)

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

93

Server::Server(Connection* connection, PeerAddress* address)

src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp

96

fAddress(address),

src/add-ons/kernel/file_systems/nfs4/RPCServer.h

186

status_t _Acquire(Server** _server, const PeerAddress& address,

src/add-ons/kernel/file_systems/nfs4/RPCServer.h

189

ServerNode* _Find(const PeerAddress& address);

src/add-ons/kernel/file_systems/nfs4/RPCServer.h

67

PeerAddress* address);

src/add-ons/kernel/file_systems/nfs4/kernel_interface.cpp

122

(*address)->ForcePort(atoi(options));

src/add-ons/kernel/file_systems/nfs4/kernel_interface.cpp

125

(*address)->ForceProtocol(options);

src/add-ons/kernel/file_systems/nfs4/kernel_interface.cpp

58

ParseArguments(const char* _args, AddressResolver** address, char** _server,

src/add-ons/kernel/file_systems/nfs4/kernel_interface.cpp

81

*address = new AddressResolver(args);

src/add-ons/kernel/file_systems/nfs4/kernel_interface.cpp

82

if (*address == NULL) {

src/add-ons/kernel/file_systems/nfs4/kernel_interface.cpp

90

delete *address;

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

371

addr_t address;

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

373

pages[i]->physical_page_number * B_PAGE_SIZE, &address,

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

380

error = output->WriteExactly((uint8*)(address + inPageOffset), toCopy);

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

383

vm_put_physical_page(address, handle);

src/add-ons/kernel/file_systems/udf/CachedBlock.h

107

CachedBlock::SetTo(long_address address)

src/add-ons/kernel/file_systems/udf/CachedBlock.h

110

if (fVolume->MapBlock(address, &block) == B_OK)

src/add-ons/kernel/file_systems/udf/CachedBlock.h

122

long_address address;

src/add-ons/kernel/file_systems/udf/CachedBlock.h

123

address.set_to(accessor.GetBlock(descriptor),

src/add-ons/kernel/file_systems/udf/CachedBlock.h

125

return SetTo(address);

src/add-ons/kernel/file_systems/udf/CachedBlock.h

39

inline status_t SetTo(long_address address);

src/add-ons/kernel/file_systems/udf/Icb.cpp

103

Icb::Icb(Volume *volume, long_address address)

src/add-ons/kernel/file_systems/udf/Icb.cpp

108

fId(to_vnode_id(address)),

src/add-ons/kernel/file_systems/udf/Icb.cpp

109

fPartition(address.partition()),

src/add-ons/kernel/file_systems/udf/Icb.cpp

116

"%d, length = %" B_PRIu32 ")\n", volume, address.block(),

src/add-ons/kernel/file_systems/udf/Icb.cpp

117

address.partition(), address.length()));

src/add-ons/kernel/file_systems/udf/Icb.cpp

125

status_t status = fVolume->MapBlock(address, &block);

src/add-ons/kernel/file_systems/udf/Icb.cpp

142

status = header->tag().init_check(address.block());

src/add-ons/kernel/file_systems/udf/Icb.h

82

Icb(Volume *volume, long_address address);

src/add-ons/kernel/file_systems/udf/MetadataPartition.cpp

28

long_address address;

src/add-ons/kernel/file_systems/udf/MetadataPartition.cpp

29

address.set_to(metadataFileLocation, fPartition);

src/add-ons/kernel/file_systems/udf/MetadataPartition.cpp

31

fMetadataIcb = new(nothrow) Icb(volume, address);

src/add-ons/kernel/file_systems/udf/MetadataPartition.cpp

37

address.set_to(metadataMirrorFileLocation, fPartition);

src/add-ons/kernel/file_systems/udf/MetadataPartition.cpp

39

fMetadataMirrorIcb = new(nothrow) Icb(volume, address);

src/add-ons/kernel/file_systems/udf/Recognition.cpp

128

off_t address = (offset + block) << blockShift;

src/add-ons/kernel/file_systems/udf/Recognition.cpp

130

"address = %" B_PRIdOFF ", ", block, address));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

131

ssize_t bytesRead = read_pos(device, address, chunk.Data(), blockSize);

src/add-ons/kernel/file_systems/udf/Recognition.cpp

160

"failed with: 0x%lx\n", address, blockSize, bytesRead));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

188

off_t address = (offset + block) << blockShift;

src/add-ons/kernel/file_systems/udf/Recognition.cpp

194

ssize_t bytesRead = read_pos(device, address, chunk.Data(), blockSize);

src/add-ons/kernel/file_systems/udf/Recognition.cpp

199

block, address, blockSize, bytesRead));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

345

off_t address = block << blockShift;

src/add-ons/kernel/file_systems/udf/Recognition.cpp

353

ssize_t bytesRead = read_pos(device, address, chunk.Data(),

src/add-ons/kernel/file_systems/udf/Recognition.cpp

359

block, address, blockSize, bytesRead));

src/add-ons/kernel/file_systems/udf/Recognition.cpp

499

off_t address = block << blockShift;

src/add-ons/kernel/file_systems/udf/Recognition.cpp

509

ssize_t bytesRead = read_pos(device, address, chunk.Data(), blockSize);

src/add-ons/kernel/file_systems/udf/Recognition.cpp

514

block, address, blockSize, bytesRead));

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

1117

const long_address *address = reinterpret_cast<const long_address*>(allocation_descriptors());

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

1120

length -= sizeof(long_address), address++)

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

1122

PDUMP(address);

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

1196

const long_address *address = reinterpret_cast<const long_address*>(allocation_descriptors());

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

1199

length -= sizeof(long_address), address++)

src/add-ons/kernel/file_systems/udf/UdfStructures.cpp

1201

PDUMP(address);

src/add-ons/kernel/file_systems/udf/Utils.cpp

168

to_vnode_id(long_address address)

src/add-ons/kernel/file_systems/udf/Utils.cpp

171

ino_t result = address.block();

src/add-ons/kernel/file_systems/udf/Utils.cpp

173

result |= address.partition();

src/add-ons/kernel/file_systems/udf/Utils.cpp

174

TRACE(("block: %" B_PRIu32 ", 0x%" B_PRIx32 "\n", address.block(),

src/add-ons/kernel/file_systems/udf/Utils.cpp

175

address.block()));

src/add-ons/kernel/file_systems/udf/Utils.cpp

176

TRACE(("partition: %d, 0x%x\n", address.partition(), address.partition()));

src/add-ons/kernel/file_systems/udf/Utils.cpp

177

TRACE(("length: %" B_PRIu32 ", 0x%" B_PRIx32 "\n", address.length(),

src/add-ons/kernel/file_systems/udf/Utils.cpp

178

address.length()));

src/add-ons/kernel/file_systems/udf/Utils.h

21

ino_t to_vnode_id(long_address address);

src/add-ons/kernel/file_systems/udf/Volume.cpp

258

off_t address;

src/add-ons/kernel/file_systems/udf/Volume.cpp

261

&address);

src/add-ons/kernel/file_systems/udf/Volume.cpp

263

address <<= blockShift;

src/add-ons/kernel/file_systems/udf/Volume.cpp

266

= read_pos(device, address, chunk.Data(), blockSize);

src/add-ons/kernel/file_systems/udf/Volume.cpp

270

") failed with: 0x%lx\n", address, blockSize,

src/add-ons/kernel/file_systems/udf/Volume.cpp

334

Volume::MapBlock(long_address address, off_t *mappedBlock)

src/add-ons/kernel/file_systems/udf/Volume.cpp

337

", mappedBlock = %p\n", address.partition(), address.block(),

src/add-ons/kernel/file_systems/udf/Volume.cpp

340

", mappedBlock = %p", address.partition(), address.block(),

src/add-ons/kernel/file_systems/udf/Volume.cpp

344

Partition *partition = _GetPartition(address.partition());

src/add-ons/kernel/file_systems/udf/Volume.cpp

347

error = partition->MapBlock(address.block(), *mappedBlock);

src/add-ons/kernel/file_systems/udf/Volume.h

38

status_t MapBlock(long_address address, off_t *mappedBlock);

src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp

1341

if ((uint8*)buffer - (uint8*)info.address

src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp

1391

- (uint8*)info.address);

src/add-ons/kernel/file_systems/userlandfs/private/AreaSupport.cpp

14

if (!address) {

src/add-ons/kernel/file_systems/userlandfs/private/AreaSupport.cpp

20

*area = area_for(address);

src/add-ons/kernel/file_systems/userlandfs/private/AreaSupport.cpp

28

*offset = (uint8*)address - (uint8*)areaInfo.address;

src/add-ons/kernel/file_systems/userlandfs/private/AreaSupport.cpp

32

*areaBaseAddress = areaInfo.address;

src/add-ons/kernel/file_systems/userlandfs/private/AreaSupport.cpp

7

UserlandFSUtil::get_area_for_address(void* address, int32 size, area_id* area,

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

178

RequestAllocator::AllocateAddress(Address& address, int32 size, int32 align,

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

201

int32 addressOffset = (uint8*)&address - (uint8*)fRequest;

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

226

info.target = &address;

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

231

address.SetTo(-1, offset, size);

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

262

info.target = &address;

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

268

address.SetTo(area, 0, size);

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

275

RequestAllocator::AllocateData(Address& address, const void* data, int32 size,

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

281

error = AllocateAddress(address, size, align, &destination,

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

294

address.SetTo(-1, 0, 0);

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

300

RequestAllocator::AllocateString(Address& address, const char* data,

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

304

return AllocateData(address, data, size, 1, deferredInit);

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

11

infos[*count].address = &_address; \

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

16

#define ADD_ADDRESS(address) _ADD_ADDRESS(address, 0)

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

17

#define ADD_STRING(address) _ADD_ADDRESS(address, ADDRESS_IS_STRING)

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

18

#define ADD_NON_NULL_ADDRESS(address) _ADD_ADDRESS(address, ADDRESS_NOT_NULL)

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

19

#define ADD_NON_NULL_STRING(address) \

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

20

_ADD_ADDRESS(address, (ADDRESS_IS_STRING | ADDRESS_NOT_NULL))

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

445

Address* address = infos[i].address;

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

446

int32 size = address->GetSize();

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

447

int32 offset = address->GetOffset();

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

455

area_id area = address->GetArea();

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

460

address->SetRelocatedAddress(NULL);

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

467

address->SetRelocatedAddress((uint8*)request + offset);

src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp

490

address->SetRelocatedAddress((uint8*)data + offset);

src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp

105

void* address;

src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp

109

B_SYMBOL_TYPE_TEXT, true, NULL, &createFSFunction.address);

src/add-ons/kernel/file_systems/xfs/BPlusTree.cpp

758

uint32 address = B_BENDIAN_TO_HOST_INT32(leafEntry[left].address);

src/add-ons/kernel/file_systems/xfs/BPlusTree.cpp

759

if (address == 0) {

src/add-ons/kernel/file_systems/xfs/BPlusTree.cpp

764

uint32 dataBlockNumber = BLOCKNO_FROM_ADDRESS(address * 8, volume);

src/add-ons/kernel/file_systems/xfs/BPlusTree.cpp

765

uint32 offset = BLOCKOFFSET_FROM_ADDRESS(address * 8, fInode);

src/add-ons/kernel/file_systems/xfs/Extent.cpp

109

Extent::GetOffsetFromAddress(uint32 address)

src/add-ons/kernel/file_systems/xfs/Extent.cpp

111

address = address * 8;

src/add-ons/kernel/file_systems/xfs/Extent.cpp

113

return address & (fInode->DirBlockSize() - 1);

src/add-ons/kernel/file_systems/xfs/Extent.cpp

234

uint32 address = B_BENDIAN_TO_HOST_INT32(leafEntry[left].address);

src/add-ons/kernel/file_systems/xfs/Extent.cpp

235

if (address == 0) {

src/add-ons/kernel/file_systems/xfs/Extent.cpp

240

uint32 offset = GetOffsetFromAddress(address);

src/add-ons/kernel/file_systems/xfs/Extent.h

145

uint32 address;

src/add-ons/kernel/file_systems/xfs/Extent.h

170

uint32 GetOffsetFromAddress(uint32 address);

src/add-ons/kernel/file_systems/xfs/LeafDirectory.cpp

177

LeafDirectory::GetOffsetFromAddress(uint32 address)

src/add-ons/kernel/file_systems/xfs/LeafDirectory.cpp

179

address = address * 8;

src/add-ons/kernel/file_systems/xfs/LeafDirectory.cpp

181

return address & (fInode->DirBlockSize() - 1);

src/add-ons/kernel/file_systems/xfs/LeafDirectory.cpp

363

uint32 address = B_BENDIAN_TO_HOST_INT32(leafEntry[left].address);

src/add-ons/kernel/file_systems/xfs/LeafDirectory.cpp

364

if (address == 0) {

src/add-ons/kernel/file_systems/xfs/LeafDirectory.cpp

369

uint32 dataBlockNumber = BLOCKNO_FROM_ADDRESS(address * 8, volume);

src/add-ons/kernel/file_systems/xfs/LeafDirectory.cpp

370

uint32 offset = BLOCKOFFSET_FROM_ADDRESS(address * 8, fInode);

src/add-ons/kernel/file_systems/xfs/LeafDirectory.h

119

uint32 GetOffsetFromAddress(uint32 address);

src/add-ons/kernel/file_systems/xfs/Node.cpp

193

NodeDirectory::GetOffsetFromAddress(uint32 address)

src/add-ons/kernel/file_systems/xfs/Node.cpp

195

address = address * 8;

src/add-ons/kernel/file_systems/xfs/Node.cpp

197

return address & (fInode->DirBlockSize() - 1);

src/add-ons/kernel/file_systems/xfs/Node.cpp

420

uint32 address = B_BENDIAN_TO_HOST_INT32(leafEntry[left].address);

src/add-ons/kernel/file_systems/xfs/Node.cpp

421

if (address == 0) {

src/add-ons/kernel/file_systems/xfs/Node.cpp

426

uint32 dataBlockNumber = BLOCKNO_FROM_ADDRESS(address * 8, volume);

src/add-ons/kernel/file_systems/xfs/Node.cpp

427

uint32 offset = BLOCKOFFSET_FROM_ADDRESS(address * 8, fInode);

src/add-ons/kernel/file_systems/xfs/Node.h

108

uint32 GetOffsetFromAddress(uint32 address);

src/add-ons/kernel/generic/ata_adapter/ata_adapter.cpp

253

prd->address = B_HOST_TO_LENDIAN_INT32((uint32)pci->ram_address(

src/add-ons/kernel/generic/ata_adapter/ata_adapter.cpp

254

device, sgList->address));

src/add-ons/kernel/generic/ata_adapter/ata_adapter.cpp

261

sgList->address, sgList->size,

src/add-ons/kernel/generic/ata_adapter/ata_adapter.cpp

262

prd->address, prd->count, prd->EOT);

src/add-ons/kernel/generic/ata_adapter/ata_adapter.cpp

264

prd->address, prd->count, prd->EOT);

src/add-ons/kernel/generic/ata_adapter/ata_adapter.cpp

424

channel->prdt_phys = pe[0].address;

src/add-ons/kernel/generic/bios/bios.cpp

189

void* address

src/add-ons/kernel/generic/bios/bios.cpp

193

return address;

src/add-ons/kernel/generic/bios/bios.cpp

248

void* address = (void*)(state->mapped_address + kEBDABase);

src/add-ons/kernel/generic/bios/bios.cpp

249

status = vm_memcpy_from_physical(address, kEBDABase, kEBDASize, false);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

1103

net_interface_address* address, int32 option,

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

1125

arp_remove_local_entry(protocol, oldAddress, address);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

1133

return protocol->next->module->change_address(protocol->next, address,

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

1149

arp_join_multicast(net_datalink_protocol *protocol, const sockaddr *address)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

1151

if (address->sa_family != AF_INET)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

1155

ipv4_to_ether_multicast(&multicastAddress, (const sockaddr_in *)address);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

1163

arp_leave_multicast(net_datalink_protocol *protocol, const sockaddr *address)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

1165

if (address->sa_family != AF_INET)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

1169

ipv4_to_ether_multicast(&multicastAddress, (const sockaddr_in *)address);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

161

mac_to_string(uint8* address)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

165

address[0], address[1], address[2], address[3], address[4], address[5]);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

171

inet_to_string(in_addr_t address)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

175

unsigned int hostAddress = ntohl(address);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

252

arp_entry::Lookup(in_addr_t address)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

254

return sCache->Lookup(address);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

449

sockaddr_dl address;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

450

address.sdl_len = sizeof(sockaddr_dl);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

451

address.sdl_family = AF_LINK;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

452

address.sdl_type = IFT_ETHER;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

453

address.sdl_e_type = htons(ETHER_TYPE_IP);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

454

address.sdl_nlen = 0;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

455

address.sdl_slen = 0;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

456

address.sdl_alen = interface->device->address.length;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

457

memcpy(LLADDR(&address), interface->device->address.data, address.sdl_alen);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

459

memcpy(&protocol->hardware_address, &address, sizeof(sockaddr_dl));

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

463

status_t status = arp_update_entry(inetAddress, &address,

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

498

net_interface_address* address = NULL;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

500

&address)) {

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

501

if (address == updateLocalAddress || address->local == NULL

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

502

|| address->local->sa_family != AF_INET)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

506

= ((sockaddr_in*)address->local)->sin_addr.s_addr;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

526

net_interface_address* address = NULL;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

528

&address)) {

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

529

if (address->local == NULL || address->local->sa_family != AF_INET)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

532

arp_remove_local_entry(protocol, address->local);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

550

net_interface_address* address = NULL;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

552

&address)) {

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

553

if (address->local == NULL || address->local->sa_family != AF_INET)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

556

if (arp_set_local_entry(protocol, address->local) == B_OK) {

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

770

arp_start_resolve(arp_protocol* protocol, in_addr_t address, arp_entry** _entry)

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

775

arp_entry *entry = arp_entry::Add(address, NULL, 0);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

805

memcpy(header.hardware_sender, device->address.data, ETHER_ADDRESS_LENGTH);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

808

header.protocol_target = address;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

821

memcpy(source.sdl_data, device->address.data, ETHER_ADDRESS_LENGTH);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

863

return arp_update_entry(control.address, &hardwareAddress,

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

870

arp_entry *entry = arp_entry::Lookup(control.address);

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

896

control.address = entry->protocol_address;

src/add-ons/kernel/network/datalink_protocols/arp/arp.cpp

909

arp_entry *entry = arp_entry::Lookup(control.address);

src/add-ons/kernel/network/datalink_protocols/ethernet_frame/ethernet_frame.cpp

185

net_interface_address* address, int32 option,

src/add-ons/kernel/network/datalink_protocols/ethernet_frame/ethernet_frame.cpp

188

return protocol->next->module->change_address(protocol->next, address,

src/add-ons/kernel/network/datalink_protocols/ethernet_frame/ethernet_frame.cpp

204

const sockaddr* address)

src/add-ons/kernel/network/datalink_protocols/ethernet_frame/ethernet_frame.cpp

206

return protocol->next->module->join_multicast(protocol->next, address);

src/add-ons/kernel/network/datalink_protocols/ethernet_frame/ethernet_frame.cpp

212

const sockaddr* address)

src/add-ons/kernel/network/datalink_protocols/ethernet_frame/ethernet_frame.cpp

214

return protocol->next->module->leave_multicast(protocol->next, address);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

1100

net_interface_address* address, int32 option,

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

1129

sDatalinkModule->add_route(address->domain, &route);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

1147

sDatalinkModule->remove_route(address->domain, &route);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

1156

return protocol->next->module->change_address(protocol->next, address,

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

1172

const sockaddr* address)

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

1174

if (address->sa_family != AF_INET6)

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

1178

ipv6_to_ether_multicast(&multicastAddress, (const sockaddr_in6*)address);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

1187

const sockaddr* address)

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

1189

if (address->sa_family != AF_INET6)

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

1193

ipv6_to_ether_multicast(&multicastAddress, (const sockaddr_in6*)address);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

203

ipv6_to_sockaddr(sockaddr_in6* target, const in6_addr& address)

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

210

memcpy(target->sin6_addr.s6_addr, address.s6_addr, sizeof(in6_addr));

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

216

ipv6_to_solicited_multicast(sockaddr_in6* target, const in6_addr& address)

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

234

memcpy(&targetIPv6[13], &address.s6_addr[13], 3);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

282

ndp_entry::Lookup(const in6_addr& address)

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

284

return sCache->Lookup(address);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

540

net_interface_address* address = NULL;

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

542

&address)) {

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

543

if (address->local == NULL || address->local->sa_family != AF_INET6)

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

547

&((sockaddr_in6*)address->local)->sin6_addr, sizeof(in6_addr));

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

562

net_interface_address* address = NULL;

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

564

&address)) {

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

565

if (address->local == NULL || address->local->sa_family != AF_INET6)

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

568

ndp_remove_local_entry(protocol, address->local, false);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

608

sockaddr_dl address;

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

609

address.sdl_len = sizeof(sockaddr_dl);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

610

address.sdl_family = AF_LINK;

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

611

address.sdl_type = IFT_ETHER;

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

612

address.sdl_e_type = htons(ETHER_TYPE_IPV6);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

613

address.sdl_nlen = 0;

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

614

address.sdl_slen = 0;

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

615

address.sdl_alen = interface->device->address.length;

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

616

memcpy(LLADDR(&address), interface->device->address.data, address.sdl_alen);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

618

memcpy(&protocol->hardware_address, &address, sizeof(sockaddr_dl));

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

622

status_t status = ndp_update_entry(inetAddress, &address,

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

642

net_interface_address* address = NULL;

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

644

&address)) {

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

645

if (address->local == NULL || address->local->sa_family != AF_INET6)

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

648

if (ndp_set_local_entry(protocol, address->local) == B_OK) {

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

898

ndp_start_resolve(ipv6_datalink_protocol* protocol, const in6_addr& address,

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

904

ndp_entry* entry = ndp_entry::Add(address, NULL, 0);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

933

ipv6_to_solicited_multicast(destination, address);

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

943

memcpy(&header->target_address, &address, sizeof(in6_addr));

src/add-ons/kernel/network/datalink_protocols/ipv6_datagram/ipv6_datagram.cpp

946

memcpy(&header->link_address, device->address.data, ETHER_ADDRESS_LENGTH);

src/add-ons/kernel/network/datalink_protocols/loopback_frame/loopback_frame.cpp

130

net_interface_address* address, int32 option,

src/add-ons/kernel/network/datalink_protocols/loopback_frame/loopback_frame.cpp

133

return protocol->next->module->change_address(protocol->next, address,

src/add-ons/kernel/network/datalink_protocols/loopback_frame/loopback_frame.cpp

149

const sockaddr* address)

src/add-ons/kernel/network/datalink_protocols/loopback_frame/loopback_frame.cpp

151

return protocol->next->module->join_multicast(protocol->next, address);

src/add-ons/kernel/network/datalink_protocols/loopback_frame/loopback_frame.cpp

157

const sockaddr* address)

src/add-ons/kernel/network/datalink_protocols/loopback_frame/loopback_frame.cpp

159

return protocol->next->module->leave_multicast(protocol->next, address);

src/add-ons/kernel/network/devices/ethernet/ethernet.cpp

188

if (ioctl(device->fd, ETHER_GETADDR, device->address.data, ETHER_ADDRESS_LENGTH) < 0)

src/add-ons/kernel/network/devices/ethernet/ethernet.cpp

231

device->address.length = ETHER_ADDRESS_LENGTH;

src/add-ons/kernel/network/devices/ethernet/ethernet.cpp

421

const sockaddr_dl *address = (const sockaddr_dl *)_address;

src/add-ons/kernel/network/devices/ethernet/ethernet.cpp

422

if (address->sdl_type != IFT_ETHER)

src/add-ons/kernel/network/devices/ethernet/ethernet.cpp

425

if (ioctl(device->fd, ETHER_ADDMULTI, LLADDR(address), 6) < 0)

src/add-ons/kernel/network/devices/ethernet/ethernet.cpp

439

const sockaddr_dl *address = (const sockaddr_dl *)_address;

src/add-ons/kernel/network/devices/ethernet/ethernet.cpp

440

if (address->sdl_type != IFT_ETHER)

src/add-ons/kernel/network/devices/ethernet/ethernet.cpp

443

if (ioctl(device->fd, ETHER_REMMULTI, LLADDR(address), 6) < 0)

src/add-ons/kernel/network/devices/loopback/loopback.cpp

143

loopback_add_multicast(net_device *device, const sockaddr *address)

src/add-ons/kernel/network/devices/loopback/loopback.cpp

150

loopback_remove_multicast(net_device *device, const sockaddr *address)

src/add-ons/kernel/network/devices/tunnel/tunnel.cpp

326

device->address.data[i] = secure_get_random<uint8>();

src/add-ons/kernel/network/devices/tunnel/tunnel.cpp

327

device->address.data[0] &= 0xFE; // multicast

src/add-ons/kernel/network/devices/tunnel/tunnel.cpp

328

device->address.data[0] |= 0x02; // local assignment

src/add-ons/kernel/network/devices/tunnel/tunnel.cpp

330

device->address.length = ETHER_ADDRESS_LENGTH;

src/add-ons/kernel/network/devices/tunnel/tunnel.cpp

477

tunnel_add_multicast(net_device* device, const sockaddr* address)

src/add-ons/kernel/network/devices/tunnel/tunnel.cpp

484

tunnel_remove_multicast(net_device* device, const sockaddr* address)

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1071

if (fLocalRequests.address == INADDR_ANY

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1073

fLocalConfiguration.address = *requestedAddress;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1366

if (fLocalRequests.address == INADDR_ANY)

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1367

ipItem.address = (fLocalConfiguration.address);

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1369

ipItem.address =(fLocalRequests.address);

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1373

fLocalConfiguration.address, fLocalRequests.address,

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1374

((ip_item*)request.ItemAt(0))->address);

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1379

ipItem.address = fLocalConfiguration.primaryDNS;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1387

ipItem.address = fLocalConfiguration.secondaryDNS;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1429

wishedAddress = &fPeerRequests.address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1430

configuredAddress = &fPeerConfiguration.address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

1468

fPeerConfiguration.address = fPeerRequests.address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

389

in_addr_t address = INADDR_ANY;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

396

address = inet_addr(requests->parameters[index].values[0]);

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

398

if (address == INADDR_NONE)

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

403

selectedRequests->address = address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

405

selectedRequests->netmask = address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

407

selectedRequests->primaryDNS = address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

412

selectedRequests->secondaryDNS = address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

467

if (fLocalRequests.address != INADDR_ANY)

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

468

memcpy(newAddr.sa_data + 2, &fLocalRequests.address, sizeof(in_addr_t));

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

469

else if (fLocalConfiguration.address == INADDR_ANY) {

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

473

memcpy(newAddr.sa_data + 2, &fLocalConfiguration.address, sizeof(in_addr_t));

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

519

if (fPeerRequests.address != INADDR_ANY)

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

520

memcpy(addrGateway.sa_data + 2, &fPeerRequests.address,

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

522

else if (fPeerConfiguration.address == INADDR_ANY) {

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

527

memcpy(addrGateway.sa_data + 2, &fPeerConfiguration.address,

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

758

wishedAddress = &fPeerRequests.address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

799

ipItem.address = *wishedAddress;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

814

if (!request.ItemWithType(IPCP_ADDRESS) && fPeerRequests.address == INADDR_ANY) {

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

819

ipItem.address = INADDR_ANY;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

959

wishedAddress = &fLocalRequests.address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

960

configuredAddress = &fLocalConfiguration.address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.cpp

998

fLocalConfiguration.address = fLocalRequests.address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.h

26

in_addr_t address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.h

41

in_addr_t address;

src/add-ons/kernel/network/ppp/ipcp/Protocol.h

51

in_addr_t address;

src/add-ons/kernel/network/ppp/ppp/ppp.cpp

277

const sockaddr_dl *address = (const sockaddr_dl *)_address;

src/add-ons/kernel/network/ppp/ppp/ppp.cpp

278

if (address->sdl_type != IFT_ETHER)

src/add-ons/kernel/network/ppp/ppp/ppp.cpp

293

const sockaddr_dl *address = (const sockaddr_dl *)_address;

src/add-ons/kernel/network/ppp/ppp/ppp.cpp

294

if (address->sdl_type != IFT_ETHER)

src/add-ons/kernel/network/ppp/ppp_frame/ppp_frame.cpp

118

net_interface_address* address, int32 option,

src/add-ons/kernel/network/ppp/ppp_frame/ppp_frame.cpp

122

return protocol->next->module->change_address(protocol->next, address,

src/add-ons/kernel/network/ppp/ppp_frame/ppp_frame.cpp

208

const sockaddr* address)

src/add-ons/kernel/network/ppp/ppp_frame/ppp_frame.cpp

211

return protocol->next->module->join_multicast(protocol->next, address);

src/add-ons/kernel/network/ppp/ppp_frame/ppp_frame.cpp

217

const sockaddr* address)

src/add-ons/kernel/network/ppp/ppp_frame/ppp_frame.cpp

220

return protocol->next->module->leave_multicast(protocol->next, address);

src/add-ons/kernel/network/ppp/pppoe/PPPoEDevice.cpp

139

memcpy(fEtherAddr, fEthernetIfnet->address.data, ETHER_ADDRESS_LENGTH);

src/add-ons/kernel/network/protocols/icmp/icmp.cpp

125

fill_sockaddr_in(sockaddr_in* target, in_addr_t address)

src/add-ons/kernel/network/protocols/icmp/icmp.cpp

130

target->sin_addr.s_addr = address;

src/add-ons/kernel/network/protocols/icmp/icmp.cpp

355

icmp_connect(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/icmp/icmp.cpp

396

icmp_bind(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/icmp/icmp.cpp

403

icmp_unbind(net_protocol* protocol, struct sockaddr* address)

src/add-ons/kernel/network/protocols/icmp/icmp.cpp

469

icmp_get_mtu(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/icmp/icmp.cpp

471

return protocol->next->module->get_mtu(protocol->next, address);

src/add-ons/kernel/network/protocols/icmp6/icmp6.cpp

101

icmp6_connect(net_protocol *protocol, const struct sockaddr *address)

src/add-ons/kernel/network/protocols/icmp6/icmp6.cpp

142

icmp6_bind(net_protocol *protocol, const struct sockaddr *address)

src/add-ons/kernel/network/protocols/icmp6/icmp6.cpp

149

icmp6_unbind(net_protocol *protocol, struct sockaddr *address)

src/add-ons/kernel/network/protocols/icmp6/icmp6.cpp

214

icmp6_get_mtu(net_protocol *protocol, const struct sockaddr *address)

src/add-ons/kernel/network/protocols/icmp6/icmp6.cpp

216

return protocol->next->module->get_mtu(protocol->next, address);

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1003

fill_sockaddr_in(&groupAddr, address ? address->s_addr : INADDR_ANY));

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1020

sockaddr_in address;

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1022

fill_sockaddr_in(&address, interfaceAddr->s_addr));

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1154

ipv4_connect(net_protocol* _protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1160

if (address->sa_len != sizeof(struct sockaddr_in))

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1162

if (address->sa_family != AF_INET)

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1165

memcpy(&protocol->socket->peer, address, sizeof(struct sockaddr_in));

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1222

struct sockaddr_in* address =

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1224

if (address == NULL)

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1225

address = &defaultAddress;

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1226

if (user_memcpy(value, &address->sin_addr, sizeof(struct in_addr))

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1335

struct sockaddr_in* address = new (std::nothrow) sockaddr_in;

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1336

if (address == NULL)

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1342

delete address;

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1345

fill_sockaddr_in(address, sin_addr.s_addr);

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1348

if (address->sin_addr.s_addr == htonl(INADDR_ANY)) {

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1349

delete address;

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1357

(sockaddr*)address);

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1359

delete address;

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1364

protocol->multicast_address = (struct sockaddr*)address;

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1450

ipv4_bind(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1452

if (address->sa_family != AF_INET)

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1456

if (((sockaddr_in*)address)->sin_addr.s_addr == INADDR_ANY

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1457

|| IN_MULTICAST(ntohl(((sockaddr_in*)address)->sin_addr.s_addr))

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1458

|| sDatalinkModule->is_local_address(sDomain, address, NULL, NULL)) {

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1459

memcpy(&protocol->socket->address, address, sizeof(struct sockaddr_in));

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1460

protocol->socket->address.ss_len = sizeof(struct sockaddr_in);

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1472

ipv4_unbind(net_protocol* protocol, struct sockaddr* address)

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1602

net_interface_address* address =

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1604

if (address == NULL || (address->interface->flags & IFF_UP) == 0) {

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1605

sDatalinkModule->put_interface_address(address);

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1609

loopbackBuffer->interface_address = address;

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1663

net_interface_address* address = sDatalinkModule->get_interface_address(

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1665

if (address == NULL || (address->interface->flags & IFF_UP) == 0) {

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1666

sDatalinkModule->put_interface_address(address);

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1671

buffer->interface_address = address;

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1674

net_route* route = sDatalinkModule->get_route(sDomain, address->local);

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1727

ipv4_get_mtu(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

1729

net_route* route = sDatalinkModule->get_route(sDomain, address);

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

223

print_address(const in_addr* address, char* buf, size_t bufLen)

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

225

unsigned int addr = ntohl(address->s_addr);

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

787

fill_sockaddr_in(sockaddr_in* target, in_addr_t address)

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

792

target->sin_addr.s_addr = address;

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

998

get_multicast_interface(ipv4_protocol* protocol, const in_addr* address)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

101

ipv4_is_empty_address(const sockaddr *address, bool checkPort)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

103

if (address == NULL || address->sa_len == 0

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

104

|| address->sa_family == AF_UNSPEC)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

107

return ((sockaddr_in *)address)->sin_addr.s_addr == 0

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

108

&& (!checkPort || ((sockaddr_in *)address)->sin_port == 0);

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

117

ipv4_is_same_family(const sockaddr *address)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

119

if (address == NULL)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

122

return address->sa_family == AF_INET;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

273

const sockaddr_in *address = (const sockaddr_in *)_address;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

278

if (address == NULL)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

281

unsigned int addr = ntohl(address->sin_addr.s_addr);

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

286

addr & 0xff, ntohs(address->sin_port));

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

318

ipv4_get_port(const sockaddr *address)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

320

if (address == NULL || address->sa_len == 0)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

323

return ((sockaddr_in *)address)->sin_port;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

332

ipv4_set_port(sockaddr *address, uint16 port)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

334

if (address == NULL || address->sa_len == 0)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

337

((sockaddr_in *)address)->sin_port = port;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

349

ipv4_set_to(sockaddr *address, const sockaddr *from)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

351

if (address == NULL || from == NULL || from->sa_len == 0)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

357

memcpy(address, from, sizeof(sockaddr_in));

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

358

address->sa_len = sizeof(sockaddr_in);

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

372

sockaddr_in *address = (sockaddr_in *)_address;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

375

if (address == NULL || from == NULL || from->sin_len == 0)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

381

address->sin_family = AF_INET;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

382

address->sin_len = sizeof(sockaddr_in);

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

384

if (address->sin_port == 0)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

385

address->sin_port = from->sin_port;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

387

if (address->sin_addr.s_addr == INADDR_ANY)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

388

address->sin_addr.s_addr = from->sin_addr.s_addr;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

399

ipv4_set_to_empty_address(sockaddr *address)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

401

if (address == NULL)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

404

memset(address, 0, sizeof(sockaddr_in));

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

405

address->sa_len = sizeof(sockaddr_in);

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

406

address->sa_family = AF_INET;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

417

const sockaddr_in *address = (const sockaddr_in *)_address;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

420

if (address == NULL || (defaultMask == NULL && defaultBroadcast == NULL))

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

426

net = ntohl(address->sin_addr.s_addr);

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

451

defaultBroadcast->sin_addr.s_addr = address->sin_addr.s_addr | ~net;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

464

const sockaddr_in* address = (const sockaddr_in*)_address;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

465

if (address == NULL || address->sin_len == 0)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

469

return address->sin_port ^ address->sin_addr.s_addr;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

471

return address->sin_addr.s_addr;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

502

ipv4_checksum_address(Checksum *checksum, const sockaddr *address)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

504

if (checksum == NULL || address == NULL || address->sa_len == 0)

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

507

(*checksum) << (uint32)((sockaddr_in *)address)->sin_addr.s_addr;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

515

sockaddr_in *address = (sockaddr_in *)_address;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

516

memset(address, 0, sizeof(sockaddr_in));

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

517

address->sin_len = sizeof(sockaddr_in);

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

518

address->sin_family = AF_INET;

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

519

address->sin_addr.s_addr = htonl(INADDR_LOOPBACK);

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

78

ipv4_mask_address(const sockaddr *address, const sockaddr *mask,

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

81

if (address == NULL || address->sa_len == 0 || result == NULL

src/add-ons/kernel/network/protocols/ipv4/ipv4_address.cpp

85

memcpy(result, address, sizeof(sockaddr_in));

src/add-ons/kernel/network/protocols/ipv4/multicast.cpp

33

const AddressType &address, net_interface *interface)

src/add-ons/kernel/network/protocols/ipv4/multicast.cpp

36

fMulticastAddress(address),

src/add-ons/kernel/network/protocols/ipv4/multicast.h

103

AddressType &Next() { return fBaseIterator.Next()->address; }

src/add-ons/kernel/network/protocols/ipv4/multicast.h

112

ContainedAddress *_Get(const AddressType &address) const

src/add-ons/kernel/network/protocols/ipv4/multicast.h

117

if (container->address == address)

src/add-ons/kernel/network/protocols/ipv4/multicast.h

141

MulticastGroupInterface(Filter *parent, const AddressType &address,

src/add-ons/kernel/network/protocols/ipv4/multicast.h

41

static size_t HashAddress(const in_addr &address)

src/add-ons/kernel/network/protocols/ipv4/multicast.h

42

{ return address.s_addr; }

src/add-ons/kernel/network/protocols/ipv4/multicast.h

48

AddressType address;

src/add-ons/kernel/network/protocols/ipv4/multicast.h

59

status_t Add(const AddressType &address)

src/add-ons/kernel/network/protocols/ipv4/multicast.h

61

if (Has(address))

src/add-ons/kernel/network/protocols/ipv4/multicast.h

68

container->address = address;

src/add-ons/kernel/network/protocols/ipv4/multicast.h

74

void Remove(const AddressType &address)

src/add-ons/kernel/network/protocols/ipv4/multicast.h

76

ContainedAddress *container = _Get(address);

src/add-ons/kernel/network/protocols/ipv4/multicast.h

84

bool Has(const AddressType &address) const

src/add-ons/kernel/network/protocols/ipv4/multicast.h

86

return _Get(address) != NULL;

src/add-ons/kernel/network/protocols/ipv4/multicast.h

94

Remove(fAddresses.Head()->address);

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1044

ipv6_connect(net_protocol* _protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1050

if (address->sa_len != sizeof(struct sockaddr_in6))

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1052

if (address->sa_family != AF_INET6)

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1055

memcpy(&protocol->socket->peer, address, sizeof(struct sockaddr_in6));

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1131

struct sockaddr_in6* address = new (std::nothrow) sockaddr_in6;

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1132

if (address == NULL)

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1135

if (user_memcpy(&address->sin6_addr, value, sizeof(in6_addr))

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1137

delete address;

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1142

if (IN6_IS_ADDR_UNSPECIFIED(&address->sin6_addr)) {

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1143

delete address;

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1151

(sockaddr*)address);

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1153

delete address;

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1158

protocol->multicast_address = (struct sockaddr*)address;

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1208

const sockaddr_in6* address = (const sockaddr_in6*)_address;

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1211

if (IN6_IS_ADDR_UNSPECIFIED(&address->sin6_addr)

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1212

|| IN6_IS_ADDR_MULTICAST(&address->sin6_addr)

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1214

memcpy(&protocol->socket->address, address, sizeof(sockaddr_in6));

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1215

protocol->socket->address.ss_len = sizeof(sockaddr_in6);

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1227

ipv6_unbind(net_protocol* protocol, struct sockaddr* address)

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1371

net_interface_address* address = sDatalinkModule->get_interface_address(

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1373

if (address == NULL || (address->interface->flags & IFF_UP) == 0) {

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1374

sDatalinkModule->put_interface_address(address);

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1379

buffer->interface_address = address;

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1382

net_route* route = sDatalinkModule->get_route(sDomain, address->local);

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1436

ipv6_get_mtu(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

1438

net_route* route = sDatalinkModule->get_route(sDomain, address);

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

807

fill_sockaddr_in6(sockaddr_in6* target, const in6_addr &address)

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

813

memcpy(target->sin6_addr.s6_addr, address.s6_addr, sizeof(in6_addr));

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

100

memcpy(result, address, sizeof(sockaddr_in6));

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

120

const sockaddr_in6 *address = (const sockaddr_in6 *)_address;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

121

if (checkPort && address->sin6_port != 0)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

124

return IN6_IS_ADDR_UNSPECIFIED(&address->sin6_addr);

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

133

ipv6_is_same_family(const sockaddr *address)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

135

if (address == NULL)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

138

return address->sa_family == AF_INET6;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

31

ipv6_mask_adress_inplace(sockaddr *address, const sockaddr *mask)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

310

const sockaddr_in6 *address = (const sockaddr_in6 *)_address;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

315

if (address == NULL) {

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

326

if (!ip6_sprintf(&address->sin6_addr, buffer, bufferSize))

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

33

in6_addr &i6addr = ((sockaddr_in6 *)address)->sin6_addr;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

331

snprintf(port, sizeof(port), "]:%d", ntohs(address->sin6_port));

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

363

ipv6_get_port(const sockaddr *address)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

365

if (address == NULL || address->sa_len == 0)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

368

return ((sockaddr_in6 *)address)->sin6_port;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

377

ipv6_set_port(sockaddr *address, uint16 port)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

379

if (address == NULL || address->sa_len == 0)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

382

((sockaddr_in6 *)address)->sin6_port = port;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

394

ipv6_set_to(sockaddr *address, const sockaddr *from)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

396

if (address == NULL || from == NULL || from->sa_len == 0)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

402

memcpy(address, from, sizeof(sockaddr_in6));

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

403

address->sa_len = sizeof(sockaddr_in6);

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

417

sockaddr_in6 *address = (sockaddr_in6 *)_address;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

420

if (address == NULL || from == NULL || from->sin6_len == 0)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

426

address->sin6_family = AF_INET6;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

427

address->sin6_len = sizeof(sockaddr_in6);

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

429

if (address->sin6_port == 0)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

430

address->sin6_port = from->sin6_port;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

432

if (IN6_IS_ADDR_UNSPECIFIED(&address->sin6_addr)) {

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

433

memcpy(address->sin6_addr.s6_addr, from->sin6_addr.s6_addr,

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

446

ipv6_set_to_empty_address(sockaddr *address)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

448

if (address == NULL)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

451

memset(address, 0, sizeof(sockaddr_in6));

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

452

address->sa_len = sizeof(sockaddr_in6);

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

453

address->sa_family = AF_INET6;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

463

sockaddr_in6 *address = (sockaddr_in6 *)_address;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

466

if (address == NULL || defaultMask == NULL)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

490

const sockaddr_in6* address = (const sockaddr_in6*)_address;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

491

if (address == NULL || address->sin6_len == 0)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

495

uint32 port = includePort ? address->sin6_port : 0;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

497

uint32 result = jenkins_hashword((const uint32*)&address->sin6_addr,

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

521

ipv6_checksum_address(Checksum *checksum, const sockaddr *address)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

523

if (checksum == NULL || address == NULL || address->sa_len == 0)

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

526

in6_addr &a = ((sockaddr_in6 *)address)->sin6_addr;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

537

sockaddr_in6 *address = (sockaddr_in6 *)_address;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

538

memset(address, 0, sizeof(sockaddr_in6));

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

539

address->sin6_len = sizeof(sockaddr_in6);

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

540

address->sin6_family = AF_INET6;

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

541

memcpy(&address->sin6_addr, &in6addr_loopback, sizeof(in6_addr));

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

93

ipv6_mask_address(const sockaddr *address, const sockaddr *mask,

src/add-ons/kernel/network/protocols/ipv6/ipv6_address.cpp

96

if (address == NULL || address->sa_len == 0 || result == NULL

src/add-ons/kernel/network/protocols/ipv6/multicast.cpp

25

const AddressType &address, net_interface *interface)

src/add-ons/kernel/network/protocols/ipv6/multicast.cpp

26

: fParent(parent), fMulticastAddress(address), fInterface(interface)

src/add-ons/kernel/network/protocols/ipv6/multicast.h

106

AddressType &Next() { return fBaseIterator.Next()->address; }

src/add-ons/kernel/network/protocols/ipv6/multicast.h

115

ContainedAddress *_Get(const AddressType &address) const

src/add-ons/kernel/network/protocols/ipv6/multicast.h

120

if (container->address == address)

src/add-ons/kernel/network/protocols/ipv6/multicast.h

144

MulticastGroupInterface(Filter *parent, const AddressType &address,

src/add-ons/kernel/network/protocols/ipv6/multicast.h

42

static size_t HashAddress(const in6_addr &address)

src/add-ons/kernel/network/protocols/ipv6/multicast.h

43

{ return jenkins_hashword((const uint32*)&address,

src/add-ons/kernel/network/protocols/ipv6/multicast.h

51

AddressType address;

src/add-ons/kernel/network/protocols/ipv6/multicast.h

62

status_t Add(const AddressType &address)

src/add-ons/kernel/network/protocols/ipv6/multicast.h

64

if (Has(address))

src/add-ons/kernel/network/protocols/ipv6/multicast.h

71

container->address = address;

src/add-ons/kernel/network/protocols/ipv6/multicast.h

77

void Remove(const AddressType &address)

src/add-ons/kernel/network/protocols/ipv6/multicast.h

79

ContainedAddress *container = _Get(address);

src/add-ons/kernel/network/protocols/ipv6/multicast.h

87

bool Has(const AddressType &address) const

src/add-ons/kernel/network/protocols/ipv6/multicast.h

89

return _Get(address) != NULL;

src/add-ons/kernel/network/protocols/ipv6/multicast.h

97

Remove(fAddresses.Head()->address);

src/add-ons/kernel/network/protocols/l2cap/L2capEndpoint.cpp

202

const sockaddr_l2cap* address

src/add-ons/kernel/network/protocols/l2cap/L2capEndpoint.cpp

208

if (address->l2cap_len != sizeof(struct sockaddr_l2cap))

src/add-ons/kernel/network/protocols/l2cap/L2capEndpoint.cpp

217

status_t status = gL2capEndpointManager.Bind(this, *address);

src/add-ons/kernel/network/protocols/l2cap/L2capEndpoint.cpp

270

const sockaddr_l2cap* address

src/add-ons/kernel/network/protocols/l2cap/L2capEndpoint.cpp

274

if (address->l2cap_len != sizeof(struct sockaddr_l2cap))

src/add-ons/kernel/network/protocols/l2cap/L2capEndpoint.cpp

304

hci_id hid = btCoreData->RouteConnection(address->l2cap_bdaddr);

src/add-ons/kernel/network/protocols/l2cap/L2capEndpoint.cpp

309

bdaddrUtils::ToString(address->l2cap_bdaddr).String());

src/add-ons/kernel/network/protocols/l2cap/L2capEndpoint.cpp

312

address->l2cap_bdaddr, hid);

src/add-ons/kernel/network/protocols/l2cap/L2capEndpoint.cpp

329

address->l2cap_psm, fChannelID);

src/add-ons/kernel/network/protocols/l2cap/L2capEndpoint.h

38

status_t Connect(const struct sockaddr* address);

src/add-ons/kernel/network/protocols/l2cap/L2capEndpointManager.cpp

32

L2capEndpointManager::Bind(L2capEndpoint* endpoint, const sockaddr_l2cap& address)

src/add-ons/kernel/network/protocols/l2cap/L2capEndpointManager.cpp

35

if (!Bluetooth::bdaddrUtils::Compare(address.l2cap_bdaddr, BDADDR_ANY))

src/add-ons/kernel/network/protocols/l2cap/L2capEndpointManager.cpp

39

if ((address.l2cap_psm & 1) == 0)

src/add-ons/kernel/network/protocols/l2cap/L2capEndpointManager.cpp

44

if (fBoundEndpoints.Find(address.l2cap_psm) != NULL)

src/add-ons/kernel/network/protocols/l2cap/L2capEndpointManager.cpp

47

memcpy(*endpoint->LocalAddress(), &address, sizeof(struct sockaddr_l2cap));

src/add-ons/kernel/network/protocols/l2cap/L2capEndpointManager.h

18

status_t Bind(L2capEndpoint* endpoint, const sockaddr_l2cap& address);

src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp

129

l2cap_bind(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp

131

return ((L2capEndpoint*)protocol)->Bind(address);

src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp

136

l2cap_unbind(net_protocol* protocol, struct sockaddr* address)

src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp

204

l2cap_get_mtu(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp

207

return protocol->next->module->get_mtu(protocol->next, address);

src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp

86

l2cap_connect(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/l2cap/l2cap.cpp

88

return ((L2capEndpoint*)protocol)->Connect(address);

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

158

const sockaddr_l2cap *address = (const sockaddr_l2cap *)_address;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

159

if (address == NULL) {

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

162

bdaddr_t addr = address->l2cap_bdaddr;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

167

address->l2cap_psm);

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

197

l2cap_get_port(const sockaddr *address)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

199

if (address == NULL)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

202

return ((sockaddr_l2cap *)address)->l2cap_psm;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

207

l2cap_set_port(sockaddr *address, uint16 port)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

209

if (address == NULL)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

212

((sockaddr_l2cap *)address)->l2cap_psm = port;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

218

l2cap_set_to(sockaddr *address, const sockaddr *from)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

220

if (address == NULL || from == NULL)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

226

memcpy(address, from, sizeof(sockaddr_l2cap));

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

232

l2cap_mask_address(const sockaddr *address, const sockaddr *mask,

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

236

return l2cap_set_to(result, address);

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

243

sockaddr_l2cap *address = (sockaddr_l2cap *)_address;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

246

if (address == NULL || from == NULL)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

252

address->l2cap_family = AF_BLUETOOTH;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

253

address->l2cap_len = sizeof(sockaddr_l2cap);

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

255

if (bdaddrs_equal(address->l2cap_bdaddr, BDADDR_NULL))

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

256

address->l2cap_bdaddr = from->l2cap_bdaddr;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

258

if (address->l2cap_psm == 0)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

259

address->l2cap_psm = from->l2cap_psm;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

266

l2cap_set_to_empty_address(sockaddr *address)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

268

if (address == NULL)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

271

memset(address, 0, sizeof(sockaddr_l2cap));

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

272

address->sa_len = sizeof(sockaddr_l2cap);

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

273

address->sa_family = AF_BLUETOOTH;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

298

const sockaddr_l2cap* address = (const sockaddr_l2cap*)_address;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

299

if (address == NULL || address->l2cap_len == 0)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

303

for (size_t i = 0; i < sizeof(address->l2cap_bdaddr.b); i++)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

304

hash += address->l2cap_bdaddr.b[i] << (i * 2);

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

307

hash += address->l2cap_psm;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

321

l2cap_checksum_address(struct Checksum *checksum, const sockaddr *address)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

323

if (checksum == NULL || address == NULL)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

327

(*checksum) << ((sockaddr_l2cap*)address)->l2cap_bdaddr.b[i];

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

67

const sockaddr_l2cap *address = (const sockaddr_l2cap *)_address;

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

69

return bdaddrs_equal(address->l2cap_bdaddr, BDADDR_NULL)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

70

&& (!checkPort || address->l2cap_psm == 0);

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

75

l2cap_is_same_family(const sockaddr *address)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

77

if (address == NULL)

src/add-ons/kernel/network/protocols/l2cap/l2cap_address.cpp

80

return address->sa_family == AF_BLUETOOTH;

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

380

EndpointManager::Bind(TCPEndpoint* endpoint, const sockaddr* address)

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

383

if (!AddressModule()->is_same_family(address))

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

388

if (AddressModule()->get_port(address) == 0)

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

389

return _BindToEphemeral(endpoint, address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

39

Bind(TCPEndpoint* endpoint, ConstSocketAddress& address, bool ephemeral)

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

391

return _BindToAddress(locker, endpoint, address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

396

EndpointManager::BindChild(TCPEndpoint* endpoint, const sockaddr* address)

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

399

return _Bind(endpoint, address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

408

ConstSocketAddress address(AddressModule(), _address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

409

uint16 port = address.Port();

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

412

T(Bind(endpoint, address, false));

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

429

|| address.EqualTo(*user->LocalAddress(), false)) {

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

44

address.AsString(fAddress, sizeof(fAddress), true);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

460

return _Bind(endpoint, *address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

467

const sockaddr* address)

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

48

Bind(TCPEndpoint* endpoint, SocketAddress& address, bool ephemeral)

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

489

newAddress.SetTo(address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

510

EndpointManager::_Bind(TCPEndpoint* endpoint, const sockaddr* address)

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

514

status_t status = endpoint->next->module->bind(endpoint->next, address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

53

address.AsString(fAddress, sizeof(fAddress), true);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.h

102

const sockaddr* address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.h

104

TCPEndpoint* endpoint, const sockaddr* address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.h

106

const sockaddr* address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.h

84

const sockaddr* address);

src/add-ons/kernel/network/protocols/tcp/EndpointManager.h

86

const sockaddr* address);

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

2454

TCPEndpoint::_MaxSegmentSize(const sockaddr* address) const

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

2456

return next->module->get_mtu(next, address) - sizeof(tcp_header);

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

59

#define PrintAddress(address) \

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

60

AddressString(Domain(), address, true).Data()

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

612

TCPEndpoint::Connect(const sockaddr* address)

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

614

if (!AddressModule()->is_same_family(address))

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

619

TRACE("Connect() on address %s", PrintAddress(address));

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

642

if (AddressModule()->is_empty_address(address, false)) {

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

645

((sockaddr_in &)_address).sin_port = ((sockaddr_in *)address)->sin_port;

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

646

address = (sockaddr *)&_address;

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

649

status_t status = _PrepareSendPath(address);

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

734

TCPEndpoint::Bind(const sockaddr *address)

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

736

if (address == NULL)

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

741

TRACE("Bind() on address %s", PrintAddress(address));

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

747

return fManager->Bind(this, address);

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

752

TCPEndpoint::Unbind(struct sockaddr *address)

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.h

112

int _MaxSegmentSize(const struct sockaddr* address) const;

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.h

39

status_t Connect(const struct sockaddr* address);

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.h

41

status_t Bind(const sockaddr* address);

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.h

42

status_t Unbind(struct sockaddr* address);

src/add-ons/kernel/network/protocols/tcp/tcp.cpp

527

tcp_connect(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/tcp/tcp.cpp

529

return ((TCPEndpoint*)protocol)->Connect(address);

src/add-ons/kernel/network/protocols/tcp/tcp.cpp

601

tcp_bind(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/tcp/tcp.cpp

603

return ((TCPEndpoint*)protocol)->Bind(address);

src/add-ons/kernel/network/protocols/tcp/tcp.cpp

608

tcp_unbind(net_protocol* protocol, struct sockaddr* address)

src/add-ons/kernel/network/protocols/tcp/tcp.cpp

610

return ((TCPEndpoint*)protocol)->Unbind(address);

src/add-ons/kernel/network/protocols/tcp/tcp.cpp

674

tcp_get_mtu(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/protocols/tcp/tcp.cpp

676

return protocol->next->module->get_mtu(protocol->next, address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

1240

udp_connect(net_protocol *protocol, const struct sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

1242

return ((UdpEndpoint *)protocol)->Connect(address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

1281

udp_bind(net_protocol *protocol, const struct sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

1283

return ((UdpEndpoint *)protocol)->Bind(address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

1288

udp_unbind(net_protocol *protocol, struct sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

1290

return ((UdpEndpoint *)protocol)->Unbind(address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

1353

udp_get_mtu(net_protocol *protocol, const struct sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

1355

return protocol->next->module->get_mtu(protocol->next, address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

191

status_t BindEndpoint(UdpEndpoint *endpoint, const sockaddr *address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

192

status_t ConnectEndpoint(UdpEndpoint *endpoint, const sockaddr *address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

198

status_t _BindEndpoint(UdpEndpoint *endpoint, const sockaddr *address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

199

status_t _Bind(UdpEndpoint *endpoint, const sockaddr *address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

200

status_t _BindToEphemeral(UdpEndpoint *endpoint, const sockaddr *address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

201

status_t _FinishBind(UdpEndpoint *endpoint, const sockaddr *address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

336

const sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

338

if (!AddressModule()->is_same_family(address))

src/add-ons/kernel/network/protocols/udp/udp.cpp

346

return _BindEndpoint(endpoint, address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

352

const sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

361

if (address->sa_family == AF_UNSPEC) {

src/add-ons/kernel/network/protocols/udp/udp.cpp

367

if (!AddressModule()->is_same_family(address))

src/add-ons/kernel/network/protocols/udp/udp.cpp

372

if (AddressModule()->is_empty_address(address, false)) {

src/add-ons/kernel/network/protocols/udp/udp.cpp

376

= ((sockaddr_in *)address)->sin_port;

src/add-ons/kernel/network/protocols/udp/udp.cpp

377

address = (sockaddr *)&_address;

src/add-ons/kernel/network/protocols/udp/udp.cpp

380

status_t status = endpoint->PeerAddress().SetTo(address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

384

= gDatalinkModule->get_route(fDomain, address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

436

const sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

438

if (AddressModule()->get_port(address) == 0)

src/add-ons/kernel/network/protocols/udp/udp.cpp

439

return _BindToEphemeral(endpoint, address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

441

return _Bind(endpoint, address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

446

UdpDomainSupport::_Bind(UdpEndpoint *endpoint, const sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

455

address, true).Data());

src/add-ons/kernel/network/protocols/udp/udp.cpp

463

if (otherEndpoint->LocalAddress().EqualPorts(address)) {

src/add-ons/kernel/network/protocols/udp/udp.cpp

466

&& ((const sockaddr_in *)address)->sin_addr.s_addr == htonl(INADDR_BROADCAST)) {

src/add-ons/kernel/network/protocols/udp/udp.cpp

477

if (otherEndpoint->LocalAddress().EqualTo(address, false)

src/add-ons/kernel/network/protocols/udp/udp.cpp

484

return _FinishBind(endpoint, address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

490

const sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

493

status_t status = newAddress.SetTo(address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

508

UdpDomainSupport::_FinishBind(UdpEndpoint *endpoint, const sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

510

status_t status = endpoint->next->module->bind(endpoint->next, address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

969

UdpEndpoint::Bind(const sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

971

TRACE_EP("Bind(%s)", AddressString(Domain(), address, true).Data());

src/add-ons/kernel/network/protocols/udp/udp.cpp

972

return fManager->BindEndpoint(this, address);

src/add-ons/kernel/network/protocols/udp/udp.cpp

977

UdpEndpoint::Unbind(sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

985

UdpEndpoint::Connect(const sockaddr *address)

src/add-ons/kernel/network/protocols/udp/udp.cpp

987

TRACE_EP("Connect(%s)", AddressString(Domain(), address, true).Data());

src/add-ons/kernel/network/protocols/udp/udp.cpp

988

return fManager->ConnectEndpoint(this, address);

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

111

unix_is_empty_address(const sockaddr *address, bool checkPort)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

113

return address == NULL || address->sa_len == 0

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

114

|| address->sa_family == AF_UNSPEC

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

115

|| (address->sa_len >= kEmptyAddress.sun_len

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

116

&& memcmp(address, &kEmptyAddress, kEmptyAddress.sun_len) == 0);

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

121

unix_is_same_family(const sockaddr *address)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

123

if (address == NULL)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

126

return address->sa_family == AF_UNIX;

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

138

unix_check_mask(const sockaddr *address)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

151

sockaddr_un* address = (sockaddr_un*)_address;

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

153

if (address == NULL)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

155

else if (address->sun_path[0] != '\0')

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

156

strlcpy(buffer, address->sun_path, bufferSize);

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

157

else if (address->sun_path[1] != '\0')

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

158

snprintf(buffer, bufferSize, "<%.5s>", address->sun_path + 1);

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

167

unix_print_address(const sockaddr *address, char **_buffer, bool printPort)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

170

status_t error = unix_print_address_buffer(address, buffer, sizeof(buffer),

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

181

unix_get_port(const sockaddr *address)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

188

unix_set_port(sockaddr *address, uint16 port)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

195

unix_set_to(sockaddr *address, const sockaddr *from)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

197

if (address == NULL || from == NULL)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

203

memcpy(address, from, from->sa_len);

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

209

unix_set_to_empty_address(sockaddr *address)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

211

return unix_set_to(address, (sockaddr*)&kEmptyAddress);

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

216

unix_mask_address(const sockaddr *address, const sockaddr *mask,

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

220

return unix_set_to(result, address);

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

226

const sockaddr *address, const sockaddr *netmask)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

228

if (address == NULL)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

242

unix_update_to(sockaddr *address, const sockaddr *from)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

244

if (address == NULL || from == NULL)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

250

return unix_set_to(address, from);

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

257

sockaddr_un* address = (sockaddr_un*)_address;

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

258

if (address == NULL)

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

261

if (address->sun_path[0] == '\0') {

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

263

strlcpy(buffer, address->sun_path + 1, 6);

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

267

return hash_hash_string(address->sun_path);

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

285

sockaddr_un* address = (sockaddr_un*)_address;

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

286

int len = (char*)address + address->sun_len - address->sun_path;

src/add-ons/kernel/network/protocols/unix/UnixAddress.cpp

288

(*checksum) << (uint8)address->sun_path[i];

src/add-ons/kernel/network/protocols/unix/UnixAddress.h

135

static bool IsEmptyAddress(const sockaddr_un& address)

src/add-ons/kernel/network/protocols/unix/UnixAddress.h

137

return address.sun_len == sizeof(sockaddr)

src/add-ons/kernel/network/protocols/unix/UnixAddress.h

138

&& address.sun_path[0] == '\0' && address.sun_path[1] == '\0';

src/add-ons/kernel/network/protocols/unix/UnixAddress.h

141

static int32 InternalID(const sockaddr_un& address)

src/add-ons/kernel/network/protocols/unix/UnixAddress.h

143

if (address.sun_len < INTERNAL_UNIX_ADDRESS_LEN

src/add-ons/kernel/network/protocols/unix/UnixAddress.h

144

|| address.sun_path[0] != '\0') {

src/add-ons/kernel/network/protocols/unix/UnixAddress.h

152

char c = address.sun_path[i + 1];

src/add-ons/kernel/network/protocols/unix/UnixAddressManager.h

68

UnixEndpoint* Lookup(const UnixAddress& address) const

src/add-ons/kernel/network/protocols/unix/UnixAddressManager.h

70

return fBoundEndpoints.Lookup(address);

src/add-ons/kernel/network/protocols/unix/UnixAddressManager.h

94

UnixAddress address(id);

src/add-ons/kernel/network/protocols/unix/UnixAddressManager.h

95

if (Lookup(address) == NULL)

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

129

const sockaddr_un* address = (const sockaddr_un*)_address;

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

131

RETURN_ERROR(_Bind(address));

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

193

PeerAddress().SetTo(&fTargetEndpoint->socket->address);

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

212

ancillary_data_container* ancillaryData, const struct sockaddr* address,

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

237

if (address == NULL) {

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

243

status = _InitializeEndpoint(address, targetEndpointReference);

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

250

memcpy(&sourceAddress, &socket->address, sizeof(struct sockaddr_storage));

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

420

struct sockaddr_un* address = (struct sockaddr_un*)&addressStorage;

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

421

socklen_t memoryLength = min_c(*_addressLength, address->sun_len);

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

422

memcpy(_address, address, memoryLength);

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

423

*_addressLength = address->sun_len;

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

515

const struct sockaddr_un* address = (const struct sockaddr_un*)_address;

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

517

if (address->sun_path[0] == '\0') {

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

520

if (UnixAddress::IsEmptyAddress(*address))

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

523

internalID = UnixAddress::InternalID(*address);

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

530

size_t pathLen = strnlen(address->sun_path, sizeof(address->sun_path));

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

531

if (pathLen == 0 || pathLen == sizeof(address->sun_path))

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.cpp

535

status_t error = vfs_read_stat(-1, address->sun_path, true, &st,

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.h

32

status_t Connect(const struct sockaddr* address) override;

src/add-ons/kernel/network/protocols/unix/UnixDatagramEndpoint.h

37

const struct sockaddr* address,

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

104

size_t pathLen = strnlen(address->sun_path, sizeof(address->sun_path));

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

105

if (pathLen == 0 || pathLen == sizeof(address->sun_path))

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

109

status_t error = vfs_create_special_node(address->sun_path,

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

121

size_t addressLen = address->sun_path + pathLen + 1 - (char*)address;

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

122

memcpy(&socket->address, address, addressLen);

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

123

socket->address.ss_len = addressLen;

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

73

UnixEndpoint::_Bind(const struct sockaddr_un* address)

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

77

ConstSocketAddress(&gAddressModule, (struct sockaddr*)address).AsString().Data());

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

79

if (address->sun_path[0] == '\0') {

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

84

if (UnixAddress::IsEmptyAddress(*address))

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

87

internalID = UnixAddress::InternalID(*address);

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

95

sockaddr_un* outAddress = (sockaddr_un*)&socket->address;

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.h

53

virtual status_t Connect(const struct sockaddr* address) = 0;

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.h

58

const struct sockaddr* address,

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.h

79

status_t _Bind(const struct sockaddr_un* address);

src/add-ons/kernel/network/protocols/unix/UnixFifo.cpp

234

memcpy(request.Address(), &datagramEntry->address, sizeof(datagramEntry->address));

src/add-ons/kernel/network/protocols/unix/UnixFifo.cpp

266

memcpy(request.Address(), &datagramEntry->address, sizeof(datagramEntry->address));

src/add-ons/kernel/network/protocols/unix/UnixFifo.cpp

28

struct sockaddr_storage* address, bool clone)

src/add-ons/kernel/network/protocols/unix/UnixFifo.cpp

292

memcpy(&datagramEntry->address, request.Address(), sizeof(datagramEntry->address));

src/add-ons/kernel/network/protocols/unix/UnixFifo.cpp

37

fAddress(address),

src/add-ons/kernel/network/protocols/unix/UnixFifo.cpp

431

struct sockaddr_storage* address, bigtime_t timeout, bool peek)

src/add-ons/kernel/network/protocols/unix/UnixFifo.cpp

439

UnixRequest request(vecs, vecCount, NULL, address, peek);

src/add-ons/kernel/network/protocols/unix/UnixFifo.cpp

477

const struct sockaddr_storage* address, bigtime_t timeout)

src/add-ons/kernel/network/protocols/unix/UnixFifo.cpp

490

(struct sockaddr_storage*)address);

src/add-ons/kernel/network/protocols/unix/UnixFifo.h

140

struct sockaddr_storage* address, bigtime_t timeout, bool peek);

src/add-ons/kernel/network/protocols/unix/UnixFifo.h

143

const struct sockaddr_storage* address, bigtime_t timeout);

src/add-ons/kernel/network/protocols/unix/UnixFifo.h

40

struct sockaddr_storage* address, bool clone = false);

src/add-ons/kernel/network/protocols/unix/UnixFifo.h

95

struct sockaddr_storage address;

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

158

const sockaddr_un* address = (const sockaddr_un*)_address;

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

165

RETURN_ERROR(_Bind(address));

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

225

const sockaddr_un* address = (const sockaddr_un*)_address;

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

239

if (address->sun_path[0] == '\0') {

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

242

if (UnixAddress::IsEmptyAddress(*address))

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

245

internalID = UnixAddress::InternalID(*address);

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

252

size_t pathLen = strnlen(address->sun_path, sizeof(address->sun_path));

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

253

if (pathLen == 0 || pathLen == sizeof(address->sun_path))

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

257

status_t error = vfs_read_stat(-1, address->sun_path, true, &st,

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

319

PeerAddress().SetTo(&connectedEndpoint->socket->address);

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

384

const struct sockaddr* address, socklen_t addressLength, int flags)

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.cpp

727

PeerAddress().SetTo(&connectingEndpoint->socket->address);

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.h

48

status_t Connect(const struct sockaddr* address) override;

src/add-ons/kernel/network/protocols/unix/UnixStreamEndpoint.h

53

const struct sockaddr* address,

src/add-ons/kernel/network/protocols/unix/unix.cpp

134

unix_connect(net_protocol *_protocol, const struct sockaddr *address)

src/add-ons/kernel/network/protocols/unix/unix.cpp

136

return ((UnixEndpoint*)_protocol)->Connect(address);

src/add-ons/kernel/network/protocols/unix/unix.cpp

272

unix_get_mtu(net_protocol *protocol, const struct sockaddr *address)

src/add-ons/kernel/network/protocols/unix/unix.cpp

445

const struct sockaddr *address, socklen_t addressLength, int flags)

src/add-ons/kernel/network/protocols/unix/unix.cpp

448

address, addressLength, flags);

src/add-ons/kernel/network/stack/datalink.cpp

1008

const sockaddr* address)

src/add-ons/kernel/network/stack/datalink.cpp

1012

return protocol->device_module->add_multicast(protocol->device, address);

src/add-ons/kernel/network/stack/datalink.cpp

1018

const sockaddr* address)

src/add-ons/kernel/network/stack/datalink.cpp

1023

address);

src/add-ons/kernel/network/stack/datalink.cpp

168

set_interface_address(net_interface_address*& target, InterfaceAddress* address)

src/add-ons/kernel/network/stack/datalink.cpp

173

target = address;

src/add-ons/kernel/network/stack/datalink.cpp

364

InterfaceAddress* address = (InterfaceAddress*)route->interface_address;

src/add-ons/kernel/network/stack/datalink.cpp

365

Interface* interface = (Interface*)address->interface;

src/add-ons/kernel/network/stack/datalink.cpp

379

address->AcquireReference();

src/add-ons/kernel/network/stack/datalink.cpp

380

set_interface_address(buffer->interface_address, address);

src/add-ons/kernel/network/stack/datalink.cpp

388

address->AcquireReference();

src/add-ons/kernel/network/stack/datalink.cpp

389

set_interface_address(buffer->interface_address, address);

src/add-ons/kernel/network/stack/datalink.cpp

415

= interface->DomainDatalink(address->domain->family);

src/add-ons/kernel/network/stack/datalink.cpp

469

datalink_is_local_address(net_domain* domain, const struct sockaddr* address,

src/add-ons/kernel/network/stack/datalink.cpp

473

AddressString(domain, address).Data());

src/add-ons/kernel/network/stack/datalink.cpp

475

if (domain == NULL || address == NULL

src/add-ons/kernel/network/stack/datalink.cpp

476

|| domain->family != address->sa_family)

src/add-ons/kernel/network/stack/datalink.cpp

481

InterfaceAddress* interfaceAddress = get_interface_address(address);

src/add-ons/kernel/network/stack/datalink.cpp

487

= get_interface_address_for_destination(domain, address);

src/add-ons/kernel/network/stack/datalink.cpp

521

const struct sockaddr* address, net_interface_address** _interfaceAddress)

src/add-ons/kernel/network/stack/datalink.cpp

523

if (domain == NULL || address == NULL || address->sa_family != AF_LINK)

src/add-ons/kernel/network/stack/datalink.cpp

527

uint8* data = LLADDR((sockaddr_dl*)address);

src/add-ons/kernel/network/stack/datalink.cpp

534

address, unconfiguredOnly);

src/add-ons/kernel/network/stack/datalink.cpp

557

datalink_get_interface_with_address(const sockaddr* address)

src/add-ons/kernel/network/stack/datalink.cpp

559

InterfaceAddress* interfaceAddress = get_interface_address(address);

src/add-ons/kernel/network/stack/datalink.cpp

583

datalink_get_interface_address(const struct sockaddr* address)

src/add-ons/kernel/network/stack/datalink.cpp

585

return get_interface_address(address);

src/add-ons/kernel/network/stack/datalink.cpp

609

InterfaceAddress* address = (InterfaceAddress*)*_address;

src/add-ons/kernel/network/stack/datalink.cpp

610

bool gotOne = interface->GetNextAddress(&address);

src/add-ons/kernel/network/stack/datalink.cpp

611

*_address = address;

src/add-ons/kernel/network/stack/datalink.cpp

618

datalink_put_interface_address(net_interface_address* address)

src/add-ons/kernel/network/stack/datalink.cpp

620

if (address == NULL)

src/add-ons/kernel/network/stack/datalink.cpp

623

((InterfaceAddress*)address)->ReleaseReference();

src/add-ons/kernel/network/stack/datalink.cpp

629

const struct sockaddr* address)

src/add-ons/kernel/network/stack/datalink.cpp

635

address);

src/add-ons/kernel/network/stack/datalink.cpp

641

const struct sockaddr* address)

src/add-ons/kernel/network/stack/datalink.cpp

647

address);

src/add-ons/kernel/network/stack/datalink.cpp

829

InterfaceAddress* address = NULL;

src/add-ons/kernel/network/stack/datalink.cpp

834

address = interface->AddressForLocal(protocol->domain,

src/add-ons/kernel/network/stack/datalink.cpp

838

address = interface->FirstForFamily(

src/add-ons/kernel/network/stack/datalink.cpp

842

request.ifra_index = interface->IndexOfAddress(address);

src/add-ons/kernel/network/stack/datalink.cpp

844

address = interface->AddressAt(request.ifra_index);

src/add-ons/kernel/network/stack/datalink.cpp

845

if (address == NULL)

src/add-ons/kernel/network/stack/datalink.cpp

855

status = fill_address(address->local,

src/add-ons/kernel/network/stack/datalink.cpp

860

status = fill_address(address->mask,

src/add-ons/kernel/network/stack/datalink.cpp

865

status = fill_address(address->destination,

src/add-ons/kernel/network/stack/datalink.cpp

871

address->ReleaseReference();

src/add-ons/kernel/network/stack/device_interfaces.cpp

318

sockaddr_dl &address = *(sockaddr_dl*)_address;

src/add-ons/kernel/network/stack/device_interfaces.cpp

320

address.sdl_family = AF_LINK;

src/add-ons/kernel/network/stack/device_interfaces.cpp

321

address.sdl_index = interface->device->index;

src/add-ons/kernel/network/stack/device_interfaces.cpp

322

address.sdl_type = interface->device->type;

src/add-ons/kernel/network/stack/device_interfaces.cpp

323

address.sdl_nlen = strlen(interface->device->name);

src/add-ons/kernel/network/stack/device_interfaces.cpp

324

address.sdl_slen = 0;

src/add-ons/kernel/network/stack/device_interfaces.cpp

325

memcpy(address.sdl_data, interface->device->name, address.sdl_nlen);

src/add-ons/kernel/network/stack/device_interfaces.cpp

327

address.sdl_alen = interface->device->address.length;

src/add-ons/kernel/network/stack/device_interfaces.cpp

328

memcpy(LLADDR(&address), interface->device->address.data, address.sdl_alen);

src/add-ons/kernel/network/stack/device_interfaces.cpp

330

address.sdl_len = sizeof(sockaddr_dl) - sizeof(address.sdl_data)

src/add-ons/kernel/network/stack/device_interfaces.cpp

331

+ address.sdl_nlen + address.sdl_alen;

src/add-ons/kernel/network/stack/device_interfaces.cpp

367

sockaddr_storage address;

src/add-ons/kernel/network/stack/device_interfaces.cpp

368

get_device_interface_address(interface, (sockaddr*)&address);

src/add-ons/kernel/network/stack/device_interfaces.cpp

370

buffer.Push(&address, address.ss_len);

src/add-ons/kernel/network/stack/device_interfaces.cpp

371

if (IF_NAMESIZE + address.ss_len < (int)sizeof(ifreq))

src/add-ons/kernel/network/stack/device_interfaces.cpp

372

buffer.Pad(sizeof(ifreq) - IF_NAMESIZE - address.ss_len);

src/add-ons/kernel/network/stack/device_interfaces.h

57

sockaddr* address);

src/add-ons/kernel/network/stack/interfaces.cpp

1070

while (InterfaceAddress* address = iterator.Next()) {

src/add-ons/kernel/network/stack/interfaces.cpp

1071

address->Dump(++i, true);

src/add-ons/kernel/network/stack/interfaces.cpp

1116

while (InterfaceAddress* address = addressIterator.Next()) {

src/add-ons/kernel/network/stack/interfaces.cpp

1117

address->AddDefaultRoutes(SIOCSIFADDR);

src/add-ons/kernel/network/stack/interfaces.cpp

1133

while (InterfaceAddress* address = iterator.Next()) {

src/add-ons/kernel/network/stack/interfaces.cpp

1134

if (address->domain != NULL && address->domain->family == family)

src/add-ons/kernel/network/stack/interfaces.cpp

1135

return address;

src/add-ons/kernel/network/stack/interfaces.cpp

1143

Interface::_ChangeAddress(RecursiveLocker& locker, InterfaceAddress* address,

src/add-ons/kernel/network/stack/interfaces.cpp

1149

if (address->domain->address_module->set_to((sockaddr*)&oldAddress,

src/add-ons/kernel/network/stack/interfaces.cpp

1156

if (address->domain->address_module->set_to((sockaddr*)&newAddress,

src/add-ons/kernel/network/stack/interfaces.cpp

1161

if (address->domain->address_module->equal_addresses(

src/add-ons/kernel/network/stack/interfaces.cpp

1169

address->AcquireReference();

src/add-ons/kernel/network/stack/interfaces.cpp

1172

domain_datalink* datalink = DomainDatalink(address->domain);

src/add-ons/kernel/network/stack/interfaces.cpp

1174

datalink->first_protocol, address, option,

src/add-ons/kernel/network/stack/interfaces.cpp

1179

address->ReleaseReference();

src/add-ons/kernel/network/stack/interfaces.cpp

1310

InterfaceAddress* address

src/add-ons/kernel/network/stack/interfaces.cpp

1312

if (address == NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

1315

status_t status = address->SetTo(request);

src/add-ons/kernel/network/stack/interfaces.cpp

1319

status = interface->AddAddress(address);

src/add-ons/kernel/network/stack/interfaces.cpp

1321

if (status == B_OK && address->local != NULL) {

src/add-ons/kernel/network/stack/interfaces.cpp

1326

datalink->first_protocol, address, SIOCAIFADDR, NULL,

src/add-ons/kernel/network/stack/interfaces.cpp

1327

address->local);

src/add-ons/kernel/network/stack/interfaces.cpp

1329

interface->RemoveAddress(address);

src/add-ons/kernel/network/stack/interfaces.cpp

1334

delete address;

src/add-ons/kernel/network/stack/interfaces.cpp

1378

sockaddr* address = *_address;

src/add-ons/kernel/network/stack/interfaces.cpp

1387

&interfaceAddress->mask, address->sa_len);

src/add-ons/kernel/network/stack/interfaces.cpp

1397

&interfaceAddress->destination, address->sa_len);

src/add-ons/kernel/network/stack/interfaces.cpp

149

while (InterfaceAddress* address = iterator.Next()) {

src/add-ons/kernel/network/stack/interfaces.cpp

150

address->Dump(++i);

src/add-ons/kernel/network/stack/interfaces.cpp

1504

if ((linkAddress.sdl_alen == interface->device->address.length

src/add-ons/kernel/network/stack/interfaces.cpp

1505

&& memcmp(LLADDR(&linkAddress), interface->device->address.data,

src/add-ons/kernel/network/stack/interfaces.cpp

152

address->domain->address_module->hash_address(address->local,

src/add-ons/kernel/network/stack/interfaces.cpp

1537

InterfaceAddress* address = sAddressTable.Lookup(local);

src/add-ons/kernel/network/stack/interfaces.cpp

1538

if (address == NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

1541

address->AcquireReference();

src/add-ons/kernel/network/stack/interfaces.cpp

1542

return address;

src/add-ons/kernel/network/stack/interfaces.cpp

1557

InterfaceAddress* address

src/add-ons/kernel/network/stack/interfaces.cpp

1559

if (address != NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

1560

return address;

src/add-ons/kernel/network/stack/interfaces.cpp

1575

get_interface_address_for_link(net_domain* domain, const sockaddr* address,

src/add-ons/kernel/network/stack/interfaces.cpp

1578

sockaddr_dl& linkAddress = *(sockaddr_dl*)address;

src/add-ons/kernel/network/stack/interfaces.cpp

1588

if (linkAddress.sdl_alen == interface->device->address.length

src/add-ons/kernel/network/stack/interfaces.cpp

1589

&& memcmp(LLADDR(&linkAddress), interface->device->address.data,

src/add-ons/kernel/network/stack/interfaces.cpp

1630

InterfaceAddress* address = interface->FirstForFamily(family);

src/add-ons/kernel/network/stack/interfaces.cpp

1633

if (address != NULL && address->local != NULL) {

src/add-ons/kernel/network/stack/interfaces.cpp

1635

buffer.Push(address->local, length = address->local->sa_len);

src/add-ons/kernel/network/stack/interfaces.cpp

1644

if (address != NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

1645

address->ReleaseReference();

src/add-ons/kernel/network/stack/interfaces.cpp

373

sockaddr* address = *_address;

src/add-ons/kernel/network/stack/interfaces.cpp

377

free(address);

src/add-ons/kernel/network/stack/interfaces.cpp

388

address = Prepare(_address, size);

src/add-ons/kernel/network/stack/interfaces.cpp

389

if (address == NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

392

memcpy(address, to, size);

src/add-ons/kernel/network/stack/interfaces.cpp

393

address->sa_len = size;

src/add-ons/kernel/network/stack/interfaces.cpp

410

sockaddr* address = *_address;

src/add-ons/kernel/network/stack/interfaces.cpp

412

if (address == NULL || size > address->sa_len) {

src/add-ons/kernel/network/stack/interfaces.cpp

413

sockaddr* resized = (sockaddr*)realloc(address, size);

src/add-ons/kernel/network/stack/interfaces.cpp

415

free(address);

src/add-ons/kernel/network/stack/interfaces.cpp

419

address = resized;

src/add-ons/kernel/network/stack/interfaces.cpp

422

address->sa_len = size;

src/add-ons/kernel/network/stack/interfaces.cpp

424

*_address = address;

src/add-ons/kernel/network/stack/interfaces.cpp

425

return address;

src/add-ons/kernel/network/stack/interfaces.cpp

520

InterfaceAddress* address = _FirstForFamily(family);

src/add-ons/kernel/network/stack/interfaces.cpp

521

if (address != NULL) {

src/add-ons/kernel/network/stack/interfaces.cpp

522

address->AcquireReference();

src/add-ons/kernel/network/stack/interfaces.cpp

523

return address;

src/add-ons/kernel/network/stack/interfaces.cpp

539

while (InterfaceAddress* address = iterator.Next()) {

src/add-ons/kernel/network/stack/interfaces.cpp

540

if (address->domain->family == family

src/add-ons/kernel/network/stack/interfaces.cpp

541

&& (address->local == NULL

src/add-ons/kernel/network/stack/interfaces.cpp

544

address->AcquireReference();

src/add-ons/kernel/network/stack/interfaces.cpp

545

return address;

src/add-ons/kernel/network/stack/interfaces.cpp

55

size_t Hash(InterfaceAddress* address) const

src/add-ons/kernel/network/stack/interfaces.cpp

568

while (InterfaceAddress* address = iterator.Next()) {

src/add-ons/kernel/network/stack/interfaces.cpp

569

if (address->domain == domain

src/add-ons/kernel/network/stack/interfaces.cpp

57

return address->domain->address_module->hash_address(address->local,

src/add-ons/kernel/network/stack/interfaces.cpp

570

&& address->destination != NULL

src/add-ons/kernel/network/stack/interfaces.cpp

571

&& domain->address_module->equal_addresses(address->destination,

src/add-ons/kernel/network/stack/interfaces.cpp

573

address->AcquireReference();

src/add-ons/kernel/network/stack/interfaces.cpp

574

return address;

src/add-ons/kernel/network/stack/interfaces.cpp

591

while (InterfaceAddress* address = iterator.Next()) {

src/add-ons/kernel/network/stack/interfaces.cpp

592

if (address->domain == domain

src/add-ons/kernel/network/stack/interfaces.cpp

593

&& address->local != NULL

src/add-ons/kernel/network/stack/interfaces.cpp

594

&& domain->address_module->equal_addresses(address->local, local)) {

src/add-ons/kernel/network/stack/interfaces.cpp

595

address->AcquireReference();

src/add-ons/kernel/network/stack/interfaces.cpp

596

return address;

src/add-ons/kernel/network/stack/interfaces.cpp

605

Interface::AddAddress(InterfaceAddress* address)

src/add-ons/kernel/network/stack/interfaces.cpp

607

net_domain* domain = address->domain;

src/add-ons/kernel/network/stack/interfaces.cpp

61

bool Compare(const KeyType& key, InterfaceAddress* address) const

src/add-ons/kernel/network/stack/interfaces.cpp

612

fAddresses.Add(address);

src/add-ons/kernel/network/stack/interfaces.cpp

615

if (address->LocalIsDefined()) {

src/add-ons/kernel/network/stack/interfaces.cpp

617

sAddressTable.Insert(address);

src/add-ons/kernel/network/stack/interfaces.cpp

624

Interface::RemoveAddress(InterfaceAddress* address)

src/add-ons/kernel/network/stack/interfaces.cpp

626

net_domain* domain = address->domain;

src/add-ons/kernel/network/stack/interfaces.cpp

63

if (address->local == NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

632

fAddresses.Remove(address);

src/add-ons/kernel/network/stack/interfaces.cpp

633

address->GetDoublyLinkedListLink()->next = NULL;

src/add-ons/kernel/network/stack/interfaces.cpp

637

if (address->LocalIsDefined()) {

src/add-ons/kernel/network/stack/interfaces.cpp

639

sAddressTable.Remove(address);

src/add-ons/kernel/network/stack/interfaces.cpp

649

InterfaceAddress* address = *_address;

src/add-ons/kernel/network/stack/interfaces.cpp

650

if (address == NULL) {

src/add-ons/kernel/network/stack/interfaces.cpp

652

address = fAddresses.First();

src/add-ons/kernel/network/stack/interfaces.cpp

655

InterfaceAddress* next = fAddresses.GetNext(address);

src/add-ons/kernel/network/stack/interfaces.cpp

656

address->ReleaseReference();

src/add-ons/kernel/network/stack/interfaces.cpp

657

address = next;

src/add-ons/kernel/network/stack/interfaces.cpp

66

if (address->local->sa_family != key->sa_family)

src/add-ons/kernel/network/stack/interfaces.cpp

660

*_address = address;

src/add-ons/kernel/network/stack/interfaces.cpp

662

if (address == NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

665

address->AcquireReference();

src/add-ons/kernel/network/stack/interfaces.cpp

678

while (InterfaceAddress* address = iterator.Next()) {

src/add-ons/kernel/network/stack/interfaces.cpp

680

address->AcquireReference();

src/add-ons/kernel/network/stack/interfaces.cpp

681

return address;

src/add-ons/kernel/network/stack/interfaces.cpp

69

return address->domain->address_module->equal_addresses(key,

src/add-ons/kernel/network/stack/interfaces.cpp

690

Interface::IndexOfAddress(InterfaceAddress* address)

src/add-ons/kernel/network/stack/interfaces.cpp

692

if (address == NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

70

address->local);

src/add-ons/kernel/network/stack/interfaces.cpp

701

if (address == iterator.Next())

src/add-ons/kernel/network/stack/interfaces.cpp

724

while (InterfaceAddress* address = fAddresses.RemoveHead()) {

src/add-ons/kernel/network/stack/interfaces.cpp

727

if (address->LocalIsDefined()) {

src/add-ons/kernel/network/stack/interfaces.cpp

729

sAddressTable.Remove(address);

src/add-ons/kernel/network/stack/interfaces.cpp

73

InterfaceAddress*& GetLink(InterfaceAddress* address) const

src/add-ons/kernel/network/stack/interfaces.cpp

731

address->ReleaseReference();

src/add-ons/kernel/network/stack/interfaces.cpp

75

return address->HashTableLink();

src/add-ons/kernel/network/stack/interfaces.cpp

796

InterfaceAddress* address = NULL;

src/add-ons/kernel/network/stack/interfaces.cpp

801

address = AddressForLocal(domain,

src/add-ons/kernel/network/stack/interfaces.cpp

804

if (address == NULL) {

src/add-ons/kernel/network/stack/interfaces.cpp

806

address = FirstForFamily(domain->family);

src/add-ons/kernel/network/stack/interfaces.cpp

808

if (address == NULL) {

src/add-ons/kernel/network/stack/interfaces.cpp

810

address = new(std::nothrow) InterfaceAddress(this, domain);

src/add-ons/kernel/network/stack/interfaces.cpp

811

if (address == NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

814

status_t status = AddAddress(address);

src/add-ons/kernel/network/stack/interfaces.cpp

816

delete address;

src/add-ons/kernel/network/stack/interfaces.cpp

822

address->AcquireReference();

src/add-ons/kernel/network/stack/interfaces.cpp

825

address = AddressAt(aliasRequest.ifra_index);

src/add-ons/kernel/network/stack/interfaces.cpp

827

if (address == NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

833

(sockaddr*)&aliasRequest.ifra_addr, address->local)) {

src/add-ons/kernel/network/stack/interfaces.cpp

834

status = _ChangeAddress(locker, address, SIOCSIFADDR,

src/add-ons/kernel/network/stack/interfaces.cpp

835

address->local, (sockaddr*)&aliasRequest.ifra_addr);

src/add-ons/kernel/network/stack/interfaces.cpp

839

(sockaddr*)&aliasRequest.ifra_mask, address->mask)

src/add-ons/kernel/network/stack/interfaces.cpp

842

status = _ChangeAddress(locker, address, SIOCSIFNETMASK,

src/add-ons/kernel/network/stack/interfaces.cpp

843

address->mask, (sockaddr*)&aliasRequest.ifra_mask);

src/add-ons/kernel/network/stack/interfaces.cpp

848

address->destination)

src/add-ons/kernel/network/stack/interfaces.cpp

851

status = _ChangeAddress(locker, address,

src/add-ons/kernel/network/stack/interfaces.cpp

855

address->destination,

src/add-ons/kernel/network/stack/interfaces.cpp

859

address->ReleaseReference();

src/add-ons/kernel/network/stack/interfaces.cpp

874

InterfaceAddress* address = NULL;

src/add-ons/kernel/network/stack/interfaces.cpp

888

while ((address = iterator.Next()) != NULL) {

src/add-ons/kernel/network/stack/interfaces.cpp

889

if (address->domain == domain

src/add-ons/kernel/network/stack/interfaces.cpp

891

address->local, (sockaddr*)&newAddress))

src/add-ons/kernel/network/stack/interfaces.cpp

895

if (address == NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

899

address = _FirstForFamily(domain->family);

src/add-ons/kernel/network/stack/interfaces.cpp

900

if (address == NULL) {

src/add-ons/kernel/network/stack/interfaces.cpp

902

address = new(std::nothrow) InterfaceAddress(this, domain);

src/add-ons/kernel/network/stack/interfaces.cpp

903

if (address == NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

906

status_t status = AddAddress(address);

src/add-ons/kernel/network/stack/interfaces.cpp

908

delete address;

src/add-ons/kernel/network/stack/interfaces.cpp

917

return _ChangeAddress(locker, address, option,

src/add-ons/kernel/network/stack/interfaces.cpp

918

*address->AddressFor(option),

src/add-ons/kernel/network/stack/interfaces.cpp

972

while (InterfaceAddress* address = iterator.Next()) {

src/add-ons/kernel/network/stack/interfaces.cpp

973

if (address->domain != NULL)

src/add-ons/kernel/network/stack/interfaces.cpp

974

invalidate_routes(address->domain, this);

src/add-ons/kernel/network/stack/interfaces.h

130

status_t AddAddress(InterfaceAddress* address);

src/add-ons/kernel/network/stack/interfaces.h

131

void RemoveAddress(InterfaceAddress* address);

src/add-ons/kernel/network/stack/interfaces.h

134

int32 IndexOfAddress(InterfaceAddress* address);

src/add-ons/kernel/network/stack/interfaces.h

166

InterfaceAddress* address, int32 option,

src/add-ons/kernel/network/stack/interfaces.h

198

Interface* get_interface_for_link(net_domain* domain, const sockaddr* address);

src/add-ons/kernel/network/stack/interfaces.h

199

InterfaceAddress* get_interface_address(const struct sockaddr* address);

src/add-ons/kernel/network/stack/link.cpp

143

LinkProtocol::Bind(const sockaddr* address)

src/add-ons/kernel/network/stack/link.cpp

146

if (address == NULL || geteuid() != 0)

src/add-ons/kernel/network/stack/link.cpp

154

Interface* interface = get_interface_for_link(sDomain, address);

src/add-ons/kernel/network/stack/link.cpp

166

sockaddr_dl& linkAddress = *(sockaddr_dl*)address;

src/add-ons/kernel/network/stack/link.cpp

185

memcpy(&socket->address, address, sizeof(struct sockaddr_storage));

src/add-ons/kernel/network/stack/link.cpp

186

socket->address.ss_len = sizeof(struct sockaddr_storage);

src/add-ons/kernel/network/stack/link.cpp

204

socket->address.ss_len = 0;

src/add-ons/kernel/network/stack/link.cpp

340

link_connect(net_protocol* protocol, const struct sockaddr* address)

src/add-ons/kernel/network/stack/link.cpp

429

sockaddr_storage address;

src/add-ons/kernel/network/stack/link.cpp

430

get_device_interface_address(interface, (sockaddr*)&address);

src/add-ons/kernel/network/stack/link.cpp

434

&address, address.ss_len);

src/add-ons/kernel/network/stack/link.cpp

53

status_t Bind(const sockaddr* address);

src/add-ons/kernel/network/stack/link.cpp

532

link_bind(net_protocol* _protocol, const struct sockaddr* address)

src/add-ons/kernel/network/stack/link.cpp

535

return protocol->Bind(address);

src/add-ons/kernel/network/stack/link.cpp

540

link_unbind(net_protocol* _protocol, struct sockaddr* address)

src/add-ons/kernel/network/stack/link.cpp

616

link_get_mtu(net_protocol* _protocol, const struct sockaddr* address)

src/add-ons/kernel/network/stack/net_buffer.cpp

586

dump_address(const char* prefix, sockaddr* address,

src/add-ons/kernel/network/stack/net_buffer.cpp

589

if (address == NULL || address->sa_len == 0)

src/add-ons/kernel/network/stack/net_buffer.cpp

593

dprintf(" %s: length %u, family %u\n", prefix, address->sa_len,

src/add-ons/kernel/network/stack/net_buffer.cpp

594

address->sa_family);

src/add-ons/kernel/network/stack/net_buffer.cpp

596

dump_block((char*)address + 2, address->sa_len - 2, " ");

src/add-ons/kernel/network/stack/net_buffer.cpp

599

interfaceAddress->domain->address_module->print_address_buffer(address,

src/add-ons/kernel/network/stack/net_socket.cpp

100

address.ss_len = 0;

src/add-ons/kernel/network/stack/net_socket.cpp

1002

memcpy(address, &socket->peer, min_c(*_addressLength, socket->peer.ss_len));

src/add-ons/kernel/network/stack/net_socket.cpp

1009

socket_getsockname(net_socket* socket, struct sockaddr* address,

src/add-ons/kernel/network/stack/net_socket.cpp

1012

if (socket->address.ss_len == 0) {

src/add-ons/kernel/network/stack/net_socket.cpp

1017

memcpy(address, &buffer, min_c(*_addressLength, sizeof(buffer)));

src/add-ons/kernel/network/stack/net_socket.cpp

1022

memcpy(address, &socket->address, min_c(*_addressLength,

src/add-ons/kernel/network/stack/net_socket.cpp

1023

socket->address.ss_len));

src/add-ons/kernel/network/stack/net_socket.cpp

1024

*_addressLength = socket->address.ss_len;

src/add-ons/kernel/network/stack/net_socket.cpp

1285

const sockaddr* address = NULL;

src/add-ons/kernel/network/stack/net_socket.cpp

1288

address = (const sockaddr*)header->msg_name;

src/add-ons/kernel/network/stack/net_socket.cpp

1306

address = NULL;

src/add-ons/kernel/network/stack/net_socket.cpp

1307

else if (address == NULL)

src/add-ons/kernel/network/stack/net_socket.cpp

1311

if (address != NULL)

src/add-ons/kernel/network/stack/net_socket.cpp

1315

address = (struct sockaddr*)&socket->peer;

src/add-ons/kernel/network/stack/net_socket.cpp

1319

if (address == NULL || addressLength == 0) {

src/add-ons/kernel/network/stack/net_socket.cpp

1328

if (socket->address.ss_len == 0) {

src/add-ons/kernel/network/stack/net_socket.cpp

1342

socket->first_protocol, vecs, vecCount, ancillaryData, address,

src/add-ons/kernel/network/stack/net_socket.cpp

1418

memcpy(buffer->source, &socket->address, socket->address.ss_len);

src/add-ons/kernel/network/stack/net_socket.cpp

1419

memcpy(buffer->destination, address, addressLength);

src/add-ons/kernel/network/stack/net_socket.cpp

1610

error = socket_connect(sockets[1], (sockaddr*)&sockets[0]->address,

src/add-ons/kernel/network/stack/net_socket.cpp

1611

sockets[0]->address.ss_len);

src/add-ons/kernel/network/stack/net_socket.cpp

1627

error = socket_connect(sockets[0], (sockaddr*)&sockets[1]->address,

src/add-ons/kernel/network/stack/net_socket.cpp

1628

sockets[1]->address.ss_len);

src/add-ons/kernel/network/stack/net_socket.cpp

310

sockaddr* address = header ? (sockaddr*)header->msg_name : NULL;

src/add-ons/kernel/network/stack/net_socket.cpp

315

socket->first_protocol, vecs, vecCount, &ancillaryData, address,

src/add-ons/kernel/network/stack/net_socket.cpp

586

memcpy(&stat->address, &socket->address, sizeof(struct sockaddr_storage));

src/add-ons/kernel/network/stack/net_socket.cpp

655

memcpy(&socket->address, &parent->address, parent->address.ss_len);

src/add-ons/kernel/network/stack/net_socket.cpp

74

int socket_bind(net_socket* socket, const struct sockaddr* address,

src/add-ons/kernel/network/stack/net_socket.cpp

915

socket_accept(net_socket* socket, struct sockaddr* address,

src/add-ons/kernel/network/stack/net_socket.cpp

929

if (address && *_addressLength > 0) {

src/add-ons/kernel/network/stack/net_socket.cpp

930

memcpy(address, &accepted->peer, min_c(*_addressLength,

src/add-ons/kernel/network/stack/net_socket.cpp

941

socket_bind(net_socket* socket, const struct sockaddr* address,

src/add-ons/kernel/network/stack/net_socket.cpp

945

if (address == NULL) {

src/add-ons/kernel/network/stack/net_socket.cpp

951

address = ∅

src/add-ons/kernel/network/stack/net_socket.cpp

955

if (socket->address.ss_len != 0)

src/add-ons/kernel/network/stack/net_socket.cpp

958

memcpy(&socket->address, address, sizeof(sockaddr));

src/add-ons/kernel/network/stack/net_socket.cpp

959

socket->address.ss_len = sizeof(sockaddr_storage);

src/add-ons/kernel/network/stack/net_socket.cpp

962

(sockaddr*)address);

src/add-ons/kernel/network/stack/net_socket.cpp

965

socket->address.ss_len = 0;

src/add-ons/kernel/network/stack/net_socket.cpp

973

socket_connect(net_socket* socket, const struct sockaddr* address,

src/add-ons/kernel/network/stack/net_socket.cpp

976

if (address == NULL || addressLength == 0)

src/add-ons/kernel/network/stack/net_socket.cpp

979

if (socket->address.ss_len == 0) {

src/add-ons/kernel/network/stack/net_socket.cpp

986

return socket->first_info->connect(socket->first_protocol, address);

src/add-ons/kernel/network/stack/net_socket.cpp

991

socket_getpeername(net_socket* _socket, struct sockaddr* address,

src/add-ons/kernel/network/stack/routes.cpp

141

find_route(net_domain* _domain, const sockaddr* address)

src/add-ons/kernel/network/stack/routes.cpp

151

AddressString(domain, address).Data());

src/add-ons/kernel/network/stack/routes.cpp

160

domain->address_module->mask_address(address, route->mask,

src/add-ons/kernel/network/stack/routes.cpp

165

} else if (!domain->address_module->equal_addresses(address,

src/add-ons/kernel/network/stack/routes.cpp

209

const struct sockaddr* address)

src/add-ons/kernel/network/stack/routes.cpp

214

if (address->sa_family == AF_LINK) {

src/add-ons/kernel/network/stack/routes.cpp

217

const sockaddr_dl* link = (const sockaddr_dl*)address;

src/add-ons/kernel/network/stack/routes.cpp

228

&& !memcmp(LLADDR(link), device->address.data,

src/add-ons/kernel/network/stack/routes.cpp

229

device->address.length)))

src/add-ons/kernel/network/stack/routes.cpp

233

route = find_route(domain, address);

src/add-ons/kernel/network/stack/routes.cpp

254

info->route = get_route_internal(domain, &info->address);

src/add-ons/kernel/network/stack/routes.cpp

260

copy_address(UserBuffer& buffer, sockaddr* address)

src/add-ons/kernel/network/stack/routes.cpp

262

if (address == NULL)

src/add-ons/kernel/network/stack/routes.cpp

265

return (sockaddr*)buffer.Push(address, address->sa_len);

src/add-ons/kernel/network/stack/routes.cpp

423

InterfaceAddress* address

src/add-ons/kernel/network/stack/routes.cpp

428

route.interface_address = address;

src/add-ons/kernel/network/stack/routes.cpp

435

if (address != NULL)

src/add-ons/kernel/network/stack/routes.cpp

436

address->ReleaseReference();

src/add-ons/kernel/network/stack/routes.cpp

603

invalidate_routes(InterfaceAddress* address)

src/add-ons/kernel/network/stack/routes.cpp

605

net_domain_private* domain = (net_domain_private*)address->domain;

src/add-ons/kernel/network/stack/routes.cpp

608

AddressString(domain, address->local).Data());

src/add-ons/kernel/network/stack/routes.cpp

616

if (route->interface_address == address)

src/add-ons/kernel/network/stack/routes.cpp

623

get_route(struct net_domain* _domain, const struct sockaddr* address)

src/add-ons/kernel/network/stack/routes.cpp

628

return get_route_internal(domain, address);

src/add-ons/kernel/network/stack/routes.cpp

65

sockaddr address;

src/add-ons/kernel/network/stack/routes.cpp

66

if (user_memcpy(&address, from, sizeof(struct sockaddr)) < B_OK)

src/add-ons/kernel/network/stack/routes.cpp

69

*to = (sockaddr*)malloc(address.sa_len);

src/add-ons/kernel/network/stack/routes.cpp

702

info->route = get_route_internal(domain, &info->address);

src/add-ons/kernel/network/stack/routes.cpp

729

info->route = get_route_internal(domain, &info->address);

src/add-ons/kernel/network/stack/routes.cpp

73

if (address.sa_len > sizeof(struct sockaddr)) {

src/add-ons/kernel/network/stack/routes.cpp

74

if (user_memcpy(*to, from, address.sa_len) < B_OK)

src/add-ons/kernel/network/stack/routes.cpp

77

memcpy(*to, &address, address.sa_len);

src/add-ons/kernel/network/stack/routes.h

47

void invalidate_routes(InterfaceAddress* address);

src/add-ons/kernel/network/stack/routes.h

49

const struct sockaddr* address);

src/add-ons/kernel/network/stack/stack_interface.cpp

132

int flags, const struct sockaddr* address, socklen_t addressLength)

src/add-ons/kernel/network/stack/stack_interface.cpp

136

message.msg_name = (void*)address;

src/add-ons/kernel/network/stack/stack_interface.cpp

185

stack_interface_getpeername(net_socket* socket, struct sockaddr* address,

src/add-ons/kernel/network/stack/stack_interface.cpp

188

return gNetSocketModule.getpeername(socket, address, _addressLength);

src/add-ons/kernel/network/stack/stack_interface.cpp

193

stack_interface_getsockname(net_socket* socket, struct sockaddr* address,

src/add-ons/kernel/network/stack/stack_interface.cpp

196

return gNetSocketModule.getsockname(socket, address, _addressLength);

src/add-ons/kernel/network/stack/stack_interface.cpp

36

stack_interface_bind(net_socket* socket, const struct sockaddr* address,

src/add-ons/kernel/network/stack/stack_interface.cpp

39

return gNetSocketModule.bind(socket, address, addressLength);

src/add-ons/kernel/network/stack/stack_interface.cpp

51

stack_interface_connect(net_socket* socket, const struct sockaddr* address,

src/add-ons/kernel/network/stack/stack_interface.cpp

54

return gNetSocketModule.connect(socket, address, addressLength);

src/add-ons/kernel/network/stack/stack_interface.cpp

66

stack_interface_accept(net_socket* socket, struct sockaddr* address,

src/add-ons/kernel/network/stack/stack_interface.cpp

69

return gNetSocketModule.accept(socket, address, _addressLength,

src/add-ons/kernel/network/stack/stack_interface.cpp

83

int flags, struct sockaddr* address, socklen_t* _addressLength)

src/add-ons/kernel/network/stack/stack_interface.cpp

87

message.msg_name = address;

src/add-ons/kernel/partitioning_systems/session/scsi-mmc.h

136

uint32 address;

src/add-ons/kernel/power/cpuidle/x86_acpi_cstates/acpi_cpuidle.cpp

221

in8(ci->address);

src/add-ons/kernel/power/cpuidle/x86_acpi_cstates/acpi_cpuidle.cpp

416

ci->address = reg->reg_addr;

src/add-ons/kernel/power/cpuidle/x86_acpi_cstates/acpi_cpuidle.cpp

423

ci->address = reg->reg_addr;

src/add-ons/kernel/power/cpuidle/x86_acpi_cstates/acpi_cpuidle.cpp

85

uint32 address;

src/add-ons/kernel/power/cpuidle/x86_acpi_cstates/x86_mwait.h

15

x86_monitor(void* address, uint32 ecx, uint32 edx)

src/add-ons/kernel/power/cpuidle/x86_acpi_cstates/x86_mwait.h

17

asm volatile("monitor" : : "a" (address), "c" (ecx), "d"(edx));

src/add-ons/kernel/power/cpuidle/x86_cstates/x86_cstates.cpp

51

x86_monitor(void* address, uint32 ecx, uint32 edx)

src/add-ons/kernel/power/cpuidle/x86_cstates/x86_cstates.cpp

53

asm volatile("monitor" : : "a" (address), "c" (ecx), "d"(edx));

src/add-ons/mail_daemon/inbound_protocols/imap/imap_lib/Protocol.cpp

45

Protocol::Connect(const BNetworkAddress& address, const char* username,

src/add-ons/mail_daemon/inbound_protocols/imap/imap_lib/Protocol.cpp

50

fSocket = new(std::nothrow) BSecureSocket(address);

src/add-ons/mail_daemon/inbound_protocols/imap/imap_lib/Protocol.cpp

52

fSocket = new(std::nothrow) BSocket(address);

src/add-ons/mail_daemon/inbound_protocols/imap/imap_lib/Protocol.h

60

status_t Connect(const BNetworkAddress& address,

src/add-ons/mail_daemon/inbound_protocols/pop3/POP3.cpp

335

BNetworkAddress address(server, port);

src/add-ons/mail_daemon/inbound_protocols/pop3/POP3.cpp

337

fServerConnection = new(std::nothrow) BSecureSocket(address);

src/add-ons/mail_daemon/inbound_protocols/pop3/POP3.cpp

339

fServerConnection = new(std::nothrow) BSocket(address);

src/add-ons/mail_daemon/outbound_protocols/smtp/SMTP.cpp

363

SMTPProtocol::Open(const char *address, int port, bool esmtp)

src/add-ons/mail_daemon/outbound_protocols/smtp/SMTP.cpp

372

BNetworkAddress addr(address);

src/add-ons/mail_daemon/outbound_protocols/smtp/SMTP.cpp

438

fServerName = address;

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

100

bool CI2CPort::Write(int address, const char * buffer, int length)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

102

if (Send(address, buffer, length, true, true) == length)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

107

bool CI2CPort::Read(int address, char * buffer, int length)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

109

if (Receive(address, buffer, length, true, true) == length)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

114

bool CI2CPort::Write(int address, const char * buffer, int length, char * result, int reslen)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

116

if (Send(address, buffer, length, true, false) == length)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

117

if (Receive(address, result, reslen, true, true) == reslen)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

122

int CI2CPort::Register(int address, int index)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

126

if (Send(address, &value, sizeof(value), true, false) == sizeof(value)) {

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

127

if (Receive(address, &value, sizeof(value), true, true) == sizeof(value))

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

134

void CI2CPort::SetRegister(int address, int index, int value)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

141

if (Send(address, buffer, sizeof(buffer), true, true) != sizeof(buffer))

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

145

int CI2CPort::Send(int address, const char * buffer, int length, bool start, bool stop)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

155

fRadeon.SetRegister(C_RADEON_I2C_DATA, address & ~(1));

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

190

int CI2CPort::Receive(int address, char * buffer, int length, bool start, bool stop)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

198

fRadeon.SetRegister(C_RADEON_I2C_DATA, address | 0x00000001);

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

55

for (int address = 0x80; address <= 0xff; address += 0x02) {

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

56

if (Probe(address))

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

57

PRINT(("0x%02x ", address));

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

93

bool CI2CPort::Probe(int address)

src/add-ons/media/media-add-ons/radeon/I2CPort.cpp

97

return Read(address, buffer, sizeof(buffer));

src/add-ons/media/media-add-ons/radeon/I2CPort.h

32

bool Probe(int address);

src/add-ons/media/media-add-ons/radeon/I2CPort.h

35

bool Write(int address, const char * buffer, int length);

src/add-ons/media/media-add-ons/radeon/I2CPort.h

37

bool Read(int address, char * buffer, int length);

src/add-ons/media/media-add-ons/radeon/I2CPort.h

39

bool Write(int address, const char * buffer, int length, char * output, int outlen);

src/add-ons/media/media-add-ons/radeon/I2CPort.h

42

int Register(int address, int index);

src/add-ons/media/media-add-ons/radeon/I2CPort.h

44

void SetRegister(int address, int index, int value);

src/add-ons/media/media-add-ons/radeon/I2CPort.h

47

int Send(int address, const char * buffer, int length, bool start, bool stop);

src/add-ons/media/media-add-ons/radeon/I2CPort.h

49

int Receive(int address, char * buffer, int length, bool start, bool stop);

src/add-ons/media/media-add-ons/radeon/MSP3430.cpp

853

int CMSP3430::Register(int address, int subaddress)

src/add-ons/media/media-add-ons/radeon/MSP3430.cpp

857

message[0] = address;

src/add-ons/media/media-add-ons/radeon/MSP3430.cpp

866

void CMSP3430::SetRegister(int address, int subaddress, int value)

src/add-ons/media/media-add-ons/radeon/MSP3430.cpp

870

message[0] = address;

src/add-ons/media/media-add-ons/radeon/MSP3430.h

31

int Register(int address, int subaddress);

src/add-ons/media/media-add-ons/radeon/MSP3430.h

33

void SetRegister(int address, int subaddress, int value);

src/add-ons/media/media-add-ons/radeon/Radeon.cpp

224

int CRadeon::VIPRegister(int device, int address)

src/add-ons/media/media-add-ons/radeon/Radeon.cpp

231

vr.address = address;

src/add-ons/media/media-add-ons/radeon/Radeon.cpp

242

void CRadeon::SetVIPRegister(int device, int address, int value)

src/add-ons/media/media-add-ons/radeon/Radeon.cpp

248

vw.address = address;

src/add-ons/media/media-add-ons/radeon/Radeon.cpp

256

int CRadeon::VIPReadFifo(int device, uint32 address, uint32 count, uint8 *buffer)

src/add-ons/media/media-add-ons/radeon/Radeon.cpp

263

vr.address = address;

src/add-ons/media/media-add-ons/radeon/Radeon.cpp

276

int CRadeon::VIPWriteFifo(int device, uint32 address, uint32 count, uint8 *buffer)

src/add-ons/media/media-add-ons/radeon/Radeon.cpp

283

vw.address = address;

src/add-ons/media/media-add-ons/radeon/Radeon.h

351

int VIPRegister(int device, int address);

src/add-ons/media/media-add-ons/radeon/Radeon.h

353

void SetVIPRegister(int device, int address, int value);

src/add-ons/media/media-add-ons/radeon/Radeon.h

355

int VIPReadFifo(int device, uint32 address, uint32 count, uint8 *buffer);

src/add-ons/media/media-add-ons/radeon/Radeon.h

357

int VIPWriteFifo(int device, uint32 address, uint32 count, uint8 *buffer);

src/add-ons/media/media-add-ons/radeon/Theater200.cpp

1196

int CTheater200::ReadFifo( uint32 address, uint8 *buffer)

src/add-ons/media/media-add-ons/radeon/Theater200.cpp

1198

return fPort.ReadFifo(fDevice, address, 1, buffer);

src/add-ons/media/media-add-ons/radeon/Theater200.cpp

1201

int CTheater200::WriteFifo( uint32 address, uint32 count, uint8 *buffer)

src/add-ons/media/media-add-ons/radeon/Theater200.cpp

1203

return fPort.WriteFifo(fDevice, address, count, buffer);

src/add-ons/media/media-add-ons/radeon/Theater200.h

137

int ReadFifo(uint32 address, uint8 *buffer);

src/add-ons/media/media-add-ons/radeon/Theater200.h

139

int WriteFifo(uint32 address, uint32 count, uint8 *buffer);

src/add-ons/media/media-add-ons/radeon/VIPPort.h

53

int Register(int device, int address) {

src/add-ons/media/media-add-ons/radeon/VIPPort.h

54

return fRadeon.VIPRegister( device, address );

src/add-ons/media/media-add-ons/radeon/VIPPort.h

57

void SetRegister(int device, int address, int value) {

src/add-ons/media/media-add-ons/radeon/VIPPort.h

58

fRadeon.SetVIPRegister( device, address, value );

src/add-ons/media/media-add-ons/radeon/VIPPort.h

61

int ReadFifo(int device, uint32 address, uint32 count, uint8 *buffer) {

src/add-ons/media/media-add-ons/radeon/VIPPort.h

62

return fRadeon.VIPReadFifo( device, address, count, buffer );

src/add-ons/media/media-add-ons/radeon/VIPPort.h

65

int WriteFifo(int device, uint32 address, uint32 count, uint8 *buffer) {

src/add-ons/media/media-add-ons/radeon/VIPPort.h

66

return fRadeon.VIPWriteFifo( device, address, count, buffer );

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

333

CamDevice::WriteReg(uint16 address, uint8 *data, size_t count)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

340

CamDevice::WriteReg8(uint16 address, uint8 data)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

342

return WriteReg(address, &data, sizeof(uint8));

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

347

CamDevice::WriteReg16(uint16 address, uint16 data)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

353

return WriteReg(address, (uint8 *)&data, sizeof(uint16));

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

358

CamDevice::ReadReg(uint16 address, uint8 *data, size_t count, bool cached)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

365

CamDevice::OrReg8(uint16 address, uint8 data, uint8 mask)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

368

if (ReadReg(address, &value, 1, true) < 1)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

372

return WriteReg8(address, value);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

377

CamDevice::AndReg8(uint16 address, uint8 data)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

380

if (ReadReg(address, &value, 1, true) < 1)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

383

return WriteReg8(address, value);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

403

CamDevice::WriteIIC(uint8 address, uint8 *data, size_t count)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

410

CamDevice::WriteIIC8(uint8 address, uint8 data)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

412

return WriteIIC(address, &data, 1);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

417

CamDevice::WriteIIC16(uint8 address, uint16 data)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

423

return WriteIIC(address, (uint8 *)&data, 2);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

428

CamDevice::ReadIIC(uint8 address, uint8 *data)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

436

CamDevice::ReadIIC8(uint8 address, uint8 *data)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

438

return ReadIIC(address, data);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

443

CamDevice::ReadIIC16(uint8 address, uint16 *data)

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

100

virtual ssize_t WriteReg16(uint16 address, uint16 data);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

101

virtual ssize_t ReadReg(uint16 address, uint8 *data, size_t count=1, bool cached=false);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

103

ssize_t OrReg8(uint16 address, uint8 data, uint8 mask=0xff);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

104

ssize_t AndReg8(uint16 address, uint8 data);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

109

virtual ssize_t WriteIIC(uint8 address, uint8 *data, size_t count);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

110

virtual ssize_t WriteIIC8(uint8 address, uint8 data);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

111

virtual ssize_t WriteIIC16(uint8 address, uint16 data);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

112

virtual ssize_t ReadIIC(uint8 address, uint8 *data);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

113

virtual ssize_t ReadIIC8(uint8 address, uint8 *data);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

114

virtual ssize_t ReadIIC16(uint8 address, uint16 *data);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

98

virtual ssize_t WriteReg(uint16 address, uint8 *data, size_t count=1);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.h

99

virtual ssize_t WriteReg8(uint16 address, uint8 data);

src/add-ons/media/media-add-ons/usb_webcam/CamSensor.h

51

virtual status_t WriteReg(uint16 address, uint8 *data, size_t count=1);

src/add-ons/media/media-add-ons/usb_webcam/CamSensor.h

52

virtual status_t WriteReg8(uint16 address, uint8 data);

src/add-ons/media/media-add-ons/usb_webcam/CamSensor.h

53

virtual status_t WriteReg16(uint16 address, uint16 data);

src/add-ons/media/media-add-ons/usb_webcam/CamSensor.h

54

virtual status_t ReadReg(uint16 address, uint8 *data, size_t count=1, bool cached=false);

src/add-ons/media/media-add-ons/usb_webcam/CamSensor.h

57

virtual status_t WriteIIC(uint8 address, uint8 *data, size_t count=1);

src/add-ons/media/media-add-ons/usb_webcam/CamSensor.h

58

virtual status_t ReadIIC(uint8 address, uint8 *data);

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

139

NW80xCamDevice::WriteReg(uint16 address, uint8 *data, size_t count)

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

141

PRINT((CH "(%u, @%p, %" B_PRIuSIZE ")" CT, address, data, count));

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

142

return SendCommand(USB_REQTYPE_DEVICE_OUT, 0x04, address, 0, count, data);

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

147

NW80xCamDevice::ReadReg(uint16 address, uint8 *data, size_t count, bool cached)

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

149

PRINT((CH "(%u, @%p, %" B_PRIuSIZE ", %d)" CT, address, data, count,

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

152

return SendCommand(USB_REQTYPE_DEVICE_IN, 0x04, address, 0, count, data);

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

178

NW80xCamDevice::WriteIIC(uint8 address, uint8 *data, size_t count)

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

189

buffer[i] = address + i;

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

197

NW80xCamDevice::ReadIIC(uint8 address, uint8 *data)

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

199

return ReadIIC(address, data);

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

204

NW80xCamDevice::ReadIIC8(uint8 address, uint8 *data)

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

212

buffer[0] = address;

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

231

NW80xCamDevice::ReadIIC16(uint8 address, uint16 *data)

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.cpp

239

buffer[0] = address;

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.h

39

virtual ssize_t WriteReg(uint16 address, uint8 *data, size_t count=1);

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.h

40

virtual ssize_t ReadReg(uint16 address, uint8 *data, size_t count=1, bool cached=false);

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.h

45

virtual ssize_t WriteIIC(uint8 address, uint8 *data, size_t count=1);

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.h

46

virtual ssize_t ReadIIC(uint8 address, uint8 *data);

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.h

47

virtual ssize_t ReadIIC8(uint8 address, uint8 *data);

src/add-ons/media/media-add-ons/usb_webcam/addons/NW80xCamDevice.h

48

virtual ssize_t ReadIIC16(uint8 address, uint16 *data);

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

104

QuickCamDevice::WriteReg(uint16 address, uint8 *data, size_t count)

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

106

PRINT((CH "(%u, @%p, %" B_PRIuSIZE ")" CT, address, data, count));

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

107

return SendCommand(USB_REQTYPE_DEVICE_OUT, 0x04, address, 0, count, data);

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

112

QuickCamDevice::ReadReg(uint16 address, uint8 *data, size_t count, bool cached)

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

114

PRINT((CH "(%u, @%p, %" B_PRIuSIZE ", %d)" CT, address, data, count,

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

117

return SendCommand(USB_REQTYPE_DEVICE_IN, 0x04, address, 0, count, data);

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

143

QuickCamDevice::WriteIIC(uint8 address, uint8 *data, size_t count)

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

154

buffer[i] = address + i;

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

162

QuickCamDevice::ReadIIC(uint8 address, uint8 *data)

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

164

return ReadIIC(address, data);

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

169

QuickCamDevice::ReadIIC8(uint8 address, uint8 *data)

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

177

buffer[0] = address;

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

196

QuickCamDevice::ReadIIC16(uint8 address, uint16 *data)

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.cpp

204

buffer[0] = address;

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.h

39

virtual ssize_t WriteReg(uint16 address, uint8 *data, size_t count=1);

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.h

40

virtual ssize_t ReadReg(uint16 address, uint8 *data, size_t count=1, bool cached=false);

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.h

45

virtual ssize_t WriteIIC(uint8 address, uint8 *data, size_t count=1);

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.h

46

virtual ssize_t ReadIIC(uint8 address, uint8 *data);

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.h

47

virtual ssize_t ReadIIC8(uint8 address, uint8 *data);

src/add-ons/media/media-add-ons/usb_webcam/addons/quickcam/QuickCamDevice.h

48

virtual ssize_t ReadIIC16(uint8 address, uint16 *data);

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

290

SonixCamDevice::WriteReg(uint16 address, uint8 *data, size_t count)

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

292

PRINT((CH "(%u, @%p, %" B_PRIuSIZE ")" CT, address, data, count));

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

294

if (address + count > SN9C102_REG_COUNT) {

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

295

PRINT((CH ": Invalid register range [%u;%" B_PRIuSIZE "]" CT, address,

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

296

address + count));

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

299

memcpy(&fCachedRegs[address], data, count);

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

300

err = SendCommand(USB_REQTYPE_DEVICE_OUT, 0x08, address, 0, count, data);

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

308

SonixCamDevice::ReadReg(uint16 address, uint8 *data, size_t count, bool cached)

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

310

PRINT((CH "(%u, @%p, %" B_PRIuSIZE ", %d)" CT, address, data, count,

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

313

if (address + count > SN9C102_REG_COUNT) {

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

314

PRINT((CH ": Invalid register range [%u;%" B_PRIuSIZE "]" CT, address,

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

315

address + count));

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

319

memcpy(data, &fCachedRegs[address], count);

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

322

err = SendCommand(USB_REQTYPE_DEVICE_IN, 0x00, address, 0, count, data);

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

363

SonixCamDevice::WriteIIC(uint8 address, uint8 *data, size_t count)

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

367

PRINT((CH "(%u, @%p, %" B_PRIuSIZE ")" CT, address, data, count));

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

378

buffer[2] = address;

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

404

SonixCamDevice::ReadIIC(uint8 address, uint8 *data)

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

408

PRINT((CH "(%u, @%p)" CT, address, data));

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.cpp

416

buffer[2] = address;

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.h

70

virtual ssize_t WriteReg(uint16 address, uint8 *data, size_t count=1);

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.h

71

virtual ssize_t ReadReg(uint16 address, uint8 *data, size_t count=1, bool cached=false);

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.h

76

virtual ssize_t WriteIIC(uint8 address, uint8 *data, size_t count=1);

src/add-ons/media/media-add-ons/usb_webcam/addons/sonix/SonixCamDevice.h

77

virtual ssize_t ReadIIC(uint8 address, uint8 *data);

src/add-ons/network_settings/dnsclient/DNSSettingsView.cpp

165

const char* address = fTextControl->Text();

src/add-ons/network_settings/dnsclient/DNSSettingsView.cpp

166

fServerListView->AddItem(new BStringItem(address));

src/add-ons/network_settings/dnsclient/DNSSettingsView.cpp

224

char* address = inet_ntoa(state.nsaddr_list[i].sin_addr);

src/add-ons/network_settings/dnsclient/DNSSettingsView.cpp

225

fServerListView->AddItem(new BStringItem(address));

src/add-ons/network_settings/dnsclient/DNSSettingsView.cpp

226

fRevertList.Add(address);

src/add-ons/print/transports/hp_jetdirect/HPJetDirectTransport.cpp

30

BString address;

src/add-ons/print/transports/hp_jetdirect/HPJetDirectTransport.cpp

32

if (printer->ReadAttrString("transport_address", &address) < 0

src/add-ons/print/transports/hp_jetdirect/HPJetDirectTransport.cpp

33

|| address.Length() == 0) {

src/add-ons/print/transports/hp_jetdirect/HPJetDirectTransport.cpp

39

if (printer->ReadAttrString("transport_address", &address) < 0)

src/add-ons/print/transports/hp_jetdirect/HPJetDirectTransport.cpp

42

printf("address = %s\n", address.String());

src/add-ons/print/transports/hp_jetdirect/HPJetDirectTransport.cpp

44

int32 index = address.FindLast(':');

src/add-ons/print/transports/hp_jetdirect/HPJetDirectTransport.cpp

46

fPort = atoi(address.String() + index + 1);

src/add-ons/print/transports/hp_jetdirect/HPJetDirectTransport.cpp

47

address.MoveInto(fHost, 0, index);

src/add-ons/print/transports/hp_jetdirect/HPJetDirectTransport.cpp

49

fHost = address;

src/add-ons/print/transports/parallel_port/ParallelTransport.cpp

58

char address[80];

src/add-ons/print/transports/parallel_port/ParallelTransport.cpp

62

unsigned int size = printer->ReadAttr("transport_address", B_STRING_TYPE, 0, address, sizeof(address));

src/add-ons/print/transports/parallel_port/ParallelTransport.cpp

63

if (size <= 0 || size >= sizeof(address)) return;

src/add-ons/print/transports/parallel_port/ParallelTransport.cpp

64

address[size] = 0; // make sure string is 0-terminated

src/add-ons/print/transports/parallel_port/ParallelTransport.cpp

66

strcat(strcpy(device, "/dev/parallel/"), address);

src/add-ons/print/transports/serial_port/SerialTransport.cpp

40

char address[80];

src/add-ons/print/transports/serial_port/SerialTransport.cpp

45

address, sizeof(address));

src/add-ons/print/transports/serial_port/SerialTransport.cpp

46

if (size <= 0 || size >= sizeof(address)) return;

src/add-ons/print/transports/serial_port/SerialTransport.cpp

47

address[size] = 0; // make sure string is 0-terminated

src/add-ons/print/transports/serial_port/SerialTransport.cpp

49

strcat(strcpy(device, "/dev/ports/"), address);

src/apps/debuganalyzer/model_loader/ModelLoader.cpp

110

IOOperation* FindOperation(void* address) const

src/apps/debuganalyzer/model_loader/ModelLoader.cpp

115

if (operation->startedEvent->operation == address)

src/apps/debugger/user_interface/cli/CliContext.cpp

299

SourceLanguage* language, target_addr_t& address)

src/apps/debugger/user_interface/cli/CliContext.cpp

319

address = variantValue.ToUInt64();

src/apps/debugger/user_interface/cli/CliContext.cpp

335

CliContext::GetMemoryBlock(target_addr_t address, TeamMemoryBlock*& block)

src/apps/debugger/user_interface/cli/CliContext.cpp

338

if (fCurrentBlock == NULL || !fCurrentBlock->Contains(address)) {

src/apps/debugger/user_interface/cli/CliContext.cpp

339

GetUserInterfaceListener()->InspectRequested(address, this);

src/apps/debugger/user_interface/cli/CliContext.h

86

SourceLanguage* language, target_addr_t& address);

src/apps/debugger/user_interface/cli/CliContext.h

88

status_t GetMemoryBlock(target_addr_t address,

src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp

73

target_addr_t address;

src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp

74

if (context.EvaluateExpression(argv[1], fLanguage, address) != B_OK)

src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp

78

if (context.GetMemoryBlock(address, block) != B_OK)

src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp

94

UiUtils::DumpMemory(output, 0, block, address, itemSize, displayWidth,

src/apps/debugger/user_interface/cli/commands/CliDumpStringCommand.cpp

62

target_addr_t address;

src/apps/debugger/user_interface/cli/commands/CliDumpStringCommand.cpp

63

if (context.EvaluateExpression(argv[1], fLanguage, address) != B_OK)

src/apps/debugger/user_interface/cli/commands/CliDumpStringCommand.cpp

67

if (context.GetMemoryBlock(address, block) != B_OK)

src/apps/debugger/user_interface/cli/commands/CliDumpStringCommand.cpp

70

printf("%p \"", (char*)address);

src/apps/debugger/user_interface/cli/commands/CliDumpStringCommand.cpp

72

target_addr_t offset = address;

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

256

target_addr_t address = 0;

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

257

if (message->FindUInt64("address", &address) != B_OK) {

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

266

_SetToAddress(address);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

305

target_addr_t address = fCurrentBlock->BaseAddress();

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

307

address -= fCurrentBlock->Size();

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

309

address += fCurrentBlock->Size();

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

312

setMessage.AddUInt64("address", address);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

356

target_addr_t address;

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

357

if (message->FindUInt64("address", &address) == B_OK

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

358

&& address >= fCurrentBlock->BaseAddress()

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

359

&& address < fCurrentBlock->BaseAddress()

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

363

fListener->InspectRequested(address, this);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

448

InspectorWindow::TargetAddressChanged(target_addr_t address)

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

452

fCurrentAddress = address;

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

454

computedAddress.SetToFormat("0x%" B_PRIx64, address);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

610

InspectorWindow::_SetToAddress(target_addr_t address)

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

612

fCurrentAddress = address;

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

614

|| !fCurrentBlock->Contains(address)) {

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

615

fListener->InspectRequested(address, this);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp

617

fMemoryView->SetTargetAddress(fCurrentBlock, address);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.h

58

virtual void TargetAddressChanged(target_addr_t address);

src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.h

82

void _SetToAddress(target_addr_t address);

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

100

fTargetAddress = address;

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

1071

target_addr_t address;

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

1073

address = *((uint32*)(fTargetBlock->Data() + fSelectionStart));

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

1075

address = *((uint64*)(fTargetBlock->Data() + fSelectionStart));

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

1078

address = B_HOST_TO_BENDIAN_INT64(address);

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

1080

address = B_HOST_TO_LENDIAN_INT64(address);

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

1083

message->AddUInt64("address", address);

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

738

const char* address) const

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

744

*((const uint8*)address));

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

749

uint16 data = *((const uint16*)address);

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

770

uint32 data = *((const uint32*)address);

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

791

uint64 data = *((const uint64*)address);

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.cpp

98

MemoryView::SetTargetAddress(TeamMemoryBlock* block, target_addr_t address)

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.h

154

virtual void TargetAddressChanged(target_addr_t address)

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.h

59

target_addr_t address);

src/apps/debugger/user_interface/gui/inspector_window/MemoryView.h

95

const char* address) const;

src/apps/debugger/user_interface/gui/team_settings_window/ExceptionStopConfigView.cpp

126

target_addr_t address;

src/apps/debugger/user_interface/gui/team_settings_window/ExceptionStopConfigView.cpp

127

if (_FindExceptionFunction(info, address) != B_OK)

src/apps/debugger/user_interface/gui/team_settings_window/ExceptionStopConfigView.cpp

131

fListener->SetBreakpointRequested(address, true, true);

src/apps/debugger/user_interface/gui/team_settings_window/ExceptionStopConfigView.cpp

133

fListener->ClearBreakpointRequested(address);

src/apps/debugger/user_interface/gui/team_settings_window/ExceptionStopConfigView.cpp

167

target_addr_t address;

src/apps/debugger/user_interface/gui/team_settings_window/ExceptionStopConfigView.cpp

168

if (_FindExceptionFunction(info, address) != B_OK)

src/apps/debugger/user_interface/gui/team_settings_window/ExceptionStopConfigView.cpp

171

if (fTeam->BreakpointAtAddress(address) != NULL) {

src/apps/debugger/user_interface/gui/team_window/ImageFunctionsView.cpp

312

target_addr_t address = instance->Address();

src/apps/debugger/user_interface/gui/team_window/ImageFunctionsView.cpp

313

if (functionAddresses.find(address) != functionAddresses.end())

src/apps/debugger/user_interface/gui/team_window/ImageFunctionsView.cpp

317

functionAddresses.insert(address);

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

1043

target_addr_t address = marker != NULL

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

1049

fListener->ClearBreakpointRequested(address);

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

1051

fListener->SetBreakpointRequested(address, false);

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

1054

fListener->ClearBreakpointRequested(address);

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

1056

fListener->SetBreakpointRequested(address, true);

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

1997

target_addr_t address = statement->CoveringAddressRange().Start();

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

2003

address)) {

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

2008

MSG_THREAD_SET_ADDRESS, address)) {

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

2038

const char* text, uint32 what, target_addr_t address) const

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

2045

message->AddUInt64("address", address);

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

2118

target_addr_t address;

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

2119

if (message->FindUInt64("address", &address) != B_OK)

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

2122

address);

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

2322

SourceView::ScrollToAddress(target_addr_t address)

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

2324

TRACE_GUI("SourceView::ScrollToAddress(%#" B_PRIx64 ")\n", address);

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

2333

if (fTeam->GetStatementAtAddress(address, functionInstance,

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

271

target_addr_t address,

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

395

target_addr_t address) const;

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

587

target_addr_t address, UserBreakpoint* breakpoint)

src/apps/debugger/user_interface/gui/team_window/SourceView.cpp

590

fAddress(address),

src/apps/debugger/user_interface/gui/team_window/SourceView.h

108

target_addr_t address, bool enabled) = 0;

src/apps/debugger/user_interface/gui/team_window/SourceView.h

110

target_addr_t address) = 0;

src/apps/debugger/user_interface/gui/team_window/SourceView.h

112

uint32 action, target_addr_t address) = 0;

src/apps/debugger/user_interface/gui/team_window/SourceView.h

51

bool ScrollToAddress(target_addr_t address);

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

483

target_addr_t address;

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

484

if (message->FindUInt64("address", &address) == B_OK) {

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

486

addressMessage.AddUInt64("address", address);

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

600

target_addr_t address;

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

604

if (message->FindUInt64("address", &address) != B_OK

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

612

fTeam->GetArchitecture(), address, type, length,

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

955

TeamWindow::SetBreakpointRequested(target_addr_t address, bool enabled)

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

957

fListener->SetBreakpointRequested(address, enabled);

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

962

TeamWindow::ClearBreakpointRequested(target_addr_t address)

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

964

fListener->ClearBreakpointRequested(address);

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

970

target_addr_t address)

src/apps/debugger/user_interface/gui/team_window/TeamWindow.cpp

973

fListener->ThreadActionRequested(thread->ID(), action, address);

src/apps/debugger/user_interface/gui/team_window/TeamWindow.h

127

virtual void SetBreakpointRequested(target_addr_t address,

src/apps/debugger/user_interface/gui/team_window/TeamWindow.h

130

target_addr_t address);

src/apps/debugger/user_interface/gui/team_window/TeamWindow.h

132

uint32 action, target_addr_t address);

src/apps/debugger/user_interface/gui/team_window/VariablesView.cpp

1457

data.SetToFormat("[@ %#" B_PRIx64 "]", piece.address);

src/apps/debugger/user_interface/gui/team_window/VariablesView.cpp

1562

i, piece.address, piece.size);

src/apps/debugger/user_interface/gui/team_window/VariablesView.cpp

2153

looperMessage.AddUInt64("address", piece.address);

src/apps/debugger/user_interface/gui/team_window/VariablesView.cpp

2665

message->AddUInt64("address", location->PieceAt(0).address);

src/apps/debugger/user_interface/gui/utility_windows/WatchPromptWindow.cpp

29

target_addr_t address, uint32 type, int32 length,

src/apps/debugger/user_interface/gui/utility_windows/WatchPromptWindow.cpp

34

fInitialAddress(address),

src/apps/debugger/user_interface/gui/utility_windows/WatchPromptWindow.cpp

72

WatchPromptWindow::Create(Architecture* architecture, target_addr_t address,

src/apps/debugger/user_interface/gui/utility_windows/WatchPromptWindow.cpp

75

WatchPromptWindow* self = new WatchPromptWindow(architecture, address,

src/apps/debugger/user_interface/gui/utility_windows/WatchPromptWindow.h

27

target_addr_t address, uint32 type,

src/apps/debugger/user_interface/gui/utility_windows/WatchPromptWindow.h

34

target_addr_t address, uint32 type,

src/apps/mail/AddressTextControl.cpp

755

BString address;

src/apps/mail/AddressTextControl.cpp

756

node.ReadAttrString(buffer, &address);

src/apps/mail/AddressTextControl.cpp

757

if (address.Length() <= 0)

src/apps/mail/AddressTextControl.cpp

762

itemMsg->AddString("email", address.String());

src/apps/mail/AddressTextControl.cpp

765

address.String(), itemMsg);

src/apps/mail/AddressTextControl.cpp

788

BString address;

src/apps/mail/AddressTextControl.cpp

791

address = email;

src/apps/mail/AddressTextControl.cpp

794

address << "\"" << name << "\" <" << email << ">";

src/apps/mail/AddressTextControl.cpp

797

_AddAddress(address);

src/apps/mail/MailWindow.cpp

1495

const char* address;

src/apps/mail/MailWindow.cpp

1497

if (msg->FindString("address", (const char**)&address) != B_OK)

src/apps/mail/MailWindow.cpp

1509

+ strlen(address) + 1);

src/apps/mail/MailWindow.cpp

1510

sprintf(arg, "META:email=%s", address);

src/apps/mail/MailWindow.cpp

1541

_CreateNewPerson(address, name);

src/apps/mail/MailWindow.cpp

2358

BString address(mail->From());

src/apps/mail/MailWindow.cpp

2359

if (address.Length() <= 0)

src/apps/mail/MailWindow.cpp

2360

address = B_TRANSLATE("(Address unavailable)");

src/apps/mail/MailWindow.cpp

2367

preamble.ReplaceAll("%e", address);

src/apps/mail/MailWindow.cpp

3133

char* address = (char*)addressList.RemoveItem((int32)0);

src/apps/mail/MailWindow.cpp

3139

if (!strcmp(address, item->Label())) {

src/apps/mail/MailWindow.cpp

3144

if (strcmp(address, item->Label()) < 0)

src/apps/mail/MailWindow.cpp

3151

msg->AddString("address", address);

src/apps/mail/MailWindow.cpp

3153

fSaveAddrMenu->AddItem(new BMenuItem(address, msg), index);

src/apps/mail/MailWindow.cpp

3156

free(address);

src/apps/mail/MailWindow.cpp

3422

TMailWindow::_CreateNewPerson(BString address, BString name)

src/apps/mail/MailWindow.cpp

3426

message.AddString("META:email", address);

src/apps/mail/MailWindow.h

137

void _CreateNewPerson(BString address, BString name);

src/apps/mail/People.cpp

138

const BString& address = person->AddressAt(addressIndex);

src/apps/mail/People.cpp

140

if (itemAddress != address) {

src/apps/mediaplayer/media_node_framework/video/VideoConsumer.cpp

234

info.offset = bits - (uint8*)bitmapAreaInfo.address;

src/apps/networkstatus/NetworkStatusView.cpp

260

BNetworkAddress address;

src/apps/networkstatus/NetworkStatusView.cpp

263

&& message->FindFlat("address", &address) == B_OK) {

src/apps/networkstatus/NetworkStatusView.cpp

265

status_t status = device.JoinNetwork(address);

src/apps/networkstatus/NetworkStatusView.cpp

340

BNetworkInterfaceAddress address;

src/apps/networkstatus/NetworkStatusView.cpp

341

networkInterface.GetAddressAt(i, address);

src/apps/networkstatus/NetworkStatusView.cpp

342

switch (address.Address().Family()) {

src/apps/networkstatus/NetworkStatusView.cpp

345

<< address.Address().ToString()

src/apps/networkstatus/NetworkStatusView.cpp

347

<< address.Broadcast().ToString()

src/apps/networkstatus/NetworkStatusView.cpp

349

<< address.Mask().ToString()

src/apps/networkstatus/NetworkStatusView.cpp

354

<< address.Address().ToString()

src/apps/networkstatus/NetworkStatusView.cpp

355

<< "/" << address.Mask().PrefixLength()

src/apps/networkstatus/NetworkStatusView.cpp

405

BNetworkAddress address;

src/apps/networkstatus/NetworkStatusView.cpp

407

while (device.GetNextAssociatedNetwork(cookie, address) == B_OK)

src/apps/networkstatus/NetworkStatusView.cpp

408

associated.insert(address);

src/apps/networkstatus/NetworkStatusView.cpp

418

message->AddFlat("address", &network.address);

src/apps/networkstatus/NetworkStatusView.cpp

422

if (associated.find(network.address) != associated.end())

src/apps/poorman/PoorManWindow.cpp

216

const char* address;

src/apps/poorman/PoorManWindow.cpp

230

if (message->FindString("addr", &address) != B_OK)

src/apps/poorman/PoorManWindow.cpp

231

address = NULL;

src/apps/poorman/PoorManWindow.cpp

246

if (address != NULL) {

src/apps/poorman/PoorManWindow.cpp

247

line << '(' << address << ") ";

src/apps/terminal/HyperLink.cpp

25

HyperLink::HyperLink(const BString& address, Type type)

src/apps/terminal/HyperLink.cpp

27

fText(address),

src/apps/terminal/HyperLink.cpp

28

fAddress(address),

src/apps/terminal/HyperLink.cpp

36

HyperLink::HyperLink(const BString& text, const BString& address, Type type)

src/apps/terminal/HyperLink.cpp

39

fAddress(address),

src/apps/terminal/HyperLink.cpp

47

HyperLink::HyperLink(const BString& address, uint32 ref, const BString& id)

src/apps/terminal/HyperLink.cpp

50

fAddress(address),

src/apps/terminal/HyperLink.cpp

65

BString address(fAddress);

src/apps/terminal/HyperLink.cpp

66

address.CharacterEscape(kShellEscapeCharacters, '\\');

src/apps/terminal/HyperLink.cpp

68

commandLine.SetToFormat("/bin/open %s", address.String());

src/apps/terminal/HyperLink.h

24

HyperLink(const BString& address, Type type);

src/apps/terminal/HyperLink.h

26

const BString& address, Type type);

src/apps/terminal/HyperLink.h

27

HyperLink(const BString& address, uint32 ref, const BString& id);

src/apps/terminal/TermViewStates.cpp

991

BString address = path == actualPath

src/apps/terminal/TermViewStates.cpp

994

_link = HyperLink(text, address,

src/bin/debug/profile/BasicProfileResult.cpp

299

addr_t address = samples[i];

src/bin/debug/profile/BasicProfileResult.cpp

302

container->FindImage(address, loadDelta));

src/bin/debug/profile/BasicProfileResult.cpp

305

symbol = image->GetImage()->FindSymbol(address - loadDelta);

src/bin/debug/profile/BasicProfileResult.cpp

343

addr_t address = samples[k];

src/bin/debug/profile/BasicProfileResult.cpp

346

container->FindImage(address, loadDelta));

src/bin/debug/profile/BasicProfileResult.cpp

348

if (image->AddHit(address - loadDelta))

src/bin/debug/profile/BasicProfileResult.cpp

67

BasicImageProfileResult::AddHit(addr_t address)

src/bin/debug/profile/BasicProfileResult.cpp

69

int32 symbolIndex = fImage->FindSymbol(address);

src/bin/debug/profile/BasicProfileResult.h

21

inline bool AddHit(addr_t address);

src/bin/debug/profile/CallgrindProfileResult.cpp

144

addr_t address = samples[i];

src/bin/debug/profile/CallgrindProfileResult.cpp

148

container->FindImage(address, loadDelta));

src/bin/debug/profile/CallgrindProfileResult.cpp

151

symbol = image->GetImage()->FindSymbol(address - loadDelta);

src/bin/debug/profile/Image.h

105

Image::ContainsAddress(addr_t address) const

src/bin/debug/profile/Image.h

107

return fImage->ContainsAddress(address - fLoadDelta);

src/bin/debug/profile/Image.h

112

Image::FindSymbol(addr_t address) const

src/bin/debug/profile/Image.h

114

return fImage->FindSymbol(address - fLoadDelta);

src/bin/debug/profile/Image.h

32

inline bool ContainsAddress(addr_t address) const;

src/bin/debug/profile/Image.h

33

inline int32 FindSymbol(addr_t address) const;

src/bin/debug/profile/ProfileResult.h

50

virtual ImageProfileResult* FindImage(addr_t address,

src/bin/debug/profile/SharedImage.cpp

101

SharedImage::FindSymbol(addr_t address) const

src/bin/debug/profile/SharedImage.cpp

109

if (address >= fSymbols[mid]->base + fSymbols[mid]->size)

src/bin/debug/profile/SharedImage.cpp

119

if (address >= symbol->base && address < symbol->base + symbol->size)

src/bin/debug/profile/SharedImage.h

107

SharedImage::ContainsAddress(addr_t address) const

src/bin/debug/profile/SharedImage.h

109

return (address >= (addr_t)fInfo.text && address < ((addr_t)fInfo.text + fInfo.text_size))

src/bin/debug/profile/SharedImage.h

110

|| (address >= (addr_t)fInfo.data && address < ((addr_t)fInfo.data + fInfo.data_size));

src/bin/debug/profile/SharedImage.h

62

inline bool ContainsAddress(addr_t address) const;

src/bin/debug/profile/SharedImage.h

63

int32 FindSymbol(addr_t address) const;

src/bin/debug/profile/SummaryProfileResult.cpp

158

SummaryProfileResult::FindImage(addr_t address, addr_t& _loadDelta) const

src/bin/debug/profile/SummaryProfileResult.h

87

virtual ImageProfileResult* FindImage(addr_t address,

src/bin/debug/profile/Thread.cpp

276

Thread::FindImage(addr_t address, addr_t& _loadDelta) const

src/bin/debug/profile/Thread.cpp

280

if (image->GetImage()->ContainsAddress(address)) {

src/bin/debug/profile/Thread.h

80

virtual ImageProfileResult* FindImage(addr_t address,

src/bin/debug/profile/profile.cpp

821

= (system_profiler_buffer_header*)info.address;

src/bin/debug/scheduling_recorder/scheduling_recorder.cpp

228

= (system_profiler_buffer_header*)info.address;

src/bin/debug/strace/Context.cpp

77

Context::FormatPointer(const void *address) const

src/bin/debug/strace/Context.cpp

80

sprintf(buffer, "%p", address);

src/bin/debug/strace/Context.h

44

const void *address = GetValue(param);

src/bin/debug/strace/Context.h

46

return value_t(*(align_t*)address);

src/bin/debug/strace/Context.h

48

return *(value_t*)address;

src/bin/debug/strace/Context.h

62

string FormatPointer(const void *address) const;

src/bin/debug/strace/MemoryReader.cpp

53

char *address = (char*)_address;

src/bin/debug/strace/MemoryReader.cpp

63

status_t error = _Read(address, buffer, toRead, actuallyRead);

src/bin/debug/strace/MemoryReader.cpp

73

address += actuallyRead;

src/bin/debug/strace/MemoryReader.cpp

83

MemoryReader::_Read(void *address, void *buffer, int32 size, int32 &bytesRead)

src/bin/debug/strace/MemoryReader.cpp

88

message.address = address;

src/bin/debug/strace/MemoryReader.h

19

status_t Read(void *address, void *buffer, int32 size,

src/bin/debug/strace/MemoryReader.h

23

status_t _Read(void *address, void *buffer, int32 size,

src/bin/debug/strace/NetworkTypes.cpp

153

format_pointer_value(Context &context, void *address)

src/bin/debug/strace/NetworkTypes.cpp

157

if (obtain_pointer_data(context, &data, address, Context::COMPLEX_STRUCTS))

src/bin/debug/strace/NetworkTypes.cpp

160

return context.FormatPointer(address);

src/bin/debug/strace/NetworkTypes.cpp

21

obtain_pointer_data(Context &context, Type *data, void *address, uint32 what)

src/bin/debug/strace/NetworkTypes.cpp

23

if (address == NULL || !context.GetContents(what))

src/bin/debug/strace/NetworkTypes.cpp

274

read_sockaddr(Context &context, Parameter *param, void *address)

src/bin/debug/strace/NetworkTypes.cpp

278

return context.FormatPointer(address);

src/bin/debug/strace/NetworkTypes.cpp

28

status_t err = context.Reader().Read(address, data, sizeof(Type), bytesRead);

src/bin/debug/strace/NetworkTypes.cpp

285

return context.FormatPointer(address);

src/bin/debug/strace/NetworkTypes.cpp

288

status_t err = context.Reader().Read(address, &data, addrlen, bytesRead);

src/bin/debug/strace/NetworkTypes.cpp

290

return context.FormatPointer(address);

src/bin/debug/strace/NetworkTypes.cpp

299

Parameter *param, const void *address)

src/bin/debug/strace/NetworkTypes.cpp

301

void *data = *(void **)address;

src/bin/debug/strace/NetworkTypes.cpp

408

const void *address)

src/bin/debug/strace/NetworkTypes.cpp

410

return format_pointer_value<Type>(context, *(void **)address);

src/bin/debug/strace/NetworkTypes.cpp

79

const void *address)

src/bin/debug/strace/NetworkTypes.cpp

82

return format_iovecs(context, (const iovec*)*(void **)address,

src/bin/debug/strace/TypeHandler.cpp

109

string GetParameterValue(Context &context, Parameter *, const void *address)

src/bin/debug/strace/TypeHandler.cpp

111

return RenderValue(context, get_value<T>(address));

src/bin/debug/strace/TypeHandler.cpp

169

const void *address)

src/bin/debug/strace/TypeHandler.cpp

171

return context.FormatPointer(*(void **)address);

src/bin/debug/strace/TypeHandler.cpp

185

const void *address)

src/bin/debug/strace/TypeHandler.cpp

187

return read_string(context, *(void **)address);

src/bin/debug/strace/TypeHandler.cpp

205

const void *address)

src/bin/debug/strace/TypeHandler.cpp

207

return RenderValue(context, get_value<unsigned int>(address));

src/bin/debug/strace/TypeHandler.cpp

23

get_value(const void *address)

src/bin/debug/strace/TypeHandler.cpp

232

const void *address)

src/bin/debug/strace/TypeHandler.cpp

234

return RenderValue(context, get_value<unsigned int>(address));

src/bin/debug/strace/TypeHandler.cpp

26

return value_t(*(align_t*)address);

src/bin/debug/strace/TypeHandler.cpp

28

return *(value_t*)address;

src/bin/debug/strace/TypeHandler.cpp

321

const void *address)

src/bin/debug/strace/TypeHandler.cpp

331

return target->GetParameterValue(context, param, address);

src/bin/debug/strace/TypeHandler.cpp

342

obtain_pointer_data(Context &context, Type *data, void *address, uint32 what)

src/bin/debug/strace/TypeHandler.cpp

344

if (address == NULL || !context.GetContents(what))

src/bin/debug/strace/TypeHandler.cpp

349

status_t err = context.Reader().Read(address, data, sizeof(Type), bytesRead);

src/bin/debug/strace/TypeHandler.cpp

358

format_signed_integer_pointer(Context &context, void *address, uint32 count)

src/bin/debug/strace/TypeHandler.cpp

362

if (obtain_pointer_data(context, &data, address, Context::POINTER_VALUES)) {

src/bin/debug/strace/TypeHandler.cpp

365

address = (void*)((Type*)address + 1);

src/bin/debug/strace/TypeHandler.cpp

366

obtain_pointer_data(context, &data, address, Context::POINTER_VALUES);

src/bin/debug/strace/TypeHandler.cpp

372

return context.FormatPointer(address);

src/bin/debug/strace/TypeHandler.cpp

377

format_unsigned_integer_pointer(Context &context, void *address, uint32 count)

src/bin/debug/strace/TypeHandler.cpp

381

if (obtain_pointer_data(context, &data, address, Context::POINTER_VALUES)) {

src/bin/debug/strace/TypeHandler.cpp

384

address = (void*)((Type*)address + 1);

src/bin/debug/strace/TypeHandler.cpp

385

obtain_pointer_data(context, &data, address, Context::POINTER_VALUES);

src/bin/debug/strace/TypeHandler.cpp

392

return context.FormatPointer(address);

src/bin/debug/strace/TypeHandler.cpp

399

const void *address)

src/bin/debug/strace/TypeHandler.cpp

401

return context.FormatSigned(get_value<Type>(address), sizeof(Type));

src/bin/debug/strace/TypeHandler.cpp

414

const void *address)

src/bin/debug/strace/TypeHandler.cpp

416

return context.FormatUnsigned(get_value<Type>(address));

src/bin/debug/strace/TypeHandler.cpp

428

const void *address)

src/bin/debug/strace/TypeHandler.cpp

430

return format_signed_integer_pointer<Type>(context, *(void **)address,

src/bin/debug/strace/TypeHandler.cpp

443

const void *address)

src/bin/debug/strace/TypeHandler.cpp

445

return format_unsigned_integer_pointer<Type>(context, *(void **)address,

src/bin/debug/strace/TypeHandler.cpp

83

const void *address)

src/bin/debug/strace/TypeHandler.cpp

85

return (*(const align_t*)address ? "true" : "false");

src/bin/debug/strace/events.cpp

131

const void *address)

src/bin/debug/strace/events.cpp

133

void *data = *(void **)address;

src/bin/debug/strace/events.cpp

199

const void *address)

src/bin/debug/strace/events.cpp

201

void *data = *(void **)address;

src/bin/debug/strace/events.cpp

262

const void *address)

src/bin/debug/strace/events.cpp

264

void *data = *(void **)address;

src/bin/debug/strace/events.cpp

339

const void *address)

src/bin/debug/strace/events.cpp

341

void *data = *(void **)address;

src/bin/debug/strace/exec.cpp

23

const void *address)

src/bin/debug/strace/exec.cpp

61

err = context.Reader().Read(*(void **)address, flatArgs, flatArgsSize,

src/bin/debug/strace/exec.cpp

96

return context.FormatPointer(address);

src/bin/debug/strace/file.cpp

110

const void *address)

src/bin/debug/strace/file.cpp

112

void *data = *(void **)address;

src/bin/debug/strace/mutex.cpp

52

const void *address)

src/bin/debug/strace/mutex.cpp

54

void *data = *(void **)address;

src/bin/debug/strace/rlimit.cpp

70

read_rlimit(Context &context, Parameter *param, void *address)

src/bin/debug/strace/rlimit.cpp

81

status_t err = context.Reader().Read(address, &data, sizeof(struct rlimit), bytesRead);

src/bin/debug/strace/rlimit.cpp

83

return context.FormatPointer(address);

src/bin/debug/strace/rlimit.cpp

92

const void *address)

src/bin/debug/strace/rlimit.cpp

94

void *data = *(void **)address;

src/bin/debug/strace/signals.cpp

282

const void *address)

src/bin/debug/strace/signals.cpp

284

void *data = *(void **)address;

src/bin/listarea.c

66

areaInfo.address,

src/bin/network/arp/arp.cpp

159

in_addr address;

src/bin/network/arp/arp.cpp

160

address.s_addr = control.address;

src/bin/network/arp/arp.cpp

161

printf("%15s %s", inet_ntoa(address),

src/bin/network/arp/arp.cpp

194

list_entries(sockaddr_in *address)

src/bin/network/arp/arp.cpp

199

if (address != NULL) {

src/bin/network/arp/arp.cpp

200

control.address = address->sin_addr.s_addr;

src/bin/network/arp/arp.cpp

221

delete_entry(sockaddr_in *address)

src/bin/network/arp/arp.cpp

224

control.address = address->sin_addr.s_addr;

src/bin/network/arp/arp.cpp

237

set_entry(sockaddr_in *address, uint8 *ethernetAddress, uint32 flags)

src/bin/network/arp/arp.cpp

240

control.address = address->sin_addr.s_addr;

src/bin/network/arp/arp.cpp

278

sockaddr_in address;

src/bin/network/arp/arp.cpp

279

if (!parse_inet_address(argument, address)) {

src/bin/network/arp/arp.cpp

293

address.sin_family = AF_INET;

src/bin/network/arp/arp.cpp

294

address.sin_len = sizeof(sockaddr_in);

src/bin/network/arp/arp.cpp

295

address.sin_addr.s_addr = *(in_addr_t *)host->h_addr;

src/bin/network/arp/arp.cpp

324

status_t status = set_entry(&address, ethernetAddress, flags);

src/bin/network/arp/arp.cpp

40

ethernet_address_to_string(uint8 *address)

src/bin/network/arp/arp.cpp

403

sockaddr_in address;

src/bin/network/arp/arp.cpp

405

if (hostname != NULL && !parse_inet_address(hostname, address)) {

src/bin/network/arp/arp.cpp

419

address.sin_family = AF_INET;

src/bin/network/arp/arp.cpp

420

address.sin_len = sizeof(sockaddr_in);

src/bin/network/arp/arp.cpp

421

address.sin_addr.s_addr = *(in_addr_t *)host->h_addr;

src/bin/network/arp/arp.cpp

44

address[0], address[1], address[2], address[3], address[4], address[5]);

src/bin/network/arp/arp.cpp

450

status_t status = set_entry(&address, ethernetAddress, flags);

src/bin/network/arp/arp.cpp

459

delete_entry(&address);

src/bin/network/arp/arp.cpp

462

list_entries(hostname ? &address : NULL);

src/bin/network/arp/arp.cpp

50

parse_ethernet_address(const char *string, uint8 *address)

src/bin/network/arp/arp.cpp

52

return sscanf(string, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &address[0], &address[1],

src/bin/network/arp/arp.cpp

53

&address[2], &address[3], &address[4], &address[5]) == 6;

src/bin/network/arp/arp.cpp

58

parse_inet_address(const char* string, sockaddr_in& address)

src/bin/network/arp/arp.cpp

64

address.sin_family = AF_INET;

src/bin/network/arp/arp.cpp

65

address.sin_len = sizeof(struct sockaddr_in);

src/bin/network/arp/arp.cpp

66

address.sin_port = 0;

src/bin/network/arp/arp.cpp

67

address.sin_addr = inetAddress;

src/bin/network/arp/arp.cpp

68

memset(&address.sin_zero[0], 0, sizeof(address.sin_zero));

src/bin/network/ifconfig/ifconfig.cpp

145

parse_address(int& family, const char* argument, BNetworkAddress& address)

src/bin/network/ifconfig/ifconfig.cpp

150

status_t status = address.SetTo(family, argument, (uint16)0,

src/bin/network/ifconfig/ifconfig.cpp

160

if (kFamilies[i].family == address.Family()) {

src/bin/network/ifconfig/ifconfig.cpp

169

family = address.Family();

src/bin/network/ifconfig/ifconfig.cpp

189

to_string(const BNetworkAddress& address)

src/bin/network/ifconfig/ifconfig.cpp

191

if (address.IsEmpty())

src/bin/network/ifconfig/ifconfig.cpp

194

return address.ToString();

src/bin/network/ifconfig/ifconfig.cpp

273

network.address.ToString().String(),

src/bin/network/ifconfig/ifconfig.cpp

465

BNetworkInterfaceAddress address;

src/bin/network/ifconfig/ifconfig.cpp

466

if (interface.GetAddressAt(i, address) != B_OK)

src/bin/network/ifconfig/ifconfig.cpp

470

= address_family_for(address.Address().Family());

src/bin/network/ifconfig/ifconfig.cpp

473

to_string(address.Address()).String());

src/bin/network/ifconfig/ifconfig.cpp

476

printf(", Bcast: %s", to_string(address.Broadcast()).String());

src/bin/network/ifconfig/ifconfig.cpp

480

printf(", Mask: %s", to_string(address.Mask()).String());

src/bin/network/ifconfig/ifconfig.cpp

483

printf(", Prefix Length: %zu", address.Mask().PrefixLength());

src/bin/network/ifconfig/ifconfig.cpp

526

BString address = linkAddress.ToString();

src/bin/network/ifconfig/ifconfig.cpp

527

if (address.Length() == 0)

src/bin/network/ifconfig/ifconfig.cpp

528

address = "none";

src/bin/network/ifconfig/ifconfig.cpp

530

printf("Hardware type: %s, Address: %s\n", type, address.String());

src/bin/network/ifconfig/ifconfig.cpp

557

network.address.ToString().String(),

src/bin/network/ifconfig/ifconfig.cpp

663

BNetworkAddress address;

src/bin/network/ifconfig/ifconfig.cpp

664

if (!parse_address(family, args[i], address)) {

src/bin/network/ifconfig/ifconfig.cpp

670

status_t status = interface.RemoveAddress(address);

src/bin/network/ifconfig/ifconfig.cpp

712

BNetworkAddress address;

src/bin/network/ifconfig/ifconfig.cpp

715

if (parse_address(family, args[i], address)) {

src/bin/network/ifconfig/ifconfig.cpp

859

if (doAutoConfig && (!address.IsEmpty() || !mask.IsEmpty()

src/bin/network/ifconfig/ifconfig.cpp

867

if (!address.IsEmpty() || !mask.IsEmpty() || !broadcast.IsEmpty()) {

src/bin/network/ifconfig/ifconfig.cpp

869

interfaceAddress.SetAddress(address);

src/bin/network/ifconfig/ifconfig.cpp

888

if (!address.IsEmpty() || !mask.IsEmpty() || !broadcast.IsEmpty()

src/bin/network/netstat/netstat.cpp

236

inet_print_address((sockaddr*)&stat.address);

src/bin/network/netstat/netstat.cpp

52

static void inet_print_address(sockaddr* address);

src/bin/network/netstat/netstat.cpp

56

inet_print_address(sockaddr* address)

src/bin/network/netstat/netstat.cpp

58

if ((address->sa_family != AF_INET && address->sa_family != AF_INET6) ||

src/bin/network/netstat/netstat.cpp

59

address->sa_len == 0) {

src/bin/network/netstat/netstat.cpp

68

if (getnameinfo(address, address->sa_len, hostName, sizeof(hostName),

src/bin/network/netstat/netstat.cpp

75

if (getnameinfo(address, address->sa_len,

src/bin/network/netstat/netstat.cpp

86

if (address->sa_family != AF_INET

src/bin/network/netstat/netstat.cpp

87

|| ((sockaddr_in*)address)->sin_addr.s_addr != INADDR_ANY) {

src/bin/network/route/route.cpp

132

parse_address(int32 familyIndex, const char* argument, BNetworkAddress& address)

src/bin/network/route/route.cpp

137

return address.SetTo(kFamilies[familyIndex].family, argument,

src/bin/network/wakeonlan.cpp

45

sockaddr_in address;

src/bin/network/wakeonlan.cpp

46

address.sin_family = AF_INET;

src/bin/network/wakeonlan.cpp

47

address.sin_addr.s_addr = 0xffffffff;

src/bin/network/wakeonlan.cpp

48

address.sin_port = 0;

src/bin/network/wakeonlan.cpp

51

(struct sockaddr *)&address, sizeof(address));

src/kits/app/LinkReceiver.cpp

306

void* areaAddress = areaInfo.address;

src/kits/app/LinkSender.cpp

190

void* address = NULL;

src/kits/app/LinkSender.cpp

192

senderArea = create_area("LinkSenderArea", &address, B_ANY_ADDRESS,

src/kits/app/LinkSender.cpp

199

memcpy(address, passedData, passedSize);

src/kits/app/LinkSender.cpp

202

senderArea = _kern_transfer_area(senderArea, &address,

src/kits/app/Message.cpp

1152

char* address = NULL;

src/kits/app/Message.cpp

1156

area_id area = create_area("BMessage data", (void**)&address,

src/kits/app/Message.cpp

1165

memcpy(address, fFields, fieldsSize);

src/kits/app/Message.cpp

1166

memcpy(address + fieldsSize, fData, fHeader->data_size);

src/kits/app/Message.cpp

1196

uint8* address = (uint8*)areaInfo.address;

src/kits/app/Message.cpp

1198

fFields = (field_header*)address;

src/kits/app/Message.cpp

1199

fData = address + fHeader->field_count * sizeof(field_header);

src/kits/app/Message.cpp

2189

void* address = NULL;

src/kits/app/Message.cpp

2191

&address, B_ANY_ADDRESS, target);

src/kits/bluetooth/RemoteDevice.cpp

309

RemoteDevice::RemoteDevice(const bdaddr_t address, uint8 record[3])

src/kits/bluetooth/RemoteDevice.cpp

316

fBdaddr = address;

src/kits/bluetooth/RemoteDevice.cpp

322

RemoteDevice::RemoteDevice(const BString& address)

src/kits/bluetooth/RemoteDevice.cpp

329

fBdaddr = bdaddrUtils::FromString((const char*)address.String());

src/kits/bluetooth/UI/ConnectionIncoming.cpp

17

ConnectionIncoming::ConnectionIncoming(bdaddr_t address)

src/kits/bluetooth/UI/ConnectionIncoming.cpp

27

bdaddrUtils::ToString(address));

src/kits/bluetooth/UI/ConnectionView.cpp

15

ConnectionView::ConnectionView(BRect frame, BString device, BString address)

src/kits/bluetooth/UI/ConnectionView.cpp

38

fAddressText = new BStringView(frame, "", address, B_FOLLOW_RIGHT);

src/kits/bluetooth/UI/PincodeWindow.cpp

222

PincodeWindow::SetBDaddr(BString address)

src/kits/bluetooth/UI/PincodeWindow.cpp

224

fAddressText->SetText(address);

src/kits/bluetooth/UI/PincodeWindow.cpp

51

PincodeWindow::PincodeWindow(bdaddr_t address, hci_id hid)

src/kits/bluetooth/UI/PincodeWindow.cpp

55

fBdaddr(address),

src/kits/debug/DebugContext.cpp

104

BDebugContext::ClearBreakpoint(void* address)

src/kits/debug/DebugContext.cpp

107

message.address = address;

src/kits/debug/DebugContext.cpp

115

BDebugContext::SetWatchpoint(void* address, uint32 type, int32 length)

src/kits/debug/DebugContext.cpp

119

message.address = address;

src/kits/debug/DebugContext.cpp

132

BDebugContext::ClearWatchpoint(void* address)

src/kits/debug/DebugContext.cpp

135

message.address = address;

src/kits/debug/DebugContext.cpp

68

BDebugContext::ReadMemoryPartial(const void* address, void* buffer, size_t size)

src/kits/debug/DebugContext.cpp

70

return debug_read_memory_partial(&fContext, address, buffer, size);

src/kits/debug/DebugContext.cpp

75

BDebugContext::ReadMemory(const void* address, void* buffer, size_t size)

src/kits/debug/DebugContext.cpp

77

return debug_read_memory(&fContext, address, buffer, size);

src/kits/debug/DebugContext.cpp

82

BDebugContext::ReadString(const void* address, char* buffer, size_t size)

src/kits/debug/DebugContext.cpp

84

return debug_read_string(&fContext, address, buffer, size);

src/kits/debug/DebugContext.cpp

89

BDebugContext::SetBreakpoint(void* address)

src/kits/debug/DebugContext.cpp

93

message.address = address;

src/kits/debug/Image.cpp

103

if (symbolAddress > address)

src/kits/debug/Image.cpp

106

addr_t symbolDelta = address - symbolAddress;

src/kits/debug/Image.cpp

86

SymbolTableBasedImage::LookupSymbol(addr_t address, addr_t* _baseAddress,

src/kits/debug/Image.h

38

virtual const elf_sym* LookupSymbol(addr_t address,

src/kits/debug/Image.h

63

virtual const elf_sym* LookupSymbol(addr_t address,

src/kits/debug/SymbolLookup.cpp

113

RemoteMemoryAccessor::AreaForLocalAddress(const void* address) const

src/kits/debug/SymbolLookup.cpp

115

if (address == NULL)

src/kits/debug/SymbolLookup.cpp

120

if (area->ContainsLocalAddress(address))

src/kits/debug/SymbolLookup.cpp

129

RemoteMemoryAccessor::_GetArea(const void *address, int32 size)

src/kits/debug/SymbolLookup.cpp

131

TRACE(("RemoteMemoryAccessor::_GetArea(%p, %" B_PRId32 ")\n", address,

src/kits/debug/SymbolLookup.cpp

135

status_t status = _GetAreaNoThrow(address, size, area);

src/kits/debug/SymbolLookup.cpp

138

address));

src/kits/debug/SymbolLookup.cpp

147

RemoteMemoryAccessor::_GetAreaNoThrow(const void *address, int32 size, Area *&_area)

src/kits/debug/SymbolLookup.cpp

151

if (area->ContainsAddress(address, size)) {

src/kits/debug/SymbolLookup.cpp

163

message.address = address;

src/kits/debug/SymbolLookup.cpp

174

address, strerror(localID)));

src/kits/debug/SymbolLookup.cpp

186

const addr_t remoteBaseAddress = (addr_t)address

src/kits/debug/SymbolLookup.cpp

187

- ((addr_t)reply.address - (addr_t)areaInfo.address);

src/kits/debug/SymbolLookup.cpp

190

remoteBaseAddress, areaInfo.address, areaInfo.size);

src/kits/debug/SymbolLookup.cpp

211

virtual const elf_sym* LookupSymbol(addr_t address,

src/kits/debug/SymbolLookup.cpp

266

remoteDebugArea = (runtime_loader_debug_area*)areaInfo.address;

src/kits/debug/SymbolLookup.cpp

315

SymbolLookup::LookupSymbolAddress(addr_t address, addr_t *_baseAddress,

src/kits/debug/SymbolLookup.cpp

319

TRACE(("SymbolLookup::LookupSymbolAddress(%p)\n", (void*)address));

src/kits/debug/SymbolLookup.cpp

321

Image* image = _FindImageAtAddress(address);

src/kits/debug/SymbolLookup.cpp

328

const elf_sym* symbolFound = image->LookupSymbol(address, _baseAddress,

src/kits/debug/SymbolLookup.cpp

35

Area::TranslateAddress(const void *address)

src/kits/debug/SymbolLookup.cpp

37

TRACE(("Area::TranslateAddress(%p): area: %" B_PRId32 "\n", address, fLocalID));

src/kits/debug/SymbolLookup.cpp

382

SymbolLookup::InitSymbolIteratorByAddress(addr_t address,

src/kits/debug/SymbolLookup.cpp

386

address));

src/kits/debug/SymbolLookup.cpp

389

iterator.image = _FindImageAtAddress(address);

src/kits/debug/SymbolLookup.cpp

40

const void *result = (const void*)((addr_t)address - (addr_t)fRemoteAddress

src/kits/debug/SymbolLookup.cpp

426

SymbolLookup::_FindLoadedImageAtAddress(addr_t address)

src/kits/debug/SymbolLookup.cpp

428

TRACE(("SymbolLookup::_FindLoadedImageAtAddress(%p)\n", (void*)address));

src/kits/debug/SymbolLookup.cpp

43

TRACE(("Area::TranslateAddress(%p) done: %p\n", address, result));

src/kits/debug/SymbolLookup.cpp

439

if (image->regions[0].vmstart <= address

src/kits/debug/SymbolLookup.cpp

440

&& address < image->regions[0].vmstart + image->regions[0].size) {

src/kits/debug/SymbolLookup.cpp

472

SymbolLookup::_FindImageAtAddress(addr_t address) const

src/kits/debug/SymbolLookup.cpp

477

if (address >= textAddress && address < textAddress + image->TextSize())

src/kits/debug/SymbolLookup.cpp

499

SymbolLookup::_SymbolNameLen(const char* address) const

src/kits/debug/SymbolLookup.cpp

501

Area* area = AreaForLocalAddress(address);

src/kits/debug/SymbolLookup.cpp

505

return strnlen(address, (addr_t)area->LocalAddress() + area->Size()

src/kits/debug/SymbolLookup.cpp

506

- (addr_t)address);

src/kits/debug/SymbolLookup.cpp

583

SymbolLookup::LoadedImage::LookupSymbol(addr_t address, addr_t* _baseAddress,

src/kits/debug/SymbolLookup.cpp

615

if (symbolAddress > address)

src/kits/debug/SymbolLookup.cpp

617

addr_t symbolDelta = address - symbolAddress;

src/kits/debug/SymbolLookup.h

113

Area* AreaForLocalAddress(const void* address) const;

src/kits/debug/SymbolLookup.h

116

Area& _GetArea(const void *address, int32 size);

src/kits/debug/SymbolLookup.h

117

status_t _GetAreaNoThrow(const void *address, int32 size, Area *&_area);

src/kits/debug/SymbolLookup.h

144

status_t LookupSymbolAddress(addr_t address, addr_t *_baseAddress,

src/kits/debug/SymbolLookup.h

150

status_t InitSymbolIteratorByAddress(addr_t address,

src/kits/debug/SymbolLookup.h

164

const image_t* _FindLoadedImageAtAddress(addr_t address);

src/kits/debug/SymbolLookup.h

166

Image* _FindImageAtAddress(addr_t address) const;

src/kits/debug/SymbolLookup.h

168

size_t _SymbolNameLen(const char* address) const;

src/kits/debug/SymbolLookup.h

70

bool ContainsAddress(const void *address, int32 size) const

src/kits/debug/SymbolLookup.h

72

return (fRemoteAddress <= (addr_t)address

src/kits/debug/SymbolLookup.h

73

&& (addr_t)address + size <= (fRemoteAddress + fSize));

src/kits/debug/SymbolLookup.h

76

bool ContainsLocalAddress(const void* address) const

src/kits/debug/SymbolLookup.h

78

return (addr_t)address >= (addr_t)fLocalAddress

src/kits/debug/SymbolLookup.h

79

&& (addr_t)address < (addr_t)fLocalAddress + fSize;

src/kits/debug/debug_support.cpp

110

debug_read_memory_partial(debug_context *context, const void *address,

src/kits/debug/debug_support.cpp

124

message.address = (void*)address;

src/kits/debug/debug_support.cpp

147

const char *address = (const char *)_address;

src/kits/debug/debug_support.cpp

151

if (!context || !address || !buffer)

src/kits/debug/debug_support.cpp

159

ssize_t bytesRead = debug_read_memory_partial(context, address, buffer,

src/kits/debug/debug_support.cpp

167

address += bytesRead;

src/kits/debug/debug_support.cpp

181

const char *address = (const char *)_address;

src/kits/debug/debug_support.cpp

184

if (!context || !address || !buffer || size == 0)

src/kits/debug/debug_support.cpp

190

ssize_t bytesRead = debug_read_memory_partial(context, address, buffer,

src/kits/debug/debug_support.cpp

206

address += bytesRead;

src/kits/debug/debug_support.cpp

222

debug_write_memory_partial(debug_context *context, const void *address,

src/kits/debug/debug_support.cpp

236

message.address = (void*)address;

src/kits/debug/debug_support.cpp

258

const char *address = (const char *)_address;

src/kits/debug/debug_support.cpp

262

if (!context || !address || !buffer)

src/kits/debug/debug_support.cpp

269

ssize_t bytesWritten = debug_write_memory_partial(context, address, buffer,

src/kits/debug/debug_support.cpp

277

address += bytesWritten;

src/kits/debug/debug_support.cpp

413

const void *address, void **baseAddress, char *symbolName,

src/kits/debug/debug_support.cpp

427

status_t error = lookup->LookupSymbolAddress((addr_t)address,

src/kits/debugger/arch/InstructionInfo.cpp

21

InstructionInfo::InstructionInfo(target_addr_t address,

src/kits/debugger/arch/InstructionInfo.cpp

26

fAddress(address),

src/kits/debugger/arch/InstructionInfo.cpp

37

InstructionInfo::SetTo(target_addr_t address, target_addr_t targetAddress,

src/kits/debugger/arch/InstructionInfo.cpp

41

fAddress = address;

src/kits/debugger/arch/InstructionInfo.h

23

InstructionInfo(target_addr_t address,

src/kits/debugger/arch/InstructionInfo.h

29

bool SetTo(target_addr_t address,

src/kits/debugger/arch/x86/ArchitectureX86.cpp

382

uint32 address;

src/kits/debugger/arch/x86/ArchitectureX86.cpp

383

if (fTeamMemory->ReadMemory(esp, &address, 4) == 4) {

src/kits/debugger/arch/x86/ArchitectureX86.cpp

384

returnAddress = address;

src/kits/debugger/arch/x86/ArchitectureX86.cpp

435

uint32 address;

src/kits/debugger/arch/x86/ArchitectureX86.cpp

436

if (fTeamMemory->ReadMemory(stack, &address, 4) == 4) {

src/kits/debugger/arch/x86/ArchitectureX86.cpp

437

returnAddress = address;

src/kits/debugger/arch/x86/ArchitectureX86.cpp

539

ArchitectureX86::ReadValueFromMemory(target_addr_t address, uint32 valueType,

src/kits/debugger/arch/x86/ArchitectureX86.cpp

547

ssize_t bytesRead = fTeamMemory->ReadMemory(address, buffer, size);

src/kits/debugger/arch/x86/ArchitectureX86.cpp

596

target_addr_t address, uint32 valueType, BVariant& _value) const

src/kits/debugger/arch/x86/ArchitectureX86.cpp

645

target_addr_t address, Statement*& _statement)

src/kits/debugger/arch/x86/ArchitectureX86.cpp

650

status_t error = GetInstructionInfo(address, info, NULL);

src/kits/debugger/arch/x86/ArchitectureX86.cpp

666

ArchitectureX86::GetInstructionInfo(target_addr_t address,

src/kits/debugger/arch/x86/ArchitectureX86.cpp

671

ssize_t bytesRead = fTeamMemory->ReadMemory(address, buffer,

src/kits/debugger/arch/x86/ArchitectureX86.cpp

678

status_t error = disassembler.Init(address, buffer, bytesRead);

src/kits/debugger/arch/x86/ArchitectureX86.h

58

virtual status_t ReadValueFromMemory(target_addr_t address,

src/kits/debugger/arch/x86/ArchitectureX86.h

61

target_addr_t address, uint32 valueType,

src/kits/debugger/arch/x86/ArchitectureX86.h

68

target_addr_t address,

src/kits/debugger/arch/x86/ArchitectureX86.h

70

virtual status_t GetInstructionInfo(target_addr_t address,

src/kits/debugger/arch/x86/CpuStateX86.cpp

169

CpuStateX86::SetInstructionPointer(target_addr_t address)

src/kits/debugger/arch/x86/CpuStateX86.cpp

171

SetIntRegister(X86_REGISTER_EIP, (uint32)address);

src/kits/debugger/arch/x86/CpuStateX86.h

93

virtual void SetInstructionPointer(target_addr_t address);

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

110

uint32 address = (uint32)(fAddress + fZydisData->offset);

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

122

operands, instruction.operand_count_visible, formatted, sizeof(formatted), address,

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

124

line.SetToFormat("0x%08" B_PRIx32 ": %16.16s %s", address, hexString, formatted);

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

126

line.SetToFormat("0x%08" B_PRIx32 ": failed-to-format", address);

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

130

_address = address;

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

157

target_addr_t address = fAddress + fZydisData->offset;

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

158

if (address == nextAddress) {

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

159

_address = address;

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

179

uint32 address = (uint32)(fAddress + fZydisData->offset);

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

201

address, &registers, &targetAddress));

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

206

int written = snprintf(string, sizeof(string), "0x%08" B_PRIx32 ": %16.16s ", address,

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

210

operands, instruction.operand_count_visible, formatted, sizeof(string) - written, address,

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

212

snprintf(string, sizeof(string), "0x%08" B_PRIx32 ": failed-to-format", address);

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

217

if (!_info.SetTo(address, targetAddress, instruction.length, type, true, string))

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

62

DisassemblerX86::Init(target_addr_t address, const void* code, size_t codeSize)

src/kits/debugger/arch/x86/disasm/DisassemblerX86.cpp

73

fAddress = address;

src/kits/debugger/arch/x86/disasm/DisassemblerX86.h

22

virtual status_t Init(target_addr_t address, const void* code,

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

458

uint64 address;

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

459

if (fTeamMemory->ReadMemory(rsp, &address, 8) == 8) {

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

460

returnAddress = address;

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

512

uint64 address;

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

513

if (fTeamMemory->ReadMemory(stack, &address, 8) == 8) {

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

514

returnAddress = address;

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

616

ArchitectureX8664::ReadValueFromMemory(target_addr_t address, uint32 valueType,

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

624

ssize_t bytesRead = fTeamMemory->ReadMemory(address, buffer, size);

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

673

target_addr_t address, uint32 valueType, BVariant& _value) const

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

722

target_addr_t address, Statement*& _statement)

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

727

status_t error = GetInstructionInfo(address, info, NULL);

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

743

ArchitectureX8664::GetInstructionInfo(target_addr_t address,

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

748

ssize_t bytesRead = fTeamMemory->ReadMemory(address, buffer,

src/kits/debugger/arch/x86_64/ArchitectureX8664.cpp

755

status_t error = disassembler.Init(address, buffer, bytesRead);

src/kits/debugger/arch/x86_64/ArchitectureX8664.h

59

virtual status_t ReadValueFromMemory(target_addr_t address,

src/kits/debugger/arch/x86_64/ArchitectureX8664.h

62

target_addr_t address, uint32 valueType,

src/kits/debugger/arch/x86_64/ArchitectureX8664.h

69

target_addr_t address,

src/kits/debugger/arch/x86_64/ArchitectureX8664.h

71

virtual status_t GetInstructionInfo(target_addr_t address,

src/kits/debugger/arch/x86_64/CpuStateX8664.cpp

215

CpuStateX8664::SetInstructionPointer(target_addr_t address)

src/kits/debugger/arch/x86_64/CpuStateX8664.cpp

217

SetIntRegister(X86_64_REGISTER_RIP, address);

src/kits/debugger/arch/x86_64/CpuStateX8664.h

119

virtual void SetInstructionPointer(target_addr_t address);

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

119

target_addr_t address = fAddress + fZydisData->offset;

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

131

instruction.operand_count_visible, formatted, sizeof(formatted), address, NULL))) {

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

132

line.SetToFormat("0x%016" B_PRIx64 ": %16.16s %s", address, hexString, formatted);

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

134

line.SetToFormat("0x%016" B_PRIx64 ": failed-to-format", address);

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

138

_address = address;

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

165

target_addr_t address = fAddress + fZydisData->offset;

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

166

if (address == nextAddress) {

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

167

_address = address;

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

187

target_addr_t address = fAddress + fZydisData->offset;

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

209

address, &registers, &targetAddress));

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

214

int written = snprintf(string, sizeof(string), "0x%016" B_PRIx64 ": %16.16s ", address,

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

219

address, NULL))) {

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

220

snprintf(string, sizeof(string), "0x%016" B_PRIx64 ": failed-to-format", address);

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

225

if (!_info.SetTo(address, targetAddress, instruction.length, type, true, string))

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

71

DisassemblerX8664::Init(target_addr_t address, const void* code, size_t codeSize)

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.cpp

82

fAddress = address;

src/kits/debugger/arch/x86_64/disasm/DisassemblerX8664.h

23

virtual status_t Init(target_addr_t address, const void* code,

src/kits/debugger/controllers/TeamDebugger.cpp

1094

uint32 action, target_addr_t address)

src/kits/debugger/controllers/TeamDebugger.cpp

1098

message.AddUInt64("address", address);

src/kits/debugger/controllers/TeamDebugger.cpp

1104

TeamDebugger::SetBreakpointRequested(target_addr_t address, bool enabled,

src/kits/debugger/controllers/TeamDebugger.cpp

1108

message.AddUInt64("address", (uint64)address);

src/kits/debugger/controllers/TeamDebugger.cpp

1156

TeamDebugger::ClearBreakpointRequested(target_addr_t address)

src/kits/debugger/controllers/TeamDebugger.cpp

1159

message.AddUInt64("address", (uint64)address);

src/kits/debugger/controllers/TeamDebugger.cpp

1234

TeamDebugger::SetWatchpointRequested(target_addr_t address, uint32 type,

src/kits/debugger/controllers/TeamDebugger.cpp

1238

message.AddUInt64("address", (uint64)address);

src/kits/debugger/controllers/TeamDebugger.cpp

1261

TeamDebugger::ClearWatchpointRequested(target_addr_t address)

src/kits/debugger/controllers/TeamDebugger.cpp

1264

message.AddUInt64("address", (uint64)address);

src/kits/debugger/controllers/TeamDebugger.cpp

1282

TeamDebugger::InspectRequested(target_addr_t address,

src/kits/debugger/controllers/TeamDebugger.cpp

1286

message.AddUInt64("address", address);

src/kits/debugger/controllers/TeamDebugger.cpp

1293

TeamDebugger::MemoryWriteRequested(target_addr_t address, const void* data,

src/kits/debugger/controllers/TeamDebugger.cpp

1297

message.AddUInt64("address", address);

src/kits/debugger/controllers/TeamDebugger.cpp

1866

target_addr_t address;

src/kits/debugger/controllers/TeamDebugger.cpp

1878

address = args[3];

src/kits/debugger/controllers/TeamDebugger.cpp

1883

address = args[2];

src/kits/debugger/controllers/TeamDebugger.cpp

1891

address, size, data);

src/kits/debugger/controllers/TeamDebugger.cpp

2036

TeamDebugger::_HandleSetUserBreakpoint(target_addr_t address, bool enabled,

src/kits/debugger/controllers/TeamDebugger.cpp

2040

", %d, %d)\n", address, enabled, hidden);

src/kits/debugger/controllers/TeamDebugger.cpp

2045

Breakpoint* breakpoint = fTeam->BreakpointAtAddress(address);

src/kits/debugger/controllers/TeamDebugger.cpp

2055

Image* image = fTeam->ImageByAddress(address);

src/kits/debugger/controllers/TeamDebugger.cpp

2069

= imageDebugInfo->FunctionAtAddress(address);

src/kits/debugger/controllers/TeamDebugger.cpp

2085

functionDebugInfo, address, breakpointStatement) != B_OK) {

src/kits/debugger/controllers/TeamDebugger.cpp

2092

target_addr_t relativeAddress = address - functionInstance->Address();

src/kits/debugger/controllers/TeamDebugger.cpp

2128

instanceAddress = address;

src/kits/debugger/controllers/TeamDebugger.cpp

2189

TeamDebugger::_HandleClearUserBreakpoint(target_addr_t address)

src/kits/debugger/controllers/TeamDebugger.cpp

2192

address);

src/kits/debugger/controllers/TeamDebugger.cpp

2196

Breakpoint* breakpoint = fTeam->BreakpointAtAddress(address);

src/kits/debugger/controllers/TeamDebugger.cpp

2217

TeamDebugger::_HandleSetWatchpoint(target_addr_t address, uint32 type,

src/kits/debugger/controllers/TeamDebugger.cpp

2220

Watchpoint* watchpoint = new(std::nothrow) Watchpoint(address, type,

src/kits/debugger/controllers/TeamDebugger.cpp

2244

TeamDebugger::_HandleClearWatchpoint(target_addr_t address)

src/kits/debugger/controllers/TeamDebugger.cpp

2247

address);

src/kits/debugger/controllers/TeamDebugger.cpp

2251

Watchpoint* watchpoint = fTeam->WatchpointAtAddress(address);

src/kits/debugger/controllers/TeamDebugger.cpp

2270

TeamDebugger::_HandleInspectAddress(target_addr_t address,

src/kits/debugger/controllers/TeamDebugger.cpp

2274

address, listener);

src/kits/debugger/controllers/TeamDebugger.cpp

2277

->GetMemoryBlock(address);

src/kits/debugger/controllers/TeamDebugger.cpp

2311

TeamDebugger::_HandleWriteMemory(target_addr_t address, void* data,

src/kits/debugger/controllers/TeamDebugger.cpp

2315

"%" B_PRIu64 ")\n", address, data, size);

src/kits/debugger/controllers/TeamDebugger.cpp

2322

new(std::nothrow) WriteMemoryJob(fTeam, memory, address, data, size),

src/kits/debugger/controllers/TeamDebugger.cpp

577

target_addr_t address;

src/kits/debugger/controllers/TeamDebugger.cpp

581

if (message->FindUInt64("address", &address) != B_OK)

src/kits/debugger/controllers/TeamDebugger.cpp

582

address = 0;

src/kits/debugger/controllers/TeamDebugger.cpp

585

handler->HandleThreadAction(message->what, address);

src/kits/debugger/controllers/TeamDebugger.cpp

596

uint64 address = 0;

src/kits/debugger/controllers/TeamDebugger.cpp

601

} else if (message->FindUInt64("address", &address) != B_OK)

src/kits/debugger/controllers/TeamDebugger.cpp

616

_HandleSetUserBreakpoint(address, enabled, hidden);

src/kits/debugger/controllers/TeamDebugger.cpp

621

_HandleClearUserBreakpoint(address);

src/kits/debugger/controllers/TeamDebugger.cpp

744

uint64 address = 0;

src/kits/debugger/controllers/TeamDebugger.cpp

751

} else if (message->FindUInt64("address", &address) != B_OK)

src/kits/debugger/controllers/TeamDebugger.cpp

768

_HandleSetWatchpoint(address, type, length, enabled);

src/kits/debugger/controllers/TeamDebugger.cpp

773

_HandleClearWatchpoint(address);

src/kits/debugger/controllers/TeamDebugger.cpp

787

target_addr_t address;

src/kits/debugger/controllers/TeamDebugger.cpp

789

&address) == B_OK) {

src/kits/debugger/controllers/TeamDebugger.cpp

790

_HandleInspectAddress(address, listener);

src/kits/debugger/controllers/TeamDebugger.cpp

797

target_addr_t address;

src/kits/debugger/controllers/TeamDebugger.cpp

798

if (message->FindUInt64("address", &address) != B_OK)

src/kits/debugger/controllers/TeamDebugger.cpp

809

_HandleWriteMemory(address, data, size);

src/kits/debugger/controllers/ThreadHandler.cpp

122

ThreadHandler::SetBreakpointAndRun(target_addr_t address)

src/kits/debugger/controllers/ThreadHandler.cpp

124

status_t error = _InstallTemporaryBreakpoint(address);

src/kits/debugger/controllers/ThreadHandler.cpp

265

target_addr_t address = 0;

src/kits/debugger/controllers/ThreadHandler.cpp

267

address = (target_addr_t)handlerInfo.sa_sigaction;

src/kits/debugger/controllers/ThreadHandler.cpp

269

address = (target_addr_t)handlerInfo.sa_handler;

src/kits/debugger/controllers/ThreadHandler.cpp

271

if (address == (target_addr_t)SIG_DFL

src/kits/debugger/controllers/ThreadHandler.cpp

272

|| address == (target_addr_t)SIG_IGN

src/kits/debugger/controllers/ThreadHandler.cpp

273

|| address == (target_addr_t)SIG_HOLD) {

src/kits/debugger/controllers/ThreadHandler.cpp

274

address = 0;

src/kits/debugger/controllers/ThreadHandler.cpp

277

if (address != 0 && _InstallTemporaryBreakpoint(address) == B_OK

src/kits/debugger/controllers/ThreadHandler.cpp

303

ThreadHandler::HandleThreadAction(uint32 action, target_addr_t address)

src/kits/debugger/controllers/ThreadHandler.cpp

324

_HandleSetAddress(cpuState, address);

src/kits/debugger/controllers/ThreadHandler.cpp

339

fStepMode = address != 0 ? STEP_UNTIL : STEP_NONE;

src/kits/debugger/controllers/ThreadHandler.cpp

340

if (address != 0)

src/kits/debugger/controllers/ThreadHandler.cpp

341

_InstallTemporaryBreakpoint(address);

src/kits/debugger/controllers/ThreadHandler.cpp

524

ThreadHandler::_HandleSetAddress(CpuState* state, target_addr_t address)

src/kits/debugger/controllers/ThreadHandler.cpp

531

newState->SetInstructionPointer(address);

src/kits/debugger/controllers/ThreadHandler.cpp

631

ThreadHandler::_InstallTemporaryBreakpoint(target_addr_t address)

src/kits/debugger/controllers/ThreadHandler.cpp

635

status_t error = fBreakpointManager->InstallTemporaryBreakpoint(address,

src/kits/debugger/controllers/ThreadHandler.cpp

640

fBreakpointAddress = address;

src/kits/debugger/debug_info/BasicFunctionDebugInfo.cpp

12

SpecificImageDebugInfo* debugInfo, target_addr_t address,

src/kits/debugger/debug_info/BasicFunctionDebugInfo.cpp

16

fAddress(address),

src/kits/debugger/debug_info/BasicFunctionDebugInfo.h

17

target_addr_t address,

src/kits/debugger/debug_info/DebuggerImageDebugInfo.cpp

114

DebuggerImageDebugInfo::ReadCode(target_addr_t address, void* buffer,

src/kits/debugger/debug_info/DebuggerImageDebugInfo.cpp

117

return fDebuggerInterface->ReadMemory(address, buffer, size);

src/kits/debugger/debug_info/DebuggerImageDebugInfo.cpp

72

DebuggerImageDebugInfo::GetAddressSectionType(target_addr_t address)

src/kits/debugger/debug_info/DebuggerImageDebugInfo.cpp

90

target_addr_t address, Statement*& _statement)

src/kits/debugger/debug_info/DebuggerImageDebugInfo.cpp

92

return fArchitecture->GetStatement(function, address, _statement);

src/kits/debugger/debug_info/DebuggerImageDebugInfo.h

40

virtual AddressSectionType GetAddressSectionType(target_addr_t address);

src/kits/debugger/debug_info/DebuggerImageDebugInfo.h

49

target_addr_t address,

src/kits/debugger/debug_info/DebuggerImageDebugInfo.h

59

virtual ssize_t ReadCode(target_addr_t address, void* buffer,

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

1030

B_PRId32 ") %d\n", state.address, state.file, state.line,

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

1037

target_addr_t endAddress = state.address;

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

1059

statementAddress = state.address;

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

136

virtual bool ReadMemory(target_addr_t address, void* buffer,

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

139

ssize_t bytesRead = fTeamMemory->ReadMemory(address, buffer, size);

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

143

virtual bool ReadValueFromMemory(target_addr_t address,

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

146

return fArchitecture->ReadValueFromMemory(address, valueType, _value)

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

151

target_addr_t address, uint32 valueType, BVariant& _value) const

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

153

return fArchitecture->ReadValueFromMemory(addressSpace, address,

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

572

DwarfImageDebugInfo::GetAddressSectionType(target_addr_t address)

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

574

if (address >= fTextSectionStart && address < fTextSectionEnd)

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

577

if (address >= fPLTSectionStart && address < fPLTSectionEnd)

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

757

target_addr_t address, Statement*& _statement)

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

760

B_PRIx64 ")\n", _function, address);

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

767

return fArchitecture->GetStatement(function, address, _statement);

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

779

return fArchitecture->GetStatement(function, address, _statement);

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

790

return fArchitecture->GetStatement(function, address, _statement);

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

806

address -= fRelocationDelta;

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

821

target_addr_t endAddress = state.address;

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

822

if (address >= statementAddress && address < endAddress) {

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

839

statementAddress = state.address;

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

899

target_addr_t endAddress = state.address;

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

935

statementAddress = state.address;

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

982

DwarfImageDebugInfo::ReadCode(target_addr_t address, void* buffer, size_t size)

src/kits/debugger/debug_info/DwarfImageDebugInfo.cpp

984

target_addr_t offset = address - fRelocationDelta

src/kits/debugger/debug_info/DwarfImageDebugInfo.h

69

virtual AddressSectionType GetAddressSectionType(target_addr_t address);

src/kits/debugger/debug_info/DwarfImageDebugInfo.h

79

target_addr_t address,

src/kits/debugger/debug_info/DwarfImageDebugInfo.h

89

virtual ssize_t ReadCode(target_addr_t address, void* buffer,

src/kits/debugger/debug_info/DwarfTypes.cpp

1169

piece.SetToMemory(piece.address + byteOffset);

src/kits/debugger/debug_info/DwarfTypes.cpp

956

&locationDescription, piece.address, true, *location);

src/kits/debugger/debug_info/ImageDebugInfo.cpp

129

ImageDebugInfo::GetAddressSectionType(target_addr_t address) const

src/kits/debugger/debug_info/ImageDebugInfo.cpp

134

type = specificInfo->GetAddressSectionType(address);

src/kits/debugger/debug_info/ImageDebugInfo.cpp

158

ImageDebugInfo::FunctionAtAddress(target_addr_t address) const

src/kits/debugger/debug_info/ImageDebugInfo.cpp

160

return fFunctions.BinarySearchByKey(address, &_CompareAddressFunction);

src/kits/debugger/debug_info/ImageDebugInfo.cpp

204

ImageDebugInfo::_CompareAddressFunction(const target_addr_t* address,

src/kits/debugger/debug_info/ImageDebugInfo.cpp

207

if (*address < function->Address())

src/kits/debugger/debug_info/ImageDebugInfo.cpp

209

return *address < function->Address() + function->Size() ? 0 : 1;

src/kits/debugger/debug_managers/BreakpointManager.cpp

232

BreakpointManager::InstallTemporaryBreakpoint(target_addr_t address,

src/kits/debugger/debug_managers/BreakpointManager.cpp

239

Breakpoint* breakpoint = fTeam->BreakpointAtAddress(address);

src/kits/debugger/debug_managers/BreakpointManager.cpp

241

Image* image = fTeam->ImageByAddress(address);

src/kits/debugger/debug_managers/BreakpointManager.cpp

245

breakpoint = new(std::nothrow) Breakpoint(image, address);

src/kits/debugger/debug_managers/BreakpointManager.cpp

264

error = fDebuggerInterface->InstallBreakpoint(address);

src/kits/debugger/debug_managers/BreakpointManager.cpp

285

BreakpointManager::UninstallTemporaryBreakpoint(target_addr_t address,

src/kits/debugger/debug_managers/BreakpointManager.cpp

291

Breakpoint* breakpoint = fTeam->BreakpointAtAddress(address);

src/kits/debugger/debug_managers/BreakpointManager.cpp

310

fDebuggerInterface->UninstallBreakpoint(address);

src/kits/debugger/debug_managers/BreakpointManager.cpp

445

target_addr_t address = instance->Address();

src/kits/debugger/debug_managers/BreakpointManager.cpp

446

Breakpoint* breakpoint = fTeam->BreakpointAtAddress(address);

src/kits/debugger/debug_managers/BreakpointManager.cpp

448

breakpoint = new(std::nothrow) Breakpoint(image, address);

src/kits/debugger/debug_managers/BreakpointManager.cpp

77

target_addr_t address = instance->Address();

src/kits/debugger/debug_managers/BreakpointManager.cpp

78

Breakpoint* breakpoint = fTeam->BreakpointAtAddress(address);

src/kits/debugger/debug_managers/BreakpointManager.cpp

82

Image* image = fTeam->ImageByAddress(address);

src/kits/debugger/debug_managers/BreakpointManager.cpp

89

breakpoint = new(std::nothrow) Breakpoint(image, address);

src/kits/debugger/debug_managers/BreakpointManager.h

32

target_addr_t address,

src/kits/debugger/debug_managers/BreakpointManager.h

35

target_addr_t address,

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

121

TeamMemoryBlockManager::GetMemoryBlock(target_addr_t address)

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

125

address &= ~(B_PAGE_SIZE - 1);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

126

MemoryBlockEntry* entry = fActiveBlocks->Lookup(address);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

133

_MarkDeadBlock(address);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

141

TeamMemoryBlock* block = new(std::nothrow) TeamMemoryBlock(address,

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

178

TeamMemoryBlockManager::_MarkDeadBlock(target_addr_t address)

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

18

target_addr_t address;

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

180

MemoryBlockEntry* entry = fActiveBlocks->Lookup(address);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

190

TeamMemoryBlockManager::_RemoveBlock(target_addr_t address)

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

193

MemoryBlockEntry* entry = fActiveBlocks->Lookup(address);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

20

Key(target_addr_t address)

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

203

if (block->BaseAddress() == address) {

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

22

address(address)

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

28

return (uint32)address;

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

33

return address == other.address;

src/kits/debugger/debug_managers/TeamMemoryBlockManager.h

29

TeamMemoryBlock* GetMemoryBlock(target_addr_t address);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.h

40

void _MarkDeadBlock(target_addr_t address);

src/kits/debugger/debug_managers/TeamMemoryBlockManager.h

41

void _RemoveBlock(target_addr_t address);

src/kits/debugger/debugger_interface/DebuggerInterface.cpp

32

virtual ssize_t Read(uint64 address, void* buffer, size_t size)

src/kits/debugger/debugger_interface/DebuggerInterface.cpp

36

if (address > fStringTableEnd)

src/kits/debugger/debugger_interface/DebuggerInterface.cpp

39

if (address < fSymbolTableSize) {

src/kits/debugger/debugger_interface/DebuggerInterface.cpp

40

size_t toCopy = std::min(size, size_t(fSymbolTableSize - address));

src/kits/debugger/debugger_interface/DebuggerInterface.cpp

41

memcpy(buffer, fSymbolTable + address, toCopy);

src/kits/debugger/debugger_interface/DebuggerInterface.cpp

42

address -= toCopy;

src/kits/debugger/debugger_interface/DebuggerInterface.cpp

47

if (address < fStringTableEnd) {

src/kits/debugger/debugger_interface/DebuggerInterface.cpp

48

size_t toCopy = std::min(size, size_t(fStringTableEnd - address));

src/kits/debugger/debugger_interface/DebuggerInterface.cpp

49

memcpy(buffer, fStringTable + address - fSymbolTableSize, toCopy);

src/kits/debugger/debugger_interface/DebuggerInterface.cpp

50

address -= toCopy;

src/kits/debugger/debugger_interface/DebuggerInterface.h

101

virtual ssize_t WriteMemory(target_addr_t address,

src/kits/debugger/debugger_interface/DebuggerInterface.h

58

virtual status_t InstallBreakpoint(target_addr_t address) = 0;

src/kits/debugger/debugger_interface/DebuggerInterface.h

59

virtual status_t UninstallBreakpoint(target_addr_t address) = 0;

src/kits/debugger/debugger_interface/DebuggerInterface.h

61

virtual status_t InstallWatchpoint(target_addr_t address,

src/kits/debugger/debugger_interface/DebuggerInterface.h

63

virtual status_t UninstallWatchpoint(target_addr_t address) = 0;

src/kits/debugger/debugger_interface/DebuggerInterface.h

96

virtual status_t GetMemoryProperties(target_addr_t address,

src/kits/debugger/debugger_interface/DebuggerInterface.h

99

virtual ssize_t ReadMemory(target_addr_t address, void* buffer,

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.cpp

137

CoreFileDebuggerInterface::InstallBreakpoint(target_addr_t address)

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.cpp

144

CoreFileDebuggerInterface::UninstallBreakpoint(target_addr_t address)

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.cpp

151

CoreFileDebuggerInterface::InstallWatchpoint(target_addr_t address, uint32 type,

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.cpp

159

CoreFileDebuggerInterface::UninstallWatchpoint(target_addr_t address)

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.cpp

329

CoreFileDebuggerInterface::GetMemoryProperties(target_addr_t address,

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.cpp

332

const CoreFileAreaInfo* info = fCoreFile->AreaInfoForAddress(address);

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.cpp

344

CoreFileDebuggerInterface::ReadMemory(target_addr_t address, void* _buffer,

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.cpp

354

const CoreFileAreaInfo* info = fCoreFile->AreaInfoForAddress(address);

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.cpp

359

uint64 offset = address - segment->LoadAddress();

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.cpp

382

CoreFileDebuggerInterface::WriteMemory(target_addr_t address, void* buffer,

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.h

43

virtual status_t InstallBreakpoint(target_addr_t address);

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.h

44

virtual status_t UninstallBreakpoint(target_addr_t address);

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.h

46

virtual status_t InstallWatchpoint(target_addr_t address,

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.h

48

virtual status_t UninstallWatchpoint(target_addr_t address);

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.h

76

virtual status_t GetMemoryProperties(target_addr_t address,

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.h

79

virtual ssize_t ReadMemory(target_addr_t address, void* buffer,

src/kits/debugger/debugger_interface/core/CoreFileDebuggerInterface.h

81

virtual ssize_t WriteMemory(target_addr_t address,

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

435

LocalDebuggerInterface::InstallBreakpoint(target_addr_t address)

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

441

message.address = (void*)(addr_t)address;

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

453

LocalDebuggerInterface::UninstallBreakpoint(target_addr_t address)

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

456

message.address = (void*)(addr_t)address;

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

464

LocalDebuggerInterface::InstallWatchpoint(target_addr_t address, uint32 type,

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

471

message.address = (void*)(addr_t)address;

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

485

LocalDebuggerInterface::UninstallWatchpoint(target_addr_t address)

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

490

message.address = (void*)(addr_t)address;

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

574

areaInfo.name, (addr_t)areaInfo.address, areaInfo.size,

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

630

void* address;

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

633

&address, &size) == B_OK) {

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

635

(target_addr_t)(addr_t)address, size, type, name);

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

762

LocalDebuggerInterface::GetMemoryProperties(target_addr_t address,

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

765

return get_memory_properties(fTeamID, (const void *)address,

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

771

LocalDebuggerInterface::ReadMemory(target_addr_t address, void* buffer, size_t size)

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

776

(const void*)(addr_t)address, buffer, size);

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

781

LocalDebuggerInterface::WriteMemory(target_addr_t address, void* buffer,

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.cpp

787

(const void*)address, buffer, size);

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.h

34

virtual status_t InstallBreakpoint(target_addr_t address);

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.h

35

virtual status_t UninstallBreakpoint(target_addr_t address);

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.h

37

virtual status_t InstallWatchpoint(target_addr_t address,

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.h

39

virtual status_t UninstallWatchpoint(target_addr_t address);

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.h

67

virtual status_t GetMemoryProperties(target_addr_t address,

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.h

70

virtual ssize_t ReadMemory(target_addr_t address, void* buffer,

src/kits/debugger/debugger_interface/local/LocalDebuggerInterface.h

72

virtual ssize_t WriteMemory(target_addr_t address,

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.cpp

164

RemoteDebugReadMemoryRequest::SetTo(target_addr_t address, target_size_t size)

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.cpp

166

fAddress = address;

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.cpp

224

RemoteDebugWriteMemoryRequest::SetTo(target_addr_t address, const void* data,

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.cpp

230

fAddress = address;

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.cpp

628

RemoteDebugAddressActionRequest::SetTo(target_addr_t address)

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.cpp

630

fAddress = address;

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.cpp

712

RemoteDebugInstallWatchpointRequest::SetTo(target_addr_t address, uint32 type,

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.cpp

715

fAddress = address;

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.h

120

void SetTo(target_addr_t address,

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.h

145

status_t SetTo(target_addr_t address,

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.h

306

void SetTo(target_addr_t address);

src/kits/debugger/debugger_interface/remote/RemoteDebugRequest.h

346

void SetTo(target_addr_t address, uint32 type,

src/kits/debugger/dwarf/AttributeValue.cpp

18

snprintf(buffer, size, "%#" B_PRIx64, address);

src/kits/debugger/dwarf/AttributeValue.h

17

target_addr_t address;

src/kits/debugger/dwarf/AttributeValue.h

44

void SetToAddress(target_addr_t address)

src/kits/debugger/dwarf/AttributeValue.h

48

this->address = address;

src/kits/debugger/dwarf/DebugInfoEntries.cpp

1012

fLowPC = value.address;

src/kits/debugger/dwarf/DebugInfoEntries.cpp

1021

fHighPC = value.address;

src/kits/debugger/dwarf/DebugInfoEntries.cpp

108

fLowPC = value.address;

src/kits/debugger/dwarf/DebugInfoEntries.cpp

117

fHighPC = value.address;

src/kits/debugger/dwarf/DebugInfoEntries.cpp

1996

fLowPC = value.address;

src/kits/debugger/dwarf/DebugInfoEntries.cpp

2005

fHighPC = value.address;

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

544

target_addr_t address;

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

545

if (!fContext->GetObjectAddress(address))

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

547

_Push(address);

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

553

target_addr_t address;

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

554

if (!fContext->GetFrameAddress(address))

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

556

_Push(address);

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

563

target_addr_t address;

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

564

if (!fContext->GetFrameBaseAddress(address)) {

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

568

_Push(address + offset);

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

574

target_addr_t address;

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

575

if (!fContext->GetTLSAddress(_Pop(), address))

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

577

_Push(address);

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

729

target_addr_t address = _Pop();

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

731

if (!fContext->TargetInterface()->ReadValueFromMemory(address, valueType,

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

764

target_addr_t address = _Pop();

src/kits/debugger/dwarf/DwarfExpressionEvaluator.cpp

767

if (!fContext->TargetInterface()->ReadValueFromMemory(addressSpace, address,

src/kits/debugger/dwarf/DwarfFile.cpp

2481

target_addr_t address;

src/kits/debugger/dwarf/DwarfFile.cpp

2487

frameAddress, true, address);

src/kits/debugger/dwarf/DwarfFile.cpp

2490

&& inputInterface->ReadValueFromMemory(address,

src/kits/debugger/dwarf/DwarfFile.cpp

3163

target_addr_t address, const void*& _expression, off_t& _length) const

src/kits/debugger/dwarf/DwarfFile.cpp

3204

if (address >= start && address < end) {

src/kits/debugger/dwarf/DwarfFile.cpp

393

target_addr_t address = valueOnly ? 0 : FDEAddressOffset(file,

src/kits/debugger/dwarf/DwarfFile.cpp

397

address += reader.ReadAddress(0);

src/kits/debugger/dwarf/DwarfFile.cpp

398

TRACE_CFI(" target address: %" B_PRId64 "\n", address);

src/kits/debugger/dwarf/DwarfFile.cpp

401

address += reader.ReadUnsignedLEB128(0);

src/kits/debugger/dwarf/DwarfFile.cpp

402

TRACE_CFI(" unsigned LEB128: %" B_PRId64 "\n", address);

src/kits/debugger/dwarf/DwarfFile.cpp

405

address += reader.ReadSignedLEB128(0);

src/kits/debugger/dwarf/DwarfFile.cpp

406

TRACE_CFI(" signed LEB128: %" B_PRId64 "\n", address);

src/kits/debugger/dwarf/DwarfFile.cpp

409

address += reader.Read<uint16>(0);

src/kits/debugger/dwarf/DwarfFile.cpp

410

TRACE_CFI(" unsigned 16-bit: %" B_PRId64 "\n", address);

src/kits/debugger/dwarf/DwarfFile.cpp

413

address += reader.Read<int16>(0);

src/kits/debugger/dwarf/DwarfFile.cpp

414

TRACE_CFI(" signed 16-bit: %" B_PRId64 "\n", address);

src/kits/debugger/dwarf/DwarfFile.cpp

417

address += reader.Read<uint32>(0);

src/kits/debugger/dwarf/DwarfFile.cpp

418

TRACE_CFI(" unsigned 32-bit: %" B_PRId64 "\n", address);

src/kits/debugger/dwarf/DwarfFile.cpp

421

address += reader.Read<int32>(0);

src/kits/debugger/dwarf/DwarfFile.cpp

422

TRACE_CFI(" signed 32-bit: %" B_PRId64 "\n", address);

src/kits/debugger/dwarf/DwarfFile.cpp

425

address += reader.Read<uint64>(0);

src/kits/debugger/dwarf/DwarfFile.cpp

426

TRACE_CFI(" unsigned 64-bit: %" B_PRId64 "\n", address);

src/kits/debugger/dwarf/DwarfFile.cpp

429

address += reader.Read<int64>(0);

src/kits/debugger/dwarf/DwarfFile.cpp

430

TRACE_CFI(" signed 64-bit: %" B_PRId64 "\n", address);

src/kits/debugger/dwarf/DwarfFile.cpp

434

return address;

src/kits/debugger/dwarf/DwarfFile.cpp

471

inline bool ContainsAddress(target_addr_t address) const

src/kits/debugger/dwarf/DwarfFile.cpp

473

return address >= start && address < end;

src/kits/debugger/dwarf/DwarfFile.h

190

uint64 offset, target_addr_t address,

src/kits/debugger/dwarf/DwarfTargetInterface.h

35

virtual bool ReadMemory(target_addr_t address, void* buffer,

src/kits/debugger/dwarf/DwarfTargetInterface.h

37

virtual bool ReadValueFromMemory(target_addr_t address,

src/kits/debugger/dwarf/DwarfTargetInterface.h

41

target_addr_t address,

src/kits/debugger/dwarf/LineNumberProgram.cpp

116

state.address += dataReader.ReadUnsignedLEB128(0)

src/kits/debugger/dwarf/LineNumberProgram.cpp

135

state.address += ((255 - fOpcodeBase) / fLineRange)

src/kits/debugger/dwarf/LineNumberProgram.cpp

139

state.address += dataReader.Read<uint16>(0);

src/kits/debugger/dwarf/LineNumberProgram.cpp

169

state.address = dataReader.ReadAddress(0);

src/kits/debugger/dwarf/LineNumberProgram.cpp

210

state.address = 0;

src/kits/debugger/dwarf/LineNumberProgram.cpp

97

state.address += (adjustedOpcode / fLineRange)

src/kits/debugger/dwarf/LineNumberProgram.h

48

target_addr_t address;

src/kits/debugger/elf/CoreFile.cpp

777

CoreFile::_FindArea(uint64 address) const

src/kits/debugger/elf/CoreFile.cpp

782

if (address >= area->BaseAddress()

src/kits/debugger/elf/CoreFile.cpp

783

&& address < area->EndAddress()) {

src/kits/debugger/elf/CoreFile.cpp

793

CoreFile::_FindAreaSegment(uint64 address) const

src/kits/debugger/elf/CoreFile.cpp

798

if (segment->Type() == PT_LOAD && segment->LoadAddress() == address)

src/kits/debugger/elf/CoreFile.h

183

const CoreFileAreaInfo* AreaInfoForAddress(uint64 address) const

src/kits/debugger/elf/CoreFile.h

184

{ return _FindArea(address); }

src/kits/debugger/elf/CoreFile.h

235

CoreFileAreaInfo* _FindArea(uint64 address) const;

src/kits/debugger/elf/CoreFile.h

236

ElfSegment* _FindAreaSegment(uint64 address) const;

src/kits/debugger/elf/ElfFile.cpp

131

virtual ssize_t Read(uint64 address, void* buffer, size_t size)

src/kits/debugger/elf/ElfFile.cpp

134

if (address < segment->fMemoryAddress

src/kits/debugger/elf/ElfFile.cpp

135

|| address - segment->fMemoryAddress

src/kits/debugger/elf/ElfFile.cpp

140

uint64 offset = address - segment->fMemoryAddress;

src/kits/debugger/elf/ElfSymbolLookup.cpp

102

status_t _Cache(uint64 address, size_t size)

src/kits/debugger/elf/ElfSymbolLookup.cpp

108

ssize_t bytesRead = fSource->Read(address, fBuffer[i], fBufferSize);

src/kits/debugger/elf/ElfSymbolLookup.cpp

114

fAddress[i] = address;

src/kits/debugger/elf/ElfSymbolLookup.cpp

236

target_addr_t address = Get(symbol.st_value) + fLoadDelta;

src/kits/debugger/elf/ElfSymbolLookup.cpp

249

_info.SetTo(address, size, type, name);

src/kits/debugger/elf/ElfSymbolLookup.cpp

274

status_t _ReadString(uint64 address, size_t size, BString& _string)

src/kits/debugger/elf/ElfSymbolLookup.cpp

281

ssize_t bytesRead = fSource->Read(address, buffer, toRead);

src/kits/debugger/elf/ElfSymbolLookup.cpp

298

address += bytesRead;

src/kits/debugger/elf/ElfSymbolLookup.cpp

53

virtual ssize_t Read(uint64 address, void* _buffer, size_t size)

src/kits/debugger/elf/ElfSymbolLookup.cpp

59

ssize_t bytesRead = _ReadPartial(address, buffer, size);

src/kits/debugger/elf/ElfSymbolLookup.cpp

74

ssize_t _ReadPartial(uint64 address, uint8* buffer, size_t size)

src/kits/debugger/elf/ElfSymbolLookup.cpp

76

size_t bytesRead = _ReadCached(address, buffer, size);

src/kits/debugger/elf/ElfSymbolLookup.cpp

80

status_t error = _Cache(address, size);

src/kits/debugger/elf/ElfSymbolLookup.cpp

84

return (ssize_t)_ReadCached(address, buffer, size);

src/kits/debugger/elf/ElfSymbolLookup.cpp

87

size_t _ReadCached(uint64 address, uint8* buffer, size_t size)

src/kits/debugger/elf/ElfSymbolLookup.cpp

90

if (address >= fAddress[i]

src/kits/debugger/elf/ElfSymbolLookup.cpp

91

&& address < fAddress[i] + fCachedSize[i]) {

src/kits/debugger/elf/ElfSymbolLookup.cpp

93

size_t(fAddress[i] + fCachedSize[i] - address));

src/kits/debugger/elf/ElfSymbolLookup.cpp

94

memcpy(buffer, fBuffer[i] + (address - fAddress[i]), toRead);

src/kits/debugger/elf/ElfSymbolLookup.cpp

95

fHitEnd[i] = address + toRead == fAddress[i] + fCachedSize[i];

src/kits/debugger/elf/ElfSymbolLookup.h

17

virtual ssize_t Read(uint64 address, void* buffer,

src/kits/debugger/jobs/Jobs.h

259

target_addr_t address, void* data,

src/kits/debugger/jobs/WriteMemoryJob.cpp

13

TeamMemory* teamMemory, target_addr_t address, void* data,

src/kits/debugger/jobs/WriteMemoryJob.cpp

19

fTargetAddress(address),

src/kits/debugger/model/AreaInfo.cpp

39

target_addr_t address, target_size_t size, target_size_t ramSize,

src/kits/debugger/model/AreaInfo.cpp

45

fAddress(address),

src/kits/debugger/model/AreaInfo.cpp

56

target_addr_t address, target_size_t size, target_size_t ramSize,

src/kits/debugger/model/AreaInfo.cpp

62

fAddress = address;

src/kits/debugger/model/Breakpoint.cpp

110

Breakpoint::CompareAddressBreakpoint(const target_addr_t* address,

src/kits/debugger/model/Breakpoint.cpp

113

if (*address < breakpoint->Address())

src/kits/debugger/model/Breakpoint.cpp

115

return *address == breakpoint->Address() ? 0 : 1;

src/kits/debugger/model/Breakpoint.cpp

20

Breakpoint::Breakpoint(Image* image, target_addr_t address)

src/kits/debugger/model/Breakpoint.cpp

22

fAddress(address),

src/kits/debugger/model/DisassembledCode.cpp

126

DisassembledCode::StatementAtAddress(target_addr_t address) const

src/kits/debugger/model/DisassembledCode.cpp

128

return fStatements.BinarySearchByKey(address, &_CompareAddressStatement);

src/kits/debugger/model/DisassembledCode.cpp

154

DisassembledCode::AddInstructionLine(const BString& line, target_addr_t address,

src/kits/debugger/model/DisassembledCode.cpp

160

SourceLocation(lineIndex), TargetAddressRange(address, size));

src/kits/debugger/model/DisassembledCode.cpp

193

DisassembledCode::_CompareAddressStatement(const target_addr_t* address,

src/kits/debugger/model/DisassembledCode.cpp

198

if (*address < range.Start())

src/kits/debugger/model/DisassembledCode.cpp

200

return *address < range.End() ? 0 : 1;

src/kits/debugger/model/Image.cpp

47

Image::ContainsAddress(target_addr_t address) const

src/kits/debugger/model/Image.cpp

49

return (address >= fInfo.TextBase()

src/kits/debugger/model/Image.cpp

50

&& address < fInfo.TextBase() + fInfo.TextSize())

src/kits/debugger/model/Image.cpp

51

|| (address >= fInfo.DataBase()

src/kits/debugger/model/Image.cpp

52

&& address < fInfo.DataBase() + fInfo.DataSize());

src/kits/debugger/model/ReturnValueInfo.cpp

21

ReturnValueInfo::ReturnValueInfo(target_addr_t address, CpuState* state)

src/kits/debugger/model/ReturnValueInfo.cpp

24

fAddress(address),

src/kits/debugger/model/ReturnValueInfo.cpp

39

ReturnValueInfo::SetTo(target_addr_t address, CpuState* state)

src/kits/debugger/model/ReturnValueInfo.cpp

41

fAddress = address;

src/kits/debugger/model/StackFrame.cpp

104

StackFrame::SetReturnAddress(target_addr_t address)

src/kits/debugger/model/StackFrame.cpp

106

fReturnAddress = address;

src/kits/debugger/model/Statement.cpp

68

ContiguousStatement::ContainsAddress(target_addr_t address) const

src/kits/debugger/model/Statement.cpp

70

return fRange.Contains(address);

src/kits/debugger/model/SymbolInfo.cpp

19

SymbolInfo::SymbolInfo(target_addr_t address, target_size_t size, uint32 type,

src/kits/debugger/model/SymbolInfo.cpp

22

fAddress(address),

src/kits/debugger/model/SymbolInfo.cpp

36

SymbolInfo::SetTo(target_addr_t address, target_size_t size, uint32 type,

src/kits/debugger/model/SymbolInfo.cpp

39

fAddress = address;

src/kits/debugger/model/Team.cpp

1064

target_addr_t address, target_size_t size)

src/kits/debugger/model/Team.cpp

1067

fTargetAddress(address),

src/kits/debugger/model/Team.cpp

262

Team::ImageByAddress(target_addr_t address) const

src/kits/debugger/model/Team.cpp

266

if (image->ContainsAddress(address))

src/kits/debugger/model/Team.cpp

34

BreakpointByAddressPredicate(target_addr_t address)

src/kits/debugger/model/Team.cpp

36

fAddress(address)

src/kits/debugger/model/Team.cpp

435

Team::BreakpointAtAddress(target_addr_t address) const

src/kits/debugger/model/Team.cpp

437

return fBreakpoints.BinarySearchByKey(address,

src/kits/debugger/model/Team.cpp

549

Team::WatchpointAtAddress(target_addr_t address) const

src/kits/debugger/model/Team.cpp

55

WatchpointByAddressPredicate(target_addr_t address)

src/kits/debugger/model/Team.cpp

551

return fWatchpoints.BinarySearchByKey(address,

src/kits/debugger/model/Team.cpp

57

fAddress(address)

src/kits/debugger/model/Team.cpp

572

Team::GetStatementAtAddress(target_addr_t address, FunctionInstance*& _function,

src/kits/debugger/model/Team.cpp

575

TRACE_CODE("Team::GetStatementAtAddress(%#" B_PRIx64 ")\n", address);

src/kits/debugger/model/Team.cpp

578

Image* image = ImageByAddress(address);

src/kits/debugger/model/Team.cpp

592

= imageDebugInfo->FunctionAtAddress(address);

src/kits/debugger/model/Team.cpp

601

Statement* statement = code->StatementAtAddress(address);

src/kits/debugger/model/Team.cpp

615

->GetStatement(functionDebugInfo, address, _statement);

src/kits/debugger/model/Team.cpp

867

Team::NotifyMemoryChanged(target_addr_t address, target_size_t size)

src/kits/debugger/model/Team.cpp

872

TEAM_EVENT_MEMORY_CHANGED, this, address, size));

src/kits/debugger/model/TeamMemory.cpp

21

TeamMemory::ReadMemoryString(target_addr_t address, size_t maxLength,

src/kits/debugger/model/TeamMemory.cpp

30

B_PAGE_SIZE - size_t(address % B_PAGE_SIZE));

src/kits/debugger/model/TeamMemory.cpp

31

ssize_t bytesRead = ReadMemory(address, buffer, toRead);

src/kits/debugger/model/TeamMemory.cpp

46

address += bytesRead;

src/kits/debugger/model/TeamMemoryBlock.cpp

81

TeamMemoryBlock::Contains(target_addr_t address) const

src/kits/debugger/model/TeamMemoryBlock.cpp

83

return fValid && address >= fBaseAddress

src/kits/debugger/model/TeamMemoryBlock.cpp

84

&& address < (fBaseAddress + sizeof(fData));

src/kits/debugger/model/UserBreakpoint.cpp

80

target_addr_t address)

src/kits/debugger/model/UserBreakpoint.cpp

82

fAddress(address),

src/kits/debugger/model/Watchpoint.cpp

11

fAddress(address),

src/kits/debugger/model/Watchpoint.cpp

40

Watchpoint::Contains(target_addr_t address) const

src/kits/debugger/model/Watchpoint.cpp

42

return address >= fAddress && address <= (fAddress + fLength);

src/kits/debugger/model/Watchpoint.cpp

56

Watchpoint::CompareAddressWatchpoint(const target_addr_t* address,

src/kits/debugger/model/Watchpoint.cpp

59

if (*address < watchpoint->Address())

src/kits/debugger/model/Watchpoint.cpp

61

return *address == watchpoint->Address() ? 0 : 1;

src/kits/debugger/model/Watchpoint.cpp

9

Watchpoint::Watchpoint(target_addr_t address, uint32 type, int32 length)

src/kits/debugger/types/TargetAddressRangeList.cpp

87

TargetAddressRangeList::Contains(target_addr_t address) const

src/kits/debugger/types/TargetAddressRangeList.cpp

91

if (fRanges[i].Contains(address))

src/kits/debugger/types/ValueLocation.cpp

25

address += excessMSBs;

src/kits/debugger/types/ValueLocation.cpp

27

address += excessLSBs;

src/kits/debugger/types/ValueLocation.cpp

295

printf(" address %#" B_PRIx64, piece.address);

src/kits/debugger/types/ValueLocation.cpp

88

piece.SetToMemory(piece.address + byteOffset);

src/kits/debugger/user_interface/util/UiUtils.cpp

351

TeamMemoryBlock* block, target_addr_t address, int32 itemSize,

src/kits/debugger/user_interface/util/UiUtils.cpp

359

if (!block->Contains(address + i * itemSize))

src/kits/debugger/user_interface/util/UiUtils.cpp

371

data.SetToFormat("[%#" B_PRIx64 "] ", address + i * itemSize);

src/kits/debugger/user_interface/util/UiUtils.cpp

375

c = *(block->Data() + address - block->BaseAddress()

src/kits/debugger/user_interface/util/UiUtils.cpp

390

value = block->Data() + address - block->BaseAddress()

src/kits/debugger/value/ValueLoader.cpp

119

target_addr_t address = piece.address;

src/kits/debugger/value/ValueLoader.cpp

123

B_PRIx64 ", bits: %" B_PRIu32 "\n", i, address,

src/kits/debugger/value/ValueLoader.cpp

133

bytesRead = fTeamMemory->ReadMemory(address,

src/kits/debugger/value/ValueWriter.cpp

76

target_addr_t address = piece.address;

src/kits/debugger/value/ValueWriter.cpp

79

B_PRIx64 ", bits: %" B_PRIu32 "\n", i, address,

src/kits/debugger/value/ValueWriter.cpp

82

ssize_t bytesWritten = fDebuggerInterface->WriteMemory(address,

src/kits/debugger/value/value_nodes/BListValueNode.cpp

274

fItemCountLocation = memberLocation->PieceAt(0).address;

src/kits/debugger/value/value_nodes/BMessageValueNode.cpp

176

headerAddress.SetTo(location->PieceAt(0).address);

src/kits/debugger/value/value_nodes/BMessageValueNode.cpp

81

piece.SetToMemory(parentLocation->PieceAt(0).address

src/kits/debugger/value/value_nodes/CStringValueNode.cpp

79

addressData.SetTo(location->PieceAt(0).address);

src/kits/interface/Bitmap.cpp

1133

fBasePointer = (uint8*)info.address + areaOffset;

src/kits/mail/MailMessage.cpp

132

char* address = (char*)list.RemoveItem((int32)0);

src/kits/mail/MailMessage.cpp

136

if (sender.ICompare(address) && cc.FindFirst(address) < 0) {

src/kits/mail/MailMessage.cpp

140

cc << address;

src/kits/mail/MailMessage.cpp

143

free(address);

src/kits/mail/MailMessage.cpp

746

char *address = (char *)recipientList.RemoveItem((int32)0);

src/kits/mail/MailMessage.cpp

748

recipients << '<' << address << '>';

src/kits/mail/MailMessage.cpp

752

free(address);

src/kits/mail/mail_util.cpp

1465

extract_address(BString &address)

src/kits/mail/mail_util.cpp

1467

const char *string = address.String();

src/kits/mail/mail_util.cpp

1472

if ((first = address.FindFirst('"')) >= 0) {

src/kits/mail/mail_util.cpp

1478

address.Remove(first, last + 1 - first);

src/kits/mail/mail_util.cpp

1483

if ((first = address.FindFirst('<')) >= 0) {

src/kits/mail/mail_util.cpp

1485

int32 last = address.FindFirst('>');

src/kits/mail/mail_util.cpp

1487

address.Truncate(last);

src/kits/mail/mail_util.cpp

1488

address.Remove(0, first + 1);

src/kits/mail/mail_util.cpp

1496

if ((first = address.FindFirst('(')) >= 0) {

src/kits/mail/mail_util.cpp

1502

address.Remove(first, last + 1 - first);

src/kits/mail/mail_util.cpp

1507

trim_white_space(address);

src/kits/mail/mail_util.cpp

1534

BString address(start, string - start);

src/kits/mail/mail_util.cpp

1535

trim_white_space(address);

src/kits/mail/mail_util.cpp

1538

cleanupFunc(address);

src/kits/mail/mail_util.cpp

1540

list.AddItem(strdup(address.String()));

src/kits/media/MediaFiles.cpp

107

const char* items = (const char*)reply.address;

src/kits/media/MediaFiles.cpp

56

const char* types = (const char*)reply.address;

src/kits/media/MediaRoster.cpp

1709

info = (live_node_info*)reply.address;

src/kits/network/libnetapi/DatagramSocket.cpp

92

BDatagramSocket::SendTo(const BNetworkAddress& address, const void* buffer,

src/kits/network/libnetapi/DatagramSocket.cpp

95

ssize_t bytesSent = sendto(fSocket, buffer, size, 0, address,

src/kits/network/libnetapi/DatagramSocket.cpp

96

address.Length());

src/kits/network/libnetapi/NetAddress.cpp

308

BNetAddress* address = new (std::nothrow) BNetAddress(archive);

src/kits/network/libnetapi/NetAddress.cpp

309

if (address == NULL)

src/kits/network/libnetapi/NetAddress.cpp

312

if (address->InitCheck() != B_OK) {

src/kits/network/libnetapi/NetAddress.cpp

313

delete address;

src/kits/network/libnetapi/NetAddress.cpp

317

return address;

src/kits/network/libnetapi/NetEndpoint.cpp

347

BNetEndpoint::Bind(const BNetAddress& address)

src/kits/network/libnetapi/NetEndpoint.cpp

353

status_t status = address.GetAddr(addr);

src/kits/network/libnetapi/NetEndpoint.cpp

384

BNetEndpoint::Connect(const BNetAddress& address)

src/kits/network/libnetapi/NetEndpoint.cpp

390

if (address.GetAddr(addr) != B_OK)

src/kits/network/libnetapi/NetEndpoint.cpp

538

BNetAddress& address, int flags)

src/kits/network/libnetapi/NetEndpoint.cpp

554

address.SetTo(addr);

src/kits/network/libnetapi/NetEndpoint.cpp

562

BNetAddress& address, int flags)

src/kits/network/libnetapi/NetEndpoint.cpp

565

ssize_t bytesReceived = ReceiveFrom(chunk.Data(), length, address, flags);

src/kits/network/libnetapi/NetEndpoint.cpp

595

const BNetAddress& address, int flags)

src/kits/network/libnetapi/NetEndpoint.cpp

601

if (address.GetAddr(addr) != B_OK)

src/kits/network/libnetapi/NetEndpoint.cpp

615

const BNetAddress& address, int flags)

src/kits/network/libnetapi/NetEndpoint.cpp

617

return SendTo(buffer.Data(), buffer.Size(), address, flags);

src/kits/network/libnetapi/NetworkAddress.cpp

101

SetTo(address);

src/kits/network/libnetapi/NetworkAddress.cpp

1032

BString address = buffer;

src/kits/network/libnetapi/NetworkAddress.cpp

1035

address = "[";

src/kits/network/libnetapi/NetworkAddress.cpp

1036

address += buffer;

src/kits/network/libnetapi/NetworkAddress.cpp

1037

address += "]";

src/kits/network/libnetapi/NetworkAddress.cpp

1041

address += buffer;

src/kits/network/libnetapi/NetworkAddress.cpp

1044

return address;

src/kits/network/libnetapi/NetworkAddress.cpp

105

BNetworkAddress::BNetworkAddress(const sockaddr_in6& address)

src/kits/network/libnetapi/NetworkAddress.cpp

107

SetTo(address);

src/kits/network/libnetapi/NetworkAddress.cpp

1080

sockaddr_in& address = (sockaddr_in&)fAddress;

src/kits/network/libnetapi/NetworkAddress.cpp

1082

return memcmp(&address.sin_addr, &otherAddress.sin_addr,

src/kits/network/libnetapi/NetworkAddress.cpp

1083

sizeof(address.sin_addr)) == 0;

src/kits/network/libnetapi/NetworkAddress.cpp

1088

sockaddr_in6& address = (sockaddr_in6&)fAddress;

src/kits/network/libnetapi/NetworkAddress.cpp

1090

return memcmp(&address.sin6_addr, &otherAddress.sin6_addr,

src/kits/network/libnetapi/NetworkAddress.cpp

1091

sizeof(address.sin6_addr)) == 0;

src/kits/network/libnetapi/NetworkAddress.cpp

111

BNetworkAddress::BNetworkAddress(const sockaddr_dl& address)

src/kits/network/libnetapi/NetworkAddress.cpp

113

SetTo(address);

src/kits/network/libnetapi/NetworkAddress.cpp

117

BNetworkAddress::BNetworkAddress(in_addr_t address, uint16 port)

src/kits/network/libnetapi/NetworkAddress.cpp

119

SetTo(address, port);

src/kits/network/libnetapi/NetworkAddress.cpp

1199

sockaddr_in& address = (sockaddr_in&)fAddress;

src/kits/network/libnetapi/NetworkAddress.cpp

1201

compare = memcmp(&address.sin_addr, &otherAddress.sin_addr,

src/kits/network/libnetapi/NetworkAddress.cpp

1202

sizeof(address.sin_addr));

src/kits/network/libnetapi/NetworkAddress.cpp

1208

sockaddr_in6& address = (sockaddr_in6&)fAddress;

src/kits/network/libnetapi/NetworkAddress.cpp

1210

compare = memcmp(&address.sin6_addr, &otherAddress.sin6_addr,

src/kits/network/libnetapi/NetworkAddress.cpp

1211

sizeof(address.sin6_addr));

src/kits/network/libnetapi/NetworkAddress.cpp

123

BNetworkAddress::BNetworkAddress(const in6_addr& address, uint16 port)

src/kits/network/libnetapi/NetworkAddress.cpp

125

SetTo(address, port);

src/kits/network/libnetapi/NetworkAddress.cpp

1276

BNetworkAddress::_ParseLinkAddress(const char* address)

src/kits/network/libnetapi/NetworkAddress.cpp

1278

if (address == NULL)

src/kits/network/libnetapi/NetworkAddress.cpp

1284

if (!isxdigit(address[0]) || !isxdigit(address[1]))

src/kits/network/libnetapi/NetworkAddress.cpp

1287

linkAddress[length++] = (from_hex(address[0]) << 4)

src/kits/network/libnetapi/NetworkAddress.cpp

1288

| from_hex(address[1]);

src/kits/network/libnetapi/NetworkAddress.cpp

1290

if (address[2] == '\0')

src/kits/network/libnetapi/NetworkAddress.cpp

1292

if (address[2] != ':')

src/kits/network/libnetapi/NetworkAddress.cpp

1295

address += 3;

src/kits/network/libnetapi/NetworkAddress.cpp

1298

fHostName = address;

src/kits/network/libnetapi/NetworkAddress.cpp

272

BNetworkAddress::SetTo(const sockaddr& address)

src/kits/network/libnetapi/NetworkAddress.cpp

274

if (address.sa_family == AF_UNSPEC) {

src/kits/network/libnetapi/NetworkAddress.cpp

279

size_t length = min_c(sizeof(sockaddr_storage), address.sa_len);

src/kits/network/libnetapi/NetworkAddress.cpp

280

switch (address.sa_family) {

src/kits/network/libnetapi/NetworkAddress.cpp

289

sockaddr_dl& link = (sockaddr_dl&)address;

src/kits/network/libnetapi/NetworkAddress.cpp

296

SetTo(address, length);

src/kits/network/libnetapi/NetworkAddress.cpp

301

BNetworkAddress::SetTo(const sockaddr& address, size_t length)

src/kits/network/libnetapi/NetworkAddress.cpp

303

if (address.sa_family == AF_UNSPEC || length == 0) {

src/kits/network/libnetapi/NetworkAddress.cpp

308

memcpy(&fAddress, &address, length);

src/kits/network/libnetapi/NetworkAddress.cpp

315

BNetworkAddress::SetTo(const sockaddr_storage& address)

src/kits/network/libnetapi/NetworkAddress.cpp

317

SetTo((sockaddr&)address);

src/kits/network/libnetapi/NetworkAddress.cpp

322

BNetworkAddress::SetTo(const sockaddr_in& address)

src/kits/network/libnetapi/NetworkAddress.cpp

324

SetTo((sockaddr&)address);

src/kits/network/libnetapi/NetworkAddress.cpp

329

BNetworkAddress::SetTo(const sockaddr_in6& address)

src/kits/network/libnetapi/NetworkAddress.cpp

331

SetTo((sockaddr&)address);

src/kits/network/libnetapi/NetworkAddress.cpp

336

BNetworkAddress::SetTo(const sockaddr_dl& address)

src/kits/network/libnetapi/NetworkAddress.cpp

338

SetTo((sockaddr&)address);

src/kits/network/libnetapi/NetworkAddress.cpp

498

sockaddr_in& address = (sockaddr_in&)fAddress;

src/kits/network/libnetapi/NetworkAddress.cpp

499

address.sin_addr.s_addr = inetAddress;

src/kits/network/libnetapi/NetworkAddress.cpp

510

sockaddr_in6& address = (sockaddr_in6&)fAddress;

src/kits/network/libnetapi/NetworkAddress.cpp

511

memcpy(address.sin6_addr.s6_addr, &inet6Address,

src/kits/network/libnetapi/NetworkAddress.cpp

512

sizeof(address.sin6_addr.s6_addr));

src/kits/network/libnetapi/NetworkAddress.cpp

536

BNetworkAddress::SetToLinkLevel(const uint8* address, size_t length)

src/kits/network/libnetapi/NetworkAddress.cpp

543

memcpy(LLADDR(&link), address, length);

src/kits/network/libnetapi/NetworkAddress.cpp

842

BNetworkInterfaceAddress address;

src/kits/network/libnetapi/NetworkAddress.cpp

843

if (interface.GetAddressAt(j, address) != B_OK)

src/kits/network/libnetapi/NetworkAddress.cpp

846

if (Equals(address.Address(), false))

src/kits/network/libnetapi/NetworkAddress.cpp

87

BNetworkAddress::BNetworkAddress(const sockaddr& address)

src/kits/network/libnetapi/NetworkAddress.cpp

89

SetTo(address);

src/kits/network/libnetapi/NetworkAddress.cpp

900

sockaddr_dl& address = (sockaddr_dl&)fAddress;

src/kits/network/libnetapi/NetworkAddress.cpp

901

if (address.sdl_nlen == 0)

src/kits/network/libnetapi/NetworkAddress.cpp

905

name.SetTo((const char*)address.sdl_data, address.sdl_nlen);

src/kits/network/libnetapi/NetworkAddress.cpp

93

BNetworkAddress::BNetworkAddress(const sockaddr_storage& address)

src/kits/network/libnetapi/NetworkAddress.cpp

95

SetTo(address);

src/kits/network/libnetapi/NetworkAddress.cpp

972

BNetworkAddress::ResolveTo(const BNetworkAddress& address)

src/kits/network/libnetapi/NetworkAddress.cpp

976

if (address.fAddress.ss_family != fAddress.ss_family)

src/kits/network/libnetapi/NetworkAddress.cpp

980

*this = address;

src/kits/network/libnetapi/NetworkAddress.cpp

99

BNetworkAddress::BNetworkAddress(const sockaddr_in& address)

src/kits/network/libnetapi/NetworkAddressResolver.cpp

119

BNetworkAddressResolver::SetTo(const char* address, uint16 port, uint32 flags)

src/kits/network/libnetapi/NetworkAddressResolver.cpp

121

return SetTo(AF_UNSPEC, address, port, flags);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

126

BNetworkAddressResolver::SetTo(const char* address, const char* service,

src/kits/network/libnetapi/NetworkAddressResolver.cpp

129

return SetTo(AF_UNSPEC, address, service, flags);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

134

BNetworkAddressResolver::SetTo(int family, const char* address, uint16 port,

src/kits/network/libnetapi/NetworkAddressResolver.cpp

140

return SetTo(family, address, port != 0 ? service.String() : NULL, flags);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

217

BNetworkAddress& address) const

src/kits/network/libnetapi/NetworkAddressResolver.cpp

235

address.SetTo(*info->ai_addr, info->ai_addrlen);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

244

BNetworkAddress& address) const

src/kits/network/libnetapi/NetworkAddressResolver.cpp

264

address.SetTo(*info->ai_addr, info->ai_addrlen);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

272

BNetworkAddressResolver::Resolve(const char* address, const char* service,

src/kits/network/libnetapi/NetworkAddressResolver.cpp

275

return Resolve(AF_UNSPEC, address, service, flags);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

280

BNetworkAddressResolver::Resolve(const char* address, uint16 port, uint32 flags)

src/kits/network/libnetapi/NetworkAddressResolver.cpp

282

return Resolve(AF_UNSPEC, address, port, flags);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

287

BNetworkAddressResolver::Resolve(int family, const char* address,

src/kits/network/libnetapi/NetworkAddressResolver.cpp

293

return Resolve(family, address, port == 0 ? NULL : service.String(), flags);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

298

BNetworkAddressResolver::Resolve(int family, const char* address,

src/kits/network/libnetapi/NetworkAddressResolver.cpp

310

if (entry->Matches(family, address, service, flags)) {

src/kits/network/libnetapi/NetworkAddressResolver.cpp

324

BNetworkAddressResolver(family, address, service, flags);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

327

CacheEntry* entry = new(std::nothrow) CacheEntry(family, address,

src/kits/network/libnetapi/NetworkAddressResolver.cpp

51

BNetworkAddressResolver::BNetworkAddressResolver(const char* address,

src/kits/network/libnetapi/NetworkAddressResolver.cpp

58

SetTo(address, port, flags);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

61

BNetworkAddressResolver::BNetworkAddressResolver(const char* address,

src/kits/network/libnetapi/NetworkAddressResolver.cpp

68

SetTo(address, service, flags);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

73

const char* address, uint16 port, uint32 flags)

src/kits/network/libnetapi/NetworkAddressResolver.cpp

79

SetTo(family, address, port, flags);

src/kits/network/libnetapi/NetworkAddressResolver.cpp

84

const char* address, const char* service, uint32 flags)

src/kits/network/libnetapi/NetworkAddressResolver.cpp

90

SetTo(family, address, service, flags);

src/kits/network/libnetapi/NetworkDevice.cpp

1012

address.SetToLinkLevel(mac, IEEE80211_ADDR_LEN);

src/kits/network/libnetapi/NetworkDevice.cpp

389

network.address.SetToLinkLevel(info.isi_macaddr,

src/kits/network/libnetapi/NetworkDevice.cpp

410

network.address.SetToLinkLevel(result.isr_bssid,

src/kits/network/libnetapi/NetworkDevice.cpp

481

const BNetworkAddress* address, const char* name)

src/kits/network/libnetapi/NetworkDevice.cpp

483

if (address != NULL && address->Family() != AF_LINK)

src/kits/network/libnetapi/NetworkDevice.cpp

512

if (index == count || (address != NULL && !memcmp(

src/kits/network/libnetapi/NetworkDevice.cpp

513

address->LinkLevelAddress(), result->isr_bssid,

src/kits/network/libnetapi/NetworkDevice.cpp

532

const BNetworkAddress* address, const char* name)

src/kits/network/libnetapi/NetworkDevice.cpp

534

if (address != NULL && address->Family() != AF_LINK)

src/kits/network/libnetapi/NetworkDevice.cpp

545

if (address != NULL) {

src/kits/network/libnetapi/NetworkDevice.cpp

546

memcpy(request.is_u.macaddr, address->LinkLevelAddress(),

src/kits/network/libnetapi/NetworkDevice.cpp

566

if (index == count || address != NULL

src/kits/network/libnetapi/NetworkDevice.cpp

583

const BNetworkAddress* address, const char* name)

src/kits/network/libnetapi/NetworkDevice.cpp

585

status_t status = get_station(device, network, index, address, name);

src/kits/network/libnetapi/NetworkDevice.cpp

587

return get_scan_result(device, network, index, address, name);

src/kits/network/libnetapi/NetworkDevice.cpp

695

BNetworkDevice::GetHardwareAddress(BNetworkAddress& address)

src/kits/network/libnetapi/NetworkDevice.cpp

702

address.SetTo(request.ifr_addr);

src/kits/network/libnetapi/NetworkDevice.cpp

850

BNetworkDevice::GetNetwork(const BNetworkAddress& address,

src/kits/network/libnetapi/NetworkDevice.cpp

853

if (address.Family() != AF_LINK)

src/kits/network/libnetapi/NetworkDevice.cpp

856

return get_network(Name(), network, UINT32_MAX, &address, NULL);

src/kits/network/libnetapi/NetworkDevice.cpp

892

return JoinNetwork(network.address, password);

src/kits/network/libnetapi/NetworkDevice.cpp

897

BNetworkDevice::JoinNetwork(const BNetworkAddress& address,

src/kits/network/libnetapi/NetworkDevice.cpp

900

if (address.InitCheck() != B_OK)

src/kits/network/libnetapi/NetworkDevice.cpp

908

const_cast<BNetworkAddress*>(&address));

src/kits/network/libnetapi/NetworkDevice.cpp

952

return LeaveNetwork(network.address);

src/kits/network/libnetapi/NetworkDevice.cpp

957

BNetworkDevice::LeaveNetwork(const BNetworkAddress& address)

src/kits/network/libnetapi/NetworkDevice.cpp

963

const_cast<BNetworkAddress*>(&address));

src/kits/network/libnetapi/NetworkDevice.cpp

984

BNetworkAddress address;

src/kits/network/libnetapi/NetworkDevice.cpp

985

status_t status = GetNextAssociatedNetwork(cookie, address);

src/kits/network/libnetapi/NetworkDevice.cpp

989

return GetNetwork(address, network);

src/kits/network/libnetapi/NetworkDevice.cpp

995

BNetworkAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

120

BNetworkInterfaceAddress::SetAddress(const BNetworkAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

122

fAddress = address;

src/kits/network/libnetapi/NetworkInterface.cpp

19

family_from_interface_address(const BNetworkInterfaceAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

21

if (address.Address().Family() != AF_UNSPEC)

src/kits/network/libnetapi/NetworkInterface.cpp

22

return address.Address().Family();

src/kits/network/libnetapi/NetworkInterface.cpp

23

if (address.Mask().Family() != AF_UNSPEC)

src/kits/network/libnetapi/NetworkInterface.cpp

24

return address.Mask().Family();

src/kits/network/libnetapi/NetworkInterface.cpp

25

if (address.Destination().Family() != AF_UNSPEC)

src/kits/network/libnetapi/NetworkInterface.cpp

26

return address.Destination().Family();

src/kits/network/libnetapi/NetworkInterface.cpp

33

do_ifaliasreq(const char* name, int32 option, BNetworkInterfaceAddress& address,

src/kits/network/libnetapi/NetworkInterface.cpp

358

BNetworkInterface::GetAddressAt(int32 index, BNetworkInterfaceAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

360

return address.SetTo(*this, index);

src/kits/network/libnetapi/NetworkInterface.cpp

365

BNetworkInterface::FindAddress(const BNetworkAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

367

FileDescriptorCloser socket(::socket(address.Family(), SOCK_DGRAM, 0));

src/kits/network/libnetapi/NetworkInterface.cpp

376

memcpy(&request.ifra_addr, &address.SockAddr(), address.Length());

src/kits/network/libnetapi/NetworkInterface.cpp

38

family = family_from_interface_address(address);

src/kits/network/libnetapi/NetworkInterface.cpp

411

BNetworkInterface::AddAddress(const BNetworkInterfaceAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

413

return do_ifaliasreq(Name(), B_SOCKET_ADD_ALIAS, address);

src/kits/network/libnetapi/NetworkInterface.cpp

420

BNetworkInterfaceAddress address;

src/kits/network/libnetapi/NetworkInterface.cpp

421

address.SetAddress(local);

src/kits/network/libnetapi/NetworkInterface.cpp

423

return do_ifaliasreq(Name(), B_SOCKET_ADD_ALIAS, address);

src/kits/network/libnetapi/NetworkInterface.cpp

428

BNetworkInterface::SetAddress(const BNetworkInterfaceAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

430

return do_ifaliasreq(Name(), B_SOCKET_SET_ALIAS, address);

src/kits/network/libnetapi/NetworkInterface.cpp

435

BNetworkInterface::RemoveAddress(const BNetworkInterfaceAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

438

memcpy(&request.ifr_addr, &address.Address().SockAddr(),

src/kits/network/libnetapi/NetworkInterface.cpp

439

address.Address().Length());

src/kits/network/libnetapi/NetworkInterface.cpp

441

return do_request(family_from_interface_address(address), request, Name(),

src/kits/network/libnetapi/NetworkInterface.cpp

447

BNetworkInterface::RemoveAddress(const BNetworkAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

450

memcpy(&request.ifr_addr, &address.SockAddr(), address.Length());

src/kits/network/libnetapi/NetworkInterface.cpp

452

return do_request(address.Family(), request, Name(), B_SOCKET_REMOVE_ALIAS);

src/kits/network/libnetapi/NetworkInterface.cpp

459

BNetworkInterfaceAddress address;

src/kits/network/libnetapi/NetworkInterface.cpp

46

request.ifra_index = address.Index();

src/kits/network/libnetapi/NetworkInterface.cpp

460

status_t status = GetAddressAt(index, address);

src/kits/network/libnetapi/NetworkInterface.cpp

464

return RemoveAddress(address);

src/kits/network/libnetapi/NetworkInterface.cpp

469

BNetworkInterface::GetHardwareAddress(BNetworkAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

47

request.ifra_flags = address.Flags();

src/kits/network/libnetapi/NetworkInterface.cpp

481

address.SetTo(request.ifr_addr);

src/kits/network/libnetapi/NetworkInterface.cpp

49

memcpy(&request.ifra_addr, &address.Address().SockAddr(),

src/kits/network/libnetapi/NetworkInterface.cpp

50

address.Address().Length());

src/kits/network/libnetapi/NetworkInterface.cpp

51

memcpy(&request.ifra_mask, &address.Mask().SockAddr(),

src/kits/network/libnetapi/NetworkInterface.cpp

52

address.Mask().Length());

src/kits/network/libnetapi/NetworkInterface.cpp

53

memcpy(&request.ifra_broadaddr, &address.Broadcast().SockAddr(),

src/kits/network/libnetapi/NetworkInterface.cpp

54

address.Broadcast().Length());

src/kits/network/libnetapi/NetworkInterface.cpp

569

BMessage address;

src/kits/network/libnetapi/NetworkInterface.cpp

570

address.AddInt32("family", family);

src/kits/network/libnetapi/NetworkInterface.cpp

571

address.AddBool("auto_config", true);

src/kits/network/libnetapi/NetworkInterface.cpp

572

message.AddMessage("address", &address);

src/kits/network/libnetapi/NetworkInterface.cpp

60

address.SetFlags(request.ifra_flags);

src/kits/network/libnetapi/NetworkInterface.cpp

61

address.Address().SetTo(request.ifra_addr);

src/kits/network/libnetapi/NetworkInterface.cpp

62

address.Mask().SetTo(request.ifra_mask);

src/kits/network/libnetapi/NetworkInterface.cpp

63

address.Broadcast().SetTo(request.ifra_broadaddr);

src/kits/network/libnetapi/NetworkInterface.cpp

72

const BNetworkInterfaceAddress& address)

src/kits/network/libnetapi/NetworkInterface.cpp

75

const_cast<BNetworkInterfaceAddress&>(address));

src/kits/network/libnetapi/NetworkRoster.cpp

204

BNetworkAddress address;

src/kits/network/libnetapi/NetworkRoster.cpp

205

if (networkMessage.FindFlat("address", &network.address) != B_OK)

src/kits/network/libnetapi/NetworkRoster.cpp

206

network.address.Unset();

src/kits/network/libnetapi/NetworkRoster.cpp

239

BNetworkAddress address = network.address;

src/kits/network/libnetapi/NetworkRoster.cpp

240

status = message.AddFlat("address", &address);

src/kits/network/libnetapi/NetworkRoute.cpp

190

#define RETURN_FAMILY_IF_SET(address) \

src/kits/network/libnetapi/NetworkRoute.cpp

191

if (fRouteEntry.address != NULL \

src/kits/network/libnetapi/NetworkRoute.cpp

192

&& fRouteEntry.address->sa_family != AF_UNSPEC) { \

src/kits/network/libnetapi/NetworkRoute.cpp

193

return fRouteEntry.address->sa_family; \

src/kits/network/libnetapi/NetworkRoute.cpp

347

BNetworkRoute::_FreeAndUnsetAddress(sockaddr*& address)

src/kits/network/libnetapi/NetworkRoute.cpp

349

free(address);

src/kits/network/libnetapi/NetworkRoute.cpp

350

address = NULL;

src/kits/network/libnetapi/NetworkRoute.cpp

41

#define SET_ADDRESS(address, setFunction) \

src/kits/network/libnetapi/NetworkRoute.cpp

42

if (routeEntry.address != NULL) { \

src/kits/network/libnetapi/NetworkRoute.cpp

43

result = setFunction(*routeEntry.address); \

src/kits/network/libnetapi/NetworkSettings.cpp

1118

BNetworkInterfaceAddressSettings address(addressData);

src/kits/network/libnetapi/NetworkSettings.cpp

1119

fAddresses.push_back(address);

src/kits/network/libnetapi/NetworkSettings.cpp

1210

const BNetworkInterfaceAddressSettings address = AddressAt(index);

src/kits/network/libnetapi/NetworkSettings.cpp

1211

if (address.Family() == family)

src/kits/network/libnetapi/NetworkSettings.cpp

1220

const BNetworkInterfaceAddressSettings& address)

src/kits/network/libnetapi/NetworkSettings.cpp

1222

fAddresses.push_back(address);

src/kits/network/libnetapi/NetworkSettings.cpp

1248

BNetworkInterfaceAddress address;

src/kits/network/libnetapi/NetworkSettings.cpp

1253

status = interface.GetAddressAt(index, address);

src/kits/network/libnetapi/NetworkSettings.cpp

1254

if (index < 0 || status != B_OK || address.Address().IsEmpty()) {

src/kits/network/libnetapi/NetworkSettings.cpp

1263

const BNetworkInterfaceAddressSettings& address

src/kits/network/libnetapi/NetworkSettings.cpp

1265

return address.IsAutoConfigure();

src/kits/network/libnetapi/NetworkSettings.cpp

1286

BMessage address;

src/kits/network/libnetapi/NetworkSettings.cpp

1287

status = AddressAt(i).GetMessage(address);

src/kits/network/libnetapi/NetworkSettings.cpp

1289

status = data.AddMessage("address", &address);

src/kits/network/libnetapi/NetworkSettings.cpp

1494

BNetworkServiceAddressSettings address(addressData, fFamily,

src/kits/network/libnetapi/NetworkSettings.cpp

1496

fAddresses.push_back(address);

src/kits/network/libnetapi/NetworkSettings.cpp

1507

BNetworkServiceAddressSettings address;

src/kits/network/libnetapi/NetworkSettings.cpp

1508

address.SetFamily(fFamily);

src/kits/network/libnetapi/NetworkSettings.cpp

1509

address.SetType(fType);

src/kits/network/libnetapi/NetworkSettings.cpp

1510

address.SetProtocol(fProtocol);

src/kits/network/libnetapi/NetworkSettings.cpp

1511

address.Address().SetToWildcard(fFamily, fPort);

src/kits/network/libnetapi/NetworkSettings.cpp

1513

fAddresses.push_back(address);

src/kits/network/libnetapi/NetworkSettings.cpp

1675

const BNetworkServiceAddressSettings& address)

src/kits/network/libnetapi/NetworkSettings.cpp

1677

fAddresses.push_back(address);

src/kits/network/libnetapi/NetworkSettings.cpp

1733

BNetworkServiceAddressSettings address = AddressAt(i);

src/kits/network/libnetapi/NetworkSettings.cpp

1734

if (address.Family() == Family()

src/kits/network/libnetapi/NetworkSettings.cpp

1735

&& address.Type() == Type()

src/kits/network/libnetapi/NetworkSettings.cpp

1736

&& address.Protocol() == Protocol()

src/kits/network/libnetapi/NetworkSettings.cpp

1737

&& address.Address().IsWildcard()

src/kits/network/libnetapi/NetworkSettings.cpp

1738

&& address.Address().Port() == Port()) {

src/kits/network/libnetapi/NetworkSettings.cpp

197

parse_address(int32& family, const char* argument, BNetworkAddress& address)

src/kits/network/libnetapi/NetworkSettings.cpp

201

address.SetToWildcard(family);

src/kits/network/libnetapi/NetworkSettings.cpp

205

status_t status = address.SetTo(family, argument, (uint16)0,

src/kits/network/libnetapi/NetworkSettings.cpp

215

if (kFamilies[i].family == address.Family()) {

src/kits/network/libnetapi/NetworkSettings.cpp

224

family = address.Family();

src/kits/network/libnetapi/NetworkSettings.cpp

699

BNetworkAddress address;

src/kits/network/libnetapi/NetworkSettings.cpp

700

status_t result = message.FindFlat("address", &address);

src/kits/network/libnetapi/NetworkSettings.cpp

704

if (result == B_OK && address.Family() == AF_LINK) {

src/kits/network/libnetapi/NetworkSettings.cpp

705

size_t addressLength = address.LinkLevelAddressLength();

src/kits/network/libnetapi/NetworkSettings.cpp

706

uint8* macAddress = address.LinkLevelAddress();

src/kits/network/libnetapi/SocketMessenger.cpp

153

BSocketMessenger::SetTo(const BNetworkAddress& address, bigtime_t timeout)

src/kits/network/libnetapi/SocketMessenger.cpp

164

status_t error = fSocket.Connect(address, timeout);

src/kits/network/libnetapi/SocketMessenger.cpp

87

BSocketMessenger::BSocketMessenger(const BNetworkAddress& address,

src/kits/network/libnetapi/SocketMessenger.cpp

95

SetTo(address, timeout);

src/kits/network/libnetservices/Geolocation.cpp

98

query += network.address.ToString().ToUpper();

src/kits/storage/Resources.cpp

208

addr_t address = (addr_t)codeOrDataPointer;

src/kits/storage/Resources.cpp

213

if (address == 0

src/kits/storage/Resources.cpp

215

: (((addr_t)info.text <= address

src/kits/storage/Resources.cpp

216

&& address - (addr_t)info.text < (addr_t)info.text_size)

src/kits/storage/Resources.cpp

217

|| ((addr_t)info.data <= address

src/kits/storage/Resources.cpp

218

&& address - (addr_t)info.data < (addr_t)info.data_size))) {

src/libs/compat/freebsd_network/device_hooks.c

283

struct sockaddr_dl address;

src/libs/compat/freebsd_network/device_hooks.c

290

memset(&address, 0, sizeof(address));

src/libs/compat/freebsd_network/device_hooks.c

291

address.sdl_family = AF_LINK;

src/libs/compat/freebsd_network/device_hooks.c

292

if (user_memcpy(LLADDR(&address), arg, ETHER_ADDR_LEN) < B_OK)

src/libs/compat/freebsd_network/device_hooks.c

297

status = if_addmulti(ifp, (struct sockaddr *)&address, NULL);

src/libs/compat/freebsd_network/device_hooks.c

299

status = if_delmulti(ifp, (struct sockaddr *)&address);

src/libs/compat/freebsd_network/if.c

474

struct sockaddr_dl *address = (struct sockaddr_dl *) _address;

src/libs/compat/freebsd_network/if.c

478

if (memcmp(LLADDR(address),

src/libs/compat/freebsd_network/if.c

515

_if_addmulti(struct ifnet *ifp, struct sockaddr *address)

src/libs/compat/freebsd_network/if.c

517

struct ifmultiaddr *addr = if_findmulti(ifp, address);

src/libs/compat/freebsd_network/if.c

532

memcpy(&addr->ifma_addr_storage, address, sizeof(struct sockaddr_dl));

src/libs/compat/freebsd_network/if.c

544

if_addmulti(struct ifnet *ifp, struct sockaddr *address,

src/libs/compat/freebsd_network/if.c

551

result = _if_addmulti(ifp, address);

src/libs/compat/freebsd_network/malloc.cpp

103

return (vm_paddr_t)entry.address;

src/libs/compat/freebsd_network/malloc.cpp

72

void* address;

src/libs/compat/freebsd_network/malloc.cpp

75

&virtualRestrictions, &physicalRestrictions, &address);

src/libs/compat/freebsd_network/malloc.cpp

79

return address;

src/libs/glut/glut_ext.c

196

return glut_functions[i].address;

src/libs/glut/glut_ext.c

61

const GLUTproc address;

src/libs/libfdt/fdt_ro.c

175

int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)

src/libs/libfdt/fdt_ro.c

184

*address = fdt64_ld_(&re->address);

src/libs/libfdt/fdt_rw.c

155

int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size)

src/libs/libfdt/fdt_rw.c

167

re->address = cpu_to_fdt64(address);

src/libs/libfdt/fdt_sw.c

200

re->address = cpu_to_fdt64(addr);

src/libs/zydis/Zydis/FormatterBase.c

230

ZyanU64 address;

src/libs/zydis/Zydis/FormatterBase.c

232

context->runtime_address, &address));

src/libs/zydis/Zydis/FormatterBase.c

242

address = (ZyanU16)address;

src/libs/zydis/Zydis/FormatterBase.c

246

address = (ZyanU32)address;

src/libs/zydis/Zydis/FormatterBase.c

257

ZYDIS_STRING_APPEND_NUM_U(formatter, formatter->addr_base, &buffer->string, address, padding,

src/libs/zydis/Zydis/FormatterBase.c

270

ZyanU64 address;

src/libs/zydis/Zydis/FormatterBase.c

271

ZYAN_CHECK(ZydisCalcAbsoluteAddress(context->instruction, context->operand, 0, &address));

src/libs/zydis/Zydis/FormatterBase.c

282

address = (ZyanU16)address;

src/libs/zydis/Zydis/FormatterBase.c

286

address = (ZyanU32)address;

src/libs/zydis/Zydis/FormatterBase.c

301

ZYDIS_STRING_APPEND_NUM_S(formatter, formatter->addr_base, &buffer->string, address,

src/libs/zydis/Zydis/FormatterBase.c

306

ZYDIS_STRING_APPEND_NUM_U(formatter, formatter->addr_base, &buffer->string, address,

src/libs/zydis/Zydis/FormatterIntel.c

421

ZyanU64 address;

src/libs/zydis/Zydis/FormatterIntel.c

422

ZYAN_CHECK(ZydisCalcAbsoluteAddress(context->instruction, context->operand, 0, &address));

src/libs/zydis/Zydis/FormatterIntel.c

433

address = (ZyanU16)address;

src/libs/zydis/Zydis/FormatterIntel.c

437

address = (ZyanU32)address;

src/libs/zydis/Zydis/FormatterIntel.c

448

ZYDIS_STRING_APPEND_NUM_S(formatter, formatter->addr_base, &buffer->string, address, padding,

src/preferences/network/IPAddressControl.cpp

80

BNetworkAddress address;

src/preferences/network/IPAddressControl.cpp

81

bool success = address.SetTo(fFamily, Text(), (char*)NULL,

src/preferences/network/InterfaceAddressView.cpp

221

BNetworkInterfaceAddress address;

src/preferences/network/InterfaceAddressView.cpp

226

status = fInterface.GetAddressAt(index, address);

src/preferences/network/InterfaceAddressView.cpp

228

|| address.Address().IsEmpty())) {

src/preferences/network/InterfaceAddressView.cpp

238

fAddressField->SetText(address.Address().ToString());

src/preferences/network/InterfaceAddressView.cpp

239

fNetmaskField->SetText(address.Mask().ToString());

src/preferences/network/InterfaceAddressView.cpp

285

BNetworkInterfaceAddressSettings& address = settings.AddressAt(index);

src/preferences/network/InterfaceAddressView.cpp

286

_ConfigureAddress(address);

src/preferences/network/InterfaceAddressView.cpp

288

BNetworkInterfaceAddressSettings address;

src/preferences/network/InterfaceAddressView.cpp

289

_ConfigureAddress(address);

src/preferences/network/InterfaceAddressView.cpp

290

settings.AddAddress(address);

src/preferences/network/InterfaceAddressView.cpp

340

InterfaceAddressView::_SetAddress(BNetworkAddress& address, const char* text)

src/preferences/network/InterfaceAddressView.cpp

347

address.SetTo(string.String(), static_cast<uint16>(0),

src/preferences/network/InterfaceAddressView.h

54

BNetworkInterfaceAddressSettings& address);

src/preferences/network/InterfaceAddressView.h

55

void _SetAddress(BNetworkAddress& address,

src/preferences/network/InterfaceView.cpp

141

BNetworkAddress address;

src/preferences/network/InterfaceView.cpp

143

&& message->FindFlat("address", &address) == B_OK) {

src/preferences/network/InterfaceView.cpp

145

status_t status = device.JoinNetwork(address);

src/preferences/network/InterfaceView.cpp

268

BNetworkAddress address;

src/preferences/network/InterfaceView.cpp

270

while (device.GetNextAssociatedNetwork(cookie, address) == B_OK)

src/preferences/network/InterfaceView.cpp

271

associated.insert(address);

src/preferences/network/InterfaceView.cpp

333

if (associated.find(network.address) != associated.end())

src/preferences/network/InterfaceView.cpp

343

message->AddFlat("address", &network.address);

src/preferences/network/InterfaceView.cpp

347

if (associated.find(network.address) != associated.end())

src/preferences/network/NetworkSettingsAddOn.cpp

222

BNetworkInterfaceAddress address;

src/preferences/network/NetworkSettingsAddOn.cpp

235

interface.GetAddressAt(index, address);

src/preferences/network/NetworkSettingsAddOn.cpp

237

fDisabled = address.Address().IsEmpty() && !autoConfigure;

src/preferences/network/NetworkSettingsAddOn.cpp

238

if (!address.Address().IsEmpty())

src/preferences/network/NetworkSettingsAddOn.cpp

239

fAddress << "(" << address.Address().ToString() << ")";

src/preferences/time/ntp.cpp

120

BNetworkAddress address;

src/preferences/time/ntp.cpp

151

while (resolver.GetNextAddress(&cookie, address) == B_OK) {

src/preferences/time/ntp.cpp

153

sizeof(ntp_data), 0, &address.SockAddr(),

src/preferences/time/ntp.cpp

154

address.Length()) != -1) {

src/preferences/time/ntp.cpp

189

socklen_t addressSize = address.Length();

src/preferences/time/ntp.cpp

191

&address.SockAddr(), &addressSize) < (ssize_t)sizeof(ntp_data)) {

src/servers/app/ClientMemoryAllocator.cpp

245

uint8* address;

src/servers/app/ClientMemoryAllocator.cpp

271

area_id area = create_area(name, (void**)&address, B_ANY_ADDRESS, size,

src/servers/app/ClientMemoryAllocator.cpp

282

chunk->base = address;

src/servers/app/ClientMemoryAllocator.cpp

292

address = chunk->base + chunk->size;

src/servers/app/ClientMemoryAllocator.cpp

299

block->base = address;

src/servers/app/ServerApp.cpp

1712

memcpy(fontData, (FT_Byte*)fontAreaInfo.address + offset, size);

src/servers/debug/DebugServer.cpp

216

const void *address, char *buffer, int32 bufferSize);

src/servers/debug/DebugServer.cpp

896

debug_symbol_lookup_context *lookupContext, const void *address,

src/servers/debug/DebugServer.cpp

906

status_t error = debug_lookup_symbol_address(lookupContext, address,

src/servers/debug/DebugServer.cpp

917

(addr_t)address - (addr_t)baseAddress,

src/servers/debug/DebugServer.cpp

923

(addr_t)address - (addr_t)baseAddress);

src/servers/debug/DebugServer.cpp

932

if ((addr_t)info.address <= (addr_t)address

src/servers/debug/DebugServer.cpp

933

&& (addr_t)info.address + info.size > (addr_t)address) {

src/servers/debug/DebugServer.cpp

941

(addr_t)address - (addr_t)info.address);

src/servers/media/BufferManager.cpp

209

void* address;

src/servers/media/BufferManager.cpp

210

area_id clonedArea = clone_area("media_server cloned buffer", &address,

src/servers/media/media_server.cpp

399

reply.area = _kern_transfer_area(area, &reply.address,

src/servers/media/media_server.cpp

773

reply.area = _kern_transfer_area(area, &reply.address,

src/servers/media/media_server.cpp

801

reply.area = _kern_transfer_area(area, &reply.address,

src/servers/net/AutoconfigLooper.cpp

124

BMessage address;

src/servers/net/AutoconfigLooper.cpp

125

address.AddInt32("family", AF_INET);

src/servers/net/AutoconfigLooper.cpp

126

address.AddString("address", string);

src/servers/net/AutoconfigLooper.cpp

127

message.AddMessage("address", &address);

src/servers/net/DHCPClient.cpp

1036

DHCPClient::_AddressToString(in_addr_t address)

src/servers/net/DHCPClient.cpp

1038

BString target = inet_ntoa(*(in_addr*)&address);

src/servers/net/DHCPClient.cpp

1045

const BNetworkAddress& address) const

src/servers/net/DHCPClient.cpp

1056

address.ToString().String());

src/servers/net/DHCPClient.cpp

1059

address.IsBroadcast() ? MSG_BCAST : 0, address, address.Length());

src/servers/net/DHCPClient.cpp

511

BNetworkAddress address = interfaceAddress.Address();

src/servers/net/DHCPClient.cpp

512

const sockaddr_in& addr = (sockaddr_in&)address.SockAddr();

src/servers/net/DHCPClient.cpp

690

BMessage address;

src/servers/net/DHCPClient.cpp

691

address.AddString("family", "inet");

src/servers/net/DHCPClient.cpp

692

address.AddString("address", _AddressToString(fAssignedAddress));

src/servers/net/DHCPClient.cpp

694

_ParseOptions(*message, address, fResolverConfiguration);

src/servers/net/DHCPClient.cpp

696

fConfiguration.AddMessage("address", &address);

src/servers/net/DHCPClient.cpp

708

BMessage address;

src/servers/net/DHCPClient.cpp

710

_ParseOptions(*message, address, fResolverConfiguration);

src/servers/net/DHCPClient.cpp

826

DHCPClient::_ParseOptions(dhcp_message& message, BMessage& address,

src/servers/net/DHCPClient.cpp

839

address.AddString("gateway", _AddressToString(data));

src/servers/net/DHCPClient.cpp

844

address.AddString("mask", _AddressToString(data));

src/servers/net/DHCPClient.cpp

849

address.AddString("broadcast", _AddressToString(data));

src/servers/net/DHCPClient.h

53

BMessage& address,

src/servers/net/DHCPClient.h

58

const BNetworkAddress& address) const;

src/servers/net/DHCPClient.h

65

static BString _AddressToString(in_addr_t address);

src/servers/net/NetServer.cpp

1001

if (address->Family() != AF_LINK)

src/servers/net/NetServer.cpp

1013

&& name != NULL && address->Family() != AF_LINK

src/servers/net/NetServer.cpp

1021

&& address->Family() == AF_LINK) {

src/servers/net/NetServer.cpp

1023

if (link == *address) {

src/servers/net/NetServer.cpp

1039

if ((address->Family() != AF_LINK

src/servers/net/NetServer.cpp

1040

|| device.GetNetwork(*address, network) != B_OK)

src/servers/net/NetServer.cpp

1045

network.address = *address;

src/servers/net/NetServer.cpp

1113

status = join.AddFlat("address", &network.address);

src/servers/net/NetServer.cpp

553

BNetworkAddress address;

src/servers/net/NetServer.cpp

554

status_t addressStatus = address.SetTo(AF_LINK, addressString);

src/servers/net/NetServer.cpp

559

addressStatus == B_OK ? &address : NULL, networkName);

src/servers/net/NetServer.cpp

686

BMessage address;

src/servers/net/NetServer.cpp

687

address.AddString("family", "inet");

src/servers/net/NetServer.cpp

688

address.AddBool("auto_config", true);

src/servers/net/NetServer.cpp

689

interface.AddMessage("address", &address);

src/servers/net/NetServer.cpp

985

NetServer::_JoinNetwork(const BMessage& message, const BNetworkAddress* address,

src/servers/net/NetServer.cpp

99

const BNetworkAddress* address = NULL,

src/servers/net/NetServer.cpp

994

if (address == NULL)

src/servers/net/NetServer.cpp

995

address = &deviceAddress;

src/servers/net/Services.cpp

363

const BNetworkServiceAddressSettings& address = settings.AddressAt(i);

src/servers/net/Services.cpp

367

connection.address = address;

src/servers/net/Services.cpp

37

BNetworkServiceAddressSettings address;

src/servers/net/Services.cpp

41

int Family() const { return address.Family(); }

src/servers/net/Services.cpp

42

int Protocol() const { return address.Protocol(); }

src/servers/net/Services.cpp

43

int Type() const { return address.Type(); }

src/servers/net/Services.cpp

44

const BNetworkAddress& Address() const { return address.Address(); }

src/servers/net/Services.cpp

74

return address == other.address;

src/servers/print/PrintServerApp.cpp

184

BString transport, address, connection, state;

src/servers/print/PrintServerApp.cpp

187

&& printer->ReadAttrString(PSRV_PRINTER_ATTR_TRANSPORT_ADDR, &address)

src/servers/print/PrintServerApp.cpp

204

address.String(), connection.String());

src/servers/print/ResourceManager.cpp

13

Resource::Resource(const char* transport, const char* address, const char* connection)

src/servers/print/ResourceManager.cpp

15

, fTransportAddress(address)

src/servers/print/ResourceManager.cpp

46

Resource::Equals(const char* transport, const char* address, const char* connection) {

src/servers/print/ResourceManager.cpp

48

fTransportAddress == address &&

src/servers/print/ResourceManager.cpp

76

ResourceManager::Find(const char* transport, const char* address, const char* connection) {

src/servers/print/ResourceManager.cpp

79

if (r->Equals(transport, address, connection)) return r;

src/servers/print/ResourceManager.cpp

86

ResourceManager::Allocate(const char* transport, const char* address, const char* connection) {

src/servers/print/ResourceManager.cpp

87

Resource* r = Find(transport, address, connection);

src/servers/print/ResourceManager.cpp

89

r = new Resource(transport, address, connection);

src/servers/print/ResourceManager.h

26

Resource(const char* transport, const char* address, const char* connection);

src/servers/print/ResourceManager.h

31

bool Equals(const char* transport, const char* address, const char* connection);

src/servers/print/ResourceManager.h

43

Resource* Find(const char* transport, const char* address, const char* connection);

src/servers/print/ResourceManager.h

48

Resource* Allocate(const char* transport, const char* address, const char* connection);

src/system/boot/arch/m68k/mmu.cpp

106

addr_t address = sNextVirtualAddress;

src/system/boot/arch/m68k/mmu.cpp

109

TRACE(("%s(%d): %08x\n", __FUNCTION__, size, address));

src/system/boot/arch/m68k/mmu.cpp

110

return address;

src/system/boot/arch/m68k/mmu.cpp

117

addr_t address = sNextPhysicalAddress;

src/system/boot/arch/m68k/mmu.cpp

120

TRACE(("%s(%d): %08x\n", __FUNCTION__, size, address));

src/system/boot/arch/m68k/mmu.cpp

121

return address;

src/system/boot/arch/m68k/mmu.cpp

149

addr_t address = sNextPageTableAddress;

src/system/boot/arch/m68k/mmu.cpp

150

if (address >= kPageTableRegionEnd)

src/system/boot/arch/m68k/mmu.cpp

154

return (uint32 *)address;

src/system/boot/arch/m68k/mmu.cpp

310

addr_t address = sNextVirtualAddress;

src/system/boot/arch/m68k/mmu.cpp

319

return address + pageOffset;

src/system/boot/arch/m68k/mmu.cpp

338

addr_t address = (addr_t)virtualAddress;

src/system/boot/arch/m68k/mmu.cpp

341

if (address < KERNEL_LOAD_BASE || address + size * B_PAGE_SIZE

src/system/boot/arch/m68k/mmu.cpp

346

map_page(address, get_next_physical_page(), kDefaultPageFlags);

src/system/boot/arch/m68k/mmu.cpp

347

address += B_PAGE_SIZE;

src/system/boot/arch/m68k/mmu.cpp

354

void *address = (void *)sNextVirtualAddress;

src/system/boot/arch/m68k/mmu.cpp

360

TRACE(("mmu_allocate(NULL, %d): %p\n", size, address));

src/system/boot/arch/m68k/mmu.cpp

361

return address;

src/system/boot/arch/m68k/mmu.cpp

375

addr_t address = (addr_t)virtualAddress;

src/system/boot/arch/m68k/mmu.cpp

376

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/boot/arch/m68k/mmu.cpp

377

address -= pageOffset;

src/system/boot/arch/m68k/mmu.cpp

381

if (address < KERNEL_LOAD_BASE || address + size > sNextVirtualAddress) {

src/system/boot/arch/m68k/mmu.cpp

383

(void *)address, size);

src/system/boot/arch/m68k/mmu.cpp

388

unmap_page(address);

src/system/boot/arch/m68k/mmu.cpp

389

address += B_PAGE_SIZE;

src/system/boot/arch/m68k/mmu.cpp

392

if (address == sNextVirtualAddress) {

src/system/boot/arch/m68k/mmu.cpp

650

void *address = mmu_allocate(*_address, size);

src/system/boot/arch/m68k/mmu.cpp

651

if (address == NULL)

src/system/boot/arch/m68k/mmu.cpp

654

*_address = address;

src/system/boot/arch/m68k/mmu.cpp

660

platform_free_region(void *address, size_t size)

src/system/boot/arch/m68k/mmu.cpp

662

mmu_free(address, size);

src/system/boot/arch/x86/arch_hpet.cpp

53

hpet->hpet_address.address);

src/system/boot/arch/x86/arch_hpet.cpp

54

gKernelArgs.arch_args.hpet_phys = hpet->hpet_address.address;

src/system/boot/loader/elf.cpp

102

if (platform_kernel_address_to_bootloader_address(address, &result) != B_OK) {

src/system/boot/loader/elf.cpp

103

panic("Couldn't convert address 0x%08x", (uint32_t)address);

src/system/boot/loader/elf.cpp

137

void* address = (void*)(addr_t)(*_address & 0xffffffff);

src/system/boot/loader/elf.cpp

139

void* address = (void*)*_address;

src/system/boot/loader/elf.cpp

142

status_t status = platform_allocate_region(&address, size, protection);

src/system/boot/loader/elf.cpp

146

*_mappedAddress = address;

src/system/boot/loader/elf.cpp

148

*_address = (AddrType)(addr_t)address + KERNEL_FIXUP_FOR_LONG_MODE;

src/system/boot/loader/elf.cpp

150

platform_bootloader_address_to_kernel_address(address, _address);

src/system/boot/loader/elf.cpp

156

Map(AddrType address)

src/system/boot/loader/elf.cpp

159

return (void*)(addr_t)(address - KERNEL_FIXUP_FOR_LONG_MODE);

src/system/boot/loader/elf.cpp

162

if (platform_kernel_address_to_bootloader_address(address, &result) != B_OK) {

src/system/boot/loader/elf.cpp

163

panic("Couldn't convert address %#" PRIx64, address);

src/system/boot/loader/elf.cpp

312

AddrType address = firstRegion->start;

src/system/boot/loader/elf.cpp

313

if (Class::AllocateRegion(&address, totalSize,

src/system/boot/loader/elf.cpp

317

__func__, (int64)address, totalSize);

src/system/boot/loader/elf.cpp

321

if (elfHeader.e_type != ET_DYN && address != firstRegion->start) {

src/system/boot/loader/elf.cpp

323

(uint64)address, (uint64)firstRegion->start);

src/system/boot/loader/elf.cpp

325

firstRegion->start = address;

src/system/boot/loader/elf.cpp

99

Map(AddrType address)

src/system/boot/loader/heap.cpp

152

free_large(void* address)

src/system/boot/loader/heap.cpp

154

LargeAllocation* allocation = sLargeAllocations.Lookup(address);

src/system/boot/loader/heap.cpp

156

panic("free_large(%p): unknown allocation!\n", address);

src/system/boot/loader/heap.cpp

305

void* address = malloc(numElements * size);

src/system/boot/loader/heap.cpp

306

if (address != NULL)

src/system/boot/loader/heap.cpp

307

memset(address, 0, numElements * size);

src/system/boot/loader/heap.cpp

309

return address;

src/system/boot/loader/kernel_args.cpp

426

void* address = (void*)ALIGN((addr_t)sFirstFree, alignment);

src/system/boot/loader/kernel_args.cpp

428

sLast = address;

src/system/boot/loader/kernel_args.cpp

431

return address;

src/system/boot/loader/net/IP.cpp

274

ip_addr_t address = 0;

src/system/boot/loader/net/IP.cpp

279

address |= strtol(string, NULL, 0) << ((4 - components - 1) * 8);

src/system/boot/loader/net/IP.cpp

289

return address;

src/system/boot/loader/net/TCP.cpp

231

TCPSocket::Connect(ip_addr_t address, uint16 port)

src/system/boot/loader/net/TCP.cpp

233

fRemoteAddress = address;

src/system/boot/loader/net/TCP.cpp

249

error = packet->SetTo(NULL, 0, fAddress, fPort, address, port,

src/system/boot/loader/net/TCP.cpp

880

TCPService::_FindSocket(ip_addr_t address, uint16 port)

src/system/boot/loader/net/TCP.cpp

886

if ((address == INADDR_ANY || socket->Address() == INADDR_ANY

src/system/boot/loader/net/TCP.cpp

887

|| socket->Address() == address)

src/system/boot/loader/net/UDP.cpp

147

UDPSocket::Bind(ip_addr_t address, uint16 port)

src/system/boot/loader/net/UDP.cpp

154

if (address == INADDR_BROADCAST || port == 0) {

src/system/boot/loader/net/UDP.cpp

165

status_t error = fUDPService->BindSocket(this, address, port);

src/system/boot/loader/net/UDP.cpp

171

fAddress = address;

src/system/boot/loader/net/UDP.cpp

392

UDPService::BindSocket(UDPSocket *socket, ip_addr_t address, uint16 port)

src/system/boot/loader/net/UDP.cpp

397

if (_FindSocket(address, port) != NULL) {

src/system/boot/loader/net/UDP.cpp

451

UDPService::_FindSocket(ip_addr_t address, uint16 port)

src/system/boot/loader/net/UDP.cpp

456

if ((address == INADDR_ANY || socket->Address() == INADDR_ANY

src/system/boot/loader/net/UDP.cpp

457

|| socket->Address() == address)

src/system/boot/platform/amiga_m68k/mmu.cpp

106

addr_t address = sNextVirtualAddress;

src/system/boot/platform/amiga_m68k/mmu.cpp

109

TRACE(("%s(%d): %08x\n", __FUNCTION__, size, address));

src/system/boot/platform/amiga_m68k/mmu.cpp

110

return address;

src/system/boot/platform/amiga_m68k/mmu.cpp

117

addr_t address = sNextPhysicalAddress;

src/system/boot/platform/amiga_m68k/mmu.cpp

120

TRACE(("%s(%d): %08x\n", __FUNCTION__, size, address));

src/system/boot/platform/amiga_m68k/mmu.cpp

121

return address;

src/system/boot/platform/amiga_m68k/mmu.cpp

149

addr_t address = sNextPageTableAddress;

src/system/boot/platform/amiga_m68k/mmu.cpp

150

if (address >= kPageTableRegionEnd)

src/system/boot/platform/amiga_m68k/mmu.cpp

154

return (uint32 *)address;

src/system/boot/platform/amiga_m68k/mmu.cpp

310

addr_t address = sNextVirtualAddress;

src/system/boot/platform/amiga_m68k/mmu.cpp

319

return address + pageOffset;

src/system/boot/platform/amiga_m68k/mmu.cpp

338

addr_t address = (addr_t)virtualAddress;

src/system/boot/platform/amiga_m68k/mmu.cpp

341

if (address < KERNEL_LOAD_BASE || address + size * B_PAGE_SIZE

src/system/boot/platform/amiga_m68k/mmu.cpp

346

map_page(address, get_next_physical_page(), kDefaultPageFlags);

src/system/boot/platform/amiga_m68k/mmu.cpp

347

address += B_PAGE_SIZE;

src/system/boot/platform/amiga_m68k/mmu.cpp

354

void *address = (void *)sNextVirtualAddress;

src/system/boot/platform/amiga_m68k/mmu.cpp

360

TRACE(("mmu_allocate(NULL, %d): %p\n", size, address));

src/system/boot/platform/amiga_m68k/mmu.cpp

361

return address;

src/system/boot/platform/amiga_m68k/mmu.cpp

375

addr_t address = (addr_t)virtualAddress;

src/system/boot/platform/amiga_m68k/mmu.cpp

376

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/boot/platform/amiga_m68k/mmu.cpp

377

address -= pageOffset;

src/system/boot/platform/amiga_m68k/mmu.cpp

381

if (address < KERNEL_LOAD_BASE || address + size > sNextVirtualAddress) {

src/system/boot/platform/amiga_m68k/mmu.cpp

383

(void *)address, size);

src/system/boot/platform/amiga_m68k/mmu.cpp

388

unmap_page(address);

src/system/boot/platform/amiga_m68k/mmu.cpp

389

address += B_PAGE_SIZE;

src/system/boot/platform/amiga_m68k/mmu.cpp

392

if (address == sNextVirtualAddress) {

src/system/boot/platform/amiga_m68k/mmu.cpp

648

void *address = mmu_allocate(*_address, size);

src/system/boot/platform/amiga_m68k/mmu.cpp

649

if (address == NULL)

src/system/boot/platform/amiga_m68k/mmu.cpp

652

*_address = address;

src/system/boot/platform/amiga_m68k/mmu.cpp

658

platform_free_region(void *address, size_t size)

src/system/boot/platform/amiga_m68k/mmu.cpp

660

mmu_free(address, size);

src/system/boot/platform/amiga_m68k/mmu.cpp

695

platform_bootloader_address_to_kernel_address(void *address, addr_t *_result)

src/system/boot/platform/amiga_m68k/mmu.cpp

699

*_result = (addr_t)address;

src/system/boot/platform/amiga_m68k/mmu.cpp

705

platform_kernel_address_to_bootloader_address(addr_t address, void **_result)

src/system/boot/platform/amiga_m68k/mmu.cpp

709

*_result = (void*)address;

src/system/boot/platform/atari_m68k/mmu.cpp

107

addr_t address = sNextVirtualAddress;

src/system/boot/platform/atari_m68k/mmu.cpp

110

TRACE(("%s(%d): %08x\n", __FUNCTION__, size, address));

src/system/boot/platform/atari_m68k/mmu.cpp

111

return address;

src/system/boot/platform/atari_m68k/mmu.cpp

118

addr_t address = sNextPhysicalAddress;

src/system/boot/platform/atari_m68k/mmu.cpp

121

TRACE(("%s(%d): %08x\n", __FUNCTION__, size, address));

src/system/boot/platform/atari_m68k/mmu.cpp

122

return address;

src/system/boot/platform/atari_m68k/mmu.cpp

150

addr_t address = sNextPageTableAddress;

src/system/boot/platform/atari_m68k/mmu.cpp

151

if (address >= kPageTableRegionEnd)

src/system/boot/platform/atari_m68k/mmu.cpp

155

return (uint32 *)address;

src/system/boot/platform/atari_m68k/mmu.cpp

311

addr_t address = sNextVirtualAddress;

src/system/boot/platform/atari_m68k/mmu.cpp

320

return address + pageOffset;

src/system/boot/platform/atari_m68k/mmu.cpp

339

addr_t address = (addr_t)virtualAddress;

src/system/boot/platform/atari_m68k/mmu.cpp

342

if (address < KERNEL_LOAD_BASE || address + size * B_PAGE_SIZE

src/system/boot/platform/atari_m68k/mmu.cpp

347

map_page(address, get_next_physical_page(), kDefaultPageFlags);

src/system/boot/platform/atari_m68k/mmu.cpp

348

address += B_PAGE_SIZE;

src/system/boot/platform/atari_m68k/mmu.cpp

355

void *address = (void *)sNextVirtualAddress;

src/system/boot/platform/atari_m68k/mmu.cpp

361

TRACE(("mmu_allocate(NULL, %d): %p\n", size, address));

src/system/boot/platform/atari_m68k/mmu.cpp

362

return address;

src/system/boot/platform/atari_m68k/mmu.cpp

376

addr_t address = (addr_t)virtualAddress;

src/system/boot/platform/atari_m68k/mmu.cpp

377

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/boot/platform/atari_m68k/mmu.cpp

378

address -= pageOffset;

src/system/boot/platform/atari_m68k/mmu.cpp

382

if (address < KERNEL_LOAD_BASE || address + size > sNextVirtualAddress) {

src/system/boot/platform/atari_m68k/mmu.cpp

384

(void *)address, size);

src/system/boot/platform/atari_m68k/mmu.cpp

389

unmap_page(address);

src/system/boot/platform/atari_m68k/mmu.cpp

390

address += B_PAGE_SIZE;

src/system/boot/platform/atari_m68k/mmu.cpp

393

if (address == sNextVirtualAddress) {

src/system/boot/platform/atari_m68k/mmu.cpp

653

void *address = mmu_allocate(*_address, size);

src/system/boot/platform/atari_m68k/mmu.cpp

654

if (address == NULL)

src/system/boot/platform/atari_m68k/mmu.cpp

657

*_address = address;

src/system/boot/platform/atari_m68k/mmu.cpp

663

platform_free_region(void *address, size_t size)

src/system/boot/platform/atari_m68k/mmu.cpp

665

mmu_free(address, size);

src/system/boot/platform/atari_m68k/mmu.cpp

700

platform_bootloader_address_to_kernel_address(void *address, addr_t *_result)

src/system/boot/platform/atari_m68k/mmu.cpp

704

*_result = (addr_t)address;

src/system/boot/platform/atari_m68k/mmu.cpp

710

platform_kernel_address_to_bootloader_address(addr_t address, void **_result)

src/system/boot/platform/atari_m68k/mmu.cpp

714

*_result = (void*)address;

src/system/boot/platform/bios_ia32/bios.h

33

#define ADDRESS_SEGMENT(address) ((addr_t)(address) >> 4)

src/system/boot/platform/bios_ia32/bios.h

34

#define ADDRESS_OFFSET(address) ((addr_t)(address) & 0xf)

src/system/boot/platform/bios_ia32/long.cpp

46

fix_address(uint64 address)

src/system/boot/platform/bios_ia32/long.cpp

48

if (address >= KERNEL_LOAD_BASE)

src/system/boot/platform/bios_ia32/long.cpp

49

return address + KERNEL_FIXUP_FOR_LONG_MODE;

src/system/boot/platform/bios_ia32/long.cpp

51

return address;

src/system/boot/platform/bios_ia32/mmu.cpp

107

addr_t address = sNextVirtualAddress;

src/system/boot/platform/bios_ia32/mmu.cpp

110

return address;

src/system/boot/platform/bios_ia32/mmu.cpp

165

addr_t address = sNextPageTableAddress;

src/system/boot/platform/bios_ia32/mmu.cpp

166

if (address >= kPageTableRegionEnd)

src/system/boot/platform/bios_ia32/mmu.cpp

170

return (uint32 *)address;

src/system/boot/platform/bios_ia32/mmu.cpp

392

addr_t address = sNextVirtualAddress;

src/system/boot/platform/bios_ia32/mmu.cpp

402

return address + pageOffset;

src/system/boot/platform/bios_ia32/mmu.cpp

421

addr_t address = (addr_t)virtualAddress;

src/system/boot/platform/bios_ia32/mmu.cpp

424

if (address < KERNEL_LOAD_BASE || address + size * B_PAGE_SIZE

src/system/boot/platform/bios_ia32/mmu.cpp

429

map_page(address, get_next_physical_page(), kDefaultPageFlags);

src/system/boot/platform/bios_ia32/mmu.cpp

430

address += B_PAGE_SIZE;

src/system/boot/platform/bios_ia32/mmu.cpp

436

void *address = (void *)sNextVirtualAddress;

src/system/boot/platform/bios_ia32/mmu.cpp

443

return address;

src/system/boot/platform/bios_ia32/mmu.cpp

500

addr_t address = (addr_t)virtualAddress;

src/system/boot/platform/bios_ia32/mmu.cpp

501

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/boot/platform/bios_ia32/mmu.cpp

502

address -= pageOffset;

src/system/boot/platform/bios_ia32/mmu.cpp

507

if (address < KERNEL_LOAD_BASE || address + size > sNextVirtualAddress) {

src/system/boot/platform/bios_ia32/mmu.cpp

509

(void *)address, size);

src/system/boot/platform/bios_ia32/mmu.cpp

514

unmap_page(address);

src/system/boot/platform/bios_ia32/mmu.cpp

515

address += B_PAGE_SIZE;

src/system/boot/platform/bios_ia32/mmu.cpp

518

if (address == sNextVirtualAddress) {

src/system/boot/platform/bios_ia32/mmu.cpp

814

void *address = mmu_allocate(*_address, size);

src/system/boot/platform/bios_ia32/mmu.cpp

815

if (address == NULL)

src/system/boot/platform/bios_ia32/mmu.cpp

818

*_address = address;

src/system/boot/platform/bios_ia32/mmu.cpp

824

platform_free_region(void *address, size_t size)

src/system/boot/platform/bios_ia32/mmu.cpp

826

mmu_free(address, size);

src/system/boot/platform/bios_ia32/mmu.cpp

858

platform_bootloader_address_to_kernel_address(void *address, addr_t *_result)

src/system/boot/platform/bios_ia32/mmu.cpp

862

*_result = (addr_t)address;

src/system/boot/platform/bios_ia32/mmu.cpp

868

platform_kernel_address_to_bootloader_address(addr_t address, void **_result)

src/system/boot/platform/bios_ia32/mmu.cpp

872

*_result = (void*)address;

src/system/boot/platform/efi/arch/arm64/aarch64.h

238

static inline bool arch_mmu_is_kernel_address(uint64 address)

src/system/boot/platform/efi/arch/arm64/aarch64.h

240

return address >= KERNEL_BASE;

src/system/boot/platform/efi/arch/arm64/aarch64.h

31

#define AARCH64_CHECK_ACCESS(operand, address) \

src/system/boot/platform/efi/arch/arm64/aarch64.h

32

__asm __volatile("at " #operand ", %0" : : "r"((uint64_t)address))

src/system/boot/platform/efi/arch/arm64/aarch64.h

45

static inline bool arch_mmu_read_access(addr_t address) {

src/system/boot/platform/efi/arch/arm64/aarch64.h

50

AARCH64_CHECK_ACCESS(S1E0R, address);

src/system/boot/platform/efi/arch/arm64/aarch64.h

53

AARCH64_CHECK_ACCESS(S1E1R, address);

src/system/boot/platform/efi/arch/arm64/aarch64.h

56

AARCH64_CHECK_ACCESS(S1E2R, address);

src/system/boot/platform/efi/arch/arm64/aarch64.h

59

AARCH64_CHECK_ACCESS(S1E3R, address);

src/system/boot/platform/efi/arch/arm64/aarch64.h

68

static inline bool arch_mmu_write_access(addr_t address) {

src/system/boot/platform/efi/arch/arm64/aarch64.h

73

AARCH64_CHECK_ACCESS(S1E0W, address);

src/system/boot/platform/efi/arch/arm64/aarch64.h

76

AARCH64_CHECK_ACCESS(S1E1W, address);

src/system/boot/platform/efi/arch/arm64/aarch64.h

79

AARCH64_CHECK_ACCESS(S1E2W, address);

src/system/boot/platform/efi/arch/arm64/aarch64.h

82

AARCH64_CHECK_ACCESS(S1E3W, address);

src/system/boot/platform/efi/arch/arm64/arch_acpi.cpp

41

uart.regs.start = spcr->base_address.address;

src/system/boot/platform/efi/arch/arm64/arch_acpi.cpp

69

uart.regs.start = base_addr->address;

src/system/boot/platform/efi/arch/arm64/arch_mmu.cpp

102

uint64 address = arch_mmu_base_register();

src/system/boot/platform/efi/arch/arm64/arch_mmu.cpp

103

dprintf("Under TTBR0: %lx\n", address);

src/system/boot/platform/efi/arch/arm64/arch_mmu.cpp

105

arch_mmu_dump_table(reinterpret_cast<uint64*>(address), 0);

src/system/boot/platform/efi/arch/arm64/arch_mmu.cpp

224

uint64 address;

src/system/boot/platform/efi/arch/arm64/arch_mmu.cpp

228

address = READ_SPECIALREG(TTBR1_EL1);

src/system/boot/platform/efi/arch/arm64/arch_mmu.cpp

232

address = READ_SPECIALREG(TTBR0_EL1);

src/system/boot/platform/efi/arch/arm64/arch_mmu.cpp

234

address = READ_SPECIALREG(TTBR0_EL2);

src/system/boot/platform/efi/arch/arm64/arch_mmu.cpp

238

0, flags, reinterpret_cast<uint64*>(address));

src/system/boot/platform/efi/arch/arm64/arch_mmu.h

130

static uint64 CleanAttributes(uint64 address) {

src/system/boot/platform/efi/arch/arm64/arch_mmu.h

131

return address & ~ATTR_MASK;

src/system/boot/platform/efi/arch/arm64/arch_mmu.h

226

bool Aligned(addr_t address, uint8 level) {

src/system/boot/platform/efi/arch/arm64/arch_mmu.h

227

return (address & Mask(level)) == 0;

src/system/boot/platform/efi/mmu.cpp

239

platform_assign_kernel_address_for_region(void *address, addr_t assign)

src/system/boot/platform/efi/mmu.cpp

242

phys_addr_t addr = (phys_addr_t)(addr_t)address;

src/system/boot/platform/efi/mmu.cpp

262

platform_bootloader_address_to_kernel_address(void *address, addr_t *_result)

src/system/boot/platform/efi/mmu.cpp

270

phys_addr_t addr = (phys_addr_t)(addr_t)address;

src/system/boot/platform/efi/mmu.cpp

291

platform_kernel_address_to_bootloader_address(addr_t address, void **_result)

src/system/boot/platform/efi/mmu.cpp

297

if (region->vaddr != 0 && region->vaddr <= address

src/system/boot/platform/efi/mmu.cpp

298

&& address < region->vaddr + region->size) {

src/system/boot/platform/efi/mmu.cpp

299

*_result = (void *)(region->paddr + (address - region->vaddr));

src/system/boot/platform/efi/mmu.cpp

311

platform_free_region(void *address, size_t size)

src/system/boot/platform/efi/mmu.cpp

314

address, size);

src/system/boot/platform/efi/mmu.cpp

319

if ((*ref)->matches((phys_addr_t)(addr_t)address, size)) {

src/system/boot/platform/efi/mmu.cpp

321

status = kBootServices->FreePages((efi_physical_addr)(addr_t)address,

src/system/boot/platform/efi/mmu.cpp

72

addr_t address = sNextVirtualAddress;

src/system/boot/platform/efi/mmu.cpp

74

return address;

src/system/boot/platform/efi/mmu.h

44

extern status_t platform_assign_kernel_address_for_region(void *address, addr_t assign);

src/system/boot/platform/efi/mmu.h

46

extern status_t platform_kernel_address_to_bootloader_address(addr_t address,

src/system/boot/platform/efi/mmu.h

49

extern status_t platform_bootloader_address_to_kernel_address(void *address,

src/system/boot/platform/efi/mmu.h

62

fix_address(addr_t address)

src/system/boot/platform/efi/mmu.h

65

if (platform_bootloader_address_to_kernel_address((void *)address, &result)

src/system/boot/platform/efi/mmu.h

67

return address;

src/system/boot/platform/efi/network.cpp

207

ip_addr_t address = ip_parse_address(ptr);

src/system/boot/platform/efi/network.cpp

208

SetIPAddress(address);

src/system/boot/platform/efi/network.cpp

245

ip_addr_t* address = (ip_addr_t*)(devicePathProtocol + 1);

src/system/boot/platform/efi/network.cpp

246

SetIPAddress(*address);

src/system/boot/platform/efi/network.cpp

284

ip_addr_t* address = (ip_addr_t*)(devicePathProtocol + 1);

src/system/boot/platform/efi/network.cpp

285

SetIPAddress(*address);

src/system/boot/platform/next_m68k/mmu.cpp

146

platform_free_region(void *address, size_t size)

src/system/boot/platform/next_m68k/mmu.cpp

168

platform_bootloader_address_to_kernel_address(void *address, addr_t *_result)

src/system/boot/platform/next_m68k/mmu.cpp

172

*_result = (addr_t)address;

src/system/boot/platform/next_m68k/mmu.cpp

178

platform_kernel_address_to_bootloader_address(addr_t address, void **_result)

src/system/boot/platform/next_m68k/mmu.cpp

182

*_result = (void*)address;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

171

is_virtual_allocated(void *address, size_t size)

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

175

gKernelArgs.num_virtual_allocated_ranges, (addr_t)address, size,

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

176

&foundBase) || foundBase != (addr_t)address;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

181

is_physical_allocated(void *address, size_t size)

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

185

gKernelArgs.num_physical_allocated_ranges, (addr_t)address, size,

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

186

&foundBase) || foundBase != (addr_t)address;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

191

is_physical_memory(void *address, size_t size)

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

194

gKernelArgs.num_physical_memory_ranges, (addr_t)address, size);

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

199

is_physical_memory(void *address)

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

201

return is_physical_memory(address, 1);

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

445

void *address

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

448

if (!is_physical_allocated(address, size)

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

449

&& is_physical_memory(address, size))

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

450

return address;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

465

void *address

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

468

if (!is_virtual_allocated(address, size)) {

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

470

return address;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

473

firstFound = address;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

474

if (address >= base

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

475

&& (firstBaseFound == NULL || address < firstBaseFound)) {

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

476

firstBaseFound = address;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

542

arch_mmu_free(void *address, size_t size)

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

558

addr_t address = 0;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

560

asm volatile("tlbie %0" : : "r" (address));

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

561

address += B_PAGE_SIZE;

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

135

is_virtual_allocated(void *address, size_t size)

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

139

gKernelArgs.num_virtual_allocated_ranges, (addr_t)address, size,

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

140

&foundBase) || foundBase != (addr_t)address;

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

145

is_physical_allocated(void *address, size_t size)

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

149

gKernelArgs.num_physical_allocated_ranges, (addr_t)address, size,

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

150

&foundBase) || foundBase != (addr_t)address;

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

155

is_physical_memory(void *address, size_t size = 1)

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

158

gKernelArgs.num_physical_memory_ranges, (addr_t)address, size);

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

312

void *address

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

315

if (!is_physical_allocated(address, size)

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

316

&& is_physical_memory(address, size)) {

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

317

return address;

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

326

void *address = (void *)gKernelArgs.physical_memory_range[i].start;

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

328

&& !is_physical_allocated(address, size)) {

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

329

return address;

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

347

void *address

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

350

if (!is_virtual_allocated(address, size)) {

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

352

return address;

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

355

firstFound = address;

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

356

if (address >= base

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

357

&& (firstBaseFound == NULL || address < firstBaseFound)) {

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

358

firstBaseFound = address;

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

450

arch_mmu_free(void *address, size_t size)

src/system/boot/platform/openfirmware/mmu.cpp

20

void *address = arch_mmu_allocate(*_address, size, protection,

src/system/boot/platform/openfirmware/mmu.cpp

22

if (address == NULL)

src/system/boot/platform/openfirmware/mmu.cpp

25

*_address = address;

src/system/boot/platform/openfirmware/mmu.cpp

31

platform_bootloader_address_to_kernel_address(void *address, addr_t *_result)

src/system/boot/platform/openfirmware/mmu.cpp

33

*_result = (addr_t)address;

src/system/boot/platform/openfirmware/mmu.cpp

39

platform_kernel_address_to_bootloader_address(addr_t address, void **_result)

src/system/boot/platform/openfirmware/mmu.cpp

41

*_result = (void*)address;

src/system/boot/platform/openfirmware/mmu.cpp

47

platform_free_region(void *address, size_t size)

src/system/boot/platform/openfirmware/mmu.cpp

49

return arch_mmu_free(address, size);

src/system/boot/platform/openfirmware/network.cpp

189

ip_addr_t address = ip_parse_address(defaultClientIP);

src/system/boot/platform/openfirmware/network.cpp

190

SetIPAddress(address);

src/system/boot/platform/openfirmware/video.cpp

80

uint32 address;

src/system/boot/platform/openfirmware/video.cpp

82

if (of_getprop(package, "address", &address, sizeof(uint32)) == OF_FAILED)

src/system/boot/platform/openfirmware/video.cpp

84

gKernelArgs.frame_buffer.physical_buffer.start = address;

src/system/boot/platform/riscv/FwCfg.cpp

40

dma.address = B_HOST_TO_BENDIAN_INT64((addr_t)bytes);

src/system/boot/platform/riscv/FwCfg.h

52

uint64_t address;

src/system/boot/platform/riscv/mmu.cpp

300

platform_allocate_region(void** address, size_t size, uint8 protection)

src/system/boot/platform/riscv/mmu.cpp

316

*address = (void*)region->physAdr;

src/system/boot/platform/riscv/mmu.cpp

326

platform_free_region(void* address, size_t size)

src/system/boot/platform/riscv/mmu.cpp

330

while (region != NULL && !(region->physAdr == (phys_addr_t)address)) {

src/system/boot/platform/riscv/mmu.cpp

335

panic("platform_free_region: address %p is not allocated\n", address);

src/system/boot/platform/riscv/mmu.cpp

370

platform_bootloader_address_to_kernel_address(void* address, addr_t* result)

src/system/boot/platform/riscv/mmu.cpp

373

while (region != NULL && !((phys_addr_t)address >= region->physAdr

src/system/boot/platform/riscv/mmu.cpp

374

&& (phys_addr_t)address < region->physAdr + region->size))

src/system/boot/platform/riscv/mmu.cpp

380

*result = (addr_t)address - region->physAdr + region->virtAdr;

src/system/boot/platform/riscv/mmu.cpp

386

platform_kernel_address_to_bootloader_address(addr_t address, void** result)

src/system/boot/platform/riscv/mmu.cpp

389

while (region != NULL && !((phys_addr_t)address >= region->virtAdr

src/system/boot/platform/riscv/mmu.cpp

390

&& (phys_addr_t)address < region->virtAdr + region->size))

src/system/boot/platform/riscv/mmu.cpp

396

*result = (void*)(address - region->virtAdr + region->physAdr);

src/system/boot/platform/riscv/mmu.h

26

fix_address(addr_t address)

src/system/boot/platform/riscv/mmu.h

29

if (platform_bootloader_address_to_kernel_address((void *)address, &result)

src/system/boot/platform/riscv/mmu.h

31

return address;

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

112

addr_t address = sNextVirtualAddress;

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

116

return address;

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

124

addr_t address = sNextPhysicalAddress;

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

128

return address;

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

367

addr_t address = (addr_t)*_address;

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

370

if (address < KERNEL_BASE

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

371

|| address + size >= KERNEL_BASE + kMaxKernelSize) {

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

375

(uint32)address, (uint32)KERNEL_BASE,

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

376

KERNEL_BASE + kMaxKernelSize, (uint32)(address + size)));

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

380

address));

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

385

void *address = (void *)get_next_virtual_address(size);

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

386

if (address == NULL)

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

390

address));

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

391

*_address = address;

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

397

platform_free_region(void *address, size_t size)

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

399

TRACE(("platform_free_region(%p, %zd)\n", address, size));

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

401

mmu_free(address, size);

src/system/kernel/arch/arm/arch_commpage.cpp

59

ASSERT(expectedAddress == symbolInfo.address);

src/system/kernel/arch/arm/arch_commpage.cpp

63

(void*)symbolInfo.address, symbolInfo.size);

src/system/kernel/arch/arm/arch_cpu.cpp

69

arch_cpu_sync_icache(void *address, size_t len)

src/system/kernel/arch/arm/arch_debug.cpp

71

lookup_symbol(Thread* thread, addr_t address, addr_t* _baseAddress,

src/system/kernel/arch/arm/arch_debug.cpp

76

if (IS_KERNEL_ADDRESS(address)) {

src/system/kernel/arch/arm/arch_debug.cpp

78

status = elf_debug_lookup_symbol_address(address, _baseAddress,

src/system/kernel/arch/arm/arch_debug.cpp

82

status = elf_debug_lookup_user_symbol_address(thread->team, address,

src/system/kernel/arch/arm/arch_elf.cpp

157

is_in_image(struct elf_image_info *image, addr_t address)

src/system/kernel/arch/arm/arch_elf.cpp

159

return (address >= image->text_region.start

src/system/kernel/arch/arm/arch_elf.cpp

160

&& address < image->text_region.start + image->text_region.size)

src/system/kernel/arch/arm/arch_elf.cpp

161

|| (address >= image->data_region.start

src/system/kernel/arch/arm/arch_elf.cpp

162

&& address < image->data_region.start + image->data_region.size);

src/system/kernel/arch/arm/arch_user_debugger.cpp

71

arch_set_breakpoint(void *address)

src/system/kernel/arch/arm/arch_user_debugger.cpp

78

arch_clear_breakpoint(void *address)

src/system/kernel/arch/arm/arch_user_debugger.cpp

85

arch_set_watchpoint(void *address, uint32 type, int32 length)

src/system/kernel/arch/arm/arch_user_debugger.cpp

92

arch_clear_watchpoint(void *address)

src/system/kernel/arch/arm/arch_vm.cpp

74

void *address = (void*)range.start;

src/system/kernel/arch/arm/arch_vm.cpp

77

panic("arch_vm_init_end(): No page mapping for %p\n", address);

src/system/kernel/arch/arm/arch_vm.cpp

80

"boot loader reserved area", &address,

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

169

slot->address = slotAddress;

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

526

addr_t address, size_t size)

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

542

+ VADDR_TO_PDENT(address) + i;

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

544

(address < KERNEL_BASE) ? ARM_MMU_L1_FLAG_PXN : 0);

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.h

91

addr_t address, size_t size);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

283

ARMVMTranslationMap32Bit::UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

286

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

289

TRACE("ARMVMTranslationMap32Bit::UnmapPage(%#" B_PRIxADDR ")\n", address);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

295

int index = VADDR_TO_PDENT(address);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

304

index = VADDR_TO_PTENT(address);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

322

InvalidatePage(address);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

641

ARMVMTranslationMap32Bit::ClearAccessedAndModified(VMArea* area, addr_t address,

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

644

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

649

")\n", address);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

653

int index = VADDR_TO_PDENT(address);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

662

index = VADDR_TO_PTENT(address);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

67

addr_t address = fPagingStructures->pgdir_virt[i]

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

69

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

702

InvalidatePage(address);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.h

30

virtual status_t UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.h

53

VMArea* area, addr_t address,

src/system/kernel/arch/arm/paging/ARMVMTranslationMap.h

39

inline void InvalidatePage(addr_t address);

src/system/kernel/arch/arm/paging/ARMVMTranslationMap.h

52

ARMVMTranslationMap::InvalidatePage(addr_t address)

src/system/kernel/arch/arm/paging/ARMVMTranslationMap.h

55

fInvalidPages[fInvalidPagesCount] = address;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

150

virtual status_t MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

186

pool->Map(physicalAddress, address);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

398

arch_cpu_invalidate_tlb_range(0, slot.slot->address,

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

399

slot.slot->address + B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

402

return (uint8*)slot.slot->address + off;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

415

return (uint8*)slot.slot->address + off;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

493

return (void*)slot->address + off;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

509

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

536

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

562

*virtualAddress = fDebugSlot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

575

LargeMemoryPhysicalPageMapper::MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

578

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

588

slot->Map(address - pageOffset);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

591

memset((void*)(slot->address + pageOffset), value, toSet);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

594

address += toSet;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

625

error = user_memcpy(to, (void*)(slot->address + pageOffset),

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

630

memcpy(to, (void*)(slot->address + pageOffset), toCopy);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

665

error = user_memcpy((void*)(slot->address + pageOffset), from,

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

670

memcpy((void*)(slot->address + pageOffset), from, toCopy);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

700

memcpy((void*)toSlot->address, (void*)fromSlot->address, B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.h

37

addr_t address;

src/system/kernel/arch/arm64/PMAPPhysicalPageMapper.cpp

29

PMAPPhysicalPageMapper::MemsetPhysical(phys_addr_t address, int value, phys_size_t length)

src/system/kernel/arch/arm64/PMAPPhysicalPageMapper.cpp

31

ASSERT(address < KERNEL_PMAP_SIZE);

src/system/kernel/arch/arm64/PMAPPhysicalPageMapper.cpp

32

memset(reinterpret_cast<void*>(KERNEL_PMAP_BASE + address), value, length);

src/system/kernel/arch/arm64/PMAPPhysicalPageMapper.h

40

virtual status_t MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

637

VMSAv8TranslationMap::UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

640

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

644

B_PRIxADDR ", %d)\n", (addr_t)area, area->name, address,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

647

ASSERT(ValidateVa(address));

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

652

ProcessRange(fPageTable, fInitialLevel, address, B_PAGE_SIZE, nullptr,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

682

VMSAv8TranslationMap::UnmapPages(VMArea* area, addr_t address, size_t size,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

687

area->name, address, size, updatePageQueue);

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

689

ASSERT(ValidateVa(address));

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

694

ProcessRange(fPageTable, fInitialLevel, address, size, nullptr,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

899

VMArea* area, addr_t address, bool unmapIfUnaccessed, bool& _modified)

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

903

area->name, address, unmapIfUnaccessed);

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

904

ASSERT(ValidateVa(address));

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

910

ProcessRange(fPageTable, fInitialLevel, address, B_PAGE_SIZE, nullptr,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

933

if (FlushVAIfAccessed(oldPte, address))

src/system/kernel/arch/arm64/VMSAv8TranslationMap.h

59

virtual status_t UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.h

80

VMArea* area, addr_t address,

src/system/kernel/arch/arm64/arch_commpage.cpp

61

ASSERT(expectedAddress == symbolInfo.address);

src/system/kernel/arch/arm64/arch_commpage.cpp

64

addr_t position = fill_commpage_entry(commpageIndex, (void*)symbolInfo.address,

src/system/kernel/arch/arm64/arch_cpu.cpp

88

arch_cpu_sync_icache(void *address, size_t len)

src/system/kernel/arch/arm64/arch_cpu.cpp

95

uint64_t addr = (uint64_t)address;

src/system/kernel/arch/arm64/arch_debug.cpp

63

lookup_symbol(Thread* thread, addr_t address, addr_t* _baseAddress,

src/system/kernel/arch/arm64/arch_debug.cpp

68

if (address >= KERNEL_BASE) {

src/system/kernel/arch/arm64/arch_debug.cpp

70

status = elf_debug_lookup_symbol_address(address, _baseAddress,

src/system/kernel/arch/arm64/arch_debug.cpp

74

status = elf_debug_lookup_user_symbol_address(thread->team, address,

src/system/kernel/arch/arm64/arch_elf.cpp

29

is_in_image(struct elf_image_info *image, addr_t address)

src/system/kernel/arch/arm64/arch_elf.cpp

31

return (address >= image->text_region.start

src/system/kernel/arch/arm64/arch_elf.cpp

32

&& address < image->text_region.start + image->text_region.size)

src/system/kernel/arch/arm64/arch_elf.cpp

33

|| (address >= image->data_region.start

src/system/kernel/arch/arm64/arch_elf.cpp

34

&& address < image->data_region.start + image->data_region.size);

src/system/kernel/arch/arm64/arch_user_debugger.cpp

61

arch_set_breakpoint(void *address)

src/system/kernel/arch/arm64/arch_user_debugger.cpp

68

arch_clear_breakpoint(void *address)

src/system/kernel/arch/arm64/arch_user_debugger.cpp

75

arch_set_watchpoint(void *address, uint32 type, int32 length)

src/system/kernel/arch/arm64/arch_user_debugger.cpp

82

arch_clear_watchpoint(void *address)

src/system/kernel/arch/arm64/arch_vm.cpp

67

void *address = (void*)range.start;

src/system/kernel/arch/arm64/arch_vm.cpp

70

panic("arch_vm_init_end(): No page mapping for %p\n", address);

src/system/kernel/arch/arm64/arch_vm.cpp

73

"boot loader reserved area", &address,

src/system/kernel/arch/arm64/arch_vm_translation_map.cpp

100

void* address = (void*) KERNEL_PMAP_BASE;

src/system/kernel/arch/arm64/arch_vm_translation_map.cpp

101

area_id area = vm_create_null_area(VMAddressSpace::KernelID(), "physical map area", &address,

src/system/kernel/arch/arm64/arch_vm_translation_map.cpp

106

address = (void*)args->arch_args.uart.regs.start;

src/system/kernel/arch/arm64/arch_vm_translation_map.cpp

108

"debug uart map area", &address, B_EXACT_ADDRESS,

src/system/kernel/arch/generic/GenericVMPhysicalPageMapper.cpp

76

GenericVMPhysicalPageMapper::MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/generic/GenericVMPhysicalPageMapper.cpp

79

return generic_vm_memset_physical(address, value, length);

src/system/kernel/arch/generic/GenericVMPhysicalPageMapper.h

35

virtual status_t MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/generic/generic_msi.cpp

28

msi_allocate_vectors(uint32 count, uint32 *startVector, uint64 *address, uint32 *data)

src/system/kernel/arch/generic/generic_msi.cpp

30

return sMSIInterface->AllocateVectors(count, *startVector, *address, *data);

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

15

generic_vm_memset_physical(phys_addr_t address, int value, phys_size_t length)

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

20

phys_addr_t pageOffset = address % B_PAGE_SIZE;

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

23

status_t error = vm_get_physical_page_current_cpu(address - pageOffset,

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

34

address += toSet;

src/system/kernel/arch/generic/generic_vm_physical_page_ops.h

16

status_t generic_vm_memset_physical(phys_addr_t address, int value,

src/system/kernel/arch/m68k/arch_030_cpu.cpp

34

sync_icache_030(addr_t address, size_t len)

src/system/kernel/arch/m68k/arch_030_cpu.cpp

40

off = (unsigned int)address & (CACHELINE - 1);

src/system/kernel/arch/m68k/arch_030_cpu.cpp

44

p = (char *)address - off;

src/system/kernel/arch/m68k/arch_040_cpu.cpp

35

sync_icache_040(addr_t address, size_t len)

src/system/kernel/arch/m68k/arch_040_cpu.cpp

40

off = (unsigned int)address & (CACHELINE - 1);

src/system/kernel/arch/m68k/arch_040_cpu.cpp

44

p = (char *)address - off;

src/system/kernel/arch/m68k/arch_040_cpu.cpp

59

sync_dcache_040(addr_t address, size_t len)

src/system/kernel/arch/m68k/arch_040_cpu.cpp

64

off = (unsigned int)address & (CACHELINE - 1);

src/system/kernel/arch/m68k/arch_040_cpu.cpp

68

p = (char *)address - off;

src/system/kernel/arch/m68k/arch_cpu.cpp

106

arch_cpu_sync_icache(void *address, size_t len)

src/system/kernel/arch/m68k/arch_cpu.cpp

108

cpu_ops.flush_icache((addr_t)address, len);

src/system/kernel/arch/m68k/arch_user_debugger.cpp

101

arch_set_watchpoint(void *address, uint32 type, int32 length)

src/system/kernel/arch/m68k/arch_user_debugger.cpp

108

arch_clear_watchpoint(void *address)

src/system/kernel/arch/m68k/arch_user_debugger.cpp

87

arch_set_breakpoint(void *address)

src/system/kernel/arch/m68k/arch_user_debugger.cpp

94

arch_clear_breakpoint(void *address)

src/system/kernel/arch/m68k/arch_vm.cpp

78

void *address = (void*)range.start;

src/system/kernel/arch/m68k/arch_vm.cpp

79

area_id area = create_area("boot loader reserved area", &address,

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

238

slot->address = slotAddress;

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

667

addr_t address, size_t size)

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

691

index = VADDR_TO_PRENT(address) + i / NUM_DIRENT_PER_TBL;

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

693

e = &pd[(VADDR_TO_PDENT(address) + i) % NUM_DIRENT_PER_TBL];

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.h

95

addr_t address, size_t size);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

116

addr_t address = fPagingStructures->pgdir_virt[i]

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

118

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

422

M68KVMTranslationMap040::UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

425

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

430

TRACE("M68KVMTranslationMap040::UnmapPage(%#" B_PRIxADDR ")\n", address);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

436

index = VADDR_TO_PRENT(address);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

445

index = VADDR_TO_PDENT(address);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

452

index = VADDR_TO_PTENT(address);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

477

InvalidatePage(address);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

859

M68KVMTranslationMap040::ClearAccessedAndModified(VMArea* area, addr_t address,

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

862

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

867

")\n", address);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

872

int index = VADDR_TO_PDENT(address);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

881

index = VADDR_TO_PTENT(address);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

922

InvalidatePage(address);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.h

29

virtual status_t UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.h

50

VMArea* area, addr_t address,

src/system/kernel/arch/m68k/paging/M68KVMTranslationMap.h

34

inline void InvalidatePage(addr_t address);

src/system/kernel/arch/m68k/paging/M68KVMTranslationMap.h

45

M68KVMTranslationMap::InvalidatePage(addr_t address)

src/system/kernel/arch/m68k/paging/M68KVMTranslationMap.h

48

fInvalidPages[fInvalidPagesCount] = address;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

155

virtual status_t MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

191

pool->Map(physicalAddress, address);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

402

arch_cpu_invalidate_tlb_range(0, slot.slot->address,

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

403

slot.slot->address);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

406

return (void*)slot.slot->address;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

419

return (void*)slot.slot->address;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

491

return (void*)slot->address;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

507

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

534

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

560

*virtualAddress = fDebugSlot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

573

LargeMemoryPhysicalPageMapper::MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

576

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

586

slot->Map(address - pageOffset);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

589

memset((void*)(slot->address + pageOffset), value, toSet);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

592

address += toSet;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

623

error = user_memcpy(to, (void*)(slot->address + pageOffset),

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

628

memcpy(to, (void*)(slot->address + pageOffset), toCopy);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

663

error = user_memcpy((void*)(slot->address + pageOffset), from,

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

668

memcpy((void*)(slot->address + pageOffset), from, toCopy);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

698

memcpy((void*)toSlot->address, (void*)fromSlot->address, B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.h

28

addr_t address;

src/system/kernel/arch/ppc/arch_cpu.cpp

151

addr_t address = 0;

src/system/kernel/arch/ppc/arch_cpu.cpp

156

tlbie(address);

src/system/kernel/arch/ppc/arch_cpu.cpp

160

address += B_PAGE_SIZE;

src/system/kernel/arch/ppc/arch_cpu.cpp

69

arch_cpu_sync_icache(void *address, size_t len)

src/system/kernel/arch/ppc/arch_cpu.cpp

74

off = (unsigned int)address & (CACHELINE - 1);

src/system/kernel/arch/ppc/arch_cpu.cpp

78

p = (char *)address - off;

src/system/kernel/arch/ppc/arch_cpu.cpp

85

p = (char *)address - off;

src/system/kernel/arch/ppc/arch_int.cpp

289

addr_t address = (addr_t)handlers;

src/system/kernel/arch/ppc/arch_int.cpp

290

status_t error = ppc_remap_address_range(&address,

src/system/kernel/arch/ppc/arch_int.cpp

297

handlers = (void*)(address);

src/system/kernel/arch/ppc/arch_user_debugger.cpp

65

arch_set_breakpoint(void *address)

src/system/kernel/arch/ppc/arch_user_debugger.cpp

72

arch_clear_breakpoint(void *address)

src/system/kernel/arch/ppc/arch_user_debugger.cpp

79

arch_set_watchpoint(void *address, uint32 type, int32 length)

src/system/kernel/arch/ppc/arch_user_debugger.cpp

86

arch_clear_watchpoint(void *address)

src/system/kernel/arch/ppc/arch_vm.cpp

122

void *address = (void*)range.start;

src/system/kernel/arch/ppc/arch_vm.cpp

125

panic("arch_vm_init_end(): No page mapping for %p\n", address);

src/system/kernel/arch/ppc/arch_vm.cpp

127

"boot loader reserved area", &address,

src/system/kernel/arch/ppc/arch_vm_translation_map.cpp

144

virtual status_t UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/ppc/arch_vm_translation_map.cpp

160

VMArea* area, addr_t address,

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

375

addr_t address, size_t size)

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

393

(address / (B_PAGE_SIZE * 1024)) + i];

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.h

105

addr_t address, size_t size);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1036

addr_t address, bool unmapIfUnaccessed, bool& _modified)

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1038

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1047

if (Query(address, &physicalAddress, &flags) != B_OK

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1055

ClearFlags(address, flags & (PAGE_ACCESSED | PAGE_MODIFIED));

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1065

UnmapPage(area, address, false);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1084

")\n", address);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1088

int index = VADDR_TO_PDENT(address);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1097

index = VADDR_TO_PTENT(address);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1138

InvalidatePage(address);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

156

addr_t address = fPagingStructures->pgdir_virt[i]

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

158

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

589

PPCVMTranslationMap460::UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

592

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

598

if (!RemovePageTableEntry(address))

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

605

page_table_entry* entry = LookupPageTableEntry(address);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

613

RemovePageTableEntry(address);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

635

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

639

TRACE("PPCVMTranslationMap460::UnmapPage(%#" B_PRIxADDR ")\n", address);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

643

int index = VADDR_TO_PDENT(address);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

652

index = VADDR_TO_PTENT(address);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

669

InvalidatePage(address);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.h

41

virtual status_t UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.h

62

VMArea* area, addr_t address,

src/system/kernel/arch/ppc/paging/PPCVMTranslationMap.h

34

inline void InvalidatePage(addr_t address);

src/system/kernel/arch/ppc/paging/PPCVMTranslationMap.h

51

PPCVMTranslationMap::InvalidatePage(addr_t address)

src/system/kernel/arch/ppc/paging/PPCVMTranslationMap.h

54

fInvalidPages[fInvalidPagesCount] = address;

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

375

addr_t address, size_t size)

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

393

(address / (B_PAGE_SIZE * 1024)) + i];

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.h

105

addr_t address, size_t size);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1036

addr_t address, bool unmapIfUnaccessed, bool& _modified)

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1038

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1047

if (Query(address, &physicalAddress, &flags) != B_OK

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1055

ClearFlags(address, flags & (PAGE_ACCESSED | PAGE_MODIFIED));

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1065

UnmapPage(area, address, false, false, NULL);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1084

")\n", address);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1088

int index = VADDR_TO_PDENT(address);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1097

index = VADDR_TO_PTENT(address);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1138

InvalidatePage(address);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

156

addr_t address = fPagingStructures->pgdir_virt[i]

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

158

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

589

PPCVMTranslationMapClassic::UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

592

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

598

if (!RemovePageTableEntry(address))

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

605

page_table_entry* entry = LookupPageTableEntry(address);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

613

RemovePageTableEntry(address);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

635

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

639

TRACE("PPCVMTranslationMapClassic::UnmapPage(%#" B_PRIxADDR ")\n", address);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

643

int index = VADDR_TO_PDENT(address);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

652

index = VADDR_TO_PTENT(address);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

669

InvalidatePage(address);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.h

41

virtual status_t UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.h

62

VMArea* area, addr_t address,

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

315

RISCV64VMTranslationMap::UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

318

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

322

B_PRIxADDR ", %d)\n", (addr_t)area, area->name, address,

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

327

std::atomic<Pte>* pte = LookupPte(address, false, NULL);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

339

InvalidatePage(address);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

534

RISCV64VMTranslationMap::SetFlags(addr_t address, uint32 flags)

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

539

std::atomic<Pte>* pte = LookupPte(address, false, NULL);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

545

if (IS_KERNEL_ADDRESS(address))

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

546

FlushTlbPage(address);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

548

FlushTlbPageAsid(address, 0);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

555

RISCV64VMTranslationMap::ClearFlags(addr_t address, uint32 flags)

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

559

std::atomic<Pte>* pte = LookupPte(address, false, NULL);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

564

InvalidatePage(address);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

570

RISCV64VMTranslationMap::ClearAccessedAndModified(VMArea* area, addr_t address,

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

575

area->name, address, unmapIfUnaccessed);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

580

std::atomic<Pte>* pte = LookupPte(address, false, NULL);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

607

InvalidatePage(address);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

898

RISCV64VMPhysicalPageMapper::MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

902

", 0x%x, 0x%" B_PRIxADDR ")\n", address, value, length);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

903

return user_memset(VirtFromPhys(address), value, length);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.h

134

RISCV64VMTranslationMap::InvalidatePage(addr_t address)

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.h

137

fInvalidPages[fInvalidPagesCount] = address;

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.h

166

virtual status_t MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.h

42

virtual status_t UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.h

66

VMArea* area, addr_t address,

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.h

91

inline void InvalidatePage(addr_t address);

src/system/kernel/arch/riscv64/arch_commpage.cpp

62

ASSERT(expectedAddress == symbolInfo.address);

src/system/kernel/arch/riscv64/arch_commpage.cpp

66

(void*)symbolInfo.address, symbolInfo.size);

src/system/kernel/arch/riscv64/arch_cpu.cpp

93

arch_cpu_sync_icache(void *address, size_t len)

src/system/kernel/arch/riscv64/arch_debug.cpp

136

lookup_symbol(Thread* thread, addr_t address, addr_t* _baseAddress,

src/system/kernel/arch/riscv64/arch_debug.cpp

141

if (IS_KERNEL_ADDRESS(address)) {

src/system/kernel/arch/riscv64/arch_debug.cpp

143

status = elf_debug_lookup_symbol_address(address, _baseAddress,

src/system/kernel/arch/riscv64/arch_debug.cpp

147

status = elf_debug_lookup_user_symbol_address(thread->team, address,

src/system/kernel/arch/riscv64/arch_debug.cpp

468

is_double_fault_stack_address(int32 cpu, addr_t address)

src/system/kernel/arch/riscv64/arch_debug.cpp

473

return address >= bottom && address < bottom + size;

src/system/kernel/arch/riscv64/arch_debug.cpp

480

is_kernel_stack_address(Thread* thread, addr_t address)

src/system/kernel/arch/riscv64/arch_debug.cpp

485

return IS_KERNEL_ADDRESS(address);

src/system/kernel/arch/riscv64/arch_debug.cpp

490

return IS_KERNEL_ADDRESS(address);

src/system/kernel/arch/riscv64/arch_debug.cpp

492

return (address >= thread->kernel_stack_base

src/system/kernel/arch/riscv64/arch_debug.cpp

493

&& address < thread->kernel_stack_top)

src/system/kernel/arch/riscv64/arch_debug.cpp

495

&& is_double_fault_stack_address(thread->cpu->cpu_num, address));

src/system/kernel/arch/riscv64/arch_debug.cpp

71

static bool is_kernel_stack_address(Thread* thread, addr_t address);

src/system/kernel/arch/riscv64/arch_elf.cpp

29

is_in_image(struct elf_image_info *image, addr_t address)

src/system/kernel/arch/riscv64/arch_elf.cpp

31

return (address >= image->text_region.start

src/system/kernel/arch/riscv64/arch_elf.cpp

32

&& address < image->text_region.start

src/system/kernel/arch/riscv64/arch_elf.cpp

34

|| (address >= image->data_region.start

src/system/kernel/arch/riscv64/arch_elf.cpp

35

&& address < image->data_region.start

src/system/kernel/arch/riscv64/arch_user_debugger.cpp

144

arch_set_breakpoint(void *address)

src/system/kernel/arch/riscv64/arch_user_debugger.cpp

151

arch_clear_breakpoint(void *address)

src/system/kernel/arch/riscv64/arch_user_debugger.cpp

158

arch_set_watchpoint(void *address, uint32 type, int32 length)

src/system/kernel/arch/riscv64/arch_user_debugger.cpp

165

arch_clear_watchpoint(void *address)

src/system/kernel/arch/riscv64/arch_vm.cpp

283

void* address = (void*)args->arch_args.physMap.start;

src/system/kernel/arch/riscv64/arch_vm.cpp

285

"physical map area", &address, B_EXACT_ADDRESS,

src/system/kernel/arch/riscv64/arch_vm.cpp

323

void *address = (void*)range.start;

src/system/kernel/arch/riscv64/arch_vm.cpp

326

panic("arch_vm_init_end(): No page mapping for %p\n", address);

src/system/kernel/arch/riscv64/arch_vm.cpp

328

"boot loader reserved area", &address,

src/system/kernel/arch/sparc/arch_cpu.cpp

54

arch_cpu_sync_icache(void *address, size_t len)

src/system/kernel/arch/sparc/arch_elf.cpp

30

is_in_image(struct elf_image_info *image, addr_t address)

src/system/kernel/arch/sparc/arch_elf.cpp

32

return (address >= image->text_region.start

src/system/kernel/arch/sparc/arch_elf.cpp

33

&& address < image->text_region.start + image->text_region.size)

src/system/kernel/arch/sparc/arch_elf.cpp

34

|| (address >= image->data_region.start

src/system/kernel/arch/sparc/arch_elf.cpp

35

&& address < image->data_region.start + image->data_region.size);

src/system/kernel/arch/sparc/arch_user_debugger.cpp

65

arch_set_breakpoint(void *address)

src/system/kernel/arch/sparc/arch_user_debugger.cpp

72

arch_clear_breakpoint(void *address)

src/system/kernel/arch/sparc/arch_user_debugger.cpp

79

arch_set_watchpoint(void *address, uint32 type, int32 length)

src/system/kernel/arch/sparc/arch_user_debugger.cpp

86

arch_clear_watchpoint(void *address)

src/system/kernel/arch/sparc/arch_vm.cpp

61

void *address = (void*)range.start;

src/system/kernel/arch/sparc/arch_vm.cpp

64

panic("arch_vm_init_end(): No page mapping for %p\n", address);

src/system/kernel/arch/sparc/arch_vm.cpp

66

"boot loader reserved area", &address,

src/system/kernel/arch/x86/32/descriptors.cpp

115

void* address;

src/system/kernel/arch/x86/32/descriptors.cpp

130

void* address;

src/system/kernel/arch/x86/32/signals.cpp

89

ASSERT(expectedAddress == symbolInfo.address);

src/system/kernel/arch/x86/32/signals.cpp

93

(void*)symbolInfo.address, symbolInfo.size);

src/system/kernel/arch/x86/64/signals.cpp

61

ASSERT(expectedAddress == symbolInfo.address);

src/system/kernel/arch/x86/64/signals.cpp

65

(void*)symbolInfo.address, symbolInfo.size);

src/system/kernel/arch/x86/arch_altcodepatch.cpp

45

void* address = (void*)(KERNEL_LOAD_BASE + patch->kernel_offset);

src/system/kernel/arch/x86/arch_altcodepatch.cpp

48

memcpy(address, newcodepatch, length);

src/system/kernel/arch/x86/arch_cpu.cpp

2063

arch_cpu_sync_icache(void* address, size_t length)

src/system/kernel/arch/x86/arch_debug.cpp

107

lookup_symbol(Thread* thread, addr_t address, addr_t* _baseAddress,

src/system/kernel/arch/x86/arch_debug.cpp

112

if (IS_KERNEL_ADDRESS(address)) {

src/system/kernel/arch/x86/arch_debug.cpp

114

status = elf_debug_lookup_symbol_address(address, _baseAddress,

src/system/kernel/arch/x86/arch_debug.cpp

118

status = elf_debug_lookup_user_symbol_address(thread->team, address,

src/system/kernel/arch/x86/arch_debug.cpp

42

static bool is_kernel_stack_address(Thread* thread, addr_t address);

src/system/kernel/arch/x86/arch_debug.cpp

517

is_double_fault_stack_address(int32 cpu, addr_t address)

src/system/kernel/arch/x86/arch_debug.cpp

521

return address >= bottom && address < bottom + size;

src/system/kernel/arch/x86/arch_debug.cpp

526

is_kernel_stack_address(Thread* thread, addr_t address)

src/system/kernel/arch/x86/arch_debug.cpp

531

return IS_KERNEL_ADDRESS(address);

src/system/kernel/arch/x86/arch_debug.cpp

536

return IS_KERNEL_ADDRESS(address);

src/system/kernel/arch/x86/arch_debug.cpp

538

return (address >= thread->kernel_stack_base

src/system/kernel/arch/x86/arch_debug.cpp

539

&& address < thread->kernel_stack_top)

src/system/kernel/arch/x86/arch_debug.cpp

541

&& is_double_fault_stack_address(thread->cpu->cpu_num, address));

src/system/kernel/arch/x86/arch_elf.cpp

30

is_in_image(struct elf_image_info *image, addr_t address)

src/system/kernel/arch/x86/arch_elf.cpp

32

return (address >= image->text_region.start

src/system/kernel/arch/x86/arch_elf.cpp

33

&& address < image->text_region.start + image->text_region.size)

src/system/kernel/arch/x86/arch_elf.cpp

34

|| (address >= image->data_region.start

src/system/kernel/arch/x86/arch_elf.cpp

35

&& address < image->data_region.start + image->data_region.size);

src/system/kernel/arch/x86/arch_user_debugger.cpp

259

asm("mov %0, %%dr0" : : "r"(teamInfo.breakpoints[0].address));

src/system/kernel/arch/x86/arch_user_debugger.cpp

260

asm("mov %0, %%dr1" : : "r"(teamInfo.breakpoints[1].address));

src/system/kernel/arch/x86/arch_user_debugger.cpp

261

asm("mov %0, %%dr2" : : "r"(teamInfo.breakpoints[2].address));

src/system/kernel/arch/x86/arch_user_debugger.cpp

262

asm("mov %0, %%dr3" : : "r"(teamInfo.breakpoints[3].address));

src/system/kernel/arch/x86/arch_user_debugger.cpp

280

set_breakpoint(arch_team_debug_info& info, void* address, size_t type,

src/system/kernel/arch/x86/arch_user_debugger.cpp

286

if (info.breakpoints[i].address == address

src/system/kernel/arch/x86/arch_user_debugger.cpp

297

if (!info.breakpoints[i].address) {

src/system/kernel/arch/x86/arch_user_debugger.cpp

305

info.breakpoints[slot].address = address;

src/system/kernel/arch/x86/arch_user_debugger.cpp

330

clear_breakpoint(arch_team_debug_info& info, void* address, bool watchpoint)

src/system/kernel/arch/x86/arch_user_debugger.cpp

335

if (info.breakpoints[i].address == address

src/system/kernel/arch/x86/arch_user_debugger.cpp

345

info.breakpoints[slot].address = NULL;

src/system/kernel/arch/x86/arch_user_debugger.cpp

363

set_breakpoint(void* address, size_t type, size_t length)

src/system/kernel/arch/x86/arch_user_debugger.cpp

365

if (!address)

src/system/kernel/arch/x86/arch_user_debugger.cpp

373

status_t error = set_breakpoint(thread->team->debug_info.arch_info, address,

src/system/kernel/arch/x86/arch_user_debugger.cpp

384

clear_breakpoint(void* address, bool watchpoint)

src/system/kernel/arch/x86/arch_user_debugger.cpp

386

if (!address)

src/system/kernel/arch/x86/arch_user_debugger.cpp

395

address, watchpoint);

src/system/kernel/arch/x86/arch_user_debugger.cpp

421

set_kernel_breakpoint(void* address, size_t type, size_t length)

src/system/kernel/arch/x86/arch_user_debugger.cpp

423

if (!address)

src/system/kernel/arch/x86/arch_user_debugger.cpp

431

status_t error = set_breakpoint(kernelTeam->debug_info.arch_info, address,

src/system/kernel/arch/x86/arch_user_debugger.cpp

445

clear_kernel_breakpoint(void* address, bool watchpoint)

src/system/kernel/arch/x86/arch_user_debugger.cpp

447

if (!address)

src/system/kernel/arch/x86/arch_user_debugger.cpp

456

address, watchpoint);

src/system/kernel/arch/x86/arch_user_debugger.cpp

471

check_watch_point_parameters(void* address, uint32 type, int32 length,

src/system/kernel/arch/x86/arch_user_debugger.cpp

494

if ((addr_t)address & 0x1)

src/system/kernel/arch/x86/arch_user_debugger.cpp

499

if ((addr_t)address & 0x3)

src/system/kernel/arch/x86/arch_user_debugger.cpp

525

if (info.breakpoints[i].address != NULL) {

src/system/kernel/arch/x86/arch_user_debugger.cpp

526

kprintf("%p ", info.breakpoints[i].address);

src/system/kernel/arch/x86/arch_user_debugger.cpp

575

addr_t address = strtoul(argv[1], NULL, 0);

src/system/kernel/arch/x86/arch_user_debugger.cpp

576

if (address == 0)

src/system/kernel/arch/x86/arch_user_debugger.cpp

594

error = clear_breakpoint(info, (void*)address, false);

src/system/kernel/arch/x86/arch_user_debugger.cpp

596

error = set_breakpoint(info, (void*)address, X86_INSTRUCTION_BREAKPOINT,

src/system/kernel/arch/x86/arch_user_debugger.cpp

617

addr_t address = strtoul(argv[1], NULL, 0);

src/system/kernel/arch/x86/arch_user_debugger.cpp

618

if (address == 0)

src/system/kernel/arch/x86/arch_user_debugger.cpp

648

error = clear_breakpoint(info, (void*)address, true);

src/system/kernel/arch/x86/arch_user_debugger.cpp

654

error = check_watch_point_parameters((void*)address, type, length,

src/system/kernel/arch/x86/arch_user_debugger.cpp

658

error = set_breakpoint(info, (void*)address, archType, archLength,

src/system/kernel/arch/x86/arch_user_debugger.cpp

700

info->breakpoints[i].address = NULL;

src/system/kernel/arch/x86/arch_user_debugger.cpp

804

arch_set_breakpoint(void* address)

src/system/kernel/arch/x86/arch_user_debugger.cpp

806

return set_breakpoint(address, X86_INSTRUCTION_BREAKPOINT,

src/system/kernel/arch/x86/arch_user_debugger.cpp

812

arch_clear_breakpoint(void* address)

src/system/kernel/arch/x86/arch_user_debugger.cpp

814

return clear_breakpoint(address, false);

src/system/kernel/arch/x86/arch_user_debugger.cpp

819

arch_set_watchpoint(void* address, uint32 type, int32 length)

src/system/kernel/arch/x86/arch_user_debugger.cpp

822

status_t error = check_watch_point_parameters(address, type, length,

src/system/kernel/arch/x86/arch_user_debugger.cpp

827

return set_breakpoint(address, archType, archLength);

src/system/kernel/arch/x86/arch_user_debugger.cpp

832

arch_clear_watchpoint(void* address)

src/system/kernel/arch/x86/arch_user_debugger.cpp

834

return clear_breakpoint(address, true);

src/system/kernel/arch/x86/arch_user_debugger.cpp

850

arch_set_kernel_breakpoint(void* address)

src/system/kernel/arch/x86/arch_user_debugger.cpp

852

status_t error = set_kernel_breakpoint(address, X86_INSTRUCTION_BREAKPOINT,

src/system/kernel/arch/x86/arch_user_debugger.cpp

865

arch_clear_kernel_breakpoint(void* address)

src/system/kernel/arch/x86/arch_user_debugger.cpp

867

status_t error = clear_kernel_breakpoint(address, false);

src/system/kernel/arch/x86/arch_user_debugger.cpp

879

arch_set_kernel_watchpoint(void* address, uint32 type, int32 length)

src/system/kernel/arch/x86/arch_user_debugger.cpp

882

status_t error = check_watch_point_parameters(address, type, length,

src/system/kernel/arch/x86/arch_user_debugger.cpp

886

error = set_kernel_breakpoint(address, archType, archLength);

src/system/kernel/arch/x86/arch_user_debugger.cpp

898

arch_clear_kernel_watchpoint(void* address)

src/system/kernel/arch/x86/arch_user_debugger.cpp

900

status_t error = clear_kernel_breakpoint(address, true);

src/system/kernel/arch/x86/arch_vm.cpp

354

rangePoints[pointCount].address = range->base;

src/system/kernel/arch/x86/arch_vm.cpp

356

rangePoints[pointCount].address = range->base + range->size;

src/system/kernel/arch/x86/arch_vm.cpp

365

TRACE_MTRR2("%12" B_PRIx64 " (%p)\n", rangePoints[i].address,

src/system/kernel/arch/x86/arch_vm.cpp

405

ranges[rangeCount].size = point->address - ranges[rangeCount].base;

src/system/kernel/arch/x86/arch_vm.cpp

427

ranges[rangeCount].base = point->address;

src/system/kernel/arch/x86/arch_vm.cpp

74

uint64 address;

src/system/kernel/arch/x86/arch_vm.cpp

77

bool IsStart() const { return range->base == address; }

src/system/kernel/arch/x86/arch_vm.cpp

81

return address < other.address;

src/system/kernel/arch/x86/msi.cpp

101

uint64* address = sMSIConfigurations[irq].fAddress;

src/system/kernel/arch/x86/msi.cpp

102

*address = MSI_ADDRESS_BASE | (apic_id << MSI_DESTINATION_ID_SHIFT)

src/system/kernel/arch/x86/msi.cpp

48

msi_allocate_vectors(uint32 count, uint32 *startVector, uint64 *address,

src/system/kernel/arch/x86/msi.cpp

65

sMSIConfigurations[vector].fAddress = address;

src/system/kernel/arch/x86/msi.cpp

70

*address = MSI_ADDRESS_BASE | (sBootCPUAPICId << MSI_DESTINATION_ID_SHIFT)

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

169

slot->address = slotAddress;

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

556

addr_t address, size_t size)

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

574

(address / (B_PAGE_SIZE * 1024)) + i];

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.h

86

addr_t address, size_t size);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

267

X86VMTranslationMap32Bit::UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

270

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

275

TRACE("X86VMTranslationMap32Bit::UnmapPage(%#" B_PRIxADDR ")\n", address);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

279

int index = VADDR_TO_PDENT(address);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

288

index = VADDR_TO_PTENT(address);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

306

InvalidatePage(address);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

619

X86VMTranslationMap32Bit::ClearAccessedAndModified(VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

62

addr_t address = fPagingStructures->pgdir_virt[i]

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

622

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

627

")\n", address);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

631

int index = VADDR_TO_PDENT(address);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

64

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

640

index = VADDR_TO_PTENT(address);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

681

InvalidatePage(address);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.h

30

virtual status_t UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.h

51

VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

93

void* address = (void*)KERNEL_PMAP_BASE;

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

95

"physical map area", &address, B_EXACT_ADDRESS,

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

101

B_PRIxPHYSADDR "\n", i, j, k, address);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

108

address = virtualPDPT[j] & X86_64_PDPTE_ADDRESS_MASK;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

109

page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

112

B_PRIxPHYSADDR "\n", i, j, address);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

119

address = virtualPML4[i] & X86_64_PML4E_ADDRESS_MASK;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

120

page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

123

address);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

131

address = virtualPML5[p] & X86_64_PML5E_ADDRESS_MASK;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

132

page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

135

address);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

320

X86VMTranslationMap64Bit::UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

323

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

326

TRACE("X86VMTranslationMap64Bit::UnmapPage(%#" B_PRIxADDR ")\n", address);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

332

fPagingStructures->VirtualPMLTop(), address, fIsKernelMap,

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

353

InvalidatePage(address);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

60

phys_addr_t address;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

606

X86VMTranslationMap64Bit::ClearFlags(addr_t address, uint32 flags)

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

609

")\n", address, flags);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

614

fPagingStructures->VirtualPMLTop(), address, fIsKernelMap,

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

626

InvalidatePage(address);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

633

X86VMTranslationMap64Bit::ClearAccessedAndModified(VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

636

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

639

")\n", address);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

645

fPagingStructures->VirtualPMLTop(), address, fIsKernelMap,

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

688

InvalidatePage(address);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

97

address = virtualPageDir[k] & X86_64_PDE_ADDRESS_MASK;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

98

page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.h

31

virtual status_t UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.h

52

VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/X86VMTranslationMap.h

34

inline void InvalidatePage(addr_t address);

src/system/kernel/arch/x86/paging/X86VMTranslationMap.h

45

X86VMTranslationMap::InvalidatePage(addr_t address)

src/system/kernel/arch/x86/paging/X86VMTranslationMap.h

48

fInvalidPages[fInvalidPagesCount] = address;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

314

bool _IsVirtualAddressAllocated(addr_t address) const

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

319

if (address < start)

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

321

if (address <= end - 1)

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

479

slot->address = slotAddress;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

884

X86PagingMethodPAE::Free32BitPage(void* address, phys_addr_t physicalAddress,

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

888

fPhysicalPageMapper->PutPage((addr_t)address, handle);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

942

X86PagingMethodPAE::_EarlyGetPageTable(phys_addr_t address)

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

944

*fFreeVirtualSlotPTE = (address & X86_PAE_PTE_ADDRESS_MASK)

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.h

103

pae_page_table_entry* _EarlyGetPageTable(phys_addr_t address);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.h

148

pae_page_directory_entry* const* pdpt, addr_t address)

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.h

150

return pdpt[address >> 30]

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.h

151

+ (address / kPAEPageTableRange) % kPAEPageDirEntryCount;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.h

49

void Free32BitPage(void* address,

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.h

88

addr_t address);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

258

phys_addr_t address = pageDir[i] & X86_PAE_PDE_ADDRESS_MASK;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

259

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

264

address,

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

503

X86VMTranslationMapPAE::UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

506

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

509

TRACE("X86VMTranslationMapPAE::UnmapPage(%#" B_PRIxADDR ")\n", address);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

515

fPagingStructures->VirtualPageDirs(), address);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

527

&pageTable[address / B_PAGE_SIZE % kPAEPageTableEntryCount]);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

529

T(Unmap(this, address, oldEntry));

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

545

InvalidatePage(address);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

859

X86VMTranslationMapPAE::ClearFlags(addr_t address, uint32 flags)

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

863

fPagingStructures->VirtualPageDirs(), address);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

878

+ address / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

886

T(ClearFlags(this, address, oldEntry, flagsToClear));

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

889

InvalidatePage(address);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

896

X86VMTranslationMapPAE::ClearAccessedAndModified(VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

899

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

902

")\n", address);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

906

fPagingStructures->VirtualPageDirs(), address);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

918

+ address / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

935

T(ClearFlags(this, address, oldEntry,

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

943

T(ClearFlagsUnmap(this, address, oldEntry));

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

952

T(ClearFlags(this, address, oldEntry,

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

964

InvalidatePage(address);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.h

33

virtual status_t UnmapPage(VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.h

54

VMArea* area, addr_t address,

src/system/kernel/arch/x86/paging/x86_physical_page_mapper.h

71

status_t MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

148

virtual status_t MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

184

pool->Map(physicalAddress, address);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

395

invalidate_TLB(slot.slot->address);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

398

return (void*)slot.slot->address;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

411

return (void*)slot.slot->address;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

488

return (void*)slot->address;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

504

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

531

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

557

*virtualAddress = fDebugSlot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

570

LargeMemoryPhysicalPageMapper::MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

573

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

583

slot->Map(address - pageOffset);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

586

memset((void*)(slot->address + pageOffset), value, toSet);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

589

address += toSet;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

620

error = user_memcpy(to, (void*)(slot->address + pageOffset),

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

625

memcpy(to, (void*)(slot->address + pageOffset), toCopy);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

660

error = user_memcpy((void*)(slot->address + pageOffset), from,

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

665

memcpy((void*)(slot->address + pageOffset), from, toCopy);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

695

memcpy((void*)toSlot->address, (void*)fromSlot->address, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.h

37

addr_t address;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_mapped.h

140

X86PhysicalPageMapper::MemsetPhysical(phys_addr_t address, int value,

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_mapped.h

143

if (address >= KERNEL_PMAP_SIZE || address + length > KERNEL_PMAP_SIZE)

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_mapped.h

146

memset((void*)(address + KERNEL_PMAP_BASE), value, length);

src/system/kernel/cache/file_cache.cpp

102

generic_addr_t address, generic_size_t size);

src/system/kernel/cache/file_cache.cpp

246

generic_addr_t address, generic_size_t size)

src/system/kernel/cache/file_cache.cpp

248

if (index > 0 && vecs[index - 1].base + vecs[index - 1].length == address) {

src/system/kernel/cache/file_cache.cpp

258

vecs[index].base = address;

src/system/kernel/cache/vnode_store.cpp

84

generic_addr_t address = vecs[i].base + vecs[i].length - length;

src/system/kernel/cache/vnode_store.cpp

86

vm_memset_physical(address, 0, length);

src/system/kernel/cache/vnode_store.cpp

88

memset((void*)(addr_t)address, 0, length);

src/system/kernel/commpage.cpp

64

clone_commpage_area(team_id team, void** address)

src/system/kernel/commpage.cpp

66

if (*address == NULL)

src/system/kernel/commpage.cpp

67

*address = (void*)KERNEL_USER_DATA_BASE;

src/system/kernel/commpage.cpp

68

return vm_clone_area(team, "commpage", address,

src/system/kernel/condition_variable.cpp

503

addr_t address = parse_expression(argv[1]);

src/system/kernel/condition_variable.cpp

504

if (address == 0)

src/system/kernel/condition_variable.cpp

507

ConditionVariable* variable = sConditionVariableHash.Lookup((void*)address);

src/system/kernel/condition_variable.cpp

511

variable = (ConditionVariable*)address;

src/system/kernel/condition_variable.cpp

520

kprintf("no condition variable at or with key %p\n", (void*)address);

src/system/kernel/cpu.cpp

192

clear_caches(void *address, size_t length, uint32 flags)

src/system/kernel/cpu.cpp

196

arch_cpu_sync_icache(address, length);

src/system/kernel/cpu.cpp

369

_user_clear_caches(void *address, size_t length, uint32 flags)

src/system/kernel/cpu.cpp

371

clear_caches(address, length, flags);

src/system/kernel/debug/BreakpointManager.cpp

101

const addr_t address = (addr_t)_address;

src/system/kernel/debug/BreakpointManager.cpp

109

InstalledBreakpoint* installed = fBreakpoints.Lookup(address);

src/system/kernel/debug/BreakpointManager.cpp

114

installed = new(std::nothrow) InstalledBreakpoint(address);

src/system/kernel/debug/BreakpointManager.cpp

123

status_t error = _InstallHardwareBreakpoint(breakpoint, address);

src/system/kernel/debug/BreakpointManager.cpp

131

status_t error = _InstallSoftwareBreakpoint(installed, address);

src/system/kernel/debug/BreakpointManager.cpp

147

const addr_t address = (addr_t)_address;

src/system/kernel/debug/BreakpointManager.cpp

151

InstalledBreakpoint* installed = fBreakpoints.Lookup(address);

src/system/kernel/debug/BreakpointManager.cpp

171

const addr_t address = (addr_t)_address;

src/system/kernel/debug/BreakpointManager.cpp

175

InstalledWatchpoint* watchpoint = _FindWatchpoint(address);

src/system/kernel/debug/BreakpointManager.cpp

193

status_t error = _InstallWatchpoint(watchpoint, address, type, length);

src/system/kernel/debug/BreakpointManager.cpp

204

BreakpointManager::UninstallWatchpoint(void* address)

src/system/kernel/debug/BreakpointManager.cpp

208

InstalledWatchpoint* watchpoint = _FindWatchpoint((addr_t)address);

src/system/kernel/debug/BreakpointManager.cpp

253

const addr_t address = (addr_t)_address;

src/system/kernel/debug/BreakpointManager.cpp

256

if (IS_USER_ADDRESS(address))

src/system/kernel/debug/BreakpointManager.cpp

282

const addr_t address = (addr_t)_address;

src/system/kernel/debug/BreakpointManager.cpp

286

status_t error = _ReadMemory(address, buffer, size, bytesRead);

src/system/kernel/debug/BreakpointManager.cpp

29

BreakpointManager::InstalledBreakpoint::InstalledBreakpoint(addr_t address)

src/system/kernel/debug/BreakpointManager.cpp

295

= std::max(address, (addr_t)DEBUG_SOFTWARE_BREAKPOINT_SIZE - 1)

src/system/kernel/debug/BreakpointManager.cpp

302

if (breakpoint->address >= address + size)

src/system/kernel/debug/BreakpointManager.cpp

308

addr_t minAddress = std::max(breakpoint->address, address);

src/system/kernel/debug/BreakpointManager.cpp

309

size_t toCopy = std::min(address + size,

src/system/kernel/debug/BreakpointManager.cpp

310

breakpoint->address + DEBUG_SOFTWARE_BREAKPOINT_SIZE)

src/system/kernel/debug/BreakpointManager.cpp

312

memcpy((uint8*)buffer + (minAddress - address),

src/system/kernel/debug/BreakpointManager.cpp

313

breakpoint->softwareData + (minAddress - breakpoint->address),

src/system/kernel/debug/BreakpointManager.cpp

32

address(address)

src/system/kernel/debug/BreakpointManager.cpp

331

addr_t address = (addr_t)_address;

src/system/kernel/debug/BreakpointManager.cpp

344

= std::max(address, (addr_t)DEBUG_SOFTWARE_BREAKPOINT_SIZE - 1)

src/system/kernel/debug/BreakpointManager.cpp

352

if (breakpoint->address >= address)

src/system/kernel/debug/BreakpointManager.cpp

358

size_t toCopy = std::min(address + size,

src/system/kernel/debug/BreakpointManager.cpp

359

breakpoint->address + DEBUG_SOFTWARE_BREAKPOINT_SIZE)

src/system/kernel/debug/BreakpointManager.cpp

360

- address;

src/system/kernel/debug/BreakpointManager.cpp

361

memcpy(breakpoint->softwareData + (address - breakpoint->address),

src/system/kernel/debug/BreakpointManager.cpp

364

address += toCopy;

src/system/kernel/debug/BreakpointManager.cpp

376

if (breakpoint->address >= address + size)

src/system/kernel/debug/BreakpointManager.cpp

381

size_t toCopy = breakpoint->address - address;

src/system/kernel/debug/BreakpointManager.cpp

384

status_t error = _WriteMemory(address, buffer, toCopy,

src/system/kernel/debug/BreakpointManager.cpp

389

address += chunkWritten;

src/system/kernel/debug/BreakpointManager.cpp

402

address += toCopy;

src/system/kernel/debug/BreakpointManager.cpp

414

status_t error = _WriteMemory(address, buffer, size, chunkWritten);

src/system/kernel/debug/BreakpointManager.cpp

428

const addr_t address = (addr_t)_address;

src/system/kernel/debug/BreakpointManager.cpp

433

InstalledBreakpoint* installed = fBreakpoints.Lookup(address);

src/system/kernel/debug/BreakpointManager.cpp

445

status_t error = _InstallHardwareBreakpoint(breakpoint, address);

src/system/kernel/debug/BreakpointManager.cpp

476

breakpoint->installedBreakpoint, breakpoint->address);

src/system/kernel/debug/BreakpointManager.cpp

490

addr_t address)

src/system/kernel/debug/BreakpointManager.cpp

497

breakpoint->address = address;

src/system/kernel/debug/BreakpointManager.cpp

504

status_t error = _ReadMemory(address, breakpoint->softwareData,

src/system/kernel/debug/BreakpointManager.cpp

512

error = _WriteMemory(address, DEBUG_SOFTWARE_BREAKPOINT,

src/system/kernel/debug/BreakpointManager.cpp

521

_WriteMemory(address, breakpoint->softwareData, bytesTransferred,

src/system/kernel/debug/BreakpointManager.cpp

530

TRACE("installed software breakpoint at %#lx\n", address);

src/system/kernel/debug/BreakpointManager.cpp

540

_WriteMemory(breakpoint->address, breakpoint->softwareData,

src/system/kernel/debug/BreakpointManager.cpp

543

TRACE("uninstalled software breakpoint at %#lx\n", breakpoint->address);

src/system/kernel/debug/BreakpointManager.cpp

552

addr_t address)

src/system/kernel/debug/BreakpointManager.cpp

554

status_t error = arch_set_breakpoint((void*)address);

src/system/kernel/debug/BreakpointManager.cpp

562

TRACE("installed hardware breakpoint at %#lx\n", address);

src/system/kernel/debug/BreakpointManager.cpp

564

breakpoint->address = address;

src/system/kernel/debug/BreakpointManager.cpp

573

status_t error = arch_clear_breakpoint((void*)breakpoint->address);

src/system/kernel/debug/BreakpointManager.cpp

577

TRACE("uninstalled hardware breakpoint at %#lx\n", breakpoint->address);

src/system/kernel/debug/BreakpointManager.cpp

586

BreakpointManager::_FindWatchpoint(addr_t address) const

src/system/kernel/debug/BreakpointManager.cpp

590

if (address == watchpoint->address)

src/system/kernel/debug/BreakpointManager.cpp

600

addr_t address, uint32 type, int32 length)

src/system/kernel/debug/BreakpointManager.cpp

611

status_t error = arch_set_watchpoint((void*)address, type, length);

src/system/kernel/debug/BreakpointManager.cpp

615

watchpoint->address = address;

src/system/kernel/debug/BreakpointManager.cpp

632

return arch_clear_watchpoint((void*)watchpoint->address);

src/system/kernel/debug/BreakpointManager.cpp

640

const uint8* address = (const uint8*)_address;

src/system/kernel/debug/BreakpointManager.cpp

644

if (!CanAccessAddress(address, false))

src/system/kernel/debug/BreakpointManager.cpp

655

if (!CanAccessAddress(address, false)) {

src/system/kernel/debug/BreakpointManager.cpp

662

int32 maxRead = B_PAGE_SIZE - (addr_t)address % B_PAGE_SIZE;

src/system/kernel/debug/BreakpointManager.cpp

666

error = user_memcpy(buffer, address, toRead);

src/system/kernel/debug/BreakpointManager.cpp

671

address += toRead;

src/system/kernel/debug/BreakpointManager.cpp

691

uint8* address = (uint8*)_address;

src/system/kernel/debug/BreakpointManager.cpp

695

if (!CanAccessAddress(address, true))

src/system/kernel/debug/BreakpointManager.cpp

706

if (!CanAccessAddress(address, true)) {

src/system/kernel/debug/BreakpointManager.cpp

713

area_id area = _user_area_for(address);

src/system/kernel/debug/BreakpointManager.cpp

716

"address: %p: %lx\n", address, area);

src/system/kernel/debug/BreakpointManager.cpp

732

int32 maxWrite = (uint8*)areaInfo.address + areaInfo.size - address;

src/system/kernel/debug/BreakpointManager.cpp

750

error = user_memcpy(address, buffer, toWrite);

src/system/kernel/debug/BreakpointManager.cpp

763

address += toWrite;

src/system/kernel/debug/BreakpointManager.cpp

86

breakpoint->address = 0;

src/system/kernel/debug/BreakpointManager.h

111

addr_t address);

src/system/kernel/debug/BreakpointManager.h

116

Breakpoint* breakpoint, addr_t address);

src/system/kernel/debug/BreakpointManager.h

120

InstalledWatchpoint* _FindWatchpoint(addr_t address) const;

src/system/kernel/debug/BreakpointManager.h

123

addr_t address, uint32 type, int32 length);

src/system/kernel/debug/BreakpointManager.h

22

status_t InstallBreakpoint(void* address);

src/system/kernel/debug/BreakpointManager.h

23

status_t UninstallBreakpoint(void* address);

src/system/kernel/debug/BreakpointManager.h

25

status_t InstallWatchpoint(void* address, uint32 type,

src/system/kernel/debug/BreakpointManager.h

27

status_t UninstallWatchpoint(void* address);

src/system/kernel/debug/BreakpointManager.h

32

static bool CanAccessAddress(const void* address,

src/system/kernel/debug/BreakpointManager.h

39

void PrepareToContinue(void* address);

src/system/kernel/debug/BreakpointManager.h

45

addr_t address;

src/system/kernel/debug/BreakpointManager.h

58

addr_t address;

src/system/kernel/debug/BreakpointManager.h

60

InstalledBreakpoint(addr_t address);

src/system/kernel/debug/BreakpointManager.h

65

addr_t address;

src/system/kernel/debug/BreakpointManager.h

80

return node->address;

src/system/kernel/debug/BreakpointManager.h

91

if (key < node->address)

src/system/kernel/debug/BreakpointManager.h

93

return key == node->address ? 0 : 1;

src/system/kernel/debug/debug.cpp

1892

debug_is_kernel_memory_accessible(addr_t address, size_t size,

src/system/kernel/debug/debug.cpp

1895

addr_t endAddress = ROUNDUP(address + size, B_PAGE_SIZE);

src/system/kernel/debug/debug.cpp

1896

address = ROUNDDOWN(address, B_PAGE_SIZE);

src/system/kernel/debug/debug.cpp

1898

if (!IS_KERNEL_ADDRESS(address) || endAddress < address)

src/system/kernel/debug/debug.cpp

1901

for (; address < endAddress; address += B_PAGE_SIZE) {

src/system/kernel/debug/debug.cpp

1902

if (!arch_vm_translation_map_is_kernel_page_accessible(address,

src/system/kernel/debug/debug_heap.cpp

122

void Free(void* address)

src/system/kernel/debug/debug_heap.cpp

125

if (((addr_t)address & 7) != 0 || address <= fBase + 1

src/system/kernel/debug/debug_heap.cpp

126

|| address >= fBase + fEnd) {

src/system/kernel/debug/debug_heap.cpp

127

kprintf("DebugAllocPool::Free(%p): bad address\n", address);

src/system/kernel/debug/debug_heap.cpp

132

allocation_header* header = (allocation_header*)address - 1;

src/system/kernel/debug/debug_heap.cpp

135

kprintf("DebugAllocPool::Free(%p): double free\n", address);

src/system/kernel/debug/debug_heap.cpp

295

debug_free(void* address)

src/system/kernel/debug/debug_heap.cpp

297

if (address != NULL && sCurrentPool != NULL)

src/system/kernel/debug/debug_heap.cpp

298

sCurrentPool->Free(address);

src/system/kernel/debug/debug_paranoia.cpp

132

ParanoiaCheck* FindCheck(const void* address) const

src/system/kernel/debug/debug_paranoia.cpp

135

while (check != NULL && check->Address() != address)

src/system/kernel/debug/debug_paranoia.cpp

270

SetCheck(const void* object, const void* address, size_t size,

src/system/kernel/debug/debug_paranoia.cpp

274

fAddress(address),

src/system/kernel/debug/debug_paranoia.cpp

308

RemoveCheck(const void* object, const void* address, size_t size)

src/system/kernel/debug/debug_paranoia.cpp

311

fAddress(address),

src/system/kernel/debug/debug_paranoia.cpp

504

set_paranoia_check(const void* object, const void* address, size_t size,

src/system/kernel/debug/debug_paranoia.cpp

507

T(SetCheck(object, address, size, mode));

src/system/kernel/debug/debug_paranoia.cpp

520

ParanoiaCheck* check = set->FindCheck(address);

src/system/kernel/debug/debug_paranoia.cpp

524

"address %p", object, address);

src/system/kernel/debug/debug_paranoia.cpp

539

"address %p yet", object, address);

src/system/kernel/debug/debug_paranoia.cpp

550

check = new(slot) ParanoiaCheck(address, size);

src/system/kernel/debug/debug_paranoia.cpp

558

remove_paranoia_check(const void* object, const void* address, size_t size)

src/system/kernel/debug/debug_paranoia.cpp

560

T(RemoveCheck(object, address, size));

src/system/kernel/debug/debug_paranoia.cpp

573

ParanoiaCheck* check = set->FindCheck(address);

src/system/kernel/debug/debug_paranoia.cpp

576

"(object %p (%s))", address, object, set->Description());

src/system/kernel/debug/debug_paranoia.cpp

78

ParanoiaCheck(const void* address, size_t size)

src/system/kernel/debug/debug_paranoia.cpp

80

fAddress(address),

src/system/kernel/debug/debug_parser.cpp

1061

const void* address = (const void*)(addr_t)_ParseUnary();

src/system/kernel/debug/debug_parser.cpp

1065

if (debug_memcpy(B_CURRENT_TEAM, &buffer, address, size) != B_OK) {

src/system/kernel/debug/debug_parser.cpp

1067

"failed to dereference address %p", address);

src/system/kernel/debug/debug_parser.cpp

1089

*_address = (void*)address;

src/system/kernel/debug/debug_parser.cpp

148

void* address = debug_malloc(size);

src/system/kernel/debug/debug_parser.cpp

149

if (address == NULL) {

src/system/kernel/debug/debug_parser.cpp

154

return address;

src/system/kernel/debug/debug_parser.cpp

667

void* address;

src/system/kernel/debug/debug_parser.cpp

669

uint64 value = _ParseDereference(&address, &size);

src/system/kernel/debug/debug_parser.cpp

726

if (debug_memcpy(B_CURRENT_TEAM, address, &buffer, size) != B_OK) {

src/system/kernel/debug/debug_parser.cpp

728

"failed to write to address %p", address);

src/system/kernel/debug/gdb.cpp

255

addr_t address;

src/system/kernel/debug/gdb.cpp

262

address = 0;

src/system/kernel/debug/gdb.cpp

265

address <<= 4;

src/system/kernel/debug/gdb.cpp

266

address += parse_nibble(*ptr);

src/system/kernel/debug/gdb.cpp

285

if (debug_memcpy(B_CURRENT_TEAM, sSafeMemory, (char*)address, len)

src/system/kernel/debug/guarded_heap.cpp

212

void* address = NULL;

src/system/kernel/debug/guarded_heap.cpp

215

&restrictions, 0, &address) != B_OK) {

src/system/kernel/debug/guarded_heap.cpp

236

guarded_heap_find_chunk(GuardedHeapChunksTree& tree, addr_t address)

src/system/kernel/debug/guarded_heap.cpp

238

GuardedHeapChunk* chunk = tree.FindClosest((addr_t)address, false, true);

src/system/kernel/debug/guarded_heap.cpp

241

if (address >= chunk->base && address

src/system/kernel/debug/guarded_heap.cpp

403

guarded_heap_free(guarded_heap& heap, void* address, uint32 flags)

src/system/kernel/debug/guarded_heap.cpp

405

if (address == NULL)

src/system/kernel/debug/guarded_heap.cpp

410

GuardedHeapChunk* chunk = guarded_heap_find_chunk(heap.live_chunks, (addr_t)address);

src/system/kernel/debug/guarded_heap.cpp

413

GuardedHeapChunk* deadChunk = guarded_heap_find_chunk(heap.dead_chunks, (addr_t)address);

src/system/kernel/debug/guarded_heap.cpp

414

GuardedHeapChunk* freeChunk = guarded_heap_find_chunk(heap.free_chunks, (addr_t)address);

src/system/kernel/debug/guarded_heap.cpp

418

address, chunk == deadChunk ? "dead" : "free", chunk->team, chunk->thread);

src/system/kernel/debug/guarded_heap.cpp

420

panic("tried to free %p, but can't find a heap chunk for it", address);

src/system/kernel/debug/guarded_heap.cpp

427

if (chunk->allocation_base != (addr_t)address) {

src/system/kernel/debug/guarded_heap.cpp

429

address, (void*)chunk->allocation_base);

src/system/kernel/debug/guarded_heap.cpp

494

guarded_heap_realloc(guarded_heap& heap, void* address, size_t newSize, uint32 flags)

src/system/kernel/debug/guarded_heap.cpp

498

GuardedHeapChunk* chunk = guarded_heap_find_chunk(heap.live_chunks, (addr_t)address);

src/system/kernel/debug/guarded_heap.cpp

500

panic("realloc(%p): no such allocation", address);

src/system/kernel/debug/guarded_heap.cpp

503

if ((addr_t)address != chunk->allocation_base) {

src/system/kernel/debug/guarded_heap.cpp

504

panic("realloc(%p): chunk base is really %p", address,

src/system/kernel/debug/guarded_heap.cpp

512

return address;

src/system/kernel/debug/guarded_heap.cpp

518

memcpy(newBlock, address, min_c(oldSize, newSize));

src/system/kernel/debug/guarded_heap.cpp

520

guarded_heap_free(heap, address, flags);

src/system/kernel/debug/guarded_heap.cpp

543

addr_t address = chunk.stack_trace[i];

src/system/kernel/debug/guarded_heap.cpp

550

if (elf_debug_lookup_symbol_address(address, &baseAddress, &symbol,

src/system/kernel/debug/guarded_heap.cpp

552

kprintf(" %p %s + 0x%lx (%s)%s\n", (void*)address, symbol,

src/system/kernel/debug/guarded_heap.cpp

553

address - baseAddress, imageName,

src/system/kernel/debug/guarded_heap.cpp

556

kprintf(" %p\n", (void*)address);

src/system/kernel/debug/guarded_heap.cpp

570

addr_t address = parse_expression(argv[1]);

src/system/kernel/debug/guarded_heap.cpp

574

GuardedHeapChunk* chunk = guarded_heap_find_chunk(sGuardedHeap.live_chunks, address);

src/system/kernel/debug/guarded_heap.cpp

579

chunk = guarded_heap_find_chunk(sGuardedHeap.free_chunks, address);

src/system/kernel/debug/guarded_heap.cpp

583

chunk = guarded_heap_find_chunk(sGuardedHeap.dead_chunks, address);

src/system/kernel/debug/guarded_heap.cpp

594

kprintf("address %p: %s chunk %p\n", (void*)address, state, chunk);

src/system/kernel/debug/guarded_heap.cpp

635

addr_t address = 0;

src/system/kernel/debug/guarded_heap.cpp

645

address = parse_expression(argv[++i]);

src/system/kernel/debug/guarded_heap.cpp

665

&& (address == 0 || (addr_t)chunk->allocation_base == address)) {

src/system/kernel/debug/guarded_heap.cpp

694

guarded_heap_init(struct kernel_args* args, addr_t address, size_t size)

src/system/kernel/debug/guarded_heap.cpp

713

sGuardedHeapEarlyMetaBase = address;

src/system/kernel/debug/guarded_heap.cpp

714

sGuardedHeapEarlyBase = address + metaSize;

src/system/kernel/debug/guarded_heap.cpp

717

sGuardedHeap.meta_allocator.AddChunk((void*)address, metaSize);

src/system/kernel/debug/guarded_heap.cpp

733

void* address = (void*)sGuardedHeapEarlyMetaBase;

src/system/kernel/debug/guarded_heap.cpp

734

area_id metaAreaId = create_area("guarded heap meta", &address, B_EXACT_ADDRESS,

src/system/kernel/debug/guarded_heap.cpp

739

address = (void*)sGuardedHeapEarlyBase;

src/system/kernel/debug/guarded_heap.cpp

740

area_id areaId = create_area("guarded heap", &address, B_EXACT_ADDRESS,

src/system/kernel/debug/guarded_heap.cpp

743

VMAreas::Lookup(areaId)->cache_offset = (addr_t)address;

src/system/kernel/debug/guarded_heap.cpp

864

guarded_heap_free_etc(void *address, uint32 flags)

src/system/kernel/debug/guarded_heap.cpp

866

guarded_heap_free(sGuardedHeap, address, flags);

src/system/kernel/debug/guarded_heap.cpp

871

guarded_heap_realloc_etc(void* address, size_t newSize, uint32 flags)

src/system/kernel/debug/guarded_heap.cpp

874

guarded_heap_free(sGuardedHeap, address, flags);

src/system/kernel/debug/guarded_heap.cpp

878

if (address == NULL)

src/system/kernel/debug/guarded_heap.cpp

881

return guarded_heap_realloc(sGuardedHeap, address, newSize, flags);

src/system/kernel/debug/heap.cpp

1401

heap_add_leak_check_info(heap_allocator *heap, addr_t address, size_t allocated,

src/system/kernel/debug/heap.cpp

1404

heap_leak_check_info *info = (heap_leak_check_info *)(address + allocated

src/system/kernel/debug/heap.cpp

1429

addr_t address = firstPage->area->base + firstPage->index * heap->page_size;

src/system/kernel/debug/heap.cpp

1431

heap_add_leak_check_info(heap, address, pageCount * heap->page_size, size);

src/system/kernel/debug/heap.cpp

1433

return (void *)address;

src/system/kernel/debug/heap.cpp

1479

void *address = NULL;

src/system/kernel/debug/heap.cpp

1482

address = page->free_list;

src/system/kernel/debug/heap.cpp

1486

address = (void *)(page->area->base + page->index * heap->page_size

src/system/kernel/debug/heap.cpp

1502

heap_add_leak_check_info(heap, (addr_t)address, bin->element_size, size);

src/system/kernel/debug/heap.cpp

1504

return address;

src/system/kernel/debug/heap.cpp

1538

void *address = NULL;

src/system/kernel/debug/heap.cpp

1551

address = heap_allocate_from_bin(heap, i, size);

src/system/kernel/debug/heap.cpp

1558

address = heap_allocate_from_bin(heap, i, size);

src/system/kernel/debug/heap.cpp

1565

if (address == NULL)

src/system/kernel/debug/heap.cpp

1566

address = heap_raw_alloc(heap, size, alignment);

src/system/kernel/debug/heap.cpp

1573

size, address));

src/system/kernel/debug/heap.cpp

1575

T(Allocate((addr_t)address, size));

src/system/kernel/debug/heap.cpp

1576

if (address == NULL)

src/system/kernel/debug/heap.cpp

1577

return address;

src/system/kernel/debug/heap.cpp

1580

memset(address, 0xcc, size);

src/system/kernel/debug/heap.cpp

1586

if (((uint32 *)address)[1] == 0xdeadbeef)

src/system/kernel/debug/heap.cpp

1587

((uint32 *)address)[1] = 0xcccccccc;

src/system/kernel/debug/heap.cpp

1590

return address;

src/system/kernel/debug/heap.cpp

1595

heap_free(heap_allocator *heap, void *address)

src/system/kernel/debug/heap.cpp

1597

if (address == NULL)

src/system/kernel/debug/heap.cpp

1606

if (area->base <= (addr_t)address) {

src/system/kernel/debug/heap.cpp

1607

if ((addr_t)address >= area->base + area->size) {

src/system/kernel/debug/heap.cpp

1625

TRACE(("free(): asked to free pointer %p\n", address));

src/system/kernel/debug/heap.cpp

1627

heap_page *page = &area->page_table[((addr_t)address - area->base)

src/system/kernel/debug/heap.cpp

1643

if (((uint32 *)address)[1] == 0xdeadbeef) {

src/system/kernel/debug/heap.cpp

1649

if (temp == address) {

src/system/kernel/debug/heap.cpp

1651

"list\n", address);

src/system/kernel/debug/heap.cpp

1659

uint32 *dead = (uint32 *)address;

src/system/kernel/debug/heap.cpp

1665

if (((addr_t)address - area->base - page->index

src/system/kernel/debug/heap.cpp

1668

"element size %" B_PRIu32 "\n", address, bin->element_size);

src/system/kernel/debug/heap.cpp

1673

*(addr_t *)address = (addr_t)page->free_list;

src/system/kernel/debug/heap.cpp

1674

page->free_list = (addr_t *)address;

src/system/kernel/debug/heap.cpp

1730

T(Free((addr_t)address));

src/system/kernel/debug/heap.cpp

1774

heap_realloc(heap_allocator *heap, void *address, void **newAddress,

src/system/kernel/debug/heap.cpp

1784

if (area->base <= (addr_t)address) {

src/system/kernel/debug/heap.cpp

1785

if ((addr_t)address >= area->base + area->size) {

src/system/kernel/debug/heap.cpp

1803

TRACE(("realloc(address = %p, newSize = %lu)\n", address, newSize));

src/system/kernel/debug/heap.cpp

1805

heap_page *page = &area->page_table[((addr_t)address - area->base)

src/system/kernel/debug/heap.cpp

1849

heap_leak_check_info *info = (heap_leak_check_info *)((addr_t)address

src/system/kernel/debug/heap.cpp

1855

T(Reallocate((addr_t)address, (addr_t)address, newSize));

src/system/kernel/debug/heap.cpp

1856

*newAddress = address;

src/system/kernel/debug/heap.cpp

1867

T(Reallocate((addr_t)address, (addr_t)*newAddress, newSize));

src/system/kernel/debug/heap.cpp

1874

memcpy(*newAddress, address, min_c(maxSize, newSize));

src/system/kernel/debug/heap.cpp

1875

heap_free(heap, address);

src/system/kernel/debug/heap.cpp

1942

void *address = NULL;

src/system/kernel/debug/heap.cpp

1943

area_id heapArea = create_area(name, &address,

src/system/kernel/debug/heap.cpp

1951

heap_add_area(heap, heapArea, (addr_t)address, size);

src/system/kernel/debug/heap.cpp

2064

void *address = NULL;

src/system/kernel/debug/heap.cpp

2065

area_id growHeapArea = create_area("dedicated grow heap", &address,

src/system/kernel/debug/heap.cpp

2074

sGrowHeap = heap_create_allocator("grow", (addr_t)address,

src/system/kernel/debug/heap.cpp

2093

area_id vipHeapArea = create_area("VIP heap", &address,

src/system/kernel/debug/heap.cpp

2101

sVIPHeap = heap_create_allocator("VIP heap", (addr_t)address,

src/system/kernel/debug/heap.cpp

220

Allocate(addr_t address, size_t size)

src/system/kernel/debug/heap.cpp

2208

void *address = NULL;

src/system/kernel/debug/heap.cpp

2209

area_id allocationArea = create_area("memalign area", &address,

src/system/kernel/debug/heap.cpp

221

: fAddress(address),

src/system/kernel/debug/heap.cpp

2217

area_allocation_info *info = (area_allocation_info *)address;

src/system/kernel/debug/heap.cpp

2220

info->base = address;

src/system/kernel/debug/heap.cpp

2225

address = (void *)((addr_t)address + sizeof(area_allocation_info));

src/system/kernel/debug/heap.cpp

2227

address = (void *)ROUNDUP((addr_t)address, alignment);

src/system/kernel/debug/heap.cpp

2228

ASSERT((addr_t)address % alignment == 0);

src/system/kernel/debug/heap.cpp

2229

ASSERT((addr_t)address + size - 1 < (addr_t)info + areaSize - 1);

src/system/kernel/debug/heap.cpp

2235

info->allocation_base = address;

src/system/kernel/debug/heap.cpp

2238

memset(address, 0xcc, size);

src/system/kernel/debug/heap.cpp

2240

return address;

src/system/kernel/debug/heap.cpp

2300

debug_heap_free(void *address)

src/system/kernel/debug/heap.cpp

2310

if (heap_free(heap, address) == B_OK) {

src/system/kernel/debug/heap.cpp

2319

if (heap_free(sGrowHeap, address) == B_OK)

src/system/kernel/debug/heap.cpp

2323

if (heap_free(sVIPHeap, address) == B_OK)

src/system/kernel/debug/heap.cpp

2328

area_id area = area_for(address);

src/system/kernel/debug/heap.cpp

2330

area_allocation_info *info = (area_allocation_info *)areaInfo.address;

src/system/kernel/debug/heap.cpp

2334

&& info->size == areaInfo.size && info->base == areaInfo.address

src/system/kernel/debug/heap.cpp

2343

panic("free(): free failed for address %p\n", address);

src/system/kernel/debug/heap.cpp

2348

debug_heap_free_etc(void *address, uint32 flags)

src/system/kernel/debug/heap.cpp

2351

heap_free(sVIPHeap, address);

src/system/kernel/debug/heap.cpp

2353

debug_heap_free(address);

src/system/kernel/debug/heap.cpp

2358

debug_heap_realloc(void *address, size_t newSize, uint32 flags)

src/system/kernel/debug/heap.cpp

2365

if (address == NULL)

src/system/kernel/debug/heap.cpp

2369

debug_heap_free_etc(address, flags);

src/system/kernel/debug/heap.cpp

2377

if (heap_realloc(heap, address, &newAddress, newSize, flags) == B_OK) {

src/system/kernel/debug/heap.cpp

2386

if (heap_realloc(sGrowHeap, address, &newAddress, newSize, flags) == B_OK)

src/system/kernel/debug/heap.cpp

2391

area_id area = area_for(address);

src/system/kernel/debug/heap.cpp

2393

area_allocation_info *info = (area_allocation_info *)areaInfo.address;

src/system/kernel/debug/heap.cpp

2397

&& info->size == areaInfo.size && info->base == areaInfo.address

src/system/kernel/debug/heap.cpp

2407

return address;

src/system/kernel/debug/heap.cpp

2418

memcpy(newAddress, address, min_c(newSize, info->allocation_size));

src/system/kernel/debug/heap.cpp

2426

panic("realloc(): failed to realloc address %p to size %lu\n", address,

src/system/kernel/debug/heap.cpp

263

Free(addr_t address)

src/system/kernel/debug/heap.cpp

264

: fAddress(address)

src/system/kernel/debug/heap.cpp

542

addr_t address = 0;

src/system/kernel/debug/heap.cpp

553

address = parse_expression(argv[++i]);

src/system/kernel/debug/heap.cpp

603

&& (address == 0 || base == address)) {

src/system/kernel/debug/heap.cpp

633

&& (address == 0 || base == address)) {

src/system/kernel/debug/heaps.cpp

276

free_etc(void* address, uint32 flags)

src/system/kernel/debug/heaps.cpp

278

return sActiveHeaps[0]->free(address, flags);

src/system/kernel/debug/heaps.cpp

283

free(void *address)

src/system/kernel/debug/heaps.cpp

285

return sActiveHeaps[0]->free(address, 0);

src/system/kernel/debug/heaps.cpp

297

realloc_etc(void* address, size_t newSize, uint32 flags)

src/system/kernel/debug/heaps.cpp

299

return sActiveHeaps[0]->realloc(address, newSize, flags);

src/system/kernel/debug/heaps.cpp

304

realloc(void *address, size_t newSize)

src/system/kernel/debug/heaps.cpp

306

return sActiveHeaps[0]->realloc(address, newSize, 0);

src/system/kernel/debug/heaps.h

23

void* (*realloc)(void* address, size_t newSize, uint32 flags);

src/system/kernel/debug/heaps.h

24

void (*free)(void* address, uint32 flags);

src/system/kernel/debug/system_profiler.cpp

1498

void* address;

src/system/kernel/debug/system_profiler.cpp

1499

area_id area = create_area("kernel profile data", &address,

src/system/kernel/debug/system_profiler.cpp

1711

void* address;

src/system/kernel/debug/system_profiler.cpp

1712

area_id newArea = transfer_area(sRecordedParameters->buffer_area, &address,

src/system/kernel/debug/tracing.cpp

105

bool IsInBuffer(void* address, size_t size);

src/system/kernel/debug/tracing.cpp

150

addr_t address = stackTrace->return_addresses[i];

src/system/kernel/debug/tracing.cpp

158

if (elf_debug_lookup_symbol_address(address, &baseAddress, &symbol,

src/system/kernel/debug/tracing.cpp

167

print(" %p %s + 0x%lx (%s)%s\n", (void*)address,

src/system/kernel/debug/tracing.cpp

169

address - baseAddress, imageName,

src/system/kernel/debug/tracing.cpp

172

print(" %p\n", (void*)address);

src/system/kernel/debug/tracing.cpp

308

TracingMetaData::IsInBuffer(void* address, size_t size)

src/system/kernel/debug/tracing.cpp

313

addr_t start = (addr_t)address;

src/system/kernel/debug/tracing.cpp

465

metaData->fPhysicalAddress = physicalEntry.address;

src/system/kernel/debug/tracing.cpp

570

virtualRestrictions.address = fTraceOutputBuffer;

src/system/kernel/debug/user_debugger.cpp

1230

unlock_memory(areaInfo.address, areaInfo.size, B_READ_DEVICE);

src/system/kernel/debug/user_debugger.cpp

1778

void *address = message.read_memory.address;

src/system/kernel/debug/user_debugger.cpp

1783

if (!BreakpointManager::CanAccessAddress(address, false))

src/system/kernel/debug/user_debugger.cpp

1791

result = breakpointManager->ReadMemory(address,

src/system/kernel/debug/user_debugger.cpp

1799

replyPort, address, size, result, bytesRead));

src/system/kernel/debug/user_debugger.cpp

1812

void *address = message.write_memory.address;

src/system/kernel/debug/user_debugger.cpp

1819

if (!BreakpointManager::CanAccessAddress(address, true))

src/system/kernel/debug/user_debugger.cpp

1827

result = breakpointManager->WriteMemory(address, data, size,

src/system/kernel/debug/user_debugger.cpp

1835

replyPort, address, size, result, bytesWritten));

src/system/kernel/debug/user_debugger.cpp

1847

const void *address = message.clone_area.address;

src/system/kernel/debug/user_debugger.cpp

1851

if (!IS_USER_ADDRESS(address))

src/system/kernel/debug/user_debugger.cpp

1858

sourceArea = _user_area_for((void*)address);

src/system/kernel/debug/user_debugger.cpp

1864

addressOffset = (addr_t)address - (addr_t)info.address;

src/system/kernel/debug/user_debugger.cpp

1874

reply.clone_area.address = (void*)((addr_t)newAddress + addressOffset);

src/system/kernel/debug/user_debugger.cpp

1881

nubThread->id, replyPort, address, result));

src/system/kernel/debug/user_debugger.cpp

2054

void *address = message.set_breakpoint.address;

src/system/kernel/debug/user_debugger.cpp

2057

": address: %p\n", nubThread->id, address));

src/system/kernel/debug/user_debugger.cpp

2061

if (address == NULL

src/system/kernel/debug/user_debugger.cpp

2062

|| !BreakpointManager::CanAccessAddress(address, false)) {

src/system/kernel/debug/user_debugger.cpp

2068

result = breakpointManager->InstallBreakpoint(address);

src/system/kernel/debug/user_debugger.cpp

2084

void *address = message.clear_breakpoint.address;

src/system/kernel/debug/user_debugger.cpp

2087

": address: %p\n", nubThread->id, address));

src/system/kernel/debug/user_debugger.cpp

2091

if (address == NULL

src/system/kernel/debug/user_debugger.cpp

2092

|| !BreakpointManager::CanAccessAddress(address, false)) {

src/system/kernel/debug/user_debugger.cpp

2098

result = breakpointManager->UninstallBreakpoint(address);

src/system/kernel/debug/user_debugger.cpp

2110

void *address = message.set_watchpoint.address;

src/system/kernel/debug/user_debugger.cpp

2116

nubThread->id, address, type, length));

src/system/kernel/debug/user_debugger.cpp

2120

if (address == NULL

src/system/kernel/debug/user_debugger.cpp

2121

|| !BreakpointManager::CanAccessAddress(address, false)) {

src/system/kernel/debug/user_debugger.cpp

2129

result = breakpointManager->InstallWatchpoint(address, type,

src/system/kernel/debug/user_debugger.cpp

2147

void *address = message.clear_watchpoint.address;

src/system/kernel/debug/user_debugger.cpp

2150

": address: %p\n", nubThread->id, address));

src/system/kernel/debug/user_debugger.cpp

2154

if (address == NULL

src/system/kernel/debug/user_debugger.cpp

2155

|| !BreakpointManager::CanAccessAddress(address, false)) {

src/system/kernel/debug/user_debugger.cpp

2161

result = breakpointManager->UninstallWatchpoint(address);

src/system/kernel/debug/user_debugger.cpp

3105

_user_set_debugger_breakpoint(void *address, uint32 type, int32 length,

src/system/kernel/debug/user_debugger.cpp

3109

if (address == NULL || !BreakpointManager::CanAccessAddress(address, false))

src/system/kernel/debug/user_debugger.cpp

3127

result = arch_set_watchpoint(address, type, length);

src/system/kernel/debug/user_debugger.cpp

3129

result = arch_set_breakpoint(address);

src/system/kernel/debug/user_debugger.cpp

3139

_user_clear_debugger_breakpoint(void *address, bool watchpoint)

src/system/kernel/debug/user_debugger.cpp

3142

if (address == NULL || !BreakpointManager::CanAccessAddress(address, false))

src/system/kernel/debug/user_debugger.cpp

3158

result = arch_clear_watchpoint(address);

src/system/kernel/debug/user_debugger.cpp

3160

result = arch_clear_breakpoint(address);

src/system/kernel/debug/user_debugger.cpp

360

unlock_memory(areaInfo.address, areaInfo.size, B_READ_DEVICE);

src/system/kernel/device_manager/IOCache.cpp

684

addr_t address;

src/system/kernel/device_manager/IOCache.cpp

686

fPages[i]->physical_page_number * B_PAGE_SIZE, &address,

src/system/kernel/device_manager/IOCache.cpp

695

error = request->CopyData((uint8*)(address + inPageOffset),

src/system/kernel/device_manager/IOCache.cpp

699

(uint8*)(address + inPageOffset), toCopy);

src/system/kernel/device_manager/IOCache.cpp

703

vm_put_physical_page(address, handle);

src/system/kernel/device_manager/IORequest.cpp

1378

error = _CopyPhysical(bounceBuffer, entry.address, entry.size, team,

src/system/kernel/device_manager/IORequest.cpp

1431

error = _ClearDataPhysical(entry.address, entry.size, team);

src/system/kernel/device_manager/IORequest.cpp

190

const generic_addr_t address = currentVec.base + cookie->vec_offset;

src/system/kernel/device_manager/IORequest.cpp

191

const size_t pageOffset = address % B_PAGE_SIZE;

src/system/kernel/device_manager/IORequest.cpp

195

status_t result = vm_get_physical_page(address - pageOffset,

src/system/kernel/device_manager/devfs.cpp

878

uint64 address;

src/system/kernel/device_manager/devfs.cpp

879

if (!evaluate_debug_expression(argv[1], &address, false))

src/system/kernel/device_manager/devfs.cpp

882

struct devfs_cookie* cookie = (devfs_cookie*)(addr_t)address;

src/system/kernel/device_manager/dma_resources.cpp

268

physicalBase = entry.address;

src/system/kernel/device_manager/dma_resources.cpp

278

buffer->address = bounceBuffer;

src/system/kernel/device_manager/dma_resources.cpp

466

vecs[segmentCount].base = entry.address;

src/system/kernel/device_manager/dma_resources.cpp

80

fBounceBuffer->address, fBounceBuffer->physical_address);

src/system/kernel/device_manager/dma_resources.h

37

void* address;

src/system/kernel/device_manager/dma_resources.h

63

? fBounceBuffer->address : NULL; }

src/system/kernel/disk_device_manager/UserDataWriter.cpp

125

UserDataWriter::AddRelocationEntry(void *address)

src/system/kernel/disk_device_manager/UserDataWriter.cpp

127

if (fRelocationEntries && (addr_t)address >= (addr_t)fBuffer

src/system/kernel/disk_device_manager/UserDataWriter.cpp

128

&& (addr_t)address < (addr_t)fBuffer + fBufferSize - sizeof(void*)) {

src/system/kernel/disk_device_manager/UserDataWriter.cpp

129

return fRelocationEntries->PushBack((addr_t*)address);

src/system/kernel/disk_device_manager/UserDataWriter.cpp

136

UserDataWriter::Relocate(void *address)

src/system/kernel/disk_device_manager/UserDataWriter.cpp

144

*entry += (addr_t)address - (addr_t)fBuffer;

src/system/kernel/disk_device_manager/UserDataWriter.h

31

status_t AddRelocationEntry(void *address);

src/system/kernel/disk_device_manager/UserDataWriter.h

32

status_t Relocate(void *address);

src/system/kernel/elf.cpp

1364

status_t LookupSymbolAddress(addr_t address, addr_t *_baseAddress,

src/system/kernel/elf.cpp

1378

status_t error = _FindImageAtAddress(address, image);

src/system/kernel/elf.cpp

1387

address -= (addr_t)fTeam->commpage_address;

src/system/kernel/elf.cpp

1388

error = elf_debug_lookup_symbol_address(address, _baseAddress,

src/system/kernel/elf.cpp

1448

if (symbolAddress > address)

src/system/kernel/elf.cpp

1450

addr_t symbolDelta = address - symbolAddress;

src/system/kernel/elf.cpp

1495

status_t _FindImageAtAddress(addr_t address, struct image*& _image)

src/system/kernel/elf.cpp

1501

if ((address < (addr_t)info->text

src/system/kernel/elf.cpp

1502

|| address >= (addr_t)info->text + info->text_size)

src/system/kernel/elf.cpp

1503

&& (address < (addr_t)info->data

src/system/kernel/elf.cpp

1504

|| address >= (addr_t)info->data + info->data_size))

src/system/kernel/elf.cpp

1518

const char* address = (char *)info.string_table + offset;

src/system/kernel/elf.cpp

1520

if (!IS_USER_ADDRESS(address))

src/system/kernel/elf.cpp

1524

return debug_strlcpy(B_CURRENT_TEAM, buffer, address, bufferSize)

src/system/kernel/elf.cpp

1527

return user_strlcpy(buffer, address, bufferSize) >= 0;

src/system/kernel/elf.cpp

1530

template<typename T> bool _Read(const T* address, T& data);

src/system/kernel/elf.cpp

1543

UserSymbolLookup::_Read(const T* address, T& data)

src/system/kernel/elf.cpp

1545

if (!IS_USER_ADDRESS(address))

src/system/kernel/elf.cpp

1549

return debug_memcpy(B_CURRENT_TEAM, &data, address, sizeof(T)) == B_OK;

src/system/kernel/elf.cpp

1550

return user_memcpy(&data, address, sizeof(T)) == B_OK;

src/system/kernel/elf.cpp

1607

elf_debug_lookup_symbol_address(addr_t address, addr_t *_baseAddress,

src/system/kernel/elf.cpp

1617

TRACE(("looking up %p\n", (void *)address));

src/system/kernel/elf.cpp

1624

image = find_image_at_address(address);

src/system/kernel/elf.cpp

1648

= address - (symbol->st_value + image->text_region.delta);

src/system/kernel/elf.cpp

1676

symbolDelta = address - (long)(symbol->st_value

src/system/kernel/elf.cpp

1738

elf_debug_lookup_user_symbol_address(Team* team, addr_t address,

src/system/kernel/elf.cpp

1750

return lookup.LookupSymbolAddress(address, _baseAddress, _symbolName,

src/system/kernel/elf.cpp

179

find_image_at_address(addr_t address)

src/system/kernel/elf.cpp

1802

info->address = foundSymbol->st_value + sKernelImage->text_region.delta;

src/system/kernel/elf.cpp

192

if ((address >= image->text_region.start && address

src/system/kernel/elf.cpp

194

|| (address >= image->data_region.start

src/system/kernel/elf.cpp

195

&& address

src/system/kernel/elf.cpp

1991

virtualRestrictions.address = regionAddress;

src/system/kernel/elf.cpp

209

addr_t address, baseAddress;

src/system/kernel/elf.cpp

216

address = strtoul(argv[1], NULL, 16);

src/system/kernel/elf.cpp

220

if (IS_KERNEL_ADDRESS(address)) {

src/system/kernel/elf.cpp

221

error = elf_debug_lookup_symbol_address(address, &baseAddress, &symbol,

src/system/kernel/elf.cpp

225

debug_get_debugged_thread()->team, address, &baseAddress, &symbol,

src/system/kernel/elf.cpp

230

kprintf("%p = %s + 0x%lx (%s)%s\n", (void*)address, symbol,

src/system/kernel/elf.cpp

231

address - baseAddress, imageName, exactMatch ? "" : " (nearest)");

src/system/kernel/elf.cpp

2431

elf_get_image_info_for_address(addr_t address, image_info* info)

src/system/kernel/elf.cpp

2434

struct elf_image_info* elfInfo = find_image_at_address(address);

src/system/kernel/elf.cpp

2515

elf_add_memory_image_symbol(image_id id, const char* name, addr_t address,

src/system/kernel/elf.cpp

2566

symbol.st_value = address;

src/system/kernel/fs/socket.cpp

1006

char address[MAX_SOCKET_ADDRESS_LENGTH] = {};

src/system/kernel/fs/socket.cpp

1008

userAddress != NULL ? (sockaddr*)address : NULL, &addressLength, false);

src/system/kernel/fs/socket.cpp

1013

if (copy_address_to_userland(address, addressLength, userAddress,

src/system/kernel/fs/socket.cpp

102

sockaddr_storage* address)

src/system/kernel/fs/socket.cpp

1030

char address[MAX_SOCKET_ADDRESS_LENGTH];

src/system/kernel/fs/socket.cpp

1033

vecsDeleter, userAddress, address);

src/system/kernel/fs/socket.cpp

1067

if ((userAddress != NULL && user_memcpy(userAddress, address,

src/system/kernel/fs/socket.cpp

107

*address = {};

src/system/kernel/fs/socket.cpp

109

|| user_memcpy(address, userAddress, addressLength) != B_OK) {

src/system/kernel/fs/socket.cpp

1098

sockaddr_storage address;

src/system/kernel/fs/socket.cpp

1100

status_t error = copy_address_from_userland(userAddress, addressLength, &address);

src/system/kernel/fs/socket.cpp

1110

userAddress != NULL ? (sockaddr*)&address : NULL, addressLength, false);

src/system/kernel/fs/socket.cpp

1122

char address[MAX_SOCKET_ADDRESS_LENGTH];

src/system/kernel/fs/socket.cpp

1125

vecsDeleter, userAddress, address);

src/system/kernel/fs/socket.cpp

113

address->ss_len = addressLength;

src/system/kernel/fs/socket.cpp

1131

&& user_memcpy(address, userAddress, message.msg_namelen) != B_OK) {

src/system/kernel/fs/socket.cpp

1233

char address[MAX_SOCKET_ADDRESS_LENGTH] = {};

src/system/kernel/fs/socket.cpp

1234

error = common_getpeername(socket, (sockaddr*)address, &addressLength,

src/system/kernel/fs/socket.cpp

1240

if (copy_address_to_userland(address, addressLength, userAddress,

src/system/kernel/fs/socket.cpp

1263

char address[MAX_SOCKET_ADDRESS_LENGTH] = {};

src/system/kernel/fs/socket.cpp

1264

error = common_getsockname(socket, (sockaddr*)address, &addressLength,

src/system/kernel/fs/socket.cpp

1270

if (copy_address_to_userland(address, addressLength, userAddress,

src/system/kernel/fs/socket.cpp

156

copy_address_to_userland(const void* address, socklen_t addressLength,

src/system/kernel/fs/socket.cpp

164

&& (!IS_USER_ADDRESS(userAddress) || user_memcpy(userAddress, address,

src/system/kernel/fs/socket.cpp

176

char* address)

src/system/kernel/fs/socket.cpp

216

memset(address, 0, MAX_SOCKET_ADDRESS_LENGTH);

src/system/kernel/fs/socket.cpp

217

message.msg_name = address;

src/system/kernel/fs/socket.cpp

466

common_bind(int fd, const struct sockaddr *address, socklen_t addressLength,

src/system/kernel/fs/socket.cpp

473

return sStackInterface->bind(FD_SOCKET(descriptor), address, addressLength);

src/system/kernel/fs/socket.cpp

492

common_connect(int fd, const struct sockaddr *address,

src/system/kernel/fs/socket.cpp

499

return sStackInterface->connect(FD_SOCKET(descriptor), address,

src/system/kernel/fs/socket.cpp

516

common_accept(int fd, struct sockaddr *address, socklen_t *_addressLength, int flags,

src/system/kernel/fs/socket.cpp

527

status_t error = sStackInterface->accept(FD_SOCKET(descriptor), address,

src/system/kernel/fs/socket.cpp

559

struct sockaddr *address, socklen_t *_addressLength, bool kernel)

src/system/kernel/fs/socket.cpp

566

flags, address, _addressLength);

src/system/kernel/fs/socket.cpp

594

const struct sockaddr *address, socklen_t addressLength, bool kernel)

src/system/kernel/fs/socket.cpp

601

address, addressLength);

src/system/kernel/fs/socket.cpp

643

common_getpeername(int fd, struct sockaddr *address,

src/system/kernel/fs/socket.cpp

650

return sStackInterface->getpeername(FD_SOCKET(descriptor), address,

src/system/kernel/fs/socket.cpp

656

common_getsockname(int fd, struct sockaddr *address,

src/system/kernel/fs/socket.cpp

663

return sStackInterface->getsockname(FD_SOCKET(descriptor), address,

src/system/kernel/fs/socket.cpp

739

bind(int socket, const struct sockaddr *address, socklen_t addressLength)

src/system/kernel/fs/socket.cpp

742

RETURN_AND_SET_ERRNO(common_bind(socket, address, addressLength, true));

src/system/kernel/fs/socket.cpp

755

connect(int socket, const struct sockaddr *address, socklen_t addressLength)

src/system/kernel/fs/socket.cpp

758

RETURN_AND_SET_ERRNO(common_connect(socket, address, addressLength, true));

src/system/kernel/fs/socket.cpp

771

accept(int socket, struct sockaddr *address, socklen_t *_addressLength)

src/system/kernel/fs/socket.cpp

774

RETURN_AND_SET_ERRNO(common_accept(socket, address, _addressLength, 0, true));

src/system/kernel/fs/socket.cpp

779

accept4(int socket, struct sockaddr *address, socklen_t *_addressLength, int flags)

src/system/kernel/fs/socket.cpp

782

RETURN_AND_SET_ERRNO(common_accept(socket, address, _addressLength, flags, true));

src/system/kernel/fs/socket.cpp

796

struct sockaddr *address, socklen_t *_addressLength)

src/system/kernel/fs/socket.cpp

799

RETURN_AND_SET_ERRNO(common_recvfrom(socket, data, length, flags, address,

src/system/kernel/fs/socket.cpp

822

const struct sockaddr *address, socklen_t addressLength)

src/system/kernel/fs/socket.cpp

825

RETURN_AND_SET_ERRNO(common_sendto(socket, data, length, flags, address,

src/system/kernel/fs/socket.cpp

858

getpeername(int socket, struct sockaddr *address, socklen_t *_addressLength)

src/system/kernel/fs/socket.cpp

861

RETURN_AND_SET_ERRNO(common_getpeername(socket, address, _addressLength,

src/system/kernel/fs/socket.cpp

867

getsockname(int socket, struct sockaddr *address, socklen_t *_addressLength)

src/system/kernel/fs/socket.cpp

870

RETURN_AND_SET_ERRNO(common_getsockname(socket, address, _addressLength,

src/system/kernel/fs/socket.cpp

907

sockaddr_storage address;

src/system/kernel/fs/socket.cpp

908

status_t error = copy_address_from_userland(userAddress, addressLength, &address);

src/system/kernel/fs/socket.cpp

913

return result = common_bind(socket, (sockaddr*)&address, addressLength,

src/system/kernel/fs/socket.cpp

930

sockaddr_storage address;

src/system/kernel/fs/socket.cpp

931

status_t error = copy_address_from_userland(userAddress, addressLength, &address);

src/system/kernel/fs/socket.cpp

936

return result = common_connect(socket, (sockaddr*)&address, addressLength,

src/system/kernel/fs/socket.cpp

963

char address[MAX_SOCKET_ADDRESS_LENGTH] = {};

src/system/kernel/fs/socket.cpp

965

userAddress != NULL ? (sockaddr*)address : NULL, &addressLength, flags, false);

src/system/kernel/fs/socket.cpp

968

if (copy_address_to_userland(address, addressLength, userAddress,

src/system/kernel/fs/vfs_net_boot.cpp

232

sockaddr_in& address = *(sockaddr_in*)&request.ifr_addr;

src/system/kernel/fs/vfs_net_boot.cpp

233

address.sin_family = AF_INET;

src/system/kernel/fs/vfs_net_boot.cpp

234

address.sin_len = sizeof(sockaddr_in);

src/system/kernel/fs/vfs_net_boot.cpp

235

address.sin_port = 0;

src/system/kernel/fs/vfs_net_boot.cpp

236

address.sin_addr.s_addr = htonl(fClientIP);

src/system/kernel/fs/vfs_net_boot.cpp

237

memset(&address.sin_zero[0], 0, sizeof(address.sin_zero));

src/system/kernel/fs/vfs_net_boot.cpp

245

address.sin_addr.s_addr = htonl(fNetMask);

src/system/kernel/fs/vfs_net_boot.cpp

253

address.sin_addr.s_addr = htonl(fClientIP | ~fNetMask);

src/system/kernel/heap.cpp

33

void *address = malloc(numElements * size);

src/system/kernel/heap.cpp

34

if (address != NULL)

src/system/kernel/heap.cpp

35

memset(address, 0, numElements * size);

src/system/kernel/heap.cpp

37

return address;

src/system/kernel/locks/user_mutex.cpp

184

const bool physical = (sSharedUserMutexContext.table.Lookup(entry->address) == entry);

src/system/kernel/locks/user_mutex.cpp

186

kprintf(" address: 0x%" B_PRIxPHYSADDR " (%s)\n", entry->address,

src/system/kernel/locks/user_mutex.cpp

195

(void*)entry->address, sizeof(mutex));

src/system/kernel/locks/user_mutex.cpp

259

generic_addr_t address, bool noInsert = false, bool alreadyLocked = false)

src/system/kernel/locks/user_mutex.cpp

265

UserMutexEntry* entry = context->table.Lookup(address);

src/system/kernel/locks/user_mutex.cpp

275

entry = context->table.Lookup(address);

src/system/kernel/locks/user_mutex.cpp

287

entry->address = address;

src/system/kernel/locks/user_mutex.cpp

303

const generic_addr_t address = entry->address;

src/system/kernel/locks/user_mutex.cpp

310

if (context->table.Lookup(address) != entry)

src/system/kernel/locks/user_mutex.cpp

34

generic_addr_t address;

src/system/kernel/locks/user_mutex.cpp

53

return HashKey(value->address);

src/system/kernel/locks/user_mutex.cpp

58

return value->address == key;

src/system/kernel/messaging/KMessage.cpp

1007

*address = (char*)fBuffer + offset;

src/system/kernel/messaging/KMessage.cpp

69

_Align(void* address, int32 offset = 0)

src/system/kernel/messaging/KMessage.cpp

71

return (void*)(((addr_t)address + offset + kMessageBufferAlignment - 1)

src/system/kernel/messaging/KMessage.cpp

793

void* address;

src/system/kernel/messaging/KMessage.cpp

796

(fieldHeader->elementCount == 0), false, &address, &alignedSize);

src/system/kernel/messaging/KMessage.cpp

800

memcpy(address, data, elementSize * elementCount);

src/system/kernel/messaging/KMessage.cpp

802

fieldHeader->fieldSize = (uint8*)address + alignedSize

src/system/kernel/messaging/KMessage.cpp

811

void* address;

src/system/kernel/messaging/KMessage.cpp

813

status_t error = _AllocateSpace(entrySize, true, false, &address,

src/system/kernel/messaging/KMessage.cpp

818

FieldValueHeader* valueHeader = (FieldValueHeader*)address;

src/system/kernel/messaging/KMessage.cpp

823

fieldHeader->fieldSize = (uint8*)address + alignedSize

src/system/kernel/messaging/KMessage.cpp

964

void** address, int32* alignedSize)

src/system/kernel/platform/openfirmware/openfirmware.cpp

560

void *address;

src/system/kernel/platform/openfirmware/openfirmware.cpp

566

return args.address;

src/system/kernel/scheduler/scheduling_analysis.cpp

252

void* address = fNextAllocation;

src/system/kernel/scheduler/scheduling_analysis.cpp

255

return address;

src/system/kernel/scheduler/scheduling_analysis.cpp

551

addr_t address = (addr_t)_address;

src/system/kernel/scheduler/scheduling_analysis.cpp

552

return address >= fKernelStart && address < fKernelEnd;

src/system/kernel/signal.cpp

1328

signal_get_user_stack(addr_t address, stack_t* stack)

src/system/kernel/signal.cpp

1334

if (thread->signal_stack_enabled && address >= thread->signal_stack_base

src/system/kernel/signal.cpp

1335

&& address < thread->signal_stack_base + thread->signal_stack_size) {

src/system/kernel/slab/MemoryManager.cpp

108

Free(void* address, uint32 flags)

src/system/kernel/slab/MemoryManager.cpp

111

fAddress(address),

src/system/kernel/slab/MemoryManager.cpp

1486

MemoryManager::_MapChunk(VMArea* vmArea, addr_t address, size_t size,

src/system/kernel/slab/MemoryManager.cpp

1490

")\n", vmArea, address, size);

src/system/kernel/slab/MemoryManager.cpp

1492

T(Map(address, size, flags));

src/system/kernel/slab/MemoryManager.cpp

1513

+ translationMap->MaxPagesNeededToMap(address, address + size - 1);

src/system/kernel/slab/MemoryManager.cpp

1528

addr_t areaOffset = address - vmArea->Base();

src/system/kernel/slab/MemoryManager.cpp

154

FreeRawOrReturnCache(void* address, uint32 flags)

src/system/kernel/slab/MemoryManager.cpp

1555

MemoryManager::_UnmapChunk(VMArea* vmArea, addr_t address, size_t size,

src/system/kernel/slab/MemoryManager.cpp

1558

T(Unmap(address, size, flags));

src/system/kernel/slab/MemoryManager.cpp

1564

")\n", vmArea, address, size);

src/system/kernel/slab/MemoryManager.cpp

157

fAddress(address),

src/system/kernel/slab/MemoryManager.cpp

1572

translationMap->Unmap(address, address + size - 1);

src/system/kernel/slab/MemoryManager.cpp

1578

addr_t areaPageOffset = (address - vmArea->Base()) / B_PAGE_SIZE;

src/system/kernel/slab/MemoryManager.cpp

1655

void* address = (void*)area->BaseAddress();

src/system/kernel/slab/MemoryManager.cpp

1656

area_id areaID = create_area(kSlabAreaName, &address, B_EXACT_ADDRESS,

src/system/kernel/slab/MemoryManager.cpp

1935

uint64 address;

src/system/kernel/slab/MemoryManager.cpp

1936

if (!evaluate_debug_expression(argv[1], &address, false))

src/system/kernel/slab/MemoryManager.cpp

1939

Area* area = _AreaForAddress(address);

src/system/kernel/slab/MemoryManager.cpp

1942

if ((addr_t)address >= (addr_t)area->metaChunks

src/system/kernel/slab/MemoryManager.cpp

1943

&& (addr_t)address

src/system/kernel/slab/MemoryManager.cpp

1945

metaChunk = (MetaChunk*)(addr_t)address;

src/system/kernel/slab/MemoryManager.cpp

1948

+ (address % SLAB_AREA_SIZE) / SLAB_CHUNK_SIZE_LARGE;

src/system/kernel/slab/MemoryManager.cpp

2008

uint64 address;

src/system/kernel/slab/MemoryManager.cpp

2009

if (!evaluate_debug_expression(argv[argi], &address, false))

src/system/kernel/slab/MemoryManager.cpp

2012

Area* area = _AreaForAddress((addr_t)address);

src/system/kernel/slab/MemoryManager.cpp

365

Map(addr_t address, size_t size, uint32 flags)

src/system/kernel/slab/MemoryManager.cpp

368

fAddress(address),

src/system/kernel/slab/MemoryManager.cpp

390

Unmap(addr_t address, size_t size, uint32 flags)

src/system/kernel/slab/MemoryManager.cpp

393

fAddress(address),

src/system/kernel/slab/MemoryManager.cpp

804

MemoryManager::GetAllocationInfo(void* address, size_t& _size)

src/system/kernel/slab/MemoryManager.cpp

808

Area* area = sAreaTable.Lookup(_AreaBaseAddressForAddress((addr_t)address));

src/system/kernel/slab/MemoryManager.cpp

814

VMArea* area = addressSpace->LookupArea((addr_t)address);

src/system/kernel/slab/MemoryManager.cpp

815

if (area != NULL && (addr_t)address == area->Base())

src/system/kernel/slab/MemoryManager.cpp

825

((addr_t)address % SLAB_AREA_SIZE) / SLAB_CHUNK_SIZE_LARGE];

src/system/kernel/slab/MemoryManager.cpp

829

ASSERT((addr_t)address >= metaChunk->chunkBase);

src/system/kernel/slab/MemoryManager.cpp

830

uint16 chunkIndex = _ChunkIndexForAddress(metaChunk, (addr_t)address);

src/system/kernel/slab/MemoryManager.cpp

839

_size = reference - (addr_t)address + 1;

src/system/kernel/slab/MemoryManager.cpp

845

MemoryManager::CacheForAddress(void* address)

src/system/kernel/slab/MemoryManager.cpp

849

Area* area = sAreaTable.Lookup(_AreaBaseAddressForAddress((addr_t)address));

src/system/kernel/slab/MemoryManager.cpp

856

((addr_t)address % SLAB_AREA_SIZE) / SLAB_CHUNK_SIZE_LARGE];

src/system/kernel/slab/MemoryManager.cpp

860

ASSERT((addr_t)address >= metaChunk->chunkBase);

src/system/kernel/slab/MemoryManager.cpp

861

uint16 chunkIndex = _ChunkIndexForAddress(metaChunk, (addr_t)address);

src/system/kernel/slab/MemoryManager.cpp

945

MemoryManager::DebugObjectCacheForAddress(void* address)

src/system/kernel/slab/MemoryManager.cpp

948

addr_t areaBase = _AreaBaseAddressForAddress((addr_t)address);

src/system/kernel/slab/MemoryManager.cpp

955

((addr_t)address % SLAB_AREA_SIZE) / SLAB_CHUNK_SIZE_LARGE];

src/system/kernel/slab/MemoryManager.cpp

960

if ((addr_t)address < metaChunk->chunkBase)

src/system/kernel/slab/MemoryManager.cpp

963

uint16 chunkIndex = _ChunkIndexForAddress(metaChunk, (addr_t)address);

src/system/kernel/slab/MemoryManager.h

173

static status_t _MapChunk(VMArea* vmArea, addr_t address,

src/system/kernel/slab/MemoryManager.h

176

static status_t _UnmapChunk(VMArea* vmArea, addr_t address,

src/system/kernel/slab/MemoryManager.h

184

static addr_t _AreaBaseAddressForAddress(addr_t address);

src/system/kernel/slab/MemoryManager.h

185

static Area* _AreaForAddress(addr_t address);

src/system/kernel/slab/MemoryManager.h

187

const MetaChunk* metaChunk, addr_t address);

src/system/kernel/slab/MemoryManager.h

243

MemoryManager::_AreaBaseAddressForAddress(addr_t address)

src/system/kernel/slab/MemoryManager.h

245

return ROUNDDOWN((addr_t)address, SLAB_AREA_SIZE);

src/system/kernel/slab/MemoryManager.h

250

MemoryManager::_AreaForAddress(addr_t address)

src/system/kernel/slab/MemoryManager.h

252

return (Area*)(_AreaBaseAddressForAddress(address)

src/system/kernel/slab/MemoryManager.h

258

MemoryManager::_ChunkIndexForAddress(const MetaChunk* metaChunk, addr_t address)

src/system/kernel/slab/MemoryManager.h

260

return (address - metaChunk->chunkBase) / metaChunk->chunkSize;

src/system/kernel/slab/MemoryManager.h

57

static ObjectCache* GetAllocationInfo(void* address,

src/system/kernel/slab/MemoryManager.h

59

static ObjectCache* CacheForAddress(void* address);

src/system/kernel/slab/MemoryManager.h

69

static ObjectCache* DebugObjectCacheForAddress(void* address);

src/system/kernel/slab/Slab.cpp

633

uint64 address;

src/system/kernel/slab/Slab.cpp

635

|| !evaluate_debug_expression(argv[i], &address, true)) {

src/system/kernel/slab/Slab.cpp

640

addressFilter = address;

src/system/kernel/slab/allocator.cpp

240

SLAB_PUBLIC_NAME(free_etc)(void *address, uint32 flags)

src/system/kernel/slab/allocator.cpp

243

deferred_free(address);

src/system/kernel/slab/allocator.cpp

247

block_free(address, flags & CACHE_ALLOC_FLAGS);

src/system/kernel/slab/allocator.cpp

252

SLAB_PUBLIC_NAME(realloc_etc)(void* address, size_t newSize, uint32 flags)

src/system/kernel/slab/allocator.cpp

255

block_free(address, flags);

src/system/kernel/slab/allocator.cpp

259

if (address == NULL)

src/system/kernel/slab/allocator.cpp

263

ObjectCache* cache = MemoryManager::GetAllocationInfo(address, oldSize);

src/system/kernel/slab/allocator.cpp

265

panic("block_realloc(): allocation %p not known", address);

src/system/kernel/slab/allocator.cpp

270

return address;

src/system/kernel/slab/allocator.cpp

276

memcpy(newBlock, address, std::min(oldSize, newSize));

src/system/kernel/slab/allocator.cpp

278

block_free(address, flags);

src/system/kernel/slab/allocator.cpp

313

free(void* address)

src/system/kernel/slab/allocator.cpp

315

block_free(address, 0);

src/system/kernel/slab/allocator.cpp

320

realloc(void* address, size_t newSize)

src/system/kernel/slab/allocator.cpp

322

return realloc_etc(address, newSize, 0);

src/system/kernel/smp.cpp

160

uint64 address;

src/system/kernel/smp.cpp

161

if (!evaluate_debug_expression(argv[1], &address, false))

src/system/kernel/smp.cpp

164

spinlock* lock = (spinlock*)(addr_t)address;

src/system/kernel/smp.cpp

264

uint64 address;

src/system/kernel/smp.cpp

265

if (!evaluate_debug_expression(argv[1], &address, false))

src/system/kernel/smp.cpp

268

smp_msg* message = (smp_msg*)(addr_t)address;

src/system/kernel/team.cpp

1363

void* address;

src/system/kernel/team.cpp

1367

address = exactAddress;

src/system/kernel/team.cpp

1370

address = (void*)KERNEL_USER_DATA_BASE;

src/system/kernel/team.cpp

1374

status_t result = vm_reserve_address_range(team->id, &address, addressSpec,

src/system/kernel/team.cpp

1380

virtualRestrictions.address = exactAddress;

src/system/kernel/team.cpp

1382

virtualRestrictions.address = address;

src/system/kernel/team.cpp

1385

virtualRestrictions.address = (void*)KERNEL_USER_DATA_BASE;

src/system/kernel/team.cpp

1393

&virtualRestrictions, &physicalRestrictions, &address);

src/system/kernel/team.cpp

1397

team->user_data = (addr_t)address;

src/system/kernel/team.cpp

2193

status = create_team_user_data(team, info.address);

src/system/kernel/team.cpp

2199

void* address;

src/system/kernel/team.cpp

2201

&address, B_CLONE_ADDRESS, info.area);

src/system/kernel/thread.cpp

2862

thread->kernel_stack_base = (addr_t)info.address;

src/system/kernel/thread.cpp

936

virtualRestrictions.address = (void*)stackBase;

src/system/kernel/vm/VMCache.cpp

478

void* address = (void*)(addr_t)addressValue;

src/system/kernel/vm/VMCache.cpp

481

isArea ? "area" : "cache", address, debugEntryIndex);

src/system/kernel/vm/VMCache.cpp

483

address = cache_stack_find_area_cache(baseIterator, address);

src/system/kernel/vm/VMCache.cpp

484

if (address == NULL) {

src/system/kernel/vm/VMCache.cpp

490

while (address != NULL) {

src/system/kernel/vm/VMCache.cpp

491

kprintf(" %p\n", address);

src/system/kernel/vm/VMCache.cpp

492

address = cache_stack_find_consumer(baseIterator, address);

src/system/kernel/vm/VMKernelAddressSpace.cpp

163

VMKernelAddressSpace::LookupArea(addr_t address) const

src/system/kernel/vm/VMKernelAddressSpace.cpp

165

Range* range = fRangeTree.FindClosest(address, true);

src/system/kernel/vm/VMKernelAddressSpace.cpp

170

return area->ContainsAddress(address) ? area : NULL;

src/system/kernel/vm/VMKernelAddressSpace.cpp

176

VMKernelAddressSpace::FindClosestArea(addr_t address, bool less) const

src/system/kernel/vm/VMKernelAddressSpace.cpp

178

Range* range = fRangeTree.FindClosest(address, less);

src/system/kernel/vm/VMKernelAddressSpace.cpp

197

", %p \"%s\")\n", addressRestrictions->address,

src/system/kernel/vm/VMKernelAddressSpace.cpp

395

B_PRIxSIZE ", %#" B_PRIx32 ")\n", addressRestrictions->address,

src/system/kernel/vm/VMKernelAddressSpace.cpp

423

VMKernelAddressSpace::UnreserveAddressRange(addr_t address, size_t size,

src/system/kernel/vm/VMKernelAddressSpace.cpp

427

B_PRIxSIZE ")\n", address, size);

src/system/kernel/vm/VMKernelAddressSpace.cpp

435

addr_t endAddress = address + (size - 1);

src/system/kernel/vm/VMKernelAddressSpace.cpp

436

Range* range = fRangeTree.FindClosest(address, false);

src/system/kernel/vm/VMKernelAddressSpace.cpp

589

addressRestrictions->address, size,

src/system/kernel/vm/VMKernelAddressSpace.cpp

593

addr_t address = (addr_t)addressRestrictions->address;

src/system/kernel/vm/VMKernelAddressSpace.cpp

601

if (address % B_PAGE_SIZE != 0)

src/system/kernel/vm/VMKernelAddressSpace.cpp

607

address = ROUNDUP(address, B_PAGE_SIZE);

src/system/kernel/vm/VMKernelAddressSpace.cpp

619

address = fBase;

src/system/kernel/vm/VMKernelAddressSpace.cpp

627

Range* range = _FindFreeRange(address, size, alignment,

src/system/kernel/vm/VMKernelAddressSpace.cpp

629

address);

src/system/kernel/vm/VMKernelAddressSpace.cpp

643

if (address == range->base) {

src/system/kernel/vm/VMKernelAddressSpace.cpp

648

Range(address + size, range->size - size, range);

src/system/kernel/vm/VMKernelAddressSpace.cpp

655

} else if (address + size == range->base + range->size) {

src/system/kernel/vm/VMKernelAddressSpace.cpp

662

range->base = address;

src/system/kernel/vm/VMKernelAddressSpace.cpp

668

range->base, address - range->base, range);

src/system/kernel/vm/VMKernelAddressSpace.cpp

672

address + size, range->size - size - leftOverRange1->size, range);

src/system/kernel/vm/VMKernelAddressSpace.cpp

679

range->base = address;

src/system/kernel/vm/VMKernelAddressSpace.h

28

virtual VMArea* LookupArea(addr_t address) const;

src/system/kernel/vm/VMKernelAddressSpace.h

29

virtual VMArea* FindClosestArea(addr_t address, bool less)

src/system/kernel/vm/VMKernelAddressSpace.h

55

virtual status_t UnreserveAddressRange(addr_t address,

src/system/kernel/vm/VMTranslationMap.cpp

118

const addr_t address = area->Base()

src/system/kernel/vm/VMTranslationMap.cpp

123

status_t status = UnmapPage(area, address, false, deletingAddressSpace, &flags);

src/system/kernel/vm/VMTranslationMap.cpp

126

"has no translation map entry", page, area, address);

src/system/kernel/vm/VMTranslationMap.cpp

131

page, area, address, status);

src/system/kernel/vm/VMTranslationMap.cpp

46

addr_t address = base;

src/system/kernel/vm/VMTranslationMap.cpp

47

addr_t end = address + size;

src/system/kernel/vm/VMTranslationMap.cpp

49

for (; address != end; address += B_PAGE_SIZE) {

src/system/kernel/vm/VMTranslationMap.cpp

52

if (Query(address, &physicalAddress, &flags) == B_OK

src/system/kernel/vm/VMTranslationMap.cpp

57

UnmapPage(area, address, updatePageQueue, deletingAddressSpace);

src/system/kernel/vm/VMTranslationMap.cpp

60

UnmapPage(area, address, updatePageQueue, deletingAddressSpace);

src/system/kernel/vm/VMTranslationMap.cpp

64

for (; address != end; address += B_PAGE_SIZE)

src/system/kernel/vm/VMTranslationMap.cpp

65

UnmapPage(area, address, updatePageQueue, deletingAddressSpace);

src/system/kernel/vm/VMUserAddressSpace.cpp

136

VMUserAddressSpace::LookupArea(addr_t address) const

src/system/kernel/vm/VMUserAddressSpace.cpp

138

VMUserArea* area = fAreas.FindClosest(address, true);

src/system/kernel/vm/VMUserAddressSpace.cpp

142

return area->ContainsAddress(address) ? area : NULL;

src/system/kernel/vm/VMUserAddressSpace.cpp

148

VMUserAddressSpace::FindClosestArea(addr_t address, bool less) const

src/system/kernel/vm/VMUserAddressSpace.cpp

150

VMUserArea* area = fAreas.FindClosest(address, less);

src/system/kernel/vm/VMUserAddressSpace.cpp

176

searchBase = (addr_t)addressRestrictions->address;

src/system/kernel/vm/VMUserAddressSpace.cpp

177

searchEnd = (addr_t)addressRestrictions->address + (size - 1);

src/system/kernel/vm/VMUserAddressSpace.cpp

182

searchBase = std::max(fBase, (addr_t)addressRestrictions->address);

src/system/kernel/vm/VMUserAddressSpace.cpp

377

VMUserAddressSpace::UnreserveAddressRange(addr_t address, size_t size,

src/system/kernel/vm/VMUserAddressSpace.cpp

388

VMUserArea* area = fAreas.FindClosest(address, false);

src/system/kernel/vm/VMUserAddressSpace.cpp

392

addr_t endAddress = address + size - 1;

src/system/kernel/vm/VMUserAddressSpace.cpp

64

align_address(addr_t address, size_t alignment)

src/system/kernel/vm/VMUserAddressSpace.cpp

66

return ROUNDUP(address, alignment);

src/system/kernel/vm/VMUserAddressSpace.cpp

71

align_address(addr_t address, size_t alignment, uint32 addressSpec,

src/system/kernel/vm/VMUserAddressSpace.cpp

75

address = std::max(address, baseAddress);

src/system/kernel/vm/VMUserAddressSpace.cpp

76

return align_address(address, alignment);

src/system/kernel/vm/VMUserAddressSpace.h

23

virtual VMArea* LookupArea(addr_t address) const;

src/system/kernel/vm/VMUserAddressSpace.h

24

virtual VMArea* FindClosestArea(addr_t address, bool less)

src/system/kernel/vm/VMUserAddressSpace.h

50

virtual status_t UnreserveAddressRange(addr_t address,

src/system/kernel/vm/vm.cpp

1102

unmap_address_range(VMAddressSpace* addressSpace, addr_t address, addr_t size,

src/system/kernel/vm/vm.cpp

1110

= addressSpace->GetAreaRangeIterator(address, size);

src/system/kernel/vm/vm.cpp

1123

= addressSpace->GetAreaRangeIterator(address, size);

src/system/kernel/vm/vm.cpp

1126

status_t error = cut_area(addressSpace, area, address, size, NULL,

src/system/kernel/vm/vm.cpp

1139

discard_area_range(VMArea* area, addr_t address, addr_t size)

src/system/kernel/vm/vm.cpp

1142

if (!intersect_area(area, address, size, offset))

src/system/kernel/vm/vm.cpp

1156

unmap_pages(area, address, size);

src/system/kernel/vm/vm.cpp

1162

const off_t endAddress = address + size;

src/system/kernel/vm/vm.cpp

1163

for (off_t pageAddress = address; pageAddress < endAddress; pageAddress += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

1188

discard_address_range(VMAddressSpace* addressSpace, addr_t address, addr_t size,

src/system/kernel/vm/vm.cpp

1192

= addressSpace->GetAreaRangeIterator(address, size);

src/system/kernel/vm/vm.cpp

1194

status_t error = discard_area_range(area, address, size);

src/system/kernel/vm/vm.cpp

1231

addressSpace, cache, addressRestrictions->address, offset, size,

src/system/kernel/vm/vm.cpp

1319

(addr_t)addressRestrictions->address, size, kernel);

src/system/kernel/vm/vm.cpp

1481

vm_block_address_range(const char* name, void* address, addr_t size)

src/system/kernel/vm/vm.cpp

1501

addressRestrictions.address = address;

src/system/kernel/vm/vm.cpp

1518

vm_unreserve_address_range(team_id team, void* address, addr_t size)

src/system/kernel/vm/vm.cpp

1525

return addressSpace->UnreserveAddressRange((addr_t)address, size,

src/system/kernel/vm/vm.cpp

1543

addressRestrictions.address = *_address;

src/system/kernel/vm/vm.cpp

1761

(addr_t)virtualAddressRestrictions->address, size, &locker));

src/system/kernel/vm/vm.cpp

1804

for (addr_t address = area->Base();

src/system/kernel/vm/vm.cpp

1805

address < area->Base() + (area->Size() - 1);

src/system/kernel/vm/vm.cpp

1806

address += B_PAGE_SIZE, offset += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

1809

if (isStack && address < area->Base()

src/system/kernel/vm/vm.cpp

1812

if (isStack && address >= area->Base() + area->Size()

src/system/kernel/vm/vm.cpp

1820

map_page(area, page, address, protection, &reservation);

src/system/kernel/vm/vm.cpp

1985

addressRestrictions.address = *_address;

src/system/kernel/vm/vm.cpp

2107

addressRestrictions.address = *_address;

src/system/kernel/vm/vm.cpp

2160

vm_create_null_area(team_id team, const char* name, void** address,

src/system/kernel/vm/vm.cpp

2175

(addr_t)*address, size, &locker));

src/system/kernel/vm/vm.cpp

2192

addressRestrictions.address = *address;

src/system/kernel/vm/vm.cpp

2197

&addressRestrictions, true, &area, address);

src/system/kernel/vm/vm.cpp

2287

virtualRestrictions.address = *_address;

src/system/kernel/vm/vm.cpp

2388

addressRestrictions.address = *_address;

src/system/kernel/vm/vm.cpp

2428

vm_map_file(team_id aid, const char* name, void** address, uint32 addressSpec,

src/system/kernel/vm/vm.cpp

2432

return _vm_map_file(aid, name, address, addressSpec, size, protection,

src/system/kernel/vm/vm.cpp

2473

vm_clone_area(team_id team, const char* name, void** address,

src/system/kernel/vm/vm.cpp

2558

addressRestrictions.address = *address;

src/system/kernel/vm/vm.cpp

2564

kernel, &newArea, address);

src/system/kernel/vm/vm.cpp

266

static status_t vm_soft_fault(VMAddressSpace* addressSpace, addr_t address,

src/system/kernel/vm/vm.cpp

285

PageFaultStart(addr_t address, bool write, bool user, addr_t pc)

src/system/kernel/vm/vm.cpp

287

fAddress(address),

src/system/kernel/vm/vm.cpp

2925

addr_t address = virtual_page_address(tempArea, page);

src/system/kernel/vm/vm.cpp

2927

uint32 pageProtection = get_area_page_protection(tempArea, address);

src/system/kernel/vm/vm.cpp

2936

map->ProtectPage(tempArea, address, protection);

src/system/kernel/vm/vm.cpp

2958

addr_t address = virtual_page_address(tempArea, page);

src/system/kernel/vm/vm.cpp

2960

uint32 pageProtection = get_area_page_protection(tempArea, address);

src/system/kernel/vm/vm.cpp

2966

map->ProtectPage(tempArea, address, protection);

src/system/kernel/vm/vm.cpp

3088

addressRestrictions.address = *_address;

src/system/kernel/vm/vm.cpp

3303

addr_t address = virtual_page_address(area, page);

src/system/kernel/vm/vm.cpp

3304

map->ProtectPage(area, address, newProtection);

src/system/kernel/vm/vm.cpp

3402

addr_t address = virtual_page_address(area, page);

src/system/kernel/vm/vm.cpp

3403

map->UnmapPage(area, address, false);

src/system/kernel/vm/vm.cpp

3460

addr_t address = virtual_page_address(area, page);

src/system/kernel/vm/vm.cpp

3462

if (map->ClearAccessedAndModified(area, address, true, modified)) {

src/system/kernel/vm/vm.cpp

3513

vm_area_for(addr_t address, bool kernel)

src/system/kernel/vm/vm.cpp

3516

if (IS_USER_ADDRESS(address)) {

src/system/kernel/vm/vm.cpp

3528

VMArea* area = locker.AddressSpace()->LookupArea(address);

src/system/kernel/vm/vm.cpp

3561

void* address = (void*)(addr_t)range.start;

src/system/kernel/vm/vm.cpp

3565

if (!IS_KERNEL_ADDRESS(address)) {

src/system/kernel/vm/vm.cpp

3567

B_PRIu64 "\n", address, range.size);

src/system/kernel/vm/vm.cpp

3572

&address, B_EXACT_ADDRESS, range.size, 0);

src/system/kernel/vm/vm.cpp

3723

vm_page_fault(addr_t address, addr_t faultAddress, bool isWrite, bool isExecute,

src/system/kernel/vm/vm.cpp

3726

FTRACE(("vm_page_fault: page fault at 0x%lx, ip 0x%lx\n", address,

src/system/kernel/vm/vm.cpp

3729

TPF(PageFaultStart(address, isWrite, isUser, faultAddress));

src/system/kernel/vm/vm.cpp

3731

addr_t pageAddress = ROUNDDOWN(address, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

3775

strerror(status), address, faultAddress, isWrite, isExecute,

src/system/kernel/vm/vm.cpp

3787

"0x%lx, ip 0x%lx\n", address, faultAddress);

src/system/kernel/vm/vm.cpp

3803

isWrite ? "write" : (isExecute ? "execute" : "read"), address,

src/system/kernel/vm/vm.cpp

3824

signal.SetAddress((void*)address);

src/system/kernel/vm/vm.cpp

4054

addr_t address = ROUNDDOWN(originalAddress, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

4078

VMArea* area = addressSpace->LookupArea(address);

src/system/kernel/vm/vm.cpp

4091

uint32 protection = get_area_page_protection(area, address);

src/system/kernel/vm/vm.cpp

4140

address - area->Base() + area->cache_offset);

src/system/kernel/vm/vm.cpp

4186

if (context.map->Query(address, &physicalAddress, &flags) == B_OK

src/system/kernel/vm/vm.cpp

4193

context.map->ProtectPage(area, address, newProtection);

src/system/kernel/vm/vm.cpp

4212

if (area->AddWaiterIfWired(&waiter, address, B_PAGE_SIZE,

src/system/kernel/vm/vm.cpp

4241

unmap_page(area, address);

src/system/kernel/vm/vm.cpp

4246

if (map_page(area, context.page, address, newProtection,

src/system/kernel/vm/vm.cpp

4621

info->address = (void*)area->Base();

src/system/kernel/vm/vm.cpp

4805

vm_memset_physical(phys_addr_t address, int value, phys_size_t length)

src/system/kernel/vm/vm.cpp

4807

return sPhysicalPageMapper->MemsetPhysical(address, value, length);

src/system/kernel/vm/vm.cpp

4838

addr_t address = (addr_t)addr;

src/system/kernel/vm/vm.cpp

4841

if ((address + size) < address)

src/system/kernel/vm/vm.cpp

4845

return IS_USER_ADDRESS(address) == IS_USER_ADDRESS(address + size - 1);

src/system/kernel/vm/vm.cpp

4930

vm_wire_page(team_id team, addr_t address, bool writable,

src/system/kernel/vm/vm.cpp

4933

addr_t pageAddress = ROUNDDOWN((addr_t)address, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

4937

bool isUser = IS_USER_ADDRESS(address);

src/system/kernel/vm/vm.cpp

5016

+ address % B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

5081

lock_memory_etc(team_id team, void* address, size_t numBytes, uint32 flags)

src/system/kernel/vm/vm.cpp

5083

addr_t lockBaseAddress = ROUNDDOWN((addr_t)address, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

5084

addr_t lockEndAddress = ROUNDUP((addr_t)address + numBytes, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

5087

bool isUser = IS_USER_ADDRESS(address);

src/system/kernel/vm/vm.cpp

5228

lock_memory(void* address, size_t numBytes, uint32 flags)

src/system/kernel/vm/vm.cpp

5230

return lock_memory_etc(B_CURRENT_TEAM, address, numBytes, flags);

src/system/kernel/vm/vm.cpp

5240

unlock_memory_etc(team_id team, void* address, size_t numBytes, uint32 flags)

src/system/kernel/vm/vm.cpp

5242

addr_t lockBaseAddress = ROUNDDOWN((addr_t)address, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

5243

addr_t lockEndAddress = ROUNDUP((addr_t)address + numBytes, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

5246

bool isUser = IS_USER_ADDRESS(address);

src/system/kernel/vm/vm.cpp

5364

unlock_memory(void* address, size_t numBytes, uint32 flags)

src/system/kernel/vm/vm.cpp

5366

return unlock_memory_etc(B_CURRENT_TEAM, address, numBytes, flags);

src/system/kernel/vm/vm.cpp

5379

get_memory_map_etc(team_id team, const void* address, size_t numBytes,

src/system/kernel/vm/vm.cpp

5385

addr_t virtualAddress = (addr_t)address;

src/system/kernel/vm/vm.cpp

5393

"entries)\n", team, address, numBytes, numEntries));

src/system/kernel/vm/vm.cpp

5422

status = map->Query((addr_t)address + offset, &physicalAddress,

src/system/kernel/vm/vm.cpp

5425

status = map->QueryInterrupt((addr_t)address + offset,

src/system/kernel/vm/vm.cpp

5442

if (index < 0 || table[index].address

src/system/kernel/vm/vm.cpp

5448

table[index].address = physicalAddress;

src/system/kernel/vm/vm.cpp

5478

__get_memory_map_haiku(const void* address, size_t numBytes,

src/system/kernel/vm/vm.cpp

5482

status_t error = get_memory_map_etc(B_CURRENT_TEAM, address, numBytes,

src/system/kernel/vm/vm.cpp

5496

table[entriesRead].address = 0;

src/system/kernel/vm/vm.cpp

5504

area_for(void* address)

src/system/kernel/vm/vm.cpp

5506

return vm_area_for((addr_t)address, true);

src/system/kernel/vm/vm.cpp

5664

virtualRestrictions.address = *_address;

src/system/kernel/vm/vm.cpp

5694

addr_t address;

src/system/kernel/vm/vm.cpp

5697

|| user_memcpy(&address, userAddress, sizeof(address)) != B_OK)

src/system/kernel/vm/vm.cpp

5701

VMAddressSpace::CurrentID(), (void**)&address, addressSpec, size,

src/system/kernel/vm/vm.cpp

5706

if (user_memcpy(userAddress, &address, sizeof(address)) != B_OK) {

src/system/kernel/vm/vm.cpp

5708

(void*)address, size);

src/system/kernel/vm/vm.cpp

5717

_user_unreserve_address_range(addr_t address, addr_t size)

src/system/kernel/vm/vm.cpp

5720

(void*)address, size);

src/system/kernel/vm/vm.cpp

5725

_user_area_for(void* address)

src/system/kernel/vm/vm.cpp

5727

return vm_area_for((addr_t)address, false);

src/system/kernel/vm/vm.cpp

5832

void* address;

src/system/kernel/vm/vm.cpp

5834

|| user_memcpy(&address, userAddress, sizeof(address)) < B_OK)

src/system/kernel/vm/vm.cpp

5837

area_id newArea = transfer_area(area, &address, addressSpec, target, false);

src/system/kernel/vm/vm.cpp

5841

if (user_memcpy(userAddress, &address, sizeof(address)) < B_OK)

src/system/kernel/vm/vm.cpp

5853

void* address;

src/system/kernel/vm/vm.cpp

5867

|| user_memcpy(&address, userAddress, sizeof(address)) < B_OK)

src/system/kernel/vm/vm.cpp

5871

&address, addressSpec, protection, REGION_NO_PRIVATE_MAP, sourceArea,

src/system/kernel/vm/vm.cpp

5876

if (user_memcpy(userAddress, &address, sizeof(address)) < B_OK) {

src/system/kernel/vm/vm.cpp

5890

void* address;

src/system/kernel/vm/vm.cpp

5904

|| user_memcpy(&address, userAddress, sizeof(address)) < B_OK)

src/system/kernel/vm/vm.cpp

5907

if (addressSpec == B_EXACT_ADDRESS && IS_KERNEL_ADDRESS(address))

src/system/kernel/vm/vm.cpp

5911

virtualRestrictions.address = address;

src/system/kernel/vm/vm.cpp

5916

&physicalRestrictions, false, &address);

src/system/kernel/vm/vm.cpp

5919

&& user_memcpy(userAddress, &address, sizeof(address)) < B_OK) {

src/system/kernel/vm/vm.cpp

5947

void* address;

src/system/kernel/vm/vm.cpp

5955

|| user_memcpy(&address, userAddress, sizeof(address)) < B_OK)

src/system/kernel/vm/vm.cpp

5959

if ((addr_t)address + size < (addr_t)address

src/system/kernel/vm/vm.cpp

5960

|| (addr_t)address % B_PAGE_SIZE != 0) {

src/system/kernel/vm/vm.cpp

5963

if (!IS_USER_ADDRESS(address)

src/system/kernel/vm/vm.cpp

5964

|| !IS_USER_ADDRESS((addr_t)address + size - 1)) {

src/system/kernel/vm/vm.cpp

5969

area = _vm_map_file(VMAddressSpace::CurrentID(), name, &address,

src/system/kernel/vm/vm.cpp

5975

if (user_memcpy(userAddress, &address, sizeof(address)) < B_OK)

src/system/kernel/vm/vm.cpp

5985

addr_t address = (addr_t)_address;

src/system/kernel/vm/vm.cpp

5988

if (size == 0 || (addr_t)address + size < (addr_t)address

src/system/kernel/vm/vm.cpp

5989

|| (addr_t)address % B_PAGE_SIZE != 0) {

src/system/kernel/vm/vm.cpp

5993

if (!IS_USER_ADDRESS(address)

src/system/kernel/vm/vm.cpp

5994

|| !IS_USER_ADDRESS((addr_t)address + size - 1)) {

src/system/kernel/vm/vm.cpp

6004

} while (wait_if_address_range_is_wired(locker.AddressSpace(), address,

src/system/kernel/vm/vm.cpp

6008

return unmap_address_range(locker.AddressSpace(), address, size, false);

src/system/kernel/vm/vm.cpp

6016

addr_t address = (addr_t)_address;

src/system/kernel/vm/vm.cpp

6019

if ((address % B_PAGE_SIZE) != 0)

src/system/kernel/vm/vm.cpp

6049

addr_t currentAddress = address;

src/system/kernel/vm/vm.cpp

6084

addr_t currentAddress = address;

src/system/kernel/vm/vm.cpp

6214

addr_t address = (addr_t)_address;

src/system/kernel/vm/vm.cpp

6218

if ((address % B_PAGE_SIZE) != 0)

src/system/kernel/vm/vm.cpp

6242

VMArea* area = locker.AddressSpace()->LookupArea(address);

src/system/kernel/vm/vm.cpp

6246

uint32 offset = address - area->Base();

src/system/kernel/vm/vm.cpp

6278

address += rangeSize;

src/system/kernel/vm/vm.cpp

6293

addr_t address = (addr_t)_address;

src/system/kernel/vm/vm.cpp

6294

if ((address % B_PAGE_SIZE) != 0)

src/system/kernel/vm/vm.cpp

6320

address, size, &locker));

src/system/kernel/vm/vm.cpp

6322

discard_address_range(locker.AddressSpace(), address, size, false);

src/system/kernel/vm/vm.cpp

6335

_user_get_memory_properties(team_id teamID, const void* address,

src/system/kernel/vm/vm.cpp

6350

VMArea* area = locker.AddressSpace()->LookupArea((addr_t)address);

src/system/kernel/vm/vm.cpp

6354

uint32 protection = get_area_page_protection(area, (addr_t)address);

src/system/kernel/vm/vm.cpp

6374

addr_t address = (addr_t)_address;

src/system/kernel/vm/vm.cpp

6377

if ((address % B_PAGE_SIZE) != 0)

src/system/kernel/vm/vm.cpp

6382

const addr_t endAddress = address + size;

src/system/kernel/vm/vm.cpp

6385

(void*)address, endAddress - address, 0);

src/system/kernel/vm/vm.cpp

6396

addr_t nextAddress = address;

src/system/kernel/vm/vm.cpp

6429

(void*)address, endAddress - address, 0);

src/system/kernel/vm/vm.cpp

6465

uint32 address;

src/system/kernel/vm/vm.cpp

6480

const uint8* address = (const uint8*)_address;

src/system/kernel/vm/vm.cpp

6485

status_t result = __get_memory_map_haiku(address, numBytes, &entry, 1);

src/system/kernel/vm/vm.cpp

6491

if (entry.address >= (phys_addr_t)1 << 32) {

src/system/kernel/vm/vm.cpp

6496

table[count].address = entry.address;

src/system/kernel/vm/vm.cpp

6499

address += entry.size;

src/system/kernel/vm/vm.cpp

6505

table[count].address = 0;

src/system/kernel/vm/vm.cpp

655

map_page(VMArea* area, vm_page* page, addr_t address, uint32 protection,

src/system/kernel/vm/vm.cpp

677

map->Map(address, page->physical_page_number * B_PAGE_SIZE, protection,

src/system/kernel/vm/vm.cpp

692

map->Map(address, page->physical_page_number * B_PAGE_SIZE, protection,

src/system/kernel/vm/vm.cpp

733

intersect_area(VMArea* area, addr_t& address, addr_t& size, addr_t& offset)

src/system/kernel/vm/vm.cpp

735

if (address < area->Base()) {

src/system/kernel/vm/vm.cpp

736

offset = area->Base() - address;

src/system/kernel/vm/vm.cpp

740

address = area->Base();

src/system/kernel/vm/vm.cpp

749

offset = address - area->Base();

src/system/kernel/vm/vm.cpp

769

cut_area(VMAddressSpace* addressSpace, VMArea* area, addr_t address,

src/system/kernel/vm/vm.cpp

773

if (!intersect_area(area, address, size, offset))

src/system/kernel/vm/vm.cpp

777

if (address == area->Base() && size == area->Size()) {

src/system/kernel/vm/vm.cpp

831

unmap_pages(area, address, size);

src/system/kernel/vm/vm.cpp

856

if (area->Base() == address) {

src/system/kernel/vm/vm.cpp

887

unmap_pages(area, address, size);

src/system/kernel/vm/vm.cpp

916

const addr_t secondBase = address + size;

src/system/kernel/vm/vm.cpp

921

unmap_pages(area, address, area->Size() - firstNewSize);

src/system/kernel/vm/vm.cpp

949

addressRestrictions.address = (void*)secondBase;

src/system/kernel/vm/vm_debug.cpp

101

int32 offset = address & (B_PAGE_SIZE - 1);

src/system/kernel/vm/vm_debug.cpp

107

address = ROUNDDOWN(address, B_PAGE_SIZE);

src/system/kernel/vm/vm_debug.cpp

109

if (vm_get_physical_page_debug(address, &copyAddress,

src/system/kernel/vm/vm_debug.cpp

115

address += offset;

src/system/kernel/vm/vm_debug.cpp

118

copyAddress = address;

src/system/kernel/vm/vm_debug.cpp

155

kprintf("[0x%lx] ", address + i * itemSize);

src/system/kernel/vm/vm_debug.cpp

238

addr_t address = parse_expression(argv[1]);

src/system/kernel/vm/vm_debug.cpp

239

if (address == 0)

src/system/kernel/vm/vm_debug.cpp

242

VMCache* cache = (VMCache*)address;

src/system/kernel/vm/vm_debug.cpp

452

addr_t address = parse_expression(argv[i]);

src/system/kernel/vm/vm_debug.cpp

453

if (address == 0)

src/system/kernel/vm/vm_debug.cpp

456

cache = (VMCache*)address;

src/system/kernel/vm/vm_debug.cpp

46

addr_t address;

src/system/kernel/vm/vm_debug.cpp

69

address = parse_expression(argv[i]);

src/system/kernel/vm/vm_init.cpp

124

void* address;

src/system/kernel/vm/vm_init.cpp

141

address = (void*)ROUNDDOWN(image->text_region.start, B_PAGE_SIZE);

src/system/kernel/vm/vm_init.cpp

142

image->text_region.id = create_area(name, &address, B_EXACT_ADDRESS,

src/system/kernel/vm/vm_init.cpp

149

address = (void*)ROUNDDOWN(image->data_region.start, B_PAGE_SIZE);

src/system/kernel/vm/vm_init.cpp

150

image->data_region.id = create_area(name, &address, B_EXACT_ADDRESS,

src/system/kernel/vm/vm_init.cpp

180

void* address = (void*)(addr_t)range.start;

src/system/kernel/vm/vm_init.cpp

182

create_area("_kernel args_", &address, B_EXACT_ADDRESS,

src/system/kernel/vm/vm_init.cpp

246

is_page_in_physical_memory_range(kernel_args* args, phys_addr_t address)

src/system/kernel/vm/vm_init.cpp

252

if (address >= range.start && address < (range.start + range.size))

src/system/kernel/vm/vm_init.cpp

456

void* address = (void*)args->cpu_kstack[i].start;

src/system/kernel/vm/vm_init.cpp

457

create_area(name, &address, B_EXACT_ADDRESS, args->cpu_kstack[i].size,

src/system/kernel/vm/vm_page.cpp

724

addr_t address;

src/system/kernel/vm/vm_page.cpp

749

address = strtoul(argv[index], NULL, 0);

src/system/kernel/vm/vm_page.cpp

750

page = (vm_page*)address;

src/system/libnetwork/getifaddrs.cpp

29

copy_address(const sockaddr& address)

src/system/libnetwork/getifaddrs.cpp

31

if (address.sa_family == AF_UNSPEC)

src/system/libnetwork/getifaddrs.cpp

38

size_t length = std::min(sizeof(sockaddr_storage), (size_t)address.sa_len);

src/system/libnetwork/getifaddrs.cpp

39

switch (address.sa_family) {

src/system/libnetwork/getifaddrs.cpp

47

memcpy(copy, &address, length);

src/system/libnetwork/netresolv/resolv/res_debug.h

26

# define Aerror(statp, file, string, error, address, addrLen) /*empty*/

src/system/libnetwork/netresolv/resolv/res_send.c

1136

const struct sockaddr *address, socklen_t alen)

src/system/libnetwork/netresolv/resolv/res_send.c

1145

if (getnameinfo(address, alen, hbuf,

src/system/libnetwork/socket.cpp

148

bind(int socket, const struct sockaddr *address, socklen_t addressLength)

src/system/libnetwork/socket.cpp

153

convert_from_r5_sockaddr(&haikuAddr, address);

src/system/libnetwork/socket.cpp

154

address = &haikuAddr;

src/system/libnetwork/socket.cpp

158

RETURN_AND_SET_ERRNO(_kern_bind(socket, address, addressLength));

src/system/libnetwork/socket.cpp

170

connect(int socket, const struct sockaddr *address, socklen_t addressLength)

src/system/libnetwork/socket.cpp

175

convert_from_r5_sockaddr(&haikuAddr, address);

src/system/libnetwork/socket.cpp

176

address = &haikuAddr;

src/system/libnetwork/socket.cpp

181

_kern_connect(socket, address, addressLength));

src/system/libnetwork/socket.cpp

205

sockaddr* address;

src/system/libnetwork/socket.cpp

209

address = &haikuAddr;

src/system/libnetwork/socket.cpp

212

address = _address;

src/system/libnetwork/socket.cpp

216

int acceptSocket = _kern_accept(socket, address, &addressLength, flags);

src/system/libnetwork/socket.cpp

250

sockaddr* address;

src/system/libnetwork/socket.cpp

254

address = &haikuAddr;

src/system/libnetwork/socket.cpp

257

address = _address;

src/system/libnetwork/socket.cpp

262

address, &addressLength);

src/system/libnetwork/socket.cpp

298

const struct sockaddr *address, socklen_t addressLength)

src/system/libnetwork/socket.cpp

303

convert_from_r5_sockaddr(&haikuAddr, address);

src/system/libnetwork/socket.cpp

304

address = &haikuAddr;

src/system/libnetwork/socket.cpp

309

_kern_sendto(socket, data, length, flags, address, addressLength));

src/system/libnetwork/socket.cpp

357

sockaddr* address;

src/system/libnetwork/socket.cpp

361

address = &haikuAddr;

src/system/libnetwork/socket.cpp

364

address = _address;

src/system/libnetwork/socket.cpp

368

status_t error = _kern_getpeername(socket, address, &addressLength);

src/system/libnetwork/socket.cpp

391

sockaddr* address;

src/system/libnetwork/socket.cpp

395

address = &haikuAddr;

src/system/libnetwork/socket.cpp

398

address = _address;

src/system/libnetwork/socket.cpp

402

status_t error = _kern_getsockname(socket, address, &addressLength);

src/system/libroot/os/area.c

15

create_area(const char *name, void **address, uint32 addressSpec, size_t size,

src/system/libroot/os/area.c

28

return _kern_create_area(name, address, addressSpec, size, lock, protection);

src/system/libroot/os/area.c

33

clone_area(const char *name, void **address, uint32 addressSpec,

src/system/libroot/os/area.c

46

return _kern_clone_area(name, address, addressSpec, protection, sourceArea);

src/system/libroot/os/area.c

58

area_for(void *address)

src/system/libroot/os/area.c

60

return _kern_area_for(address);

src/system/libroot/os/debug.c

120

set_debugger_breakpoint(void *address)

src/system/libroot/os/debug.c

122

return _kern_set_debugger_breakpoint(address, 0, 0, false);

src/system/libroot/os/debug.c

127

clear_debugger_breakpoint(void *address)

src/system/libroot/os/debug.c

129

return _kern_clear_debugger_breakpoint(address, false);

src/system/libroot/os/debug.c

134

set_debugger_watchpoint(void *address, uint32 type, int32 length)

src/system/libroot/os/debug.c

136

return _kern_set_debugger_breakpoint(address, type, length, true);

src/system/libroot/os/debug.c

141

clear_debugger_watchpoint(void *address)

src/system/libroot/os/debug.c

143

return _kern_clear_debugger_breakpoint(address, true);

src/system/libroot/os/image.cpp

315

clear_caches(void *address, size_t length, uint32 flags)

src/system/libroot/os/image.cpp

317

_kern_clear_caches(address, length, flags);

src/system/libroot/os/memory.cpp

13

get_memory_properties(team_id teamID, const void* address, uint32* _protected,

src/system/libroot/os/memory.cpp

16

return _kern_get_memory_properties(teamID, address, _protected, _lock);

src/system/libroot/posix/dlfcn.c

78

dladdr(const void *address, Dl_info *info)

src/system/libroot/posix/dlfcn.c

86

sStatus = __gRuntimeLoader->get_nearest_symbol_at_address(address, &image,

src/system/libroot/posix/glibc/extensions/obstack.c

614

POINTER (obstack_copy) (obstack, address, length)

src/system/libroot/posix/glibc/extensions/obstack.c

616

const POINTER address;

src/system/libroot/posix/glibc/extensions/obstack.c

619

return obstack_copy (obstack, address, length);

src/system/libroot/posix/glibc/extensions/obstack.c

622

POINTER (obstack_copy0) (obstack, address, length)

src/system/libroot/posix/glibc/extensions/obstack.c

624

const POINTER address;

src/system/libroot/posix/glibc/extensions/obstack.c

627

return obstack_copy0 (obstack, address, length);

src/system/libroot/posix/glibc/extensions/obstack.h

223

void * obstack_copy (struct obstack *obstack, const void *address, int size);

src/system/libroot/posix/glibc/extensions/obstack.h

224

void * obstack_copy0 (struct obstack *obstack, const void *address, int size);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

1202

heap_free(void* address)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

1204

if (!guarded_heap_free(address))

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

1205

panic("free failed for address %p", address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

1210

heap_realloc(void* address, size_t newSize)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

1213

free(address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

1217

if (address == NULL)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

1220

return guarded_heap_realloc(address, newSize);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

204

static void dump_guarded_heap_page(void* address, bool doPanic = false);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

226

guarded_heap_page_protect_raw(addr_t address, size_t size, uint32 protection)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

228

mprotect((void*)address, size, protection);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

230

madvise((void*)address, size, MADV_FREE);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

232

memset((void*)address, 0xcc, size);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

254

addr_t address = stackTrace[i];

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

257

(void*)address, NULL, NULL, &imageName, &symbolName, NULL,

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

260

print_stdout("\t%#" B_PRIxADDR " (lookup failed: %s)\n", address,

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

266

address - (addr_t)location, exactMatch ? "" : " (nearest)");

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

522

void* address = NULL;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

523

area_id area = create_area("guarded_heap_huge_allocation", &address,

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

533

guarded_heap_page* page = (guarded_heap_page*)address;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

537

page->allocation_base = (void*)(((addr_t)address

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

549

(addr_t)address + pagesNeeded * B_PAGE_SIZE, B_PAGE_SIZE, 0);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

552

addr_t protectedStart = (addr_t)address + B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

561

protectedSize = (addr_t)address + (pagesNeeded + 1) * B_PAGE_SIZE

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

615

guarded_heap_get_locked_area_for(guarded_heap& heap, void* address)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

620

if ((addr_t)address < area->base)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

623

if ((addr_t)address >= area->base + area->size)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

635

guarded_heap_area_page_index_for(guarded_heap_area& area, void* address)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

637

size_t pageIndex = ((addr_t)address - area.base) / B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

641

" which is not marked in use", address, pageIndex);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

647

" which is a guard page", address, pageIndex);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

653

" which is not an allocation first page", address, pageIndex);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

659

" which is a dead page", address, pageIndex);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

668

guarded_heap_area_free(guarded_heap_area& area, void* address)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

670

size_t pageIndex = guarded_heap_area_page_index_for(area, address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

707

guarded_heap_area_allocation_for(void* address, area_id& allocationArea)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

709

allocationArea = area_for(address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

719

address, allocationArea);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

726

guarded_heap_page* page = (guarded_heap_page*)areaInfo.address;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

732

if (page->allocation_base != address)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

742

guarded_heap_free_area_allocation(void* address)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

745

if (guarded_heap_area_allocation_for(address, allocationArea) == NULL)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

754

guarded_heap_free(void* address)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

756

if (address == NULL)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

760

address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

762

return guarded_heap_free_area_allocation(address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

765

return guarded_heap_area_free(*area, address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

770

guarded_heap_realloc(void* address, size_t newSize)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

773

address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

779

size_t pageIndex = guarded_heap_area_page_index_for(*area, address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

787

guarded_heap_page* page = guarded_heap_area_allocation_for(address,

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

796

return address;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

803

memcpy(newBlock, address, min_c(oldSize, newSize));

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

809

guarded_heap_area_free(*area, address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

842

dump_guarded_heap_page(void* address, bool doPanic)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

849

if ((addr_t)address < candidate->base)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

851

if ((addr_t)address >= candidate->base + candidate->size)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

859

panic("didn't find area for address %p\n", address);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

863

size_t pageIndex = ((addr_t)address - area->base) / B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

889

find_thread(NULL), address, page.allocation_base, \

src/system/libroot/posix/malloc/debug/heap.cpp

1008

heap_add_leak_check_info(addr_t address, size_t allocated, size_t size)

src/system/libroot/posix/malloc/debug/heap.cpp

1011

heap_leak_check_info *info = (heap_leak_check_info *)(address + allocated

src/system/libroot/posix/malloc/debug/heap.cpp

1016

addr_t wallAddress = address + size;

src/system/libroot/posix/malloc/debug/heap.cpp

1038

addr_t address = firstPage->area->base + firstPage->index * heap->page_size;

src/system/libroot/posix/malloc/debug/heap.cpp

1039

heap_add_leak_check_info(address, pageCount * heap->page_size, size);

src/system/libroot/posix/malloc/debug/heap.cpp

1040

return (void *)address;

src/system/libroot/posix/malloc/debug/heap.cpp

1087

void *address = NULL;

src/system/libroot/posix/malloc/debug/heap.cpp

1090

address = page->free_list;

src/system/libroot/posix/malloc/debug/heap.cpp

1094

address = (void *)(page->area->base + page->index * heap->page_size

src/system/libroot/posix/malloc/debug/heap.cpp

1108

heap_add_leak_check_info((addr_t)address, bin->element_size, size);

src/system/libroot/posix/malloc/debug/heap.cpp

1109

return address;

src/system/libroot/posix/malloc/debug/heap.cpp

1126

void *address = NULL;

src/system/libroot/posix/malloc/debug/heap.cpp

1139

address = heap_allocate_from_bin(heap, i, size);

src/system/libroot/posix/malloc/debug/heap.cpp

1146

address = heap_allocate_from_bin(heap, i, size);

src/system/libroot/posix/malloc/debug/heap.cpp

1153

if (address == NULL)

src/system/libroot/posix/malloc/debug/heap.cpp

1154

address = heap_raw_alloc(heap, size, alignment);

src/system/libroot/posix/malloc/debug/heap.cpp

1159

size, address));

src/system/libroot/posix/malloc/debug/heap.cpp

1161

if (address == NULL)

src/system/libroot/posix/malloc/debug/heap.cpp

1162

return address;

src/system/libroot/posix/malloc/debug/heap.cpp

1164

memset(address, 0xcc, size);

src/system/libroot/posix/malloc/debug/heap.cpp

1168

if (((uint32 *)address)[1] == 0xdeadbeef)

src/system/libroot/posix/malloc/debug/heap.cpp

1169

((uint32 *)address)[1] = 0xcccccccc;

src/system/libroot/posix/malloc/debug/heap.cpp

1171

return address;

src/system/libroot/posix/malloc/debug/heap.cpp

1176

heap_free(heap_allocator *heap, void *address)

src/system/libroot/posix/malloc/debug/heap.cpp

1178

if (address == NULL)

src/system/libroot/posix/malloc/debug/heap.cpp

1187

if (area->base <= (addr_t)address) {

src/system/libroot/posix/malloc/debug/heap.cpp

1188

if ((addr_t)address >= area->base + area->size) {

src/system/libroot/posix/malloc/debug/heap.cpp

1206

INFO(("free(): asked to free pointer %p\n", address));

src/system/libroot/posix/malloc/debug/heap.cpp

1208

heap_page *page = &area->page_table[((addr_t)address - area->base)

src/system/libroot/posix/malloc/debug/heap.cpp

1224

if (((addr_t)address - pageBase) % bin->element_size != 0) {

src/system/libroot/posix/malloc/debug/heap.cpp

1226

" for page base %p and element size %" B_PRIu32 "\n", address,

src/system/libroot/posix/malloc/debug/heap.cpp

1233

if (((uint32 *)address)[1] == 0xdeadbeef) {

src/system/libroot/posix/malloc/debug/heap.cpp

1238

if (temp == address) {

src/system/libroot/posix/malloc/debug/heap.cpp

1240

" list (double free)\n", address);

src/system/libroot/posix/malloc/debug/heap.cpp

1246

heap_leak_check_info *info = (heap_leak_check_info *)((addr_t)address

src/system/libroot/posix/malloc/debug/heap.cpp

1257

addr_t wallAddress = (addr_t)address + info->size;

src/system/libroot/posix/malloc/debug/heap.cpp

1263

address, info->size, info->thread, wallValue);

src/system/libroot/posix/malloc/debug/heap.cpp

1268

uint32 *dead = (uint32 *)address;

src/system/libroot/posix/malloc/debug/heap.cpp

1274

*(addr_t *)address = (addr_t)page->free_list;

src/system/libroot/posix/malloc/debug/heap.cpp

1275

page->free_list = (addr_t *)address;

src/system/libroot/posix/malloc/debug/heap.cpp

1308

if ((addr_t)address != pageBase) {

src/system/libroot/posix/malloc/debug/heap.cpp

1310

address, (void *)pageBase);

src/system/libroot/posix/malloc/debug/heap.cpp

1339

heap_leak_check_info *info = (heap_leak_check_info *)((addr_t)address

src/system/libroot/posix/malloc/debug/heap.cpp

1350

addr_t wallAddress = (addr_t)address + info->size;

src/system/libroot/posix/malloc/debug/heap.cpp

1355

address, info->size, info->thread, wallValue);

src/system/libroot/posix/malloc/debug/heap.cpp

1358

uint32 *dead = (uint32 *)address;

src/system/libroot/posix/malloc/debug/heap.cpp

1391

heap_realloc(heap_allocator *heap, void *address, void **newAddress,

src/system/libroot/posix/malloc/debug/heap.cpp

1401

if (area->base <= (addr_t)address) {

src/system/libroot/posix/malloc/debug/heap.cpp

1402

if ((addr_t)address >= area->base + area->size) {

src/system/libroot/posix/malloc/debug/heap.cpp

1420

INFO(("realloc(address = %p, newSize = %" B_PRIuSIZE ")\n", address, newSize));

src/system/libroot/posix/malloc/debug/heap.cpp

1422

heap_page *page = &area->page_table[((addr_t)address - area->base)

src/system/libroot/posix/malloc/debug/heap.cpp

1461

heap_leak_check_info *info = (heap_leak_check_info *)((addr_t)address

src/system/libroot/posix/malloc/debug/heap.cpp

1464

*newAddress = address;

src/system/libroot/posix/malloc/debug/heap.cpp

1468

addr_t wallAddress = (addr_t)address + newSize;

src/system/libroot/posix/malloc/debug/heap.cpp

1486

memcpy(*newAddress, address, min_c(maxSize, newSize));

src/system/libroot/posix/malloc/debug/heap.cpp

1487

heap_free(heap, address);

src/system/libroot/posix/malloc/debug/heap.cpp

1509

heap_get_allocation_info(heap_allocator *heap, void *address, size_t *size,

src/system/libroot/posix/malloc/debug/heap.cpp

1518

if (area->base <= (addr_t)address) {

src/system/libroot/posix/malloc/debug/heap.cpp

1519

if ((addr_t)address >= area->base + area->size) {

src/system/libroot/posix/malloc/debug/heap.cpp

1537

heap_page *page = &area->page_table[((addr_t)address - area->base)

src/system/libroot/posix/malloc/debug/heap.cpp

1551

if (((addr_t)address - pageBase) % bin->element_size != 0) {

src/system/libroot/posix/malloc/debug/heap.cpp

1554

address, (void *)pageBase, bin->element_size);

src/system/libroot/posix/malloc/debug/heap.cpp

1560

info = (heap_leak_check_info *)((addr_t)address + bin->element_size

src/system/libroot/posix/malloc/debug/heap.cpp

1571

if ((addr_t)address != pageBase) {

src/system/libroot/posix/malloc/debug/heap.cpp

1573

" page base %p\n", address, (void *)pageBase);

src/system/libroot/posix/malloc/debug/heap.cpp

1592

info = (heap_leak_check_info *)((addr_t)address + allocationSize

src/system/libroot/posix/malloc/debug/heap.cpp

1619

void *address = NULL;

src/system/libroot/posix/malloc/debug/heap.cpp

1620

area_id heapArea = create_area(name, &address, B_ANY_ADDRESS, size,

src/system/libroot/posix/malloc/debug/heap.cpp

1627

heap_add_area(heap, heapArea, (addr_t)address, size);

src/system/libroot/posix/malloc/debug/heap.cpp

1730

void *address = NULL;

src/system/libroot/posix/malloc/debug/heap.cpp

1731

area_id allocationArea = create_area("guarded area", &address,

src/system/libroot/posix/malloc/debug/heap.cpp

1739

if (mprotect((void *)((addr_t)address + areaSize - B_PAGE_SIZE),

src/system/libroot/posix/malloc/debug/heap.cpp

1746

area_allocation_info *info = (area_allocation_info *)address;

src/system/libroot/posix/malloc/debug/heap.cpp

1749

info->base = address;

src/system/libroot/posix/malloc/debug/heap.cpp

1757

address = (void *)((addr_t)address + areaSize - B_PAGE_SIZE - size);

src/system/libroot/posix/malloc/debug/heap.cpp

1762

info->allocation_base = address;

src/system/libroot/posix/malloc/debug/heap.cpp

1764

memset(address, 0xcc, size);

src/system/libroot/posix/malloc/debug/heap.cpp

1765

return address;

src/system/libroot/posix/malloc/debug/heap.cpp

1770

debug_heap_get_allocation_info(void *address, size_t *size,

src/system/libroot/posix/malloc/debug/heap.cpp

1775

if (heap_get_allocation_info(heap, address, size, thread) == B_OK)

src/system/libroot/posix/malloc/debug/heap.cpp

1781

area_id area = area_for(address);

src/system/libroot/posix/malloc/debug/heap.cpp

1783

area_allocation_info *info = (area_allocation_info *)areaInfo.address;

src/system/libroot/posix/malloc/debug/heap.cpp

1787

&& info->size == areaInfo.size && info->base == areaInfo.address

src/system/libroot/posix/malloc/debug/heap.cpp

1852

void *address = NULL;

src/system/libroot/posix/malloc/debug/heap.cpp

1853

area_id allocationArea = create_area("memalign area", &address,

src/system/libroot/posix/malloc/debug/heap.cpp

1861

area_allocation_info *info = (area_allocation_info *)address;

src/system/libroot/posix/malloc/debug/heap.cpp

1864

info->base = address;

src/system/libroot/posix/malloc/debug/heap.cpp

1870

address = (void *)((addr_t)address + sizeof(area_allocation_info));

src/system/libroot/posix/malloc/debug/heap.cpp

1872

address = (void *)ROUNDUP((addr_t)address, alignment);

src/system/libroot/posix/malloc/debug/heap.cpp

1873

ASSERT((addr_t)address % alignment == 0);

src/system/libroot/posix/malloc/debug/heap.cpp

1874

ASSERT((addr_t)address + size - 1 < (addr_t)info + areaSize - 1);

src/system/libroot/posix/malloc/debug/heap.cpp

1880

info->allocation_base = address;

src/system/libroot/posix/malloc/debug/heap.cpp

1882

memset(address, 0xcc, size);

src/system/libroot/posix/malloc/debug/heap.cpp

1883

return address;

src/system/libroot/posix/malloc/debug/heap.cpp

1923

debug_heap_free(void *address)

src/system/libroot/posix/malloc/debug/heap.cpp

1927

if (heap_free(heap, address) == B_OK) {

src/system/libroot/posix/malloc/debug/heap.cpp

1936

area_id area = area_for(address);

src/system/libroot/posix/malloc/debug/heap.cpp

1938

area_allocation_info *info = (area_allocation_info *)areaInfo.address;

src/system/libroot/posix/malloc/debug/heap.cpp

1942

&& info->size == areaInfo.size && info->base == areaInfo.address

src/system/libroot/posix/malloc/debug/heap.cpp

1951

panic("free(): free failed for address %p\n", address);

src/system/libroot/posix/malloc/debug/heap.cpp

1956

debug_heap_realloc(void *address, size_t newSize)

src/system/libroot/posix/malloc/debug/heap.cpp

1958

if (address == NULL)

src/system/libroot/posix/malloc/debug/heap.cpp

1962

free(address);

src/system/libroot/posix/malloc/debug/heap.cpp

1969

if (heap_realloc(heap, address, &newAddress, newSize) == B_OK) {

src/system/libroot/posix/malloc/debug/heap.cpp

1978

area_id area = area_for(address);

src/system/libroot/posix/malloc/debug/heap.cpp

1980

area_allocation_info *info = (area_allocation_info *)areaInfo.address;

src/system/libroot/posix/malloc/debug/heap.cpp

1984

&& info->size == areaInfo.size && info->base == areaInfo.address

src/system/libroot/posix/malloc/debug/heap.cpp

2015

return address;

src/system/libroot/posix/malloc/debug/heap.cpp

2027

memcpy(newAddress, address, min_c(newSize, info->allocation_size));

src/system/libroot/posix/malloc/debug/heap.cpp

2036

panic("realloc(): failed to realloc address %p to size %" B_PRIuSIZE "\n", address,

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

117

heap_debug_get_allocation_info(void *address, size_t *size,

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

121

return sCurrentHeap->get_allocation_info(address, size, thread);

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

263

free(void* address)

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

265

sCurrentHeap->free(address);

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

270

realloc(void* address, size_t newSize)

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

272

return sCurrentHeap->realloc(address, newSize);

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

282

void* address = malloc(numElements * size);

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

283

if (address != NULL)

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

284

memset(address, 0, numElements * size);

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

286

return address;

src/system/libroot/posix/malloc/debug/malloc_debug_api.h

18

void (*free)(void* address);

src/system/libroot/posix/malloc/debug/malloc_debug_api.h

19

void* (*realloc)(void* address, size_t newSize);

src/system/libroot/posix/malloc/debug/malloc_debug_api.h

39

status_t (*get_allocation_info)(void* address, size_t *size,

src/system/libroot/posix/malloc/hoard2/arch-specific.cpp

178

void *address = (void *)chunk;

src/system/libroot/posix/malloc/hoard2/arch-specific.cpp

204

return address;

src/system/libroot/posix/malloc/hoard2/block.h

117

setCallStack(int index, void *address)

src/system/libroot/posix/malloc/hoard2/block.h

119

_callStack[index] = address;

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

146

add_address(void* address, size_t size)

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

148

block *b = (block *)address - 1;

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

180

remove_address(void* address)

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

182

block* b = (block *)address - 1;

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

56

get_symbol_for_address(void* address, char *imageBuffer, size_t imageBufferSize,

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

64

if (((addr_t)info.text > (addr_t)address

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

65

|| (addr_t)info.text + info.text_size < (addr_t)address)

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

66

&& ((addr_t)info.data > (addr_t)address

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

67

|| (addr_t)info.data + info.data_size < (addr_t)address))

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

77

if ((addr_t)address >= (addr_t)location) {

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

79

int32 newOffset = (addr_t)address - (addr_t)location;

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

104

address = _Use(chunk, allocate);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

117

address = _Use(chunk, allocate);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

124

const addr_t address = (addr_t)_address;

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

128

FreeChunk* chunk = fChunksByAddressTree.FindClosest(address, false, true);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

129

if (chunk != NULL && chunk->NextAddress() > address) {

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

131

size_t remainingAfter = chunk->size - (address - (addr_t)chunk);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

145

if (address == (addr_t)chunk) {

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

157

if (address == fLastAreaTop) {

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

169

if (address >= (fLastAreaTop - fLastAreaSize) && address < fLastAreaTop) {

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

178

info.area = area_for((void*)(address - 1));

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

186

if (((addr_t)info.address + info.size) != address)

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

229

&& (info.address == freedChunk

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

230

|| ((addr_t)info.address + info.size) == freedChunk->NextAddress()))) {

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

299

const addr_t address = (addr_t)_address;

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

302

FreeChunk* preceding = fChunksByAddressTree.FindClosest(address, false, false);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

303

if (preceding != NULL && preceding->NextAddress() == address) {

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

422

const addr_t address = (addr_t)chunk;

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

423

const addr_t top = address + size;

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

426

if (address <= lastAreaBase && top >= fLastAreaTop) {

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

444

} else if (address == lastAreaBase) {

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

450

} else if (address >= lastAreaBase && address < fLastAreaTop) {

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

512

addr_t address;

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

533

return ChunksByAddressTreeDefinition::Compare(key.address, node);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

592

__allocate_pages(void** address, size_t length, int flags, uint8* cleared)

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

598

return sPagesAllocator->AllocatePagesAt(*address, length, *(bool*)cleared);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

601

return sPagesAllocator->AllocatePages(length, *address, *(bool*)cleared);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

606

__free_pages(void* address, size_t length)

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

612

sPagesAllocator->FreePages(address, length);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

81

status_t AllocatePages(size_t allocate, void*& address, bool& cleared)

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

89

&address, B_ANY_ADDRESS, allocate,

src/system/libroot/posix/malloc/openbsd/PagesAllocator.h

21

status_t __allocate_pages(void** address, size_t length, int flags, uint8* cleared);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.h

22

status_t __free_pages(void* address, size_t length);

src/system/libroot/posix/malloc/openbsd/wrapper.c

101

malloc_mmap(void* address, size_t length, int protection, int flags, int fd, off_t offset)

src/system/libroot/posix/malloc/openbsd/wrapper.c

108

status = __allocate_pages(&address, length, flags, &cleared);

src/system/libroot/posix/malloc/openbsd/wrapper.c

115

memset(address, 0, length);

src/system/libroot/posix/malloc/openbsd/wrapper.c

116

return address;

src/system/libroot/posix/malloc/openbsd/wrapper.c

122

malloc_munmap(void* address, size_t length)

src/system/libroot/posix/malloc/openbsd/wrapper.c

124

status_t status = __free_pages(address, length);

src/system/libroot/posix/malloc/openbsd/wrapper.c

39

const uintptr_t address = (uintptr_t)&address;

src/system/libroot/posix/malloc/openbsd/wrapper.c

40

uint32_t random = (uint32_t)address * 1103515245;

src/system/libroot/posix/malloc/openbsd/wrapper.c

81

malloc_mprotect(void* address, size_t length, int protection)

src/system/libroot/posix/malloc/openbsd/wrapper.c

90

mimmutable(void* address, size_t length)

src/system/libroot/posix/stdlib/exit.cpp

113

addr_t address = (addr_t)info->hook;

src/system/libroot/posix/stdlib/exit.cpp

114

return info->dsoHandle == NULL && address >= fStart && address <= fEnd;

src/system/libroot/posix/sys/mman.cpp

122

else if (address != NULL)

src/system/libroot/posix/sys/mman.cpp

150

area_id area = _kern_map_file(areaName, &address, addressSpec,

src/system/libroot/posix/sys/mman.cpp

157

return address;

src/system/libroot/posix/sys/mman.cpp

162

munmap(void* address, size_t length)

src/system/libroot/posix/sys/mman.cpp

164

RETURN_AND_SET_ERRNO(_kern_unmap_memory(address, length));

src/system/libroot/posix/sys/mman.cpp

169

mprotect(void* address, size_t length, int protection)

src/system/libroot/posix/sys/mman.cpp

171

RETURN_AND_SET_ERRNO(_kern_set_memory_protection(address, length,

src/system/libroot/posix/sys/mman.cpp

177

msync(void* address, size_t length, int flags)

src/system/libroot/posix/sys/mman.cpp

179

RETURN_AND_SET_ERRNO_TEST_CANCEL(_kern_sync_memory(address, length, flags));

src/system/libroot/posix/sys/mman.cpp

184

madvise(void* address, size_t length, int advice)

src/system/libroot/posix/sys/mman.cpp

186

RETURN_AND_SET_ERRNO(_kern_memory_advice(address, length, advice));

src/system/libroot/posix/sys/mman.cpp

191

posix_madvise(void* address, size_t length, int advice)

src/system/libroot/posix/sys/mman.cpp

193

return madvise(address, length, advice);

src/system/libroot/posix/sys/mman.cpp

198

mlock(const void* address, size_t length)

src/system/libroot/posix/sys/mman.cpp

200

RETURN_AND_SET_ERRNO(_kern_mlock(address, length));

src/system/libroot/posix/sys/mman.cpp

205

munlock(const void* address, size_t length)

src/system/libroot/posix/sys/mman.cpp

207

RETURN_AND_SET_ERRNO(_kern_munlock(address, length));

src/system/libroot/posix/sys/mman.cpp

92

mmap(void* address, size_t length, int protection, int flags, int fd,

src/system/libroot/posix/unistd/brk.c

116

resize_area_to_address(area_info *a_info, void *address)

src/system/libroot/posix/unistd/brk.c

118

size_t new_size = (uint8_t *)address - (uint8_t *)(a_info->address);

src/system/libroot/posix/unistd/brk.c

146

next_area_address = (uint8_t *)base_area_info->address

src/system/libroot/posix/unistd/brk.c

162

if (addr <= base_area_info->address) {

src/system/libroot/posix/unistd/brk.c

195

&& addr > base_area_info.address

src/system/libroot/posix/unistd/brk.c

196

&& program_break_within_resource_limits(addr, base_area_info.address))

src/system/libroot/posix/unistd/brk.c

237

next_area = area_for((uint8_t *)(next_area_info.address)

src/system/libroot/posix/unistd/brk.c

245

program_break = (uint8_t *)(next_area_info.address)

src/system/libroot/posix/unistd/brk.c

254

base_area_info.address)

src/system/runtime_loader/commpage.cpp

110

if (location <= (addr_t)address && location >= foundLocation) {

src/system/runtime_loader/commpage.cpp

115

if (location + symbol->st_size > (addr_t)address) {

src/system/runtime_loader/commpage.cpp

46

get_nearest_commpage_symbol_at_address_locked(void* address, image_id* _imageID, char** _imagePath,

src/system/runtime_loader/commpage.h

14

status_t get_nearest_commpage_symbol_at_address_locked(void* address,

src/system/runtime_loader/elf.cpp

855

get_nearest_symbol_at_address(void* address, image_id* _imageID,

src/system/runtime_loader/elf.cpp

861

image_t* image = find_loaded_image_by_address((addr_t)address);

src/system/runtime_loader/elf.cpp

867

if ((addr_t)address >= commpageBegin && (addr_t)address < commpageEnd) {

src/system/runtime_loader/elf.cpp

868

return get_nearest_commpage_symbol_at_address_locked(address, _imageID, _imagePath,

src/system/runtime_loader/elf.cpp

897

if (location <= (addr_t)address && location >= foundLocation) {

src/system/runtime_loader/elf.cpp

902

if (location + symbol->st_size > (addr_t)address) {

src/system/runtime_loader/elf_tls.h

18

inline TLSBlockTemplate(void* address, size_t fileSize,

src/system/runtime_loader/elf_tls.h

62

TLSBlockTemplate::TLSBlockTemplate(void* address, size_t fileSize,

src/system/runtime_loader/elf_tls.h

65

fAddress(address),

src/system/runtime_loader/heap.cpp

153

void* address = malloc(numElements * size);

src/system/runtime_loader/heap.cpp

154

if (address != NULL)

src/system/runtime_loader/heap.cpp

155

memset(address, 0, numElements * size);

src/system/runtime_loader/heap.cpp

157

return address;

src/system/runtime_loader/images.cpp

644

find_loaded_image_by_address(addr_t address)

src/system/runtime_loader/images.cpp

649

if (region.vmstart <= address

src/system/runtime_loader/images.cpp

650

&& region.vmstart - 1 + region.vmsize >= address)

src/system/runtime_loader/images.h

70

image_t* find_loaded_image_by_address(addr_t address);

src/system/runtime_loader/runtime_loader_private.h

79

status_t get_nearest_symbol_at_address(void* address, image_id* _imageID,

src/tests/add-ons/accelerants/intel_extreme/intel_reg.cpp

133

uint64_t address;

src/tests/add-ons/accelerants/intel_extreme/intel_reg.cpp

135

address = strtol(arg + 2, (char **)NULL, 16);

src/tests/add-ons/accelerants/intel_extreme/intel_reg.cpp

137

address = strtol(arg, (char **)NULL, 10);

src/tests/add-ons/accelerants/intel_extreme/intel_reg.cpp

138

if (address == 0 && errno != 0)

src/tests/add-ons/accelerants/intel_extreme/intel_reg.cpp

142

addr_t addr = (addr_t)regs + address + i * sizeof(uint32);

src/tests/add-ons/accelerants/intel_extreme/intel_reg.cpp

146

printf("(0x%08" B_PRIxADDR "): 0x%08" B_PRIx32 "\n", address + i * sizeof(uint32), *(uint32*)addr);

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

211

void *address;

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

212

area_id area = create_area("test", &address, B_ANY_ADDRESS, 2 * B_PAGE_SIZE,

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

214

printf("Area %ld, address %p\n", area, address);

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

37

get_memory_map(const void* address, ulong numBytes, physical_entry* table,

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

40

table[0].address = (void *)((addr_t)address - 0x100000);

src/tests/add-ons/kernel/kernelland_emu/misc.cpp

43

free_etc(void* address, uint32 flags)

src/tests/add-ons/kernel/kernelland_emu/misc.cpp

45

free(address);

src/tests/add-ons/mail/imap/imap_tester.cpp

291

BNetworkAddress address(AF_INET, server, port);

src/tests/add-ons/mail/imap/imap_tester.cpp

293

useSSL ? " with SSL" : "", address.Port());

src/tests/add-ons/mail/imap/imap_tester.cpp

295

status_t status = sProtocol.Connect(address, user, password, useSSL);

src/tests/kits/media/AreaTest.cpp

36

adr = (char *)info.address;

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

51

BNetworkAddress address;

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

53

CPPUNIT_ASSERT(address.SetTo("127.0.0.1") == B_OK);

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

54

CPPUNIT_ASSERT(address.Family() == AF_INET);

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

55

CPPUNIT_ASSERT(address == BNetworkAddress(htonl(INADDR_LOOPBACK)));

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

57

CPPUNIT_ASSERT(address.SetTo("::1", (uint16)0,

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

59

CPPUNIT_ASSERT(address.Family() == AF_INET6);

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

60

CPPUNIT_ASSERT(address == BNetworkAddress(in6addr_loopback));

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

62

CPPUNIT_ASSERT(address.SetTo(AF_INET, "::1") != B_OK);

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

63

CPPUNIT_ASSERT(address.SetTo(AF_INET6, "127.0.0.1") != B_OK);

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

64

CPPUNIT_ASSERT(address.SetTo(AF_INET, "127.0.0.1") == B_OK);

src/tests/kits/net/libnetapi/NetworkAddressTest.cpp

65

CPPUNIT_ASSERT(address.SetTo(AF_INET6, "::1", (uint16)0,

src/tests/kits/net/wlan_test.cpp

46

" %s\n", network.name, network.address.ToString().String(),

src/tests/system/boot/loader/platform_mmu.cpp

19

void *address = malloc(size);

src/tests/system/boot/loader/platform_mmu.cpp

20

if (address == NULL)

src/tests/system/boot/loader/platform_mmu.cpp

23

*_address = address;

src/tests/system/boot/loader/platform_mmu.cpp

29

platform_free_region(void *address, size_t size)

src/tests/system/boot/loader/platform_mmu.cpp

31

free(address);

src/tests/system/boot/loader/platform_mmu.cpp

37

platform_bootloader_address_to_kernel_address(void *address, addr_t *_result)

src/tests/system/boot/loader/platform_mmu.cpp

39

*_result = (addr_t)address;

src/tests/system/boot/loader/platform_mmu.cpp

45

platform_kernel_address_to_bootloader_address(addr_t address, void **_result)

src/tests/system/boot/loader/platform_mmu.cpp

47

*_result = (void*)address;

src/tests/system/kernel/device_manager/dma_resource_test.cpp

254

fPhysicalDataBase = (addr_t)entry[0].address;

src/tests/system/kernel/device_manager/dma_resource_test.cpp

255

fSecondPhysicalDataBase = (addr_t)entry[1].address;

src/tests/system/kernel/device_manager/dma_resource_test.cpp

259

(void*)fDataBase, entry[0].address, entry[1].address);

src/tests/system/kernel/device_manager/dma_resource_test.cpp

276

fPhysicalDataBase = (addr_t)entry.address;

src/tests/system/kernel/device_manager/dma_resource_test.cpp

280

(void*)fDataBase, entry.address);

src/tests/system/kernel/device_manager/dma_resource_test.cpp

312

Test::AddSource(addr_t address, size_t length)

src/tests/system/kernel/device_manager/dma_resource_test.cpp

315

|| address < B_PAGE_SIZE) {

src/tests/system/kernel/device_manager/dma_resource_test.cpp

318

? fSuite.DataBase() : fSuite.PhysicalDataBase()) + address;

src/tests/system/kernel/device_manager/dma_resource_test.cpp

321

= fSuite.SecondPhysicalDataBase() + address;

src/tests/system/kernel/device_manager/dma_resource_test.cpp

349

target.address = base;

src/tests/system/kernel/device_manager/dma_resource_test.cpp

602

generic_addr_t address;

src/tests/system/kernel/device_manager/dma_resource_test.cpp

604

address = target.address

src/tests/system/kernel/device_manager/dma_resource_test.cpp

606

} else if (fSuite.IsContiguous() || target.address < B_PAGE_SIZE) {

src/tests/system/kernel/device_manager/dma_resource_test.cpp

607

address = target.address + fSuite.PhysicalDataBase();

src/tests/system/kernel/device_manager/dma_resource_test.cpp

609

address = target.address - B_PAGE_SIZE

src/tests/system/kernel/device_manager/dma_resource_test.cpp

613

if (address != vec.base) {

src/tests/system/kernel/device_manager/dma_resource_test.cpp

615

", should be %#" B_PRIuGENADDR "", i, vec.base, address);

src/tests/system/kernel/device_manager/dma_resource_test.cpp

689

dprintf(" [%p, %lu, %d]\n", (void*)target.address, target.length,

src/tests/system/kernel/device_manager/dma_resource_test.cpp

90

addr_t address;

src/tests/system/kernel/vm/mmap_resize_test.cpp

41

void* address = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

src/tests/system/kernel/vm/mmap_resize_test.cpp

42

if (address == MAP_FAILED) {

src/tests/system/kernel/vm/mmap_resize_test.cpp

56

*(int*)address = 42;

src/tests/system/kernel/vm/page_fault_cache_merge_test.cpp

18

uint8* address;

src/tests/system/kernel/vm/page_fault_cache_merge_test.cpp

19

area_id area = create_area("test area", (void**)&address, B_ANY_ADDRESS,

src/tests/system/kernel/vm/page_fault_cache_merge_test.cpp

29

address[i * B_PAGE_SIZE] = 42;

src/tests/system/kernel/vm/page_fault_cache_merge_test.cpp

42

delete_area(area_for(address));

src/tests/system/kernel/vm/page_fault_cache_merge_test.cpp

51

address[i * B_PAGE_SIZE] = 42;

src/tests/system/kernel/vm/set_area_protection_test1.cpp

18

create_test_area(const char* name, int** address, uint32 protection)

src/tests/system/kernel/vm/set_area_protection_test1.cpp

20

area_id area = create_area(name, (void**)address, B_ANY_ADDRESS,

src/tests/system/kernel/vm/set_area_protection_test1.cpp

33

clone_test_area(const char* name, int** address, uint32 protection,

src/tests/system/kernel/vm/set_area_protection_test1.cpp

36

area_id area = clone_area(name, (void**)address, B_ANY_ADDRESS,

src/tests/system/kernel/vm/transfer_area_test.cpp

34

char *address;

src/tests/system/kernel/vm/transfer_area_test.cpp

35

area = create_area("test transfer area", (void **)&address,

src/tests/system/kernel/vm/transfer_area_test.cpp

42

sprintf(address, "Oh my god - it's working! (%s)", argv[1]);

src/tests/system/kernel/vm/transfer_area_test.cpp

44

area_id targetArea = _kern_transfer_area(area, (void **)&address,

src/tests/system/kernel/vm/transfer_area_test.cpp

78

info.name, info.address, info.size, info.team);

src/tests/system/kernel/vm/transfer_area_test.cpp

79

printf(" contents: %s\n", (char *)info.address);

src/tests/system/libroot/posix/brk_test.c

34

next_area_address = (uint8_t *)(next_area_info.address)

src/tests/system/libroot/posix/brk_test.c

38

next_area_info.area, next_area_info.address,

src/tests/system/libroot/posix/brk_test.c

51

output_data_segment_info(void *address)

src/tests/system/libroot/posix/brk_test.c

54

output_area_info(address);

src/tests/system/libroot/posix/memalign_test.cpp

16

sum(addr_t address)

src/tests/system/libroot/posix/memalign_test.cpp

18

return (address >> 24) | (address >> 16) | (address >> 8) | address;

src/tests/system/libroot/posix/memalign_test.cpp

23

write_test_pattern(void *address, size_t size)

src/tests/system/libroot/posix/memalign_test.cpp

26

*((uint8 *)address + i) = sum((addr_t)address + i);

src/tests/system/libroot/posix/memalign_test.cpp

31

verify_test_pattern(void *address, size_t size)

src/tests/system/libroot/posix/memalign_test.cpp

34

if (*((uint8 *)address + i) != sum((addr_t)address + i)) {

src/tests/system/libroot/posix/memalign_test.cpp

36

(uint8 *)address + i, *((uint8 *)address + i),

src/tests/system/libroot/posix/memalign_test.cpp

37

sum((addr_t)address + i));

src/tests/system/libroot/posix/realtime_sem_test1.cpp

1001

assert_posix_success(munmap(address, 4096));

src/tests/system/libroot/posix/realtime_sem_test1.cpp

885

void* address = mmap(NULL, 4096, PROT_READ | PROT_WRITE,

src/tests/system/libroot/posix/realtime_sem_test1.cpp

887

assert_posix_bool_success(address != MAP_FAILED);

src/tests/system/libroot/posix/realtime_sem_test1.cpp

891

sem_t* sem = (sem_t*)address;

src/tests/system/network/firefox_crash.cpp

110

if (peerAddress.sin_port != address.sin_port)

src/tests/system/network/firefox_crash.cpp

33

init_sockaddr(struct sockaddr_in& address, unsigned ipAddress, unsigned port)

src/tests/system/network/firefox_crash.cpp

35

memset(&address, 0, sizeof(sockaddr_in));

src/tests/system/network/firefox_crash.cpp

36

address.sin_family = AF_INET;

src/tests/system/network/firefox_crash.cpp

37

address.sin_port = htons(port);

src/tests/system/network/firefox_crash.cpp

38

address.sin_addr.s_addr = htonl(ipAddress);

src/tests/system/network/firefox_crash.cpp

53

sockaddr_in address;

src/tests/system/network/firefox_crash.cpp

71

init_sockaddr(address, INADDR_LOOPBACK, ntohs(listenAddress.sin_port));

src/tests/system/network/firefox_crash.cpp

73

if (connect(pair[0], (sockaddr*)&address, sizeof(sockaddr_in)) != 0

src/tests/system/network/firefox_crash.cpp

89

if (getsockname(pair[0], (sockaddr*)&address, &length) != 0)

src/tests/system/network/getpeername.cpp

47

sockaddr_in address;

src/tests/system/network/getpeername.cpp

48

memset(&address, 0, sizeof(sockaddr_in));

src/tests/system/network/getpeername.cpp

50

address.sin_family = AF_INET;

src/tests/system/network/getpeername.cpp

51

address.sin_port = htons(port);

src/tests/system/network/getpeername.cpp

52

address.sin_addr = *((struct in_addr*)host->h_addr);

src/tests/system/network/getpeername.cpp

60

if (connect(socket, (sockaddr*)&address, sizeof(sockaddr_in)) < 0) {

src/tests/system/network/ipv6/raw_server.cpp

25

sockaddr_storage address;

src/tests/system/network/ipv6/raw_server.cpp

26

socklen_t socklen = sizeof(address);

src/tests/system/network/ipv6/raw_server.cpp

27

memset(&address, 0, socklen);

src/tests/system/network/ipv6/raw_server.cpp

30

(sockaddr *) &address, &socklen);

src/tests/system/network/ipv6/raw_server.cpp

40

if (address.ss_family == AF_INET && status >= sizeof(struct ip))

src/tests/system/network/ipv6/udp_server.cpp

25

sockaddr_storage address;

src/tests/system/network/ipv6/udp_server.cpp

26

socklen_t socklen = sizeof(address);

src/tests/system/network/ipv6/udp_server.cpp

27

memset(&address, 0, socklen);

src/tests/system/network/ipv6/udp_server.cpp

30

(sockaddr *) &address, &socklen);

src/tests/system/network/multicast/multicat.c

183

char address[NI_MAXHOST], port[NI_MAXSERV];

src/tests/system/network/multicast/multicat.c

186

if (getnameinfo(raddr, rlen, address, sizeof(address), port,

src/tests/system/network/multicast/multicat.c

189

printf("Received %d bytes from [%s]:%s.\n", n, address, port);

src/tests/system/network/multicast/multicat.c

192

out_fd = open_packet_file(buf, n, address);

src/tests/system/network/multicast/multicat.c

323

static int open_packet_file(void *buf, int n, const char *address)

src/tests/system/network/multicast/multicat.c

329

snprintf(filename, sizeof(filename), "pkt-%lu-%s", counter++, address);

src/tests/system/network/posixnet/SocketTests.cpp

28

sockaddr_in address;

src/tests/system/network/posixnet/SocketTests.cpp

29

memset(&address, 0, sizeof(sockaddr_in));

src/tests/system/network/posixnet/SocketTests.cpp

30

address.sin_family = AF_INET;

src/tests/system/network/posixnet/SocketTests.cpp

31

address.sin_port = htons(kFirstPort);

src/tests/system/network/posixnet/SocketTests.cpp

32

address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

src/tests/system/network/posixnet/SocketTests.cpp

36

reinterpret_cast<const sockaddr *>(&address),

src/tests/system/network/posixnet/SocketTests.cpp

42

address.sin_port = htons(kSecondPort);

src/tests/system/network/posixnet/SocketTests.cpp

45

reinterpret_cast<const sockaddr *>(&address),

src/tests/system/network/tcp_shell/tcp_shell.cpp

1256

sockaddr_in address;

src/tests/system/network/tcp_shell/tcp_shell.cpp

1257

memset(&address, 0, sizeof(address));

src/tests/system/network/tcp_shell/tcp_shell.cpp

1258

address.sin_family = AF_INET;

src/tests/system/network/tcp_shell/tcp_shell.cpp

1259

address.sin_port = htons(1023);

src/tests/system/network/tcp_shell/tcp_shell.cpp

1260

address.sin_addr.s_addr = htonl(0xc0a80001);

src/tests/system/network/tcp_shell/tcp_shell.cpp

1263

(struct sockaddr *)&address, sizeof(struct sockaddr));

src/tests/system/network/tcp_shell/tcp_shell.cpp

1301

sockaddr_in address;

src/tests/system/network/tcp_shell/tcp_shell.cpp

1304

(struct sockaddr *)&address, &size, &connectionSocket);

src/tests/system/network/tcp_shell/tcp_shell.cpp

1310

printf("server: got connection from %08x\n", address.sin_addr.s_addr);

src/tests/system/network/tcp_shell/tcp_shell.cpp

1340

sockaddr_in address;

src/tests/system/network/tcp_shell/tcp_shell.cpp

1341

memset(&address, 0, sizeof(address));

src/tests/system/network/tcp_shell/tcp_shell.cpp

1342

address.sin_len = sizeof(sockaddr_in);

src/tests/system/network/tcp_shell/tcp_shell.cpp

1343

address.sin_family = AF_INET;

src/tests/system/network/tcp_shell/tcp_shell.cpp

1344

address.sin_port = htons(1024);

src/tests/system/network/tcp_shell/tcp_shell.cpp

1345

address.sin_addr.s_addr = INADDR_ANY;

src/tests/system/network/tcp_shell/tcp_shell.cpp

1347

status_t status = socket_bind(gServerSocket, (struct sockaddr*)&address,

src/tests/system/network/tcp_shell/tcp_shell.cpp

1425

sockaddr_in address;

src/tests/system/network/tcp_shell/tcp_shell.cpp

1426

memset(&address, 0, sizeof(address));

src/tests/system/network/tcp_shell/tcp_shell.cpp

1427

address.sin_family = AF_INET;

src/tests/system/network/tcp_shell/tcp_shell.cpp

1428

address.sin_port = htons(1023);

src/tests/system/network/tcp_shell/tcp_shell.cpp

1429

address.sin_addr.s_addr = htonl(0xc0a80001);

src/tests/system/network/tcp_shell/tcp_shell.cpp

1431

status_t status = socket_bind(gClientSocket, (struct sockaddr *)&address,

src/tests/system/network/tcp_shell/tcp_shell.cpp

1442

sockaddr_in address;

src/tests/system/network/tcp_shell/tcp_shell.cpp

1443

memset(&address, 0, sizeof(address));

src/tests/system/network/tcp_shell/tcp_shell.cpp

1444

address.sin_family = AF_INET;

src/tests/system/network/tcp_shell/tcp_shell.cpp

1445

address.sin_port = htons(port);

src/tests/system/network/tcp_shell/tcp_shell.cpp

1446

address.sin_addr.s_addr = htonl(0xc0a80001);

src/tests/system/network/tcp_shell/tcp_shell.cpp

1448

status_t status = socket_connect(gClientSocket, (struct sockaddr *)&address,

src/tests/system/network/tcp_shell/tcp_shell.cpp

338

socket_accept(net_socket *socket, struct sockaddr *address,

src/tests/system/network/tcp_shell/tcp_shell.cpp

347

if (address && *_addressLength > 0) {

src/tests/system/network/tcp_shell/tcp_shell.cpp

348

memcpy(address, &accepted->peer, min_c(*_addressLength,

src/tests/system/network/tcp_shell/tcp_shell.cpp

359

socket_bind(net_socket *socket, const struct sockaddr *address, socklen_t addressLength)

src/tests/system/network/tcp_shell/tcp_shell.cpp

362

if (address == NULL) {

src/tests/system/network/tcp_shell/tcp_shell.cpp

368

address = ∅

src/tests/system/network/tcp_shell/tcp_shell.cpp

372

if (socket->address.ss_len != 0) {

src/tests/system/network/tcp_shell/tcp_shell.cpp

374

(sockaddr *)&socket->address);

src/tests/system/network/tcp_shell/tcp_shell.cpp

379

memcpy(&socket->address, address, sizeof(sockaddr));

src/tests/system/network/tcp_shell/tcp_shell.cpp

382

(sockaddr *)address);

src/tests/system/network/tcp_shell/tcp_shell.cpp

385

socket->address.ss_len = 0;

src/tests/system/network/tcp_shell/tcp_shell.cpp

393

socket_connect(net_socket *socket, const struct sockaddr *address, socklen_t addressLength)

src/tests/system/network/tcp_shell/tcp_shell.cpp

395

if (address == NULL || addressLength == 0)

src/tests/system/network/tcp_shell/tcp_shell.cpp

398

if (socket->address.ss_len == 0) {

src/tests/system/network/tcp_shell/tcp_shell.cpp

405

return socket->first_info->connect(socket->first_protocol, address);

src/tests/system/network/tcp_shell/tcp_shell.cpp

426

if (socket->address.ss_len == 0) {

src/tests/system/network/tcp_shell/tcp_shell.cpp

445

memcpy(buffer->source, &socket->address, socket->address.ss_len);

src/tests/system/network/tcp_shell/tcp_shell.cpp

517

memcpy(&socket->address, &parent->address, parent->address.ss_len);

src/tests/system/network/tcp_shell/tcp_shell.cpp

770

get_route(struct net_domain *_domain, const struct sockaddr *address)

src/tests/system/network/tcp_shell/tcp_shell.cpp

772

if (is_server(address)) {

src/tests/system/network/tcp_shell/tcp_shell.cpp

848

domain_connect(net_protocol *protocol, const struct sockaddr *address)

src/tests/system/network/tcp_shell/tcp_shell.cpp

870

domain_bind(net_protocol *protocol, const struct sockaddr *address)

src/tests/system/network/tcp_shell/tcp_shell.cpp

872

memcpy(&protocol->socket->address, address, sizeof(struct sockaddr_in));

src/tests/system/network/tcp_shell/tcp_shell.cpp

873

protocol->socket->address.ss_len = sizeof(struct sockaddr_in);

src/tests/system/network/tcp_shell/tcp_shell.cpp

881

domain_unbind(net_protocol *protocol, struct sockaddr *address)

src/tests/system/network/tcp_shell/tcp_shell.cpp

951

domain_get_mtu(net_protocol *protocol, const struct sockaddr *address)

src/tools/anyboot/anyboot.cpp

100

address[1] |= (cylinders >> 2) & 0xc0;

src/tools/anyboot/anyboot.cpp

101

address[2] = cylinders;

src/tools/anyboot/anyboot.cpp

71

chsAddressFor(uint32_t offset, uint8_t *address, uint32_t sectorsPerTrack,

src/tools/anyboot/anyboot.cpp

76

address[0] = 0xff;

src/tools/anyboot/anyboot.cpp

77

address[1] = 0xff;

src/tools/anyboot/anyboot.cpp

78

address[2] = 0xff;

src/tools/anyboot/anyboot.cpp

98

address[0] = heads;

src/tools/anyboot/anyboot.cpp

99

address[1] = sectors;

src/tools/elfsymbolpatcher/ElfImage.cpp

144

ElfImage::FindSymbol(const char* symbolName, void** address)

src/tools/elfsymbolpatcher/ElfImage.cpp

146

return get_image_symbol(fImage, symbolName, B_SYMBOL_TYPE_ANY, address);

src/tools/elfsymbolpatcher/ElfImage.h

56

void** address);

src/tools/elfsymbolpatcher/ElfSymbolPatcher.cpp

210

ElfSymbolPatchInfo::SetOriginalAddress(void* address, image_id image)

src/tools/elfsymbolpatcher/ElfSymbolPatcher.cpp

212

fOriginalAddress = address;

src/tools/elfsymbolpatcher/ElfSymbolPatcher.cpp

396

void* address = NULL;

src/tools/elfsymbolpatcher/ElfSymbolPatcher.cpp

397

if (image->FindSymbol(symbolName, &address) == B_OK && address) {

src/tools/elfsymbolpatcher/ElfSymbolPatcher.cpp

407

info->SetOriginalAddress(address, image->GetID());