lislocks.c

7号信令功能代码,为开源代码

}

void    lis_rw_write_unlock_fcn(lis_rw_lock_t *lock, FL)
{
    lis_flags_t	 prev ;
    DCL_r ;

    (void) r ;				/* avoid warning in non-SMP case */
    SAVE_FLAGS(prev) ;

    LOCK_EXIT(lock,TRACK_UNLOCK,file,line,prev)
    lock->taskp = NULL ;
    SET_SPIN_UNLOCK
    write_unlock(r) ;
}

void    lis_rw_read_lock_irq_fcn(lis_rw_lock_t *lock, FL)
{
    lis_flags_t	 prev ;
    DCL_r ;

    (void) r ;				/* compiler happiness in 2.2 */
    SAVE_FLAGS(prev) ;

    SET_SPINNER
    read_lock_irq(r) ;
    THELOCK->taskp = (void *) current ;
    SET_OWNER
    LOCK_ENTRY(lock,TRACK_LOCK,file,line,prev)
}

void    lis_rw_write_lock_irq_fcn(lis_rw_lock_t *lock, FL)
{
    lis_flags_t	 prev ;
    DCL_r ;

    (void) r ;				/* compiler happiness in 2.2 */
    SAVE_FLAGS(prev) ;

    SET_SPINNER
    write_lock_irq(r) ;
    THELOCK->taskp = (void *) current ;
    SET_OWNER
    LOCK_ENTRY(lock,TRACK_LOCK,file,line,prev)
}

void    lis_rw_read_unlock_irq_fcn(lis_rw_lock_t *lock, FL)
{
    lis_flags_t	 prev ;
    DCL_r ;

    (void) r ;				/* avoid warning in non-SMP case */
    SAVE_FLAGS(prev) ;

    LOCK_EXIT(lock,TRACK_UNLOCK,file,line,prev)
    THELOCK->taskp = NULL ;
    SET_SPIN_UNLOCK
    read_unlock_irq(r) ;
}

void    lis_rw_write_unlock_irq_fcn(lis_rw_lock_t *lock, FL)
{
    lis_flags_t	 prev ;
    DCL_r ;

    (void) r ;				/* avoid warning in non-SMP case */
    SAVE_FLAGS(prev) ;

    LOCK_EXIT(lock,TRACK_UNLOCK,file,line,prev)
    THELOCK->taskp = NULL ;
    SET_SPIN_UNLOCK
    write_unlock_irq(r) ;
}

void    lis_rw_read_lock_irqsave_fcn(lis_rw_lock_t *lock,
				     lis_flags_t *flags, FL)
{
    lis_flags_t	 prev ;
    DCL_r ;

    (void) r ;				/* compiler happiness in 2.2 */
    SAVE_FLAGS(prev) ;

    SET_SPINNER
    read_lock_irqsave(r, (*flags)) ;
    THELOCK->taskp = (void *) current ;
    SET_OWNER
    lis_atomic_inc(&THELOCK->nest) ;
    LOCK_ENTRY(lock,TRACK_LOCK,file,line,prev)
}

void    lis_rw_write_lock_irqsave_fcn(lis_rw_lock_t *lock,
				      lis_flags_t *flags, FL)
{
    lis_flags_t	 prev ;
    DCL_r ;

    (void) r ;				/* compiler happiness in 2.2 */
    SAVE_FLAGS(prev) ;

    SET_SPINNER
    write_lock_irqsave(r, (*flags)) ;
    THELOCK->taskp = (void *) current ;
    SET_OWNER
    lis_atomic_inc(&THELOCK->nest) ;
    LOCK_ENTRY(lock,TRACK_LOCK,file,line,prev)
}

void    lis_rw_read_unlock_irqrestore_fcn(lis_rw_lock_t *lock,
					  lis_flags_t *flags, FL)
{
    lis_flags_t	 prev ;
    DCL_r ;

    (void) r ;				/* avoid warning in non-SMP case */
    SAVE_FLAGS(prev) ;

    LOCK_EXIT(lock,TRACK_UNLOCK,file,line,prev)
    THELOCK->taskp = NULL ;
    SET_SPIN_UNLOCK
    read_unlock_irqrestore(r, (*flags)) ;
}

