int
tdbio_end_transaction()
{
int rc;
if( !in_transaction )
log_bug("tdbio: no active transaction\n");
take_write_lock ();
block_all_signals();
in_transaction = 0;
rc = tdbio_sync();
unblock_all_signals();
release_write_lock ();
return rc;
}
void
cleanup_rlwrap_and_exit(int status)
{
unblock_all_signals();
DPRINTF0(DEBUG_TERMIO, "Cleaning up");
if (write_histfile && (histsize==0 || history_total_bytes() > 0)) /* avoid creating empty .speling_eror_history file after typo */
write_history(history_filename); /* ignore errors */
close_logfile();
DPRINTF4(DEBUG_SIGNALS, "command_pid: %d, commands_exit_status: %x, filter_pid: %d, filters_exit_status: %x",
command_pid, commands_exit_status, filter_pid, filters_exit_status);
mymicrosleep(10); /* we may have got an EOF or EPIPE because the filter or command died, but this doesn't mean that
SIGCHLD has been caught already. Taking a little nap now improves the chance that we will catch it
(no grave problem if we miss it, but diagnostics, exit status and transparent signal handling depend on it) */
if (filter_pid)
kill_filter();
else if (filter_is_dead) {
int filters_killer = killed_by(filters_exit_status);
errno = 0;
mywarn((filters_killer ? "filter was killed by signal %d (%s)": WEXITSTATUS(filters_exit_status) ? "filter died" : "filter exited"), filters_killer, signal_name(filters_killer));
}
if (debug)
debug_postmortem();
if (terminal_settings_saved)
if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &saved_terminal_settings) < 0) /* ignore errors (almost dead anyway) */
; /* fprintf(stderr, "Arggh\n"); don't use myerror!!*/
if (!newline_came_last) /* print concluding newline, if necessary */
my_putstr("\n");
if (status != EXIT_SUCCESS) /* rlwrap itself has failed, rather than the wrapped command */
exit(status);
else {
int commands_killer = killed_by(commands_exit_status);
if (commands_killer)
suicide_by(commands_killer, commands_exit_status); /* command terminated by signal, make rlwrap's
parent believe rlwrap was killed by it */
else
exit(WEXITSTATUS(commands_exit_status)); /* propagate command's exit status */
}
}
void suicide_by(int signal, int status) {
/* Some signals suggest a program error. When rlwrap kills itself with one of those,
the shell may tell the user that rlwrap itself has failed. Make clear that
it didn't. @@@ We could also try argv[0] = command_name just before dying ? */
if (signals_program_error(signal)) {
myerror(WARNING|NOERRNO, "%s crashed, killed by %s%s.\n%s itself has not crashed, but for transparency,\n"
"it will now kill itself %swith the same signal\n",
command_name, signal_name(signal), (coredump(status) ? " (core dumped)" : ""),
program_name, (coredump(status) ? "" : "(without dumping core) ") );
}
uninstall_signal_handlers();
unblock_all_signals();
set_ulimit(RLIMIT_CORE,0); /* prevent our own useless core dump from clobbering the interesting one created by command */
DPRINTF1(DEBUG_SIGNALS, "suicide by signal %s", signal_name(signal));
kill(getpid(), signal);
/* still alive? */
sleep(1);
exit(0);
}
int tdfx_unlock(struct inode *inode, struct file *filp, unsigned int cmd,
unsigned long arg)
{
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->dev;
drm_lock_t lock;
if (copy_from_user(&lock, (drm_lock_t *)arg, sizeof(lock)))
return -EFAULT;
if (lock.context == DRM_KERNEL_CONTEXT) {
DRM_ERROR("Process %d using kernel context %d\n",
current->pid, lock.context);
return -EINVAL;
}
DRM_DEBUG("%d frees lock (%d holds)\n",
lock.context,
_DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
atomic_inc(&dev->total_unlocks);
if (_DRM_LOCK_IS_CONT(dev->lock.hw_lock->lock))
atomic_inc(&dev->total_contends);
drm_lock_transfer(dev, &dev->lock.hw_lock->lock, DRM_KERNEL_CONTEXT);
/* FIXME: Try to send data to card here */
if (!dev->context_flag) {
if (drm_lock_free(dev, &dev->lock.hw_lock->lock,
DRM_KERNEL_CONTEXT)) {
DRM_ERROR("\n");
}
}
#if LINUX_VERSION_CODE < 0x020400
if (lock.context != tdfx_res_ctx.handle) {
current->counter = 5;
current->priority = DEF_PRIORITY;
}
#endif
unblock_all_signals();
return 0;
}
int
tdbio_end_transaction()
{
int rc;
if( !in_transaction )
log_bug("tdbio: no active transaction\n");
if( !is_locked ) {
if( make_dotlock( lockhandle, -1 ) )
log_fatal("can't acquire lock - giving up\n");
else
is_locked = 1;
}
block_all_signals();
in_transaction = 0;
rc = tdbio_sync();
unblock_all_signals();
if( !opt.lock_once ) {
if( !release_dotlock( lockhandle ) )
is_locked = 0;
}
return rc;
}
int i810_unlock(struct inode *inode, struct file *filp, unsigned int cmd,
unsigned long arg)
{
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->dev;
drm_lock_t lock;
if (copy_from_user(&lock, (drm_lock_t *)arg, sizeof(lock)))
return -EFAULT;
if (lock.context == DRM_KERNEL_CONTEXT) {
DRM_ERROR("Process %d using kernel context %d\n",
current->pid, lock.context);
return -EINVAL;
}
DRM_DEBUG("%d frees lock (%d holds)\n",
lock.context,
_DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
atomic_inc(&dev->total_unlocks);
if (_DRM_LOCK_IS_CONT(dev->lock.hw_lock->lock))
atomic_inc(&dev->total_contends);
drm_lock_transfer(dev, &dev->lock.hw_lock->lock, DRM_KERNEL_CONTEXT);
if (!dev->context_flag) {
if (drm_lock_free(dev, &dev->lock.hw_lock->lock,
DRM_KERNEL_CONTEXT)) {
DRM_ERROR("\n");
}
}
#if DRM_DMA_HISTOGRAM
atomic_inc(&dev->histo.lhld[drm_histogram_slot(get_cycles()
- dev->lck_start)]);
#endif
unblock_all_signals();
return 0;
}
pid_t
my_pty_fork(int *ptr_master_fd,
const struct termios *slave_termios,
const struct winsize *slave_winsize)
{
int fdm, fds = -1;
int ttyfd;
pid_t pid;
const char *slave_name;
struct termios pterm;
int only_sigchld[] = { SIGCHLD, 0 };
ptytty_openpty(&fdm, &fds, &slave_name);
slave_pty_fd = fds;
block_signals(only_sigchld); /* block SIGCHLD until we have had a chance to install a handler for it after the fork() */
if ((pid = fork()) < 0) {
myerror("Cannot fork");
return(42); /* the compiler may not know that myerror() won't return */
} else if (pid == 0) { /* child */
DEBUG_RANDOM_SLEEP;
i_am_child = TRUE; /* remember who I am */
unblock_all_signals();
close(fdm); /* fdm not used in child */
ptytty_control_tty(fds, slave_name);
if (dup2(fds, STDIN_FILENO) != STDIN_FILENO)
myerror("dup2 to stdin failed");
if (isatty(STDOUT_FILENO) && dup2(fds, STDOUT_FILENO) != STDOUT_FILENO)
myerror("dup2 to stdout failed");
if (isatty(STDERR_FILENO) && dup2(fds, STDERR_FILENO) != STDERR_FILENO)
myerror("dup2 to stderr failed");
if (fds > STDERR_FILENO)
close(fds);
if (slave_termios != NULL)
if (tcsetattr(STDIN_FILENO, TCSANOW, slave_termios) < 0)
myerror("tcsetattr failed on slave pty");
return (0);
} else { /* parent */
srand(pid); DEBUG_RANDOM_SLEEP;
command_pid = pid; /* the SIGCHLD signal handler needs this global variable */
*ptr_master_fd = fdm;
if (!command_is_dead && tcgetattr(fdm, &pterm) < 0) {
sleep(1); /* we might be more succesful after the child command has
initialized its terminal. As there is no reliable way to sense this
from the parent, we just wait a little */
if (tcgetattr(slave_pty_fd, &pterm) < 0) {
fprintf(stderr, /* don't use mywarn() because of the strerror() message *within* the text */
"Warning: %s cannot determine terminal mode of %s\n"
"(because: %s).\n"
"Readline mode will always be on (as if -a option was set);\n"
"passwords etc. *will* be echoed and saved in history list!\n\n",
program_name, command_name, strerror(errno));
always_echo = TRUE;
}
}
if (!isatty(STDOUT_FILENO) || !isatty(STDERR_FILENO)) { /* stdout or stderr redirected? */
ttyfd = open("/dev/tty", O_WRONLY); /* open users terminal */
DPRINTF1(DEBUG_TERMIO, "stdout or stderr are not a terminal, onpening /dev/tty with fd=%d", ttyfd);
if (ttyfd <0)
myerror("Could not open /dev/tty");
if (dup2(ttyfd, STDOUT_FILENO) != STDOUT_FILENO)
myerror("dup2 of stdout to ttyfd failed");
if (dup2(ttyfd, STDERR_FILENO) != STDERR_FILENO)
myerror("dup2 of stderr to ttyfd failed");
close (ttyfd);
}
if (renice && !nice(1)) /* impossible */
myerror("could not increase my own niceness");
if (slave_winsize != NULL)
if (ioctl(fdm, TIOCSWINSZ, slave_winsize) < 0) /* this assumes that master and slave have identical winsizes */
myerror("TIOCSWINSZ failed on master pty");
return (pid); /* returns in parent and in child (and pid lets us determine who we are) */
}
}
