Searched refs:nn (Results 1 - 65 of 65) sorted by relevance

/linux-4.1.27/lib/reed_solomon/
H A Dencode_rs.c22 int nn = rs->nn; variable
28 uint16_t msk = (uint16_t) rs->nn;
31 pad = nn - nroots - len;
32 if (pad < 0 || pad >= nn)
38 if (fb != nn) {
46 if (fb != nn) {
H A Ddecode_rs.c22 int nn = rs->nn; variable
38 uint16_t msk = (uint16_t) rs->nn;
41 pad = nn - nroots - len;
42 BUG_ON(pad < 0 || pad >= nn);
102 prim * (nn - 1 - eras_pos[0]))];
104 u = rs_modnn(rs, prim * (nn - 1 - eras_pos[i]));
107 if (tmp != nn) {
128 if ((lambda[i] != 0) && (s[r - i - 1] != nn)) {
136 if (discr_r == nn) {
139 b[0] = nn;
144 if (b[i] != nn) {
158 b[i] = (lambda[i] == 0) ? nn :
160 - discr_r + nn);
165 b[0] = nn;
175 if (lambda[i] != nn)
181 for (i = 1, k = iprim - 1; i <= nn; i++, k = rs_modnn(rs, k + iprim)) {
184 if (reg[j] != nn) {
216 if ((s[i - j] != nn) && (lambda[j] != nn))
230 if (omega[i] != nn)
234 num2 = alpha_to[rs_modnn(rs, root[j] * (fcr - 1) + nn)];
240 if (lambda[i + 1] != nn) {
249 nn - index_of[den])];
258 if (data && (loc[j] < (nn - nroots)))
H A Dreed_solomon.c80 rs->nn = (1 << symsize) - 1; rs_init()
88 rs->alpha_to = kmalloc(sizeof(uint16_t) * (rs->nn + 1), GFP_KERNEL); rs_init()
92 rs->index_of = kmalloc(sizeof(uint16_t) * (rs->nn + 1), GFP_KERNEL); rs_init()
101 rs->index_of[0] = rs->nn; /* log(zero) = -inf */ rs_init()
102 rs->alpha_to[rs->nn] = 0; /* alpha**-inf = 0 */ rs_init()
105 for (i = 0; i < rs->nn; i++) { rs_init()
111 sr &= rs->nn; rs_init()
115 for (i = 0; i < rs->nn; i++) { rs_init()
126 for(iprim = 1; (iprim % prim) != 0; iprim += rs->nn); rs_init()
/linux-4.1.27/fs/nfs/blocklayout/
H A Drpc_pipefs.c57 struct nfs_net *nn = net_generic(net, nfs_net_id); bl_resolve_deviceid() local
58 struct bl_dev_msg *reply = &nn->bl_mount_reply; bl_resolve_deviceid()
68 mutex_lock(&nn->bl_mutex); bl_resolve_deviceid()
69 bl_pipe_msg.bl_wq = &nn->bl_wq; bl_resolve_deviceid()
87 add_wait_queue(&nn->bl_wq, &wq); bl_resolve_deviceid()
88 rc = rpc_queue_upcall(nn->bl_device_pipe, msg); bl_resolve_deviceid()
90 remove_wait_queue(&nn->bl_wq, &wq); bl_resolve_deviceid()
96 remove_wait_queue(&nn->bl_wq, &wq); bl_resolve_deviceid()
108 mutex_unlock(&nn->bl_mutex); bl_resolve_deviceid()
115 struct nfs_net *nn = net_generic(file_inode(filp)->i_sb->s_fs_info, bl_pipe_downcall() local
121 if (copy_from_user(&nn->bl_mount_reply, src, mlen) != 0) bl_pipe_downcall()
124 wake_up(&nn->bl_wq); bl_pipe_downcall()
170 struct nfs_net *nn = net_generic(net, nfs_net_id); rpc_pipefs_event() local
177 if (nn->bl_device_pipe == NULL) { rpc_pipefs_event()
184 dentry = nfs4blocklayout_register_sb(sb, nn->bl_device_pipe); rpc_pipefs_event()
189 nn->bl_device_pipe->dentry = dentry; rpc_pipefs_event()
192 if (nn->bl_device_pipe->dentry) rpc_pipefs_event()
193 nfs4blocklayout_unregister_sb(sb, nn->bl_device_pipe); rpc_pipefs_event()
235 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs4blocklayout_net_init() local
238 mutex_init(&nn->bl_mutex); nfs4blocklayout_net_init()
239 init_waitqueue_head(&nn->bl_wq); nfs4blocklayout_net_init()
240 nn->bl_device_pipe = rpc_mkpipe_data(&bl_upcall_ops, 0); nfs4blocklayout_net_init()
241 if (IS_ERR(nn->bl_device_pipe)) nfs4blocklayout_net_init()
242 return PTR_ERR(nn->bl_device_pipe); nfs4blocklayout_net_init()
243 dentry = nfs4blocklayout_register_net(net, nn->bl_device_pipe); nfs4blocklayout_net_init()
245 rpc_destroy_pipe_data(nn->bl_device_pipe); nfs4blocklayout_net_init()
248 nn->bl_device_pipe->dentry = dentry; nfs4blocklayout_net_init()
254 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs4blocklayout_net_exit() local
256 nfs4blocklayout_unregister_net(net, nn->bl_device_pipe); nfs4blocklayout_net_exit()
257 rpc_destroy_pipe_data(nn->bl_device_pipe); nfs4blocklayout_net_exit()
258 nn->bl_device_pipe = NULL; nfs4blocklayout_net_exit()
/linux-4.1.27/fs/nfsd/
H A Dnfs4recover.c174 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_create_clid_dir() local
178 if (!nn->rec_file) nfsd4_create_clid_dir()
189 status = mnt_want_write_file(nn->rec_file); nfsd4_create_clid_dir()
193 dir = nn->rec_file->f_path.dentry; nfsd4_create_clid_dir()
218 if (nn->in_grace) { nfsd4_create_clid_dir()
219 crp = nfs4_client_to_reclaim(dname, nn); nfsd4_create_clid_dir()
223 vfs_fsync(nn->rec_file, 0); nfsd4_create_clid_dir()
230 mnt_drop_write_file(nn->rec_file); nfsd4_create_clid_dir()
267 nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn) nfsd4_list_rec_dir() argument
270 struct dentry *dir = nn->rec_file->f_path.dentry; nfsd4_list_rec_dir()
281 status = vfs_llseek(nn->rec_file, 0, SEEK_SET); nfsd4_list_rec_dir()
287 status = iterate_dir(nn->rec_file, &ctx.ctx); nfsd4_list_rec_dir()
299 status = f(dir, dentry, nn); nfsd4_list_rec_dir()
311 nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn) nfsd4_unlink_clid_dir() argument
318 dir = nn->rec_file->f_path.dentry; nfsd4_unlink_clid_dir()
343 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_remove_clid_dir() local
345 if (!nn->rec_file || !test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) nfsd4_remove_clid_dir()
352 status = mnt_want_write_file(nn->rec_file); nfsd4_remove_clid_dir()
361 status = nfsd4_unlink_clid_dir(dname, HEXDIR_LEN-1, nn); nfsd4_remove_clid_dir()
364 vfs_fsync(nn->rec_file, 0); nfsd4_remove_clid_dir()
365 if (nn->in_grace) { nfsd4_remove_clid_dir()
367 crp = nfsd4_find_reclaim_client(dname, nn); nfsd4_remove_clid_dir()
369 nfs4_remove_reclaim_record(crp, nn); nfsd4_remove_clid_dir()
373 mnt_drop_write_file(nn->rec_file); nfsd4_remove_clid_dir()
381 purge_old(struct dentry *parent, struct dentry *child, struct nfsd_net *nn) purge_old() argument
385 if (nfs4_has_reclaimed_state(child->d_name.name, nn)) purge_old()
397 nfsd4_recdir_purge_old(struct nfsd_net *nn) nfsd4_recdir_purge_old() argument
401 nn->in_grace = false; nfsd4_recdir_purge_old()
402 if (!nn->rec_file) nfsd4_recdir_purge_old()
404 status = mnt_want_write_file(nn->rec_file); nfsd4_recdir_purge_old()
407 status = nfsd4_list_rec_dir(purge_old, nn); nfsd4_recdir_purge_old()
409 vfs_fsync(nn->rec_file, 0); nfsd4_recdir_purge_old()
410 mnt_drop_write_file(nn->rec_file); nfsd4_recdir_purge_old()
412 nfs4_release_reclaim(nn); nfsd4_recdir_purge_old()
415 " directory %pD\n", nn->rec_file); nfsd4_recdir_purge_old()
419 load_recdir(struct dentry *parent, struct dentry *child, struct nfsd_net *nn) load_recdir() argument
427 nfs4_client_to_reclaim(child->d_name.name, nn); load_recdir()
434 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_recdir_load() local
436 if (!nn->rec_file) nfsd4_recdir_load()
439 status = nfsd4_list_rec_dir(load_recdir, nn); nfsd4_recdir_load()
442 " directory %pD\n", nn->rec_file); nfsd4_recdir_load()
453 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_init_recdir() local
460 BUG_ON(nn->rec_file); nfsd4_init_recdir()
470 nn->rec_file = filp_open(user_recovery_dirname, O_RDONLY | O_DIRECTORY, 0); nfsd4_init_recdir()
471 if (IS_ERR(nn->rec_file)) { nfsd4_init_recdir()
474 status = PTR_ERR(nn->rec_file); nfsd4_init_recdir()
475 nn->rec_file = NULL; nfsd4_init_recdir()
480 nn->in_grace = true; nfsd4_init_recdir()
487 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_shutdown_recdir() local
489 if (!nn->rec_file) nfsd4_shutdown_recdir()
491 fput(nn->rec_file); nfsd4_shutdown_recdir()
492 nn->rec_file = NULL; nfsd4_shutdown_recdir()
498 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfs4_legacy_state_init() local
501 nn->reclaim_str_hashtbl = kmalloc(sizeof(struct list_head) * nfs4_legacy_state_init()
503 if (!nn->reclaim_str_hashtbl) nfs4_legacy_state_init()
507 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]); nfs4_legacy_state_init()
508 nn->reclaim_str_hashtbl_size = 0; nfs4_legacy_state_init()
516 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfs4_legacy_state_shutdown() local
518 kfree(nn->reclaim_str_hashtbl); nfs4_legacy_state_shutdown()
566 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_legacy_tracking_exit() local
568 nfs4_release_reclaim(nn); nfsd4_legacy_tracking_exit()
606 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_check_legacy_client() local
619 crp = nfsd4_find_reclaim_client(dname, nn); nfsd4_check_legacy_client()
708 struct nfsd_net *nn = net_generic(file_inode(filp)->i_sb->s_fs_info, cld_pipe_downcall() local
710 struct cld_net *cn = nn->cld_net; cld_pipe_downcall()
821 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_init_cld_pipe() local
824 if (nn->cld_net) nfsd4_init_cld_pipe()
848 nn->cld_net = cn; nfsd4_init_cld_pipe()
863 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_remove_cld_pipe() local
864 struct cld_net *cn = nn->cld_net; nfsd4_remove_cld_pipe()
868 kfree(nn->cld_net); nfsd4_remove_cld_pipe()
869 nn->cld_net = NULL; nfsd4_remove_cld_pipe()
920 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_cld_create() local
921 struct cld_net *cn = nn->cld_net; nfsd4_cld_create()
957 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_cld_remove() local
958 struct cld_net *cn = nn->cld_net; nfsd4_cld_remove()
994 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_cld_check() local
995 struct cld_net *cn = nn->cld_net; nfsd4_cld_check()
1024 nfsd4_cld_grace_done(struct nfsd_net *nn) nfsd4_cld_grace_done() argument
1028 struct cld_net *cn = nn->cld_net; nfsd4_cld_grace_done()
1037 cup->cu_msg.cm_u.cm_gracetime = (int64_t)nn->boot_time; nfsd4_cld_grace_done()
1252 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_umh_cltrack_init() local
1253 char *grace_start = nfsd4_cltrack_grace_start(nn->boot_time); nfsd4_umh_cltrack_init()
1287 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_umh_cltrack_create() local
1312 grace_start = nfsd4_cltrack_grace_start(nn->boot_time); nfsd4_umh_cltrack_create()
1382 nfsd4_umh_cltrack_grace_done(struct nfsd_net *nn) nfsd4_umh_cltrack_grace_done() argument
1387 sprintf(timestr, "%ld", nn->boot_time); nfsd4_umh_cltrack_grace_done()
1407 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_client_tracking_init() local
1410 if (nn->client_tracking_ops) nfsd4_client_tracking_init()
1417 nn->client_tracking_ops = &nfsd4_umh_tracking_ops; nfsd4_client_tracking_init()
1418 status = nn->client_tracking_ops->init(net); nfsd4_client_tracking_init()
1426 nn->client_tracking_ops = &nfsd4_legacy_tracking_ops; nfsd4_client_tracking_init()
1436 nn->client_tracking_ops = &nfsd4_cld_tracking_ops; nfsd4_client_tracking_init()
1441 status = nn->client_tracking_ops->init(net); nfsd4_client_tracking_init()
1445 nn->client_tracking_ops = NULL; nfsd4_client_tracking_init()
1453 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_client_tracking_exit() local
1455 if (nn->client_tracking_ops) { nfsd4_client_tracking_exit()
1456 if (nn->client_tracking_ops->exit) nfsd4_client_tracking_exit()
1457 nn->client_tracking_ops->exit(net); nfsd4_client_tracking_exit()
1458 nn->client_tracking_ops = NULL; nfsd4_client_tracking_exit()
1465 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_client_record_create() local
1467 if (nn->client_tracking_ops) nfsd4_client_record_create()
1468 nn->client_tracking_ops->create(clp); nfsd4_client_record_create()
1474 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_client_record_remove() local
1476 if (nn->client_tracking_ops) nfsd4_client_record_remove()
1477 nn->client_tracking_ops->remove(clp); nfsd4_client_record_remove()
1483 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_client_record_check() local
1485 if (nn->client_tracking_ops) nfsd4_client_record_check()
1486 return nn->client_tracking_ops->check(clp); nfsd4_client_record_check()
1492 nfsd4_record_grace_done(struct nfsd_net *nn) nfsd4_record_grace_done() argument
1494 if (nn->client_tracking_ops) nfsd4_record_grace_done()
1495 nn->client_tracking_ops->grace_done(nn); nfsd4_record_grace_done()
1503 struct nfsd_net *nn = net_generic(net, nfsd_net_id); rpc_pipefs_event() local
1504 struct cld_net *cn = nn->cld_net; rpc_pipefs_event()
H A Dnfssvc.c32 * nfsd_mutex protects nn->nfsd_serv -- both the pointer itself and the members
36 * If (out side the lock) nn->nfsd_serv is non-NULL, then it must point to a
179 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_nrthreads() local
182 if (nn->nfsd_serv) nfsd_nrthreads()
183 rv = nn->nfsd_serv->sv_nrthreads; nfsd_nrthreads()
191 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_init_socks() local
193 if (!list_empty(&nn->nfsd_serv->sv_permsocks)) nfsd_init_socks()
196 error = svc_create_xprt(nn->nfsd_serv, "udp", net, PF_INET, NFS_PORT, nfsd_init_socks()
201 error = svc_create_xprt(nn->nfsd_serv, "tcp", net, PF_INET, NFS_PORT, nfsd_init_socks()
259 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_startup_net() local
262 if (nn->nfsd_net_up) nfsd_startup_net()
272 if (nfsd_needs_lockd() && !nn->lockd_up) { nfsd_startup_net()
276 nn->lockd_up = 1; nfsd_startup_net()
283 nn->nfsd_net_up = true; nfsd_startup_net()
287 if (nn->lockd_up) { nfsd_startup_net()
289 nn->lockd_up = 0; nfsd_startup_net()
298 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_shutdown_net() local
301 if (nn->lockd_up) { nfsd_shutdown_net()
303 nn->lockd_up = 0; nfsd_shutdown_net()
305 nn->nfsd_net_up = false; nfsd_shutdown_net()
311 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_last_thread() local
319 if (!nn->nfsd_net_up) nfsd_last_thread()
397 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_create_serv() local
400 if (nn->nfsd_serv) { nfsd_create_serv()
401 svc_get(nn->nfsd_serv); nfsd_create_serv()
407 nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize, nfsd_create_serv()
409 if (nn->nfsd_serv == NULL) nfsd_create_serv()
412 nn->nfsd_serv->sv_maxconn = nn->max_connections; nfsd_create_serv()
413 error = svc_bind(nn->nfsd_serv, net); nfsd_create_serv()
415 svc_destroy(nn->nfsd_serv); nfsd_create_serv()
420 do_gettimeofday(&nn->nfssvc_boot); /* record boot time */ nfsd_create_serv()
426 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_nrpools() local
428 if (nn->nfsd_serv == NULL) nfsd_nrpools()
431 return nn->nfsd_serv->sv_nrpools; nfsd_nrpools()
437 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_get_nrthreads() local
439 if (nn->nfsd_serv != NULL) { nfsd_get_nrthreads()
440 for (i = 0; i < nn->nfsd_serv->sv_nrpools && i < n; i++) nfsd_get_nrthreads()
441 nthreads[i] = nn->nfsd_serv->sv_pools[i].sp_nrthreads; nfsd_get_nrthreads()
449 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_destroy() local
450 int destroy = (nn->nfsd_serv->sv_nrthreads == 1); nfsd_destroy()
453 svc_shutdown_net(nn->nfsd_serv, net); nfsd_destroy()
454 svc_destroy(nn->nfsd_serv); nfsd_destroy()
456 nn->nfsd_serv = NULL; nfsd_destroy()
464 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_set_nrthreads() local
468 if (nn->nfsd_serv == NULL || n <= 0) nfsd_set_nrthreads()
471 if (n > nn->nfsd_serv->sv_nrpools) nfsd_set_nrthreads()
472 n = nn->nfsd_serv->sv_nrpools; nfsd_set_nrthreads()
501 svc_get(nn->nfsd_serv); nfsd_set_nrthreads()
503 err = svc_set_num_threads(nn->nfsd_serv, &nn->nfsd_serv->sv_pools[i], nfsd_set_nrthreads()
522 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_svc() local
531 if (nrservs == 0 && nn->nfsd_serv == NULL) nfsd_svc()
538 nfsd_up_before = nn->nfsd_net_up; nfsd_svc()
543 error = svc_set_num_threads(nn->nfsd_serv, NULL, nrservs); nfsd_svc()
546 /* We are holding a reference to nn->nfsd_serv which nfsd_svc()
550 error = nn->nfsd_serv->sv_nrthreads - 1; nfsd_svc()
571 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd() local
606 rqstp->rq_server->sv_maxconn = nn->max_connections; nfsd()
728 struct nfsd_net *nn = net_generic(inode->i_sb->s_fs_info, nfsd_net_id); nfsd_pool_stats_open() local
731 if (nn->nfsd_serv == NULL) { nfsd_pool_stats_open()
736 svc_get(nn->nfsd_serv); nfsd_pool_stats_open()
737 ret = svc_pool_stats_open(nn->nfsd_serv, file); nfsd_pool_stats_open()
H A Dnfs4state.c123 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); get_client_locked() local
125 lockdep_assert_held(&nn->client_lock); get_client_locked()
137 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); renew_client_locked() local
151 list_move_tail(&clp->cl_lru, &nn->client_lru); renew_client_locked()
157 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); put_client_renew_locked() local
159 lockdep_assert_held(&nn->client_lock); put_client_renew_locked()
169 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); put_client_renew() local
171 if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock)) put_client_renew()
175 spin_unlock(&nn->client_lock); put_client_renew()
194 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_put_session_locked() local
196 lockdep_assert_held(&nn->client_lock); nfsd4_put_session_locked()
206 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); nfsd4_put_session() local
208 spin_lock(&nn->client_lock); nfsd4_put_session()
210 spin_unlock(&nn->client_lock); nfsd4_put_session()
1256 struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net, release_last_closed_stateid() local
1260 spin_lock(&nn->client_lock); release_last_closed_stateid()
1266 spin_unlock(&nn->client_lock); release_last_closed_stateid()
1564 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); init_session() local
1577 list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]); init_session()
1602 struct nfsd_net *nn = net_generic(net, nfsd_net_id); __find_in_sessionid_hashtbl() local
1604 lockdep_assert_held(&nn->client_lock); __find_in_sessionid_hashtbl()
1609 list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) { __find_in_sessionid_hashtbl()
1643 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); unhash_session() local
1645 lockdep_assert_held(&nn->client_lock); unhash_session()
1655 STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn) STALE_CLIENTID() argument
1662 if (clid->cl_boot == (u32)nn->boot_time) STALE_CLIENTID()
1665 clid->cl_boot, clid->cl_id, nn->boot_time); STALE_CLIENTID()
1737 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); unhash_client_locked() local
1740 lockdep_assert_held(&nn->client_lock); unhash_client_locked()
1748 rb_erase(&clp->cl_namenode, &nn->conf_name_tree); unhash_client_locked()
1750 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree); unhash_client_locked()
1762 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); unhash_client() local
1764 spin_lock(&nn->client_lock); unhash_client()
1766 spin_unlock(&nn->client_lock); unhash_client()
1959 static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn) gen_confirm() argument
1968 verf[1] = (__force __be32)nn->clientid_counter; gen_confirm()
1972 static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn) gen_clid() argument
1974 clp->cl_clientid.cl_boot = nn->boot_time; gen_clid()
1975 clp->cl_clientid.cl_id = nn->clientid_counter++; gen_clid()
1976 gen_confirm(clp, nn); gen_clid()
2078 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); add_to_unconfirmed() local
2080 lockdep_assert_held(&nn->client_lock); add_to_unconfirmed()
2083 add_clp_to_name_tree(clp, &nn->unconf_name_tree); add_to_unconfirmed()
2085 list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]); add_to_unconfirmed()
2093 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); move_to_confirmed() local
2095 lockdep_assert_held(&nn->client_lock); move_to_confirmed()
2098 list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]); move_to_confirmed()
2099 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree); move_to_confirmed()
2100 add_clp_to_name_tree(clp, &nn->conf_name_tree); move_to_confirmed()
2123 find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn) find_confirmed_client() argument
2125 struct list_head *tbl = nn->conf_id_hashtbl; find_confirmed_client()
2127 lockdep_assert_held(&nn->client_lock); find_confirmed_client()
2132 find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn) find_unconfirmed_client() argument
2134 struct list_head *tbl = nn->unconf_id_hashtbl; find_unconfirmed_client()
2136 lockdep_assert_held(&nn->client_lock); find_unconfirmed_client()
2146 find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn) find_confirmed_client_by_name() argument
2148 lockdep_assert_held(&nn->client_lock); find_confirmed_client_by_name()
2149 return find_clp_in_name_tree(name, &nn->conf_name_tree); find_confirmed_client_by_name()
2153 find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn) find_unconfirmed_client_by_name() argument
2155 lockdep_assert_held(&nn->client_lock); find_unconfirmed_client_by_name()
2156 return find_clp_in_name_tree(name, &nn->unconf_name_tree); find_unconfirmed_client_by_name()
2331 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_exchange_id() local
2359 spin_lock(&nn->client_lock); nfsd4_exchange_id()
2360 conf = find_confirmed_client_by_name(&exid->clname, nn); nfsd4_exchange_id()
2407 unconf = find_unconfirmed_client_by_name(&exid->clname, nn); nfsd4_exchange_id()
2421 gen_clid(new, nn); nfsd4_exchange_id()
2436 spin_unlock(&nn->client_lock); nfsd4_exchange_id()
2503 static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn) check_forechannel_attrs() argument
2505 u32 maxrpc = nn->nfsd_serv->sv_max_mesg; check_forechannel_attrs()
2589 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_create_session() local
2596 status = check_forechannel_attrs(&cr_ses->fore_channel, nn); nfsd4_create_session()
2610 spin_lock(&nn->client_lock); nfsd4_create_session()
2611 unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn); nfsd4_create_session()
2612 conf = find_confirmed_client(&cr_ses->clientid, true, nn); nfsd4_create_session()
2644 old = find_confirmed_client_by_name(&unconf->cl_name, nn); nfsd4_create_session()
2675 spin_unlock(&nn->client_lock); nfsd4_create_session()
2683 spin_unlock(&nn->client_lock); nfsd4_create_session()
2711 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_backchannel_ctl() local
2717 spin_lock(&nn->client_lock); nfsd4_backchannel_ctl()
2720 spin_unlock(&nn->client_lock); nfsd4_backchannel_ctl()
2735 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_bind_conn_to_session() local
2739 spin_lock(&nn->client_lock); nfsd4_bind_conn_to_session()
2741 spin_unlock(&nn->client_lock); nfsd4_bind_conn_to_session()
2778 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_destroy_session() local
2787 spin_lock(&nn->client_lock); nfsd4_destroy_session()
2798 spin_unlock(&nn->client_lock); nfsd4_destroy_session()
2802 spin_lock(&nn->client_lock); nfsd4_destroy_session()
2807 spin_unlock(&nn->client_lock); nfsd4_destroy_session()
2880 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_sequence() local
2893 spin_lock(&nn->client_lock); nfsd4_sequence()
2980 spin_unlock(&nn->client_lock); nfsd4_sequence()
3009 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_destroy_clientid() local
3011 spin_lock(&nn->client_lock); nfsd4_destroy_clientid()
3012 unconf = find_unconfirmed_client(&dc->clientid, true, nn); nfsd4_destroy_clientid()
3013 conf = find_confirmed_client(&dc->clientid, true, nn); nfsd4_destroy_clientid()
3038 spin_unlock(&nn->client_lock); nfsd4_destroy_clientid()
3090 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_setclientid() local
3096 spin_lock(&nn->client_lock); nfsd4_setclientid()
3097 conf = find_confirmed_client_by_name(&clname, nn); nfsd4_setclientid()
3112 unconf = find_unconfirmed_client_by_name(&clname, nn); nfsd4_setclientid()
3119 gen_clid(new, nn); nfsd4_setclientid()
3129 spin_unlock(&nn->client_lock); nfsd4_setclientid()
3148 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_setclientid_confirm() local
3150 if (STALE_CLIENTID(clid, nn)) nfsd4_setclientid_confirm()
3153 spin_lock(&nn->client_lock); nfsd4_setclientid_confirm()
3154 conf = find_confirmed_client(clid, false, nn); nfsd4_setclientid_confirm()
3155 unconf = find_unconfirmed_client(clid, false, nn); nfsd4_setclientid_confirm()
3181 old = find_confirmed_client_by_name(&unconf->cl_name, nn); nfsd4_setclientid_confirm()
3193 spin_unlock(&nn->client_lock); nfsd4_setclientid_confirm()
3195 spin_lock(&nn->client_lock); nfsd4_setclientid_confirm()
3198 spin_unlock(&nn->client_lock); nfsd4_setclientid_confirm()
3425 struct nfsd_net *nn = net_generic(s->st_stid.sc_client->net, move_to_close_lru() local
3447 spin_lock(&nn->client_lock); move_to_close_lru()
3450 list_move_tail(&oo->oo_close_lru, &nn->close_lru); move_to_close_lru()
3452 spin_unlock(&nn->client_lock); move_to_close_lru()
3532 struct nfsd_net *nn = net_generic(dp->dl_stid.sc_client->net, nfsd4_cb_recall_prepare() local
3547 list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru); nfsd4_cb_recall_prepare()
3668 struct nfsd_net *nn) lookup_clientid()
3679 if (STALE_CLIENTID(clid, nn)) lookup_clientid()
3688 spin_lock(&nn->client_lock); lookup_clientid()
3689 found = find_confirmed_client(clid, false, nn); lookup_clientid()
3691 spin_unlock(&nn->client_lock); lookup_clientid()
3695 spin_unlock(&nn->client_lock); lookup_clientid()
3704 struct nfsd4_open *open, struct nfsd_net *nn) nfsd4_process_open1()
3712 if (STALE_CLIENTID(&open->op_clientid, nn)) nfsd4_process_open1()
3722 status = lookup_clientid(clientid, cstate, nn); nfsd4_process_open1()
4352 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_renew() local
4356 status = lookup_clientid(clid, cstate, nn); nfsd4_renew()
4370 nfsd4_end_grace(struct nfsd_net *nn) nfsd4_end_grace() argument
4373 if (nn->grace_ended) nfsd4_end_grace()
4377 nn->grace_ended = true; nfsd4_end_grace()
4384 nfsd4_record_grace_done(nn); nfsd4_end_grace()
4394 locks_end_grace(&nn->nfsd4_manager); nfsd4_end_grace()
4403 nfs4_laundromat(struct nfsd_net *nn) nfs4_laundromat() argument
4410 time_t cutoff = get_seconds() - nn->nfsd4_lease; nfs4_laundromat()
4411 time_t t, new_timeo = nn->nfsd4_lease; nfs4_laundromat()
4414 nfsd4_end_grace(nn); nfs4_laundromat()
4416 spin_lock(&nn->client_lock); nfs4_laundromat()
4417 list_for_each_safe(pos, next, &nn->client_lru) { nfs4_laundromat()
4431 spin_unlock(&nn->client_lock); nfs4_laundromat()
4440 list_for_each_safe(pos, next, &nn->del_recall_lru) { nfs4_laundromat()
4442 if (net_generic(dp->dl_stid.sc_client->net, nfsd_net_id) != nn) nfs4_laundromat()
4460 spin_lock(&nn->client_lock); nfs4_laundromat()
4461 while (!list_empty(&nn->close_lru)) { nfs4_laundromat()
4462 oo = list_first_entry(&nn->close_lru, struct nfs4_openowner, nfs4_laundromat()
4473 spin_unlock(&nn->client_lock); nfs4_laundromat()
4475 spin_lock(&nn->client_lock); nfs4_laundromat()
4477 spin_unlock(&nn->client_lock); nfs4_laundromat()
4492 struct nfsd_net *nn = container_of(dwork, struct nfsd_net, laundromat_main() local
4495 t = nfs4_laundromat(nn); laundromat_main()
4497 queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ); laundromat_main()
4657 struct nfs4_stid **s, struct nfsd_net *nn) nfsd4_lookup_stateid()
4663 status = lookup_clientid(&stateid->si_opaque.so_clid, cstate, nn); nfsd4_lookup_stateid()
4717 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfs4_preprocess_stateid_op() local
4732 &s, nn); nfs4_preprocess_stateid_op()
4877 struct nfsd_net *nn) nfs4_preprocess_seqid_op()
4887 status = nfsd4_lookup_stateid(cstate, stateid, typemask, &s, nn); nfs4_preprocess_seqid_op()
4902 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn) nfs4_preprocess_confirmed_seqid_op()
4909 NFS4_OPEN_STID, &stp, nn); nfs4_preprocess_confirmed_seqid_op()
4929 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_open_confirm() local
4940 NFS4_OPEN_STID, &stp, nn); nfsd4_open_confirm()
4998 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_open_downgrade() local
5009 &od->od_stateid, &stp, nn); nfsd4_open_downgrade()
5071 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_close() local
5079 &stp, nn); nfsd4_close()
5103 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_delegreturn() local
5108 status = nfsd4_lookup_stateid(cstate, stateid, NFS4_DELEG_STID, &s, nn); nfsd4_delegreturn()
5452 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_lock() local
5475 if (STALE_CLIENTID(&lock->lk_new_clientid, nn)) nfsd4_lock()
5482 &open_stp, nn); nfsd4_lock()
5499 NFS4_LOCK_STID, &lock_stp, nn); nfsd4_lock()
5648 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_lockt() local
5657 status = lookup_clientid(&lockt->lt_clientid, cstate, nn); nfsd4_lockt()
5724 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_locku() local
5735 &stp, nn); nfsd4_locku()
5834 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_release_lockowner() local
5840 status = lookup_clientid(clid, cstate, nn); nfsd4_release_lockowner()
5879 nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn) nfs4_has_reclaimed_state() argument
5883 crp = nfsd4_find_reclaim_client(name, nn); nfs4_has_reclaimed_state()
5891 nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn) nfs4_client_to_reclaim() argument
5901 list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]); nfs4_client_to_reclaim()
5904 nn->reclaim_str_hashtbl_size++; nfs4_client_to_reclaim()
5910 nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn) nfs4_remove_reclaim_record() argument
5914 nn->reclaim_str_hashtbl_size--; nfs4_remove_reclaim_record()
5918 nfs4_release_reclaim(struct nfsd_net *nn) nfs4_release_reclaim() argument
5924 while (!list_empty(&nn->reclaim_str_hashtbl[i])) { nfs4_release_reclaim()
5925 crp = list_entry(nn->reclaim_str_hashtbl[i].next, nfs4_release_reclaim()
5927 nfs4_remove_reclaim_record(crp, nn); nfs4_release_reclaim()
5930 WARN_ON_ONCE(nn->reclaim_str_hashtbl_size); nfs4_release_reclaim()
5936 nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn) nfsd4_find_reclaim_client() argument
5944 list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) { nfsd4_find_reclaim_client()
5958 struct nfsd_net *nn) nfs4_check_open_reclaim()
5963 status = lookup_clientid(clid, cstate, nn); nfs4_check_open_reclaim()
5987 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_find_client() local
5990 if (!nfsd_netns_ready(nn)) nfsd_find_client()
5993 list_for_each_entry(clp, &nn->client_lru, cl_lru) { nfsd_find_client()
6005 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_print_clients() local
6009 if (!nfsd_netns_ready(nn)) nfsd_inject_print_clients()
6012 spin_lock(&nn->client_lock); nfsd_inject_print_clients()
6013 list_for_each_entry(clp, &nn->client_lru, cl_lru) { nfsd_inject_print_clients()
6018 spin_unlock(&nn->client_lock); nfsd_inject_print_clients()
6028 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_forget_client() local
6031 if (!nfsd_netns_ready(nn)) nfsd_inject_forget_client()
6034 spin_lock(&nn->client_lock); nfsd_inject_forget_client()
6042 spin_unlock(&nn->client_lock); nfsd_inject_forget_client()
6055 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_forget_clients() local
6059 if (!nfsd_netns_ready(nn)) nfsd_inject_forget_clients()
6062 spin_lock(&nn->client_lock); nfsd_inject_forget_clients()
6063 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) { nfsd_inject_forget_clients()
6070 spin_unlock(&nn->client_lock); nfsd_inject_forget_clients()
6091 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_add_lock_to_list() local
6097 lockdep_assert_held(&nn->client_lock); nfsd_inject_add_lock_to_list()
6162 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_print_locks() local
6165 if (!nfsd_netns_ready(nn)) nfsd_inject_print_locks()
6168 spin_lock(&nn->client_lock); nfsd_inject_print_locks()
6169 list_for_each_entry(clp, &nn->client_lru, cl_lru) nfsd_inject_print_locks()
6171 spin_unlock(&nn->client_lock); nfsd_inject_print_locks()
6195 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_forget_client_locks() local
6199 if (!nfsd_netns_ready(nn)) nfsd_inject_forget_client_locks()
6202 spin_lock(&nn->client_lock); nfsd_inject_forget_client_locks()
6206 spin_unlock(&nn->client_lock); nfsd_inject_forget_client_locks()
6216 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_forget_locks() local
6220 if (!nfsd_netns_ready(nn)) nfsd_inject_forget_locks()
6223 spin_lock(&nn->client_lock); nfsd_inject_forget_locks()
6224 list_for_each_entry(clp, &nn->client_lru, cl_lru) { nfsd_inject_forget_locks()
6229 spin_unlock(&nn->client_lock); nfsd_inject_forget_locks()
6240 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_foreach_client_openowner() local
6244 lockdep_assert_held(&nn->client_lock); nfsd_foreach_client_openowner()
6293 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_print_openowners() local
6296 if (!nfsd_netns_ready(nn)) nfsd_inject_print_openowners()
6299 spin_lock(&nn->client_lock); nfsd_inject_print_openowners()
6300 list_for_each_entry(clp, &nn->client_lru, cl_lru) nfsd_inject_print_openowners()
6302 spin_unlock(&nn->client_lock); nfsd_inject_print_openowners()
6327 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_forget_client_openowners() local
6331 if (!nfsd_netns_ready(nn)) nfsd_inject_forget_client_openowners()
6334 spin_lock(&nn->client_lock); nfsd_inject_forget_client_openowners()
6338 spin_unlock(&nn->client_lock); nfsd_inject_forget_client_openowners()
6348 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_forget_openowners() local
6352 if (!nfsd_netns_ready(nn)) nfsd_inject_forget_openowners()
6355 spin_lock(&nn->client_lock); nfsd_inject_forget_openowners()
6356 list_for_each_entry(clp, &nn->client_lru, cl_lru) { nfsd_inject_forget_openowners()
6362 spin_unlock(&nn->client_lock); nfsd_inject_forget_openowners()
6371 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_find_all_delegations() local
6375 lockdep_assert_held(&nn->client_lock); nfsd_find_all_delegations()
6422 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_print_delegations() local
6425 if (!nfsd_netns_ready(nn)) nfsd_inject_print_delegations()
6428 spin_lock(&nn->client_lock); nfsd_inject_print_delegations()
6429 list_for_each_entry(clp, &nn->client_lru, cl_lru) nfsd_inject_print_delegations()
6431 spin_unlock(&nn->client_lock); nfsd_inject_print_delegations()
6456 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_forget_client_delegations() local
6460 if (!nfsd_netns_ready(nn)) nfsd_inject_forget_client_delegations()
6463 spin_lock(&nn->client_lock); nfsd_inject_forget_client_delegations()
6467 spin_unlock(&nn->client_lock); nfsd_inject_forget_client_delegations()
6478 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_forget_delegations() local
6482 if (!nfsd_netns_ready(nn)) nfsd_inject_forget_delegations()
6485 spin_lock(&nn->client_lock); nfsd_inject_forget_delegations()
6486 list_for_each_entry(clp, &nn->client_lru, cl_lru) { nfsd_inject_forget_delegations()
6491 spin_unlock(&nn->client_lock); nfsd_inject_forget_delegations()
6525 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_recall_client_delegations() local
6529 if (!nfsd_netns_ready(nn)) nfsd_inject_recall_client_delegations()
6532 spin_lock(&nn->client_lock); nfsd_inject_recall_client_delegations()
6536 spin_unlock(&nn->client_lock); nfsd_inject_recall_client_delegations()
6547 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_inject_recall_delegations() local
6551 if (!nfsd_netns_ready(nn)) nfsd_inject_recall_delegations()
6554 spin_lock(&nn->client_lock); nfsd_inject_recall_delegations()
6555 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) { nfsd_inject_recall_delegations()
6560 spin_unlock(&nn->client_lock); nfsd_inject_recall_delegations()
6589 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfs4_state_create_net() local
6592 nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) * nfs4_state_create_net()
6594 if (!nn->conf_id_hashtbl) nfs4_state_create_net()
6596 nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) * nfs4_state_create_net()
6598 if (!nn->unconf_id_hashtbl) nfs4_state_create_net()
6600 nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) * nfs4_state_create_net()
6602 if (!nn->sessionid_hashtbl) nfs4_state_create_net()
6606 INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]); nfs4_state_create_net()
6607 INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]); nfs4_state_create_net()
6610 INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]); nfs4_state_create_net()
6611 nn->conf_name_tree = RB_ROOT; nfs4_state_create_net()
6612 nn->unconf_name_tree = RB_ROOT; nfs4_state_create_net()
6613 INIT_LIST_HEAD(&nn->client_lru); nfs4_state_create_net()
6614 INIT_LIST_HEAD(&nn->close_lru); nfs4_state_create_net()
6615 INIT_LIST_HEAD(&nn->del_recall_lru); nfs4_state_create_net()
6616 spin_lock_init(&nn->client_lock); nfs4_state_create_net()
6618 INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main); nfs4_state_create_net()
6624 kfree(nn->unconf_id_hashtbl); nfs4_state_create_net()
6626 kfree(nn->conf_id_hashtbl); nfs4_state_create_net()
6636 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfs4_state_destroy_net() local
6639 while (!list_empty(&nn->conf_id_hashtbl[i])) { nfs4_state_destroy_net()
6640 clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash); nfs4_state_destroy_net()
6646 while (!list_empty(&nn->unconf_id_hashtbl[i])) { nfs4_state_destroy_net()
6647 clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash); nfs4_state_destroy_net()
6652 kfree(nn->sessionid_hashtbl); nfs4_state_destroy_net()
6653 kfree(nn->unconf_id_hashtbl); nfs4_state_destroy_net()
6654 kfree(nn->conf_id_hashtbl); nfs4_state_destroy_net()
6661 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfs4_state_start_net() local
6667 nn->boot_time = get_seconds(); nfs4_state_start_net()
6668 nn->grace_ended = false; nfs4_state_start_net()
6669 locks_start_grace(net, &nn->nfsd4_manager); nfs4_state_start_net()
6672 nn->nfsd4_grace, net); nfs4_state_start_net()
6673 queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ); nfs4_state_start_net()
6711 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfs4_state_shutdown_net() local
6713 cancel_delayed_work_sync(&nn->laundromat_work); nfs4_state_shutdown_net()
6714 locks_end_grace(&nn->nfsd4_manager); nfs4_state_shutdown_net()
6718 list_for_each_safe(pos, next, &nn->del_recall_lru) { nfs4_state_shutdown_net()
3666 lookup_clientid(clientid_t *clid, struct nfsd4_compound_state *cstate, struct nfsd_net *nn) lookup_clientid() argument
3703 nfsd4_process_open1(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct nfsd_net *nn) nfsd4_process_open1() argument
4655 nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid, unsigned char typemask, struct nfs4_stid **s, struct nfsd_net *nn) nfsd4_lookup_stateid() argument
4874 nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid, stateid_t *stateid, char typemask, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn) nfs4_preprocess_seqid_op() argument
4901 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid, stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn) nfs4_preprocess_confirmed_seqid_op() argument
5956 nfs4_check_open_reclaim(clientid_t *clid, struct nfsd4_compound_state *cstate, struct nfsd_net *nn) nfs4_check_open_reclaim() argument
H A Dnfsctl.c140 struct nfsd_net *nn = net_generic(net, nfsd_net_id); exports_net_open() local
147 seq->private = nn->svc_export_cache; exports_net_open()
550 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); __write_versions() local
553 if (nn->nfsd_serv) __write_versions()
555 * nn->nfsd_serv->sv_xdrsize, and reallocing __write_versions()
688 struct nfsd_net *nn = net_generic(net, nfsd_net_id); __write_ports_names() local
690 if (nn->nfsd_serv == NULL) __write_ports_names()
692 return svc_xprt_names(nn->nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT); __write_ports_names()
704 struct nfsd_net *nn = net_generic(net, nfsd_net_id); __write_ports_addfd() local
719 err = svc_addsock(nn->nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT); __write_ports_addfd()
726 nn->nfsd_serv->sv_nrthreads--; __write_ports_addfd()
739 struct nfsd_net *nn = net_generic(net, nfsd_net_id); __write_ports_addxprt() local
751 err = svc_create_xprt(nn->nfsd_serv, transport, net, __write_ports_addxprt()
756 err = svc_create_xprt(nn->nfsd_serv, transport, net, __write_ports_addxprt()
762 nn->nfsd_serv->sv_nrthreads--; __write_ports_addxprt()
765 xprt = svc_find_xprt(nn->nfsd_serv, transport, net, PF_INET, port); __write_ports_addxprt()
870 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); write_maxblksize() local
884 if (nn->nfsd_serv) { write_maxblksize()
919 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); write_maxconn() local
920 unsigned int maxconn = nn->max_connections; write_maxconn()
927 nn->max_connections = maxconn; write_maxconn()
935 time_t *time, struct nfsd_net *nn) __nfsd4_write_time()
941 if (nn->nfsd_serv) __nfsd4_write_time()
967 time_t *time, struct nfsd_net *nn) nfsd4_write_time()
972 rv = __nfsd4_write_time(file, buf, size, time, nn); nfsd4_write_time()
1000 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); write_leasetime() local
1001 return nfsd4_write_time(file, buf, size, &nn->nfsd4_lease, nn); write_leasetime()
1016 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); write_gracetime() local
1017 return nfsd4_write_time(file, buf, size, &nn->nfsd4_grace, nn); write_gracetime()
1021 struct nfsd_net *nn) __write_recoverydir()
1028 if (nn->nfsd_serv) __write_recoverydir()
1072 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); write_recoverydir() local
1075 rv = __write_recoverydir(file, buf, size, nn); write_recoverydir()
1102 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); write_v4_end_grace() local
1109 nfsd4_end_grace(nn); write_v4_end_grace()
1117 nn->grace_ended ? 'Y' : 'N'); write_v4_end_grace()
1217 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_init_net() local
1225 nn->nfsd4_lease = 90; /* default lease time */ nfsd_init_net()
1226 nn->nfsd4_grace = 90; nfsd_init_net()
934 __nfsd4_write_time(struct file *file, char *buf, size_t size, time_t *time, struct nfsd_net *nn) __nfsd4_write_time() argument
966 nfsd4_write_time(struct file *file, char *buf, size_t size, time_t *time, struct nfsd_net *nn) nfsd4_write_time() argument
1020 __write_recoverydir(struct file *file, char *buf, size_t size, struct nfsd_net *nn) __write_recoverydir() argument
H A Dnfs4idmap.c455 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_idmap_init() local
457 nn->idtoname_cache = cache_create_net(&idtoname_cache_template, net); nfsd_idmap_init()
458 if (IS_ERR(nn->idtoname_cache)) nfsd_idmap_init()
459 return PTR_ERR(nn->idtoname_cache); nfsd_idmap_init()
460 rv = cache_register_net(nn->idtoname_cache, net); nfsd_idmap_init()
463 nn->nametoid_cache = cache_create_net(&nametoid_cache_template, net); nfsd_idmap_init()
464 if (IS_ERR(nn->nametoid_cache)) { nfsd_idmap_init()
465 rv = PTR_ERR(nn->nametoid_cache); nfsd_idmap_init()
468 rv = cache_register_net(nn->nametoid_cache, net); nfsd_idmap_init()
474 cache_destroy_net(nn->nametoid_cache, net); nfsd_idmap_init()
476 cache_unregister_net(nn->idtoname_cache, net); nfsd_idmap_init()
478 cache_destroy_net(nn->idtoname_cache, net); nfsd_idmap_init()
485 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_idmap_shutdown() local
487 cache_unregister_net(nn->idtoname_cache, net); nfsd_idmap_shutdown()
488 cache_unregister_net(nn->nametoid_cache, net); nfsd_idmap_shutdown()
489 cache_destroy_net(nn->idtoname_cache, net); nfsd_idmap_shutdown()
490 cache_destroy_net(nn->nametoid_cache, net); nfsd_idmap_shutdown()
533 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); idmap_name_to_id() local
540 ret = idmap_lookup(rqstp, nametoid_lookup, &key, nn->nametoid_cache, &item); idmap_name_to_id()
546 cache_put(&item->h, nn->nametoid_cache); idmap_name_to_id()
573 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); idmap_id_to_name() local
576 ret = idmap_lookup(rqstp, idtoname_lookup, &key, nn->idtoname_cache, &item); idmap_id_to_name()
587 cache_put(&item->h, nn->idtoname_cache); idmap_id_to_name()
H A Dexport.c884 struct nfsd_net *nn = net_generic(net, nfsd_net_id); exp_rootfh() local
885 struct cache_detail *cd = nn->svc_export_cache; exp_rootfh()
925 struct nfsd_net *nn = net_generic(cd->net, nfsd_net_id); exp_find() local
926 struct svc_expkey *ek = exp_find_key(nn->svc_expkey_cache, clp, fsid_type, fsidv, reqp); exp_find()
931 cache_put(&ek->h, nn->svc_expkey_cache); exp_find()
973 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); rqst_exp_get_by_name() local
974 struct cache_detail *cd = nn->svc_export_cache; rqst_exp_get_by_name()
1004 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); rqst_exp_find() local
1005 struct cache_detail *cd = nn->svc_export_cache; rqst_exp_find()
1286 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_export_init() local
1290 nn->svc_export_cache = cache_create_net(&svc_export_cache_template, net); nfsd_export_init()
1291 if (IS_ERR(nn->svc_export_cache)) nfsd_export_init()
1292 return PTR_ERR(nn->svc_export_cache); nfsd_export_init()
1293 rv = cache_register_net(nn->svc_export_cache, net); nfsd_export_init()
1297 nn->svc_expkey_cache = cache_create_net(&svc_expkey_cache_template, net); nfsd_export_init()
1298 if (IS_ERR(nn->svc_expkey_cache)) { nfsd_export_init()
1299 rv = PTR_ERR(nn->svc_expkey_cache); nfsd_export_init()
1302 rv = cache_register_net(nn->svc_expkey_cache, net); nfsd_export_init()
1308 cache_destroy_net(nn->svc_expkey_cache, net); nfsd_export_init()
1310 cache_unregister_net(nn->svc_export_cache, net); nfsd_export_init()
1312 cache_destroy_net(nn->svc_export_cache, net); nfsd_export_init()
1322 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_export_flush() local
1324 cache_purge(nn->svc_expkey_cache); nfsd_export_flush()
1325 cache_purge(nn->svc_export_cache); nfsd_export_flush()
1334 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd_export_shutdown() local
1338 cache_unregister_net(nn->svc_expkey_cache, net); nfsd_export_shutdown()
1339 cache_unregister_net(nn->svc_export_cache, net); nfsd_export_shutdown()
1340 cache_destroy_net(nn->svc_expkey_cache, net); nfsd_export_shutdown()
1341 cache_destroy_net(nn->svc_export_cache, net); nfsd_export_shutdown()
H A Dnetns.h118 #define nfsd_netns_ready(nn) ((nn)->sessionid_hashtbl)
H A Dstate.h591 struct nfs4_stid **s, struct nfsd_net *nn);
599 struct nfsd_net *nn);
601 struct nfsd4_compound_state *cstate, struct nfsd_net *nn);
614 struct nfsd_net *nn);
615 extern bool nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn);
626 void nfsd4_end_grace(struct nfsd_net *nn);
634 extern void nfsd4_record_grace_done(struct nfsd_net *nn);
H A Dnfs3xdr.c721 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfs3svc_encode_writeres() local
727 *p++ = htonl(nn->nfssvc_boot.tv_sec); nfs3svc_encode_writeres()
728 *p++ = htonl(nn->nfssvc_boot.tv_usec); nfs3svc_encode_writeres()
1085 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfs3svc_encode_commitres() local
1090 *p++ = htonl(nn->nfssvc_boot.tv_sec); nfs3svc_encode_commitres()
1091 *p++ = htonl(nn->nfssvc_boot.tv_usec); nfs3svc_encode_commitres()
H A Dnfs4proc.c367 struct nfsd_net *nn = net_generic(net, nfsd_net_id); nfsd4_open() local
393 status = nfsd4_process_open1(&resp->cstate, open, nn); nfsd4_open()
435 cstate, nn); nfsd4_open()
580 struct nfsd_net *nn = net_generic(net, nfsd_net_id); gen_boot_verifier() local
586 verf[0] = (__force __be32)nn->nfssvc_boot.tv_sec; gen_boot_verifier()
587 verf[1] = (__force __be32)nn->nfssvc_boot.tv_usec; gen_boot_verifier()
H A Dnfs4callback.c683 struct nfsd_net *nn = net_generic(net, nfsd_net_id); max_cb_time() local
684 return max(nn->nfsd4_lease/10, (time_t)1) * HZ; max_cb_time()
H A Dxdr4.h681 struct nfsd4_open *open, struct nfsd_net *nn);
H A Dnfs4xdr.c2267 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); nfsd4_encode_fattr() local
2472 *p++ = cpu_to_be32(nn->nfsd4_lease); nfsd4_encode_fattr()
/linux-4.1.27/fs/ocfs2/cluster/
H A Dtcp.c297 static u8 o2net_num_from_nn(struct o2net_node *nn) o2net_num_from_nn() argument
299 BUG_ON(nn == NULL); o2net_num_from_nn()
300 return nn - o2net_nodes; o2net_num_from_nn()
305 static int o2net_prep_nsw(struct o2net_node *nn, struct o2net_status_wait *nsw) o2net_prep_nsw() argument
309 spin_lock(&nn->nn_lock); o2net_prep_nsw()
310 ret = idr_alloc(&nn->nn_status_idr, nsw, 0, 0, GFP_ATOMIC); o2net_prep_nsw()
313 list_add_tail(&nsw->ns_node_item, &nn->nn_status_list); o2net_prep_nsw()
315 spin_unlock(&nn->nn_lock); o2net_prep_nsw()
325 static void o2net_complete_nsw_locked(struct o2net_node *nn, o2net_complete_nsw_locked() argument
330 assert_spin_locked(&nn->nn_lock); o2net_complete_nsw_locked()
336 idr_remove(&nn->nn_status_idr, nsw->ns_id); o2net_complete_nsw_locked()
341 static void o2net_complete_nsw(struct o2net_node *nn, o2net_complete_nsw() argument
346 spin_lock(&nn->nn_lock); o2net_complete_nsw()
351 nsw = idr_find(&nn->nn_status_idr, id); o2net_complete_nsw()
356 o2net_complete_nsw_locked(nn, nsw, sys_status, status); o2net_complete_nsw()
359 spin_unlock(&nn->nn_lock); o2net_complete_nsw()
363 static void o2net_complete_nodes_nsw(struct o2net_node *nn) o2net_complete_nodes_nsw() argument
368 assert_spin_locked(&nn->nn_lock); o2net_complete_nodes_nsw()
370 list_for_each_entry_safe(nsw, tmp, &nn->nn_status_list, ns_node_item) { o2net_complete_nodes_nsw()
371 o2net_complete_nsw_locked(nn, nsw, O2NET_ERR_DIED, 0); o2net_complete_nodes_nsw()
376 o2net_num_from_nn(nn)); o2net_complete_nodes_nsw()
379 static int o2net_nsw_completed(struct o2net_node *nn, o2net_nsw_completed() argument
383 spin_lock(&nn->nn_lock); o2net_nsw_completed()
385 spin_unlock(&nn->nn_lock); o2net_nsw_completed()
503 static void o2net_set_nn_state(struct o2net_node *nn, o2net_set_nn_state() argument
507 int was_valid = nn->nn_sc_valid; o2net_set_nn_state()
508 int was_err = nn->nn_persistent_error; o2net_set_nn_state()
509 struct o2net_sock_container *old_sc = nn->nn_sc; o2net_set_nn_state()
511 assert_spin_locked(&nn->nn_lock); o2net_set_nn_state()
520 BUG_ON(sc && nn->nn_sc && nn->nn_sc != sc); o2net_set_nn_state()
528 o2net_num_from_nn(nn), nn->nn_sc, sc, nn->nn_sc_valid, valid, o2net_set_nn_state()
529 nn->nn_persistent_error, err); o2net_set_nn_state()
531 nn->nn_sc = sc; o2net_set_nn_state()
532 nn->nn_sc_valid = valid ? 1 : 0; o2net_set_nn_state()
533 nn->nn_persistent_error = err; o2net_set_nn_state()
536 if (nn->nn_persistent_error || nn->nn_sc_valid) o2net_set_nn_state()
537 wake_up(&nn->nn_sc_wq); o2net_set_nn_state()
539 if (was_valid && !was_err && nn->nn_persistent_error) { o2net_set_nn_state()
540 o2quo_conn_err(o2net_num_from_nn(nn)); o2net_set_nn_state()
541 queue_delayed_work(o2net_wq, &nn->nn_still_up, o2net_set_nn_state()
549 o2net_complete_nodes_nsw(nn); o2net_set_nn_state()
553 o2quo_conn_up(o2net_num_from_nn(nn)); o2net_set_nn_state()
554 cancel_delayed_work(&nn->nn_connect_expired); o2net_set_nn_state()
569 delay = (nn->nn_last_connect_attempt + o2net_set_nn_state()
575 queue_delayed_work(o2net_wq, &nn->nn_connect_work, delay); o2net_set_nn_state()
587 queue_delayed_work(o2net_wq, &nn->nn_connect_expired, delay); o2net_set_nn_state()
590 /* keep track of the nn's sc ref for the caller */ o2net_set_nn_state()
705 * with an sc and want to detach it from the nn if someone already hasn't beat
709 static void o2net_ensure_shutdown(struct o2net_node *nn, o2net_ensure_shutdown() argument
713 spin_lock(&nn->nn_lock); o2net_ensure_shutdown()
714 if (nn->nn_sc == sc) o2net_ensure_shutdown()
715 o2net_set_nn_state(nn, NULL, 0, err); o2net_ensure_shutdown()
716 spin_unlock(&nn->nn_lock); o2net_ensure_shutdown()
722 * sc detached from the nn. state_change will also trigger this callback
732 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num); o2net_shutdown_sc() local
748 o2net_ensure_shutdown(nn, sc, 0); o2net_shutdown_sc()
950 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num); o2net_sendpage() local
970 o2net_ensure_shutdown(nn, sc, 0); o2net_sendpage()
986 static int o2net_tx_can_proceed(struct o2net_node *nn, o2net_tx_can_proceed() argument
992 spin_lock(&nn->nn_lock); o2net_tx_can_proceed()
993 if (nn->nn_persistent_error) { o2net_tx_can_proceed()
996 *error = nn->nn_persistent_error; o2net_tx_can_proceed()
997 } else if (nn->nn_sc_valid) { o2net_tx_can_proceed()
998 kref_get(&nn->nn_sc->sc_kref); o2net_tx_can_proceed()
1001 *sc_ret = nn->nn_sc; o2net_tx_can_proceed()
1004 spin_unlock(&nn->nn_lock); o2net_tx_can_proceed()
1037 struct o2net_node *nn = o2net_nn_from_num(target_node); o2net_send_message_vec() local
1073 wait_event(nn->nn_sc_wq, o2net_tx_can_proceed(nn, &sc, &ret)); o2net_send_message_vec()
1100 ret = o2net_prep_nsw(nn, &nsw); o2net_send_message_vec()
1123 wait_event(nsw.ns_wq, o2net_nsw_completed(nn, &nsw)); o2net_send_message_vec()
1142 o2net_complete_nsw(nn, &nsw, 0, 0, 0); o2net_send_message_vec()
1186 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num); o2net_process_message() local
1199 o2net_complete_nsw(nn, NULL, o2net_process_message()
1274 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num); o2net_check_handshake() local
1284 o2net_ensure_shutdown(nn, sc, -ENOTCONN); o2net_check_handshake()
1300 o2net_ensure_shutdown(nn, sc, -ENOTCONN); o2net_check_handshake()
1311 o2net_ensure_shutdown(nn, sc, -ENOTCONN); o2net_check_handshake()
1322 o2net_ensure_shutdown(nn, sc, -ENOTCONN); o2net_check_handshake()
1328 spin_lock(&nn->nn_lock); o2net_check_handshake()
1331 if (nn->nn_sc == sc) { o2net_check_handshake()
1333 atomic_set(&nn->nn_timeout, 0); o2net_check_handshake()
1334 o2net_set_nn_state(nn, sc, 1, 0); o2net_check_handshake()
1336 spin_unlock(&nn->nn_lock); o2net_check_handshake()
1450 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num); o2net_rx_until_empty() local
1453 o2net_ensure_shutdown(nn, sc, 0); o2net_rx_until_empty()
1539 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num); o2net_idle_timer() local
1555 atomic_set(&nn->nn_timeout, 1); o2net_idle_timer()
1556 o2quo_conn_err(o2net_num_from_nn(nn)); o2net_idle_timer()
1557 queue_delayed_work(o2net_wq, &nn->nn_still_up, o2net_idle_timer()
1576 struct o2net_node *nn = o2net_nn_from_num(sc->sc_node->nd_num); o2net_sc_postpone_idle() local
1579 if (atomic_read(&nn->nn_timeout)) { o2net_sc_postpone_idle()
1580 o2quo_conn_up(o2net_num_from_nn(nn)); o2net_sc_postpone_idle()
1581 cancel_delayed_work(&nn->nn_still_up); o2net_sc_postpone_idle()
1582 atomic_set(&nn->nn_timeout, 0); o2net_sc_postpone_idle()
1590 /* this work func is kicked whenever a path sets the nn state which doesn't
1597 struct o2net_node *nn = o2net_start_connect() local
1615 if (o2nm_this_node() <= o2net_num_from_nn(nn)) o2net_start_connect()
1619 node = o2nm_get_node_by_num(o2net_num_from_nn(nn)); o2net_start_connect()
1631 spin_lock(&nn->nn_lock); o2net_start_connect()
1639 timeout = atomic_read(&nn->nn_timeout); o2net_start_connect()
1640 stop = (nn->nn_sc || o2net_start_connect()
1641 (nn->nn_persistent_error && o2net_start_connect()
1642 (nn->nn_persistent_error != -ENOTCONN || timeout == 0))); o2net_start_connect()
1643 spin_unlock(&nn->nn_lock); o2net_start_connect()
1647 nn->nn_last_connect_attempt = jiffies; o2net_start_connect()
1691 spin_lock(&nn->nn_lock); o2net_start_connect()
1692 /* handshake completion will set nn->nn_sc_valid */ o2net_start_connect()
1693 o2net_set_nn_state(nn, sc, 0, 0); o2net_start_connect()
1694 spin_unlock(&nn->nn_lock); o2net_start_connect()
1713 o2net_ensure_shutdown(nn, sc, 0); o2net_start_connect()
1728 struct o2net_node *nn = o2net_connect_expired() local
1731 spin_lock(&nn->nn_lock); o2net_connect_expired()
1732 if (!nn->nn_sc_valid) { o2net_connect_expired()
1736 o2net_num_from_nn(nn), o2net_connect_expired()
1740 o2net_set_nn_state(nn, NULL, 0, 0); o2net_connect_expired()
1742 spin_unlock(&nn->nn_lock); o2net_connect_expired()
1747 struct o2net_node *nn = o2net_still_up() local
1750 o2quo_hb_still_up(o2net_num_from_nn(nn)); o2net_still_up()
1757 struct o2net_node *nn = o2net_nn_from_num(node->nd_num); o2net_disconnect_node() local
1760 spin_lock(&nn->nn_lock); o2net_disconnect_node()
1761 atomic_set(&nn->nn_timeout, 0); o2net_disconnect_node()
1762 o2net_set_nn_state(nn, NULL, 0, -ENOTCONN); o2net_disconnect_node()
1763 spin_unlock(&nn->nn_lock); o2net_disconnect_node()
1766 cancel_delayed_work(&nn->nn_connect_expired); o2net_disconnect_node()
1767 cancel_delayed_work(&nn->nn_connect_work); o2net_disconnect_node()
1768 cancel_delayed_work(&nn->nn_still_up); o2net_disconnect_node()
1790 struct o2net_node *nn = o2net_nn_from_num(node_num); o2net_hb_node_up_cb() local
1797 nn->nn_last_connect_attempt = jiffies - o2net_hb_node_up_cb()
1805 spin_lock(&nn->nn_lock); o2net_hb_node_up_cb()
1806 atomic_set(&nn->nn_timeout, 0); o2net_hb_node_up_cb()
1807 if (nn->nn_persistent_error) o2net_hb_node_up_cb()
1808 o2net_set_nn_state(nn, NULL, 0, 0); o2net_hb_node_up_cb()
1809 spin_unlock(&nn->nn_lock); o2net_hb_node_up_cb()
1848 struct o2net_node *nn; o2net_accept_one() local
1929 nn = o2net_nn_from_num(node->nd_num); o2net_accept_one()
1931 spin_lock(&nn->nn_lock); o2net_accept_one()
1932 if (nn->nn_sc) o2net_accept_one()
1936 spin_unlock(&nn->nn_lock); o2net_accept_one()
1954 spin_lock(&nn->nn_lock); o2net_accept_one()
1955 atomic_set(&nn->nn_timeout, 0); o2net_accept_one()
1956 o2net_set_nn_state(nn, sc, 0, 0); o2net_accept_one()
1957 spin_unlock(&nn->nn_lock); o2net_accept_one()
2186 struct o2net_node *nn = o2net_nn_from_num(i); o2net_init() local
2188 atomic_set(&nn->nn_timeout, 0); o2net_init()
2189 spin_lock_init(&nn->nn_lock); o2net_init()
2190 INIT_DELAYED_WORK(&nn->nn_connect_work, o2net_start_connect); o2net_init()
2191 INIT_DELAYED_WORK(&nn->nn_connect_expired, o2net_init()
2193 INIT_DELAYED_WORK(&nn->nn_still_up, o2net_still_up); o2net_init()
2195 nn->nn_persistent_error = -ENOTCONN; o2net_init()
2196 init_waitqueue_head(&nn->nn_sc_wq); o2net_init()
2197 idr_init(&nn->nn_status_idr); o2net_init()
2198 INIT_LIST_HEAD(&nn->nn_status_list); o2net_init()
H A Dtcp_internal.h113 * shutdown is careful to first mark the nn such that no connects will
146 * the sc from the nn, and queues the work. in this case the
149 * still on the nn and will call ensure_shutdown itself.. this
152 * has to be careful to remove the sc from the nn before waiting
/linux-4.1.27/include/linux/
H A Drslib.h28 * @nn: Symbols per block (= (1<<mm)-1)
43 int nn; member in struct:rs_control
95 * rs->nn = (2^rs->mm) - 1
98 * >= 3 * rs->nn
102 while (x >= rs->nn) { rs_modnn()
103 x -= rs->nn; rs_modnn()
104 x = (x >> rs->mm) + (x & rs->nn); rs_modnn()
/linux-4.1.27/fs/nfs/
H A Dclient.c203 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs_cleanup_cb_ident_idr() local
205 idr_destroy(&nn->cb_ident_idr); nfs_cleanup_cb_ident_idr()
211 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); nfs_cb_idr_remove_locked() local
214 idr_remove(&nn->cb_ident_idr, clp->cl_cb_ident); nfs_cb_idr_remove_locked()
268 struct nfs_net *nn; nfs_put_client() local
274 nn = net_generic(clp->cl_net, nfs_net_id); nfs_put_client()
276 if (atomic_dec_and_lock(&clp->cl_count, &nn->nfs_client_lock)) { nfs_put_client()
279 spin_unlock(&nn->nfs_client_lock); nfs_put_client()
406 struct nfs_net *nn = net_generic(data->net, nfs_net_id); nfs_match_client() local
408 list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) { nfs_match_client()
484 struct nfs_net *nn = net_generic(cl_init->net, nfs_net_id); nfs_get_client() local
497 spin_lock(&nn->nfs_client_lock); nfs_get_client()
501 spin_unlock(&nn->nfs_client_lock); nfs_get_client()
508 &nn->nfs_client_list); nfs_get_client()
509 spin_unlock(&nn->nfs_client_lock); nfs_get_client()
514 spin_unlock(&nn->nfs_client_lock); nfs_get_client()
947 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); nfs_server_insert_lists() local
949 spin_lock(&nn->nfs_client_lock); nfs_server_insert_lists()
951 list_add_tail(&server->master_link, &nn->nfs_volume_list); nfs_server_insert_lists()
953 spin_unlock(&nn->nfs_client_lock); nfs_server_insert_lists()
961 struct nfs_net *nn; nfs_server_remove_lists() local
965 nn = net_generic(clp->cl_net, nfs_net_id); nfs_server_remove_lists()
966 spin_lock(&nn->nfs_client_lock); nfs_server_remove_lists()
971 spin_unlock(&nn->nfs_client_lock); nfs_server_remove_lists()
1184 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs_clients_init() local
1186 INIT_LIST_HEAD(&nn->nfs_client_list); nfs_clients_init()
1187 INIT_LIST_HEAD(&nn->nfs_volume_list); nfs_clients_init()
1189 idr_init(&nn->cb_ident_idr); nfs_clients_init()
1191 spin_lock_init(&nn->nfs_client_lock); nfs_clients_init()
1192 nn->boot_time = CURRENT_TIME; nfs_clients_init()
1254 __acquires(&nn->nfs_client_lock)
1256 struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id); variable in typeref:struct:nfs_net
1259 spin_lock(&nn->nfs_client_lock);
1260 return seq_list_start_head(&nn->nfs_client_list, *_pos);
1268 struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id); nfs_server_list_next() local
1270 return seq_list_next(v, &nn->nfs_client_list, pos); nfs_server_list_next()
1277 __releases(&nn->nfs_client_lock)
1279 struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id); variable in typeref:struct:nfs_net
1281 spin_unlock(&nn->nfs_client_lock);
1290 struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id); nfs_server_list_show() local
1293 if (v == &nn->nfs_client_list) { nfs_server_list_show()
1330 __acquires(&nn->nfs_client_lock)
1332 struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id); variable in typeref:struct:nfs_net
1335 spin_lock(&nn->nfs_client_lock);
1336 return seq_list_start_head(&nn->nfs_volume_list, *_pos);
1344 struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id); nfs_volume_list_next() local
1346 return seq_list_next(v, &nn->nfs_volume_list, pos); nfs_volume_list_next()
1353 __releases(&nn->nfs_client_lock)
1355 struct nfs_net *nn = net_generic(seq_file_net(p), nfs_net_id); variable in typeref:struct:nfs_net
1357 spin_unlock(&nn->nfs_client_lock);
1368 struct nfs_net *nn = net_generic(seq_file_net(m), nfs_net_id); nfs_volume_list_show() local
1371 if (v == &nn->nfs_volume_list) { nfs_volume_list_show()
1401 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs_fs_proc_net_init() local
1404 nn->proc_nfsfs = proc_net_mkdir(net, "nfsfs", net->proc_net); nfs_fs_proc_net_init()
1405 if (!nn->proc_nfsfs) nfs_fs_proc_net_init()
1410 nn->proc_nfsfs, &nfs_server_list_fops); nfs_fs_proc_net_init()
1416 nn->proc_nfsfs, &nfs_volume_list_fops); nfs_fs_proc_net_init()
H A Ddns_resolve.c341 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs_dns_resolve_name() local
343 ret = do_cache_lookup_wait(nn->nfs_dns_resolve, &key, &item); nfs_dns_resolve_name()
350 cache_put(&item->h, nn->nfs_dns_resolve); nfs_dns_resolve_name()
375 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs_dns_resolver_cache_init() local
377 nn->nfs_dns_resolve = cache_create_net(&nfs_dns_resolve_template, net); nfs_dns_resolver_cache_init()
378 if (IS_ERR(nn->nfs_dns_resolve)) nfs_dns_resolver_cache_init()
379 return PTR_ERR(nn->nfs_dns_resolve); nfs_dns_resolver_cache_init()
381 err = nfs_cache_register_net(net, nn->nfs_dns_resolve); nfs_dns_resolver_cache_init()
387 cache_destroy_net(nn->nfs_dns_resolve, net); nfs_dns_resolver_cache_init()
393 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs_dns_resolver_cache_destroy() local
395 nfs_cache_unregister_net(net, nn->nfs_dns_resolve); nfs_dns_resolver_cache_destroy()
396 cache_destroy_net(nn->nfs_dns_resolve, net); nfs_dns_resolver_cache_destroy()
419 struct nfs_net *nn = net_generic(net, nfs_net_id); rpc_pipefs_event() local
420 struct cache_detail *cd = nn->nfs_dns_resolve; rpc_pipefs_event()
H A Dnfs4client.c30 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); nfs_get_cb_ident_idr() local
35 spin_lock(&nn->nfs_client_lock); nfs_get_cb_ident_idr()
36 ret = idr_alloc(&nn->cb_ident_idr, clp, 1, 0, GFP_NOWAIT); nfs_get_cb_ident_idr()
39 spin_unlock(&nn->nfs_client_lock); nfs_get_cb_ident_idr()
436 struct nfs_net *nn = net_generic(keep->cl_net, nfs_net_id); nfs4_swap_callback_idents() local
445 spin_lock(&nn->nfs_client_lock); nfs4_swap_callback_idents()
447 idr_replace(&nn->cb_ident_idr, keep, drop->cl_cb_ident); nfs4_swap_callback_idents()
450 idr_replace(&nn->cb_ident_idr, drop, save); nfs4_swap_callback_idents()
453 spin_unlock(&nn->nfs_client_lock); nfs4_swap_callback_idents()
481 struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id); nfs40_walk_client_list() local
489 spin_lock(&nn->nfs_client_lock); nfs40_walk_client_list()
490 list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) { nfs40_walk_client_list()
502 spin_unlock(&nn->nfs_client_lock); nfs40_walk_client_list()
511 spin_lock(&nn->nfs_client_lock); nfs40_walk_client_list()
523 spin_unlock(&nn->nfs_client_lock); nfs40_walk_client_list()
550 spin_lock(&nn->nfs_client_lock); nfs40_walk_client_list()
552 spin_unlock(&nn->nfs_client_lock); nfs40_walk_client_list()
617 struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id); nfs41_walk_client_list() local
621 spin_lock(&nn->nfs_client_lock); nfs41_walk_client_list()
622 list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) { nfs41_walk_client_list()
639 spin_unlock(&nn->nfs_client_lock); nfs41_walk_client_list()
645 spin_lock(&nn->nfs_client_lock); nfs41_walk_client_list()
680 spin_unlock(&nn->nfs_client_lock); nfs41_walk_client_list()
703 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs4_find_client_ident() local
705 spin_lock(&nn->nfs_client_lock); nfs4_find_client_ident()
706 clp = idr_find(&nn->cb_ident_idr, cb_ident); nfs4_find_client_ident()
709 spin_unlock(&nn->nfs_client_lock); nfs4_find_client_ident()
751 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs4_find_client_sessionid() local
753 spin_lock(&nn->nfs_client_lock); nfs4_find_client_sessionid()
754 list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) { nfs4_find_client_sessionid()
767 spin_unlock(&nn->nfs_client_lock); nfs4_find_client_sessionid()
770 spin_unlock(&nn->nfs_client_lock); nfs4_find_client_sessionid()
H A Dcallback.c45 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs4_callback_up_net() local
51 nn->nfs_callback_tcpport = ret; nfs4_callback_up_net()
53 nn->nfs_callback_tcpport, PF_INET, net); nfs4_callback_up_net()
58 nn->nfs_callback_tcpport6 = ret; nfs4_callback_up_net()
60 nn->nfs_callback_tcpport6, PF_INET6, net); nfs4_callback_up_net()
257 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs_callback_down_net() local
259 if (--nn->cb_users[minorversion]) nfs_callback_down_net()
268 struct nfs_net *nn = net_generic(net, nfs_net_id); nfs_callback_up_net() local
271 if (nn->cb_users[minorversion]++) nfs_callback_up_net()
H A Dnfs4state.c79 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); nfs4_init_clientid() local
83 port = nn->nfs_callback_tcpport; nfs4_init_clientid()
85 port = nn->nfs_callback_tcpport6; nfs4_init_clientid()
124 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); nfs40_discover_server_trunking() local
128 port = nn->nfs_callback_tcpport; nfs40_discover_server_trunking()
130 port = nn->nfs_callback_tcpport6; nfs40_discover_server_trunking()
H A Dnfs4proc.c4961 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); nfs4_init_boot_verifier() local
4962 verf[0] = cpu_to_be32(nn->boot_time.tv_sec); nfs4_init_boot_verifier()
4963 verf[1] = cpu_to_be32(nn->boot_time.tv_nsec); nfs4_init_boot_verifier()
H A Dnfs4xdr.c1797 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); encode_create_session() local
1836 *p++ = cpu_to_be32(nn->boot_time.tv_nsec); /* stamp */ encode_create_session()
/linux-4.1.27/arch/powerpc/math-emu/
H A Dudivmodti4.c21 /* 0q = nn / 0D */ _fp_udivmodti4()
48 /* 0q = nn / 0D */ _fp_udivmodti4()
119 /* 00 = nn / DD */ _fp_udivmodti4()
/linux-4.1.27/arch/xtensa/include/asm/
H A Dmxregs.h20 * 00nn 0...0p..p Interrupt Routing, route IRQ n to processor p
/linux-4.1.27/tools/testing/selftests/rcutorture/bin/
H A Dkvm.sh66 echo " --mac nn:nn:nn:nn:nn:nn"
/linux-4.1.27/net/dccp/
H A Dfeat.c267 dccp_pr_debug_cat("%llu", (unsigned long long)val->nn); dccp_feat_printval()
278 fval.nn = dccp_decode_value_var(list, len); dccp_feat_printvals()
334 val = fval->nn; __dccp_feat_activate()
525 new->val.nn = 0; /* zeroes the whole structure */ dccp_feat_push_confirm()
659 dccp_encode_value_var(pos->val.nn, ptr, len); list_for_each_entry_safe_reverse()
703 dccp_feat_val fval = { .nn = nn_val }; __feat_register_nn()
779 return entry->val.nn; dccp_feat_nn_get()
804 dccp_feat_val fval = { .nn = nn_val }; dccp_feat_signal_nn_change()
820 (unsigned long long)entry->val.nn, dccp_feat_signal_nn_change()
1115 if (local || len > sizeof(fval.nn)) dccp_feat_change_recv()
1119 fval.nn = dccp_decode_value_var(val, len); dccp_feat_change_recv()
1120 if (!dccp_feat_is_valid_nn_val(feat, fval.nn)) dccp_feat_change_recv()
1244 if (len > sizeof(entry->val.nn)) dccp_feat_confirm_recv()
1247 if (entry->val.nn == dccp_decode_value_var(val, len)) dccp_feat_confirm_recv()
1331 if (len == 0 || len > sizeof(fval.nn)) dccp_feat_handle_nn_established()
1335 fval.nn = dccp_decode_value_var(val, len); dccp_feat_handle_nn_established()
1336 if (!dccp_feat_is_valid_nn_val(feat, fval.nn)) dccp_feat_handle_nn_established()
1351 fval.nn = dccp_decode_value_var(val, len); dccp_feat_handle_nn_established()
1358 if (fval.nn != entry->val.nn) dccp_feat_handle_nn_established()
H A Dfeat.h46 * @nn: single NN value
51 u64 nn; member in union:__anon14100
/linux-4.1.27/fs/ubifs/
H A Dtnc.c597 int nn = *n; tnc_next() local
599 nn += 1; tnc_next()
600 if (nn < znode->child_cnt) { tnc_next()
601 *n = nn; tnc_next()
610 nn = znode->iip + 1; tnc_next()
612 if (nn < znode->child_cnt) { tnc_next()
613 znode = get_znode(c, znode, nn); tnc_next()
621 nn = 0; tnc_next()
626 *n = nn; tnc_next()
642 int nn = *n; tnc_prev() local
644 if (nn > 0) { tnc_prev()
645 *n = nn - 1; tnc_prev()
654 nn = znode->iip - 1; tnc_prev()
656 if (nn >= 0) { tnc_prev()
657 znode = get_znode(c, znode, nn); tnc_prev()
661 nn = znode->child_cnt - 1; tnc_prev()
662 znode = get_znode(c, znode, nn); tnc_prev()
666 nn = znode->child_cnt - 1; tnc_prev()
671 *n = nn; tnc_prev()
768 int nn = *n; resolve_collision() local
773 err = tnc_next(c, &znode, &nn); resolve_collision()
778 if (keys_cmp(c, &znode->zbranch[nn].key, key)) resolve_collision()
780 err = matches_name(c, &znode->zbranch[nn], nm); resolve_collision()
786 *n = nn; resolve_collision()
885 int uninitialized_var(o_n), err, cmp, unsure = 0, nn = *n; fallible_resolve_collision() local
887 cmp = fallible_matches_name(c, &znode->zbranch[nn], nm); fallible_resolve_collision()
894 o_n = nn; fallible_resolve_collision()
953 *n = nn; fallible_resolve_collision()
955 err = tnc_next(c, &znode, &nn); fallible_resolve_collision()
960 if (keys_cmp(c, &znode->zbranch[nn].key, key)) fallible_resolve_collision()
962 err = fallible_matches_name(c, &znode->zbranch[nn], nm); fallible_resolve_collision()
968 *n = nn; fallible_resolve_collision()
973 o_n = nn; fallible_resolve_collision()
1029 int nn, err; resolve_collision_directly() local
1032 nn = *n; resolve_collision_directly()
1033 if (matches_position(&znode->zbranch[nn], lnum, offs)) resolve_collision_directly()
1038 err = tnc_prev(c, &znode, &nn); resolve_collision_directly()
1043 if (keys_cmp(c, &znode->zbranch[nn].key, key)) resolve_collision_directly()
1045 if (matches_position(&znode->zbranch[nn], lnum, offs)) { resolve_collision_directly()
1047 *n = nn; resolve_collision_directly()
1054 nn = *n; resolve_collision_directly()
1056 err = tnc_next(c, &znode, &nn); resolve_collision_directly()
1061 if (keys_cmp(c, &znode->zbranch[nn].key, key)) resolve_collision_directly()
1064 *n = nn; resolve_collision_directly()
1065 if (matches_position(&znode->zbranch[nn], lnum, offs)) resolve_collision_directly()
2977 int n, nn; lookup_znode() local
3037 nn = n; lookup_znode()
3061 n = nn; lookup_znode()
3133 int n, found, err, nn; is_leaf_node_in_tnc() local
3151 nn = n; is_leaf_node_in_tnc()
3167 n = nn; is_leaf_node_in_tnc()
H A Dfile.c613 int i = 0, nn = *n, offs = bu->zbranch[0].offs, hole = 0, read = 0; populate_page() local
636 if (nn >= bu->cnt) { populate_page()
639 } else if (key_block(c, &bu->zbranch[nn].key) == page_block) { populate_page()
642 dn = bu->buf + (bu->zbranch[nn].offs - offs); populate_page()
661 nn += 1; populate_page()
663 } else if (key_block(c, &bu->zbranch[nn].key) < page_block) { populate_page()
664 nn += 1; populate_page()
693 *n = nn; populate_page()
H A Dlpt.c2226 struct ubifs_nnode *nnode, *nn; dbg_check_lpt_nodes() local
2245 nn = (struct ubifs_nnode *)cnode; dbg_check_lpt_nodes()
2247 cn = nn->nbranch[iip].cnode; dbg_check_lpt_nodes()
/linux-4.1.27/net/netfilter/
H A Dnf_conntrack_helper.c395 const struct hlist_nulls_node *nn; __nf_conntrack_helper_unregister() local
422 hlist_nulls_for_each_entry(h, nn, &pcpu->unconfirmed, hnnode) for_each_possible_cpu()
430 hlist_nulls_for_each_entry(h, nn, &net->ct.hash[i], hnnode)
/linux-4.1.27/fs/gfs2/
H A Dtrace_gfs2.h19 #define dlm_state_name(nn) { DLM_LOCK_##nn, #nn }
/linux-4.1.27/arch/x86/crypto/
H A Dcast6-avx-x86_64-asm_64.S159 #define get_round_keys(nn) \
160 vbroadcastss (km+(4*(nn)))(CTX), RKM; \
/linux-4.1.27/drivers/message/fusion/
H A Dmptfc.c436 u64 pn, nn; mptfc_register_dev() local
492 nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low; mptfc_register_dev()
499 (unsigned long long)nn, mptfc_register_dev()
579 u64 nn, pn; mptfc_dump_lun_info() local
584 nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low; mptfc_dump_lun_info()
594 (unsigned long long)nn)); mptfc_dump_lun_info()
/linux-4.1.27/drivers/video/fbdev/
H A Dpm2fb.c255 static void pm2_mnp(u32 clk, unsigned char *mm, unsigned char *nn, pm2_mnp() argument
265 *mm = *nn = *pp = 0; pm2_mnp()
275 *nn = n; pm2_mnp()
284 static void pm2v_mnp(u32 clk, unsigned char *mm, unsigned char *nn, pm2v_mnp() argument
293 *mm = *nn = *pp = 0; pm2v_mnp()
301 *nn = n; pm2v_mnp()
/linux-4.1.27/arch/arm/mach-davinci/
H A Ddevices-da8xx.c855 pr_err("%s: 'rproc_mem=nn@address' badly specified\n" da8xx_rproc_reserve_cma()
856 " 'nn' and 'address' must both be non-zero\n", da8xx_rproc_reserve_cma()
/linux-4.1.27/drivers/net/fddi/skfp/
H A Dpmf.c1566 int nn ; dump_smt() local
1622 nn = (n > 16) ? 16 : n ; dump_smt()
1630 dump_hex(c,nn) ; dump_smt()
1633 n -= nn ; dump_smt()
/linux-4.1.27/fs/ocfs2/dlm/
H A Ddlmdomain.c68 unsigned int nn; byte_copymap() local
74 for (nn = 0 ; nn < sz; nn++) byte_copymap()
75 if (test_bit(nn, smap)) byte_copymap()
76 byte_set_bit(nn, dmap); byte_copymap()
H A Ddlmmaster.c1941 int nn = -1; dlm_assert_master_handler() local
1951 while ((nn = find_next_bit (mle->response_map, O2NM_MAX_NODES, dlm_assert_master_handler()
1952 nn+1)) < O2NM_MAX_NODES) { dlm_assert_master_handler()
1953 if (nn != dlm->node_num && nn != assert->node_idx) { dlm_assert_master_handler()
/linux-4.1.27/kernel/debug/kdb/
H A Dkdb_io.c618 * The "[nn]kdb> " prompt should vkdb_printf()
621 * The "[nn]more " prompt should also be vkdb_printf()
/linux-4.1.27/include/uapi/linux/
H A Dnvme.h71 __le32 nn; member in struct:nvme_id_ctrl
/linux-4.1.27/drivers/net/ethernet/xircom/
H A Dxirc2ps_cs.c1134 unsigned n, nn; xirc2ps_interrupt() local
1137 nn = GetByte(XIRCREG0_PTR); xirc2ps_interrupt()
1138 lp->last_ptr_value = nn; xirc2ps_interrupt()
1139 if (nn < n) /* rollover */ xirc2ps_interrupt()
1141 else if (n == nn) { /* happens sometimes - don't know why */ xirc2ps_interrupt()
/linux-4.1.27/kernel/rcu/
H A Dtree_trace.c371 seq_printf(m, "gpc=%ld gps=%ld nn=%ld ndw%ld\n", print_one_rcu_pending()
/linux-4.1.27/arch/x86/kernel/
H A Duprobes.c741 * 16-bit overrides such as CALLW (66 e8 nn nn) are not supported. branch_setup_xol_ops()
/linux-4.1.27/drivers/mtd/nand/
H A Datmel_nand.c1116 unsigned int nn = (1 << mm) - 1; build_gf_tables() local
1122 for (i = 0; i < nn; i++) { build_gf_tables()
1132 alpha_to[nn] = 1; build_gf_tables()
/linux-4.1.27/drivers/scsi/
H A Dconstants.c798 * {0x40NN, "Diagnostic failure on component nn"},
852 * {0x4DNN, "Tagged overlapped commands (nn = queue tag)"},
1083 * {0x70NN, "Decompression exception short algorithm id of nn"},
/linux-4.1.27/drivers/net/fddi/skfp/h/
H A Dcmtdef.h438 u_short lem_float_ber ; /* 10E-nn bit error rate */
/linux-4.1.27/drivers/scsi/qla2xxx/
H A Dqla_gs.c234 "GA_NXT entry - nn %8phN pn %8phN " qla2x00_ga_nxt()
447 "GID_PT entry - nn %8phN pn %8phN " qla2x00_gnn_id()
792 "GA_NXT entry - nn %8phN pn %8phN " qla2x00_sns_ga_nxt()
979 "GID_PT entry - nn %8phN pn %8phN " qla2x00_sns_gnn_id()
/linux-4.1.27/arch/x86/mm/
H A Dnuma.c488 * When booting with mem=nn[kMG] or in a kdump kernel, numa_meminfo numa_clear_kernel_node_hotplug()
/linux-4.1.27/drivers/block/
H A Dnvme-core.c2291 unsigned nn, i; nvme_dev_add() local
2309 nn = le32_to_cpup(&ctrl->nn); nvme_dev_add()
2345 for (i = 1; i <= nn; i++) nvme_dev_add()
H A Dnvme-scsi.c2569 ll_length = le32_to_cpu(id_ctrl->nn) * LUN_ENTRY_SIZE; nvme_trans_report_luns()
2587 for (lun_id = 0; lun_id < le32_to_cpu(id_ctrl->nn); lun_id++) { nvme_trans_report_luns()
/linux-4.1.27/drivers/crypto/qat/qat_common/
H A Dqat_hal.c1234 unsigned short nn, unsigned int val) qat_hal_put_rel_nn()
1243 stat = qat_hal_put_rel_wr_xfer(handle, ae, ctx, ICP_NEIGH_REL, nn, val); qat_hal_put_rel_nn()
1232 qat_hal_put_rel_nn(struct icp_qat_fw_loader_handle *handle, unsigned char ae, unsigned char ctx, unsigned short nn, unsigned int val) qat_hal_put_rel_nn() argument
/linux-4.1.27/arch/tile/kernel/
H A Dsetup.c195 pr_err("\"memmap=nn@ss\" (force RAM) invalid on tile\n"); setup_memmap()
197 pr_err("\"memmap=nn#ss\" (force ACPI data) invalid on tile\n"); setup_memmap()
/linux-4.1.27/drivers/staging/wlan-ng/
H A Dprism2fw.c813 * nn - number of bytes starting with the address field
/linux-4.1.27/lib/zlib_deflate/
H A Ddeftree.c525 Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ", gen_codes()
/linux-4.1.27/drivers/scsi/lpfc/
H A Dlpfc_nportdisc.c49 struct lpfc_name *nn, struct lpfc_name *pn) lpfc_check_adisc()
58 if (memcmp(nn, &ndlp->nlp_nodename, sizeof (struct lpfc_name))) lpfc_check_adisc()
48 lpfc_check_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, struct lpfc_name *nn, struct lpfc_name *pn) lpfc_check_adisc() argument
/linux-4.1.27/drivers/pci/
H A Dpci.c74 /* pci=cbmemsize=nnM,cbiosize=nn can override this */
80 /* pci=hpmemsize=nnM,hpiosize=nn can override this */
/linux-4.1.27/mm/
H A Dpage_alloc.c5259 * If movablecore=nn[KMG] was specified, calculate what size of
/linux-4.1.27/arch/m68k/ifpsp060/src/
H A Dpfpsp.S6367 # <--(24)--->nn\ /
6392 # nn\ /
H A Dfpsp.S22245 # <--(24)--->nn\ /
22270 # nn\ /

Completed in 1915 milliseconds