Page MenuHomeFreeBSD
Files F176832665

D46315.1793451164.diff
No OneTemporary
Actions

Authored By
Unknown
Size
18 KB
Referenced Files
None
Subscribers
None

D46315.1793451164.diff
View Options

Index: sys/fs/tmpfs/tmpfs_vnops.c
===================================================================
--- sys/fs/tmpfs/tmpfs_vnops.c
+++ sys/fs/tmpfs/tmpfs_vnops.c
@@ -48,6 +48,7 @@
#include <sys/lock.h>
#include <sys/mount.h>
#include <sys/namei.h>
+#include <sys/pctrie.h>
#include <sys/priv.h>
#include <sys/proc.h>
#include <sys/rwlock.h>
@@ -2070,11 +2071,13 @@
static off_t
tmpfs_seek_data_locked(vm_object_t obj, off_t noff)
{
+ struct pctrie_iter blks;
vm_page_t m;
vm_pindex_t p, p_m, p_swp;
p = OFF_TO_IDX(noff);
m = vm_page_find_least(obj, p);
+ swblk_iter_init(&blks, obj);
/*
* Microoptimize the most common case for SEEK_DATA, where
@@ -2083,7 +2086,7 @@
if (m != NULL && vm_page_any_valid(m) && m->pindex == p)
return (noff);
- p_swp = swap_pager_find_least(obj, p);
+ p_swp = swap_pager_find_least(&blks, p);
if (p_swp == p)
return (noff);
@@ -2111,9 +2114,11 @@
static off_t
tmpfs_seek_hole_locked(vm_object_t obj, off_t noff)
{
+ struct pctrie_iter blks;
vm_page_t m;
vm_pindex_t p, p_swp;
+ swblk_iter_init(&blks, obj);
for (;; noff = tmpfs_seek_next(noff)) {
/*
* Walk over the largest sequential run of the valid pages.
@@ -2128,7 +2133,7 @@
* there is a hole in the swap at the same place.
*/
p = OFF_TO_IDX(noff);
- p_swp = swap_pager_find_least(obj, p);
+ p_swp = swap_pager_find_least(&blks, p);
if (p_swp != p) {
noff = IDX_TO_OFF(p);
break;
Index: sys/vm/swap_pager.h
===================================================================
--- sys/vm/swap_pager.h
+++ sys/vm/swap_pager.h
@@ -40,6 +40,7 @@
#include <sys/_types.h>
struct buf;
+struct pctrie_iter;
struct swdevt;
struct thread;
typedef void sw_strategy_t(struct buf *, struct swdevt *);
@@ -74,7 +75,8 @@
struct xswdev;
int swap_dev_info(int name, struct xswdev *xs, char *devname, size_t len);
void swap_pager_copy(vm_object_t, vm_object_t, vm_pindex_t, int);
-vm_pindex_t swap_pager_find_least(vm_object_t object, vm_pindex_t pindex);
+void swblk_iter_init(struct pctrie_iter *blks, vm_object_t object);
+vm_pindex_t swap_pager_find_least(struct pctrie_iter *blks, vm_pindex_t pindex);
void swap_pager_freespace(vm_object_t object, vm_pindex_t start,
vm_size_t size, vm_size_t *freed);
void swap_pager_swap_init(void);
Index: sys/vm/swap_pager.c
===================================================================
--- sys/vm/swap_pager.c
+++ sys/vm/swap_pager.c
@@ -491,7 +491,7 @@
static void swp_pager_meta_free(vm_object_t, vm_pindex_t, vm_pindex_t,
vm_size_t *);
static void swp_pager_meta_transfer(vm_object_t src, vm_object_t dst,
- vm_pindex_t pindex, vm_pindex_t count, vm_size_t *freed);
+ vm_pindex_t pindex, vm_pindex_t count);
static void swp_pager_meta_free_all(vm_object_t);
static daddr_t swp_pager_meta_lookup(vm_object_t, vm_pindex_t);
@@ -531,6 +531,77 @@
PCTRIE_DEFINE(SWAP, swblk, p, swblk_trie_alloc, swblk_trie_free);
+void
+swblk_iter_init(struct pctrie_iter *blks, vm_object_t object)
+{
+ VM_OBJECT_ASSERT_LOCKED(object);
+ MPASS((object->flags & OBJ_SWAP) != 0);
+ pctrie_iter_init(blks, &object->un_pager.swp.swp_blks);
+}
+
+static struct swblk *
+swblk_lookup(vm_object_t object, vm_pindex_t pindex)
+{
+ return (SWAP_PCTRIE_LOOKUP(&object->un_pager.swp.swp_blks, pindex));
+}
+
+static struct swblk *
+swblk_start(struct pctrie_iter *blks, vm_pindex_t pindex)
+{
+ return (SWAP_PCTRIE_ITER_LOOKUP_GE(blks,
+ rounddown(pindex, SWAP_META_PAGES)));
+}
+
+static struct swblk *
+swblk_next(struct pctrie_iter *blks)
+{
+ return (SWAP_PCTRIE_ITER_JUMP_GE(blks, SWAP_META_PAGES));
+}
+
+static struct swblk *
+swblk_start_limit(struct pctrie_iter *blks, vm_pindex_t pindex,
+ vm_pindex_t limit)
+{
+ return (SWAP_PCTRIE_ITER_LOOKUP_GE_LIMIT(blks,
+ rounddown(pindex, SWAP_META_PAGES), limit));
+}
+
+static struct swblk *
+swblk_next_limit(struct pctrie_iter *blks, vm_pindex_t limit)
+{
+ return (SWAP_PCTRIE_ITER_JUMP_GE_LIMIT(blks, SWAP_META_PAGES, limit));
+}
+
+static struct swblk *
+swblk_restart(struct pctrie_iter *blks, vm_pindex_t pindex)
+{
+ return (SWAP_PCTRIE_ITER_LOOKUP(blks, pindex));
+}
+
+static void
+swblk_remove(struct pctrie_iter *blks)
+{
+ SWAP_PCTRIE_ITER_REMOVE(blks);
+}
+
+static void
+swblk_lookup_remove(vm_object_t object, vm_pindex_t pindex)
+{
+ SWAP_PCTRIE_REMOVE(&object->un_pager.swp.swp_blks, pindex);
+}
+
+static int
+swblk_lookup_insert(vm_object_t object, struct swblk *sb)
+{
+ return (SWAP_PCTRIE_INSERT(&object->un_pager.swp.swp_blks, sb));
+}
+
+static bool
+swblk_is_empty(vm_object_t object)
+{
+ return (pctrie_is_empty(&object->un_pager.swp.swp_blks));
+}
+
/*
* SWP_SIZECHECK() - update swap_pager_full indication
*
@@ -1084,8 +1155,7 @@
/*
* Transfer source to destination.
*/
- swp_pager_meta_transfer(srcobject, dstobject, offset, dstobject->size,
- NULL);
+ swp_pager_meta_transfer(srcobject, dstobject, offset, dstobject->size);
/*
* Free left over swap blocks in source.
@@ -1218,8 +1288,7 @@
}
swap_pager_unswapped_acct(m);
- sb = SWAP_PCTRIE_LOOKUP(&m->object->un_pager.swp.swp_blks,
- rounddown(m->pindex, SWAP_META_PAGES));
+ sb = swblk_lookup(m->object, rounddown(m->pindex, SWAP_META_PAGES));
if (sb == NULL)
return;
range.start = sb->d[m->pindex % SWAP_META_PAGES];
@@ -1776,19 +1845,19 @@
u_long
swap_pager_swapped_pages(vm_object_t object)
{
+ struct pctrie_iter blks;
struct swblk *sb;
- vm_pindex_t pi;
u_long res;
int i;
VM_OBJECT_ASSERT_LOCKED(object);
- if (pctrie_is_empty(&object->un_pager.swp.swp_blks))
+ if (swblk_is_empty(object))
return (0);
- for (res = 0, pi = 0; (sb = SWAP_PCTRIE_LOOKUP_GE(
- &object->un_pager.swp.swp_blks, pi)) != NULL;
- pi = sb->p + SWAP_META_PAGES) {
+ res = 0;
+ swblk_iter_init(&blks, object);
+ for (sb = swblk_start(&blks, 0); sb != NULL; sb = swblk_next(&blks)) {
for (i = 0; i < SWAP_META_PAGES; i++) {
if (sb->d[i] != SWAPBLK_NONE)
res++;
@@ -1806,6 +1875,7 @@
static void
swap_pager_swapoff_object(struct swdevt *sp, vm_object_t object)
{
+ struct pctrie_iter blks;
struct page_range range;
struct swblk *sb;
vm_page_t m;
@@ -1822,31 +1892,33 @@
i = 0;
swp_pager_init_freerange(&range);
for (;;) {
- if (i == 0 && (object->flags & OBJ_DEAD) != 0) {
- /*
- * Make sure that pending writes finish before
- * returning.
- */
- vm_object_pip_wait(object, "swpoff");
- swp_pager_meta_free_all(object);
- break;
- }
-
- if (i == SWAP_META_PAGES) {
+ if (i == 0) {
+ if ((object->flags & OBJ_DEAD) != 0) {
+ /*
+ * Make sure that pending writes finish before
+ * returning.
+ */
+ vm_object_pip_wait(object, "swpoff");
+ swp_pager_meta_free_all(object);
+ break;
+ }
+ VM_OBJECT_NORELEASE(object);
+ swblk_iter_init(&blks, object);
+ sb = swblk_start(&blks, pi);
+ } else if (i == SWAP_META_PAGES) {
pi = sb->p + SWAP_META_PAGES;
if (sb_empty) {
- SWAP_PCTRIE_REMOVE(
- &object->un_pager.swp.swp_blks, sb->p);
+ swblk_remove(&blks);
uma_zfree(swblk_zone, sb);
}
+ sb = swblk_next(&blks);
i = 0;
}
-
if (i == 0) {
- sb = SWAP_PCTRIE_LOOKUP_GE(
- &object->un_pager.swp.swp_blks, pi);
- if (sb == NULL)
+ if (sb == NULL) {
+ VM_OBJECT_RELEASEOK(object);
break;
+ }
sb_empty = true;
m = NULL;
}
@@ -1868,6 +1940,7 @@
m = m != NULL ? vm_page_next(m) :
vm_page_lookup(object, sb->p + i);
if (m != NULL && (m->oflags & VPO_SWAPINPROG) != 0) {
+ VM_OBJECT_RELEASEOK(object);
m->oflags |= VPO_SWAPSLEEP;
VM_OBJECT_SLEEP(object, &object->handle, PSWP, "swpoff",
0);
@@ -1897,6 +1970,7 @@
continue;
/* Get the page from swap, mark it dirty, restart the scan. */
+ VM_OBJECT_RELEASEOK(object);
vm_object_pip_add(object, 1);
rahead = SWAP_META_PAGES;
rv = swap_pager_getpages_locked(object, &m, 1, NULL, &rahead);
@@ -2020,7 +2094,7 @@
{
if (swp_pager_swblk_empty(sb, 0, SWAP_META_PAGES)) {
- SWAP_PCTRIE_REMOVE(&object->un_pager.swp.swp_blks, sb->p);
+ swblk_lookup_remove(object, sb->p);
uma_zfree(swblk_zone, sb);
}
}
@@ -2050,7 +2124,7 @@
VM_OBJECT_ASSERT_WLOCKED(object);
rdpi = rounddown(pindex, SWAP_META_PAGES);
- sb = SWAP_PCTRIE_LOOKUP(&object->un_pager.swp.swp_blks, rdpi);
+ sb = swblk_lookup(object, rdpi);
if (sb == NULL) {
if (swapblk == SWAPBLK_NONE)
return (SWAPBLK_NONE);
@@ -2079,8 +2153,7 @@
} else
uma_zwait(swblk_zone);
VM_OBJECT_WLOCK(object);
- sb = SWAP_PCTRIE_LOOKUP(&object->un_pager.swp.swp_blks,
- rdpi);
+ sb = swblk_lookup(object, rdpi);
if (sb != NULL)
/*
* Somebody swapped out a nearby page,
@@ -2090,8 +2163,7 @@
goto allocated;
}
for (;;) {
- error = SWAP_PCTRIE_INSERT(
- &object->un_pager.swp.swp_blks, sb);
+ error = swblk_lookup_insert(object, sb);
if (error == 0) {
if (atomic_cmpset_int(&swpctrie_zone_exhausted,
1, 0))
@@ -2113,8 +2185,7 @@
} else
uma_zwait(swpctrie_zone);
VM_OBJECT_WLOCK(object);
- sb1 = SWAP_PCTRIE_LOOKUP(&object->un_pager.swp.swp_blks,
- rdpi);
+ sb1 = swblk_lookup(object, rdpi);
if (sb1 != NULL) {
uma_zfree(swblk_zone, sb);
sb = sb1;
@@ -2142,85 +2213,76 @@
}
/*
- * SWP_PAGER_META_TRANSFER() - free a range of blocks in the srcobject's swap
- * metadata, or transfer it into dstobject.
+ * SWP_PAGER_META_TRANSFER() - transfer a range of blocks in the srcobject's
+ * swap metadata into dstobject.
*
* This routine will free swap metadata structures as they are cleaned
* out.
*/
static void
swp_pager_meta_transfer(vm_object_t srcobject, vm_object_t dstobject,
- vm_pindex_t pindex, vm_pindex_t count, vm_size_t *moved)
+ vm_pindex_t pindex, vm_pindex_t count)
{
+ struct pctrie_iter blks;
struct page_range range;
struct swblk *sb;
daddr_t blk;
- vm_page_t m;
- vm_pindex_t offset, last;
- vm_size_t mc;
+ vm_pindex_t last;
int i, limit, start;
+ bool reset;
VM_OBJECT_ASSERT_WLOCKED(srcobject);
- MPASS(moved == NULL || dstobject == NULL);
+ VM_OBJECT_ASSERT_WLOCKED(dstobject);
- mc = 0;
- m = NULL;
- if (count == 0 || pctrie_is_empty(&srcobject->un_pager.swp.swp_blks))
- goto out;
+ if (count == 0 || swblk_is_empty(srcobject))
+ return;
swp_pager_init_freerange(&range);
- offset = pindex;
+ VM_OBJECT_NORELEASE(srcobject);
+ swblk_iter_init(&blks, srcobject);
last = pindex + count;
- for (;;) {
- sb = SWAP_PCTRIE_LOOKUP_GE(&srcobject->un_pager.swp.swp_blks,
- rounddown(pindex, SWAP_META_PAGES));
- if (sb == NULL || sb->p >= last)
- break;
- start = pindex > sb->p ? pindex - sb->p : 0;
- limit = last - sb->p < SWAP_META_PAGES ? last - sb->p :
- SWAP_META_PAGES;
+ reset = false;
+ for (sb = swblk_start_limit(&blks, pindex, last),
+ start = (sb != NULL && sb->p < pindex) ? pindex - sb->p : 0;
+ sb != NULL; sb = swblk_next_limit(&blks, last), start = 0) {
+ limit = MIN(last - sb->p, SWAP_META_PAGES);
for (i = start; i < limit; i++) {
- blk = sb->d[i];
- if (blk == SWAPBLK_NONE)
+ if (sb->d[i] == SWAPBLK_NONE)
continue;
- if (dstobject == NULL ||
- (blk = swp_pager_meta_build(dstobject,
- sb->p + i - offset, blk, true),
- blk != sb->d[i] && blk != SWAPBLK_NONE))
- swp_pager_update_freerange(&range, sb->d[i]);
- else if (blk == sb->d[i]) {
+ blk = swp_pager_meta_build(dstobject,
+ sb->p + i - pindex, sb->d[i], true);
+ if (blk == sb->d[i]) {
/*
* Destination has no swapblk and is not
* resident, so transfer source.
* swp_pager_meta_build() failed memory
* allocation already, likely to sleep in retry.
*/
+ VM_OBJECT_RELEASEOK(srcobject);
VM_OBJECT_WUNLOCK(srcobject);
swp_pager_meta_build(dstobject,
- sb->p + i - offset, blk, false);
+ sb->p + i - pindex, sb->d[i], false);
VM_OBJECT_WLOCK(srcobject);
- }
- if (moved != NULL) {
- m = (m != NULL && m->pindex == sb->p + i - 1) ?
- vm_page_next(m) :
- vm_page_lookup(srcobject, sb->p + i);
- if (m == NULL || vm_page_none_valid(m))
- mc++;
- }
+ VM_OBJECT_NORELEASE(srcobject);
+ reset = true;
+ } else if (blk != SWAPBLK_NONE)
+ swp_pager_update_freerange(&range, sb->d[i]);
sb->d[i] = SWAPBLK_NONE;
}
- pindex = sb->p + SWAP_META_PAGES;
+ if (reset) {
+ /* Rebuild search path after losing object lock. */
+ reset = false;
+ swblk_iter_init(&blks, srcobject);
+ swblk_restart(&blks, sb->p);
+ }
if (swp_pager_swblk_empty(sb, 0, start) &&
swp_pager_swblk_empty(sb, limit, SWAP_META_PAGES)) {
- SWAP_PCTRIE_REMOVE(&srcobject->un_pager.swp.swp_blks,
- sb->p);
+ swblk_remove(&blks);
uma_zfree(swblk_zone, sb);
}
}
+ VM_OBJECT_RELEASEOK(srcobject);
swp_pager_freeswapspace(&range);
-out:
- if (moved != NULL)
- *moved = mc;
}
/*
@@ -2237,7 +2299,53 @@
swp_pager_meta_free(vm_object_t object, vm_pindex_t pindex, vm_pindex_t count,
vm_size_t *freed)
{
- swp_pager_meta_transfer(object, NULL, pindex, count, freed);
+ struct pctrie_iter blks;
+ struct page_range range;
+ struct swblk *sb;
+ vm_page_t m;
+ vm_pindex_t last;
+ vm_size_t fc;
+ int i, limit, start;
+
+ VM_OBJECT_ASSERT_WLOCKED(object);
+
+ fc = 0;
+ m = NULL;
+ if (count == 0 || swblk_is_empty(object))
+ goto out;
+
+ swp_pager_init_freerange(&range);
+ last = pindex + count;
+ VM_OBJECT_NORELEASE(object);
+ swblk_iter_init(&blks, object);
+ for (sb = swblk_start_limit(&blks, pindex, last),
+ start = (sb != NULL && sb->p < pindex) ? pindex - sb->p : 0;
+ sb != NULL; sb = swblk_next_limit(&blks, last), start = 0) {
+ limit = MIN(last - sb->p, SWAP_META_PAGES);
+ for (i = start; i < limit; i++) {
+ if (sb->d[i] == SWAPBLK_NONE)
+ continue;
+ swp_pager_update_freerange(&range, sb->d[i]);
+ if (freed != NULL) {
+ m = (m != NULL && m->pindex == sb->p + i - 1) ?
+ vm_page_next(m) :
+ vm_page_lookup(object, sb->p + i);
+ if (m == NULL || vm_page_none_valid(m))
+ fc++;
+ }
+ sb->d[i] = SWAPBLK_NONE;
+ }
+ if (swp_pager_swblk_empty(sb, 0, start) &&
+ swp_pager_swblk_empty(sb, limit, SWAP_META_PAGES)) {
+ swblk_remove(&blks);
+ uma_zfree(swblk_zone, sb);
+ }
+ }
+ VM_OBJECT_RELEASEOK(object);
+ swp_pager_freeswapspace(&range);
+out:
+ if (freed != NULL)
+ *freed = fc;
}
static void
@@ -2296,44 +2404,32 @@
KASSERT((object->flags & OBJ_SWAP) != 0,
("Lookup object not swappable"));
- sb = SWAP_PCTRIE_LOOKUP(&object->un_pager.swp.swp_blks,
- rounddown(pindex, SWAP_META_PAGES));
+ sb = swblk_lookup(object, rounddown(pindex, SWAP_META_PAGES));
if (sb == NULL)
return (SWAPBLK_NONE);
return (sb->d[pindex % SWAP_META_PAGES]);
}
/*
- * Returns the least page index which is greater than or equal to the
- * parameter pindex and for which there is a swap block allocated.
- * Returns object's size if the object's type is not swap or if there
- * are no allocated swap blocks for the object after the requested
- * pindex.
+ * Returns the least page index which is greater than or equal to the parameter
+ * pindex and for which there is a swap block allocated. Returns OBJ_MAX_SIZE
+ * if are no allocated swap blocks for the object after the requested pindex.
*/
vm_pindex_t
-swap_pager_find_least(vm_object_t object, vm_pindex_t pindex)
+swap_pager_find_least(struct pctrie_iter *blks, vm_pindex_t pindex)
{
struct swblk *sb;
int i;
- VM_OBJECT_ASSERT_LOCKED(object);
- MPASS((object->flags & OBJ_SWAP) != 0);
-
- if (pctrie_is_empty(&object->un_pager.swp.swp_blks))
- return (object->size);
- sb = SWAP_PCTRIE_LOOKUP_GE(&object->un_pager.swp.swp_blks,
- rounddown(pindex, SWAP_META_PAGES));
- if (sb == NULL)
- return (object->size);
+ if ((sb = swblk_start(blks, pindex)) == NULL)
+ return (OBJ_MAX_SIZE);
if (sb->p < pindex) {
for (i = pindex % SWAP_META_PAGES; i < SWAP_META_PAGES; i++) {
if (sb->d[i] != SWAPBLK_NONE)
return (sb->p + i);
}
- sb = SWAP_PCTRIE_LOOKUP_GE(&object->un_pager.swp.swp_blks,
- roundup(pindex, SWAP_META_PAGES));
- if (sb == NULL)
- return (object->size);
+ if ((sb = swblk_next(blks)) == NULL)
+ return (OBJ_MAX_SIZE);
}
for (i = 0; i < SWAP_META_PAGES; i++) {
if (sb->d[i] != SWAPBLK_NONE)
@@ -2345,7 +2441,7 @@
* doesn't map any blocks.
*/
MPASS(0);
- return (object->size);
+ return (OBJ_MAX_SIZE);
}
/*
@@ -2775,6 +2871,7 @@
long
vmspace_swap_count(struct vmspace *vmspace)
{
+ struct pctrie_iter blks;
vm_map_t map;
vm_map_entry_t cur;
vm_object_t object;
@@ -2797,11 +2894,9 @@
goto unlock;
pi = OFF_TO_IDX(cur->offset);
e = pi + OFF_TO_IDX(cur->end - cur->start);
- for (;; pi = sb->p + SWAP_META_PAGES) {
- sb = SWAP_PCTRIE_LOOKUP_GE(
- &object->un_pager.swp.swp_blks, pi);
- if (sb == NULL || sb->p >= e)
- break;
+ swblk_iter_init(&blks, object);
+ for (sb = swblk_start_limit(&blks, pi, e);
+ sb != NULL; sb = swblk_next_limit(&blks, e)) {
for (i = 0; i < SWAP_META_PAGES; i++) {
if (sb->p + i < e &&
sb->d[i] != SWAPBLK_NONE)
Index: sys/vm/vm_object.h
===================================================================
--- sys/vm/vm_object.h
+++ sys/vm/vm_object.h
@@ -269,6 +269,8 @@
lock_class_rw.lc_unlock(&(object)->lock.lock_object)
#define VM_OBJECT_PICKUP(object, state) \
lock_class_rw.lc_lock(&(object)->lock.lock_object, (state))
+#define VM_OBJECT_NORELEASE(object) WITNESS_NORELEASE(&(object)->lock)
+#define VM_OBJECT_RELEASEOK(object) WITNESS_RELEASEOK(&(object)->lock)
#define VM_OBJECT_ASSERT_PAGING(object) \
KASSERT(blockcount_read(&(object)->paging_in_progress) != 0, \
Index: sys/vm/vm_object.c
===================================================================
--- sys/vm/vm_object.c
+++ sys/vm/vm_object.c
@@ -1681,6 +1681,7 @@
static bool
vm_object_scan_all_shadowed(vm_object_t object)
{
+ struct pctrie_iter blks;
vm_object_t backing_object;
vm_page_t p, pp;
vm_pindex_t backing_offset_index, new_pindex, pi, ps;
@@ -1695,7 +1696,8 @@
pi = backing_offset_index = OFF_TO_IDX(object->backing_object_offset);
p = vm_page_find_least(backing_object, pi);
- ps = swap_pager_find_least(backing_object, pi);
+ swblk_iter_init(&blks, backing_object);
+ ps = swap_pager_find_least(&blks, pi);
/*
* Only check pages inside the parent object's range and
@@ -1705,7 +1707,7 @@
if (p != NULL && p->pindex < pi)
p = TAILQ_NEXT(p, listq);
if (ps < pi)
- ps = swap_pager_find_least(backing_object, pi);
+ ps = swap_pager_find_least(&blks, pi);
if (p == NULL && ps >= backing_object->size)
break;
else if (p == NULL)

File Metadata

Mime Type
text/plain
Expires
Sat, Oct 31, 12:52 PM (16 h, 37 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
41263707
Default Alt Text
D46315.1793451164.diff (18 KB)

Event Timeline