xref: /linux/drivers/hwtracing/coresight/coresight-syscfg.c (revision 4f2c0a4acffbec01079c28f839422e64ddeff004)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2020 Linaro Limited, All rights reserved.
4  * Author: Mike Leach <mike.leach@linaro.org>
5  */
6 
7 #include <linux/platform_device.h>
8 #include <linux/slab.h>
9 
10 #include "coresight-config.h"
11 #include "coresight-etm-perf.h"
12 #include "coresight-syscfg.h"
13 #include "coresight-syscfg-configfs.h"
14 
15 /*
16  * cscfg_ API manages configurations and features for the entire coresight
17  * infrastructure.
18  *
19  * It allows the loading of configurations and features, and loads these into
20  * coresight devices as appropriate.
21  */
22 
23 /* protect the cscsg_data and device */
24 static DEFINE_MUTEX(cscfg_mutex);
25 
26 /* only one of these */
27 static struct cscfg_manager *cscfg_mgr;
28 
29 /* load features and configuations into the lists */
30 
31 /* get name feature instance from a coresight device list of features */
32 static struct cscfg_feature_csdev *
cscfg_get_feat_csdev(struct coresight_device * csdev,const char * name)33 cscfg_get_feat_csdev(struct coresight_device *csdev, const char *name)
34 {
35 	struct cscfg_feature_csdev *feat_csdev = NULL;
36 
37 	list_for_each_entry(feat_csdev, &csdev->feature_csdev_list, node) {
38 		if (strcmp(feat_csdev->feat_desc->name, name) == 0)
39 			return feat_csdev;
40 	}
41 	return NULL;
42 }
43 
44 /* allocate the device config instance - with max number of used features */
45 static struct cscfg_config_csdev *
cscfg_alloc_csdev_cfg(struct coresight_device * csdev,int nr_feats)46 cscfg_alloc_csdev_cfg(struct coresight_device *csdev, int nr_feats)
47 {
48 	struct cscfg_config_csdev *config_csdev = NULL;
49 	struct device *dev = csdev->dev.parent;
50 
51 	/* this is being allocated using the devm for the coresight device */
52 	config_csdev = devm_kzalloc(dev,
53 				    offsetof(struct cscfg_config_csdev, feats_csdev[nr_feats]),
54 				    GFP_KERNEL);
55 	if (!config_csdev)
56 		return NULL;
57 
58 	config_csdev->csdev = csdev;
59 	return config_csdev;
60 }
61 
62 /* Load a config into a device if there are any feature matches between config and device */
cscfg_add_csdev_cfg(struct coresight_device * csdev,struct cscfg_config_desc * config_desc)63 static int cscfg_add_csdev_cfg(struct coresight_device *csdev,
64 			       struct cscfg_config_desc *config_desc)
65 {
66 	struct cscfg_config_csdev *config_csdev = NULL;
67 	struct cscfg_feature_csdev *feat_csdev;
68 	unsigned long flags;
69 	int i;
70 
71 	/* look at each required feature and see if it matches any feature on the device */
72 	for (i = 0; i < config_desc->nr_feat_refs; i++) {
73 		/* look for a matching name */
74 		feat_csdev = cscfg_get_feat_csdev(csdev, config_desc->feat_ref_names[i]);
75 		if (feat_csdev) {
76 			/*
77 			 * At least one feature on this device matches the config
78 			 * add a config instance to the device and a reference to the feature.
79 			 */
80 			if (!config_csdev) {
81 				config_csdev = cscfg_alloc_csdev_cfg(csdev,
82 								     config_desc->nr_feat_refs);
83 				if (!config_csdev)
84 					return -ENOMEM;
85 				config_csdev->config_desc = config_desc;
86 			}
87 			config_csdev->feats_csdev[config_csdev->nr_feat++] = feat_csdev;
88 		}
89 	}
90 	/* if matched features, add config to device.*/
91 	if (config_csdev) {
92 		spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
93 		list_add(&config_csdev->node, &csdev->config_csdev_list);
94 		spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
95 	}
96 
97 	return 0;
98 }
99 
100 /*
101  * Add the config to the set of registered devices - call with mutex locked.
102  * Iterates through devices - any device that matches one or more of the
103  * configuration features will load it, the others will ignore it.
104  */
cscfg_add_cfg_to_csdevs(struct cscfg_config_desc * config_desc)105 static int cscfg_add_cfg_to_csdevs(struct cscfg_config_desc *config_desc)
106 {
107 	struct cscfg_registered_csdev *csdev_item;
108 	int err;
109 
110 	list_for_each_entry(csdev_item, &cscfg_mgr->csdev_desc_list, item) {
111 		err = cscfg_add_csdev_cfg(csdev_item->csdev, config_desc);
112 		if (err)
113 			return err;
114 	}
115 	return 0;
116 }
117 
118 /*
119  * Allocate a feature object for load into a csdev.
120  * memory allocated using the csdev->dev object using devm managed allocator.
121  */
122 static struct cscfg_feature_csdev *
cscfg_alloc_csdev_feat(struct coresight_device * csdev,struct cscfg_feature_desc * feat_desc)123 cscfg_alloc_csdev_feat(struct coresight_device *csdev, struct cscfg_feature_desc *feat_desc)
124 {
125 	struct cscfg_feature_csdev *feat_csdev = NULL;
126 	struct device *dev = csdev->dev.parent;
127 	int i;
128 
129 	feat_csdev = devm_kzalloc(dev, sizeof(struct cscfg_feature_csdev), GFP_KERNEL);
130 	if (!feat_csdev)
131 		return NULL;
132 
133 	/* parameters are optional - could be 0 */
134 	feat_csdev->nr_params = feat_desc->nr_params;
135 
136 	/*
137 	 * if we need parameters, zero alloc the space here, the load routine in
138 	 * the csdev device driver will fill out some information according to
139 	 * feature descriptor.
140 	 */
141 	if (feat_csdev->nr_params) {
142 		feat_csdev->params_csdev = devm_kcalloc(dev, feat_csdev->nr_params,
143 							sizeof(struct cscfg_parameter_csdev),
144 							GFP_KERNEL);
145 		if (!feat_csdev->params_csdev)
146 			return NULL;
147 
148 		/*
149 		 * fill in the feature reference in the param - other fields
150 		 * handled by loader in csdev.
151 		 */
152 		for (i = 0; i < feat_csdev->nr_params; i++)
153 			feat_csdev->params_csdev[i].feat_csdev = feat_csdev;
154 	}
155 
156 	/*
157 	 * Always have registers to program - again the load routine in csdev device
158 	 * will fill out according to feature descriptor and device requirements.
159 	 */
160 	feat_csdev->nr_regs = feat_desc->nr_regs;
161 	feat_csdev->regs_csdev = devm_kcalloc(dev, feat_csdev->nr_regs,
162 					      sizeof(struct cscfg_regval_csdev),
163 					      GFP_KERNEL);
164 	if (!feat_csdev->regs_csdev)
165 		return NULL;
166 
167 	/* load the feature default values */
168 	feat_csdev->feat_desc = feat_desc;
169 	feat_csdev->csdev = csdev;
170 
171 	return feat_csdev;
172 }
173 
174 /* load one feature into one coresight device */
cscfg_load_feat_csdev(struct coresight_device * csdev,struct cscfg_feature_desc * feat_desc,struct cscfg_csdev_feat_ops * ops)175 static int cscfg_load_feat_csdev(struct coresight_device *csdev,
176 				 struct cscfg_feature_desc *feat_desc,
177 				 struct cscfg_csdev_feat_ops *ops)
178 {
179 	struct cscfg_feature_csdev *feat_csdev;
180 	unsigned long flags;
181 	int err;
182 
183 	if (!ops->load_feat)
184 		return -EINVAL;
185 
186 	feat_csdev = cscfg_alloc_csdev_feat(csdev, feat_desc);
187 	if (!feat_csdev)
188 		return -ENOMEM;
189 
190 	/* load the feature into the device */
191 	err = ops->load_feat(csdev, feat_csdev);
192 	if (err)
193 		return err;
194 
195 	/* add to internal csdev feature list & initialise using reset call */
196 	cscfg_reset_feat(feat_csdev);
197 	spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
198 	list_add(&feat_csdev->node, &csdev->feature_csdev_list);
199 	spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
200 
201 	return 0;
202 }
203 
204 /*
205  * Add feature to any matching devices - call with mutex locked.
206  * Iterates through devices - any device that matches the feature will be
207  * called to load it.
208  */
cscfg_add_feat_to_csdevs(struct cscfg_feature_desc * feat_desc)209 static int cscfg_add_feat_to_csdevs(struct cscfg_feature_desc *feat_desc)
210 {
211 	struct cscfg_registered_csdev *csdev_item;
212 	int err;
213 
214 	list_for_each_entry(csdev_item, &cscfg_mgr->csdev_desc_list, item) {
215 		if (csdev_item->match_flags & feat_desc->match_flags) {
216 			err = cscfg_load_feat_csdev(csdev_item->csdev, feat_desc, &csdev_item->ops);
217 			if (err)
218 				return err;
219 		}
220 	}
221 	return 0;
222 }
223 
224 /* check feature list for a named feature - call with mutex locked. */
cscfg_match_list_feat(const char * name)225 static bool cscfg_match_list_feat(const char *name)
226 {
227 	struct cscfg_feature_desc *feat_desc;
228 
229 	list_for_each_entry(feat_desc, &cscfg_mgr->feat_desc_list, item) {
230 		if (strcmp(feat_desc->name, name) == 0)
231 			return true;
232 	}
233 	return false;
234 }
235 
236 /* check all feat needed for cfg are in the list - call with mutex locked. */
cscfg_check_feat_for_cfg(struct cscfg_config_desc * config_desc)237 static int cscfg_check_feat_for_cfg(struct cscfg_config_desc *config_desc)
238 {
239 	int i;
240 
241 	for (i = 0; i < config_desc->nr_feat_refs; i++)
242 		if (!cscfg_match_list_feat(config_desc->feat_ref_names[i]))
243 			return -EINVAL;
244 	return 0;
245 }
246 
247 /*
248  * load feature - add to feature list.
249  */
cscfg_load_feat(struct cscfg_feature_desc * feat_desc)250 static int cscfg_load_feat(struct cscfg_feature_desc *feat_desc)
251 {
252 	int err;
253 	struct cscfg_feature_desc *feat_desc_exist;
254 
255 	/* new feature must have unique name */
256 	list_for_each_entry(feat_desc_exist, &cscfg_mgr->feat_desc_list, item) {
257 		if (!strcmp(feat_desc_exist->name, feat_desc->name))
258 			return -EEXIST;
259 	}
260 
261 	/* add feature to any matching registered devices */
262 	err = cscfg_add_feat_to_csdevs(feat_desc);
263 	if (err)
264 		return err;
265 
266 	list_add(&feat_desc->item, &cscfg_mgr->feat_desc_list);
267 	return 0;
268 }
269 
270 /*
271  * load config into the system - validate used features exist then add to
272  * config list.
273  */
cscfg_load_config(struct cscfg_config_desc * config_desc)274 static int cscfg_load_config(struct cscfg_config_desc *config_desc)
275 {
276 	int err;
277 	struct cscfg_config_desc *config_desc_exist;
278 
279 	/* new configuration must have a unique name */
280 	list_for_each_entry(config_desc_exist, &cscfg_mgr->config_desc_list, item) {
281 		if (!strcmp(config_desc_exist->name, config_desc->name))
282 			return -EEXIST;
283 	}
284 
285 	/* validate features are present */
286 	err = cscfg_check_feat_for_cfg(config_desc);
287 	if (err)
288 		return err;
289 
290 	/* add config to any matching registered device */
291 	err = cscfg_add_cfg_to_csdevs(config_desc);
292 	if (err)
293 		return err;
294 
295 	/* add config to perf fs to allow selection */
296 	err = etm_perf_add_symlink_cscfg(cscfg_device(), config_desc);
297 	if (err)
298 		return err;
299 
300 	list_add(&config_desc->item, &cscfg_mgr->config_desc_list);
301 	atomic_set(&config_desc->active_cnt, 0);
302 	return 0;
303 }
304 
305 /* get a feature descriptor by name */
cscfg_get_named_feat_desc(const char * name)306 const struct cscfg_feature_desc *cscfg_get_named_feat_desc(const char *name)
307 {
308 	const struct cscfg_feature_desc *feat_desc = NULL, *feat_desc_item;
309 
310 	mutex_lock(&cscfg_mutex);
311 
312 	list_for_each_entry(feat_desc_item, &cscfg_mgr->feat_desc_list, item) {
313 		if (strcmp(feat_desc_item->name, name) == 0) {
314 			feat_desc = feat_desc_item;
315 			break;
316 		}
317 	}
318 
319 	mutex_unlock(&cscfg_mutex);
320 	return feat_desc;
321 }
322 
323 /* called with cscfg_mutex held */
324 static struct cscfg_feature_csdev *
cscfg_csdev_get_feat_from_desc(struct coresight_device * csdev,struct cscfg_feature_desc * feat_desc)325 cscfg_csdev_get_feat_from_desc(struct coresight_device *csdev,
326 			       struct cscfg_feature_desc *feat_desc)
327 {
328 	struct cscfg_feature_csdev *feat_csdev;
329 
330 	list_for_each_entry(feat_csdev, &csdev->feature_csdev_list, node) {
331 		if (feat_csdev->feat_desc == feat_desc)
332 			return feat_csdev;
333 	}
334 	return NULL;
335 }
336 
cscfg_update_feat_param_val(struct cscfg_feature_desc * feat_desc,int param_idx,u64 value)337 int cscfg_update_feat_param_val(struct cscfg_feature_desc *feat_desc,
338 				int param_idx, u64 value)
339 {
340 	int err = 0;
341 	struct cscfg_feature_csdev *feat_csdev;
342 	struct cscfg_registered_csdev *csdev_item;
343 
344 	mutex_lock(&cscfg_mutex);
345 
346 	/* check if any config active & return busy */
347 	if (atomic_read(&cscfg_mgr->sys_active_cnt)) {
348 		err = -EBUSY;
349 		goto unlock_exit;
350 	}
351 
352 	/* set the value */
353 	if ((param_idx < 0) || (param_idx >= feat_desc->nr_params)) {
354 		err = -EINVAL;
355 		goto unlock_exit;
356 	}
357 	feat_desc->params_desc[param_idx].value = value;
358 
359 	/* update loaded instances.*/
360 	list_for_each_entry(csdev_item, &cscfg_mgr->csdev_desc_list, item) {
361 		feat_csdev = cscfg_csdev_get_feat_from_desc(csdev_item->csdev, feat_desc);
362 		if (feat_csdev)
363 			feat_csdev->params_csdev[param_idx].current_value = value;
364 	}
365 
366 unlock_exit:
367 	mutex_unlock(&cscfg_mutex);
368 	return err;
369 }
370 
371 /*
372  * Conditionally up reference count on owner to prevent unload.
373  *
374  * module loaded configs need to be locked in to prevent premature unload.
375  */
cscfg_owner_get(struct cscfg_load_owner_info * owner_info)376 static int cscfg_owner_get(struct cscfg_load_owner_info *owner_info)
377 {
378 	if ((owner_info->type == CSCFG_OWNER_MODULE) &&
379 	    (!try_module_get(owner_info->owner_handle)))
380 		return -EINVAL;
381 	return 0;
382 }
383 
384 /* conditionally lower ref count on an owner */
cscfg_owner_put(struct cscfg_load_owner_info * owner_info)385 static void cscfg_owner_put(struct cscfg_load_owner_info *owner_info)
386 {
387 	if (owner_info->type == CSCFG_OWNER_MODULE)
388 		module_put(owner_info->owner_handle);
389 }
390 
cscfg_remove_owned_csdev_configs(struct coresight_device * csdev,void * load_owner)391 static void cscfg_remove_owned_csdev_configs(struct coresight_device *csdev, void *load_owner)
392 {
393 	struct cscfg_config_csdev *config_csdev, *tmp;
394 
395 	if (list_empty(&csdev->config_csdev_list))
396 		return;
397 
398 	list_for_each_entry_safe(config_csdev, tmp, &csdev->config_csdev_list, node) {
399 		if (config_csdev->config_desc->load_owner == load_owner)
400 			list_del(&config_csdev->node);
401 	}
402 }
403 
cscfg_remove_owned_csdev_features(struct coresight_device * csdev,void * load_owner)404 static void cscfg_remove_owned_csdev_features(struct coresight_device *csdev, void *load_owner)
405 {
406 	struct cscfg_feature_csdev *feat_csdev, *tmp;
407 
408 	if (list_empty(&csdev->feature_csdev_list))
409 		return;
410 
411 	list_for_each_entry_safe(feat_csdev, tmp, &csdev->feature_csdev_list, node) {
412 		if (feat_csdev->feat_desc->load_owner == load_owner)
413 			list_del(&feat_csdev->node);
414 	}
415 }
416 
417 /*
418  * Unregister all configuration and features from configfs owned by load_owner.
419  * Although this is called without the list mutex being held, it is in the
420  * context of an unload operation which are strictly serialised,
421  * so the lists cannot change during this call.
422  */
cscfg_fs_unregister_cfgs_feats(void * load_owner)423 static void cscfg_fs_unregister_cfgs_feats(void *load_owner)
424 {
425 	struct cscfg_config_desc *config_desc;
426 	struct cscfg_feature_desc *feat_desc;
427 
428 	list_for_each_entry(config_desc, &cscfg_mgr->config_desc_list, item) {
429 		if (config_desc->load_owner == load_owner)
430 			cscfg_configfs_del_config(config_desc);
431 	}
432 	list_for_each_entry(feat_desc, &cscfg_mgr->feat_desc_list, item) {
433 		if (feat_desc->load_owner == load_owner)
434 			cscfg_configfs_del_feature(feat_desc);
435 	}
436 }
437 
438 /*
439  * removal is relatively easy - just remove from all lists, anything that
440  * matches the owner. Memory for the descriptors will be managed by the owner,
441  * memory for the csdev items is devm_ allocated with the individual csdev
442  * devices.
443  */
cscfg_unload_owned_cfgs_feats(void * load_owner)444 static void cscfg_unload_owned_cfgs_feats(void *load_owner)
445 {
446 	struct cscfg_config_desc *config_desc, *cfg_tmp;
447 	struct cscfg_feature_desc *feat_desc, *feat_tmp;
448 	struct cscfg_registered_csdev *csdev_item;
449 
450 	lockdep_assert_held(&cscfg_mutex);
451 
452 	/* remove from each csdev instance feature and config lists */
453 	list_for_each_entry(csdev_item, &cscfg_mgr->csdev_desc_list, item) {
454 		/*
455 		 * for each csdev, check the loaded lists and remove if
456 		 * referenced descriptor is owned
457 		 */
458 		cscfg_remove_owned_csdev_configs(csdev_item->csdev, load_owner);
459 		cscfg_remove_owned_csdev_features(csdev_item->csdev, load_owner);
460 	}
461 
462 	/* remove from the config descriptor lists */
463 	list_for_each_entry_safe(config_desc, cfg_tmp, &cscfg_mgr->config_desc_list, item) {
464 		if (config_desc->load_owner == load_owner) {
465 			etm_perf_del_symlink_cscfg(config_desc);
466 			list_del(&config_desc->item);
467 		}
468 	}
469 
470 	/* remove from the feature descriptor lists */
471 	list_for_each_entry_safe(feat_desc, feat_tmp, &cscfg_mgr->feat_desc_list, item) {
472 		if (feat_desc->load_owner == load_owner) {
473 			list_del(&feat_desc->item);
474 		}
475 	}
476 }
477 
478 /*
479  * load the features and configs to the lists - called with list mutex held
480  */
cscfg_load_owned_cfgs_feats(struct cscfg_config_desc ** config_descs,struct cscfg_feature_desc ** feat_descs,struct cscfg_load_owner_info * owner_info)481 static int cscfg_load_owned_cfgs_feats(struct cscfg_config_desc **config_descs,
482 				       struct cscfg_feature_desc **feat_descs,
483 				       struct cscfg_load_owner_info *owner_info)
484 {
485 	int i, err;
486 
487 	lockdep_assert_held(&cscfg_mutex);
488 
489 	/* load features first */
490 	if (feat_descs) {
491 		for (i = 0; feat_descs[i]; i++) {
492 			err = cscfg_load_feat(feat_descs[i]);
493 			if (err) {
494 				pr_err("coresight-syscfg: Failed to load feature %s\n",
495 				       feat_descs[i]->name);
496 				return err;
497 			}
498 			feat_descs[i]->load_owner = owner_info;
499 		}
500 	}
501 
502 	/* next any configurations to check feature dependencies */
503 	if (config_descs) {
504 		for (i = 0; config_descs[i]; i++) {
505 			err = cscfg_load_config(config_descs[i]);
506 			if (err) {
507 				pr_err("coresight-syscfg: Failed to load configuration %s\n",
508 				       config_descs[i]->name);
509 				return err;
510 			}
511 			config_descs[i]->load_owner = owner_info;
512 			config_descs[i]->available = false;
513 		}
514 	}
515 	return 0;
516 }
517 
518 /* set configurations as available to activate at the end of the load process */
cscfg_set_configs_available(struct cscfg_config_desc ** config_descs)519 static void cscfg_set_configs_available(struct cscfg_config_desc **config_descs)
520 {
521 	int i;
522 
523 	lockdep_assert_held(&cscfg_mutex);
524 
525 	if (config_descs) {
526 		for (i = 0; config_descs[i]; i++)
527 			config_descs[i]->available = true;
528 	}
529 }
530 
531 /*
532  * Create and register each of the configurations and features with configfs.
533  * Called without mutex being held.
534  */
cscfg_fs_register_cfgs_feats(struct cscfg_config_desc ** config_descs,struct cscfg_feature_desc ** feat_descs)535 static int cscfg_fs_register_cfgs_feats(struct cscfg_config_desc **config_descs,
536 					struct cscfg_feature_desc **feat_descs)
537 {
538 	int i, err;
539 
540 	if (feat_descs) {
541 		for (i = 0; feat_descs[i]; i++) {
542 			err = cscfg_configfs_add_feature(feat_descs[i]);
543 			if (err)
544 				return err;
545 		}
546 	}
547 	if (config_descs) {
548 		for (i = 0; config_descs[i]; i++) {
549 			err = cscfg_configfs_add_config(config_descs[i]);
550 			if (err)
551 				return err;
552 		}
553 	}
554 	return 0;
555 }
556 
557 /**
558  * cscfg_load_config_sets - API function to load feature and config sets.
559  *
560  * Take a 0 terminated array of feature descriptors and/or configuration
561  * descriptors and load into the system.
562  * Features are loaded first to ensure configuration dependencies can be met.
563  *
564  * To facilitate dynamic loading and unloading, features and configurations
565  * have a "load_owner", to allow later unload by the same owner. An owner may
566  * be a loadable module or configuration dynamically created via configfs.
567  * As later loaded configurations can use earlier loaded features, creating load
568  * dependencies, a load order list is maintained. Unload is strictly in the
569  * reverse order to load.
570  *
571  * @config_descs: 0 terminated array of configuration descriptors.
572  * @feat_descs:   0 terminated array of feature descriptors.
573  * @owner_info:	  Information on the owner of this set.
574  */
cscfg_load_config_sets(struct cscfg_config_desc ** config_descs,struct cscfg_feature_desc ** feat_descs,struct cscfg_load_owner_info * owner_info)575 int cscfg_load_config_sets(struct cscfg_config_desc **config_descs,
576 			   struct cscfg_feature_desc **feat_descs,
577 			   struct cscfg_load_owner_info *owner_info)
578 {
579 	int err = 0;
580 
581 	mutex_lock(&cscfg_mutex);
582 	if (cscfg_mgr->load_state != CSCFG_NONE) {
583 		mutex_unlock(&cscfg_mutex);
584 		return -EBUSY;
585 	}
586 	cscfg_mgr->load_state = CSCFG_LOAD;
587 
588 	/* first load and add to the lists */
589 	err = cscfg_load_owned_cfgs_feats(config_descs, feat_descs, owner_info);
590 	if (err)
591 		goto err_clean_load;
592 
593 	/* add the load owner to the load order list */
594 	list_add_tail(&owner_info->item, &cscfg_mgr->load_order_list);
595 	if (!list_is_singular(&cscfg_mgr->load_order_list)) {
596 		/* lock previous item in load order list */
597 		err = cscfg_owner_get(list_prev_entry(owner_info, item));
598 		if (err)
599 			goto err_clean_owner_list;
600 	}
601 
602 	/*
603 	 * make visible to configfs - configfs manipulation must occur outside
604 	 * the list mutex lock to avoid circular lockdep issues with configfs
605 	 * built in mutexes and semaphores. This is safe as it is not possible
606 	 * to start a new load/unload operation till the current one is done.
607 	 */
608 	mutex_unlock(&cscfg_mutex);
609 
610 	/* create the configfs elements */
611 	err = cscfg_fs_register_cfgs_feats(config_descs, feat_descs);
612 	mutex_lock(&cscfg_mutex);
613 
614 	if (err)
615 		goto err_clean_cfs;
616 
617 	/* mark any new configs as available for activation */
618 	cscfg_set_configs_available(config_descs);
619 	goto exit_unlock;
620 
621 err_clean_cfs:
622 	/* cleanup after error registering with configfs */
623 	cscfg_fs_unregister_cfgs_feats(owner_info);
624 
625 	if (!list_is_singular(&cscfg_mgr->load_order_list))
626 		cscfg_owner_put(list_prev_entry(owner_info, item));
627 
628 err_clean_owner_list:
629 	list_del(&owner_info->item);
630 
631 err_clean_load:
632 	cscfg_unload_owned_cfgs_feats(owner_info);
633 
634 exit_unlock:
635 	cscfg_mgr->load_state = CSCFG_NONE;
636 	mutex_unlock(&cscfg_mutex);
637 	return err;
638 }
639 EXPORT_SYMBOL_GPL(cscfg_load_config_sets);
640 
641 /**
642  * cscfg_unload_config_sets - unload a set of configurations by owner.
643  *
644  * Dynamic unload of configuration and feature sets is done on the basis of
645  * the load owner of that set. Later loaded configurations can depend on
646  * features loaded earlier.
647  *
648  * Therefore, unload is only possible if:-
649  * 1) no configurations are active.
650  * 2) the set being unloaded was the last to be loaded to maintain dependencies.
651  *
652  * Once the unload operation commences, we disallow any configuration being
653  * made active until it is complete.
654  *
655  * @owner_info:	Information on owner for set being unloaded.
656  */
cscfg_unload_config_sets(struct cscfg_load_owner_info * owner_info)657 int cscfg_unload_config_sets(struct cscfg_load_owner_info *owner_info)
658 {
659 	int err = 0;
660 	struct cscfg_load_owner_info *load_list_item = NULL;
661 
662 	mutex_lock(&cscfg_mutex);
663 	if (cscfg_mgr->load_state != CSCFG_NONE) {
664 		mutex_unlock(&cscfg_mutex);
665 		return -EBUSY;
666 	}
667 
668 	/* unload op in progress also prevents activation of any config */
669 	cscfg_mgr->load_state = CSCFG_UNLOAD;
670 
671 	/* cannot unload if anything is active */
672 	if (atomic_read(&cscfg_mgr->sys_active_cnt)) {
673 		err = -EBUSY;
674 		goto exit_unlock;
675 	}
676 
677 	/* cannot unload if not last loaded in load order */
678 	if (!list_empty(&cscfg_mgr->load_order_list)) {
679 		load_list_item = list_last_entry(&cscfg_mgr->load_order_list,
680 						 struct cscfg_load_owner_info, item);
681 		if (load_list_item != owner_info)
682 			load_list_item = NULL;
683 	}
684 
685 	if (!load_list_item) {
686 		err = -EINVAL;
687 		goto exit_unlock;
688 	}
689 
690 	/* remove from configfs - again outside the scope of the list mutex */
691 	mutex_unlock(&cscfg_mutex);
692 	cscfg_fs_unregister_cfgs_feats(owner_info);
693 	mutex_lock(&cscfg_mutex);
694 
695 	/* unload everything from lists belonging to load_owner */
696 	cscfg_unload_owned_cfgs_feats(owner_info);
697 
698 	/* remove from load order list */
699 	if (!list_is_singular(&cscfg_mgr->load_order_list)) {
700 		/* unlock previous item in load order list */
701 		cscfg_owner_put(list_prev_entry(owner_info, item));
702 	}
703 	list_del(&owner_info->item);
704 
705 exit_unlock:
706 	cscfg_mgr->load_state = CSCFG_NONE;
707 	mutex_unlock(&cscfg_mutex);
708 	return err;
709 }
710 EXPORT_SYMBOL_GPL(cscfg_unload_config_sets);
711 
712 /* Handle coresight device registration and add configs and features to devices */
713 
714 /* iterate through config lists and load matching configs to device */
cscfg_add_cfgs_csdev(struct coresight_device * csdev)715 static int cscfg_add_cfgs_csdev(struct coresight_device *csdev)
716 {
717 	struct cscfg_config_desc *config_desc;
718 	int err = 0;
719 
720 	list_for_each_entry(config_desc, &cscfg_mgr->config_desc_list, item) {
721 		err = cscfg_add_csdev_cfg(csdev, config_desc);
722 		if (err)
723 			break;
724 	}
725 	return err;
726 }
727 
728 /* iterate through feature lists and load matching features to device */
cscfg_add_feats_csdev(struct coresight_device * csdev,u32 match_flags,struct cscfg_csdev_feat_ops * ops)729 static int cscfg_add_feats_csdev(struct coresight_device *csdev,
730 				 u32 match_flags,
731 				 struct cscfg_csdev_feat_ops *ops)
732 {
733 	struct cscfg_feature_desc *feat_desc;
734 	int err = 0;
735 
736 	if (!ops->load_feat)
737 		return -EINVAL;
738 
739 	list_for_each_entry(feat_desc, &cscfg_mgr->feat_desc_list, item) {
740 		if (feat_desc->match_flags & match_flags) {
741 			err = cscfg_load_feat_csdev(csdev, feat_desc, ops);
742 			if (err)
743 				break;
744 		}
745 	}
746 	return err;
747 }
748 
749 /* Add coresight device to list and copy its matching info */
cscfg_list_add_csdev(struct coresight_device * csdev,u32 match_flags,struct cscfg_csdev_feat_ops * ops)750 static int cscfg_list_add_csdev(struct coresight_device *csdev,
751 				u32 match_flags,
752 				struct cscfg_csdev_feat_ops *ops)
753 {
754 	struct cscfg_registered_csdev *csdev_item;
755 
756 	/* allocate the list entry structure */
757 	csdev_item = kzalloc(sizeof(struct cscfg_registered_csdev), GFP_KERNEL);
758 	if (!csdev_item)
759 		return -ENOMEM;
760 
761 	csdev_item->csdev = csdev;
762 	csdev_item->match_flags = match_flags;
763 	csdev_item->ops.load_feat = ops->load_feat;
764 	list_add(&csdev_item->item, &cscfg_mgr->csdev_desc_list);
765 
766 	INIT_LIST_HEAD(&csdev->feature_csdev_list);
767 	INIT_LIST_HEAD(&csdev->config_csdev_list);
768 	spin_lock_init(&csdev->cscfg_csdev_lock);
769 
770 	return 0;
771 }
772 
773 /* remove a coresight device from the list and free data */
cscfg_list_remove_csdev(struct coresight_device * csdev)774 static void cscfg_list_remove_csdev(struct coresight_device *csdev)
775 {
776 	struct cscfg_registered_csdev *csdev_item, *tmp;
777 
778 	list_for_each_entry_safe(csdev_item, tmp, &cscfg_mgr->csdev_desc_list, item) {
779 		if (csdev_item->csdev == csdev) {
780 			list_del(&csdev_item->item);
781 			kfree(csdev_item);
782 			break;
783 		}
784 	}
785 }
786 
787 /**
788  * cscfg_register_csdev - register a coresight device with the syscfg manager.
789  *
790  * Registers the coresight device with the system. @match_flags used to check
791  * if the device is a match for registered features. Any currently registered
792  * configurations and features that match the device will be loaded onto it.
793  *
794  * @csdev:		The coresight device to register.
795  * @match_flags:	Matching information to load features.
796  * @ops:		Standard operations supported by the device.
797  */
cscfg_register_csdev(struct coresight_device * csdev,u32 match_flags,struct cscfg_csdev_feat_ops * ops)798 int cscfg_register_csdev(struct coresight_device *csdev,
799 			 u32 match_flags,
800 			 struct cscfg_csdev_feat_ops *ops)
801 {
802 	int ret = 0;
803 
804 	mutex_lock(&cscfg_mutex);
805 
806 	/* add device to list of registered devices  */
807 	ret = cscfg_list_add_csdev(csdev, match_flags, ops);
808 	if (ret)
809 		goto reg_csdev_unlock;
810 
811 	/* now load any registered features and configs matching the device. */
812 	ret = cscfg_add_feats_csdev(csdev, match_flags, ops);
813 	if (ret) {
814 		cscfg_list_remove_csdev(csdev);
815 		goto reg_csdev_unlock;
816 	}
817 
818 	ret = cscfg_add_cfgs_csdev(csdev);
819 	if (ret) {
820 		cscfg_list_remove_csdev(csdev);
821 		goto reg_csdev_unlock;
822 	}
823 
824 	pr_info("CSCFG registered %s", dev_name(&csdev->dev));
825 
826 reg_csdev_unlock:
827 	mutex_unlock(&cscfg_mutex);
828 	return ret;
829 }
830 EXPORT_SYMBOL_GPL(cscfg_register_csdev);
831 
832 /**
833  * cscfg_unregister_csdev - remove coresight device from syscfg manager.
834  *
835  * @csdev: Device to remove.
836  */
cscfg_unregister_csdev(struct coresight_device * csdev)837 void cscfg_unregister_csdev(struct coresight_device *csdev)
838 {
839 	mutex_lock(&cscfg_mutex);
840 	cscfg_list_remove_csdev(csdev);
841 	mutex_unlock(&cscfg_mutex);
842 }
843 EXPORT_SYMBOL_GPL(cscfg_unregister_csdev);
844 
845 /**
846  * cscfg_csdev_reset_feats - reset features for a CoreSight device.
847  *
848  * Resets all parameters and register values for any features loaded
849  * into @csdev to their default values.
850  *
851  * @csdev: The CoreSight device.
852  */
cscfg_csdev_reset_feats(struct coresight_device * csdev)853 void cscfg_csdev_reset_feats(struct coresight_device *csdev)
854 {
855 	struct cscfg_feature_csdev *feat_csdev;
856 	unsigned long flags;
857 
858 	spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
859 	if (list_empty(&csdev->feature_csdev_list))
860 		goto unlock_exit;
861 
862 	list_for_each_entry(feat_csdev, &csdev->feature_csdev_list, node)
863 		cscfg_reset_feat(feat_csdev);
864 
865 unlock_exit:
866 	spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
867 }
868 EXPORT_SYMBOL_GPL(cscfg_csdev_reset_feats);
869 
870 /*
871  * This activate configuration for either perf or sysfs. Perf can have multiple
872  * active configs, selected per event, sysfs is limited to one.
873  *
874  * Increments the configuration descriptor active count and the global active
875  * count.
876  *
877  * @cfg_hash: Hash value of the selected configuration name.
878  */
_cscfg_activate_config(unsigned long cfg_hash)879 static int _cscfg_activate_config(unsigned long cfg_hash)
880 {
881 	struct cscfg_config_desc *config_desc;
882 	int err = -EINVAL;
883 
884 	if (cscfg_mgr->load_state == CSCFG_UNLOAD)
885 		return -EBUSY;
886 
887 	list_for_each_entry(config_desc, &cscfg_mgr->config_desc_list, item) {
888 		if ((unsigned long)config_desc->event_ea->var == cfg_hash) {
889 			/* if we happen upon a partly loaded config, can't use it */
890 			if (config_desc->available == false)
891 				return -EBUSY;
892 
893 			/* must ensure that config cannot be unloaded in use */
894 			err = cscfg_owner_get(config_desc->load_owner);
895 			if (err)
896 				break;
897 			/*
898 			 * increment the global active count - control changes to
899 			 * active configurations
900 			 */
901 			atomic_inc(&cscfg_mgr->sys_active_cnt);
902 
903 			/*
904 			 * mark the descriptor as active so enable config on a
905 			 * device instance will use it
906 			 */
907 			atomic_inc(&config_desc->active_cnt);
908 
909 			err = 0;
910 			dev_dbg(cscfg_device(), "Activate config %s.\n", config_desc->name);
911 			break;
912 		}
913 	}
914 	return err;
915 }
916 
_cscfg_deactivate_config(unsigned long cfg_hash)917 static void _cscfg_deactivate_config(unsigned long cfg_hash)
918 {
919 	struct cscfg_config_desc *config_desc;
920 
921 	list_for_each_entry(config_desc, &cscfg_mgr->config_desc_list, item) {
922 		if ((unsigned long)config_desc->event_ea->var == cfg_hash) {
923 			atomic_dec(&config_desc->active_cnt);
924 			atomic_dec(&cscfg_mgr->sys_active_cnt);
925 			cscfg_owner_put(config_desc->load_owner);
926 			dev_dbg(cscfg_device(), "Deactivate config %s.\n", config_desc->name);
927 			break;
928 		}
929 	}
930 }
931 
932 /*
933  * called from configfs to set/clear the active configuration for use when
934  * using sysfs to control trace.
935  */
cscfg_config_sysfs_activate(struct cscfg_config_desc * config_desc,bool activate)936 int cscfg_config_sysfs_activate(struct cscfg_config_desc *config_desc, bool activate)
937 {
938 	unsigned long cfg_hash;
939 	int err = 0;
940 
941 	mutex_lock(&cscfg_mutex);
942 
943 	cfg_hash = (unsigned long)config_desc->event_ea->var;
944 
945 	if (activate) {
946 		/* cannot be a current active value to activate this */
947 		if (cscfg_mgr->sysfs_active_config) {
948 			err = -EBUSY;
949 			goto exit_unlock;
950 		}
951 		err = _cscfg_activate_config(cfg_hash);
952 		if (!err)
953 			cscfg_mgr->sysfs_active_config = cfg_hash;
954 	} else {
955 		/* disable if matching current value */
956 		if (cscfg_mgr->sysfs_active_config == cfg_hash) {
957 			_cscfg_deactivate_config(cfg_hash);
958 			cscfg_mgr->sysfs_active_config = 0;
959 		} else
960 			err = -EINVAL;
961 	}
962 
963 exit_unlock:
964 	mutex_unlock(&cscfg_mutex);
965 	return err;
966 }
967 
968 /* set the sysfs preset value */
cscfg_config_sysfs_set_preset(int preset)969 void cscfg_config_sysfs_set_preset(int preset)
970 {
971 	mutex_lock(&cscfg_mutex);
972 	cscfg_mgr->sysfs_active_preset = preset;
973 	mutex_unlock(&cscfg_mutex);
974 }
975 
976 /*
977  * Used by a device to get the config and preset selected as active in configfs,
978  * when using sysfs to control trace.
979  */
cscfg_config_sysfs_get_active_cfg(unsigned long * cfg_hash,int * preset)980 void cscfg_config_sysfs_get_active_cfg(unsigned long *cfg_hash, int *preset)
981 {
982 	mutex_lock(&cscfg_mutex);
983 	*preset = cscfg_mgr->sysfs_active_preset;
984 	*cfg_hash = cscfg_mgr->sysfs_active_config;
985 	mutex_unlock(&cscfg_mutex);
986 }
987 EXPORT_SYMBOL_GPL(cscfg_config_sysfs_get_active_cfg);
988 
989 /**
990  * cscfg_activate_config -  Mark a configuration descriptor as active.
991  *
992  * This will be seen when csdev devices are enabled in the system.
993  * Only activated configurations can be enabled on individual devices.
994  * Activation protects the configuration from alteration or removal while
995  * active.
996  *
997  * Selection by hash value - generated from the configuration name when it
998  * was loaded and added to the cs_etm/configurations file system for selection
999  * by perf.
1000  *
1001  * @cfg_hash: Hash value of the selected configuration name.
1002  */
cscfg_activate_config(unsigned long cfg_hash)1003 int cscfg_activate_config(unsigned long cfg_hash)
1004 {
1005 	int err = 0;
1006 
1007 	mutex_lock(&cscfg_mutex);
1008 	err = _cscfg_activate_config(cfg_hash);
1009 	mutex_unlock(&cscfg_mutex);
1010 
1011 	return err;
1012 }
1013 EXPORT_SYMBOL_GPL(cscfg_activate_config);
1014 
1015 /**
1016  * cscfg_deactivate_config -  Mark a config descriptor as inactive.
1017  *
1018  * Decrement the configuration and global active counts.
1019  *
1020  * @cfg_hash: Hash value of the selected configuration name.
1021  */
cscfg_deactivate_config(unsigned long cfg_hash)1022 void cscfg_deactivate_config(unsigned long cfg_hash)
1023 {
1024 	mutex_lock(&cscfg_mutex);
1025 	_cscfg_deactivate_config(cfg_hash);
1026 	mutex_unlock(&cscfg_mutex);
1027 }
1028 EXPORT_SYMBOL_GPL(cscfg_deactivate_config);
1029 
1030 /**
1031  * cscfg_csdev_enable_active_config - Enable matching active configuration for device.
1032  *
1033  * Enables the configuration selected by @cfg_hash if the configuration is supported
1034  * on the device and has been activated.
1035  *
1036  * If active and supported the CoreSight device @csdev will be programmed with the
1037  * configuration, using @preset parameters.
1038  *
1039  * Should be called before driver hardware enable for the requested device, prior to
1040  * programming and enabling the physical hardware.
1041  *
1042  * @csdev:	CoreSight device to program.
1043  * @cfg_hash:	Selector for the configuration.
1044  * @preset:	Preset parameter values to use, 0 for current / default values.
1045  */
cscfg_csdev_enable_active_config(struct coresight_device * csdev,unsigned long cfg_hash,int preset)1046 int cscfg_csdev_enable_active_config(struct coresight_device *csdev,
1047 				     unsigned long cfg_hash, int preset)
1048 {
1049 	struct cscfg_config_csdev *config_csdev_active = NULL, *config_csdev_item;
1050 	const struct cscfg_config_desc *config_desc;
1051 	unsigned long flags;
1052 	int err = 0;
1053 
1054 	/* quickly check global count */
1055 	if (!atomic_read(&cscfg_mgr->sys_active_cnt))
1056 		return 0;
1057 
1058 	/*
1059 	 * Look for matching configuration - set the active configuration
1060 	 * context if found.
1061 	 */
1062 	spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
1063 	list_for_each_entry(config_csdev_item, &csdev->config_csdev_list, node) {
1064 		config_desc = config_csdev_item->config_desc;
1065 		if ((atomic_read(&config_desc->active_cnt)) &&
1066 		    ((unsigned long)config_desc->event_ea->var == cfg_hash)) {
1067 			config_csdev_active = config_csdev_item;
1068 			csdev->active_cscfg_ctxt = (void *)config_csdev_active;
1069 			break;
1070 		}
1071 	}
1072 	spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
1073 
1074 	/*
1075 	 * If found, attempt to enable
1076 	 */
1077 	if (config_csdev_active) {
1078 		/*
1079 		 * Call the generic routine that will program up the internal
1080 		 * driver structures prior to programming up the hardware.
1081 		 * This routine takes the driver spinlock saved in the configs.
1082 		 */
1083 		err = cscfg_csdev_enable_config(config_csdev_active, preset);
1084 		if (!err) {
1085 			/*
1086 			 * Successful programming. Check the active_cscfg_ctxt
1087 			 * pointer to ensure no pre-emption disabled it via
1088 			 * cscfg_csdev_disable_active_config() before
1089 			 * we could start.
1090 			 *
1091 			 * Set enabled if OK, err if not.
1092 			 */
1093 			spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
1094 			if (csdev->active_cscfg_ctxt)
1095 				config_csdev_active->enabled = true;
1096 			else
1097 				err = -EBUSY;
1098 			spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
1099 		}
1100 	}
1101 	return err;
1102 }
1103 EXPORT_SYMBOL_GPL(cscfg_csdev_enable_active_config);
1104 
1105 /**
1106  * cscfg_csdev_disable_active_config - disable an active config on the device.
1107  *
1108  * Disables the active configuration on the CoreSight device @csdev.
1109  * Disable will save the values of any registers marked in the configurations
1110  * as save on disable.
1111  *
1112  * Should be called after driver hardware disable for the requested device,
1113  * after disabling the physical hardware and reading back registers.
1114  *
1115  * @csdev: The CoreSight device.
1116  */
cscfg_csdev_disable_active_config(struct coresight_device * csdev)1117 void cscfg_csdev_disable_active_config(struct coresight_device *csdev)
1118 {
1119 	struct cscfg_config_csdev *config_csdev;
1120 	unsigned long flags;
1121 
1122 	/*
1123 	 * Check if we have an active config, and that it was successfully enabled.
1124 	 * If it was not enabled, we have no work to do, otherwise mark as disabled.
1125 	 * Clear the active config pointer.
1126 	 */
1127 	spin_lock_irqsave(&csdev->cscfg_csdev_lock, flags);
1128 	config_csdev = (struct cscfg_config_csdev *)csdev->active_cscfg_ctxt;
1129 	if (config_csdev) {
1130 		if (!config_csdev->enabled)
1131 			config_csdev = NULL;
1132 		else
1133 			config_csdev->enabled = false;
1134 	}
1135 	csdev->active_cscfg_ctxt = NULL;
1136 	spin_unlock_irqrestore(&csdev->cscfg_csdev_lock, flags);
1137 
1138 	/* true if there was an enabled active config */
1139 	if (config_csdev)
1140 		cscfg_csdev_disable_config(config_csdev);
1141 }
1142 EXPORT_SYMBOL_GPL(cscfg_csdev_disable_active_config);
1143 
1144 /* Initialise system configuration management device. */
1145 
cscfg_device(void)1146 struct device *cscfg_device(void)
1147 {
1148 	return cscfg_mgr ? &cscfg_mgr->dev : NULL;
1149 }
1150 
1151 /* Must have a release function or the kernel will complain on module unload */
cscfg_dev_release(struct device * dev)1152 static void cscfg_dev_release(struct device *dev)
1153 {
1154 	mutex_lock(&cscfg_mutex);
1155 	kfree(cscfg_mgr);
1156 	cscfg_mgr = NULL;
1157 	mutex_unlock(&cscfg_mutex);
1158 }
1159 
1160 /* a device is needed to "own" some kernel elements such as sysfs entries.  */
cscfg_create_device(void)1161 static int cscfg_create_device(void)
1162 {
1163 	struct device *dev;
1164 	int err = -ENOMEM;
1165 
1166 	mutex_lock(&cscfg_mutex);
1167 	if (cscfg_mgr) {
1168 		err = -EINVAL;
1169 		goto create_dev_exit_unlock;
1170 	}
1171 
1172 	cscfg_mgr = kzalloc(sizeof(struct cscfg_manager), GFP_KERNEL);
1173 	if (!cscfg_mgr)
1174 		goto create_dev_exit_unlock;
1175 
1176 	/* initialise the cscfg_mgr structure */
1177 	INIT_LIST_HEAD(&cscfg_mgr->csdev_desc_list);
1178 	INIT_LIST_HEAD(&cscfg_mgr->feat_desc_list);
1179 	INIT_LIST_HEAD(&cscfg_mgr->config_desc_list);
1180 	INIT_LIST_HEAD(&cscfg_mgr->load_order_list);
1181 	atomic_set(&cscfg_mgr->sys_active_cnt, 0);
1182 	cscfg_mgr->load_state = CSCFG_NONE;
1183 
1184 	/* setup the device */
1185 	dev = cscfg_device();
1186 	dev->release = cscfg_dev_release;
1187 	dev->init_name = "cs_system_cfg";
1188 
1189 	err = device_register(dev);
1190 	if (err)
1191 		put_device(dev);
1192 
1193 create_dev_exit_unlock:
1194 	mutex_unlock(&cscfg_mutex);
1195 	return err;
1196 }
1197 
1198 /*
1199  * Loading and unloading is generally on user discretion.
1200  * If exiting due to coresight module unload, we need to unload any configurations that remain,
1201  * before we unregister the configfs intrastructure.
1202  *
1203  * Do this by walking the load_owner list and taking appropriate action, depending on the load
1204  * owner type.
1205  */
cscfg_unload_cfgs_on_exit(void)1206 static void cscfg_unload_cfgs_on_exit(void)
1207 {
1208 	struct cscfg_load_owner_info *owner_info = NULL;
1209 
1210 	/*
1211 	 * grab the mutex - even though we are exiting, some configfs files
1212 	 * may still be live till we dump them, so ensure list data is
1213 	 * protected from a race condition.
1214 	 */
1215 	mutex_lock(&cscfg_mutex);
1216 	while (!list_empty(&cscfg_mgr->load_order_list)) {
1217 
1218 		/* remove in reverse order of loading */
1219 		owner_info = list_last_entry(&cscfg_mgr->load_order_list,
1220 					     struct cscfg_load_owner_info, item);
1221 
1222 		/* action according to type */
1223 		switch (owner_info->type) {
1224 		case CSCFG_OWNER_PRELOAD:
1225 			/*
1226 			 * preloaded  descriptors are statically allocated in
1227 			 * this module - just need to unload dynamic items from
1228 			 * csdev lists, and remove from configfs directories.
1229 			 */
1230 			pr_info("cscfg: unloading preloaded configurations\n");
1231 			break;
1232 
1233 		case  CSCFG_OWNER_MODULE:
1234 			/*
1235 			 * this is an error - the loadable module must have been unloaded prior
1236 			 * to the coresight module unload. Therefore that module has not
1237 			 * correctly unloaded configs in its own exit code.
1238 			 * Nothing to do other than emit an error string as the static descriptor
1239 			 * references we need to unload will have disappeared with the module.
1240 			 */
1241 			pr_err("cscfg: ERROR: prior module failed to unload configuration\n");
1242 			goto list_remove;
1243 		}
1244 
1245 		/* remove from configfs - outside the scope of the list mutex */
1246 		mutex_unlock(&cscfg_mutex);
1247 		cscfg_fs_unregister_cfgs_feats(owner_info);
1248 		mutex_lock(&cscfg_mutex);
1249 
1250 		/* Next unload from csdev lists. */
1251 		cscfg_unload_owned_cfgs_feats(owner_info);
1252 
1253 list_remove:
1254 		/* remove from load order list */
1255 		list_del(&owner_info->item);
1256 	}
1257 	mutex_unlock(&cscfg_mutex);
1258 }
1259 
cscfg_clear_device(void)1260 static void cscfg_clear_device(void)
1261 {
1262 	cscfg_unload_cfgs_on_exit();
1263 	cscfg_configfs_release(cscfg_mgr);
1264 	device_unregister(cscfg_device());
1265 }
1266 
1267 /* Initialise system config management API device  */
cscfg_init(void)1268 int __init cscfg_init(void)
1269 {
1270 	int err = 0;
1271 
1272 	/* create the device and init cscfg_mgr */
1273 	err = cscfg_create_device();
1274 	if (err)
1275 		return err;
1276 
1277 	/* initialise configfs subsystem */
1278 	err = cscfg_configfs_init(cscfg_mgr);
1279 	if (err)
1280 		goto exit_err;
1281 
1282 	/* preload built-in configurations */
1283 	err = cscfg_preload(THIS_MODULE);
1284 	if (err)
1285 		goto exit_err;
1286 
1287 	dev_info(cscfg_device(), "CoreSight Configuration manager initialised");
1288 	return 0;
1289 
1290 exit_err:
1291 	cscfg_clear_device();
1292 	return err;
1293 }
1294 
cscfg_exit(void)1295 void cscfg_exit(void)
1296 {
1297 	cscfg_clear_device();
1298 }
1299