Lines Matching refs:freed
160 * c) the client has freed the object.
164 * layer and freed to the slab layer so it will no longer hold the
178 * 5. About to be freed (no longer in a valid state for the move callback)
182 * 8. Deconstructed on a magazine that is about to be freed
197 * pending until kmem processes them from another context. Also, objects freed
225 * cache's slabs are freed to the virtual memory (VM) subsystem while a move
226 * callback is pending. When the last object on a slab is freed, if there is a
236 * (known, in use) to state #5 (about to be freed, invalid) by setting the low
239 * 0xdeadbeef to freed memory, any scribbling on the object done by kmem is
267 * At this point the client knows that the object cannot be freed as long as
282 * In the common case, the object is freed to the magazine layer, where it may
507 * from being freed. The caller must take measures before calling object_hold()
508 * (afterwards is too late) to ensure that the held object cannot be freed. The
543 * the object has been freed. Although it is possible to release the hold
650 * objects have all been freed to the slab are released to the virtual memory
651 * (VM) subsystem (objects freed to magazines are still allocated as far as the
672 * allocated slab is freed to the slab, that slab is added to the front of the
789 * completely allocate any slab that cannot be completely freed. kmem does not
876 kstat_named_t kmc_move_slabs_freed; /* slabs freed by consolidator */
1160 #define KMERR_DUPFREE 2 /* freed a buffer twice */
1161 #define KMERR_BADADDR 3 /* freed a bad (unallocated) address */
1164 #define KMERR_BADCACHE 6 /* freed a buffer to the wrong cache */
1349 printf("buffer modified after being freed\n");
1368 printf("duplicate free: buffer freed twice\n");
1383 printf("buffer freed to wrong cache\n");
1844 * buffer is freed. (It makes sense to do this in
1884 * patterns baddcafe (uninitialized) and deadbeef (freed) both
1900 * distinguish between slabs freed while move callbacks
1901 * are pending (list head) and a slab freed while the
2654 * The freed argument tells whether or not kmem_cache_free_debug() has already
2656 * buffer on a magazine has already been freed by the client but is still
2660 kmem_slab_free_constructed(kmem_cache_t *cp, void *buf, boolean_t freed)
2662 if (!freed && (cp->cache_flags & KMF_BUFTAG))
3679 * freed before another allocation can tie up the slab. For that reason a slab
4703 * The state of the returned buffer is freed and constructed.
4770 * or when the buffer is freed.
4839 * Slabs are not freed while there is a pending callback, but instead are kept
4842 * their buffers have been freed. Once slab_refcnt reaches zero, it stays at
4844 * freed.
5258 * freed while we dropped cache_lock and there