type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
includes | #include <linux/stat.h> |
includes | #include <linux/string.h> |
includes | #include <linux/inet.h> |
includes | #include <linux/list.h> |
includes | #include <linux/pagemap.h> |
includes | #include <linux/utsname.h> |
includes | #include <asm/uaccess.h> |
includes | #include <linux/idr.h> |
includes | #include <linux/uio.h> |
includes | #include <linux/slab.h> |
includes | #include <net/9p/9p.h> |
includes | #include <net/9p/client.h> |
functions | int v9fs_file_open(struct inode *inode, struct file *file)
{
int err;
struct v9fs_inode *v9inode;
struct v9fs_session_info *v9ses;
struct p9_fid *fid;
int omode;
p9_debug(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file);
v9inode = V9FS_I(inode);
v9ses = v9fs_inode2v9ses(inode);
if (v9fs_proto_dotl(v9ses))
... |
functions | int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
{
int res = 0;
struct inode *inode = file_inode(filp);
p9_debug(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
/* No mandatory locks */
if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
return -ENOLCK;
if ((IS_SETLK(cmd) || IS_SETLKW(... |
functions | int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl)
{
struct p9_flock flock;
struct p9_fid *fid;
uint8_t status;
int res = 0;
unsigned char fl_type;
fid = filp->private_data;
BUG_ON(fid == NULL);
if ((fl->fl_flags & FL_POSIX) != FL_POSIX)
BUG();
res = posix_lock_file_wait(filp, fl);
i... |
functions | int v9fs_file_getlock(struct file *filp, struct file_lock *fl)
{
struct p9_getlock glock;
struct p9_fid *fid;
int res = 0;
fid = filp->private_data;
BUG_ON(fid == NULL);
posix_test_lock(filp, fl);
/*
* if we have a conflicting lock locally, no need to validate
* with server
*/
if (fl->fl_type != F_UNLCK... |
functions | int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl)
{
struct inode *inode = file_inode(filp);
int ret = -ENOLCK;
p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n",
filp, cmd, fl, filp);
/* No mandatory locks */
if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
goto out... |
functions | int v9fs_file_flock_dotl(struct file *filp, int cmd,
struct file_lock *fl)
{
struct inode *inode = file_inode(filp);
int ret = -ENOLCK;
p9_debug(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %pD\n",
filp, cmd, fl, filp);
/* No mandatory locks */
if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
goto o... |
functions | ssize_t
v9fs_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
struct p9_fid *fid = iocb->ki_filp->private_data;
int ret, err;
p9_debug(P9_DEBUG_VFS, "count %zu offset %lld\n",
iov_iter_count(to), iocb->ki_pos);
ret = p9_client_read(fid, iocb->ki_pos, to, &err);
if (!ret)
return err;
iocb->ki_pos ... |
functions | ssize_t
v9fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
struct file *file = iocb->ki_filp;
ssize_t retval;
loff_t origin;
int err = 0;
retval = generic_write_checks(iocb, from);
if (retval <= 0)
return retval;
origin = iocb->ki_pos;
retval = p9_client_write(file->private_data, iocb->ki_pos... |
functions | int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end,
int datasync)
{
struct p9_fid *fid;
struct inode *inode = filp->f_mapping->host;
struct p9_wstat wstat;
int retval;
retval = filemap_write_and_wait_range(inode->i_mapping, start, end);
if (retval)
return retval;
mutex_lock(&inode->i_mutex... |
functions | int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end,
int datasync)
{
struct p9_fid *fid;
struct inode *inode = filp->f_mapping->host;
int retval;
retval = filemap_write_and_wait_range(inode->i_mapping, start, end);
if (retval)
return retval;
mutex_lock(&inode->i_mutex);
p9_debug(P9_DEBUG... |
functions | int
v9fs_file_mmap(struct file *filp, struct vm_area_struct *vma)
{
int retval;
retval = generic_file_mmap(filp, vma);
if (!retval)
vma->vm_ops = &v9fs_file_vm_ops;
return retval;
} |
functions | int
v9fs_mmap_file_mmap(struct file *filp, struct vm_area_struct *vma)
{
int retval;
struct inode *inode;
struct v9fs_inode *v9inode;
struct p9_fid *fid;
inode = file_inode(filp);
v9inode = V9FS_I(inode);
mutex_lock(&v9inode->v_mutex);
if (!v9inode->writeback_fid &&
(vma->vm_flags & VM_WRITE)) {
/*
*... |
functions | int
v9fs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
{
struct v9fs_inode *v9inode;
struct page *page = vmf->page;
struct file *filp = vma->vm_file;
struct inode *inode = file_inode(filp);
p9_debug(P9_DEBUG_VFS, "page %p fid %lx\n",
page, (unsigned long)filp->private_data);
/* Update fi... |
functions | ssize_t
v9fs_mmap_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
/* TODO: Check if there are dirty pages */
return v9fs_file_read_iter(iocb, to);
} |
functions | ssize_t
v9fs_mmap_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
/*
* TODO: invalidate mmaps on filp's inode between
* offset and offset+count
*/
return v9fs_file_write_iter(iocb, from);
} |
functions | void v9fs_mmap_vm_close(struct vm_area_struct *vma)
{
struct inode *inode;
struct writeback_control wbc = {
.nr_to_write = LONG_MAX,
.sync_mode = WB_SYNC_ALL,
.range_start = vma->vm_pgoff * PAGE_SIZE,
/* absolute end, byte at end included */
.range_end = vma->vm_pgoff * PAGE_SIZE +
(vma->vm_end - vma->... |
defines |
#define DEBUG_CHAR
|
defines |
#define SPRITE_GLOBAL_X 0
|
defines | #define SPRITE_GLOBAL_Y 1
|
defines | #define SUBLIST_OFFSET 2
|
defines | #define SUBLIST_LENGTH 3
|
defines |
#define SUBLIST_OFFSET_SHIFT 3
|
defines | #define SPRITE_LIST_END_MARKER 0x8000
|
defines |
#define SPRITE_TILE 0
|
defines | #define SPRITE_PALETTE 1
|
defines | #define SPRITE_LOCAL_X 2
|
defines | #define SPRITE_LOCAL_Y 3
|
defines | #define SPRITE_SIZE 4
|
defines |
#define SPRITE_SUBLIST_ENTRY_LENGTH 8
|
defines | #define SPRITE_LIST_ENTRY_LENGTH 4
|
defines |
#define SPRITE_DATA_GRANULARITY 0x80
|
functions | static SCREEN_UPDATE( srmp5 )
{
srmp5_state *state = screen->machine().driver_data<srmp5_state>();
int x,y,address,xs,xs2,ys,ys2,height,width,xw,yw,xb,yb,sizex,sizey;
UINT16 *sprite_list=state->m_sprram;
UINT16 *sprite_list_end=&state->m_sprram[0x4000]; //guess
UINT8 *pixels=(UINT8 *)state->m_tileram;
cons... |
functions | static READ32_HANDLER(srmp5_palette_r)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
return state->m_palram[offset];
} |
functions | static WRITE32_HANDLER(srmp5_palette_w)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
COMBINE_DATA(&state->m_palram[offset]);
palette_set_color(space->machine(), offset, MAKE_RGB(data << 3 & 0xFF, data >> 2 & 0xFF, data >> 7 & 0xFF));
} |
functions | static WRITE32_HANDLER(bank_w)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
COMBINE_DATA(&state->m_databank);
} |
functions | static READ32_HANDLER(tileram_r)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
return state->m_tileram[offset];
} |
functions | static WRITE32_HANDLER(tileram_w)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
state->m_tileram[offset] = data & 0xFFFF; //lower 16bit only
#ifdef DEBUG_CHAR
state->m_tileduty[offset >> 6] = 1;
#endif
} |
functions | static READ32_HANDLER(spr_r)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
return state->m_sprram[offset];
} |
functions | static WRITE32_HANDLER(spr_w)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
state->m_sprram[offset] = data & 0xFFFF; //lower 16bit only
} |
functions | static READ32_HANDLER(data_r)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
UINT32 data;
const UINT8 *usr = space->machine().region("user2")->base();
data=((state->m_databank>>4)&0xf)*0x100000; //guess
data=usr[data+offset*2]+usr[data+offset*2+1]*256;
return data|(data<<16);
} |
functions | static WRITE32_HANDLER(input_select_w)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
state->m_input_select = data & 0x0F;
} |
functions | static READ32_HANDLER(srmp5_inputs_r)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
UINT32 ret = 0;
switch (state->m_input_select)
{
case 0x01:
ret = input_port_read(space->machine(), "IN0");
break;
case 0x02:
ret = input_port_read(space->machine(), "IN1");
break;
case... |
functions | static WRITE32_HANDLER(cmd1_w)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
state->m_cmd1 = data & 0xFF;
logerror("cmd1_w %08X\n", data);
} |
functions | static WRITE32_HANDLER(cmd2_w)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
state->m_cmd2 = data & 0xFF;
state->m_cmd_stat = 5;
logerror("cmd2_w %08X\n", data);
} |
functions | static READ32_HANDLER(cmd_stat32_r)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
return state->m_cmd_stat;
} |
functions | static READ32_HANDLER(srmp5_vidregs_r)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
logerror("vidregs read %08X %08X\n", offset << 2, state->m_vidregs[offset]);
return state->m_vidregs[offset];
} |
functions | static WRITE32_HANDLER(srmp5_vidregs_w)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
COMBINE_DATA(&state->m_vidregs[offset]);
if(offset != 0x10C / 4)
logerror("vidregs write %08X %08X\n", offset << 2, state->m_vidregs[offset]);
} |
functions | static READ32_HANDLER(irq_ack_clear)
{
cputag_set_input_line(space->machine(), "sub", R3000_IRQ4, CLEAR_LINE);
return 0;
} |
functions | static READ8_HANDLER(cmd1_r)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
state->m_cmd_stat = 0;
return state->m_cmd1;
} |
functions | static READ8_HANDLER(cmd2_r)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
return state->m_cmd2;
} |
functions | static READ8_HANDLER(cmd_stat8_r)
{
srmp5_state *state = space->machine().driver_data<srmp5_state>();
return state->m_cmd_stat;
} |
functions | static DRIVER_INIT(srmp5)
{
srmp5_state *state = machine.driver_data<srmp5_state>();
st0016_game = 9;
state->m_tileram = auto_alloc_array(machine, UINT16, 0x100000/2);
state->m_sprram = auto_alloc_array(machine, UINT16, 0x080000/2);
state->m_palram = auto_alloc_array(machine, UINT16, 0x040000/2);
#ifdef... |
includes | #include <linux/stat.h> |
includes | #include <linux/sysctl.h> |
includes | #include <linux/sunrpc/debug.h> |
includes | #include <linux/string.h> |
includes | #include <net/ip_vs.h> |
functions | int sysctl_depth(struct ctl_table *table)
{
struct ctl_table *tmp;
int depth;
depth = 0;
for (tmp = table; tmp->parent; tmp = tmp->parent)
depth++;
return depth;
} |
functions | void sysctl_print_path(struct ctl_table *table)
{
struct ctl_table *tmp;
int depth, i;
depth = sysctl_depth(table);
if (table->procname) {
for (i = depth; i >= 0; i--) {
tmp = sysctl_parent(table, i);
printk("/%s", tmp->procname?tmp->procname:"");
} |
functions | void set_fail(const char **fail, struct ctl_table *table, const char *str)
{
if (*fail) {
printk(KERN_ERR "sysctl table check failed: ");
sysctl_print_path(table);
printk(" %s\n", *fail);
dump_stack();
} |
functions | void sysctl_check_leaf(struct nsproxy *namespaces,
struct ctl_table *table, const char **fail)
{
struct ctl_table *ref;
ref = sysctl_check_lookup(namespaces, table);
if (ref && (ref != table))
set_fail(fail, table, "Sysctl already exists");
} |
functions | int sysctl_check_table(struct nsproxy *namespaces, struct ctl_table *table)
{
int error = 0;
for (; table->procname; table++) {
const char *fail = NULL;
if (table->parent) {
if (!table->parent->procname)
set_fail(&fail, table, "Parent without procname");
} |
includes |
#include <stdio.h> |
includes | #include <stdlib.h> |
includes | #include <string.h> |
includes | #include <unistd.h> |
includes | #include <fcntl.h> |
includes | #include <signal.h> |
includes | #include <ctype.h> |
includes | #include <assert.h> |
includes | #include <sys/time.h> |
defines |
#define CHECK_COLOR_NAME(value, name, DEFNAME) \ |
functions | void
init_windows()
{
top = newwin(LIST_TOP - 1, COLS, 0, 0);
bottom = newwin(LINES - LIST_BOTTOM, COLS, LIST_BOTTOM, 0);
} |
functions | void
free_windows()
{
delwin(top);
delwin(bottom);
} |
functions | void
resize_abook()
{
#ifdef TIOCGWINSZ
struct winsize winsz;
ioctl(0, TIOCGWINSZ, &winsz);
#ifdef DEBUG
if(winsz.ws_col >= MIN_COLS && winsz.ws_row >= MIN_LINES) {
fprintf(stderr, "Warning: COLS=%d, LINES=%d\n", winsz.ws_col, winsz.ws_row);
} |
functions | endif
if(winsz.ws_col >= MIN_COLS && winsz.ws_row >= MIN_LINES) {
#ifdef HAVE_RESIZETERM
resizeterm(winsz.ws_row, winsz.ws_col);
#else
COLS = winsz.ws_col;
LINES = winsz.ws_row;
#endif
} |
functions | void
win_changed(int i)
{
if(can_resize)
resize_abook();
else
should_resize = TRUE;
} |
functions | int
is_ui_initialized()
{
return ui_initialized;
} |
functions | void
ui_init_curses()
{
if(!is_ui_initialized())
initscr();
cbreak();
noecho();
nonl();
intrflush(stdscr, FALSE);
if(opt_get_bool(BOOL_USE_MOUSE)) {
mouseinterval(0);
timerclear(&last_click_time);
ui_enable_mouse(TRUE);
} |
functions | void
ui_enable_mouse(bool enabled)
{
mmask_t mask;
if(enabled) {
mask = BUTTON1_CLICKED | BUTTON4_PRESSED;
#if NCURSES_MOUSE_VERSION == 2
mask |= BUTTON5_PRESSED;
#endif
} |
functions | bool
was_double_click() {
struct timeval click_time, click_diff, maxdiff;
maxdiff.tv_sec = double_click_interval / 1000;
maxdiff.tv_usec = (double_click_interval % 1000)*1000;
gettimeofday(&click_time, NULL);
timersub(&click_time, &last_click_time, &click_diff);
last_click_time = click_time;
return !timercmp(&c... |
functions | short
opt_color_to_color(enum str_opts enum_name)
{
char* name = opt_get_str(enum_name);
CHECK_COLOR_NAME(name, "default", COLOR_DEFAULT)
else CHECK_COLOR_NAME(name, "black", COLOR_BLACK)
else CHECK_COLOR_NAME(name, "red", COLOR_RED)
else CHECK_COLOR_NAME(name, "green", COLOR_GREEN)
else CHECK_COLOR_NAME(name, "y... |
functions | void
ui_init_color_pairs_user()
{
init_pair(CP_HEADER, opt_color_to_color(STR_COLOR_HEADER_FG),
opt_color_to_color(STR_COLOR_HEADER_BG));
init_pair(CP_FOOTER, opt_color_to_color(STR_COLOR_FOOTER_FG),
opt_color_to_color(STR_COLOR_FOOTER_BG));
init_pair(CP_LIST_EVEN, opt_col... |
functions | int
init_ui()
{
ui_init_curses();
#ifdef DEBUG
fprintf(stderr, "init_abook():\n");
fprintf(stderr, " COLS = %d, LINES = %d\n", COLS, LINES);
#endif
if( LINES < MIN_LINES || COLS < MIN_COLS ) {
clear(); refresh(); endwin();
fprintf(stderr, _("Your terminal size is %dx%d\n"), COLS, LINES);
fprint... |
functions | void
close_ui()
{
close_list();
free_windows();
clear();
refresh();
endwin();
ui_initialized = FALSE;
} |
functions | void
headerline(const char *str)
{
werase(top);
wattrset(top, COLOR_PAIR(CP_HEADER));
mvwhline(top, 0, 0, ' ', COLS);
mvwhline(top, 1, 0, UI_HLINE_CHAR, COLS);
mvwprintw(top, 0, 0, "%s | %s", PACKAGE " " VERSION, str);
refresh();
wrefresh(top);
} |
functions | void
refresh_screen()
{
#ifdef SIGWINCH
if(should_resize) {
resize_abook();
return;
} |
functions | int
statusline_msg(const char *msg)
{
int c;
clear_statusline();
statusline_addstr(msg);
c = getch();
#ifdef DEBUG
fprintf(stderr, "statusline_msg(\"%s\")\n", msg);
#endif
clear_statusline();
return c;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.