/*ARGSUSED*/
static uint_t
clock_tick_execute(caddr_t arg1, caddr_t arg2)
{
clock_tick_cpu_t *ctp;
int start, scan, end, pending;
clock_t mylbolt;
/*
* We could have raced with cpu offline. We don't want to
* process anything on an offlined CPU. If we got blocked
* on anything, we may not get scheduled when we wakeup
* later on.
*/
if (!CLOCK_TICK_XCALL_SAFE(CPU))
goto out;
ctp = clock_tick_cpu[CPU->cpu_id];
mutex_enter(&ctp->ct_lock);
pending = ctp->ct_pending;
if (pending == 0) {
/*
* If a CPU is busy at LOCK_LEVEL, then an invocation
* of this softint may be queued for some time. In that case,
* clock_tick_active will not be incremented.
* clock_tick_schedule() will then assume that the previous
* invocation is done and post a new softint. The first one
* that gets in will reset the pending count so the
* second one is a noop.
*/
mutex_exit(&ctp->ct_lock);
goto out;
}
ctp->ct_pending = 0;
start = ctp->ct_start;
end = ctp->ct_end;
scan = ctp->ct_scan;
mylbolt = ctp->ct_lbolt;
mutex_exit(&ctp->ct_lock);
clock_tick_execute_common(start, scan, end, mylbolt, pending);
out:
/*
* Signal completion to the clock handler.
*/
atomic_dec_ulong(&clock_tick_active);
return (1);
}
/* ARGSUSED */
int
ufs_fioffs(
struct vnode *vp,
char *vap, /* must be NULL - reserved */
struct cred *cr) /* credentials from ufs_ioctl */
{
int error;
struct ufsvfs *ufsvfsp;
struct ulockfs *ulp;
/* file system has been forcibly unmounted */
ufsvfsp = VTOI(vp)->i_ufsvfs;
if (ufsvfsp == NULL)
return (EIO);
ulp = &ufsvfsp->vfs_ulockfs;
/*
* suspend the delete thread
* this must be done outside the lockfs locking protocol
*/
vfs_lock_wait(vp->v_vfsp);
ufs_thread_suspend(&ufsvfsp->vfs_delete);
/* hold the mutex to prevent race with a lockfs request */
mutex_enter(&ulp->ul_lock);
atomic_inc_ulong(&ufs_quiesce_pend);
if (ULOCKFS_IS_HLOCK(ulp)) {
error = EIO;
goto out;
}
if (ULOCKFS_IS_ELOCK(ulp)) {
error = EBUSY;
goto out;
}
/* wait for outstanding accesses to finish */
if (error = ufs_quiesce(ulp))
goto out;
/*
* If logging, and the logmap was marked as not rollable,
* make it rollable now, and start the trans_roll thread and
* the reclaim thread. The log at this point is safe to write to.
*/
if (ufsvfsp->vfs_log) {
ml_unit_t *ul = ufsvfsp->vfs_log;
struct fs *fsp = ufsvfsp->vfs_fs;
int err;
if (ul->un_flags & LDL_NOROLL) {
ul->un_flags &= ~LDL_NOROLL;
logmap_start_roll(ul);
if (!fsp->fs_ronly && (fsp->fs_reclaim &
(FS_RECLAIM|FS_RECLAIMING))) {
fsp->fs_reclaim &= ~FS_RECLAIM;
fsp->fs_reclaim |= FS_RECLAIMING;
ufs_thread_start(&ufsvfsp->vfs_reclaim,
ufs_thread_reclaim, vp->v_vfsp);
if (!fsp->fs_ronly) {
TRANS_SBWRITE(ufsvfsp,
TOP_SBUPDATE_UPDATE);
if (err =
geterror(ufsvfsp->vfs_bufp)) {
refstr_t *mntpt;
mntpt = vfs_getmntpoint(
vp->v_vfsp);
cmn_err(CE_NOTE,
"Filesystem Flush "
"Failed to update "
"Reclaim Status for "
" %s, Write failed to "
"update superblock, "
"error %d",
refstr_value(mntpt),
err);
refstr_rele(mntpt);
}
}
}
}
}
/* synchronously flush dirty data and metadata */
error = ufs_flush(vp->v_vfsp);
out:
atomic_dec_ulong(&ufs_quiesce_pend);
cv_broadcast(&ulp->ul_cv);
mutex_exit(&ulp->ul_lock);
vfs_unlock(vp->v_vfsp);
/*
* allow the delete thread to continue
*/
ufs_thread_continue(&ufsvfsp->vfs_delete);
return (error);
}
/*
* ufs_fiosdio
* Set delayed-io state. This ioctl is tailored
* to metamucil's needs and may change at any time.
*/
int
ufs_fiosdio(
struct vnode *vp, /* file's vnode */
uint_t *diop, /* dio flag */
int flag, /* flag from ufs_ioctl */
struct cred *cr) /* credentials from ufs_ioctl */
{
uint_t dio; /* copy of user's dio */
struct inode *ip; /* inode for vp */
struct ufsvfs *ufsvfsp;
struct fs *fs;
struct ulockfs *ulp;
int error = 0;
#ifdef lint
flag = flag;
#endif
/* check input conditions */
if (secpolicy_fs_config(cr, vp->v_vfsp) != 0)
return (EPERM);
if (copyin(diop, &dio, sizeof (dio)))
return (EFAULT);
if (dio > 1)
return (EINVAL);
/* file system has been forcibly unmounted */
if (VTOI(vp)->i_ufsvfs == NULL)
return (EIO);
ip = VTOI(vp);
ufsvfsp = ip->i_ufsvfs;
ulp = &ufsvfsp->vfs_ulockfs;
/* logging file system; dio ignored */
if (TRANS_ISTRANS(ufsvfsp))
return (error);
/* hold the mutex to prevent race with a lockfs request */
vfs_lock_wait(vp->v_vfsp);
mutex_enter(&ulp->ul_lock);
atomic_inc_ulong(&ufs_quiesce_pend);
if (ULOCKFS_IS_HLOCK(ulp)) {
error = EIO;
goto out;
}
if (ULOCKFS_IS_ELOCK(ulp)) {
error = EBUSY;
goto out;
}
/* wait for outstanding accesses to finish */
if (error = ufs_quiesce(ulp))
goto out;
/* flush w/invalidate */
if (error = ufs_flush(vp->v_vfsp))
goto out;
/*
* update dio
*/
mutex_enter(&ufsvfsp->vfs_lock);
ufsvfsp->vfs_dio = dio;
/*
* enable/disable clean flag processing
*/
fs = ip->i_fs;
if (fs->fs_ronly == 0 &&
fs->fs_clean != FSBAD &&
fs->fs_clean != FSLOG) {
if (dio)
fs->fs_clean = FSSUSPEND;
else
fs->fs_clean = FSACTIVE;
ufs_sbwrite(ufsvfsp);
mutex_exit(&ufsvfsp->vfs_lock);
} else
mutex_exit(&ufsvfsp->vfs_lock);
out:
/*
* we need this broadcast because of the ufs_quiesce call above
*/
atomic_dec_ulong(&ufs_quiesce_pend);
cv_broadcast(&ulp->ul_cv);
mutex_exit(&ulp->ul_lock);
vfs_unlock(vp->v_vfsp);
return (error);
}
void
interrupt(unsigned long a0, unsigned long a1, unsigned long a2,
struct trapframe *framep)
{
struct cpu_info *ci = curcpu();
struct cpu_softc *sc = ci->ci_softc;
switch (a0) {
case ALPHA_INTR_XPROC: /* interprocessor interrupt */
#if defined(MULTIPROCESSOR)
atomic_inc_ulong(&ci->ci_intrdepth);
alpha_ipi_process(ci, framep);
/*
* Handle inter-console messages if we're the primary
* CPU.
*/
if (ci->ci_cpuid == hwrpb->rpb_primary_cpu_id &&
hwrpb->rpb_txrdy != 0)
cpu_iccb_receive();
atomic_dec_ulong(&ci->ci_intrdepth);
#else
printf("WARNING: received interprocessor interrupt!\n");
#endif /* MULTIPROCESSOR */
break;
case ALPHA_INTR_CLOCK: /* clock interrupt */
/*
* We don't increment the interrupt depth for the
* clock interrupt, since it is *sampled* from
* the clock interrupt, so if we did, all system
* time would be counted as interrupt time.
*/
sc->sc_evcnt_clock.ev_count++;
ci->ci_data.cpu_nintr++;
if (platform.clockintr) {
/*
* Call hardclock(). This will also call
* statclock(). On the primary CPU, it
* will also deal with time-of-day stuff.
*/
(*platform.clockintr)((struct clockframe *)framep);
/*
* If it's time to call the scheduler clock,
* do so.
*/
if ((++ci->ci_schedstate.spc_schedticks & 0x3f) == 0 &&
schedhz != 0)
schedclock(ci->ci_curlwp);
}
break;
case ALPHA_INTR_ERROR: /* Machine Check or Correctable Error */
atomic_inc_ulong(&ci->ci_intrdepth);
a0 = alpha_pal_rdmces();
if (platform.mcheck_handler != NULL &&
(void *)framep->tf_regs[FRAME_PC] != XentArith)
(*platform.mcheck_handler)(a0, framep, a1, a2);
else
machine_check(a0, framep, a1, a2);
atomic_dec_ulong(&ci->ci_intrdepth);
break;
case ALPHA_INTR_DEVICE: /* I/O device interrupt */
{
struct scbvec *scb;
int idx = SCB_VECTOIDX(a1 - SCB_IOVECBASE);
bool mpsafe = scb_mpsafe[idx];
KDASSERT(a1 >= SCB_IOVECBASE && a1 < SCB_SIZE);
atomic_inc_ulong(&sc->sc_evcnt_device.ev_count);
atomic_inc_ulong(&ci->ci_intrdepth);
if (!mpsafe) {
KERNEL_LOCK(1, NULL);
}
ci->ci_data.cpu_nintr++;
scb = &scb_iovectab[idx];
(*scb->scb_func)(scb->scb_arg, a1);
if (!mpsafe)
KERNEL_UNLOCK_ONE(NULL);
atomic_dec_ulong(&ci->ci_intrdepth);
break;
}
case ALPHA_INTR_PERF: /* performance counter interrupt */
printf("WARNING: received performance counter interrupt!\n");
break;
case ALPHA_INTR_PASSIVE:
#if 0
printf("WARNING: received passive release interrupt vec "
"0x%lx\n", a1);
#endif
break;
default:
printf("unexpected interrupt: type 0x%lx vec 0x%lx "
"a2 0x%lx"
#if defined(MULTIPROCESSOR)
" cpu %lu"
#endif
"\n", a0, a1, a2
#if defined(MULTIPROCESSOR)
, ci->ci_cpuid
#endif
);
panic("interrupt");
/* NOTREACHED */
}
}