int
lnet_acceptor_start(void)
{
+ struct task_struct *task;
int rc;
long rc2;
long secure;
if (lnet_count_acceptor_nis() == 0) /* not required */
return 0;
- rc2 = PTR_ERR(kthread_run(lnet_acceptor,
- (void *)(ulong_ptr_t)secure,
- "acceptor_%03ld", secure));
- if (IS_ERR_VALUE(rc2)) {
+ task = kthread_run(lnet_acceptor, (void *)(ulong_ptr_t)secure,
+ "acceptor_%03ld", secure);
+ if (IS_ERR(task)) {
+ rc2 = PTR_ERR(task);
CERROR("Can't start acceptor thread: %ld\n", rc2);
fini_completion(&lnet_acceptor_state.pta_signal);
int
lnet_router_checker_start(void)
{
- int rc;
- int eqsz;
-#ifndef __KERNEL__
- lnet_peer_t *rtr;
- __u64 version;
- int nrtr = 0;
- int router_checker_max_eqsize = 10240;
+ int rc;
+ int eqsz;
+#ifdef __KERNEL__
+ struct task_struct *task;
+#else /* __KERNEL__ */
+ lnet_peer_t *rtr;
+ __u64 version;
+ int nrtr = 0;
+ int router_checker_max_eqsize = 10240;
LASSERT (check_routers_before_use);
LASSERT (dead_router_check_interval > 0);
the_lnet.ln_rc_state = LNET_RC_STATE_RUNNING;
#ifdef __KERNEL__
- rc = PTR_ERR(kthread_run(lnet_router_checker,
- NULL, "router_checker"));
- if (IS_ERR_VALUE(rc)) {
+ task = kthread_run(lnet_router_checker, NULL, "router_checker");
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
CERROR("Can't start router checker thread: %d\n", rc);
/* block until event callback signals exit */
down(&the_lnet.ln_rc_signal);
/* Spawn poll threads */
for (i = 0; i < usock_data.ud_npollthreads; i++) {
- rc = PTR_ERR(kthread_run(usocklnd_poll_thread,
- &usock_data.ud_pollthreads[i],
- ""));
- if (IS_ERR_VALUE(rc)) {
+ struct task_struct *task;
+
+ task = kthread_run(usocklnd_poll_thread,
+ &usock_data.ud_pollthreads[i], "");
+ if (IS_ERR(task)) {
usocklnd_base_shutdown(i);
- return rc;
+ return PTR_ERR(task);
}
}
static int ldlm_setup(void)
{
static struct ptlrpc_service_conf conf;
- struct ldlm_bl_pool *blp = NULL;
- int rc = 0;
+ struct ldlm_bl_pool *blp = NULL;
#ifdef __KERNEL__
- int i;
+# ifdef HAVE_SERVER_SUPPORT
+ struct task_struct *task;
+# endif
+ int i;
#endif
+ int rc = 0;
+
ENTRY;
if (ldlm_state != NULL)
spin_lock_init(&waiting_locks_spinlock);
cfs_timer_init(&waiting_locks_timer, waiting_locks_callback, 0);
- rc = PTR_ERR(kthread_run(expired_lock_main, NULL, "ldlm_elt"));
- if (IS_ERR_VALUE(rc)) {
+ task = kthread_run(expired_lock_main, NULL, "ldlm_elt");
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
CERROR("Cannot start ldlm expired-lock thread: %d\n", rc);
GOTO(out, rc);
}
struct ll_sa_entry *entry;
struct ptlrpc_thread *thread;
struct l_wait_info lwi = { 0 };
+ struct task_struct *task;
int rc = 0;
struct ll_inode_info *plli;
ENTRY;
lli->lli_sai = sai;
plli = ll_i2info(parent->d_inode);
- rc = PTR_ERR(kthread_run(ll_statahead_thread, parent,
- "ll_sa_%u", plli->lli_opendir_pid));
+ task = kthread_run(ll_statahead_thread, parent, "ll_sa_%u",
+ plli->lli_opendir_pid);
thread = &sai->sai_thread;
- if (IS_ERR_VALUE(rc)) {
- CERROR("can't start ll_sa thread, rc: %d\n", rc);
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
+ CERROR("cannot start ll_sa thread: rc = %d\n", rc);
dput(parent);
lli->lli_opendir_key = NULL;
thread_set_flags(thread, SVC_STOPPED);
static int mdc_ioc_changelog_send(struct obd_device *obd,
struct ioc_changelog *icc)
{
- struct changelog_show *cs;
- int rc;
+ struct changelog_show *cs;
+ struct task_struct *task;
+ int rc;
/* Freed in mdc_changelog_send_thread */
OBD_ALLOC_PTR(cs);
* New thread because we should return to user app before
* writing into our pipe
*/
- rc = PTR_ERR(kthread_run(mdc_changelog_send_thread, cs,
- "mdc_clg_send_thread"));
- if (!IS_ERR_VALUE(rc)) {
- CDEBUG(D_CHANGELOG, "start changelog thread\n");
- return 0;
+ task = kthread_run(mdc_changelog_send_thread, cs,
+ "mdc_clg_send_thread");
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
+ CERROR("%s: cannot start changelog thread: rc = %d\n",
+ obd->obd_name, rc);
+ OBD_FREE_PTR(cs);
+ } else {
+ rc = 0;
+ CDEBUG(D_CHANGELOG, "%s: started changelog thread\n",
+ obd->obd_name);
}
- CERROR("Failed to start changelog thread: %d\n", rc);
- OBD_FREE_PTR(cs);
- return rc;
+ return rc;
}
static int mdc_ioc_hsm_ct_start(struct obd_export *exp,
static int mgc_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
{
- int rc;
+ struct task_struct *task;
+ int rc;
ENTRY;
rc = ptlrpcd_addref();
init_waitqueue_head(&rq_waitq);
/* start requeue thread */
- rc = PTR_ERR(kthread_run(mgc_requeue_thread, NULL,
- "ll_cfg_requeue"));
- if (IS_ERR_VALUE(rc)) {
- CERROR("%s: Cannot start requeue thread (%d),"
- "no more log updates!\n",
+ task = kthread_run(mgc_requeue_thread, NULL, "ll_cfg_requeue");
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
+ CERROR("%s: cannot start requeue thread: rc = %d; "
+ "no more log updates\n",
obd->obd_name, rc);
GOTO(err_cleanup, rc);
}
#ifdef __KERNEL__
if (fork) {
+ struct task_struct *task;
+
/* The new thread can't use parent env,
* init the new one in llog_process_thread_daemonize. */
lpi->lpi_env = NULL;
init_completion(&lpi->lpi_completion);
- rc = PTR_ERR(kthread_run(llog_process_thread_daemonize, lpi,
- "llog_process_thread"));
- if (IS_ERR_VALUE(rc)) {
+ task = kthread_run(llog_process_thread_daemonize, lpi,
+ "llog_process_thread");
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
CERROR("%s: cannot start thread: rc = %d\n",
loghandle->lgh_ctxt->loc_obd->obd_name, rc);
- OBD_FREE_PTR(lpi);
- RETURN(rc);
+ GOTO(out_lpi, rc);
}
wait_for_completion(&lpi->lpi_completion);
} else {
lpi->lpi_env = env;
llog_process_thread(lpi);
#endif
- rc = lpi->lpi_rc;
- OBD_FREE_PTR(lpi);
- RETURN(rc);
+ rc = lpi->lpi_rc;
+
+#ifdef __KERNEL__
+out_lpi:
+#endif
+ OBD_FREE_PTR(lpi);
+ RETURN(rc);
}
EXPORT_SYMBOL(llog_process_or_fork);
struct osd_scrub *scrub = &dev->od_scrub;
struct ptlrpc_thread *thread = &scrub->os_thread;
struct l_wait_info lwi = { 0 };
+ struct task_struct *task;
int rc;
ENTRY;
scrub->os_start_flags = flags;
thread_set_flags(thread, 0);
- rc = PTR_ERR(kthread_run(osd_scrub_main, dev, "OI_scrub"));
- if (IS_ERR_VALUE(rc)) {
- CERROR("%.16s: cannot start iteration thread, rc = %d\n",
+ task = kthread_run(osd_scrub_main, dev, "OI_scrub");
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
+ CERROR("%.16s: cannot start iteration thread: rc = %d\n",
LDISKFS_SB(osd_sb(dev))->s_es->s_volume_name, rc);
RETURN(rc);
}
int osp_sync_init(const struct lu_env *env, struct osp_device *d)
{
struct l_wait_info lwi = { 0 };
+ struct task_struct *task;
int rc;
ENTRY;
init_waitqueue_head(&d->opd_syn_thread.t_ctl_waitq);
CFS_INIT_LIST_HEAD(&d->opd_syn_committed_there);
- rc = PTR_ERR(kthread_run(osp_sync_thread, d,
- "osp-syn-%u-%u", d->opd_index, d->opd_group));
- if (IS_ERR_VALUE(rc)) {
- CERROR("%s: can't start sync thread: rc = %d\n",
+ task = kthread_run(osp_sync_thread, d, "osp-syn-%u-%u",
+ d->opd_index, d->opd_group);
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
+ CERROR("%s: cannot start sync thread: rc = %d\n",
d->opd_obd->obd_name, rc);
GOTO(err_llog, rc);
}
int ptlrpc_start_pinger(void)
{
struct l_wait_info lwi = { 0 };
+ struct task_struct *task;
int rc;
#ifndef ENABLE_PINGER
return 0;
/* CLONE_VM and CLONE_FILES just avoid a needless copy, because we
* just drop the VM and FILES in kthread_run() right away. */
- rc = PTR_ERR(kthread_run(ptlrpc_pinger_main,
- &pinger_thread, pinger_thread.t_name));
- if (IS_ERR_VALUE(rc)) {
- CERROR("cannot start thread: %d\n", rc);
+ task = kthread_run(ptlrpc_pinger_main, &pinger_thread,
+ pinger_thread.t_name);
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
+ CERROR("cannot start pinger thread: rc = %d\n", rc);
RETURN(rc);
}
+
l_wait_event(pinger_thread.t_ctl_waitq,
thread_is_running(&pinger_thread), &lwi);
int rc = 0;
for (j = 0; j < hrp->hrp_nthrs; j++) {
- struct ptlrpc_hr_thread *hrt = &hrp->hrp_thrs[j];
- rc = PTR_ERR(kthread_run(ptlrpc_hr_main,
- &hrp->hrp_thrs[j],
- "ptlrpc_hr%02d_%03d",
- hrp->hrp_cpt,
- hrt->hrt_id));
- if (IS_ERR_VALUE(rc))
+ struct ptlrpc_hr_thread *hrt = &hrp->hrp_thrs[j];
+ struct task_struct *task;
+
+ task = kthread_run(ptlrpc_hr_main,
+ &hrp->hrp_thrs[j],
+ "ptlrpc_hr%02d_%03d",
+ hrp->hrp_cpt,
+ hrt->hrt_id);
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
break;
+ }
}
+
wait_event(ptlrpc_hr.hr_waitq,
- atomic_read(&hrp->hrp_nstarted) == j);
- if (!IS_ERR_VALUE(rc))
- continue;
+ atomic_read(&hrp->hrp_nstarted) == j);
- CERROR("Reply handling thread %d:%d Failed on starting: "
- "rc = %d\n", i, j, rc);
- ptlrpc_stop_hr_threads();
- RETURN(rc);
+ if (rc < 0) {
+ CERROR("cannot start reply handler thread %d:%d: "
+ "rc = %d\n", i, j, rc);
+ ptlrpc_stop_hr_threads();
+ RETURN(rc);
+ }
}
+
RETURN(0);
}
struct l_wait_info lwi = { 0 };
struct ptlrpc_thread *thread;
struct ptlrpc_service *svc;
+ struct task_struct *task;
int rc;
ENTRY;
}
CDEBUG(D_RPCTRACE, "starting thread '%s'\n", thread->t_name);
- rc = PTR_ERR(kthread_run(ptlrpc_main, thread, thread->t_name));
- if (IS_ERR_VALUE(rc)) {
- CERROR("cannot start thread '%s': rc %d\n",
+ task = kthread_run(ptlrpc_main, thread, "%s", thread->t_name);
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
+ CERROR("cannot start thread '%s': rc = %d\n",
thread->t_name, rc);
spin_lock(&svcpt->scp_lock);
--svcpt->scp_nthrs_starting;
struct ptlrpc_thread *thread = &qqi->qqi_reint_thread;
struct qsd_instance *qsd = qqi->qqi_qsd;
struct l_wait_info lwi = { 0 };
+ struct task_struct *task;
int rc;
char *name;
ENTRY;
snprintf(name, MTI_NAME_MAXLEN, "qsd_reint_%d.%s",
qqi->qqi_qtype, qsd->qsd_svname);
- rc = PTR_ERR(kthread_run(qsd_reint_main, (void *)qqi, name));
+ task = kthread_run(qsd_reint_main, qqi, name);
OBD_FREE(name, MTI_NAME_MAXLEN);
- if (IS_ERR_VALUE(rc)) {
+ if (IS_ERR(task)) {
+ rc = PTR_ERR(task);
thread_set_flags(thread, SVC_STOPPED);
write_lock(&qsd->qsd_lock);
qqi->qqi_reint = 0;