Annotation of qemu/qerror.c, revision 1.1.1.5

1.1       root        1: /*
1.1.1.2   root        2:  * QError Module
1.1       root        3:  *
                      4:  * Copyright (C) 2009 Red Hat Inc.
                      5:  *
                      6:  * Authors:
                      7:  *  Luiz Capitulino <lcapitulino@redhat.com>
                      8:  *
                      9:  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
                     10:  * See the COPYING.LIB file in the top-level directory.
                     11:  */
1.1.1.2   root       12: 
                     13: #include "monitor.h"
1.1       root       14: #include "qjson.h"
                     15: #include "qerror.h"
                     16: #include "qemu-common.h"
                     17: 
                     18: static void qerror_destroy_obj(QObject *obj);
                     19: 
                     20: static const QType qerror_type = {
                     21:     .code = QTYPE_QERROR,
                     22:     .destroy = qerror_destroy_obj,
                     23: };
                     24: 
                     25: /**
                     26:  * The 'desc' parameter is a printf-like string, the format of the format
                     27:  * string is:
                     28:  *
                     29:  * %(KEY)
                     30:  *
                     31:  * Where KEY is a QDict key, which has to be passed to qerror_from_info().
                     32:  *
                     33:  * Example:
                     34:  *
                     35:  * "foo error on device: %(device) slot: %(slot_nr)"
                     36:  *
                     37:  * A single percent sign can be printed if followed by a second one,
                     38:  * for example:
                     39:  *
                     40:  * "running out of foo: %(foo)%%"
1.1.1.2   root       41:  *
                     42:  * Please keep the entries in alphabetical order.
                     43:  * Use "sed -n '/^static.*qerror_table\[\]/,/^};/s/QERR_/&/gp' qerror.c | sort -c"
                     44:  * to check.
1.1       root       45:  */
                     46: static const QErrorStringTable qerror_table[] = {
                     47:     {
1.1.1.2   root       48:         .error_fmt = QERR_BAD_BUS_FOR_DEVICE,
                     49:         .desc      = "Device '%(device)' can't go on a %(bad_bus_type) bus",
                     50:     },
                     51:     {
1.1.1.5 ! root       52:         .error_fmt = QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
        !            53:         .desc      = "Block format '%(format)' used by device '%(name)' does not support feature '%(feature)'",
        !            54:     },
        !            55:     {
1.1.1.2   root       56:         .error_fmt = QERR_BUS_NOT_FOUND,
                     57:         .desc      = "Bus '%(bus)' not found",
                     58:     },
                     59:     {
                     60:         .error_fmt = QERR_BUS_NO_HOTPLUG,
                     61:         .desc      = "Bus '%(bus)' does not support hotplugging",
                     62:     },
                     63:     {
1.1       root       64:         .error_fmt = QERR_COMMAND_NOT_FOUND,
                     65:         .desc      = "The command %(name) has not been found",
                     66:     },
                     67:     {
                     68:         .error_fmt = QERR_DEVICE_ENCRYPTED,
1.1.1.2   root       69:         .desc      = "Device '%(device)' is encrypted",
                     70:     },
                     71:     {
                     72:         .error_fmt = QERR_DEVICE_INIT_FAILED,
                     73:         .desc      = "Device '%(device)' could not be initialized",
                     74:     },
                     75:     {
                     76:         .error_fmt = QERR_DEVICE_IN_USE,
                     77:         .desc      = "Device '%(device)' is in use",
1.1       root       78:     },
                     79:     {
1.1.1.5 ! root       80:         .error_fmt = QERR_DEVICE_FEATURE_BLOCKS_MIGRATION,
        !            81:         .desc      = "Migration is disabled when using feature '%(feature)' in device '%(device)'",
        !            82:     },
        !            83:     {
1.1       root       84:         .error_fmt = QERR_DEVICE_LOCKED,
1.1.1.2   root       85:         .desc      = "Device '%(device)' is locked",
                     86:     },
                     87:     {
                     88:         .error_fmt = QERR_DEVICE_MULTIPLE_BUSSES,
                     89:         .desc      = "Device '%(device)' has multiple child busses",
1.1       root       90:     },
                     91:     {
                     92:         .error_fmt = QERR_DEVICE_NOT_ACTIVE,
1.1.1.2   root       93:         .desc      = "Device '%(device)' has not been activated",
                     94:     },
                     95:     {
                     96:         .error_fmt = QERR_DEVICE_NOT_ENCRYPTED,
                     97:         .desc      = "Device '%(device)' is not encrypted",
1.1       root       98:     },
                     99:     {
                    100:         .error_fmt = QERR_DEVICE_NOT_FOUND,
1.1.1.2   root      101:         .desc      = "Device '%(device)' not found",
1.1       root      102:     },
                    103:     {
                    104:         .error_fmt = QERR_DEVICE_NOT_REMOVABLE,
1.1.1.2   root      105:         .desc      = "Device '%(device)' is not removable",
                    106:     },
                    107:     {
                    108:         .error_fmt = QERR_DEVICE_NO_BUS,
                    109:         .desc      = "Device '%(device)' has no child bus",
                    110:     },
                    111:     {
1.1.1.3   root      112:         .error_fmt = QERR_DEVICE_NO_HOTPLUG,
                    113:         .desc      = "Device '%(device)' does not support hotplugging",
                    114:     },
                    115:     {
1.1.1.2   root      116:         .error_fmt = QERR_DUPLICATE_ID,
                    117:         .desc      = "Duplicate ID '%(id)' for %(object)",
1.1       root      118:     },
                    119:     {
                    120:         .error_fmt = QERR_FD_NOT_FOUND,
1.1.1.2   root      121:         .desc      = "File descriptor named '%(name)' not found",
1.1       root      122:     },
                    123:     {
                    124:         .error_fmt = QERR_FD_NOT_SUPPLIED,
                    125:         .desc      = "No file descriptor supplied via SCM_RIGHTS",
                    126:     },
                    127:     {
1.1.1.5 ! root      128:         .error_fmt = QERR_FEATURE_DISABLED,
        !           129:         .desc      = "The feature '%(name)' is not enabled",
        !           130:     },
        !           131:     {
1.1       root      132:         .error_fmt = QERR_INVALID_BLOCK_FORMAT,
1.1.1.2   root      133:         .desc      = "Invalid block format '%(name)'",
1.1       root      134:     },
                    135:     {
                    136:         .error_fmt = QERR_INVALID_PARAMETER,
1.1.1.2   root      137:         .desc      = "Invalid parameter '%(name)'",
1.1       root      138:     },
                    139:     {
                    140:         .error_fmt = QERR_INVALID_PARAMETER_TYPE,
                    141:         .desc      = "Invalid parameter type, expected: %(expected)",
                    142:     },
                    143:     {
1.1.1.2   root      144:         .error_fmt = QERR_INVALID_PARAMETER_VALUE,
                    145:         .desc      = "Parameter '%(name)' expects %(expected)",
                    146:     },
                    147:     {
1.1       root      148:         .error_fmt = QERR_INVALID_PASSWORD,
1.1.1.2   root      149:         .desc      = "Password incorrect",
1.1       root      150:     },
                    151:     {
                    152:         .error_fmt = QERR_JSON_PARSING,
                    153:         .desc      = "Invalid JSON syntax",
                    154:     },
                    155:     {
1.1.1.4   root      156:         .error_fmt = QERR_JSON_PARSE_ERROR,
                    157:         .desc      = "JSON parse error, %(message)",
                    158: 
                    159:     },
                    160:     {
1.1       root      161:         .error_fmt = QERR_KVM_MISSING_CAP,
                    162:         .desc      = "Using KVM without %(capability), %(feature) unavailable",
                    163:     },
                    164:     {
1.1.1.2   root      165:         .error_fmt = QERR_MIGRATION_EXPECTED,
                    166:         .desc      = "An incoming migration is expected before this command can be executed",
                    167:     },
                    168:     {
1.1       root      169:         .error_fmt = QERR_MISSING_PARAMETER,
1.1.1.2   root      170:         .desc      = "Parameter '%(name)' is missing",
                    171:     },
                    172:     {
                    173:         .error_fmt = QERR_NO_BUS_FOR_DEVICE,
                    174:         .desc      = "No '%(bus)' bus found for device '%(device)'",
                    175:     },
                    176:     {
                    177:         .error_fmt = QERR_OPEN_FILE_FAILED,
                    178:         .desc      = "Could not open '%(filename)'",
                    179:     },
                    180:     {
                    181:         .error_fmt = QERR_PROPERTY_NOT_FOUND,
                    182:         .desc      = "Property '%(device).%(property)' not found",
                    183:     },
                    184:     {
                    185:         .error_fmt = QERR_PROPERTY_VALUE_BAD,
                    186:         .desc      = "Property '%(device).%(property)' doesn't take value '%(value)'",
                    187:     },
                    188:     {
                    189:         .error_fmt = QERR_PROPERTY_VALUE_IN_USE,
                    190:         .desc      = "Property '%(device).%(property)' can't take value '%(value)', it's in use",
                    191:     },
                    192:     {
                    193:         .error_fmt = QERR_PROPERTY_VALUE_NOT_FOUND,
                    194:         .desc      = "Property '%(device).%(property)' can't find value '%(value)'",
1.1       root      195:     },
                    196:     {
                    197:         .error_fmt = QERR_QMP_BAD_INPUT_OBJECT,
1.1.1.2   root      198:         .desc      = "Expected '%(expected)' in QMP input",
                    199:     },
                    200:     {
                    201:         .error_fmt = QERR_QMP_BAD_INPUT_OBJECT_MEMBER,
                    202:         .desc      = "QMP input object member '%(member)' expects '%(expected)'",
                    203:     },
                    204:     {
                    205:         .error_fmt = QERR_QMP_EXTRA_MEMBER,
                    206:         .desc      = "QMP input object member '%(member)' is unexpected",
1.1       root      207:     },
                    208:     {
1.1.1.5 ! root      209:         .error_fmt = QERR_RESET_REQUIRED,
        !           210:         .desc      = "Resetting the Virtual Machine is required",
        !           211:     },
        !           212:     {
1.1       root      213:         .error_fmt = QERR_SET_PASSWD_FAILED,
                    214:         .desc      = "Could not set password",
                    215:     },
                    216:     {
1.1.1.4   root      217:         .error_fmt = QERR_ADD_CLIENT_FAILED,
                    218:         .desc      = "Could not add client",
                    219:     },
                    220:     {
1.1       root      221:         .error_fmt = QERR_TOO_MANY_FILES,
                    222:         .desc      = "Too many open files",
                    223:     },
                    224:     {
                    225:         .error_fmt = QERR_UNDEFINED_ERROR,
                    226:         .desc      = "An undefined error has ocurred",
                    227:     },
                    228:     {
1.1.1.4   root      229:         .error_fmt = QERR_UNSUPPORTED,
                    230:         .desc      = "this feature or command is not currently supported",
                    231:     },
                    232:     {
1.1.1.3   root      233:         .error_fmt = QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
                    234:         .desc      = "'%(device)' uses a %(format) feature which is not "
                    235:                      "supported by this qemu version: %(feature)",
                    236:     },
                    237:     {
1.1.1.5 ! root      238:         .error_fmt = QERR_VIRTFS_FEATURE_BLOCKS_MIGRATION,
        !           239:         .desc      = "Migration is disabled when VirtFS export path '%(path)' "
        !           240:                      "is mounted in the guest using mount_tag '%(tag)'",
        !           241:     },
        !           242:     {
1.1       root      243:         .error_fmt = QERR_VNC_SERVER_FAILED,
                    244:         .desc      = "Could not start VNC server on %(target)",
                    245:     },
1.1.1.4   root      246:     {
                    247:         .error_fmt = QERR_QGA_LOGGING_FAILED,
                    248:         .desc      = "Guest agent failed to log non-optional log statement",
                    249:     },
                    250:     {
                    251:         .error_fmt = QERR_QGA_COMMAND_FAILED,
                    252:         .desc      = "Guest agent command failed, error was '%(message)'",
                    253:     },
1.1       root      254:     {}
                    255: };
                    256: 
                    257: /**
                    258:  * qerror_new(): Create a new QError
                    259:  *
                    260:  * Return strong reference.
                    261:  */
                    262: QError *qerror_new(void)
                    263: {
                    264:     QError *qerr;
                    265: 
1.1.1.5 ! root      266:     qerr = g_malloc0(sizeof(*qerr));
1.1       root      267:     QOBJECT_INIT(qerr, &qerror_type);
                    268: 
                    269:     return qerr;
                    270: }
                    271: 
