| /onnv/onnv-gate/usr/src/lib/libpool/common/ |
| llib-lpool | 31 #include <pool.h>
|
| /onnv/onnv-gate/usr/src/cmd/ipf/lib/common/ |
| printpooldata.c | 17 void printpooldata(pool, opts)
18 ip_pool_t *pool;
23 if ((pool->ipo_flags & IPOOL_ANON) != 0)
24 PRINTF("# 'anonymous' tree %s\n", pool->ipo_name);
27 PRINTF("Name: %s", pool->ipo_name);
28 if ((pool->ipo_flags & IPOOL_ANON) == IPOOL_ANON)
34 switch (pool->ipo_unit)
61 PRINTF("unknown(%d)", pool->ipo_unit);
65 PRINTF(" type = tree number = %s\n", pool->ipo_name);
69 PRINTF("\tReferences: %d\tHits: %lu\n", pool->ipo_ref
[all...] |
| remove_pool.c | 23 ip_pool_t pool; local
33 op.iplo_size = sizeof(pool);
34 op.iplo_struct = &pool;
36 bzero((char *)&pool, sizeof(pool));
37 pool.ipo_unit = poolp->ipo_unit;
38 strncpy(pool.ipo_name, poolp->ipo_name, sizeof(pool.ipo_name));
39 pool.ipo_flags = poolp->ipo_flags;
|
| load_pool.c | 29 ip_pool_t pool; local
40 op.iplo_size = sizeof(pool);
41 op.iplo_struct = &pool;
42 bzero((char *)&pool, sizeof(pool));
43 strncpy(pool.ipo_name, plp->ipo_name, sizeof(pool.ipo_name));
56 pool.ipo_list = plp->ipo_list;
57 printpool(&pool, bcopywrap, pool.ipo_name, opts)
[all...] |
| printpool_live.c | 20 ip_pool_t *printpool_live(pool, fd, name, opts)
21 ip_pool_t *pool;
31 if ((name != NULL) && strncmp(name, pool->ipo_name, FR_GROUPLEN))
32 return pool->ipo_next;
34 printpooldata(pool, opts);
48 iter.ili_unit = pool->ipo_unit;
49 strncpy(iter.ili_name, pool->ipo_name, FR_GROUPLEN);
80 return pool->ipo_next;
|
| /onnv/onnv-gate/usr/src/uts/common/rpc/ |
| svc.c | 50 * Each master transport is registered to exactly one thread pool.
64 * A pool represents a kernel RPC service (NFS, Lock Manager, etc.).
65 * Transports related to the service are registered to the service pool.
66 * Service threads can switch between different transports in the pool.
67 * Thus, each service has its own pool of service threads. The maximum
68 * number of threads in a pool is pool->p_maxthreads. This limit allows
76 * In addition, each pool contains a doubly-linked list of transports,
78 * the pool share some other parameters such as stack size and
85 * svc_do_run(), respectively. Once the pool has been initialized
357 SVCPOOL *pool; local
474 SVCPOOL *pool; local
498 SVCPOOL *pool; local
679 SVCPOOL *pool; local
712 SVCPOOL *pool; local
786 SVCPOOL *pool; local
848 SVCPOOL *pool = xprt->xp_pool; local
1653 SVCPOOL *pool; local
2274 SVCPOOL *pool; local
2328 SVCPOOL *pool = xprt->xp_pool; local
2376 SVCPOOL *pool = xprt->xp_pool; local
2477 SVCPOOL *pool = clone_xprt->xp_master->xp_pool; local
2507 SVCPOOL *pool = clone_xprt->xp_master->xp_pool; local
2545 SVCPOOL *pool = xprt->xp_pool; local
2591 SVCPOOL *pool; local
[all...] |
| /onnv/onnv-gate/usr/src/pkgdefs/SUNWpoold/ |
| prototype_com | 49 d none usr/lib/pool 755 root bin
50 f none usr/lib/pool/poold 555 root bin
51 f none usr/lib/pool/libjkstat.so.1 755 root bin
52 s none usr/lib/pool/libjkstat.so=./libjkstat.so.1
53 f none usr/lib/pool/libjlgrp.so.1 755 root bin
54 s none usr/lib/pool/libjlgrp.so=./libjlgrp.so.1
55 f none usr/lib/pool/libjpool.so.1 755 root bin
56 s none usr/lib/pool/libjpool.so=./libjpool.so.1
57 f none usr/lib/pool/libjsyslog.so.1 755 root bin
58 s none usr/lib/pool/libjsyslog.so=./libjsyslog.so.
[all...] |
| /onnv/onnv-gate/usr/src/cmd/pools/poold/ |
| svc-poold | 33 if [ ! -x /usr/lib/pool/poold ]; then
34 echo "/usr/lib/pool/poold not found or not executable"
45 /usr/lib/pool/poold
|
| /onnv/onnv-gate/usr/src/common/zfs/ |
| zfs_namecheck.c | 289 * For pool names, we have the same set of valid characters as described in
290 * dataset names, with the additional restriction that the pool name must begin
291 * with a letter. The pool names 'raidz' and 'mirror' are also reserved names
295 pool_namecheck(const char *pool, namecheck_err_t *why, char *what)
302 * ZPOOL_MAXNAMELEN is the maximum pool length used in the userland
307 if (strlen(pool) >= MAXNAMELEN) {
313 c = pool;
325 if (!(*pool >= 'a' && *pool <= 'z') &&
326 !(*pool >= 'A' && *pool <= 'Z'))
[all...] |
| /onnv/onnv-gate/usr/src/cmd/filebench/scripts/ |
| fs_flush.pl | 47 # It is zfs. Find name of pool to export/import from supplied
82 # first forward slash is the pool name
84 ($pool) = split /\//, $root;
96 print "'zpool export \/ import $pool'\n";
97 if (run_prog("zpool export $pool") == 0) {
98 system("zpool import $cachefile$pool");
|
| /onnv/onnv-gate/usr/src/lib/libast/common/sfio/ |
| sfstack.c | 73 if(f1->pool && f1->pool != &_Sfpool && f1->pool != f2->pool &&
74 f1 == f1->pool->sf[0])
75 { /* get something else to pool front since f1 will be locked */
76 for(n = 1; n < f1->pool->n_sf; ++n)
77 { if(SFFROZEN(f1->pool->sf[n]) )
79 (*_Sfpmove)(f1->pool->sf[n],0);
85 if(f2->pool && f2->pool != &_Sfpool && f2 != f2->pool->sf[0]
[all...] |
| sfswap.c | 76 if(!f1->pool)
78 else for(f1pool = f1->pool->n_sf-1; f1pool >= 0; --f1pool)
79 if(f1->pool->sf[f1pool] == f1)
81 if(!f2->pool)
83 else for(f2pool = f2->pool->n_sf-1; f2pool >= 0; --f2pool)
84 if(f2->pool->sf[f2pool] == f2)
90 /* swap image and pool entries */
95 f1->pool->sf[f2pool] = f1;
97 f2->pool->sf[f1pool] = f2;
|
| sfpool.c | 26 ** otherwise, f is isolated from its pool. flag can be one of
32 /* Note that we do not free the space for a pool once it is allocated.
33 ** This is to prevent memory faults in calls such as sfsync(NULL) that walk the pool
62 /* look to see if there is a free pool */
102 Sfpool_t* p; /* the pool */
104 int n; /* current position in pool */
127 else /* shared pool of write-streams, data can be moved among streams */
168 /* delete a stream from its pool */
173 Sfpool_t* p; /* the pool */
175 int n; /* position in pool */
[all...] |
| /onnv/onnv-gate/usr/src/lib/pkcs11/libpkcs11/common/ |
| metaSlotManager.c | 144 * No need to lock pool, we assume all meta sessions are closed.
442 session_pool_t *pool; local
451 pool = &slots[slotnum].session_pool;
457 (void) pthread_mutex_lock(&pool->list_lock);
459 if (pool->idle_list_head != NULL) {
460 tmp_session = get_session(&(pool->idle_list_head), flags);
463 INSERT_INTO_LIST(pool->active_list_head, tmp_session);
465 pool->num_idle_sessions--;
466 (void) pthread_mutex_unlock(&pool->list_lock);
471 if (pool->persist_list_head != NULL)
530 session_pool_t *pool; local
[all...] |
| /onnv/onnv-gate/usr/src/cmd/fm/dicts/ |
| ZFS.dict | 31 ereport.fs.zfs.pool.corrupt_cache=1
36 ereport.fs.zfs.pool.bad_guid_sum=6
37 ereport.fs.zfs.pool.corrupt_pool=7
41 fault.fs.zfs.pool=11
43 ereport.fs.zfs.pool.hostname_mismatch=13
|
| /onnv/onnv-gate/usr/src/lib/udapl/udapl_tavor/common/ |
| dapl_cookie.c | 45 * To support this feature, a pool of memory is allocated up front large
54 * Each cookie store its index in this memory pool.
151 buffer->pool = dapl_os_alloc(size * sizeof (DAPL_COOKIE));
152 if (NULL != buffer->pool) {
158 buffer->pool[i].index = i;
159 buffer->pool[i].queue_type = type;
161 buffer->pool[i].queue.ep = queue;
163 buffer->pool[i].queue.srq = queue;
215 curr_buffer->pool[0].queue.ptr, curr_buffer->pool[0].queue_type
[all...] |
| /onnv/onnv-gate/usr/src/cmd/availdevs/ |
| availdevs.c | 128 xmlNodePtr pool; local
141 pool = xmlNewChild(importable, NULL, (xmlChar *)ELEMENT_POOL, NULL);
142 xmlSetProp(pool, (xmlChar *)ATTR_POOL_NAME, (xmlChar *)name);
144 set_uint64_prop(pool, ATTR_POOL_ID, guid);
145 set_uint64_prop(pool, ATTR_POOL_VERSION, version);
146 set_uint64_prop(pool, ATTR_POOL_USED, vs->vs_alloc);
147 set_uint64_prop(pool, ATTR_POOL_SIZE, vs->vs_space);
148 set_uint64_prop(pool, ATTR_POOL_REPLACEMENT_SIZE, vs->vs_rsize);
149 set_uint64_prop(pool, ATTR_POOL_READ_BYTES,
151 set_uint64_prop(pool, ATTR_POOL_WRITE_BYTES
[all...] |
| /onnv/onnv-gate/usr/src/uts/common/io/idm/ |
| idm_impl.c | 615 * ID pool code. We use this to generate unique structure identifiers without
619 * A pool of IDs is a pool of 16 bit numbers. It is implemented as a bitmap.
626 * The pools start with a size of 8 bytes or 64 IDs. Each time the pool runs
629 * means that a pool can have a maximum number of 65534 IDs available.
634 idm_idpool_t *pool)
639 ASSERT(pool->id_magic == IDM_IDPOOL_MAGIC);
641 new_size = pool->id_size * 2;
646 bcopy(pool->id_pool, new_pool, pool->id_size / 8)
[all...] |
| /onnv/onnv-gate/usr/src/cmd/mdb/common/modules/genunix/ |
| irm.c | 68 return (list_walk_init_named(wsp, "interrupt pools", "pool"));
83 ddi_irm_pool_t pool; local
104 if (mdb_vread(&pool, sizeof (pool), addr) != sizeof (pool)) {
105 mdb_warn("couldn't read interrupt pool at %p", addr);
110 (uintptr_t)pool.ipool_owner) != sizeof (dev)) {
111 mdb_warn("couldn't read dev_info at %p", pool.ipool_owner);
115 mdb_devinfo2driver((uintptr_t)pool.ipool_owner, driver,
121 irm_get_type(pool.ipool_types), pool.ipool_totsz
[all...] |
| /onnv/onnv-gate/usr/src/uts/common/os/ |
| pool.c | 27 #include <sys/pool.h>
52 * a common abstraction called a pool. Processor sets and other entities can
57 * to the same pool (pool_default), and processor sets can be managed through
85 * new pool, or (in case of an error) they will be all left bound to the
86 * old pool. Processes in a given task or a given project can only be bound to
88 * processes. Threads or LWPs of the same process do not have pool bindings,
89 * and are bound to the same resource sets associated with the resource pool
92 * The following picture shows one possible pool configuration with three
140 pool_t *pool_default; /* default pool which always exists */
148 static id_space_t *pool_ids; /* pool ID space *
349 pool_t *pool = pool_default; local
365 pool_t *pool = pool_default; local
383 pool_t *pool; local
433 pool_t *pool; local
646 pool_t *pool; local
693 pool_t *pool; local
744 pool_t *pool; local
952 pool_t *pool; local
968 pool_t *pool; local
[all...] |
| /onnv/onnv-gate/usr/src/uts/common/io/1394/targets/av1394/ |
| av1394_isoch_chan.c | 98 av1394_isoch_pool_t *pool; local
159 pool = &icp->ic_ir.ir_data_pool;
162 pool = &icp->ic_it.it_data_pool;
174 icp->ic_mmap_sz = pool->ip_umem_size;
412 * Allocate isoch pool for at least 'mincnt' and at most 'cnt' frames
422 * Function returns number of frames the resulting pool can hold.
425 av1394_ic_alloc_pool(av1394_isoch_pool_t *pool, size_t framesz, int cnt,
461 pool->ip_alloc_size = nsegs * sizeof (av1394_isoch_seg_t);
462 pool->ip_seg = kmem_zalloc(pool->ip_alloc_size, KM_SLEEP)
[all...] |
| /onnv/onnv-gate/usr/src/uts/common/fs/smbsrv/ |
| smb_util.c | 407 * This function increments the ID pool by doubling the current size. This
408 * function assumes the caller entered the mutex of the pool.
412 smb_idpool_t *pool)
417 ASSERT(pool->id_magic == SMB_IDPOOL_MAGIC);
419 new_size = pool->id_size * 2;
424 bcopy(pool->id_pool, new_pool, pool->id_size / 8);
425 kmem_free(pool->id_pool, pool->id_size / 8);
426 pool->id_pool = new_pool
[all...] |
| /onnv/onnv-gate/usr/src/pkgdefs/SUNWpool/ |
| prototype_i386 | 51 f none usr/kernel/drv/pool 755 root sys
52 f none usr/kernel/drv/pool.conf 644 root sys
54 f none usr/kernel/drv/amd64/pool 755 root sys
|
| prototype_sparc | 51 f none usr/kernel/drv/sparcv9/pool 755 root sys
52 f none usr/kernel/drv/pool.conf 644 root sys
|
| /onnv/onnv-gate/usr/src/cmd/zinject/ |
| zinject.c | 38 * pool. There are two types of errors that can be injected, EIO and ENXIO,
50 * zinject -d device [-e errno] [-L <uber | nvlist>] pool
72 * config pool configuration
102 * zinject <-a | -u pool>
106 * zinject [-f freq] [-a] [-m] [-u] -b objset:object:level:start:end pool
225 "\tzinject -p <function name> pool\n"
231 "\t [-T <read|write|free|claim|all> pool\n"
236 "\tzinject -d device -A <degrade|fault> pool\n"
239 "\tzinject -I [-s <seconds> | -g <txgs>] pool\n"
240 "\t\tCause the pool to stop writing blocks yet not\n
550 char pool[MAXNAMELEN]; local
[all...] |
