static void
rf_configure(int fd, char *config_file, int force)
{
void *generic;
RF_Config_t cfg;
if (rf_MakeConfig( config_file, &cfg ) != 0)
err(1, "Unable to create RAIDframe configuration structure");
cfg.force = force;
/*
* Note the extra level of redirection needed here, since
* what we really want to pass in is a pointer to the pointer to
* the configuration structure.
*/
generic = &cfg;
do_ioctl(fd, RAIDFRAME_CONFIGURE, &generic, "RAIDFRAME_CONFIGURE");
}
long unionfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
long err;
struct dentry *dentry = file->f_path.dentry;
struct dentry *parent;
unionfs_read_lock(dentry->d_sb, UNIONFS_SMUTEX_PARENT);
parent = unionfs_lock_parent(dentry, UNIONFS_DMUTEX_PARENT);
unionfs_lock_dentry(dentry, UNIONFS_DMUTEX_CHILD);
err = unionfs_file_revalidate(file, parent, true);
if (unlikely(err))
goto out;
/* check if asked for local commands */
switch (cmd) {
case UNIONFS_IOCTL_INCGEN:
/* Increment the superblock generation count */
pr_info("unionfs: incgen ioctl deprecated; "
"use \"-o remount,incgen\"\n");
err = -ENOSYS;
break;
case UNIONFS_IOCTL_QUERYFILE:
/* Return list of branches containing the given file */
err = unionfs_ioctl_queryfile(file, parent, cmd, arg);
break;
default:
/* pass the ioctl down */
err = do_ioctl(file, cmd, arg);
break;
}
out:
unionfs_check_file(file);
unionfs_unlock_dentry(dentry);
unionfs_unlock_parent(dentry, parent);
unionfs_read_unlock(dentry->d_sb);
return err;
}
int main(int argc, char** argv)
{
struct configuration cfg;
int sock;
unsigned int pkt_num = 0;
parse_options(argc, argv, &cfg);
/* Initialise */
sock = add_socket(&cfg);
do_mcast(&cfg, sock);
do_ioctl(&cfg, sock);
do_ts_sockopt(&cfg, sock);
/* Run until we've got enough packets, or an error occurs */
while( (pkt_num++ < cfg.cfg_max_packets) || (cfg.cfg_max_packets == 0) )
TRY( do_echo(sock, pkt_num, cfg.cfg_templated) );
close(sock);
return 0;
}
/* this puts the VC under process control */
void set_process_control(void)
{
struct vt_mode vt_mode;
struct sigaction sa;
vt_mode.mode = VT_PROCESS;
vt_mode.waitv = 0;
vt_mode.relsig = SIG_RELEASE;
vt_mode.acqsig = SIG_ACQUIRE;
vt_mode.frsig = 0;
SCR_STATE.vt_requested = 0; /* a switch has not been attempted yet */
allow_switch();
/* NEWSETQSIG (SIG_RELEASE, release_vt); */
/* NEWSETQSIG (SIG_ACQUIRE, acquire_vt); */
if (do_ioctl(console_fd, VT_SETMODE, (int) &vt_mode))
debug_vid("initial VT_SETMODE failed!\n");
debug_vid("VID: Set process control\n");
}
status_t
DVBCard::GetCardInfo(char *_name, int max_name_len, char *_info, int max_info_len)
{
dvb_interface_info_t info;
if (do_ioctl(fDev, DVB_GET_INTERFACE_INFO, &info) < 0) {
printf("DVB_GET_INTERFACE_INFO failed with error %s\n", strerror(errno));
return errno;
}
// strlcpy(_name, info.name, max_name_len);
// strlcpy(_info, info.info, max_info_len);
strcpy(_name, info.name);
strcpy(_info, info.info);
if (info.version < 1) {
printf("DVBCard::GetCardInfo wrong API version\n");
return B_ERROR;
}
return B_OK;
}
static int file_ioctl(struct file *filp, unsigned int cmd,
unsigned long arg)
{
int error;
int block;
struct inode * inode = filp->f_dentry->d_inode;
int __user *p = (int __user *)arg;
switch (cmd) {
case FIBMAP:
{
struct address_space *mapping = filp->f_mapping;
int res;
/* do we support this mess? */
if (!mapping->a_ops->bmap)
return -EINVAL;
if (!capable(CAP_SYS_RAWIO))
return -EPERM;
if ((error = get_user(block, p)) != 0)
return error;
lock_kernel();
res = mapping->a_ops->bmap(mapping, block);
unlock_kernel();
return put_user(res, p);
}
case FS_IOC_FIEMAP:
return ioctl_fiemap(filp, arg);
case FIGETBSZ:
if (inode->i_sb == NULL)
return -EBADF;
return put_user(inode->i_sb->s_blocksize, p);
case FIONREAD:
return put_user(i_size_read(inode) - filp->f_pos, p);
}
return do_ioctl(filp, cmd, arg);
}
static void
rebuild_in_place(int fd, char *component)
{
RF_SingleComponent_t comp;
int component_num;
int num_cols;
get_component_number(fd, component, &component_num, &num_cols);
comp.row = 0;
comp.column = component_num;
strncpy(comp.component_name, component, sizeof(comp.component_name));
do_ioctl( fd, RAIDFRAME_REBUILD_IN_PLACE, &comp,
"RAIDFRAME_REBUILD_IN_PLACE");
if (verbose) {
printf("Reconstruction status:\n");
sleep(3); /* XXX give reconstruction a chance to start */
do_meter(fd,RAIDFRAME_CHECK_RECON_STATUS_EXT);
}
}
static void test_fault_buffer(int in)
{
int fd = setup(in, 0);
struct drm_mode_map_dumb arg;
char *buf;
memset(&arg, 0, sizeof(arg));
arg.handle = dumb_create(fd);
do_ioctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &arg);
buf = mmap(0, 4096, PROT_WRITE, MAP_SHARED, fd, arg.offset);
igt_assert(buf != MAP_FAILED);
generate_event(fd);
alarm(1);
igt_assert(read(fd, buf, 4096) > 0);
munmap(buf, 4096);
teardown(fd);
}
int get_range_info(const int sock, const char *ifname, struct iw_range *range)
{
struct iwreq req;
char buffer[sizeof(struct iw_range) * 2]; /* Large enough */
if (sock <= 0) {
return (-1);
}
/* Cleanup */
memset(buffer, 0, sizeof(buffer));
req.u.data.pointer = (caddr_t) buffer;
req.u.data.length = sizeof(buffer);
req.u.data.flags = 0;
if (do_ioctl(sock, ifname, SIOCGIWRANGE, &req) < 0)
return (-1);
/* Copy stuff at the right place, ignore extra */
memcpy((char *) range, buffer, sizeof(struct iw_range));
return (0);
}
static void
rf_configure(int fd, char *config_file, int force)
{
void *generic;
RF_Config_t cfg;
if (rf_MakeConfig( config_file, &cfg ) != 0) {
fprintf(stderr,"%s: unable to create RAIDframe %s\n",
getprogname(), "configuration structure\n");
exit(1);
}
cfg.force = force;
/*
* Note the extra level of redirection needed here, since
* what we really want to pass in is a pointer to the pointer to
* the configuration structure.
*/
generic = (void *) &cfg;
do_ioctl(fd, RAIDFRAME_CONFIGURE, &generic, "RAIDFRAME_CONFIGURE");
}
static void exec(int fd, uint32_t handle, uint32_t offset)
{
struct drm_i915_gem_execbuffer2 execbuf;
struct drm_i915_gem_exec_object2 gem_exec[1];
struct drm_i915_gem_relocation_entry gem_reloc[1];
gem_reloc[0].offset = 1024;
gem_reloc[0].delta = 0;
gem_reloc[0].target_handle = handle;
gem_reloc[0].read_domains = I915_GEM_DOMAIN_RENDER;
gem_reloc[0].write_domain = 0;
gem_reloc[0].presumed_offset = 0;
gem_exec[0].handle = handle;
gem_exec[0].relocation_count = 1;
gem_exec[0].relocs_ptr = (uintptr_t) gem_reloc;
gem_exec[0].alignment = 0;
gem_exec[0].offset = 0;
gem_exec[0].flags = 0;
gem_exec[0].rsvd1 = 0;
gem_exec[0].rsvd2 = 0;
execbuf.buffers_ptr = (uintptr_t)gem_exec;
execbuf.buffer_count = 1;
execbuf.batch_start_offset = 0;
execbuf.batch_len = 8;
execbuf.cliprects_ptr = 0;
execbuf.num_cliprects = 0;
execbuf.DR1 = 0;
execbuf.DR4 = 0;
execbuf.flags = 0;
i915_execbuffer2_set_context_id(execbuf, 0);
execbuf.rsvd2 = 0;
do_ioctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf);
igt_assert(gem_exec[0].offset == offset);
}
static void
set_component_label(int fd, char *component)
{
RF_ComponentLabel_t component_label;
int component_num;
int num_cols;
get_component_number(fd, component, &component_num, &num_cols);
/* XXX This is currently here for testing, and future expandability */
component_label.version = 1;
component_label.serial_number = 123456;
component_label.mod_counter = 0;
component_label.row = component_num / num_cols;
component_label.column = component_num % num_cols;
component_label.num_rows = 0;
component_label.num_columns = 5;
component_label.clean = 0;
component_label.status = 1;
do_ioctl( fd, RAIDFRAME_SET_COMPONENT_LABEL, &component_label,
"RAIDFRAME_SET_COMPONENT_LABEL");
}
static int get_ifname(struct iwreq *preq, const char *dev)
{
/* do not cache this call !!! */
struct iwreq req;
char key_buffer[32];
if (sock <= 0) {
return (-1);
}
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_PROTO);
if (!preq)
preq = &req;
if (do_ioctl(sock, dev, SIOCGIWNAME, preq)) {
debug("%s isn't a wirelesss interface !", dev);
return -1;
}
hash_put(&wireless, key_buffer, preq->u.name);
return (0);
}
int
main(int argc, char **argv)
{
int opt;
char *disk = NULL;
unsigned long ru_start = 0, ru_end = 1;
struct cb_tioctl_copyback sarg;
while ((opt = getopt(argc, argv, "d:s:e:")) != -1) {
switch (opt) {
case 'd':
disk = optarg;
break;
case 's':
ru_start = atoll(optarg);
break;
case 'e':
ru_end = atoll(optarg);
break;
}
}
if (!disk) {
usage();
}
strncpy((char *)&sarg.cbt_devpath, disk, CBX_PATHNAME_MAX - 1);
sarg.cbt_ru_start = ru_start;
sarg.cbt_ru_end = ru_end;
if (do_ioctl((void *)&sarg) < 0) {
exit(errno);
}
exit(0);
}
static void
rf_fail_disk(int fd, char *component_to_fail, int do_recon)
{
struct rf_recon_req recon_request;
int component_num;
int num_cols;
get_component_number(fd, component_to_fail, &component_num, &num_cols);
recon_request.row = component_num / num_cols;
recon_request.col = component_num % num_cols;
if (do_recon) {
recon_request.flags = RF_FDFLAGS_RECON;
} else {
recon_request.flags = RF_FDFLAGS_NONE;
}
do_ioctl(fd, RAIDFRAME_FAIL_DISK, &recon_request,
"RAIDFRAME_FAIL_DISK");
if (do_recon && verbose) {
printf("Reconstruction status:\n");
sleep(3); /* XXX give reconstruction a chance to start */
do_meter(fd,RAIDFRAME_CHECK_RECON_STATUS_EXT);
}
}
int
test_unit_ready(int argc, char **argv)
{
iscsi_iocommand_parameters_t io;
int rc;
(void) memset(&io, 0x0, sizeof(io));
if ((io.session_id = get_sessid(argc, argv, FALSE)) == 0) {
return 1;
}
io.lun = cl_get_longlong('l', argc, argv);
check_extra_args(argc, argv);
io.req.cmdlen = 6;
io.req.cmd[0] = 0x00;
io.req.datalen = 0;
if ((rc = do_ioctl(&io, TRUE)) != 0) {
return rc;
}
printf("Unit is ready\n");
return 0;
}
int check_cdrom_media_change(int full_dev, int flag){
int retval;
lock_sr_ioctl();
target = MINOR(full_dev);
if (target >= NR_SR) {
printk("CD-ROM request error: invalid device.\n");
unlock_sr_ioctl();
return 0;
};
sr_cmd[0] = TEST_UNIT_READY;
sr_cmd[1] = (scsi_CDs[target].device->lun << 5) & 0xe0;
sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = sr_cmd[5] = 0;
retval = do_ioctl();
if(retval){ /* Unable to test, unit probably not ready. This usually
means there is no disc in the drive. Mark as changed,
and we will figure it out later once the drive is
available again. */
scsi_CDs[target].changed = 1;
unlock_sr_ioctl();
return 1; /* This will force a flush, if called from
check_disk_change */
};
retval = scsi_CDs[target].changed;
if(!flag) scsi_CDs[target].changed = 0;
unlock_sr_ioctl();
return retval;
}
/*
* this function adds all servers in srvlist to the kernel(!) rule
* the name of which is passed as argument.
*/
static ilb_status_t
i_update_ksrv_rules(char *name, ilbd_sg_t *sg, ilbd_rule_t *rl)
{
ilb_status_t rc;
ilbd_srv_t *srvp;
ilb_servers_info_cmd_t *kcmd = NULL;
int i;
/*
* If the servergroup doesn't have any servers associated with
* it yet, there's nothing more to do here.
*/
if (sg->isg_srvcount == 0)
return (ILB_STATUS_OK);
/*
* walk the list of servers attached to this SG
*/
srvp = list_head(&sg->isg_srvlist);
for (i = 0; srvp != NULL; srvp = list_next(&sg->isg_srvlist, srvp)) {
rc = adjust_srv_info_cmd(&kcmd, i);
if (rc != ILB_STATUS_OK)
goto rollback_kcmd;
ILB_SGSRV_2_KSRV(&srvp->isv_srv, &kcmd->servers[i]);
/*
* "no port" means "copy rule's port" (for kernel rule)
*/
if (kcmd->servers[i].min_port == 0) {
kcmd->servers[i].min_port = rl->irl_minport;
kcmd->servers[i].max_port = rl->irl_maxport;
}
i++;
}
assert(kcmd != NULL);
kcmd->cmd = ILB_ADD_SERVERS;
kcmd->num_servers = i;
(void) strlcpy(kcmd->name, name, sizeof (kcmd->name));
rc = do_ioctl(kcmd, 0);
if (rc != ILB_STATUS_OK)
goto rollback_kcmd;
for (i = 0; i < kcmd->num_servers; i++) {
int e;
if ((e = kcmd->servers[i].err) != 0) {
logerr("i_update_ksrv_rules "
"ioctl indicates failure: %s", strerror(e));
rc = ilb_map_errno2ilbstat(e);
/*
* if adding even a single server failed, we need to
* roll back the whole wad. We ignore any errors and
* return the one that was returned by the first ioctl.
*/
kcmd->cmd = ILB_DEL_SERVERS;
(void) do_ioctl(kcmd, 0);
goto rollback_kcmd;
}
}
rollback_kcmd:
free(kcmd);
return (rc);
}
static int get_stats(const char *dev, const char *key)
{
struct iw_statistics stats;
struct iwreq req;
char qprintf_buffer[1024];
char key_buffer[32];
int age;
struct iw_range range;
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
age = hash_age(&wireless, key);
/* reread every HASH_TTL msec only */
if (age > 0 && age <= HASH_TTL) {
return (0);
}
if (get_ifname(&req, dev) != 0) {
return (-1);
}
req.u.data.pointer = (caddr_t) & stats;
req.u.data.length = sizeof(stats);
req.u.data.flags = 1; /* Clear updated flag */
if (do_ioctl(sock, dev, SIOCGIWSTATS, &req) < 0) {
ioctl_error(__LINE__);
return -1;
}
if (get_range_info(sock, dev, &range) < 0)
memset(&range, 0, sizeof(range));
if (stats.qual.level > range.max_qual.level) {
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d", stats.qual.level - 0x100);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_LEVEL);
hash_put(&wireless, key_buffer, qprintf_buffer);
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d", stats.qual.noise - 0x100);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_NOISE);
hash_put(&wireless, key_buffer, qprintf_buffer);
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.qual, range.max_qual.qual);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_QUALITY);
hash_put(&wireless, key_buffer, qprintf_buffer);
} else {
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.level, range.max_qual.level);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_LEVEL);
hash_put(&wireless, key_buffer, qprintf_buffer);
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.noise, range.max_qual.noise);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_NOISE);
hash_put(&wireless, key_buffer, qprintf_buffer);
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.qual, range.max_qual.qual);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_QUALITY);
hash_put(&wireless, key_buffer, qprintf_buffer);
}
return 0;
}
/*
* When you add any new common ioctls to the switches above and below
* please update compat_sys_ioctl() too.
*
* vfs_ioctl() is not for drivers and not intended to be EXPORT_SYMBOL()'d.
* It's just a simple helper for sys_ioctl and compat_sys_ioctl.
*/
int vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd, unsigned long arg)
{
unsigned int flag;
int on, error = 0;
umode_t mode;
struct _file *_filp = tx_cache_get_file(filp);
/* Patch up ioctl for bad tx cases*/
if((!_filp) || !_filp->f_dentry ){
#ifdef CONFIG_TX_KSTM_WARNINGS
printk(KERN_ERR "Fixing up ioctl\n");
#endif
return 0;
}
mode = d_get_inode_ro(f_get_dentry(_filp))->i_mode;
switch (cmd) {
case FIOCLEX:
set_close_on_exec(fd, 1);
break;
case FIONCLEX:
set_close_on_exec(fd, 0);
break;
case FIONBIO:
if ((error = get_user(on, (int __user *)arg)) != 0)
break;
flag = O_NONBLOCK;
#ifdef __sparc__
/* SunOS compatibility item. */
if(O_NONBLOCK != O_NDELAY)
flag |= O_NDELAY;
#endif
if (on)
_filp->f_flags |= flag;
else
_filp->f_flags &= ~flag;
break;
case FIOASYNC:
if ((error = get_user(on, (int __user *)arg)) != 0)
break;
flag = on ? FASYNC : 0;
/* Did FASYNC state change ? */
if ((flag ^ _filp->f_flags) & FASYNC) {
if (filp->f_op && filp->f_op->fasync) {
lock_kernel();
error = filp->f_op->fasync(fd, filp, on);
unlock_kernel();
}
else error = -ENOTTY;
}
if (error != 0)
break;
if (on)
_filp->f_flags |= FASYNC;
else
_filp->f_flags &= ~FASYNC;
break;
case FIOQSIZE:
if (S_ISDIR(mode) ||
S_ISREG(mode) ||
S_ISLNK(mode)) {
loff_t res = inode_get_bytes(f_get_dentry(_filp)->d_inode);
error = copy_to_user((loff_t __user *)arg, &res, sizeof(res)) ? -EFAULT : 0;
}
else
error = -ENOTTY;
break;
default:
if(live_transaction()){
/* Short circuit this stupid ioctl */
if(cmd == TIOCGWINSZ){
#ifdef CONFIG_TX_KSTM_WARNINGS
printk(KERN_ERR "Warning: some bozo wants to know the terminal width in a transaction.\n");
#endif
error = -EINVAL;
break;
} else if(cmd != TCGETS)
BUG();
}
if (S_ISREG(mode))
error = file_ioctl(filp, cmd, arg);
else
error = do_ioctl(filp, cmd, arg);
break;
}
return error;
}
static ilb_status_t
i_ilbd_rule_action(const char *rule_name, const struct passwd *ps,
ilbd_cmd_t cmd, ucred_t *ucredp)
{
ilbd_rule_t *irl, *irl_next;
boolean_t is_all_rules = B_FALSE;
ilb_status_t rc = ILB_STATUS_OK;
ilb_name_cmd_t kcmd;
ilbd_cmd_t u_cmd;
char rulename[ILB_NAMESZ];
if (ps != NULL) {
if ((cmd == ILBD_ENABLE_RULE) || (cmd == ILBD_DISABLE_RULE))
rc = ilbd_check_client_enable_auth(ps);
else
rc = ilbd_check_client_config_auth(ps);
/* generate the audit record before bailing out */
if (rc != ILB_STATUS_OK) {
if (rule_name != '\0') {
ilbd_audit_rule_event(rule_name, NULL,
cmd, rc, ucredp);
} else {
(void) snprintf(rulename, sizeof (rulename),
"all");
ilbd_audit_rule_event(rulename, NULL, cmd, rc,
ucredp);
}
goto out;
}
}
is_all_rules = rule_name[0] == 0;
/* just one rule */
if (!is_all_rules) {
irl = i_find_rule_byname(rule_name);
if (irl == NULL) {
rc = ILB_STATUS_ENORULE;
ilbd_audit_rule_event(rule_name, NULL, cmd, rc, ucredp);
goto out;
}
/* auditing will be done by i_ilbd_action_switch() */
rc = i_ilbd_action_switch(irl, cmd, B_FALSE, ucredp);
goto out;
}
/* all rules: first tell the kernel, then walk the daemon's list */
kcmd.cmd = i_ilbd2ilb_cmd(cmd);
kcmd.flags = ILB_RULE_ALLRULES;
rc = do_ioctl(&kcmd, 0);
if (rc != ILB_STATUS_OK) {
(void) snprintf(rulename, sizeof (rulename), "all");
ilbd_audit_rule_event(rulename, NULL, cmd, rc, ucredp);
goto out;
}
irl = list_head(&ilbd_rule_hlist);
while (irl != NULL) {
irl_next = list_next(&ilbd_rule_hlist, irl);
irl->irl_flags |= ILB_FLAGS_RULE_ALLRULES;
/* auditing will be done by i_ilbd_action_switch() */
rc = i_ilbd_action_switch(irl, cmd, B_FALSE, ucredp);
irl->irl_flags &= ~ILB_FLAGS_RULE_ALLRULES;
if (rc != ILB_STATUS_OK)
goto rollback_list;
irl = irl_next;
}
return (rc);
rollback_list:
u_cmd = get_undo_cmd(cmd);
if (u_cmd == ILBD_BAD_CMD)
return (rc);
if (is_all_rules) {
kcmd.cmd = i_ilbd2ilb_cmd(u_cmd);
(void) do_ioctl(&kcmd, 0);
}
/* current list element failed, so we start with previous one */
irl = list_prev(&ilbd_rule_hlist, irl);
while (irl != NULL) {
if (is_all_rules)
irl->irl_flags |= ILB_FLAGS_RULE_ALLRULES;
/*
* When the processing of a command consists of
* multiple sequential steps, and one of them fails,
* ilbd performs rollback to undo the steps taken before the
* failing step. Since ilbd is initiating these steps
* there is not need to audit them.
*/
rc = i_ilbd_action_switch(irl, u_cmd, B_TRUE, NULL);
irl->irl_flags &= ~ILB_FLAGS_RULE_ALLRULES;
irl = list_prev(&ilbd_rule_hlist, irl);
}
out:
return (rc);
}
/*
* ev_port is only used for rollback purposes in this function
*/
ilb_status_t
i_rem_srv_frm_krules(list_t *rlist, ilb_sg_srv_t *srv, int ev_port)
{
ilb_status_t rc = ILB_STATUS_OK;
ilbd_rule_t *rl, *add_rl;
ilb_servers_cmd_t kcmd;
ilb_servers_info_cmd_t add_kcmd;
kcmd.cmd = ILB_DEL_SERVERS;
kcmd.num_servers = 1;
kcmd.servers[0].err = 0;
kcmd.servers[0].addr = srv->sgs_addr;
for (rl = list_head(rlist); rl != NULL; rl = list_next(rlist, rl)) {
(void) strlcpy(kcmd.name, rl->irl_name, sizeof (kcmd.name));
rc = do_ioctl((void *)&kcmd, 0);
if (rc != ILB_STATUS_OK) {
logdebug("i_rem_srv_frm_krules: do_ioctl"
"call failed");
add_rl = list_prev(rlist, rl);
goto rollback;
}
/*
* if ioctl() returns != 0, it doesn't perform the copyout
* necessary to indicate *which* server failed (we could be
* removing more than one); therefore we must check this
* 'err' field even if ioctl() returns 0.
*/
if (kcmd.servers[0].err != 0) {
logerr("i_rem_srv_frm_krules: SIOCILB ioctl"
" returned error %s",
strerror(kcmd.servers[0].err));
rc = ilb_map_errno2ilbstat(kcmd.servers[0].err);
add_rl = list_prev(rlist, rl);
goto rollback;
}
if (RULE_HAS_HC(rl) &&
(rc = ilbd_hc_del_server(rl, srv)) != ILB_STATUS_OK) {
logerr("i_rem_srv_frm_krules: cannot delete "
"timer for rules %s server %s", rl->irl_name,
srv->sgs_srvID);
add_rl = rl;
goto rollback;
}
}
return (rc);
rollback:
/* Don't do roll back if ev_port == -1. */
if (ev_port == -1)
return (rc);
add_kcmd.cmd = ILB_ADD_SERVERS;
add_kcmd.num_servers = 1;
add_kcmd.servers[0].err = 0;
add_kcmd.servers[0].addr = srv->sgs_addr;
add_kcmd.servers[0].flags = i_flags_d2k(srv->sgs_flags);
(void) strlcpy(add_kcmd.servers[0].name, srv->sgs_srvID,
sizeof (add_kcmd.servers[0].name));
while (add_rl != NULL) {
if (srv->sgs_minport == 0) {
add_kcmd.servers[0].min_port = add_rl->irl_minport;
add_kcmd.servers[0].max_port = add_rl->irl_maxport;
} else {
add_kcmd.servers[0].min_port = srv->sgs_minport;
add_kcmd.servers[0].max_port = srv->sgs_maxport;
}
if (RULE_HAS_HC(add_rl))
(void) ilbd_hc_add_server(add_rl, srv, ev_port);
(void) strlcpy(add_kcmd.name, add_rl->irl_name,
sizeof (add_kcmd.name));
(void) do_ioctl((void *)&add_kcmd, 0);
add_rl = list_prev(rlist, add_rl);
}
return (rc);
}
/*
* walk the list of rules and add srv to the *kernel* rule
* (this is a list of rules hanging off of a server group)
*/
ilb_status_t
i_add_srv2krules(list_t *rlist, ilb_sg_srv_t *srv, int ev_port)
{
ilb_status_t rc = ILB_STATUS_OK;
ilbd_rule_t *rl, *del_rl;
ilb_servers_info_cmd_t kcmd;
ilb_servers_cmd_t del_kcmd;
kcmd.cmd = ILB_ADD_SERVERS;
kcmd.num_servers = 1;
kcmd.servers[0].err = 0;
kcmd.servers[0].addr = srv->sgs_addr;
kcmd.servers[0].flags = i_flags_d2k(srv->sgs_flags);
(void) strlcpy(kcmd.servers[0].name, srv->sgs_srvID,
sizeof (kcmd.servers[0].name));
/*
* a note about rollback: since we need to start rollback with the
* current list element in some case, and with the previous one
* in others, we must "go back" in this latter case before
* we jump to the rollback code.
*/
for (rl = list_head(rlist); rl != NULL; rl = list_next(rlist, rl)) {
(void) strlcpy(kcmd.name, rl->irl_name, sizeof (kcmd.name));
/*
* sgs_minport == 0 means "no port specified"; this
* indicates that the server matches anything the rule
* provides.
* NOTE: this can be different for different rules
* using the same server group, therefore we don't modify
* this information in the servergroup, but *only* in
* the kernel's rule.
*/
if (srv->sgs_minport == 0) {
kcmd.servers[0].min_port = rl->irl_minport;
kcmd.servers[0].max_port = rl->irl_maxport;
} else {
kcmd.servers[0].min_port = srv->sgs_minport;
kcmd.servers[0].max_port = srv->sgs_maxport;
}
rc = do_ioctl((void *)&kcmd, 0);
if (rc != ILB_STATUS_OK) {
logdebug("i_add_srv2krules: do_ioctl call failed");
del_rl = list_prev(rlist, rl);
goto rollback;
}
/*
* if ioctl() returns != 0, it doesn't perform the copyout
* necessary to indicate *which* server failed (we could be
* adding more than one); therefore we must check this
* 'err' field even if ioctl() returns 0.
*/
if (kcmd.servers[0].err != 0) {
logerr("i_add_srv2krules: SIOCILB ioctl returned"
" error %d", kcmd.servers[0].err);
rc = ilb_map_errno2ilbstat(kcmd.servers[0].err);
del_rl = list_prev(rlist, rl);
goto rollback;
}
if (RULE_HAS_HC(rl)) {
if ((rc = ilbd_hc_add_server(rl, srv, ev_port)) !=
ILB_STATUS_OK) {
logerr("i_add_srv2krules: cannot start timer "
" for rules %s server %s", rl->irl_name,
srv->sgs_srvID);
del_rl = rl;
goto rollback;
}
}
}
return (rc);
rollback:
/*
* this is almost, but not quite, the same as i_rem_srv_frm_krules()
* therefore we keep it seperate.
*/
del_kcmd.cmd = ILB_DEL_SERVERS;
del_kcmd.num_servers = 1;
del_kcmd.servers[0].addr = srv->sgs_addr;
while (del_rl != NULL) {
if (RULE_HAS_HC(del_rl))
(void) ilbd_hc_del_server(del_rl, srv);
(void) strlcpy(del_kcmd.name, del_rl->irl_name,
sizeof (del_kcmd.name));
(void) do_ioctl((void *)&del_kcmd, 0);
del_rl = list_prev(rlist, del_rl);
}
return (rc);
}
/*
* When you add any new common ioctls to the switches above and below
* please update compat_sys_ioctl() too.
*
* vfs_ioctl() is not for drivers and not intended to be EXPORT_SYMBOL()'d.
* It's just a simple helper for sys_ioctl and compat_sys_ioctl.
*/
int vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd, unsigned long arg)
{
unsigned int flag;
int on, error = 0;
switch (cmd) {
case FIOCLEX:
set_close_on_exec(fd, 1);
break;
case FIONCLEX:
set_close_on_exec(fd, 0);
break;
case FIONBIO:
if ((error = get_user(on, (int __user *)arg)) != 0)
break;
flag = O_NONBLOCK;
#ifdef __sparc__
/* SunOS compatibility item. */
if(O_NONBLOCK != O_NDELAY)
flag |= O_NDELAY;
#endif
if (on)
filp->f_flags |= flag;
else
filp->f_flags &= ~flag;
break;
case FIOASYNC:
if ((error = get_user(on, (int __user *)arg)) != 0)
break;
flag = on ? FASYNC : 0;
/* Did FASYNC state change ? */
if ((flag ^ filp->f_flags) & FASYNC) {
if (filp->f_op && filp->f_op->fasync) {
lock_kernel();
error = filp->f_op->fasync(fd, filp, on);
unlock_kernel();
}
else error = -ENOTTY;
}
if (error != 0)
break;
if (on)
filp->f_flags |= FASYNC;
else
filp->f_flags &= ~FASYNC;
break;
case FIOQSIZE:
if (S_ISDIR(filp->f_dentry->d_inode->i_mode) ||
S_ISREG(filp->f_dentry->d_inode->i_mode) ||
S_ISLNK(filp->f_dentry->d_inode->i_mode)) {
loff_t res = inode_get_bytes(filp->f_dentry->d_inode);
error = copy_to_user((loff_t __user *)arg, &res, sizeof(res)) ? -EFAULT : 0;
}
else
error = -ENOTTY;
break;
case FIFREEZE:
error = ioctl_fsfreeze(filp);
break;
case FITHAW:
error = ioctl_fsthaw(filp);
break;
default:
if (S_ISREG(filp->f_dentry->d_inode->i_mode))
error = file_ioctl(filp, cmd, arg);
else
error = do_ioctl(filp, cmd, arg);
break;
}
return error;
}
int sr_ioctl(struct inode * inode, struct file * file, unsigned long cmd, unsigned long arg)
{
int dev = inode->i_rdev;
int result;
target = MINOR(dev);
switch (cmd)
{
/* linux-specific */
case CDROMDOORUNLOCK:
lock_sr_ioctl();
sr_cmd[0] = ALLOW_MEDIUM_REMOVAL;
sr_cmd[1] = scsi_CDs[target].device->lun << 5;
sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
sr_cmd[4] = SR_REMOVAL_ALLOW;
result = do_ioctl();
unlock_sr_ioctl();
return result;
case CDROMDOORLOCK:
lock_sr_ioctl();
sr_cmd[0] = ALLOW_MEDIUM_REMOVAL;
sr_cmd[1] = scsi_CDs[target].device->lun << 5;
sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
sr_cmd[4] = SR_REMOVAL_PREVENT;
result = do_ioctl();
unlock_sr_ioctl();
return result;
/* Sun-compatible */
case CDROMPAUSE:
lock_sr_ioctl();
sr_cmd[0] = SCMD_PAUSE_RESUME;
sr_cmd[1] = scsi_CDs[target].device->lun << 5;
sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = 0;
sr_cmd[5] = sr_cmd[6] = sr_cmd[7] = 0;
sr_cmd[8] = 1;
sr_cmd[9] = 0;
result = do_ioctl();
unlock_sr_ioctl();
return result;
case CDROMRESUME:
lock_sr_ioctl();
sr_cmd[0] = SCMD_PAUSE_RESUME;
sr_cmd[1] = scsi_CDs[target].device->lun << 5;
sr_cmd[2] = sr_cmd[3] = sr_cmd[4] = 0;
sr_cmd[5] = sr_cmd[6] = sr_cmd[7] = 0;
sr_cmd[8] = 0;
sr_cmd[9] = 0;
result = do_ioctl();
unlock_sr_ioctl();
return result;
case CDROMPLAYMSF:
{
struct cdrom_msf msf;
lock_sr_ioctl();
memcpy_fromfs(&msf, (void *) arg, sizeof(msf));
sr_cmd[0] = SCMD_PLAYAUDIO_MSF;
sr_cmd[1] = scsi_CDs[target].device->lun << 5;
sr_cmd[2] = 0;
sr_cmd[3] = msf.cdmsf_min0;
sr_cmd[4] = msf.cdmsf_sec0;
sr_cmd[5] = msf.cdmsf_frame0;
sr_cmd[6] = msf.cdmsf_min1;
sr_cmd[7] = msf.cdmsf_sec1;
sr_cmd[8] = msf.cdmsf_frame1;
sr_cmd[9] = 0;
result = do_ioctl();
unlock_sr_ioctl();
return result;
}
case CDROMPLAYTRKIND:
{
struct cdrom_ti ti;
lock_sr_ioctl();
memcpy_fromfs(&ti, (void *) arg, sizeof(ti));
sr_cmd[0] = SCMD_PLAYAUDIO_TI;
sr_cmd[1] = scsi_CDs[target].device->lun << 5;
sr_cmd[2] = 0;
sr_cmd[3] = 0;
sr_cmd[4] = ti.cdti_trk0;
sr_cmd[5] = ti.cdti_ind0;
sr_cmd[6] = 0;
sr_cmd[7] = ti.cdti_trk1;
sr_cmd[8] = ti.cdti_ind1;
sr_cmd[9] = 0;
result = do_ioctl();
unlock_sr_ioctl();
return result;
}
case CDROMREADTOCHDR:
return -EINVAL;
case CDROMREADTOCENTRY:
return -EINVAL;
case CDROMSTOP:
lock_sr_ioctl();
sr_cmd[0] = START_STOP;
sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
sr_cmd[4] = 0;
result = do_ioctl();
unlock_sr_ioctl();
return result;
case CDROMSTART:
lock_sr_ioctl();
sr_cmd[0] = START_STOP;
sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
sr_cmd[4] = 1;
result = do_ioctl();
unlock_sr_ioctl();
return result;
case CDROMEJECT:
lock_sr_ioctl();
sr_cmd[0] = START_STOP;
sr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
sr_cmd[2] = sr_cmd[3] = sr_cmd[5] = 0;
sr_cmd[4] = 0x02;
result = do_ioctl();
unlock_sr_ioctl();
return result;
case CDROMVOLCTRL:
return -EINVAL;
case CDROMSUBCHNL:
return -EINVAL;
case CDROMREADMODE2:
return -EINVAL;
case CDROMREADMODE1:
return -EINVAL;
RO_IOCTLS(dev,arg);
default:
return scsi_ioctl(scsi_CDs[target].device,cmd,(void *) arg);
}
}
int main(int argc, char **argv)
{
int opt = 0;
int retval = 0;
int iRecv = 0;
int i;
char *dev_name = NULL;
int baudrate = 115200;
char *settings = "8N1N";
unsigned char aucBuf[512];
unsigned char disp_mode = 0x00;
struct sigaction sigact;
struct option long_options[] = {
{"device", required_argument, NULL, 'd'},
{"baudrate", required_argument, NULL, 'b'},
{"settings", required_argument, NULL, 's'},
{"ioctl", required_argument, NULL, 'i'},
{"hex", no_argument, NULL, 'x'},
{"version", no_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
while ((opt = getopt_long(argc, argv, "d:b:s:ivh", long_options, NULL)) != -1)
{
switch (opt)
{
case 'd':
dev_name = optarg;
break;
case 'b':
baudrate = atoi(optarg);
break;
case 's': /* Default settings as 8N1N */
settings = optarg;
break;
case 'i':
if (5 != argc)
{
usage(argv[0]);
}
else
{
do_ioctl(argv[2], atoi(argv[3]), atoi(argv[4]));
}
return 0;
case 'x': /* Display receive data as Hex mode */
disp_mode = 0x01;
break;
case 'v': /* version */
print_version(argv[0]);
return 0;
case 'h': /* help */
usage(argv[0]);
return 0;
default:
break;
} /* end of "switch(opt)" */
}
if (argc < 2)
{
usage(argv[0]);
return 0;
}
COM_PORT *comport = NULL;
if (NULL == (comport = comport_init(dev_name, baudrate, settings)))
{
printf("Comport initialize failure.\n");
return -1;
}
if ((retval = comport_open(comport)) < 0)
{
printf("Failed to open %s with baudrate %d, %s. RetCode [0x%02x]", dev_name, baudrate,
settings, retval);
return -1;
}
nonblock();
/* Process level signal handler */
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
sigact.sa_handler = signal_handler;
sigaction(SIGTERM, &sigact, NULL); /* catch terminate signal */
sigaction(SIGINT, &sigact, NULL); /* catch interrupt signal */
sigaction(SIGSEGV, &sigact, NULL); /* catch segmentation faults */
sigaction(SIGTSTP, &sigact, NULL); /* catch ctrl+Z */
sigaction(SIGSTOP, &sigact, NULL); /* catch ctrl+Z */
while (0x01 == g_ucProcToken)
{
retval = comport_recv(comport, aucBuf, sizeof(aucBuf) - 1, &iRecv, 10);
if (0x00 == retval && 0 < iRecv)
{
for (i = 0; i < iRecv; i++)
{
if (0 == disp_mode)
printf("%c", aucBuf[i]);
else
printf("%02X ", aucBuf[i]);
}
fflush(stdout);
}
if (0 != kbhit())
{
iRecv = fgetc(stdin);
if (10 == iRecv)
{
aucBuf[0] = 13;
}
else
{
aucBuf[0] = iRecv;
}
comport_send(comport, aucBuf, 1);
}
else if (0x00 != g_ucCtrlZ)
{
g_ucCtrlZ = 0x00;
aucBuf[0] = 0x1A;
comport_send(comport, aucBuf, 1);
}
}
comport_term(comport);
return 0;
} /* ----- End of main() ----- */
static int robo_probe(char *devname)
{
__u32 phyid;
unsigned int i;
int err = 1;
printk(KERN_INFO PFX "Probing device %s: ", devname);
strcpy(robo.ifr.ifr_name, devname);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
if ((robo.dev = dev_get_by_name(devname)) == NULL) {
#else
if ((robo.dev = dev_get_by_name(&init_net, devname)) == NULL) {
#endif
printk("No such device\n");
return 1;
}
robo.device = devname;
for (i = 0; i < 5; i++)
robo.port[i] = i;
robo.port[5] = 8;
/* try access using MII ioctls - get phy address */
if (do_ioctl(SIOCGMIIPHY, NULL) < 0) {
robo.use_et = 1;
robo.phy_addr = ROBO_PHY_ADDR;
} else {
/* got phy address check for robo address */
struct mii_ioctl_data *mii = (struct mii_ioctl_data *) &robo.ifr.ifr_data;
if ((mii->phy_id != ROBO_PHY_ADDR) &&
(mii->phy_id != ROBO_PHY_ADDR_BCM63XX) &&
(mii->phy_id != ROBO_PHY_ADDR_TG3)) {
printk("Invalid phy address (%d)\n", mii->phy_id);
goto done;
}
robo.use_et = 0;
/* The robo has a fixed PHY address that is different from the
* Tigon3 and BCM63xx PHY address. */
robo.phy_addr = ROBO_PHY_ADDR;
}
phyid = mdio_read(robo.phy_addr, 0x2) |
(mdio_read(robo.phy_addr, 0x3) << 16);
if (phyid == 0xffffffff || phyid == 0x55210022) {
printk("No Robo switch in managed mode found, phy_id = 0x%08x\n", phyid);
goto done;
}
/* Get the device ID */
for (i = 0; i < 10; i++) {
robo.devid = robo_read16(ROBO_MGMT_PAGE, ROBO_DEVICE_ID);
if (robo.devid)
break;
udelay(10);
}
if (!robo.devid)
robo.devid = ROBO_DEVICE_ID_5325; /* Fake it */
robo.is_5350 = robo_vlan5350();
robo_switch_reset();
err = robo_switch_enable();
if (err)
goto done;
err = 0;
printk("found a 5%s%x!%s\n", robo.devid & 0xff00 ? "" : "3", robo.devid,
robo.is_5350 ? " It's a 5350." : "");
done:
if (err) {
dev_put(robo.dev);
robo.dev = NULL;
}
return err;
}
static int handle_vlan_port_read(void *driver, char *buf, int nr)
{
__u16 val16;
int len = 0;
int j;
val16 = (nr) /* vlan */ | (0 << 12) /* read */ | (1 << 13) /* enable */;
if (robo.is_5350) {
u32 val32;
robo_write16(ROBO_VLAN_PAGE, ROBO_VLAN_TABLE_ACCESS_5350, val16);
/* actual read */
val32 = robo_read32(ROBO_VLAN_PAGE, ROBO_VLAN_READ);
if ((val32 & (1 << 20)) /* valid */) {
for (j = 0; j < 6; j++) {
if (val32 & (1 << j)) {
len += sprintf(buf + len, "%d", j);
if (val32 & (1 << (j + 6))) {
if (j == 5) buf[len++] = 'u';
} else {
buf[len++] = 't';
if (robo_read16(ROBO_VLAN_PAGE, ROBO_VLAN_PORT0_DEF_TAG + (j << 1)) == nr)
buf[len++] = '*';
}
buf[len++] = '\t';
}
}
len += sprintf(buf + len, "\n");
}
} else {
robo_write16(ROBO_VLAN_PAGE, ROBO_VLAN_TABLE_ACCESS, val16);
/* actual read */
val16 = robo_read16(ROBO_VLAN_PAGE, ROBO_VLAN_READ);
if ((val16 & (1 << 14)) /* valid */) {
for (j = 0; j < 6; j++) {
if (val16 & (1 << j)) {
len += sprintf(buf + len, "%d", j);
if (val16 & (1 << (j + 7))) {
if (j == 5) buf[len++] = 'u';
} else {
buf[len++] = 't';
if (robo_read16(ROBO_VLAN_PAGE, ROBO_VLAN_PORT0_DEF_TAG + (j << 1)) == nr)
buf[len++] = '*';
}
buf[len++] = '\t';
}
}
len += sprintf(buf + len, "\n");
}
}
buf[len] = '\0';
return len;
}
ilb_status_t
ilbd_create_rule(ilb_rule_info_t *rl, int ev_port,
const struct passwd *ps, ucred_t *ucredp)
{
ilb_status_t rc;
ilbd_rule_t *irl = NULL;
ilbd_sg_t *sg;
ilb_rule_cmd_t *kcmd = NULL;
if (ps != NULL) {
if ((rc = ilbd_check_client_config_auth(ps)) != ILB_STATUS_OK)
goto out;
}
if (i_find_rule_byname(rl->rl_name) != NULL) {
logdebug("ilbd_create_rule: rule %s"
" already exists", rl->rl_name);
ilbd_audit_rule_event(NULL, rl, ILBD_CREATE_RULE,
ILB_STATUS_DUP_RULE, ucredp);
return (ILB_STATUS_DUP_RULE);
}
sg = i_find_sg_byname(rl->rl_sgname);
if (sg == NULL) {
logdebug("ilbd_create_rule: rule %s uses non-existent"
" servergroup name %s", rl->rl_name, rl->rl_sgname);
ilbd_audit_rule_event(NULL, rl, ILBD_CREATE_RULE,
ILB_STATUS_SGUNAVAIL, ucredp);
return (ILB_STATUS_SGUNAVAIL);
}
if ((rc = ilbd_sg_check_rule_port(sg, rl)) != ILB_STATUS_OK) {
ilbd_audit_rule_event(NULL, rl, ILBD_CREATE_RULE, rc, ucredp);
return (rc);
}
/* allocs and copies contents of arg (if != NULL) into new rule */
irl = i_alloc_ilbd_rule(rl);
if (irl == NULL) {
ilbd_audit_rule_event(NULL, rl, ILBD_CREATE_RULE,
ILB_STATUS_ENOMEM, ucredp);
return (ILB_STATUS_ENOMEM);
}
/* make sure rule's IPversion (via vip) and SG's match */
if (sg->isg_srvcount > 0) {
ilbd_srv_t *srv = list_head(&sg->isg_srvlist);
int32_t r_af = rl->rl_ipversion;
int32_t s_af = GET_AF(&srv->isv_addr);
if (r_af != s_af) {
logdebug("address family mismatch with servergroup");
rc = ILB_STATUS_MISMATCHSG;
goto out;
}
}
irl->irl_sg = sg;
/* Try associating the rule with the given hc oject. */
if (RULE_HAS_HC(irl)) {
if ((rc = ilbd_hc_associate_rule(irl, ev_port)) !=
ILB_STATUS_OK)
goto out;
}
/*
* checks are done, now:
* 1. create rule in kernel
* 2. tell it about the backend server (which we maintain in SG)
* 3. attach the rule in memory
*/
/* 1. */
/* allocs and copies contents of arg (if != NULL) into new rule */
kcmd = i_alloc_kernel_rule_cmd(irl);
if (kcmd == NULL) {
rc = ILB_STATUS_ENOMEM;
goto rollback_hc;
}
kcmd->cmd = ILB_CREATE_RULE;
rc = do_ioctl(kcmd, 0);
if (rc != ILB_STATUS_OK)
goto rollback_kcmd;
/* 2. */
rc = i_update_ksrv_rules(kcmd->name, sg, irl);
if (rc != ILB_STATUS_OK)
goto rollback_kcmd;
/* 3. */
(void) i_attach_rule2sg(sg, irl);
list_insert_tail(&ilbd_rule_hlist, irl);
if (ps != NULL) {
rc = i_ilbd_save_rule(irl, ILBD_SCF_CREATE);
if (rc != ILB_STATUS_OK)
goto rollback_rule;
}
free(kcmd);
ilbd_audit_rule_event(NULL, rl, ILBD_CREATE_RULE,
ILB_STATUS_OK, ucredp);
return (ILB_STATUS_OK);
rollback_rule:
/*
* ilbd_destroy_one_rule() also frees irl, as well as dissociate
* rule and HC, so all we need to do afterwards is free the kcmd
* and return.
*/
(void) ilbd_destroy_one_rule(irl);
ilbd_audit_rule_event(NULL, rl, ILBD_CREATE_RULE, rc, ucredp);
free(kcmd);
return (rc);
rollback_kcmd:
free(kcmd);
rollback_hc:
/* Cannot fail since the rule is just associated with the hc object. */
if (RULE_HAS_HC(irl))
(void) ilbd_hc_dissociate_rule(irl);
out:
ilbd_audit_rule_event(NULL, rl, ILBD_CREATE_RULE, rc, ucredp);
free(irl);
return (rc);
}
/*===========================================================================*
* blockdriver_process_on_thread *
*===========================================================================*/
void blockdriver_process_on_thread(struct blockdriver *bdp, message *m_ptr,
int ipc_status, thread_id_t id)
{
/* Call the appropiate driver function, based on the type of request. Send
* a result code to the caller. The call is processed in the context of the
* given thread ID, which may be SINGLE_THREAD for single-threaded callers.
*/
int r;
/* Check for notifications first. We never reply to notifications. */
if (is_ipc_notify(ipc_status)) {
switch (_ENDPOINT_P(m_ptr->m_source)) {
case HARDWARE:
if (bdp->bdr_intr)
(*bdp->bdr_intr)(m_ptr->m_notify.interrupts);
break;
case CLOCK:
if (bdp->bdr_alarm)
(*bdp->bdr_alarm)(m_ptr->m_notify.timestamp);
break;
default:
if (bdp->bdr_other)
(*bdp->bdr_other)(m_ptr, ipc_status);
}
return; /* do not send a reply */
}
/* Reply to character driver open requests with an error code. Otherwise, if
* someone creates a character device node for a block driver, opening that
* device node will cause the corresponding VFS thread to block forever.
*/
if (m_ptr->m_type == CDEV_OPEN) {
do_char_open(m_ptr, ipc_status);
return;
}
/* We might get spurious requests if the driver has been restarted. Deny any
* requests on devices that have not previously been opened, signaling the
* caller that something went wrong.
*/
if (IS_BDEV_RQ(m_ptr->m_type) && !is_open_dev(m_ptr->m_lbdev_lblockdriver_msg.minor)) {
/* Reply ERESTART to spurious requests for unopened devices. */
if (m_ptr->m_type != BDEV_OPEN) {
blockdriver_reply(m_ptr, ipc_status, ERESTART);
return;
}
/* Mark the device as opened otherwise. */
set_open_dev(m_ptr->m_lbdev_lblockdriver_msg.minor);
}
trace_start(id, m_ptr);
/* Call the appropriate function(s) for this request. */
switch (m_ptr->m_type) {
case BDEV_OPEN: r = do_open(bdp, m_ptr); break;
case BDEV_CLOSE: r = do_close(bdp, m_ptr); break;
case BDEV_READ:
case BDEV_WRITE: r = do_rdwt(bdp, m_ptr); break;
case BDEV_GATHER:
case BDEV_SCATTER: r = do_vrdwt(bdp, m_ptr, id); break;
case BDEV_IOCTL: r = do_ioctl(bdp, m_ptr); break;
default:
if (bdp->bdr_other != NULL)
(*bdp->bdr_other)(m_ptr, ipc_status);
return; /* do not send a reply */
}
/* Let the driver perform any cleanup. */
if (bdp->bdr_cleanup != NULL)
(*bdp->bdr_cleanup)();
trace_finish(id, r);
blockdriver_reply(m_ptr, ipc_status, r);
}
static void big_exec(int fd, uint32_t handle, int ring)
{
struct drm_i915_gem_execbuffer2 execbuf;
struct drm_i915_gem_exec_object2 *gem_exec;
uint32_t ctx_id1, ctx_id2;
int num_buffers = gem_available_aperture_size(fd) / 4096;
int i;
/* Make sure we only fill half of RAM with gem objects. */
igt_require(intel_get_total_ram_mb() * 1024 / 2 > num_buffers * 4);
gem_exec = calloc(num_buffers + 1, sizeof(*gem_exec));
igt_assert(gem_exec);
memset(gem_exec, 0, (num_buffers + 1) * sizeof(*gem_exec));
ctx_id1 = gem_context_create(fd);
ctx_id2 = gem_context_create(fd);
gem_exec[0].handle = handle;
execbuf.buffers_ptr = (uintptr_t)gem_exec;
execbuf.buffer_count = num_buffers + 1;
execbuf.batch_start_offset = 0;
execbuf.batch_len = 8;
execbuf.cliprects_ptr = 0;
execbuf.num_cliprects = 0;
execbuf.DR1 = 0;
execbuf.DR4 = 0;
execbuf.flags = ring;
execbuf.rsvd2 = 0;
execbuf.buffer_count = 1;
i915_execbuffer2_set_context_id(execbuf, ctx_id1);
do_ioctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf);
for (i = 0; i < num_buffers; i++) {
uint32_t tmp_handle = gem_create(fd, 4096);
gem_exec[i].handle = tmp_handle;
}
gem_exec[i].handle = handle;
execbuf.buffer_count = i + 1;
/* figure out how many buffers we can exactly fit */
while (drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2,
&execbuf) != 0) {
i--;
gem_close(fd, gem_exec[i].handle);
gem_exec[i].handle = handle;
execbuf.buffer_count--;
igt_info("trying buffer count %i\n", i - 1);
}
igt_info("reduced buffer count to %i from %i\n",
i - 1, num_buffers);
/* double check that it works */
do_ioctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf);
i915_execbuffer2_set_context_id(execbuf, ctx_id2);
do_ioctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf);
gem_sync(fd, handle);
}