1.1.1.3   root      272: static void GCC_FMT_ATTR(2, 3) qerror_abort(const QError *qerr,
                    273:                                             const char *fmt, ...)
1.1       root      274: {
                    275:     va_list ap;
                    276: 
                    277:     fprintf(stderr, "qerror: bad call in function '%s':\n", qerr->func);
                    278:     fprintf(stderr, "qerror: -> ");
                    279: 
                    280:     va_start(ap, fmt);
                    281:     vfprintf(stderr, fmt, ap);
                    282:     va_end(ap);
                    283: 
                    284:     fprintf(stderr, "\nqerror: call at %s:%d\n", qerr->file, qerr->linenr);
                    285:     abort();
                    286: }
                    287: 
1.1.1.3   root      288: static void GCC_FMT_ATTR(2, 0) qerror_set_data(QError *qerr,
                    289:                                                const char *fmt, va_list *va)
1.1       root      290: {
                    291:     QObject *obj;
                    292: 
                    293:     obj = qobject_from_jsonv(fmt, va);
                    294:     if (!obj) {
                    295:         qerror_abort(qerr, "invalid format '%s'", fmt);
                    296:     }
                    297:     if (qobject_type(obj) != QTYPE_QDICT) {
                    298:         qerror_abort(qerr, "error format is not a QDict '%s'", fmt);
                    299:     }
                    300: 
                    301:     qerr->error = qobject_to_qdict(obj);
                    302: 
                    303:     obj = qdict_get(qerr->error, "class");
                    304:     if (!obj) {
                    305:         qerror_abort(qerr, "missing 'class' key in '%s'", fmt);
                    306:     }
                    307:     if (qobject_type(obj) != QTYPE_QSTRING) {
                    308:         qerror_abort(qerr, "'class' key value should be a QString");
                    309:     }
                    310:     
                    311:     obj = qdict_get(qerr->error, "data");
                    312:     if (!obj) {
                    313:         qerror_abort(qerr, "missing 'data' key in '%s'", fmt);
                    314:     }
                    315:     if (qobject_type(obj) != QTYPE_QDICT) {
                    316:         qerror_abort(qerr, "'data' key value should be a QDICT");
                    317:     }
                    318: }
                    319: 
                    320: static void qerror_set_desc(QError *qerr, const char *fmt)
                    321: {
                    322:     int i;
                    323: 
                    324:     // FIXME: inefficient loop
                    325: 
                    326:     for (i = 0; qerror_table[i].error_fmt; i++) {
                    327:         if (strcmp(qerror_table[i].error_fmt, fmt) == 0) {
                    328:             qerr->entry = &qerror_table[i];
                    329:             return;
                    330:         }
                    331:     }
                    332: 
                    333:     qerror_abort(qerr, "error format '%s' not found", fmt);
                    334: }
                    335: 
                    336: /**
                    337:  * qerror_from_info(): Create a new QError from error information
                    338:  *
                    339:  * The information consists of:
                    340:  *
                    341:  * - file   the file name of where the error occurred
                    342:  * - linenr the line number of where the error occurred
                    343:  * - func   the function name of where the error occurred
                    344:  * - fmt    JSON printf-like dictionary, there must exist keys 'class' and
                    345:  *          'data'
                    346:  * - va     va_list of all arguments specified by fmt
                    347:  *
                    348:  * Return strong reference.
                    349:  */
                    350: QError *qerror_from_info(const char *file, int linenr, const char *func,
                    351:                          const char *fmt, va_list *va)
                    352: {
                    353:     QError *qerr;
                    354: 
                    355:     qerr = qerror_new();
1.1.1.2   root      356:     loc_save(&qerr->loc);
1.1       root      357:     qerr->linenr = linenr;
                    358:     qerr->file = file;
                    359:     qerr->func = func;
                    360: 
                    361:     if (!fmt) {
                    362:         qerror_abort(qerr, "QDict not specified");
                    363:     }
                    364: 
                    365:     qerror_set_data(qerr, fmt, va);
                    366:     qerror_set_desc(qerr, fmt);
                    367: 
                    368:     return qerr;
                    369: }
                    370: 
