From c0add7fd05ff99c3a516c78eb6b1e6460a3efdae Mon Sep 17 00:00:00 2001 From: Nicholas Bellinger Date: Fri, 7 Jun 2013 17:38:58 -0700 Subject: target: Add transport_init_session_tags using per-cpu ida This patch adds lib/idr.c based transport_init_session_tags() logic that allows fabric drivers to setup a per-cpu se_sess->sess_tag_pool and associated se_sess->sess_cmd_map for basic tagged pre-allocation of fabric descriptor sized memory. v5 changes: - Convert to percpu_ida.h include v4 changes: - Add transport_alloc_session_tags() for fabrics that need early transport_init_session() v3 changes: - Update to percpu-ida usage Cc: Kent Overstreet Cc: Asias He Cc: Michael S. Tsirkin Reviewed-by: Asias He Signed-off-by: Nicholas Bellinger --- drivers/target/target_core_transport.c | 48 ++++++++++++++++++++++++++++++++++ include/target/target_core_base.h | 5 ++++ include/target/target_core_fabric.h | 3 +++ 3 files changed, 56 insertions(+) diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c index 7172d005d063..98ec7110873b 100644 --- a/drivers/target/target_core_transport.c +++ b/drivers/target/target_core_transport.c @@ -232,6 +232,50 @@ struct se_session *transport_init_session(void) } EXPORT_SYMBOL(transport_init_session); +int transport_alloc_session_tags(struct se_session *se_sess, + unsigned int tag_num, unsigned int tag_size) +{ + int rc; + + se_sess->sess_cmd_map = kzalloc(tag_num * tag_size, GFP_KERNEL); + if (!se_sess->sess_cmd_map) { + pr_err("Unable to allocate se_sess->sess_cmd_map\n"); + return -ENOMEM; + } + + rc = percpu_ida_init(&se_sess->sess_tag_pool, tag_num); + if (rc < 0) { + pr_err("Unable to init se_sess->sess_tag_pool," + " tag_num: %u\n", tag_num); + kfree(se_sess->sess_cmd_map); + se_sess->sess_cmd_map = NULL; + return -ENOMEM; + } + + return 0; +} +EXPORT_SYMBOL(transport_alloc_session_tags); + +struct se_session *transport_init_session_tags(unsigned int tag_num, + unsigned int tag_size) +{ + struct se_session *se_sess; + int rc; + + se_sess = transport_init_session(); + if (IS_ERR(se_sess)) + return se_sess; + + rc = transport_alloc_session_tags(se_sess, tag_num, tag_size); + if (rc < 0) { + transport_free_session(se_sess); + return ERR_PTR(-ENOMEM); + } + + return se_sess; +} +EXPORT_SYMBOL(transport_init_session_tags); + /* * Called with spin_lock_irqsave(&struct se_portal_group->session_lock called. */ @@ -367,6 +411,10 @@ EXPORT_SYMBOL(transport_deregister_session_configfs); void transport_free_session(struct se_session *se_sess) { + if (se_sess->sess_cmd_map) { + percpu_ida_destroy(&se_sess->sess_tag_pool); + kfree(se_sess->sess_cmd_map); + } kmem_cache_free(se_sess_cache, se_sess); } EXPORT_SYMBOL(transport_free_session); diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h index e34fc904f2e1..bd55acd43005 100644 --- a/include/target/target_core_base.h +++ b/include/target/target_core_base.h @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -415,6 +416,8 @@ struct se_cmd { enum dma_data_direction data_direction; /* For SAM Task Attribute */ int sam_task_attr; + /* Used for se_sess->sess_tag_pool */ + unsigned int map_tag; /* Transport protocol dependent state, see transport_state_table */ enum transport_state_table t_state; unsigned cmd_wait_set:1; @@ -536,6 +539,8 @@ struct se_session { struct list_head sess_wait_list; spinlock_t sess_cmd_lock; struct kref sess_kref; + void *sess_cmd_map; + struct percpu_ida sess_tag_pool; }; struct se_device; diff --git a/include/target/target_core_fabric.h b/include/target/target_core_fabric.h index 7a16178424f9..d559c36692af 100644 --- a/include/target/target_core_fabric.h +++ b/include/target/target_core_fabric.h @@ -84,6 +84,9 @@ struct target_core_fabric_ops { }; struct se_session *transport_init_session(void); +int transport_alloc_session_tags(struct se_session *, unsigned int, + unsigned int); +struct se_session *transport_init_session_tags(unsigned int, unsigned int); void __transport_register_session(struct se_portal_group *, struct se_node_acl *, struct se_session *, void *); void transport_register_session(struct se_portal_group *, -- cgit v1.2.2 ederman <ebiederm@xmission.com> 2012-11-19 08:57:31 -0500 pidns: Capture the user namespace and filter ns_last_pid' href='/cgit/cgit.cgi/litmus-rt-ext-res.git/commit/kernel/pid_namespace.c?id=49f4d8b93ccf9454284b6f524b96c66d8d7fbccc'>49f4d8b93ccf 
74bd59bb39eb


0b6b030fc30d

5a0e3ad6af86

4308eebbeb20

cf3f89214ef6

523a6a945f3c

74bd59bb39eb






















































0a01f2cc390e






f2302505775f



49f4d8b93ccf


74bd59bb39eb


ed469a63c37a

f2302505775f







74bd59bb39eb

f2302505775f

84406c153a5b

74bd59bb39eb











98f842e675f9




74bd59bb39eb

74bd59bb39eb

ed469a63c37a

49f4d8b93ccf

c876ad768215

0a01f2cc390e

74bd59bb39eb




84406c153a5b

74bd59bb39eb

74bd59bb39eb








4308eebbeb20

74bd59bb39eb






98f842e675f9

74bd59bb39eb


49f4d8b93ccf

74bd59bb39eb



49f4d8b93ccf


74bd59bb39eb

74bd59bb39eb

dca4a979604d

225778d68d98


49f4d8b93ccf

74bd59bb39eb


bbc2e3ef8785

74bd59bb39eb

bbc2e3ef8785

74bd59bb39eb


74bd59bb39eb

bbc2e3ef8785

74bd59bb39eb

bbc2e3ef8785










74bd59bb39eb

bbc2e3ef8785

74bd59bb39eb





00c10bc13cdb


c876ad768215



00c10bc13cdb




74bd59bb39eb

















e4da026f980d


e4da026f980d

a02d6fd643cb


e4da026f980d



74bd59bb39eb




6347e9009104

74bd59bb39eb





6347e9009104


af4b8a83add9

6347e9009104


af4b8a83add9


6347e9009104



af4b8a83add9

6347e9009104

cf3f89214ef6



0b6b030fc30d

74bd59bb39eb



98ed57eef9f6

b8f566b04d3c



49f4d8b93ccf

b8f566b04d3c


49f4d8b93ccf

b8f566b04d3c








49f4d8b93ccf

579035dc5ddd

b8f566b04d3c


579035dc5ddd


b8f566b04d3c






579035dc5ddd


b8f566b04d3c



b8f566b04d3c

98ed57eef9f6

b8f566b04d3c

cf3f89214ef6





























57e8391d3276





















5e4a08476b50


57e8391d3276
























98f842e675f9






57e8391d3276






98f842e675f9

57e8391d3276


74bd59bb39eb



98ed57eef9f6


b8f566b04d3c

98ed57eef9f6

74bd59bb39eb




1
2
3
4
5
6
7
8
9
10
11
12

13

14
15

16

17

18

19

20

21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

75
76
77
78
79
80

81
82
83

84
85

86
87

88

89
90
91
92
93
94
95

96

97

98

99
100
101
102
103
104
105
106
107
108
109

110
111
112
113

114

115

116

117

118

119

120
121
122
123

124

125

126
127
128
129
130
131
132
133

134

135
136
137
138
139
140

141

142
143

144

145
146
147

148
149

150

151

152

153
154

155

156
157

158

159

160

161
162

163

164

165

166
167
168
169
170
171
172
173
174
175

176

177

178
179
180
181
182

183
184

185
186
187

188
189
190
191

192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

209
210

211

212
213

214
215
216

217
218
219
220

221

222
223
224
225
226

227
228

229

230
231

232
233

234
235
236

237

238

239
240
241

242

243
244
245

246

247
248
249

250

251
252

253

254
255
256
257
258
259
260
261

262

263

264
265

266
267

268
269
270
271
272
273

274
275

276
277
278

279

280

281

282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310

311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331

332
333

334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357

358
359
360
361
362
363

364
365
366
367
368
369

370

371
372

373
374
375

376
377

378

379

380
381
382
383












                                                                      
                                 

                           
                       
                       
                          
                         
                         





















































                                                                                





                                                                                       


                                                                  

                                                                                 

                                 
                                                      






                                       
 
                      
                                                          










                                                            



                                              
                             
                          
                                               
                                           
                                          
                                                     



                                                              
                                            
                                                                  







                                           
                            





                                                           
                                      

                                            
                                 


                                           

                                                                     
 
                                    
                                          

                                                  
                                                     

 
                                          
 
                                 

                                                            
                                  
 
 









                                                      
 
                              




                                                       

                                                


                                                                   



                                                                        
















                                                                               

                                
                                                            

                                                                      


                                  



                                             
                                                                




                                                       

                                                               
                                                      

                  

                                                        


                              
                                          
 


                                                                  
                             


               
                                


                                                                 
                                                                   

                                      
                                                                 







                                                                         
                                     
                                                                     

 

                    





                                                                          

                                   


           
                                                                        
                                       
 




























                                                        




















                                                                   

                                                       























                                                                     





                                          





                                                    
                                     

  


                                                              

                                
                                                           
      



                                
/*
 * Pid namespaces
 *
 * Authors:
 *    (C) 2007 Pavel Emelyanov <xemul@openvz.org>, OpenVZ, SWsoft Inc.
 *    (C) 2007 Sukadev Bhattiprolu <sukadev@us.ibm.com>, IBM
 *     Many thanks to Oleg Nesterov for comments and help
 *
 */

#include <linux/pid.h>
#include <linux/pid_namespace.h>
#include <linux/user_namespace.h>
#include <linux/syscalls.h>
#include <linux/err.h>
#include <linux/acct.h>
#include <linux/slab.h>
#include <linux/proc_fs.h>
#include <linux/reboot.h>
#include <linux/export.h>

#define BITS_PER_PAGE		(PAGE_SIZE*8)

struct pid_cache {
	int nr_ids;
	char name[16];
	struct kmem_cache *cachep;
	struct list_head list;
};

static LIST_HEAD(pid_caches_lh);
static DEFINE_MUTEX(pid_caches_mutex);
static struct kmem_cache *pid_ns_cachep;

/*
 * creates the kmem cache to allocate pids from.
 * @nr_ids: the number of numerical ids this pid will have to carry
 */

static struct kmem_cache *create_pid_cachep(int nr_ids)
{
	struct pid_cache *pcache;
	struct kmem_cache *cachep;

	mutex_lock(&pid_caches_mutex);
	list_for_each_entry(pcache, &pid_caches_lh, list)
		if (pcache->nr_ids == nr_ids)
			goto out;

	pcache = kmalloc(sizeof(struct pid_cache), GFP_KERNEL);
	if (pcache == NULL)
		goto err_alloc;

	snprintf(pcache->name, sizeof(pcache->name), "pid_%d", nr_ids);
	cachep = kmem_cache_create(pcache->name,
			sizeof(struct pid) + (nr_ids - 1) * sizeof(struct upid),
			0, SLAB_HWCACHE_ALIGN, NULL);
	if (cachep == NULL)
		goto err_cachep;

	pcache->nr_ids = nr_ids;
	pcache->cachep = cachep;
	list_add(&pcache->list, &pid_caches_lh);
out:
	mutex_unlock(&pid_caches_mutex);
	return pcache->cachep;

err_cachep:
	kfree(pcache);
err_alloc:
	mutex_unlock(&pid_caches_mutex);
	return NULL;
}

static void proc_cleanup_work(struct work_struct *work)
{
	struct pid_namespace *ns = container_of(work, struct pid_namespace, proc_work);
	pid_ns_release_proc(ns);
}

/* MAX_PID_NS_LEVEL is needed for limiting size of 'struct pid' */
#define MAX_PID_NS_LEVEL 32

static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns,
	struct pid_namespace *parent_pid_ns)
{
	struct pid_namespace *ns;
	unsigned int level = parent_pid_ns->level + 1;
	int i;
	int err;

	if (level > MAX_PID_NS_LEVEL) {
		err = -EINVAL;
		goto out;
	}

	err = -ENOMEM;
	ns = kmem_cache_zalloc(pid_ns_cachep, GFP_KERNEL);
	if (ns == NULL)
		goto out;

	ns->pidmap[0].page = kzalloc(PAGE_SIZE, GFP_KERNEL);
	if (!ns->pidmap[0].page)
		goto out_free;

	ns->pid_cachep = create_pid_cachep(level + 1);
	if (ns->pid_cachep == NULL)
		goto out_free_map;

	err = proc_alloc_inum(&ns->proc_inum);
	if (err)
		goto out_free_map;

	kref_init(&ns->kref);
	ns->level = level;
	ns->parent = get_pid_ns(parent_pid_ns);
	ns->user_ns = get_user_ns(user_ns);
	ns->nr_hashed = PIDNS_HASH_ADDING;
	INIT_WORK(&ns->proc_work, proc_cleanup_work);

	set_bit(0, ns->pidmap[0].page);
	atomic_set(&ns->pidmap[0].nr_free, BITS_PER_PAGE - 1);

	for (i = 1; i < PIDMAP_ENTRIES; i++)
		atomic_set(&ns->pidmap[i].nr_free, BITS_PER_PAGE);

	return ns;

out_free_map:
	kfree(ns->pidmap[0].page);
out_free:
	kmem_cache_free(pid_ns_cachep, ns);
out:
	return ERR_PTR(err);
}

static void destroy_pid_namespace(struct pid_namespace *ns)
{
	int i;

	proc_free_inum(ns->proc_inum);
	for (i = 0; i < PIDMAP_ENTRIES; i++)
		kfree(ns->pidmap[i].page);
	put_user_ns(ns->user_ns);
	kmem_cache_free(pid_ns_cachep, ns);
}

struct pid_namespace *copy_pid_ns(unsigned long flags,
	struct user_namespace *user_ns, struct pid_namespace *old_ns)
{
	if (!(flags & CLONE_NEWPID))
		return get_pid_ns(old_ns);
	if (task_active_pid_ns(current) != old_ns)
		return ERR_PTR(-EINVAL);
	return create_pid_namespace(user_ns, old_ns);
}

static void free_pid_ns(struct kref *kref)
{
	struct pid_namespace *ns;

	ns = container_of(kref, struct pid_namespace, kref);
	destroy_pid_namespace(ns);
}

void put_pid_ns(struct pid_namespace *ns)
{
	struct pid_namespace *parent;

	while (ns != &init_pid_ns) {
		parent = ns->parent;
		if (!kref_put(&ns->kref, free_pid_ns))
			break;
		ns = parent;
	}
}
EXPORT_SYMBOL_GPL(put_pid_ns);

void zap_pid_ns_processes(struct pid_namespace *pid_ns)
{
	int nr;
	int rc;
	struct task_struct *task, *me = current;

	/* Don't allow any more processes into the pid namespace */
	disable_pid_allocation(pid_ns);

	/* Ignore SIGCHLD causing any terminated children to autoreap */
	spin_lock_irq(&me->sighand->siglock);
	me->sighand->action[SIGCHLD - 1].sa.sa_handler = SIG_IGN;
	spin_unlock_irq(&me->sighand->siglock);

	/*
	 * The last thread in the cgroup-init thread group is terminating.
	 * Find remaining pid_ts in the namespace, signal and wait for them
	 * to exit.
	 *