Hallo, dies ist ein Test.

PWD: /www/data-lst1/unixsoft/unixsoft/kaempfer/.public_html

Running in File Mode
Relative path: ././../../../../../../usr/include/vm/credits.h
Real path: /usr/include/vm/credits.h
Zurück

/*
 * Copyright (c) 2014, 2022, Oracle and/or its affiliates.
 */

#ifndef	_VM_CREDITS_H
#define	_VM_CREDITS_H

#include <vm/types.h>
#include <vm/interface.h>
#include <vm/sparse.h>
#include <vm/szc.h>

#include <sys/lgrp.h>

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * fed allocation flags
 */
typedef enum {
	FED_WAIT =		0x0001,	/* sleep until request succeeds */
	FED_WAIT_PRED =		0x0002,	/* sleep until request unsatisfiable */
	FED_WAIT_PRED_ONCE =	0x0004,	/* sleep at most one predictor cycle */
	FED_NOWAIT =		0x0008,	/* do not sleep */

FED_HIGHPRI =		0x0010,	/* can tap entire reserve */
	FED_MEDIUMPRI =		0x0020,	/* can tap part of reserve */
	FED_LOWPRI =		0x0040,	/* cannot tap reserve */

FED_LOCALONLY =		0x0100, /* fail if local memory not found */
	FED_OPTIONAL =		0x0200,	/* FED_NOWAIT allocation not critical */
	FED_SIG =		0x0400,	/* allow interruption by sigs */
	FED_PANIC =		0x0800,	/* Panic instead of failing */

/* Steal from MRPs before hitting breadline */
	FED_STEAL =		0x1000,

FED_ALCHEMY_RESIZE = 	0x10000,  /* alchemy: allow smaller credits */
	FED_ALCHEMY_PARTIAL =	0x20000,  /* alchemy: allow partial success */
	FED_ALCHEMY_LPGWAITPRED = 0x40000 /* alchemy: WAIT_PRED for >SZC_MIN */
} fed_flags_t;

#define	FED_NORMALFLAGS (FED_WAITFLAGS | FED_PRIFLAGS | FED_OPTFLAGS)

/*
 * Arguments to crd_xfer().
 */
typedef enum {
	CRD_XFER_USER_FIRST = (1 << 0),		/* xfer user, then kcage */
	CRD_XFER_KCAGE_FIRST = (1 << 1),	/* xfer kcage, then user */
	CRD_XFER_RESIZE = (1 << 2)		/* allow downsizing */
} crd_xfer_flags_t;

/*
 * ------------------------------------------------------------------------
 * Internal interfaces.
 *
 * Yes, we mean it.
 */

#ifdef _KERNEL

/*
 * Threads
 */
extern void	fed_soupline_mnode_thread(void *);
extern void	fed_soupline_thread(void *);
extern void	cachelist_juice_thread(void *);

/*
 * Init functions
 */
extern void	crd_alchemy_init(void);
extern void	fed_breadline_init(void);
extern void	wallet_init(void);

typedef struct crd_alchemy_state crd_alchemy_state_t;

/*
 * Crd alchemy fills a set of "gold" wallets based on a set of "lead" counts.
 * It is mainly used by capture.
 *
 * Because the number of arguments to crd_alchemy were getting out of hand,
 * it now takes this data structure as an argument.
 */
typedef struct crd_alchemy_request {
	/* global request info */
	crd_alchemy_state_t	*car_state;	/* storage for temp state */

/* parallel arrays of arguments */
	crd_t		*const	*car_crds;	/* "gold" wallets */
	const crd_t	*const	*car_templates;	/* "lead" templates */
	const fed_flags_t	*car_flags;	/* per-wallet flags */
	uint_t			car_ncrds;	/* size of above arrays */

/* output: info on failure; only set if crd_alchemy returns 0 or -1 */
	uint_t			car_failed_crd;	/* crd # we failed on */
	szc_t			car_failed_szc;	/* SZC we were allocating */
	pgcnt_t			car_failed_count; /* # pages we were short */
} crd_alchemy_request_t;

typedef uint_t	fed_sleep_f(void *, struct mutex *);
typedef void	fed_wakeup_f(void *);

extern int	crd_alchemy(struct crd_alchemy_request *, flr_t *,
    fed_sleep_f *, fed_wakeup_f *, void *);
extern void	crd_alchemy_sweep(struct crd_alchemy_request *);
extern void	crd_init(crd_t *, uint_t, uint_t, uint_t, uint_t);
extern void	crd_init_fixed(crd_t *, uint_t, uint_t, mnodeid_t, uint_t);
extern void	crd_lock(crd_t *);
extern int	crd_holds(crd_t *, pgcnt_t, uint_t);
extern int	crd_holds_one_page_resize(crd_t *, uint_t);
extern uint_t	crd_nmnodes_for_szc(const crd_t *, uint_t);
extern void	crd_empty(crd_t *);
extern void	crd_unlock(crd_t *);
extern void	crd_tick(crd_t *);
extern void	crd_push(crd_t *);
extern void	crd_pop(crd_t *);
extern void	crd_pop_nonempty(crd_t *);
extern void	crd_thief_thread(void);
extern void	crd_thief_wakeup(void);
extern void	crd_withdraw_credit(crd_t *, pgcnt_t,
    mnodeid_t, ku_type_t, uint_t);
extern void	crd_deposit_credit(crd_t *, pgcnt_t,
    mnodeid_t, ku_type_t, uint_t, uint_t);