1.1.1.4   root      371: static void parse_error(const QErrorStringTable *entry, int c)
1.1       root      372: {
1.1.1.4   root      373:     fprintf(stderr, "expected '%c' in '%s'", c, entry->desc);
                    374:     abort();
1.1       root      375: }
                    376: 
1.1.1.4   root      377: static const char *append_field(QDict *error, QString *outstr,
                    378:                                 const QErrorStringTable *entry,
1.1       root      379:                                 const char *start)
                    380: {
                    381:     QObject *obj;
                    382:     QDict *qdict;
                    383:     QString *key_qs;
                    384:     const char *end, *key;
                    385: 
                    386:     if (*start != '%')
1.1.1.4   root      387:         parse_error(entry, '%');
1.1       root      388:     start++;
                    389:     if (*start != '(')
1.1.1.4   root      390:         parse_error(entry, '(');
1.1       root      391:     start++;
                    392: 
                    393:     end = strchr(start, ')');
                    394:     if (!end)
1.1.1.4   root      395:         parse_error(entry, ')');
1.1       root      396: 
                    397:     key_qs = qstring_from_substr(start, 0, end - start - 1);
                    398:     key = qstring_get_str(key_qs);
                    399: 
1.1.1.4   root      400:     qdict = qobject_to_qdict(qdict_get(error, "data"));
1.1       root      401:     obj = qdict_get(qdict, key);
                    402:     if (!obj) {
1.1.1.4   root      403:         abort();
1.1       root      404:     }
                    405: 
                    406:     switch (qobject_type(obj)) {
                    407:         case QTYPE_QSTRING:
                    408:             qstring_append(outstr, qdict_get_str(qdict, key));
                    409:             break;
                    410:         case QTYPE_QINT:
                    411:             qstring_append_int(outstr, qdict_get_int(qdict, key));
                    412:             break;
                    413:         default:
1.1.1.4   root      414:             abort();
1.1       root      415:     }
                    416: 
                    417:     QDECREF(key_qs);
                    418:     return ++end;
                    419: }
                    420: 
