Page MenuHomeFreeBSD
Differential D4520

sesutil: Add extra information specific to some SES devices
ClosedPublic
Actions

Authored by bapt on Dec 11 2015, 5:20 PM.
Tags
None
Referenced Files
Unknown Object (File)
Fri, Mar 14, 5:26 AM
Unknown Object (File)
Feb 18 2025, 7:20 AM
Unknown Object (File)
Feb 13 2025, 4:31 PM
Unknown Object (File)
Feb 12 2025, 10:54 AM
Unknown Object (File)
Feb 6 2025, 9:05 AM
Unknown Object (File)
Jan 31 2025, 11:28 AM
Unknown Object (File)
Jan 31 2025, 10:24 AM
Unknown Object (File)
Jan 31 2025, 7:53 AM
View All 91 Files
Subscribers
imp

Details

Reviewers
allanjude
Commits
rS292121: sesutil: Add extra information specific to some SES devices to sesutil map
Summary

Rework stat2ascii into a printing function that allows to add more data
with a risk of overflowing a static buffer.

In the sesutil map command add extra informations:

  • Thermal sensor temperature
  • Cooling devices speed
  • Voltage sensors, current consumption

Diff Detail

Repository
rS FreeBSD src repository - subversion
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

bapt updated this revision to Diff 11138.Dec 11 2015, 5:20 PM
bapt retitled this revision from to sesutil: Add extra information specific to some SES devices.
bapt updated this object.
bapt edited the test plan for this revision. (Show Details)
bapt added a reviewer: allanjude.
Herald added a subscriber: imp. · View Herald TranscriptDec 11 2015, 5:20 PM
bapt updated this revision to Diff 11142.Dec 11 2015, 6:51 PM

Use a buffer to only print extra status if needed

allanjude accepted this revision.Dec 11 2015, 8:39 PM
allanjude edited edge metadata.

I like the extra output, thank you.

This revision is now accepted and ready to land.Dec 11 2015, 8:39 PM
Closed by commit rS292121: sesutil: Add extra information specific to some SES devices to sesutil map (authored by bapt). · Explain WhyDec 11 2015, 8:46 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathSize
head/
usr.sbin/
sesutil/
2 lines
5 lines
75 lines
15 lines

Diff 11145

View Options

head/usr.sbin/sesutil/Makefile

