static int create_work_queues(void)
{
if (init_work_queue(get_nr_nodes))
return -1;
sys->net_wqueue = create_work_queue("net", WQ_UNLIMITED);
sys->gateway_wqueue = create_work_queue("gway", WQ_UNLIMITED);
sys->io_wqueue = create_work_queue("io", WQ_UNLIMITED);
sys->recovery_wqueue = create_ordered_work_queue("rw");
sys->deletion_wqueue = create_ordered_work_queue("deletion");
sys->block_wqueue = create_ordered_work_queue("block");
sys->md_wqueue = create_ordered_work_queue("md");
sys->areq_wqueue = create_work_queue("async_req", WQ_UNLIMITED);
if (sys->enable_object_cache) {
sys->oc_reclaim_wqueue =
create_ordered_work_queue("oc_reclaim");
sys->oc_push_wqueue = create_work_queue("oc_push", WQ_DYNAMIC);
if (!sys->oc_reclaim_wqueue || !sys->oc_push_wqueue)
return -1;
}
if (!sys->gateway_wqueue || !sys->io_wqueue || !sys->recovery_wqueue ||
!sys->deletion_wqueue || !sys->block_wqueue || !sys->md_wqueue ||
!sys->areq_wqueue)
return -1;
return 0;
}
static int create_work_queues(void)
{
struct work_queue *util_wq;
if (init_work_queue(get_nr_nodes))
return -1;
if (wq_net_threads) {
sd_info("# of threads in net workqueue: %d", wq_net_threads);
sys->net_wqueue = create_fixed_work_queue("net", wq_net_threads);
} else {
sd_info("net workqueue is created as unlimited, it is not recommended!");
sys->net_wqueue = create_work_queue("net", WQ_UNLIMITED);
}
if (wq_gway_threads) {
sd_info("# of threads in gway workqueue: %d", wq_gway_threads);
sys->gateway_wqueue = create_fixed_work_queue("gway", wq_gway_threads);
} else {
sd_info("gway workqueue is created as unlimited, it is not recommended!");
sys->gateway_wqueue = create_work_queue("gway", WQ_UNLIMITED);
}
if (wq_io_threads) {
sd_info("# of threads in io workqueue: %d", wq_io_threads);
sys->io_wqueue = create_fixed_work_queue("io", wq_io_threads);
} else {
sd_info("io workqueue is created as unlimited, it is not recommended!");
sys->io_wqueue = create_work_queue("io", WQ_UNLIMITED);
}
if (wq_recovery_threads) {
sd_info("# of threads in rw workqueue: %d", wq_recovery_threads);
sys->recovery_wqueue = create_fixed_work_queue("rw", wq_recovery_threads);
} else {
sd_info("recovery workqueue is created as unlimited, it is not recommended!");
sys->recovery_wqueue = create_work_queue("rw", WQ_UNLIMITED);
}
sys->deletion_wqueue = create_ordered_work_queue("deletion");
sys->block_wqueue = create_ordered_work_queue("block");
sys->md_wqueue = create_ordered_work_queue("md");
if (wq_async_threads) {
sd_info("# of threads in async_req workqueue: %d", wq_async_threads);
sys->areq_wqueue = create_fixed_work_queue("async_req", wq_async_threads);
} else {
sd_info("async_req workqueue is created as unlimited, it is not recommended!");
sys->areq_wqueue = create_work_queue("async_req", WQ_UNLIMITED);
}
if (!sys->gateway_wqueue || !sys->io_wqueue || !sys->recovery_wqueue ||
!sys->deletion_wqueue || !sys->block_wqueue || !sys->md_wqueue ||
!sys->areq_wqueue)
return -1;
util_wq = create_ordered_work_queue("util");
if (!util_wq)
return -1;
register_util_wq(util_wq);
return 0;
}
int init_module(void){
Major = register_chrdev(0, DEVICE_NAME, &fops);
Proc_File = create_proc_entry(PROCFS_NAME, 0644, NULL);
if( NULL == Proc_File ){
remove_proc_entry(PROCFS_NAME, NULL);
printk(KERN_ALERT "Error: couldn't init /proc/%s\n", PROCFS_NAME);
return -ENOMEM;
}
Proc_File->read_proc = procfile_read;
Proc_File->write_proc = procfile_write;
Proc_File->mode = S_IFREG | S_IRUGO;
Proc_File->uid = 0;
Proc_File->gid = 0;
Proc_File->size = 37;
workqueue = create_work_queue(WQ_NAME);
queue_delayed_work(workqueue, &Task, INTERVAL);
printk("<1>Tamagotchi loaded\n");
printk("<1>To read Tamagotchi status create a dev file with\n");
printk("<1>'mknod /dev/%s c %d 0'.\n", DEVICE_NAME, Major);
printk("<1>Remove the device file and unload module to finish\n");
return 0;
}
int init_workqueue(void)
{
//printk(KERN_INFO "workqueue init called\n");
initialize_timer();//Initializing timer
create_work_queue(); //calling workqueue
//printk(KERN_INFO "workqueue init done\n");
//queue_work( my_wq, &wk1->work );
return 0;
}
void
phase3(
struct xfs_mount *mp,
int scan_threads)
{
int i, j;
int *counts;
work_queue_t wq;
do_log(_("Phase 3 - for each AG...\n"));
if (!no_modify)
do_log(_(" - scan and clear agi unlinked lists...\n"));
else
do_log(_(" - scan (but don't clear) agi unlinked lists...\n"));
set_progress_msg(PROG_FMT_AGI_UNLINKED, (__uint64_t) glob_agcount);
/* first clear the agi unlinked AGI list */
if (!no_modify) {
for (i = 0; i < mp->m_sb.sb_agcount; i++)
process_agi_unlinked(mp, i);
}
/* now look at possibly bogus inodes */
for (i = 0; i < mp->m_sb.sb_agcount; i++) {
check_uncertain_aginodes(mp, i);
PROG_RPT_INC(prog_rpt_done[i], 1);
}
print_final_rpt();
/* ok, now that the tree's ok, let's take a good look */
do_log(_(
" - process known inodes and perform inode discovery...\n"));
set_progress_msg(PROG_FMT_PROCESS_INO, (__uint64_t) mp->m_sb.sb_icount);
process_ags(mp);
print_final_rpt();
/*
* process newly discovered inode chunks
*/
do_log(_(" - process newly discovered inodes...\n"));
set_progress_msg(PROG_FMT_NEW_INODES, (__uint64_t) glob_agcount);
counts = calloc(sizeof(*counts), mp->m_sb.sb_agcount);
if (!counts) {
do_abort(_("no memory for uncertain inode counts\n"));
return;
}
do {
/*
* have to loop until no ag has any uncertain
* inodes
*/
j = 0;
memset(counts, 0, mp->m_sb.sb_agcount * sizeof(*counts));
create_work_queue(&wq, mp, scan_threads);
for (i = 0; i < mp->m_sb.sb_agcount; i++)
queue_work(&wq, do_uncertain_aginodes, i, &counts[i]);
destroy_work_queue(&wq);
/* tally up the counts */
for (i = 0; i < mp->m_sb.sb_agcount; i++)
j += counts[i];
} while (j != 0);
free(counts);
print_final_rpt();
}