extern pgcnt_t	crd_fill_from_crd(crd_t *, crd_t *, pgcnt_t, flr_t *, szc_t);
extern size_t	crd_remove_amount_mnodes(crd_t *, size_t, szc_t, mnodeset_t);
extern size_t	crd_free_rml(crd_t *, rm_t *);

extern void	crd_xfer(crd_t *, crd_t *, pgcnt_t, szc_t, crd_xfer_flags_t);
extern void	crd_xfer_credits(crd_t *, crd_t *, pgcnt_t,
    mnodeid_t, ku_type_t, uint_t);

/*
 * Generic "transfer from this CRD" crd_alloc_cb_f callback.
 * The last parameter "void *" should be a CRD we can allocate from.
 */
extern spgcnt_t crd_alloc_xfer_cb(crd_t *, pgcnt_t, mnodeid_t, szc_t, void *);

extern wallet_t	*wallet_stack_one_fixed(one_wallet_t *, mnodeid_t, szc_t,
    wallet_stack_flags_t);
extern spgcnt_t	wallet_fill_sig(wallet_t *, pgcnt_t, uint_t, flr_t *,
    wallet_fill_flags_t);

typedef void wallet_walk_bymnode_cb_f(crd_t *, mnodeid_t, szc_t, pgcnt_t,
    void *);
extern void wallet_walk_bymnode(wallet_t *, szc_t, wallet_walk_bymnode_cb_f *,
    void *);

extern crd_t	*leadcrd_init(lead_wallet_t *, uint_t);
extern void	leadcrd_withdraw(crd_t *, pgcnt_t, uint_t);
extern void	leadcrd_deposit(crd_t *, pgcnt_t, uint_t);

typedef void	lead_multi_wallet_walk_cb_f(pgcnt_t, mnodeid_t, szc_t, void *);

extern void	lead_multi_wallet_init(lead_multi_wallet_t *);
extern void	lead_multi_wallet_deposit(lead_multi_wallet_t *,
    pgcnt_t, mnodeid_t, szc_t);
extern void	lead_multi_wallet_walk_bymnid_szc(const lead_multi_wallet_t *,
    lead_multi_wallet_walk_cb_f *, void *);

extern szcmap_t	lead_multi_wallet_szcmap(const lead_multi_wallet_t *);
extern mnodeset_t lead_multi_wallet_mnodeset(const lead_multi_wallet_t *);

extern size_t	fed_credit_tree_size(void);
extern void	fed_credit_tree_init(mnodeid_t, ku_type_t, uint_t);
extern void	fed_sample(mnodeid_t, pgcnt_t [KU_NTYPES][SZC_MAX]);
extern void	tile_sample(mnodeid_t, pgcnt_t [KU_NTYPES][SZC_MAX]);
extern void	borrow_sample(mnodeid_t, pgcnt_t [KU_NTYPES][SZC_MAX]);
extern void	cache_sample(mnodeid_t, pgcnt_t [KU_NTYPES][SZC_MAX]);
extern void	fed_borrow_sample(mnodeid_t, pgcnt_t [KU_NTYPES][SZC_MAX]);
extern void	fed_reserve_setup(pgcnt_t, pgcnt_t);
extern pgcnt_t	fed_reserve_total_size(void);
extern pgcnt_t	fed_free_page_count(mnodeid_t, ku_type_t, uint_t);

extern void	fed_borrow_kcage_credits(mnodeid_t, uint_t, pgcnt_t);
extern void	fed_return_kcage_credits(mnodeid_t, uint_t, pgcnt_t);

/*
 * Calls related to breadline-predictor interactions and generating credits
 * on-demand.
 */
extern pgcnt_t	fed_fccb(pgcnt_t, mnodeid_t, ku_type_t, uint_t, uint_t,
    boolean_t);
extern pgcnt_t	fed_generate_credits(pgcnt_t, mnodeid_t, ku_type_t, uint_t);

extern void predictor_breadline_reserve_tapped(mnodeid_t, ku_type_t, uint_t);

/* Does it make sense to borrow? Steal? */
extern void fed_enable_borrow(mnodeid_t, uint_t);
extern void fed_limit_borrow(mnodeid_t, uint_t);

extern pgcnt_t fed_breadline_current_need(mnodeid_t, ku_type_t, uint_t);

extern void predictor_breadline_active(mnodeid_t, ku_type_t, uint_t);

extern pgcnt_t fed_breadline_predictor_mark_nosleeps(mnodeid_t, ku_type_t,
    uint_t);
extern pgcnt_t fed_breadline_predictor_done(mnodeid_t, ku_type_t, uint_t);
extern void fed_breadline_predictor_disable(mnodeid_t, ku_type_t, uint_t);
extern void fed_breadline_predictor_enable(mnodeid_t, ku_type_t, uint_t);

extern void	fed_soupline_wakeup_timedouts(void);

extern spgcnt_t fed_fill(crd_t *, pgcnt_t, uint_t, flr_t *, fed_flags_t,
    fed_sleep_f *, fed_wakeup_f *, void *);

/*
 * ------------------------------------------------------------------
 * Well-known global variables.
 */

extern pgcnt_t		User_freemem;
extern pgcnt_t		Kernel_freemem;
extern pgcnt_t		Cachelist_freemem;

#endif /* _KERNEL */

#ifdef	__cplusplus
}
#endif

#endif	/* _VM_CREDITS_H */