Page MenuHomeFreeBSD
Differential D16848

Move etc/services to usr.sbin/services_mkdb/
ClosedPublic
Actions

Authored by brd on Aug 22 2018, 4:30 PM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Mar 20, 12:34 AM
Unknown Object (File)
Tue, Mar 11, 10:44 PM
Unknown Object (File)
Fri, Feb 28, 7:07 PM
Unknown Object (File)
Feb 22 2025, 12:10 AM
Unknown Object (File)
Jan 25 2025, 7:40 PM
Unknown Object (File)
Jan 24 2025, 7:17 PM
Unknown Object (File)
Jan 19 2025, 7:34 AM
Unknown Object (File)
Jan 19 2025, 7:34 AM
View All 95 Files
Subscribers
imp

Details

Reviewers
will
Commits
rS338212: Move services to usr.sbin/services_mkdb/
Test Plan

Run make distribution and compare the results

Diff Detail

Repository
rS FreeBSD src repository - subversion
Lint
Lint Passed
Unit
No Test Coverage
Build Status
Buildable 19061
Build 18692: arc lint + arc unit

Event Timeline

brd created this revision.Aug 22 2018, 4:30 PM
Herald added a subscriber: imp. · View Herald TranscriptAug 22 2018, 4:30 PM
Harbormaster completed remote builds in B19052: Diff 47109.Aug 22 2018, 4:30 PM
brd updated this revision to Diff 47119.Aug 22 2018, 6:33 PM

Include src.opts.mk so the MK_ knob works as expected

Harbormaster completed remote builds in B19061: Diff 47119.Aug 22 2018, 6:33 PM
will accepted this revision.Aug 22 2018, 8:36 PM
This revision is now accepted and ready to land.Aug 22 2018, 8:36 PM
Closed by commit rS338212: Move services to usr.sbin/services_mkdb/ (authored by brd). · Explain WhyAug 22 2018, 9:22 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathSize
etc/
8 lines
usr.sbin/
services_mkdb/
13 lines
usr.sbin/
services_mkdb/
etc/

Diff 47119

View Options

etc/Makefile

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Lines
} }
/* /*
* blist_alloc() - reserve space in the block bitmap. Return the base * blist_alloc() - reserve space in the block bitmap. Return the base
* of a contiguous region or SWAPBLK_NONE if space could * of a contiguous region or SWAPBLK_NONE if space could
* not be allocated. * not be allocated.
*/ */
daddr_t daddr_t
blist_alloc(blist_t bl, int *count, int maxcount) blist_alloc(blist_t bl, daddr_t *io_cursor, int *count, int maxcount)
{ {
daddr_t blk, cursor; daddr_t blk, cursor;
KASSERT(*count <= maxcount, KASSERT(*count <= maxcount,
("invalid parameters %d > %d", *count, maxcount)); ("invalid parameters %d > %d", *count, maxcount));
KASSERT(*count <= BLIST_MAX_ALLOC, KASSERT(*count <= BLIST_MAX_ALLOC,
("minimum allocation too large: %d", *count)); ("minimum allocation too large: %d", *count));
/* /*
* This loop iterates at most twice. An allocation failure in the * This loop iterates at most twice. An allocation failure in the
* first iteration leads to a second iteration only if the cursor was * first iteration leads to a second iteration only if the cursor was
* non-zero. When the cursor is zero, an allocation failure will * non-zero. When the cursor is zero, an allocation failure will
* stop further iterations. * stop further iterations.
*/ */
for (cursor = bl->bl_cursor;; cursor = 0) { for (cursor = *io_cursor;; cursor = 0) {
blk = blst_meta_alloc(bl->bl_root, cursor, count, maxcount, blk = blst_meta_alloc(bl->bl_root, cursor, count, maxcount,
bl->bl_radix); bl->bl_radix);
if (blk != SWAPBLK_NONE) { if (blk != SWAPBLK_NONE) {
bl->bl_avail -= *count; bl->bl_avail -= *count;
bl->bl_cursor = blk + *count; *io_cursor = blk + *count;
if (bl->bl_cursor == bl->bl_blocks) if (*io_cursor == bl->bl_blocks)
bl->bl_cursor = 0; *io_cursor = 0;
return (blk); return (blk);
} }
if (cursor == 0) if (cursor == 0)
return (SWAPBLK_NONE); return (SWAPBLK_NONE);
} }
} }
/* /*
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
#ifdef BLIST_DEBUG #ifdef BLIST_DEBUG
/* /*
* blist_print() - dump radix tree * blist_print() - dump radix tree
*/ */
void void
blist_print(blist_t bl) blist_print(blist_t bl)
{ {
printf("BLIST avail = %jd, cursor = %08jx {\n", printf("BLIST avail = %jd {\n", (uintmax_t)bl->bl_avail);
(uintmax_t)bl->bl_avail, (uintmax_t)bl->bl_cursor);
if (bl->bl_root->bm_bitmap != 0) if (bl->bl_root->bm_bitmap != 0)
blst_radix_print(bl->bl_root, 0, bl->bl_radix, 4); blst_radix_print(bl->bl_root, 0, bl->bl_radix, 4);
printf("}\n"); printf("}\n");
} }
#endif #endif
▲ Show 20 Lines • Show All 801 Lines • Show Last 20 Lines
View Options

etc/services

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Lines
} }
/* /*
* blist_alloc() - reserve space in the block bitmap. Return the base * blist_alloc() - reserve space in the block bitmap. Return the base
* of a contiguous region or SWAPBLK_NONE if space could * of a contiguous region or SWAPBLK_NONE if space could
* not be allocated. * not be allocated.
*/ */
daddr_t daddr_t
blist_alloc(blist_t bl, int *count, int maxcount) blist_alloc(blist_t bl, daddr_t *io_cursor, int *count, int maxcount)
{ {
daddr_t blk, cursor; daddr_t blk, cursor;
KASSERT(*count <= maxcount, KASSERT(*count <= maxcount,
("invalid parameters %d > %d", *count, maxcount)); ("invalid parameters %d > %d", *count, maxcount));
KASSERT(*count <= BLIST_MAX_ALLOC, KASSERT(*count <= BLIST_MAX_ALLOC,
("minimum allocation too large: %d", *count)); ("minimum allocation too large: %d", *count));
/* /*
* This loop iterates at most twice. An allocation failure in the * This loop iterates at most twice. An allocation failure in the
* first iteration leads to a second iteration only if the cursor was * first iteration leads to a second iteration only if the cursor was
* non-zero. When the cursor is zero, an allocation failure will * non-zero. When the cursor is zero, an allocation failure will
* stop further iterations. * stop further iterations.
*/ */
for (cursor = bl->bl_cursor;; cursor = 0) { for (cursor = *io_cursor;; cursor = 0) {
blk = blst_meta_alloc(bl->bl_root, cursor, count, maxcount, blk = blst_meta_alloc(bl->bl_root, cursor, count, maxcount,
bl->bl_radix); bl->bl_radix);
if (blk != SWAPBLK_NONE) { if (blk != SWAPBLK_NONE) {
bl->bl_avail -= *count; bl->bl_avail -= *count;
bl->bl_cursor = blk + *count; *io_cursor = blk + *count;
if (bl->bl_cursor == bl->bl_blocks) if (*io_cursor == bl->bl_blocks)
bl->bl_cursor = 0; *io_cursor = 0;
return (blk); return (blk);
} }
if (cursor == 0) if (cursor == 0)
return (SWAPBLK_NONE); return (SWAPBLK_NONE);
} }
} }
/* /*
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
#ifdef BLIST_DEBUG #ifdef BLIST_DEBUG
/* /*
* blist_print() - dump radix tree * blist_print() - dump radix tree
*/ */
void void
blist_print(blist_t bl) blist_print(blist_t bl)
{ {
printf("BLIST avail = %jd, cursor = %08jx {\n", printf("BLIST avail = %jd {\n", (uintmax_t)bl->bl_avail);
(uintmax_t)bl->bl_avail, (uintmax_t)bl->bl_cursor);
if (bl->bl_root->bm_bitmap != 0) if (bl->bl_root->bm_bitmap != 0)
blst_radix_print(bl->bl_root, 0, bl->bl_radix, 4); blst_radix_print(bl->bl_root, 0, bl->bl_radix, 4);
printf("}\n"); printf("}\n");
} }
#endif #endif
▲ Show 20 Lines • Show All 801 Lines • Show Last 20 Lines
View Options