1.1.1.4   root      421: static QString *qerror_format_desc(QDict *error,
                    422:                                    const QErrorStringTable *entry)
1.1       root      423: {
                    424:     QString *qstring;
1.1.1.4   root      425:     const char *p;
1.1       root      426: 
1.1.1.4   root      427:     assert(entry != NULL);
1.1       root      428: 
                    429:     qstring = qstring_new();
                    430: 
1.1.1.4   root      431:     for (p = entry->desc; *p != '\0';) {
1.1       root      432:         if (*p != '%') {
                    433:             qstring_append_chr(qstring, *p++);
                    434:         } else if (*(p + 1) == '%') {
                    435:             qstring_append_chr(qstring, '%');
                    436:             p += 2;
                    437:         } else {
1.1.1.4   root      438:             p = append_field(error, qstring, entry, p);
1.1       root      439:         }
                    440:     }
                    441: 
                    442:     return qstring;
                    443: }
                    444: 
1.1.1.4   root      445: QString *qerror_format(const char *fmt, QDict *error)
                    446: {
                    447:     const QErrorStringTable *entry = NULL;
                    448:     int i;
                    449: 
                    450:     for (i = 0; qerror_table[i].error_fmt; i++) {
                    451:         if (strcmp(qerror_table[i].error_fmt, fmt) == 0) {
                    452:             entry = &qerror_table[i];
                    453:             break;
                    454:         }
                    455:     }
                    456: 
                    457:     return qerror_format_desc(error, entry);
                    458: }
                    459: 
                    460: /**
                    461:  * qerror_human(): Format QError data into human-readable string.
                    462:  */
                    463: QString *qerror_human(const QError *qerror)
                    464: {
                    465:     return qerror_format_desc(qerror->error, qerror->entry);
                    466: }
                    467: 
