~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/thermal/tmon/sysfs.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * sysfs.c sysfs ABI access functions for TMON program
  3  *
  4  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  5  *
  6  * This program is free software; you can redistribute it and/or
  7  * modify it under the terms of the GNU General Public License version
  8  * 2 or later as published by the Free Software Foundation.
  9  *
 10  * This program is distributed in the hope that it will be useful,
 11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13  * GNU General Public License for more details.
 14  *
 15  * Author: Jacob Pan <jacob.jun.pan@linux.intel.com>
 16  *
 17  */
 18 #include <unistd.h>
 19 #include <stdio.h>
 20 #include <stdlib.h>
 21 #include <string.h>
 22 #include <stdint.h>
 23 #include <dirent.h>
 24 #include <libintl.h>
 25 #include <ctype.h>
 26 #include <time.h>
 27 #include <syslog.h>
 28 #include <sys/time.h>
 29 #include <errno.h>
 30 
 31 #include "tmon.h"
 32 
 33 struct tmon_platform_data ptdata;
 34 const char *trip_type_name[] = {
 35         "critical",
 36         "hot",
 37         "passive",
 38         "active",
 39 };
 40 
 41 int sysfs_set_ulong(char *path, char *filename, unsigned long val)
 42 {
 43         FILE *fd;
 44         int ret = -1;
 45         char filepath[256];
 46 
 47         snprintf(filepath, 256, "%s/%s", path, filename);
 48 
 49         fd = fopen(filepath, "w");
 50         if (!fd) {
 51                 syslog(LOG_ERR, "Err: open %s: %s\n", __func__, filepath);
 52                 return ret;
 53         }
 54         ret = fprintf(fd, "%lu", val);
 55         fclose(fd);
 56 
 57         return 0;
 58 }
 59 
 60 /* history of thermal data, used for control algo */
 61 #define NR_THERMAL_RECORDS 3
 62 struct thermal_data_record trec[NR_THERMAL_RECORDS];
 63 int cur_thermal_record; /* index to the trec array */
 64 
 65 static int sysfs_get_ulong(char *path, char *filename, unsigned long *p_ulong)
 66 {
 67         FILE *fd;
 68         int ret = -1;
 69         char filepath[256];
 70 
 71         snprintf(filepath, 256, "%s/%s", path, filename);
 72 
 73         fd = fopen(filepath, "r");
 74         if (!fd) {
 75                 syslog(LOG_ERR, "Err: open %s: %s\n", __func__, filepath);
 76                 return ret;
 77         }
 78         ret = fscanf(fd, "%lu", p_ulong);
 79         fclose(fd);
 80 
 81         return 0;
 82 }
 83 
 84 static int sysfs_get_string(char *path, char *filename, char *str)
 85 {
 86         FILE *fd;
 87         int ret = -1;
 88         char filepath[256];
 89 
 90         snprintf(filepath, 256, "%s/%s", path, filename);
 91 
 92         fd = fopen(filepath, "r");
 93         if (!fd) {
 94                 syslog(LOG_ERR, "Err: open %s: %s\n", __func__, filepath);
 95                 return ret;
 96         }
 97         ret = fscanf(fd, "%256s", str);
 98         fclose(fd);
 99 
100         return ret;
101 }
102 
103 /* get states of the cooling device instance */
104 static int probe_cdev(struct cdev_info *cdi, char *path)
105 {
106         sysfs_get_string(path, "type", cdi->type);
107         sysfs_get_ulong(path, "max_state",  &cdi->max_state);
108         sysfs_get_ulong(path, "cur_state", &cdi->cur_state);
109 
110         syslog(LOG_INFO, "%s: %s: type %s, max %lu, curr %lu inst %d\n",
111                 __func__, path,
112                 cdi->type, cdi->max_state, cdi->cur_state, cdi->instance);
113 
114         return 0;
115 }
116 
117 static int str_to_trip_type(char *name)
118 {
119         int i;
120 
121         for (i = 0; i < NR_THERMAL_TRIP_TYPE; i++) {
122                 if (!strcmp(name, trip_type_name[i]))
123                         return i;
124         }
125 
126         return -ENOENT;
127 }
128 
129 /* scan and fill in trip point info for a thermal zone and trip point id */
130 static int get_trip_point_data(char *tz_path, int tzid, int tpid)
131 {
132         char filename[256];
133         char temp_str[256];
134         int trip_type;
135 
136         if (tpid >= MAX_NR_TRIP)
137                 return -EINVAL;
138         /* check trip point type */
139         snprintf(filename, sizeof(filename), "trip_point_%d_type", tpid);
140         sysfs_get_string(tz_path, filename, temp_str);
141         trip_type = str_to_trip_type(temp_str);
142         if (trip_type < 0) {
143                 syslog(LOG_ERR, "%s:%s no matching type\n", __func__, temp_str);
144                 return -ENOENT;
145         }
146         ptdata.tzi[tzid].tp[tpid].type = trip_type;
147         syslog(LOG_INFO, "%s:tz:%d tp:%d:type:%s type id %d\n", __func__, tzid,
148                 tpid, temp_str, trip_type);
149 
150         /* TODO: check attribute */
151 
152         return 0;
153 }
154 
155 /* return instance id for file format such as trip_point_4_temp */
156 static int get_instance_id(char *name, int pos, int skip)
157 {
158         char *ch;
159         int i = 0;
160 
161         ch = strtok(name, "_");
162         while (ch != NULL) {
163                 ++i;
164                 syslog(LOG_INFO, "%s:%s:%s:%d", __func__, name, ch, i);
165                 ch = strtok(NULL, "_");
166                 if (pos == i)
167                         return atol(ch + skip);
168         }
169 
170         return -1;
171 }
172 
173 /* Find trip point info of a thermal zone */
174 static int find_tzone_tp(char *tz_name, char *d_name, struct tz_info *tzi,
175                         int tz_id)
176 {
177         int tp_id;
178         unsigned long temp_ulong;
179 
180         if (strstr(d_name, "trip_point") &&
181                 strstr(d_name, "temp")) {
182                 /* check if trip point temp is non-zero
183                  * ignore 0/invalid trip points
184                  */
185                 sysfs_get_ulong(tz_name, d_name, &temp_ulong);
186                 if (temp_ulong < MAX_TEMP_KC) {
187                         tzi->nr_trip_pts++;
188                         /* found a valid trip point */
189                         tp_id = get_instance_id(d_name, 2, 0);
190                         syslog(LOG_DEBUG, "tzone %s trip %d temp %lu tpnode %s",
191                                 tz_name, tp_id, temp_ulong, d_name);
192                         if (tp_id < 0 || tp_id >= MAX_NR_TRIP) {
193                                 syslog(LOG_ERR, "Failed to find TP inst %s\n",
194                                         d_name);
195                                 return -1;
196                         }
197                         get_trip_point_data(tz_name, tz_id, tp_id);
198                         tzi->tp[tp_id].temp = temp_ulong;
199                 }
200         }
201 
202         return 0;
203 }
204 
205 /* check cooling devices for binding info. */
206 static int find_tzone_cdev(struct dirent *nl, char *tz_name,
207                         struct tz_info *tzi, int tz_id, int cid)
208 {
209         unsigned long trip_instance = 0;
210         char cdev_name_linked[256];
211         char cdev_name[256];
212         char cdev_trip_name[256];
213         int cdev_id;
214 
215         if (nl->d_type == DT_LNK) {
216                 syslog(LOG_DEBUG, "TZ%d: cdev: %s cid %d\n", tz_id, nl->d_name,
217                         cid);
218                 tzi->nr_cdev++;
219                 if (tzi->nr_cdev > ptdata.nr_cooling_dev) {
220                         syslog(LOG_ERR, "Err: Too many cdev? %d\n",
221                                 tzi->nr_cdev);
222                         return -EINVAL;
223                 }
224                 /* find the link to real cooling device record binding */
225                 snprintf(cdev_name, 256, "%s/%s", tz_name, nl->d_name);
226                 memset(cdev_name_linked, 0, sizeof(cdev_name_linked));
227                 if (readlink(cdev_name, cdev_name_linked,
228                                 sizeof(cdev_name_linked) - 1) != -1) {
229                         cdev_id = get_instance_id(cdev_name_linked, 1,
230                                                 sizeof("device") - 1);
231                         syslog(LOG_DEBUG, "cdev %s linked to %s : %d\n",
232                                 cdev_name, cdev_name_linked, cdev_id);
233                         tzi->cdev_binding |= (1 << cdev_id);
234 
235                         /* find the trip point in which the cdev is binded to
236                          * in this tzone
237                          */
238                         snprintf(cdev_trip_name, 256, "%s%s", nl->d_name,
239                                 "_trip_point");
240                         sysfs_get_ulong(tz_name, cdev_trip_name,
241                                         &trip_instance);
242                         /* validate trip point range, e.g. trip could return -1
243                          * when passive is enabled
244                          */
245                         if (trip_instance > MAX_NR_TRIP)
246                                 trip_instance = 0;
247                         tzi->trip_binding[cdev_id] |= 1 << trip_instance;
248                         syslog(LOG_DEBUG, "cdev %s -> trip:%lu: 0x%lx %d\n",
249                                 cdev_name, trip_instance,
250                                 tzi->trip_binding[cdev_id],
251                                 cdev_id);
252 
253 
254                 }
255                 return 0;
256         }
257 
258         return -ENODEV;
259 }
260 
261 
262 
263 /*****************************************************************************
264  * Before calling scan_tzones, thermal sysfs must be probed to determine
265  * the number of thermal zones and cooling devices.
266  * We loop through each thermal zone and fill in tz_info struct, i.e.
267  * ptdata.tzi[]
268 root@jacob-chiefriver:~# tree -d /sys/class/thermal/thermal_zone0
269 /sys/class/thermal/thermal_zone0
270 |-- cdev0 -> ../cooling_device4
271 |-- cdev1 -> ../cooling_device3
272 |-- cdev10 -> ../cooling_device7
273 |-- cdev11 -> ../cooling_device6
274 |-- cdev12 -> ../cooling_device5
275 |-- cdev2 -> ../cooling_device2
276 |-- cdev3 -> ../cooling_device1
277 |-- cdev4 -> ../cooling_device0
278 |-- cdev5 -> ../cooling_device12
279 |-- cdev6 -> ../cooling_device11
280 |-- cdev7 -> ../cooling_device10
281 |-- cdev8 -> ../cooling_device9
282 |-- cdev9 -> ../cooling_device8
283 |-- device -> ../../../LNXSYSTM:00/device:62/LNXTHERM:00
284 |-- power
285 `-- subsystem -> ../../../../class/thermal
286 *****************************************************************************/
287 static int scan_tzones(void)
288 {
289         DIR *dir;
290         struct dirent **namelist;
291         char tz_name[256];
292         int i, j, n, k = 0;
293 
294         if (!ptdata.nr_tz_sensor)
295                 return -1;
296 
297         for (i = 0; i <= ptdata.max_tz_instance; i++) {
298                 memset(tz_name, 0, sizeof(tz_name));
299                 snprintf(tz_name, 256, "%s/%s%d", THERMAL_SYSFS, TZONE, i);
300 
301                 dir = opendir(tz_name);
302                 if (!dir) {
303                         syslog(LOG_INFO, "Thermal zone %s skipped\n", tz_name);
304                         continue;
305                 }
306                 /* keep track of valid tzones */
307                 n = scandir(tz_name, &namelist, 0, alphasort);
308                 if (n < 0)
309                         syslog(LOG_ERR, "scandir failed in %s",  tz_name);
310                 else {
311                         sysfs_get_string(tz_name, "type", ptdata.tzi[k].type);
312                         ptdata.tzi[k].instance = i;
313                         /* detect trip points and cdev attached to this tzone */
314                         j = 0; /* index for cdev */
315                         ptdata.tzi[k].nr_cdev = 0;
316                         ptdata.tzi[k].nr_trip_pts = 0;
317                         while (n--) {
318                                 char *temp_str;
319 
320                                 if (find_tzone_tp(tz_name, namelist[n]->d_name,
321                                                         &ptdata.tzi[k], k))
322                                         break;
323                                 temp_str = strstr(namelist[n]->d_name, "cdev");
324                                 if (!temp_str) {
325                                         free(namelist[n]);
326                                         continue;
327                                 }
328                                 if (!find_tzone_cdev(namelist[n], tz_name,
329                                                         &ptdata.tzi[k], i, j))
330                                         j++; /* increment cdev index */
331                                 free(namelist[n]);
332                         }
333                         free(namelist);
334                 }
335                 /*TODO: reverse trip points */
336                 closedir(dir);
337                 syslog(LOG_INFO, "TZ %d has %d cdev\n", i,
338                         ptdata.tzi[k].nr_cdev);
339                 k++;
340         }
341 
342         return 0;
343 }
344 
345 static int scan_cdevs(void)
346 {
347         DIR *dir;
348         struct dirent **namelist;
349         char cdev_name[256];
350         int i, n, k = 0;
351 
352         if (!ptdata.nr_cooling_dev) {
353                 fprintf(stderr, "No cooling devices found\n");
354                 return 0;
355         }
356         for (i = 0; i <= ptdata.max_cdev_instance; i++) {
357                 memset(cdev_name, 0, sizeof(cdev_name));
358                 snprintf(cdev_name, 256, "%s/%s%d", THERMAL_SYSFS, CDEV, i);
359 
360                 dir = opendir(cdev_name);
361                 if (!dir) {
362                         syslog(LOG_INFO, "Cooling dev %s skipped\n", cdev_name);
363                         /* there is a gap in cooling device id, check again
364                          * for the same index.
365                          */
366                         continue;
367                 }
368 
369                 n = scandir(cdev_name, &namelist, 0, alphasort);
370                 if (n < 0)
371                         syslog(LOG_ERR, "scandir failed in %s",  cdev_name);
372                 else {
373                         sysfs_get_string(cdev_name, "type", ptdata.cdi[k].type);
374                         ptdata.cdi[k].instance = i;
375                         if (strstr(ptdata.cdi[k].type, ctrl_cdev)) {
376                                 ptdata.cdi[k].flag |= CDEV_FLAG_IN_CONTROL;
377                                 syslog(LOG_DEBUG, "control cdev id %d\n", i);
378                         }
379                         while (n--)
380                                 free(namelist[n]);
381                         free(namelist);
382                 }
383                 closedir(dir);
384                 k++;
385         }
386         return 0;
387 }
388 
389 
390 int probe_thermal_sysfs(void)
391 {
392         DIR *dir;
393         struct dirent **namelist;
394         int n;
395 
396         dir = opendir(THERMAL_SYSFS);
397         if (!dir) {
398                 fprintf(stderr, "\nNo thermal sysfs, exit\n");
399                 return -1;
400         }
401         n = scandir(THERMAL_SYSFS, &namelist, 0, alphasort);
402         if (n < 0)
403                 syslog(LOG_ERR, "scandir failed in thermal sysfs");
404         else {
405                 /* detect number of thermal zones and cooling devices */
406                 while (n--) {
407                         int inst;
408 
409                         if (strstr(namelist[n]->d_name, CDEV)) {
410                                 inst = get_instance_id(namelist[n]->d_name, 1,
411                                                 sizeof("device") - 1);
412                                 /* keep track of the max cooling device since
413                                  * there may be gaps.
414                                  */
415                                 if (inst > ptdata.max_cdev_instance)
416                                         ptdata.max_cdev_instance = inst;
417 
418                                 syslog(LOG_DEBUG, "found cdev: %s %d %d\n",
419                                         namelist[n]->d_name,
420                                         ptdata.nr_cooling_dev,
421                                         ptdata.max_cdev_instance);
422                                 ptdata.nr_cooling_dev++;
423                         } else if (strstr(namelist[n]->d_name, TZONE)) {
424                                 inst = get_instance_id(namelist[n]->d_name, 1,
425                                                 sizeof("zone") - 1);
426                                 if (inst > ptdata.max_tz_instance)
427                                         ptdata.max_tz_instance = inst;
428 
429                                 syslog(LOG_DEBUG, "found tzone: %s %d %d\n",
430                                         namelist[n]->d_name,
431                                         ptdata.nr_tz_sensor,
432                                         ptdata.max_tz_instance);
433                                 ptdata.nr_tz_sensor++;
434                         }
435                         free(namelist[n]);
436                 }
437                 free(namelist);
438         }
439         syslog(LOG_INFO, "found %d tzone(s), %d cdev(s), target zone %d\n",
440                 ptdata.nr_tz_sensor, ptdata.nr_cooling_dev,
441                 target_thermal_zone);
442         closedir(dir);
443 
444         if (!ptdata.nr_tz_sensor) {
445                 fprintf(stderr, "\nNo thermal zones found, exit\n\n");
446                 return -1;
447         }
448 
449         ptdata.tzi = calloc(ptdata.max_tz_instance+1, sizeof(struct tz_info));
450         if (!ptdata.tzi) {
451                 fprintf(stderr, "Err: allocate tz_info\n");
452                 return -1;
453         }
454 
455         /* we still show thermal zone information if there is no cdev */
456         if (ptdata.nr_cooling_dev) {
457                 ptdata.cdi = calloc(ptdata.max_cdev_instance + 1,
458                                 sizeof(struct cdev_info));
459                 if (!ptdata.cdi) {
460                         free(ptdata.tzi);
461                         fprintf(stderr, "Err: allocate cdev_info\n");
462                         return -1;
463                 }
464         }
465 
466         /* now probe tzones */
467         if (scan_tzones())
468                 return -1;
469         if (scan_cdevs())
470                 return -1;
471         return 0;
472 }
473 
474 /* convert sysfs zone instance to zone array index */
475 int zone_instance_to_index(int zone_inst)
476 {
477         int i;
478 
479         for (i = 0; i < ptdata.nr_tz_sensor; i++)
480                 if (ptdata.tzi[i].instance == zone_inst)
481                         return i;
482         return -ENOENT;
483 }
484 
485 /* read temperature of all thermal zones */
486 int update_thermal_data()
487 {
488         int i;
489         int next_thermal_record = cur_thermal_record + 1;
490         char tz_name[256];
491         static unsigned long samples;
492 
493         if (!ptdata.nr_tz_sensor) {
494                 syslog(LOG_ERR, "No thermal zones found!\n");
495                 return -1;
496         }
497 
498         /* circular buffer for keeping historic data */
499         if (next_thermal_record >= NR_THERMAL_RECORDS)
500                 next_thermal_record = 0;
501         gettimeofday(&trec[next_thermal_record].tv, NULL);
502         if (tmon_log) {
503                 fprintf(tmon_log, "%lu ", ++samples);
504                 fprintf(tmon_log, "%3.1f ", p_param.t_target);
505         }
506         for (i = 0; i < ptdata.nr_tz_sensor; i++) {
507                 memset(tz_name, 0, sizeof(tz_name));
508                 snprintf(tz_name, 256, "%s/%s%d", THERMAL_SYSFS, TZONE,
509                         ptdata.tzi[i].instance);
510                 sysfs_get_ulong(tz_name, "temp",
511                                 &trec[next_thermal_record].temp[i]);
512                 if (tmon_log)
513                         fprintf(tmon_log, "%lu ",
514                                 trec[next_thermal_record].temp[i] / 1000);
515         }
516         cur_thermal_record = next_thermal_record;
517         for (i = 0; i < ptdata.nr_cooling_dev; i++) {
518                 char cdev_name[256];
519                 unsigned long val;
520 
521                 snprintf(cdev_name, 256, "%s/%s%d", THERMAL_SYSFS, CDEV,
522                         ptdata.cdi[i].instance);
523                 probe_cdev(&ptdata.cdi[i], cdev_name);
524                 val = ptdata.cdi[i].cur_state;
525                 if (val > 1000000)
526                         val = 0;
527                 if (tmon_log)
528                         fprintf(tmon_log, "%lu ", val);
529         }
530 
531         if (tmon_log) {
532                 fprintf(tmon_log, "\n");
533                 fflush(tmon_log);
534         }
535 
536         return 0;
537 }
538 
539 void set_ctrl_state(unsigned long state)
540 {
541         char ctrl_cdev_path[256];
542         int i;
543         unsigned long cdev_state;
544 
545         if (no_control)
546                 return;
547         /* set all ctrl cdev to the same state */
548         for (i = 0; i < ptdata.nr_cooling_dev; i++) {
549                 if (ptdata.cdi[i].flag & CDEV_FLAG_IN_CONTROL) {
550                         if (ptdata.cdi[i].max_state < 10) {
551                                 strcpy(ctrl_cdev, "None.");
552                                 return;
553                         }
554                         /* scale to percentage of max_state */
555                         cdev_state = state * ptdata.cdi[i].max_state/100;
556                         syslog(LOG_DEBUG,
557                                 "ctrl cdev %d set state %lu scaled to %lu\n",
558                                 ptdata.cdi[i].instance, state, cdev_state);
559                         snprintf(ctrl_cdev_path, 256, "%s/%s%d", THERMAL_SYSFS,
560                                 CDEV, ptdata.cdi[i].instance);
561                         syslog(LOG_DEBUG, "ctrl cdev path %s", ctrl_cdev_path);
562                         sysfs_set_ulong(ctrl_cdev_path, "cur_state",
563                                         cdev_state);
564                 }
565         }
566 }
567 
568 void get_ctrl_state(unsigned long *state)
569 {
570         char ctrl_cdev_path[256];
571         int ctrl_cdev_id = -1;
572         int i;
573 
574         /* TODO: take average of all ctrl types. also consider change based on
575          * uevent. Take the first reading for now.
576          */
577         for (i = 0; i < ptdata.nr_cooling_dev; i++) {
578                 if (ptdata.cdi[i].flag & CDEV_FLAG_IN_CONTROL) {
579                         ctrl_cdev_id = ptdata.cdi[i].instance;
580                         syslog(LOG_INFO, "ctrl cdev %d get state\n",
581                                 ptdata.cdi[i].instance);
582                         break;
583                 }
584         }
585         if (ctrl_cdev_id == -1) {
586                 *state = 0;
587                 return;
588         }
589         snprintf(ctrl_cdev_path, 256, "%s/%s%d", THERMAL_SYSFS,
590                 CDEV, ctrl_cdev_id);
591         sysfs_get_ulong(ctrl_cdev_path, "cur_state", state);
592 }
593 
594 void free_thermal_data(void)
595 {
596         free(ptdata.tzi);
597         free(ptdata.cdi);
598 }
599 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp