I had a pool which was exported and due to some issues on my SAN i was never able to import it again. Can anyone tell me how can i destroy the exported pool to free up the LUN. I tried to create a new pool on the same pool but it gives me following error
# zpool create emcpool4 emcpower0c
cannot create 'emcpool4': invalid argument for this pool operation
Can anyone tell me how can i remove the old pool and create a new pool on the same LUN
So,
We have a Netapp storage solution. We have Sparc T4-4s running with LDOMS and client zones in the LDOMS, We are using FC for storage comms. So here's the basic setup
FC luns are exported to the primary on the Sparc box. using LDM they are then exported to the LDOM using vdisk. at the... (4 Replies)
I added a disk to a zpool using "zpool add diskname"
My intention was mirror a zpool disk that no mirror; that is a zpool with only one disk. I did not issue the right command. Now, the disk has been added successfully but I cannot remove nor detach it as Solaris 11 thinks it has data on it... (14 Replies)
Hi ,
One of my zone went down and when i booted it up i could see the pool in degraded state with some check sum errors . we have brought the pool online after scrubbing. But few files are showing this error
Bad exchange descriptor
Please let me know how to remove these files (2 Replies)
i have to use the exported variable from one script into another script
ex :
A.ksh
# !/bin/ksh
chk1=56
export chk1
B.ksh
# !/bin/ksh
echo $chk1
i have executed the... (6 Replies)
Hi,
I have the following executable in cron:
10 * * * 1-5 /apps/bin/dmg_cronlaunch -ENVI ENVIRONMENT -EXE exec -FILE ratespb_sdos_prdf_`TZ=US/Eastern;date +\%Y\%m\%d\%H\%M\%S`.sdos > /tmp/dmg_exec.log.`/usr/bin/date +\%Y_\%m_\%d_\%H:\%M:\%S` 2>&1
Comprised of the following:
... (13 Replies)
Hi
I'm hoping someone can tell me how to extend the scope of an exported function in the korn shell.
I have written a function in a file that I dot in from my .kshrc file and it works fine.
However I would like this function to be available to anyone in a certain group on the machine... (10 Replies)
Dear All,How can use a variable which I have exported when I am logged into one user to be used once I su to another user.something like 1.Login to Unix box as user12. export var1="TEST"3. su - user24. User the var1 value ( it should return TEST)I have checked just export does not work. any other... (1 Reply)
Greeting to all of you!
I've small issue related to the variable which we are setting and exporting through scripts, in one of the script there are some variable used but I am not abel to get the detail as where they are set. I tried finding the detail with the help of env but no luck.
... (2 Replies)
libtalloc_pools(3) talloc libtalloc_pools(3)NAME
libtalloc_pools - Chapter 5: Memory pools
Memory pools
Allocation of a new memory is an expensive operation and large programs can contain thousands of calls of malloc() for a single
computation, where every call allocates only a very small amount of the memory. This can result in an undesirable slowdown of the
application. We can avoid this slowdown by decreasing the number of malloc() calls by using a memory pool.
A memory pool is a preallocated memory space with a fixed size. If we need to allocate new data we will take the desired amount of the
memory from the pool instead of requesting a new memory from the system. This is done by creating a pointer that points inside the
preallocated memory. Such a pool must not be reallocated as it would change its location - pointers that were pointing inside the pool
would become invalid. Therefore, a memory pool requires a very good estimate of the required memory space.
The talloc library contains its own implementation of a memory pool. It is highly transparent for the programmer. The only thing that needs
to be done is an initialization of a new pool context using talloc_pool() - which can be used in the same way as any other context.
Refactoring of existing code (that uses talloc) to take the advantage of a memory pool is quite simple due to the following properties of
the pool context:
o if we are allocating data on a pool context, it takes the desired amount of memory from the pool,
o if the context is a descendant of the pool context, it takes the space from the pool as well,
o if the pool does not have sufficient portion of memory left, it will create a new non-pool context, leaving the pool intact
/* allocate 1KiB in a pool */
TALLOC_CTX *pool_ctx = talloc_pool(NULL, 1024);
/* Take 512B from the pool, 512B is left there */
void *ptr = talloc_size(pool_ctx, 512);
/* 1024B > 512B, this will create new talloc chunk outside
the pool */
void *ptr2 = talloc_size(ptr, 1024);
/* The pool still contains 512 free bytes
* this will take 200B from them. */
void *ptr3 = talloc_size(ptr, 200);
/* This will destroy context 'ptr3' but the memory
* is not freed, the available space in the pool
* will increase to 512B. */
talloc_free(ptr3);
/* This will free memory taken by 'pool_ctx'
* and 'ptr2' as well. */
talloc_free(pool_ctx);
The above given is very convenient, but there is one big issue to be kept in mind. If the parent of a talloc pool child is changed to a
parent that is outside of this pool, the whole pool memory will not be freed until the child is freed. For this reason we must be very
careful when stealing a descendant of a pool context.
TALLOC_CTX *mem_ctx = talloc_new(NULL);
TALLOC_CTX *pool_ctx = talloc_pool(NULL, 1024);
struct foo *foo = talloc(pool_ctx, struct foo);
/* mem_ctx is not in the pool */
talloc_steal(mem_ctx, foo);
/* pool_ctx is marked as freed but the memory is not
deallocated, accessing the pool_ctx again will cause
an error */
talloc_free(pool_ctx);
/* This deallocates the pool_ctx. */
talloc_free(mem_ctx);
It may often be better to copy the memory we want instead of stealing it to avoid this problem. If we do not need to retain the context
name (to keep the type information), we can use talloc_memdup() to do this.
Copying the memory out of the pool may, however, discard all the performance boost given by the pool, depending on the size of the copied
memory. Therefore, the code should be well profiled before taking this path. In general, the golden rule is: if we need to steal from the
pool context, we should not use a pool context.
Version 2.0 Tue Jun 17 2014 libtalloc_pools(3)