void    lis_rw_write_unlock_irqrestore_fcn(lis_rw_lock_t *lock,
					   lis_flags_t *flags, FL)
{
    lis_flags_t	 prev ;
    DCL_r ;

    (void) r ;				/* avoid warning in non-SMP case */
    SAVE_FLAGS(prev) ;

    LOCK_EXIT(lock,TRACK_UNLOCK,file,line,prev)
    THELOCK->taskp = NULL ;
    SET_SPIN_UNLOCK
    write_unlock_irqrestore(r, (*flags)) ;
}

#if defined(CONFIG_DEV)
static void lis_rw_lock_fill(lis_rw_lock_t *lock, const char *name, FL)
#else
static void lis_rw_lock_fill(lis_rw_lock_t *lock, const char *name)
#endif
{
    DCL_r ;

    (void) r ;				/* avoid warning in non-SMP case */
    if (name == NULL) name = "RW-Lock" ;

    lock->name 		= (char *) name ;
    lock->spinner_file  = "Initialized" ;
    lock->owner_file    = lock->spinner_file ;
    lock->unlocker_file = lock->spinner_file ;
    lock->unlocker_cntr = ++lis_seq_cntr ;
    rwlock_init(r) ;			/* kernel's init function */
}

#else			/* KERNEL_2_3 */

/*
 * For 2.2 kernel, just use the "noop" spin lock routines.
 */
void    lis_rw_read_lock_fcn(lis_rw_lock_t *lock, FL)
{
    lis_spin_lock_fcn((lis_spin_lock_t *)lock, file, line) ;
}

void    lis_rw_write_lock_fcn(lis_rw_lock_t *lock, FL)
{
    lis_spin_lock_fcn((lis_spin_lock_t *)lock, file, line) ;
}

void    lis_rw_read_unlock_fcn(lis_rw_lock_t *lock, FL)
{
    lis_spin_unlock_fcn((lis_spin_lock_t *)lock, file, line) ;
}

void    lis_rw_write_unlock_fcn(lis_rw_lock_t *lock, FL)
{
    lis_spin_unlock_fcn((lis_spin_lock_t *)lock, file, line) ;
}

void    lis_rw_read_lock_irq_fcn(lis_rw_lock_t *lock, FL)
{
    lis_spin_lock_irq_fcn((lis_spin_lock_t *)lock, file, line) ;
}

void    lis_rw_write_lock_irq_fcn(lis_rw_lock_t *lock, FL)
{
    lis_spin_lock_irq_fcn((lis_spin_lock_t *)lock, file, line) ;
}

void    lis_rw_read_unlock_irq_fcn(lis_rw_lock_t *lock, FL)
{
    lis_spin_unlock_irq_fcn((lis_spin_lock_t *)lock, file, line) ;
}

void    lis_rw_write_unlock_irq_fcn(lis_rw_lock_t *lock, FL)
{
    lis_spin_unlock_irq_fcn((lis_spin_lock_t *)lock, file, line) ;
}

void    lis_rw_read_lock_irqsave_fcn(lis_rw_lock_t *lock,
				     lis_flags_t *flags, FL)
{
    lis_spin_lock_irqsave_fcn((lis_spin_lock_t *)lock, flags, file, line) ;
}

void    lis_rw_write_lock_irqsave_fcn(lis_rw_lock_t *lock,
				      lis_flags_t *flags, FL)
{
    lis_spin_lock_irqsave_fcn((lis_spin_lock_t *)lock, flags, file, line) ;
}

void    lis_rw_read_unlock_irqrestore_fcn(lis_rw_lock_t *lock,
					  lis_flags_t *flags, FL)
{
    lis_spin_unlock_irqrestore_fcn((lis_spin_lock_t *)lock, flags, file, line) ;
}

void    lis_rw_write_unlock_irqrestore_fcn(lis_rw_lock_t *lock,
					   lis_flags_t *flags, FL)
{
    lis_spin_unlock_irqrestore_fcn((lis_spin_lock_t *)lock, flags, file, line) ;
}

static void lis_rw_lock_fill(lis_rw_lock_t *lock, const char *name, FL)
{
    lis_spin_lock_fill((lis_spin_lock_t *)lock, name, file, line) ;
}

#endif			/* KERNEL_2_3 */

void    lis_rw_lock_init_fcn(lis_rw_lock_t *lock, const char *name, FL)
{
    memset((void *)lock, 0, sizeof(*lock)) ;
    RW_LOCK_FILL;
}

