spin_unlock(&rpc_authflavor_lock);
return ret;
}
-EXPORT_SYMBOL(rpcauth_register);
+EXPORT_SYMBOL_GPL(rpcauth_register);
int
rpcauth_unregister(const struct rpc_authops *ops)
spin_unlock(&rpc_authflavor_lock);
return ret;
}
-EXPORT_SYMBOL(rpcauth_unregister);
+EXPORT_SYMBOL_GPL(rpcauth_unregister);
struct rpc_auth *
rpcauth_create(rpc_authflavor_t pseudoflavor, struct rpc_clnt *clnt)
out:
return auth;
}
-EXPORT_SYMBOL(rpcauth_create);
+EXPORT_SYMBOL_GPL(rpcauth_create);
void
rpcauth_release(struct rpc_auth *auth)
auth->au_credcache = new;
return 0;
}
-EXPORT_SYMBOL(rpcauth_init_credcache);
+EXPORT_SYMBOL_GPL(rpcauth_init_credcache);
/*
* Destroy a list of credentials
kfree(cache);
}
}
-EXPORT_SYMBOL(rpcauth_destroy_credcache);
+EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache);
/*
* Remove stale credentials. Avoid sleeping inside the loop.
out:
return cred;
}
-EXPORT_SYMBOL(rpcauth_lookup_credcache);
+EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache);
struct rpc_cred *
rpcauth_lookupcred(struct rpc_auth *auth, int flags)
put_group_info(acred.group_info);
return ret;
}
-EXPORT_SYMBOL(rpcauth_lookupcred);
+EXPORT_SYMBOL_GPL(rpcauth_lookupcred);
void
rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred,
#endif
cred->cr_uid = acred->uid;
}
-EXPORT_SYMBOL(rpcauth_init_cred);
+EXPORT_SYMBOL_GPL(rpcauth_init_cred);
struct rpc_cred *
rpcauth_bindcred(struct rpc_task *task)
out_destroy:
cred->cr_ops->crdestroy(cred);
}
-EXPORT_SYMBOL(put_rpccred);
+EXPORT_SYMBOL_GPL(put_rpccred);
void
rpcauth_unbindcred(struct rpc_task *task)
dprintk("RPC: %s: returned error %d\n", __FUNCTION__, err);
return ERR_PTR(err);
}
-EXPORT_SYMBOL(rpc_clone_client);
+EXPORT_SYMBOL_GPL(rpc_clone_client);
/*
* Properly shut down an RPC client, terminating all outstanding
rpc_release_client(clnt);
}
-EXPORT_SYMBOL(rpc_shutdown_client);
+EXPORT_SYMBOL_GPL(rpc_shutdown_client);
/*
* Free an RPC client
out:
return clnt;
}
-EXPORT_SYMBOL(rpc_bind_new_program);
+EXPORT_SYMBOL_GPL(rpc_bind_new_program);
/*
* Default callback for async RPC calls
{
rpc_save_sigmask(oldset, clnt->cl_intr);
}
-EXPORT_SYMBOL(rpc_clnt_sigmask);
+EXPORT_SYMBOL_GPL(rpc_clnt_sigmask);
void rpc_clnt_sigunmask(struct rpc_clnt *clnt, sigset_t *oldset)
{
rpc_restore_sigmask(oldset);
}
-EXPORT_SYMBOL(rpc_clnt_sigunmask);
+EXPORT_SYMBOL_GPL(rpc_clnt_sigunmask);
static
struct rpc_task *rpc_do_run_task(struct rpc_clnt *clnt,
rpc_put_task(task);
return status;
}
-EXPORT_SYMBOL(rpc_call_sync);
+EXPORT_SYMBOL_GPL(rpc_call_sync);
/**
* rpc_call_async - Perform an asynchronous RPC call
rpc_put_task(task);
return 0;
}
-EXPORT_SYMBOL(rpc_call_async);
+EXPORT_SYMBOL_GPL(rpc_call_async);
/**
* rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
{
return rpc_do_run_task(clnt, NULL, flags, tk_ops, data);
}
-EXPORT_SYMBOL(rpc_run_task);
+EXPORT_SYMBOL_GPL(rpc_run_task);
void
rpc_call_setup(struct rpc_task *task, struct rpc_message *msg, int flags)
else
task->tk_action = rpc_exit_task;
}
-EXPORT_SYMBOL(rpc_call_setup);
+EXPORT_SYMBOL_GPL(rpc_call_setup);
/**
* rpc_peeraddr - extract remote peer address from clnt's xprt
if (xprt->ops->set_buffer_size)
xprt->ops->set_buffer_size(xprt, sndsize, rcvsize);
}
-EXPORT_SYMBOL(rpc_setbufsize);
+EXPORT_SYMBOL_GPL(rpc_setbufsize);
/*
* Return size of largest payload RPC client can support, in bytes
task->tk_action = call_start;
}
-EXPORT_SYMBOL(rpc_restart_call);
+EXPORT_SYMBOL_GPL(rpc_restart_call);
/*
* 0. Initial state
};
return rpc_do_run_task(clnt, &msg, flags, &rpc_default_ops, NULL);
}
-EXPORT_SYMBOL(rpc_call_null);
+EXPORT_SYMBOL_GPL(rpc_call_null);
#ifdef RPC_DEBUG
void rpc_show_tasks(void)
{
__rpc_init_priority_wait_queue(queue, qname, 0);
}
-EXPORT_SYMBOL(rpc_init_wait_queue);
+EXPORT_SYMBOL_GPL(rpc_init_wait_queue);
static int rpc_wait_bit_interruptible(void *word)
{
return wait_on_bit(&task->tk_runstate, RPC_TASK_ACTIVE,
action, TASK_INTERRUPTIBLE);
}
-EXPORT_SYMBOL(__rpc_wait_for_completion_task);
+EXPORT_SYMBOL_GPL(__rpc_wait_for_completion_task);
/*
* Make an RPC task runnable.
__rpc_sleep_on(q, task, action, timer);
spin_unlock_bh(&q->lock);
}
-EXPORT_SYMBOL(rpc_sleep_on);
+EXPORT_SYMBOL_GPL(rpc_sleep_on);
/**
* __rpc_do_wake_up_task - wake up a single rpc_task
}
rcu_read_unlock_bh();
}
-EXPORT_SYMBOL(rpc_wake_up_task);
+EXPORT_SYMBOL_GPL(rpc_wake_up_task);
/*
* Wake up the next task on a priority queue.
return task;
}
-EXPORT_SYMBOL(rpc_wake_up_next);
+EXPORT_SYMBOL_GPL(rpc_wake_up_next);
/**
* rpc_wake_up - wake up all rpc_tasks
spin_unlock(&queue->lock);
rcu_read_unlock_bh();
}
-EXPORT_SYMBOL(rpc_wake_up);
+EXPORT_SYMBOL_GPL(rpc_wake_up);
/**
* rpc_wake_up_status - wake up all rpc_tasks and set their status value.
spin_unlock(&queue->lock);
rcu_read_unlock_bh();
}
-EXPORT_SYMBOL(rpc_wake_up_status);
+EXPORT_SYMBOL_GPL(rpc_wake_up_status);
static void __rpc_atrun(struct rpc_task *task)
{
task->tk_timeout = delay;
rpc_sleep_on(&delay_queue, task, NULL, __rpc_atrun);
}
-EXPORT_SYMBOL(rpc_delay);
+EXPORT_SYMBOL_GPL(rpc_delay);
/*
* Helper to call task->tk_ops->rpc_call_prepare
}
}
}
-EXPORT_SYMBOL(rpc_exit_task);
+EXPORT_SYMBOL_GPL(rpc_exit_task);
void rpc_release_calldata(const struct rpc_call_ops *ops, void *calldata)
{
rpc_set_running(task);
__rpc_execute(task);
}
-EXPORT_SYMBOL(rpc_execute);
+EXPORT_SYMBOL_GPL(rpc_execute);
static void rpc_async_schedule(struct work_struct *work)
{
dprintk("RPC: new task initialized, procpid %u\n",
task_pid_nr(current));
}
-EXPORT_SYMBOL(rpc_init_task);
+EXPORT_SYMBOL_GPL(rpc_init_task);
static struct rpc_task *
rpc_alloc_task(void)
call_rcu_bh(&task->u.tk_rcu, rpc_free_task);
rpc_release_calldata(tk_ops, calldata);
}
-EXPORT_SYMBOL(rpc_put_task);
+EXPORT_SYMBOL_GPL(rpc_put_task);
static void rpc_release_task(struct rpc_task *task)
{
}
spin_unlock(&clnt->cl_lock);
}
-EXPORT_SYMBOL(rpc_killall_tasks);
+EXPORT_SYMBOL_GPL(rpc_killall_tasks);
int rpciod_up(void)
{
new = kcalloc(clnt->cl_maxproc, sizeof(struct rpc_iostats), GFP_KERNEL);
return new;
}
-EXPORT_SYMBOL(rpc_alloc_iostats);
+EXPORT_SYMBOL_GPL(rpc_alloc_iostats);
/**
* rpc_free_iostats - release an rpc_iostats structure
{
kfree(stats);
}
-EXPORT_SYMBOL(rpc_free_iostats);
+EXPORT_SYMBOL_GPL(rpc_free_iostats);
/**
* rpc_count_iostats - tally up per-task stats
metrics->om_execute * MILLISECS_PER_JIFFY);
}
}
-EXPORT_SYMBOL(rpc_print_iostats);
+EXPORT_SYMBOL_GPL(rpc_print_iostats);
/*
* Register/unregister RPC proc files
{
return do_register(statp->program->name, statp, &rpc_proc_fops);
}
-EXPORT_SYMBOL(rpc_proc_register);
+EXPORT_SYMBOL_GPL(rpc_proc_register);
void
rpc_proc_unregister(const char *name)
{
remove_proc_entry(name, proc_net_rpc);
}
-EXPORT_SYMBOL(rpc_proc_unregister);
+EXPORT_SYMBOL_GPL(rpc_proc_unregister);
struct proc_dir_entry *
svc_proc_register(struct svc_stat *statp, const struct file_operations *fops)
* Declare the debug flags here
*/
unsigned int rpc_debug;
-EXPORT_SYMBOL(rpc_debug);
+EXPORT_SYMBOL_GPL(rpc_debug);
unsigned int nfs_debug;
-EXPORT_SYMBOL(nfs_debug);
+EXPORT_SYMBOL_GPL(nfs_debug);
unsigned int nfsd_debug;
-EXPORT_SYMBOL(nfsd_debug);
+EXPORT_SYMBOL_GPL(nfsd_debug);
unsigned int nlm_debug;
-EXPORT_SYMBOL(nlm_debug);
+EXPORT_SYMBOL_GPL(nlm_debug);
#ifdef RPC_DEBUG
to->to_retries = retr;
to->to_exponential = 0;
}
-EXPORT_SYMBOL(xprt_set_timeout);
+EXPORT_SYMBOL_GPL(xprt_set_timeout);
/**
* xprt_create_transport - create an RPC transport
git://ftp.safe.ca / safe / jmp / linux-2.6 / commitdiff