1.1       root      468: /**
                    469:  * qerror_print(): Print QError data
                    470:  *
                    471:  * This function will print the member 'desc' of the specified QError object,
1.1.1.2   root      472:  * it uses error_report() for this, so that the output is routed to the right
1.1       root      473:  * place (ie. stderr or Monitor's device).
                    474:  */
1.1.1.2   root      475: void qerror_print(QError *qerror)
1.1       root      476: {
                    477:     QString *qstring = qerror_human(qerror);
1.1.1.2   root      478:     loc_push_restore(&qerror->loc);
                    479:     error_report("%s", qstring_get_str(qstring));
                    480:     loc_pop(&qerror->loc);
1.1       root      481:     QDECREF(qstring);
                    482: }
                    483: 
1.1.1.2   root      484: void qerror_report_internal(const char *file, int linenr, const char *func,
                    485:                             const char *fmt, ...)
                    486: {
                    487:     va_list va;
                    488:     QError *qerror;
                    489: 
                    490:     va_start(va, fmt);
                    491:     qerror = qerror_from_info(file, linenr, func, fmt, &va);
                    492:     va_end(va);
                    493: 
                    494:     if (monitor_cur_is_qmp()) {
                    495:         monitor_set_error(cur_mon, qerror);
                    496:     } else {
                    497:         qerror_print(qerror);
                    498:         QDECREF(qerror);
                    499:     }
                    500: }
                    501: 
