/* get the next process in the snapshot */ static int snapshot_next_process( struct snapshot *snapshot, struct next_process_reply *reply ) { struct process_snapshot *ptr; struct process_dll *exe_module; if (!snapshot->process_count) { set_error( STATUS_INVALID_PARAMETER ); /* FIXME */ return 0; } if (snapshot->process_pos >= snapshot->process_count) { set_error( STATUS_NO_MORE_FILES ); return 0; } ptr = &snapshot->processes[snapshot->process_pos++]; reply->count = ptr->count; reply->pid = get_process_id( ptr->process ); reply->ppid = ptr->process->parent ? get_process_id( ptr->process->parent ) : 0; reply->threads = ptr->threads; reply->priority = ptr->priority; reply->handles = ptr->handles; reply->unix_pid = ptr->process->unix_pid; if ((exe_module = get_process_exe_module( ptr->process )) && exe_module->filename) { data_size_t len = min( exe_module->namelen, get_reply_max_size() ); set_reply_data( exe_module->filename, len ); } return 1; }
/* allocate the reply data */ void *set_reply_data_size( data_size_t size ) { assert( size <= get_reply_max_size() ); if (size && !(current->reply_data = mem_alloc( size ))) size = 0; current->reply_size = size; return current->reply_data; }
static obj_handle_t device_file_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, int blocking ) { struct device_file *file = get_fd_user( fd ); struct irp_call *irp; obj_handle_t handle; irp_params_t params; memset( ¶ms, 0, sizeof(params) ); params.ioctl.major = IRP_MJ_DEVICE_CONTROL; params.ioctl.code = code; params.ioctl.file = file->user_ptr; irp = create_irp( file, ¶ms, get_req_data(), get_req_data_size(), get_reply_max_size() ); if (!irp) return 0; handle = queue_irp( file, irp, async_data, blocking ); release_object( irp ); return handle; }
static obj_handle_t device_file_read( struct fd *fd, const async_data_t *async_data, int blocking, file_pos_t pos ) { struct device_file *file = get_fd_user( fd ); struct irp_call *irp; obj_handle_t handle; irp_params_t params; memset( ¶ms, 0, sizeof(params) ); params.read.major = IRP_MJ_READ; params.read.key = 0; params.read.pos = pos; params.read.file = file->user_ptr; irp = create_irp( file, ¶ms, NULL, 0, get_reply_max_size() ); if (!irp) return 0; handle = queue_irp( file, irp, async_data, blocking ); release_object( irp ); return handle; }
static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, int blocking, const void *data, data_size_t size ) { struct device *device = get_fd_user( fd ); struct ioctl_call *ioctl; obj_handle_t handle; if (!device->manager) /* it has been deleted */ { set_error( STATUS_FILE_DELETED ); return 0; } if (!(ioctl = create_ioctl( device, code, data, size, get_reply_max_size() ))) return 0; ioctl->thread = (struct thread *)grab_object( current ); ioctl->user_arg = async_data->arg; if (!(handle = alloc_handle( current->process, ioctl, SYNCHRONIZE, 0 ))) { release_object( ioctl ); return 0; } if (!(ioctl->async = fd_queue_async( device->fd, async_data, ASYNC_TYPE_WAIT ))) { close_handle( current->process, handle ); release_object( ioctl ); return 0; } list_add_tail( &device->requests, &ioctl->dev_entry ); list_add_tail( &device->manager->requests, &ioctl->mgr_entry ); if (list_head( &device->manager->requests ) == &ioctl->mgr_entry) /* first one */ wake_up( &device->manager->obj, 0 ); /* don't release ioctl since it is now queued in the device */ set_error( STATUS_PENDING ); return handle; }