lis_rw_lock_t *
lis_rw_lock_alloc_fcn(const char *name, FL)
{
    lis_rw_lock_t	*lock ;
    int			 lock_size ;

    lock_size = sizeof(*lock) - sizeof(lock->rw_lock_mem) +
						    sizeof(rwlock_t) ;
    lock = (lis_rw_lock_t *) lis_alloc_kernel_fcn(lock_size, file, line);
    if (lock == NULL) return(NULL) ;

    memset((void *)lock, 0, lock_size) ;
    RW_LOCK_FILL;
    lock->allocated = 1 ;
    return(lock) ;
}

lis_rw_lock_t *
lis_rw_lock_free_fcn(lis_rw_lock_t *lock, FL)
{
    if (lock->allocated)
	lis_free_mem_fcn((void *)lock, file, line) ;
    return(NULL) ;
}

/************************************************************************
*                        Semaphores                                     *
*************************************************************************
*									*
* Subroutines here to insulate from kernel version differences.		*
*									*
************************************************************************/

/*
 * Initialize a semaphore
 */
#if defined(KERNEL_2_1)			/* 2.1 kernel or later */
# define SET_SEM_COUNT(semp,cnt)	sema_init((semp), (cnt))
#else					/* 2.0 kernel */
# ifdef ATOMIC_INIT
# define SET_SEM_COUNT(semp,cnt)	atomic_set(&((semp)->count), (cnt))
# else
# define SET_SEM_COUNT(semp,cnt)	(semp)->count = (cnt)
# endif
#endif

void	lis_up_fcn(lis_semaphore_t *lsem, FL)
{
    struct semaphore	*sem = (struct semaphore *) lsem->sem_mem ;

    SEM_EXIT(lsem,TRACK_UP,file,line,0) ;
    SET_UPSEM                           /* most recent "up" */
    lsem->taskp      = NULL ;
    up(sem) ;
}

int	lis_down_fcn(lis_semaphore_t *lsem, FL)
{
    struct semaphore	*sem = (struct semaphore *) lsem->sem_mem ;
    int			 ret ;

    SET_DSEM                            /* most recent "down" */
    ret = down_interruptible(sem) ;
    if (ret == 0)
    {
	SEM_ENTRY(lsem,TRACK_DOWN,file,line,0) ;
	lsem->taskp = (void *) current ;
	SET_SEMOWNER                    /* current owner */
    }
    else
    {
	SEM_ENTRY(lsem,TRACK_DOWN,file,line,ret) ;
	lsem->owner_file = "Error" ;
	lsem->owner_line = ret ;
	lsem->owner_cntr = ++lis_seq_cntr ;
    }

    return(ret) ;
}

static void lis_sem_fill(lis_semaphore_t *lsem, int count)
{
    struct semaphore	*sem = (struct semaphore *) lsem->sem_mem ;

    SET_SEM_COUNT(sem,count);
    lsem->owner_file = "Initialized" ;
    lsem->owner_cntr = ++lis_seq_cntr ;
}

void	lis_sem_init(lis_semaphore_t *lsem, int count)
{
    static lis_semaphore_t lis_sem_template ;	/* blank semaphore */

    *lsem = lis_sem_template ;			/* blank semaphore */
    lis_sem_fill(lsem, count) ;
}


lis_semaphore_t *lis_sem_destroy(lis_semaphore_t *lsem)
{
    if (lsem->allocated)
	lis_free_mem(lsem) ;
    else
    {
	static lis_semaphore_t lis_sem_template ;	/* blank semaphore */
	*lsem = lis_sem_template ;			/* blank semaphore */
	lsem->owner_file = "De-Initialized" ;
	lsem->owner_cntr = ++lis_seq_cntr ;
    }

    return(NULL) ;
}

lis_semaphore_t *lis_sem_alloc(int count)
{
    lis_semaphore_t *lsem ;
    int		     sem_size ;

    sem_size = sizeof(*lsem) - sizeof(lsem->sem_mem) + sizeof(struct semaphore);
    lsem     = (lis_semaphore_t *) lis_alloc_kernel(sem_size);

    if (lsem == NULL) return(NULL) ;

    memset(lsem, 0, sem_size) ;
    lis_sem_fill(lsem, count) ;
    lsem->allocated = 1 ;
    return(lsem) ;
}