1.1.1.5 ! root      502: /* Evil... */
        !           503: struct Error
        !           504: {
        !           505:     QDict *obj;
        !           506:     const char *fmt;
        !           507:     char *msg;
        !           508: };
        !           509: 
        !           510: void qerror_report_err(Error *err)
        !           511: {
        !           512:     QError *qerr;
        !           513:     int i;
        !           514: 
        !           515:     qerr = qerror_new();
        !           516:     loc_save(&qerr->loc);
        !           517:     QINCREF(err->obj);
        !           518:     qerr->error = err->obj;
        !           519: 
        !           520:     for (i = 0; qerror_table[i].error_fmt; i++) {
        !           521:         if (strcmp(qerror_table[i].error_fmt, err->fmt) == 0) {
        !           522:             qerr->entry = &qerror_table[i];
        !           523:             break;
        !           524:         }
        !           525:     }
        !           526: 
        !           527:     if (monitor_cur_is_qmp()) {
        !           528:         monitor_set_error(cur_mon, qerr);
        !           529:     } else {
        !           530:         qerror_print(qerr);
        !           531:         QDECREF(qerr);
        !           532:     }
        !           533: }
        !           534: 
1.1       root      535: /**
                    536:  * qobject_to_qerror(): Convert a QObject into a QError
                    537:  */
                    538: QError *qobject_to_qerror(const QObject *obj)
                    539: {
                    540:     if (qobject_type(obj) != QTYPE_QERROR) {
                    541:         return NULL;
                    542:     }
                    543: 
                    544:     return container_of(obj, QError, base);
                    545: }
                    546: 
                    547: /**
                    548:  * qerror_destroy_obj(): Free all memory allocated by a QError
                    549:  */
                    550: static void qerror_destroy_obj(QObject *obj)
                    551: {
                    552:     QError *qerr;
                    553: 
                    554:     assert(obj != NULL);
                    555:     qerr = qobject_to_qerror(obj);
                    556: 
                    557:     QDECREF(qerr->error);
1.1.1.5 ! root      558:     g_free(qerr);
1.1       root      559: }

unix.superglobalmegacorp.com