25     def object_range(self):  argument
26         return self.kmem.bits_range
28     def describe(self, verbose=False):  argument
51     def __init__(self, kmem, address):  argument
67         self.mo_sbv = sbv
68         self.kmem   = kmem
85         self.sbv        = sbv
86         self._idx       = idx
87         self._chunk_len = chunk_len
107     def object_range(self):  argument
108         addr = self.sbv.GetLoadAddress()
109         clen = self._chunk_len
110         if clen == 1 and self.zone.percpu:
111             clen  = self.kmem.ncpus
112         size = self._chunk_len * self.kmem.zpm_type.GetByteSize()
117     def zone(self):  argument
118         sbv = self.sbv
122     def pgz_slot(self):  argument
123         addr = self.page_addr
124         kmem = self.kmem
129     def _pgz_alloc_frames(self, index):  argument
130         kmem   = self.kmem
142     def pgz_alloc_bt_frames(self):  argument
143         return self._pgz_alloc_frames(2 * self.pgz_slot)
146     def pgz_free_bt_frames(self):  argument
147         return self._pgz_alloc_frames(2 * self.pgz_slot + 1)
149     def describe(self, verbose=False):  argument
150         kmem = self.kmem
151         sbv  = self.sbv
152         zone = self.zone
154         chunk_len = self._chunk_len
163         print(" page                 : {:#x}".format(self.page_addr))
169                     for i in range(self._chunk_len)
201         mo_sbv = self.mo_sbv
203             pg_idx = self.mo_sbv.xGetIntegerByName('zm_page_index')
209                 self.page_addr + (pg_idx << kmem.page_shift)))
215             print(str(self.mo_sbv))
220     def next_pva(self):  argument
223         return self.sbv.xGetIntegerByPath('.zm_page_next.packed_address')
226     def page_addr(self):  argument
229         kmem = self.kmem
230         return kmem.zone_range.start + (self._idx << kmem.page_shift)
232     def iter_all(self, zone):  argument
235         base  = self.page_addr
239         run   = self.sbv.xGetIntegerByName('zm_chunk_len')
241         return range(base + offs, base + (run << self.kmem.page_shift), esize)
243     def is_allocated(self, zone, addr):  argument
246         if not self._chunk_len:
249         sbv   = self.sbv
250         base  = self.page_addr + zone.elem_inner_offs
261             kmem  = self.kmem
265     def iter_allocated(self, zone):  argument
268         kmem  = self.kmem
269         sbv   = self.sbv
270         base  = self.page_addr
273         sbv.target.xReadBytes(base, self._chunk_len << kmem.page_shift)
303     def __init__(self, kmem, address):  argument
319             self.real_addr = real_addr
320             self.real_meta = ZonePageMetadata._create_with_zone_address(kmem, real_addr)
321             self.pgz       = True
326             self.real_addr = elem_addr
327             self.real_meta = meta
328             self.pgz       = False
330         self.kmem      = kmem
331         self.meta      = meta
332         self.zone      = zone
333         self.elem_idx  = elem_idx
334         self.elem_addr = elem_addr
337     def object_range(self):  argument
338         if self.elem_idx >= 0:
339             elem_addr = self.elem_addr
340             elem_size = self.zone.elem_outer_size
343         base = self.meta.page_addr
344         size = self.zone.elem_inner_offs
348     def status(self):  argument
349         zone      = self.zone
350         real_addr = self.real_addr
352         if self.elem_idx < 0:
355         elif not self.real_meta.is_allocated(zone, real_addr):
367     def hexdump(self):  argument
370         target = self.kmem.target
371         zone   = self.zone
372         eaddr  = self.elem_addr
374         delta  = self.real_addr - eaddr
379         marks  = { self.address: '>' }
425     def describe(self, verbose=False):  argument
426         meta   = self.meta
427         zone   = self.zone
428         status = self.status
434         print(" element index        : {}".format(self.elem_idx))
435         print(" chunk offset         : {}".format(self.address - meta.page_addr))
437         if self.pgz:
438             print(" pgz orig address     : {:#x}".format(self.real_addr))
453                 wantElement=self.elem_addr, reverse=True), None)
461         if self.elem_idx >= 0 and verbose:
462             self.hexdump()
474     def __init__(self, kmem):  argument
477     def claims(self, address):  argument
478         kmem = self.kmem
485     def lookup(self, address):  argument
486         kmem = self.kmem
489             return ZonePageMetadata(self.kmem, address)
492             return ZoneBitsMemoryObject(self.kmem, address)
494         return ZoneHeapMemoryObject(self.kmem, address)
502     def __init__(self, sbvalue):  argument
507         self.sbv = sbvalue
509     def __iter__(self):  argument
510         sbv  = self.sbv
528     def __init__(self, index_name_or_addr):  argument
545             zid = self._find_zone_id_by_mangled_name(mangled_name)
552         self.kmem = kmem
553         self.zid  = zid
554         self.sbv  = zarr.chkGetChildAtIndex(zid)
606     def initialized(self):  argument
609         return self.sbv.xGetIntegerByName('z_self') != 0
612     def address(self):  argument
615         return self.sbv.GetLoadAddress()
618     def name(self):  argument
621         return self.get_zone_name(self.zid)
624     def mangled_name(self):  argument
627         return self.name.replace(' ', '.')
630     def elem_redzone(self, target=None):  argument
633         if self.kmem.kasan_classic:
634             return self.sbv.xGetIntegerByName('z_kasan_redzone')
638     def elem_inner_size(self, target=None):  argument
641         return self.sbv.xGetIntegerByName('z_elem_size')
644     def elem_outer_size(self, target=None):  argument
647         if not self.kmem.kasan_classic:
648             return self.elem_inner_size
649         return self.elem_inner_size + self.elem_redzone
652     def elem_inner_offs(self, target=None):  argument
655         return self.sbv.xGetIntegerByName('z_elem_offs')
658     def chunk_pages(self, target=None):  argument
661         return self.sbv.xGetIntegerByName('z_chunk_pages')
664     def chunk_elems(self, target=None):  argument
667         return self.sbv.xGetIntegerByName('z_chunk_elems')
670     def percpu(self):  argument
673         return self.sbv.xGetIntegerByName('z_percpu')
676     def btlog(self):  argument
680             btlog = self.sbv.xGetPointeeByName('z_btlog')
685     def describe(self):  argument
686         kmem = self.kmem
687         zone = self.sbv
688         zsec = kmem.zsec_array.chkGetChildAtIndex(self.zid)
714         print(xnu_format(fmt, self, submap_name,
717     def iter_page_queue(self, name):  argument
718         kmem = self.kmem
719         zone = self.sbv
728     def _depotElements(self, depot, into):  argument
732         kmem   = self.kmem
745     def cached(self, into = None):  argument
748         pcpu = self.sbv.GetChildMemberWithName('z_pcpu_cache')
753             kmem   = self.kmem
766                 self._depotElements(
773     def recirc(self, into = None):  argument
776         return self._depotElements(
777             self.sbv.chkGetChildMemberWithName('z_recirc'),
781     def iter_all(self, ty = None):  argument
800             for meta in self.iter_page_queue(name)
801             for addr in meta.iter_all(self)
807         fn = self.kmem.target.xCreateValueFromAddress
810     def iter_free(self, ty = None):  argument
823         self.cached(into = cached)
824         self.recirc(into = cached)
832             for meta in self.iter_page_queue(name)
833             for addr in meta.iter_all(self)
834             if  addr in cached or not meta.is_allocated(self, addr)
840         fn = self.kmem.target.xCreateValueFromAddress
843     def iter_allocated(self, ty = None):  argument
856         self.cached(into = cached)
857         self.recirc(into = cached)
865             for meta in self.iter_page_queue(name)
866             for addr in meta.iter_allocated(self)
873         fn = self.kmem.target.xCreateValueFromAddress
876     def __iter__(self):  argument
877         return self.iter_allocated()