Show First 20 Lines • Show All 2,966 Lines • ▼ Show 20 Lines
*/ */
bool bool
vm_page_reclaim_contig_domain(int domain, int req, u_long npages, vm_page_reclaim_contig_domain(int domain, int req, u_long npages,
vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary) vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary)
{ {
struct vm_domain *vmd; struct vm_domain *vmd;
vm_paddr_t curr_low; vm_paddr_t curr_low;
vm_page_t m_run, m_runs[NRUNS]; vm_page_t m_run, m_runs[NRUNS];
u_long count, reclaimed; u_long count, minalign, reclaimed;
int error, i, options, req_class; int error, i, options, req_class;
KASSERT(npages > 0, ("npages is 0")); KASSERT(npages > 0, ("npages is 0"));
KASSERT(powerof2(alignment), ("alignment is not a power of 2")); KASSERT(powerof2(alignment), ("alignment is not a power of 2"));
KASSERT(powerof2(boundary), ("boundary is not a power of 2")); KASSERT(powerof2(boundary), ("boundary is not a power of 2"));
alcUnsubmitted
Done
Inline Actions

I think that the rounding should be performed here, right after the KASSERT()s and before the sanity check on the number of free pages. The reason being that in the worst case vm_page_reclaim_run() will perform the rounded up number of page allocations before it frees any of the pages from the contiguous run.

alc: I think that the rounding should be performed here, right after the KASSERT()s and before the…
req_class = req & VM_ALLOC_CLASS_MASK; req_class = req & VM_ALLOC_CLASS_MASK;
/* /*
* The page daemon is allowed to dig deeper into the free page list. * The page daemon is allowed to dig deeper into the free page list.
*/ */
if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT) if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
req_class = VM_ALLOC_SYSTEM; req_class = VM_ALLOC_SYSTEM;
/* /*
* Return if the number of free pages cannot satisfy the requested * Return if the number of free pages cannot satisfy the requested
* allocation. * allocation.
*/ */
vmd = VM_DOMAIN(domain); vmd = VM_DOMAIN(domain);
count = vmd->vmd_free_count; count = vmd->vmd_free_count;
if (count < npages + vmd->vmd_free_reserved || (count < npages + if (count < npages + vmd->vmd_free_reserved || (count < npages +
vmd->vmd_interrupt_free_min && req_class == VM_ALLOC_SYSTEM) || vmd->vmd_interrupt_free_min && req_class == VM_ALLOC_SYSTEM) ||
(count < npages && req_class == VM_ALLOC_INTERRUPT)) (count < npages && req_class == VM_ALLOC_INTERRUPT))
return (false); return (false);
/*
* The caller will attempt an allocation after some runs have been
* reclaimed and added to the vm_phys buddy lists. To ensure that runs
* are not fragmented, round up the requested length to the next power
alcUnsubmitted
Done
Inline Actions

Rather than "To ensure that runs are not fragmented, ...", I would say, "Due to limitations of vm_phys_alloc_contig(), ..."

alc: Rather than "To ensure that runs are not fragmented, ...", I would say, "Due to limitations of…
* or two or maximum chunk size, and ensure that each run is suitably
* aligned.
*/
minalign = 1ul << imin(flsl(npages - 1), VM_NFREEORDER - 1);
npages = roundup2(npages, minalign);
if (alignment < ptoa(minalign))
alignment = ptoa(minalign);
/* /*
* Scan up to three times, relaxing the restrictions ("options") on * Scan up to three times, relaxing the restrictions ("options") on
* the reclamation of reservations and superpages each time. * the reclamation of reservations and superpages each time.
*/ */
for (options = VPSC_NORESERV;;) { for (options = VPSC_NORESERV;;) {
/* /*
* Find the highest runs that satisfy the given constraints * Find the highest runs that satisfy the given constraints
▲ Show 20 Lines • Show All 2,522 Lines • Show Last 20 Lines
View Options

head/usr.sbin/sesutil/eltsub.h

Show First 20 Lines • Show All 2,966 Lines • ▼ Show 20 Lines
*/ */
bool bool
vm_page_reclaim_contig_domain(int domain, int req, u_long npages, vm_page_reclaim_contig_domain(int domain, int req, u_long npages,
vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary) vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary)
{ {
struct vm_domain *vmd; struct vm_domain *vmd;
vm_paddr_t curr_low; vm_paddr_t curr_low;
vm_page_t m_run, m_runs[NRUNS]; vm_page_t m_run, m_runs[NRUNS];
u_long count, reclaimed; u_long count, minalign, reclaimed;
int error, i, options, req_class; int error, i, options, req_class;
KASSERT(npages > 0, ("npages is 0")); KASSERT(npages > 0, ("npages is 0"));
KASSERT(powerof2(alignment), ("alignment is not a power of 2")); KASSERT(powerof2(alignment), ("alignment is not a power of 2"));
KASSERT(powerof2(boundary), ("boundary is not a power of 2")); KASSERT(powerof2(boundary), ("boundary is not a power of 2"));
alcUnsubmitted
Done
Inline Actions

I think that the rounding should be performed here, right after the KASSERT()s and before the sanity check on the number of free pages. The reason being that in the worst case vm_page_reclaim_run() will perform the rounded up number of page allocations before it frees any of the pages from the contiguous run.

alc: I think that the rounding should be performed here, right after the KASSERT()s and before the…
req_class = req & VM_ALLOC_CLASS_MASK; req_class = req & VM_ALLOC_CLASS_MASK;
/* /*
* The page daemon is allowed to dig deeper into the free page list. * The page daemon is allowed to dig deeper into the free page list.
*/ */
if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT) if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
req_class = VM_ALLOC_SYSTEM; req_class = VM_ALLOC_SYSTEM;
/* /*
* Return if the number of free pages cannot satisfy the requested * Return if the number of free pages cannot satisfy the requested
* allocation. * allocation.
*/ */
vmd = VM_DOMAIN(domain); vmd = VM_DOMAIN(domain);
count = vmd->vmd_free_count; count = vmd->vmd_free_count;
if (count < npages + vmd->vmd_free_reserved || (count < npages + if (count < npages + vmd->vmd_free_reserved || (count < npages +
vmd->vmd_interrupt_free_min && req_class == VM_ALLOC_SYSTEM) || vmd->vmd_interrupt_free_min && req_class == VM_ALLOC_SYSTEM) ||
(count < npages && req_class == VM_ALLOC_INTERRUPT)) (count < npages && req_class == VM_ALLOC_INTERRUPT))
return (false); return (false);
/*
* The caller will attempt an allocation after some runs have been
* reclaimed and added to the vm_phys buddy lists. To ensure that runs
* are not fragmented, round up the requested length to the next power
alcUnsubmitted
Done
Inline Actions

Rather than "To ensure that runs are not fragmented, ...", I would say, "Due to limitations of vm_phys_alloc_contig(), ..."

alc: Rather than "To ensure that runs are not fragmented, ...", I would say, "Due to limitations of…
* or two or maximum chunk size, and ensure that each run is suitably
* aligned.
*/
minalign = 1ul << imin(flsl(npages - 1), VM_NFREEORDER - 1);
npages = roundup2(npages, minalign);
if (alignment < ptoa(minalign))
alignment = ptoa(minalign);
/* /*
* Scan up to three times, relaxing the restrictions ("options") on * Scan up to three times, relaxing the restrictions ("options") on
* the reclamation of reservations and superpages each time. * the reclamation of reservations and superpages each time.
*/ */
for (options = VPSC_NORESERV;;) { for (options = VPSC_NORESERV;;) {
/* /*
* Find the highest runs that satisfy the given constraints * Find the highest runs that satisfy the given constraints
▲ Show 20 Lines • Show All 2,522 Lines • Show Last 20 Lines
View Options

head/usr.sbin/sesutil/eltsub.c

Show First 20 Lines • Show All 2,966 Lines • ▼ Show 20 Lines
*/ */
bool bool
vm_page_reclaim_contig_domain(int domain, int req, u_long npages, vm_page_reclaim_contig_domain(int domain, int req, u_long npages,
vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary) vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary)
{ {
struct vm_domain *vmd; struct vm_domain *vmd;
vm_paddr_t curr_low; vm_paddr_t curr_low;
vm_page_t m_run, m_runs[NRUNS]; vm_page_t m_run, m_runs[NRUNS];
u_long count, reclaimed; u_long count, minalign, reclaimed;
int error, i, options, req_class; int error, i, options, req_class;
KASSERT(npages > 0, ("npages is 0")); KASSERT(npages > 0, ("npages is 0"));
KASSERT(powerof2(alignment), ("alignment is not a power of 2")); KASSERT(powerof2(alignment), ("alignment is not a power of 2"));
KASSERT(powerof2(boundary), ("boundary is not a power of 2")); KASSERT(powerof2(boundary), ("boundary is not a power of 2"));
alcUnsubmitted
Done
Inline Actions

I think that the rounding should be performed here, right after the KASSERT()s and before the sanity check on the number of free pages. The reason being that in the worst case vm_page_reclaim_run() will perform the rounded up number of page allocations before it frees any of the pages from the contiguous run.

alc: I think that the rounding should be performed here, right after the KASSERT()s and before the…
req_class = req & VM_ALLOC_CLASS_MASK; req_class = req & VM_ALLOC_CLASS_MASK;
/* /*
* The page daemon is allowed to dig deeper into the free page list. * The page daemon is allowed to dig deeper into the free page list.
*/ */
if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT) if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
req_class = VM_ALLOC_SYSTEM; req_class = VM_ALLOC_SYSTEM;
/* /*
* Return if the number of free pages cannot satisfy the requested * Return if the number of free pages cannot satisfy the requested
* allocation. * allocation.
*/ */
vmd = VM_DOMAIN(domain); vmd = VM_DOMAIN(domain);
count = vmd->vmd_free_count; count = vmd->vmd_free_count;
if (count < npages + vmd->vmd_free_reserved || (count < npages + if (count < npages + vmd->vmd_free_reserved || (count < npages +
vmd->vmd_interrupt_free_min && req_class == VM_ALLOC_SYSTEM) || vmd->vmd_interrupt_free_min && req_class == VM_ALLOC_SYSTEM) ||
(count < npages && req_class == VM_ALLOC_INTERRUPT)) (count < npages && req_class == VM_ALLOC_INTERRUPT))
return (false); return (false);
/*
* The caller will attempt an allocation after some runs have been
* reclaimed and added to the vm_phys buddy lists. To ensure that runs
* are not fragmented, round up the requested length to the next power
alcUnsubmitted
Done
Inline Actions

Rather than "To ensure that runs are not fragmented, ...", I would say, "Due to limitations of vm_phys_alloc_contig(), ..."

alc: Rather than "To ensure that runs are not fragmented, ...", I would say, "Due to limitations of…
* or two or maximum chunk size, and ensure that each run is suitably
* aligned.
*/
minalign = 1ul << imin(flsl(npages - 1), VM_NFREEORDER - 1);
npages = roundup2(npages, minalign);
if (alignment < ptoa(minalign))
alignment = ptoa(minalign);
/* /*
* Scan up to three times, relaxing the restrictions ("options") on * Scan up to three times, relaxing the restrictions ("options") on
* the reclamation of reservations and superpages each time. * the reclamation of reservations and superpages each time.
*/ */
for (options = VPSC_NORESERV;;) { for (options = VPSC_NORESERV;;) {
/* /*
* Find the highest runs that satisfy the given constraints * Find the highest runs that satisfy the given constraints
▲ Show 20 Lines • Show All 2,522 Lines • Show Last 20 Lines
View Options

head/usr.sbin/sesutil/sesutil.c

Show First 20 Lines • Show All 2,966 Lines • ▼ Show 20 Lines
*/ */
bool bool
vm_page_reclaim_contig_domain(int domain, int req, u_long npages, vm_page_reclaim_contig_domain(int domain, int req, u_long npages,
vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary) vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary)
{ {
struct vm_domain *vmd; struct vm_domain *vmd;
vm_paddr_t curr_low; vm_paddr_t curr_low;
vm_page_t m_run, m_runs[NRUNS]; vm_page_t m_run, m_runs[NRUNS];
u_long count, reclaimed; u_long count, minalign, reclaimed;
int error, i, options, req_class; int error, i, options, req_class;
KASSERT(npages > 0, ("npages is 0")); KASSERT(npages > 0, ("npages is 0"));
KASSERT(powerof2(alignment), ("alignment is not a power of 2")); KASSERT(powerof2(alignment), ("alignment is not a power of 2"));
KASSERT(powerof2(boundary), ("boundary is not a power of 2")); KASSERT(powerof2(boundary), ("boundary is not a power of 2"));
alcUnsubmitted
Done
Inline Actions

I think that the rounding should be performed here, right after the KASSERT()s and before the sanity check on the number of free pages. The reason being that in the worst case vm_page_reclaim_run() will perform the rounded up number of page allocations before it frees any of the pages from the contiguous run.

alc: I think that the rounding should be performed here, right after the KASSERT()s and before the…
req_class = req & VM_ALLOC_CLASS_MASK; req_class = req & VM_ALLOC_CLASS_MASK;
/* /*
* The page daemon is allowed to dig deeper into the free page list. * The page daemon is allowed to dig deeper into the free page list.
*/ */
if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT) if (curproc == pageproc && req_class != VM_ALLOC_INTERRUPT)
req_class = VM_ALLOC_SYSTEM; req_class = VM_ALLOC_SYSTEM;
/* /*
* Return if the number of free pages cannot satisfy the requested * Return if the number of free pages cannot satisfy the requested
* allocation. * allocation.
*/ */
vmd = VM_DOMAIN(domain); vmd = VM_DOMAIN(domain);
count = vmd->vmd_free_count; count = vmd->vmd_free_count;
if (count < npages + vmd->vmd_free_reserved || (count < npages + if (count < npages + vmd->vmd_free_reserved || (count < npages +
vmd->vmd_interrupt_free_min && req_class == VM_ALLOC_SYSTEM) || vmd->vmd_interrupt_free_min && req_class == VM_ALLOC_SYSTEM) ||
(count < npages && req_class == VM_ALLOC_INTERRUPT)) (count < npages && req_class == VM_ALLOC_INTERRUPT))
return (false); return (false);
/*
* The caller will attempt an allocation after some runs have been
* reclaimed and added to the vm_phys buddy lists. To ensure that runs
* are not fragmented, round up the requested length to the next power
alcUnsubmitted
Done
Inline Actions

Rather than "To ensure that runs are not fragmented, ...", I would say, "Due to limitations of vm_phys_alloc_contig(), ..."

alc: Rather than "To ensure that runs are not fragmented, ...", I would say, "Due to limitations of…
* or two or maximum chunk size, and ensure that each run is suitably
* aligned.
*/
minalign = 1ul << imin(flsl(npages - 1), VM_NFREEORDER - 1);
npages = roundup2(npages, minalign);
if (alignment < ptoa(minalign))
alignment = ptoa(minalign);
/* /*
* Scan up to three times, relaxing the restrictions ("options") on * Scan up to three times, relaxing the restrictions ("options") on
* the reclamation of reservations and superpages each time. * the reclamation of reservations and superpages each time.
*/ */
for (options = VPSC_NORESERV;;) { for (options = VPSC_NORESERV;;) {
/* /*
* Find the highest runs that satisfy the given constraints * Find the highest runs that satisfy the given constraints
▲ Show 20 Lines • Show All 2,522 Lines • Show Last 20 Lines