xref: /linux/drivers/gpu/drm/xe/xe_gt_sriov_pf_debugfs.c (revision 2c1ed907520c50326b8f604907a8478b27881a2e)
1 // SPDX-License-Identifier: MIT
2 /*
3  * Copyright © 2023-2024 Intel Corporation
4  */
5 
6 #include <linux/debugfs.h>
7 
8 #include <drm/drm_print.h>
9 #include <drm/drm_debugfs.h>
10 
11 #include "xe_bo.h"
12 #include "xe_debugfs.h"
13 #include "xe_device.h"
14 #include "xe_gt.h"
15 #include "xe_gt_debugfs.h"
16 #include "xe_gt_sriov_pf_config.h"
17 #include "xe_gt_sriov_pf_control.h"
18 #include "xe_gt_sriov_pf_debugfs.h"
19 #include "xe_gt_sriov_pf_helpers.h"
20 #include "xe_gt_sriov_pf_migration.h"
21 #include "xe_gt_sriov_pf_monitor.h"
22 #include "xe_gt_sriov_pf_policy.h"
23 #include "xe_gt_sriov_pf_service.h"
24 #include "xe_pm.h"
25 
26 /*
27  *      /sys/kernel/debug/dri/0/
28  *      ├── gt0		# d_inode->i_private = gt
29  *      │   ├── pf	# d_inode->i_private = gt
30  *      │   ├── vf1	# d_inode->i_private = VFID(1)
31  *      :   :
32  *      │   ├── vfN	# d_inode->i_private = VFID(N)
33  */
34 
extract_priv(struct dentry * d)35 static void *extract_priv(struct dentry *d)
36 {
37 	return d->d_inode->i_private;
38 }
39 
extract_gt(struct dentry * d)40 static struct xe_gt *extract_gt(struct dentry *d)
41 {
42 	return extract_priv(d->d_parent);
43 }
44 
extract_vfid(struct dentry * d)45 static unsigned int extract_vfid(struct dentry *d)
46 {
47 	return extract_priv(d) == extract_gt(d) ? PFID : (uintptr_t)extract_priv(d);
48 }
49 
50 /*
51  *      /sys/kernel/debug/dri/0/
52  *      ├── gt0
53  *      │   ├── pf
54  *      │   │   ├── ggtt_available
55  *      │   │   ├── ggtt_provisioned
56  *      │   │   ├── contexts_provisioned
57  *      │   │   ├── doorbells_provisioned
58  *      │   │   ├── runtime_registers
59  *      │   │   ├── negotiated_versions
60  *      │   │   ├── adverse_events
61  */
62 
63 static const struct drm_info_list pf_info[] = {
64 	{
65 		"ggtt_available",
66 		.show = xe_gt_debugfs_simple_show,
67 		.data = xe_gt_sriov_pf_config_print_available_ggtt,
68 	},
69 	{
70 		"ggtt_provisioned",
71 		.show = xe_gt_debugfs_simple_show,
72 		.data = xe_gt_sriov_pf_config_print_ggtt,
73 	},
74 	{
75 		"contexts_provisioned",
76 		.show = xe_gt_debugfs_simple_show,
77 		.data = xe_gt_sriov_pf_config_print_ctxs,
78 	},
79 	{
80 		"doorbells_provisioned",
81 		.show = xe_gt_debugfs_simple_show,
82 		.data = xe_gt_sriov_pf_config_print_dbs,
83 	},
84 	{
85 		"lmem_provisioned",
86 		.show = xe_gt_debugfs_simple_show,
87 		.data = xe_gt_sriov_pf_config_print_lmem,
88 	},
89 	{
90 		"runtime_registers",
91 		.show = xe_gt_debugfs_simple_show,
92 		.data = xe_gt_sriov_pf_service_print_runtime,
93 	},
94 	{
95 		"negotiated_versions",
96 		.show = xe_gt_debugfs_simple_show,
97 		.data = xe_gt_sriov_pf_service_print_version,
98 	},
99 	{
100 		"adverse_events",
101 		.show = xe_gt_debugfs_simple_show,
102 		.data = xe_gt_sriov_pf_monitor_print_events,
103 	},
104 };
105 
106 /*
107  *      /sys/kernel/debug/dri/0/
108  *      ├── gt0
109  *      │   ├── pf
110  *      │   │   ├── reset_engine
111  *      │   │   ├── sample_period
112  *      │   │   ├── sched_if_idle
113  */
114 
115 #define DEFINE_SRIOV_GT_POLICY_DEBUGFS_ATTRIBUTE(POLICY, TYPE, FORMAT)		\
116 										\
117 static int POLICY##_set(void *data, u64 val)					\
118 {										\
119 	struct xe_gt *gt = extract_gt(data);					\
120 	struct xe_device *xe = gt_to_xe(gt);					\
121 	int err;								\
122 										\
123 	if (val > (TYPE)~0ull)							\
124 		return -EOVERFLOW;						\
125 										\
126 	xe_pm_runtime_get(xe);							\
127 	err = xe_gt_sriov_pf_policy_set_##POLICY(gt, val);			\
128 	xe_pm_runtime_put(xe);							\
129 										\
130 	return err;								\
131 }										\
132 										\
133 static int POLICY##_get(void *data, u64 *val)					\
134 {										\
135 	struct xe_gt *gt = extract_gt(data);					\
136 										\
137 	*val = xe_gt_sriov_pf_policy_get_##POLICY(gt);				\
138 	return 0;								\
139 }										\
140 										\
141 DEFINE_DEBUGFS_ATTRIBUTE(POLICY##_fops, POLICY##_get, POLICY##_set, FORMAT)
142 
143 DEFINE_SRIOV_GT_POLICY_DEBUGFS_ATTRIBUTE(reset_engine, bool, "%llu\n");
144 DEFINE_SRIOV_GT_POLICY_DEBUGFS_ATTRIBUTE(sched_if_idle, bool, "%llu\n");
145 DEFINE_SRIOV_GT_POLICY_DEBUGFS_ATTRIBUTE(sample_period, u32, "%llu\n");
146 
pf_add_policy_attrs(struct xe_gt * gt,struct dentry * parent)147 static void pf_add_policy_attrs(struct xe_gt *gt, struct dentry *parent)
148 {
149 	xe_gt_assert(gt, gt == extract_gt(parent));
150 	xe_gt_assert(gt, PFID == extract_vfid(parent));
151 
152 	debugfs_create_file_unsafe("reset_engine", 0644, parent, parent, &reset_engine_fops);
153 	debugfs_create_file_unsafe("sched_if_idle", 0644, parent, parent, &sched_if_idle_fops);
154 	debugfs_create_file_unsafe("sample_period_ms", 0644, parent, parent, &sample_period_fops);
155 }
156 
157 /*
158  *      /sys/kernel/debug/dri/0/
159  *      ├── gt0
160  *      │   ├── pf
161  *      │   │   ├── ggtt_spare
162  *      │   │   ├── lmem_spare
163  *      │   │   ├── doorbells_spare
164  *      │   │   ├── contexts_spare
165  *      │   │   ├── exec_quantum_ms
166  *      │   │   ├── preempt_timeout_us
167  *      │   │   ├── sched_priority
168  *      │   ├── vf1
169  *      │   │   ├── ggtt_quota
170  *      │   │   ├── lmem_quota
171  *      │   │   ├── doorbells_quota
172  *      │   │   ├── contexts_quota
173  *      │   │   ├── exec_quantum_ms
174  *      │   │   ├── preempt_timeout_us
175  *      │   │   ├── sched_priority
176  */
177 
178 #define DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(CONFIG, TYPE, FORMAT)		\
179 										\
180 static int CONFIG##_set(void *data, u64 val)					\
181 {										\
182 	struct xe_gt *gt = extract_gt(data);					\
183 	unsigned int vfid = extract_vfid(data);					\
184 	struct xe_device *xe = gt_to_xe(gt);					\
185 	int err;								\
186 										\
187 	if (val > (TYPE)~0ull)							\
188 		return -EOVERFLOW;						\
189 										\
190 	xe_pm_runtime_get(xe);							\
191 	err = xe_gt_sriov_pf_config_set_##CONFIG(gt, vfid, val);		\
192 	xe_pm_runtime_put(xe);							\
193 										\
194 	return err;								\
195 }										\
196 										\
197 static int CONFIG##_get(void *data, u64 *val)					\
198 {										\
199 	struct xe_gt *gt = extract_gt(data);					\
200 	unsigned int vfid = extract_vfid(data);					\
201 										\
202 	*val = xe_gt_sriov_pf_config_get_##CONFIG(gt, vfid);			\
203 	return 0;								\
204 }										\
205 										\
206 DEFINE_DEBUGFS_ATTRIBUTE(CONFIG##_fops, CONFIG##_get, CONFIG##_set, FORMAT)
207 
208 DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(ggtt, u64, "%llu\n");
209 DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(lmem, u64, "%llu\n");
210 DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(ctxs, u32, "%llu\n");
211 DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(dbs, u32, "%llu\n");
212 DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(exec_quantum, u32, "%llu\n");
213 DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(preempt_timeout, u32, "%llu\n");
214 DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(sched_priority, u32, "%llu\n");
215 
216 /*
217  *      /sys/kernel/debug/dri/0/
218  *      ├── gt0
219  *      │   ├── pf
220  *      │   │   ├── threshold_cat_error_count
221  *      │   │   ├── threshold_doorbell_time_us
222  *      │   │   ├── threshold_engine_reset_count
223  *      │   │   ├── threshold_guc_time_us
224  *      │   │   ├── threshold_irq_time_us
225  *      │   │   ├── threshold_page_fault_count
226  *      │   ├── vf1
227  *      │   │   ├── threshold_cat_error_count
228  *      │   │   ├── threshold_doorbell_time_us
229  *      │   │   ├── threshold_engine_reset_count
230  *      │   │   ├── threshold_guc_time_us
231  *      │   │   ├── threshold_irq_time_us
232  *      │   │   ├── threshold_page_fault_count
233  */
234 
set_threshold(void * data,u64 val,enum xe_guc_klv_threshold_index index)235 static int set_threshold(void *data, u64 val, enum xe_guc_klv_threshold_index index)
236 {
237 	struct xe_gt *gt = extract_gt(data);
238 	unsigned int vfid = extract_vfid(data);
239 	struct xe_device *xe = gt_to_xe(gt);
240 	int err;
241 
242 	if (val > (u32)~0ull)
243 		return -EOVERFLOW;
244 
245 	xe_pm_runtime_get(xe);
246 	err = xe_gt_sriov_pf_config_set_threshold(gt, vfid, index, val);
247 	xe_pm_runtime_put(xe);
248 
249 	return err;
250 }
251 
get_threshold(void * data,u64 * val,enum xe_guc_klv_threshold_index index)252 static int get_threshold(void *data, u64 *val, enum xe_guc_klv_threshold_index index)
253 {
254 	struct xe_gt *gt = extract_gt(data);
255 	unsigned int vfid = extract_vfid(data);
256 
257 	*val = xe_gt_sriov_pf_config_get_threshold(gt, vfid, index);
258 	return 0;
259 }
260 
261 #define DEFINE_SRIOV_GT_THRESHOLD_DEBUGFS_ATTRIBUTE(THRESHOLD, INDEX)		\
262 										\
263 static int THRESHOLD##_set(void *data, u64 val)					\
264 {										\
265 	return set_threshold(data, val, INDEX);					\
266 }										\
267 										\
268 static int THRESHOLD##_get(void *data, u64 *val)				\
269 {										\
270 	return get_threshold(data, val, INDEX);					\
271 }										\
272 										\
273 DEFINE_DEBUGFS_ATTRIBUTE(THRESHOLD##_fops, THRESHOLD##_get, THRESHOLD##_set, "%llu\n")
274 
275 /* generate all threshold attributes */
276 #define define_threshold_attribute(TAG, NAME, ...) \
277 	DEFINE_SRIOV_GT_THRESHOLD_DEBUGFS_ATTRIBUTE(NAME, MAKE_XE_GUC_KLV_THRESHOLD_INDEX(TAG));
MAKE_XE_GUC_KLV_THRESHOLDS_SET(define_threshold_attribute)278 MAKE_XE_GUC_KLV_THRESHOLDS_SET(define_threshold_attribute)
279 #undef define_threshold_attribute
280 
281 static void pf_add_config_attrs(struct xe_gt *gt, struct dentry *parent, unsigned int vfid)
282 {
283 	xe_gt_assert(gt, gt == extract_gt(parent));
284 	xe_gt_assert(gt, vfid == extract_vfid(parent));
285 
286 	if (!xe_gt_is_media_type(gt)) {
287 		debugfs_create_file_unsafe(vfid ? "ggtt_quota" : "ggtt_spare",
288 					   0644, parent, parent, &ggtt_fops);
289 		if (IS_DGFX(gt_to_xe(gt)))
290 			debugfs_create_file_unsafe(vfid ? "lmem_quota" : "lmem_spare",
291 						   0644, parent, parent, &lmem_fops);
292 	}
293 	debugfs_create_file_unsafe(vfid ? "doorbells_quota" : "doorbells_spare",
294 				   0644, parent, parent, &dbs_fops);
295 	debugfs_create_file_unsafe(vfid ? "contexts_quota" : "contexts_spare",
296 				   0644, parent, parent, &ctxs_fops);
297 	debugfs_create_file_unsafe("exec_quantum_ms", 0644, parent, parent,
298 				   &exec_quantum_fops);
299 	debugfs_create_file_unsafe("preempt_timeout_us", 0644, parent, parent,
300 				   &preempt_timeout_fops);
301 	debugfs_create_file_unsafe("sched_priority", 0644, parent, parent,
302 				   &sched_priority_fops);
303 
304 	/* register all threshold attributes */
305 #define register_threshold_attribute(TAG, NAME, ...) \
306 	debugfs_create_file_unsafe("threshold_" #NAME, 0644, parent, parent, \
307 				   &NAME##_fops);
308 	MAKE_XE_GUC_KLV_THRESHOLDS_SET(register_threshold_attribute)
309 #undef register_threshold_attribute
310 }
311 
312 /*
313  *      /sys/kernel/debug/dri/0/
314  *      ├── gt0
315  *      │   ├── vf1
316  *      │   │   ├── control { stop, pause, resume }
317  */
318 
319 static const struct {
320 	const char *cmd;
321 	int (*fn)(struct xe_gt *gt, unsigned int vfid);
322 } control_cmds[] = {
323 	{ "stop", xe_gt_sriov_pf_control_stop_vf },
324 	{ "pause", xe_gt_sriov_pf_control_pause_vf },
325 	{ "resume", xe_gt_sriov_pf_control_resume_vf },
326 #ifdef CONFIG_DRM_XE_DEBUG_SRIOV
327 	{ "restore!", xe_gt_sriov_pf_migration_restore_guc_state },
328 #endif
329 };
330 
control_write(struct file * file,const char __user * buf,size_t count,loff_t * pos)331 static ssize_t control_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
332 {
333 	struct dentry *dent = file_dentry(file);
334 	struct dentry *parent = dent->d_parent;
335 	struct xe_gt *gt = extract_gt(parent);
336 	struct xe_device *xe = gt_to_xe(gt);
337 	unsigned int vfid = extract_vfid(parent);
338 	int ret = -EINVAL;
339 	char cmd[32];
340 	size_t n;
341 
342 	xe_gt_assert(gt, vfid);
343 	xe_gt_sriov_pf_assert_vfid(gt, vfid);
344 
345 	if (*pos)
346 		return -ESPIPE;
347 
348 	if (count > sizeof(cmd) - 1)
349 		return -EINVAL;
350 
351 	ret = simple_write_to_buffer(cmd, sizeof(cmd) - 1, pos, buf, count);
352 	if (ret < 0)
353 		return ret;
354 	cmd[ret] = '\0';
355 
356 	for (n = 0; n < ARRAY_SIZE(control_cmds); n++) {
357 		xe_gt_assert(gt, sizeof(cmd) > strlen(control_cmds[n].cmd));
358 
359 		if (sysfs_streq(cmd, control_cmds[n].cmd)) {
360 			xe_pm_runtime_get(xe);
361 			ret = control_cmds[n].fn ? (*control_cmds[n].fn)(gt, vfid) : 0;
362 			xe_pm_runtime_put(xe);
363 			break;
364 		}
365 	}
366 
367 	return (ret < 0) ? ret : count;
368 }
369 
control_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)370 static ssize_t control_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
371 {
372 	char help[128];
373 	size_t n;
374 
375 	help[0] = '\0';
376 	for (n = 0; n < ARRAY_SIZE(control_cmds); n++) {
377 		strlcat(help, control_cmds[n].cmd, sizeof(help));
378 		strlcat(help, "\n", sizeof(help));
379 	}
380 
381 	return simple_read_from_buffer(buf, count, ppos, help, strlen(help));
382 }
383 
384 static const struct file_operations control_ops = {
385 	.owner		= THIS_MODULE,
386 	.open		= simple_open,
387 	.write		= control_write,
388 	.read		= control_read,
389 	.llseek		= default_llseek,
390 };
391 
392 /*
393  *      /sys/kernel/debug/dri/0/
394  *      ├── gt0
395  *      │   ├── vf1
396  *      │   │   ├── guc_state
397  */
guc_state_read(struct file * file,char __user * buf,size_t count,loff_t * pos)398 static ssize_t guc_state_read(struct file *file, char __user *buf,
399 			      size_t count, loff_t *pos)
400 {
401 	struct dentry *dent = file_dentry(file);
402 	struct dentry *parent = dent->d_parent;
403 	struct xe_gt *gt = extract_gt(parent);
404 	unsigned int vfid = extract_vfid(parent);
405 
406 	return xe_gt_sriov_pf_migration_read_guc_state(gt, vfid, buf, count, pos);
407 }
408 
guc_state_write(struct file * file,const char __user * buf,size_t count,loff_t * pos)409 static ssize_t guc_state_write(struct file *file, const char __user *buf,
410 			       size_t count, loff_t *pos)
411 {
412 	struct dentry *dent = file_dentry(file);
413 	struct dentry *parent = dent->d_parent;
414 	struct xe_gt *gt = extract_gt(parent);
415 	unsigned int vfid = extract_vfid(parent);
416 
417 	if (*pos)
418 		return -EINVAL;
419 
420 	return xe_gt_sriov_pf_migration_write_guc_state(gt, vfid, buf, count);
421 }
422 
423 static const struct file_operations guc_state_ops = {
424 	.owner		= THIS_MODULE,
425 	.read		= guc_state_read,
426 	.write		= guc_state_write,
427 	.llseek		= default_llseek,
428 };
429 
430 /*
431  *      /sys/kernel/debug/dri/0/
432  *      ├── gt0
433  *      │   ├── vf1
434  *      │   │   ├── config_blob
435  */
config_blob_read(struct file * file,char __user * buf,size_t count,loff_t * pos)436 static ssize_t config_blob_read(struct file *file, char __user *buf,
437 				size_t count, loff_t *pos)
438 {
439 	struct dentry *dent = file_dentry(file);
440 	struct dentry *parent = dent->d_parent;
441 	struct xe_gt *gt = extract_gt(parent);
442 	unsigned int vfid = extract_vfid(parent);
443 	ssize_t ret;
444 	void *tmp;
445 
446 	ret = xe_gt_sriov_pf_config_save(gt, vfid, NULL, 0);
447 	if (!ret)
448 		return -ENODATA;
449 	if (ret < 0)
450 		return ret;
451 
452 	tmp = kzalloc(ret, GFP_KERNEL);
453 	if (!tmp)
454 		return -ENOMEM;
455 
456 	ret = xe_gt_sriov_pf_config_save(gt, vfid, tmp, ret);
457 	if (ret > 0)
458 		ret = simple_read_from_buffer(buf, count, pos, tmp, ret);
459 
460 	kfree(tmp);
461 	return ret;
462 }
463 
config_blob_write(struct file * file,const char __user * buf,size_t count,loff_t * pos)464 static ssize_t config_blob_write(struct file *file, const char __user *buf,
465 				 size_t count, loff_t *pos)
466 {
467 	struct dentry *dent = file_dentry(file);
468 	struct dentry *parent = dent->d_parent;
469 	struct xe_gt *gt = extract_gt(parent);
470 	unsigned int vfid = extract_vfid(parent);
471 	ssize_t ret;
472 	void *tmp;
473 
474 	if (*pos)
475 		return -EINVAL;
476 
477 	if (!count)
478 		return -ENODATA;
479 
480 	if (count > SZ_4K)
481 		return -EINVAL;
482 
483 	tmp = kzalloc(count, GFP_KERNEL);
484 	if (!tmp)
485 		return -ENOMEM;
486 
487 	if (copy_from_user(tmp, buf, count)) {
488 		ret = -EFAULT;
489 	} else {
490 		ret = xe_gt_sriov_pf_config_restore(gt, vfid, tmp, count);
491 		if (!ret)
492 			ret = count;
493 	}
494 	kfree(tmp);
495 	return ret;
496 }
497 
498 static const struct file_operations config_blob_ops = {
499 	.owner		= THIS_MODULE,
500 	.read		= config_blob_read,
501 	.write		= config_blob_write,
502 	.llseek		= default_llseek,
503 };
504 
505 /**
506  * xe_gt_sriov_pf_debugfs_register - Register SR-IOV PF specific entries in GT debugfs.
507  * @gt: the &xe_gt to register
508  * @root: the &dentry that represents the GT directory
509  *
510  * Register SR-IOV PF entries that are GT related and must be shown under GT debugfs.
511  */
xe_gt_sriov_pf_debugfs_register(struct xe_gt * gt,struct dentry * root)512 void xe_gt_sriov_pf_debugfs_register(struct xe_gt *gt, struct dentry *root)
513 {
514 	struct xe_device *xe = gt_to_xe(gt);
515 	struct drm_minor *minor = xe->drm.primary;
516 	int n, totalvfs = xe_sriov_pf_get_totalvfs(xe);
517 	struct dentry *pfdentry;
518 	struct dentry *vfdentry;
519 	char buf[14]; /* should be enough up to "vf%u\0" for 2^32 - 1 */
520 
521 	xe_gt_assert(gt, IS_SRIOV_PF(xe));
522 	xe_gt_assert(gt, root->d_inode->i_private == gt);
523 
524 	/*
525 	 *      /sys/kernel/debug/dri/0/
526 	 *      ├── gt0
527 	 *      │   ├── pf
528 	 */
529 	pfdentry = debugfs_create_dir("pf", root);
530 	if (IS_ERR(pfdentry))
531 		return;
532 	pfdentry->d_inode->i_private = gt;
533 
534 	drm_debugfs_create_files(pf_info, ARRAY_SIZE(pf_info), pfdentry, minor);
535 	pf_add_policy_attrs(gt, pfdentry);
536 	pf_add_config_attrs(gt, pfdentry, PFID);
537 
538 	for (n = 1; n <= totalvfs; n++) {
539 		/*
540 		 *      /sys/kernel/debug/dri/0/
541 		 *      ├── gt0
542 		 *      │   ├── vf1
543 		 *      │   ├── vf2
544 		 */
545 		snprintf(buf, sizeof(buf), "vf%u", n);
546 		vfdentry = debugfs_create_dir(buf, root);
547 		if (IS_ERR(vfdentry))
548 			break;
549 		vfdentry->d_inode->i_private = (void *)(uintptr_t)n;
550 
551 		pf_add_config_attrs(gt, vfdentry, VFID(n));
552 		debugfs_create_file("control", 0600, vfdentry, NULL, &control_ops);
553 
554 		/* for testing/debugging purposes only! */
555 		if (IS_ENABLED(CONFIG_DRM_XE_DEBUG)) {
556 			debugfs_create_file("guc_state",
557 					    IS_ENABLED(CONFIG_DRM_XE_DEBUG_SRIOV) ? 0600 : 0400,
558 					    vfdentry, NULL, &guc_state_ops);
559 			debugfs_create_file("config_blob",
560 					    IS_ENABLED(CONFIG_DRM_XE_DEBUG_SRIOV) ? 0600 : 0400,
561 					    vfdentry, NULL, &config_blob_ops);
562 		}
563 	}
564 }
565