本文整理汇总了C++中eprintk函数的典型用法代码示例。如果您正苦于以下问题:C++ eprintk函数的具体用法?C++ eprintk怎么用?C++ eprintk使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了eprintk函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: osprd_close_last
// This function is called when a /dev/osprdX file is finally closed.
// (If the file descriptor was dup2ed, this function is called only when the
// last copy is closed.)
static int osprd_close_last(struct inode *inode, struct file *filp)
{
if (filp) {
osprd_info_t *d = file2osprd(filp);
int filp_writable = filp->f_mode & FMODE_WRITE;
// EXERCISE: If the user closes a ramdisk file that holds
// a lock, release the lock. Also wake up blocked processes
// as appropriate.
if (filp->f_flags & F_OSPRD_LOCKED) {
if (filp_writable) {
if (d->write_lock == 1) d->write_lock = 0;
else eprintk("file attempted to unlock write lock it didn't have\n");
}
else {
osp_spin_lock(&(d->mutex));
if (d->read_lock > 0) d->read_lock--;
else eprintk("file attempted to unlock read lock it didn't have\n");
osp_spin_unlock(&(d->mutex));
}
}
wake_up_all(&(d->blockq));
}
return 0;
}
示例2: run_hw_break_test
static void run_hw_break_test(int is_write_test)
{
test_complete = 0;
init_simple_test();
if (is_write_test) {
ts.tst = hw_write_break_test;
ts.name = "hw_write_break_test";
} else {
ts.tst = hw_access_break_test;
ts.name = "hw_access_break_test";
}
/* Activate test with initial breakpoint */
kgdb_breakpoint();
hw_break_val_access();
if (is_write_test) {
if (test_complete == 2) {
eprintk("kgdbts: ERROR %s broke on access\n",
ts.name);
hwbreaks_ok = 0;
}
hw_break_val_write();
}
kgdb_breakpoint();
if (test_complete == 1)
return;
eprintk("kgdbts: ERROR %s test failed\n", ts.name);
hwbreaks_ok = 0;
}
示例3: indirect_data
static int indirect_data(struct scsi_cmnd *scmd, struct srp_cmd *cmd,
struct srp_indirect_buf *id,
enum dma_data_direction dir, rdma_io_t rdma_io)
{
struct iu_entry *iue = (struct iu_entry *) scmd->SCp.ptr;
struct srp_target *target = iue->target;
struct srp_direct_buf *md;
struct scatterlist dummy, *sg = scmd->request_buffer;
dma_addr_t token = 0;
long err;
unsigned int done = 0;
int nmd, nsg;
nmd = id->table_desc.len / sizeof(struct srp_direct_buf);
dprintk("%p %u %u %u %u %d %d %d\n",
iue, scmd->request_bufflen, scmd->bufflen,
id->len, scmd->offset, nmd,
cmd->data_in_desc_cnt, cmd->data_out_desc_cnt);
if ((dir == DMA_FROM_DEVICE && nmd == cmd->data_in_desc_cnt) ||
(dir == DMA_TO_DEVICE && nmd == cmd->data_out_desc_cnt)) {
md = &id->desc_list[0];
goto rdma;
}
md = dma_alloc_coherent(target->dev, id->table_desc.len,
&token, GFP_KERNEL);
if (!md) {
eprintk("Can't get dma memory %u\n", id->table_desc.len);
return 0;
}
sg_init_one(&dummy, md, id->table_desc.len);
sg_dma_address(&dummy) = token;
err = rdma_io(iue, &dummy, 1, &id->table_desc, 1, DMA_TO_DEVICE,
id->table_desc.len);
if (err < 0) {
eprintk("Error copying indirect table %ld\n", err);
goto free_mem;
}
rdma:
nsg = dma_map_sg(target->dev, sg, scmd->use_sg, DMA_BIDIRECTIONAL);
if (!nsg) {
eprintk("fail to map %p %d\n", iue, scmd->use_sg);
goto free_mem;
}
err = rdma_io(iue, sg, nsg, md, nmd, dir,
min(scmd->request_bufflen, id->len));
dma_unmap_sg(target->dev, sg, nsg, DMA_BIDIRECTIONAL);
free_mem:
if (token)
dma_free_coherent(target->dev, id->table_desc.len, md, token);
return done;
}
示例4: osprd_process_request
/*
* osprd_process_request(d, req)
* Called when the user reads or writes a sector.
* Should perform the read or write, as appropriate.
*/
static void osprd_process_request(osprd_info_t *d, struct request *req)
{
size_t offset;
size_t num_bytes;
if (!blk_fs_request(req)) {
end_request(req, 0);
return;
}
// EXERCISE: Perform the read or write request by copying data between
// our data array and the request's buffer.
// Hint: The 'struct request' argument tells you what kind of request
// this is, and which sectors are being read or written.
// Read about 'struct request' in <linux/blkdev.h>.
// Consider the 'req->sector', 'req->current_nr_sectors', and
// 'req->buffer' members, and the rq_data_dir() function.
if (req->sector < 0 || req->sector >= nsectors)
{
// sector_t is defined as an unsigned long in <linux/types.h>
eprintk("Invalid sector requested: [%lu]. max sectors: [%i]\n", (unsigned long)req->sector, nsectors);
end_request(req, 0);
}
offset = req->sector * SECTOR_SIZE;
// If the number of requested sectors would reach the end of the disk
// use as many sectors as possible until the end is reached
if(req->sector + req->current_nr_sectors > nsectors)
{
num_bytes = (nsectors - req->sector) * SECTOR_SIZE;
eprintk("Requested sector [%lu] with [%u] additional sectors.\n", (unsigned long)req->sector, req->current_nr_sectors);
eprintk("Using [%u] additional sectors instead.\n", num_bytes / SECTOR_SIZE);
}
else
{
num_bytes = req->current_nr_sectors * SECTOR_SIZE;
}
// According to http://www.makelinux.net/ldd3/chp-16-sect-3
// it is save to dereference req->buffer and write to it.
// Note from @ipetkov: I'm not sure if req->buffer needs to
// be resized at all, I'm assuming linux will allocate the
// memory before the request is sent. No issues are apparent
// from the first 8 default test cases.
spin_lock(&d->mutex);
if(rq_data_dir(req) == READ)
memcpy(req->buffer, d->data + offset, num_bytes);
else // WRITE
memcpy(d->data + offset, req->buffer, num_bytes);
spin_unlock(&d->mutex);
end_request(req, 1);
}
示例5: osprd_process_request
/*
* osprd_process_request(d, req)
* Called when the user reads or writes a sector.
* Should perform the read or write, as appropriate.
*/
static void osprd_process_request(osprd_info_t *d, struct request *req)
{
// Declare variables at the beginning
// Calculate where to starta and the amount of data needed to copy
int data_size = req->current_nr_sectors * SECTOR_SIZE;
int data_offset = req->sector * SECTOR_SIZE;
// Check for a bad request
if (!blk_fs_request(req)) {
end_request(req, 0);
return;
}
// EXERCISE: Perform the read or write request by copying data between
// our data array and the request's buffer.
// Hint: The 'struct request' argument tells you what kind of request
// this is, and which sectors are being read or written.
// Read about 'struct request' in <linux/blkdev.h>.
// Consider the 'req->sector', 'req->current_nr_sectors', and
// 'req->buffer' members, and the rq_data_dir() function.
// Your code here:
// Check to see if we are trying to write to nonexistant sectors
if(req->sector + req->current_nr_sectors > nsectors)
{
eprintk("Trying to write to nonexistant sectors\n");
end_request(req, 0);
}
// Read from the RAMDISK
// Copy the data in the requested sectors into the buffer
if(rq_data_dir(req) == READ)
{
memcpy(req->buffer, d->data + data_offset, data_size);
}
// Write to the RAMDISK
// Copy the data in the buffer into the requested sectors
else if(rq_data_dir(req) == WRITE)
{
memcpy(d->data + data_offset, req->buffer, data_size);
}
// Trying to perform an invalid action
else
{
eprintk("Neither a read nor a write\n");
end_request(req,0);
}
end_request(req, 1);
}
示例6: emul_sstep_put
static int emul_sstep_put(char *put_str, char *arg)
{
if (!arch_needs_sstep_emulation) {
char *ptr = &put_str[11];
if (put_str[1] != 'T' || put_str[2] != '0')
return 1;
kgdb_hex2long(&ptr, &sstep_thread_id);
return 0;
}
switch (sstep_state) {
case 1:
/* validate the "g" packet to get the IP */
kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
NUMREGBYTES);
gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
v2printk("Stopped at IP: %lx\n",
instruction_pointer(&kgdbts_regs));
/* Want to stop at IP + break instruction size by default */
sstep_addr = cont_addr + BREAK_INSTR_SIZE;
break;
case 2:
if (strncmp(put_str, "$OK", 3)) {
eprintk("kgdbts: failed sstep break set\n");
return 1;
}
break;
case 3:
if (strncmp(put_str, "$T0", 3)) {
eprintk("kgdbts: failed continue sstep\n");
return 1;
} else {
char *ptr = &put_str[11];
kgdb_hex2long(&ptr, &sstep_thread_id);
}
break;
case 4:
if (strncmp(put_str, "$OK", 3)) {
eprintk("kgdbts: failed sstep break unset\n");
return 1;
}
/* Single step is complete so continue on! */
sstep_state = 0;
return 0;
default:
eprintk("kgdbts: ERROR failed sstep put emulation\n");
}
/* Continue on the same test line until emulation is complete */
ts.idx--;
return 0;
}
示例7: bd6084gu_get_alc_level
static int bd6084gu_get_alc_level(struct bd6084gu_driver_data *drvdata)
{
u8 level = 0;
if(drvdata->mode == ALC_MODE) {
if(bd6084gu_read(drvdata->client, 0x0C, &level))
eprintk("Error while read register(0x13).\n");
dprintk("alc level: %d\n", level);
}
else {
eprintk("Current mode is not ALC mode\n");
}
return level;
}
示例8: delete_check_deadlock_list
pid_list_t
delete_check_deadlock_list (pid_list_t head,pid_list_t tail, pid_t current_pid)
{
if (current_pid <0)
{
eprintk ("error delete");
return NULL;
}
else
{
pid_list_t curr = head;
while (curr->pid != current_pid)
{
curr = curr->next;
if (curr == NULL)
{
eprintk ("can't find current_pid");
return NULL;
}
}
if (curr == head && curr== tail)
{
head = NULL;
tail = NULL;
kfree(curr);
}
else if (curr == head)
{
head = head->next;
head->prev = NULL;
kfree(curr);
}
else if (curr == tail)
{
tail = tail->prev;
tail->next = NULL;
kfree (curr);
}
else
{
curr->next->prev = curr->prev;
curr->prev->next = curr->next;
kfree(curr);
}
}
return head;
}
示例9: aat28xx_setup_version
/********************************************
* Functions
********************************************/
static int aat28xx_setup_version(struct aat28xx_driver_data *drvdata)
{
if(!drvdata)
return -ENODEV;
if(drvdata->version == 2862) {
drvdata->cmds.normal = aat2862bl_normal_tbl;
drvdata->cmds.alc = aat2862bl_alc_tbl;
drvdata->cmds.sleep = aat2862bl_sleep_tbl;
drvdata->reg_addrs.bl_m = AAT2862BL_REG_BLM;
drvdata->reg_addrs.bl_s = AAT2862BL_REG_BLS;
drvdata->reg_addrs.fade = AAT2862BL_REG_FADE;
drvdata->reg_addrs.ldo_ab = AAT2862BL_REG_LDOAB;
drvdata->reg_addrs.ldo_cd = AAT2862BL_REG_LDOCD;
drvdata->reg_addrs.ldo_en = AAT2862BL_REG_LDOEN;
}
else if(drvdata->version == 2870) {
drvdata->cmds.normal = aat2870bl_normal_tbl;
drvdata->cmds.alc = aat2870bl_alc_tbl;
drvdata->cmds.sleep = aat2870bl_sleep_tbl;
drvdata->reg_addrs.bl_m = AAT2870BL_REG_BLM;
drvdata->reg_addrs.ldo_ab = AAT2870BL_REG_LDOAB;
drvdata->reg_addrs.ldo_cd = AAT2870BL_REG_LDOCD;
drvdata->reg_addrs.ldo_en = AAT2870BL_REG_LDOEN;
}
else {
eprintk("Not supported version!!\n");
return -ENODEV;
}
return 0;
}
示例10: ua_establish_for_session
void ua_establish_for_session(struct iscsi_session *sess, u32 lun,
u8 asc, u8 ascq)
{
struct list_head *l = &sess->ua_hash[ua_hashfn(lun)];
struct ua_entry *ua = kmem_cache_alloc(ua_cache, GFP_KERNEL);
struct ua_entry *e;
if (!ua) {
eprintk("%s", "Failed to alloc ua");
return;
}
ua->asc = asc;
ua->ascq = ascq;
ua->lun = lun;
ua->session = sess;
INIT_LIST_HEAD(&ua->entry);
spin_lock(&sess->ua_hash_lock);
/* One UA per occurrence of an event */
list_for_each_entry(e, l, entry) {
if (e->session == sess && e->lun == lun &&
e->asc == asc && e->ascq == ascq &&
e->session->exp_cmd_sn == sess->exp_cmd_sn) {
spin_unlock(&sess->ua_hash_lock);
ua_free(ua);
return;
}
}
list_add_tail(&ua->entry, l);
spin_unlock(&sess->ua_hash_lock);
dprintk_ua(ua, sess, lun);
}
示例11: lm3530_sleep
static void lm3530_sleep(struct lm3530_driver_data *drvdata)
{
if (!drvdata || drvdata->state == SLEEP_STATE)
return;
dprintk("operation mode is %s\n", (drvdata->mode == NORMAL_MODE) ? "normal_mode" : "alc_mode");
switch (drvdata->mode) {
case NORMAL_MODE:
drvdata->state = SLEEP_STATE;
lm3530_set_table(drvdata, drvdata->cmds.sleep);
break;
case ALC_MODE:
/* LGE_CHANGE
* Remove ALC mode
* 2010-07-26. [email protected]
*/
//drvdata->state = SLEEP_STATE;
//lm3530_set_table(drvdata, drvdata->cmds.sleep);
//udelay(500);
//break;
default:
eprintk("Invalid Mode\n");
break;
}
if (drvdata->client && gpio_is_valid(drvdata->gpio)) {
gpio_tlmm_config(GPIO_CFG(drvdata->gpio, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
bl_config_gpio(0);
udelay(10);
gpio_set_value(drvdata->gpio, 0);
}
}
示例12: check_and_rewind_pc
static int check_and_rewind_pc(char *put_str, char *arg)
{
unsigned long addr = lookup_addr(arg);
int offset = 0;
kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
NUMREGBYTES);
gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
v2printk("Stopped at IP: %lx\n", instruction_pointer(&kgdbts_regs));
#ifdef CONFIG_X86
/* On x86 a breakpoint stop requires it to be decremented */
if (addr + 1 == kgdbts_regs.ip)
offset = -1;
#endif
if (strcmp(arg, "silent") &&
instruction_pointer(&kgdbts_regs) + offset != addr) {
eprintk("kgdbts: BP mismatch %lx expected %lx\n",
instruction_pointer(&kgdbts_regs) + offset, addr);
return 1;
}
#ifdef CONFIG_X86
/* On x86 adjust the instruction pointer if needed */
kgdbts_regs.ip += offset;
#endif
return 0;
}
示例13: osprd_process_request
/*
* osprd_process_request(d, req)
* Called when the user reads or writes a sector.
* Should perform the read or write, as appropriate.
*/
static void osprd_process_request(osprd_info_t *d, struct request *req)
{
void *data_offset;
unsigned int data_length;
if (!blk_fs_request(req)) {
end_request(req, 0);
return;
}
// EXERCISE: Perform the read or write request by copying data between
// our data array and the request's buffer.
// Hint: The 'struct request' argument tells you what kind of request
// this is, and which sectors are being read or written.
// Read about 'struct request' in <linux/blkdev.h>.
// Consider the 'req->sector', 'req->current_nr_sectors', and
// 'req->buffer' members, and the rq_data_dir() function.
data_offset = d->data + (SECTOR_SIZE * req->sector);
data_length = req->current_nr_sectors * SECTOR_SIZE;
// TODO: include a test for out-of-range read/writes
if (rq_data_dir(req) == WRITE)
memcpy(data_offset, req->buffer, data_length);
else if (rq_data_dir(req) == READ)
memcpy(req->buffer, data_offset, data_length);
else {
eprintk("Unrecognized command.\n");
end_request(req, 0);
}
end_request(req, 1);
}
示例14: bd6084gu_set_table
static int bd6084gu_set_table(struct bd6084gu_driver_data *drvdata, struct bd6084gu_ctrl_tbl *ptbl)
{
unsigned int i = 0;
if (ptbl == NULL) {
eprintk("input ptr is null\n");
return -EIO;
}
for( ;;) {
if (ptbl->reg == 0xFF) {
if (ptbl->val != 0xfe)
udelay(ptbl->val);
else
break;
}
else {
if(bd6084gu_write(drvdata->client, ptbl->reg, ptbl->val) != 0)
dprintk("i2c failed addr:%d, value:%d\n", ptbl->reg, ptbl->val);
}
ptbl++;
i++;
}
return 0;
}
示例15: aat28xx_sleep
static void aat28xx_sleep(struct aat28xx_driver_data *drvdata)
{
if (!drvdata || drvdata->state == SLEEP_STATE)
return;
dprintk("operation mode is %s\n", (drvdata->mode == NORMAL_MODE) ? "normal_mode" : "alc_mode");
switch (drvdata->mode) {
case NORMAL_MODE:
drvdata->state = SLEEP_STATE;
aat28xx_set_table(drvdata, drvdata->cmds.sleep);
break;
case ALC_MODE:
/*
*/
//drvdata->state = SLEEP_STATE;
//aat28xx_set_table(drvdata, drvdata->cmds.sleep);
//udelay(500);
//break;
default:
eprintk("Invalid Mode\n");
break;
}
}