static void list_test(void)
{
int i ;
struct data *node,*next;
LIST_HEAD(lhead);
for(i = 0; i < MAX_LIST; i++)
{
struct data *pdata;
pdata = kmalloc(sizeof(struct data),GFP_KERNEL);
pdata->i = i;
if(!pdata)
goto clean;
list_add(&pdata->list,&lhead);
}
list_for_each_entry(node,&lhead,list)
printk("list entry:%d\n",node->i);
clean:
list_for_each_entry_safe(node,next,&lhead,list)
kfree(node);
}
/* Test if realserver is marked UP for a specific checker */
int
svr_checker_up(checker_id_t cid, real_server_t *rs)
{
element e;
list l = rs->failed_checkers;
checker_id_t *id;
/*
* We assume there is not too much checker per
* real server, so we consider this lookup as
* o(1).
*/
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
id = ELEMENT_DATA(e);
if (*id == cid)
return 0;
}
return 1;
}
static void __linkwatch_run_queue(int urgent_only)
{
struct net_device *dev;
LIST_HEAD(wrk);
/*
*/
if (!urgent_only)
linkwatch_nextevent = jiffies + HZ;
/* */
else if (time_after(linkwatch_nextevent, jiffies + HZ))
linkwatch_nextevent = jiffies;
clear_bit(LW_URGENT, &linkwatch_flags);
spin_lock_irq(&lweventlist_lock);
list_splice_init(&lweventlist, &wrk);
while (!list_empty(&wrk)) {
dev = list_first_entry(&wrk, struct net_device, link_watch_list);
list_del_init(&dev->link_watch_list);
if (urgent_only && !linkwatch_urgent_event(dev)) {
list_add_tail(&dev->link_watch_list, &lweventlist);
continue;
}
spin_unlock_irq(&lweventlist_lock);
linkwatch_do_dev(dev);
spin_lock_irq(&lweventlist_lock);
}
if (!list_empty(&lweventlist))
linkwatch_schedule_work(0);
spin_unlock_irq(&lweventlist_lock);
}
/**
* 获得远程返回的结果，
*/
int distdb_fetch_result_remote(struct DISTDB_SQL_RESULT * reslt,
char ** table[], int ifpeek)
{
int i;
struct sql_result_plain_text * ptext;
pthread_mutex_lock(&reslt->lock);
if (LIST_ISEMPTY(reslt->sql_result))
{
if (reslt->ref && !ifpeek) //还有结果会陆续进来，呵呵
{
pthread_cond_wait(&reslt->waitcond, &reslt->lock);
}
else if (reslt->ref && ifpeek)
{
pthread_mutex_unlock(&reslt->lock);
return 1;
}
else if( reslt->ref ==0)
{
pthread_mutex_unlock(&reslt->lock);
return -1;
}
}
if (reslt->ref == 0)
return -1;
if (reslt->last)
free(reslt->last);
ptext = LIST_HEAD(reslt->sql_result.head,sql_result_plain_text,resultlist);
LIST_DELETE_AT(&ptext->resultlist);
reslt->last = ptext;
for (i = 0; i < reslt->colums; ++i)
{
reslt ->last_table[i] = ptext->plaindata + ptext->strings[i].offset;
}
pthread_mutex_unlock(&reslt->lock);
return 0;
}
void
vrrp_print_stats(void)
{
FILE *file;
file = fopen ("/tmp/keepalived.stats","w");
list l = vrrp_data->vrrp;
element e;
vrrp_t *vrrp;
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vrrp = ELEMENT_DATA(e);
fprintf(file, "VRRP Instance: %s\n", vrrp->iname);
fprintf(file, " Advertisements:\n");
fprintf(file, " Received: %d\n", vrrp->stats->advert_rcvd);
fprintf(file, " Sent: %d\n", vrrp->stats->advert_sent);
fprintf(file, " Became master: %d\n", vrrp->stats->become_master);
fprintf(file, " Released master: %d\n",
vrrp->stats->release_master);
fprintf(file, " Packet Errors:\n");
fprintf(file, " Length: %d\n", vrrp->stats->packet_len_err);
fprintf(file, " TTL: %d\n", vrrp->stats->ip_ttl_err);
fprintf(file, " Invalid Type: %d\n",
vrrp->stats->invalid_type_rcvd);
fprintf(file, " Advertisement Interval: %d\n",
vrrp->stats->advert_interval_err);
fprintf(file, " Address List: %d\n",
vrrp->stats->addr_list_err);
fprintf(file, " Authentication Errors:\n");
fprintf(file, " Invalid Type: %d\n",
vrrp->stats->invalid_authtype);
fprintf(file, " Type Mismatch: %d\n",
vrrp->stats->authtype_mismatch);
fprintf(file, " Failure: %d\n",
vrrp->stats->auth_failure);
fprintf(file, " Priority Zero:\n");
fprintf(file, " Received: %d\n", vrrp->stats->pri_zero_rcvd);
fprintf(file, " Sent: %d\n", vrrp->stats->pri_zero_sent);
}
fclose(file);
}
static int __init print_processes_backwards(void)
{
LIST_HEAD(data_stack);
int result = 0; // OK
stack_entry_t *task_entry = NULL;
struct task_struct *task = NULL;
char *task_name = NULL;
for_each_process (task) {
task_name = kmalloc(TASK_COMM_LEN, GFP_KERNEL);
if (task_name) {
task_entry = create_stack_entry(task_name);
if (task_entry) {
task_name = get_task_comm(task_name, task);
stack_push(&data_stack, task_entry);
} else {
kfree(task_name);
result = -ENOMEM;
break;
}
} else {
result = -ENOMEM;
break;
}
}
while (!stack_empty(&data_stack)) {
task_entry = stack_pop(&data_stack);
task_name = STACK_ENTRY_DATA(task_entry, char*);
delete_stack_entry(task_entry);
if (result != -ENOMEM) {
printk(KERN_ALERT "task name = %s\n", task_name);
}
kfree(task_name);
}
return result;
}
static void
nfs_flushd(struct rpc_task *task)
{
struct nfs_server *server;
struct nfs_reqlist *cache;
LIST_HEAD(head);
dprintk("NFS: %4d flushd starting\n", task->tk_pid);
server = (struct nfs_server *) task->tk_calldata;
cache = server->rw_requests;
for(;;) {
spin_lock(&nfs_wreq_lock);
if (nfs_scan_lru_dirty_timeout(server, &head)) {
spin_unlock(&nfs_wreq_lock);
nfs_flush_list(&head, server->wpages, FLUSH_AGING);
continue;
}
if (nfs_scan_lru_read_timeout(server, &head)) {
spin_unlock(&nfs_wreq_lock);
nfs_pagein_list(&head, server->rpages);
continue;
}
#ifdef CONFIG_NFS_V3
if (nfs_scan_lru_commit_timeout(server, &head)) {
spin_unlock(&nfs_wreq_lock);
nfs_commit_list(&head, FLUSH_AGING);
continue;
}
#endif
spin_unlock(&nfs_wreq_lock);
break;
}
dprintk("NFS: %4d flushd back to sleep\n", task->tk_pid);
if (task->tk_action) {
task->tk_timeout = NFS_FLUSHD_TIMEOUT;
cache->runat = jiffies + task->tk_timeout;
rpc_sleep_on(&flushd_queue, task, NULL, NULL);
}
}
/*
* Initialization. Try all known PCI access methods. Note that we support
* using both PCI BIOS and direct access: in such cases, we use I/O ports
* to access config space, but we still keep BIOS order of cards to be
* compatible with 2.0.X. This should go away some day.
*/
static int __init pcibios_init(void)
{
resource_size_t io_offset, mem_offset;
LIST_HEAD(resources);
struct pci_bus *bus;
ioport_resource.start = 0xA0000000;
ioport_resource.end = 0xDFFFFFFF;
iomem_resource.start = 0xA0000000;
iomem_resource.end = 0xDFFFFFFF;
if (insert_resource(&iomem_resource, &pci_iomem_resource) < 0)
panic("Unable to insert PCI IOMEM resource\n");
if (insert_resource(&ioport_resource, &pci_ioport_resource) < 0)
panic("Unable to insert PCI IOPORT resource\n");
if (!pci_probe)
return 0;
if (pci_check_direct() < 0) {
printk(KERN_WARNING "PCI: No PCI bus detected\n");
return 0;
}
printk(KERN_INFO "PCI: Probing PCI hardware [mempage %08x]\n",
MEM_PAGING_REG);
io_offset = pci_ioport_resource.start -
(pci_ioport_resource.start & 0x00ffffff);
mem_offset = pci_iomem_resource.start -
((pci_iomem_resource.start & 0x03ffffff) | MEM_PAGING_REG);
pci_add_resource_offset(&resources, &pci_ioport_resource, io_offset);
pci_add_resource_offset(&resources, &pci_iomem_resource, mem_offset);
bus = pci_scan_root_bus(NULL, 0, &pci_direct_ampci, NULL, &resources);
if (!bus)
return 0;
pcibios_resource_survey();
pci_bus_add_devices(bus);
return 0;
}
static void __linkwatch_run_queue(int urgent_only)
{
struct net_device *dev;
LIST_HEAD(wrk);
/*
* Limit the number of linkwatch events to one
* per second so that a runaway driver does not
* cause a storm of messages on the netlink
* socket. This limit does not apply to up events
* while the device qdisc is down.
*/
if (!urgent_only)
linkwatch_nextevent = jiffies + HZ;
/* Limit wrap-around effect on delay. */
else if (time_after(linkwatch_nextevent, jiffies + HZ))
linkwatch_nextevent = jiffies;
clear_bit(LW_URGENT, &linkwatch_flags);
spin_lock_irq(&lweventlist_lock);
list_splice_init(&lweventlist, &wrk);
while (!list_empty(&wrk)) {
dev = list_first_entry(&wrk, struct net_device, link_watch_list);
list_del_init(&dev->link_watch_list);
if (urgent_only && !linkwatch_urgent_event(dev)) {
list_add_tail(&dev->link_watch_list, &lweventlist);
continue;
}
spin_unlock_irq(&lweventlist_lock);
linkwatch_do_dev(dev);
spin_lock_irq(&lweventlist_lock);
}
if (!list_empty(&lweventlist))
linkwatch_schedule_work(0);
spin_unlock_irq(&lweventlist_lock);
}
static int expand_single_string(struct token *tok, struct token *next,
struct string **string_ret)
{
int ret;
LIST_HEAD(string_list);
ret = expand_params_and_word_split(tok, next, &string_list);
if (ret)
goto out_free_string_list;
ret = glue_strings(&string_list);
if (ret)
goto out_free_string_list;
if (!mysh_filename_expansion_disabled) {
ret = do_filename_expansion(&string_list);
if (ret)
goto out_free_string_list;
}
if (list_empty(&string_list))
*string_ret = NULL;
else if (list_is_singular(&string_list))
*string_ret = list_entry(string_list.next, struct string, list);
else {
int main()
{
LIST_HEAD(list);
append_node(&list);
append_node(&list);
struct node *pos;
list_for_each_entry(pos, &list, embedded_head)
___sl_plot(NULL);
___sl_plot(NULL);
// insane -- better to use list_for_each_entry_safe()
while (&list != list.prev) {
list.next = list.prev->prev;
free(list_entry(list.prev, struct node, embedded_head));
list.prev = list.next;
}
return 0;
}
static int
vrrp_timer_vrid_timeout(const int fd)
{
vrrp_rt *vrrp;
element e;
list l = &vrrp_data->vrrp_index_fd[fd%1024 + 1];
TIMEVAL timer;
int vrid = 0;
/* Multiple instances on the same interface */
TIMER_RESET(timer);
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vrrp = ELEMENT_DATA(e);
if (timer_cmp(vrrp->sands, timer) < 0 ||
TIMER_ISNULL(timer)) {
timer = timer_dup(vrrp->sands);
vrid = vrrp->vrid;
}
}
return vrid;
}
static void take_over_work(struct ehca_comp_pool *pool, int cpu)
{
struct ehca_cpu_comp_task *cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
LIST_HEAD(list);
struct ehca_cq *cq;
unsigned long flags_cct;
spin_lock_irqsave(&cct->task_lock, flags_cct);
list_splice_init(&cct->cq_list, &list);
while (!list_empty(&list)) {
cq = list_entry(cct->cq_list.next, struct ehca_cq, entry);
list_del(&cq->entry);
__queue_comp_task(cq, this_cpu_ptr(pool->cpu_comp_tasks));
}
spin_unlock_irqrestore(&cct->task_lock, flags_cct);
}
static void draw_battle_target(
BATTLE *battle,
BATTLE_ACTOR *ba
)
{
int x, y;
STEP_POINT *p;
for (p = (STEP_POINT *) LIST_HEAD(&ba->targetList);
p != NULL;
p = (STEP_POINT *) LIST_NEXT(&p->listNode)) {
x = p->i * BMARKER_WIDTH - battle->world->x;
y = p->j * BMARKER_HEIGHT - battle->world->y;
draw_sprite(x, y,
TARGET_MARKER, battle->bmarker,
0, 0, window_width, window_height);
}
}
static void
rpc_timeout_upcall_queue(struct work_struct *work)
{
LIST_HEAD(free_list);
struct rpc_pipe *pipe =
container_of(work, struct rpc_pipe, queue_timeout.work);
void (*destroy_msg)(struct rpc_pipe_msg *);
struct dentry *dentry;
spin_lock(&pipe->lock);
destroy_msg = pipe->ops->destroy_msg;
if (pipe->nreaders == 0) {
list_splice_init(&pipe->pipe, &free_list);
pipe->pipelen = 0;
}
dentry = dget(pipe->dentry);
spin_unlock(&pipe->lock);
rpc_purge_list(dentry ? &RPC_I(dentry->d_inode)->waitq : NULL,
&free_list, destroy_msg, -ETIMEDOUT);
dput(dentry);
}
void kmem_cache_reap(struct kmem_cache *cache)
{
LIST_HEAD(list);
const bool enabled = spin_lock_irqsave(&cache->lock);
list_splice(&cache->free_list, &list);
spin_unlock_irqrestore(&cache->lock, enabled);
for (struct list_head *ptr = list.next; ptr != &list;) {
struct kmem_slab *slab =
LIST_ENTRY(ptr, struct kmem_slab, link);
struct page *pages = slab->pages;
ptr = ptr->next;
if (cache->ops->destroy)
cache->ops->destroy(cache, slab);
free_pages(pages, cache->order);
}
}
/*
* General routine to allocate a hash table.
*/
void *
hashinit(int elements, int type, u_long *hashmask)
{
long hashsize;
LIST_HEAD(generic, generic) *hashtbl;
int i;
if (elements <= 0)
panic("hashinit: bad cnt");
for (hashsize = 1; hashsize <= elements; hashsize <<= 1)
continue;
hashsize >>= 1;
MALLOC(hashtbl, struct generic *,
(u_long)hashsize * sizeof(*hashtbl), type, M_WAITOK|M_ZERO);
if (hashtbl != NULL) {
for (i = 0; i < hashsize; i++)
LIST_INIT(&hashtbl[i]);
*hashmask = hashsize - 1;
}
return (hashtbl);
}
int main()
{
// NOTE: two nodes should be enough to trigger DLS abstraction by default
// and consequently the spurious memory leak in the end
LIST_HEAD(list);
append_node(&list);
append_node(&list);
// plot heap in each iteration
struct node *pos;
list_for_each_entry(pos, &list, embedded_head)
___sl_plot(NULL);
// plot heap after list_for_each_entry() -- an off-value should be there
___sl_plot(NULL);
// use list_entry()
free(list_entry(list.next, struct node, embedded_head));
free(list_entry(list.prev, struct node, embedded_head));
return 0;
}
/*
* General routine to allocate a prime number sized hash table.
*/
void *
phashinit(int elements, struct malloc_type *type, u_long *nentries)
{
long hashsize;
LIST_HEAD(generic, generic) *hashtbl;
int i;
KASSERT(elements > 0, ("%s: bad elements", __func__));
for (i = 1, hashsize = primes[1]; hashsize <= elements;) {
i++;
if (i == NPRIMES)
break;
hashsize = primes[i];
}
hashsize = primes[i - 1];
hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, M_WAITOK);
for (i = 0; i < hashsize; i++)
LIST_INIT(&hashtbl[i]);
*nentries = hashsize;
return (hashtbl);
}
/* Add/Delete a list of IP routes */
void
netlink_rtlist(list rt_list, int cmd)
{
ip_route_t *iproute;
element e;
/* No routes to add */
if (LIST_ISEMPTY(rt_list))
return;
for (e = LIST_HEAD(rt_list); e; ELEMENT_NEXT(e)) {
iproute = ELEMENT_DATA(e);
if ((cmd == IPROUTE_ADD && !iproute->set) ||
(cmd == IPROUTE_DEL && iproute->set)) {
if (netlink_route(iproute, cmd) > 0)
iproute->set = (cmd == IPROUTE_ADD);
else
iproute->set = false;
}
}
}
/* All interface are UP in the same group */
int
vrrp_sync_group_up(vrrp_sgroup * vgroup)
{
vrrp_rt *vrrp;
element e;
list l = vgroup->index_list;
int is_up = 0;
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vrrp = ELEMENT_DATA(e);
if (VRRP_ISUP(vrrp))
is_up++;
}
if (is_up == LIST_SIZE(vgroup->index_list)) {
log_message(LOG_INFO, "Kernel is reporting: Group(%s) UP"
, GROUP_NAME(vgroup));
return 1;
}
return 0;
}
void
put_lseg(struct pnfs_layout_segment *lseg)
{
struct inode *inode;
if (!lseg)
return;
dprintk("%s: lseg %p ref %d valid %d\n", __func__, lseg,
atomic_read(&lseg->pls_refcount),
test_bit(NFS_LSEG_VALID, &lseg->pls_flags));
inode = lseg->pls_layout->plh_inode;
if (atomic_dec_and_lock(&lseg->pls_refcount, &inode->i_lock)) {
LIST_HEAD(free_me);
put_lseg_common(lseg);
list_add(&lseg->pls_list, &free_me);
spin_unlock(&inode->i_lock);
pnfs_free_lseg_list(&free_me);
}
}
static int
vrrp_timer_vrid_timeout(const int fd)
{
vrrp_t *vrrp;
element e;
list l = &vrrp_data->vrrp_index_fd[fd%1024 + 1];
timeval_t timer;
int vrid = 0;
/* Multiple instances on the same interface */
timer_reset(timer);
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vrrp = ELEMENT_DATA(e);
if (timer_cmp(vrrp->sands, timer) < 0 ||
timer_isnull(timer)) {
timer = timer_dup(vrrp->sands);
vrid = vrrp->vrid;
}
}
return vrid;
}
/* Check if a vsg entry is in new data */
static int
vsge_exist(virtual_server_group_entry *vsg_entry, list l)
{
element e;
virtual_server_group_entry *vsge;
for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {
vsge = ELEMENT_DATA(e);
if (VSGE_ISEQ(vsg_entry, vsge)) {
/*
* If vsge exist this entry
* is alive since only rs entries
* are changing from alive state.
*/
SET_ALIVE(vsge);
return 1;
}
}
return 0;
}
static void cli_complete(char *line)
{
const HIST_ENTRY *hist;
const char *c;
LIST_HEAD(msgs);
if (line == NULL) {
printf("\n");
cli_exit();
exit(0);
}
line = cli_append_multiline(line);
if (line == NULL)
return;
for (c = line; *c != '\0'; c++)
if (!isspace(*c))
break;
if (*c == '\0')
return;
if (!strcmp(line, "quit")) {
cli_exit();
exit(0);
}
/* avoid duplicate history entries */
hist = history_get(history_length);
if (hist == NULL || strcmp(hist->line, line))
add_history(line);
parser_init(state, &msgs);
scanner_push_buffer(scanner, &indesc_cli, line);
nft_run(scanner, state, &msgs);
erec_print_list(stdout, &msgs);
xfree(line);
cache_release();
iface_cache_release();
}
static NV_STATUS uvm_unmap_external_allocation(uvm_va_space_t *va_space, NvU64 base, const NvProcessorUuid *gpu_uuid)
{
uvm_va_range_t *va_range;
uvm_gpu_t *gpu = NULL;
NV_STATUS status = NV_OK;
LIST_HEAD(deferred_free_list);
// TODO: Bug 1799173: Consider a va_range lock for external ranges so we can
// do the unmap in read mode.
uvm_va_space_down_write(va_space);
va_range = uvm_va_range_find(va_space, base);
if (!va_range || va_range->type != UVM_VA_RANGE_TYPE_EXTERNAL || va_range->node.start != base) {
status = NV_ERR_INVALID_ADDRESS;
goto out;
}
gpu = uvm_va_space_get_gpu_by_uuid(va_space, gpu_uuid);
if (!gpu || !uvm_va_range_ext_gpu_map(va_range, gpu)) {
status = NV_ERR_INVALID_DEVICE;
goto out;
}
// Retain the GPU which maps the allocation because it's the parent of
// dup_handle. The owning GPU (if any) is retained internally by the
// deferred free layer.
uvm_gpu_retain(gpu);
uvm_ext_gpu_map_destroy(va_range, gpu, &deferred_free_list);
out:
uvm_va_space_up_write(va_space);
if (status == NV_OK) {
uvm_deferred_free_object_list(&deferred_free_list);
uvm_gpu_release(gpu);
}
return status;
}
static int my_init(void)
{
int result, i;
dev_t dev = 0;
LIST_HEAD(head);
printk("DEVICE GETTING INITIALIZED:\n");
if (dev_major) {
dev = MKDEV(dev_major, dev_minor);
result = register_chrdev_region(dev, NUM_DEVICES, MYDEV_NAME);
} else {
result = alloc_chrdev_region(&dev, dev_minor, NUM_DEVICES,
MYDEV_NAME);
dev_major = MAJOR(dev);
}
if (result < 0) {
printk(KERN_WARNING "DEVICE CAN'T GET A MAJOR NUMBER %d\n", dev_major);
return result;
}
printk("DEVICE MODULE REGISTERED AND ITS MAJOR NUMBER IS:%d\n", dev_major);
dev_devices = kmalloc(NUM_DEVICES*sizeof(struct asp_mycdrv), GFP_KERNEL);
if (!dev_devices) {
result = -ENOMEM;
printk("FAILURE:MALLOC FUNC\n");
}
memset(dev_devices, 0, NUM_DEVICES * sizeof(struct asp_mycdrv));
foo_class = class_create(THIS_MODULE, "my_class");
sema_init(&sem_d, 1);
for (i = 0; i < NUM_DEVICES; i++) {
dev_devices[i].ramdisk = kmalloc(ramdisk_size, GFP_KERNEL);
dev_devices[i].devNo=i;
sema_init(&dev_devices[i].sem, 1);
device_setup_cdev(&dev_devices[i], i);
device_create(foo_class, NULL, MKDEV(MAJOR(dev), MINOR(dev) + i) , NULL, "mycdrv%d", i);
list_add (&dev_devices[i].list ,&head) ;
printk("set up the %dth device.\n",i);
}
return 0;
}
/* add or remove _alive_ real servers from a virtual server */
static void
perform_quorum_state(virtual_server_t *vs, int add)
{
element e;
real_server_t *rs;
if (LIST_ISEMPTY(vs->rs))
return;
log_message(LOG_INFO, "%s the pool for VS %s"
, add?"Adding alive servers to":"Removing alive servers from"
, FMT_VS(vs));
for (e = LIST_HEAD(vs->rs); e; ELEMENT_NEXT(e)) {
rs = ELEMENT_DATA(e);
if (!ISALIVE(rs)) /* We only handle alive servers */
continue;
if (add)
rs->alive = 0;
ipvs_cmd(add?LVS_CMD_ADD_DEST:LVS_CMD_DEL_DEST, vs, rs);
rs->alive = 1;
}
}
void CondSignal (struct Cond *cond)
{
struct Process *proc;
if (current_process == NULL)
return;
DisableInterrupts();
proc = LIST_HEAD (&cond->blocked_list);
if (proc != NULL)
{
LIST_REM_HEAD (&cond->blocked_list, blocked_entry);
proc->state = PROC_STATE_READY;
SchedReady (proc);
Reschedule();
}
EnableInterrupts();
}
static void
rpc_timeout_upcall_queue(struct work_struct *work)
{
LIST_HEAD(free_list);
struct rpc_inode *rpci =
container_of(work, struct rpc_inode, queue_timeout.work);
struct inode *inode = &rpci->vfs_inode;
void (*destroy_msg)(struct rpc_pipe_msg *);
spin_lock(&inode->i_lock);
if (rpci->ops == NULL) {
spin_unlock(&inode->i_lock);
return;
}
destroy_msg = rpci->ops->destroy_msg;
if (rpci->nreaders == 0) {
list_splice_init(&rpci->pipe, &free_list);
rpci->pipelen = 0;
}
spin_unlock(&inode->i_lock);
rpc_purge_list(rpci, &free_list, destroy_msg, -ETIMEDOUT);
}
