projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[S390] Inline assembly cleanup.
[deliverable/linux.git] / arch / s390 / hypfs / hypfs_diag.c
CommitLineData
24bbb1fa 1/*
f19bfb2c 2 * arch/s390/hypfs/hypfs_diag.c
24bbb1fa
MH		 3 * Hypervisor filesystem for Linux on s390. Diag 204 and 224
4 * implementation.
5 *
6 * Copyright (C) IBM Corp. 2006
7 * Author(s): Michael Holzheu <holzheu@de.ibm.com>
8 */
9
10#include <linux/types.h>
11#include <linux/errno.h>
12#include <linux/string.h>
13#include <linux/vmalloc.h>
14#include <asm/ebcdic.h>
15#include "hypfs.h"
16
17#define LPAR_NAME_LEN 8 /* lpar name len in diag 204 data */
18#define CPU_NAME_LEN 16 /* type name len of cpus in diag224 name table */
19#define TMP_SIZE 64 /* size of temporary buffers */
20
21/* diag 204 subcodes */
22enum diag204_sc {
23 SUBC_STIB4 = 4,
24 SUBC_RSI = 5,
25 SUBC_STIB6 = 6,
26 SUBC_STIB7 = 7
27};
28
29/* The two available diag 204 data formats */
30enum diag204_format {
31 INFO_SIMPLE = 0,
32 INFO_EXT = 0x00010000
33};
34
35/* bit is set in flags, when physical cpu info is included in diag 204 data */
36#define LPAR_PHYS_FLG 0x80
37
38static char *diag224_cpu_names; /* diag 224 name table */
39static enum diag204_sc diag204_store_sc; /* used subcode for store */
40static enum diag204_format diag204_info_type; /* used diag 204 data format */
41
42static void *diag204_buf; /* 4K aligned buffer for diag204 data */
43static void *diag204_buf_vmalloc; /* vmalloc pointer for diag204 data */
44static int diag204_buf_pages; /* number of pages for diag204 data */
45
46/*
47 * DIAG 204 data structures and member access functions.
48 *
49 * Since we have two different diag 204 data formats for old and new s390
50 * machines, we do not access the structs directly, but use getter functions for
51 * each struct member instead. This should make the code more readable.
52 */
53
54/* Time information block */
55
56struct info_blk_hdr {
57 __u8 npar;
58 __u8 flags;
59 __u16 tslice;
60 __u16 phys_cpus;
61 __u16 this_part;
62 __u64 curtod;
63} __attribute__ ((packed));
64
65struct x_info_blk_hdr {
66 __u8 npar;
67 __u8 flags;
68 __u16 tslice;
69 __u16 phys_cpus;
70 __u16 this_part;
71 __u64 curtod1;
72 __u64 curtod2;
73 char reserved[40];
74} __attribute__ ((packed));
75
76static inline int info_blk_hdr__size(enum diag204_format type)
77{
78 if (type == INFO_SIMPLE)
79 return sizeof(struct info_blk_hdr);
80 else /* INFO_EXT */
81 return sizeof(struct x_info_blk_hdr);
82}
83
84static inline __u8 info_blk_hdr__npar(enum diag204_format type, void *hdr)
85{
86 if (type == INFO_SIMPLE)
87 return ((struct info_blk_hdr *)hdr)->npar;
88 else /* INFO_EXT */
89 return ((struct x_info_blk_hdr *)hdr)->npar;
90}
91
92static inline __u8 info_blk_hdr__flags(enum diag204_format type, void *hdr)
93{
94 if (type == INFO_SIMPLE)
95 return ((struct info_blk_hdr *)hdr)->flags;
96 else /* INFO_EXT */
97 return ((struct x_info_blk_hdr *)hdr)->flags;
98}
99
100static inline __u16 info_blk_hdr__pcpus(enum diag204_format type, void *hdr)
101{
102 if (type == INFO_SIMPLE)
103 return ((struct info_blk_hdr *)hdr)->phys_cpus;
104 else /* INFO_EXT */
105 return ((struct x_info_blk_hdr *)hdr)->phys_cpus;
106}
107
108/* Partition header */
109
110struct part_hdr {
111 __u8 pn;
112 __u8 cpus;
113 char reserved[6];
114 char part_name[LPAR_NAME_LEN];
115} __attribute__ ((packed));
116
117struct x_part_hdr {
118 __u8 pn;
119 __u8 cpus;
120 __u8 rcpus;
121 __u8 pflag;
122 __u32 mlu;
123 char part_name[LPAR_NAME_LEN];
124 char lpc_name[8];
125 char os_name[8];
126 __u64 online_cs;
127 __u64 online_es;
128 __u8 upid;
129 char reserved1[3];
130 __u32 group_mlu;
131 char group_name[8];
132 char reserved2[32];
133} __attribute__ ((packed));
134
135static inline int part_hdr__size(enum diag204_format type)
136{
137 if (type == INFO_SIMPLE)
138 return sizeof(struct part_hdr);
139 else /* INFO_EXT */
140 return sizeof(struct x_part_hdr);
141}
142
143static inline __u8 part_hdr__rcpus(enum diag204_format type, void *hdr)
144{
145 if (type == INFO_SIMPLE)
146 return ((struct part_hdr *)hdr)->cpus;
147 else /* INFO_EXT */
148 return ((struct x_part_hdr *)hdr)->rcpus;
149}
150
151static inline void part_hdr__part_name(enum diag204_format type, void *hdr,
152 char *name)
153{
154 if (type == INFO_SIMPLE)
155 memcpy(name, ((struct part_hdr *)hdr)->part_name,
156 LPAR_NAME_LEN);
157 else /* INFO_EXT */
158 memcpy(name, ((struct x_part_hdr *)hdr)->part_name,
159 LPAR_NAME_LEN);
160 EBCASC(name, LPAR_NAME_LEN);
161 name[LPAR_NAME_LEN] = 0;
162 strstrip(name);
163}
164
165struct cpu_info {
166 __u16 cpu_addr;
167 char reserved1[2];
168 __u8 ctidx;
169 __u8 cflag;
170 __u16 weight;
171 __u64 acc_time;
172 __u64 lp_time;
173} __attribute__ ((packed));
174
175struct x_cpu_info {
176 __u16 cpu_addr;
177 char reserved1[2];
178 __u8 ctidx;
179 __u8 cflag;
180 __u16 weight;
181 __u64 acc_time;
182 __u64 lp_time;
183 __u16 min_weight;
184 __u16 cur_weight;
185 __u16 max_weight;
186 char reseved2[2];
187 __u64 online_time;
188 __u64 wait_time;
189 __u32 pma_weight;
190 __u32 polar_weight;
191 char reserved3[40];
192} __attribute__ ((packed));
193
194/* CPU info block */
195
196static inline int cpu_info__size(enum diag204_format type)
197{
198 if (type == INFO_SIMPLE)
199 return sizeof(struct cpu_info);
200 else /* INFO_EXT */
201 return sizeof(struct x_cpu_info);
202}
203
204static inline __u8 cpu_info__ctidx(enum diag204_format type, void *hdr)
205{
206 if (type == INFO_SIMPLE)
207 return ((struct cpu_info *)hdr)->ctidx;
208 else /* INFO_EXT */
209 return ((struct x_cpu_info *)hdr)->ctidx;
210}
211
212static inline __u16 cpu_info__cpu_addr(enum diag204_format type, void *hdr)
213{
214 if (type == INFO_SIMPLE)
215 return ((struct cpu_info *)hdr)->cpu_addr;
216 else /* INFO_EXT */
217 return ((struct x_cpu_info *)hdr)->cpu_addr;
218}
219
220static inline __u64 cpu_info__acc_time(enum diag204_format type, void *hdr)
221{
222 if (type == INFO_SIMPLE)
223 return ((struct cpu_info *)hdr)->acc_time;
224 else /* INFO_EXT */
225 return ((struct x_cpu_info *)hdr)->acc_time;
226}
227
228static inline __u64 cpu_info__lp_time(enum diag204_format type, void *hdr)
229{
230 if (type == INFO_SIMPLE)
231 return ((struct cpu_info *)hdr)->lp_time;
232 else /* INFO_EXT */
233 return ((struct x_cpu_info *)hdr)->lp_time;
234}
235
236static inline __u64 cpu_info__online_time(enum diag204_format type, void *hdr)
237{
238 if (type == INFO_SIMPLE)
239 return 0; /* online_time not available in simple info */
240 else /* INFO_EXT */
241 return ((struct x_cpu_info *)hdr)->online_time;
242}
243
244/* Physical header */
245
246struct phys_hdr {
247 char reserved1[1];
248 __u8 cpus;
249 char reserved2[6];
250 char mgm_name[8];
251} __attribute__ ((packed));
252
253struct x_phys_hdr {
254 char reserved1[1];
255 __u8 cpus;
256 char reserved2[6];
257 char mgm_name[8];
258 char reserved3[80];
259} __attribute__ ((packed));
260
261static inline int phys_hdr__size(enum diag204_format type)
262{
263 if (type == INFO_SIMPLE)
264 return sizeof(struct phys_hdr);
265 else /* INFO_EXT */
266 return sizeof(struct x_phys_hdr);
267}
268
269static inline __u8 phys_hdr__cpus(enum diag204_format type, void *hdr)
270{
271 if (type == INFO_SIMPLE)
272 return ((struct phys_hdr *)hdr)->cpus;
273 else /* INFO_EXT */
274 return ((struct x_phys_hdr *)hdr)->cpus;
275}
276
277/* Physical CPU info block */
278
279struct phys_cpu {
280 __u16 cpu_addr;
281 char reserved1[2];
282 __u8 ctidx;
283 char reserved2[3];
284 __u64 mgm_time;
285 char reserved3[8];
286} __attribute__ ((packed));
287
288struct x_phys_cpu {
289 __u16 cpu_addr;
290 char reserved1[2];
291 __u8 ctidx;
292 char reserved2[3];
293 __u64 mgm_time;
294 char reserved3[80];
295} __attribute__ ((packed));
296
297static inline int phys_cpu__size(enum diag204_format type)
298{
299 if (type == INFO_SIMPLE)
300 return sizeof(struct phys_cpu);
301 else /* INFO_EXT */
302 return sizeof(struct x_phys_cpu);
303}
304
305static inline __u16 phys_cpu__cpu_addr(enum diag204_format type, void *hdr)
306{
307 if (type == INFO_SIMPLE)
308 return ((struct phys_cpu *)hdr)->cpu_addr;
309 else /* INFO_EXT */
310 return ((struct x_phys_cpu *)hdr)->cpu_addr;
311}
312
313static inline __u64 phys_cpu__mgm_time(enum diag204_format type, void *hdr)
314{
315 if (type == INFO_SIMPLE)
316 return ((struct phys_cpu *)hdr)->mgm_time;
317 else /* INFO_EXT */
318 return ((struct x_phys_cpu *)hdr)->mgm_time;
319}
320
321static inline __u64 phys_cpu__ctidx(enum diag204_format type, void *hdr)
322{
323 if (type == INFO_SIMPLE)
324 return ((struct phys_cpu *)hdr)->ctidx;
325 else /* INFO_EXT */
326 return ((struct x_phys_cpu *)hdr)->ctidx;
327}
328
329/* Diagnose 204 functions */
330
331static int diag204(unsigned long subcode, unsigned long size, void *addr)
332{
333 register unsigned long _subcode asm("0") = subcode;
334 register unsigned long _size asm("1") = size;
335
94c12cc7
MS		 336 asm volatile(
337 " diag %2,%0,0x204\n"
338 "0:\n"
339 EX_TABLE(0b,0b)
340 : "+d" (_subcode), "+d" (_size) : "d" (addr) : "memory");
24bbb1fa
MH		 341 if (_subcode)
342 return -1;
94c12cc7 343 return _size;
24bbb1fa
MH		 344}
345
346/*
347 * For the old diag subcode 4 with simple data format we have to use real
348 * memory. If we use subcode 6 or 7 with extended data format, we can (and
349 * should) use vmalloc, since we need a lot of memory in that case. Currently
350 * up to 93 pages!
351 */
352
353static void diag204_free_buffer(void)
354{
355 if (!diag204_buf)
356 return;
357 if (diag204_buf_vmalloc) {
358 vfree(diag204_buf_vmalloc);
359 diag204_buf_vmalloc = NULL;
360 } else {
361 free_pages((unsigned long) diag204_buf, 0);
362 }
363 diag204_buf_pages = 0;
364 diag204_buf = NULL;
365}
366
367static void *diag204_alloc_vbuf(int pages)
368{
369 /* The buffer has to be page aligned! */
370 diag204_buf_vmalloc = vmalloc(PAGE_SIZE * (pages + 1));
371 if (!diag204_buf_vmalloc)
372 return ERR_PTR(-ENOMEM);
373 diag204_buf = (void*)((unsigned long)diag204_buf_vmalloc
374 & ~0xfffUL) + 0x1000;
375 diag204_buf_pages = pages;
376 return diag204_buf;
377}
378
379static void *diag204_alloc_rbuf(void)
380{
381 diag204_buf = (void*)__get_free_pages(GFP_KERNEL,0);
382 if (diag204_buf)
383 return ERR_PTR(-ENOMEM);
384 diag204_buf_pages = 1;
385 return diag204_buf;
386}
387
388static void *diag204_get_buffer(enum diag204_format fmt, int *pages)
389{
390 if (diag204_buf) {
391 *pages = diag204_buf_pages;
392 return diag204_buf;
393 }
394 if (fmt == INFO_SIMPLE) {
395 *pages = 1;
396 return diag204_alloc_rbuf();
397 } else {/* INFO_EXT */
23c100d9
MH		 398 *pages = diag204((unsigned long)SUBC_RSI |
399 (unsigned long)INFO_EXT, 0, NULL);
24bbb1fa
MH		 400 if (*pages <= 0)
401 return ERR_PTR(-ENOSYS);
402 else
403 return diag204_alloc_vbuf(*pages);
404 }
405}
406
407/*
408 * diag204_probe() has to find out, which type of diagnose 204 implementation
409 * we have on our machine. Currently there are three possible scanarios:
410 * - subcode 4 + simple data format (only one page)
411 * - subcode 4-6 + extended data format
412 * - subcode 4-7 + extended data format
413 *
414 * Subcode 5 is used to retrieve the size of the data, provided by subcodes
415 * 6 and 7. Subcode 7 basically has the same function as subcode 6. In addition
416 * to subcode 6 it provides also information about secondary cpus.
417 * In order to get as much information as possible, we first try
418 * subcode 7, then 6 and if both fail, we use subcode 4.
419 */
420
421static int diag204_probe(void)
422{
423 void *buf;
424 int pages, rc;
425
426 buf = diag204_get_buffer(INFO_EXT, &pages);
427 if (!IS_ERR(buf)) {
331c982d
MH		 428 if (diag204((unsigned long)SUBC_STIB7 |
429 (unsigned long)INFO_EXT, pages, buf) >= 0) {
24bbb1fa
MH		 430 diag204_store_sc = SUBC_STIB7;
431 diag204_info_type = INFO_EXT;
432 goto out;
433 }
331c982d
MH		 434 if (diag204((unsigned long)SUBC_STIB6 |
435 (unsigned long)INFO_EXT, pages, buf) >= 0) {
24bbb1fa
MH		 436 diag204_store_sc = SUBC_STIB7;
437 diag204_info_type = INFO_EXT;
438 goto out;
439 }
440 diag204_free_buffer();
441 }
442
443 /* subcodes 6 and 7 failed, now try subcode 4 */
444
445 buf = diag204_get_buffer(INFO_SIMPLE, &pages);
446 if (IS_ERR(buf)) {
447 rc = PTR_ERR(buf);
448 goto fail_alloc;
449 }
331c982d
MH		 450 if (diag204((unsigned long)SUBC_STIB4 |
451 (unsigned long)INFO_SIMPLE, pages, buf) >= 0) {
24bbb1fa
MH		 452 diag204_store_sc = SUBC_STIB4;
453 diag204_info_type = INFO_SIMPLE;
454 goto out;
455 } else {
456 rc = -ENOSYS;
457 goto fail_store;
458 }
459out:
460 rc = 0;
461fail_store:
462 diag204_free_buffer();
463fail_alloc:
464 return rc;
465}
466
467static void *diag204_store(void)
468{
469 void *buf;
470 int pages;
471
472 buf = diag204_get_buffer(diag204_info_type, &pages);
473 if (IS_ERR(buf))
474 goto out;
331c982d
MH		 475 if (diag204((unsigned long)diag204_store_sc |
476 (unsigned long)diag204_info_type, pages, buf) < 0)
24bbb1fa
MH		 477 return ERR_PTR(-ENOSYS);
478out:
479 return buf;
480}
481
482/* Diagnose 224 functions */
483
484static void diag224(void *ptr)
485{
94c12cc7 486 asm volatile("diag %0,%1,0x224" : :"d" (0), "d"(ptr) : "memory");
24bbb1fa
MH		 487}
488
489static int diag224_get_name_table(void)
490{
491 /* memory must be below 2GB */
492 diag224_cpu_names = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA);
493 if (!diag224_cpu_names)
494 return -ENOMEM;
495 diag224(diag224_cpu_names);
496 EBCASC(diag224_cpu_names + 16, (*diag224_cpu_names + 1) * 16);
497 return 0;
498}
499
500static void diag224_delete_name_table(void)
501{
502 kfree(diag224_cpu_names);
503}
504
505static int diag224_idx2name(int index, char *name)
506{
507 memcpy(name, diag224_cpu_names + ((index + 1) * CPU_NAME_LEN),
508 CPU_NAME_LEN);
509 name[CPU_NAME_LEN] = 0;
510 strstrip(name);
511 return 0;
512}
513
514__init int hypfs_diag_init(void)
515{
516 int rc;
517
518 if (diag204_probe()) {
519 printk(KERN_ERR "hypfs: diag 204 not working.");
520 return -ENODATA;
521 }
522 rc = diag224_get_name_table();
523 if (rc) {
524 diag224_delete_name_table();
525 printk(KERN_ERR "hypfs: could not get name table.\n");
526 }
527 return rc;
528}
529
1375fc1f 530void hypfs_diag_exit(void)
24bbb1fa
MH		 531{
532 diag224_delete_name_table();
533 diag204_free_buffer();
534}
535
536/*
537 * Functions to create the directory structure
538 * *******************************************
539 */
540
541static int hypfs_create_cpu_files(struct super_block *sb,
542 struct dentry *cpus_dir, void *cpu_info)
543{
544 struct dentry *cpu_dir;
545 char buffer[TMP_SIZE];
546 void *rc;
547
548 snprintf(buffer, TMP_SIZE, "%d", cpu_info__cpu_addr(diag204_info_type,
549 cpu_info));
550 cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);
551 rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",
552 cpu_info__acc_time(diag204_info_type, cpu_info) -
553 cpu_info__lp_time(diag204_info_type, cpu_info));
554 if (IS_ERR(rc))
555 return PTR_ERR(rc);
556 rc = hypfs_create_u64(sb, cpu_dir, "cputime",
557 cpu_info__lp_time(diag204_info_type, cpu_info));
558 if (IS_ERR(rc))
559 return PTR_ERR(rc);
560 if (diag204_info_type == INFO_EXT) {
561 rc = hypfs_create_u64(sb, cpu_dir, "onlinetime",
562 cpu_info__online_time(diag204_info_type,
563 cpu_info));
564 if (IS_ERR(rc))
565 return PTR_ERR(rc);
566 }
567 diag224_idx2name(cpu_info__ctidx(diag204_info_type, cpu_info), buffer);
568 rc = hypfs_create_str(sb, cpu_dir, "type", buffer);
569 if (IS_ERR(rc))
570 return PTR_ERR(rc);
571 return 0;
572}
573
574static void *hypfs_create_lpar_files(struct super_block *sb,
575 struct dentry *systems_dir, void *part_hdr)
576{
577 struct dentry *cpus_dir;
578 struct dentry *lpar_dir;
579 char lpar_name[LPAR_NAME_LEN + 1];
580 void *cpu_info;
581 int i;
582
583 part_hdr__part_name(diag204_info_type, part_hdr, lpar_name);
584 lpar_name[LPAR_NAME_LEN] = 0;
585 lpar_dir = hypfs_mkdir(sb, systems_dir, lpar_name);
586 if (IS_ERR(lpar_dir))
587 return lpar_dir;
588 cpus_dir = hypfs_mkdir(sb, lpar_dir, "cpus");
589 if (IS_ERR(cpus_dir))
590 return cpus_dir;
591 cpu_info = part_hdr + part_hdr__size(diag204_info_type);
592 for (i = 0; i < part_hdr__rcpus(diag204_info_type, part_hdr); i++) {
593 int rc;
594 rc = hypfs_create_cpu_files(sb, cpus_dir, cpu_info);
595 if (rc)
596 return ERR_PTR(rc);
597 cpu_info += cpu_info__size(diag204_info_type);
598 }
599 return cpu_info;
600}
601
602static int hypfs_create_phys_cpu_files(struct super_block *sb,
603 struct dentry *cpus_dir, void *cpu_info)
604{
605 struct dentry *cpu_dir;
606 char buffer[TMP_SIZE];
607 void *rc;
608
609 snprintf(buffer, TMP_SIZE, "%i", phys_cpu__cpu_addr(diag204_info_type,
610 cpu_info));
611 cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);
612 if (IS_ERR(cpu_dir))
613 return PTR_ERR(cpu_dir);
614 rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",
615 phys_cpu__mgm_time(diag204_info_type, cpu_info));
616 if (IS_ERR(rc))
617 return PTR_ERR(rc);
618 diag224_idx2name(phys_cpu__ctidx(diag204_info_type, cpu_info), buffer);
619 rc = hypfs_create_str(sb, cpu_dir, "type", buffer);
620 if (IS_ERR(rc))
621 return PTR_ERR(rc);
622 return 0;
623}
624
625static void *hypfs_create_phys_files(struct super_block *sb,
626 struct dentry *parent_dir, void *phys_hdr)
627{
628 int i;
629 void *cpu_info;
630 struct dentry *cpus_dir;
631
632 cpus_dir = hypfs_mkdir(sb, parent_dir, "cpus");
633 if (IS_ERR(cpus_dir))
634 return cpus_dir;
635 cpu_info = phys_hdr + phys_hdr__size(diag204_info_type);
636 for (i = 0; i < phys_hdr__cpus(diag204_info_type, phys_hdr); i++) {
637 int rc;
638 rc = hypfs_create_phys_cpu_files(sb, cpus_dir, cpu_info);
639 if (rc)
640 return ERR_PTR(rc);
641 cpu_info += phys_cpu__size(diag204_info_type);
642 }
643 return cpu_info;
644}
645
646int hypfs_diag_create_files(struct super_block *sb, struct dentry *root)
647{
648 struct dentry *systems_dir, *hyp_dir;
649 void *time_hdr, *part_hdr;
650 int i, rc;
651 void *buffer, *ptr;
652
653 buffer = diag204_store();
654 if (IS_ERR(buffer))
655 return PTR_ERR(buffer);
656
657 systems_dir = hypfs_mkdir(sb, root, "systems");
658 if (IS_ERR(systems_dir)) {
659 rc = PTR_ERR(systems_dir);
660 goto err_out;
661 }
662 time_hdr = (struct x_info_blk_hdr *)buffer;
663 part_hdr = time_hdr + info_blk_hdr__size(diag204_info_type);
664 for (i = 0; i < info_blk_hdr__npar(diag204_info_type, time_hdr); i++) {
665 part_hdr = hypfs_create_lpar_files(sb, systems_dir, part_hdr);
666 if (IS_ERR(part_hdr)) {
667 rc = PTR_ERR(part_hdr);
668 goto err_out;
669 }
670 }
671 if (info_blk_hdr__flags(diag204_info_type, time_hdr) & LPAR_PHYS_FLG) {
672 ptr = hypfs_create_phys_files(sb, root, part_hdr);
673 if (IS_ERR(ptr)) {
674 rc = PTR_ERR(ptr);
675 goto err_out;
676 }
677 }
678 hyp_dir = hypfs_mkdir(sb, root, "hyp");
679 if (IS_ERR(hyp_dir)) {
680 rc = PTR_ERR(hyp_dir);
681 goto err_out;
682 }
683 ptr = hypfs_create_str(sb, hyp_dir, "type", "LPAR Hypervisor");
684 if (IS_ERR(ptr)) {
685 rc = PTR_ERR(ptr);
686 goto err_out;
687 }
688 rc = 0;
689
690err_out:
691 return rc;
692}
Linux kernel - Deliverables
This page took 0.079188 seconds and 5 git commands to generate.