usr.sbin/services_mkdb/Makefile

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Lines
} }
/* /*
* blist_alloc() - reserve space in the block bitmap. Return the base * blist_alloc() - reserve space in the block bitmap. Return the base
* of a contiguous region or SWAPBLK_NONE if space could * of a contiguous region or SWAPBLK_NONE if space could
* not be allocated. * not be allocated.
*/ */
daddr_t daddr_t
blist_alloc(blist_t bl, int *count, int maxcount) blist_alloc(blist_t bl, daddr_t *io_cursor, int *count, int maxcount)
{ {
daddr_t blk, cursor; daddr_t blk, cursor;
KASSERT(*count <= maxcount, KASSERT(*count <= maxcount,
("invalid parameters %d > %d", *count, maxcount)); ("invalid parameters %d > %d", *count, maxcount));
KASSERT(*count <= BLIST_MAX_ALLOC, KASSERT(*count <= BLIST_MAX_ALLOC,
("minimum allocation too large: %d", *count)); ("minimum allocation too large: %d", *count));
/* /*
* This loop iterates at most twice. An allocation failure in the * This loop iterates at most twice. An allocation failure in the
* first iteration leads to a second iteration only if the cursor was * first iteration leads to a second iteration only if the cursor was
* non-zero. When the cursor is zero, an allocation failure will * non-zero. When the cursor is zero, an allocation failure will
* stop further iterations. * stop further iterations.
*/ */
for (cursor = bl->bl_cursor;; cursor = 0) { for (cursor = *io_cursor;; cursor = 0) {
blk = blst_meta_alloc(bl->bl_root, cursor, count, maxcount, blk = blst_meta_alloc(bl->bl_root, cursor, count, maxcount,
bl->bl_radix); bl->bl_radix);
if (blk != SWAPBLK_NONE) { if (blk != SWAPBLK_NONE) {
bl->bl_avail -= *count; bl->bl_avail -= *count;
bl->bl_cursor = blk + *count; *io_cursor = blk + *count;
if (bl->bl_cursor == bl->bl_blocks) if (*io_cursor == bl->bl_blocks)
bl->bl_cursor = 0; *io_cursor = 0;
return (blk); return (blk);
} }
if (cursor == 0) if (cursor == 0)
return (SWAPBLK_NONE); return (SWAPBLK_NONE);
} }
} }
/* /*
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
#ifdef BLIST_DEBUG #ifdef BLIST_DEBUG
/* /*
* blist_print() - dump radix tree * blist_print() - dump radix tree
*/ */
void void
blist_print(blist_t bl) blist_print(blist_t bl)
{ {
printf("BLIST avail = %jd, cursor = %08jx {\n", printf("BLIST avail = %jd {\n", (uintmax_t)bl->bl_avail);
(uintmax_t)bl->bl_avail, (uintmax_t)bl->bl_cursor);
if (bl->bl_root->bm_bitmap != 0) if (bl->bl_root->bm_bitmap != 0)
blst_radix_print(bl->bl_root, 0, bl->bl_radix, 4); blst_radix_print(bl->bl_root, 0, bl->bl_radix, 4);
printf("}\n"); printf("}\n");
} }
#endif #endif
▲ Show 20 Lines • Show All 801 Lines • Show Last 20 Lines
View Options

usr.sbin/services_mkdb/services

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Lines
} }
/* /*
* blist_alloc() - reserve space in the block bitmap. Return the base * blist_alloc() - reserve space in the block bitmap. Return the base
* of a contiguous region or SWAPBLK_NONE if space could * of a contiguous region or SWAPBLK_NONE if space could
* not be allocated. * not be allocated.
*/ */
daddr_t daddr_t
blist_alloc(blist_t bl, int *count, int maxcount) blist_alloc(blist_t bl, daddr_t *io_cursor, int *count, int maxcount)
{ {
daddr_t blk, cursor; daddr_t blk, cursor;
KASSERT(*count <= maxcount, KASSERT(*count <= maxcount,
("invalid parameters %d > %d", *count, maxcount)); ("invalid parameters %d > %d", *count, maxcount));
KASSERT(*count <= BLIST_MAX_ALLOC, KASSERT(*count <= BLIST_MAX_ALLOC,
("minimum allocation too large: %d", *count)); ("minimum allocation too large: %d", *count));
/* /*
* This loop iterates at most twice. An allocation failure in the * This loop iterates at most twice. An allocation failure in the
* first iteration leads to a second iteration only if the cursor was * first iteration leads to a second iteration only if the cursor was
* non-zero. When the cursor is zero, an allocation failure will * non-zero. When the cursor is zero, an allocation failure will
* stop further iterations. * stop further iterations.
*/ */
for (cursor = bl->bl_cursor;; cursor = 0) { for (cursor = *io_cursor;; cursor = 0) {
blk = blst_meta_alloc(bl->bl_root, cursor, count, maxcount, blk = blst_meta_alloc(bl->bl_root, cursor, count, maxcount,
bl->bl_radix); bl->bl_radix);
if (blk != SWAPBLK_NONE) { if (blk != SWAPBLK_NONE) {
bl->bl_avail -= *count; bl->bl_avail -= *count;
bl->bl_cursor = blk + *count; *io_cursor = blk + *count;
if (bl->bl_cursor == bl->bl_blocks) if (*io_cursor == bl->bl_blocks)
bl->bl_cursor = 0; *io_cursor = 0;
return (blk); return (blk);
} }
if (cursor == 0) if (cursor == 0)
return (SWAPBLK_NONE); return (SWAPBLK_NONE);
} }
} }
/* /*
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
#ifdef BLIST_DEBUG #ifdef BLIST_DEBUG
/* /*
* blist_print() - dump radix tree * blist_print() - dump radix tree
*/ */
void void
blist_print(blist_t bl) blist_print(blist_t bl)
{ {
printf("BLIST avail = %jd, cursor = %08jx {\n", printf("BLIST avail = %jd {\n", (uintmax_t)bl->bl_avail);
(uintmax_t)bl->bl_avail, (uintmax_t)bl->bl_cursor);
if (bl->bl_root->bm_bitmap != 0) if (bl->bl_root->bm_bitmap != 0)
blst_radix_print(bl->bl_root, 0, bl->bl_radix, 4); blst_radix_print(bl->bl_root, 0, bl->bl_radix, 4);
printf("}\n"); printf("}\n");
} }
#endif #endif
▲ Show 20 Lines • Show All 801 Lines • Show Last 20 Lines