cfs_list_for_each_entry_typed||list_for_each_entry_typed
cfs_list_for_each_prev||list_for_each_prev
cfs_list_for_each_safe||list_for_each_safe
-CFS_LIST_HEAD||struct list_head foo = LIST_HEAD_INIT(foo);
+CFS_LIST_HEAD||LIST_HEAD(foo);
CFS_LIST_HEAD_INIT||LIST_HEAD_INIT
cfs_list_move||list_move
cfs_list_move_tail||list_move_tail
static int
kiblnd_del_peer(struct lnet_ni *ni, lnet_nid_t nid)
{
- struct list_head zombies = LIST_HEAD_INIT(zombies);
+ LIST_HEAD(zombies);
struct list_head *ptmp;
struct list_head *pnxt;
struct kib_peer_ni *peer_ni;
void
kiblnd_fmr_pool_unmap(struct kib_fmr *fmr, int status)
{
- struct list_head zombies = LIST_HEAD_INIT(zombies);
+ LIST_HEAD(zombies);
struct kib_fmr_pool *fpo = fmr->fmr_pool;
struct kib_fmr_poolset *fps;
time64_t now = ktime_get_seconds();
void
kiblnd_pool_free_node(struct kib_pool *pool, struct list_head *node)
{
- struct list_head zombies = LIST_HEAD_INIT(zombies);
+ LIST_HEAD(zombies);
struct kib_poolset *ps = pool->po_owner;
struct kib_pool *tmp;
time64_t now = ktime_get_seconds();
int
kiblnd_dev_failover(struct kib_dev *dev, struct net *ns)
{
- struct list_head zombie_tpo = LIST_HEAD_INIT(zombie_tpo);
- struct list_head zombie_ppo = LIST_HEAD_INIT(zombie_ppo);
- struct list_head zombie_fpo = LIST_HEAD_INIT(zombie_fpo);
+ LIST_HEAD(zombie_tpo);
+ LIST_HEAD(zombie_ppo);
+ LIST_HEAD(zombie_fpo);
struct rdma_cm_id *cmid = NULL;
struct kib_hca_dev *hdev = NULL;
struct kib_hca_dev *old;
void
kiblnd_abort_txs(struct kib_conn *conn, struct list_head *txs)
{
- struct list_head zombies = LIST_HEAD_INIT(zombies);
+ LIST_HEAD(zombies);
struct list_head *tmp;
struct list_head *nxt;
struct kib_tx *tx;
kiblnd_peer_connect_failed(struct kib_peer_ni *peer_ni, int active,
int error)
{
- struct list_head zombies = LIST_HEAD_INIT(zombies);
+ LIST_HEAD(zombies);
unsigned long flags;
LASSERT (error != 0);
static void
kiblnd_check_conns (int idx)
{
- struct list_head closes = LIST_HEAD_INIT(closes);
- struct list_head checksends = LIST_HEAD_INIT(checksends);
- struct list_head timedout_txs = LIST_HEAD_INIT(timedout_txs);
+ LIST_HEAD(closes);
+ LIST_HEAD(checksends);
+ LIST_HEAD(timedout_txs);
struct list_head *peers = &kiblnd_data.kib_peers[idx];
struct list_head *ptmp;
struct kib_peer_ni *peer_ni;
static int
ksocknal_del_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ip)
{
- struct list_head zombies = LIST_HEAD_INIT(zombies);
+ LIST_HEAD(zombies);
struct list_head *ptmp;
struct list_head *pnxt;
struct ksock_peer_ni *peer_ni;
struct socket *sock, int type)
{
rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock;
- struct list_head zombies = LIST_HEAD_INIT(zombies);
+ LIST_HEAD(zombies);
struct lnet_process_id peerid;
struct list_head *tmp;
u64 incarnation;
struct ksock_peer_ni *peer_ni = conn->ksnc_peer;
struct ksock_tx *tx;
struct ksock_tx *tmp;
- struct list_head zlist = LIST_HEAD_INIT(zlist);
+ LIST_HEAD(zlist);
/* NB safe to finalize TXs because closing of socket will
* abort all buffered data */
}
if (!list_empty(&sched->kss_tx_conns)) {
- struct list_head zlist = LIST_HEAD_INIT(zlist);
+ LIST_HEAD(zlist);
if (!list_empty(&sched->kss_zombie_noop_txs)) {
list_add(&zlist,
static int
ksocknal_connect(struct ksock_route *route)
{
- struct list_head zombies = LIST_HEAD_INIT(zombies);
+ LIST_HEAD(zombies);
struct ksock_peer_ni *peer_ni = route->ksnr_peer;
int type;
int wanted;
ksocknal_flush_stale_txs(struct ksock_peer_ni *peer_ni)
{
struct ksock_tx *tx;
- struct list_head stale_txs = LIST_HEAD_INIT(stale_txs);
+ LIST_HEAD(stale_txs);
write_lock_bh(&ksocknal_data.ksnd_global_lock);
struct ksock_peer_ni *peer_ni = conn->ksnc_peer;
struct ksock_tx *tx;
struct ksock_tx *tmp;
- struct list_head zlist = LIST_HEAD_INIT(zlist);
+ LIST_HEAD(zlist);
int count;
if (cookie1 == 0)
static int
lnet_match_network_token(char *token, int len, __u32 *ipaddrs, int nip)
{
- struct list_head list = LIST_HEAD_INIT(list);
+ LIST_HEAD(list);
int rc;
int i;
LNetMDAttach(struct lnet_handle_me meh, struct lnet_md umd,
enum lnet_unlink unlink, struct lnet_handle_md *handle)
{
- struct list_head matches = LIST_HEAD_INIT(matches);
- struct list_head drops = LIST_HEAD_INIT(drops);
+ LIST_HEAD(matches);
+ LIST_HEAD(drops);
struct lnet_me *me;
struct lnet_libmd *md;
int cpt;
lnet_clear_lazy_portal(struct lnet_ni *ni, int portal, char *reason)
{
struct lnet_portal *ptl;
- struct list_head zombies = LIST_HEAD_INIT(zombies);
+ LIST_HEAD(zombies);
if (portal < 0 || portal >= the_lnet.ln_nportals)
return -EINVAL;
__u64 flags;
int rc = LDLM_ITER_CONTINUE;
enum ldlm_error err;
- struct list_head bl_ast_list = LIST_HEAD_INIT(bl_ast_list);
+ LIST_HEAD(bl_ast_list);
struct ldlm_ibits_queues *queues = res->lr_ibits_queues;
int i;
PLDLMRES(res), res);
for (i = 0; i < MDS_INODELOCK_NUMBITS; i++) {
- struct list_head rpc_list = LIST_HEAD_INIT(rpc_list);
+ LIST_HEAD(rpc_list);
struct list_head *head = &queues->liq_waiting[i];
struct ldlm_lock *pending;
struct ldlm_ibits_node *node;
{
struct ldlm_resource *res = lock->l_resource;
enum ldlm_error rc = ELDLM_OK;
- struct list_head rpc_list = LIST_HEAD_INIT(rpc_list);
+ LIST_HEAD(rpc_list);
ldlm_processing_policy policy;
ENTRY;
__u64 flags;
int rc = LDLM_ITER_CONTINUE;
enum ldlm_error err;
- struct list_head bl_ast_list = LIST_HEAD_INIT(bl_ast_list);
+ LIST_HEAD(bl_ast_list);
ENTRY;
restart:
list_for_each_safe(tmp, pos, queue) {
struct ldlm_lock *pending;
- struct list_head rpc_list = LIST_HEAD_INIT(rpc_list);
+ LIST_HEAD(rpc_list);
pending = list_entry(tmp, struct ldlm_lock, l_res_link);
struct ldlm_namespace *ns = exp->exp_obd->obd_namespace;
struct req_capsule *pill = &req->rq_pill;
struct ldlm_request *dlm = NULL;
- struct list_head head = LIST_HEAD_INIT(head);
+ LIST_HEAD(head);
enum ldlm_lru_flags lru_flags;
int avail, to_free, pack = 0;
int rc;
__u64 rc = 0;
struct ldlm_namespace *ns;
struct ldlm_lock *lock;
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
ENTRY;
int ldlm_cli_cancel_list_local(struct list_head *cancels, int count,
enum ldlm_cancel_flags cancel_flags)
{
- struct list_head head = LIST_HEAD_INIT(head);
+ LIST_HEAD(head);
struct ldlm_lock *lock, *next;
int left = 0, bl_ast = 0;
__u64 rc;
enum ldlm_cancel_flags cancel_flags,
enum ldlm_lru_flags lru_flags)
{
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
int count, rc;
ENTRY;
enum ldlm_cancel_flags flags, void *opaque)
{
struct ldlm_resource *res;
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
int count;
int rc;
static void ldlm_cancel_unused_locks_for_replay(struct ldlm_namespace *ns)
{
int canceled;
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
CDEBUG(D_DLMTRACE,
"Dropping as many unused locks as possible before replay for namespace %s (%d)\n",
int ldlm_replay_locks(struct obd_import *imp)
{
struct ldlm_namespace *ns = imp->imp_obd->obd_namespace;
- struct list_head list = LIST_HEAD_INIT(list);
+ LIST_HEAD(list);
struct ldlm_lock *lock, *next;
int rc = 0;
mutex_lock(&lov->lov_lock);
/* ok to dec to 0 more than once -- ltd_exp's will be null */
if (atomic_dec_and_test(&lov->lov_refcount) && lov->lov_death_row) {
- struct list_head kill = LIST_HEAD_INIT(kill);
+ LIST_HEAD(kill);
struct lov_tgt_desc *tgt, *n;
int i;
enum ldlm_mode mode;
bool glimpse = *flags & LDLM_FL_HAS_INTENT;
__u64 match_flags = *flags;
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
int rc, count;
ENTRY;
const void *lmm = op_data->op_data;
__u32 lmmsize = op_data->op_data_size;
__u32 mdt_md_capsule_size;
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
int count = 0;
enum ldlm_mode mode;
int rc;
struct ptlrpc_request *req;
struct ldlm_intent *lit;
int rc, count = 0;
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
u32 ea_vals_buf_size = GA_DEFAULT_EA_VAL_LEN * GA_DEFAULT_EA_NUM;
ENTRY;
struct md_op_data *op_data)
{
struct obd_device *obd = class_exp2obd(exp);
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
struct ptlrpc_request *req;
struct ldlm_intent *lit;
struct layout_intent *layout;
int mdc_setattr(struct obd_export *exp, struct md_op_data *op_data,
void *ea, size_t ealen, struct ptlrpc_request **request)
{
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
struct ptlrpc_request *req;
int count = 0, rc;
__u64 bits;
int count, resends = 0;
struct obd_import *import = exp->exp_obd->u.cli.cl_import;
int generation = import->imp_generation;
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
ENTRY;
/* For case if upper layer did not alloc fid, do it now. */
int mdc_unlink(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **request)
{
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
struct obd_device *obd = class_exp2obd(exp);
struct ptlrpc_request *req = *request;
int count = 0, rc;
int mdc_link(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **request)
{
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
struct ptlrpc_request *req;
int count = 0, rc;
ENTRY;
const char *old, size_t oldlen, const char *new, size_t newlen,
struct ptlrpc_request **request)
{
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
struct obd_device *obd = exp->exp_obd;
struct ptlrpc_request *req;
int count = 0, rc;
int mdc_file_resync(struct obd_export *exp, struct md_op_data *op_data)
{
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
struct ptlrpc_request *req;
struct ldlm_lock *lock;
struct mdt_rec_resync *rec;
/* Flush local XATTR locks to get rid of a possible cancel RPC */
if (opcode == MDS_REINT && fid_is_sane(fid) &&
exp->exp_connect_data.ocd_ibits_known & MDS_INODELOCK_XATTR) {
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
int count;
/* Without that packing would fail */
static int mdc_ioc_swap_layouts(struct obd_export *exp,
struct md_op_data *op_data)
{
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
struct ptlrpc_request *req;
int rc, count;
struct mdc_swap_layouts *msl, *payload;
EXPORT_SYMBOL(mgc_logname2resid);
/********************** config llog list **********************/
-static struct list_head config_llog_list = LIST_HEAD_INIT(config_llog_list);
+static LIST_HEAD(config_llog_list);
static DEFINE_SPINLOCK(config_list_lock); /* protects config_llog_list */
/* Take a reference to a config log */
struct ldlm_resource *res;
struct ldlm_glimpse_work *work;
struct ldlm_glimpse_work *tmp;
- struct list_head gl_list = LIST_HEAD_INIT(gl_list);
+ LIST_HEAD(gl_list);
struct list_head *pos;
int i;
int rc;
static void mgs_nidtbl_fini_fs(struct fs_db *fsdb)
{
struct mgs_nidtbl *tbl = &fsdb->fsdb_nidtbl;
- struct list_head head = LIST_HEAD_INIT(head);
+ LIST_HEAD(head);
mutex_lock(&tbl->mn_lock);
tbl->mn_nr_targets = 0;
{
struct mgs_export_data *data = &exp->u.eu_mgs_data;
struct mgs_fsc *fsc, *tmp;
- struct list_head head = LIST_HEAD_INIT(head);
+ LIST_HEAD(head);
spin_lock(&data->med_lock);
list_splice_init(&data->med_clients, &head);
struct osc_object *osc)
__must_hold(osc)
{
- struct list_head rpclist = LIST_HEAD_INIT(rpclist);
+ LIST_HEAD(rpclist);
struct osc_extent *ext;
struct osc_extent *tmp;
struct osc_extent *first = NULL;
{
struct osc_extent *ext;
struct osc_extent *next;
- struct list_head rpclist = LIST_HEAD_INIT(rpclist);
+ LIST_HEAD(rpclist);
struct extent_rpc_data data = {
.erd_rpc_list = &rpclist,
.erd_page_count = 0,
struct osc_extent *ext;
struct osc_extent *waiting = NULL;
pgoff_t index;
- struct list_head list = LIST_HEAD_INIT(list);
+ LIST_HEAD(list);
int result = 0;
bool partial;
ENTRY;
pgoff_t start, pgoff_t end, int hp, int discard)
{
struct osc_extent *ext;
- struct list_head discard_list = LIST_HEAD_INIT(discard_list);
+ LIST_HEAD(discard_list);
bool unplug = false;
int result = 0;
ENTRY;
struct osc_object *osc = NULL; /* to keep gcc happy */
struct osc_page *opg;
struct cl_io *io;
- struct list_head list = LIST_HEAD_INIT(list);
+ LIST_HEAD(list);
struct cl_page_list *qin = &queue->c2_qin;
struct cl_page_list *qout = &queue->c2_qout;
void osc_lru_add_batch(struct client_obd *cli, struct list_head *plist)
{
- struct list_head lru = LIST_HEAD_INIT(lru);
+ LIST_HEAD(lru);
struct osc_async_page *oap;
long npages = 0;
struct client_obd *cli = &exp->exp_obd->u.cli;
struct ptlrpc_request *req;
struct ost_body *body;
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
int rc, count;
ENTRY;
int grant = 0;
int rc;
__u32 layout_version = 0;
- struct list_head rpc_list = LIST_HEAD_INIT(rpc_list);
+ LIST_HEAD(rpc_list);
struct ost_body *body;
ENTRY;
LASSERT(!list_empty(ext_list));
};
static struct shrinker *osc_cache_shrinker;
-struct list_head osc_shrink_list = LIST_HEAD_INIT(osc_shrink_list);
+LIST_HEAD(osc_shrink_list);
DEFINE_SPINLOCK(osc_shrink_lock);
#ifndef HAVE_SHRINKER_COUNT
struct osd_device *osd = osd_dt_dev(th->th_dev);
struct qsd_instance *qsd = osd_def_qsd(osd);
struct lquota_trans *qtrans;
- struct list_head truncates = LIST_HEAD_INIT(truncates);
+ LIST_HEAD(truncates);
int rc = 0, remove_agents = 0;
ENTRY;
*
* No locking. Callers synchronize.
*/
-static struct list_head iam_formats = LIST_HEAD_INIT(iam_formats);
+static LIST_HEAD(iam_formats);
void iam_format_register(struct iam_format *fmt)
{
#include "gss_api.h"
#include "gss_crypto.h"
-static struct list_head registered_mechs = LIST_HEAD_INIT(registered_mechs);
+static LIST_HEAD(registered_mechs);
static DEFINE_SPINLOCK(registered_mechs_lock);
int lgss_mech_register(struct gss_api_mech *gm)
qmt_glimpse_cb_t cb, void *arg)
{
struct list_head *tmp, *pos;
- struct list_head gl_list = LIST_HEAD_INIT(gl_list);
+ LIST_HEAD(gl_list);
struct qmt_gl_lock_array locks;
unsigned long i;
int rc = 0;
#include "qsd_internal.h"
-static struct list_head qfs_list = LIST_HEAD_INIT(qfs_list);
+static LIST_HEAD(qfs_list);
/* protect the qfs_list */
static DEFINE_SPINLOCK(qfs_list_lock);